diff --git a/electron/main.js b/electron/main.js
index cad5cb1..1f1784a 100644
--- a/electron/main.js
+++ b/electron/main.js
@@ -14,6 +14,7 @@ const {
 let mainWindow = null;
 let pythonBackend = null;
 let backendStartupError = '';
+let backendStartupState = 'idle';
 
 const isDev = !app.isPackaged;
 const PROJECT_ROOT = path.join(__dirname, '..');
@@ -151,14 +152,20 @@ app.whenReady().then(async () => {
     userDataPath: app.getPath('userData'),
     projectRoot: PROJECT_ROOT,
   });
+  const rendererSmoke = process.env.SCRIPTCUT_RENDERER_SMOKE === '1';
+  const creatorQualificationSmoke = process.env.SCRIPTCUT_CREATOR_QUALIFICATION_SMOKE === '1';
+  if (!rendererSmoke && !creatorQualificationSmoke) createWindow();
+  backendStartupState = 'starting';
   try {
     await pythonBackend.start();
+    backendStartupState = 'ready';
   } catch (error) {
     backendStartupError = error instanceof Error ? error.message : String(error);
+    backendStartupState = 'error';
     console.error('[backend] Startup failed:', backendStartupError);
   }
 
-  if (process.env.SCRIPTCUT_RENDERER_SMOKE === '1') {
+  if (rendererSmoke) {
     try {
       if (!app.isPackaged) throw new Error('renderer transport smoke requires a packaged app');
       const { runRendererTransportSmoke } = require('./renderer-transport-smoke');
@@ -182,7 +189,7 @@ app.whenReady().then(async () => {
     return;
   }
 
-  if (process.env.SCRIPTCUT_CREATOR_QUALIFICATION_SMOKE === '1') {
+  if (creatorQualificationSmoke) {
     try {
       if (!app.isPackaged) throw new Error('creator qualification smoke requires a packaged app');
       const { runCreatorQualificationSmoke } = require('./creator-qualification-smoke');
@@ -211,7 +218,6 @@ app.whenReady().then(async () => {
     return;
   }
 
-  createWindow();
   app.on('activate', () => {
     if (BrowserWindow.getAllWindows().length === 0) createWindow();
   });
@@ -284,7 +290,10 @@ ipcMain.handle('file:getUrl', (event, filePath) => {
   assertTrustedSender(event);
   return createApprovedBackendFileUrl(filePath);
 });
-ipcMain.handle('app:getStartupStatus', (event) => { assertTrustedSender(event); return { backendError: backendStartupError }; });
+ipcMain.handle('app:getStartupStatus', (event) => {
+  assertTrustedSender(event);
+  return { backendError: backendStartupError, backendState: backendStartupState };
+});
 ipcMain.handle('app:getInfo', (event) => {
   assertTrustedSender(event);
   return { version: app.getVersion(), platform: process.platform, arch: process.arch, packaged: app.isPackaged, electron: process.versions.electron };
diff --git a/frontend/scripts/smoke-settings-export-ux.mjs b/frontend/scripts/smoke-settings-export-ux.mjs
index d49b23f..2d5d498 100644
--- a/frontend/scripts/smoke-settings-export-ux.mjs
+++ b/frontend/scripts/smoke-settings-export-ux.mjs
@@ -11,6 +11,8 @@ const readSource = (relativePath) => readFileSync(resolve(__dirname, relativePat
 
 const settingsSource = readSource('../src/components/SettingsPanel.tsx');
 const exportSource = readSource('../src/components/ExportDialog.tsx');
+const exportControllerSource = readSource('../src/features/export/useFullVideoExportController.ts');
+const appSource = readSource('../src/App.tsx');
 const releaseSource = readSource('../src/utils/releaseInfo.ts');
 const editorStoreSource = readSource('../src/store/editorStore.ts');
 const helperSource = readSource('../src/utils/settingsUx.ts');
@@ -65,17 +67,49 @@ for (const technicalControl of [
 ]) {
   assert.match(exportSource, new RegExp(technicalControl.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
 }
-for (const contract of [
-  'getExportPreflight',
-  'startExport',
-  '/jobs/export',
-  'pollExportJob',
-  '/retry',
-  '/cancel',
-  'getFriendlyExportError',
-]) {
+for (const contract of ['getExportPreflight', 'startExport', 'getFriendlyExportError', 'applyExportCompletion']) {
   assert.match(exportSource, new RegExp(contract.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
 }
+for (const contract of ['/jobs/export', 'pollExportJob', '/retry', '/cancel']) {
+  assert.match(exportControllerSource, new RegExp(contract.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+}
+assert.match(appSource, /const fullVideoExportController = useFullVideoExportController\(\{ backendUrl, workspaceRevision \}\)/);
+assert.match(appSource, /activePanel === 'export' && <ExportDialog controller=\{fullVideoExportController\} \/>/);
+assert.ok(
+  appSource.indexOf('useFullVideoExportController({ backendUrl, workspaceRevision })') < appSource.indexOf("activePanel === 'export'"),
+  'full-video export controller must remain mounted above the conditional ExportDialog panel',
+);
+assert.match(exportControllerSource, /const activeRunRef = useRef<FullVideoExportRun \| null>\(null\)/);
+assert.match(exportControllerSource, /Another full-video export is still running/);
+assert.match(exportControllerSource, /Connection interrupted; checking export status[\s\S]*setExporting\(true, activeProgressRef\.current\)[\s\S]*continue/);
+assert.match(exportControllerSource, /if \(!res\.ok\) \{[\s\S]*res\.status === 404[\s\S]*Export status unavailable; retrying[\s\S]*continue/);
+assert.match(exportControllerSource, /Export status was unreadable; retrying[\s\S]*setExporting\(true, activeProgressRef\.current\)[\s\S]*continue/);
+assert.match(exportControllerSource, /const mirroredIsExporting = useEditorStore\(\(state\) => state\.isExporting\)/);
+assert.match(exportControllerSource, /const mirroredExportProgress = useEditorStore\(\(state\) => state\.exportProgress\)/);
+assert.match(exportControllerSource, /if \(!mirroredIsExporting \|\| mirroredExportProgress !== activeProgressRef\.current\) \{\s*setExporting\(true, activeProgressRef\.current\);\s*\}/);
+assert.match(exportControllerSource, /workspaceRevision: number/);
+assert.match(exportControllerSource, /const currentWorkspaceRef = useRef\(\{ mediaPath: currentMediaPath, workspaceRevision \}\)/);
+assert.match(exportControllerSource, /context\.workspaceRevision === currentWorkspaceRef\.current\.workspaceRevision/);
+assert.match(exportControllerSource, /if \(!isCurrentWorkspace\(context\)\) return null;[\s\S]*const run = beginRun\(context\)/);
+const cancelTransportBody = exportControllerSource.match(/const cancelExportJob = useCallback\(async \(\) => \{([\s\S]*?)\n\s*\}, \[/)?.[1] || '';
+assert.match(cancelTransportBody, /job\.runId !== run\.id \|\| !isCurrentRun\(run\)/);
+assert.doesNotMatch(cancelTransportBody, /setExporting\(false/);
+const retryTransportBody = exportControllerSource.match(/const retryExportJob = useCallback\(async \(\) => \{([\s\S]*?)\n\s*\}, \[/)?.[1] || '';
+assert.match(retryTransportBody, /\['failed', 'canceled'\]\.includes\(sourceJob\.status\)/);
+assert.match(retryTransportBody, /!isCurrentWorkspace\(sourceJob\.context\)/);
+assert.match(retryTransportBody, /const run = beginRun\(sourceJob\.context\)/);
+assert.doesNotMatch(exportControllerSource, /getExportPreflight|localStorage|rememberExport|buildBackendFileUrl|setExportOptions/);
+assert.doesNotMatch(exportSource, /\/jobs\/export|\/jobs\/\$\{[^}]+\}\/cancel|\/jobs\/\$\{[^}]+\}\/retry/);
+assert.match(exportSource, /completion\.context\.preset/);
+assert.match(exportSource, /completion\.context\.format/);
+assert.match(exportSource, /!mountedRef\.current/);
+assert.match(exportSource, /useEditorStore\.getState\(\)\.videoPath !== completion\.context\.mediaPath/);
+assert.match(exportControllerSource, /setPendingCompletion\(\{ jobId, completion \}\)/);
+assert.match(exportSource, /pendingCompletion\.completion\.context\.mediaPath !== videoPath/);
+assert.match(exportSource, /pendingCompletion\.completion\.context\.workspaceRevision !== workspaceRevision/);
+assert.match(exportSource, /workspaceRevision,\s*preset: exportOptions\.preset/);
+assert.match(exportSource, /applyExportCompletion\(pendingCompletion\.completion\)/);
+assert.match(exportSource, /acknowledgeCompletion\(pendingCompletion\.jobId\)/);
 assert.match(editorStoreSource, /preset: 'source'/);
 assert.match(editorStoreSource, /mode: 'fast'/);
 assert.match(editorStoreSource, /aspectRatio: 'source'/);
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 4e48f49..5e0f8c2 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,12 +1,9 @@
-import { useCallback, useEffect, useState, useRef } from 'react';
+import { lazy, Suspense, useCallback, useEffect, useState, useRef } from 'react';
 import { useEditorStore } from './store/editorStore';
 import { useAIStore } from './store/aiStore';
 import VideoPlayer from './components/VideoPlayer';
 import TranscriptEditor from './components/TranscriptEditor';
 import WaveformTimeline from './components/WaveformTimeline';
-import AIPanel from './components/AIPanel';
-import ExportDialog from './components/ExportDialog';
-import SettingsPanel from './components/SettingsPanel';
 import EditorTaskHeader from './components/EditorTaskHeader';
 import HomeScreen, {
   type SystemChecksResponse,
@@ -21,6 +18,7 @@ import {
   type TranscriptionEngineStatus,
 } from './utils/transcriptionModels';
 import { useTranscriptionController } from './features/transcription/useTranscriptionController';
+import { useFullVideoExportController } from './features/export/useFullVideoExportController';
 import { saveProject, useKeyboardShortcuts } from './hooks/useKeyboardShortcuts';
 import {
   getAutosaveCandidatePaths,
@@ -62,6 +60,9 @@ import { resolveBackendFileUrl } from './utils/backendFile';
 
 const IS_ELECTRON = !!window.electronAPI;
 const ONBOARDING_DISMISSED_KEY = 'scriptcut.onboarding.dismissed.v1';
+const AIPanel = lazy(() => import('./components/AIPanel'));
+const ExportDialog = lazy(() => import('./components/ExportDialog'));
+const SettingsPanel = lazy(() => import('./components/SettingsPanel'));
 
 type Panel = EditorPanel;
 
@@ -98,12 +99,13 @@ export default function App() {
   const [systemChecks, setSystemChecks] = useState<SystemChecksResponse | null>(null);
   const [systemChecksError, setSystemChecksError] = useState('');
   const [backendStartupError, setBackendStartupError] = useState('');
+  const [backendReady, setBackendReady] = useState(!IS_ELECTRON);
   const [creatorNotice, setCreatorNotice] = useState<CreatorNoticeData | null>(null);
   const [autosaveRestoreRequest, setAutosaveRestoreRequest] = useState<{
     data: ReturnType<typeof parseProjectFile>;
     resolve: (restore: boolean) => void;
   } | null>(null);
-  const [isCheckingSystem, setIsCheckingSystem] = useState(false);
+  const [isCheckingSystem, setIsCheckingSystem] = useState(IS_ELECTRON);
   const [onboardingDismissed, setOnboardingDismissed] = useState(
     () => window.localStorage.getItem(ONBOARDING_DISMISSED_KEY) === 'true',
   );
@@ -130,22 +132,56 @@ export default function App() {
     transcriptionModel,
     onCompleted: handleTranscriptionCompleted,
   });
+  const fullVideoExportController = useFullVideoExportController({ backendUrl, workspaceRevision });
 
   useKeyboardShortcuts();
   const autosave = useProjectAutosave();
 
   useEffect(() => {
-    if (IS_ELECTRON) {
-      window.electronAPI!.getBackendUrl().then(setBackendUrl);
-      window.electronAPI!.getStartupStatus().then(({ backendError }) => {
-        if (!backendError) return;
-        setBackendStartupError(String(backendError));
+    if (!IS_ELECTRON) return;
+    let canceled = false;
+    let retryTimer: number | undefined;
+
+    window.electronAPI!.getBackendUrl().then((url) => {
+      if (!canceled) setBackendUrl(url);
+    });
+
+    const syncStartupStatus = async () => {
+      try {
+        const { backendError, backendState } = await window.electronAPI!.getStartupStatus();
+        if (canceled) return;
+        if (backendState === 'ready') {
+          setBackendStartupError('');
+          setBackendReady(true);
+          return;
+        }
+        if (backendState === 'error' || backendError) {
+          setBackendReady(false);
+          setBackendStartupError(String(backendError || 'Local editing service could not start.'));
+          setOnboardingDismissed(false);
+          return;
+        }
+        retryTimer = window.setTimeout(() => void syncStartupStatus(), 250);
+      } catch (error) {
+        if (canceled) return;
+        setBackendReady(false);
+        setBackendStartupError(error instanceof Error ? error.message : String(error));
         setOnboardingDismissed(false);
-      });
-    }
+      }
+    };
+
+    void syncStartupStatus();
+    return () => {
+      canceled = true;
+      if (retryTimer !== undefined) window.clearTimeout(retryTimer);
+    };
   }, [setBackendUrl]);
 
   useEffect(() => {
+    if (!backendReady) {
+      setTranscriptionEngineStatus(null);
+      return;
+    }
     let canceled = false;
     fetch(`${backendUrl}/transcription/engines`)
       .then((res) => (res.ok ? res.json() : null))
@@ -159,9 +195,15 @@ export default function App() {
     return () => {
       canceled = true;
     };
-  }, [backendUrl]);
+  }, [backendUrl, backendReady]);
 
   const refreshSystemChecks = useCallback(async () => {
+    if (IS_ELECTRON && !backendReady) {
+      setSystemChecks(null);
+      setSystemChecksError('');
+      setIsCheckingSystem(!backendStartupError);
+      return;
+    }
     setIsCheckingSystem(true);
     setSystemChecksError('');
     try {
@@ -174,7 +216,7 @@ export default function App() {
     } finally {
       setIsCheckingSystem(false);
     }
-  }, [backendUrl]);
+  }, [backendStartupError, backendUrl, backendReady]);
 
   useEffect(() => {
     void refreshSystemChecks();
@@ -775,9 +817,11 @@ export default function App() {
             aria-label={sidePanelLabel}
             className="w-80 border-l border-editor-border overflow-y-auto shrink-0"
           >
-            {activePanel === 'ai' && <AIPanel key={workspaceRevision} mode={editorWorkflow === 'short' ? 'clips' : 'general'} />}
-            {activePanel === 'export' && <ExportDialog />}
-            {activePanel === 'settings' && <SettingsPanel />}
+            <Suspense fallback={<PanelLoading label={sidePanelLabel} />}>
+              {activePanel === 'ai' && <AIPanel key={workspaceRevision} mode={editorWorkflow === 'short' ? 'clips' : 'general'} />}
+              {activePanel === 'export' && <ExportDialog controller={fullVideoExportController} />}
+              {activePanel === 'settings' && <SettingsPanel />}
+            </Suspense>
           </aside>
         )}
       </div>
@@ -787,6 +831,15 @@ export default function App() {
   );
 }
 
+function PanelLoading({ label }: { label: string }) {
+  return (
+    <div className="flex min-h-32 items-center justify-center gap-2 px-4 text-xs text-editor-text-muted" role="status">
+      <Loader2 className="h-4 w-4 animate-spin" aria-hidden="true" />
+      Loading {label.toLowerCase()}…
+    </div>
+  );
+}
+
 function AutosaveStatus({ autosave }: { autosave: ReturnType<typeof useProjectAutosave> }) {
   if (autosave.status === 'idle') return null;
   if (autosave.status === 'unavailable') {
diff --git a/frontend/src/components/ExportDialog.tsx b/frontend/src/components/ExportDialog.tsx
index af78c80..65df758 100644
--- a/frontend/src/components/ExportDialog.tsx
+++ b/frontend/src/components/ExportDialog.tsx
@@ -1,9 +1,13 @@
-import { useEffect, useState, useCallback } from 'react';
+import { useEffect, useRef, useState, useCallback } from 'react';
 import { useEditorStore } from '../store/editorStore';
 import { Download, Loader2, Zap, Cog, Info, Monitor, Smartphone, Square, X, Image, FolderOpen, ExternalLink, RotateCcw, AlertTriangle, CheckCircle2 } from 'lucide-react';
 import type { CaptionStyle, ExportOptions, ProjectExportOptions } from '../types/project';
 import CaptionPreview from './CaptionPreview';
 import { buildBackendFileUrl } from '../utils/backendFile';
+import type {
+  FullVideoExportCompletion,
+  FullVideoExportController,
+} from '../features/export/useFullVideoExportController';
 
 type ExportPreset = ExportOptions['preset'];
 type CaptionPreset = NonNullable<CaptionStyle['preset']>;
@@ -16,22 +20,6 @@ interface ExportResult {
   srtDownloadUrl?: string;
 }
 
-interface ExportJob {
-  id: string;
-  status: 'queued' | 'running' | 'canceling' | 'succeeded' | 'failed' | 'canceled';
-  progress: number;
-  message: string;
-  logs?: Array<{ time: string; message: string }>;
-  result?: {
-    output_path?: string;
-    srt_path?: string;
-    file_capability?: string;
-    srt_file_capability?: string;
-    warnings?: string[];
-  };
-  error?: string;
-}
-
 interface ExportHistoryItem {
   outputPath: string;
   srtPath?: string;
@@ -312,7 +300,7 @@ function getFriendlyExportError(message: string) {
   return message;
 }
 
-export default function ExportDialog() {
+export default function ExportDialog({ controller }: { controller: FullVideoExportController }) {
   const {
     videoPath,
     words,
@@ -321,7 +309,6 @@ export default function ExportDialog() {
     isExporting,
     exportProgress,
     backendUrl,
-    setExporting,
     getKeepSegments,
     getMutedRanges,
     getCaptionHiddenIndices,
@@ -329,14 +316,24 @@ export default function ExportDialog() {
     exportOptions: options,
     setExportOptions,
   } = useEditorStore();
+  const {
+    acknowledgeCompletion,
+    cancelExportJob,
+    canRetryExport,
+    exportFailure,
+    exportJobId,
+    exportJobStatus,
+    exportLogs,
+    exportMessage,
+    pendingCompletion,
+    retryExportJob,
+    startExportJob,
+    workspaceRevision,
+  } = controller;
 
   const hasCuts = deletedRanges.length > 0;
   const [exportError, setExportError] = useState('');
   const [exportResult, setExportResult] = useState<ExportResult | null>(null);
-  const [exportJobId, setExportJobId] = useState('');
-  const [exportMessage, setExportMessage] = useState('');
-  const [lastExportJobId, setLastExportJobId] = useState('');
-  const [exportLogs, setExportLogs] = useState<Array<{ time: string; message: string }>>([]);
   const [backgroundCapabilities, setBackgroundCapabilities] = useState<BackgroundCapabilities | null>(null);
   const [systemChecks, setSystemChecks] = useState<SystemChecksResponse | null>(null);
   const [showAdvancedExport, setShowAdvancedExport] = useState(false);
@@ -344,6 +341,8 @@ export default function ExportDialog() {
   const [exportDirectory, setExportDirectory] = useState(() => window.localStorage.getItem(EXPORT_DIRECTORY_KEY) || '');
   const [exportPath, setExportPath] = useState(() => window.localStorage.getItem(EXPORT_PATH_KEY) || '');
   const [exportHistory, setExportHistory] = useState<ExportHistoryItem[]>(loadExportHistory);
+  const mountedRef = useRef(true);
+  const visibleExportError = exportError || (exportFailure ? getFriendlyExportError(exportFailure) : '');
   const readiness = getExportReadiness(options, hasCuts, words.length, !!window.electronAPI, systemChecks);
   const preflight = getExportPreflight({
     videoPath,
@@ -358,6 +357,13 @@ export default function ExportDialog() {
     systemChecks,
   });
 
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+
   useEffect(() => {
     let canceled = false;
     fetch(`${backendUrl}/background/capabilities`)
@@ -529,51 +535,37 @@ export default function ExportDialog() {
     window.localStorage.removeItem(EXPORT_HISTORY_KEY);
   }, []);
 
-  const pollExportJob = useCallback(
-    async (jobId: string) => {
-      for (;;) {
-        await new Promise((resolve) => window.setTimeout(resolve, 700));
-        const res = await fetch(`${backendUrl}/jobs/${jobId}`);
-        if (!res.ok) throw new Error(`Could not read export job: ${res.statusText}`);
-
-        const job = (await res.json()) as ExportJob;
-        setExportMessage(job.message || job.status);
-        setExportLogs(job.logs || []);
-        setExporting(job.status === 'queued' || job.status === 'running' || job.status === 'canceling', job.progress);
-
-        if (job.status === 'succeeded') {
-          const outputPath = job.result?.output_path || '';
-          const srtPath = job.result?.srt_path;
-          setExportResult({
-            outputPath,
-            srtPath,
-            warnings: job.result?.warnings || [],
-            downloadUrl: buildBackendFileUrl(backendUrl, outputPath, job.result?.file_capability),
-            srtDownloadUrl: buildBackendFileUrl(backendUrl, srtPath, job.result?.srt_file_capability),
-          });
-          if (outputPath) {
-            rememberExport({
-              outputPath,
-              srtPath,
-              exportedAt: new Date().toISOString(),
-              preset: options.preset,
-              format: options.format,
-            });
-          }
-          setExportJobId('');
-          setLastExportJobId(jobId);
-          setExporting(false, 100);
-          return;
-        }
-
-        if (job.status === 'failed' || job.status === 'canceled') {
-          setLastExportJobId(jobId);
-          throw new Error(job.error || job.message || `Export ${job.status}`);
-        }
-      }
-    },
-    [backendUrl, options.format, options.preset, rememberExport, setExporting],
-  );
+  const applyExportCompletion = useCallback((completion: FullVideoExportCompletion) => {
+    if (!mountedRef.current) return;
+    if (useEditorStore.getState().videoPath !== completion.context.mediaPath) return;
+    if (completion.context.workspaceRevision !== workspaceRevision) return;
+    const outputPath = completion.result.output_path || '';
+    const srtPath = completion.result.srt_path;
+    setExportResult({
+      outputPath,
+      srtPath,
+      warnings: completion.result.warnings || [],
+      downloadUrl: buildBackendFileUrl(backendUrl, outputPath, completion.result.file_capability),
+      srtDownloadUrl: buildBackendFileUrl(backendUrl, srtPath, completion.result.srt_file_capability),
+    });
+    if (outputPath) {
+      rememberExport({
+        outputPath,
+        srtPath,
+        exportedAt: new Date().toISOString(),
+        preset: completion.context.preset,
+        format: completion.context.format,
+      });
+    }
+  }, [backendUrl, rememberExport, workspaceRevision]);
+
+  useEffect(() => {
+    if (!pendingCompletion) return;
+    if (pendingCompletion.completion.context.mediaPath !== videoPath) return;
+    if (pendingCompletion.completion.context.workspaceRevision !== workspaceRevision) return;
+    applyExportCompletion(pendingCompletion.completion);
+    acknowledgeCompletion(pendingCompletion.jobId);
+  }, [acknowledgeCompletion, applyExportCompletion, pendingCompletion, videoPath, workspaceRevision]);
 
   const startExport = useCallback(async (exportOptions: ProjectExportOptions) => {
     if (!videoPath) return;
@@ -611,6 +603,7 @@ export default function ExportDialog() {
           })
       : undefined;
     if (window.electronAPI && !outputPath) return;
+    if (useEditorStore.getState().videoPath !== videoPath) return;
     if (window.electronAPI && outputPath && !exportPath && !exportDirectory) {
       setExportPath(outputPath);
       window.localStorage.setItem(EXPORT_PATH_KEY, outputPath);
@@ -618,10 +611,6 @@ export default function ExportDialog() {
 
     setExportError('');
     setExportResult(null);
-    setExportLogs([]);
-    setLastExportJobId('');
-    setExporting(true, 1);
-    setExportMessage('Starting export');
 
     try {
       const keepSegments = getKeepSegments();
@@ -632,10 +621,14 @@ export default function ExportDialog() {
       }
       for (const idx of getCaptionHiddenIndices()) deletedSet.add(idx);
 
-      const res = await fetch(`${backendUrl}/jobs/export`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
+      await startExportJob({
+        context: {
+          mediaPath: videoPath,
+          workspaceRevision,
+          preset: exportOptions.preset,
+          format: exportOptions.format,
+        },
+        body: {
           ...exportOptions,
           input_path: videoPath,
           output_path: outputPath || undefined,
@@ -644,28 +637,14 @@ export default function ExportDialog() {
           words: exportOptions.captions !== 'none' ? words : undefined,
           deleted_indices: exportOptions.captions !== 'none' ? [...deletedSet] : undefined,
           captionStyle: exportOptions.captions === 'burn-in' ? exportOptions.captionStyle : undefined,
-        }),
+        },
       });
-      if (!res.ok) {
-        let detail = res.statusText;
-        try {
-          const data = await res.json();
-          detail = data.detail || JSON.stringify(data);
-        } catch {
-          // Keep the HTTP status text if the backend did not return JSON.
-        }
-        throw new Error(`Export start failed: ${detail}`);
-      }
-      const { job_id: jobId } = await res.json();
-      setExportJobId(jobId);
-      setLastExportJobId(jobId);
-      await pollExportJob(jobId);
     } catch (err) {
       console.error('Export error:', err);
+      if (!mountedRef.current || useEditorStore.getState().videoPath !== videoPath) return;
       setExportError(getFriendlyExportError(err instanceof Error ? err.message : String(err)));
-      setExporting(false, 0);
     }
-  }, [videoPath, duration, hasCuts, words, backgroundCapabilities, exportDirectory, exportPath, systemChecks, backendUrl, setExporting, getKeepSegments, getMutedRanges, getCaptionHiddenIndices, deletedRanges, pollExportJob]);
+  }, [videoPath, duration, hasCuts, words, backgroundCapabilities, exportDirectory, exportPath, systemChecks, getKeepSegments, getMutedRanges, getCaptionHiddenIndices, deletedRanges, startExportJob, workspaceRevision]);
 
   const handleExport = useCallback(() => {
     void startExport(options);
@@ -678,35 +657,26 @@ export default function ExportDialog() {
   }, [options, setExportOptions, startExport]);
 
   const cancelExport = useCallback(async () => {
-    if (!exportJobId) return;
-    await fetch(`${backendUrl}/jobs/${exportJobId}/cancel`, { method: 'POST' });
-    setExportJobId('');
-    setExportMessage('Cancel requested');
-  }, [backendUrl, exportJobId]);
+    try {
+      await cancelExportJob();
+    } catch (err) {
+      if (!mountedRef.current) return;
+      setExportError(getFriendlyExportError(err instanceof Error ? err.message : String(err)));
+    }
+  }, [cancelExportJob]);
 
   const retryExport = useCallback(async () => {
-    if (!lastExportJobId) return;
+    if (!canRetryExport) return;
     setExportError('');
     setExportResult(null);
-    setExporting(true, 1);
-    setExportMessage('Retrying export');
-    const res = await fetch(`${backendUrl}/jobs/${lastExportJobId}/retry`, { method: 'POST' });
-    if (!res.ok) {
-      setExporting(false, 0);
-      setExportError(`Retry failed: ${res.statusText}`);
-      return;
-    }
-    const { job_id: jobId } = await res.json();
-    setExportJobId(jobId);
-    setLastExportJobId(jobId);
     try {
-      await pollExportJob(jobId);
+      await retryExportJob();
     } catch (err) {
       console.error('Export retry error:', err);
+      if (!mountedRef.current) return;
       setExportError(getFriendlyExportError(err instanceof Error ? err.message : String(err)));
-      setExporting(false, 0);
     }
-  }, [backendUrl, lastExportJobId, pollExportJob, setExporting]);
+  }, [canRetryExport, retryExportJob]);
 
   return (
     <div className="p-4 space-y-5">
@@ -912,8 +882,9 @@ export default function ExportDialog() {
         {isExporting && exportJobId && (
           <button
             onClick={cancelExport}
+            disabled={exportJobStatus === 'canceling'}
             className="flex items-center justify-center px-3 py-3 bg-editor-border text-editor-text-muted hover:bg-editor-surface rounded-lg transition-colors"
-            title="Cancel export"
+            title={exportJobStatus === 'canceling' ? 'Cancel requested' : 'Cancel export'}
           >
             <X className="w-4 h-4" />
           </button>
@@ -1074,10 +1045,10 @@ export default function ExportDialog() {
         </div>
       )}
 
-      {exportError && (
+      {visibleExportError && (
         <div className="space-y-2 rounded bg-editor-danger/10 border border-editor-danger/30 p-2 text-[11px] text-editor-danger">
-          <div>{exportError}</div>
-          {lastExportJobId && (
+          <div>{visibleExportError}</div>
+          {canRetryExport && (
             <button
               onClick={retryExport}
               className="rounded bg-editor-danger/20 px-2 py-1 text-[10px] text-editor-danger hover:bg-editor-danger/30"
diff --git a/frontend/src/components/HomeScreen.tsx b/frontend/src/components/HomeScreen.tsx
index ee643c0..7452f0e 100644
--- a/frontend/src/components/HomeScreen.tsx
+++ b/frontend/src/components/HomeScreen.tsx
@@ -168,18 +168,21 @@ export default function HomeScreen({
               title="Edit a Video"
               detail="Edit spoken video by editing the transcript"
               onClick={() => void onOpenWorkflow('full-video')}
+              disabled={isCheckingSystem}
             />
             <StartWorkflowButton
               icon={<Smartphone className="h-4 w-4" aria-hidden="true" />}
               title="Create Clips"
               detail="Find, review and export social-ready moments"
               onClick={() => void onOpenWorkflow('short')}
+              disabled={isCheckingSystem}
             />
           </div>
           <button
             type="button"
             onClick={() => void onLoadProject()}
-            className="mx-auto flex items-center gap-2 rounded-lg px-4 py-2 text-sm text-editor-text-muted transition-colors hover:bg-editor-surface hover:text-editor-text"
+            disabled={isCheckingSystem}
+            className="mx-auto flex items-center gap-2 rounded-lg px-4 py-2 text-sm text-editor-text-muted transition-colors hover:bg-editor-surface hover:text-editor-text disabled:cursor-wait disabled:opacity-50"
           >
             <FileInput className="h-4 w-4" aria-hidden="true" />
             Open Project
diff --git a/frontend/src/features/export/useFullVideoExportController.ts b/frontend/src/features/export/useFullVideoExportController.ts
new file mode 100644
index 0000000..b1bd725
--- /dev/null
+++ b/frontend/src/features/export/useFullVideoExportController.ts
@@ -0,0 +1,344 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { useEditorStore } from '../../store/editorStore';
+import type { ExportOptions } from '../../types/project';
+
+export type FullVideoExportContext = {
+  mediaPath: string;
+  workspaceRevision: number;
+  preset: ExportOptions['preset'];
+  format: ExportOptions['format'];
+};
+
+type FullVideoExportRun = {
+  id: number;
+  context: FullVideoExportContext;
+};
+
+export type FullVideoExportJobResult = {
+  output_path?: string;
+  srt_path?: string;
+  file_capability?: string;
+  srt_file_capability?: string;
+  warnings?: string[];
+};
+
+export type FullVideoExportJob = {
+  id: string;
+  status: 'queued' | 'running' | 'canceling' | 'succeeded' | 'failed' | 'canceled';
+  progress: number;
+  message: string;
+  logs?: Array<{ time: string; message: string }>;
+  result?: FullVideoExportJobResult;
+  error?: string;
+  runId: number;
+  context: FullVideoExportContext;
+};
+
+export type FullVideoExportCompletion = {
+  context: FullVideoExportContext;
+  result: FullVideoExportJobResult;
+};
+
+type PendingFullVideoExportCompletion = {
+  jobId: string;
+  completion: FullVideoExportCompletion;
+};
+
+type StartFullVideoExportInput = {
+  body: unknown;
+  context: FullVideoExportContext;
+};
+
+type UseFullVideoExportControllerOptions = {
+  backendUrl: string;
+  workspaceRevision: number;
+};
+
+export function useFullVideoExportController({ backendUrl, workspaceRevision }: UseFullVideoExportControllerOptions) {
+  const currentMediaPath = useEditorStore((state) => state.videoPath);
+  const mirroredIsExporting = useEditorStore((state) => state.isExporting);
+  const mirroredExportProgress = useEditorStore((state) => state.exportProgress);
+  const setExporting = useEditorStore((state) => state.setExporting);
+  const [trackedJob, setTrackedJob] = useState<FullVideoExportJob | null>(null);
+  const [exportMessage, setExportMessage] = useState('');
+  const [exportLogs, setExportLogs] = useState<Array<{ time: string; message: string }>>([]);
+  const [failure, setFailure] = useState<{ message: string; context: FullVideoExportContext } | null>(null);
+  const [pendingCompletion, setPendingCompletion] = useState<PendingFullVideoExportCompletion | null>(null);
+  const runEpochRef = useRef(0);
+  const activeRunRef = useRef<FullVideoExportRun | null>(null);
+  const activeProgressRef = useRef(0);
+  const mountedRef = useRef(true);
+  const currentWorkspaceRef = useRef({ mediaPath: currentMediaPath, workspaceRevision });
+  currentWorkspaceRef.current = { mediaPath: currentMediaPath, workspaceRevision };
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      activeRunRef.current = null;
+    };
+  }, []);
+
+  const isCurrentRun = useCallback((run: FullVideoExportRun) => (
+    mountedRef.current && activeRunRef.current?.id === run.id
+  ), []);
+
+  const isCurrentWorkspace = useCallback((context: FullVideoExportContext) => (
+    context.mediaPath === currentWorkspaceRef.current.mediaPath
+    && context.workspaceRevision === currentWorkspaceRef.current.workspaceRevision
+  ), []);
+
+  const beginRun = useCallback((context: FullVideoExportContext) => {
+    if (activeRunRef.current) {
+      throw new Error('Another full-video export is still running. Wait for it to finish or cancel it first.');
+    }
+    const run = { id: runEpochRef.current + 1, context };
+    runEpochRef.current = run.id;
+    activeRunRef.current = run;
+    activeProgressRef.current = 1;
+    return run;
+  }, []);
+
+  const finishRun = useCallback((run: FullVideoExportRun, succeeded: boolean) => {
+    if (!isCurrentRun(run)) return;
+    activeRunRef.current = null;
+    setExporting(false, succeeded ? 100 : 0);
+    if (!isCurrentWorkspace(run.context)) {
+      setTrackedJob(null);
+      setExportMessage('');
+      setExportLogs([]);
+      setFailure(null);
+      setPendingCompletion(null);
+    }
+  }, [isCurrentRun, isCurrentWorkspace, setExporting]);
+
+  useLayoutEffect(() => {
+    const run = activeRunRef.current;
+    if (!run) {
+      if (trackedJob && !isCurrentWorkspace(trackedJob.context)) {
+        setTrackedJob(null);
+        setExportMessage('');
+        setExportLogs([]);
+      }
+      if (failure && !isCurrentWorkspace(failure.context)) setFailure(null);
+      if (pendingCompletion && !isCurrentWorkspace(pendingCompletion.completion.context)) {
+        setPendingCompletion(null);
+      }
+      return;
+    }
+    if (!mirroredIsExporting || mirroredExportProgress !== activeProgressRef.current) {
+      setExporting(true, activeProgressRef.current);
+    }
+  }, [
+    currentMediaPath,
+    failure,
+    isCurrentWorkspace,
+    mirroredExportProgress,
+    mirroredIsExporting,
+    pendingCompletion,
+    setExporting,
+    trackedJob,
+    workspaceRevision,
+  ]);
+
+  const pollExportJob = useCallback(async (jobId: string, run: FullVideoExportRun) => {
+    for (;;) {
+      await new Promise((resolve) => window.setTimeout(resolve, 700));
+      if (!isCurrentRun(run)) return null;
+
+      let res: Response;
+      try {
+        res = await fetch(`${backendUrl}/jobs/${jobId}`);
+      } catch {
+        if (!isCurrentRun(run)) return null;
+        setExportMessage('Connection interrupted; checking export status...');
+        setExporting(true, activeProgressRef.current);
+        continue;
+      }
+
+      if (!isCurrentRun(run)) return null;
+      if (!res.ok) {
+        if (res.status === 404) throw new Error('Export job is no longer available');
+        setExportMessage('Export status unavailable; retrying...');
+        setExporting(true, activeProgressRef.current);
+        continue;
+      }
+
+      let job: Omit<FullVideoExportJob, 'runId' | 'context'>;
+      try {
+        job = await res.json() as Omit<FullVideoExportJob, 'runId' | 'context'>;
+      } catch {
+        if (!isCurrentRun(run)) return null;
+        setExportMessage('Export status was unreadable; retrying...');
+        setExporting(true, activeProgressRef.current);
+        continue;
+      }
+
+      if (!isCurrentRun(run)) return null;
+      activeProgressRef.current = job.progress;
+      const tracked = { ...job, runId: run.id, context: run.context };
+      setTrackedJob(tracked);
+      setExportMessage(job.message || job.status);
+      setExportLogs(job.logs || []);
+      setExporting(
+        job.status === 'queued' || job.status === 'running' || job.status === 'canceling',
+        job.progress,
+      );
+
+      if (job.status === 'succeeded') {
+        return { context: run.context, result: job.result || {} } satisfies FullVideoExportCompletion;
+      }
+      if (job.status === 'failed' || job.status === 'canceled') {
+        throw new Error(job.error || job.message || `Export ${job.status}`);
+      }
+    }
+  }, [backendUrl, isCurrentRun, setExporting]);
+
+  const startExportJob = useCallback(async ({ body, context }: StartFullVideoExportInput) => {
+    if (!isCurrentWorkspace(context)) return null;
+    const run = beginRun(context);
+    let succeeded = false;
+    setTrackedJob(null);
+    setExportMessage('Starting export');
+    setExportLogs([]);
+    setFailure(null);
+    setExporting(true, 1);
+
+    try {
+      const res = await fetch(`${backendUrl}/jobs/export`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      if (!isCurrentRun(run)) return null;
+      if (!res.ok) {
+        let detail = res.statusText;
+        try {
+          const data = await res.json() as { detail?: unknown };
+          if (typeof data.detail === 'string') detail = data.detail;
+          else if (data.detail !== undefined) detail = JSON.stringify(data.detail);
+        } catch {
+          // Keep the HTTP status text if the backend did not return JSON.
+        }
+        throw new Error(`Export start failed: ${detail}`);
+      }
+      const { job_id: jobId } = await res.json() as { job_id: string };
+      if (!isCurrentRun(run)) return null;
+      setTrackedJob({
+        id: jobId,
+        status: 'queued',
+        progress: 0,
+        message: 'Queued',
+        logs: [],
+        runId: run.id,
+        context: run.context,
+      });
+      const completion = await pollExportJob(jobId, run);
+      if (!completion || !isCurrentRun(run)) return null;
+      succeeded = true;
+      setFailure(null);
+      if (isCurrentWorkspace(run.context)) setPendingCompletion({ jobId, completion });
+      return completion;
+    } catch (err) {
+      if (isCurrentRun(run)) {
+        setFailure({ message: err instanceof Error ? err.message : String(err), context: run.context });
+      }
+      throw err;
+    } finally {
+      finishRun(run, succeeded);
+    }
+  }, [backendUrl, beginRun, finishRun, isCurrentRun, isCurrentWorkspace, pollExportJob, setExporting]);
+
+  const cancelExportJob = useCallback(async () => {
+    const run = activeRunRef.current;
+    const job = trackedJob;
+    if (!run || !job || !['queued', 'running'].includes(job.status)) return;
+    if (job.runId !== run.id || !isCurrentRun(run)) return;
+
+    const res = await fetch(`${backendUrl}/jobs/${job.id}/cancel`, { method: 'POST' });
+    if (!isCurrentRun(run)) return;
+    if (!res.ok) {
+      const error = new Error(`Cancel failed: ${res.statusText}`);
+      setFailure({ message: error.message, context: run.context });
+      throw error;
+    }
+    const canceledJob = await res.json() as Omit<FullVideoExportJob, 'runId' | 'context'>;
+    if (!isCurrentRun(run)) return;
+    setTrackedJob({ ...canceledJob, runId: run.id, context: run.context });
+    setExportMessage(canceledJob.message || 'Cancel requested');
+    setExportLogs(canceledJob.logs || []);
+  }, [backendUrl, isCurrentRun, trackedJob]);
+
+  const retryExportJob = useCallback(async () => {
+    const sourceJob = trackedJob;
+    if (!sourceJob || !['failed', 'canceled'].includes(sourceJob.status)) return null;
+    if (!isCurrentWorkspace(sourceJob.context)) return null;
+
+    const run = beginRun(sourceJob.context);
+    let succeeded = false;
+    setExportMessage('Retrying export');
+    setExportLogs([]);
+    setFailure(null);
+    setExporting(true, 1);
+
+    try {
+      const res = await fetch(`${backendUrl}/jobs/${sourceJob.id}/retry`, { method: 'POST' });
+      if (!isCurrentRun(run)) return null;
+      if (!res.ok) throw new Error(`Retry failed: ${res.statusText}`);
+      const { job_id: jobId } = await res.json() as { job_id: string };
+      if (!isCurrentRun(run)) return null;
+      setTrackedJob({
+        id: jobId,
+        status: 'queued',
+        progress: 0,
+        message: 'Queued',
+        logs: [],
+        runId: run.id,
+        context: run.context,
+      });
+      const completion = await pollExportJob(jobId, run);
+      if (!completion || !isCurrentRun(run)) return null;
+      succeeded = true;
+      setFailure(null);
+      if (isCurrentWorkspace(run.context)) setPendingCompletion({ jobId, completion });
+      return completion;
+    } catch (err) {
+      if (isCurrentRun(run)) {
+        setFailure({ message: err instanceof Error ? err.message : String(err), context: run.context });
+      }
+      throw err;
+    } finally {
+      finishRun(run, succeeded);
+    }
+  }, [backendUrl, beginRun, finishRun, isCurrentRun, isCurrentWorkspace, pollExportJob, setExporting, trackedJob]);
+
+  const exportJobId = trackedJob?.id || '';
+  const exportJobStatus = trackedJob?.status || null;
+  const canRetryExport = !!trackedJob && ['failed', 'canceled'].includes(trackedJob.status)
+    && isCurrentWorkspace(trackedJob.context);
+  const exportFailure = failure && isCurrentWorkspace(failure.context) ? failure.message : '';
+  const visiblePendingCompletion = pendingCompletion
+    && isCurrentWorkspace(pendingCompletion.completion.context)
+    ? pendingCompletion
+    : null;
+  const acknowledgeCompletion = useCallback((jobId: string) => {
+    setPendingCompletion((current) => current?.jobId === jobId ? null : current);
+  }, []);
+
+  return {
+    acknowledgeCompletion,
+    cancelExportJob,
+    canRetryExport,
+    exportFailure,
+    exportJobId,
+    exportJobStatus,
+    exportLogs,
+    exportMessage,
+    pendingCompletion: visiblePendingCompletion,
+    retryExportJob,
+    startExportJob,
+    workspaceRevision,
+  };
+}
+
+export type FullVideoExportController = ReturnType<typeof useFullVideoExportController>;
diff --git a/frontend/src/vite-env.d.ts b/frontend/src/vite-env.d.ts
index 00542bb..8d68425 100644
--- a/frontend/src/vite-env.d.ts
+++ b/frontend/src/vite-env.d.ts
@@ -9,7 +9,10 @@ interface ElectronAPI {
   openProject: () => Promise<string | null>;
   getBackendUrl: () => Promise<string>;
   getBackendFileUrl: (path: string) => Promise<string>;
-  getStartupStatus: () => Promise<{ backendError: string }>;
+  getStartupStatus: () => Promise<{
+    backendError: string;
+    backendState: 'idle' | 'starting' | 'ready' | 'error';
+  }>;
   getAppInfo: () => Promise<{
     version: string;
     platform: string;
diff --git a/package-lock.json b/package-lock.json
index 0238c71..38f6261 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -7,9 +7,6 @@
     "": {
       "name": "scriptcut",
       "version": "0.1.0",
-      "dependencies": {
-        "python-shell": "^5.0.0"
-      },
       "devDependencies": {
         "concurrently": "^9.1.0",
         "electron": "^43.1.0",
@@ -3093,15 +3090,6 @@
         "node": ">=16.0.0"
       }
     },
-    "node_modules/python-shell": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/python-shell/-/python-shell-5.0.0.tgz",
-      "integrity": "sha512-RUOOOjHLhgR1MIQrCtnEqz/HJ1RMZBIN+REnpSUrfft2bXqXy69fwJASVziWExfFXsR1bCY0TznnHooNsCo0/w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
     "node_modules/quick-lru": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
diff --git a/package.json b/package.json
index 2f7edb6..a875f76 100644
--- a/package.json
+++ b/package.json
@@ -67,13 +67,12 @@
     "smoke:renderer-policy": "node scripts/smoke-packaged-renderer-policy.js"
   },
   "devDependencies": {"concurrently": "^9.1.0", "electron": "^43.1.0", "electron-builder": "^26.15.3", "wait-on": "^8.0.0"},
-  "dependencies": {"python-shell": "^5.0.0"},
   "build": {
     "appId": "com.fernandoabishai.scriptcut",
     "productName": "ScriptCut",
     "files": ["electron/**/*", "frontend/dist/**/*", "shared/**/*"],
     "extraResources": [
-      {"from": "backend", "to": "backend"},
+      {"from": "backend", "to": "backend", "filter": ["**/*", "!scripts/**", "!**/__pycache__/**", "!**/*.pyc", "!**/*.pyo"]},
       {"from": "build/bin", "to": "bin", "filter": ["**/*"]},
       {"from": "runtime/models/whisper-base.json", "to": "manifests/model-manifest.json"}
     ],
diff --git a/runtime/core-darwin-arm64-py311.constraints.txt b/runtime/core-darwin-arm64-py311.constraints.txt
new file mode 100644
index 0000000..24585c9
--- /dev/null
+++ b/runtime/core-darwin-arm64-py311.constraints.txt
@@ -0,0 +1,38 @@
+# Resolved on native macOS arm64 with the bundled Python 3.11.15 runtime.
+# This freezes the full runtime version graph. Artifact hashes remain a separate
+# release-hardening step because openai-whisper is built from a source archive.
+annotated-doc==0.0.5
+annotated-types==0.8.0
+anyio==4.15.1
+certifi==2026.7.22
+charset-normalizer==3.5.2
+click==8.5.0
+fastapi==0.138.1
+filelock==4.1.1
+fsspec==2026.9.0
+h11==0.16.0
+idna==3.20
+jinja2==3.1.6
+llvmlite==0.50.0
+markupsafe==3.0.4
+more-itertools==11.2.0
+mpmath==1.3.0
+networkx==3.6.1
+numba==0.68.0
+numpy==1.26.4
+openai-whisper==20250625
+pydantic==2.13.4
+pydantic-core==2.46.4
+python-multipart==0.0.32
+regex==2026.9.29
+requests==2.34.2
+setuptools==81.0.0
+starlette==1.8.0
+sympy==1.14.0
+tiktoken==0.14.0
+torch==2.12.1
+tqdm==4.70.1
+typing-extensions==4.16.0
+typing-inspection==0.4.4
+urllib3==2.8.0
+uvicorn==0.49.0
diff --git a/runtime/core-darwin-arm64-py311.txt b/runtime/core-darwin-arm64-py311.txt
index 982c270..0f5c49c 100644
--- a/runtime/core-darwin-arm64-py311.txt
+++ b/runtime/core-darwin-arm64-py311.txt
@@ -1,6 +1,7 @@
 # Direct, startup-proven core dependencies for the current backend.
 # Python: 3.11.15 | target: darwin-arm64 | runtime: python-build-standalone 20260807
-# This is an exact-version input, not a hash-locked release inventory yet.
+# Direct runtime requirements. The companion constraints file freezes the full
+# resolved version graph; artifact hashes are still a separate release step.
 fastapi==0.138.1
 uvicorn==0.49.0
 pydantic==2.13.4
diff --git a/scripts/check-packaged-runtime.js b/scripts/check-packaged-runtime.js
index bf258ec..5c19927 100644
--- a/scripts/check-packaged-runtime.js
+++ b/scripts/check-packaged-runtime.js
@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
@@ -37,6 +38,10 @@ function fail(message) {
   throw new Error(`Packaged runtime check failed: ${message}`);
 }
 
+function sha256(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
 function findAppBundles(directory) {
   if (!fs.existsSync(directory)) return [];
   const bundles = [];
@@ -148,6 +153,18 @@ function inspectPackage(appPath) {
     fail(`runtime manifest is not valid JSON: ${error.message}`);
   }
   const normalized = validateRuntimeManifest(manifest, { expectedTarget: 'darwin-arm64' });
+  const constraints = manifest.packs?.constraints;
+  if (!constraints || typeof constraints.source !== 'string' || !/^[a-f0-9]{64}$/.test(constraints.sha256 || '')) {
+    fail('runtime manifest is missing valid core dependency constraints provenance');
+  }
+  if (path.isAbsolute(constraints.source)) fail('runtime constraints source must be repository-relative');
+  const constraintsPath = path.resolve(root, constraints.source);
+  const relativeConstraintsPath = path.relative(root, constraintsPath);
+  if (!relativeConstraintsPath || relativeConstraintsPath.startsWith('..') || path.isAbsolute(relativeConstraintsPath)) {
+    fail('runtime constraints source escapes the repository root');
+  }
+  if (!fs.existsSync(constraintsPath)) fail(`runtime constraints source is missing: ${constraints.source}`);
+  if (sha256(constraintsPath) !== constraints.sha256) fail('runtime constraints SHA-256 does not match the committed source');
   let modelManifest;
   try {
     modelManifest = readModelManifest(modelManifestPath);
@@ -214,6 +231,7 @@ function inspectPackage(appPath) {
   console.log(`Backend: ${backendSize} bytes`);
   console.log(`FFmpeg/bin: ${binSize} bytes`);
   console.log(`Manifest: ${normalized.schema}, ${normalized.target.id}, Python ${normalized.python.version}`);
+  console.log(`Core constraints: ${constraints.source}, SHA-256 ${constraints.sha256}`);
   console.log(`Model manifest: ${modelManifest.id}, ${modelManifest.revision}, ${modelManifest.expectedBytes} bytes`);
   console.log('Core imports: fastapi, uvicorn, pydantic, requests, torch, whisper==20250625');
   console.log('Optional packages bundled: No');
diff --git a/scripts/measure-bundle-size.js b/scripts/measure-bundle-size.js
index 762105a..ba33327 100644
--- a/scripts/measure-bundle-size.js
+++ b/scripts/measure-bundle-size.js
@@ -219,18 +219,11 @@ function distributionMetadata(distInfoPath) {
   };
 }
 
-function findDistInfos(directory, found = []) {
-  for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
-    const entryPath = path.join(directory, entry.name);
-    if (entry.isSymbolicLink()) continue;
-    if (!entry.isDirectory()) continue;
-    if (entry.name.endsWith('.dist-info')) {
-      found.push(entryPath);
-      continue;
-    }
-    findDistInfos(entryPath, found);
-  }
-  return found;
+function findDistInfos(directory) {
+  return fs.readdirSync(directory, { withFileTypes: true })
+    .filter((entry) => !entry.isSymbolicLink() && entry.isDirectory() && entry.name.endsWith('.dist-info'))
+    .sort((left, right) => left.name.localeCompare(right.name))
+    .map((entry) => path.join(directory, entry.name));
 }
 
 function distributionAttribution(coreRoot, coreFiles) {
diff --git a/scripts/prepare-python-runtime.js b/scripts/prepare-python-runtime.js
index 43db44a..9e17af1 100644
--- a/scripts/prepare-python-runtime.js
+++ b/scripts/prepare-python-runtime.js
@@ -24,6 +24,9 @@ const manifestPath = path.join(buildRoot, 'manifests', 'runtime-manifest.json');
 const modelInputPath = path.join(root, 'runtime', 'models', 'whisper-base.json');
 const generatedModelManifestPath = path.join(buildRoot, 'manifests', 'model-manifest.json');
 const coreInputPath = path.join(root, 'runtime', 'core-darwin-arm64-py311.txt');
+const coreConstraintsPath = path.join(root, 'runtime', 'core-darwin-arm64-py311.constraints.txt');
+// Torch imports torch.testing through its normal autograd import path.
+const RUNTIME_REQUIRED_TEST_DIRECTORIES = new Set(['torch/testing']);
 
 function getOption(name) {
   const index = process.argv.indexOf(name);
@@ -184,6 +187,7 @@ function isolatedEnvironment(extra = {}) {
   delete environment.SCRIPTCUT_PYTHON_PATH;
   delete environment.CUTSCRIPT_PYTHON_PATH;
   environment.PYTHONNOUSERSITE = '1';
+  environment.PYTHONDONTWRITEBYTECODE = '1';
   return environment;
 }
 
@@ -206,6 +210,7 @@ function pythonVersion(interpreterPath, environment) {
 
 function installCorePack(interpreterPath) {
   if (!fs.existsSync(coreInputPath)) fail(`missing committed core input: ${path.relative(root, coreInputPath)}`);
+  if (!fs.existsSync(coreConstraintsPath)) fail(`missing committed core constraints: ${path.relative(root, coreConstraintsPath)}`);
   fs.rmSync(corePackRoot, { recursive: true, force: true });
   fs.mkdirSync(corePackRoot, { recursive: true });
   const environment = isolatedEnvironment({
@@ -216,7 +221,9 @@ function installCorePack(interpreterPath) {
   run(interpreterPath, [
     '-m', 'pip', 'install',
     '--disable-pip-version-check',
+    '--no-compile',
     '--target', corePackRoot,
+    '--constraint', coreConstraintsPath,
     '--requirement', coreInputPath,
   ], { env: environment, inherit: true });
 }
@@ -272,7 +279,13 @@ function writeManifest(relativeInterpreter, version) {
       archiveSha256: PYTHON_RUNTIME_ARTIFACT.sha256,
     },
     backend: { root: 'backend' },
-    packs: { core: path.posix.join('runtime', 'packs', 'core', PYTHON_RUNTIME_ARTIFACT.target) },
+    packs: {
+      core: path.posix.join('runtime', 'packs', 'core', PYTHON_RUNTIME_ARTIFACT.target),
+      constraints: {
+        source: path.relative(root, coreConstraintsPath).split(path.sep).join('/'),
+        sha256: sha256(coreConstraintsPath),
+      },
+    },
     security: { tokenRequired: true },
   };
   fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
@@ -318,6 +331,60 @@ function pruneNonRuntimeCoreArtifacts() {
   return removed;
 }
 
+function prunePythonBytecode(directory) {
+  const removed = { files: 0, bytes: 0 };
+  if (!fs.existsSync(directory)) return removed;
+
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory() && entry.name === '__pycache__') {
+      const stats = directoryStats(entryPath);
+      fs.rmSync(entryPath, { recursive: true, force: false });
+      removed.files += stats.files;
+      removed.bytes += stats.bytes;
+      continue;
+    }
+    if (entry.isDirectory()) {
+      const child = prunePythonBytecode(entryPath);
+      removed.files += child.files;
+      removed.bytes += child.bytes;
+      continue;
+    }
+    if (entry.isFile() && /\.(pyc|pyo)$/i.test(entry.name)) {
+      const stat = fs.statSync(entryPath);
+      fs.rmSync(entryPath, { force: false });
+      removed.files += 1;
+      removed.bytes += stat.size;
+    }
+  }
+  return removed;
+}
+
+function prunePackageTestArtifacts(directory) {
+  const removed = { directories: 0, files: 0, bytes: 0 };
+  if (!fs.existsSync(directory)) return removed;
+
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const entryPath = path.join(directory, entry.name);
+    const relativeToCore = path.relative(corePackRoot, entryPath).split(path.sep).join('/');
+    if (RUNTIME_REQUIRED_TEST_DIRECTORIES.has(relativeToCore)) continue;
+    if (entry.name === 'test' || entry.name === 'tests' || entry.name === 'testing') {
+      const stats = directoryStats(entryPath);
+      fs.rmSync(entryPath, { recursive: true, force: false });
+      removed.directories += 1;
+      removed.files += stats.files;
+      removed.bytes += stats.bytes;
+      continue;
+    }
+    const child = prunePackageTestArtifacts(entryPath);
+    removed.directories += child.directories;
+    removed.files += child.files;
+    removed.bytes += child.bytes;
+  }
+  return removed;
+}
+
 async function main() {
   verifyTarget();
   fs.mkdirSync(buildRoot, { recursive: true });
@@ -331,16 +398,24 @@ async function main() {
   console.log(`Core pack files before pruning: ${coreBefore.files}`);
   console.log(`Core pack bytes before pruning: ${coreBefore.bytes}`);
   const headersRemoved = pruneNonRuntimeCoreArtifacts();
+  const testsRemoved = prunePackageTestArtifacts(corePackRoot);
   const coreAfter = directoryStats(corePackRoot);
   console.log(`Torch headers removed: ${headersRemoved.files}`);
+  console.log(`Package test artifacts removed: ${testsRemoved.directories} directories, ${testsRemoved.files} files, ${testsRemoved.bytes} bytes`);
   console.log(`Core pack files after pruning: ${coreAfter.files}`);
   console.log(`Core pack bytes after pruning: ${coreAfter.bytes}`);
   verifyCore(interpreterPath, relativeInterpreter);
+  const portableBytecodeRemoved = prunePythonBytecode(runtimeRoot);
+  const coreBytecodeRemoved = prunePythonBytecode(corePackRoot);
+  const runtimeAfterPruning = directoryStats(runtimeRoot);
+  const coreAfterPruning = directoryStats(corePackRoot);
+  console.log(`Portable Python bytecode removed: ${portableBytecodeRemoved.files} files, ${portableBytecodeRemoved.bytes} bytes`);
+  console.log(`Core pack bytecode removed: ${coreBytecodeRemoved.files} files, ${coreBytecodeRemoved.bytes} bytes`);
   const modelManifest = validateTrustedModelManifest();
   const manifest = writeManifest(relativeInterpreter, version);
 
-  console.log(`Portable Python: ${path.relative(root, runtimeRoot)} (${directorySize(runtimeRoot)} bytes)`);
-  console.log(`Core pack: ${path.relative(root, corePackRoot)} (${coreAfter.bytes} bytes)`);
+  console.log(`Portable Python: ${path.relative(root, runtimeRoot)} (${runtimeAfterPruning.bytes} bytes)`);
+  console.log(`Core pack: ${path.relative(root, corePackRoot)} (${coreAfterPruning.bytes} bytes)`);
   console.log(`Backend: backend (${directorySize(path.join(root, 'backend'))} bytes)`);
   console.log(`Runtime manifest: ${path.relative(root, manifestPath)}`);
   console.log(`Trusted model manifest: ${path.relative(root, modelInputPath)} (${modelManifest.id}, ${modelManifest.expectedBytes} bytes)`);
diff --git a/scripts/smoke-bundle-size.js b/scripts/smoke-bundle-size.js
index fde81a0..89335c0 100644
--- a/scripts/smoke-bundle-size.js
+++ b/scripts/smoke-bundle-size.js
@@ -67,6 +67,9 @@ function makeFixture(tempRoot) {
   write(path.join(distB, 'RECORD'), 'shared.py,,11\n');
   write(path.join(distTorch, 'METADATA'), 'Name: torch\nVersion: 3.0\n');
   write(path.join(distTorch, 'RECORD'), 'torch/lib/libtorch.dylib,,60\ntorch/__init__.py,,14\n');
+  const vendoredDist = path.join(coreRoot, 'setuptools', '_vendor', 'more_itertools-10.8.0.dist-info');
+  write(path.join(vendoredDist, 'METADATA'), 'Name: more-itertools\nVersion: 10.8.0\n');
+  write(path.join(vendoredDist, 'RECORD'), 'shared.py,,11\n');
   const dmg = path.join(tempRoot, 'candidate.dmg');
   write(dmg, Buffer.alloc(100, 11));
   return { app, dmg, resources, coreRoot, shared };
@@ -95,6 +98,7 @@ function main() {
     assert(!/(\/Users\/|\/private\/|\/tmp\/|RUNNER_TEMP)/.test(JSON.stringify(report)));
     assert(report.largestFiles.every((file, index, files) => index === 0 || files[index - 1].logicalBytes >= file.logicalBytes));
     assert(report.topDistributions.every((distribution) => distribution.logicalBytes >= 0));
+    assert(!report.topDistributions.some((distribution) => distribution.name === 'more-itertools'));
     assert(report.distributionOwnershipConflicts.some((conflict) => conflict.relativePath === 'shared.py'));
     assert.strictEqual(report.unattributedCorePackBytes, report.primaryCategories.find((category) => category.name === 'pythonCorePack').logicalBytes - report.attributedDistributionBytes);
     assert.strictEqual(report.torch.torchTotal, 74);
diff --git a/scripts/smoke-runtime-artifacts.js b/scripts/smoke-runtime-artifacts.js
index 399f6f8..c172dc2 100644
--- a/scripts/smoke-runtime-artifacts.js
+++ b/scripts/smoke-runtime-artifacts.js
@@ -17,10 +17,20 @@ const commonModelMappings = (packageJson.build?.extraResources || []).filter((en
 assert.strictEqual(commonModelMappings.length, 1);
 assert.ok(!(packageJson.build?.extraResources || []).some((entry) => entry.from === 'build/manifests'));
 const coreRequirements = fs.readFileSync(path.join(__dirname, '..', 'runtime', 'core-darwin-arm64-py311.txt'), 'utf8');
+const coreConstraints = fs.readFileSync(path.join(__dirname, '..', 'runtime', 'core-darwin-arm64-py311.constraints.txt'), 'utf8');
 assert.ok(!coreRequirements.includes('model-manifest'));
 assert.ok(!coreRequirements.includes('base.pt'));
+for (const requirement of coreRequirements.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith('#'))) {
+  assert.ok(coreConstraints.split(/\r?\n/).includes(requirement), `core constraints are missing direct pin: ${requirement}`);
+}
 const runtimePreparation = fs.readFileSync(path.join(__dirname, 'prepare-python-runtime.js'), 'utf8');
 assert.match(runtimePreparation, /function\s+pruneNonRuntimeCoreArtifacts\s*\(/);
+assert.match(runtimePreparation, /function\s+prunePythonBytecode\s*\(/);
+assert.match(runtimePreparation, /function\s+prunePackageTestArtifacts\s*\(/);
+assert.match(runtimePreparation, /RUNTIME_REQUIRED_TEST_DIRECTORIES\s*=\s*new Set\(\[['"]torch\/testing['"]\]\)/);
+assert.match(runtimePreparation, /['"]--no-compile['"]/);
+assert.match(runtimePreparation, /['"]--constraint['"],\s*coreConstraintsPath/);
+assert.match(runtimePreparation, /PYTHONDONTWRITEBYTECODE\s*=\s*['"]1['"]/);
 assert.match(runtimePreparation, /path\.join\(\s*corePackRoot\s*,\s*['"]torch['"]\s*,\s*['"]include['"]\s*\)/);
 assert.match(runtimePreparation, /fs\.rmSync\(\s*torchIncludePath\s*,\s*\{[\s\S]*?recursive:\s*true/);
 assert.ok(!/path\.join\(\s*corePackRoot\s*,\s*['"]torch['"]\s*\)/.test(runtimePreparation));