codex-overleaf-link 2.6.0 → 2.6.5

package/extension/src/content/runReviewController.js

@@ -246,6 +246,8 @@ function undoOwner(run) {
 async function executeUndo(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') {
@@ -338,9 +340,11 @@ async function executeUndo(runId) {
         // Undo remains bound to its original project, including after navigation.
         runProjectId: getRunProjectIdForWriteback(run)
       });
+      // 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 }),
@@ -369,6 +373,8 @@ 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);
@@ -452,8 +458,8 @@ async function executeTrackedUndo(runId, run) {
             operation, result: { ok: false, code: 'undo_operation_failed', reason: error.message }
           })) };
         }
-        run = assertInputs();
         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
@@ -484,7 +490,7 @@ 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);
     }
   }
 

package/extension/src/content/scopedPersistencePanelState.js

@@ -134,6 +134,19 @@
     }
   }
 
+  function projectPreferenceValues(input, prefs, projectId) {
+    return {
+      experimentalOtByProject: input.normalizeExperimentalOtByProject(prefs.experimentalOtByProject)[projectId] === true,
+      reviewingAvailabilityByProject: prefs.reviewingAvailabilityByProject?.[projectId],
+      governanceRulesByProject: input.normalizeGovernanceRulesByProject({
+        [projectId]: prefs.governanceRulesByProject?.[projectId] || {}
+      })[projectId],
+      customInstructionsByProject: input.normalizeCustomInstructionsByProject({
+        [projectId]: prefs.customInstructionsByProject?.[projectId] || ''
+      })[projectId]
+    };
+  }
+
   async function persistPanelState(input) {
     var state = cloneSnapshot(input.state || {});
     var compactState = cloneSnapshot(input.compactState || {});
@@ -163,6 +176,11 @@
     var reviewRuns = (input.reviewRunIds || []).map(id =>
       (state.sessions || []).flatMap(session => session.runs || []).find(run => run.id === id));
     if (reviewRuns.some(run => !run)) throw reviewPersistenceError();
+    var preferenceBaseline = input.projectPreferenceBaseline
+      || Migration.getProjectPreferenceBaseline?.(accountScopeId, projectId);
+    var preferenceWrite = input.projectPreferenceWrite || Migration.captureProjectPreferenceWrite?.({
+      ...input, state: state, baseline: preferenceBaseline, accountScopeId: accountScopeId, projectId: projectId
+    });
     var latestPrefs = typeof Migration.loadPrefs === 'function'
       ? await Migration.loadPrefs(accountScopeId, projectId)
       : {};
@@ -176,32 +194,23 @@
       projectId,
       compactState.activeSessionId || state.activeSessionId || ''
     );
