From 949d6b5f149b985c45ed7f73d9e75688c027950f Mon Sep 17 00:00:00 2001
From: Levy Tate <78818969+iLevyTate@users.noreply.github.com>
Date: Wed, 11 Nov 2026 15:35:10 -0500
Subject: [PATCH] fix(knowledge-os): folder nodes, chat scope, graph refresh
 and silent failures in the search modal

Search and Chat: preview details no longer linger under a new selection,
Add to scope chunks past 1000 files, Ask AI is limited to visible results,
reopening starts a clean conversation, a refused send keeps the input,
Ctrl+1..5 works from text fields, and conversation switching keeps the
last click.

Graph and Atlas: folder nodes resolve the smart folder path instead of
sending its name, the vector DB status listener uses electronAPI, the
delayed cluster refresh no longer overwrites user changes, knowledge edges
survive redraws, metadata and tag calls are chunked to their schema limits,
regrouped groups no longer parse to NaN ids, and failed rename, move, open
and reveal calls are reported.
---
 docs/FEATURES_GRAPH.md                        |  22 +-
 scripts/verify-checkjs-ratchet.js             |   2 +-
 .../components/search/AtlasTabContent.jsx     |  23 +-
 src/renderer/components/search/ChatPanel.jsx  |   6 +-
 .../components/search/SearchTabContent.jsx    |  11 +-
 .../components/search/UnifiedSearchModal.jsx  | 105 +++---
 .../components/search/hooks/useChatTab.js     | 125 +++++--
 .../components/search/hooks/useGraphTab.js    | 338 +++++++++++++-----
 .../components/search/nodes/FolderNode.jsx    |  11 +-
 .../search/utils/clusterRegroupUtils.js       |  15 +
 .../search/utils/graphLayoutUtils.js          |  99 +++++
 src/renderer/components/search/utils/index.js |  15 +
 .../components/search/utils/ipcBatchUtils.js  | 110 ++++++
 test/components/ChatPanel.test.js             |  31 +-
 test/components/FolderNode.test.js            |  29 +-
 test/components/UnifiedSearchModal.test.js    | 104 ++++++
 .../search/knowledgeGraphHelpers.test.js      | 268 ++++++++++++++
 .../search/useChatTab.scope.test.js           | 226 +++++++++++-
 .../search/useGraphTab.knowledgeFixes.test.js | 293 +++++++++++++++
 19 files changed, 1630 insertions(+), 203 deletions(-)
 create mode 100644 src/renderer/components/search/utils/ipcBatchUtils.js
 create mode 100644 test/renderer/components/search/knowledgeGraphHelpers.test.js
 create mode 100644 test/renderer/components/search/useGraphTab.knowledgeFixes.test.js

diff --git a/docs/FEATURES_GRAPH.md b/docs/FEATURES_GRAPH.md
index a94a97a..a0d94a2 100644
--- a/docs/FEATURES_GRAPH.md
+++ b/docs/FEATURES_GRAPH.md
@@ -17,7 +17,11 @@ semantically.
 
 - **React Flow Integration**: Smooth, zoomable canvas interface.
 - **Auto-Layout**: Uses ELK algorithms to organize nodes intelligently.
-- **Context Menus**: Right-click on any node for quick actions (Open, Reveal in Explorer, Organize).
+- **Context Menus**: Right-click a file node for Open File, Reveal in Folder, Find Similar, Focus on
+  Node and Show Related Documents. Right-click a cluster for Expand/Collapse cluster, Tag Cluster,
+  Create Smart Folder, Move All to Folder and Export File List. Other nodes (the query node,
+  suggested-folder nodes, duplicate groups) have no context menu; a suggested-folder node has its
+  own toolbar for moving its connected files there or revealing the folder.
 
 ### Semantic Clustering
 
@@ -31,10 +35,16 @@ The graph doesn't just show files; it shows _meaning_.
 
 ### Exploration Tools
 
-- **Focus Mode**: Double-click any node to center the graph on it and reveal its specific
-  connections.
+- **Double-click**: Double-clicking a cluster expands it into its member files. Double-clicking a
+  file selects it and adds its similar files to the graph (as many hops as the hop setting allows).
+  Double-clicking other nodes does nothing.
+- **Focus Mode**: "Focus on Node" (file context menu, or the Focus button in the details panel)
+  centers the graph on one node and its nearby connections.
 - **Expansion**: Dynamically load more connections as you explore "hops" away from your starting
   point.
+- **Find similar**: The context-menu **Find Similar** adds similar files to the graph. The details
+  panel's **Find similar** button is different: it switches to the Search tab with a
+  `similar to: <file name>` query.
 - **Filtering**: Use the legend to toggle visibility of clusters, file types, or confidence levels.
 
 ## Technical Implementation
@@ -63,9 +73,11 @@ The graph doesn't just show files; it shows _meaning_.
     visualized.
 3.  **Explore**:
     - **Click** a node to select it.
-    - **Double-click** to focus and expand.
+    - **Double-click** a cluster to expand it, or a file to add its similar files.
     - **Drag** nodes to rearrange your view.
-4.  **Action**: Right-click to open files or apply organization suggestions.
+4.  **Action**: Right-click a file to open or reveal it, or a cluster to tag, move or export its
+    files. To act on an organization suggestion, select the suggested-folder node and use its
+    toolbar.
 
 ## Other Knowledge OS views
 
diff --git a/scripts/verify-checkjs-ratchet.js b/scripts/verify-checkjs-ratchet.js
index d80eb91..b7db8e0 100644
--- a/scripts/verify-checkjs-ratchet.js
+++ b/scripts/verify-checkjs-ratchet.js
@@ -43,7 +43,7 @@ const COVERED_DIRS = [
   'src/renderer/utils',
   'src/renderer/components'
 ];
-const GLOBAL_DIRECTIVE_FLOOR = 493;
+const GLOBAL_DIRECTIVE_FLOOR = 494;
 // ────────────────────────────────────────────────────────────────────────
 
 const DIRECTIVE_SCAN_LINES = 5;
diff --git a/src/renderer/components/search/AtlasTabContent.jsx b/src/renderer/components/search/AtlasTabContent.jsx
index e4d03c9..6ac52a1 100644
--- a/src/renderer/components/search/AtlasTabContent.jsx
+++ b/src/renderer/components/search/AtlasTabContent.jsx
@@ -15,6 +15,7 @@ import { useAppSelector } from '../../store/hooks';
 import { joinPath } from '../../utils/platform';
 import { useMoveFilesToFolder } from './hooks/useMoveFilesToFolder';
 import { useAtlasRebuildPoll } from './hooks/useAtlasRebuildPoll';
