codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/content/contentRuntime.js

@@ -33,6 +33,7 @@
   const RUN_PROJECT_SYNC_MAX_AGE_MS = 30000;
   const RUN_SNAPSHOT_ZIP_TIMEOUT_MS = 30000;
   const STREAM_RENDER_FLUSH_MS = 80;
+  const REVIEWING_CONFIRM_TIMEOUT_MS = 120000;
   const STREAM_SAVE_DELAY_MS = 1000;
   const MAX_RUN_EVENTS = 300;
   const MAX_SAFE_UNDO_REPLACEALL_CHARS = 2000;
@@ -56,7 +57,12 @@
     'codex.history.clearPlugin',
     'skills.list',
     'skills.install',
-    'skills.remove'
+    'skills.remove',
+    'writing-style.get',
+    'writing-style.set',
+    'codex.thread.fork',
+    'asset.readChunk',
+    'asset.release'
   ]);
   const PageRpcContract = Modules.PageRpcContract;
   const PANEL_DEFAULT_WIDTH = 380;
@@ -64,7 +70,9 @@
   const PANEL_MAX_WIDTH = 760;
   const PAGE_MIN_WIDTH = 520;
   const CodexOverleafCompatibility = Modules.Compatibility;
-  const INSTALL_COMMAND = CodexOverleafCompatibility?.buildInstallCommand?.(
+  const MANAGED_INSTALLATION = chrome.runtime.getManifest?.()?.background?.service_worker === 'bootstrap/background.js'
+    || root.__CODEX_OVERLEAF_RUNTIME_PREFIX__ === 'runtime/';
+  const INSTALL_COMMAND = MANAGED_INSTALLATION ? '' : CodexOverleafCompatibility?.buildInstallCommand?.(
     undefined,
     undefined,
     getCurrentExtensionId()
@@ -91,7 +99,8 @@
     recordSessionResult,
     selectVisibleSessionsForList,
     setActiveSession,
-    updateActiveSession
+    updateActiveSession,
+    updateActiveSessionDraft
   } = Modules.SessionState;
   const LineReferences = Modules.LineReferences;
   const { getProjectStorageKey } = Modules.StorageKeys;
@@ -207,6 +216,8 @@
     closeSlashMenu: () => closeSlashMenu(),
     getCurrentProjectId: () => getCurrentProjectId(),
     getLocalSkillsPanel: () => localSkillsPanel,
+    getCodexLocalSkills: () => getCodexLocalSkillsCatalog(),
+    onSkillsChange: () => updateSlashMenuForTaskInput(),
     getLocale: () => getLocale(),
     getPanel: () => panel,
     getPanelRendererInstance: () => panelRendererInstance,
@@ -229,6 +240,9 @@
     closeCustomInstructionsSettings,
     closeSkillsView,
     getCodexOverleafSkillEnabled,
+    getCodexLocalSkillEnabled,
+    isCodexLocalSkillEnabled,
+    setCodexLocalSkillEnabled,
     getCustomInstructionsForCurrentProject,
     getGovernanceRulesForCurrentProject,
     getSkillLoadingSettings,
@@ -335,6 +349,7 @@
     otWarmMirrorController,
     getActiveFocusFiles,
     getCurrentProjectId,
+    getScope: () => ({ accountScopeId: cachedAccountScopeId, projectId: getCurrentProjectId(), generation: spaRouteGeneration }),
     isExperimentalOtEnabled,
     readOtBridgeStatus,
     formatOtStatusLabel,
@@ -383,9 +398,17 @@
     openCustomInstructionsSettings: () => openCustomInstructionsSettings(),
     onHistoryRowJump: record => jumpToHistoryRun(record),
     resetProjectNameCache: () => recentProjects.resetProjectNameCache(),
+    clearHistoryComposer: () => {
+      pendingRetryReplacement = null;
+      clearTaskComposer();
+      persistComposerAttachmentsToState();
+    },
     getPanel: () => panel,
     getState: () => state,
-    setState: next => { state = next; },
+    setState: next => {
+      if (next.activeSessionId !== state?.activeSessionId) composerDraftEditedHere = false;
+      state = next;
+    },
     getCurrentRunView: () => currentRunView,
     getSettingsPanelInstance: () => settingsPanelInstance,
     prepareRetryReplacement: (run, task) => prepareRetryReplacement(run, task)
@@ -406,30 +429,45 @@
   const sessionForkController = Modules.SessionForkController.create({
     SessionState: Modules.SessionState,
     getState: () => state,
-    setState: next => { state = next; },
-    sendBackgroundNative,
-    saveState,
+    setState: next => {
+      if (next.activeSessionId !== state?.activeSessionId) composerDraftEditedHere = false;
+      state = next;
+    },
+    getScope: () => ({ accountScopeId: cachedAccountScopeId, projectId: getCurrentProjectId(), generation: spaRouteGeneration }),
+    sendBackgroundNative, saveState,
+    getEnabledCodexLocalSkillIds: () => getEnabledCodexLocalSkillIds(),
+    captureLocalSkillIdsForFork: async preferences => {
+      if (preferences.loadCodexLocalSkills === false) return [];
+      const choices = { ...preferences.codexLocalSkillEnabled };
+      const skills = await primeCodexLocalSkillsCatalog({ required: true });
+      return skills.filter(skill => Object.hasOwn(choices, skill.id) ? choices[skill.id] !== false : skill.enabled !== false).map(skill => skill.id);
+    },
     applyStateToPanel,
     showPluginToast,
     tr
   });
   const runResultActions = Modules.RunResultActions.create({
     tr,
-    getLocale,
     forkRunFromNode: sessionForkController.forkRunFromNode
   });
   const runTimelineView = Modules.RunTimelineView.create({
     RunActivitySummary: Modules.RunActivitySummary,
     RunPresence: Modules.RunPresence,
+    PanelIcons: Modules.PanelIcons,
     // recentProjects is composed below; the empty state only reads it after startup.
     getProjectName: () => { try { return recentProjects.readCurrentProjectNameFromDom(); } catch { return ''; } },
-    getCurrentProjectId: () => getCurrentProjectId(),
     RunActivityModel: Modules.RunActivityModel,
     SubagentActivityView: Modules.SubagentActivityView,
     RunGuidanceView: Modules.RunGuidanceView,
+    getPendingGuidance: run => runGuidanceController.getPending(run),
     RunResultActions: runResultActions,
     RunScrollLayout: Modules.RunScrollLayout,
     RunFailureNotice: Modules.RunFailureNotice,
+    I18n: i18n,
+    FailureReasons,
+    projectContextLimitEvent: event => Modules.AgentTranscript.projectContextLimitEvent(event, getLocale()),
+    localizeVisibleReason: value => localizeVisibleReason(value),
+    localizeCompileReason: value => Modules.CompileAdapter.localizeCompileReason(value, getLocale()),
     tr,
     tx,
     getLocale,
@@ -447,7 +485,8 @@
     cssEscape,
     renderMarkdownInlineText,
     renderMarkdownBlockText,
-    decorateCompletionReport: Modules.MarkdownDomRenderer.decorateCompletionReport,
+    decorateCompletionReport: (container, options) => Modules.MarkdownDomRenderer.decorateCompletionReport(container,
+      { ...options, formatOperationType }),
     sanitizeAssistantVisibleText,
     sanitizeAssistantVisibleValue,
     buildMarkdownInlineNodes,
@@ -457,6 +496,8 @@
     refillComposerForRetry,
     canEditRun: run => runController.isRetryReplacementEligible(run, WritebackSettlement.projectRunSettlement(run)),
     retryWriteback: retryRunWriteback,
+    getCurrentProjectId,
+    getAccountScopeId: () => cachedAccountScopeId,
     showNativeSetupGuidance: () => showNativeUpdateGuidanceModal({}),
     openProjectFileForFailure,
     openStorageSettings,
@@ -489,6 +530,7 @@
     SessionPanel: Modules.SessionPanel,
     SessionState: Modules.SessionState,
     SessionMenuView: Modules.SessionMenuView,
+    PanelIcons: Modules.PanelIcons,
     tr,
     showPluginConfirm,
     showPluginToast,
@@ -496,10 +538,29 @@
     saveState,
     saveStateSoon,
     readPanelInputs,
+    flushComposerDraft: () => flushComposerDraft({ requireDurable: true }),
+    setSessionTransition: pending => {
+      if (pending) {
+        closeSlashMenu();
+        contextUsageView?.close();
+      }
+      const ready = composerPanelInstance?.setSessionTransition(pending);
+      syncComposerSendAvailability();
+      if (!pending && deferredSessionStart) {
+        const deferred = deferredSessionStart;
+        deferredSessionStart = null;
+        if (deferred.scope === getComposerDraftScope()) runQueueScheduler?.scheduleOne(deferred.sessionId);
+      }
+      return ready;
+    },
+    getDraftScope: getComposerDraftScope,
     applyStateToPanel, syncSessionProvider: () => providerSettingsCoordinator.syncSessionProvider(),
     getPanel: () => panel,
     getState: () => state,
-    setState: next => { state = next; },
+    setState: next => {
+      if (next.activeSessionId !== state?.activeSessionId) composerDraftEditedHere = false;
+      state = next;
+    },
     getSessionPanelInstance: () => sessionPanelInstance,
     formatSessionTime
   });
@@ -563,6 +624,7 @@
         selectionContext: value,
         ...(options.edit ? { mode: 'auto' } : {})
       });
+      syncProbeStatus();
       if (options.edit && panel) {
         const modeInput = panel.querySelector('[data-mode]');
         if (modeInput) modeInput.value = 'auto';
@@ -609,6 +671,14 @@
         locale: getLocale()
       };
     },
+    preflightProjectReferences: ({ project, assertCurrent }) => {
+      assertCurrent();
+      return Modules.SensitivePreflight.create({
+        SensitiveScan, normalizeGovernanceRules, isTextSnapshotFile, getCurrentProjectId,
+        appendRunEvent: () => {}, appendCompletionReport: () => {},
+        showPluginConfirm, tr, tx
+      }).run({ task: '', project, rules: getGovernanceRulesForCurrentProject(), assertCurrent });
+    },
     startBuild: async params => {
       const gate = await nativeCompatibilityController.ensureForMethod('codex.run');
       if (!gate.ok) throw new Error(gate.response?.error?.message || 'Native host update required.');
@@ -722,6 +792,7 @@
       || { providerId: state?.providerId || 'builtin', providerRevision: 0 },
     readSelectedSpeedInput,
     getRenderedModelEntries,
+    onSelectionRendered: renderContextUsage,
     persistPanelInputs,
     closeDiagnosticsMenu,
     closeCustomInstructionsSettings,
@@ -765,8 +836,10 @@
     window,
     getSettingsPanelInstance: () => settingsPanelInstance,
     getSelectedModel: () => state?.model || '', getSelectedProviderId: () => state?.providerId || 'builtin',
+    getSelectedProviderRevision: () => state?.providerRevision,
     setSelectedProviderId: projectProviderSelection.commit,
     confirmProviderSwitch: projectProviderSelection.confirmSwitch,
+    assertProviderSwitchAllowed: projectProviderSelection.assertSwitchAllowed,
     refreshModelOptions: loadModelOptions, persistInputs: persistPanelInputs
   });
   // v1.8.1 D3: the dashboard was a one-shot render — another tab finishing a
@@ -802,8 +875,11 @@
   document.addEventListener('visibilitychange', () => {
     if (document.visibilityState === 'visible') {
       refreshDashboardSoon();
+    } else {
+      flushComposerDraftOnLeave();
     }
   });
