codex-overleaf-link 2.5.1 → 2.6.5

package/extension/src/content/runQueueScheduler.js

@@ -42,10 +42,15 @@
             reason: status === 'completed' ? 'completed' : 'continue_queue'
           })
         );
-      } else if (!shouldContinue) {
-        const paused = originalQueue.length
-          ? Queue.pauseAll(originalQueue, status || 'run_did_not_complete')
-          : originalQueue;
+      }
+      const canStart = shouldContinue ? options.canStart?.(sessionId) : true;
+      const latestQueue = options.getQueue?.(sessionId) || originalQueue;
+      const inactive = shouldContinue && canStart !== 'session_transition'
+        && (canStart === false || options.isRunning?.())
+        && latestQueue.some(item => item?.status === 'queued');
+      if (!shouldContinue || inactive) {
+        const reason = inactive ? 'session_inactive' : status || 'run_did_not_complete';
+        const paused = latestQueue.length ? Queue.pauseAll(latestQueue, reason) : latestQueue;
         options.setQueue?.(sessionId, paused);
         try {
           await options.persist?.({
@@ -55,19 +60,23 @@
           const latestQueue = options.getQueue?.(sessionId) || paused;
           options.setQueue?.(
             sessionId,
-            Queue.pauseAll(latestQueue, status || 'run_did_not_complete')
+            Queue.pauseAll(latestQueue, reason)
           );
           throw error;
         }
       }
       options.onChange?.(sessionId);
-      if (shouldContinue) {
+      if (shouldContinue && !inactive) {
         scheduleOne(sessionId);
       }
     }
 
     function scheduleOne(sessionId) {
-      if (scheduling || options.isRunning?.() || options.canStart?.(sessionId) === false) {
+      if (scheduling || options.isRunning?.()) {
+        return false;
+      }
+      const canStart = options.canStart?.(sessionId);
+      if (canStart === false || canStart === 'session_transition') {
         return false;
       }
       const initialQueue = options.getQueue?.(sessionId) || [];
@@ -195,7 +204,7 @@
       setQueue: (sessionId, pendingInputs) => options.setQueue?.(sessionId, pendingInputs),
       persist: persistenceOptions => options.save?.(persistenceOptions),
       isRunning: () => Boolean(options.getCurrentRun?.()),
-      canStart: sessionId => options.canStart?.(sessionId) !== false,
+      canStart: sessionId => options.canStart?.(sessionId),
       start: (item, sessionId) => startQueuedInput(item, sessionId),
       onChange: () => render(),
       onDequeued: (item, context) => options.removeGuidance?.(item.id, {
@@ -444,12 +453,17 @@
     }
 
     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 = () => {
+        const canStart = options.canStart?.(sessionId);
+        if (canStart === false || canStart === 'session_transition' || 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

@@ -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,34 +70,22 @@
       });
     }
 
-    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);
       existing.replaceWith(button);
-      const finalAnswer = root.querySelector('.run-completion-report .run-final-answer');
-      const copyText = String(finalAnswer?.innerText || finalAnswer?.textContent || '').trim();
+      const available = Boolean(readConclusionText(root).trim());
       button.hidden = false;
-      button.disabled = !copyText;
+      button.disabled = !available;
       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>';
-      if (!copyText) return;
+      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 (!available) return;
       button.addEventListener('click', async event => {
         event.stopPropagation();
         try {
+          const copyText = readConclusionText(root);
+          if (!copyText.trim()) return;
           await writeClipboardText(copyText);
           button.title = tr('copyConclusionDone');
         } catch (_error) {
@@ -92,6 +95,52 @@
       });
     }
 
+    function readConclusionText(root) {
+      const answer = root.querySelector('.run-completion-report .run-final-answer');
+      if (!answer) return '';
+      return extractConclusionText(answer).replace(/\u200b/g, '').replace(/[ \t]+$/gm, '').trim();
+    }
+
+    function extractConclusionText(node) {
+      if (node.nodeType === 3) return String(node.textContent || '').replace(/\s+/g, ' ');
+      const tag = node.tagName?.toLowerCase();
+      if (tag === 'br') return '\n';
+      if (tag === 'pre' || tag === 'code') return node.textContent || '';
+      if (node.classList?.contains('run-math')) {
+        const source = node.dataset.mathRendered === 'false'
+          ? node.textContent || ''
+          : node.querySelector('annotation[encoding="application/x-tex"]')?.textContent || '';
+        const delimiter = node.dataset.mathDisplay === 'block' ? '$$' : '$';
+        return source ? `${delimiter}${source}${delimiter}` : '';
+      }
+      const children = Array.from(node.childNodes || []);
+      if (tag === 'ul' || tag === 'ol') {
+        const start = Number(node.getAttribute('start') || 1);
+        return children.filter(child => child.tagName?.toLowerCase() === 'li')
+          .map((child, index) => `${tag === 'ol' ? `${start + index}. ` : '- '}${extractConclusionText(child)}`)
+          .join('\n');
+      }
+      if (tag === 'table') {
+        return Array.from(node.querySelectorAll('tr'), row => Array.from(row.children,
+          cell => extractConclusionText(cell)).join('\t')).join('\n');
+      }
+      let text = '';
+      let previousBlock = false;
+      for (const child of children) {
+        const value = extractConclusionText(child);
+        if (!value) continue;
+        const block = /^(p|h[1-6]|blockquote|ul|ol|pre|table|div)$/.test(child.tagName?.toLowerCase())
+          || child.dataset?.mathDisplay === 'block';
+        if (text && (previousBlock || block)) {
+          const newlines = (text.match(/\n*$/)?.[0].length || 0) + (value.match(/^\n*/)?.[0].length || 0);
+          text += '\n'.repeat(Math.max(0, 2 - newlines));
+        }
+        text += value;
+        previousBlock = block;
+      }
+      return text;
+    }
+
     async function writeClipboardText(text) {
       if (navigatorRef?.clipboard?.writeText) {
         await navigatorRef.clipboard.writeText(text);
@@ -109,7 +158,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,12 @@ 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 mirrorOwner = { projectId: getRunProjectIdForWriteback(run), runAccountScopeId: run?.runAccountScopeId || getAccountScopeId?.() || '',
+      sessionId: getState().activeSessionId };
     const assertCurrent = undoOwner(run);
+    let assertInputs = checkpointGuard(run, assertCurrent);
     if (!getRunUndoCount(run) || run.undoStatus === 'applied') {
       return;
     }
@@ -210,7 +259,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 +321,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 +331,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,9 +340,11 @@ async function executeUndo(runId) {
         // Undo remains bound to its original project, including after navigation.
         runProjectId: getRunProjectIdForWriteback(run)
       });
-      assertCurrent();
+      // The Page may have changed the original document even if this view moved
+      // while awaiting its reply. Fence that project's mirror before rechecking.
+      writebackOrchestrator.invalidateMirrorAfterUndo(runId, mirrorOwner.projectId, result, mirrorOwner);
+      run = assertInputs();
       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 }),
@@ -320,7 +373,10 @@ async function executeUndo(runId) {
   }
 
 async function executeTrackedUndo(runId, run) {
+    const mirrorOwner = { projectId: getRunProjectIdForWriteback(run), runAccountScopeId: run?.runAccountScopeId || getAccountScopeId?.() || '',
+      sessionId: getState().activeSessionId };
     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 +399,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 +420,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 +433,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,8 +458,8 @@ async function executeTrackedUndo(runId, run) {
             operation, result: { ok: false, code: 'undo_operation_failed', reason: error.message }
           })) };
         }
-        assertCurrent();
         result = Modules.UndoOperations.mergeFileUndoResult(result, createdResult, fileUndoOperations);
+        run = assertInputs();
       }
       appendRunRecordEvent(runId, {
         title: fileUndoOperations.length ? tr('undoResult', { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }) : trackedUndo
@@ -431,28 +490,29 @@ async function executeTrackedUndo(runId, run) {
       await applyLegacyUndoSettlement(runId, result.ok === true && !result.skipped?.length ? 'applied' : 'partial', result);
     } finally {
       // Known Page changes require invalidation even when a durable checkpoint fails.
-      if (result) writebackOrchestrator.invalidateMirrorAfterUndo(runId, getRunProjectIdForWriteback(run), result);
+      if (result) writebackOrchestrator.invalidateMirrorAfterUndo(runId, mirrorOwner.projectId, result, mirrorOwner);
     }
   }
 
 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 +531,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 +542,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 +550,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 +627,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 };
 });