+import { FILE_METADATA_BATCH_LIMIT, chunkArray, addTagsChunked } from './utils/ipcBatchUtils';
 import {
   pickNextPointInDirection,
   ARROW_DIRECTIONS,
@@ -38,7 +39,6 @@ import { buildEmbeddingData, nearestPointIndex, indicesInLasso } from './atlasEm
  */
 
 const PAGE_LIMIT = 5000;
-const META_BATCH_LIMIT = 100;
 const SIMILAR_TOP_K = 10;
 const MAX_FOLDER_LABELS = 10;
 const MIN_LABEL_MEMBERS = 3;
@@ -157,8 +157,7 @@ function AtlasTabContent({ isActive, openFile, revealFile, setError, simpleMode
     }
     const api = /** @type {any} */ (window).electronAPI?.embeddings;
     if (!api?.getFileMetadata || missing.length === 0) return out;
-    for (let i = 0; i < missing.length; i += META_BATCH_LIMIT) {
-      const chunk = missing.slice(i, i + META_BATCH_LIMIT);
+    for (const chunk of chunkArray(missing, FILE_METADATA_BATCH_LIMIT)) {
       try {
         const res = await api.getFileMetadata(chunk);
         for (const id of chunk) {
@@ -858,14 +857,20 @@ function AtlasTabContent({ isActive, openFile, revealFile, setError, simpleMode
       setIsBulkWorking(true);
       setBulkStatus(`Tagging ${selectedFileIds.length} file(s)…`);
       try {
-        const api = /** @type {any} */ (window).electronAPI?.files;
-        const res = await api?.addTags?.(selectedFileIds, tags);
-        if (!res?.success) {
-          throw new Error(atlasIpcFailureMessage(res?.errors?.[0]?.error || res, 'Tags'));
+        // One call takes at most 1000 ids and may tag only some of them, so
+        // send the selection in chunks and report what was really tagged.
+        const res = await addTagsChunked(selectedFileIds, tags);
+        if (!res.success) {
+          throw new Error(atlasIpcFailureMessage(res.error || res, 'Tags'));
         }
-        setBulkStatus(`Tagged ${selectedFileIds.length} file(s).`);
-        setTagDraft(null);
         metaCacheRef.current.clear();
+        if (res.failed > 0) {
+          setBulkStatus(`Tagged ${res.updated} of ${res.total} file(s).`);
+          setBothErrors(`Could not tag ${res.failed} of ${res.total} file(s).`);
+        } else {
+          setBulkStatus(`Tagged ${res.updated} file(s).`);
+          setTagDraft(null);
+        }
       } catch (err) {
         setBothErrors(atlasIpcFailureMessage(err, 'Tags'));
       } finally {
diff --git a/src/renderer/components/search/ChatPanel.jsx b/src/renderer/components/search/ChatPanel.jsx
index 74ae311..bb00309 100644
--- a/src/renderer/components/search/ChatPanel.jsx
+++ b/src/renderer/components/search/ChatPanel.jsx
@@ -874,8 +874,10 @@ function ChatPanel({
     const trimmed = input.trim();
     if (!trimmed || isSending) return;
     try {
-      await onSend(trimmed);
-      setInput('');
+      // onSend resolves false when the send was refused (e.g. strict scope
+      // with no documents); keep the text so it is not lost.
+      const accepted = await onSend(trimmed);
+      if (accepted !== false) setInput('');
     } catch {
       // Keep the input so the user can retry on failure
     }
diff --git a/src/renderer/components/search/SearchTabContent.jsx b/src/renderer/components/search/SearchTabContent.jsx
index 53fd57a..c301dd8 100644
--- a/src/renderer/components/search/SearchTabContent.jsx
+++ b/src/renderer/components/search/SearchTabContent.jsx
@@ -144,7 +144,16 @@ export default function SearchTabContent({
                 setActiveTab('chat');
                 // If there is a query, ask about it
                 if (debouncedQuery) {
-                  handleChatSend(`Tell me about "${debouncedQuery}" based on these results`);
+                  // "These results" are the ones on screen: send their ids so
+                  // the answer is drawn from them, not the whole library.
+                  const resultIds = searchResults
+                    .map((result) => result?.id)
+                    .filter((id) => typeof id === 'string' && id.length > 0)
+                    .slice(0, 200);
+                  handleChatSend(
+                    `Tell me about "${debouncedQuery}" based on these results`,
+                    resultIds
+                  );
                 }
               }}
               title="Ask AI assistant about these results"
diff --git a/src/renderer/components/search/UnifiedSearchModal.jsx b/src/renderer/components/search/UnifiedSearchModal.jsx
index 9a4b783..ef583e1 100644
--- a/src/renderer/components/search/UnifiedSearchModal.jsx
+++ b/src/renderer/components/search/UnifiedSearchModal.jsx
@@ -242,7 +242,7 @@ export default function UnifiedSearchModal({
 
   // Chat tab state + logic live in hooks/useChatTab (§I Phase 4). The
   // graph bridge (handleUseSourcesInGraph) stays below — it writes graph state.
-  const chatTab = useChatTab({ isOpen, searchResults, defaultTopK, openFile, setError });
+  const chatTab = useChatTab({ isOpen, searchResults, defaultTopK, openFile });
   const {
     chatMessages,
     setChatMessages,
@@ -1104,6 +1104,27 @@ export default function UnifiedSearchModal({
         onClose?.();
       }
 
+      // Tab switching: Ctrl + 1 search, 2 relate, 3 atlas, 4 chat, 5 timeline
+      // (F-212: Chat and Timeline had no hotkey). Handled before the
+      // editable-target guard so it works while a text field has focus.
+      // AltGr reports Ctrl+Alt on Windows and types a character, so Alt is
+      // excluded.
+      if (e.ctrlKey && !e.altKey) {
+        const tabForKey = {
+          1: 'search',
+          2: graphViewEnabled ? 'graph' : null,
+          3: graphViewEnabled ? 'atlas' : null,
+          4: 'chat',
+          5: 'timeline'
+        }[e.key];
+        if (tabForKey) {
+          e.preventDefault();
+          pendingInitialGraphTabRef.current = false;
+          setActiveTab(tabForKey);
+          return;
+        }
+      }
+
       if (isEditableTarget(e.target)) {
         return;
       }
@@ -1157,34 +1178,6 @@ export default function UnifiedSearchModal({
         }
       }
 
-      // Tab switching: Ctrl + 1 search, 2 relate, 3 atlas, 4 chat, 5 timeline
-      if (e.ctrlKey && e.key === '1') {
-        e.preventDefault();
-        pendingInitialGraphTabRef.current = false;
-        setActiveTab('search');
-      }
-      if (e.ctrlKey && e.key === '2' && graphViewEnabled) {
-        e.preventDefault();
-        pendingInitialGraphTabRef.current = false;
-        setActiveTab('graph');
-      }
-      if (e.ctrlKey && e.key === '3' && graphViewEnabled) {
-        e.preventDefault();
-        pendingInitialGraphTabRef.current = false;
-        setActiveTab('atlas');
-      }
-      // F-212: Chat and Timeline had no hotkey (mouse only).
-      if (e.ctrlKey && e.key === '4') {
-        e.preventDefault();
-        pendingInitialGraphTabRef.current = false;
-        setActiveTab('chat');
-      }
-      if (e.ctrlKey && e.key === '5') {
-        e.preventDefault();
-        pendingInitialGraphTabRef.current = false;
-        setActiveTab('timeline');
-      }
-
       // Graph keyboard shortcuts — only when the graph tab is active so we
       // don't fight browser zoom or undo behaviors elsewhere in the modal.
       if (graphViewEnabled && activeTab === 'graph') {
@@ -1369,8 +1362,11 @@ export default function UnifiedSearchModal({
     };
 
     const handleFolderAction = async (event) => {
-      const { action, folderId, folderPath } = event.detail || {};
+      // folderPath is the smart folder's path on disk ('' when the suggested
+      // name matches no smart folder); folderName is only for messages.
+      const { action, folderId, folderName, folderPath } = event.detail || {};
       if (!folderId) return;
+      const folderLabel = folderName || folderPath || 'this folder';
       if (action === 'moveFilesHere') {
         // Find all file nodes connected to this folder node via organize edges
         const currentEdges = edgesRef.current || [];
@@ -1389,21 +1385,34 @@ export default function UnifiedSearchModal({
           return;
         }
         setGraphStatus(
-          `Moving ${filePaths.length} file${filePaths.length === 1 ? '' : 's'} to "${folderPath}"...`
+          `Moving ${filePaths.length} file${filePaths.length === 1 ? '' : 's'} to "${folderLabel}"...`
         );
+        let outcome = null;
         try {
-          await handleMoveAllToFolderRef.current?.(
-            { id: folderId, label: folderPath, memberIds: fileIds },
-            folderPath
+          // With no known path the move asks the user for a destination.
+          outcome = await handleMoveAllToFolderRef.current?.(
+            { id: folderId, label: folderLabel, memberIds: fileIds },
+            folderPath || undefined
           );
         } catch {
-          setGraphStatus('Failed to move files.');
+          showError('Failed to move files.');
+        } finally {
+          // A successful move sets its own status; otherwise (cancelled or
+          // failed, which the move reports itself) clear "Moving...".
+          if (!outcome?.moved) setGraphStatus('');
         }
       } else if (action === 'reveal') {
+        if (!folderPath) {
+          showError(`"${folderLabel}" is not one of your smart folders, so it cannot be revealed.`);
+          return;
+        }
         try {
-          await window.electronAPI?.files?.reveal?.(folderPath);
+          const result = await window.electronAPI?.files?.reveal?.(folderPath);
+          if (!result || result.success === false) {
+            showError(`Could not reveal "${folderLabel}": ${result?.error || 'folder not found'}`);
+          }
         } catch {
-          setGraphStatus(`Could not reveal "${folderPath}" in Explorer.`);
+          showError(`Could not reveal "${folderLabel}".`);
         }
       }
     };
@@ -1437,7 +1446,8 @@ export default function UnifiedSearchModal({
     reactFlowInstance,
     setFocusDepth,
     setFocusNodeId,
-    setGraphStatus
+    setGraphStatus,
+    showError
   ]); // handleMoveAllToFolder accessed via ref to avoid TDZ
 
   // Prevent wheel events on the graph container from scrolling the parent modal.
@@ -1555,15 +1565,21 @@ export default function UnifiedSearchModal({
     // Don't re-fetch if we already have details for this path
     if (lastFetchedDetailsPathRef.current === path) return undefined;
 
+    // A different file is selected: drop the previous file's details so the
+    // preview never shows them under the new selection while this loads, or
+    // when the new file has no analysis history.
+    lastFetchedDetailsPathRef.current = null;
+    setSelectedDocumentDetails(null);
+
     let cancelled = false;
     const requestId = (detailsRequestCounterRef.current += 1);
     const fetchDetails = async () => {
       setIsLoadingDocumentDetails(true);
       try {
         const history = await window.electronAPI?.analysisHistory?.getFileHistory?.(path);
-        if (!cancelled && detailsRequestCounterRef.current === requestId && history) {
+        if (!cancelled && detailsRequestCounterRef.current === requestId) {
           lastFetchedDetailsPathRef.current = path;
-          setSelectedDocumentDetails(history);
+          setSelectedDocumentDetails(history || null);
         }
       } catch (err) {
         logger.warn('Failed to fetch document details', err);
@@ -1924,9 +1940,8 @@ export default function UnifiedSearchModal({
                 <button
                   className="dropdown-menu-item dropdown-menu-item--default flex w-full items-center gap-compact text-left"
                   onClick={() => {
-                    if (contextMenu.data?.path) {
-                      window.electronAPI?.files?.open?.(contextMenu.data.path);
-                    }
+                    // The shared actions report a missing path or a failed open.
+                    openFile(contextMenu.data?.path);
                     closeContextMenu();
                   }}
                 >
@@ -1935,9 +1950,7 @@ export default function UnifiedSearchModal({
                 <button
                   className="dropdown-menu-item dropdown-menu-item--default flex w-full items-center gap-compact text-left"
                   onClick={() => {
-                    if (contextMenu.data?.path) {
-                      window.electronAPI?.files?.reveal?.(contextMenu.data.path);
-                    }
+                    revealFile(contextMenu.data?.path);
                     closeContextMenu();
                   }}
                 >
diff --git a/src/renderer/components/search/hooks/useChatTab.js b/src/renderer/components/search/hooks/useChatTab.js
index 5659884..f9e9a71 100644
--- a/src/renderer/components/search/hooks/useChatTab.js
+++ b/src/renderer/components/search/hooks/useChatTab.js
@@ -29,16 +29,20 @@ const ENABLE_SEARCH_TRACE_LOGS = process.env.NODE_ENV === 'development';
 
 const MAX_CHAT_MESSAGES = 200;
 
+// Both the index lookup (paths) and the chat query (contextFileIds,
+// documentScopeItems) are capped at 1000 entries by the IPC schemas.
+const MAX_SCOPE_LOOKUP_PATHS = 1000;
+const MAX_DOCUMENT_SCOPE_ITEMS = 1000;
+
 /**
  * @param {{
  *   isOpen: boolean,
  *   searchResults: any[],
  *   defaultTopK: number,
- *   openFile: (path: string) => void,
- *   setError: (v: string) => void
+ *   openFile: (path: string) => void
  * }} props
  */
-export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setError }) {
+export function useChatTab({ isOpen, searchResults, defaultTopK, openFile }) {
   const [chatMessages, setChatMessages] = useState([]);
   const [currentConversationId, setCurrentConversationId] = useState(null);
   const [strictScope, setStrictScope] = useState(false);
@@ -98,6 +102,12 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
 
   const chatSessionRef = useRef(null);
   const chatRequestCounterRef = useRef(0);
+  const conversationLoadCounterRef = useRef(0);
+  // Mirrors documentScope so handleAddToScope can tell how much room is left.
+  const documentScopeRef = useRef(documentScope);
+  useEffect(() => {
+    documentScopeRef.current = documentScope;
+  }, [documentScope]);
   const chatInFlightRef = useRef(false);
   const chatStreamRef = useRef(null);
   const chatWatchdogRef = useRef(null);
@@ -138,6 +148,8 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
     return chatSessionRef.current;
   }, []);
 
+  // Resolves false when the send was refused (nothing was added to the
+  // thread), so the caller can keep the typed text.
   const handleChatSend = useCallback(
     async (
       /** @type {any} */ text,
@@ -146,10 +158,10 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
     ) => {
       const { skipAddUserMessage = false } = options || {};
       const trimmed = typeof text === 'string' ? text.trim() : '';
-      if (!trimmed) return;
+      if (!trimmed) return false;
       if (chatInFlightRef.current) {
         setChatWarning('Please wait for the current response to finish.');
-        return;
+        return false;
       }
 
       const requestId = nextRequestId(chatRequestCounterRef);
@@ -197,7 +209,7 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
           setChatStatus('');
           setIsChatting(false);
           chatInFlightRef.current = false;
-          return;
+          return false;
         }
 
         if (strictScope && documentScope.length === 0 && contextFileIds.length > 0) {
@@ -459,6 +471,7 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
         });
 
         stream.begin();
+        return true;
       } catch (chatErr) {
         clearTimeout(chatWatchdogRef.current);
         cancelAnimationFrame(streamingRafRef.current);
@@ -466,7 +479,7 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
         clearInterval(streamingFlushIntervalRef.current);
         streamingFlushIntervalRef.current = null;
         pendingStreamChunkRef.current = '';
-        if (!isCurrentRequest(chatRequestCounterRef, requestId)) return;
+        if (!isCurrentRequest(chatRequestCounterRef, requestId)) return false;
         logger.warn('[KnowledgeOS] Chat query failed', { error: chatErr?.message || chatErr });
         const { message } = mapErrorToNotification({ error: chatErr?.message || chatErr });
         setChatError(message);
@@ -476,6 +489,7 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
         chatInFlightRef.current = false;
         chatStreamRef.current?.cancel?.();
         chatStreamRef.current = null;
+        return false;
       }
     },
     [
@@ -489,21 +503,20 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
     ]
   );
 
-  const handleResponseModeChange = useCallback(
-    (/** @type {any} */ nextMode) => {
-      if (nextMode !== 'fast' && nextMode !== 'deep') return;
-      setResponseMode(nextMode);
-      window.electronAPI?.settings
-        ?.save?.({ chatResponseMode: nextMode })
-        .catch((/** @type {any} */ err) => {
-          logger.debug('[UnifiedSearchModal] Failed to save chat response mode', {
-            error: err?.message || String(err)
-          });
-          setError('Failed to save chat response mode. Please try again.');
+  // Save failures show in the chat panel's own banner: the modal-level
+  // banner is titled "Search error".
+  const handleResponseModeChange = useCallback((/** @type {any} */ nextMode) => {
+    if (nextMode !== 'fast' && nextMode !== 'deep') return;
+    setResponseMode(nextMode);
+    window.electronAPI?.settings
+      ?.save?.({ chatResponseMode: nextMode })
+      .catch((/** @type {any} */ err) => {
+        logger.debug('[UnifiedSearchModal] Failed to save chat response mode', {
+          error: err?.message || String(err)
         });
-    },
-    [setError]
-  );
+        setChatWarning('Failed to save chat response mode. Please try again.');
+      });
+  }, []);
 
   const handleChatPersonaChange = useCallback(
     (/** @type {any} */ nextPersona) => {
@@ -515,10 +528,10 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
           logger.debug('[UnifiedSearchModal] Failed to save chat persona', {
             error: err?.message || String(err)
           });
-          setError('Failed to save chat persona. Please try again.');
+          setChatWarning('Failed to save chat persona. Please try again.');
         });
     },
-    [savedCustomPersonas, setError]
+    [savedCustomPersonas]
   );
 
   const handleAddToScope = useCallback(async (/** @type {any} */ items) => {
@@ -552,14 +565,25 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
     }
 
     try {
-      const result =
-        allPaths.length > 0
-          ? await window.electronAPI.embeddings.findFilesByPaths(allPaths)
-          : { success: true, results: [] };
-      if (result?.success === false) {
-        throw new Error(result.error || 'Index lookup failed');
+      // The lookup accepts at most 1000 paths per call, so a large folder is
+      // checked in chunks, stopping once the matches would fill the scope.
+      const lookupPaths = Array.from(new Set(allPaths));
+      const checkedPaths = [];
+      const directMatches = [];
+      for (
+        let start = 0;
+        start < lookupPaths.length && directMatches.length < MAX_DOCUMENT_SCOPE_ITEMS;
+        start += MAX_SCOPE_LOOKUP_PATHS
+      ) {
+        const chunk = lookupPaths.slice(start, start + MAX_SCOPE_LOOKUP_PATHS);
+        const result = await window.electronAPI.embeddings.findFilesByPaths(chunk);
+        if (result?.success === false) {
+          throw new Error(result.error || 'Index lookup failed');
+        }
+        checkedPaths.push(...chunk);
+        if (Array.isArray(result?.results)) directMatches.push(...result.results);
       }
-      const directMatches = result?.results ? result.results : [];
+      let scopeCapped = checkedPaths.length < lookupPaths.length;
       const nameMatches = [];
 
       for (const unresolvedName of unresolvedNames) {
@@ -595,7 +619,7 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
       const dedupedNewItems = Array.from(new Map(newItems.map((item) => [item.id, item])).values());
 
       const resolvedPaths = new Set(dedupedNewItems.map((i) => i.path));
-      const droppedPaths = allPaths.filter((p) => !resolvedPaths.has(p));
+      const droppedPaths = checkedPaths.filter((p) => !resolvedPaths.has(p));
       const unresolvedFoundByName = new Set(
         dedupedNewItems.map((item) => item.name?.toLowerCase()).filter(Boolean)
       );
@@ -603,25 +627,38 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
         (name) => !unresolvedFoundByName.has(name.toLowerCase())
       );
       const droppedEntries = [...droppedPaths, ...droppedNames];
+
+      const currentScope = documentScopeRef.current;
+      const currentIds = new Set(currentScope.map((/** @type {any} */ i) => i.id));
+      const room = Math.max(0, MAX_DOCUMENT_SCOPE_ITEMS - currentScope.length);
+      if (dedupedNewItems.filter((i) => !currentIds.has(i.id)).length > room) scopeCapped = true;
+
       // Warn even when nothing resolved, so adding to the scope is never a
       // silent no-op.
+      const warnings = [];
       if (droppedEntries.length > 0) {
         const visibleNames = droppedEntries.map((p) => p.split(/[/\\]/).pop()).slice(0, 5);
         const suffix = droppedEntries.length > 5 ? ` and ${droppedEntries.length - 5} more` : '';
-        setChatWarning(
+        warnings.push(
           `${droppedEntries.length} file(s) not in index: ${visibleNames.join(', ')}${suffix}. Index these files first.`
         );
       } else if (dedupedNewItems.length === 0 && items.length > 0) {
-        setChatWarning(
+        warnings.push(
           'No files were added to the document scope. The items could not be read, or the folder has no files.'
         );
       }
+      if (scopeCapped) {
+        warnings.push(
+          `The document scope holds up to ${MAX_DOCUMENT_SCOPE_ITEMS} files, so not every file was added.`
+        );
+      }
+      if (warnings.length > 0) setChatWarning(warnings.join(' '));
 
       if (dedupedNewItems.length > 0) {
         setDocumentScope((prev) => {
           const existingIds = new Set(prev.map((i) => i.id));
           const uniqueNew = dedupedNewItems.filter((i) => !existingIds.has(i.id));
-          return [...prev, ...uniqueNew];
+          return [...prev, ...uniqueNew].slice(0, MAX_DOCUMENT_SCOPE_ITEMS);
         });
       }
     } catch (e) {
@@ -649,6 +686,8 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
     chatStreamRef.current?.cancel?.();
     chatStreamRef.current = null;
     invalidateRequests(chatRequestCounterRef);
+    // A conversation still loading must not replace the new, empty one.
+    invalidateRequests(conversationLoadCounterRef);
     chatInFlightRef.current = false;
     setCurrentConversationId(null);
     setChatMessages([]);
@@ -671,8 +710,11 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
   }, []);
 
   const handleSelectConversation = useCallback(async (/** @type {any} */ id) => {
+    // Latest click wins: an earlier conversation that resolves later is dropped.
+    const loadId = nextRequestId(conversationLoadCounterRef);
     try {
       const conversation = await getConversation(id);
+      if (!isCurrentRequest(conversationLoadCounterRef, loadId)) return;
       if (conversation) {
         clearTimeout(chatWatchdogRef.current);
         cancelAnimationFrame(streamingRafRef.current);
@@ -694,6 +736,7 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
         setDocumentScope(conversation.documentScope || []);
       }
     } catch (err) {
+      if (!isCurrentRequest(conversationLoadCounterRef, loadId)) return;
       logger.error('[UnifiedSearchModal] Failed to load conversation', err);
       setChatError('Failed to load conversation');
     }
@@ -757,10 +800,22 @@ export function useChatTab({ isOpen, searchResults, defaultTopK, openFile, setEr
   );
 
   // Reset to a clean slate for a fresh open (called from the modal's
-  // open-reset effect so the reset ordering stays exactly as before).
+  // open-reset effect so the reset ordering stays exactly as before). The
+  // modal drops the messages and the stream on close, so a reopen is a new
+  // conversation: nothing of the previous one may stay selected, scoped or
+  // marked as still sending.
   const resetChatState = useCallback(() => {
+    invalidateRequests(chatRequestCounterRef);
+    invalidateRequests(conversationLoadCounterRef);
+    chatInFlightRef.current = false;
+    pendingStreamChunkRef.current = '';
     setChatMessages([]);
+    setCurrentConversationId(null);
+    setDocumentScope([]);
+    setStrictScope(false);
     setChatError('');
+    setChatWarning('');
+    setChatStatus('');
     setIsChatting(false);
     setUseSearchContext(false);
     chatSessionRef.current = crypto.randomUUID();
diff --git a/src/renderer/components/search/hooks/useGraphTab.js b/src/renderer/components/search/hooks/useGraphTab.js
index 2493d43..f11473e 100644
--- a/src/renderer/components/search/hooks/useGraphTab.js
+++ b/src/renderer/components/search/hooks/useGraphTab.js
@@ -61,7 +61,15 @@ import {
   getConnectionReason,
   rankCrossClusterConnections,
   sortClustersForInsight,
-  pickSurpriseConnections
+  pickSurpriseConnections,
+  parseSemanticClusterId,
+  carryOverRelClusterEdges,
+  REL_CLUSTER_EDGE_PREFIX,
+  buildClusterOverviewSignature,
+  isClusterOverviewUntouched,
+  getClusterPayloadKey,
+  fetchFileMetadataChunked,
+  addTagsChunked
 } from '../utils';
 
 const logger = createLogger('useGraphTab');
@@ -453,6 +461,15 @@ export function useGraphTab(
   const reactFlowInstance = useRef(null);
   const clusterRefreshTimeoutRef = useRef(null);
   const userHasExpandedRef = useRef(false);
+  // Fingerprint of the cluster overview as last drawn; the delayed refresh
+  // only redraws while the graph still matches it.
+  const clusterOverviewSignatureRef = useRef(/** @type {string|null} */ (null));
+  // Cluster node id -> name the user gave it this session.
+  const clusterLabelOverridesRef = useRef(/** @type {Map<string, string>} */ (new Map()));
+  // Knowledge edges between clusters for the current cluster load. Kept apart
+  // from the graph so they survive redraws and a round trip through another
+  // "cluster by" mode, where their endpoints are not on screen.
+  const relClusterEdgesRef = useRef(/** @type {any[]} */ ([]));
   const freshMetadataRequestCounterRef = useRef(0);
   const graphSearchRequestCounterRef = useRef(0);
   const graphDropRequestCounterRef = useRef(0);
@@ -549,33 +566,40 @@ export function useGraphTab(
    * Core move flow shared by every "Group into folder" affordance:
    * prompts the user for a destination folder, resolves paths for the
    * given file IDs, and moves them in batches via the existing
-   * `files.performOperation` IPC. Returns nothing — surfaces success and
-   * failure through the existing `setGraphStatus` / `setError` channels.
+   * `files.performOperation` IPC. Surfaces success and failure through the
+   * existing `setGraphStatus` / `setError` channels, and resolves with the
+   * outcome so a caller that showed its own progress text can clear it.
    *
    * @param {string[]} fileIds - File IDs (Orama doc IDs) to move.
-   * @param {{ source?: string }} [opts] - Telemetry tag for logger.
+   * @param {{ source?: string, destFolder?: string }} [opts] - Telemetry tag for
+   *   logger; `destFolder` moves straight there instead of asking.
+   * @returns {Promise<{ moved: number, failed: number, cancelled: boolean }>}
    */
   const moveFilesToChosenFolder = useCallback(async (/** @type {any} */ fileIds, opts = {}) => {
     const ids = Array.isArray(fileIds) ? fileIds.filter(Boolean) : [];
     if (ids.length === 0) {
       if (isMountedRef.current) setError('No files selected to move.');
-      return;
+      return { moved: 0, failed: 0, cancelled: false };
     }
     const source = /** @type {any} */ (opts).source || 'graph_group_action';
+    const knownDest = /** @type {any} */ (opts).destFolder;
 
     try {
-      const dirResult = await window.electronAPI?.files?.selectDirectory?.({
-        purpose: 'destination'
-      });
-      if (!dirResult?.success || !dirResult?.path) {
-        return; // User cancelled the folder picker.
+      let destFolder = typeof knownDest === 'string' ? knownDest.trim() : '';
+      if (!destFolder) {
+        const dirResult = await window.electronAPI?.files?.selectDirectory?.({
+          purpose: 'destination'
+        });
+        if (!dirResult?.success || !dirResult?.path) {
+          return { moved: 0, failed: 0, cancelled: true }; // User cancelled the folder picker.
+        }
+        destFolder = dirResult.path;
       }
-      const destFolder = dirResult.path;
 
-      const metadataResult = await window.electronAPI?.embeddings?.getFileMetadata?.(ids);
-      if (!metadataResult?.success) {
+      const metadataResult = await fetchFileMetadataChunked(ids);
+      if (!metadataResult.success) {
         if (isMountedRef.current) setError('Failed to retrieve file metadata');
-        return;
+        return { moved: 0, failed: ids.length, cancelled: false };
       }
       const metadata = metadataResult.metadata || {};
       let successCount = 0;
@@ -625,17 +649,24 @@ export function useGraphTab(
           setError(`Failed to move ${failCount} file(s)`);
         }
       }
+      return { moved: successCount, failed: failCount, cancelled: false };
     } catch (e) {
       logger.error('[Graph] Move files failed', { error: e?.message, source });
       if (isMountedRef.current) setError(`Move failed: ${e?.message || 'Unknown error'}`);
+      return { moved: 0, failed: ids.length, cancelled: false };
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   // Cluster path (existing entry point used by cluster cards + selection menu).
+  // A folder node passes its real path as `destFolder`; cluster cards pass
+  // nothing and the user picks the folder.
   const handleMoveAllToFolder = useCallback(
-    (/** @type {any} */ clusterData) =>
-      moveFilesToChosenFolder(clusterData?.memberIds || [], { source: 'cluster' }),
+    (/** @type {any} */ clusterData, /** @type {any} */ destFolder) =>
+      moveFilesToChosenFolder(clusterData?.memberIds || [], {
+        source: 'cluster',
+        destFolder: typeof destFolder === 'string' ? destFolder : undefined
+      }),
     [moveFilesToChosenFolder]
   );
   handleMoveAllToFolderRef.current = handleMoveAllToFolder;
@@ -669,9 +700,9 @@ export function useGraphTab(
         return;
       }
 
-      // Get file metadata for all members in one call
-      const metadataResult = await window.electronAPI?.embeddings?.getFileMetadata?.(memberIds);
-      if (!metadataResult?.success) {
+      // The metadata call takes at most 100 ids; fetch large clusters in chunks.
+      const metadataResult = await fetchFileMetadataChunked(memberIds);
+      if (!metadataResult.success) {
         if (isMountedRef.current) setError('Failed to retrieve file metadata');
         return;
       }
@@ -832,11 +863,11 @@ export function useGraphTab(
         setGraphStatus(`Applying ${tags.length} tags to ${memberIds.length} files...`);
 
       try {
-        // Call backend to add tags
-        const result = await window.electronAPI.files.addTags(memberIds, tags);
+        // The handler takes at most 1000 ids per call and can tag only some of them.
+        const result = await addTagsChunked(memberIds, tags);
 
-        if (!result?.success) {
-          throw new Error(getErrorMessage(result?.errors?.[0]?.error || result?.error, 'Tags'));
+        if (!result.success) {
+          throw new Error(getErrorMessage(result.error, 'Tags'));
         }
 
         if (isMountedRef.current) {
@@ -861,7 +892,12 @@ export function useGraphTab(
             })
           );
 
-          setGraphStatus(`Applied tags to cluster: ${selectedClusterForTagging.label}`);
+          if (result.failed > 0) {
+            setGraphStatus(`Tagged ${result.updated} of ${result.total} files`);
+            setError(`Could not tag ${result.failed} of ${result.total} files`);
+          } else {
+            setGraphStatus(`Applied tags to cluster: ${selectedClusterForTagging.label}`);
+          }
         }
       } catch (error) {
         logger.error('Failed to apply tags', {
@@ -882,32 +918,47 @@ export function useGraphTab(
 
       if (!clusterId || !newLabel) return;
 
-      // Optimistic UI update
-      graphActions.setNodes((/** @type {any} */ prev) =>
-        prev.map((/** @type {any} */ n) =>
-          n.id === clusterId
-            ? {
-                ...n,
-                data: {
-                  ...n.data,
-                  label: newLabel,
-                  isAutoGenerated: false
-                }
-              }
-            : n
-        )
-      );
+      const previous = (nodesRef.current || []).find((/** @type {any} */ n) => n.id === clusterId);
+      const previousOverride = clusterLabelOverridesRef.current.get(clusterId);
+      const applyLabel = (/** @type {any} */ label, /** @type {any} */ isAutoGenerated) =>
+        graphActions.setNodes((/** @type {any} */ prev) =>
+          prev.map((/** @type {any} */ n) =>
+            n.id === clusterId ? { ...n, data: { ...n.data, label, isAutoGenerated } } : n
+          )
+        );
+
+      // Optimistic UI update. The override keeps the name across re-renders
+      // (mode/filter changes, background refresh) for the rest of the session.
+      clusterLabelOverridesRef.current.set(clusterId, newLabel);
+      applyLabel(newLabel, false);
+
+      // Only semantic clusters exist in the backend. A regrouped or duplicate
+      // group has no stored label to update, so its name lasts for this session.
+      if (parseSemanticClusterId(clusterId) === null) {
+        setGraphStatus(`Group renamed to "${newLabel}" for this session`);
+        return;
+      }
 
       setGraphStatus(`Cluster renamed to "${newLabel}"`);
 
       // Persist to backend so the label survives graph reloads and app restarts
       try {
-        await window.electronAPI?.embeddings?.renameCluster?.(clusterId, newLabel);
+        const result = await window.electronAPI?.embeddings?.renameCluster?.(clusterId, newLabel);
+        if (result?.success === false) {
+          throw new Error(getErrorMessage(result.error, 'Rename'));
+        }
       } catch (e) {
         logger.warn('[Graph] Failed to persist cluster rename:', e?.message);
+        if (!isMountedRef.current) return;
+        // Put the old name back rather than show one that will not survive a reload.
+        if (previousOverride === undefined) clusterLabelOverridesRef.current.delete(clusterId);
+        else clusterLabelOverridesRef.current.set(clusterId, previousOverride);
+        if (previous) applyLabel(previous.data?.label, previous.data?.isAutoGenerated);
+        setGraphStatus('');
+        setError(`Could not rename the cluster: ${e?.message || 'Unknown error'}`);
       }
     },
-    [graphActions]
+    [graphActions, setError]
   );
 
   // Ref-based node lookup: always holds the latest nodes map but does NOT
@@ -1248,13 +1299,20 @@ export function useGraphTab(
     handleClusterExpand
   ]);
 
+  const findDuplicatesInFlightRef = useRef(false);
+
   /**
    * Find near-duplicate files across the collection
    * Displays them as special clusters in the graph
    */
   const handleFindDuplicates = useCallback(async () => {
+    // Several entry points start this scan and each replaces the graph; a
+    // second click while one is running must not start a competing scan.
+    if (findDuplicatesInFlightRef.current) return;
+    findDuplicatesInFlightRef.current = true;
     setError('');
     setDuplicateGroups([]);
+    setGraphStatus('Looking for duplicate files...');
 
     try {
       const result = await window.electronAPI?.embeddings?.findDuplicates?.({
@@ -1264,6 +1322,7 @@ export function useGraphTab(
 
       if (!result?.success) {
         setError(getErrorMessage(result?.error, 'Duplicate detection'));
+        setGraphStatus('');
         return;
       }
 
@@ -1370,6 +1429,9 @@ export function useGraphTab(
     } catch (e) {
       logger.error('[Graph] Find duplicates failed', e);
       setError(`Find duplicates failed: ${e?.message || 'Unknown error'}`);
+      setGraphStatus('');
+    } finally {
+      findDuplicatesInFlightRef.current = false;
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
@@ -1656,14 +1718,18 @@ export function useGraphTab(
 
     let cancelled = false;
     const requestId = (freshMetadataRequestCounterRef.current += 1);
+    // Drop the previous node's metadata now; otherwise the panel shows (and
+    // acts on) the old file's path until this node's fetch returns, or for
+    // good if it fails.
+    setFreshMetadata(null);
 
     // Debounce 150ms to avoid IPC flood on rapid node selection
     const debounceTimer = setTimeout(async () => {
       setIsLoadingMetadata(true);
       try {
         const resp = await window.electronAPI?.embeddings?.getFileMetadata?.([nodeId]);
-        if (!cancelled && freshMetadataRequestCounterRef.current === requestId && resp?.success) {
-          const meta = resp.metadata?.[nodeId] || null;
+        if (!cancelled && freshMetadataRequestCounterRef.current === requestId) {
+          const meta = (resp?.success && resp.metadata?.[nodeId]) || null;
           setFreshMetadata(meta);
           // Cache for later re-selection (cap at 50 entries)
           if (meta) {
@@ -2076,7 +2142,8 @@ export function useGraphTab(
           kind: 'cluster',
           id: cluster.id,
           clusterId: cluster.clusterId,
-          label: getClusterDisplayLabel(cluster),
+          label:
+            clusterLabelOverridesRef.current.get(cluster.id) || getClusterDisplayLabel(cluster),
           memberCount: cluster.memberCount,
           memberIds: cluster.memberIds,
           expanded: false,
@@ -2088,7 +2155,7 @@ export function useGraphTab(
           dominantFolderName: cluster.dominantFolderName || '',
           commonTags: sanitizeGraphMetadataTerms(cluster.commonTags, { maxTerms: 10 }),
           timeRange: cluster.timeRange || null,
-          isAutoGenerated: true,
+          isAutoGenerated: !clusterLabelOverridesRef.current.has(cluster.id),
           onCreateSmartFolder: handleCreateSmartFolderFromCluster,
           onMoveAllToFolder: handleMoveAllToFolder,
           onExportFileList: handleExportFileList,
@@ -2241,7 +2308,15 @@ export function useGraphTab(
         };
       });
 
-      graphActions.setGraph(clusterNodes, clusterEdges);
+      // Knowledge edges are fetched once per load and added after the first
+      // draw; a redraw must not drop the ones that still connect two groups.
+      const edgesToRender = carryOverRelClusterEdges(
+        relClusterEdgesRef.current,
+        clusterNodes,
+        clusterEdges
+      );
+      graphActions.setGraph(clusterNodes, edgesToRender);
+      clusterOverviewSignatureRef.current = buildClusterOverviewSignature(clusterNodes);
       setShowClusters(true);
 
       setGraphStatus(`Found ${presentationClusters.length} groups (cluster by: ${mode})`);
@@ -2261,6 +2336,7 @@ export function useGraphTab(
             radius: dynamicRadius
           });
           graphActions.setNodes(layoutedNodes);
+          clusterOverviewSignatureRef.current = buildClusterOverviewSignature(layoutedNodes);
         } catch (layoutError) {
           logger.warn('[Graph] Cluster layout failed:', layoutError);
         }
@@ -2296,6 +2372,10 @@ export function useGraphTab(
     setError('');
     // Reset expansion flag so the background refresh is allowed again on a fresh load
     userHasExpandedRef.current = false;
+    // Cluster ids are reassigned by a recompute, so earlier knowledge edges and
+    // session names no longer describe these clusters.
+    relClusterEdgesRef.current = [];
+    clusterLabelOverridesRef.current.clear();
 
     try {
       // Prefer using cached clusters when available; recompute only if stale.
@@ -2427,6 +2507,10 @@ export function useGraphTab(
                     });
                   }
                 }
+                relClusterEdgesRef.current = next.filter(
+                  (/** @type {any} */ e) =>
+                    typeof e?.id === 'string' && e.id.startsWith(REL_CLUSTER_EDGE_PREFIX)
+                );
                 return next;
               });
               return undefined;
@@ -2449,17 +2533,30 @@ export function useGraphTab(
         try {
           if (!isMountedRef.current) return;
           const refreshed = await window.electronAPI?.embeddings?.getClusters?.();
+          // The redraw replaces the whole graph, so it may only land on the
+          // overview this load drew: not on a newer load, an expanded cluster,
+          // dragged nodes, or a graph since replaced by a search or duplicates.
+          if (
+            !isMountedRef.current ||
+            !isCurrentRequest(clustersRequestCounterRef, requestId) ||
+            userHasExpandedRef.current ||
+            !isClusterOverviewUntouched(clusterOverviewSignatureRef.current, nodesRef.current)
+          ) {
+            return;
+          }
           if (
             refreshed?.success &&
             Array.isArray(refreshed.clusters) &&
             refreshed.clusters.length > 0
           ) {
+            const refreshedEdges = refreshed.crossClusterEdges || crossClusterEdges;
+            const unchanged =
+              getClusterPayloadKey(refreshed.clusters, refreshedEdges) ===
+              getClusterPayloadKey(lastClustersRef.current, lastCrossClusterEdgesRef.current);
             lastClustersRef.current = refreshed.clusters;
-            lastCrossClusterEdgesRef.current = refreshed.crossClusterEdges || crossClusterEdges;
-            renderClustersToGraph(
-              refreshed.clusters,
-              refreshed.crossClusterEdges || crossClusterEdges
-            );
+            lastCrossClusterEdgesRef.current = refreshedEdges;
+            // Nothing new to show: leave the user's viewport and selection alone.
+            if (!unchanged) renderClustersToGraph(refreshed.clusters, refreshedEdges);
           }
         } catch {
           // Label refresh is best-effort; failures are non-critical.
@@ -2500,22 +2597,20 @@ export function useGraphTab(
   const lastVectorDbStatusRef = useRef(null);
   useEffect(() => {
     if (!isOpen) return undefined;
-    const offFn = /** @type {any} */ (window)?.api?.vectorDb?.onStatusChanged?.(
-      (/** @type {any} */ payload) => {
-        const status = payload?.status;
-        if (!status) return;
-        const prev = lastVectorDbStatusRef.current;
-        lastVectorDbStatusRef.current = status;
-        // Only refresh on the transition INTO `connected`/`online` from a
-        // degraded state; ignore steady-state ticks to avoid refresh loops.
-        const becameHealthy =
-          (status === 'connected' || status === 'online') &&
-          (prev === 'hydrating' || prev === 'recovering' || prev === 'connecting');
-        if (becameHealthy && graphViewEnabled && activeTab === 'graph') {
-          loadClustersRef.current?.();
-        }
+    const offFn = window.electronAPI?.vectorDb?.onStatusChanged?.((/** @type {any} */ payload) => {
+      const status = payload?.status;
+      if (!status) return;
+      const prev = lastVectorDbStatusRef.current;
+      lastVectorDbStatusRef.current = status;
+      // Only refresh on the transition INTO `connected`/`online` from a
+      // degraded state; ignore steady-state ticks to avoid refresh loops.
+      const becameHealthy =
+        (status === 'connected' || status === 'online') &&
+        (prev === 'hydrating' || prev === 'recovering' || prev === 'connecting');
+      if (becameHealthy && graphViewEnabled && activeTab === 'graph') {
+        loadClustersRef.current?.();
       }
-    );
+    });
     return typeof offFn === 'function' ? offFn : undefined;
   }, [isOpen, graphViewEnabled, activeTab]);
 
@@ -2640,6 +2735,28 @@ export function useGraphTab(
     return () => window.removeEventListener('file-operation-complete', handleFileOperation);
   }, [graphActions]);
 
+  /**
+   * Members of a cluster node as `{ id, metadata }` rows. Only semantic
+   * clusters (`cluster:<n>`) exist in the backend; a regrouped or duplicate
+   * group is described by the node's own memberIds, so look those up directly.
+   */
+  const fetchClusterMemberRows = useCallback(
+    async (/** @type {any} */ clusterNodeId, /** @type {any} */ memberIds) => {
+      const numericClusterId = parseSemanticClusterId(clusterNodeId);
+      if (numericClusterId !== null) {
+        const memberResp =
+          await window.electronAPI?.embeddings?.getClusterMembers?.(numericClusterId);
+        return memberResp?.success && Array.isArray(memberResp.members) ? memberResp.members : [];
+      }
+      const ids = Array.isArray(memberIds) ? memberIds.filter(Boolean) : [];
+      const { metadata } = await fetchFileMetadataChunked(ids);
+      return ids
+        .filter((/** @type {any} */ id) => metadata[id])
+        .map((/** @type {any} */ id) => ({ id, metadata: metadata[id] }));
+    },
+    []
+  );
+
   /**
    * Expand a cluster to show its members with current file names
    */
@@ -2682,14 +2799,7 @@ export function useGraphTab(
         // Fetch actual file metadata to get current names (not original names)
         let membersWithMetadata = [];
         try {
-          // Extract numeric cluster ID from the string ID (e.g., "cluster:0" -> 0)
-          const numericClusterId = parseInt(clusterId.replace('cluster:', ''), 10);
-          const memberResp =
-            await window.electronAPI?.embeddings?.getClusterMembers?.(numericClusterId);
-
-          if (memberResp?.success && Array.isArray(memberResp.members)) {
-            membersWithMetadata = memberResp.members;
-          }
+          membersWithMetadata = await fetchClusterMemberRows(clusterId, memberIds);
         } catch (fetchErr) {
           logger.warn('[Graph] Failed to fetch cluster members metadata:', fetchErr);
         }
@@ -3866,6 +3976,13 @@ export function useGraphTab(
     event.preventDefault();
     event.stopPropagation();
     if (!node?.id) return;
+    // The menu only has items for files and clusters; for anything else
+    // (folder, query, duplicate group) it would open as an empty box.
+    const menuKind = node.data?.kind || node.type || 'file';
+    if (menuKind !== 'file' && menuKind !== 'cluster') {
+      setContextMenu(null);
+      return;
+    }
 
     // Estimated menu dimensions for viewport clamping
     const menuW = 180;
@@ -4176,7 +4293,13 @@ export function useGraphTab(
     hasLoadedStats && stats && typeof stats.files === 'number' && stats.files === 0 && !error;
   // Use fresh metadata from the vector DB when available (for current file paths after moves)
   const selectedPath = freshMetadata?.path || selectedNode?.data?.path || '';
-  const selectedLabel = freshMetadata?.name || selectedNode?.data?.label || selectedNode?.id || '';
+  // The metadata handler returns `fileName`; `name` is kept for older payloads.
+  const selectedLabel =
+    /** @type {any} */ (freshMetadata)?.fileName ||
+    /** @type {any} */ (freshMetadata)?.name ||
+    selectedNode?.data?.label ||
+    selectedNode?.id ||
+    '';
   const selectedKind = selectedNode?.data?.kind || '';
   const nodeLabelById = useMemo(() => {
     const map = new Map();
@@ -4295,15 +4418,32 @@ export function useGraphTab(
         }));
 
         const result = await window.electronAPI.files.organize(operations);
-        if (result.success) {
+        const rows = Array.isArray(result?.results) ? result.results : [];
+        const failedSources = new Set(
+          rows
+            .filter((/** @type {any} */ row) => row?.success === false)
+            .map((/** @type {any} */ row) => row.source)
+        );
+        if (result?.success) {
           refreshStats();
-          // Remove moved files from triage list
+          // Remove moved files from triage list (a failed row stays listed)
           setTriageFiles((prev) =>
             prev.filter(
-              (f) => !files.find((/** @type {any} */ mf) => (mf.path || mf.id) === (f.path || f.id))
+              (f) =>
+                failedSources.has(f.path || f.id) ||
+                !files.find((/** @type {any} */ mf) => (mf.path || mf.id) === (f.path || f.id))
             )
           );
         }
+        if (!result?.success || failedSources.size > 0) {
+          const failedCount = result?.success ? failedSources.size : files.length;
+          const detail =
+            rows.find((/** @type {any} */ row) => row?.success === false)?.error || result?.error;
+          throw new Error(
+            `Could not move ${failedCount} of ${files.length} file(s)` +
+              (typeof detail === 'string' && detail ? `: ${detail}` : '')
+          );
+        }
       } catch (error) {
         logger.error('Failed to move files', {
           error: error?.message,
@@ -4315,6 +4455,9 @@ export function useGraphTab(
         // sanitized for known error shapes.
         const { message } = mapErrorToNotification({ error, operationType: 'Move files' });
         setError(message);
+        // Rethrow so the triage dialog shows the failure instead of closing
+        // as though the move had worked.
+        throw new Error(message, { cause: error });
       }
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -4405,24 +4548,19 @@ export function useGraphTab(
     try {
       const allFiles = [];
       for (const cluster of scatteredClusters) {
-        const clusterId = parseInt(cluster.id.replace('cluster:', ''), 10);
-        if (isNaN(clusterId)) continue;
-
-        const result = await window.electronAPI.embeddings.getClusterMembers(clusterId);
-        if (result.success && result.members) {
-          allFiles.push(
-            ...result.members.map((/** @type {any} */ m) => ({
-              id: m.id,
-              path: getMetadataPath(m?.metadata || {}, m.id) || m.id,
-              name: getMetadataName(
-                m?.metadata || {},
-                getMetadataPath(m?.metadata || {}, m.id),
-                m.id
-              ),
-              size: m.metadata?.size
-            }))
-          );
-        }
+        const members = await fetchClusterMemberRows(cluster.id, cluster.data?.memberIds);
+        allFiles.push(
+          ...members.map((/** @type {any} */ m) => ({
+            id: m.id,
+            path: getMetadataPath(m?.metadata || {}, m.id) || m.id,
+            name: getMetadataName(
+              m?.metadata || {},
+              getMetadataPath(m?.metadata || {}, m.id),
+              m.id
+            ),
+            size: m.metadata?.size
+          }))
+        );
       }
 
       // Deduplicate by path
@@ -4438,7 +4576,13 @@ export function useGraphTab(
       });
       setGraphStatus('Failed to load scattered files');
     }
-  }, [clusterInsights.clusterNodes, setGraphStatus, setIsTriageModalOpen, setTriageFiles]);
+  }, [
+    clusterInsights.clusterNodes,
+    fetchClusterMemberRows,
+    setGraphStatus,
+    setIsTriageModalOpen,
+    setTriageFiles
+  ]);
 
   const handleOrgFindingClick = useCallback(
     (/** @type {any} */ findingKey) => {
diff --git a/src/renderer/components/search/nodes/FolderNode.jsx b/src/renderer/components/search/nodes/FolderNode.jsx
index 9acebfe..bdff72a 100644
--- a/src/renderer/components/search/nodes/FolderNode.jsx
+++ b/src/renderer/components/search/nodes/FolderNode.jsx
@@ -3,21 +3,28 @@ import PropTypes from 'prop-types';
 import { Handle, Position, NodeToolbar } from '@xyflow/react';
 import { Folder, FolderInput, FolderOpen } from 'lucide-react';
 import { IconButton } from '../../ui';
+import { useAppSelector } from '../../../store/hooks';
+import { selectSmartFolders } from '../../../store/selectors';
+import { resolveSmartFolderPath } from '../utils/graphLayoutUtils';
 
 const FolderNode = memo(({ data, selected }) => {
   const label = data?.label || 'Suggested folder';
   const memberCount = data?.memberCount || 0;
   const folderId = data?.id;
+  // The node only knows the smart folder's name; moving and revealing need
+  // its path on disk. Empty when the name matches no configured smart folder.
+  const smartFolders = useAppSelector(selectSmartFolders);
+  const folderPath = resolveSmartFolderPath(smartFolders, data?.label);
 
   const dispatchFolderAction = useCallback(
     (action) => {
       window.dispatchEvent(
         new CustomEvent('graph:folderAction', {
-          detail: { action, folderId, folderPath: label }
+          detail: { action, folderId, folderName: label, folderPath }
         })
       );
     },
-    [folderId, label]
+    [folderId, label, folderPath]
   );
 
   const handleMoveFilesHere = useCallback(
diff --git a/src/renderer/components/search/utils/clusterRegroupUtils.js b/src/renderer/components/search/utils/clusterRegroupUtils.js
index 9502a3b..a25e4e8 100644
--- a/src/renderer/components/search/utils/clusterRegroupUtils.js
+++ b/src/renderer/components/search/utils/clusterRegroupUtils.js
@@ -211,3 +211,18 @@ export function regroupClustersForMode(clusters, mode) {
     };
   });
 }
+
+/**
+ * Numeric backend id of a semantic cluster node (`cluster:<n>`). Regrouped
+ * (`regroup:<mode>:<bucket>`) and duplicate-group nodes have no backend
+ * cluster, so they return null and callers must use the node's own memberIds.
+ *
+ * @param {any} clusterNodeId
+ * @returns {number|null}
+ */
+export function parseSemanticClusterId(clusterNodeId) {
+  const match = /^cluster:(\d+)$/.exec(typeof clusterNodeId === 'string' ? clusterNodeId : '');
+  if (!match) return null;
+  const numeric = Number(match[1]);
+  return Number.isSafeInteger(numeric) ? numeric : null;
+}
diff --git a/src/renderer/components/search/utils/graphLayoutUtils.js b/src/renderer/components/search/utils/graphLayoutUtils.js
index ee754c0..0940ef1 100644
--- a/src/renderer/components/search/utils/graphLayoutUtils.js
+++ b/src/renderer/components/search/utils/graphLayoutUtils.js
@@ -155,3 +155,102 @@ export function buildRecommendationGraph(/** @type {any[]} */ fileNodes = []) {
     edges
   };
 }
+
+/**
+ * Folder nodes are keyed by smart-folder NAME (see buildRecommendationGraph);
+ * file operations need the folder's real path. Returns '' when unknown.
+ *
+ * @param {any[]} smartFolders - `{ name, path }` entries from the store
+ * @param {string} folderName
+ * @returns {string}
+ */
+export function resolveSmartFolderPath(smartFolders, folderName) {
+  const wanted = typeof folderName === 'string' ? folderName.trim() : '';
+  if (!wanted) return '';
+  // Already an absolute path (older recommendation payloads).
+  if (/^([a-zA-Z]:[\\/]|[\\/])/.test(wanted)) return wanted;
+  const key = wanted.toLowerCase();
+  const match = (Array.isArray(smartFolders) ? smartFolders : []).find(
+    (folder) =>
+      typeof folder?.name === 'string' &&
+      folder.name.trim().toLowerCase() === key &&
+      typeof folder?.path === 'string' &&
+      folder.path.trim().length > 0
+  );
+  return match ? match.path : '';
+}
+
+export const REL_CLUSTER_EDGE_PREFIX = 'rel-cluster:';
+
+/**
+ * Knowledge edges between clusters are fetched once per cluster load and
+ * added after the first render. A re-render (mode/filter change, background
+ * refresh) rebuilds the edge list, so carry over the ones whose two clusters
+ * are still on screen.
+ *
+ * @param {any[]} previousEdges - edges currently in the graph
+ * @param {any[]} nextNodes - nodes about to be rendered
+ * @param {any[]} nextEdges - edges about to be rendered
+ * @returns {any[]}
+ */
+export function carryOverRelClusterEdges(previousEdges, nextNodes, nextEdges) {
+  const next = Array.isArray(nextEdges) ? nextEdges : [];
+  const nodeIds = new Set((Array.isArray(nextNodes) ? nextNodes : []).map((n) => n?.id));
+  const taken = new Set(next.map((e) => e?.id));
+  const kept = (Array.isArray(previousEdges) ? previousEdges : []).filter(
+    (edge) =>
+      typeof edge?.id === 'string' &&
+      edge.id.startsWith(REL_CLUSTER_EDGE_PREFIX) &&
+      !taken.has(edge.id) &&
+      nodeIds.has(edge.source) &&
+      nodeIds.has(edge.target)
+  );
+  return kept.length > 0 ? [...next, ...kept] : next;
+}
+
+/**
+ * Fingerprint of a freshly drawn cluster overview: which nodes, and where.
+ *
+ * @param {any[]} nodes
+ * @returns {string}
+ */
+export function buildClusterOverviewSignature(nodes) {
+  return (Array.isArray(nodes) ? nodes : [])
+    .map((n) => `${n?.id}@${Math.round(n?.position?.x ?? 0)},${Math.round(n?.position?.y ?? 0)}`)
+    .sort()
+    .join('|');
+}
+
+/**
+ * True while the graph is still exactly the overview that was drawn: no node
+ * added, removed, expanded or dragged since. The delayed background refresh
+ * redraws the whole graph, so it may only run while this holds.
+ *
+ * @param {string|null} signature - from buildClusterOverviewSignature at draw time
+ * @param {any[]} currentNodes
+ * @returns {boolean}
+ */
+export function isClusterOverviewUntouched(signature, currentNodes) {
+  if (typeof signature !== 'string' || signature.length === 0) return false;
+  const nodes = Array.isArray(currentNodes) ? currentNodes : [];
+  if (nodes.some((n) => n?.data?.expanded || n?.dragging)) return false;
+  return buildClusterOverviewSignature(nodes) === signature;
+}
+
+/**
+ * What a cluster payload would draw. Two payloads with the same key render
+ * the same overview, so a refresh that returns one can be skipped.
+ *
+ * @param {any[]} clusters
+ * @param {any[]} crossClusterEdges
+ * @returns {string}
+ */
+export function getClusterPayloadKey(clusters, crossClusterEdges) {
+  const clusterPart = (Array.isArray(clusters) ? clusters : [])
+    .map((c) => `${c?.id}:${c?.label}:${c?.memberCount}:${c?.confidence}`)
+    .join('|');
+  const edgePart = (Array.isArray(crossClusterEdges) ? crossClusterEdges : [])
+    .map((e) => `${e?.source}>${e?.target}:${e?.similarity}`)
+    .join('|');
+  return `${clusterPart}#${edgePart}`;
+}
diff --git a/src/renderer/components/search/utils/index.js b/src/renderer/components/search/utils/index.js
index 0b35fa1..d404b58 100644
--- a/src/renderer/components/search/utils/index.js
+++ b/src/renderer/components/search/utils/index.js
@@ -20,6 +20,12 @@ export {
   buildUndirectedEdgeKey,
   applyParallelEdgeOffsets,
   buildRecommendationGraph,
+  resolveSmartFolderPath,
+  carryOverRelClusterEdges,
+  buildClusterOverviewSignature,
+  isClusterOverviewUntouched,
+  getClusterPayloadKey,
+  REL_CLUSTER_EDGE_PREFIX,
   EDGE_KIND_PRIORITY
 } from './graphLayoutUtils';
 
@@ -44,9 +50,18 @@ export {
   flattenClusterMembers,
   getRecencyBucketKey,
   getRecencyBucketLabel,
+  parseSemanticClusterId,
   RECENCY_BUCKETS
 } from './clusterRegroupUtils';
 
+export {
+  FILE_METADATA_BATCH_LIMIT,
+  ADD_TAGS_BATCH_LIMIT,
+  chunkArray,
+  fetchFileMetadataChunked,
+  addTagsChunked
+} from './ipcBatchUtils';
+
 export {
   scoreBridgeConnection,
   scoreClusterForInsight,
diff --git a/src/renderer/components/search/utils/ipcBatchUtils.js b/src/renderer/components/search/utils/ipcBatchUtils.js
new file mode 100644
index 0000000..23105bb
--- /dev/null
+++ b/src/renderer/components/search/utils/ipcBatchUtils.js
@@ -0,0 +1,110 @@
+// @ts-check
+/**
+ * Chunked wrappers for IPC calls whose schemas cap the id list.
+ * A cluster or an Atlas lasso can hold far more ids than one call accepts,
+ * and an oversized call is rejected whole by the main-process schema.
+ */
+
+/** `getFileMetadata` accepts at most this many ids per call. */
+export const FILE_METADATA_BATCH_LIMIT = 100;
+/** `files.addTags` accepts at most this many file ids per call. */
+export const ADD_TAGS_BATCH_LIMIT = 1000;
+
+/**
+ * @template T
+ * @param {T[]} items
+ * @param {number} size
+ * @returns {T[][]}
+ */
+export function chunkArray(items, size) {
+  const list = Array.isArray(items) ? items : [];
+  const step = Math.max(1, Math.floor(size) || 1);
+  /** @type {T[][]} */
+  const chunks = [];
+  for (let i = 0; i < list.length; i += step) {
+    chunks.push(list.slice(i, i + step));
+  }
+  return chunks;
+}
+
+/**
+ * Fetch metadata for any number of ids, one schema-sized call at a time.
+ * A failed chunk leaves its ids out of `metadata` and is counted in
+ * `failedChunks`; `success` is false only when nothing could be fetched.
+ *
+ * @param {string[]} ids
+ * @param {(ids: string[]) => Promise<any>} [getFileMetadata] - defaults to the preload bridge
+ * @returns {Promise<{ success: boolean, metadata: Record<string, any>, failedChunks: number, error?: string }>}
+ */
+export async function fetchFileMetadataChunked(ids, getFileMetadata) {
+  const call =
+    getFileMetadata ||
+    /** @type {any} */ (globalThis).window?.electronAPI?.embeddings?.getFileMetadata;
+  const list = Array.isArray(ids) ? ids.filter(Boolean) : [];
+  /** @type {Record<string, any>} */
+  const metadata = {};
+  if (typeof call !== 'function') {
+    return { success: false, metadata, failedChunks: 0, error: 'File metadata is unavailable' };
+  }
+  const chunks = chunkArray(list, FILE_METADATA_BATCH_LIMIT);
+  let failedChunks = 0;
+  /** @type {string|undefined} */
+  let error;
+  for (const chunk of chunks) {
+    try {
+      const res = await call(chunk);
+      if (res?.success === false) {
+        failedChunks++;
+        error = error || (typeof res.error === 'string' ? res.error : undefined);
+        continue;
+      }
+      Object.assign(metadata, res?.metadata || {});
+    } catch (e) {
+      failedChunks++;
+      error = error || /** @type {any} */ (e)?.message;
+    }
+  }
+  const success = chunks.length === 0 || failedChunks < chunks.length;
+  return error ? { success, metadata, failedChunks, error } : { success, metadata, failedChunks };
+}
+
+/**
+ * Tag any number of files, one schema-sized call at a time, and report how
+ * many files were really updated (the handler can succeed for only some).
+ *
+ * @param {string[]} fileIds
+ * @param {string[]} tags
+ * @param {(fileIds: string[], tags: string[]) => Promise<any>} [addTags] - defaults to the preload bridge
+ * @returns {Promise<{ success: boolean, total: number, updated: number, failed: number, error?: any }>}
+ */
+export async function addTagsChunked(fileIds, tags, addTags) {
+  const call = addTags || /** @type {any} */ (globalThis).window?.electronAPI?.files?.addTags;
+  const list = Array.isArray(fileIds) ? fileIds.filter(Boolean) : [];
+  const total = list.length;
+  if (typeof call !== 'function') {
+    return { success: false, total, updated: 0, failed: total, error: 'Tagging is unavailable' };
+  }
+  let updated = 0;
+  /** @type {any} */
+  let error;
+  for (const chunk of chunkArray(list, ADD_TAGS_BATCH_LIMIT)) {
+    try {
+      const res = await call(chunk, tags);
+      // Older handlers return no count; treat a bare success as the whole chunk.
+      const count = Number.isFinite(res?.updated)
+        ? Number(res.updated)
+        : res?.success
+          ? chunk.length
+          : 0;
+      updated += Math.min(chunk.length, Math.max(0, count));
+      if (!res?.success || count < chunk.length) {
+        error = error || res?.errors?.[0]?.error || res?.error;
+      }
+    } catch (e) {
+      error = error || /** @type {any} */ (e)?.message;
+    }
+  }
+  const failed = total - updated;
+  const result = { success: updated > 0, total, updated, failed };
+  return error && failed > 0 ? { ...result, error } : result;
+}
diff --git a/test/components/ChatPanel.test.js b/test/components/ChatPanel.test.js
index 0c985c5..4abeb80 100644
--- a/test/components/ChatPanel.test.js
+++ b/test/components/ChatPanel.test.js
@@ -1,5 +1,5 @@
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
 import { Provider } from 'react-redux';
 import { configureStore } from '@reduxjs/toolkit';
 
@@ -296,6 +296,35 @@ describe('ChatPanel', () => {
   });
 });
 
+describe('ChatPanel composer', () => {
+  const typeAndSend = (text) => {
+    const box = screen.getByRole('textbox');
+    fireEvent.change(box, { target: { value: text } });
+    fireEvent.click(screen.getByRole('button', { name: 'Send message' }));
+    return box;
+  };
+
+  test('keeps the typed text when the send is refused', async () => {
+    const onSend = jest.fn().mockResolvedValue(false);
+    renderWithRedux(<ChatPanel {...createBaseProps({ onSend })} />);
+
+    const box = typeAndSend('What changed last quarter?');
+
+    await waitFor(() => expect(onSend).toHaveBeenCalledWith('What changed last quarter?'));
+    await Promise.resolve();
+    expect(box).toHaveValue('What changed last quarter?');
+  });
+
+  test('clears the text once the send is accepted', async () => {
+    const onSend = jest.fn().mockResolvedValue(true);
+    renderWithRedux(<ChatPanel {...createBaseProps({ onSend })} />);
+
+    const box = typeAndSend('What changed last quarter?');
+
+    await waitFor(() => expect(box).toHaveValue(''));
+  });
+});
+
 describe('ChatPanel search-context scope line', () => {
   test('names the scope when search context is on and a search has results', () => {
     renderWithRedux(
diff --git a/test/components/FolderNode.test.js b/test/components/FolderNode.test.js
index 1362d1b..31a03ba 100644
--- a/test/components/FolderNode.test.js
+++ b/test/components/FolderNode.test.js
@@ -29,6 +29,15 @@ jest.mock('../../src/renderer/components/ui', () => ({
   )
 }));
 
+const mockSmartFolders = [
+  { id: 'sf-1', name: 'Invoices/2025', path: 'C:\\Docs\\Invoices\\2025' },
+  { id: 'sf-2', name: 'Receipts', path: 'C:\\Docs\\Receipts' }
+];
+jest.mock('../../src/renderer/store/hooks', () => ({
+  useAppSelector: (selector) => selector({ files: { smartFolders: mockSmartFolders } }),
+  useAppDispatch: () => jest.fn()
+}));
+
 import FolderNode from '../../src/renderer/components/search/nodes/FolderNode';
 
 const baseData = {
@@ -67,10 +76,28 @@ describe('FolderNode keyboard affordances', () => {
     fireEvent.keyDown(node, { key: 'Enter' });
 
     expect(handler).toHaveBeenCalledTimes(1);
+    // folderPath is the smart folder's path on disk, never its display name.
+    expect(handler.mock.calls[0][0].detail).toEqual({
+      action: 'moveFilesHere',
+      folderId: 'folder-1',
+      folderName: 'Invoices/2025',
+      folderPath: 'C:\\Docs\\Invoices\\2025'
+    });
+    window.removeEventListener('graph:folderAction', handler);
+  });
+
+  test('sends an empty folderPath when the name matches no smart folder', () => {
+    const handler = jest.fn();
+    window.addEventListener('graph:folderAction', handler);
+
+    render(<FolderNode data={{ ...baseData, label: 'Unknown folder' }} selected={false} />);
+    fireEvent.keyDown(screen.getByRole('button', { name: /Unknown folder/i }), { key: 'Enter' });
+
     expect(handler.mock.calls[0][0].detail).toEqual({
       action: 'moveFilesHere',
       folderId: 'folder-1',
-      folderPath: 'Invoices/2025'
+      folderName: 'Unknown folder',
+      folderPath: ''
     });
     window.removeEventListener('graph:folderAction', handler);
   });
diff --git a/test/components/UnifiedSearchModal.test.js b/test/components/UnifiedSearchModal.test.js
index 528b4bb..498c2c5 100644
--- a/test/components/UnifiedSearchModal.test.js
+++ b/test/components/UnifiedSearchModal.test.js
@@ -30,6 +30,7 @@ import UnifiedSearchModal, {
   getGraphMiniMapNodeColor
 } from '../../src/renderer/components/search/UnifiedSearchModal';
 import { embeddingsIpc } from '../../src/renderer/services/ipc/embeddingsIpc';
+import * as chatIpc from '../../src/renderer/services/ipc/chatIpc';
 
 describe('UnifiedSearchModal', () => {
   beforeEach(() => {
@@ -168,6 +169,27 @@ describe('UnifiedSearchModal', () => {
       }
     });
 
+    test('Ctrl+digit switches tabs while the search field has focus, AltGr+digit does not', () => {
+      const {
+        registerOverlay,
+        unregisterOverlay
+      } = require('../../src/renderer/utils/overlayStack');
+      registerOverlay('knowledge-os-modal');
+      try {
+        renderWithRedux(<UnifiedSearchModal isOpen={true} onClose={jest.fn()} />);
+        const searchInput = screen.getByLabelText(/search query/i);
+
+        // AltGr reports Ctrl+Alt on Windows and types a character.
+        fireEvent.keyDown(searchInput, { key: '4', ctrlKey: true, altKey: true });
+        expect(screen.queryByTestId('chat-panel')).not.toBeInTheDocument();
+
+        fireEvent.keyDown(searchInput, { key: '4', ctrlKey: true });
+        expect(screen.getByTestId('chat-panel')).toBeInTheDocument();
+      } finally {
+        unregisterOverlay('knowledge-os-modal');
+      }
+    });
+
     // The Atlas stays mounted after its first visit (WebGL rebuild is slow) and
     // is only hidden visually; without `inert` its controls stay in the Tab order.
     test('the hidden Atlas tab is inert while another tab is active', () => {
@@ -463,6 +485,88 @@ describe('UnifiedSearchModal', () => {
         expect(resultRows[0]?.className).toContain('border-stratosort-blue/35');
       });
     });
+
+    const searchForTwoResults = async () => {
+      mockElectronAPI.embeddings.search.mockResolvedValue({
+        success: true,
+        results: [
+          { id: 'doc-a', metadata: { name: 'alpha.pdf', path: '/path/alpha.pdf' }, score: 0.9 },
+          { id: 'doc-b', metadata: { name: 'beta.pdf', path: '/path/beta.pdf' }, score: 0.8 }
+        ],
+        mode: 'hybrid'
+      });
+      const view = renderWithRedux(<UnifiedSearchModal isOpen={true} onClose={jest.fn()} />);
+      fireEvent.change(screen.getByLabelText(/search query/i), { target: { value: 'report' } });
+      await act(async () => {
+        jest.advanceTimersByTime(400);
+      });
+      await waitFor(() => {
+        expect(view.container.querySelectorAll('[data-result-item]')).toHaveLength(2);
+      });
+      return view;
+    };
+
+    test('the preview never shows the previous file’s details under a new selection', async () => {
+      let resolveBeta;
+      mockElectronAPI.analysisHistory.getFileHistory = jest.fn((filePath) =>
+        filePath === '/path/alpha.pdf'
+          ? Promise.resolve({ analysis: { extractedText: 'ALPHA EXTRACTED TEXT' } })
+          : new Promise((resolve) => {
+              resolveBeta = resolve;
+            })
+      );
+      // jsdom has no scrollIntoView; selecting a row scrolls it into view.
+      const originalScrollIntoView = Element.prototype.scrollIntoView;
+      Element.prototype.scrollIntoView = jest.fn();
+      try {
+        await searchForTwoResults();
+
+        fireEvent.click(screen.getAllByText('alpha.pdf')[0]);
+        await waitFor(() => {
+          expect(screen.getByText('ALPHA EXTRACTED TEXT')).toBeInTheDocument();
+        });
+
+        // While the second file's details load.
+        fireEvent.click(screen.getAllByText('beta.pdf')[0]);
+        await waitFor(() => {
+          expect(mockElectronAPI.analysisHistory.getFileHistory).toHaveBeenCalledWith(
+            '/path/beta.pdf'
+          );
+        });
+        expect(screen.queryByText('ALPHA EXTRACTED TEXT')).not.toBeInTheDocument();
+
+        // And when it turns out to have no analysis history.
+        await act(async () => {
+          resolveBeta(null);
+        });
+        expect(screen.queryByText('ALPHA EXTRACTED TEXT')).not.toBeInTheDocument();
+      } finally {
+        Element.prototype.scrollIntoView = originalScrollIntoView;
+        delete mockElectronAPI.analysisHistory.getFileHistory;
+      }
+    });
+
+    test('Ask AI scopes the question to the results on screen', async () => {
+      const queryStreamSpy = jest
+        .spyOn(chatIpc, 'queryStream')
+        .mockReturnValue({ on: jest.fn(), begin: jest.fn(), cancel: jest.fn() });
+      try {
+        await searchForTwoResults();
+
+        fireEvent.click(screen.getByRole('button', { name: /ask ai assistant/i }));
+
+        await waitFor(() => {
+          expect(queryStreamSpy).toHaveBeenCalledWith(
+            expect.objectContaining({
+              query: 'Tell me about "report" based on these results',
+              contextFileIds: ['doc-a', 'doc-b']
+            })
+          );
+        });
+      } finally {
+        queryStreamSpy.mockRestore();
+      }
+    });
   });
 
   describe('Error Handling', () => {
diff --git a/test/renderer/components/search/knowledgeGraphHelpers.test.js b/test/renderer/components/search/knowledgeGraphHelpers.test.js
new file mode 100644
index 0000000..3ea64da
--- /dev/null
+++ b/test/renderer/components/search/knowledgeGraphHelpers.test.js
@@ -0,0 +1,268 @@
+/**
+ * Pure helpers behind the Knowledge OS graph and Atlas fixes: smart-folder
+ * path lookup, cluster-id parsing, carried-over knowledge edges, the guard
+ * for the delayed cluster refresh, and the chunked IPC wrappers.
+ */
+import {
+  resolveSmartFolderPath,
+  carryOverRelClusterEdges,
+  buildClusterOverviewSignature,
+  isClusterOverviewUntouched,
+  getClusterPayloadKey,
+  parseSemanticClusterId,
+  chunkArray,
+  fetchFileMetadataChunked,
+  addTagsChunked,
+  FILE_METADATA_BATCH_LIMIT,
+  ADD_TAGS_BATCH_LIMIT
+} from '../../../../src/renderer/components/search/utils';
+
+const ids = (count, prefix = 'file:') => Array.from({ length: count }, (_, i) => `${prefix}${i}`);
+
+describe('resolveSmartFolderPath', () => {
+  const folders = [
+    { id: 'a', name: 'Invoices', path: 'C:\\Docs\\Invoices' },
+    { id: 'b', name: 'No Path' },
+    { id: 'c', name: 'Receipts', path: '/home/me/Receipts' }
+  ];
+
+  test('maps a smart folder name to its path, ignoring case and padding', () => {
+    expect(resolveSmartFolderPath(folders, 'Invoices')).toBe('C:\\Docs\\Invoices');
+    expect(resolveSmartFolderPath(folders, '  invoices ')).toBe('C:\\Docs\\Invoices');
+    expect(resolveSmartFolderPath(folders, 'Receipts')).toBe('/home/me/Receipts');
+  });
+
+  test('returns an empty string when the name has no usable path', () => {
+    expect(resolveSmartFolderPath(folders, 'Taxes')).toBe('');
+    expect(resolveSmartFolderPath(folders, 'No Path')).toBe('');
+    expect(resolveSmartFolderPath(null, 'Invoices')).toBe('');
+    expect(resolveSmartFolderPath(folders, undefined)).toBe('');
+  });
+
+  test('passes an absolute path through unchanged', () => {
+    expect(resolveSmartFolderPath([], 'C:\\Other\\Place')).toBe('C:\\Other\\Place');
+    expect(resolveSmartFolderPath([], 'D:/Other/Place')).toBe('D:/Other/Place');
+    expect(resolveSmartFolderPath([], '/srv/place')).toBe('/srv/place');
+  });
+});
+
+describe('parseSemanticClusterId', () => {
+  test('reads the backend number from a semantic cluster id', () => {
+    expect(parseSemanticClusterId('cluster:0')).toBe(0);
+    expect(parseSemanticClusterId('cluster:17')).toBe(17);
+  });
+
+  test('returns null for regrouped, duplicate and malformed ids', () => {
+    expect(parseSemanticClusterId('regroup:type:documents')).toBeNull();
+    expect(parseSemanticClusterId('dup-group-3')).toBeNull();
+    expect(parseSemanticClusterId('cluster:')).toBeNull();
+    expect(parseSemanticClusterId('cluster:1:2')).toBeNull();
+    expect(parseSemanticClusterId(undefined)).toBeNull();
+    expect(parseSemanticClusterId(4)).toBeNull();
+  });
+});
+
+describe('carryOverRelClusterEdges', () => {
+  const rel = { id: 'rel-cluster:cluster:1->cluster:2', source: 'cluster:1', target: 'cluster:2' };
+  const cross = { id: 'cross:cluster:1->cluster:2', source: 'cluster:1', target: 'cluster:2' };
+  const nodes = [{ id: 'cluster:1' }, { id: 'cluster:2' }];
+
+  test('keeps knowledge edges whose two clusters are still drawn', () => {
+    expect(carryOverRelClusterEdges([rel], nodes, [cross])).toEqual([cross, rel]);
+  });
+
+  test('drops knowledge edges that lost an endpoint', () => {
+    expect(carryOverRelClusterEdges([rel], [{ id: 'cluster:1' }], [cross])).toEqual([cross]);
+  });
+
+  test('never carries other edge kinds or duplicates an edge already present', () => {
+    const stale = { id: 'cross:old', source: 'cluster:1', target: 'cluster:2' };
+    expect(carryOverRelClusterEdges([stale], nodes, [cross])).toEqual([cross]);
+    expect(carryOverRelClusterEdges([rel], nodes, [cross, rel])).toEqual([cross, rel]);
+  });
+
+  test('tolerates missing lists', () => {
+    expect(carryOverRelClusterEdges(undefined, nodes, undefined)).toEqual([]);
+  });
+});
+
+describe('cluster overview refresh guard', () => {
+  const drawn = [
+    { id: 'cluster:1', position: { x: 10, y: 20 }, data: {} },
+    { id: 'cluster:2', position: { x: 300, y: 40 }, data: {} }
+  ];
+  const signature = buildClusterOverviewSignature(drawn);
+
+  test('holds while the drawn overview is unchanged, in any node order', () => {
+    expect(isClusterOverviewUntouched(signature, drawn)).toBe(true);
+    expect(isClusterOverviewUntouched(signature, [...drawn].reverse())).toBe(true);
+  });
+
+  test('fails once a cluster is expanded', () => {
+    const expanded = [{ ...drawn[0], data: { expanded: true } }, drawn[1]];
+    expect(isClusterOverviewUntouched(signature, expanded)).toBe(false);
+  });
+
+  test('fails once a node is moved or is being dragged', () => {
+    const moved = [{ ...drawn[0], position: { x: 90, y: 20 } }, drawn[1]];
+    expect(isClusterOverviewUntouched(signature, moved)).toBe(false);
+    expect(isClusterOverviewUntouched(signature, [{ ...drawn[0], dragging: true }, drawn[1]])).toBe(
+      false
+    );
+  });
+
+  test('fails once nodes are added or removed', () => {
+    const added = [...drawn, { id: 'file:a', position: { x: 0, y: 0 }, data: {} }];
+    expect(isClusterOverviewUntouched(signature, added)).toBe(false);
+    expect(isClusterOverviewUntouched(signature, [drawn[0]])).toBe(false);
+  });
+
+  test('fails when no overview was recorded', () => {
+    expect(isClusterOverviewUntouched(null, drawn)).toBe(false);
+    expect(isClusterOverviewUntouched('', [])).toBe(false);
+  });
+});
+
+describe('getClusterPayloadKey', () => {
+  const clusters = [{ id: 1, label: 'Taxes', memberCount: 4, confidence: 0.8 }];
+  const edges = [{ source: 1, target: 2, similarity: 0.5 }];
+
+  test('is stable for an identical payload', () => {
+    expect(getClusterPayloadKey(clusters, edges)).toBe(
+      getClusterPayloadKey(
+        clusters.map((c) => ({ ...c })),
+        edges.map((e) => ({ ...e }))
+      )
+    );
+  });
+
+  test('changes with a label, a member count or an edge', () => {
+    const base = getClusterPayloadKey(clusters, edges);
+    expect(getClusterPayloadKey([{ ...clusters[0], label: 'Tax 2025' }], edges)).not.toBe(base);
+    expect(getClusterPayloadKey([{ ...clusters[0], memberCount: 5 }], edges)).not.toBe(base);
+    expect(getClusterPayloadKey(clusters, [])).not.toBe(base);
+  });
+});
+
+describe('chunkArray', () => {
+  test('splits into pieces of at most the given size', () => {
+    expect(chunkArray([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
+    expect(chunkArray([], 3)).toEqual([]);
+    expect(chunkArray(undefined, 3)).toEqual([]);
+  });
+
+  test('never loops forever on a bad size', () => {
+    expect(chunkArray([1, 2], 0)).toEqual([[1], [2]]);
+  });
+});
+
+describe('fetchFileMetadataChunked', () => {
+  const echo = jest.fn(async (chunk) => ({
+    success: true,
+    metadata: Object.fromEntries(chunk.map((id) => [id, { fileName: id }]))
+  }));
+
+  beforeEach(() => echo.mockClear());
+
+  test('never sends more ids than one call accepts and merges every chunk', async () => {
+    const result = await fetchFileMetadataChunked(ids(250), echo);
+
+    expect(echo).toHaveBeenCalledTimes(3);
+    echo.mock.calls.forEach(([chunk]) =>
+      expect(chunk.length).toBeLessThanOrEqual(FILE_METADATA_BATCH_LIMIT)
+    );
+    expect(Object.keys(result.metadata)).toHaveLength(250);
+    expect(result).toMatchObject({ success: true, failedChunks: 0 });
+  });
+
+  test('keeps what it could fetch when one chunk is rejected or throws', async () => {
+    const flaky = jest
+      .fn(echo)
+      .mockImplementationOnce(async () => ({ success: false, error: 'Too many ids' }))
+      .mockImplementationOnce(async () => {
+        throw new Error('ipc down');
+      });
+
+    const result = await fetchFileMetadataChunked(ids(250), flaky);
+
+    expect(result.success).toBe(true);
+    expect(result.failedChunks).toBe(2);
+    expect(result.error).toBe('Too many ids');
+    expect(Object.keys(result.metadata)).toHaveLength(50);
+  });
+
+  test('reports failure when every chunk fails', async () => {
+    const result = await fetchFileMetadataChunked(ids(150), async () => ({
+      success: false,
+      error: 'nope'
+    }));
+
+    expect(result).toEqual({ success: false, metadata: {}, failedChunks: 2, error: 'nope' });
+  });
+
+  test('uses the preload bridge by default and fails cleanly without it', async () => {
+    window.electronAPI = { embeddings: { getFileMetadata: echo } };
+    await expect(fetchFileMetadataChunked(['file:a'])).resolves.toMatchObject({
+      success: true,
+      metadata: { 'file:a': { fileName: 'file:a' } }
+    });
+
+    delete window.electronAPI;
+    await expect(fetchFileMetadataChunked(['file:a'])).resolves.toMatchObject({ success: false });
+  });
+});
+
+describe('addTagsChunked', () => {
+  test('splits a large selection and adds up what was really tagged', async () => {
+    const addTags = jest.fn(async (chunk) => ({ success: true, updated: chunk.length }));
+
+    const result = await addTagsChunked(ids(2500), ['tax'], addTags);
+
+    expect(addTags).toHaveBeenCalledTimes(3);
+    addTags.mock.calls.forEach(([chunk, tags]) => {
+      expect(chunk.length).toBeLessThanOrEqual(ADD_TAGS_BATCH_LIMIT);
+      expect(tags).toEqual(['tax']);
+    });
+    expect(result).toEqual({ success: true, total: 2500, updated: 2500, failed: 0 });
+  });
+
+  test('reports a partial result instead of full success', async () => {
+    const addTags = jest
+      .fn()
+      .mockResolvedValueOnce({ success: true, updated: 1000 })
+      .mockResolvedValueOnce({
+        success: true,
+        updated: 400,
+        errors: [{ fileId: 'file:1400', error: 'File not indexed' }]
+      })
+      .mockRejectedValueOnce(new Error('ipc down'));
+
+    const result = await addTagsChunked(ids(2500), ['tax'], addTags);
+
+    expect(result).toEqual({
+      success: true,
+      total: 2500,
+      updated: 1400,
+      failed: 1100,
+      error: 'File not indexed'
+    });
+  });
+
+  test('fails when nothing was tagged', async () => {
+    const addTags = jest.fn(async () => ({ success: false, updated: 0, error: 'No index' }));
+
+    await expect(addTagsChunked(ids(3), ['tax'], addTags)).resolves.toEqual({
+      success: false,
+      total: 3,
+      updated: 0,
+      failed: 3,
+      error: 'No index'
+    });
+  });
+
+  test('counts a bare success as the whole chunk', async () => {
+    await expect(addTagsChunked(ids(3), ['tax'], async () => ({ success: true }))).resolves.toEqual(
+      { success: true, total: 3, updated: 3, failed: 0 }
+    );
+  });
+});
diff --git a/test/renderer/components/search/useChatTab.scope.test.js b/test/renderer/components/search/useChatTab.scope.test.js
index 4e99bec..b3a6424 100644
--- a/test/renderer/components/search/useChatTab.scope.test.js
+++ b/test/renderer/components/search/useChatTab.scope.test.js
@@ -1,11 +1,19 @@
 /**
  * useChatTab — adding files to the chat document scope must never be a
- * silent no-op: when nothing could be added the user is told why.
+ * silent no-op: when nothing could be added the user is told why. Also
+ * covers the scope size limits, the fresh-open reset, refused sends,
+ * conversation switching and where settings-save failures are shown.
  */
 
 import { renderHook, act } from '@testing-library/react';
 
 import { useChatTab } from '../../../../src/renderer/components/search/hooks/useChatTab';
+import { queryStream, getConversation } from '../../../../src/renderer/services/ipc/chatIpc';
+
+jest.mock('../../../../src/renderer/services/ipc/chatIpc', () => ({
+  queryStream: jest.fn(),
+  getConversation: jest.fn()
+}));
 
 jest.mock('../../../../src/shared/logger', () => {
   const logger = { info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() };
@@ -18,8 +26,7 @@ function renderChatTab() {
       isOpen: false,
       searchResults: [],
       defaultTopK: 6,
-      openFile: jest.fn(),
-      setError: jest.fn()
+      openFile: jest.fn()
     })
   );
 }
@@ -122,4 +129,217 @@ describe('useChatTab document scope', () => {
     expect(api.files.getDirectoryContents).toHaveBeenCalledWith('/synthetic/docs/Invoices');
     expect(result.current.documentScope.map((item) => item.id)).toEqual(['file:jan']);
   });
+
+  const folderOf = (count, prefix = 'f') => ({
+    success: true,
+    files: Array.from({ length: count }, (_, i) => ({ path: `/synthetic/big/${prefix}-${i}.txt` }))
+  });
+  const indexEveryPath = (paths) => ({
+    success: true,
+    results: paths.map((p) => ({ id: `file:${p}`, path: p, name: p.split('/').pop() }))
+  });
+  const bigFolder = [{ path: '/synthetic/big', name: 'big', type: 'folder' }];
+
+  test('looks a large folder up in chunks of at most 1000 paths', async () => {
+    api.files.getDirectoryContents.mockResolvedValue(folderOf(2500));
+    const { result } = renderChatTab();
+
+    await act(async () => {
+      await result.current.handleAddToScope(bigFolder);
+    });
+
+    const chunkSizes = api.embeddings.findFilesByPaths.mock.calls.map(([paths]) => paths.length);
+    expect(chunkSizes).toEqual([1000, 1000, 500]);
+    expect(result.current.chatWarning).toMatch(/2500 file\(s\) not in index/);
+  });
+
+  test('caps the scope at 1000 files and says so', async () => {
+    api.files.getDirectoryContents.mockResolvedValue(folderOf(1500));
+    api.embeddings.findFilesByPaths.mockImplementation(async (paths) => indexEveryPath(paths));
+    const { result } = renderChatTab();
+
+    await act(async () => {
+      await result.current.handleAddToScope(bigFolder);
+    });
+
+    expect(result.current.documentScope).toHaveLength(1000);
+    expect(result.current.chatWarning).toMatch(/holds up to 1000 files/);
+    // The unchecked remainder is not reported as missing from the index.
+    expect(result.current.chatWarning).not.toMatch(/not in index/);
+  });
+
+  test('caps the scope across several additions', async () => {
+    api.embeddings.findFilesByPaths.mockImplementation(async (paths) => indexEveryPath(paths));
+    const { result } = renderChatTab();
+
+    api.files.getDirectoryContents.mockResolvedValue(folderOf(600, 'a'));
+    await act(async () => {
+      await result.current.handleAddToScope(bigFolder);
+    });
+    expect(result.current.documentScope).toHaveLength(600);
+    expect(result.current.chatWarning).toBe('');
+
+    api.files.getDirectoryContents.mockResolvedValue(folderOf(600, 'b'));
+    await act(async () => {
+      await result.current.handleAddToScope(bigFolder);
+    });
+    expect(result.current.documentScope).toHaveLength(1000);
+    expect(result.current.chatWarning).toMatch(/holds up to 1000 files/);
+  });
+});
+
+describe('useChatTab conversation state', () => {
+  const originalApi = window.electronAPI;
+  let api;
+  const fakeStream = () => ({ on: jest.fn(), begin: jest.fn(), cancel: jest.fn() });
+  const deferred = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  };
+
+  beforeEach(() => {
+    queryStream.mockReset();
+    getConversation.mockReset();
+    queryStream.mockImplementation(() => fakeStream());
+    api = {
+      settings: { get: jest.fn().mockResolvedValue({}), save: jest.fn().mockResolvedValue({}) },
+      chat: { resetSession: jest.fn().mockResolvedValue({}) }
+    };
+    Object.defineProperty(window, 'electronAPI', { configurable: true, value: api });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(window, 'electronAPI', { configurable: true, value: originalApi });
+  });
+
+  test('a send reports whether it was accepted', async () => {
+    const { result } = renderChatTab();
+
+    act(() => result.current.setStrictScope(true));
+    let accepted;
+    await act(async () => {
+      accepted = await result.current.handleChatSend('What is in my files?');
+    });
+    expect(accepted).toBe(false);
+    expect(queryStream).not.toHaveBeenCalled();
+    expect(result.current.chatMessages).toEqual([]);
+
+    act(() => result.current.setStrictScope(false));
+    await act(async () => {
+      accepted = await result.current.handleChatSend('What is in my files?');
+    });
+    expect(accepted).toBe(true);
+    expect(queryStream).toHaveBeenCalledTimes(1);
+
+    // A second send while the first is still streaming is refused.
+    await act(async () => {
+      accepted = await result.current.handleChatSend('And another thing');
+    });
+    expect(accepted).toBe(false);
+    expect(queryStream).toHaveBeenCalledTimes(1);
+  });
+
+  test('a fresh open starts a new conversation with nothing carried over', async () => {
+    getConversation.mockResolvedValue({
+      messages: [{ role: 'user', text: 'earlier question' }],
+      documentScope: [{ id: 'file:1', path: '/synthetic/a.pdf', name: 'a.pdf', type: 'file' }]
+    });
+    const { result } = renderChatTab();
+
+    await act(async () => {
+      await result.current.handleSelectConversation('conv-1');
+    });
+    act(() => result.current.setStrictScope(true));
+    await act(async () => {
+      await result.current.handleChatSend('follow-up');
+    });
+    // Leaves a warning behind, and the first send is still in flight.
+    await act(async () => {
+      await result.current.handleChatSend('too soon');
+    });
+    expect(result.current.currentConversationId).toBe('conv-1');
+    expect(result.current.documentScope).toHaveLength(1);
+    expect(result.current.chatWarning).not.toBe('');
+    expect(result.current.chatStatus).not.toBe('');
+
+    act(() => result.current.resetChatState());
+
+    expect(result.current.chatMessages).toEqual([]);
+    expect(result.current.currentConversationId).toBeNull();
+    expect(result.current.documentScope).toEqual([]);
+    expect(result.current.strictScope).toBe(false);
+    expect(result.current.chatWarning).toBe('');
+    expect(result.current.chatStatus).toBe('');
+    expect(result.current.isChatting).toBe(false);
+    expect(result.current.chatSessionRef.current).not.toBe('conv-1');
+
+    // The send that was in flight when the modal closed no longer blocks.
+    let accepted;
+    await act(async () => {
+      accepted = await result.current.handleChatSend('first question after reopening');
+    });
+    expect(accepted).toBe(true);
+  });
+
+  test('the conversation clicked last wins when loads resolve out of order', async () => {
+    const first = deferred();
+    const second = deferred();
+    getConversation.mockImplementation((id) => (id === 'conv-a' ? first.promise : second.promise));
+    const { result } = renderChatTab();
+
+    let loadA;
+    let loadB;
+    act(() => {
+      loadA = result.current.handleSelectConversation('conv-a');
+      loadB = result.current.handleSelectConversation('conv-b');
+    });
+    await act(async () => {
+      second.resolve({ messages: [{ role: 'user', text: 'from B' }] });
+      await loadB;
+    });
+    await act(async () => {
+      first.resolve({ messages: [{ role: 'user', text: 'from A' }] });
+      await loadA;
+    });
+
+    expect(result.current.currentConversationId).toBe('conv-b');
+    expect(result.current.chatMessages).toEqual([{ role: 'user', text: 'from B' }]);
+    expect(result.current.chatSessionRef.current).toBe('conv-b');
+  });
+
+  test('a conversation that finishes loading after New chat is dropped', async () => {
+    const pending = deferred();
+    getConversation.mockReturnValue(pending.promise);
+    const { result } = renderChatTab();
+
+    let load;
+    act(() => {
+      load = result.current.handleSelectConversation('conv-a');
+    });
+    act(() => result.current.handleNewConversation());
+    await act(async () => {
+      pending.resolve({ messages: [{ role: 'user', text: 'from A' }] });
+      await load;
+    });
+
+    expect(result.current.currentConversationId).toBeNull();
+    expect(result.current.chatMessages).toEqual([]);
+  });
+
+  test('a failed settings save is reported in the chat panel warning', async () => {
+    api.settings.save.mockRejectedValue(new Error('disk full'));
+    const { result } = renderChatTab();
+
+    await act(async () => {
+      result.current.handleResponseModeChange('deep');
+    });
+    expect(result.current.chatWarning).toBe('Failed to save chat response mode. Please try again.');
+    // Not the chat error banner: its Retry button would regenerate an answer.
+    expect(result.current.chatError).toBe('');
+  });
 });
diff --git a/test/renderer/components/search/useGraphTab.knowledgeFixes.test.js b/test/renderer/components/search/useGraphTab.knowledgeFixes.test.js
new file mode 100644
index 0000000..a9797c5
--- /dev/null
+++ b/test/renderer/components/search/useGraphTab.knowledgeFixes.test.js
@@ -0,0 +1,293 @@
+/**
+ * @jest-environment jsdom
+ */
+/**
+ * Knowledge OS graph handlers that used to hide failures or act on the wrong
+ * thing: the vector DB status subscription, cluster rename, triage moves,
+ * oversized tag requests and the context menu on nodes that have no menu.
+ * The store hooks and the graph's own state are mocked.
+ */
+import { renderHook, act } from '@testing-library/react';
+
+const mockDispatch = jest.fn();
+const mockState = {
+  ui: { currentPhase: 'organize', viewMode: 'phased', isOrganizing: false, isLoading: false },
+  files: {
+    smartFolders: [],
+    selectedFiles: [],
+    fileStates: {},
+    organizedFiles: [],
+    organizedPathIndex: []
+  },
+  analysis: { isAnalyzing: false, results: [] }
+};
+
+jest.mock('../../../../src/renderer/store/hooks', () => ({
+  useAppDispatch: jest.fn(() => mockDispatch),
+  useAppSelector: jest.fn((selector) => selector(mockState))
+}));
+
+jest.mock('../../../../src/renderer/contexts/NotificationContext', () => ({
+  useNotification: jest.fn(() => ({ showInfo: jest.fn(), addNotification: jest.fn() }))
+}));
+
+let mockNodes = [];
+const mockSetNodes = jest.fn((update) => {
+  mockNodes = typeof update === 'function' ? update(mockNodes) : update;
+});
+
+jest.mock('../../../../src/renderer/hooks', () => {
+  const fallback = {};
+  const actions = new Proxy(
+    {},
+    {
+      get: (_target, name) => {
+        if (name === 'setNodes') return mockSetNodes;
+        if (!fallback[name]) fallback[name] = jest.fn();
+        return fallback[name];
+      }
+    }
+  );
+  return {
+    useGraphState: () => ({ nodes: mockNodes, edges: [], selectedNodeId: null, actions })
+  };
+});
+
+jest.mock('../../../../src/renderer/components/search/hooks/useDuplicateBadgeScan', () => ({
+  useDuplicateBadgeScan: jest.fn()
+}));
+
+jest.mock('../../../../src/renderer/utils/elkLayout', () => ({
+  elkLayout: jest.fn(),
+  cancelPendingLayout: jest.fn(),
+  debouncedElkLayout: jest.fn(),
+  smartLayout: jest.fn(),
+  clusterRadialLayout: jest.fn(),
+  clusterExpansionLayout: jest.fn(),
+  LARGE_GRAPH_THRESHOLD: 1000
+}));
+
+import { useGraphTab } from '../../../../src/renderer/components/search/hooks/useGraphTab';
+
+function renderGraphTab(overrides = {}) {
+  const ref = () => ({ current: null });
+  const setError = jest.fn();
+  const refreshStats = jest.fn();
+  const hook = renderHook(() =>
+    useGraphTab({
+      isOpen: false,
+      activeTab: 'search',
+      onClose: jest.fn(),
+      query: '',
+      setQuery: jest.fn(),
+      defaultTopK: 10,
+      stats: null,
+      graphViewEnabled: false,
+      setError,
+      recommendationMap: {},
+      sidebarSections: {},
+      chatMessages: [],
+      setChatMessages: jest.fn(),
+      clusterActionRefs: ref(),
+      handleMoveAllToFolderRef: ref(),
+      layoutRequestCounterRef: { current: 0 },
+      error: null,
+      hasLoadedStats: false,
+      refreshStats,
+      organizationalHealthRef: ref(),
+      ...overrides
+    })
+  );
+  return { ...hook, setError, refreshStats };
+}
+
+const clusterNode = (id, label = 'Old name') => ({
+  id,
+  type: 'clusterNode',
+  position: { x: 0, y: 0 },
+  data: { kind: 'cluster', label, isAutoGenerated: true }
+});
+
+const labelOf = (id) => mockNodes.find((n) => n.id === id)?.data?.label;
+
+describe('Knowledge OS graph handlers', () => {
+  beforeEach(() => {
+    mockNodes = [];
+    mockSetNodes.mockClear();
+    window.electronAPI = {};
+  });
+
+  afterEach(() => {
+    delete window.electronAPI;
+    delete window.api;
+  });
+
+  describe('vector DB status subscription', () => {
+    test('subscribes through the preload bridge and unsubscribes on unmount', () => {
+      const off = jest.fn();
+      const onStatusChanged = jest.fn(() => off);
+      const legacy = jest.fn();
+      window.electronAPI = { vectorDb: { onStatusChanged } };
+      window.api = { vectorDb: { onStatusChanged: legacy } };
+
+      const { unmount } = renderGraphTab({ isOpen: true });
+
+      expect(onStatusChanged).toHaveBeenCalledTimes(1);
+      expect(onStatusChanged).toHaveBeenCalledWith(expect.any(Function));
+      expect(legacy).not.toHaveBeenCalled();
+
+      unmount();
+      expect(off).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('cluster rename', () => {
+    test('puts the old name back and reports it when the backend refuses', async () => {
+      mockNodes = [clusterNode('cluster:3')];
+      const renameCluster = jest.fn(async () => ({ success: false, error: 'Cluster not found' }));
+      window.electronAPI = { embeddings: { renameCluster } };
+      const { result, setError } = renderGraphTab();
+
+      await act(async () => {
+        await result.current.handleRenameCluster({ id: 'cluster:3', newLabel: 'Taxes' });
+      });
+
+      expect(renameCluster).toHaveBeenCalledWith('cluster:3', 'Taxes');
+      expect(labelOf('cluster:3')).toBe('Old name');
+      expect(setError).toHaveBeenCalledWith(expect.stringContaining('Could not rename'));
+    });
+
+    test('keeps the new name when the backend accepts it', async () => {
+      mockNodes = [clusterNode('cluster:3')];
+      window.electronAPI = {
+        embeddings: { renameCluster: jest.fn(async () => ({ success: true })) }
+      };
+      const { result, setError } = renderGraphTab();
+
+      await act(async () => {
+        await result.current.handleRenameCluster({ id: 'cluster:3', newLabel: 'Taxes' });
+      });
+
+      expect(labelOf('cluster:3')).toBe('Taxes');
+      expect(setError).not.toHaveBeenCalled();
+    });
+
+    test('renames a regrouped group locally without calling the backend', async () => {
+      mockNodes = [clusterNode('regroup:type:documents')];
+      const renameCluster = jest.fn();
+      window.electronAPI = { embeddings: { renameCluster } };
+      const { result, setError } = renderGraphTab();
+
+      await act(async () => {
+        await result.current.handleRenameCluster({
+          id: 'regroup:type:documents',
+          newLabel: 'Paperwork'
+        });
+      });
+
+      expect(renameCluster).not.toHaveBeenCalled();
+      expect(labelOf('regroup:type:documents')).toBe('Paperwork');
+      expect(setError).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('triage move', () => {
+    const files = [{ path: 'C:\\in\\a.pdf' }, { path: 'C:\\in\\b.pdf' }];
+
+    test('rejects when the batch fails, so the dialog does not close as if it worked', async () => {
+      const organize = jest.fn(async () => ({ success: false, error: 'Destination is read-only' }));
+      window.electronAPI = { files: { organize } };
+      const { result, setError, refreshStats } = renderGraphTab();
+
+      let thrown = null;
+      await act(async () => {
+        try {
+          await result.current.handleMoveFiles(files, 'C:\\out');
+        } catch (e) {
+          thrown = e;
+        }
+      });
+
+      expect(organize).toHaveBeenCalledTimes(1);
+      expect(thrown).toBeInstanceOf(Error);
+      expect(setError).toHaveBeenCalledTimes(1);
+      expect(refreshStats).not.toHaveBeenCalled();
+    });
+
+    test('rejects on a partial move and keeps the file that failed in the list', async () => {
+      const organize = jest.fn(async (ops) => ({
+        success: true,
+        successCount: 1,
+        failCount: 1,
+        results: [
+          { success: true, source: ops[0].source, destination: ops[0].destination },
+          { success: false, source: ops[1].source, error: 'File is in use' }
+        ]
+      }));
+      window.electronAPI = { files: { organize } };
+      const { result, setError } = renderGraphTab();
+      act(() => result.current.setTriageFiles(files));
+
+      let thrown = null;
+      await act(async () => {
+        try {
+          await result.current.handleMoveFiles(files, 'C:\\out');
+        } catch (e) {
+          thrown = e;
+        }
+      });
+
+      expect(thrown).toBeInstanceOf(Error);
+      expect(setError).toHaveBeenCalledTimes(1);
+      expect(result.current.triageFiles).toEqual([files[1]]);
+    });
+
+    test('resolves and clears the list when every file moved', async () => {
+      const organize = jest.fn(async (ops) => ({
+        success: true,
+        results: ops.map((op) => ({ success: true, source: op.source }))
+      }));
+      window.electronAPI = { files: { organize } };
+      const { result, setError, refreshStats } = renderGraphTab();
+      act(() => result.current.setTriageFiles(files));
+
+      await act(async () => {
+        await result.current.handleMoveFiles(files, 'C:\\out');
+      });
+
+      expect(setError).not.toHaveBeenCalled();
+      expect(refreshStats).toHaveBeenCalled();
+      expect(result.current.triageFiles).toEqual([]);
+    });
+  });
+
+  describe('context menu', () => {
+    const rightClick = () => ({
+      preventDefault: jest.fn(),
+      stopPropagation: jest.fn(),
+      clientX: 40,
+      clientY: 40
+    });
+
+    test.each([
+      ['folder', { id: 'folder:Invoices', type: 'folderNode', data: { kind: 'folder' } }],
+      ['query', { id: 'query:tax', type: 'queryNode', data: { kind: 'query' } }],
+      ['duplicate group', { id: 'dup:1', type: 'clusterNode', data: { kind: 'duplicate' } }]
+    ])('does not open for a %s node', (_name, node) => {
+      const { result } = renderGraphTab();
+
+      act(() => result.current.onNodeContextMenu(rightClick(), node));
+
+      expect(result.current.contextMenu).toBeNull();
+    });
+
+    test('opens for a file node', () => {
+      const { result } = renderGraphTab();
+      const node = { id: 'file:a', type: 'fileNode', data: { kind: 'file', path: 'C:\\a.pdf' } };
+
+      act(() => result.current.onNodeContextMenu(rightClick(), node));
+
+      expect(result.current.contextMenu).toMatchObject({ nodeId: 'file:a' });
+    });
+  });
+});