+  window.addEventListener('pagehide', flushComposerDraftOnLeave);
 
   const recentProjects = Modules.RecentProjects.create({
     ProjectSessionCleanup: Modules.ProjectSessionCleanup,
@@ -845,9 +921,11 @@
   const MAX_ATTACHMENT_PREVIEW_DATA_URL_CHARS = 768 * 1024;
   const composerAttachmentController = Modules.ComposerAttachments.createComposerAttachmentController({
     getPanel: () => panel,
+    icons: Modules.PanelIcons,
     tr,
     tx,
     appendPlainLog,
+    onChange: () => getComposerDraftPersistence().changed(),
     limits: {
       maxAttachmentBytes: MAX_COMPOSER_ATTACHMENT_BYTES,
       maxAttachmentTotalBytes: MAX_COMPOSER_ATTACHMENT_TOTAL_BYTES,
@@ -874,11 +952,14 @@
   });
   const contextTrayController = ContextTray.createContextTrayController({
     root: window,
+    icons: Modules.PanelIcons,
     document,
     getPanel: () => panel,
     getState: () => state,
     setState: nextState => {
       state = nextState;
+      // Paint focus changes before ContextTray waits for durable persistence.
+      syncProbeStatus();
     },
     saveState,
     saveStateSoon,
@@ -905,9 +986,15 @@
     saveState,
     sendBackgroundNative,
     getCurrentProjectId,
+    getScope: () => getCodexLocalSkillsCatalogScope(),
     getSkillLoadingSettings,
     isCodexOverleafSkillEnabled,
     setCodexOverleafSkillEnabled,
+    isCodexLocalSkillEnabled,
+    setCodexLocalSkillEnabled,
+    getCodexLocalSkills: () => getCodexLocalSkillsCatalog(),
+    getCodexLocalSkillWarnings: () => getCodexLocalSkillWarnings(),
+    refreshCodexLocalSkills: options => primeCodexLocalSkillsCatalog(options),
     setProjectSettingsStatus,
     tr,
     tx,
@@ -936,15 +1023,22 @@
   let settingsPanelInstance = null;
   let diagnosticsPanelInstance = null;
   let composerPanelInstance = null;
+  let contextUsageView = null;
   let state = null;
   let storageKey = LEGACY_STORAGE_KEY;
   let globalPreferencesController = null;
   let currentRunView = null;
+  let runSubmissionPending = false;
   let pendingRetryReplacement = null;
   let runQueueScheduler = null;
+  let deferredSessionStart = null;
   let runInputCoordinator = null;
   const activeTurnControl = ActiveTurnControl.create({ chrome });
   let saveStateTimer = null;
+  const DRAFT_SAVE_DELAY_MS = 800;
+  const DRAFT_SAVE_MAX_WAIT_MS = 4000;
+  let draftSaveTimer = null;
+  let pendingDraftSave = null;
   // Two-phase saveState scheduling. `saveStateInFlight` flips to true while
   // an async saveState() is actually writing; `saveStateRunAfterFlight` is
   // set when a fresh saveStateSoon() fires during the in-flight phase. When
@@ -960,6 +1054,9 @@
   let pendingStreamRenderEvents = new Map();
   let storageNoticeKeys = new Set();
   let composerSkillInvocation = null;
+  let composerDraftRevision = 0;
+  // Page-local provenance only; the draft itself stays shared per conversation.
+  let composerDraftEditedHere = false;
   let slashCodexOverleafSkills = [];
   let slashCodexOverleafSkillsLoaded = false;
   let slashCodexOverleafSkillsLoading = false;
@@ -982,6 +1079,7 @@
     showPluginToast,
     getPanel: () => panel,
     ensurePanelOpen,
+    getIconUrl: () => chrome.runtime.getURL('assets/icons/codex-overleaf-dialog-icon.png'),
     getPanelRendererInstance: () => panelRendererInstance,
     setBadge: (...args) => PanelRenderer.setBadge(...args),
     setDiagnosticsHealth,
@@ -1000,7 +1098,7 @@
     getBusyState: () => ({
       run: Boolean(currentRunView),
       cancelling: runCancellationRequested,
-      storage: saveStateInFlight || Boolean(saveStateTimer),
+      storage: saveStateInFlight || Boolean(saveStateTimer) || Boolean(pendingDraftSave),
       reviewAction: trackedChangeInFlight.size > 0,
       dialog: Boolean(pluginConfirmController?.isOpen())
     }),
@@ -1017,6 +1115,7 @@
   const diagnosticsExporter = Modules.DiagnosticsExport.create({
     root, window, document, Blob, URL, TextEncoder, AuditRecords, StorageDb: Modules.StorageDb,
     CodexOverleafCompatibility, getState: () => state, getCurrentRunView: () => currentRunView,
+    getAccountScopeId: () => cachedAccountScopeId || '',
     getCurrentProjectId, findRunRecord, getMirrorFreshness, getExtensionCompatibilityMetadata,
     getModelDiscovery, getGovernanceRulesForCurrentProject, sendBackgroundNative,
     fallbackNativeCompatibility, isNativeCompatibilityCompatible, getNativeCompatibilityClassification,
@@ -1029,7 +1128,7 @@
   chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
     if (message?.type === 'codex-overleaf/runtime-health-probe') {
       sendResponse?.({
-        ok: true,
+        ok: true, runOwnerProtocol: 2, runOwners: [activeTurnControl.getOwner()].filter(Boolean),
         version: CodexOverleafCompatibility?.BUILD_TARGET_VERSION || chrome.runtime.getManifest().version
       });
       return false;
@@ -1094,6 +1193,8 @@
     await refreshAccountScopeId();
     storageKey = getProjectStorageKey(LEGACY_STORAGE_KEY, window.location.href);
     state = normalizeLoadedPanelState(await loadStoredState());
+    composerDraftEditedHere = false;
+    await getRunReviewController().recoverInterruptedUndoStatuses();
     initializeRunQueueScheduler();
     recoverInterruptedRunJournals()
       .then(() => applyStateToPanel())
@@ -1165,7 +1266,8 @@
       version: CodexOverleafCompatibility?.BUILD_TARGET_VERSION ||
         chrome.runtime.getManifest?.().version ||
         '',
-      extensionId: getCurrentExtensionId()
+      extensionId: getCurrentExtensionId(),
+      installIdentity: { managed: MANAGED_INSTALLATION }
     };
   }
 
@@ -1197,7 +1299,6 @@
         callbacks: {
           onLauncherToggle: () => ensurePanelOpen(),
           onClosePanel: () => closePanel(),
-          onRefresh: () => refreshProbe({ userInitiated: true }),
           onNewSession: () => startNewSession(),
           onChangeHistory: () => openChangeHistory(),
           onSettingsClick: () => toggleCustomInstructionsSettings(),
@@ -1219,7 +1320,9 @@
       diagnosticsPanelInstance = DiagnosticsPanel.create({
         container: panelRendererInstance.diagnosticsSlot,
         i18n: { tr },
+        icons: Modules.PanelIcons,
         callbacks: {
+          onRefresh: () => refreshProbe({ userInitiated: true }),
           onBeforeOpen: () => {
             closeModelConfigPopover();
             closeContextTray();
@@ -1257,6 +1360,7 @@
         projectId: getCurrentProjectId(),
         i18n: { tr },
         button: panel.querySelector('[data-custom-instructions-settings]'),
+        getProjectName: () => { try { return recentProjects.readCurrentProjectNameFromDom(); } catch { return ''; } },
         callbacks: {
           onBack: () => closeCustomInstructionsSettings(),
           onInputChange: event => persistPanelInputs(event),
@@ -1297,9 +1401,12 @@
       composerPanelInstance = ComposerPanel.create({
         container: panelRendererInstance.composerSlot,
         i18n: { tr },
+        icons: Modules.PanelIcons,
         attachmentController: composerAttachmentController,
         callbacks: {
           onSubmit: () => safeRunTask(),
+          getTaskScope: getComposerDraftScope,
+          getTaskValue: () => state.task,
           isRunning: () => Boolean(currentRunView),
           onCancel: () => cancelActiveRun(),
           onPaste: handleComposerPaste,
@@ -1309,12 +1416,13 @@
           onTaskKeydown: handleTaskInputKeydown,
           onTaskInput: handleTaskInput,
           onSlashMenuClick: handleSlashMenuClick,
+          onMenuLayoutChange: updateSlashMenuLayout,
           onClearSkillInvocation: clearComposerSkillInvocation,
           onAddContext: toggleContextTray,
           onAttachClick: () => panel.querySelector('[data-attach-input]')?.click(),
           onAttachInput: handleAttachInputChange,
           onContextRefresh: () => loadContextFiles({ force: true }),
-          onModelConfigToggle: () => toggleModelConfigPopover(),
+          onModelConfigToggle: () => { contextUsageView?.close(); toggleModelConfigPopover(); },
           onModelConfigChoiceClick: event => {
             handleModelConfigChoiceClick(event).catch(error => {
               appendPlainLog(tx(`Failed to update model settings: ${error.message}`, `更新模型设置失败：${error.message}`));
@@ -1327,6 +1435,18 @@
         }
       });
 
+      contextUsageView = Modules.ContextUsageView.create({
+        getPanel: () => panel, getLocale, tr,
+        onOpen: () => {
+          closeModelConfigPopover();
+          closeContextTray();
+          closeSlashMenu();
+        },
+        getCompactAvailability,
+        level: Modules.ContextUsage.level,
+        onCompact: () => safeRunTask({ operation: 'compact' })
+      });
+      renderContextUsage();
       installContextDismiss();
       installModelConfigDismiss();
       bindLogAutoFollow();
@@ -1335,34 +1455,87 @@
       renderContextSelection();
       scheduleMirrorPrefetch({ reason: 'cold-start', delayMs: 2500 });
       primeCodexOverleafSkillsCatalog().catch(() => { /* non-blocking */ });
+      primeCodexLocalSkillsCatalog().catch(() => { /* retry through settings, slash, or submission */ });
     }
 
     PanelRenderer.setVisible(panel, true);
   }
 
-  // One-shot catalog prime: the parallel-subagents broker gate reads
-  // state.codexOverleafSkills at run time. The catalog persists once filled
-  // (v1.6.1), but states saved by older builds have it stripped — without
-  // this prime, the gate stays silently off until the user happens to open
-  // the Skills page. Fire-and-forget on panel open; only fetches when the
-  // catalog is empty.
-  async function primeCodexOverleafSkillsCatalog() {
+  // Panel prefetch and first submission share the same official catalog read.
+  // A required read fails through the existing task-start error presentation.
+  let codexOverleafSkillsCatalogPromise = null;
+  async function primeCodexOverleafSkillsCatalog({ required = false } = {}) {
     if (Array.isArray(state?.codexOverleafSkills) && state.codexOverleafSkills.length) {
-      return;
-    }
-    if (getSkillLoadingSettings().loadCodexOverleafSkills === false) {
-      return;
-    }
-    const response = await sendBackgroundNative({
-      method: 'skills.list',
-      params: { scope: 'codex-overleaf' }
+      return state.codexOverleafSkills;
+    }
+    if (!required && getSkillLoadingSettings().loadCodexOverleafSkills === false) return [];
+    if (!codexOverleafSkillsCatalogPromise) {
+      codexOverleafSkillsCatalogPromise = sendBackgroundNative({
+        method: 'skills.list', params: { scope: 'codex-overleaf' }
+      }).then(response => {
+        const skills = Array.isArray(response?.result?.skills) ? response.result.skills : [];
+        if (!response?.ok || !skills.length) throw new Error(tx(
+          'Could not load Codex Overleaf skills. Try again.', '无法加载 Codex Overleaf 技能，请重试。'));
+        state = { ...state, codexOverleafSkills: skills };
+        saveStateSoon();
+        return skills;
+      }).finally(() => { codexOverleafSkillsCatalogPromise = null; });
+    }
+    return codexOverleafSkillsCatalogPromise;
+  }
+
+  // Local metadata stays in memory. A stale page/account read cannot become the
+  // next page's selected catalog, and an empty successful directory is valid.
+  let codexLocalSkillsCatalog = null;
+  let codexLocalSkillsWarnings = [];
+  let codexLocalSkillsCatalogScope = '';
+  let codexLocalSkillsCatalogRequest = null;
+  function getCodexLocalSkillsCatalogScope() {
+    return [cachedAccountScopeId, getCurrentProjectId(), spaRouteGeneration].join(':');
+  }
+
+  function getCodexLocalSkillsCatalog() {
+    return codexLocalSkillsCatalogScope === getCodexLocalSkillsCatalogScope() ? codexLocalSkillsCatalog : null;
+  }
+
+  function getCodexLocalSkillWarnings() {
+    return codexLocalSkillsCatalogScope === getCodexLocalSkillsCatalogScope() ? codexLocalSkillsWarnings : [];
+  }
+
+  async function primeCodexLocalSkillsCatalog({ required = false, force = false } = {}) {
+    const scope = getCodexLocalSkillsCatalogScope();
+    if (!required && !force && getSkillLoadingSettings().loadCodexLocalSkills === false) return [];
+    if (!force && codexLocalSkillsCatalogScope === scope && Array.isArray(codexLocalSkillsCatalog)) return codexLocalSkillsCatalog;
+    if (codexLocalSkillsCatalogRequest?.scope === scope) return codexLocalSkillsCatalogRequest.promise;
+    const request = { scope, promise: null };
+    request.promise = sendBackgroundNative({ method: 'skills.list', params: { scope: 'codex-local' } }).then(response => {
+      if (!response?.ok || !Array.isArray(response.result?.skills)) throw new Error(tx(
+        'Could not load local Codex skills. Try again.', '无法加载 Codex 本地技能，请重试。'));
+      if (scope !== getCodexLocalSkillsCatalogScope()) throw new Error(tx(
+        'The active project changed while loading skills. Try again.', '加载技能时活动项目已改变，请重试。'));
+      const seen = new Set();
+      const skills = response.result.skills.filter(skill => {
+        const id = String(skill?.id || '');
+        if (!isSafeSkillId(id) || seen.has(id)) return false;
+        seen.add(id); return true;
+      });
+      codexLocalSkillsCatalog = skills;
+      codexLocalSkillsWarnings = (Array.isArray(response.result.discoveryWarnings) ? response.result.discoveryWarnings : [])
+        .filter(warning => warning?.code === 'codex_local_skills_skipped' && Number.isSafeInteger(warning.count) && warning.count > 0)
+        .map(warning => ({ code: warning.code, count: warning.count }));
+      codexLocalSkillsCatalogScope = scope;
+      updateSkillsEntrySummary();
+      updateSlashMenuForTaskInput();
+      return skills;
+    }).catch(() => {
+      if (scope !== getCodexLocalSkillsCatalogScope()) throw new Error(tx(
+        'The active project changed while loading skills. Try again.', '加载技能时活动项目已改变，请重试。'));
+      throw new Error(tx('Could not load local Codex skills. Try again.', '无法加载 Codex 本地技能，请重试。'));
+    }).finally(() => {
+      if (codexLocalSkillsCatalogRequest === request) codexLocalSkillsCatalogRequest = null;
     });
-    const skills = Array.isArray(response?.result?.skills) ? response.result.skills : [];
-    if (!response?.ok || !skills.length) {
-      return;
-    }
-    state = { ...state, codexOverleafSkills: skills };
-    saveStateSoon();
+    codexLocalSkillsCatalogRequest = request;
+    return request.promise;
   }
 
   function closePanel() {
@@ -1445,9 +1618,13 @@
     panel.querySelectorAll('[data-i18n]').forEach(element => {
       element.textContent = tr(element.dataset.i18n);
     });
+    panel.querySelectorAll('[data-i18n-aria-label]').forEach(element => {
+      element.setAttribute('aria-label', tr(element.dataset.i18nAriaLabel));
+    });
+    panelRendererInstance?.setLocale?.({ launcher: tx('Show or hide Codex panel', '显示或隐藏 Codex 边栏'), close: tx('Close Codex panel', '关闭 Codex 边栏') });
 
     setElementTitleAndAria('[data-panel-resize-handle]', tr('resizePanel'), tr('resizePanel'));
-    setElementTitleAndAria('[data-refresh]', tr('refreshProbe'), tr('refreshProbe'));
+    setRefreshProbeLoading(panel?.querySelector('[data-refresh]')?.dataset.loading === 'true');
     // State-dependent tooltip: re-derive from the dot's current health so a
     // locale/session refresh doesn't clobber it back to the generic label.
     setDiagnosticsHealth(panel.querySelector('[data-diagnostics-health-dot]')?.dataset.health || 'unknown');
@@ -1498,7 +1675,7 @@
     }
     const reviewToggle = panel.querySelector('.codex-review-toggle');
     if (reviewToggle) {
-      reviewToggle.title = tr('requireReviewingTitle');
+      syncReviewingTooltip();
     }
     const recompileToggle = panel.querySelector('.codex-recompile-toggle');
     if (recompileToggle) {
@@ -1514,18 +1691,32 @@
       contextStatus.textContent = tr('contextStatus');
     }
     // Re-render rather than patch text: the first div is the animated mark.
-    if (panel.querySelector('.empty-runs')) renderRunHistory();
+    if (arguments[0]?.reprojectDynamic !== false) runTimelineView.refreshLocale?.();
 
     syncModeControls();
     updateOtStatusDisplay();
     updateExperimentalOtMenuStatus();
     renderModelConfigChoices();
     updateModelDisplay();
+    // The header switcher's title and accessible name carry localized text too.
+    applySessionLabel();
     renderSessionList();
+    renderContextUsage();
+    if (panel.querySelector('[data-slash-menu]')?.hidden === false) updateSlashMenuForTaskInput();
     renderContextSelection();
+    renderContextSummary();
+    renderPendingInputs();
+    renderComposerAttachments();
+    renderComposerSkillInvocation();
     writingStyleSettings.sync();
     updateSkillsEntrySummary();
+    localSkillsPanel.refreshLocale?.();
     providerSettingsCoordinator.renderSummary();
+    providerSettingsCoordinator.refreshLocale?.();
+    settingsPanelInstance?.refreshLocale?.();
+    Modules.UpdateNotice?.refreshLocale?.();
+    DiagnosticsPanel.refreshLocale?.(diagnosticsPanelInstance, diagnosticsController.refreshLocale?.());
+    if (!panel.querySelector('[data-context-tray]')?.hidden) renderContextFiles();
     if (settingsPanelInstance?.container?.querySelector('[data-storage-card]')?.open) refreshStorageUsageSummary();
   }
 
@@ -1685,47 +1876,81 @@
   function resetContextProject() { return contextTrayController.resetContextProject(); }
 
   async function runTask(options = {}) {
-    // Barrier on a still-flying background mirror refresh from the previous
-    // turn (v1.7.5) BEFORE startRunView creates the new run view: the mirror's
-    // wrap-up events must land in the run that produced them, not the new
-    // one, and mirror.sync landing mid-run would swap the local baseline
-    // under Codex.
-    const pendingMirror = getPendingMirrorRefresh?.();
-    if (pendingMirror) {
-      await pendingMirror.catch(() => {});
-    }
+    // Capture the click before any preparation can yield to another draft/session.
     readPanelInputs();
     const queuedInput = options.queuedInput || null;
-    const task = String(queuedInput?.text || state.task || '').trim();
+    const compact = !queuedInput && options.operation === 'compact';
+    const task = compact ? '/compact' : String(queuedInput?.text || state.task || '').trim();
     if (!task) {
       appendLog(tx('Enter a task first.', '请先输入任务。'));
       return;
     }
+    const submittedSessionId = state.activeSessionId;
+    const submittedSession = runController.captureSessionContext(state);
+    const submittedThreadId = getActiveSession(state)?.codexThreadId || '';
+    if (compact && !submittedThreadId) {
+      showPluginToast(tr('compactNoThread'), { status: 'info' });
+      return;
+    }
+    const submittedDraft = state.task;
+    const submittedRetryReplacement = pendingRetryReplacement;
     const submittedWritingStyleScope = { accountScopeId: cachedAccountScopeId, projectId: getCurrentProjectId() };
     const submittedPanelState = {
-      mode: state.mode,
+      mode: compact ? 'ask' : state.mode,
       providerId: state.providerId,
       model: state.model,
       reasoningEffort: state.reasoningEffort,
       speedTier: state.speedTier,
       autoRecompile: state.autoRecompile !== false,
       requireReviewing: state.requireReviewing === true,
-      focusFiles: getActiveFocusFiles(),
-      selectionContext: selectionContextView.capture()
+      focusFiles: compact ? [] : getActiveFocusFiles(),
+      selectionContext: compact ? null : selectionContextView.capture()
     };
-    const submittedCustomInstructions = getCustomInstructionsForCurrentProject();
-    const submittedSkillLoadingSettings = getSkillLoadingSettings();
-    const submittedAttachments = getComposerAttachmentsForRun();
-    const submittedSkillInvocation = getComposerSkillInvocationForRun();
+    const queuedContext = queuedInput
+      ? RunInputQueue.normalizeSubmissionContext(queuedInput.payload?.submissionContext) : null;
+    const submittedCustomInstructions = queuedContext ? queuedContext.customInstructions : getCustomInstructionsForCurrentProject();
+    const submittedSkillLoadingSettings = queuedContext ? queuedContext.skillLoadingSettings : getSkillLoadingSettings();
+    const submittedAttachments = queuedInput || compact ? [] : getComposerAttachmentsForRun();
+    const submittedSkillInvocation = compact ? null : queuedContext ? queuedContext.skillInvocation : getComposerSkillInvocationForRun();
+    let submittedEnabledSkillIds = queuedContext ? queuedContext.enabledCodexOverleafSkillIds : getEnabledCodexOverleafSkillIds();
+    const submittedSkillEnabled = { ...state.codexOverleafSkillEnabled };
+    const submittedLocalSkillEnabled = { ...state.codexLocalSkillEnabled };
+    const submittedSelectionRevision = selectionContextView.getRevision?.();
+    let submittedEnabledLocalSkillIds = queuedContext ? queuedContext.enabledCodexLocalSkillIds : compact ? getEnabledCodexLocalSkillIds() : [];
+    // Capture submission first; a save must not adopt text typed while it waits.
+    if (!queuedInput) await flushComposerDraft({ requireDurable: true });
+    if (!compact && !queuedInput && submittedSkillLoadingSettings.loadCodexLocalSkills !== false) {
+      const localSkills = await primeCodexLocalSkillsCatalog({ required: true, force: submittedSkillInvocation?.scope === 'codex-local' });
+      submittedEnabledLocalSkillIds = localSkills.filter(skill => Object.hasOwn(submittedLocalSkillEnabled, skill.id)
+        ? submittedLocalSkillEnabled[skill.id] !== false : skill.enabled !== false).map(skill => skill.id);
+    }
+    if (!queuedInput && submittedSkillInvocation?.scope === 'codex-local'
+      && (submittedSkillLoadingSettings.loadCodexLocalSkills === false || !submittedEnabledLocalSkillIds.includes(submittedSkillInvocation.id))) {
+      throw new Error(tx('The selected local Codex skill is unavailable or disabled. Select an enabled skill and try again.',
+        '所选 Codex 本地技能不可用或已关闭，请选择已启用的技能后重试。'));
+    }
+    if (!compact && !queuedInput && submittedSkillLoadingSettings.loadCodexOverleafSkills !== false) {
+      const skills = await primeCodexOverleafSkillsCatalog({ required: true });
+      submittedEnabledSkillIds = skills.map(skill => String(skill?.id || '').trim())
+        .filter(id => id && submittedSkillEnabled[id] !== false);
+    }
+    // Keep the previous mirror's completion events on its own run.
+    const pendingMirror = getPendingMirrorRefresh?.();
+    if (pendingMirror) await pendingMirror.catch(() => {});
     await providerSettingsCoordinator.ensureLoaded();
-    if (!queuedInput) await writingStyleSettings.ensureLoaded(true);
+    if (!queuedInput && !compact) await writingStyleSettings.ensureLoaded(true);
     if (submittedWritingStyleScope.accountScopeId !== cachedAccountScopeId
       || submittedWritingStyleScope.projectId !== getCurrentProjectId()) {
       throw new Error(tx('The active project changed before submission. Submit the task again.',
         '提交前活动项目已改变，请重新提交任务。'));
     }
-    submittedPanelState.writingStyle = queuedInput ? null : writingStyleSettings.capture();
-    const executionSnapshot = queuedInput
+    if (!findSessionById(submittedSessionId) || currentRunView
+      || (compact && findSessionById(submittedSessionId)?.codexThreadId !== submittedThreadId)) {
+      throw new Error(tx('The submitted session changed before submission. Submit the task again.',
+        '提交所属会话已改变，请重新提交任务。'));
+    }
+    submittedPanelState.writingStyle = queuedInput || compact ? null : writingStyleSettings.capture();
+    let executionSnapshot = queuedInput
       ? RunExecutionSnapshot.resolveForExecution(
         RunExecutionSnapshot.fromQueuePayload(queuedInput.payload),
         { catalog: providerSettingsCoordinator.getCatalog() }
@@ -1733,33 +1958,89 @@
       : captureCurrentExecutionSnapshot(submittedPanelState);
     // Freeze submitted run identity before the panel can change during the run.
     const submittedMode = executionSnapshot.mode;
-    const submittedRequireReviewing = executionSnapshot.requireReviewing === true;
-    const replaceRunId = queuedInput ? '' : runController.resolveRetryReplacement({
-      candidate: pendingRetryReplacement,
-      activeSessionId: state.activeSessionId,
-      runs: state.runs,
+    let submittedRequireReviewing = executionSnapshot.requireReviewing === true;
+    const replaceRunId = queuedInput || compact ? '' : runController.resolveRetryReplacement({
+      candidate: submittedRetryReplacement,
+      activeSessionId: submittedSessionId,
+      runs: findSessionById(submittedSessionId)?.runs,
       projectRunSettlement: run => WritebackSettlement.projectRunSettlement(run)
     });
 
     runCancellationRequested = false;
     runCancellationController = new AbortController();
     setRunning(true);
-    currentRunView = startRunView({
-      task,
-      mode: submittedMode,
-      model: executionSnapshot.model,
-      reasoningEffort: executionSnapshot.reasoningEffort,
-      speedTier: executionSnapshot.speedTier,
-      executionSnapshot,
-      attachments: submittedAttachments,
-      skillInvocation: submittedSkillInvocation,
-      queueItemId: queuedInput?.id || '',
-      replaceRunId
-    });
-    if (!queuedInput) pendingRetryReplacement = null;
-    const runSessionId = currentRunView.sessionId;
+    const runSessionId = submittedSessionId;
     let runAuditDraft = null;
+    let localSkillRestorePoint = null;
     try {
+      currentRunView = startRunView({
+        sessionId: submittedSessionId,
+        sessionContext: submittedSession,
+        codexThreadId: submittedThreadId,
+        operation: compact ? 'compact' : undefined,
+        task,
+        mode: submittedMode,
+        model: executionSnapshot.model,
+        reasoningEffort: executionSnapshot.reasoningEffort,
+        speedTier: executionSnapshot.speedTier,
+        executionSnapshot,
+        attachments: submittedAttachments,
+        skillInvocation: submittedSkillInvocation,
+        queueItemId: queuedInput?.id || '',
+        replaceRunId
+      });
+      // Preparation can await project/audit work before a Native request exists.
+      // Give other pages a live owner to check throughout that interval.
+      const bound = await awaitRunStep(activeTurnControl.bindBrowserRun({
+        requestId: ActiveTurnControl.getStartupRequestId(runSessionId, currentRunView.recordId),
+        projectKey: currentRunView.runProjectId, clientRunId: currentRunView.recordId,
+        sessionId: runSessionId, ownerToken: crypto.randomUUID()
+      }));
+      throwIfRunCancellationRequested();
+      if (!bound) throw new Error(tx('Could not start the task. Reload the page and try again.',
+        '无法启动任务，请刷新页面后重试。'));
+      renderContextUsage();
+      if (!queuedInput && !compact && pendingRetryReplacement === submittedRetryReplacement) pendingRetryReplacement = null;
+      if (compact) {
+        announceCrossTabRunStart();
+        // Only the slash-command text is consumed; a draft kept while compacting from the popover stays.
+        if (options.consumeCompactDraft === true && state.activeSessionId === submittedSessionId
+          && /^\/[^\s/]*$/.test(String(submittedDraft || '').trim())
+          && panel?.querySelector('[data-task]')?.value === submittedDraft) {
+          panel.querySelector('[data-task]').value = '';
+          updateSessionById(submittedSessionId, { task: '' });
+          recordSubmittedDraftConsumption(submittedSessionId, submittedDraft);
+          composerDraftEditedHere = false;
+          composerDraftRevision += 1;
+          autosizeTaskTextarea();
+          closeSlashMenu();
+          syncComposerSendAvailability(true);
+        }
+        appendRunEvent({ title: tr('contextUsageCompacting'), status: 'running',
+          activity: { v: 1, kind: 'lifecycle', state: 'running', target: 'context_compaction' } });
+        renderContextUsage();
+        const response = await awaitRunStep(sendTrackedCodexRun({
+          operation: 'compact', task: '/compact', mode: 'ask',
+          projectId: currentRunView.runProjectId, accountScopeId: currentRunView.runAccountScopeId,
+          clientRunId: currentRunView.recordId, clientSessionId: runSessionId,
+          threadId: submittedThreadId, model: executionSnapshot.model,
+          reasoningEffort: executionSnapshot.reasoningEffort, speedTier: executionSnapshot.speedTier,
+          providerSelection: RunExecutionSnapshot.toProviderSelection(executionSnapshot),
+          locale: getLocale(), ...submittedSkillLoadingSettings,
+          enabledCodexOverleafSkillIds: submittedEnabledSkillIds,
+          enabledCodexLocalSkillIds: submittedEnabledLocalSkillIds
+        }));
+        if (!response?.ok) throw Object.assign(new Error(response?.error?.message || 'Compaction failed'), response?.error);
+        if (response.result?.operation !== 'compact' || response.result?.status !== 'completed'
+          || response.result?.threadId !== submittedThreadId) {
+          throw Object.assign(new Error('Compaction completion was not confirmed'), { code: 'codex_compact_unconfirmed' });
+        }
+        throwIfRunCancellationRequested();
+        appendCompletionReport({ conclusion: tr('compactCompleted'), conclusionKey: 'context_compacted',
+          status: 'completed', mode: 'ask', operations: [], applyResults: [] });
+        await finishRunView(tr('compactCompleted'), 'completed');
+        return;
+      }
       if (queuedInput?.id) {
         await runQueueScheduler?.markExecuting(runSessionId, queuedInput.id, currentRunView.recordId);
       }
@@ -1770,14 +2051,32 @@
         focusFiles: executionSnapshot.focusFiles,
         executionSnapshot
       }));
+      if (submittedWritingStyleScope.accountScopeId !== cachedAccountScopeId
+        || submittedWritingStyleScope.projectId !== getCurrentProjectId()) {
+        throw Object.assign(createRunCancellationError(), {
+          message: 'The active project or account changed before dispatch.'
+        });
+      }
       announceCrossTabRunStart();
       // Binary attachments belong to this submitted turn. The run record has
       // already captured their snapshots, so clear them from the composer
       // together with the submitted text. Persistent @context remains intact.
-      clearTaskComposer({ keepAttachments: false });
+      const submittedComposerCleared = !queuedInput && clearTaskComposer({ keepAttachments: false, submission: {
+        ...submittedWritingStyleScope,
+        sessionId: submittedSessionId, task: submittedDraft, attachments: submittedAttachments,
+        skillInvocation: submittedSkillInvocation, selectionContext: submittedPanelState.selectionContext,
+        selectionRevision: submittedSelectionRevision
+      } });
+      if (submittedComposerCleared && submittedSkillInvocation?.scope === 'codex-local'
+        && state.activeSessionId === submittedSessionId && !panel?.querySelector('[data-task]')?.value
+        && !getComposerAttachmentsForRun().length && !composerAttachmentController.getAttachmentByteUsage?.().pending
+        && !getComposerSkillInvocationForRun() && !selectionContextView.capture()) {
+        localSkillRestorePoint = { draftRevision: composerDraftRevision,
+          attachmentRevision: composerAttachmentController.getRevision?.(), selectionRevision: selectionContextView.getRevision?.() };
+      }
       syncComposerSendAvailability(true);
       appendRunEvent({
-        title: submittedSkillInvocation?.id === 'skill-installer'
+        title: submittedSkillInvocation?.id === 'skill-installer' && !submittedSkillInvocation.scope
           ? tx('I will use the Codex skill installer for this request.', '我会用 Codex skill installer 处理这个请求。')
           : tx('I will first understand your request, then inspect the relevant Overleaf files.', '我会先理解你的请求，再检查相关 Overleaf 文件。'),
         status: 'running',
@@ -1792,7 +2091,7 @@
           '@context': formatContextItems(executionSnapshot.focusFiles)
         }
       });
-      if (submittedSkillInvocation?.id === 'skill-installer') {
+      if (submittedSkillInvocation?.id === 'skill-installer' && !submittedSkillInvocation.scope) {
         await awaitRunStep(runSkillInstallerTask({
           task,
           runSessionId,
@@ -1800,6 +2099,8 @@
           submittedMode,
           submittedCustomInstructions,
           submittedSkillLoadingSettings,
+          submittedEnabledLocalSkillIds,
+          submittedEnabledSkillIds,
           submittedAttachments,
           submittedSkillInvocation,
           executionSnapshot
@@ -1818,7 +2119,30 @@
       await awaitRunStep(pauseOtWarmMirror('run-start'));
       const writeSafety = await awaitRunStep(preflightWriteSafety({
         mode: submittedMode,
-        requireReviewing: submittedRequireReviewing
+        requireReviewing: submittedRequireReviewing,
+        onUntracked: async choice => {
+          submittedRequireReviewing = false;
+          // Keep the effective policy identical in dispatch, recovery and Undo consumers.
+          const view = currentRunView;
+          const record = findRunRecord(view.recordId, view.sessionId);
+          executionSnapshot = RunExecutionSnapshot.applyUntrackedDecision(view, record, choice);
+          if (choice === 'disable') {
+            updateSessionById(view.sessionId, { requireReviewing: false });
+            if (state.activeSessionId === view.sessionId) {
+              state.requireReviewing = false;
+              panel.querySelector('[data-require-reviewing]').checked = false;
+            }
+          }
+          appendRunEvent({ title: tr('reviewingUnavailableRunUntracked'), status: 'completed',
+            technicalDetail: { code: 'reviewing_unavailable', submittedRequireReviewing: true,
+              effectiveRequireReviewing: false, choice } });
+          saveStateSoon(0);
+          syncProbeStatus();
+          runAuditDraft = await finalizeAuditDraftPartial(runAuditDraft, {
+            requireReviewing: false, trackingDecision: choice
+          });
+          await flushQueuedSaveState({ requireDurable: true });
+        }
       }));
       if (!writeSafety.ok) {
         await finalizeAuditRecord(runAuditDraft, {
@@ -1860,6 +2184,7 @@
         project,
         snapshotWarnings,
         focusFiles,
+        focusFilesAreLiteral: true,
         isUsableProjectFileContent: Modules.ProjectFiles.isUsableProjectFileContent
       });
       let restrictToFocusFiles = runController.shouldRestrictWritebackToFocus({ focusFiles, focusedPartialSnapshot });
@@ -1879,7 +2204,7 @@
             fileCount: (project?.files || []).length
           }
         });
-        appendCompletionReport({
+        appendCompletionReport({ conclusionKey: 'full_project_unread',
           conclusion: tx('This run did not continue: the full Overleaf project was not read.', '这轮没有继续：没有读到完整的 Overleaf 项目内容。'),
           status: 'blocked',
           operations: [],
@@ -1928,8 +2253,7 @@
         }
       }
 
-      const activeSession = findSessionById(runSessionId) || getActiveSession(state);
-      const codexThreadId = activeSession?.codexThreadId || '';
+      const codexThreadId = submittedThreadId;
 
       // Resolve @compile-log if mentioned in task
       let compileLogContext = null;
@@ -1957,14 +2281,14 @@
             }
           });
           appendRunEvent({
-            title: tx(`Compile log unavailable: ${compileLogContext.reason}`, `编译日志不可用：${compileLogContext.reason}`),
+            title: tx(`Compile log unavailable: ${Modules.CompileAdapter.localizeCompileReason(compileLogContext.reason, getLocale())}`, `编译日志不可用：${Modules.CompileAdapter.localizeCompileReason(compileLogContext.reason, getLocale())}`),
             status: 'failed',
             failure: contextFailure
           });
         }
       }
 
-      const sensitiveFindings = await awaitRunStep(runSensitivePreflight({
+      let sensitiveFindings = await awaitRunStep(runSensitivePreflight({
         task,
         project,
         rules: getGovernanceRulesForCurrentProject(),
@@ -2001,6 +2325,8 @@
           compileLogContext,
           customInstructions: submittedCustomInstructions,
           skillLoadingSettings: submittedSkillLoadingSettings,
+          enabledCodexOverleafSkillIds: submittedEnabledSkillIds,
+          enabledCodexLocalSkillIds: submittedEnabledLocalSkillIds,
           attachments: submittedAttachments,
           skillInvocation: submittedSkillInvocation,
           submittedMode
@@ -2022,6 +2348,25 @@
         fileOverlays = null;
         otWarmStart = false;
         restrictToFocusFiles = staleRetry.restrictToFocusFiles;
+        const retryFindings = await awaitRunStep(runSensitivePreflight({
+          task, project, rules: getGovernanceRulesForCurrentProject(), useExistingMirror: false
+        }));
+        if (retryFindings.blocked) {
+          await finalizeAuditRecord(runAuditDraft, {
+            resultStatus: 'blocked_sensitive', sensitiveFindings: retryFindings.findings,
+            blockedFiles: retryFindings.findings.map(finding => ({
+              path: finding.path || finding.source || 'task', reason: finding.detectorId || 'sensitive'
+            }))
+          });
+          await finishRunView(tx('Blocked: sensitive content review required', '已阻止：需要处理敏感内容'), 'failed');
+          return;
+        }
+        if (retryFindings.findings.length) {
+          sensitiveFindings = {
+            blocked: false, findings: [...sensitiveFindings.findings, ...retryFindings.findings]
+          };
+          runAuditDraft = await updateAuditSensitiveFindings(runAuditDraft, sensitiveFindings.findings);
+        }
         response = await awaitRunStep(sendTrackedCodexRun(buildCodexRunParams({
             task,
             project,
@@ -2034,6 +2379,8 @@
             compileLogContext,
             customInstructions: submittedCustomInstructions,
             skillLoadingSettings: submittedSkillLoadingSettings,
+            enabledCodexOverleafSkillIds: submittedEnabledSkillIds,
+            enabledCodexLocalSkillIds: submittedEnabledLocalSkillIds,
             attachments: submittedAttachments,
             skillInvocation: submittedSkillInvocation,
             submittedMode
@@ -2044,12 +2391,17 @@
         const userChoice = await showThreadResumeFailedPrompt();
         if (userChoice === 'new') {
           updateSessionById(runSessionId, { codexThreadId: '' });
+          renderContextUsage();
           const StorageDb = Modules.StorageDb;
-          if (StorageDb) {
-            const record = await StorageDb.getRecord('sessions', runSessionId);
+          // A live session goes through the ordinary writer. An envelope
+          // conflict there must not abort the run that is choosing a new thread.
+          if (findSessionById(runSessionId)) {
+            saveStateSoon();
+          } else if (StorageDb) {
+            const record = await StorageDb.getRecord('sessions', runSessionId, { adopt: false });
             if (record) {
               record.codexThreadId = '';
-              await StorageDb.putRecord('sessions', record);
+              await StorageDb.putRecord('sessions', record, { adopt: false });
             }
           }
           appendRunEvent({ title: tx('Creating a new Codex conversation thread.', '正在新建 Codex 会话线程。'), status: 'running' });
@@ -2065,6 +2417,8 @@
               compileLogContext,
               customInstructions: submittedCustomInstructions,
               skillLoadingSettings: submittedSkillLoadingSettings,
+              enabledCodexOverleafSkillIds: submittedEnabledSkillIds,
+              enabledCodexLocalSkillIds: submittedEnabledLocalSkillIds,
               attachments: submittedAttachments,
               skillInvocation: submittedSkillInvocation,
               submittedMode
@@ -2085,19 +2439,33 @@
           void finalizeAuditRecord(runAuditDraft, { resultStatus: 'cancelled' });
           return;
         }
-        const translated = translateRawError(response.error.message, { mode: submittedMode, locale: getLocale() });
+        if (response.error?.code === 'codex_local_skill_unavailable' && localSkillRestorePoint) {
+          restoreRejectedLocalSkillSubmission({ ...submittedWritingStyleScope, sessionId: submittedSessionId,
+            task: submittedDraft, attachments: submittedAttachments, skillInvocation: submittedSkillInvocation,
+            selectionContext: submittedPanelState.selectionContext }, localSkillRestorePoint);
+        }
+        const translated = translateRawError(response.error.message, { mode: submittedMode, locale: getLocale(), code: response.error?.code });
         // Structured FailureReason (§9.7): split bridge-availability from
         // Codex-side errors. `native_connection_failed` / `native_unavailable`
         // / `native_update_required` indicate the bridge itself is missing,
-        // so emit `native_bridge_unavailable` (blocked, retryable). All other
-        // native errors are treated as a Codex-side surface error and emit
-        // `codex_no_usable_result` (error, retryable).
+        // so emit `native_bridge_unavailable` (blocked, retryable). Recognized
+        // Codex failures retain their specific cause; only unmatched errors
+        // fall back to `codex_no_usable_result` (error, retryable).
         // Map native/codex failures onto their SPECIFIC catalog codes — the
         // timeout/not-found/output-limit entries (and their bilingual next
         // steps) existed but were never emitted, so everything collapsed into
         // "no usable result" and pointed users at the wrong recovery.
         const runErrorMessage = String(response.error?.message || '');
-        const codexRunFailure = response.error?.code === 'native_execution_interrupted'
+        const codexRunFailure = translated.failureCode === 'codex_context_limit'
+          ? buildContentFailure('codex_context_limit', { path: 'codex.run' }, {
+            technicalMessage: runErrorMessage,
+            evidence: { errorCode: response.error?.code || '' }
+          })
+          : response.error?.code === 'codex_local_skill_unavailable'
+          ? buildContentFailure('codex_local_skill_unavailable', { path: 'codex.run' }, { technicalMessage: runErrorMessage })
+          : translated.failureCode === 'codex_local_skills_failed'
+            ? buildContentFailure('codex_local_skills_failed', { path: 'codex.run' }, { technicalMessage: runErrorMessage })
+          : response.error?.code === 'native_execution_interrupted'
           ? buildContentFailure('native_request_failed', { path: 'codex.run' }, {
             // The host IS installed — the request was interrupted mid-flight.
             // Telling this user to reinstall would be a misdiagnosis.
@@ -2154,7 +2522,7 @@
           detail: response.error
         });
         appendCompletionReport({
-          conclusion: translated.conclusion,
+          conclusion: translated.conclusion, conclusionKey: translated.conclusionKey,
           status: response.error?.code === 'project_locked' ? 'blocked' : 'failed',
           operations: [],
           applyResults: [],
@@ -2204,7 +2572,7 @@
           status: 'failed',
           failure: emptyFailure
         });
-        appendCompletionReport({
+        appendCompletionReport({ conclusionKey: 'empty_result',
           conclusion: emptyResultConclusion,
           status: 'failed',
           operations: [],
@@ -2308,12 +2676,14 @@
         if (returnedThreadId && returnedThreadId !== codexThreadId) {
           updateSessionById(runSessionId, { codexThreadId: returnedThreadId });
           const StorageDb = Modules.StorageDb;
-          if (StorageDb) {
-            const record = await StorageDb.getRecord('sessions', runSessionId);
+          // The live session is saved below with its latest draft. Writing an
+          // older DB snapshot here can give stale text a newer timestamp.
+          if (StorageDb && !findSessionById(runSessionId)) {
+            const record = await StorageDb.getRecord('sessions', runSessionId, { adopt: false });
             if (record) {
               record.codexThreadId = returnedThreadId;
               record.updatedAt = new Date().toISOString();
-              await StorageDb.putRecord('sessions', record);
+              await StorageDb.putRecord('sessions', record, { adopt: false });
             }
           }
         }
@@ -2334,17 +2704,43 @@
       }
     } catch (error) {
       if (runCancellationRequested || isRunCancellationError(error)) {
-        appendRunCancelledReport();
+        if (currentRunView?.reviewingUnavailablePreflight) {
+          appendCompletionReport({ conclusionKey: 'launch_not_started',
+            conclusion: tx('This task did not start: Codex did not run and no files were written.', '这轮任务没有开始：Codex 没有运行，也没有写入文件。'),
+            status: 'blocked', operations: [], applyResults: [],
+            failure: buildContentFailure('reviewing_unavailable', {}, {
+              changedDocument: false, evidence: { declinedChoice: true }
+            }),
+            nextStep: tr('failureReason_reviewing_unavailable_cancelled_next') });
+        } else appendRunCancelledReport();
         await finishRunView(tx('Cancelled', '已取消'), 'cancelled');
         void finalizeAuditRecord(runAuditDraft, { resultStatus: 'cancelled' });
         return;
       }
+      if (compact) {
+        const key = error.code === 'codex_compact_unsupported' ? 'compactUnsupported'
+          : ['project_locked', 'codex_compact_thread_busy'].includes(error.code) ? 'compactBusy' : 'compactFailed';
+        const contextLimit = FailureReasons.isContextLimitError(error.message, error.code)
+          ? translateRawError(error.message, { locale: getLocale(), code: error.code }) : null;
+        const failure = contextLimit ? buildContentFailure('codex_context_limit', { path: 'codex.run' }, {
+          technicalMessage: error.message, evidence: { errorCode: error.code || '' }
+        }) : undefined;
+        const conclusion = contextLimit?.conclusion || tr(key);
+        appendRunEvent({ title: conclusion, status: 'failed', failure,
+          technicalDetail: { code: error.code || '', message: error.message } });
+        appendCompletionReport({ conclusion, conclusionKey: contextLimit?.conclusionKey || (key === 'compactUnsupported'
+          ? 'compact_unsupported' : key === 'compactBusy' ? 'compact_busy' : 'compact_failed'),
+          nextStep: contextLimit?.nextStep, failure,
+          status: 'failed', mode: 'ask', operations: [], applyResults: [] });
+        await finishRunView(conclusion, 'failed');
+        return;
+      }
       // codexReturned: assistantMessage arrived on the stream before the
       // exception escaped, so Codex's answer is preserved in the conversation
       // — the fallback conclusion must reflect that instead of saying
       // 'local Codex returned no usable result'.
       const codexReturned = Boolean(getAssistantAnswerForCurrentRun());
-      const translated = translateRawError(error.message, { mode: submittedMode, locale: getLocale(), codexReturned });
+      const translated = translateRawError(error.message, { mode: submittedMode, locale: getLocale(), code: error.code, codexReturned });
       // When translateRawError maps the raw error to a FailureReason code,
       // attach the structured failure to the run-event and completion-report
       // so the run record carries machine-readable failure data alongside
@@ -2372,7 +2768,7 @@
         }
       });
       appendCompletionReport({
-        conclusion: translated.conclusion,
+        conclusion: translated.conclusion, conclusionKey: translated.conclusionKey,
         status: 'failed',
         operations: [],
         applyResults: [],
@@ -2386,6 +2782,10 @@
         blockedFiles: [{ path: 'task', reason: error.message }]
       });
       await finishRunView(tx('Task failed', '任务失败'), 'failed');
+      // A failed initial card render must still leave a visible terminal record.
+      if (currentRunView?.sessionId === state.activeSessionId && !getCurrentRunViewForRender()) {
+        renderRunHistory({ preserveScroll: true });
+      }
     } finally {
       const settledView = currentRunView;
       const settledRecord = settledView ? findRunRecord(settledView.recordId, settledView.sessionId) : null;
@@ -2422,6 +2822,8 @@
     submittedMode,
     submittedCustomInstructions,
     submittedSkillLoadingSettings,
+    submittedEnabledLocalSkillIds,
+    submittedEnabledSkillIds,
     submittedAttachments,
     submittedSkillInvocation,
     executionSnapshot
@@ -2430,8 +2832,7 @@
       title: tx('Starting the Codex skill installer.', '正在启动 Codex skill installer。'),
       status: 'running'
     });
-    const activeSession = findSessionById(runSessionId) || getActiveSession(state);
-    const codexThreadId = activeSession?.codexThreadId || '';
+    const codexThreadId = currentRunView?.codexThreadId || '';
     const params = {
       projectId: getCurrentProjectId(),
       mode: submittedMode,
@@ -2439,21 +2840,24 @@
       model: executionSnapshot.model,
       reasoningEffort: executionSnapshot.reasoningEffort,
       speedTier: executionSnapshot.speedTier,
-      session: state.session,
+      session: currentRunView?.sessionContext,
+      locale: getLocale(),
+      clientRunId: currentRunView?.recordId || '',
+      clientSessionId: runSessionId,
+      accountScopeId: currentRunView?.runAccountScopeId || '',
       threadId: codexThreadId || undefined,
       customInstructions: submittedCustomInstructions || undefined,
       loadCodexLocalSkills: submittedSkillLoadingSettings?.loadCodexLocalSkills !== false,
       loadCodexOverleafSkills: submittedSkillLoadingSettings?.loadCodexOverleafSkills !== false,
+      enabledCodexLocalSkillIds: submittedEnabledLocalSkillIds,
+      enabledCodexOverleafSkillIds: submittedEnabledSkillIds,
       attachments: submittedAttachments.length ? submittedAttachments : undefined,
       skillInvocation: submittedSkillInvocation,
       focusFiles: [],
       skipMirrorSync: true
     };
 
-    const response = await sendNative({
-      method: 'codex.run',
-      params
-    });
+    const response = await sendTrackedCodexRun(params);
 
     if (!response.ok) {
       if (runCancellationRequested || isRunCancellationError(response.error)) {
@@ -2479,7 +2883,7 @@
         failure: translatedFailure
       });
       appendCompletionReport({
-        conclusion: translated.conclusion,
+        conclusion: translated.conclusion, conclusionKey: translated.conclusionKey,
         status: 'failed',
         operations: [],
         applyResults: [],
@@ -2497,7 +2901,7 @@
     }
 
     const assistantMessage = response.result?.assistantMessage || getAssistantAnswerForCurrentRun();
-    appendCompletionReport({
+    appendCompletionReport({ conclusionKey: !assistantMessage ? 'skill_installer_completed' : undefined,
       conclusion: assistantMessage || tx('Skill installer completed.', 'Skill installer 已完成。'),
       status: 'completed',
       operations: [],
@@ -2531,11 +2935,14 @@
     if (returnedThreadId && returnedThreadId !== codexThreadId) {
       updateSessionById(runSessionId, { codexThreadId: returnedThreadId });
       const StorageDb = Modules.StorageDb;
-      if (StorageDb) {
-        const record = await StorageDb.getRecord('sessions', runSessionId);
+      // The installer already finished; a later envelope conflict only delays this save.
+      if (findSessionById(runSessionId)) {
+        saveStateSoon();
+      } else if (StorageDb) {
+        const record = await StorageDb.getRecord('sessions', runSessionId, { adopt: false });
         if (record) {
           record.codexThreadId = returnedThreadId;
-          await StorageDb.putRecord('sessions', record);
+          await StorageDb.putRecord('sessions', record, { adopt: false });
         }
       }
     }
@@ -2549,8 +2956,6 @@
     if (mode === 'ask') {
       return { ok: true, skipped: true };
     }
-    const method = requireReviewing ? 'ensureReviewing' : 'ensureEditing';
-
     appendRunEvent({
       title: requireReviewing
         ? tx('Checking Overleaf Reviewing/Track Changes before starting.', '正在确认 Overleaf 留痕状态。')
@@ -2558,30 +2963,67 @@
       status: 'running'
     });
 
-    let result = null;
-    try {
-      // Thread runProjectId through so the page-bridge dispatcher applies the
-      // writeGuard. Without it, a mid-flight SPA navigation could leave the
-      // pre-flight ensureReviewing/Editing toggle landing in the wrong
-      // project — Track Changes flipped on/off in a project the user did
-      // not intend to write to.
-      result = await callPageBridge(method, {
-        waitMs: 1800,
-        runProjectId: currentRunView?.runProjectId || ''
-      });
-    } catch (error) {
-      result = {
-        ok: false,
-        reason: error?.message || (requireReviewing
-          ? tx('Overleaf did not return track changes status', 'Overleaf 没有返回留痕状态')
-          : tx('Overleaf did not return Editing mode status', 'Overleaf 没有返回 Editing 模式状态')),
-        reviewing: null
-      };
-    }
+    const owner = currentRunView;
+    const signal = runCancellationController?.signal;
+    const isCurrent = () => owner === currentRunView && !signal?.aborted && !runCancellationRequested
+      && owner?.runProjectId === getCurrentProjectId() && owner?.runAccountScopeId === cachedAccountScopeId;
+    const assertCurrent = () => { if (!isCurrent()) throw createRunCancellationError(); };
+    assertCurrent();
+    if (requireReviewing) {
+      // Another tab may have observed this project's capability since hydration.
+      const prefs = await Modules.StorageMigration.loadPrefs(owner.runAccountScopeId, owner.runProjectId);
+      assertCurrent();
+      const incoming = prefs?.reviewingAvailabilityByProject?.[owner.runProjectId];
+      const current = projectSettingsCoordinator.getReviewingAvailability();
+      if (incoming && (!current || incoming.observedAt > current.observedAt
+        || (incoming.observedAt === current.observedAt && incoming.status === 'available'))) {
+        state = { ...state, reviewingAvailabilityByProject: {
+          ...state.reviewingAvailabilityByProject, [owner.runProjectId]: incoming
+        } };
+        syncProbeStatus();
+      }
+    }
+    let result = await Modules.Reviewing.resolveWritePolicy({ requireReviewing,
+      knownUnavailable: isReviewingKnownUnavailable() }, {
+      assertCurrent,
+      ensureMode: async required => {
+        try {
+          return await callPageBridge(required ? 'ensureReviewing' : 'ensureEditing', {
+            waitMs: 1800, runProjectId: owner.runProjectId
+          });
+        } catch (error) {
+          assertCurrent();
+          return { ok: false, code: error?.code, reason: error?.message, reviewing: null };
+        }
+      },
+      observe: async (status, evidence) => {
+        projectSettingsCoordinator.observeReviewingAvailability(status, evidence);
+        syncProbeStatus();
+        // Publish a detected paywall before waiting for the user's decision.
+        if (status === 'unavailable') await flushQueuedSaveState({ requireDurable: true });
+        assertCurrent();
+      },
+      choose: () => {
+        owner.reviewingUnavailablePreflight = true;
+        return showPluginConfirm({
+          title: tr('reviewingUnavailableTitle'),
+          message: tr('reviewingUnavailableChoiceMessage'),
+          choices: [
+            { value: 'continue', label: tr('reviewingUnavailableContinue') },
+            { value: 'disable', label: tr('reviewingUnavailableDisable'), secondary: true },
+            { value: 'cancel', label: tr('confirmDefaultCancel') }
+          ],
+          signal, isCurrent, timeoutMs: REVIEWING_CONFIRM_TIMEOUT_MS
+        });
+      },
+      applyUntracked: choice => { assertCurrent(); return options.onUntracked(choice); }
+    });
+    if (result.ok) owner.reviewingUnavailablePreflight = false;
+    const effectiveRequireReviewing = result.requireReviewing ?? requireReviewing;
 
     if (result?.ok) {
       appendRunEvent({
-        title: requireReviewing
+        title: effectiveRequireReviewing
           ? (result.activated
             ? tx('Overleaf Reviewing/Track Changes is now on. Starting the task.', '已开启 Overleaf 留痕，开始处理任务。')
             : tx('Overleaf Reviewing/Track Changes is already on. Starting the task.', 'Overleaf 留痕已经开启，开始处理任务。'))
@@ -2593,10 +3035,23 @@
       return result;
     }
 
-    const reason = localizeVisibleReason(result?.reason || (requireReviewing
+    const unavailable = result?.code === 'reviewing_unavailable';
+    if (unavailable && !result.failure) result.failure = buildContentFailure('reviewing_unavailable', {}, {
+      changedDocument: false, evidence: result.evidence
+    });
+    const reason = unavailable ? tr('failureReason_reviewing_unavailable_user') : localizeVisibleReason(result?.reason || (effectiveRequireReviewing
       ? tx('Overleaf did not return track changes status', 'Overleaf 没有返回留痕状态')
       : tx('Overleaf did not return Editing mode status', 'Overleaf 没有返回 Editing 模式状态')));
-    const nextStep = requireReviewing
+    // Affirmative choices retain trackingDecision even if the Editing check fails.
+    const declinedReviewingChoice = owner.reviewingUnavailablePreflight === true && !result.trackingDecision;
+    const reportFailure = unavailable && declinedReviewingChoice
+      ? buildContentFailure('reviewing_unavailable', {}, {
+        ...result.failure, changedDocument: false,
+        evidence: { ...result.failure?.evidence, declinedChoice: true }
+      }) : result?.failure;
+    const nextStep = unavailable ? tr(declinedReviewingChoice
+      ? 'failureReason_reviewing_unavailable_cancelled_next'
+      : 'failureReason_reviewing_unavailable_next') : effectiveRequireReviewing
       ? tx(
         'You may not have permission, or this Overleaf page did not expose the Reviewing switch. Switch to Reviewing manually and retry, or turn off Track before writing.',
         '你可能没有权限，或 Overleaf 当前页面没有暴露切换入口。可以手动切到 Reviewing 后重试，或关闭“留痕”再运行。'
@@ -2606,7 +3061,7 @@
         '你可能没有权限，或 Overleaf 当前页面没有暴露切换入口。请在 Overleaf 手动切到 Editing 后重试。'
       );
     appendRunEvent({
-      title: requireReviewing
+      title: effectiveRequireReviewing
         ? tx('Task not started: could not enable Overleaf Reviewing/Track Changes.', '任务未开始：无法开启 Overleaf 留痕。')
         : tx('Task not started: could not switch to Overleaf Editing.', '任务未开始：无法切换到 Overleaf Editing。'),
       status: 'failed',
@@ -2615,24 +3070,25 @@
         [tr('detailNext')]: nextStep
       },
       technicalDetail: {
-        reason,
+        reason, code: result?.code, evidence: result?.evidence, failure: result?.failure,
         reviewing: result?.reviewing || null
       }
     });
-    appendCompletionReport({
+    appendCompletionReport({ conclusionKey: 'launch_not_started',
       conclusion: tx('This task did not start: Codex did not run and no files were written.', '这轮任务没有开始：Codex 没有运行，也没有写入文件。'),
       status: 'blocked',
       operations: [],
       applyResults: [],
-      nextStep
+      nextStep,
+      reason: result?.code, failure: reportFailure
     });
-    const finishTitle = requireReviewing
+    const finishTitle = effectiveRequireReviewing
       ? tx('Not started: could not enable Track Changes', '未开始：无法开启留痕')
       : tx('Not started: could not switch to Editing', '未开始：无法切换到 Editing');
     await finishRunView(finishTitle, 'failed');
     return {
-      ok: false,
-      reason,
+      ...result, ok: false,
+      reason: result?.code || reason,
       reviewing: result?.reviewing || null
     };
   }
@@ -2645,27 +3101,47 @@
     return runController.truncateSessionHistoryText(value, maxLength);
   }
 
-  function safeRunTask() {
+  function safeRunTask(options = {}) {
+    if (sessionManager.isTransitioning()) return;
     if (updateIdleClient?.isApplying()) {
       showPluginToast(tx('An update is being applied. Codex will be available again after reload.', '正在应用更新，重新加载后即可继续使用 Codex。'), { status: 'info' });
       return;
     }
+    const submittedCompactCommand = options.operation !== 'compact'
+      && panel?.querySelector('[data-task]')?.value.trim() === '/compact';
+    const compact = options.operation === 'compact' || submittedCompactCommand;
+    if (compact && (currentRunView || runSubmissionPending)) {
+      showPluginToast(tr('compactBusy'), { status: 'info' });
+      return;
+    }
     if (currentRunView) {
       return queueComposerInput();
     }
-    runTask().catch(error => {
-      setRunning(false);
-      nativeChannel.clearActiveRequest();
-      stopRunElapsedTick();
-      currentRunView = null;
-      runCancellationController = null;
+    if (runSubmissionPending) return;
+    runSubmissionPending = true;
+    runTask(compact ? { operation: 'compact', consumeCompactDraft: options.consumeCompactDraft === true || submittedCompactCommand } : {}).catch(error => {
+      if (!currentRunView) {
+        setRunning(false);
+        nativeChannel.clearActiveRequest();
+        stopRunElapsedTick();
+        runCancellationController = null;
+      }
       console.error('[codex-overleaf] failed to start task', error);
-      appendPlainLog(tx(`Could not start Codex task: ${error.message}`, `无法启动 Codex 任务：${error.message}`));
-    });
+      appendPlainLog(tx(`Could not start Codex task: ${localizeVisibleReason(error.message)}`, `无法启动 Codex 任务：${localizeVisibleReason(error.message)}`));
+    }).finally(() => { runSubmissionPending = false; });
   }
 
   const runGuidanceController = Modules.RunGuidanceController.create({
-    findRunRecord, appendRunEvent, getCurrentRunView: () => currentRunView,
+    findRunRecord, getCurrentRunView: () => getCurrentRunViewForRender(),
+    getActiveSessionId: () => state?.activeSessionId,
+    getScope: () => ({ accountScopeId: cachedAccountScopeId, projectId: getCurrentProjectId(), generation: spaRouteGeneration }),
+    getSessionCreatedAt: sessionId => findSessionById(sessionId)?.createdAt,
+    getRunRoot: target => target.sessionId === state?.activeSessionId
+      ? panel?.querySelector(`[data-run-id="${cssEscape(target.recordId)}"]`) : null,
+    onRecordChanged: target => updateSessionById(target.sessionId, {}),
+    onPresentationError: error => console.warn('[codex-overleaf] guidance presentation failed', error),
+    RunGuidanceView: Modules.RunGuidanceView, tx, maxRunEvents: MAX_RUN_EVENTS,
+    revealGuidance: row => runTimelineView.revealGuidance(row),
     renderRunEvent, cssEscape, bumpUnreadIfDetached
   });
 
@@ -2675,17 +3151,27 @@
       getActiveSession: () => getActiveSession(state),
       setQueue: (sessionId, pendingInputs) => updateSessionById(sessionId, { pendingInputs }),
       getCurrentRun: () => currentRunView,
-      canStart: sessionId => state?.activeSessionId === sessionId && isProjectEditorRoute(window.location),
+      canStart: canStartQueuedSession,
       readInputs: readPanelInputs,
       getTask: () => panel?.querySelector('[data-task]')?.value || '',
       hasAttachments: () => getComposerAttachmentsForRun().length > 0,
-      capturePayload: () => RunExecutionSnapshot.toQueuePayload(captureCurrentExecutionSnapshot()),
+      capturePayload: () => ({
+        ...RunExecutionSnapshot.toQueuePayload(captureCurrentExecutionSnapshot()),
+        submissionContext: RunInputQueue.normalizeSubmissionContext({
+          customInstructions: getCustomInstructionsForCurrentProject(),
+          skillLoadingSettings: getSkillLoadingSettings(),
+          skillInvocation: getComposerSkillInvocationForRun(),
+          enabledCodexOverleafSkillIds: getEnabledCodexOverleafSkillIds(),
+          enabledCodexLocalSkillIds: getEnabledCodexLocalSkillIds()
+        })
+      }),
       prepareClaim: () => providerSettingsCoordinator.ensureLoaded(),
       resolveExecutionSnapshot: snapshot => RunExecutionSnapshot.resolveForExecution(snapshot, {
         catalog: providerSettingsCoordinator.getCatalog()
       }),
       clearTask: () => {
         panel.querySelector('[data-task]').value = '';
+        composerDraftEditedHere = false;
         selectionContextView.clear();
         updateSessionById(state.activeSessionId, { task: '' });
         autosizeTaskTextarea();
@@ -2696,12 +3182,22 @@
           RunExecutionSnapshot.fromQueuePayload(item.payload),
           { catalog: providerSettingsCoordinator.getCatalog() }
         );
+        // Promotion uses its captured snapshot; this line still describes the current draft.
+        syncProbeStatus();
       },
       run: item => runTask({ queuedInput: item }),
-      sendSteer: params => sendBackgroundNative({ method: 'codex.steer', params }),
+      getGuideScope: () => ({ projectId: getCurrentProjectId(), accountScopeId: cachedAccountScopeId, generation: spaRouteGeneration }),
+      isGuideCancelled: () => runCancellationRequested || runCancellationController?.signal?.aborted === true,
+      preflightGuide: ({ task, assertCurrent }) => runSensitivePreflight({
+        task, project: { files: [] }, rules: getGovernanceRulesForCurrentProject(),
+        guidance: true, useExistingMirror: false, assertCurrent
+      }),
+      sendSteer: (params, context) => nativeCompatibilityController.sendBackgroundNative({ method: 'codex.steer', params }, context),
       getContainer: () => panel?.querySelector('[data-pending-inputs]'),
       createView: options => PendingInputView.create(options),
       appendEvent: (title, status) => appendRunEvent({ title, status }),
+      previewGuidance: runGuidanceController.preview,
+      clearGuidancePreview: runGuidanceController.clearPreview,
       appendGuidance: runGuidanceController.upsert,
       removeGuidance: runGuidanceController.remove,
       toast: (message, status) => showPluginToast(message, { status }),
@@ -2740,7 +3236,29 @@
     });
   }
 
+  function canStartQueuedSession(sessionId) {
+    if (state?.activeSessionId !== sessionId || !isProjectEditorRoute(window.location)) return false;
+    if (sessionManager.isTransitioning()) {
+      deferredSessionStart = { sessionId, scope: getComposerDraftScope() };
+      return false;
+    }
+    return true;
+  }
+
   function queueComposerInput() {
+    if (sessionManager.isTransitioning()) return;
+    if (getSkillLoadingSettings().loadCodexLocalSkills !== false && !Array.isArray(getCodexLocalSkillsCatalog())) {
+      primeCodexLocalSkillsCatalog({ required: true }).catch(() => {});
+      showPluginToast(tx('Local Codex skills are still loading. Try submitting again when loading finishes.',
+        'Codex 本地技能仍在加载，请在加载完成后重新提交。'), { status: 'info' });
+      return;
+    }
+    const invocation = getComposerSkillInvocationForRun();
+    if (invocation?.scope === 'codex-local' && !getEnabledCodexLocalSkillIds()?.includes(invocation.id)) {
+      showPluginToast(tx('The selected local Codex skill is unavailable or disabled. Select an enabled skill and try again.',
+        '所选 Codex 本地技能不可用或已关闭，请选择已启用的技能后重试。'), { status: 'failed' });
+      return;
+    }
     return runInputCoordinator?.queueComposerInput();
   }
 
@@ -2790,7 +3308,7 @@
       const nativeResult = results[0];
       const nativeResponse = nativeResult?.status === 'fulfilled' ? nativeResult.value : null;
       if (nativeResponse && !nativeResponse.ok) {
-        const message = nativeResponse?.error?.message || tx('native host did not respond', 'native host 没有响应');
+        const message = localizeVisibleReason(nativeResponse?.error?.message || tx('native host did not respond', 'native host 没有响应'));
         appendRunEvent({
           title: tx(`Cancel request was not delivered: ${message}`, `中断请求没有送达：${message}`),
           status: 'failed'
@@ -2832,25 +3350,8 @@
         force: true
       }
     });
-    if (response?.ok) {
-      const result = response.result || response;
-      const released = result.lockReleased === true || result.cancelled === true;
-      appendPlainLog(released
-        ? tx(
-          `Force-released the stuck Codex run for project ${projectKey}. You can retry now.`,
-          `已强制释放项目 ${projectKey} 的 Codex 占用，可以重试了。`
-        )
-        : tx(
-          `No stuck run was found for project ${projectKey}.`,
-          `没有发现项目 ${projectKey} 上的卡住任务。`
-        ));
-      return response;
-    }
-    const message = response?.error?.message || tx('native host did not respond', 'native host 没有响应');
-    appendPlainLog(tx(
-      `Force-release request was not delivered: ${message}`,
-      `强制释放请求没有送达：${message}`
-    ));
+    appendPlainLog(Modules.RunRecoveryActions.formatForceCancelOutcome(response, tx));
+    if (response?.ok !== true && response?.error?.message) appendPlainLog(localizeVisibleReason(response.error.message));
     return response;
   }
 
@@ -2954,6 +3455,12 @@
       .filter(id => id && isCodexOverleafSkillEnabled(id));
   }
 
+  function getEnabledCodexLocalSkillIds() {
+    if (getSkillLoadingSettings().loadCodexLocalSkills === false) return [];
+    const skills = getCodexLocalSkillsCatalog();
+    return Array.isArray(skills) ? skills.filter(skill => isCodexLocalSkillEnabled(skill.id, skill)).map(skill => skill.id) : undefined;
+  }
+
   function buildCodexRunParams({
     task,
     project,
@@ -2966,15 +3473,20 @@
     compileLogContext,
     customInstructions,
     skillLoadingSettings,
+    enabledCodexOverleafSkillIds,
+    enabledCodexLocalSkillIds,
     attachments,
     skillInvocation,
     submittedMode
   } = {}) {
     const executionSnapshot = currentRunView?.executionSnapshot || captureCurrentExecutionSnapshot();
-    const submittedState = RunExecutionSnapshot.applyToState(state, executionSnapshot);
+    const submittedState = RunExecutionSnapshot.applyToState({
+      ...state, session: currentRunView?.sessionContext || state.session
+    }, executionSnapshot);
     const params = runController.buildCodexRunParams({
       currentProjectId: getCurrentProjectId(),
       state: submittedState,
+      locale: getLocale(),
       task,
       project,
       useExistingMirror,
@@ -2991,7 +3503,9 @@
           ? getSkillLoadingSettings()
           : { loadCodexLocalSkills: true, loadCodexOverleafSkills: true })
         : skillLoadingSettings,
-      enabledCodexOverleafSkillIds: getEnabledCodexOverleafSkillIds(),
+      enabledCodexOverleafSkillIds: enabledCodexOverleafSkillIds === undefined
+        ? getEnabledCodexOverleafSkillIds() : enabledCodexOverleafSkillIds,
+      enabledCodexLocalSkillIds,
       attachments,
       skillInvocation,
       compileLogContext,
@@ -3009,11 +3523,26 @@
   }
 
   async function sendTrackedCodexRun(params) {
-    const compatibilityGate = await nativeCompatibilityController.ensureForMethod('codex.run');
+    const owner = currentRunView;
+    const signal = runCancellationController?.signal;
+    const assertCurrent = () => {
+      if (signal?.aborted || (owner && owner !== currentRunView)) throw createRunCancellationError();
+      throwIfRunCancellationRequested();
+      if (owner && (owner.runProjectId !== getCurrentProjectId()
+        || owner.runAccountScopeId !== cachedAccountScopeId)) {
+        throw Object.assign(createRunCancellationError(), {
+          message: 'The active project or account changed before dispatch.'
+        });
+      }
+    };
+    const compatibilityGate = await nativeCompatibilityController.ensureForMethod('codex.run', { assertCurrent });
+    assertCurrent();
     if (!compatibilityGate.ok) {
       return compatibilityGate.response;
     }
-    throwIfRunCancellationRequested();
+    if (params.operation === 'compact' && compatibilityGate.compatibility?.native?.capabilities?.threadCompact !== true) {
+      return { ok: false, error: { code: 'codex_compact_unsupported', message: 'This Native host does not support context compaction.' } };
+    }
     const tracked = nativeChannel.sendNativeTracked(nativeCompatibilityController.attachEvidence({
       method: 'codex.run',
       params
@@ -3041,57 +3570,44 @@
   }
 
   async function recoverInterruptedRunJournals() {
-    const projectKey = getCurrentProjectId();
+    const projectKey = getCurrentProjectId(), accountScopeId = cachedAccountScopeId;
+    const generation = spaRouteGeneration;
+    const isCurrent = () => generation === spaRouteGeneration
+      && projectKey === getCurrentProjectId() && accountScopeId === cachedAccountScopeId;
     const recovery = await activeTurnControl.recoverJournals({
       projectKey,
+      accountScopeId,
+      isCurrent,
+      onRecheck: async () => {
+        if (!isCurrent()) return;
+        await recoverInterruptedRunJournals();
+        if (isCurrent()) applyStateToPanel();
+      },
       requireOwnerLost: Modules.StorageDb.sharedSessionsEnabled?.() === true,
       normalizeInterruptedRun: record => Object.assign(record, Modules.SessionState.normalizeRuns([record], {
         restoreRunningRuns: true,
         locale: getLocale()
       })[0]),
       findSession: findSessionById,
+      listSessions: () => state?.sessions || [],
+      isLiveRun: (record, session) => currentRunView?.recordId === record.id
+        && currentRunView.sessionId === session.id && currentRunView.runProjectId === projectKey,
       getActiveSession: () => getActiveSession(state),
-      createInterruptedRun: journal => ({
-          id: journal.clientRunId,
-          task: journal.task || 'interrupted task',
-          mode: journal.mode || 'ask',
-          model: journal.model || '',
-          status: 'interrupted',
-          statusText: tr('restoredRunStoppedStatus'),
-          runProjectId: projectKey,
-          startedAt: journal.createdAt || new Date().toISOString(),
-          finishedAt: journal.updatedAt || new Date().toISOString(),
-          events: [],
-          attachments: [],
-          undoOperations: [],
-          undoTrackedChanges: [],
-          undoExpectedFiles: []
+      createInterruptedRun: journal => ActiveTurnControl.createInterruptedRun(journal, projectKey, tr('restoredRunStoppedStatus')),
+      onRawEvent: (raw, { record, session, sequence }) => storeContextUsage(raw, record, session, sequence),
+      mapEvent: (raw, journal) => ActiveTurnControl.mapRecoveredEvent(raw, journal, {
+        mapActivity: value => mapAgentEventToActivity(value, { locale: getLocale() }),
+        sanitizeText: sanitizeAssistantVisibleText, sanitizeValue: sanitizeAssistantVisibleValue
       }),
-      mapEvent: (raw, journal) => {
-        const activity = mapAgentEventToActivity(raw, { locale: getLocale() });
-        if (!activity?.visible || activity.kind === 'technical') {
-          return null;
-        }
-        return {
-          kind: activity.kind || 'activity',
-          title: sanitizeAssistantVisibleText(activity.title) || 'Event',
-          status: activity.status || 'running',
-          detail: sanitizeAssistantVisibleValue(activity.detail),
-          timestamp: raw.timestamp || journal.updatedAt || new Date().toISOString(),
-          streamKey: sanitizeAssistantVisibleText(activity.streamKey),
-          streamRole: sanitizeAssistantVisibleText(activity.streamRole),
-          appendText: sanitizeAssistantVisibleText(activity.appendText),
-          replaceText: activity.replaceText
-        };
-      },
       upsertStream: upsertRunStreamRecordEvent,
       pauseSessionQueue: (session, reason) => {
         session.pendingInputs = RunInputQueue.pauseAll(session.pendingInputs || [], reason);
       },
       maxEvents: MAX_RUN_EVENTS
     });
+    if (!isCurrent()) return;
     if (recovery.changed) {
-      await saveState();
+      if (await saveState({ recoveryRuns: recovery.recoveredRuns }) !== true || !isCurrent()) return;
       for (const requestId of recovery.acknowledgeIds) {
         await activeTurnControl.acknowledge(requestId).catch(() => false);
       }
@@ -3103,14 +3619,21 @@
     if (!StorageDb || !AuditRecords) {
       return null;
     }
+    // Audit follows the captured run owner even if the visible page changes.
+    // Missing owner identity must never be filled with a later account.
+    const accountScopeId = currentRunView ? currentRunView.runAccountScopeId : cachedAccountScopeId;
+    const projectId = currentRunView ? currentRunView.runProjectId : getCurrentProjectId();
+    if (!accountScopeId || !projectId) return null;
     const executionSnapshot = input.executionSnapshot
       || currentRunView?.executionSnapshot
       || captureCurrentExecutionSnapshot();
     const draft = AuditRecords.buildAuditDraftRecord({
-      projectId: getCurrentProjectId(),
+      accountScopeId,
+      projectId,
       sessionId: input.sessionId || '',
       turnId: currentRunView?.recordId || '',
       mode: input.mode || executionSnapshot.mode,
+      requireReviewing: executionSnapshot.requireReviewing,
       ...providerSettingsCoordinator.getProviderSnapshot(executionSnapshot.providerId),
       providerRevision: executionSnapshot.providerRevision,
       model: executionSnapshot.model,
@@ -3142,8 +3665,10 @@
       return draft;
     }
     const record = StorageDb.buildAuditLogRecord
-      ? StorageDb.buildAuditLogRecord({ ...draft, ...updates, id: draft.id, completedAt: updates.completedAt || draft.completedAt || '' })
-      : { ...draft, ...updates };
+      ? StorageDb.buildAuditLogRecord({ ...draft, ...updates, id: draft.id,
+        accountScopeId: draft.accountScopeId, projectId: draft.projectId,
+        completedAt: updates.completedAt || draft.completedAt || '' })
+      : { ...draft, ...updates, id: draft.id, accountScopeId: draft.accountScopeId, projectId: draft.projectId };
     return StorageDb.putRecord('auditLogs', record).then(() => record).catch(() => draft);
   }
 
@@ -3173,121 +3698,10 @@
   }
 
   async function runSensitivePreflight(options) {
-    options = options || {};
-    const { task, project, rules, useExistingMirror = false } = options;
-    const normalizedRules = normalizeGovernanceRules(rules);
-    if (normalizedRules.sensitiveCheckEnabled === false) {
-      return { blocked: false, findings: [] };
-    }
-    if (!SensitiveScan?.scanSensitiveInputs && !useExistingMirror) {
-      return { blocked: false, findings: [] };
-    }
-    let findings = SensitiveScan?.scanSensitiveInputs
-      ? SensitiveScan.scanSensitiveInputs({
-        task,
-        files: (project?.files || []).filter(isTextSnapshotFile)
-      })
-      : [];
-    if (useExistingMirror) {
-      findings = dedupeSensitiveFindings([
-        ...findings,
-        ...await scanNativeMirrorSensitiveFindings()
-      ]);
-    }
-    if (!findings.length) {
-      return { blocked: false, findings: [] };
-    }
-    appendRunEvent({
-      title: tx(
-        `Sensitive content check found ${findings.length} item(s).`,
-        `敏感内容检查发现 ${findings.length} 项。`
-      ),
-      status: 'failed',
-      detail: findings.slice(0, 8).map(finding => ({
-        [tr('detailFile')]: finding.path || finding.source || 'task',
-        [tr('detailReason')]: finding.detectorId,
-        [tx('Preview', '预览')]: finding.preview || '[REDACTED]'
-      }))
-    });
-    if (normalizedRules.sensitiveConfirmAllowed === true) {
-      const approved = await showPluginConfirm({
-        title: tr('sensitiveConfirmTitle'),
-        message: formatSensitiveConfirmMessage(findings),
-        confirmLabel: tr('sensitiveConfirmRun'),
-        cancelLabel: tr('confirmDefaultCancel'),
-        destructive: true
-      });
-      return { blocked: !approved, findings };
-    }
-    appendCompletionReport({
-      conclusion: tx(
-        'This run was blocked before Codex received project context because sensitive content was detected.',
-        '检测到敏感内容，本轮已在向 Codex 发送项目上下文前阻止。'
-      ),
-      status: 'blocked',
-      operations: [],
-      applyResults: [],
-      nextStep: tx(
-        'Remove the sensitive content, narrow @context, or enable explicit sensitive confirmation in Project Settings.',
-        '请移除敏感内容、缩小 @context，或在项目设置里允许敏感内容显式确认。'
-      )
-    });
-    return { blocked: true, findings };
-  }
-
-  function formatSensitiveConfirmMessage(findings = []) {
-    const visible = findings.slice(0, 8).map(finding => {
-      const path = finding.path || finding.source || 'task';
-      return `${path}: ${finding.detectorId || 'sensitive'} (${finding.preview || '[REDACTED]'})`;
-    });
-    return [
-      tr('sensitiveConfirmMessage'),
-      '',
-      ...visible,
-      findings.length > visible.length ? tx(`${findings.length - visible.length} more finding(s).`, `另有 ${findings.length - visible.length} 项。`) : ''
-    ].filter(Boolean).join('\n');
-  }
-
-  async function scanNativeMirrorSensitiveFindings() {
-    try {
-      const response = await sendBackgroundNative({
-        method: 'mirror.scanSensitive',
-        params: { projectId: getCurrentProjectId() }
-      });
-      if (response?.ok) {
-        return Array.isArray(response.result?.findings) ? response.result.findings : [];
-      }
-      return [{
-        detectorId: 'mirror-sensitive-scan-unavailable',
-        source: 'local-mirror',
-        preview: response?.error?.message || 'Could not scan the local mirror before Codex runs.'
-      }];
-    } catch (error) {
-      return [{
-        detectorId: 'mirror-sensitive-scan-unavailable',
-        source: 'local-mirror',
-        preview: error?.message || 'Could not scan the local mirror before Codex runs.'
-      }];
-    }
-  }
-
-  function dedupeSensitiveFindings(findings = []) {
-    const seen = new Set();
-    const deduped = [];
-    for (const finding of findings || []) {
-      const key = [
-        finding?.detectorId || '',
-        finding?.source || '',
-        finding?.path || '',
-        finding?.preview || ''
-      ].join('\u0000');
-      if (seen.has(key)) {
-        continue;
-      }
-      seen.add(key);
-      deduped.push(finding);
-    }
-    return deduped;
+    return Modules.SensitivePreflight.create({
+      SensitiveScan, normalizeGovernanceRules, isTextSnapshotFile, sendBackgroundNative,
+      getCurrentProjectId, appendRunEvent, appendCompletionReport, showPluginConfirm, tr, tx
+    }).run(options);
   }
 
   function appendRunCancelledReport() {
@@ -3298,7 +3712,7 @@
       status: 'info',
       activity: { v: 1, kind: 'lifecycle', state: 'cancelled', target: 'cancelled' }
     });
-    appendCompletionReport({
+    appendCompletionReport({ conclusionKey: 'cancelled',
       conclusion: tx('This run was cancelled. It did not continue syncing or writing to Overleaf.', '这轮已中断，没有继续同步或写入 Overleaf。'),
       status: 'cancelled',
       operations: [],
@@ -3327,7 +3741,8 @@
     const running = typeof runningOverride === 'boolean'
       ? runningOverride
       : Boolean(currentRunView);
-    const action = running && !hasInput ? 'cancel' : 'send';
+    const transitioning = sessionManager.isTransitioning();
+    const action = running && (!hasInput || transitioning) ? 'cancel' : 'send';
     const label = action === 'cancel'
       ? tr('cancelRun')
       : running
@@ -3336,13 +3751,17 @@
     runButton.dataset.action = action;
     runButton.disabled = action === 'cancel'
       ? runCancellationRequested
-      : !hasInput;
+      : !hasInput || transitioning;
     runButton.title = label;
     runButton.setAttribute('aria-label', label);
-    if (currentRunView?.writebackRetry && hasInput) runButton.disabled = true;
+    if (currentRunView?.writebackRetry && hasInput && action !== 'cancel') runButton.disabled = true;
   }
 
   function handleTaskInputKeydown(event) {
+    if (sessionManager.isTransitioning()) {
+      if (event.key === 'Enter' && !event.isComposing && event.keyCode !== 229) event.preventDefault();
+      return;
+    }
     if (handleSlashMenuKeydown(event)) {
       return;
     }
@@ -3354,6 +3773,7 @@
   }
 
   function handleTaskInput() {
+    composerDraftRevision += 1;
     autosizeTaskTextarea();
     syncComposerSendAvailability();
     renderPendingInputs();
@@ -3369,17 +3789,18 @@
 
   function getSlashCommands() {
     const commands = [
+      { id: 'compact', kind: 'compact', group: 'commands', title: tr('slashCompactTitle'), slug: '/compact',
+        subtitle: tr('slashCompactSubtitle') },
       {
         id: 'install-skill',
         kind: 'installer',
+        group: 'commands',
         title: tr('slashInstallSkillTitle'),
         subtitle: tr('slashInstallSkillSubtitle')
       }
     ];
-    if (getSkillLoadingSettings().loadCodexOverleafSkills === false) {
-      return commands;
-    }
-    for (const skill of slashCodexOverleafSkills) {
+    const settings = getSkillLoadingSettings();
+    for (const skill of settings.loadCodexOverleafSkills === false ? [] : slashCodexOverleafSkills) {
       const id = String(skill?.id || '').trim();
       if (!isSafeSkillId(id)) {
         continue;
@@ -3392,16 +3813,34 @@
       commands.push({
         id: `skill:${id}`,
         kind: 'codex-overleaf-skill',
+        group: 'overleaf',
         scope: 'codex-overleaf',
         skillId: id,
         title,
-        subtitle: tr('slashUseSkillSubtitle')
+        subtitle: tr('slashUseOverleafSkillSubtitle')
       });
     }
+    const localSkills = settings.loadCodexLocalSkills === false ? [] : (getCodexLocalSkillsCatalog() || []);
+    for (const skill of localSkills) {
+      if (!isSafeSkillId(skill.id) || !isCodexLocalSkillEnabled(skill.id, skill)) continue;
+      const sameName = localSkills.filter(other => String(other.title || other.name || other.id) === String(skill.title || skill.name || skill.id)).length > 1;
+      // Source and duplicate hints lead so a truncated preview cannot hide them.
+      commands.push({ id: `local-skill:${skill.id}`, kind: 'codex-local-skill', group: 'local', scope: 'codex-local', skillId: skill.id,
+        title: String(skill.title || skill.name || skill.id).trim().slice(0, 80),
+        searchName: String(skill.name || ''),
+        subtitle: [skill.sourceKind === 'plugin' && skill.sourceLabel ? skill.sourceLabel : '',
+          sameName ? skill.sourceHint || skill.id.slice(-8) : '',
+          String(skill.preview || '').trim() || tr('slashUseLocalSkillSubtitle')].filter(Boolean).join(' · ') });
+    }
     return commands;
   }
 
   async function refreshCodexOverleafSkillsForSlashMenu() {
+    if (getSlashTrigger() && getSkillLoadingSettings().loadCodexLocalSkills !== false) {
+      primeCodexLocalSkillsCatalog().catch(() => {
+        showPluginToast(tx('Could not load local Codex skills. Try again.', '无法加载 Codex 本地技能，请重试。'), { status: 'failed' });
+      });
+    }
     if (slashCodexOverleafSkillsLoaded || slashCodexOverleafSkillsLoading) {
       return;
     }
@@ -3435,9 +3874,10 @@
       const commands = getSlashCommands().filter(command => {
         return !query
           || command.title.toLowerCase().includes(query)
-          || command.id.toLowerCase().includes(query);
+          || command.id.toLowerCase().includes(query)
+          || String(command.searchName || '').toLowerCase().includes(query);
       });
-      renderSlashMenu(commands);
+      renderSlashMenu(commands, { query });
       return;
     }
     const atTrigger = getAtFileTrigger();
@@ -3535,7 +3975,7 @@
       closeSlashMenu();
       return;
     }
-    renderSlashMenu(entries);
+    renderSlashMenu(entries, { query });
   }
 
   // Lazy one-shot load: the tray's file list is usually warm (panel open
@@ -3618,7 +4058,22 @@
     };
   }
 
-  function renderSlashMenu(commands = []) {
+  const SLASH_MENU_GROUPS = { commands: 'slashGroupCommands', overleaf: 'slashGroupOverleafSkills', local: 'slashGroupLocalSkills' };
+  const SLASH_MENU_ICONS = { compact: 'compact', installer: 'install', 'codex-overleaf-skill': 'book', 'codex-local-skill': 'terminal' };
+
+  function appendHighlightedText(node, value, query) {
+    const text = String(value || '');
+    const at = query ? text.toLowerCase().indexOf(query) : -1;
+    if (at < 0) {
+      node.append(text);
+      return;
+    }
+    const mark = document.createElement('mark');
+    mark.textContent = text.slice(at, at + query.length);
+    node.append(text.slice(0, at), mark, text.slice(at + query.length));
+  }
+
+  function renderSlashMenu(commands = [], { query = '' } = {}) {
     const menu = panel?.querySelector('[data-slash-menu]');
     if (!menu) {
       return;
@@ -3628,7 +4083,17 @@
       menu.hidden = true;
       return;
     }
+    const usage = commands.some(command => command.kind === 'compact') ? getContextUsageDisplay().usage : null;
+    const percent = usage?.contextWindow > 0 ? usage.usedTokens / usage.contextWindow * 100 : null;
+    let group = '';
     commands.forEach((command, index) => {
+      if (command.group && command.group !== group) {
+        group = command.group;
+        const label = document.createElement('div');
+        label.className = 'codex-slash-menu-group';
+        label.textContent = tr(SLASH_MENU_GROUPS[group]);
+        menu.append(label);
+      }
       const button = document.createElement('button');
       button.type = 'button';
       button.dataset.slashCommand = command.id;
@@ -3640,16 +4105,58 @@
         button.dataset.slashSkillScope = command.scope;
       }
       button.dataset.active = index === 0 ? 'true' : 'false';
+      const icon = document.createElement('span');
+      icon.className = 'codex-slash-menu-icon';
+      icon.innerHTML = Modules.PanelIcons.svg(SLASH_MENU_ICONS[command.kind] || 'file');
+      const text = document.createElement('span');
+      text.className = 'codex-slash-menu-text';
       const title = document.createElement('span');
-      title.textContent = command.title;
+      title.className = 'codex-slash-menu-title';
+      appendHighlightedText(title, command.title, query);
+      if (command.slug) {
+        const slug = document.createElement('code');
+        appendHighlightedText(slug, command.slug, query);
+        title.append(slug);
+      }
       const subtitle = document.createElement('small');
       subtitle.textContent = command.subtitle;
-      button.append(title, subtitle);
+      subtitle.title = command.subtitle;
+      text.append(title, subtitle);
+      button.append(icon, text);
+      if (command.kind === 'compact' && percent !== null) {
+        const meta = document.createElement('span');
+        meta.className = 'codex-slash-menu-meta';
+        meta.dataset.level = Modules.ContextUsage.level(percent);
+        meta.title = tr('contextUsageTitle');
+        meta.textContent = new Intl.NumberFormat(getLocale() === 'zh' ? 'zh-CN' : 'en-US', { maximumFractionDigits: 0 }).format(percent) + '%';
+        button.append(meta);
+      }
       menu.append(button);
     });
+    const foot = document.createElement('div');
+    foot.className = 'codex-slash-menu-foot';
+    foot.dataset.slashMenuFoot = '';
+    for (const [keys, label] of [[['↑', '↓'], 'slashKeyMove'], [['Enter'], 'slashKeyRun'], [['Esc'], 'slashKeyClose']]) {
+      const hint = document.createElement('span');
+      for (const key of keys) hint.append(Object.assign(document.createElement('kbd'), { textContent: key }));
+      hint.append(tr(label));
+      foot.append(hint);
+    }
+    menu.append(foot);
     renderedSlashCommands = new Map(commands.map(command => [command.id, command]));
     menu.dataset.activeIndex = '0';
     menu.hidden = false;
+    menu.scrollTop = 0;
+    updateSlashMenuLayout();
+  }
+
+  function updateSlashMenuLayout() {
+    const menu = panel?.querySelector('[data-slash-menu]');
+    const composer = panel?.querySelector('[data-composer-form]');
+    if (!menu || menu.hidden || !composer) return;
+    const visibleTop = Math.max(0, root.visualViewport?.offsetTop || 0, panel.getBoundingClientRect().top);
+    const available = Math.max(0, Math.floor(composer.getBoundingClientRect().top - visibleTop - 12));
+    menu.style.setProperty('--codex-slash-menu-space', `${available}px`);
   }
 
   function handleSlashMenuClick(event) {
@@ -3708,9 +4215,28 @@
     buttons.forEach((button, buttonIndex) => {
       button.dataset.active = buttonIndex === index ? 'true' : 'false';
     });
+    const active = buttons[index];
+    if (!active || !menu.clientHeight) return;
+    // Wrapping to the first item also reveals its group label.
+    if (index === 0) {
+      menu.scrollTop = 0;
+      return;
+    }
+    const viewport = menu.getBoundingClientRect();
+    const item = active.getBoundingClientRect();
+    const top = viewport.top + menu.clientTop;
+    // The sticky key-hint footer covers the bottom of the scroll area.
+    const bottom = top + menu.clientHeight - (menu.querySelector('[data-slash-menu-foot]')?.offsetHeight || 0);
+    // Scroll only this popup; scrollIntoView may move the chat or editor too.
+    if (item.height > menu.clientHeight || item.top < top) {
+      menu.scrollTop += item.top - top;
+    } else if (item.bottom > bottom) {
+      menu.scrollTop += item.bottom - bottom;
+    }
   }
 
   function selectSlashCommand(commandId) {
+    if (sessionManager.isTransitioning()) return;
     const command = renderedSlashCommands.get(commandId);
     if (!command) {
       closeSlashMenu();
@@ -3723,13 +4249,18 @@
       applyAtFileSelection(command);
       return;
     }
+    if (command.kind === 'compact') {
+      closeSlashMenu();
+      safeRunTask({ operation: 'compact', consumeCompactDraft: true });
+      return;
+    }
     clearSlashTriggerFromTaskInput();
     closeSlashMenu();
     if (command.kind === 'installer') {
       activateSkillInstallerComposerContext();
       return;
     }
-    if (command.kind === 'codex-overleaf-skill') {
+    if (command.kind === 'codex-overleaf-skill' || command.kind === 'codex-local-skill') {
       activateCodexOverleafSkillComposerContext(command);
     }
   }
@@ -3756,6 +4287,7 @@
   }
 
   function activateSkillInstallerComposerContext() {
+    composerDraftRevision += 1;
     composerSkillInvocation = {
       id: 'skill-installer',
       title: tr('skillInstallerComposerLabel')
@@ -3766,6 +4298,7 @@
   }
 
   function activateCodexOverleafSkillComposerContext(command) {
+    composerDraftRevision += 1;
     const id = String(command?.skillId || '').trim();
     if (!isSafeSkillId(id)) {
       return;
@@ -3773,7 +4306,7 @@
     composerSkillInvocation = {
       id,
       title: String(command?.title || id).trim().slice(0, 80) || id,
-      scope: 'codex-overleaf'
+      scope: command.scope === 'codex-local' ? 'codex-local' : 'codex-overleaf'
     };
     renderComposerSkillInvocation();
     const input = panel?.querySelector('[data-task]');
@@ -3781,6 +4314,7 @@
   }
 
   function clearComposerSkillInvocation() {
+    composerDraftRevision += 1;
     composerSkillInvocation = null;
     renderComposerSkillInvocation();
     panel?.querySelector('[data-task]')?.focus?.();
@@ -3791,7 +4325,7 @@
     if (!normalized) {
       return null;
     }
-    if (normalized.id === 'skill-installer') {
+    if (normalized.id === 'skill-installer' && !normalized.scope) {
       return {
         id: 'skill-installer',
         title: tr('skillInstallerComposerLabel')
@@ -3806,13 +4340,9 @@
       return null;
     }
     const title = String(value?.title || id).trim().slice(0, 80) || id;
-    if (id === 'skill-installer') {
-      return { id, title };
-    }
-    if (value?.scope !== 'codex-overleaf') {
-      return null;
-    }
-    return { id, title, scope: 'codex-overleaf' };
+    if (id === 'skill-installer' && (!value?.scope || value.scope === 'builtin')) return { id, title };
+    if (!['codex-overleaf', 'codex-local'].includes(value?.scope)) return null;
+    return { id, title, scope: value.scope };
   }
 
   function isSafeSkillId(id) {
@@ -3833,7 +4363,7 @@
     }
     const clear = context.querySelector('[data-composer-skill-clear]');
     if (clear) {
-      const clearLabel = active?.id === 'skill-installer'
+      const clearLabel = active?.id === 'skill-installer' && !active.scope
         ? tr('skillInstallerComposerClear')
         : tr('composerSkillClear');
       clear.title = clearLabel;
@@ -3996,18 +4526,17 @@
   // it from cross-project queries (spec §5.2 storage rules).
   window.codexOverleafDeriveAccountScopeId = () => cachedAccountScopeId;
   var sharedSessionViewSync = Modules.SharedSessionViewSync.install({
-    Bridge: Modules.SharedSessionBridge,
-    StorageDb: Modules.StorageDb,
-    getScope: () => ({
-      accountScopeId: cachedAccountScopeId,
-      projectId: getCurrentProjectId(),
-      generation: spaRouteGeneration
-    }),
-    getState: () => state,
-    isBusy: () => Boolean(readLiveRunViewForSaveStateGuard() || document.querySelector('dialog[open]')),
-    apply: sessions => {
-      state = normalizePanelState({ ...state, sessions }, { restoreRunningRuns: false });
+    Bridge: Modules.SharedSessionBridge, StorageDb: Modules.StorageDb,
+    getScope: () => ({ accountScopeId: cachedAccountScopeId, projectId: getCurrentProjectId(), generation: spaRouteGeneration }),
+    getState: () => state, setState: next => { state = next; },
+    // An in-flight Accept/Undo keeps its view until it settles; refresh applies afterwards.
+    isBusy: () => Boolean(pendingDraftSave || readLiveRunViewForSaveStateGuard() || trackedChangeInFlight.size
+      || runReviewController?.hasActiveReview?.() || document.querySelector('dialog[open]')),
+    hasLocalDraft: current => Boolean(current.task) && composerDraftEditedHere,
+    normalize: normalizePanelState,
+    render: () => {
       applyStateToPanel();
+      composerDraftEditedHere = false;
     },
     notice: error => appendStorageNoticeOnce('shared-history-refresh', tx(
       `Could not refresh shared history: ${error.message}`,
@@ -4092,7 +4621,7 @@
       chromeApi: chrome, getState: () => state, setState: next => { state = next; }, getPanel: () => panel,
       applyTheme: applyPanelTheme, applyLocale: () => { applyLocaleToPanel(); refreshDashboardSoon(); },
       onPreloadChange: enabled => contextTrayController.scheduleContextPrefetch({ enabled }),
-      onSkillsChange: () => { renderLocalSkillList(); updateSkillsEntrySummary(); },
+      onSkillsChange: () => { renderLocalSkillList(); updateSkillsEntrySummary(); updateSlashMenuForTaskInput(); },
       onError: error => showPluginToast(tx(
         `Global settings could not be saved or loaded: ${error.message}. Please retry.`,
         `全局设置未能保存或读取：${error.message}。请重试。`), { status: 'failed', sticky: true })
@@ -4108,6 +4637,8 @@
       storageKey = getProjectStorageKey(LEGACY_STORAGE_KEY, window.location.href);
       const reloaded = await loadStoredState();
       state = normalizeLoadedPanelState(reloaded);
+      composerDraftEditedHere = false;
+      await getRunReviewController().recoverInterruptedUndoStatuses();
       applyStateToPanel();
     } catch (_error) {
       // Reload failures fall back to the in-memory state; the next saveState
@@ -4169,6 +4700,8 @@
   function leaveActiveProject(newId) {
     const prevId = activeProjectId;
     activeProjectId = newId; // null for non-project URLs (spec §5.7.1)
+    if (prevId !== newId) composerDraftEditedHere = false;
+    getComposerDraftPersistence().syncScope();
     if (!prevId || prevId === newId) {
       return;
     }
@@ -4194,7 +4727,15 @@
   }
 
   async function onSpaRouteChange() {
+    // Snapshot the departing draft before hydration replaces state. The detached
+    // writer retains its original account/project and never reads the new view's attachments.
+    if (pendingDraftSave?.projectId === activeProjectId
+      && pendingDraftSave?.accountScopeId === cachedAccountScopeId) {
+      void saveState({ draftScope: pendingDraftSave });
+    }
+    resetDraftSave();
     const generation = ++spaRouteGeneration;
+    activeTurnControl.cancelRecovery();
     const url = new URL(window.location.href);
     const pathname = url.pathname;
     const previousProjectId = activeProjectId;
@@ -4209,6 +4750,7 @@
     // project derivation: account menu is global chrome and should be
     // readable on per-project URLs too).
     await refreshAccountScopeId();
+    getComposerDraftPersistence().syncScope();
     if (generation !== spaRouteGeneration || pathname !== window.location.pathname) {
       return;
     }
@@ -4417,7 +4959,7 @@
         operations: [],
         status: tr('modeAsk')
       });
-      appendCompletionReport({
+      appendCompletionReport({ conclusionKey: !notes ? 'ask_inspected' : undefined,
         conclusion: notes || tx('This run only inspected and explained; no files were written.', '这轮只做了检查和说明，没有写入文件。'),
         status: tr('modeAsk'),
         notes,
@@ -4437,7 +4979,7 @@
       const applied = await applyTaskOperations(project, operations);
       applyResults.push(applied);
       appendApplyResult(applied);
-      recordUndoFromApply(project, applied);
+      await recordUndoFromApply(project, applied);
       const approved = await showPluginConfirm({
         title: tx('Confirm delete plan?', '确认删除计划？'),
         message: formatDeletePlan(result.deletePlan || []),
@@ -4451,7 +4993,7 @@
         const deleteApplied = await applyTaskOperations(project, pendingOperations, { allowHighRisk: true });
         applyResults.push(deleteApplied);
         appendApplyResult(deleteApplied);
-        recordUndoFromApply(project, deleteApplied);
+        await recordUndoFromApply(project, deleteApplied);
         appendLog(tx('Deleted files after confirmation.', '已按确认删除文件。'));
         const summaryLine = appendChangeSummary({
           notes,
@@ -4459,7 +5001,7 @@
           applyResults,
           status: 'applied with delete plan'
         });
-        appendCompletionReport({
+        appendCompletionReport({ conclusionKey: !notes ? 'delete_handled' : undefined,
           conclusion: notes || tx('Changes were written, and delete items were handled after your confirmation.', '已写入修改，并按你的确认处理删除项。'),
           status: 'applied with delete plan',
           notes,
@@ -4482,7 +5024,7 @@
         status: 'applied without deletes',
         deletePlanRejected: true
       });
-      appendCompletionReport({
+      appendCompletionReport({ conclusionKey: 'delete_rejected',
         conclusion: tx('Non-delete changes were kept; delete items were not written.', '已保留非删除修改；删除项没有写入。'),
         status: 'applied without deletes',
         notes,
@@ -4504,7 +5046,7 @@
     appendOperationsPreview(operations, tx('Preparing to write', '准备写入'));
     const applied = await applyTaskOperations(project, operations);
     appendApplyResult(applied);
-    recordUndoFromApply(project, applied);
+    await recordUndoFromApply(project, applied);
     appendLog(mode === 'auto' ? tx('Auto write task completed.', '自动写入任务完成。') : tx('Task completed.', '任务完成。'));
     const summaryLine = appendChangeSummary({
       notes,
@@ -4512,7 +5054,7 @@
       applyResults: [applied],
       status: result.status || 'completed'
     });
-    appendCompletionReport({
+    appendCompletionReport({ conclusionKey: !notes ? 'run_complete' : undefined,
       conclusion: notes || tx('This run is complete.', '这轮任务已完成。'),
       status: result.status || 'completed',
       notes,
@@ -4529,6 +5071,7 @@
   }
 
   async function applyTaskOperations(project, operations, options = {}) {
+    const target = currentRunView;
     const runRequireReviewing = typeof options.requireReviewing === 'boolean'
       ? options.requireReviewing
       : state.requireReviewing === true;
@@ -4538,7 +5081,13 @@
         title: tr('undoNoWritesTitle'),
         status: 'completed'
       });
-    } else {
+    }
+    const reviewing = await ensureReviewingBeforeWrite(partitioned.safe, { requireReviewing: runRequireReviewing });
+    if (!reviewing.ok) {
+      return buildReviewingBlockedApplyResult(partitioned.safe, reviewing, partitioned.skipped);
+    }
+    if (partitioned.safe.length) await stageWritebackRecovery(partitioned.safe, target, runRequireReviewing, project);
+    if (partitioned.safe.length) {
       appendRunEvent({
         title: tx('Saved a recoverable version before this run writes.', '已保存本轮写入前的可恢复版本。'),
         status: 'completed',
@@ -4547,10 +5096,7 @@
         }
       });
     }
-    const reviewing = await ensureReviewingBeforeWrite(partitioned.safe, { requireReviewing: runRequireReviewing });
-    if (!reviewing.ok) {
-      return buildReviewingBlockedApplyResult(partitioned.safe, reviewing, partitioned.skipped);
-    }
+
     const applied = partitioned.safe.length
       ? await callPageBridge('applyOperations', {
         operations: partitioned.safe,
@@ -4558,7 +5104,7 @@
         requireReviewing: runRequireReviewing,
         requireEditing: !runRequireReviewing,
         // Welcome-panel + write-guard:
-        runProjectId: currentRunView?.runProjectId || ''
+        runProjectId: target?.runProjectId || ''
       })
       : { ok: true, applied: [], skipped: [] };
 
@@ -4590,10 +5136,19 @@
     // Thread runProjectId so the page-side dispatcher gates the toggle. Same
     // intent as the pre-flight check above: do not flip Track Changes /
     // Editing in a different project than the run is bound to.
+    const owner = currentRunView;
     const result = await callPageBridge(method, {
       waitMs: 1800,
       runProjectId: currentRunView?.runProjectId || ''
     });
+    throwIfRunCancellationRequested();
+    if (owner && (owner !== currentRunView || owner.runProjectId !== getCurrentProjectId()
+      || owner.runAccountScopeId !== cachedAccountScopeId)) throw createRunCancellationError();
+    if (requireReviewing && (result?.ok || result?.code === 'reviewing_unavailable')) {
+      projectSettingsCoordinator.observeReviewingAvailability(result.ok ? 'available' : 'unavailable',
+        result.ok ? 'reviewing_confirmed' : 'upgrade_modal');
+      syncProbeStatus();
+    }
     if (result?.ok) {
       appendRunEvent({
         title: requireReviewing
@@ -4625,6 +5180,7 @@
       code: result?.code || (requireReviewing ? 'reviewing_not_enabled' : 'editing_not_confirmed'),
       reason: result?.reason || (requireReviewing ? 'Reviewing/Track Changes was not enabled' : 'Editing mode was not confirmed'),
       reviewing: result?.reviewing || null,
+      evidence: result?.evidence, failure: result?.failure,
       requireReviewing
     };
   }
@@ -4639,8 +5195,9 @@
           operation,
           result: {
             ok: false,
-            code: blockedByEditing ? 'editing_not_confirmed' : 'reviewing_not_enabled',
-            reason: blockedByEditing
+            code: reviewing?.code || (blockedByEditing ? 'editing_not_confirmed' : 'reviewing_not_enabled'),
+            evidence: reviewing?.evidence, failure: reviewing?.failure,
+            reason: reviewing?.code === 'reviewing_unavailable' ? tr('failureReason_reviewing_unavailable_user') : blockedByEditing
               ? tx(
                 'Track is off, but Overleaf Editing mode was not verified before writing. Codex did not write this file.',
                 '已关闭“留痕”，但写入前没有确认 Overleaf 正在用 Editing 模式。Codex 没有写入这个文件。'
@@ -4694,13 +5251,13 @@
 
   async function refreshProbe(options = {}) {
     const projectId = getCurrentProjectId();
+    const accountScopeId = cachedAccountScopeId;
     const userInitiated = options.userInitiated === true;
     if (userInitiated) {
       setRefreshProbeLoading(true);
       const status = panel?.querySelector('[data-probe-status]');
       if (status) {
-        status.textContent = tr('refreshProbeLoading');
-        status.dataset.ok = 'false';
+        renderProbeStatusMessage(status, tr('refreshProbeLoading'));
         status.dataset.refreshing = 'true';
       }
     }
@@ -4710,13 +5267,14 @@
         manualOverride: state?.requireReviewing === false
       });
       if (projectId !== getCurrentProjectId()) return null;
+      if (accountScopeId !== cachedAccountScopeId) return null;
+      if (probe.capabilities?.reviewing?.confirmed === true) {
+        projectSettingsCoordinator.observeReviewingAvailability('available', 'reviewing_confirmed');
+      }
       probeStatusSnapshot = { projectId, probe, userInitiated };
       const status = panel?.querySelector('[data-probe-status]');
       if (status) {
-        status.textContent = userInitiated
-          ? tr('refreshProbeDone', { status: formatProbeStatusBar(probe) })
-          : formatProbeStatusBar(probe);
-        status.dataset.ok = isProbeReadyForCurrentMode(probe) ? 'true' : 'false';
+        renderProbeStatusLine(status, probe, { refreshed: userInitiated });
         status.dataset.refreshing = 'false';
       }
       if (!options.quiet && !userInitiated) {
@@ -4733,8 +5291,7 @@
       probeStatusSnapshot = { projectId, failed: true };
       const status = panel?.querySelector('[data-probe-status]');
       if (status) {
-        status.textContent = tr('refreshProbeFailed');
-        status.dataset.ok = 'false';
+        renderProbeStatusMessage(status, tr('refreshProbeFailed'), 'warn');
         status.dataset.refreshing = 'false';
       }
       console.warn('[codex-overleaf] refresh probe failed', error);
@@ -4754,23 +5311,81 @@
     button.dataset.loading = loading ? 'true' : 'false';
     button.disabled = Boolean(loading);
     button.setAttribute('aria-busy', loading ? 'true' : 'false');
+    setElementTitleAndAria('[data-refresh]', tr(loading ? 'refreshProbeLoading' : 'refreshProbe'),
+      tr(loading ? 'refreshProbeLoading' : 'refreshProbeTitle'));
   }
 
   function syncProbeStatus(mode = state?.mode) {
     const status = panel?.querySelector('[data-probe-status]');
     if (!status) return;
     if (status.dataset.refreshing === 'true') {
-      status.textContent = tr('refreshProbeLoading');
+      renderProbeStatusMessage(status, tr('refreshProbeLoading'));
       return;
     }
     if (probeStatusSnapshot?.projectId !== getCurrentProjectId()) return;
     const { failed, probe, userInitiated } = probeStatusSnapshot;
-    const text = failed ? tr('refreshProbeFailed') : formatProbeStatusBar(probe, mode);
-    status.textContent = userInitiated && !failed ? tr('refreshProbeDone', { status: text }) : text;
-    status.dataset.ok = !failed && isProbeReadyForCurrentMode(probe, mode) ? 'true' : 'false';
+    if (failed) renderProbeStatusMessage(status, tr('refreshProbeFailed'), 'warn');
+    else renderProbeStatusLine(status, probe, { refreshed: userInitiated });
     if (!failed) updateExistingProbeNotice(probe, mode);
   }
 
+  // Keep the read scope visible; a known Track limitation adds its own warning segment.
+  function getProbeScope(probe) {
+    const selection = selectionContextView.capture();
+    const focusFiles = getActiveFocusFiles();
+    // Match submission priority: an edit selection, then explicit focus files,
+    // then reference context, ahead of the editor's implicit current-file hint.
+    if (selection?.mode === 'edit') return { icon: 'file', key: 'probeScopeSelection' };
+    if (focusFiles.some(file => /\.tex$/i.test(file))) return { icon: 'file', key: 'probeScopeFiles' };
+    if (focusFiles.length || selection) return { icon: 'attach', key: 'probeScopeContext' };
+    if (getProbeRunReadiness(probe).editorOk) return { icon: 'file', key: 'probeScopeCurrentFile' };
+    return { icon: 'folder', key: 'probeScopeProject' };
+  }
+
+  function isReviewingKnownUnavailable() {
+    return Modules.Reviewing.knownUnavailable(projectSettingsCoordinator.getReviewingAvailability());
+  }
+
+  function syncReviewingTooltip() {
+    const toggle = panel?.querySelector('[data-require-reviewing]');
+    const title = tr(isReviewingKnownUnavailable() ? 'reviewingUnavailableTooltip' : 'requireReviewingTitle');
+    if (toggle) toggle.title = title;
+    const label = toggle?.closest('.codex-review-toggle');
+    if (label) label.title = title;
+  }
+
+  function renderProbeStatusLine(status, probe, options = {}) {
+    const scope = getProbeScope(probe);
+    const parts = [];
+    if (options.refreshed) parts.push(tr('refreshProbeDone', { status: '' }).trim());
+    const label = document.createElement('span');
+    label.className = 'codex-probe-scope';
+    label.innerHTML = Modules.PanelIcons?.svg?.(scope.icon) || ''; // Static, repository-owned icon path.
+    label.append(tr(scope.key));
+    parts.push(label);
+    if (isExperimentalOtEnabled()) {
+      const separator = document.createElement('span');
+      separator.className = 'codex-probe-sep';
+      separator.textContent = '·';
+      parts.push(separator, 'OT ' + formatOtStatusLabel(getCurrentOtStatus()));
+    }
+    if (state.requireReviewing && isReviewingKnownUnavailable()) {
+      const warning = document.createElement('span');
+      warning.dataset.tone = 'warn';
+      warning.textContent = ' · ' + tr('reviewingUnavailableStatus');
+      parts.push(warning);
+    }
+    syncReviewingTooltip();
+    status.replaceChildren(...parts);
+    delete status.dataset.tone;
+  }
+
+  function renderProbeStatusMessage(status, text, tone = '') {
+    status.replaceChildren(text);
+    if (tone) status.dataset.tone = tone;
+    else delete status.dataset.tone;
+  }
+
   function formatProbeStatusBar(probe, mode = state?.mode) {
     const readiness = getProbeRunReadiness(probe);
     const reviewingOk = readiness.reviewingOk;
@@ -4804,17 +5419,7 @@
     if (!status || status.dataset.refreshing === 'true') {
       return;
     }
-    const text = String(status.textContent || '');
-    if (!text) {
-      return;
-    }
-    const base = text.split(' · OT ')[0];
-    status.textContent = appendOtStatusToProbeStatus(base);
-  }
-
-  function isProbeReadyForCurrentMode(probe, mode = state?.mode) {
-    const readiness = getProbeRunReadiness(probe);
-    return mode === 'ask' || readiness.reviewingOk;
+    syncProbeStatus();
   }
 
   function getProbeRunReadiness(probe) {
@@ -4919,8 +5524,8 @@
         ready: true,
         message: manualOverride
           ? tx(
-            `Ready: you confirmed Overleaf Track Changes is on. Codex ${readiness.contextLabel}.`,
-            `可以运行：你已确认 Overleaf 已开启留痕，Codex ${readiness.contextLabel}。`
+            `Ready: Codex writes without tracked changes and ${readiness.contextLabel}.`,
+            `可以运行：Codex 写入时不使用留痕，并且${readiness.contextLabel}。`
           )
           : tx(
             `Ready: Codex verified Overleaf Reviewing/Track Changes is on and ${readiness.contextLabel}.`,
@@ -4929,21 +5534,13 @@
       };
     }
 
-    if (readiness.contextReady) {
-      return {
-        ready: false,
-        message: tx(
-          `Not safe to write yet: Codex ${readiness.contextLabel}, but Overleaf Reviewing/Track Changes was not verified. Turn on Reviewing first, or disable Track below.`,
-          `还不能安全写入：Codex ${readiness.contextLabel}，但没有确认 Overleaf 已开启 Reviewing/Track Changes。请先打开 Reviewing，或关闭下方的安全检查。`
-        )
-      };
-    }
-
+    // ensureReviewingBeforeWrite switches Overleaf to Reviewing before the first
+    // write and blocks the write only if that cannot be confirmed.
     return {
-      ready: false,
+      ready: true,
       message: tx(
-        'Not safe to write yet: turn on Overleaf Reviewing/Track Changes first. Codex will read the whole project at run time; you can also use @file to focus on specific files.',
-        '还不能安全写入：请先在 Overleaf 打开 Reviewing/Track Changes；Codex 会在运行时读取整个项目，也可以用 @file 指定重点文件。'
+        `Ready: Codex ${readiness.contextLabel} and will switch Overleaf to Reviewing/Track Changes before writing.`,
+        `可以运行：Codex ${readiness.contextLabel}，写入前会把 Overleaf 切到 Reviewing/Track Changes。`
       )
     };
   }
@@ -4962,7 +5559,7 @@
       focusFiles: getActiveFocusFiles()
     });
     const sanitizedProject = sanitizeRunProjectSnapshot(project);
-    if (sanitizedProject?.capabilities?.fullProjectSnapshot) {
+    if (sanitizedProject?.capabilities?.fullProjectSnapshot || sanitizedProject?.capabilities?.pathIdentityComplete === false) {
       return sanitizedProject;
     }
     const pageStateProject = await callPageBridge('getProjectSnapshot', {
@@ -4983,25 +5580,37 @@
   }
 
   function sanitizeRunProjectSnapshot(project) {
-    if (!project || typeof project !== 'object') {
-      return project;
-    }
-    const activePath = normalizeSnapshotPath(project.activePath || '');
+    if (!project || typeof project !== 'object') return project;
+    const normalize = Modules.ProjectFiles.normalizeSafeProjectPath;
     const files = Array.isArray(project.files) ? project.files : [];
-    const filePathSet = new Set(files.map(file => normalizeSnapshotPath(file?.path || '')).filter(Boolean));
-    const activePathKnown = activePath && filePathSet.has(activePath);
-    if (!activePath || activePathKnown) {
-      return project;
+    const counts = new Map();
+    for (const file of files) {
+      const path = normalize(file?.path);
+      if (path) counts.set(path, (counts.get(path) || 0) + 1);
     }
+    const skipped = [];
+    const safeFiles = files.filter(file => {
+      const path = normalize(file?.path);
+      if (path && counts.get(path) === 1) return true;
+      skipped.push({ path: typeof file?.path === 'string' ? file.path : '',
+        reason: path ? 'snapshot_path_duplicate' : 'snapshot_path_invalid' });
+      return false;
+    });
+    const activePath = normalize(project.activePath || '');
+    const activePathKnown = activePath && safeFiles.some(file => file.path === activePath);
+    const rejectActive = Boolean(project.activePath && !activePathKnown);
+    if (!skipped.length && !rejectActive) return project;
     return {
       ...project,
-      activePath: '',
-      files: files.map(file => file?.active ? { ...file, active: false } : file),
+      activePath: rejectActive ? '' : project.activePath,
+      files: safeFiles.map(file => rejectActive && file?.active ? { ...file, active: false } : file),
       capabilities: {
         ...(project.capabilities || {}),
+        ...(skipped.length ? { fullProjectSnapshot: false, contentComplete: false, pathIdentityComplete: false,
+          skipped: [...(project.capabilities?.skipped || []), ...skipped] } : {}),
         diagnostics: {
           ...(project.capabilities?.diagnostics || {}),
-          rejectedActivePath: project.activePath
+          ...(rejectActive ? { rejectedActivePath: project.activePath } : {})
         }
       }
     };
@@ -5087,11 +5696,8 @@
   }
 
   function normalizeSnapshotPath(path) {
-    return String(path || '')
-      .replace(/^@file:/i, '')
-      .replace(/\\/g, '/')
-      .trim()
-      .replace(/^\/+/, '');
+    // Snapshot/overlay/focus arrays already carry canonical names from file chips.
+    return Modules.ProjectFiles.normalizeSafeProjectPath(path);
   }
 
   function mergeProjectWithSyncChangeBaseFiles(project = {}, syncChanges = []) {
@@ -5303,8 +5909,10 @@
         legacyKey,
         accountScopeId
       );
+      const composerAttachments = await loadComposerAttachmentsForProject(accountScopeId, projectId);
 
       return {
+        composerAttachments,
         model: prefs.model || '', providerId: prefs.providerId || 'builtin',
         reasoningEffort: prefs.reasoningEffort || '',
         speedTier: prefs.speedTier || '',
@@ -5316,8 +5924,10 @@
         loadCodexLocalSkills: prefs.loadCodexLocalSkills !== false,
         loadCodexOverleafSkills: prefs.loadCodexOverleafSkills !== false,
         codexOverleafSkillEnabled: prefs.codexOverleafSkillEnabled || {},
+        codexLocalSkillEnabled: prefs.codexLocalSkillEnabled || {},
         experimentalOtByProject: prefs.experimentalOtByProject || {},
         customInstructionsByProject: prefs.customInstructionsByProject || {},
+        reviewingAvailabilityByProject: prefs.reviewingAvailabilityByProject || {},
         governanceRulesByProject: normalizeGovernanceRulesByProject(prefs.governanceRulesByProject),
         panelWidth: prefs.panelWidth || PANEL_DEFAULT_WIDTH,
         sessions: sessions.map(session => ({
@@ -5328,6 +5938,9 @@
           focusFiles: session.focusFiles || [], selectionContext: session.selectionContext?.projectId === projectId ? session.selectionContext : null,
           projectReferenceFiles: session.projectReferenceFiles || [],
           codexThreadId: session.codexThreadId || '',
+          contextUsage: session.contextUsage || null,
+          forkedFromSessionId: session.forkedFromSessionId || '',
+          forkedFromRunId: session.forkedFromRunId || '',
           createdAt: session.createdAt,
           updatedAt: session.updatedAt,
           runs: Array.isArray(session.runs) ? session.runs : [],
@@ -5368,8 +5981,10 @@
           loadCodexLocalSkills: fallback.loadCodexLocalSkills !== false,
           loadCodexOverleafSkills: fallback.loadCodexOverleafSkills !== false,
           codexOverleafSkillEnabled: fallback.codexOverleafSkillEnabled || {},
+          codexLocalSkillEnabled: fallback.codexLocalSkillEnabled || {},
           experimentalOtByProject: fallback.experimentalOtByProject || {},
           customInstructionsByProject: fallback.customInstructionsByProject || {},
+          reviewingAvailabilityByProject: fallback.reviewingAvailabilityByProject || {},
           governanceRulesByProject: normalizeGovernanceRulesByProject(fallback.governanceRulesByProject),
           panelWidth: fallback.panelWidth || PANEL_DEFAULT_WIDTH,
           sessions: [],
@@ -5401,30 +6016,15 @@
     try {
       const StorageDb = Modules.StorageDb;
       const Migration = Modules.StorageMigration;
-      // Welcome-panel + write-guard:
-      // post-navigation persistence gate. The normal URL-derived projectId
-      // belongs to the route the user is *currently looking at*. When a run
-      // is in flight on a different project (mid-run SPA navigation), saving
-      // under that URL-derived id would pollute another project's Recent-
-      // projects entry and surface bogus disabled rows. Two safety lanes:
-      //   1. `options.projectIdOverride` lets a caller that legitimately
-      //      needs to persist to a non-active project supply the projectId
-      //      explicitly (the only such caller today is the post-navigation
-      //      settlement path in `persistPostNavigationRunStatus`, which goes
-      //      directly through StorageDb — but the override is in place so
-      //      future callers do not have to monkey-patch around saveState).
-      //   2. When no override is set AND a navigation-divergent run is in
-      //      flight (currentRunView.runProjectId !== URL-derived id), log a
-      //      warning and skip persistence. The settlement path owns that
-      //      run's persistence; routing through saveState would write to the
-      //      WRONG projectId record.
-      const projectIdOverride = options && typeof options.projectIdOverride === 'string'
-        ? options.projectIdOverride
-        : '';
+      // Settlement owns a run after navigation away from its project. Ordinary
+      // view saves must not write that run into the current route's project.
+      // An explicit override is reserved for callers that own a detached scope.
+      const projectIdOverride = options?.draftScope?.projectId || (options && typeof options.projectIdOverride === 'string'
+        ? options.projectIdOverride : '');
       const urlProjectId = getCurrentProjectId();
       const projectId = projectIdOverride || urlProjectId;
       if (!projectId) {
-        if (options?.reviewRunIds?.length) throw new Error('Review persistence lost its project.'); return;
+        if (options?.requireDurable || options?.reviewRunIds?.length) throw new Error('Persistence lost its project.'); return;
       }
       // Read currentRunView through a defensive accessor so historical test
       // harnesses that inline `saveState` without re-declaring the module-
@@ -5436,28 +6036,41 @@
           'Skipped saveState: run is in flight on a different project than the current URL; settlement owns persistence.',
           '已跳过 saveState：本次运行所属项目与当前 URL 不一致，写回由 settlement 负责。'
         ));
-        if (options?.reviewRunIds?.length) throw new Error('Review persistence project changed.'); return;
+        if (options?.requireDurable || options?.reviewRunIds?.length) throw new Error('Persistence project changed.'); return;
       }
+      const savedDraft = !projectIdOverride && pendingDraftSave?.scope === getComposerDraftScope()
+        ? pendingDraftSave : null;
       const compactState = prepareStateForStorage(state, { onAggressive: notifyAggressiveCompactionOnce });
       compactState.autoRecompile = state.autoRecompile;
       compactState.loadCodexLocalSkills = state.loadCodexLocalSkills !== false;
       compactState.loadCodexOverleafSkills = state.loadCodexOverleafSkills !== false;
       compactState.codexOverleafSkillEnabled = getCodexOverleafSkillEnabled();
+      compactState.codexLocalSkillEnabled = getCodexLocalSkillEnabled();
       compactState.experimentalOtByProject = state.experimentalOtByProject;
       compactState.customInstructionsByProject = state.customInstructionsByProject;
+      compactState.reviewingAvailabilityByProject = state.reviewingAvailabilityByProject;
       compactState.governanceRulesByProject = state.governanceRulesByProject;
       const stateSnapshot = typeof structuredClone === 'function'
         ? structuredClone(state)
         : JSON.parse(JSON.stringify(state));
+      // Keep consumption provenance on the live run owner across ordinary
+      // session normalization; it is not a composer edit or a queued input.
+      const consumedSession = liveRunView?.draftConsumption && liveRunView.runProjectId === projectId
+        && liveRunView.runAccountScopeId === cachedAccountScopeId
+        ? stateSnapshot.sessions?.find(session => session.id === liveRunView.sessionId) : null;
+      if (consumedSession?.task === '') consumedSession.draftConsumption = { ...liveRunView.draftConsumption };
       const compactStateSnapshot = typeof structuredClone === 'function'
         ? structuredClone(compactState)
         : JSON.parse(JSON.stringify(compactState));
 
-      const persistScopedState = persistenceContext => Modules.ScopedPersistenceCoordinator.persistPanelState({
+      const retentionScope = { accountScopeId: typeof cachedAccountScopeId === 'string' ? cachedAccountScopeId : '', projectId, generation: typeof spaRouteGeneration === 'number' ? spaRouteGeneration : null };
+      let written;
+      const persistScopedState = async persistenceContext => {
+        written = await Modules.ScopedPersistenceCoordinator.persistPanelState({
         state: stateSnapshot,
         compactState: compactStateSnapshot,
         projectId,
-        deletedSessionIds: options?.deletedSessionIds, reviewRunIds: options?.reviewRunIds,
+        deletedSessionIds: options?.deletedSessionIds, reviewRunIds: options?.reviewRunIds, recoveryRuns: options?.recoveryRuns,
         Migration,
         StorageDb,
         SessionPersistence: Modules.SessionPersistence,
@@ -5465,7 +6078,11 @@
         normalizeGovernanceRulesByProject,
         normalizeCustomInstructionsByProject,
         persistenceContext
-      });
+        });
+        if (!options?.draftScope) {
+          await getComposerDraftPersistence().save({ accountScopeId: persistenceContext.scope.accountScopeId, projectId });
+        }
+      };
 
       const persistenceCoordinator = getScopedPersistenceCoordinator();
       if (!persistenceCoordinator) {
@@ -5473,19 +6090,18 @@
           code: 'scoped_persistence_unavailable'
         });
       } else {
-        const committed = await persistenceCoordinator.commit(
-          projectId,
-          {
+        const commitOptions = {
             detached: Boolean(projectIdOverride),
             rebase: true,
             queueMutation: options?.queueMutation,
             queueMutations: options?.queueMutations,
             sessionTombstones: options?.deletedSessionIds
-          },
-          persistScopedState
-        );
+        };
+        const committed = options?.draftScope
+          ? await persistenceCoordinator.commitDetached(projectId, options.draftScope.accountScopeId, commitOptions, persistScopedState)
+          : await persistenceCoordinator.commit(projectId, commitOptions, persistScopedState);
         if (!committed.ok && (
-          options?.reviewRunIds?.length || options?.queueMutation
+          options?.requireDurable || options?.reviewRunIds?.length || options?.recoveryRuns?.length || options?.queueMutation
           || options?.queueMutations?.length
           || committed.reason !== 'stale_view'
         )) {
@@ -5493,8 +6109,35 @@
             code: committed.reason
           });
         }
+        if (committed.ok) {
+          if (savedDraft && pendingDraftSave === savedDraft) {
+            const capturedTask = stateSnapshot.sessions.find(item => item.id === stateSnapshot.activeSessionId)?.task;
+            const storedTask = StorageDb.buildSessionRecord({ task: capturedTask }).task;
+            if (!(written || []).some(session => session.id === stateSnapshot.activeSessionId && session.task === storedTask)) {
+              throw Object.assign(new Error(tx('The latest draft could not be saved. It is still available in this page.',
+                '最新草稿未能保存，内容仍保留在当前页面。')), { code: 'draft_state_not_persisted' });
+            }
+            // A newer input revision keeps its own timer, even if this save finishes later.
+            resetDraftSave();
+          }
+          const retentionUpdates = StorageDb.projectRetentionUpdates?.({ liveState: state, capturedState: stateSnapshot, written,
+            capturedScope: retentionScope, currentScope: { accountScopeId: typeof cachedAccountScopeId === 'string' ? cachedAccountScopeId : '',
+              projectId: getCurrentProjectId(), generation: typeof spaRouteGeneration === 'number' ? spaRouteGeneration : null } }) || [];
+          for (const update of retentionUpdates) for (const run of [...(state.runs || []), ...(state.sessions || []).flatMap(session => session.runs || [])]) {
+            if (run.id !== update.runId) continue;
+            if (update.retention) run.recoveryRetention = update.retention; else delete run.recoveryRetention;
+          }
+          if (retentionUpdates.some(update => update.retention)) appendStorageNoticeOnce('undo-retention', tx(
+            'Some recovery evidence was not retained durably. After reloading, check Overleaf history or Review.',
+            '部分恢复材料未持久保留；刷新后请核对 Overleaf 历史或审阅。'));
+        }
+        if (options?.requireDurable || options?.recoveryRuns?.length) return true;
       }
     } catch (error) {
+      if (options?.requireDurable) throw error;
+      // A departing draft must never fall back using the destination page's state/scope.
+      if (options?.draftScope) return;
+      if (error?.code === 'recovery_scope_changed') return;
       if (
         error?.code === 'account_scope_unavailable' &&
         !options?.reviewRunIds?.length && !options?.queueMutation &&
@@ -5522,7 +6165,7 @@
         emitStorageQuotaFailure(error, fallbackError);
       }
       if (typeof appendStorageNoticeOnce === 'function') {
-        appendStorageNoticeOnce('save-failed', tx(`Failed to save session state: ${error.message}`, `保存会话状态失败：${error.message}`));
+        appendStorageNoticeOnce('save-failed', tx(`Failed to save session state: ${localizeVisibleReason(error.message)}`, `保存会话状态失败：${localizeVisibleReason(error.message)}`));
       } else {
         throw error;
       }
@@ -5531,12 +6174,12 @@
     }
   }
 
-
   function prepareCompactFallbackState(inputState) {
     const compact = prepareStateForStorage(inputState);
     return {
       ...compact,
       __codexOverleafCompactFallback: true,
+      composerAttachments: [],
       task: '',
       session: null,
       sessions: [],
@@ -5611,6 +6254,65 @@
     }, delayMs);
   }
 
+  function getComposerDraftScope() {
+    return JSON.stringify([cachedAccountScopeId, getCurrentProjectId(), spaRouteGeneration, state.activeSessionId]);
+  }
+
+  function resetDraftSave() {
+    if (draftSaveTimer) clearTimeout(draftSaveTimer);
+    draftSaveTimer = null;
+    pendingDraftSave = null;
+  }
+
+  function captureComposerDraft() {
+    const input = panel?.querySelector('[data-task]');
+    if (!input || !state.activeSessionId) return;
+    const next = updateActiveSessionDraft(state, input.value);
+    if (next === state) return;
+    if (next.task !== state.task) {
+      composerDraftEditedHere = true;
+      if (currentRunView?.sessionId === state.activeSessionId) delete currentRunView.draftConsumption;
+    }
+    state = next;
+    const now = Date.now(), scope = getComposerDraftScope();
+    pendingDraftSave = {
+      scope,
+      projectId: getCurrentProjectId(),
+      accountScopeId: cachedAccountScopeId,
+      firstAt: pendingDraftSave?.scope === scope ? pendingDraftSave.firstAt : now
+    };
+    if (draftSaveTimer) clearTimeout(draftSaveTimer);
+    const delay = Math.max(0, Math.min(DRAFT_SAVE_DELAY_MS, pendingDraftSave.firstAt + DRAFT_SAVE_MAX_WAIT_MS - now));
+    draftSaveTimer = setTimeout(() => {
+      draftSaveTimer = null;
+      if (pendingDraftSave?.scope !== getComposerDraftScope()) { resetDraftSave(); return; }
+      pendingDraftSave.firstAt = Date.now();
+      // Join the existing writer immediately; never reset its timer on every key.
+      saveStateSoon(0);
+    }, delay);
+  }
+
+  async function flushComposerDraft({ requireDurable = false } = {}) {
+    if (!pendingDraftSave) return;
+    const scope = getComposerDraftScope();
+    if (pendingDraftSave.scope !== scope) { resetDraftSave(); return; }
+    if (draftSaveTimer) clearTimeout(draftSaveTimer);
+    draftSaveTimer = null;
+    pendingDraftSave.firstAt = Date.now();
+    await flushQueuedSaveState(requireDurable ? { requireDurable: true } : null);
+    if (requireDurable && scope !== getComposerDraftScope()) {
+      throw new Error(tx('The active session changed while saving the draft. Try again.',
+        '保存草稿时活动会话已改变，请重试。'));
+    }
+  }
+
+  function flushComposerDraftOnLeave() {
+    // Lifecycle events cannot await completion; periodic saves remain the primary protection.
+    flushComposerDraft().catch(error => appendStorageNoticeOnce('save-failed', tx(
+      `Failed to save session state: ${localizeVisibleReason(error.message)}`,
+      `保存会话状态失败：${localizeVisibleReason(error.message)}`)));
+  }
+
   function runQueuedSaveState() {
     if (saveStateInFlightPromise) {
       saveStateRunAfterFlight = true;
@@ -5629,7 +6331,7 @@
           // here (e.g. fallback chrome.storage.local.set rethrew).
           emitStorageQuotaFailure(error, null);
         }
-        if (persistenceOptions?.reviewRunIds?.length) throw error;
+        if (persistenceOptions?.requireDurable || persistenceOptions?.reviewRunIds?.length) throw error;
         appendPlainLog(tx(`Failed to save session state: ${formatStateSaveError(error)}`, `保存会话状态失败：${formatStateSaveError(error)}`));
       })
       .finally(() => {
@@ -5705,19 +6407,17 @@
     if (isStorageQuotaError(error)) {
       return tx('Local session history is too large. Delete some old tasks and retry.', '本地会话记录太大，请删除一些旧任务后重试。');
     }
-    return error?.message || String(error);
+    return localizeVisibleReason(error?.message || String(error));
   }
 
   async function persistPanelInputs(event) {
     const globalWrite = getGlobalPreferences().handleInput(event);
     if (globalWrite) return globalWrite;
-    // Typing in the task box is the hottest write path: a full saveState per
-    // keystroke serializes every session/run/event and rewrites IndexedDB, so
-    // panels get slower as history grows. Drafts take the debounced saver;
-    // committed control changes keep the immediate full save below.
-    if (event?.type === 'input' && event?.target?.matches?.('[data-task]')) {
-      readPanelInputs();
-      saveStateSoon();
+    // Draft edits retain run/event identity. Composition updates also capture the
+    // current text; compositionend captures its committed value if no final input fires.
+    if (event?.target?.matches?.('[data-task]')) {
+      captureComposerDraft();
+      if (event.type === 'change') await flushComposerDraft();
       return;
     }
     if (event?.target?.matches?.('[data-speed]')) {
@@ -5729,8 +6429,18 @@
     }
     renderSpeedOptions(getRenderedModelEntries());
     readPanelInputs();
+    // Only a user re-enabling Track requests another capability check. The
+    // preceding input event and programmatic session renders must not reset it.
+    if (event?.type === 'change' && event.isTrusted === true
+      && event.target?.matches?.('[data-require-reviewing]') && event.target.checked
+      && isReviewingKnownUnavailable()) {
+      projectSettingsCoordinator.observeReviewingAvailability('unknown', 'user_retry');
+      syncReviewingTooltip();
+      syncProbeStatus();
+    }
     renderModelConfigChoices();
     updateModelDisplay();
+    renderContextUsage();
     // Save feedback is per-card now (settingsPanel flashSaved); the global
     // header chip and its Saving/Saved lifecycle are gone.
     await saveState();
@@ -5817,21 +6527,64 @@
     return speedSelect?.value || state?.speedTier || 'standard';
   }
 
-
-  let composerAttachmentsRestoredOnce = false;
+  let composerDraftPersistence = null;
   let lastRunActivityBumpMs = 0;
 
+  function getComposerDraftPersistence() {
+    if (!composerDraftPersistence) composerDraftPersistence = Modules.ComposerAttachmentDraft.createController({
+      getScope: () => ({ accountScopeId: cachedAccountScopeId, projectId: getCurrentProjectId() }),
+      getAttachments: () => composerAttachmentController.serializePersistableAttachments(),
+      setAttachments: value => { state.composerAttachments = value; },
+      clear: () => composerAttachmentController.clear({ notify: false }),
+      restore: value => composerAttachmentController.restorePersistedAttachments(value),
+      read: scope => Modules.StorageDb.readComposerAttachmentDraft(scope),
+      write: (scope, value) => Modules.StorageDb.writeComposerAttachmentDraft(scope, value),
+      scheduleSave: () => saveStateSoon()
+    });
+    return composerDraftPersistence;
+  }
+
+  async function loadComposerAttachmentsForProject(accountScopeId, projectId) {
+    if (!accountScopeId || !projectId) return [];
+    try {
+      return await getComposerDraftPersistence().load({ accountScopeId, projectId });
+    } catch (error) {
+      if (error?.code === 'stale_hydration' || error?.code === 'account_scope_unavailable') throw error;
+      appendPlainLog(tx('Saved attachments could not be restored. Reattach the files before sending.',
+        '已保存的附件无法恢复，请在发送前重新添加文件。'));
+      return [];
+    }
+  }
+
   function persistComposerAttachmentsToState() {
     if (typeof composerAttachmentController?.serializePersistableAttachments === 'function') {
       state.composerAttachments = composerAttachmentController.serializePersistableAttachments();
     }
   }
 
-  function clearTaskComposer({ keepAttachments = false } = {}) {
+  function clearTaskComposer({ keepAttachments = false, submission = null } = {}) {
     const taskInput = panel?.querySelector('[data-task]');
+    if (submission) {
+      if (submission.projectId !== getCurrentProjectId()
+        || submission.accountScopeId !== cachedAccountScopeId) return false;
+      if (findSessionById(submission.sessionId)?.task !== submission.task) return false;
+      if (state.activeSessionId !== submission.sessionId) {
+        updateSessionById(submission.sessionId, { task: '' });
+        recordSubmittedDraftConsumption(submission.sessionId, submission.task);
+        saveStateSoon();
+        return false;
+      }
+      if (composerAttachmentController.getAttachmentByteUsage?.().pending > 0
+        || selectionContextView.getRevision?.() !== submission.selectionRevision) return false;
+      if (!runController.isSubmittedComposerUnchanged(submission, {
+        task: taskInput?.value, attachments: getComposerAttachmentsForRun(),
+        skillInvocation: getComposerSkillInvocationForRun(), selectionContext: selectionContextView.capture()
+      })) return false;
+    }
     if (taskInput) {
       taskInput.value = '';
     }
+    composerDraftEditedHere = false;
     autosizeTaskTextarea();
     if (!keepAttachments) {
       composerAttachmentController.clear();
@@ -5840,10 +6593,47 @@
     renderComposerSkillInvocation();
     selectionContextView.clear();
     state = updateActiveSession(state, { task: '' });
+    if (submission) recordSubmittedDraftConsumption(submission.sessionId, submission.task);
+    else if (currentRunView?.sessionId === state.activeSessionId) delete currentRunView.draftConsumption;
+    saveStateSoon();
+    return true;
+  }
+
+  function recordSubmittedDraftConsumption(sessionId, task) {
+    if (task && currentRunView?.sessionId === sessionId
+      && currentRunView.runProjectId === getCurrentProjectId()
+      && currentRunView.runAccountScopeId === cachedAccountScopeId) {
+      currentRunView.draftConsumption = { runId: currentRunView.recordId, task };
+    }
+  }
+
+  function restoreRejectedLocalSkillSubmission(submission, checkpoint) {
+    const input = panel?.querySelector('[data-task]');
+    if (!checkpoint || !input || submission.accountScopeId !== cachedAccountScopeId
+      || submission.projectId !== getCurrentProjectId() || submission.sessionId !== state.activeSessionId
+      || !findSessionById(submission.sessionId) || input.value || state.task
+      || composerDraftRevision !== checkpoint.draftRevision
+      || getComposerAttachmentsForRun().length || composerAttachmentController.getAttachmentByteUsage?.().pending
+      || composerAttachmentController.getRevision?.() !== checkpoint.attachmentRevision
+      || selectionContextView.getRevision?.() !== checkpoint.selectionRevision
+      || selectionContextView.capture() || getComposerSkillInvocationForRun()) return false;
+    if (!composerAttachmentController.restoreSubmittedAttachments?.(submission.attachments, checkpoint.attachmentRevision)) return false;
+    composerDraftRevision += 1;
+    composerSkillInvocation = submission.skillInvocation;
+    input.value = submission.task;
+    state = updateActiveSession(state, { task: submission.task, selectionContext: submission.selectionContext });
+    renderComposerSkillInvocation();
+    selectionContextView.render();
+    syncProbeStatus();
+    autosizeTaskTextarea();
+    syncComposerSendAvailability();
     saveStateSoon();
+    return true;
   }
 
   function applyStateToPanel(options = {}) {
+    if (pendingDraftSave && pendingDraftSave.scope !== getComposerDraftScope()) resetDraftSave();
+    contextUsageView?.close();
     selectionContextView.render();
     writingStyleSettings.sync();
     applyPanelTheme(getThemePreference());
@@ -5866,6 +6656,7 @@
     autosizeTaskTextarea();
     syncComposerSendAvailability();
     panel.querySelector('[data-require-reviewing]').checked = state.requireReviewing;
+    syncReviewingTooltip();
     const recompileCheckbox = panel?.querySelector('[data-auto-recompile]');
     if (recompileCheckbox) {
       recompileCheckbox.checked = state.autoRecompile !== false;
@@ -5882,23 +6673,14 @@
     applySessionLabel();
     renderSessionList();
     renderRunHistory(options);
+    renderPendingInputs();
     getTrackedChangeCaptureController().schedule();
     renderContextSelection();
     renderContextSummary();
-    // v1.8.0 C4: refresh recovery — small attachments persisted in state are
-    // restored into the (empty) tray ONCE per page load, before the render
-    // below. Re-running the gate on later renders would resurrect files the
-    // user explicitly removed (fleet P2).
-    if (!composerAttachmentsRestoredOnce
-      && Array.isArray(state.composerAttachments) && state.composerAttachments.length
-      && !composerAttachmentController.getAttachmentsForRun?.().length
-      && typeof composerAttachmentController.restorePersistedAttachments === 'function') {
-      composerAttachmentController.restorePersistedAttachments(state.composerAttachments);
-    }
-    composerAttachmentsRestoredOnce = true;
+    getComposerDraftPersistence().hydrate(state.composerAttachments);
     renderComposerAttachments();
     renderComposerSkillInvocation();
-    applyLocaleToPanel();
+    applyLocaleToPanel({ reprojectDynamic: false });
     if (!panel.querySelector('[data-context-tray]')?.hidden) {
       renderContextFiles();
     }
@@ -5929,6 +6711,47 @@
       if (record) configureWritebackButton(root, record, { running });
     });
     renderPendingInputs();
+    renderContextUsage();
+  }
+
+  function renderContextUsage() {
+    if (!contextUsageView || !state) return;
+    contextUsageView.setState(getContextUsageDisplay());
+  }
+
+  function getContextUsageDisplay() {
+    const session = getActiveSession(state);
+    const run = currentRunView?.sessionId === session?.id
+      ? findRunRecord(currentRunView.recordId, currentRunView.sessionId) : null;
+    const selection = providerSettingsCoordinator.getRunSelection(state.providerId);
+    const runningSelection = run?.status === 'running' && run.model === state.model
+      && (run.providerId || 'builtin') === (state.providerId || 'builtin');
+    const scope = {
+      threadId: session?.codexThreadId || '',
+      providerId: state.providerId || 'builtin',
+      providerRevision: runningSelection ? Number(run.providerRevision || 0)
+        : selection?.providerRevision ?? ((state.providerId || 'builtin') === 'builtin' ? 0 : null),
+      model: state.model || ''
+    };
+    // The composer can select the next turn's model while this turn runs.
+    // Only show statistics produced by the selected model and provider.
+    const matchesRun = run && run.model === scope.model
+      && (run.providerId || 'builtin') === scope.providerId
+      && Number(run.providerRevision || 0) === scope.providerRevision;
+    // Starting another turn must not revive statistics from before an automatic
+    // compaction. Retain the watermark across this thread's saved normal runs.
+    const compactedAt = (session?.runs || []).reduce((latest, candidate) => candidate && !candidate.forkSnapshot
+      && candidate.operation !== 'compact' && scope.threadId && candidate.codexThreadId === scope.threadId
+      ? Math.max(latest, Modules.RunActivityModel.getCompactedAt(candidate)) : latest, 0);
+    const { usage, pending, compacted } = Modules.ContextUsage.status(session, { ...scope, compactedAt });
+    const compacting = Boolean(matchesRun && Modules.RunActivityModel.project(run).compacting);
+    return { usage, pending, compacted, compacting, compactingKind: compacting ? (run.operation === 'compact' ? 'manual' : 'auto') : '' };
+  }
+
+  function getCompactAvailability() {
+    if (sessionManager.isTransitioning() || updateIdleClient?.isApplying() || currentRunView || runSubmissionPending) return { ok: false, reason: 'compactBusy' };
+    if (!getActiveSession(state)?.codexThreadId) return { ok: false, reason: 'compactNoThread' };
+    return { ok: true };
   }
 
   function prepareRetryReplacement(run, task) {
@@ -5959,6 +6782,10 @@
   }
 
   function startRunView({
+    sessionId = state.activeSessionId,
+    sessionContext = runController.captureSessionContext(state),
+    codexThreadId = '',
+    operation,
     task,
     mode,
     model,
@@ -5975,6 +6802,7 @@
     resetAutoFollow();
     const record = {
       id: createRunId(),
+      ...(operation === 'compact' ? { operation } : {}),
       task,
       mode,
       ...providerSettingsCoordinator.getProviderSnapshot(executionSnapshot?.providerId || state?.providerId),
@@ -5999,63 +6827,54 @@
       executionSnapshot: executionSnapshot
         ? RunExecutionSnapshot.cloneSnapshot(executionSnapshot)
         : undefined,
-      // Welcome-panel + write-guard:
-      // Immutable per-run capture of the project this run was submitted
-      // against. Every writeback / accept / undo dispatch attaches this id
-      // to its page-bridge params so the page-side guard can verify the run
-      // is still acting on the same project before mutating the editor. No
-      // language-level enforcement — the field is treated as immutable by
-      // convention and never reassigned anywhere downstream.
+      // Writeback/Accept/Undo carry this immutable project identity to Page.
       runProjectId: getCurrentProjectId() || '',
       runAccountScopeId: cachedAccountScopeId || ''
     };
-    const active = getActiveSession(state);
-    const titlePatch = active?.titleSource !== 'manual'
+    const active = findSessionById(sessionId);
+    const titlePatch = operation !== 'compact' && active?.titleSource !== 'manual'
       ? {
         title: deriveSessionTitle([], task),
         titleSource: 'auto'
       }
       : {};
-    state = updateActiveSession(state, {
-      runs: runController.replaceRunForRetry(state.runs, replaceRunId, record),
+    // Establish the in-memory owner before publishing or rendering the record.
+    // If presentation throws, runTask still has the identity needed to settle it.
+    const view = currentRunView = {
+      operation, sessionId, sessionContext, codexThreadId, recordId: record.id,
+      runProjectId: record.runProjectId, runAccountScopeId: record.runAccountScopeId,
+      executionSnapshot: record.executionSnapshot, startedAt: Date.now(), queueItemId,
+      nativeRequestId: '', activeTurn: null
+    };
+    updateSessionById(sessionId, {
+      runs: runController.replaceRunForRetry(active?.runs, replaceRunId, record),
       ...titlePatch
     });
     saveStateSoon(replaceRunId ? 0 : 120);
 
     const log = panel.querySelector('[data-log]');
-    removeEmptyRunsMessage(log);
-    if (replaceRunId) log.querySelector(`[data-run-id="${cssEscape(replaceRunId)}"]`)?.remove();
     const root = renderRunCard(record);
-    log.append(root);
-    scrollLogToBottom({ force: true });
-    startRunElapsedTick();
-    renderSessionList();
-    applySessionLabel();
-
-    return {
-      sessionId: state.activeSessionId,
-      recordId: record.id,
-      // Mirror the immutable runProjectId on the view so writeback /
-      // accept / undo dispatches don't need to re-look up the record.
-      runProjectId: record.runProjectId,
-      runAccountScopeId: record.runAccountScopeId,
-      executionSnapshot: record.executionSnapshot,
+    Object.assign(view, {
       root,
       runProcess: root.querySelector('[data-run-process]'),
       processLabel: root.querySelector('[data-run-process-summary]'),
       events: root.querySelector('[data-run-events]'),
       report: root.querySelector('[data-run-report]'),
       status: root.querySelector('[data-run-status]'),
-      // A run starts before warm-mirror resolution has produced its lightweight
-      // project snapshot. Seed references from the already-prefetched project
-      // inventory so early stream events and fast Ask responses can still
-      // resolve project-relative locations.
-      projectFiles: getCurrentProjectReferenceFiles(),
-      startedAt: Date.now(),
-      queueItemId,
-      nativeRequestId: '',
-      activeTurn: null
-    };
+      // Seed references before warm-mirror resolution produces its snapshot.
+      projectFiles: getCurrentProjectReferenceFiles()
+    });
+    if (state.activeSessionId === sessionId) {
+      removeEmptyRunsMessage(log);
+      if (replaceRunId) log.querySelector(`[data-run-id="${cssEscape(replaceRunId)}"]`)?.remove();
+      log.append(root);
+      scrollLogToBottom({ force: true });
+    }
+    startRunElapsedTick();
+    renderSessionList();
+    applySessionLabel();
+
+    return view;
   }
 
   function touchSessionForTerminalRun(sessionId, finishedAt) {
@@ -6118,6 +6937,7 @@
       ].filter(Boolean).join(' · ');
       collapseRunProcess(visibleView, statusText);
     }
+    renderContextUsage();
   }
 
 
@@ -6132,6 +6952,11 @@
     }
 
     const owner = currentRunView && findRunRecord(currentRunView.recordId, currentRunView.sessionId);
+    if (storeContextUsage(event, owner, findSessionById(currentRunView?.sessionId), journalSeq)) {
+      scheduleRunStateSave('stream');
+      renderContextUsage();
+      return;
+    }
     if (owner && Modules.SubagentActivityModel.ingest(owner, event, {
       locale: getLocale(), sanitize: sanitizeAssistantVisibleText, nativeEventSeq: journalSeq
     })) {
@@ -6160,6 +6985,20 @@
       replaceText: activity.replaceText,
       nativeEventSeq: journalSeq
     });
+    if (activity.kind !== 'stream') renderContextUsage();
+  }
+
+  function storeContextUsage(event, record, session, sequence) {
+    if (!record) return false;
+    const usage = Modules.ContextUsage.fromEvent(event, {
+      ...record, providerRevision: Number(record.providerRevision || 0), eventSeq: sequence
+    });
+    if (!usage || !Modules.ContextUsage.isNewer(usage, record.contextUsage)) return false;
+    record.contextUsage = usage;
+    record.nativeEventSeq = Math.max(Number(record.nativeEventSeq || 0), Number(sequence || 0));
+    if (session?.codexThreadId === usage.threadId
+      && Modules.ContextUsage.isNewer(usage, session.contextUsage)) session.contextUsage = usage;
+    return true;
   }
 
   function bindActiveTurn(detail = {}, journalSeq = 0) {
@@ -6168,16 +7007,24 @@
     }
     const threadId = String(detail.threadId || '');
     const turnId = String(detail.turnId || '');
-    currentRunView.activeTurn = { threadId, turnId };
+    currentRunView.activeTurn = currentRunView.operation === 'compact' ? null : { threadId, turnId };
     const record = findRunRecord(currentRunView.recordId, currentRunView.sessionId);
     if (record) {
       record.codexThreadId = threadId; record.codexTurnId = turnId;
+      if (record.operation === 'compact') {
+        const session = findSessionById(currentRunView.sessionId);
+        if (session?.contextUsage?.threadId === threadId
+          && Date.parse(session.contextUsage.observedAt) < Date.parse(record.startedAt)) {
+          session.contextUsage = null;
+        }
+      }
       record.nativeEventSeq = Math.max(Number(record.nativeEventSeq || 0), Number(journalSeq || 0));
     }
     if (threadId) {
       updateSessionById(currentRunView.sessionId, { codexThreadId: threadId });
     }
     renderPendingInputs();
+    renderContextUsage();
     saveState().catch(() => {});
   }
 
@@ -6198,7 +7045,7 @@
   function appendRunEvent(input = {}) {
     const { title, status = 'info', detail, timestamp } = input;
     const safeTitle = sanitizeAssistantVisibleText(title) || 'Event';
-    if (!currentRunView?.events) {
+    if (!currentRunView) {
       appendPlainLog(safeTitle);
       return;
     }
@@ -6242,21 +7089,20 @@
           })).filter(item => item.path)
         : undefined
     };
+    // Keep the activity timestamp current without retaining a run reference
+    // across session normalization, which replaces run and event objects.
+    const nowMs = Date.now();
+    if (nowMs - lastRunActivityBumpMs > 60000
+      && findRunRecord(currentRunView.recordId, currentRunView.sessionId)) {
+      lastRunActivityBumpMs = nowMs;
+      state = updateActiveSession(state, {});
+    }
     const record = findRunRecord(currentRunView.recordId, currentRunView.sessionId);
     let renderedEvent = event;
     if (record) {
       if (Number.isFinite(Number(input.nativeEventSeq))) {
         record.nativeEventSeq = Math.max(Number(record.nativeEventSeq || 0), Number(input.nativeEventSeq || 0));
       }
-      // v1.8.1: keep the session's activity timestamp honest DURING a run —
-      // it was pinned to run start, so the dashboard's 30-minute zombie
-      // heuristic mislabeled any long live run as interrupted (fleet P1).
-      // Throttled to once a minute; updateActiveSession stamps updatedAt.
-      const nowMs = Date.now();
-      if (nowMs - lastRunActivityBumpMs > 60000) {
-        lastRunActivityBumpMs = nowMs;
-        state = updateActiveSession(state, {});
-      }
       renderedEvent = event.kind === 'stream'
         ? upsertRunStreamRecordEvent(record, event)
         : event;
@@ -6592,311 +7438,34 @@
     );
   }
 
-  async function undoRun(runId) {
-    const run = findRunRecord(runId);
-    if (!getRunUndoCount(run) || run.undoStatus === 'applied') {
-      return;
-    }
-    // Wait out any background mirror refresh before undoing (v1.7.5): a
-    // mirror.sync finishing after the undo would push the pre-undo snapshot
-    // as the local baseline and resurrect the undone content next run.
-    const pendingMirror = getPendingMirrorRefresh?.();
-    if (pendingMirror) {
-      await pendingMirror.catch(() => {});
-    }
-
-    if ((Array.isArray(run.undoTrackedChanges) && run.undoTrackedChanges.length) || hasTrackedEditorUndo(run)
-      || (run.trackedChangeStatus === 'needs_review' && run.undoOperations?.some(operation => operation?.undoCreatedFile?.v === 1))) {
-      await undoRunTrackedChanges(runId, run);
-      return;
-    }
-
-    const undoRestore = buildNoTraceUndoRestore(run);
-    const undoOperations = undoRestore.operations;
-    const unsafeFullFileUndo = findUnsafeFullFileUndoOperation(undoOperations, {
-      allowSnapshotRestore: undoRestore.snapshotRestore
-    });
-    if (unsafeFullFileUndo) {
-      appendRunRecordEvent(runId, {
-        title: tr('undoUnsafeFullFileTitle'),
-        status: 'failed',
-        detail: {
-          [tr('detailFile')]: unsafeFullFileUndo.path,
-          [tr('detailReason')]: tr('undoUnsafeFullFileReason')
-        }
-      });
-      return;
-    }
-
-    // v1.8.0 C3: multi-file undos confirm through a per-file selection —
-    // undoing a subset leaves undoStatus 'partial' and the button usable;
-    // re-undoing an already-restored file is skipped by the base check.
-    const undoPaths = Array.from(new Set(undoOperations.map(operation => operation?.path).filter(Boolean)));
-    let selectedOperations = undoOperations;
-    if (undoPaths.length > 1 && typeof showUndoFileSelection === 'function') {
-      const selectedPaths = await showUndoFileSelection({
-        title: tr('undoFileSelectTitle'),
-        task: truncateRunTitle(run.task),
-        confirmLabel: tr('undoFileSelectConfirm'),
-        cancelLabel: tr('confirmDefaultCancel'),
-        selectAllLabel: tr('undoFileSelectAll'),
-        paths: undoPaths
-      });
-      if (!selectedPaths) {
-        return;
-      }
-      const selectedSet = new Set(selectedPaths);
-      selectedOperations = undoOperations.filter(operation => selectedSet.has(operation?.path));
-    } else {
-      const approved = await showPluginConfirm({
-        title: tr('undoNoTraceTitle'),
-        message: [
-          truncateRunTitle(run.task),
-          '',
-          tr('undoNoTraceMessage', { files: formatOperationFiles(undoOperations) })
-        ].join('\n'),
-        confirmLabel: tr('undoConfirm'),
-        cancelLabel: tr('confirmDefaultCancel'),
-        destructive: true
-      });
-      if (!approved) {
-        return;
-      }
-    }
-
-    const deadlineAt = Date.now() + getPageBridgeTimeoutMs('rejectTrackedChanges');
-    setRunUndoStatus(runId, 'running');
-    appendRunRecordEvent(runId, {
-      title: tr('undoNoTraceStarted'),
-      status: 'running',
-      detail: { [tr('detailWillUndo')]: formatOperationFiles(selectedOperations) }
+  let runReviewController = null;
+  function getRunReviewController() {
+    if (!runReviewController) runReviewController = Modules.RunReviewController.create({
+      Modules, WritebackSettlement, trackedChangeInFlight, findRunRecord,
+      getRunUndoCount, isTrackedChangeLifecycleRun, getPendingMirrorRefresh, hasTrackedEditorUndo, buildNoTraceUndoRestore,
+      findUnsafeFullFileUndoOperation, showUndoFileSelection, showPluginConfirm, tr,
+      truncateRunTitle, formatOperationFiles, formatTrackedChangeFiles, formatTrackedUndoFiles,
+      getPageBridgeTimeoutMs, callPageBridge, setRunUndoStatus, appendRunRecordEvent, getRunProjectIdForWriteback,
+      isUndoResultEffectivelyApplied, writebackOrchestrator, appendUndoReviewingPolicyEvent, formatOperationType,
+      formatApplyResultReason, buildTrackedUndoPostFiles, getTrackedChangeCaptureController, buildContentFailure,
+      applyTrackedChangeSettlement, refreshRunCardControls, formatBridgeResultReason, advanceRunUndoProgress,
+      saveStateSoon, flushQueuedSaveState,
+      getState: () => state, getCurrentProjectId, getAccountScopeId: () => cachedAccountScopeId,
+      getRouteGeneration: () => spaRouteGeneration, tx, notify: message => showPluginToast(message, { status: 'warning', sticky: true })
     });
+    return runReviewController;
+  }
 
-      const result = await callPageBridge('applyOperations', {
-        operations: selectedOperations, deadlineAt,
-        baseFiles: run.undoBaseFiles || [],
-        reviewingPolicy: 'no-trace-undo',
-        // Undo remains bound to its original project, including after navigation.
-        runProjectId: getRunProjectIdForWriteback(run)
-      });
-      const undoApplied = isUndoResultEffectivelyApplied(run, result);
-      writebackOrchestrator.invalidateMirrorAfterUndo(runId, getRunProjectIdForWriteback(run), result);
-      appendUndoReviewingPolicyEvent(runId, result.reviewingPolicy);
-      appendRunRecordEvent(runId, {
-        title: tr('undoResult', { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }),
-        status: undoApplied ? 'completed' : result.skipped?.length ? 'failed' : 'completed',
-        detail: {
-          [tr('detailUndone')]: (result.applied || []).map(item => ({
-            [tr('detailAction')]: formatOperationType(item.operation?.type),
-            [tr('detailFile')]: item.operation?.path
-        })),
-        [tr('detailSkipped')]: (result.skipped || []).map(item => ({
-          [tr('detailAction')]: formatOperationType(item.operation?.type),
-          [tr('detailFile')]: item.operation?.path,
-            [tr('detailReason')]: formatApplyResultReason(item)
-          }))
-        }
-      });
-      // A subset undo never closes the ledger: unselected files can still
-      // be undone later, so the run stays 'partial' and the button usable.
-      const fullSelection = selectedOperations.length === undoOperations.length;
-      applyLegacyUndoSettlement(
-        runId,
-        undoApplied && fullSelection ? 'applied' : 'partial',
-        result
-      );
+  async function undoRun(runId) {
+    return getRunReviewController().undoRun(runId);
   }
 
   async function undoRunTrackedChanges(runId, run) {
-    const createdUndoOperations = (run.undoOperations || []).filter(operation => operation?.undoCreatedFile?.v === 1);
-    const trackedUndo = Array.isArray(run.undoTrackedChanges) && run.undoTrackedChanges.length > 0;
-    const hasTextUndo = trackedUndo || buildTrackedUndoPostFiles(run).length > 0;
-    const approved = await showPluginConfirm({
-      title: !hasTextUndo ? tr('undoNoTraceTitle') : trackedUndo ? tr('undoTrackedTitle') : tr('undoNativeTitle'),
-      message: [
-        truncateRunTitle(run.task),
-        '',
-        ...(hasTextUndo ? [trackedUndo
-          ? tr('undoTrackedMessage', { files: formatTrackedChangeFiles(run.undoTrackedChanges) })
-          : tr('undoNativeMessage', { files: formatTrackedUndoFiles(run) })] : []),
-        ...(createdUndoOperations.length ? [tr('undoNoTraceMessage', { files: formatOperationFiles(createdUndoOperations) })] : [])
-      ].join('\n'),
-      confirmLabel: trackedUndo ? tr('undoTrackedConfirm') : tr('undoConfirm'),
-      cancelLabel: tr('confirmDefaultCancel'),
-      destructive: true
-    });
-    if (!approved) {
-      return;
-    }
-
-    const deadlineAt = Date.now() + getPageBridgeTimeoutMs('rejectTrackedChanges');
-    // Keep the review lifecycle until every pending part has settled.
-    // Its local lock stays active while verified recovery progress is persisted.
-    const lifecycleReject = (trackedUndo || createdUndoOperations.length > 0) && isTrackedChangeLifecycleRun(run);
-    if (lifecycleReject) {
-      trackedChangeInFlight.set(runId, 'reject');
-      refreshRunCardControls(runId);
-    } else {
-      setRunUndoStatus(runId, 'running');
-    }
-    appendRunRecordEvent(runId, {
-      title: !hasTextUndo ? tr('undoNoTraceStarted') : trackedUndo ? tr('undoTrackedStarted') : tr('undoNativeStarted'),
-      status: 'running',
-      detail: { [tr('detailWillUndo')]: !hasTextUndo ? formatOperationFiles(createdUndoOperations)
-        : trackedUndo ? formatTrackedChangeFiles(run.undoTrackedChanges) : formatTrackedUndoFiles(run) }
-    });
-
-    try {
-      const trackedUndoPostFilesAtDispatch = buildTrackedUndoPostFiles(run);
-      let result = hasTextUndo ? await callPageBridge('rejectTrackedChanges', {
-        trackedChanges: run.undoTrackedChanges || [], deadlineAt,
-        expectedFiles: run.undoExpectedFiles || [],
-        postFiles: trackedUndoPostFilesAtDispatch,
-        untrackedUndo: run.executionSnapshot
-          ? run.executionSnapshot.requireReviewing === false && ['submitted', 'legacy-captured'].includes(run.executionSnapshot.source)
-          : getTrackedChangeCaptureController().hasLegacyUntrackedCheckpoint(run),
-        // The page-side project guard still refuses writes after navigation.
-        runProjectId: getRunProjectIdForWriteback(run)
-      }) : { ok: true, applied: [], skipped: [] };
-      if (createdUndoOperations.length && lifecycleReject && hasTextUndo) {
-        WritebackSettlement.attachUndoNotVerifiedFailure(run, result, { buildFailure: buildContentFailure, postFiles: trackedUndoPostFilesAtDispatch });
-        await applyTrackedChangeSettlement(runId, 'reject', { ...result, ok: false });
-      }
-      if (createdUndoOperations.length) {
-        let createdResult;
-        try {
-          if (result.ok === false || result.skipped?.length) {
-            throw new Error('Text changes remain unresolved; created files were kept for the next undo attempt.');
-          }
-          createdResult = await callPageBridge('applyOperations', {
-            operations: createdUndoOperations, deadlineAt,
-            baseFiles: run.undoBaseFiles || [],
-            reviewingPolicy: 'no-trace-undo',
-            runProjectId: getRunProjectIdForWriteback(run)
-          });
-        } catch (error) {
-          createdResult = { ok: false, applied: [], skipped: createdUndoOperations.map(operation => ({
-            operation, result: { ok: false, code: 'undo_operation_failed', reason: error.message }
-          })) };
-        }
-        const applied = [...(result.applied || []), ...(createdResult.applied || [])];
-        const skipped = [...(result.skipped || []), ...(createdResult.skipped || [])];
-        for (const operation of createdUndoOperations) {
-          if (!(createdResult.applied || []).some(entry => entry.operation?.path === operation.path
-            && entry.result?.ok === true && entry.result?.verified === true)
-            && !(createdResult.skipped || []).some(entry => entry.operation?.path === operation.path)) {
-            skipped.push({ operation, result: { ok: false, code: 'undo_operation_failed',
-              reason: 'The created file has no verified deletion receipt.' } });
-          }
-        }
-        result = { ...result, ok: result.ok !== false && createdResult.ok !== false && !skipped.length, applied, skipped };
-      }
-      writebackOrchestrator.invalidateMirrorAfterUndo(runId, getRunProjectIdForWriteback(run), result);
-      appendRunRecordEvent(runId, {
-        title: createdUndoOperations.length ? tr('undoResult', { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }) : trackedUndo
-          ? tr('undoTrackedResult', { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 })
-          : tr('undoNativeResult', { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }),
-        status: result.skipped?.length ? 'failed' : 'completed',
-        detail: {
-          [trackedUndo && !createdUndoOperations.length ? tr('detailRejected') : tr('detailUndone')]: (result.applied || []).map(item => ({
-            [tr('detailFile')]: item.trackedChange?.path || item.operation?.path || tr('unknownFile'),
-            [tr('detailRecord')]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key || item.operation?.type
-          })),
-          [tr('detailSkipped')]: (result.skipped || []).map(item => ({
-            [tr('detailFile')]: item.trackedChange?.path || item.operation?.path || tr('unknownFile'),
-            [tr('detailRecord')]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key || item.operation?.type || '',
-            [tr('detailReason')]: formatBridgeResultReason(item.result, item.trackedChange?.path || item.operation?.path)
-          }))
-        }
-      });
-      if (lifecycleReject) {
-        WritebackSettlement.attachUndoNotVerifiedFailure(run, result, {
-          buildFailure: buildContentFailure,
-          postFiles: trackedUndoPostFilesAtDispatch
-        });
-        await applyTrackedChangeSettlement(runId, 'reject', result);
-        return;
-      }
-      applyLegacyUndoSettlement(runId, result.skipped?.length ? 'partial' : 'applied', result);
-    } finally {
-      if (lifecycleReject) {
-        trackedChangeInFlight.delete(runId);
-        refreshRunCardControls(runId);
-      }
-    }
+    return getRunReviewController().undoRunTrackedChanges(runId, run);
   }
 
   async function acceptRun(runId) {
-    const run = findRunRecord(runId);
-    if (!run || !isTrackedChangeLifecycleRun(run)) {
-      return;
-    }
-    const status = run.trackedChangeStatus || '';
-    // pending and needs_review are both actionable per §7: needs_review means
-    // the prior attempt could not prove a clean post-action state, and the
-    // user is supposed to be able to retry after inspecting Overleaf.
-    if (status !== 'pending' && status !== 'needs_review') {
-      return;
-    }
-    if (!Array.isArray(run.undoTrackedChanges) || !run.undoTrackedChanges.length) {
-      return;
-    }
-    if (trackedChangeInFlight.get(runId)) {
-      return;
-    }
-
-    trackedChangeInFlight.set(runId, 'accept');
-    refreshRunCardControls(runId);
-    appendRunRecordEvent(runId, {
-      title: tr('runAcceptTrackedStarted'),
-      status: 'running',
-      detail: { [tr('detailAccepted')]: formatTrackedChangeFiles(run.undoTrackedChanges) }
-    });
-
-    try {
-      const result = await callPageBridge('acceptTrackedChanges', {
-        trackedChanges: run.undoTrackedChanges || [],
-        expectedFiles: run.undoExpectedFiles || [],
-        postFiles: buildTrackedUndoPostFiles(run),
-        appliedOperations: Array.isArray(run.appliedOperations) ? run.appliedOperations : [],
-        runProjectId: getRunProjectIdForWriteback(run)
-      });
-      appendAcceptDiagnosticEvents(runId, Array.isArray(result.diagnostics) ? result.diagnostics : []);
-      appendRunRecordEvent(runId, {
-        title: tr('runAcceptTrackedResult', { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }),
-        status: result.skipped?.length ? 'failed' : 'completed',
-        detail: {
-          [tr('detailAccepted')]: (result.applied || []).map(item => ({
-            [tr('detailFile')]: item.trackedChange?.path || tr('unknownFile'),
-            [tr('detailRecord')]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key
-          })),
-          [tr('detailSkipped')]: (result.skipped || []).map(item => ({
-            [tr('detailFile')]: item.trackedChange?.path || tr('unknownFile'),
-            [tr('detailRecord')]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key || '',
-            [tr('detailReason')]: formatBridgeResultReason(item.result, item.trackedChange?.path)
-          }))
-        }
-      });
-      if (result.ok === false) {
-        appendRunRecordEvent(runId, {
-          title: tr('runAcceptTrackedFailed'),
-          status: 'failed',
-          detail: {
-            [tr('detailReason')]: tr('runAcceptTrackedFailedReason')
-          }
-        });
-        if (!WritebackSettlement.isSuccessfulTrackedChangeSettlement(result)) {
-          refreshRunCardControls(runId);
-        }
-      }
-      WritebackSettlement.attachAcceptNotVerifiedFailure(run, result, {
-        buildFailure: buildContentFailure
-      });
-      await applyTrackedChangeSettlement(runId, 'accept', result);
-    } finally {
-      trackedChangeInFlight.delete(runId);
-      refreshRunCardControls(runId);
-    }
+    return getRunReviewController().acceptRun(runId);
   }
 
   function getRunProjectIdForWriteback(run) {
@@ -6905,32 +7474,6 @@
       : '';
   }
 
-  // Translates the page bridge's Accept All `diagnostics` array into one
-  // run-card event row per step. Each entry is `{ step, info }`; the step
-  // names map 1:1 to the runAcceptTrackedStep* i18n keys. We render `info`
-  // as the event detail so the user can copy-paste the full trace without
-  // any extra page-state query.
-  function appendAcceptDiagnosticEvents(runId, diagnostics) {
-    for (const entry of diagnostics || []) {
-      const step = entry && entry.step;
-      const info = (entry && entry.info) || {};
-      const titleKey = WritebackSettlement.ACCEPT_DIAGNOSTIC_TITLE_KEYS[step];
-      if (!titleKey) {
-        continue;
-      }
-      const title = titleKey === 'runAcceptTrackedStepReplayStart' || titleKey === 'runAcceptTrackedStepReplayDone'
-        ? tr(titleKey, { path: info.path || tr('unknownFile') })
-        : tr(titleKey);
-      const status = WritebackSettlement.acceptDiagnosticStatus(step, info);
-      appendRunRecordEvent(runId, {
-        title,
-        kind: 'activity',
-        status,
-        detail: info
-      });
-    }
-  }
-
   function buildContentFailure(code, operation, overrides) {
     return WritebackSettlement.buildContentFailure(
       code,
@@ -6940,27 +7483,29 @@
     );
   }
 
-  async function applyTrackedChangeSettlement(runId, kind, result) {
+  async function applyTrackedChangeSettlement(runId, kind, result, options = {}) {
     const record = findRunRecord(runId);
-    const createdUndo = record?.undoOperations?.some(operation => operation?.undoCreatedFile?.v === 1);
-    const run = kind === 'reject' && createdUndo ? advanceRunUndoProgress(record, result) : record;
+    const run = kind === 'reject' ? advanceRunUndoProgress(record, result) : record;
     const settlement = WritebackSettlement.settleTrackedChangeLifecycle({
       kind,
       run,
       result,
       failureReasons: FailureReasons
     });
-    if (settlement.decision === 'blocked' && !(kind === 'reject' && createdUndo)) {
+    if (settlement.decision === 'blocked'
+      && !(kind === 'reject' && (run !== record || record?.undoOperations?.some(Modules.UndoOperations.isFileUndoOperation)))) {
       return;
     }
     await Modules.ScopedPersistenceCoordinator.applyReviewTransition({
       getState: () => state, runId, transition: WritebackSettlement.applySettlementTransition(run, settlement),
-      persist: flushQueuedSaveState
+      persist: flushQueuedSaveState, assertCurrent: options.assertCurrent, SessionState: Modules.SessionState
     });
   }
 
 
   function advanceRunUndoProgress(run, result) {
+    getDirectoryCleanupRecovery().capture({ recordId: run.id, sessionId: state.activeSessionId,
+      runProjectId: run.runProjectId, runAccountScopeId: run.runAccountScopeId }, result);
     const postFiles = buildTrackedUndoPostFiles(run);
     return Modules.UndoOperations.advanceUndoCheckpoint(run, result, file =>
       WritebackSettlement.isUndoVerifiedContentMatching({ undoExpectedFiles: [file] }, result, { postFiles })
@@ -6970,11 +7515,12 @@
     if (!run) {
       return 0;
     }
+    run = Modules.UndoOperations.withAvailableUndo(run);
     const trackedEditorUndoCount = hasTrackedEditorUndo(run) ? 1 : 0;
     if (trackedEditorUndoCount) {
-      return trackedEditorUndoCount + (run.undoOperations || []).filter(operation => operation?.undoCreatedFile?.v === 1).length;
+      return trackedEditorUndoCount + Modules.UndoOperations.getFileUndoOperations(run).length;
     }
-    return (run.undoOperations?.length || 0)
+    return Modules.UndoOperations.prepareRunUndo(run).undoOperations.length
       + (run.undoTrackedChanges?.length || 0);
   }
 
@@ -6986,29 +7532,55 @@
       sessionId: target.sessionId, runId: target.recordId, createdAt: new Date().toISOString() };
   }
 
+  let directoryCleanupRecovery = null;
+  function getDirectoryCleanupRecovery() {
+    return directoryCleanupRecovery || (directoryCleanupRecovery = Modules.DirectoryCleanupRecovery.create({
+      getProjectId: getCurrentProjectId, getAccountScopeId: () => cachedAccountScopeId,
+      getRouteGeneration: () => spaRouteGeneration, findRunRecord, refresh: refreshRunCardControls,
+      onOmitted: (runId, code) => appendRunRecordEvent(runId, { kind: 'technical', status: 'warning',
+        title: tx('Some folder observations exceeded the storage limit; existing observations were kept.',
+          '部分文件夹观测记录超过存储上限，已有记录已保留。'), detail: { code } })
+    }));
+  }
   async function stageWritebackRecovery(operations, target, requireReviewing) {
-    const record = findRunRecord(target.recordId, target.sessionId);
-    if (!record) throw new Error('The writeback run is no longer available.');
+    const owner = recoveryOwner(target), generation = spaRouteGeneration, view = currentRunView;
+    const assertCurrent = () => {
+      const record = findRunRecord(target.recordId, target.sessionId);
+      if (owner.projectId !== getCurrentProjectId() || owner.accountScopeId !== cachedAccountScopeId
+        || generation !== spaRouteGeneration || view !== currentRunView || !view
+        || view.recordId !== owner.runId || view.sessionId !== owner.sessionId
+        || (target.runAccountScopeId && target.runAccountScopeId !== owner.accountScopeId)
+        || !record || record.forkSnapshot || record.runProjectId !== owner.projectId) {
+        throw new Error('The project, account or writeback run changed before dispatch.');
+      }
+      return record;
+    };
+    const record = assertCurrent();
     const creates = operations.filter(op => op.type === 'create' && typeof op.content === 'string');
-    record.retryRequireReviewing = requireReviewing === true; // In-memory; seeds an edit-only retry intent.
+    record.retryRequireReviewing = requireReviewing === true;
     if (!creates.length) return;
-    const candidate = Modules.WritebackIntent.normalize({ ...recoveryOwner(target), id: crypto.randomUUID(),
+    const candidate = Modules.WritebackIntent.normalize({ ...owner, id: crypto.randomUUID(),
       operations: creates, baseFiles: [], requireReviewing });
     const safe = Modules.SessionState.pickWritebackRecovery({ ...record, retryWriteback: candidate }).retryWriteback;
     if (safe) record.retryWriteback = safe; else delete record.retryWriteback;
     await flushQueuedSaveState();
+    assertCurrent();
   }
 
-  async function settleWritebackRecovery(applied, project, verification, target) {
+  async function settleWritebackRecovery(applied, project, verification, target, requireReviewing) {
     const record = findRunRecord(target.recordId, target.sessionId);
     if (!record) return;
+    // retryRequireReviewing is in-memory only; a renormalized run copy loses it.
+    const retryReviewing = typeof requireReviewing === 'boolean' ? requireReviewing
+      : typeof record.retryRequireReviewing === 'boolean' ? record.retryRequireReviewing
+        : record.executionSnapshot?.requireReviewing === true;
     const owner = recoveryOwner(target);
     const skippedPaths = new Set((applied.skipped || []).map(entry => entry.operation?.path));
     const creates = (record.retryWriteback?.operations || []).filter(op => skippedPaths.has(op.path));
     // Untouched edits (never opened / rejected) and deletes whose server check failed are safe to replay.
     const edits = (applied.skipped || []).filter(({ operation: op, result }) => result?.failure?.changedDocument === false && ((op?.type === 'edit'
       && (result.failure.stage === 'navigation' || result.failure.code === 'write_operation_failed')) || (op?.type === 'delete' && result.failure.code === 'source_zip_unavailable'))).map(entry => entry.operation);
-    const base = { ...(record.retryWriteback || { ...owner, id: crypto.randomUUID(), requireReviewing: record.retryRequireReviewing === true }),
+    const base = { ...(record.retryWriteback || { ...owner, id: crypto.randomUUID() }), requireReviewing: retryReviewing,
       baseFiles: project?.files || [], requestId: applied.receiptUnconfirmed ? applied.requestId || '' : '' };
     // An oversized edit pre-image must not cost the create retries (the intent has a 300 KiB ceiling).
     const safeRetry = [[...creates, ...edits], creates].filter(ops => ops.length).map(ops => Modules.SessionState
@@ -7040,32 +7612,43 @@
       || owner.accountScopeId !== cachedAccountScopeId || owner.sessionId !== session.id
       || owner.runId !== record.id || record.undoStatus === 'applied' || record.trackedChangeStatus === 'rejected') return;
     const originalStatus = record.status;
+    const retryAutoRecompile = typeof record.executionSnapshot?.autoRecompile === 'boolean'
+      ? record.executionSnapshot.autoRecompile : undefined;
     // State is renormalized during the awaits below (probes, session sync), which
     // replaces run objects; always write through the current copy.
     const live = () => findRunRecord(runId, session.id) || record;
     let finished = false;
     runCancellationRequested = false;
     runCancellationController = new AbortController();
-    record.status = 'running';
-    record.retryingWriteback = true;
-    renderRunHistory({ preserveScroll: true });
-    const root = panel.querySelector(`[data-run-id="${cssEscape(runId)}"]`);
-    currentRunView = { root, recordId: runId, sessionId: session.id, runProjectId: owner.projectId,
+    const generation = spaRouteGeneration;
+    const requestId = record.nativeRequestId || `writeback:${owner.sessionId}:${runId}`;
+    const ownerToken = crypto.randomUUID();
+    const retryView = { recordId: runId, sessionId: session.id, runProjectId: owner.projectId,
       runAccountScopeId: owner.accountScopeId, executionSnapshot: record.executionSnapshot,
-      startedAt: Date.now(), writebackRetry: true, events: root?.querySelector('[data-run-events]'),
-      report: root?.querySelector('[data-run-report]'), status: root?.querySelector('[data-run-status]'),
-      runProcess: root?.querySelector('[data-run-process]'), processLabel: root?.querySelector('[data-run-process-summary]') };
+      startedAt: Date.now(), writebackRetry: true };
+    currentRunView = retryView;
     setRunning(true);
     const assertOwner = () => {
-      if (runCancellationRequested || currentRunView?.recordId !== runId) {
+      if (runCancellationRequested || currentRunView !== retryView) {
         throw Object.assign(new Error('Save checking was cancelled.'), { code: 'codex_cancelled' });
       }
-      if (owner.projectId !== getCurrentProjectId() || owner.accountScopeId !== cachedAccountScopeId) {
+      if (generation !== spaRouteGeneration || owner.projectId !== getCurrentProjectId() || owner.accountScopeId !== cachedAccountScopeId) {
         throw Object.assign(new Error('The project or account changed.'), { code: 'aborted_project_changed' });
       }
     };
     try {
+      const bound = await activeTurnControl.bindBrowserRun({ requestId, projectKey: owner.projectId,
+        clientRunId: runId, sessionId: session.id, ownerToken });
       assertOwner();
+      if (!bound) throw new Error(tx('Could not start sync. Reload the page and try again.', '无法开始同步，请刷新页面后重试。'));
+      // Publish running only after another page can observe this browser owner.
+      live().status = 'running';
+      live().retryingWriteback = true;
+      renderRunHistory({ preserveScroll: true });
+      const root = panel.querySelector(`[data-run-id="${cssEscape(runId)}"]`);
+      Object.assign(retryView, { root, events: root?.querySelector('[data-run-events]'),
+        report: root?.querySelector('[data-run-report]'), status: root?.querySelector('[data-run-status]'),
+        runProcess: root?.querySelector('[data-run-process]'), processLabel: root?.querySelector('[data-run-process-summary]') });
       if (intent?.requestId) {
         const receipt = await callPageBridge('getWritebackReceipt', { requestId: intent.requestId, runProjectId: owner.projectId });
         if (receipt?.state === 'running') throw new Error(tx('The previous upload is still finishing. Try again shortly.', '上一轮上传仍在收尾，请稍后再试。'));
@@ -7074,8 +7657,11 @@
         // Edits replay against the run's original base files, so the stale guard still refuses changed documents.
         const result = await applySyncChangesToOverleaf(intent.operations.map(op => op.type === 'edit'
           ? { type: 'write', path: op.path, patches: op.patches, content: op.replaceAll } : op.type === 'delete' ? { type: 'delete', path: op.path } : { ...op, type: 'create' }),
-          { id: owner.projectId, files: intent.baseFiles }, { mode: 'auto', requireReviewing: intent.requireReviewing,
-            retryCreates: true, assistantMessage: tx('Retried the remaining file transfers for this task.', '已重试本轮未完成的文件同步。') });
+          // The submitted snapshot owns the write mode; older intents may carry a lost value.
+          { id: owner.projectId, files: intent.baseFiles }, { mode: 'auto', requireReviewing: typeof record.executionSnapshot?.requireReviewing === 'boolean'
+            ? record.executionSnapshot.requireReviewing : intent.requireReviewing,
+            autoRecompile: retryAutoRecompile,
+            retryCreates: true, assistantMessageKey: 'retry_sync', assistantMessage: tx('Retried the remaining file transfers for this task.', '已重试本轮未完成的文件同步。') });
         assertOwner();
         if (result.settlement?.facts) live().settlement = WritebackSettlement.mergeRetrySettlement(live().settlement, result.settlement.facts); // Keep files outside the retry.
         await finishRunView(result.hasSkippedOperations ? tx('Sync incomplete', '同步未完成') : tx('Synced', '已同步'),
@@ -7100,11 +7686,19 @@
     } finally {
       // Only finishRunView settles a new terminal status; every other exit
       // returns the card to the status it had before the retry.
+      if (currentRunView !== retryView) {
+        activeTurnControl.release(requestId, ownerToken);
+        return;
+      }
       for (const copy of new Set([record, live()])) {
         delete copy.retryingWriteback;
         if (!finished && copy.status === 'running') copy.status = originalStatus;
       }
-      if (currentRunView?.recordId === runId) currentRunView = null;
+      saveStateSoon();
+      await flushQueuedSaveState().catch(() => {});
+      activeTurnControl.release(requestId, ownerToken);
+      if (currentRunView !== retryView) return;
+      currentRunView = null;
       runCancellationRequested = false;
       runCancellationController = null;
       setRunning(false);
@@ -7195,7 +7789,9 @@
     });
   }
 
-  function recordUndoFromApply(project, applyResult) {
+  async function recordUndoFromApply(project, applyResult) {
+    const directoryRecovery = Modules.DirectoryCleanupRecovery ? getDirectoryCleanupRecovery() : null;
+    directoryRecovery?.capture(currentRunView, applyResult);
     const appliedEntries = getAppliedEntries(applyResult).filter(entry => entry.result?.idempotent !== true);
     if (!currentRunView?.recordId || !appliedEntries.length) {
       return;
@@ -7210,11 +7806,18 @@
       return;
     }
 
-    const combinedAppliedOperations = [
+    let combinedAppliedOperations = [
       ...(Array.isArray(record.appliedOperations) ? record.appliedOperations : []),
       ...appliedOperations
     ];
+    const checkpoint = buildUndoCheckpoint(project, combinedAppliedOperations);
+    combinedAppliedOperations = checkpoint.appliedOperations;
     record.appliedOperations = combinedAppliedOperations;
+    if (checkpoint.undoUnavailable.length) {
+      appendRunEvent({ title: tr('failureReason_snapshot_undo_unavailable_user'), status: 'warning',
+        detail: checkpoint.undoUnavailable.map(item => ({ [tr('detailFile')]: item.path,
+          [tr('detailReason')]: item.code, [tr('detailNext')]: tr('failureReason_snapshot_undo_unavailable_next') })) });
+    }
     const createdCheckpoint = buildCreatedFileUndoCheckpoint(project, combinedAppliedOperations, record);
 
     if ((currentRunView?.executionSnapshot?.requireReviewing ?? state.requireReviewing) === true) {
@@ -7231,6 +7834,7 @@
         combinedTrackedChanges,
         record.undoExpectedFiles
       );
+      record.undoOperations = Modules.UndoOperations.getFileUndoOperations(record);
       record.undoStatus = '';
       record.partialWriteback = skippedEntries.length > 0;
       // Recording tracked-change refs enters the run into the tracked-change
@@ -7276,7 +7880,6 @@
       return;
     }
 
-    const checkpoint = buildUndoCheckpoint(project, combinedAppliedOperations);
     const createdPaths = new Set(createdCheckpoint.undoOperations.map(operation => operation.path));
     checkpoint.undoOperations = [
       ...checkpoint.undoOperations.filter(operation => !createdPaths.has(operation.path)),
@@ -7286,10 +7889,7 @@
       ...checkpoint.undoBaseFiles.filter(file => !createdPaths.has(file.path)),
       ...createdCheckpoint.undoBaseFiles
     ];
-    if (!checkpoint.undoOperations.length) {
-      return;
-    }
-
+    if (!checkpoint.undoOperations.length && !checkpoint.undoUnavailable.length) return;
     record.undoOperations = checkpoint.undoOperations;
     record.undoBaseFiles = checkpoint.undoBaseFiles;
     record.undoTrackedChanges = [];
@@ -7302,6 +7902,7 @@
     record.undoStatus = '';
     record.partialWriteback = skippedEntries.length > 0;
     refreshRunCardControls(record.id);
+    if (!checkpoint.undoOperations.length) return;
     appendRunEvent({
       title: tr('undoCheckpointPlain', { count: record.undoOperations.length }),
       status: 'completed',
@@ -7363,6 +7964,8 @@
       activity: Modules.RunActivityModel.capture(event, sanitizeAssistantVisibleText),
       guidanceId: sanitizeAssistantVisibleText(event.guidanceId)
     };
+    if (event.failure) normalized.failure = sanitizeAssistantVisibleValue(event.failure);
+    if (event.detailStructured) normalized.detailStructured = sanitizeAssistantVisibleValue(event.detailStructured);
     record.events = [...(record.events || []), normalized].slice(-MAX_RUN_EVENTS);
     saveStateSoon();
 
@@ -7387,21 +7990,8 @@
     refreshRunCardControls(runId);
   }
 
-  function applyLegacyUndoSettlement(runId, undoStatus, result) {
-    const run = findRunRecord(runId);
-    if (!run) return;
-    const checkpoint = run.undoOperations?.some(operation => operation?.undoCreatedFile?.v === 1)
-      ? advanceRunUndoProgress(run, result) : run;
-    Object.assign(run, WritebackSettlement.applySettlementTransition(
-      checkpoint,
-      WritebackSettlement.settleLegacyUndo({
-        run: checkpoint,
-        status: undoStatus,
-        result
-      })
-    ));
-    saveStateSoon();
-    refreshRunCardControls(runId);
+  async function applyLegacyUndoSettlement(runId, undoStatus, result) {
+    return getRunReviewController().applyLegacyUndoSettlement(runId, undoStatus, result);
   }
 
   function refreshRunCardControls(runId) {
@@ -7825,8 +8415,14 @@
       return;
     }
 
+    const groupKey = String(options.groupKey || '');
+    const grouped = groupKey && Array.from(region.children).find(item => item.dataset.groupKey === groupKey);
+    if (grouped) {
+      updateToastGroup(grouped);
+      return;
+    }
     const last = region.lastElementChild;
-    if (last?.classList?.contains('codex-toast') && last.dataset.baseText === value) {
+    if (!groupKey && !last?.dataset.groupKey && last?.classList?.contains('codex-toast') && last.dataset.baseText === value) {
       const repeatCount = Number(last.dataset.repeatCount || '1') + 1;
       last.dataset.repeatCount = String(repeatCount);
       const textNode = last.querySelector('[data-toast-text]');
@@ -7844,15 +8440,34 @@
 
     const body = document.createElement('div');
     body.className = 'codex-toast-body';
-    body.dataset.toastText = 'true';
-    body.textContent = value;
+    if (options.title) {
+      const title = document.createElement('div');
+      title.className = 'codex-toast-title';
+      title.textContent = options.title;
+      body.append(title);
+    }
+    const textNode = document.createElement('div');
+    textNode.dataset.toastText = 'true';
+    textNode.textContent = value;
+    body.append(textNode);
+    if (groupKey) {
+      item.dataset.groupKey = groupKey;
+      const details = document.createElement('details');
+      details.className = 'codex-toast-group';
+      const summary = document.createElement('summary');
+      const list = document.createElement('ul');
+      list.dataset.toastGroupItems = 'true';
+      details.append(summary, list);
+      body.append(details);
+    }
     item.append(body);
+    if (groupKey) updateToastGroup(item);
 
     const close = document.createElement('button');
     close.type = 'button';
     close.className = 'codex-toast-close';
     close.setAttribute('aria-label', tr('dismissNotification'));
-    close.textContent = '×';
+    close.innerHTML = Modules.PanelIcons.svg('close', 'codex-close-glyph');
     close.addEventListener('click', () => item.remove());
     item.append(close);
 
@@ -7866,6 +8481,20 @@
         item.remove();
       }, 5200);
     }
+
+    function updateToastGroup(toast) {
+      const list = toast.querySelector('[data-toast-group-items]');
+      const value = String(options.groupItem || '').trim();
+      if (value && !Array.from(list.children).some(item => item.textContent === value)) {
+        const item = document.createElement('li');
+        const code = document.createElement('code');
+        code.textContent = value;
+        item.append(code);
+        list.append(item);
+      }
+      toast.querySelector('.codex-toast-group summary').textContent =
+        options.groupSummary?.(list.children.length) || String(list.children.length);
+    }
   }
 
   function updateProbeNotice(text) {