-    prefs.experimentalOtByProject = Object.assign(
-      {},
-      latestPrefs && latestPrefs.experimentalOtByProject || {},
-      { [projectId]: input.normalizeExperimentalOtByProject(state.experimentalOtByProject)[projectId] === true }
-    );
-    prefs.reviewingAvailabilityByProject = Object.assign({}, latestPrefs?.reviewingAvailabilityByProject || {},
-      state.reviewingAvailabilityByProject || {});
-    prefs.governanceRulesByProject = Object.assign(
-      {},
-      latestPrefs && latestPrefs.governanceRulesByProject || {},
-      input.normalizeGovernanceRulesByProject(state.governanceRulesByProject)
-    );
-    var normalizedCustomProject = input.normalizeCustomInstructionsByProject({ [projectId]: '' });
-    var customProjectId = Object.keys(normalizedCustomProject)[0] || '';
-    var currentCustom = input.normalizeCustomInstructionsByProject(state.customInstructionsByProject);
-    prefs.customInstructionsByProject = Object.assign(
-      {},
-      latestPrefs && latestPrefs.customInstructionsByProject || {}
-    );
-    if (customProjectId) {
-      prefs.customInstructionsByProject[customProjectId] =
-        Object.prototype.hasOwnProperty.call(currentCustom, customProjectId)
-          ? currentCustom[customProjectId]
-          : '';
+    var currentPreferences = projectPreferenceValues(input, state, projectId);
+    if (preferenceWrite) {
+      Object.assign(prefs, Migration.projectPreferencePatch(preferenceWrite, accountScopeId, projectId));
+    } else {
+      var baselinePreferences = projectPreferenceValues(input, preferenceBaseline || latestPrefs || {}, projectId);
+      for (var name of Object.keys(currentPreferences)) {
+        prefs[name] = JSON.stringify(currentPreferences[name]) === JSON.stringify(baselinePreferences[name])
+          ? {} : { [projectId]: currentPreferences[name] };
+      }
+    }
+    var savedPrefs = await Migration.savePrefs(prefs, accountScopeId, projectId);
+    if (savedPrefs) {
+      var fields = preferenceWrite ? Migration.completeProjectPreferenceWrite(preferenceWrite, savedPrefs)
+        : Object.keys(currentPreferences);
+      var applied = input.applyProjectPreferences?.(savedPrefs, state, fields);
+      if (!preferenceWrite && applied !== false) Migration.adoptProjectPreferenceBaseline?.(savedPrefs, accountScopeId, projectId);
     }
-    await Migration.savePrefs(prefs, accountScopeId, projectId);
     var persistenceMeta = input.persistenceContext?.nextMeta || {};
     var queueTombstones = persistenceMeta.queueTombstones || {};
     var sessionTombstones = persistenceMeta.sessionTombstones || {};

package/extension/src/content/selectionContextView.js

@@ -133,6 +133,28 @@
       }
     }
 
