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
     );