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' });
+    });
+  });
+});