codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/content/runQueueScheduler.js

@@ -171,6 +171,25 @@
 
   function createCoordinator(options = {}) {
     let view = null;
+    const guidanceAttempts = new Map();
+    const guidanceKey = (sessionId, itemId) => JSON.stringify([sessionId, itemId]);
+    const matchesGuidanceItem = (item, identity) => item?.id === identity.itemId
+      && item.createdAt === identity.itemCreatedAt && item.text === identity.text
+      && item.clientUserMessageId === identity.clientUserMessageId;
+    const matchesGuidanceScope = expected => {
+      const scope = options.getGuideScope?.();
+      return !expected || ['projectId', 'accountScopeId', 'generation'].every(key => scope?.[key] === expected[key]);
+    };
+    const guideErrorKeys = {
+      codex_turn_not_ready: 'queuedInputGuideNotReady',
+      codex_turn_mismatch: 'queuedInputGuideTurnChanged',
+      codex_steer_empty: 'queuedInputGuideEmpty',
+      codex_steer_too_large: 'queuedInputGuideTooLarge'
+    };
+    function formatGuideError(error) {
+      const key = guideErrorKeys[error?.code];
+      return (key && options.tr?.(key)) || error?.message || options.tr?.('queuedInputGuideFailed');
+    }
     const scheduler = create({
       getQueue: sessionId => options.getSession?.(sessionId)?.pendingInputs || [],
       setQueue: (sessionId, pendingInputs) => options.setQueue?.(sessionId, pendingInputs),
@@ -226,62 +245,143 @@
       const item = (session?.pendingInputs || []).find(entry => entry.id === itemId);
       const run = options.getCurrentRun?.();
       const binding = run?.activeTurn;
-      if (!session || !item || !run || run.sessionId !== session.id || !binding?.threadId || !binding?.turnId) {
+      const initialScope = options.getGuideScope?.();
+      const guideScope = initialScope ? { ...initialScope } : null;
+      if (!session || !item || item.status !== 'queued' || !run || run.sessionId !== session.id || !binding?.threadId || !binding?.turnId) {
         options.toast?.(options.tr?.('queuedInputGuideUnavailable'), 'warning');
         return;
       }
+      const identity = { requestId: run.nativeRequestId, threadId: binding.threadId, turnId: binding.turnId,
+        projectKey: run.runProjectId, recordId: run.recordId, sessionId: session.id, sessionCreatedAt: session.createdAt,
+        itemId, itemCreatedAt: item.createdAt, text: item.text, clientUserMessageId: item.clientUserMessageId };
+      const attemptKey = guidanceKey(identity.sessionId, itemId);
+      const attempt = { identity, scope: guideScope, previewToken: null };
+      const sameScope = () => matchesGuidanceScope(guideScope);
+      const ownedSession = () => {
+        const latest = options.getSession?.(identity.sessionId);
+        return sameScope() && latest?.createdAt === identity.sessionCreatedAt ? latest : null;
+      };
+      const ownedItemSession = (allowPaused = false) => {
+        const latest = ownedSession();
+        const current = latest?.pendingInputs?.find(entry => entry.id === itemId);
+        return guidanceAttempts.get(attemptKey) === attempt
+          && (current?.status === 'steering' || (allowPaused && current?.status === 'paused'))
+          && matchesGuidanceItem(current, identity) ? latest : null;
+      };
+      function clearPreview() {
+        const token = attempt.previewToken;
+        attempt.previewToken = null;
+        if (token) options.clearGuidancePreview?.(token);
+      }
+      const assertCurrent = () => {
+        const currentRun = options.getCurrentRun?.();
+        if (options.isGuideCancelled?.() || currentRun !== run || options.getActiveSession?.()?.id !== identity.sessionId
+          || currentRun?.nativeRequestId !== identity.requestId
+          || currentRun?.recordId !== identity.recordId || currentRun?.runProjectId !== identity.projectKey
+          || currentRun?.activeTurn?.threadId !== identity.threadId || currentRun?.activeTurn?.turnId !== identity.turnId
+          || !ownedItemSession()) {
+          throw Object.assign(new Error(options.tr?.('queuedInputGuideUnavailable') || 'Guidance is no longer available for this turn.'), { code: 'codex_turn_mismatch' });
+        }
+      };
+      async function restoreUnsent(error) {
+        // No steer was dispatched. Restore only this attempt's still-owned item;
+        // a concurrent removal, replacement or scope switch must stay untouched.
+        clearPreview();
+        const latest = ownedItemSession();
+        if (latest) {
+          options.setQueue?.(identity.sessionId, Queue.returnToQueue(latest.pendingInputs, itemId));
+          render();
+          try {
+            await options.save?.({ queueMutation: { type: 'transition', sessionId: identity.sessionId, itemId } });
+          } catch (recoveryError) {
+            if (error && typeof error === 'object') error.persistenceRecoveryError = recoveryError?.message || String(recoveryError);
+          }
+        }
+      }
       options.setQueue?.(session.id, Queue.markSteering(session.pendingInputs, itemId));
-      render();
-      await options.save?.({
-        queueMutation: { type: 'transition', sessionId: session.id, itemId }
-      });
+      guidanceAttempts.set(attemptKey, attempt);
       try {
-        const response = await options.sendSteer?.({
-          requestId: run.nativeRequestId,
-          projectKey: run.runProjectId,
-          threadId: binding.threadId,
-          expectedTurnId: binding.turnId,
-          clientUserMessageId: item.clientUserMessageId,
-          input: [{ type: 'text', text: item.text }]
-        });
-        const latest = options.getSession?.(session.id);
-        options.setQueue?.(
-          session.id,
-          response?.ok
-            ? Queue.remove(latest?.pendingInputs || [], itemId)
-            : Queue.returnToQueue(latest?.pendingInputs || [], itemId, response?.error?.code || 'steer_failed')
+        try {
+          attempt.previewToken = options.previewGuidance?.(identity.text, {
+            guidanceId: itemId, sessionId: identity.sessionId, recordId: identity.recordId,
+            sessionCreatedAt: identity.sessionCreatedAt
+          });
+          render();
+          const preflight = await options.preflightGuide?.({ task: identity.text, assertCurrent });
+          assertCurrent();
+          if (preflight?.blocked) throw Object.assign(new Error('Guidance was blocked before dispatch.'), { guidanceBlocked: true });
+          await options.save?.({
+            queueMutation: { type: 'transition', sessionId: identity.sessionId, itemId }
+          });
+          assertCurrent();
+        } catch (error) {
+          await restoreUnsent(error);
+          if (error?.guidanceBlocked) return { ok: false, blocked: true };
+          throw error;
+        }
+        let response;
+        try {
+          response = await options.sendSteer?.({
+            requestId: identity.requestId,
+            projectKey: identity.projectKey,
+            threadId: identity.threadId,
+            expectedTurnId: identity.turnId,
+            clientUserMessageId: identity.clientUserMessageId,
+            input: [{ type: 'text', text: identity.text }]
+          }, { assertCurrent });
+        } catch (error) {
+          if (error?.requestDispatched === false) { await restoreUnsent(error); throw error; }
+          clearPreview();
+          const latest = ownedItemSession(true);
+          if (latest) {
+            const paused = latest.pendingInputs.map(entry => entry.id === itemId
+              ? { ...entry, status: 'paused', pauseReason: 'steer_delivery_unknown' }
+              : entry);
+            options.setQueue?.(identity.sessionId, Queue.normalizeQueue(paused));
+          }
+          options.toast?.(formatGuideError(error), 'warning');
+          render();
+          if (latest) await options.save?.({
+            queueMutation: { type: 'transition', sessionId: identity.sessionId, itemId }
+          });
+          return;
+        }
+        // Cancellation can pause the owned row while a dispatched steer is
+        // awaiting acknowledgement. A confirmed receipt also consumes that
+        // paused copy, so Resume cannot send an already accepted input again.
+        const latest = ownedItemSession(Boolean(response?.ok));
+        if (latest) options.setQueue?.(
+          identity.sessionId,
+          response?.ok ? Queue.remove(latest.pendingInputs, itemId)
+            : Queue.returnToQueue(latest.pendingInputs, itemId, response?.error?.code || 'steer_failed')
         );
         if (response?.ok) {
-          if (typeof options.appendGuidance === 'function') {
-            options.appendGuidance(item.text, {
-              guidanceId: item.id,
-              sessionId: session.id,
-              recordId: run.recordId,
-              status: 'completed'
+          if (ownedSession() && typeof options.appendGuidance === 'function') {
+            options.appendGuidance(identity.text, {
+              guidanceId: itemId, sessionId: identity.sessionId, recordId: identity.recordId,
+              sessionCreatedAt: identity.sessionCreatedAt, status: 'completed',
+              timestamp: attempt.previewToken?.event?.timestamp
             });
-          } else {
+          } else if (ownedSession() && options.getCurrentRun?.() === run) {
             options.appendEvent?.(options.tr?.('queuedInputGuided'), 'completed');
           }
         } else {
-          options.toast?.(response?.error?.message || options.tr?.('queuedInputGuideFailed'), 'warning');
+          options.toast?.(formatGuideError(response?.error), 'warning');
         }
+        clearPreview();
         render();
-        await options.save?.({
+        // A Native acknowledgement is final delivery evidence. A later local
+        // save failure must not turn it into an unknown delivery or resend it.
+        if (latest) await options.save?.({
           queueMutation: response?.ok
-            ? { type: 'remove', sessionId: session.id, itemId }
-            : { type: 'transition', sessionId: session.id, itemId }
+            ? { type: 'remove', sessionId: identity.sessionId, itemId }
+            : { type: 'transition', sessionId: identity.sessionId, itemId }
         });
-      } catch (error) {
-        const latest = options.getSession?.(session.id);
-        const paused = (latest?.pendingInputs || []).map(entry => entry.id === itemId
-          ? { ...entry, status: 'paused', pauseReason: 'steer_delivery_unknown' }
-          : entry);
-        options.setQueue?.(session.id, Queue.normalizeQueue(paused));
-        options.toast?.(error?.message || options.tr?.('queuedInputGuideFailed'), 'warning');
+        else if (response?.ok && ownedSession()) await options.save?.();
+      } finally {
+        clearPreview();
+        if (guidanceAttempts.get(attemptKey) === attempt) guidanceAttempts.delete(attemptKey);
         render();
-        await options.save?.({
-          queueMutation: { type: 'transition', sessionId: session.id, itemId }
-        });
       }
     }
 
@@ -320,7 +420,7 @@
         view = options.createView?.({
           container,
           tr: options.tr,
-          onGuide: itemId => guide(itemId).catch(error => options.toast?.(error.message, 'warning')),
+          onGuide: itemId => guide(itemId).catch(error => options.toast?.(formatGuideError(error), 'warning')),
           onRemove: remove,
           onResume: resume,
           onToast: message => options.toast?.(message, 'warning')
@@ -331,19 +431,29 @@
       }
       const session = options.getActiveSession?.();
       const run = options.getCurrentRun?.();
-      view?.render?.(session?.pendingInputs || [], {
+      const visibleQueue = (session?.pendingInputs || []).filter(item => {
+        const attempt = guidanceAttempts.get(guidanceKey(session.id, item.id));
+        return !attempt?.previewToken || !['steering', 'paused'].includes(item.status)
+          || !matchesGuidanceScope(attempt.scope)
+          || session.createdAt !== attempt.identity.sessionCreatedAt || !matchesGuidanceItem(item, attempt.identity);
+      });
+      view?.render?.(visibleQueue, {
         running: Boolean(run),
         canGuide: Boolean(run?.activeTurn?.turnId)
       });
     }
 
     async function startQueuedInput(item, sessionId) {
-      if (options.canStart?.(sessionId) === false || options.getCurrentRun?.()) {
-        const error = new Error('Queued input cannot start in the current session.');
-        error.code = 'queue_session_not_active';
-        throw error;
-      }
+      const assertCanStart = () => {
+        if (options.canStart?.(sessionId) === false || options.getCurrentRun?.()) {
+          const error = new Error('Queued input cannot start in the current session.');
+          error.code = 'queue_session_not_active';
+          throw error;
+        }
+      };
+      assertCanStart();
       await options.applyQueuedInput?.(item);
+      assertCanStart();
       await options.run?.(item);
     }
 

package/extension/src/content/runRecoveryActions.js

@@ -0,0 +1,147 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexOverleafModuleRegistry.define('RunRecoveryActions', [], factory);
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+
+  function formatForceCancelOutcome(response, tx) {
+    if (response?.ok !== true) return tx('Release failed — refresh the tab, then try again.', '释放失败，请刷新页面后重试。');
+    const result = response.result || response;
+    if (result.lockReleased === true) return tx('Force-released — you can retry the run.', '已释放，可以重试本轮任务。');
+    if (result.cancelled === true) return tx('Cancellation requested. Wait for the task to stop before retrying.', '已请求取消，请等待任务停止后再重试。');
+    if (result.cancelled === false) return tx('No active task matched the release request.', '没有发现与释放请求匹配的活动任务。');
+    if (result.sent === true) return tx('Cancellation request sent; release is not yet confirmed.', '取消请求已发送，释放状态尚未确认。');
+    return tx('Release is not yet confirmed. Check the current task before retrying.', '释放状态尚未确认，请检查当前任务后再重试。');
+  }
+
+  function create(deps = {}) {
+    const { tx, failureNotice, refillComposerForRetry, openProjectFileForFailure, showNativeSetupGuidance,
+      openStorageSettings, forceCancelStuckTaskForCurrentProject } = deps;
+    const document = deps.document || globalThis.document;
+    const window = deps.window || globalThis.window;
+
+  const RETRYABLE_FAILURE_CODES = new Set([
+    'native_request_failed', 'codex_timeout', 'codex_no_usable_result',
+    'codex_output_limit', 'codex_context_limit', 'stale_source_changed', 'patch_anchor_not_found',
+    'target_editor_not_ready', 'write_timeout', 'partial_write_needs_review',
+    'write_operation_failed'
+  ]);
+  const NATIVE_SETUP_FAILURE_CODES = new Set([
+    'native_bridge_unavailable', 'native_protocol_incompatible'
+  ]);
+  const OPEN_FILE_FAILURE_CODES = new Set([
+    'target_file_not_active', 'target_file_open_failed', 'target_file_not_found'
+  ]);
+  const STORAGE_FAILURE_CODES = new Set([
+    'storage_quota_exceeded', 'run_state_persist_failed'
+  ]);
+  // A missing `codex` binary is fixed in the terminal, not the panel — the
+  // action opens the README troubleshooting section (PATH / login checks).
+  const CODEX_INSTALL_FAILURE_CODES = new Set(['codex_not_found']);
+  const CODEX_CLI_TROUBLESHOOTING_URL = 'https://github.com/Ghqqqq/codex-overleaf-link#faq-and-troubleshooting';
+
+  function buildRecoveryButton(failureCode, label, title) {
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'run-final-answer__recovery-action';
+    button.dataset.recoveryFor = failureCode;
+    button.textContent = label;
+    if (title) {
+      button.title = title;
+    }
+    return button;
+  }
+
+  function appendEditAndResend(report, run, actionKey) {
+    const retry = buildRecoveryButton(actionKey,
+      tx('Edit & resend', '编辑后重发'),
+      tx('Put this run\u2019s task back into the composer so you can adjust and resend it.', '把本轮任务填回输入框，修改后可直接重发。'));
+    retry.dataset.recoveryAction = 'edit-resend';
+    retry.addEventListener('click', clickEvent => {
+      clickEvent.stopPropagation();
+      refillComposerForRetry(run || null);
+    });
+    report.append(retry);
+  }
+
+  function appendRecoveryActionForFailure(report, event, run) {
+    const recovery = failureNotice?.prepareRecovery(report, { openFile: openProjectFileForFailure });
+    const failure = recovery?.failure || event?.failure;
+    const failureCode = failure?.code || '';
+    if (recovery?.handled) return;
+    report = recovery?.target || report;
+    if (RETRYABLE_FAILURE_CODES.has(failureCode) && typeof refillComposerForRetry === 'function') {
+      appendEditAndResend(report, run, failureCode);
+      return;
+    }
+    if (NATIVE_SETUP_FAILURE_CODES.has(failureCode) && typeof showNativeSetupGuidance === 'function') {
+      const fix = buildRecoveryButton(failureCode,
+        tx('Fix the native host', '修复 native host'),
+        tx('Opens the install/update guidance with the copyable command.', '打开安装/更新指引（含可复制命令）。'));
+      fix.addEventListener('click', clickEvent => {
+        clickEvent.stopPropagation();
+        showNativeSetupGuidance();
+      });
+      report.append(fix);
+      return;
+    }
+    if (OPEN_FILE_FAILURE_CODES.has(failureCode) && failure?.file && typeof openProjectFileForFailure === 'function') {
+      const open = buildRecoveryButton(failureCode,
+        tx(`Open ${failure.file} in Overleaf`, `在 Overleaf 打开 ${failure.file}`), '');
+      open.addEventListener('click', clickEvent => {
+        clickEvent.stopPropagation();
+        openProjectFileForFailure(failure.file);
+      });
+      report.append(open);
+      return;
+    }
+    if (STORAGE_FAILURE_CODES.has(failureCode) && typeof openStorageSettings === 'function') {
+      const clean = buildRecoveryButton(failureCode,
+        tx('Open history & storage cleanup', '打开历史与存储清理'), '');
+      clean.addEventListener('click', clickEvent => {
+        clickEvent.stopPropagation();
+        openStorageSettings();
+      });
+      report.append(clean);
+      return;
+    }
+    if (CODEX_INSTALL_FAILURE_CODES.has(failureCode)) {
+      const guide = buildRecoveryButton(failureCode,
+        tx('Codex CLI troubleshooting guide', '查看 Codex CLI 排查指引'),
+        tx('Opens the README section on fixing a missing `codex` command (PATH / login).', '打开 README 中「找不到 codex 命令」的排查说明（PATH／登录）。'));
+      guide.addEventListener('click', clickEvent => {
+        clickEvent.stopPropagation();
+        window.open(CODEX_CLI_TROUBLESHOOTING_URL, '_blank', 'noopener');
+      });
+      report.append(guide);
+      return;
+    }
+    if (failureCode !== 'codex_project_locked') return;
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'run-final-answer__recovery-action';
+    button.dataset.recoveryFor = failureCode;
+    button.textContent = tx('Force-release the stuck task', '强制释放卡住的任务');
+    button.title = tx(
+      'Requests cancellation for this project. A sent request does not confirm that the task has stopped. Use this when refreshing the tab did not free the project.',
+      '请求取消当前项目的任务；请求已发送不代表任务已经停止。刷新页面仍未解除占用时使用。'
+    );
+    button.addEventListener('click', event => {
+      event.stopPropagation();
+      button.disabled = true;
+      button.textContent = tx('Releasing…', '正在释放…');
+      forceCancelStuckTaskForCurrentProject().then(result => {
+        button.textContent = formatForceCancelOutcome(result, tx);
+        button.disabled = result?.ok === true;
+      }).catch(() => {
+        button.disabled = false;
+        button.textContent = tx('Release failed — refresh the tab, then try again.', '释放失败，请刷新页面后重试。');
+      });
+    });
+    report.append(button);
+  }
+
+    return { buildRecoveryButton, appendRecoveryActionForFailure };
+  }
+  return { create, formatForceCancelOutcome };
+});

package/extension/src/content/runResultActions.js

@@ -1,14 +1,15 @@
-(function initCodexOverleafRunResultActions(root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  if (root) root.CodexOverleafRunResultActions = api;
-})(typeof window !== 'undefined' ? window : globalThis, function runResultActionsFactory() {
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory(require('./runCompletionMeta'));
+  else root.CodexOverleafModuleRegistry.define('RunResultActions', ['RunCompletionMeta'], factory);
+})(typeof window !== 'undefined' ? window : globalThis, function (RunCompletionMeta) {
   'use strict';
 
+  const { splitFlatCompletionReport, projectNotStartedRun, projectFinishedRun, projectCompletionConclusion, projectCompletionBody, projectCompletionMeta, summarizeCompletionMeta } = RunCompletionMeta;
+
+
   function create(deps = {}) {
     const {
       tr,
-      getLocale,
       forkRunFromNode,
       document: documentRef = globalThis.document,
       navigator: navigatorRef = globalThis.navigator
@@ -19,11 +20,27 @@
       const reports = root.querySelectorAll('.run-completion-report');
       const report = reports[reports.length - 1];
       if (!actions || !report) return;
-      report.append(actions);
+      // Share one row with the facts summary when it exists; the expandable
+      // details list stays below both.
+      const factsToggle = report.querySelector(':scope > .run-final-answer__facts > .run-final-answer__facts-sum');
+      if (factsToggle) factsToggle.after(actions);
+      else {
+        // Without a facts summary, the report's own Details toggle shares the row.
+        const details = report.querySelector(':scope > .run-outcome-details, :scope > .run-outcome-footer > .run-outcome-details');
+        if (details) {
+          let footer = details.parentElement.matches('.run-outcome-footer') ? details.parentElement : null;
+          if (!footer) {
+            footer = documentRef.createElement('div');
+            footer.className = 'run-outcome-footer';
+            details.before(footer);
+            footer.append(details);
+          }
+          footer.append(actions);
+        } else report.append(actions);
+      }
       actions.hidden = false;
       configureCopyButton(root);
       configureForkButton(root, run);
-      configureCompletedTime(actions, run);
     }
 
     function configureForkButton(root, run) {
@@ -38,7 +55,7 @@
       button.disabled = !available;
       button.title = tr(available ? 'forkRunTitle' : 'forkRunUnavailable');
       button.setAttribute('aria-label', button.title);
-      button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><path d="M3 10h3.5c3.5 0 4.2-4 7.5-4h2m-2.5-2.5L16 6l-2.5 2.5M6.5 10c3.5 0 4.2 4 7.5 4h2m-2.5-2.5L16 14l-2.5 2.5"/></svg>';
+      button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><path transform="translate(.5 0)" d="M3 10h3.5c3.5 0 4.2-4 7.5-4h2m-2.5-2.5L16 6l-2.5 2.5M6.5 10c3.5 0 4.2 4 7.5 4h2m-2.5-2.5L16 14l-2.5 2.5"/></svg>';
       if (!available) return;
       button.addEventListener('click', async event => {
         event.stopPropagation();
@@ -53,19 +70,6 @@
       });
     }
 
-    function configureCompletedTime(actions, run) {
-      const target = actions.querySelector('[data-run-completed-time]');
-      const finishedAt = String(run.finishedAt || '').trim();
-      const date = finishedAt ? new Date(finishedAt) : null;
-      if (!target || !date || !Number.isFinite(date.getTime())) return;
-      target.hidden = false;
-      target.textContent = new Intl.DateTimeFormat(getLocale(), {
-        hour: '2-digit',
-        minute: '2-digit'
-      }).format(date);
-      target.title = date.toLocaleString(getLocale());
-    }
-
     function configureCopyButton(root) {
       const existing = root.querySelector('[data-run-copy]');
       const button = existing.cloneNode(true);
@@ -76,7 +80,7 @@
       button.disabled = !copyText;
       button.title = tr('copyConclusionTitle');
       button.setAttribute('aria-label', button.title);
-      button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><rect x="6.5" y="6.5" width="9" height="9" rx="2"/><path d="M13.5 6.5V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6.5a2 2 0 0 0 2 2h1.5"/></svg>';
+      button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><g transform="translate(.75 .75)"><rect x="6.5" y="6.5" width="9" height="9" rx="2"/><path d="M13.5 6.5V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6.5a2 2 0 0 0 2 2h1.5"/></g></svg>';
       if (!copyText) return;
       button.addEventListener('click', async event => {
         event.stopPropagation();
@@ -107,128 +111,9 @@
       if (!copied) throw new Error('clipboard_copy_failed');
     }
 
-    return Object.freeze({ configureResultActions, projectUndoAvailability, splitFlatCompletionReport, projectCompletionMeta, summarizeCompletionMeta });
-  }
-
-
-  const FLAT_REPORT_STATUS_SECTIONS = [
-    { key: 'saveState', prefixes: ['Save:', '保存：'], en: 'Save', zh: '保存' },
-    { key: 'unchangedReason', prefixes: ['Why nothing changed:', '未修改原因：'], en: 'Why nothing changed', zh: '未修改原因' },
-    { key: 'writeResult', prefixes: ['Write result:', '写入结果：'], en: 'Write result', zh: '写入结果' },
-    { key: 'undo', prefixes: ['Undo:', '可撤销：'], en: 'Undo', zh: '可撤销' },
-    { key: 'nextStep', prefixes: ['Next:', '下一步：'], en: 'Next', zh: '下一步' }
-  ];
-
-  function splitFlatCompletionReport(text, tx = value => value) {
-    const raw = typeof text === 'string' ? text : '';
-    if (!raw.trim()) return { body: raw, meta: [] };
-    const bodySections = [], meta = [];
-    for (const section of raw.split(/\n{2,}/)) {
-      const trimmed = section.trim();
-      if (!trimmed) continue;
-      const entry = trimmed.includes('\n') ? null
-        : FLAT_REPORT_STATUS_SECTIONS.find(item => item.prefixes.some(prefix => trimmed.startsWith(prefix)));
-      if (entry) {
-        const prefix = entry.prefixes.find(value => trimmed.startsWith(value));
-        const value = trimmed.slice(prefix.length).trim();
-        if (value) {
-          meta.push({ key: entry.key, label: tx(entry.en, entry.zh), value });
-          continue;
-        }
-      }
-      bodySections.push(trimmed);
-    }
-    return { body: bodySections.join('\n\n'), meta };
-  }
-
-  function projectCompletionMeta(meta, run, options) {
-    const { tx, trackedChangeInFlight, isTrackedChangeLifecycleRun, projectRunSettlement } = options;
-    if (!Array.isArray(meta) || !run) return meta;
-    const undone = run.undoStatus === 'applied' || run.trackedChangeStatus === 'rejected';
-    const rows = undone ? meta.filter(row => row?.key !== 'saveState') : meta;
-    const inFlight = trackedChangeInFlight?.get(run.id);
-    const tracked = isTrackedChangeLifecycleRun(run);
-    const pendingCreatedUndo = tracked && run.trackedChangeStatus === 'needs_review' && run.undoOperations?.some(operation => operation?.undoCreatedFile?.v === 1);
-    let undo;
-    if (run.undoStatus === 'running' || inFlight === 'reject') {
-      undo = tx('Undoing changes...', '正在撤销修改…');
-    } else if (run.undoStatus === 'applied' || (tracked && run.trackedChangeStatus === 'rejected')) {
-      undo = tx('This run\'s changes have been undone.', '本轮修改已撤销。');
-    } else if (tracked && run.trackedChangeStatus === 'accepted') {
-      undo = tx('Changes accepted; undo is no longer available.', '修改已接受，无法再撤销。');
-    } else if (run.undoStatus === 'partial' || pendingCreatedUndo) {
-      undo = hasUndoProgress(run)
-        ? projectRunSettlement(run).canUndo
-          ? tx(pendingCreatedUndo ? 'Some changes were undone; retry the remaining files.' : 'Some changes were undone; remaining changes can still be undone.', pendingCreatedUndo ? '已撤销部分修改，可重试剩余文件。' : '已撤销部分修改，剩余修改仍可撤销。')
-          : tx('Some changes were undone.', '已撤销部分修改。')
-        : projectRunSettlement(run).canUndo
-          ? tx(pendingCreatedUndo ? 'Undo is incomplete; retry the remaining files.' : 'Undo is incomplete; remaining changes can still be undone.', pendingCreatedUndo ? '撤销未完成，可重试剩余文件。' : '撤销未完成，剩余修改仍可撤销。')
-          : tx('Undo is incomplete.', '撤销未完成。');
-    }
-    if (!undo && !run.saveCheck && !run.saveConfirmedAt) return rows;
-    return rows.map(row => row?.key === 'undo' && undo
-      ? { ...row, label: tx('Undo', '撤销'), value: undo }
-      : row?.key === 'saveState' && (run.saveCheck || run.saveConfirmedAt)
-        ? { ...row, label: tx('Save', '保存'), value: run.saveCheck
-          ? tx('Pending confirmation', '待确认') : tx('Saved', '已确认保存') }
-        : row);
-  }
-
-  function hasUndoProgress(run) {
-    const failures = run?.settlement?.failures || run?.settlementFacts?.failures || [];
-    return (Array.isArray(run?.events) ? run.events : []).some(event => {
-      if (!['completed', 'failed'].includes(event?.status) || event.streamRole || ['report', 'guidance', 'stream'].includes(event.kind)) return false;
-      const count = String(event.title || '').match(/^(?:Undo result: (?:undone|rejected) (\d+) (?:item\(s\)|file\(s\)|tracked change\(s\)), skipped \d+(?: item\(s\))?|撤销结果：已(?:撤销|拒绝) (\d+) (?:项|条留痕|个文件)，跳过 \d+ (?:项|条))$/);
-      if (!(Number(count?.[1] || count?.[2]) > 0)) return false;
-      const detail = event.detail || {}, applied = detail.Undone || detail.Rejected || detail['已撤销'] || detail['已拒绝'];
-      const skipped = detail.Skipped || detail['跳过'], path = item => item?.File || item?.['文件'];
-      return Array.isArray(applied) && Array.isArray(skipped) && applied.some(item =>
-        typeof path(item) === 'string' && path(item).trim() && !skipped.some(other => path(other) === path(item))
-        && !(Array.isArray(failures) && failures.some(failure => failure?.code === 'undo_not_verified'
-          && (!failure.file || failure.file === path(item)))));
-    });
+    return Object.freeze({ configureResultActions, projectUndoAvailability, splitFlatCompletionReport, projectNotStartedRun, projectFinishedRun, projectCompletionConclusion, projectCompletionBody, projectCompletionMeta, summarizeCompletionMeta });
   }
 
-  // Generic reasons say nothing beyond "no files were written", so they stay in
-  // the details. Both locales match because a report keeps its original locale.
-  const GENERIC_UNCHANGED_REASONS = new Set([
-    'No file changes need to sync back to Overleaf.', '没有产生需要同步回 Overleaf 的文件改动。',
-    'No approved file changes remain to sync back to Overleaf.', '没有剩余已确认的文件改动需要同步回 Overleaf。',
-    'This run was Ask mode.', '这轮是只问不改。'
-  ]);
-
-  // One summary line for the meta rows: what was written, whether it can be
-  // undone, and a pending save. The rows themselves stay behind the disclosure,
-  // which opens by itself only when something needs the user's attention.
-  function summarizeCompletionMeta(rows, run, { tx, failed = false, unconfirmed = false } = {}) {
-    const find = key => String(rows.find(row => row?.key === key)?.value || '').trim();
-    const counts = find('writeResult').match(/wrote (\d+) items?, skipped (\d+)|已写入 (\d+) 项，跳过 (\d+) 项/);
-    const wrote = Number(counts?.[1] ?? counts?.[3] ?? 0), skipped = Number(counts?.[2] ?? counts?.[4] ?? 0);
-    const reason = find('unchangedReason');
-    const undone = run?.undoStatus === 'applied' || run?.trackedChangeStatus === 'rejected';
-    const savePending = !undone && (Boolean(run?.saveCheck) || (!run?.saveConfirmedAt && /^(?:Pending|待确认)/.test(find('saveState'))));
-    const pendingCreatedUndo = run?.trackedChangeStatus === 'needs_review'
-      && run.undoOperations?.some(operation => operation?.undoCreatedFile?.v === 1);
-    const facts = [];
-    if (failed) facts.push({ key: 'write', tone: 'fail', text: unconfirmed ? tx('Write not confirmed', '写入结果未确认') : tx('Write incomplete', '写入未完成') });
-    else if (wrote) facts.push({ key: 'write', text: tx(`Wrote ${wrote} item${wrote === 1 ? '' : 's'}`, `已写入 ${wrote} 项`) });
-    else if (reason && !GENERIC_UNCHANGED_REASONS.has(reason)) facts.push({ key: 'write', text: tx('Not written: ', '未写入：') + reason.replace(/[.。]$/, '') });
-    else facts.push({ key: 'write', text: tx('No files written', '未写入文件') });
-    if (skipped) facts.push({ key: 'skip', tone: 'warn', text: tx(`${skipped} skipped`, `跳过 ${skipped} 项`) });
-    const undoable = Number(find('undo').match(/(\d+)/)?.[1] || 0);
-    const undo = run?.undoStatus === 'running' || /^(?:Undoing changes\.\.\.|正在撤销修改…)$/.test(find('undo')) ? tx('Undoing…', '正在撤销…')
-      : run?.undoStatus === 'applied' || run?.trackedChangeStatus === 'rejected' ? tx('Changes undone', '已撤销本轮修改')
-        : run?.trackedChangeStatus === 'accepted' ? tx('Changes accepted', '修改已接受')
-          : pendingCreatedUndo || run?.undoStatus === 'partial'
-            ? (hasUndoProgress(run) ? tx('Partly undone', '已撤销部分修改') : tx('Undo incomplete', '撤销未完成'))
-            : undoable ? tx(`${undoable} undoable`, `可撤销 ${undoable} 项`)
-              : failed ? '' : tx('Nothing to undo', '无可撤销写入');
-    if (undo) facts.push({ key: 'undo', text: undo });
-    if (savePending) facts.push({ key: 'save', tone: 'warn', text: tx('Save pending', '保存待确认') });
-    const attention = failed || skipped > 0;
-    const warnKeys = new Set([...(attention ? ['writeResult', 'nextStep'] : []), ...(savePending ? ['saveState'] : [])]);
-    return { facts, open: attention, warnKeys };
-  }
 
   function projectUndoAvailability(run, projectRunSettlement) {
     const payload = run.recoveryPayload && typeof run.recoveryPayload === 'object'