@@ -139,6 +139,9 @@ Dashboards are **generated by the embedded DeepSQL Agent acting as a coding agen
 - **Rendering + data access**: `DashboardArtifact.jsx` renders the HTML in a **sandboxed iframe** (`sandbox="allow-scripts"`, opaque origin + a strict CSP — no external network). The artifact fetches data only through an injected `deepsql.query(sql)` bridge that `postMessage`s to the parent; the parent calls **`POST /api/dashboards/query`** (`DashboardQueryController`), which is **read-only twice over** (`McpSqlGuardService.validateReadOnlySql` + `QueryExecutionContext.api` = `READ_ONLY_ONLY`) and access-scoped via `assertCanReadConnectionContent`. So the agent's code has full creative freedom while every query stays guarded and sandboxed. The bridge also auto-sizes the iframe and forwards runtime errors.
 - Generation endpoints unchanged (`POST /api/dashboards/generate` + `/generate/stream`). `DashboardBuilder.js`/`DashboardInputs.js` remain only because `tabs/Core/PreviewTab.js` still uses them — the dashboard *creation* path no longer touches them.
 - **Sharing**: both share types render a standalone read-only `DashboardViewer` (title + `DashboardArtifact` with an injected `queryFn`). Internal link `/dashboard-view/:id` (auth) uses the authed broker; public link `/share/dashboard/:token` (permitAll) uses `PublicDashboardController` (`GET /api/public/dashboards/{token}` + `/query`), which resolves only while `saved_dashboards.is_public` is true (revoke = flip it) and runs read-only + connection-scoped. `share_token`/`is_public` are set only via `POST|DELETE /api/saved-dashboards/{id}/share` (access-checked), never a general update. `ShareMenu.jsx` drives the UI. The public query path has its own nginx `dashq` limiter.
+- **Organization** (search/folders/favorites): `SavedDashboardController`'s search/folder/favorite endpoints existed for a while with no UI consumer. `DashboardsHome.jsx` now wires all of it — a search box (client-side filter over name/description), folder chips derived from `GET /connection/{id}/folders` with a per-card "move to folder" popover (`PUT /saved-dashboards/{id}` with `folder: ""` to clear — `updateDashboard` treats `null` as "field omitted" so blank is the explicit clear signal, same convention as `setSharePassword`), and a favorite star toggle (`POST /{id}/favorite`) with optimistic UI update.
+- **Clone**: `POST /saved-dashboards/{id}/clone` (`SavedDashboardService.cloneDashboard`) duplicates a dashboard's config/chat/tags/folder into a fresh row — not shared, not favorited. Exposed as a copy icon on each `DashboardsHome.jsx` card.
+- **Version history**: every real overwrite of `dashboardConfig` (agent build via `completeBuildTurn`, manual Source-tab edit via `updateDashboard`, or a restore) snapshots the *previous* config into `dashboard_versions` (`V113__create_dashboard_versions.sql`) before overwriting, tagged with a trigger (`AGENT_BUILD`/`MANUAL_EDIT`/`RESTORE`) — capped at 50 snapshots per dashboard, oldest pruned first. `GET /{id}/versions` lists them newest-first; `POST /{id}/versions/{versionId}/restore` swaps a snapshot back in as current (itself snapshotting whatever was live, so a restore is undoable too). `DashboardWorkspace.jsx`'s canvas toolbar has a History panel (reusing the Queries panel's layout) listing versions with a Restore button, disabled while a build is in flight to avoid racing the agent's own write.
 
 ## LLM Providers
 
 
@@ -1,5 +1,6 @@
 package com.dbaagent.controller;
 
+import com.dbaagent.model.DashboardVersion;
 import com.dbaagent.model.SavedDashboard;
 import com.dbaagent.service.SavedDashboardService;
 import com.dbaagent.service.security.AccessControlService;
@@ -227,6 +228,83 @@ public ResponseEntity<Map<String, Object>> updateDashboard(@PathVariable UUID id
         }
     }
 
