From 0d0c1eb855cb828c706ecd2e9bf4121d7c7a4078 Mon Sep 17 00:00:00 2001
From: Levy Tate <78818969+iLevyTate@users.noreply.github.com>
Date: Wed, 11 Nov 2026 13:02:19 -0500
Subject: [PATCH] fix(analysis): the run outlives leaving Discover, and a
 queued run is not cancelled by auto-advance

A finished batch scheduled a jump to Organize 2 s later. Files added during
that batch start as the next run right away, and the jump fired anyway:
Discover unmounted and aborted the queued run 1.5 s in (logged as
"Analysis interrupted by navigation", 70 files, 0 processed). Returning to
Discover restarted all 70, and because the run lived in Discover, analysis
locked every phase tab for the whole run, so the earlier batch could not be
organized meanwhile.

- Auto-advance skips when another run is active or queued (read at fire time).
- The run moves out of DiscoverPhase into AnalysisRunProvider, mounted in
  PhaseRenderer above every phase, together with the stuck-run watchdog and
  the total-failure flag. Discover reads it through useAnalysisRun().
- A running analysis no longer pauses the phase tabs, Alt+Arrow, dashboard
  jump links or Discover's Continue (once a file is ready). File moves,
  loading and undo/redo still pause; switching to the dashboard still waits,
  since the dashboard replaces PhaseRenderer.
- The run's final merge drops results for files organized mid-run, so a
  moved file's old-path result is not re-added.
---
 src/renderer/components/NavigationBar.jsx     |  29 ++-
 src/renderer/components/PhaseRenderer.jsx     |   7 +-
 src/renderer/phases/DiscoverPhase.jsx         | 134 ++-----------
 .../phases/discover/AnalysisRunProvider.jsx   | 177 ++++++++++++++++++
 src/renderer/phases/discover/index.js         |   1 +
 src/renderer/phases/discover/useAnalysis.js   | 104 ++++++----
 src/renderer/utils/phaseNavigation.js         |  24 +--
 test/components/AnalysisRunProvider.test.js   | 153 +++++++++++++++
 test/components/DiscoverPhase.test.js         |  50 +++--
 test/components/PhaseRenderer.test.js         |   6 +
 .../dashboard/DashboardView.test.js           |  18 +-
 test/renderer/phaseNavigation.test.js         |   5 +-
 test/renderer/usePhaseJump.test.js            |  12 +-
 test/useAnalysis.test.js                      |  58 ++++++
 test/useKeyboardShortcuts.phaseGating.test.js |  10 +-
 15 files changed, 580 insertions(+), 208 deletions(-)
 create mode 100644 src/renderer/phases/discover/AnalysisRunProvider.jsx
 create mode 100644 test/components/AnalysisRunProvider.test.js