+    async function attachInstruction(action, selected) {
+      const selection = await attach('edit', selected);
+      if (!selection) return;
+      const task = deps.getPanel()?.querySelector('[data-task]');
+      if (!task) return;
+      if (task.value.trim()) {
+        deps.toast?.(tx('Kept your draft. The selection is attached for editing.', '已保留你的草稿，选区已附上，仅编辑此处。'));
+        return;
+      }
+      const instructions = {
+        polish: tx('Polish the selected passage for clarity and flow. Keep the meaning, citations, labels and math unchanged.',
+          '润色选中段落，让表达更清晰流畅，保持原意以及引用、标签、公式不变。'),
+        shorten: tx('Shorten the selected passage by about 20%. Keep citations, labels, math and the main claim unchanged.',
+          '将选中段落精简约 20%，保留引用、标签、公式和核心论点不变。'),
+        translate: tx('Translate the selected passage into English. Keep LaTeX commands, citations, labels and math unchanged.',
+          '将选中段落翻译成英文，保留 LaTeX 命令、引用、标签和公式不变。')
+      };
+      task.value = instructions[action];
+      task.setSelectionRange(task.value.length, task.value.length);
+      task.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+
     function editorFor(node) {
       const element = node?.nodeType === 1 ? node : node?.parentElement;
       const editor = element?.closest?.('.cm-editor');
@@ -164,6 +186,9 @@
       toolbar.setAttribute('aria-label', tx('Selected text actions', '选区操作'));
       toolbar.querySelector('[data-selection-action="reference"]').textContent = tx('Add to Chat', '加入对话');
       toolbar.querySelector('[data-selection-action="edit"]').textContent = tx('Edit Selection', '仅编辑此处');
+      toolbar.querySelector('[data-selection-action="polish"]').textContent = tx('Polish', '润色');
+      toolbar.querySelector('[data-selection-action="shorten"]').textContent = tx('Shorten', '精简');
+      toolbar.querySelector('[data-selection-action="translate"]').textContent = tx('Translate', '翻译');
     }
 
     function ensureToolbar() {
@@ -174,8 +199,8 @@
       toolbar.setAttribute('role', 'toolbar');
       toolbar.hidden = true;
       if (typeof toolbar.showPopover === 'function') toolbar.setAttribute('popover', 'manual');
-      for (const mode of ['reference', 'edit']) {
-        if (mode === 'edit') {
+      for (const mode of ['reference', 'edit', 'polish', 'shorten', 'translate']) {
+        if (mode === 'edit' || mode === 'polish') {
           const divider = document.createElement('span');
           divider.className = 'codex-selection-action-divider';
           divider.setAttribute('aria-hidden', 'true');
@@ -186,7 +211,9 @@
         button.dataset.selectionAction = mode;
         button.addEventListener('click', () => {
           const selected = candidate;
-          if (selected) void attach(mode, selected);
+          if (!selected) return;
+          if (mode === 'reference' || mode === 'edit') void attach(mode, selected);
+          else void attachInstruction(mode, selected);
         });
         toolbar.append(button);
       }

package/extension/src/content/sharedSessionViewSync.js

@@ -9,7 +9,11 @@
 
   function applySnapshot(options, sessions) {
     const previous = options.getState(), scope = options.getScope();
-    const next = options.normalize({ ...previous, sessions }, { restoreRunningRuns: false });
+    const input = sessions.length ? { ...previous, sessions } : {
+      ...previous, session: null, sessions: [], runs: [], activeSessionId: '',
+      task: '', focusFiles: [], selectionContext: null, composerAttachments: []
+    };
+    const next = options.normalize(input, { restoreRunningRuns: false });
     const unchangedSnapshot = JSON.stringify(next);
     options.setState(next);
     try {
@@ -88,6 +92,10 @@
     }
     const unsubscribe = Bridge.subscribe(change => {
       const scope = getScope();
+      if (options.isDashboard?.()) {
+        if (scope.accountScopeId && change.accountScopeId === scope.accountScopeId) options.refreshDashboard?.();
+        return;
+      }
       if (!change.projectId || change.projectId === scope.projectId) {
         retryCount = 0; pending = true; schedule();
       }

package/extension/src/content/writebackOrchestrator.js

@@ -21,6 +21,12 @@
   let appendRunRecordEvent;
   // In-flight background mirror refresh (v1.7.5) — see the writeback path.
   let pendingMirrorRefresh = null;
+  const mirrorSettlementOwners = new Map();
+  const mirrorReuseFences = new Map();
+  const mirrorFenceWrites = new Map();
+  const mirrorFenceRevisions = new Map();
+  const MIRROR_INVALIDATION_TIMEOUT_MS = 20000;
+  const MIRROR_FENCE_STORAGE_TIMEOUT_MS = 2000;
   let appendChangeSummary;
   let appendCompletionReport;
   let appendOperationsPreview;
@@ -31,6 +37,8 @@
   let callPageBridge;
   let sendBackgroundNative;
   let getCurrentProjectId;
+  let getAccountScopeId;
+  let mirrorFenceStore;
   let resetContextProject;
   let sanitizeRunProjectSnapshot;
   let getAssistantAnswerForCurrentRun;
@@ -72,27 +80,158 @@
       : null;
   }
 
-  function invalidateMirrorAfterUndo(runId, projectId, result = {}) {
-    if (!projectId || (result?.changedDocument !== true && !result?.applied?.length)) return Promise.resolve('not-attempted');
-    const pending = Promise.resolve(pendingMirrorRefresh).catch(() => {}).then(async () => {
-      const response = await sendBackgroundNative({ method: 'mirror.invalidate', params: { projectId } });
-      if (!response?.ok || response.result?.invalidated !== true) {
-        throw new Error(response?.error?.message || 'Native host did not confirm mirror invalidation.');
+  function mirrorFenceScope(projectId, accountScopeId = getAccountScopeId?.() || '') {
+    return { projectId, accountScopeId };
+  }
+
+  function mirrorFenceKey(scope) {
+    return JSON.stringify([scope.accountScopeId, scope.projectId]);
+  }
+
+  function getMirrorReuseFence(projectId, accountScopeId) {
+    return mirrorReuseFences.get(mirrorFenceKey(mirrorFenceScope(projectId, accountScopeId))) || null;
+  }
+
+  function updateMirrorReuseFence(scope, generations, unknown = false) {
+    const key = mirrorFenceKey(scope), current = mirrorReuseFences.get(key);
+    const ids = [...new Set(generations)].sort();
+    if (current && current.unknown === unknown && current.generations.join(':') === ids.join(':')) return current;
+    const fence = ids.length || unknown ? { scope, generations: ids, unknown, syncAttempted: false } : null;
+    if (fence) mirrorReuseFences.set(key, fence);
+    else mirrorReuseFences.delete(key);
+    mirrorFenceRevisions.set(key, (mirrorFenceRevisions.get(key) || 0) + 1);
+    return fence;
+  }
+
+  async function awaitMirrorFenceStorage(work) {
+    let timer;
+    try {
+      return await Promise.race([
+        Promise.resolve().then(work),
+        new Promise((_resolve, reject) => {
+          timer = setTimeout(() => reject(new Error('Mirror fence storage timed out.')), MIRROR_FENCE_STORAGE_TIMEOUT_MS);
+        })
+      ]);
+    } finally { clearTimeout(timer); }
+  }
+
+  async function refreshMirrorReuseFence(projectId, accountScopeId) {
+    const scope = mirrorFenceScope(projectId, accountScopeId), key = mirrorFenceKey(scope);
+    if (!mirrorFenceStore) return getMirrorReuseFence(projectId, scope.accountScopeId);
+    const revision = mirrorFenceRevisions.get(key) || 0;
+    try {
+      const stored = await awaitMirrorFenceStorage(() => mirrorFenceStore.getMirrorReuseFences(scope));
+      const writes = mirrorFenceWrites.get(key) || new Map();
+      const changed = revision !== (mirrorFenceRevisions.get(key) || 0);
+      const generations = new Set(stored.filter(id => !writes.get(id)?.retired));
+      for (const [id, write] of writes) {
+        if (!write.retired && (!write.persisted || changed)) generations.add(id);
       }
-      if (getCurrentProjectId() === projectId) {
-        resetContextProject();
-        await callPageBridge('invalidateProjectSnapshot', { invalidateFileList: true });
+      // A read started before a local write or newer read cannot erase that evidence.
+      if (changed) for (const id of mirrorReuseFences.get(key)?.generations || []) {
+        if (!writes.get(id)?.retired) generations.add(id);
       }
-      return 'invalidated';
-    }).catch(error => {
-      appendRunRecordEvent?.(runId, {
-        status: 'warning',
-        title: tx(
-          `Overleaf undo finished, but local mirror invalidation failed: ${error.message}. Refresh this project or reconnect the native host before running again.`,
-          `Overleaf 撤销已完成，但本地镜像失效处理失败：${error.message}。请刷新项目或重新连接 Native Host 后再运行。`
-        )
-      });
-      return 'failed';
+      return updateMirrorReuseFence(scope, [...generations]);
+    } catch (_error) {
+      return updateMirrorReuseFence(scope, mirrorReuseFences.get(key)?.generations || [], true);
+    }
+  }
+
+  async function recordMirrorReuseFence(target) {
+    const scope = mirrorFenceScope(target.runProjectId, target.runAccountScopeId);
+    const key = mirrorFenceKey(scope);
+    const generation = globalThis.crypto?.randomUUID?.()
+      || Date.now().toString(36) + '-' + Math.random().toString(36).slice(2) + '-' + Math.random().toString(36).slice(2);
+    const writes = mirrorFenceWrites.get(key) || new Map();
+    mirrorFenceWrites.set(key, writes);
+    const write = { persisted: false, retired: false, clearAfterWrite: false };
+    writes.set(generation, write);
+    updateMirrorReuseFence(scope, [...(mirrorReuseFences.get(key)?.generations || []), generation]);
+    const token = { scope, generation };
+    if (!mirrorFenceStore) return token;
+    const pending = Promise.resolve().then(() => mirrorFenceStore.setMirrorReuseFence(scope, generation));
+    pending.then(() => {
+      write.persisted = true;
+      mirrorFenceRevisions.set(key, (mirrorFenceRevisions.get(key) || 0) + 1);
+      // A slow set may finish after a successful full sync already removed its key.
+      if (write.clearAfterWrite) {
+        awaitMirrorFenceStorage(() => mirrorFenceStore.clearMirrorReuseFences(scope, [generation]))
+          .then(() => { write.retired = true; }).catch(() => {});
+      }
+    }, () => {});
+    try { await awaitMirrorFenceStorage(() => pending); }
+    catch (_error) { /* The existing invalidation warning and memory fence remain. */ }
+    return token;
+  }
+
+  async function clearMirrorReuseFenceGenerations(scope, generations) {
+    const writes = mirrorFenceWrites.get(mirrorFenceKey(scope));
+    for (const id of generations) if (writes?.has(id)) writes.get(id).clearAfterWrite = true;
+    const clearing = Promise.resolve().then(() => mirrorFenceStore?.clearMirrorReuseFences(scope, generations));
+    clearing.then(() => {
+      for (const id of generations) if (writes?.has(id)) writes.get(id).retired = true;
+    }, () => {});
+    await awaitMirrorFenceStorage(() => clearing);
+  }
+
+  async function settleFullMirrorSync(projectId, project, fence, response, options = {}) {
+    if (!fence || fence.unknown || getMirrorReuseFence(projectId, fence.scope.accountScopeId) !== fence || response?.ok !== true
+      || project?.capabilities?.fullProjectSnapshot !== true
+      || project.capabilities.contentComplete === false || project.capabilities.skipped?.length) return false;
+    try {
+      options.assertCurrent?.();
+      const status = await (options.sendNative || sendBackgroundNative)({ method: 'mirror.status', params: { projectId } });
+      options.assertCurrent?.();
+      const current = await refreshMirrorReuseFence(projectId, fence.scope.accountScopeId);
+      options.assertCurrent?.();
+      if (getCurrentProjectId() !== projectId || current !== fence
+        || status?.ok !== true || status.result?.exists !== true || status.result.dirty === true) return false;
+      await clearMirrorReuseFenceGenerations(fence.scope, fence.generations);
+      options.assertCurrent?.();
+      if (getMirrorReuseFence(projectId, fence.scope.accountScopeId) === fence) updateMirrorReuseFence(fence.scope, []);
+      return !(await refreshMirrorReuseFence(projectId, fence.scope.accountScopeId));
+    } catch (_error) {
+      options.assertCurrent?.();
+      return false;
+    }
+  }
+
+  async function syncFencedMirror(projectId, project, options = {}) {
+    const fence = options.fence;
+    if (!fence || fence.unknown || getMirrorReuseFence(projectId, fence.scope.accountScopeId) !== fence || fence.syncAttempted
+      || project?.id !== projectId || project.capabilities?.fullProjectSnapshot !== true
+      || project.capabilities.contentComplete === false || project.capabilities.skipped?.length) return false;
+    options.assertCurrent();
+    // Only the next full-read path adds a sync; a failed attempt keeps reuse
+    // fenced without adding another request on every subsequent run.
+    fence.syncAttempted = true;
+    try {
+      const response = await options.sendNative({ method: 'mirror.sync', params: { projectId, project } });
+      options.assertCurrent();
+      return await settleFullMirrorSync(projectId, project, fence, response, options);
+    } catch (_error) {
+      options.assertCurrent();
+      return false;
+    }
+  }
+
+  function trackWritebackMirror(work, target, onSettled) {
+    const key = JSON.stringify([target.runProjectId, target.sessionId, target.recordId]);
+    const owner = {};
+    mirrorSettlementOwners.set(key, owner);
+    const refresh = Promise.resolve(work).then(async state => {
+      if (mirrorSettlementOwners.get(key) !== owner) return state;
+      onSettled?.(state);
+      await onMirrorRefreshSettled?.({ ...target, state: state || 'not-attempted' });
+      return state;
+    }).finally(() => {
+      if (mirrorSettlementOwners.get(key) === owner) mirrorSettlementOwners.delete(key);
+    });
+    // Keep earlier work in the barrier even if this attempt finishes first or
+    // fails. Only the latest composed barrier may clear the shared slot.
+    const pending = Promise.allSettled([pendingMirrorRefresh, refresh]).then(([, result]) => {
+      if (result.status === 'rejected') throw result.reason;
+      return result.value;
     }).finally(() => {
       if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
     });
@@ -100,6 +239,21 @@
     return pending;
   }
 
+  function invalidateMirrorAfterUndo(runId, projectId, result = {}, owner = {}) {
+    if (!projectId || (result?.changedDocument !== true && !result?.applied?.length)) return Promise.resolve('not-attempted');
+    const target = { recordId: runId, runProjectId: projectId,
+      runAccountScopeId: owner.runAccountScopeId || getAccountScopeId?.() || '', sessionId: owner.sessionId || '' };
+    const pending = Promise.resolve(pendingMirrorRefresh).catch(() => {})
+      .then(() => invalidateWritebackMirror(target, {
+        pageFirst: true, nativeTimeoutMs: MIRROR_INVALIDATION_TIMEOUT_MS, undo: true
+      }))
+      .then(state => state === 'not-attempted' ? 'invalidated' : state).finally(() => {
+      if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
+    });
+    pendingMirrorRefresh = pending;
+    return pending;
+  }
+
   function selectionViolationNextStep() {
     return tx('Select the intended region again and request only changes within it. Valid written parts can be undone.',
       '请重新选择目标范围，仅请求修改该范围。已写入的合法部分可撤销。');
@@ -117,7 +271,8 @@
 
   async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options = {}) {
     const activeRun = getCurrentRunView?.();
-    const saveTarget = { runProjectId: activeRun?.runProjectId || '', recordId: activeRun?.recordId || '', sessionId: activeRun?.sessionId || '' };
+    const saveTarget = { runProjectId: activeRun?.runProjectId || '', runAccountScopeId: activeRun?.runAccountScopeId || getAccountScopeId?.() || '',
+      recordId: activeRun?.recordId || '', sessionId: activeRun?.sessionId || '' };
     const runMode = options.mode || getState().mode;
     const runRequireReviewing = typeof options.requireReviewing === 'boolean'
       ? options.requireReviewing
@@ -418,9 +573,35 @@
     // zero-write run (every operation skipped) has nothing to save-verify, so
     // skip the ~5s probe and its misleading "could not verify saved" warning
     // (v1.6.2).
-    const confirmation = appliedPaths.length
-      ? await verifyPostWriteSaveState(applied, project, saveTarget)
-      : { verification: { ok: false, state: 'not_checked', reason: 'No applied writeback operations were returned.' } };
+    let confirmation;
+    try {
+      confirmation = appliedPaths.length
+        ? await verifyPostWriteSaveState(applied, project, saveTarget)
+        : { verification: { ok: false, state: 'not_checked', reason: 'No applied writeback operations were returned.' } };
+    } catch (error) {
+      if (!appliedPaths.length || (error?.code !== 'codex_cancelled' && error?.name !== 'AbortError')) throw error;
+      const saveVerification = { ok: false, state: 'unknown_timeout', signal: 'unavailable',
+        reason: 'Save confirmation was cancelled.', recoveryReason: 'codex_cancelled', attempts: [] };
+      // Cancellation cannot erase the returned writes or the recovery needed to
+      // check their save state. Carry the same evidence into the cancelled report.
+      error.writebackOutcome = { operations, applied, saveVerification,
+        settlement: buildSettlement({ operations, applyResult: applied, saveVerification, mirror: { state: 'unknown' } }) };
+      // Fence the Page cache now; bound the Native wait so an unanswered
+      // invalidation cannot strand the next run or recovery behind the barrier.
+      trackWritebackMirror(invalidateWritebackMirror(saveTarget, {
+        pageFirst: true, nativeTimeoutMs: MIRROR_INVALIDATION_TIMEOUT_MS
+      }), saveTarget,
+        state => {
+          error.writebackOutcome.settlement = buildSettlement({ operations, applyResult: applied, saveVerification, mirror: { state } });
+        });
+      try {
+        await settleWritebackRecovery?.(applied, project, saveVerification, saveTarget, runRequireReviewing);
+      } catch (recoveryError) {
+        appendRunRecordEvent?.(saveTarget.recordId, { kind: 'technical', status: 'warning',
+          title: tx('Writeback recovery persistence failed', '写回恢复信息保存失败'), detail: { reason: recoveryError.message } });
+      }
+      throw error;
+    }
     const saveVerification = confirmation.verification;
     await settleWritebackRecovery?.(applied, project, saveVerification, saveTarget, runRequireReviewing);
     if (appliedPaths.length) {
@@ -432,24 +613,11 @@
     // pending promise is exposed so undoRun and the next runTask barrier on
     // it — a mirror.sync landing AFTER an undo would otherwise push the
     // pre-undo snapshot as the local baseline.
-    const mirrorSettlementTarget = saveTarget;
-    pendingMirrorRefresh = refreshProjectMirrorAfterWriteback(project, applied, saveVerification, { target: saveTarget, snapshot: confirmation.snapshot })
+    trackWritebackMirror(refreshProjectMirrorAfterWriteback(project, applied, saveVerification, { target: saveTarget, snapshot: confirmation.snapshot })
       .catch(async error => {
         appendRunRecordEvent(saveTarget.recordId, { kind: 'technical', title: 'Mirror refresh requires a fresh read', status: 'info', detail: { reason: error.message } });
         return invalidateWritebackMirror(saveTarget);
-      })
-      .then(state => {
-        if (typeof onMirrorRefreshSettled !== 'function') return;
-        return onMirrorRefreshSettled({
-          recordId: mirrorSettlementTarget?.recordId || '',
-          sessionId: mirrorSettlementTarget?.sessionId || '',
-          runProjectId: mirrorSettlementTarget?.runProjectId || '',
-          state: state || 'not-attempted'
-        });
-      })
-      .finally(() => {
-        pendingMirrorRefresh = null;
-      });
+      }), saveTarget);
     const compileSummary = appliedPaths.length
       ? await autoRecompileAfterWriteback(appliedPaths, saveVerification, {
         autoRecompile: options.autoRecompile,
@@ -522,7 +690,9 @@
       // the run by inspecting the `applied.skipped` entries' failure codes.
       // Existing call sites that only read `summaryLine` / `hasSkippedOperations`
       // / `audit` are unaffected.
+      operations,
       applied,
+      saveVerification,
       settlement: buildSettlement({
         operations,
         applyResult: applied,
@@ -575,25 +745,64 @@
     else appendRunEvent({ title, status: 'warning' });
   }
 
-  async function invalidateWritebackMirror(target = {}) {
+  async function invalidateWritebackMirror(target = {}, options = {}) {
+    const invalidatePage = async () => {
+      if (getCurrentProjectId() !== target.runProjectId
+        || (target.runAccountScopeId && getAccountScopeId?.() !== target.runAccountScopeId)) return true;
+      try {
+        resetContextProject();
+        const response = await callPageBridge('invalidateProjectSnapshot', { invalidateFileList: true, runProjectId: target.runProjectId });
+        return response?.ok === true;
+      } catch (_error) { return false; }
+    };
+    const pageInvalidation = options.pageFirst === true ? invalidatePage() : null;
+    // The local mirror barrier is not shared with other tabs. Publish this
+    // cancellation's fence before waiting for Native, including its handshake.
+    const pendingFence = options.pageFirst === true && target.runProjectId
+      ? await recordMirrorReuseFence(target) : null;
     let invalidated = false;
+    let failureReason = 'Native host did not confirm mirror invalidation.';
+    let timer;
     try {
       if (target.runProjectId) {
-        const response = await sendBackgroundNative({ method: 'mirror.invalidate', params: { projectId: target.runProjectId } });
+        const pending = sendBackgroundNative({ method: 'mirror.invalidate', params: { projectId: target.runProjectId } });
+        // A rejection after the bound has nobody left to observe it.
+        pending.catch(() => {});
+        const response = options.nativeTimeoutMs
+          ? await Promise.race([
+            pending,
+            new Promise(resolve => {
+              timer = setTimeout(() => resolve(null), options.nativeTimeoutMs);
+            })
+          ])
+          : await pending;
         invalidated = response?.ok === true && response.result?.invalidated === true;
+        if (!invalidated && response?.error?.message) failureReason = response.error.message;
       }
-    } catch (_error) { /* An unavailable host cannot acknowledge invalidation. */ }
-    let pageInvalidated = getCurrentProjectId() !== target.runProjectId;
-    if (!pageInvalidated) {
-      resetContextProject();
-      try {
-        const response = await callPageBridge('invalidateProjectSnapshot', { invalidateFileList: true, runProjectId: target.runProjectId });
-        pageInvalidated = response?.ok === true;
-      } catch (_error) { /* Leave the failure visible if both caches cannot be fenced. */ }
+    } catch (error) { failureReason = error?.message || failureReason; }
+    finally {
+      if (timer !== undefined) clearTimeout(timer);
+    }
+    const pageInvalidated = await (pageInvalidation || invalidatePage());
+    if (invalidated && pageInvalidated) {
+      if (pendingFence) {
+        try {
+          await clearMirrorReuseFenceGenerations(pendingFence.scope, [pendingFence.generation]);
+          const current = getMirrorReuseFence(target.runProjectId, pendingFence.scope.accountScopeId);
+          if (current) updateMirrorReuseFence(pendingFence.scope,
+            current.generations.filter(id => id !== pendingFence.generation), current.unknown);
+          await refreshMirrorReuseFence(target.runProjectId, pendingFence.scope.accountScopeId);
+        } catch (_error) { /* Retain the fence if its durable cleanup is unconfirmed. */ }
+      }
+      return 'not-attempted';
     }
-    if (invalidated && pageInvalidated) return 'not-attempted';
+    if (target.runProjectId && !pendingFence) await recordMirrorReuseFence(target);
+    if (invalidated && !pageInvalidated) failureReason = 'The page did not confirm snapshot invalidation.';
     const event = {
-      title: tx('The local project cache could not be reset. Check the local connection before starting another task.',
+      title: options.undo === true ? tx(
+        `Overleaf undo finished, but local mirror invalidation failed: ${failureReason}. Refresh this project or reconnect the native host before running again.`,
+        `Overleaf 撤销已完成，但本地镜像失效处理失败：${failureReason}。请刷新项目或重新连接 Native Host 后再运行。`
+      ) : tx('The local project cache could not be reset. Check the local connection before starting another task.',
         '本地项目缓存未能重置。请检查本地连接后再开始下一轮任务。'),
       status: 'warning'
     };
@@ -638,6 +847,7 @@
     if (!Array.isArray(applied?.applied) || !applied.applied.length) {
       return 'not-attempted';
     }
+    const mirrorFence = await refreshMirrorReuseFence(target.runProjectId, target.runAccountScopeId);
 
     if (!confirmation.snapshot && await tryConfirmMirrorWriteback(applied, target.runProjectId)) {
       appendRunEvent({
@@ -689,6 +899,7 @@
       }
     });
     if (response?.ok) {
+      await settleFullMirrorSync(target.runProjectId, syncedProject, mirrorFence, response);
       appendRunEvent({
         title: tx('Local Codex workspace refreshed. The next run will start from the latest Overleaf content.', '已刷新本地 Codex workspace，下一轮会从最新 Overleaf 内容开始。'),
         status: 'completed'
@@ -916,6 +1127,8 @@
       getCurrentRunView,
     } = deps);
     assetTransferBroker = deps.assetTransferBroker;
+    mirrorFenceStore = deps.mirrorFenceStore;
+    getAccountScopeId = deps.getAccountScopeId;
     stageWritebackRecovery = deps.stageWritebackRecovery;
     settleWritebackRecovery = deps.settleWritebackRecovery;
     onMirrorRefreshSettled = deps.onMirrorRefreshSettled;
@@ -925,6 +1138,9 @@
       applySyncChangesToOverleaf,
       resolveCompileLogContext,
       invalidateMirrorAfterUndo,
+      getMirrorReuseFence,
+      refreshMirrorReuseFence,
+      syncFencedMirror,
       getPendingMirrorRefresh: () => pendingMirrorRefresh
     };
   }