+    /**
+     * Duplicate a dashboard as a new, independent draft.
+     */
+    @PostMapping("/{id}/clone")
+    public ResponseEntity<Map<String, Object>> cloneDashboard(@PathVariable UUID id) {
+        try {
+            SavedDashboard existing = savedDashboardService.getDashboardById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Dashboard not found"));
+            accessControlService.assertCanManageConnectionContent(existing.getConnectionId());
+            SavedDashboard clone = savedDashboardService.cloneDashboard(id);
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", true);
+            response.put("savedDashboard", clone);
+            return ResponseEntity.status(HttpStatus.CREATED).body(response);
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("success", false, "message", e.getMessage()));
+        } catch (org.springframework.web.server.ResponseStatusException e) {
+            throw e;
+        } catch (Exception e) {
+            log.error("Error cloning dashboard", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                .body(Map.of("success", false, "message", "Failed to clone dashboard"));
+        }
+    }
+
+    /**
+     * List version history for a dashboard, most recent first.
+     */
+    @GetMapping("/{id}/versions")
+    public ResponseEntity<Map<String, Object>> getVersionHistory(@PathVariable UUID id) {
+        try {
+            SavedDashboard existing = savedDashboardService.getDashboardById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Dashboard not found"));
+            accessControlService.assertCanReadConnectionContent(existing.getConnectionId());
+            List<DashboardVersion> versions = savedDashboardService.getVersionHistory(id);
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", true);
+            response.put("versions", versions);
+            return ResponseEntity.ok(response);
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("success", false, "message", e.getMessage()));
+        } catch (org.springframework.web.server.ResponseStatusException e) {
+            throw e;
+        } catch (Exception e) {
+            log.error("Error fetching dashboard version history", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                .body(Map.of("success", false, "message", "Failed to fetch version history"));
+        }
+    }
+
+    /**
+     * Restore a prior version as the dashboard's current config.
+     */
+    @PostMapping("/{id}/versions/{versionId}/restore")
+    public ResponseEntity<Map<String, Object>> restoreVersion(@PathVariable UUID id, @PathVariable UUID versionId) {
+        try {
+            SavedDashboard existing = savedDashboardService.getDashboardById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Dashboard not found"));
+            accessControlService.assertCanManageConnectionContent(existing.getConnectionId());
+            SavedDashboard restored = savedDashboardService.restoreVersion(id, versionId);
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", true);
+            response.put("savedDashboard", restored);
+            return ResponseEntity.ok(response);
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("success", false, "message", e.getMessage()));
+        } catch (org.springframework.web.server.ResponseStatusException e) {
+            throw e;
+        } catch (OptimisticLockingFailureException e) {
+            return conflict(e);
+        } catch (Exception e) {
+            log.error("Error restoring dashboard version", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                .body(Map.of("success", false, "message", "Failed to restore version"));
+        }
+    }
+
     /**
      * Delete a saved dashboard
      */
 