diff --git a/src/renderer/components/NavigationBar.jsx b/src/renderer/components/NavigationBar.jsx
index 9219a02..6c01fac 100644
--- a/src/renderer/components/NavigationBar.jsx
+++ b/src/renderer/components/NavigationBar.jsx
@@ -267,7 +267,7 @@ const NavTab = memo(function NavTab({
       title={
         !canNavigate && !isActive
           ? blockReason ||
-            'Navigation is paused while analysis or file moves run. Wait for the step to finish, or cancel from the active phase.'
+            'Navigation is paused while files are being moved. Wait for the move to finish, or cancel from the active phase.'
           : `Step ${(metadata?.step ?? 0) + 1} of ${PHASE_ORDER.length} • ${metadata?.description || metadata?.title}`
       }
       style={{ WebkitAppRegion: 'no-drag' }}
@@ -339,8 +339,9 @@ const DASHBOARD_WAITS_FOR_ANALYSIS =
  * dashboard overview. Subscribes to ui.viewMode directly and dispatches
  * setViewMode, so it is not gated by isBlockedByOperation the way the phase
  * tabs are: the way back to Guided is always open. The way into the dashboard
- * waits for a running analysis, because Discover owns the run and App.js
- * unmounts Discover to show the dashboard, which would stop it.
+ * waits for a running analysis: the run lives in AnalysisRunProvider inside
+ * PhaseRenderer, and App.js replaces PhaseRenderer with the dashboard, which
+ * would stop it. (Phase tabs do not wait: the run outlives a phase change.)
  */
 const ViewModeToggle = memo(function ViewModeToggle() {
   const dispatch = useAppDispatch();
@@ -842,9 +843,10 @@ function NavigationBar() {
     };
   }, []);
 
-  // Keep top-level navigation responsive; analysis state can become stale.
-  const isBlockedByOperation =
-    isOrganizing || isLoading || Boolean(isAnalyzing) || Boolean(isUndoRedoExecuting);
+  // File moves, loading and undo/redo pause the step tabs. A running analysis
+  // does not: the run lives in AnalysisRunProvider above the phases, so the
+  // user can organize finished files while the rest keep analyzing.
+  const isBlockedByOperation = isOrganizing || isLoading || Boolean(isUndoRedoExecuting);
 
   // Phase navigation handler
   const handlePhaseChange = useCallback(
@@ -871,9 +873,7 @@ function NavigationBar() {
         showInfo(
           isOrganizing
             ? 'Files are still moving. Stay on this step until the move finishes or cancel from Organize.'
-            : isAnalyzing
-              ? 'Analysis is still running. You can keep reviewing this step while processing finishes.'
-              : 'Navigation is paused until the current operation finishes.',
+            : 'Navigation is paused until the current operation finishes.',
           5200
         );
         return;
@@ -891,11 +891,11 @@ function NavigationBar() {
       showInfo(
         isOrganizing
           ? 'Navigation is paused while files are moving. You can still open Settings from the gear.'
-          : 'Navigation is paused while analysis is running. You can still open Settings from the gear.',
+          : 'Navigation is paused until the current operation finishes. You can still open Settings from the gear.',
         5200
       );
     },
-    [actions, currentPhase, isAnalyzing, isBlockedByOperation, isOrganizing, showInfo]
+    [actions, currentPhase, isBlockedByOperation, isOrganizing, showInfo]
   );
 
   // Settings handler
@@ -905,7 +905,8 @@ function NavigationBar() {
 
   // Return to the dashboard the user deep-linked out of. A view switch, not a
   // phase transition, so moves and undo/redo do not gate it. A running
-  // analysis does: it belongs to Discover, which unmounts for the dashboard.
+  // analysis does: its provider lives in PhaseRenderer, which the dashboard
+  // replaces.
   const handleReturnToDashboard = useCallback(() => {
     if (isAnalyzing) {
       showInfo(DASHBOARD_WAITS_FOR_ANALYSIS, 5200);
@@ -1052,9 +1053,7 @@ function NavigationBar() {
                 ? executionStatus?.label
                   ? `${executionStatus.label} Step navigation is paused until file moves finish.`
                   : 'Step navigation is paused while undo/redo moves files.'
-                : isAnalyzing
-                  ? 'Step navigation is paused while analysis is running.'
-                  : 'Step navigation is paused. Please wait for the current operation to finish.'}
+                : 'Step navigation is paused. Please wait for the current operation to finish.'}
           </Text>
         </div>
       )}
diff --git a/src/renderer/components/PhaseRenderer.jsx b/src/renderer/components/PhaseRenderer.jsx
index 811f665..c8d65b8 100644
--- a/src/renderer/components/PhaseRenderer.jsx
+++ b/src/renderer/components/PhaseRenderer.jsx
@@ -6,6 +6,7 @@ import { LazyLoadingSpinner } from './ui/LoadingSkeleton';
 import { logger } from '../../shared/logger';
 import { PHASES, PHASE_METADATA } from '../../shared/constants';
 import perfMarks from '../../shared/perfMarks';
+import { AnalysisRunProvider } from '../phases/discover/AnalysisRunProvider';
 
 // The settings overlay and useKeyboardShortcuts are deliberately NOT here:
 // they live in App.js so they stay active on the dashboard surface, which
@@ -222,8 +223,10 @@ function PhaseRenderer() {
     }
   };
 
+  // AnalysisRunProvider wraps every phase so an analysis run outlives the
+  // Discover screen: the user can organize finished files mid-run.
   return (
-    <>
+    <AnalysisRunProvider>
       <PhaseEnterAnnouncement currentPhase={currentPhase} />
       <div className="flex flex-col w-full h-full">
         <Suspense fallback={<LazyLoadingSpinner message={getPhaseLoadingMessage(currentPhase)} />}>
@@ -242,7 +245,7 @@ function PhaseRenderer() {
           </AnimatePresence>
         </Suspense>
       </div>
-    </>
+    </AnalysisRunProvider>
   );
 }
 
diff --git a/src/renderer/phases/DiscoverPhase.jsx b/src/renderer/phases/DiscoverPhase.jsx
index 0bbc57d..0f0b286 100644
--- a/src/renderer/phases/DiscoverPhase.jsx
+++ b/src/renderer/phases/DiscoverPhase.jsx
@@ -18,13 +18,12 @@ import {
   AnalysisProgress
 } from '../components/discover';
 import { FileListSkeleton } from '../components/ui/LoadingSkeleton';
-import store from '../store';
 import { useAppSelector } from '../store/hooks';
 import { selectOrganizedCount } from '../store/selectors';
 import { toCanonicalPath } from '../utils/canonicalPath';
 import {
   useDiscoverState,
-  useAnalysis,
+  useAnalysisRun,
   useFileHandlers,
   useFileActions,
   getFileStateDisplayInfo
@@ -46,13 +45,9 @@ function DiscoverPhase() {
     dateFormat,
     caseConvention,
     separator,
-    namingSettings,
     setSelectedFiles,
     addSelectedFiles,
     setAnalysisResults,
-    setIsAnalyzing,
-    setAnalysisProgress,
-    setCurrentAnalysisFile,
     setNamingConvention,
     setDateFormat,
     setCaseConvention,
@@ -61,7 +56,6 @@ function DiscoverPhase() {
     updateFileState,
     resetAnalysisState,
     actions,
-    getCurrentPhase,
     organizedFiles,
     organizedPathIndex,
     fileStats
@@ -72,7 +66,6 @@ function DiscoverPhase() {
   const { openSearchModal } = useFloatingSearch();
 
   const [showNamingSettings, setShowNamingSettings] = useState(false);
-  const [totalAnalysisFailure, setTotalAnalysisFailure] = useState(false);
   const [showEmbeddingPrompt, setShowEmbeddingPrompt] = useState(false);
   const [isRebuildingEmbeddings, setIsRebuildingEmbeddings] = useState(false);
   const isMountedRef = useRef(true);
@@ -280,45 +273,17 @@ function DiscoverPhase() {
   // and it's never set in this context, so use a stable empty object
   const stablePhaseData = useRef({}).current;
 
-  const extendedActions = useMemo(
-    () => ({
-      ...actions,
-      setPhaseData: (key, value) => {
-        if (key === 'totalAnalysisFailure') {
-          setTotalAnalysisFailure(value);
-        } else {
-          actions.setPhaseData(key, value);
-        }
-      }
-    }),
-    [actions]
-  );
-
+  // The run lives in AnalysisRunProvider (PhaseRenderer), not here, so it
+  // keeps going when the user moves to Organize or Complete.
   const {
     analyzeFiles,
     cancelAnalysis,
     clearAnalysisQueue,
     retryFailedFiles,
-    pruneBatchResultsForPath
-  } = useAnalysis({
-    selectedFiles,
-    fileStates,
-    analysisResults,
-    isAnalyzing,
-    analysisProgress,
-    namingSettings,
-    setters: {
-      setIsAnalyzing,
-      setAnalysisProgress,
-      setCurrentAnalysisFile,
-      setAnalysisResults,
-      setFileStates
-    },
-    updateFileState,
-    addNotification,
-    actions: extendedActions,
-    getCurrentPhase
-  });
+    pruneBatchResultsForPath,
+    totalAnalysisFailure,
+    setTotalAnalysisFailure
+  } = useAnalysisRun();
 
   const {
     isScanning,
@@ -354,7 +319,6 @@ function DiscoverPhase() {
   );
 
   const { isDragging, dragProps } = useDragAndDrop(handleFileDrop);
-  const initialStuckCheckRef = useRef(false);
 
   useSettingsSubscription(
     useCallback(
@@ -447,67 +411,7 @@ function DiscoverPhase() {
     };
   }, []);
 
-  const analysisProgressRef = useRef(analysisProgress);
-  analysisProgressRef.current = analysisProgress;
-
-  useEffect(() => {
-    if (initialStuckCheckRef.current) return;
-    initialStuckCheckRef.current = true;
-
-    if (isAnalyzing) {
-      const lastActivity = analysisProgress?.lastActivity || Date.now();
-      const timeSinceActivity = Date.now() - lastActivity;
-      const isStuck = timeSinceActivity > 2 * 60 * 1000;
-
-      if (isStuck) {
-        logger.info('Detected stuck analysis state on mount, resetting');
-        resetAnalysisState('Stuck analysis detected on mount');
-      }
-    }
-  }, [isAnalyzing, analysisProgress, resetAnalysisState]);
-
-  useEffect(() => {
-    if (!isAnalyzing) return;
-
-    const checkStalled = () => {
-      // Use Redux store directly to prevent stale reads when the window is minimized
-      // (React suspends rendering when minimized, so refs bound to props become stale)
-      const state = store.getState();
-      const isActuallyAnalyzing = state.analysis.isAnalyzing;
-
-      if (!isActuallyAnalyzing) return; // Already finished, ignore
-
-      const progress = state.analysis.analysisProgress || analysisProgressRef.current;
-      const lastActivity = progress?.lastActivity || Date.now();
-      const timeSinceActivity = Date.now() - lastActivity;
-      const current = progress?.current || 0;
-      const total = progress?.total || 0;
-
-      if (current === 0 && total > 0 && timeSinceActivity > TIMEOUTS.STUCK_ANALYSIS_CHECK) {
-        addNotification('Analysis paused. Restarting...', 'info', 3000, 'analysis-stalled');
-        resetAnalysisState('Analysis stalled with no progress after 2 minutes');
-        return;
-      }
-
-      if (timeSinceActivity > TIMEOUTS.ANALYSIS_LOCK) {
-        addNotification('Analysis timed out. Ready to retry.', 'info', 3000, 'analysis-auto-reset');
-        resetAnalysisState('Stuck analysis state after 5 minutes of inactivity');
-      }
-    };
-
-    // Defer state updates so the interval handler returns quickly (avoids Long Task violations)
-    const checkStalledDeferred = () => {
-      setTimeout(checkStalled, 0);
-    };
-
-    // Check immediately on dependency change
-    checkStalled();
-
-    // Also check periodically in case dependencies stop updating (the exact stall scenario).
-    // Defer so the interval handler returns quickly (avoids Long Task violations).
-    const intervalId = setInterval(checkStalledDeferred, TIMEOUTS.SERVICE_STARTUP);
-    return () => clearInterval(intervalId);
-  }, [isAnalyzing, addNotification, resetAnalysisState]);
+  // Stuck-run checks live in AnalysisRunProvider with the run itself.
 
   const fileStatesRef = useRef(fileStates);
   fileStatesRef.current = fileStates;
@@ -938,27 +842,25 @@ function DiscoverPhase() {
           // one analyzed file, so there would be nothing to organize there.
           // Organized history also opens Organize, the same rule as the tab
           // (uiSlice getPhaseNavigation), so a returning user can reach it.
+          // A running analysis does not hold this back: the run lives above
+          // the phases (AnalysisRunProvider), so files already analyzed can be
+          // organized while the rest keep analyzing.
           const canContinue = visibleReadyCount > 0 || organizedCount > 0;
-          const disabledBecauseAnalyzing = isAnalyzing;
-          const disabledBecauseNoReady = !canContinue;
 
           let disabledReason = '';
-          if (disabledBecauseAnalyzing) {
-            disabledReason = 'Analysis is in progress.';
-          } else if (disabledBecauseNoReady) {
-            disabledReason =
-              visibleFailedCount > 0
+          if (!canContinue) {
+            disabledReason = isAnalyzing
+              ? 'Organize opens as soon as the first file is analyzed.'
+              : visibleFailedCount > 0
                 ? 'All files failed analysis. Retry them, or clear the queue and try again.'
                 : 'Analyze at least one file first.';
+          } else if (isAnalyzing) {
+            disabledReason = 'Analysis keeps running while you organize the files that are ready.';
           }
 
           return (
             <Button
               onClick={() => {
-                if (isAnalyzing) {
-                  addNotification('Please wait for analysis to complete', 'warning', 3000);
-                  return;
-                }
                 if (!canContinue) {
                   addNotification(
                     visibleFailedCount > 0
@@ -977,7 +879,7 @@ function DiscoverPhase() {
               variant="primary"
               size="md"
               className="w-full sm:w-auto min-w-[180px]"
-              disabled={isAnalyzing || !canContinue}
+              disabled={!canContinue}
               title={disabledReason || undefined}
             >
               Continue to Organize →
diff --git a/src/renderer/phases/discover/AnalysisRunProvider.jsx b/src/renderer/phases/discover/AnalysisRunProvider.jsx
new file mode 100644
index 0000000..56a24d7
--- /dev/null
+++ b/src/renderer/phases/discover/AnalysisRunProvider.jsx
@@ -0,0 +1,177 @@
+import React, { createContext, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import PropTypes from 'prop-types';
+import { useStore } from 'react-redux';
+import { TIMEOUTS } from '../../../shared/performanceConstants';
+import { createLogger } from '../../../shared/logger';
+import { useNotification } from '../../contexts/NotificationContext';
+import { useDiscoverState } from './useDiscoverState';
+import { useAnalysis } from './useAnalysis';
+
+const logger = createLogger('AnalysisRunProvider');
+
+const AnalysisRunContext = createContext(null);
+
+/**
+ * Owns the analysis run for the phased workflow. It sits in PhaseRenderer,
+ * above the phase screens, so moving between Discover, Organize and Complete
+ * no longer unmounts the run: files analyzed earlier can be reviewed and
+ * organized while later ones are still analyzing. (When the run lived in
+ * Discover, leaving Discover cancelled it, so the tabs were locked for the
+ * whole run.) The dashboard replaces PhaseRenderer, so switching to it still
+ * waits for the run to finish.
+ *
+ * Discover reads the run's actions through useAnalysisRun().
+ */
+export function AnalysisRunProvider({ children }) {
+  const store = useStore();
+  const {
+    selectedFiles,
+    analysisResults,
+    isAnalyzing,
+    analysisProgress,
+    fileStates,
+    namingSettings,
+    setIsAnalyzing,
+    setAnalysisProgress,
+    setCurrentAnalysisFile,
+    setAnalysisResults,
+    setFileStates,
+    updateFileState,
+    resetAnalysisState,
+    actions,
+    getCurrentPhase
+  } = useDiscoverState();
+  const { addNotification } = useNotification();
+  const [totalAnalysisFailure, setTotalAnalysisFailure] = useState(false);
+
+  const extendedActions = useMemo(
+    () => ({
+      ...actions,
+      setPhaseData: (key, value) => {
+        if (key === 'totalAnalysisFailure') {
+          setTotalAnalysisFailure(value);
+        } else {
+          actions.setPhaseData(key, value);
+        }
+      }
+    }),
+    [actions]
+  );
+
+  const {
+    analyzeFiles,
+    cancelAnalysis,
+    clearAnalysisQueue,
+    retryFailedFiles,
+    pruneBatchResultsForPath
+  } = useAnalysis({
+    selectedFiles,
+    fileStates,
+    analysisResults,
+    isAnalyzing,
+    analysisProgress,
+    namingSettings,
+    setters: {
+      setIsAnalyzing,
+      setAnalysisProgress,
+      setCurrentAnalysisFile,
+      setAnalysisResults,
+      setFileStates
+    },
+    updateFileState,
+    addNotification,
+    actions: extendedActions,
+    getCurrentPhase
+  });
+
+  // Stuck-run checks. They belong with the run, not with the Discover
+  // screen: a run that keeps going while the user is on Organize still
+  // needs its watchdog.
+  const initialStuckCheckRef = useRef(false);
+  useEffect(() => {
+    if (initialStuckCheckRef.current) return;
+    initialStuckCheckRef.current = true;
+
+    if (isAnalyzing) {
+      const lastActivity = analysisProgress?.lastActivity || Date.now();
+      if (Date.now() - lastActivity > 2 * 60 * 1000) {
+        logger.info('Detected stuck analysis state on mount, resetting');
+        resetAnalysisState('Stuck analysis detected on mount');
+      }
+    }
+  }, [isAnalyzing, analysisProgress, resetAnalysisState]);
+
+  const analysisProgressRef = useRef(analysisProgress);
+  analysisProgressRef.current = analysisProgress;
+
+  useEffect(() => {
+    if (!isAnalyzing) return undefined;
+
+    const checkStalled = () => {
+      // Read the store directly: React pauses rendering while the window is
+      // minimized, so props and refs bound to them can be stale.
+      const state = /** @type {any} */ (store.getState());
+      if (!state.analysis.isAnalyzing) return; // Already finished
+
+      const progress = state.analysis.analysisProgress || analysisProgressRef.current;
+      const lastActivity = progress?.lastActivity || Date.now();
+      const timeSinceActivity = Date.now() - lastActivity;
+      const current = progress?.current || 0;
+      const total = progress?.total || 0;
+
+      if (current === 0 && total > 0 && timeSinceActivity > TIMEOUTS.STUCK_ANALYSIS_CHECK) {
+        addNotification('Analysis paused. Restarting...', 'info', 3000, 'analysis-stalled');
+        resetAnalysisState('Analysis stalled with no progress after 2 minutes');
+        return;
+      }
+
+      if (timeSinceActivity > TIMEOUTS.ANALYSIS_LOCK) {
+        addNotification('Analysis timed out. Ready to retry.', 'info', 3000, 'analysis-auto-reset');
+        resetAnalysisState('Stuck analysis state after 5 minutes of inactivity');
+      }
+    };
+
+    checkStalled();
+    // Defer so the interval handler returns quickly (avoids Long Task violations).
+    const intervalId = setInterval(() => setTimeout(checkStalled, 0), TIMEOUTS.SERVICE_STARTUP);
+    return () => clearInterval(intervalId);
+  }, [isAnalyzing, addNotification, resetAnalysisState, store]);
+
+  const value = useMemo(
+    () => ({
+      analyzeFiles,
+      cancelAnalysis,
+      clearAnalysisQueue,
+      retryFailedFiles,
+      pruneBatchResultsForPath,
+      totalAnalysisFailure,
+      setTotalAnalysisFailure
+    }),
+    [
+      analyzeFiles,
+      cancelAnalysis,
+      clearAnalysisQueue,
+      retryFailedFiles,
+      pruneBatchResultsForPath,
+      totalAnalysisFailure
+    ]
+  );
+
+  return <AnalysisRunContext.Provider value={value}>{children}</AnalysisRunContext.Provider>;
+}
+
+AnalysisRunProvider.propTypes = {
+  children: PropTypes.node
+};
+
+/**
+ * The analysis run's actions and its total-failure flag. Must be used under
+ * AnalysisRunProvider (PhaseRenderer mounts it).
+ */
+export function useAnalysisRun() {
+  const run = useContext(AnalysisRunContext);
+  if (!run) {
+    throw new Error('useAnalysisRun must be used inside AnalysisRunProvider');
+  }
+  return run;
+}
diff --git a/src/renderer/phases/discover/index.js b/src/renderer/phases/discover/index.js
index e68e039..dfbaaf3 100644
--- a/src/renderer/phases/discover/index.js
+++ b/src/renderer/phases/discover/index.js
@@ -21,5 +21,6 @@ export {
 // Custom hooks
 export { useDiscoverState } from './useDiscoverState';
 export { useAnalysis } from './useAnalysis';
+export { AnalysisRunProvider, useAnalysisRun } from './AnalysisRunProvider';
 export { useFileHandlers } from './useFileHandlers';
 export { useFileActions } from './useFileActions';
diff --git a/src/renderer/phases/discover/useAnalysis.js b/src/renderer/phases/discover/useAnalysis.js
index f85e725..e14c73d 100644
--- a/src/renderer/phases/discover/useAnalysis.js
+++ b/src/renderer/phases/discover/useAnalysis.js
@@ -37,6 +37,7 @@ import {
 import { mapErrorToNotification } from '../../utils/errorMapping';
 import { normalizeNamingConventionState } from '../../../shared/namingConventions';
 import { toCanonicalPath } from '../../utils/canonicalPath';
+import { collectOrganizedPathKeys, mergeOrganizedPathIndex } from '../../utils/organizedPathIndex';
 import {
   BATCH_BUSY_RETRY_MS,
   filesNotYetReady,
@@ -327,10 +328,42 @@ function mergeFileStates(existingStates, results) {
 }
 
 /**
- * Show appropriate notification based on analysis results.
+ * Move to Organize shortly after a run finishes, unless the user has left
+ * Discover or more analysis is running or queued. Files added during the run
+ * start as the next run right after this one ends; jumping to Organize then
+ * used to unmount Discover and cancel that run before it analyzed anything.
  *
+ * @param {{ actions: any, getCurrentPhase: Function, autoAdvanceTimeoutRef: any, isMoreAnalysisPending?: () => boolean }} params
+ */
+function scheduleAutoAdvance({
+  actions,
+  getCurrentPhase,
+  autoAdvanceTimeoutRef,
+  isMoreAnalysisPending
+}) {
+  clearAutoAdvanceTimeoutRef(autoAdvanceTimeoutRef); // Clear any previous pending timeout
+  autoAdvanceTimeoutRef.current = setTimeout(() => {
+    autoAdvanceTimeoutRef.current = null;
+    const currentPhase = getCurrentPhase?.();
+    if (currentPhase !== (PHASES?.DISCOVER ?? 'discover')) {
+      logger.debug('Skipping auto-advance: phase changed during delay', {
+        currentPhase,
+        expectedPhase: PHASES?.DISCOVER ?? 'discover'
+      });
+      return;
+    }
+    if (isMoreAnalysisPending?.()) {
+      logger.debug('Skipping auto-advance: another analysis run is active or queued');
+      return;
+    }
+    actions.advancePhase(PHASES?.ORGANIZE ?? 'organize');
+  }, 2000);
+}
+
 /**
- * @param {{ successCount: number, failureCount: number, addNotification: Function, actions: any, getCurrentPhase: Function, autoAdvanceTimeoutRef: any }} params
+ * Show appropriate notification based on analysis results.
+ *
+ * @param {{ successCount: number, failureCount: number, addNotification: Function, actions: any, getCurrentPhase: Function, autoAdvanceTimeoutRef: any, isMoreAnalysisPending?: () => boolean }} params
  */
 function showAnalysisCompletionNotification({
   successCount,
@@ -338,7 +371,8 @@ function showAnalysisCompletionNotification({
   addNotification,
   actions,
   getCurrentPhase,
-  autoAdvanceTimeoutRef
+  autoAdvanceTimeoutRef,
+  isMoreAnalysisPending
 }) {
   if (successCount > 0 && failureCount === 0) {
     addNotification(
@@ -347,21 +381,7 @@ function showAnalysisCompletionNotification({
       4000,
       'analysis-complete'
     );
-    clearAutoAdvanceTimeoutRef(autoAdvanceTimeoutRef); // Clear any previous pending timeout
-    autoAdvanceTimeoutRef.current = setTimeout(() => {
-      autoAdvanceTimeoutRef.current = null;
-      // Check if still in DISCOVER phase before auto-advancing
-      // This prevents unexpected navigation if user moved away during the delay
-      const currentPhase = getCurrentPhase?.();
-      if (currentPhase === (PHASES?.DISCOVER ?? 'discover')) {
-        actions.advancePhase(PHASES?.ORGANIZE ?? 'organize');
-      } else {
-        logger.debug('Skipping auto-advance: phase changed during delay', {
-          currentPhase,
-          expectedPhase: PHASES?.DISCOVER ?? 'discover'
-        });
-      }
-    }, 2000);
+    scheduleAutoAdvance({ actions, getCurrentPhase, autoAdvanceTimeoutRef, isMoreAnalysisPending });
   } else if (successCount > 0) {
     addNotification(
       `Analysis complete: ${successCount} successful, ${failureCount} failed`,
@@ -369,20 +389,7 @@ function showAnalysisCompletionNotification({
       4000,
       'analysis-complete'
     );
-    clearAutoAdvanceTimeoutRef(autoAdvanceTimeoutRef); // Clear any previous pending timeout
-    autoAdvanceTimeoutRef.current = setTimeout(() => {
-      autoAdvanceTimeoutRef.current = null;
-      // Check if still in DISCOVER phase before auto-advancing
-      const currentPhase = getCurrentPhase?.();
-      if (currentPhase === (PHASES?.DISCOVER ?? 'discover')) {
-        actions.advancePhase(PHASES?.ORGANIZE ?? 'organize');
-      } else {
-        logger.debug('Skipping auto-advance: phase changed during delay', {
-          currentPhase,
-          expectedPhase: PHASES?.DISCOVER ?? 'discover'
-        });
-      }
-    }, 2000);
+    scheduleAutoAdvance({ actions, getCurrentPhase, autoAdvanceTimeoutRef, isMoreAnalysisPending });
   } else if (failureCount > 0) {
     addNotification(
       `Analysis failed for all ${failureCount} files.`,
@@ -401,11 +408,12 @@ export {
   BATCH_ANALYSIS_LOW_VRAM_MIN_FILES
 };
 
-// Parked resume intent across Discover unmount/remount. Redux `isAnalyzing`
-// drives NavigationBar's isBlockedByOperation, so it MUST be cleared when
-// Discover unmounts mid-run (otherwise every tab — including the one back to
-// Discover — stays blocked with no way to recover). This module flag survives
-// the unmount so the resume effect still knows a run was interrupted.
+// Parked resume intent across an unmount/remount of the hook's owner. The
+// hook runs in AnalysisRunProvider (PhaseRenderer), so phase changes do not
+// unmount it; the phased view being replaced (dashboard) or torn down does.
+// Redux `isAnalyzing` must be cleared then, or the dashboard toggle and the
+// way back stay waiting on a run that no longer exists. This module flag
+// survives the unmount so the resume effect still knows a run was interrupted.
 let analysisInterruptedByUnmount = false;
 
 // Counts runs across every instance of the hook. Refs cannot: a Discover
@@ -1892,7 +1900,20 @@ export function useAnalysis(options = {}) {
         };
         dispatchProgressUpdate(finalProgress, { force: true });
 
-        const batchResults = batchResultsRef.current;
+        // Analysis now keeps running while the user organizes, so a file
+        // this run finished may already have been moved (its result re-keyed
+        // to the new path). Re-adding its old-path result would resurrect a
+        // file that is no longer there.
+        const filesState = /** @type {any} */ (store.getState())?.files;
+        const organizedKeys = new Set(
+          mergeOrganizedPathIndex(
+            filesState?.organizedPathIndex,
+            collectOrganizedPathKeys(filesState?.organizedFiles)
+          )
+        );
+        const batchResults = batchResultsRef.current.filter(
+          (/** @type {any} */ r) => !organizedKeys.has(toCanonicalPath(r?.path))
+        );
         // Merge results using extracted helper functions
         const mergedResults = dedupeSuggestedNames(
           mergeAnalysisResults(analysisResultsRef.current, batchResults)
@@ -1922,7 +1943,12 @@ export function useAnalysis(options = {}) {
           addNotification,
           actions,
           getCurrentPhase,
-          autoAdvanceTimeoutRef
+          autoAdvanceTimeoutRef,
+          // Read at fire time: by then a queued run has either started (store
+          // says analyzing) or is still waiting in pendingFilesRef.
+          isMoreAnalysisPending: () =>
+            pendingFilesRef.current.length > 0 ||
+            Boolean(/** @type {any} */ (store.getState())?.analysis?.isAnalyzing)
         });
       } catch (error) {
         if (error.message !== 'Analysis cancelled by user') {
diff --git a/src/renderer/utils/phaseNavigation.js b/src/renderer/utils/phaseNavigation.js
index a4cba19..dcea143 100644
--- a/src/renderer/utils/phaseNavigation.js
+++ b/src/renderer/utils/phaseNavigation.js
@@ -16,12 +16,7 @@ import {
   setViewMode,
   setCameFromDashboard
 } from '../store/slices/uiSlice';
-import {
-  selectFileStats,
-  selectIsAnalyzing,
-  selectOrganizedCount,
-  selectSmartFolders
-} from '../store/selectors';
+import { selectFileStats, selectOrganizedCount, selectSmartFolders } from '../store/selectors';
 import { useAppDispatch, useAppSelector } from '../store/hooks';
 import { hasDestinationFolder } from './smartFolderDestinations';
 
@@ -47,19 +42,18 @@ export const selectPhaseNavigationContext = createSelector(
 );
 
 /**
- * Work in flight that pauses every phase move: file moves, loading and
- * analysis (NavigationBar's isBlockedByOperation). Undo/redo is the other
- * half; it lives in UndoRedoProvider state, so callers inside that provider
- * add useUndoRedo().isExecuting.
+ * Work in flight that pauses every phase move: file moves and loading
+ * (NavigationBar's isBlockedByOperation). Undo/redo is the other half; it
+ * lives in UndoRedoProvider state, so callers inside that provider add
+ * useUndoRedo().isExecuting. A running analysis does not pause phase moves:
+ * the run lives in AnalysisRunProvider above the phases and keeps going.
+ * Leaving the phased view for the dashboard still waits for it
+ * (selectIsAnalyzing), since the dashboard replaces that provider.
  * @param {any} state
  * @returns {boolean}
  */
 export function selectIsNavigationPaused(state) {
-  return (
-    Boolean(state?.ui?.isOrganizing) ||
-    Boolean(state?.ui?.isLoading) ||
-    Boolean(selectIsAnalyzing(state))
-  );
+  return Boolean(state?.ui?.isOrganizing) || Boolean(state?.ui?.isLoading);
 }
 
 /**
diff --git a/test/components/AnalysisRunProvider.test.js b/test/components/AnalysisRunProvider.test.js
new file mode 100644
index 0000000..137eb89
--- /dev/null
+++ b/test/components/AnalysisRunProvider.test.js
@@ -0,0 +1,153 @@
+/**
+ * @jest-environment jsdom
+ *
+ * The analysis run lives in AnalysisRunProvider, above the phase screens.
+ * Moving from Discover to Organize must not unmount it: when the run lived
+ * in Discover, leaving Discover cancelled it, so a long run locked every
+ * phase tab and earlier analyzed files could not be organized meanwhile.
+ */
+import React from 'react';
+import { render, screen, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+const mockRunLifecycle = { mounts: 0, unmounts: 0 };
+let mockUseAnalysisOptions = null;
+const mockAnalyzeFiles = jest.fn();
+
+jest.mock('react-redux', () => ({
+  useStore: () => ({ getState: () => ({ analysis: { isAnalyzing: false } }) })
+}));
+
+jest.mock('../../src/renderer/contexts/NotificationContext', () => ({
+  useNotification: () => ({ addNotification: jest.fn() })
+}));
+
+jest.mock('../../src/renderer/phases/discover/useDiscoverState', () => {
+  const actions = { setPhaseData: jest.fn(), advancePhase: jest.fn() };
+  return {
+    useDiscoverState: () => ({
+      selectedFiles: [],
+      analysisResults: [],
+      isAnalyzing: false,
+      analysisProgress: { current: 0, total: 0 },
+      fileStates: {},
+      namingSettings: {},
+      setIsAnalyzing: jest.fn(),
+      setAnalysisProgress: jest.fn(),
+      setCurrentAnalysisFile: jest.fn(),
+      setAnalysisResults: jest.fn(),
+      setFileStates: jest.fn(),
+      updateFileState: jest.fn(),
+      resetAnalysisState: jest.fn(),
+      actions,
+      getCurrentPhase: () => 'discover'
+    })
+  };
+});
+
+jest.mock('../../src/renderer/phases/discover/useAnalysis', () => {
+  const React = require('react');
+  return {
+    useAnalysis: (options) => {
+      mockUseAnalysisOptions = options;
+      React.useEffect(() => {
+        mockRunLifecycle.mounts += 1;
+        return () => {
+          mockRunLifecycle.unmounts += 1;
+        };
+      }, []);
+      return {
+        analyzeFiles: mockAnalyzeFiles,
+        cancelAnalysis: jest.fn(),
+        clearAnalysisQueue: jest.fn(),
+        retryFailedFiles: jest.fn(),
+        pruneBatchResultsForPath: jest.fn()
+      };
+    }
+  };
+});
+
+import {
+  AnalysisRunProvider,
+  useAnalysisRun
+} from '../../src/renderer/phases/discover/AnalysisRunProvider';
+
+function DiscoverLike() {
+  const run = useAnalysisRun();
+  return (
+    <div>
+      Discover
+      {run.totalAnalysisFailure && <span>All failed</span>}
+    </div>
+  );
+}
+
+describe('AnalysisRunProvider', () => {
+  beforeEach(() => {
+    mockRunLifecycle.mounts = 0;
+    mockRunLifecycle.unmounts = 0;
+    mockUseAnalysisOptions = null;
+  });
+
+  test('the run survives leaving Discover for another phase', () => {
+    const { rerender } = render(
+      <AnalysisRunProvider>
+        <DiscoverLike />
+      </AnalysisRunProvider>
+    );
+    expect(mockRunLifecycle.mounts).toBe(1);
+
+    rerender(
+      <AnalysisRunProvider>
+        <div>Organize</div>
+      </AnalysisRunProvider>
+    );
+    rerender(
+      <AnalysisRunProvider>
+        <DiscoverLike />
+      </AnalysisRunProvider>
+    );
+
+    expect(screen.getByText('Discover')).toBeInTheDocument();
+    expect(mockRunLifecycle.mounts).toBe(1);
+    expect(mockRunLifecycle.unmounts).toBe(0);
+  });
+
+  test('Discover reads the run actions from the provider', () => {
+    let seen;
+    function Probe() {
+      seen = useAnalysisRun();
+      return null;
+    }
+    render(
+      <AnalysisRunProvider>
+        <Probe />
+      </AnalysisRunProvider>
+    );
+    expect(seen.analyzeFiles).toBe(mockAnalyzeFiles);
+  });
+
+  test('a total analysis failure reported by the run reaches Discover', () => {
+    render(
+      <AnalysisRunProvider>
+        <DiscoverLike />
+      </AnalysisRunProvider>
+    );
+    expect(screen.queryByText('All failed')).not.toBeInTheDocument();
+
+    act(() => {
+      mockUseAnalysisOptions.actions.setPhaseData('totalAnalysisFailure', true);
+    });
+
+    expect(screen.getByText('All failed')).toBeInTheDocument();
+  });
+
+  test('useAnalysisRun outside the provider fails loudly', () => {
+    const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      expect(() => render(<DiscoverLike />)).toThrow(/inside AnalysisRunProvider/);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});
diff --git a/test/components/DiscoverPhase.test.js b/test/components/DiscoverPhase.test.js
index 8113b2c..5b6bf2b 100644
--- a/test/components/DiscoverPhase.test.js
+++ b/test/components/DiscoverPhase.test.js
@@ -160,11 +160,15 @@ jest.mock('../../src/renderer/phases/discover', () => ({
     organizedFiles: [],
     organizedPathIndex: []
   })),
-  useAnalysis: jest.fn(() => ({
+  // The run lives in AnalysisRunProvider; Discover reads it via useAnalysisRun.
+  useAnalysisRun: jest.fn(() => ({
     analyzeFiles: mockAnalyzeFiles,
     cancelAnalysis: mockCancelAnalysis,
     clearAnalysisQueue: mockClearAnalysisQueue,
-    retryFailedFiles: mockRetryFailedFiles
+    retryFailedFiles: mockRetryFailedFiles,
+    pruneBatchResultsForPath: jest.fn(),
+    totalAnalysisFailure: false,
+    setTotalAnalysisFailure: jest.fn()
   })),
   useFileHandlers: jest.fn(() => ({
     isScanning: false,
@@ -259,6 +263,29 @@ describe('DiscoverPhase premium guidance', () => {
     }
   });
 
+  // The run lives above the phases now, so leaving Discover no longer stops
+  // it: analyzed files can be organized while the rest keep analyzing.
+  test('Continue to Organize stays open while more files analyze', () => {
+    const { useDiscoverState } = require('../../src/renderer/phases/discover');
+    const defaultImpl = useDiscoverState.getMockImplementation();
+    const advancePhase = jest.fn();
+    useDiscoverState.mockImplementation(() => ({
+      ...defaultImpl(),
+      isAnalyzing: true,
+      analysisProgress: { current: 1, total: 3, lastActivity: Date.now() },
+      actions: { setPhaseData: jest.fn(), advancePhase }
+    }));
+    try {
+      render(<DiscoverPhase />);
+      const footer = screen.getByRole('button', { name: /Continue to Organize/i });
+      expect(footer).toBeEnabled();
+      fireEvent.click(footer);
+      expect(advancePhase).toHaveBeenCalledWith('organize');
+    } finally {
+      useDiscoverState.mockImplementation(defaultImpl);
+    }
+  });
+
   test('the selection badge says "ready" once every file is analyzed', () => {
     render(<DiscoverPhase />);
     expect(screen.getByText('1 file ready')).toBeInTheDocument();
@@ -347,12 +374,11 @@ describe('DiscoverPhase premium guidance', () => {
   // failed there is nothing it can organize. Discover must offer recovery
   // instead of sending the user to an empty Organize screen.
   test('when every analysis failed, Discover offers recovery and does not advance to Organize', () => {
-    const { useDiscoverState, useAnalysis } = require('../../src/renderer/phases/discover');
+    const { useDiscoverState, useAnalysisRun } = require('../../src/renderer/phases/discover');
     const defaults = useDiscoverState();
     const originalDiscoverState = useDiscoverState.getMockImplementation();
-    const originalAnalysis = useAnalysis.getMockImplementation();
+    const originalAnalysisRun = useAnalysisRun.getMockImplementation();
     const advancePhase = jest.fn();
-    let analysisArgs;
     useDiscoverState.mockImplementation(() => ({
       ...defaults,
       analysisResults: [
@@ -369,16 +395,14 @@ describe('DiscoverPhase premium guidance', () => {
       readySelectedFilesCount: 0,
       actions: { setPhaseData: jest.fn(), advancePhase }
     }));
-    useAnalysis.mockImplementation((args) => {
-      analysisArgs = args;
-      return originalAnalysis(args);
-    });
+    // The run reports a total failure (AnalysisRunProvider owns the flag).
+    useAnalysisRun.mockImplementation(() => ({
+      ...originalAnalysisRun(),
+      totalAnalysisFailure: true
+    }));
 
     try {
       render(<DiscoverPhase />);
-      act(() => {
-        analysisArgs.actions.setPhaseData('totalAnalysisFailure', true);
-      });
 
       expect(screen.getByText('All file analyses failed')).toBeInTheDocument();
       expect(screen.queryByRole('button', { name: /Skip to Organize/i })).not.toBeInTheDocument();
@@ -397,7 +421,7 @@ describe('DiscoverPhase premium guidance', () => {
       expect(advancePhase).not.toHaveBeenCalledWith('organize');
     } finally {
       useDiscoverState.mockImplementation(originalDiscoverState);
-      useAnalysis.mockImplementation(originalAnalysis);
+      useAnalysisRun.mockImplementation(originalAnalysisRun);
     }
   });
   // A returning user with organized history may continue to Organize even
diff --git a/test/components/PhaseRenderer.test.js b/test/components/PhaseRenderer.test.js
index c7bf224..fb51c5b 100644
--- a/test/components/PhaseRenderer.test.js
+++ b/test/components/PhaseRenderer.test.js
@@ -53,6 +53,12 @@ jest.mock('../../src/renderer/components/ui/LoadingSkeleton', () => ({
   ModalLoadingOverlay: ({ message }) => <div>{message}</div>
 }));
 
+// The analysis run's provider wraps every phase; its own behavior is covered
+// by the AnalysisRunProvider tests.
+jest.mock('../../src/renderer/phases/discover/AnalysisRunProvider', () => ({
+  AnalysisRunProvider: ({ children }) => <div data-testid="analysis-run-provider">{children}</div>
+}));
+
 jest.mock('../../src/renderer/phases/WelcomePhase', () => ({
   __esModule: true,
   default: () => <div>WELCOME_PHASE</div>
diff --git a/test/components/dashboard/DashboardView.test.js b/test/components/dashboard/DashboardView.test.js
index 1b67248..be793e3 100644
--- a/test/components/dashboard/DashboardView.test.js
+++ b/test/components/dashboard/DashboardView.test.js
@@ -731,8 +731,24 @@ describe('DashboardView', () => {
   describe('navigation pause', () => {
     const PAUSED = 'Navigation is paused until the current operation finishes.';
 
+    // The analysis run lives in AnalysisRunProvider above the phases and
+    // keeps going across phase moves, so a running analysis does not pause
+    // the links (nor the tabs).
+    test('links still open a step while analysis runs, like the tabs', () => {
+      setupState({
+        currentPhase: 'discover',
+        fileStats: { total: 5, ready: 1, failed: 0, pending: 4 },
+        isAnalyzing: true,
+        analysisProgress: { current: 1, total: 5 }
+      });
+      render(<DashboardView />);
+
+      fireEvent.click(buttonFor('Review & organize'));
+      expect(phasePayloads()).toEqual(['organize']);
+      expect(mockNotification.showInfo).not.toHaveBeenCalledWith(PAUSED, 5200);
+    });
+
     test.each([
-      ['analysis', { isAnalyzing: true, analysisProgress: { current: 1, total: 5 } }],
       ['a file move', { isOrganizing: true }],
       ['loading', { isLoading: true }]
     ])('links pause while %s runs, like the tabs', (_label, busy) => {
diff --git a/test/renderer/phaseNavigation.test.js b/test/renderer/phaseNavigation.test.js
index aea79e3..8e02943 100644
--- a/test/renderer/phaseNavigation.test.js
+++ b/test/renderer/phaseNavigation.test.js
@@ -195,10 +195,11 @@ describe('navigation pause', () => {
     );
   });
 
-  test('selectIsNavigationPaused reads moves, loading and analysis in flight', () => {
+  test('selectIsNavigationPaused reads moves and loading; a running analysis does not pause', () => {
     expect(selectIsNavigationPaused({ ui: {}, analysis: {} })).toBe(false);
     expect(selectIsNavigationPaused({ ui: { isOrganizing: true }, analysis: {} })).toBe(true);
     expect(selectIsNavigationPaused({ ui: { isLoading: true }, analysis: {} })).toBe(true);
-    expect(selectIsNavigationPaused({ ui: {}, analysis: { isAnalyzing: true } })).toBe(true);
+    // The run lives in AnalysisRunProvider above the phases and keeps going.
+    expect(selectIsNavigationPaused({ ui: {}, analysis: { isAnalyzing: true } })).toBe(false);
   });
 });
diff --git a/test/renderer/usePhaseJump.test.js b/test/renderer/usePhaseJump.test.js
index b0246e5..6b3e272 100644
--- a/test/renderer/usePhaseJump.test.js
+++ b/test/renderer/usePhaseJump.test.js
@@ -112,8 +112,18 @@ describe('usePhaseJump', () => {
     expect(notify).toHaveBeenCalledWith(PHASE_PREREQUISITE_REASONS.needsAnalyzedFile, 5200);
   });
 
+  // The analysis run lives in AnalysisRunProvider above the phases, so it
+  // does not pause phase moves; the tabs follow the same rule.
+  test('a running analysis does not pause the jump', () => {
+    mockState = buildState({ phase: 'organize', isAnalyzing: true });
+    const { reached, notify } = jump('discover');
+
+    expect(reached).toBe(true);
+    expect(setPhaseDispatches()).toEqual(['discover']);
+    expect(notify).not.toHaveBeenCalled();
+  });
+
   test.each([
-    ['analysis', { isAnalyzing: true }],
     ['a file move', { isOrganizing: true }],
     ['loading', { isLoading: true }]
   ])('pauses while %s runs: no move, no view switch, and says why', (_label, busy) => {
diff --git a/test/useAnalysis.test.js b/test/useAnalysis.test.js
index 15bdcb4..ffb0614 100644
--- a/test/useAnalysis.test.js
+++ b/test/useAnalysis.test.js
@@ -193,6 +193,64 @@ describe('useAnalysis', () => {
     jest.useRealTimers();
   });
 
+  // A run that ends moves to Organize two seconds later. Files added during
+  // the run start as the next run right after it; the jump used to fire
+  // anyway, unmounting Discover and cancelling that run (logged as
+  // "Analysis interrupted by navigation" 1.5 s into a 70-file run).
+  describe('auto-advance after a run', () => {
+    const { useStore } = require('react-redux');
+    let storeState;
+
+    beforeEach(() => {
+      storeState = { analysis: { isAnalyzing: false } };
+      useStore.mockReturnValue({ getState: () => storeState });
+    });
+
+    afterEach(() => {
+      useStore.mockReset();
+      useStore.mockImplementation(() => ({
+        getState: jest.fn(() => ({ analysis: { isAnalyzing: false, progress: null } }))
+      }));
+    });
+
+    const finishOneFileRun = async (result) => {
+      await act(async () => {
+        const promise = result.current.analyzeFiles([{ path: '/test.txt', name: 'test.txt' }]);
+        await jest.advanceTimersByTimeAsync(500);
+        await promise;
+      });
+    };
+
+    test('moves to Organize when nothing else is running', async () => {
+      const { result } = renderHook(() =>
+        useAnalysis(createMockOptions({ getCurrentPhase: () => 'discover' }))
+      );
+      await finishOneFileRun(result);
+
+      await act(async () => {
+        await jest.advanceTimersByTimeAsync(2500);
+      });
+
+      expect(mockActions.advancePhase).toHaveBeenCalledWith('organize');
+    });
+
+    test('stays on Discover when the next run has started', async () => {
+      const { result } = renderHook(() =>
+        useAnalysis(createMockOptions({ getCurrentPhase: () => 'discover' }))
+      );
+      await finishOneFileRun(result);
+      expect(mockActions.advancePhase).not.toHaveBeenCalled();
+
+      // The queued files started as a new run before the jump fired.
+      storeState.analysis.isAnalyzing = true;
+      await act(async () => {
+        await jest.advanceTimersByTimeAsync(2500);
+      });
+
+      expect(mockActions.advancePhase).not.toHaveBeenCalled();
+    });
+  });
+
   describe('initialization', () => {
     test('returns analyzeFiles function', () => {
       const { result } = renderHook(() => useAnalysis(createMockOptions()));
diff --git a/test/useKeyboardShortcuts.phaseGating.test.js b/test/useKeyboardShortcuts.phaseGating.test.js
index be64fd7..49b96b4 100644
--- a/test/useKeyboardShortcuts.phaseGating.test.js
+++ b/test/useKeyboardShortcuts.phaseGating.test.js
@@ -201,7 +201,10 @@ describe('Alt+Arrow phase navigation follows the phase-tab rule', () => {
     expect(setPhaseDispatches()).toEqual(['complete']);
   });
 
-  test('Alt+Arrow is paused while analysis runs, like the phase tabs', () => {
+  // The analysis run lives above the phases (AnalysisRunProvider), so a
+  // running analysis no longer pauses phase moves: analyzed files can be
+  // organized while the rest keep analyzing.
+  test('Alt+Arrow still moves while analysis runs, like the phase tabs', () => {
     const state = buildState({
       phase: 'discover',
       selectedFiles: [{ path: '/docs/a.pdf', name: 'a.pdf' }],
@@ -212,10 +215,9 @@ describe('Alt+Arrow phase navigation follows the phase-tab rule', () => {
     renderHook(() => useKeyboardShortcuts());
 
     pressAlt('ArrowRight');
-    pressAlt('ArrowLeft');
 
-    expect(setPhaseDispatches()).toEqual([]);
-    expect(mockNotification.showInfo).toHaveBeenCalledWith(
+    expect(setPhaseDispatches()).toEqual(['organize']);
+    expect(mockNotification.showInfo).not.toHaveBeenCalledWith(
       'Navigation is paused until the current operation finishes.',
       5200
     );