codex-overleaf-link 2.5.1 → 2.6.0

package/extension/src/content/runRecoveryActions.js

@@ -22,7 +22,7 @@
 
   const RETRYABLE_FAILURE_CODES = new Set([
     'native_request_failed', 'codex_timeout', 'codex_no_usable_result',
-    'codex_output_limit', 'stale_source_changed', 'patch_anchor_not_found',
+    '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'
   ]);
@@ -56,6 +56,7 @@
     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);

package/extension/src/content/runResultActions.js

@@ -4,13 +4,12 @@
 })(typeof window !== 'undefined' ? window : globalThis, function (RunCompletionMeta) {
   'use strict';
 
-  const { splitFlatCompletionReport, projectCompletionBody, projectCompletionMeta, summarizeCompletionMeta } = RunCompletionMeta;
+  const { splitFlatCompletionReport, projectNotStartedRun, projectFinishedRun, projectCompletionConclusion, projectCompletionBody, projectCompletionMeta, summarizeCompletionMeta } = RunCompletionMeta;
 
 
   function create(deps = {}) {
     const {
       tr,
-      getLocale,
       forkRunFromNode,
       document: documentRef = globalThis.document,
       navigator: navigatorRef = globalThis.navigator
@@ -21,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) {
@@ -40,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();
@@ -55,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);
@@ -78,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();
@@ -109,7 +111,7 @@
       if (!copied) throw new Error('clipboard_copy_failed');
     }
 
-    return Object.freeze({ configureResultActions, projectUndoAvailability, splitFlatCompletionReport, projectCompletionBody, projectCompletionMeta, summarizeCompletionMeta });
+    return Object.freeze({ configureResultActions, projectUndoAvailability, splitFlatCompletionReport, projectNotStartedRun, projectFinishedRun, projectCompletionConclusion, projectCompletionBody, projectCompletionMeta, summarizeCompletionMeta });
   }
 
 

package/extension/src/content/runReviewController.js

@@ -58,9 +58,12 @@
       if (Modules.StorageDb?.sharedSessionsEnabled?.() !== true) return;
       findRunRecord(runId).undoOwnerProtocol = 1;
       try { await flushQueuedSaveState({ requireDurable: true, reviewRunIds: [runId] }); }
-      catch (cause) { throw Object.assign(new Error('The Undo owner marker could not be durably saved.'), { code: 'review_state_not_persisted', cause }); }
+      catch (cause) {
+        if (cause.code === 'shared_session_conflict' && cause.durableReviewRunIds?.includes(runId)) notify?.(cause.message);
+        else throw Object.assign(new Error('The Undo owner marker could not be durably saved.'), { code: 'review_state_not_persisted', cause });
+      }
       reviewOwners.get(runId)?.();
-      const saved = await Modules.StorageDb.getRecord('sessions', getState().activeSessionId);
+      const saved = await Modules.StorageDb.getRecord('sessions', getState().activeSessionId, { adopt: false });
       if (saved?.runs?.find(run => run.id === runId)?.undoOwnerProtocol !== 1)
         throw Object.assign(new Error('The Undo owner marker was not durably retained.'), { code: 'review_state_not_persisted' });
       reviewOwners.get(runId)?.();
@@ -68,7 +71,7 @@
     async function withSharedReviewOwnership(runId, work) {
       const db = Modules.StorageDb;
       if (db?.sharedSessionsEnabled?.() !== true) return work();
-      const run = findRunRecord(runId);
+      let run = findRunRecord(runId);
       if (!run || trackedChangeInFlight.has(runId)) return;
       const assertCurrent = undoOwner(run);
       const sessionId = getState().activeSessionId;
@@ -77,8 +80,9 @@
         reviewOwners.set(runId, assertOwner);
         try {
           assertCurrent();
-          const session = await db.getRecord('sessions', sessionId);
-          assertCurrent();
+          // Only the run is refreshed here; keep the visible session's merge baseline.
+          const session = await db.getRecord('sessions', sessionId, { adopt: false });
+          run = assertCurrent();
           const latest = session?.runs?.find(record => record.id === runId);
           if (!latest || session.projectId !== getRunProjectIdForWriteback(run) || session.accountScopeId !== getAccountScopeId())
             throw Object.assign(new Error('The shared Undo run is no longer available in its original scope.'), { code: 'review_context_changed' });
@@ -162,9 +166,10 @@
       trackedChangeInFlight.set(runId, 'reject'); refreshRunCardControls(runId);
       try { return await work(); }
       catch (error) {
-        let current = true; try { assertOwner(); } catch (_stale) { current = false; }
-        if (current && findRunRecord(runId) === run) {
-          if (run.undoStatus === 'running') setRunUndoStatus(runId, 'partial');
+        let current; try { current = assertOwner(); } catch (_stale) {}
+        const durableReviewConflict = error.code === 'shared_session_conflict' && error.durableReviewRunIds?.includes(runId);
+        if (current && error.code !== 'review_context_changed' && !durableReviewConflict) {
+          if (current.undoStatus === 'running') setRunUndoStatus(runId, 'partial');
           appendRunRecordEvent(runId, { title: tr('undoNoTraceTitle'), status: 'failed',
             detail: { [tr('detailReason')]: error.message } });
         }
@@ -174,18 +179,59 @@
       } finally { trackedChangeInFlight.delete(runId); refreshRunCardControls(runId); }
     }
     const withUndoLock = (runId, work) => withSharedReviewOwnership(runId, () => withLocalUndoLock(runId, work));
-    const undoRun = runId => withUndoLock(runId, () => executeUndo(runId));
+    // Undo restores the source; with Auto compile on, refresh the PDF the way a write does.
+    async function recompileAfterUndo(runId, work) {
+      const before = findRunRecord(runId);
+      const prior = `${before?.undoStatus || ''}|${before?.trackedChangeStatus || ''}`;
+      const result = await work();
+      const run = findRunRecord(runId);
+      const undone = ['applied', 'partial'].includes(run?.undoStatus) || run?.trackedChangeStatus === 'rejected';
+      if (undone && `${run.undoStatus || ''}|${run.trackedChangeStatus || ''}` !== prior
+        && getState()?.autoRecompile !== false && run.runProjectId && run.runProjectId === getCurrentProjectId?.()) {
+        Promise.resolve(callPageBridge('triggerCompile', { preferUiClick: true, waitForSaveMs: 5000,
+          runProjectId: run.runProjectId })).catch(() => {});
+      }
+      return result;
+    }
+    // Inside the lock: a stale page that adopts another page's finished Undo never reaches its work.
+    const undoRun = runId => withUndoLock(runId, () => recompileAfterUndo(runId, () => executeUndo(runId)));
     const acceptRun = runId => withSharedReviewOwnership(runId, () => executeAcceptRun(runId));
-    const undoRunTrackedChanges = (runId, run) => withUndoLock(runId, () => executeTrackedUndo(runId, run));
+    const undoRunTrackedChanges = (runId, run) => withUndoLock(runId,
+      () => recompileAfterUndo(runId, () => executeTrackedUndo(runId, run)));
 
 function undoOwner(run) {
-    const captured = getState(), sessionId = captured.activeSessionId;
+    const sessionId = getState().activeSessionId;
     const scope = [getCurrentProjectId?.(), getAccountScopeId?.(), getRouteGeneration?.()];
+    const provenance = value => JSON.stringify([value?.id, value?.runProjectId || '', value?.startedAt || '',
+      value?.runAccountScopeId || scope[1] || '', value?.nativeEventSeq || 0, value?.codexThreadId || '', value?.codexTurnId || '', value?.executionSnapshot || null]);
+    const sessionScope = () => {
+      const session = getState().sessions?.find(item => item.id === sessionId);
+      return JSON.stringify([session?.projectId || '', session?.accountScopeId || '']);
+    };
+    const source = provenance(run), owningSession = sessionScope();
     return () => {
       reviewOwners.get(run.id)?.();
-      if (getState() !== captured || captured.activeSessionId !== sessionId || findRunRecord(run.id) !== run
+      const live = findRunRecord(run.id);
+      if (getState().activeSessionId !== sessionId || sessionScope() !== owningSession || !live
+        || !(live === run || Modules.SessionState?.sameRunIdentity?.(run, live)) || provenance(live) !== source
         || JSON.stringify(scope) !== JSON.stringify([getCurrentProjectId?.(), getAccountScopeId?.(), getRouteGeneration?.()]))
         throw Object.assign(new Error('The Undo project, account or session changed.'), { code: 'review_context_changed' });
+      return live;
+    };
+  }
+
+  function checkpointGuard(run, assertOwner) {
+    const snapshot = value => {
+      const normalized = Modules.SessionState?.normalizeRuns?.([value])?.[0] || value;
+      return JSON.stringify(['appliedOperations', 'undoOperations', 'undoBaseFiles', 'undoExpectedFiles',
+        'undoTrackedChanges', 'trackedChangeCaptures', 'undoStatus', 'trackedChangeStatus', 'forkSnapshot']
+        .map(key => normalized[key]));
+    };
+    const expected = snapshot(run);
+    return () => {
+      const live = assertOwner();
+      if (snapshot(live) !== expected) throw Object.assign(new Error('The Undo project, account or session changed.'), { code: 'review_context_changed' });
+      return live;
     };
   }
 
@@ -198,9 +244,10 @@ function undoOwner(run) {
   }
 
 async function executeUndo(runId) {
-    const run = findRunRecord(runId);
+    let run = findRunRecord(runId);
     if (run) Object.assign(run, Modules.UndoOperations.prepareRunUndo(run));
     const assertCurrent = undoOwner(run);
+    let assertInputs = checkpointGuard(run, assertCurrent);
     if (!getRunUndoCount(run) || run.undoStatus === 'applied') {
       return;
     }
@@ -210,7 +257,7 @@ async function executeUndo(runId) {
     const pendingMirror = getPendingMirrorRefresh?.();
     if (pendingMirror) {
       await pendingMirror.catch(() => {});
-      assertCurrent();
+      run = assertInputs();
     }
 
     if ((Array.isArray(run.undoTrackedChanges) && run.undoTrackedChanges.length) || hasTrackedEditorUndo(run)
@@ -272,8 +319,9 @@ async function executeUndo(runId) {
       }
     }
 
-    assertCurrent();
+    run = assertInputs();
     const deadlineAt = await prepareUndoDispatch(runId);
+    run = assertInputs();
     setRunUndoStatus(runId, 'running');
     appendRunRecordEvent(runId, {
       title: tr('undoNoTraceStarted'),
@@ -281,7 +329,8 @@ async function executeUndo(runId) {
       detail: { [tr('detailWillUndo')]: formatOperationFiles(selectedOperations) }
     });
 
-      await persistUndoOwnerMarker(runId); assertCurrent();
+      assertInputs = checkpointGuard(run, assertCurrent);
+      await persistUndoOwnerMarker(runId); run = assertInputs();
       const result = await callPageBridge('applyOperations', {
         operations: selectedOperations, deadlineAt, reviewOwnerToken: reviewOwners.get(runId)?.token,
         baseFiles: run.undoBaseFiles || [],
@@ -289,7 +338,7 @@ async function executeUndo(runId) {
         // Undo remains bound to its original project, including after navigation.
         runProjectId: getRunProjectIdForWriteback(run)
       });
-      assertCurrent();
+      run = assertInputs();
       const undoApplied = isUndoResultEffectivelyApplied(run, result);
       writebackOrchestrator.invalidateMirrorAfterUndo(runId, getRunProjectIdForWriteback(run), result);
       appendUndoReviewingPolicyEvent(runId, result.reviewingPolicy);
@@ -321,6 +370,7 @@ async function executeUndo(runId) {
 
 async function executeTrackedUndo(runId, run) {
     const assertCurrent = undoOwner(run);
+    let assertInputs = checkpointGuard(run, assertCurrent);
     const fileUndoOperations = Modules.UndoOperations.getFileUndoOperations(run);
     const textRun = Modules.UndoOperations.textUndoRun(run);
     const trackedUndo = textRun.undoTrackedChanges.length > 0;
@@ -343,8 +393,9 @@ async function executeTrackedUndo(runId, run) {
       return;
     }
 
-    assertCurrent();
+    run = assertInputs();
     const deadlineAt = await prepareUndoDispatch(runId);
+    run = assertInputs();
     // Keep the review lifecycle until every pending part has settled.
     // Its local lock stays active while verified recovery progress is persisted.
     const lifecycleReject = (trackedUndo || fileUndoOperations.length > 0) && isTrackedChangeLifecycleRun(run);
@@ -363,7 +414,8 @@ async function executeTrackedUndo(runId, run) {
 
     let result;
     try {
-      await persistUndoOwnerMarker(runId); assertCurrent();
+      assertInputs = checkpointGuard(run, assertCurrent);
+      await persistUndoOwnerMarker(runId); run = assertInputs();
       const trackedUndoPostFilesAtDispatch = buildTrackedUndoPostFiles(textRun);
       result = hasTextUndo ? await callPageBridge('rejectTrackedChanges', {
         trackedChanges: textRun.undoTrackedChanges || [], deadlineAt, reviewOwnerToken: reviewOwners.get(runId)?.token,
@@ -375,12 +427,13 @@ async function executeTrackedUndo(runId, run) {
         // The page-side project guard still refuses writes after navigation.
         runProjectId: getRunProjectIdForWriteback(run)
       }) : { ok: true, applied: [], skipped: [] };
-      assertCurrent();
+      run = assertInputs();
       if (hasTextUndo) WritebackSettlement.attachUndoNotVerifiedFailure(textRun, result, {
         buildFailure: buildContentFailure, postFiles: trackedUndoPostFilesAtDispatch });
       if (fileUndoOperations.length && lifecycleReject && hasTextUndo) {
         WritebackSettlement.attachUndoNotVerifiedFailure(textRun, result, { buildFailure: buildContentFailure, postFiles: trackedUndoPostFilesAtDispatch });
         await applyTrackedChangeSettlement(runId, 'reject', { ...result, ok: false }, { assertCurrent });
+        run = assertCurrent(); assertInputs = checkpointGuard(run, assertCurrent);
       }
       if (fileUndoOperations.length) {
         let createdResult;
@@ -399,7 +452,7 @@ async function executeTrackedUndo(runId, run) {
             operation, result: { ok: false, code: 'undo_operation_failed', reason: error.message }
           })) };
         }
-        assertCurrent();
+        run = assertInputs();
         result = Modules.UndoOperations.mergeFileUndoResult(result, createdResult, fileUndoOperations);
       }
       appendRunRecordEvent(runId, {
@@ -436,23 +489,24 @@ async function executeTrackedUndo(runId, run) {
   }
 
 function reviewOwner(run) {
-    const owner = { run, state: getState(), sessionId: getState().activeSessionId,
-      projectId: getCurrentProjectId(), accountScopeId: getAccountScopeId(), generation: getRouteGeneration() };
+    const projectId = getCurrentProjectId(), accountScopeId = getAccountScopeId();
+    const assertRun = undoOwner(run);
     const assert = () => {
-      reviewOwners.get(run.id)?.();
-      if (!owner.projectId || !owner.accountScopeId || run.runProjectId !== owner.projectId
-        || getCurrentProjectId() !== owner.projectId || getAccountScopeId() !== owner.accountScopeId
-        || getRouteGeneration() !== owner.generation || getState() !== owner.state
-        || getState().activeSessionId !== owner.sessionId || findRunRecord(run.id) !== run
-        || (run.runAccountScopeId && run.runAccountScopeId !== owner.accountScopeId))
+      let live;
+      try { live = assertRun(); } catch (error) {
+        if (error.code === 'review_context_changed') error.message = 'The original review project, account or session changed.';
+        throw error;
+      }
+      if (!projectId || !accountScopeId || live.runProjectId !== projectId
+        || (live.runAccountScopeId && live.runAccountScopeId !== accountScopeId))
         throw Object.assign(new Error('The original review project, account or session changed.'), { code: 'review_context_changed' });
-      return run;
+      return live;
     };
-    assert(); return { ...owner, assert };
+    assert(); return { projectId, accountScopeId, assert };
   }
 
 async function executeAcceptRun(runId) {
-    const run = findRunRecord(runId);
+    let run = findRunRecord(runId);
     if (!run || !isTrackedChangeLifecycleRun(run)) {
       return;
     }
@@ -471,6 +525,7 @@ async function executeAcceptRun(runId) {
     }
 
     const owner = reviewOwner(run);
+    const assertInputs = checkpointGuard(run, owner.assert);
     trackedChangeInFlight.set(runId, 'accept');
     refreshRunCardControls(runId);
     appendRunRecordEvent(runId, {
@@ -481,6 +536,7 @@ async function executeAcceptRun(runId) {
 
     try {
       const deadlineAt = await prepareUndoDispatch(runId);
+      run = assertInputs();
       const result = await callPageBridge('acceptTrackedChanges', { deadlineAt, reviewOwnerToken: reviewOwners.get(runId)?.token,
         trackedChanges: run.undoTrackedChanges || [],
         expectedFiles: run.undoExpectedFiles || [],
@@ -488,7 +544,7 @@ async function executeAcceptRun(runId) {
         appliedOperations: Array.isArray(run.appliedOperations) ? run.appliedOperations : [],
         runProjectId: owner.projectId, accountScopeId: owner.accountScopeId
       });
-      owner.assert();
+      run = assertInputs();
       appendAcceptDiagnosticEvents(runId, Array.isArray(result.diagnostics) ? result.diagnostics : []);
       appendRunRecordEvent(runId, {
         title: tr('runAcceptTrackedResult', { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }),
@@ -565,10 +621,13 @@ async function applyLegacyUndoSettlement(runId, undoStatus, result) {
       })
     );
     await Modules.ScopedPersistenceCoordinator.applyReviewTransition({ getState, runId, transition,
-      legacyUndo: true, persist: flushQueuedSaveState, assertCurrent });
+      legacyUndo: true, persist: flushQueuedSaveState, assertCurrent, SessionState: Modules.SessionState });
     refreshRunCardControls(runId);
   }
-    return { recoverInterruptedUndoStatuses, undoRun, undoRunTrackedChanges, acceptRun, applyLegacyUndoSettlement };
+    // From the shared review lock until settlement, a replaced view would
+    // invalidate the action's ownership checks after Page effects.
+    const hasActiveReview = () => reviewOwners.size > 0;
+    return { recoverInterruptedUndoStatuses, undoRun, undoRunTrackedChanges, acceptRun, applyLegacyUndoSettlement, hasActiveReview };
   }
   return { create };
 });