@@ -0,0 +1,43 @@
+package com.dbaagent.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.CreationTimestamp;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+@Entity
+@Table(name = "dashboard_versions", indexes = {
+    @Index(name = "idx_dashboard_versions_dashboard_id", columnList = "dashboardId")
+})
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class DashboardVersion {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private UUID id;
+
+    @Column(nullable = false)
+    private UUID dashboardId;
+
+    @Column(nullable = false, columnDefinition = "TEXT")
+    private String dashboardConfig;
+
+    @Column(length = 255)
+    private String name;
+
+    // What produced this snapshot: AGENT_BUILD (agent finished a turn) or MANUAL_EDIT
+    // (Source tab Apply) — shown in the History list so a restore point reads as
+    // "before this edit" rather than an anonymous timestamp.
+    @Column(nullable = false, length = 32)
+    private String trigger;
+
+    @CreationTimestamp
+    @Column(nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+}
@@ -0,0 +1,16 @@
+package com.dbaagent.repository;
+
+import com.dbaagent.model.DashboardVersion;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.UUID;
+
+@Repository
+public interface DashboardVersionRepository extends JpaRepository<DashboardVersion, UUID> {
+
+    List<DashboardVersion> findByDashboardIdOrderByCreatedAtDesc(UUID dashboardId);
+
+    void deleteByDashboardId(UUID dashboardId);
+}
@@ -1,6 +1,8 @@
 package com.dbaagent.service;
 
+import com.dbaagent.model.DashboardVersion;
 import com.dbaagent.model.SavedDashboard;
+import com.dbaagent.repository.DashboardVersionRepository;
 import com.dbaagent.repository.SavedDashboardRepository;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -30,9 +32,16 @@ public class SavedDashboardService {
     // a legitimate retry forever — only respected while still fresh.
     private static final Duration STALE_RUNNING_THRESHOLD = Duration.ofMinutes(20);
 
+    // Bound history growth — a dashboard iterated on for months shouldn't carry an
+    // unbounded snapshot table. Oldest beyond this count are pruned on each write.
+    private static final int MAX_VERSIONS_PER_DASHBOARD = 50;
+
     @Autowired
     private SavedDashboardRepository savedDashboardRepository;
 
+    @Autowired
+    private DashboardVersionRepository dashboardVersionRepository;
+
     @Autowired
     private ObjectMapper objectMapper;
 
@@ -121,7 +130,10 @@ public SavedDashboard updateDashboard(UUID id, SavedDashboard updates) {
         if (updates.getDescription() != null) {
             existing.setDescription(updates.getDescription());
         }
-        if (updates.getDashboardConfig() != null) {
+        if (updates.getDashboardConfig() != null && !updates.getDashboardConfig().equals(existing.getDashboardConfig())) {
+            if (hasRealBuild(existing)) {
+                snapshotVersion(existing, "MANUAL_EDIT");
+            }
             existing.setDashboardConfig(updates.getDashboardConfig());
         }
         if (updates.getChatMessages() != null) {
@@ -135,8 +147,10 @@ public SavedDashboard updateDashboard(UUID id, SavedDashboard updates) {
         if (updates.getIsFavorite() != null) {
             existing.setIsFavorite(updates.getIsFavorite());
         }
+        // Blank clears the folder (moves back to "no folder") — distinguished from
+        // null, which means the update omitted this field entirely.
         if (updates.getFolder() != null) {
-            existing.setFolder(updates.getFolder());
+            existing.setFolder(updates.getFolder().isBlank() ? null : updates.getFolder());
         }
 
         return savedDashboardRepository.save(existing);
@@ -224,6 +238,86 @@ public void deleteDashboard(UUID id) {
         savedDashboardRepository.deleteById(id);
     }
 
+    /** Duplicate a dashboard (fresh id, not shared, not a favorite) as a starting point to iterate on. */
+    @Transactional
+    public SavedDashboard cloneDashboard(UUID id) {
+        SavedDashboard source = requireDashboard(id);
+        SavedDashboard copy = new SavedDashboard();
+        copy.setConnectionId(source.getConnectionId());
+        copy.setUserId(source.getUserId());
+        copy.setName(source.getName() == null ? "Untitled copy" : source.getName() + " (copy)");
+        copy.setDescription(source.getDescription());
+        copy.setDashboardConfig(source.getDashboardConfig());
+        copy.setChatMessages(source.getChatMessages());
+        copy.setTags(source.getTags());
+        copy.setFolder(source.getFolder());
+        copy.setIsFavorite(false);
+        copy.setIsPublic(false);
+        return savedDashboardRepository.save(copy);
+    }
+
+    /** True once a dashboard has an actual rendered artifact, not just the initial placeholder. */
+    private boolean hasRealBuild(SavedDashboard dashboard) {
+        String cfg = dashboard.getDashboardConfig();
+        return cfg != null && !cfg.isBlank() && !cfg.equals("{}") && cfg.contains("\"html\"");
+    }
+
+    private void snapshotVersion(SavedDashboard dashboard, String trigger) {
+        DashboardVersion version = new DashboardVersion();
+        version.setDashboardId(dashboard.getId());
+        version.setDashboardConfig(dashboard.getDashboardConfig());
+        version.setName(dashboard.getName());
+        version.setTrigger(trigger);
+        dashboardVersionRepository.save(version);
+        pruneOldVersions(dashboard.getId());
+    }
+
+    private void pruneOldVersions(UUID dashboardId) {
+        List<DashboardVersion> versions = dashboardVersionRepository.findByDashboardIdOrderByCreatedAtDesc(dashboardId);
+        if (versions.size() > MAX_VERSIONS_PER_DASHBOARD) {
+            dashboardVersionRepository.deleteAll(versions.subList(MAX_VERSIONS_PER_DASHBOARD, versions.size()));
+        }
+    }
+
+    /** History for a dashboard, most recent first. */
+    public List<DashboardVersion> getVersionHistory(UUID dashboardId) {
+        return dashboardVersionRepository.findByDashboardIdOrderByCreatedAtDesc(dashboardId);
+    }
+
+    /**
+     * Restore a prior snapshot as the current config — snapshots what's live now first, so
+     * restoring is itself undoable.
+     *
+     * <p>The restored version's own row (and any other row with byte-identical content —
+     * an earlier restore of the same snapshot) is then deleted: that content is now the
+     * live config, not history, so leaving it in the list would show it twice — once as
+     * "Current" and again as a stale history entry a user could re-restore into a no-op.
+     * A flip-flop restore-edit-restore-edit session otherwise piles up an alternating
+     * chain of identical snapshots, one pair per cycle.
+     */
+    @Transactional
+    public SavedDashboard restoreVersion(UUID dashboardId, UUID versionId) {
+        SavedDashboard dashboard = requireDashboard(dashboardId);
+        DashboardVersion version = dashboardVersionRepository.findById(versionId)
+            .orElseThrow(() -> new IllegalArgumentException("Version not found with id: " + versionId));
+        if (!version.getDashboardId().equals(dashboardId)) {
+            throw new IllegalArgumentException("Version does not belong to dashboard: " + dashboardId);
+        }
+        if (hasRealBuild(dashboard)) {
+            snapshotVersion(dashboard, "RESTORE");
+        }
+        String restoredConfig = version.getDashboardConfig();
+        dashboard.setDashboardConfig(restoredConfig);
+        SavedDashboard saved = savedDashboardRepository.save(dashboard);
+        List<DashboardVersion> duplicates = dashboardVersionRepository.findByDashboardIdOrderByCreatedAtDesc(dashboardId).stream()
+            .filter(v -> v.getDashboardConfig().equals(restoredConfig))
+            .toList();
+        if (!duplicates.isEmpty()) {
+            dashboardVersionRepository.deleteAll(duplicates);
+        }
+        return saved;
+    }
+
     /**
      * Delete all dashboards for a connection
      */
@@ -302,6 +396,9 @@ public SavedDashboard appendAgentReply(UUID dashboardId, String replyText) {
     @Transactional
     public SavedDashboard completeBuildTurn(UUID dashboardId, Map<String, Object> config) {
         SavedDashboard dashboard = requireDashboard(dashboardId);
+        if (hasRealBuild(dashboard)) {
+            snapshotVersion(dashboard, "AGENT_BUILD");
+        }
         try {
             dashboard.setDashboardConfig(objectMapper.writeValueAsString(config));
         } catch (Exception e) {
 
@@ -69,7 +69,11 @@ public void assertCanManageConnectionConfig(String connectionId) {
 
     public ConnectionAccessService.ResolvedConnectionAccess resolveCurrentUserAccess(String connectionId) {
         if (!authEnabled) {
-            return connectionAccessService.resolveAccess(connectionId, null, true);
+            try {
+                return connectionAccessService.resolveAccess(connectionId, null, true);
+            } catch (RuntimeException e) {
+                throw new ResponseStatusException(NOT_FOUND, "Connection not found");
+            }
         }
         Authentication authentication = currentAuthentication();
         if (authentication == null || !authentication.isAuthenticated()) {
 
@@ -0,0 +1,10 @@
+CREATE TABLE dashboard_versions (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    dashboard_id UUID NOT NULL REFERENCES saved_dashboards(id) ON DELETE CASCADE,
+    dashboard_config TEXT NOT NULL,
+    name VARCHAR(255),
+    trigger VARCHAR(32) NOT NULL,
+    created_at TIMESTAMP NOT NULL DEFAULT now()
+);
+
+CREATE INDEX idx_dashboard_versions_dashboard_id ON dashboard_versions(dashboard_id, created_at DESC);