codex-overleaf-link 2.3.6 → 2.4.0

package/extension/src/content/generated/content.bundle.meta.json

@@ -2,9 +2,9 @@
   "schemaVersion": 1,
   "entry": "extension/entries/content-entry.mjs",
   "output": "extension/src/content/generated/content.bundle.js",
-  "sourceDigest": "15c3e103532c84dea57aeac33e02ec665fbf7518543e14daac2459c434b3e5d5",
-  "outputDigest": "5e1dba4bfcf4c595835312deabefa5ecdd2ee7c6d98f29d1b2bd9711ad5b195c",
-  "byteLength": 2375784,
+  "sourceDigest": "f146d7e07b67706193fa5fcff26d7c9719826ac745aec9b745dd95c52413d27c",
+  "outputDigest": "11993fd0746a026b1e74399060e70559eb569fca492fcdec36c2fb69a78d6b80",
+  "byteLength": 2404976,
   "inputs": [
     "extension/entries/content-entry.mjs",
     "extension/src/content/activeTurnControl.js",
@@ -62,6 +62,7 @@
     "extension/src/content/sessionPersistence.js",
     "extension/src/content/settingsPanel.js",
     "extension/src/content/themeController.js",
+    "extension/src/content/trackedChangeCaptureController.js",
     "extension/src/content/updateIdle.js",
     "extension/src/content/updateNotice.js",
     "extension/src/content/writebackController.js",

package/extension/src/content/legacyGlobalRegistry.js

@@ -75,6 +75,7 @@
     'StorageMigration',
     'Summary',
     'Theme',
+    'TrackedChangeCaptureController',
     'UndoOperations',
     'UpdateIdle',
     'UpdateNotice',

package/extension/src/content/modelPicker.js

@@ -134,7 +134,8 @@
         return { stale: false, error: response?.error || { code: 'provider_models_unavailable' } };
       }
       const sourceModels = hasDiscoveredModels ? response.result.models : fallbackModels;
-      const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel);
+      const preserveBuiltin = (selection?.providerId || 'builtin') === 'builtin' && (getState()?.providerId || 'builtin') === 'builtin';
+      const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel, { preserveUnavailable: preserveBuiltin });
       const normalized = modelCatalog.normalizeDiscoveredModels({ models: sourceModels, selectedModel: retainedSelectedModel });
       if (normalized.usedFallback && response.result?.providerId && response.result.providerId !== 'builtin') {
         applyUnavailableModelOptions({ code: 'provider_model_catalog_invalid', message: 'The active provider returned no usable models.' });
@@ -143,9 +144,12 @@
           error: { code: 'provider_model_catalog_invalid', message: 'The active provider returned no usable models.' }
         };
       }
-      renderModelOptions(normalized.models, retainedSelectedModel, { allowUnknownSelected: false });
+      const renderedModels = preserveBuiltin
+        ? Support.preserveSelectedCapabilities(normalized.models, retainedSelectedModel, getState(), !hasDiscoveredModels || response.result?.source === 'fallback')
+        : normalized.models;
+      renderModelOptions(renderedModels, retainedSelectedModel, { allowUnknownSelected: false });
       modelDiscovery = {
-        status: hasDiscoveredModels && !normalized.usedFallback ? 'discovered' : 'fallback',
+        status: hasDiscoveredModels && !normalized.usedFallback && response.result?.source !== 'fallback' ? 'discovered' : 'fallback',
         source: hasDiscoveredModels ? response.result?.source || 'unknown' : 'fallback',
         fetchedAt: hasDiscoveredModels ? response.result?.fetchedAt || '' : '',
         errorCode: hasDiscoveredModels ? '' : response?.error?.code || '',
@@ -172,15 +176,16 @@
   }
 
   function applyUnavailableModelOptions(error) {
+    const selectedModel = resolveSelectedModel();
     const modelSelect = getPanel()?.querySelector('[data-model]');
     if (modelSelect) {
       modelSelect.textContent = '';
       const option = document.createElement('option');
-      option.value = resolveSelectedModel();
+      option.value = selectedModel;
       option.textContent = tx('Models unavailable', '模型不可用');
       option.disabled = true;
       modelSelect.append(option);
-      modelSelect.value = '';
+      modelSelect.value = selectedModel;
       modelSelect.disabled = true;
     }
     modelDiscovery = {
@@ -190,8 +195,15 @@
       errorCode: error?.code || '',
       errorMessage: error?.message || (error ? String(error) : '')
     };
-    renderReasoningOptions([]);
-    renderSpeedOptions([]);
+    const pendingModels = Support.preserveSelectedCapabilities(
+      [{ id: selectedModel, unverified: true }], selectedModel, getState(), true
+    );
+    renderReasoningOptions(pendingModels);
+    renderSpeedOptions(pendingModels);
+    for (const selector of ['[data-reasoning]', '[data-speed]']) {
+      const input = getPanel()?.querySelector(selector);
+      if (input) input.disabled = true;
+    }
     renderModelConfigChoices();
     updateModelDisplay();
   }
@@ -200,9 +212,9 @@
     const modelCatalog = getModelCatalog();
     const fallbackModels = modelCatalog.FALLBACK_MODELS;
     const sourceModels = fallbackModels;
-    const retainedSelectedModel = retainSelectedModel(sourceModels, selectedModel);
+    const retainedSelectedModel = retainSelectedModel(sourceModels, selectedModel, { preserveUnavailable: (getState()?.providerId || 'builtin') === 'builtin' });
     const normalized = modelCatalog.normalizeDiscoveredModels({ models: sourceModels, selectedModel: retainedSelectedModel });
-    renderModelOptions(normalized.models, retainedSelectedModel);
+    renderModelOptions(Support.preserveSelectedCapabilities(normalized.models, retainedSelectedModel, getState(), true), retainedSelectedModel);
     modelDiscovery = {
       status: 'fallback',
       source: 'fallback',

package/extension/src/content/modelPickerSupport.js

@@ -29,14 +29,49 @@
     return String(label || '').replace(/^gpt[-\s]*/i, '');
   }
 
-  function retainSelectedModel(models, selectedModel) {
+  function retainSelectedModel(models, selectedModel, options = {}) {
     const selectedId = normalizeModelOptionId(selectedModel);
     if (!selectedId) return '';
+    if (options.preserveUnavailable === true) return selectedId;
     return (Array.isArray(models) ? models : []).some(model => (
       normalizeModelOptionId(typeof model === 'string' ? model : model?.id) === selectedId
     )) ? selectedId : '';
   }
 
+  // A fallback or missing catalog entry cannot revoke an explicit selection.
+  // Keep its saved controls provisional until real capability data arrives.
+  function preserveSelectedCapabilities(models, selectedModel, preferences = {}, provisional = false) {
+    const selectedId = normalizeModelOptionId(selectedModel);
+    const saved = preferences || {};
+    return (Array.isArray(models) ? models : []).map(model => {
+      if (model.id !== selectedId || (!provisional && !model.unverified)) return model;
+      const reasoningEfforts = normalizeReasoningEffortsForSelect([
+        ...(model.reasoningEfforts || []), saved.reasoningEffort
+      ]);
+      const speedTiers = normalizeSpeedTiersForSelect(model.speedTiers);
+      const speed = ['standard', 'fast'].includes(saved.speedTier) ? saved.speedTier : '';
+      if (speed && !speedTiers.includes(speed)) speedTiers.push(speed);
+      return {
+        ...model, unverified: true, reasoningEfforts, speedTiers,
+        defaultReasoningEffort: reasoningEfforts.includes(saved.reasoningEffort)
+          ? saved.reasoningEffort : model.defaultReasoningEffort,
+        defaultSpeedTier: speed || model.defaultSpeedTier || 'standard'
+      };
+    });
+  }
+
+  function getRenderedModelEntries(panel) {
+    return Array.from(panel?.querySelector('[data-model]')?.options || []).map(option => ({
+      id: option.value,
+      label: option.textContent,
+      reasoningEfforts: (option.dataset.reasoningEfforts || '').split(',').filter(Boolean),
+      defaultReasoningEffort: option.dataset.defaultReasoningEffort || '',
+      reasoningPresentation: option.dataset.reasoningPresentation || '',
+      speedTiers: (option.dataset.speedTiers || 'standard').split(',').filter(Boolean),
+      defaultSpeedTier: option.dataset.defaultSpeedTier || 'standard'
+    }));
+  }
+
   function shouldUseBuiltInFallback(response) {
     const providerId = normalizeModelOptionId(response?.result?.providerId);
     return response?.ok === true && (!providerId || providerId === 'builtin');
@@ -114,6 +149,8 @@
     normalizeReasoningEffortsForSelect,
     normalizeSpeedTiersForSelect,
     retainSelectedModel,
+    preserveSelectedCapabilities,
+    getRenderedModelEntries,
     shouldUseBuiltInFallback
   };
   return api;

package/extension/src/content/nativeCompatibilityController.js

@@ -23,7 +23,10 @@
     async function dispatch(payload, channelMethod) {
       const compatibilityGate = await ensureForMethod(payload?.method);
       if (!compatibilityGate.ok) return compatibilityGate.response;
-      if (gatedMethods.has(payload?.method)) options.throwIfCancellationRequested?.();
+      // Post-Undo cache bookkeeping must survive the ended run's cancellation.
+      if (gatedMethods.has(payload?.method) && payload.method !== 'mirror.invalidate') {
+        options.throwIfCancellationRequested?.();
+      }
       return nativeChannel[channelMethod](
         attachEvidence(payload, compatibilityGate.compatibility)
       );

package/extension/src/content/otWarmMirror.js

@@ -1,6 +1,5 @@
 (function initCodexOverleafOtWarmMirror() {
   'use strict';
-
   // Experimental OT warm-mirror glue carved out of contentRuntime.js (v1.4.9
   // structural-debt phase 5): the per-project enable toggle flow, the
   // poll/flush timers and patch queue, mirror prefetch, warm-start
@@ -52,6 +51,7 @@
   let currentOtStatus = 'off';
   let otTogglePending = false;
   let otSyncRequestId = 0;
+  let otStartRetryCount = 0;
   let otWarmMirrorProjectId = '';
   let lastExperimentalOtProjectId = '';
   let otWarmMirrorState = {
@@ -226,6 +226,7 @@
     const projectId = getCurrentProjectId();
     otWarmMirrorState.failureActive = false;
     lastExperimentalOtProjectId = projectId;
+    otStartRetryCount = 0;
     setExperimentalOtEnabledForProject(projectId, checkbox.checked);
     updateExperimentalOtToggleControl(checkbox.checked);
     // Per-card saved feedback, same contract as every other settings card.
@@ -306,8 +307,10 @@
       await pauseOtWarmMirror(pauseAfterStart.reason || 'paused');
       return response;
     }
-    otWarmMirrorState.failureActive = false;
+    if (status === 'starting') recordOtFailure('missing_active_path', 'start');
+    else otWarmMirrorState.failureActive = false;
     updateOtStatusDisplay(status);
+    otStartRetryCount = 0;
     scheduleOtEventPolling(projectId, { immediate: true });
     return response;
   }
@@ -338,21 +341,36 @@
     clearOtEventPolling({ clearPatchQueue: true });
     recordOtFailure(readOtBridgeErrorCode(response, 'ot_start_failed'), 'start');
     otWarmMirrorState.suspended = true;
-    setExperimentalOtEnabledForProject(projectId, false);
-    const experimentalOtCheckbox = getPanel()?.querySelector('[data-experimental-ot]');
-    if (experimentalOtCheckbox) {
-      experimentalOtCheckbox.checked = false;
-    }
+    // Observer availability is transient; only an explicit user action may
+    // change the persisted opt-in. A cold editor/bridge must not turn OT off
+    // permanently. failureActive/suspended already prohibit cache reuse.
+    updateExperimentalOtToggleControl(isExperimentalOtEnabledForProject(projectId));
     updateOtStatusDisplay('unavailable');
-    saveStateSoon();
     try { await callPageBridge('stopOtObserver', { projectId }); } catch (_error) { /* preserve the original failure */ }
+    scheduleOtStartRetry(projectId, requestId);
+  }
+
+  function scheduleOtStartRetry(projectId, requestId) {
+    const retryDelays = [1000, 3000, 6000];
+    const canRetry = () => isCurrentOtSync(requestId, projectId) && getCurrentProjectId() === projectId
+      && isExperimentalOtEnabledForProject(projectId) && !getCurrentRunView();
+    if (!canRetry() || otStartRetryCount >= retryDelays.length) return;
+    // Use the existing owned timer so disabling OT, changing projects and
+    // starting a new observation all cancel pending retries normally.
+    const delayMs = retryDelays[otStartRetryCount++];
+    otWarmMirrorState.pollTimer = window.setTimeout(() => {
+      otWarmMirrorState.pollTimer = null;
+      if (!canRetry()) return;
+      syncOtWarmMirrorController().catch(() => {
+        if (getCurrentProjectId() === projectId && isExperimentalOtEnabledForProject(projectId)) {
+          updateOtStatusDisplay('unavailable');
+        }
+      });
+    }, delayMs);
   }
 
   function readOtBridgeStatus(response) {
-    if (!response || response.ok === false) {
-      return 'unavailable';
-    }
-    return response.state || response.status || response.result?.state || response.result?.status || 'unavailable';
+    return otWarmMirrorController.readOtBridgeStatus(response);
   }
 
   function ensureOtWarmMirrorStateProject(projectId) {
@@ -361,6 +379,7 @@
     }
     clearOtEventPolling({ clearPatchQueue: true });
     otWarmMirrorState.projectId = projectId;
+    otStartRetryCount = 0;
     otWarmMirrorState.lastPatchAt = 0;
     otWarmMirrorState.lastErrorCode = '';
     otWarmMirrorState.failureActive = false;
@@ -438,6 +457,7 @@
         return statusResponse;
       }
       const status = readOtBridgeStatus(statusResponse);
+      if (status === 'observing' && otWarmMirrorState.lastFailure?.phase === 'start') Object.assign(otWarmMirrorState, { failureActive: false, lastErrorCode: '', lastFailure: null });
       if (['unavailable', 'inconsistent'].includes(status)) recordOtFailure(readOtBridgeErrorCode(statusResponse, 'ot_observer_unavailable'), 'observe');
       if (status) {
         updateOtStatusDisplay(status);
@@ -470,27 +490,11 @@
   }
 
   function readOtBridgeEvents(response) {
-    if (Array.isArray(response)) {
-      return response;
-    }
-    if (Array.isArray(response?.events)) {
-      return response.events;
-    }
-    if (Array.isArray(response?.result?.events)) {
-      return response.result.events;
-    }
-    return [];
+    return otWarmMirrorController.readOtBridgeEvents(response);
   }
-
   function readOtBridgeErrorCode(response, fallback) {
-    const value = response?.lastErrorCode
-      || response?.reason
-      || response?.error?.code
-      || response?.error
-      || fallback;
-    return typeof value === 'string' ? value : fallback;
+    return otWarmMirrorController.readOtBridgeErrorCode(response, fallback);
   }
-
   function recordOtFailure(code, phase) {
     code = otWarmMirrorController.normalizeFailureCode(code);
     otWarmMirrorState.lastErrorCode = code;

package/extension/src/content/otWarmMirrorController.js

@@ -174,6 +174,23 @@
     return { ok: true };
   }
 
+  function readOtBridgeStatus(response) {
+    if (!response || response.ok === false) return 'unavailable';
+    return response.state || response.status || response.result?.state || response.result?.status || 'unavailable';
+  }
+
+  function readOtBridgeEvents(response) {
+    if (Array.isArray(response)) return response;
+    if (Array.isArray(response?.events)) return response.events;
+    if (Array.isArray(response?.result?.events)) return response.result.events;
+    return [];
+  }
+
+  function readOtBridgeErrorCode(response, fallback) {
+    const value = response?.lastErrorCode || response?.reason || response?.error?.code || response?.error || fallback;
+    return typeof value === 'string' ? value : fallback;
+  }
+
   function normalizeFailureCode(value, fallback = 'ot_error') {
     const code = typeof value === 'string' ? value : value?.code;
     if (/^[a-z][a-z0-9_]{0,79}$/.test(code || '')) return code;
@@ -265,6 +282,9 @@
     takePatchBatch,
     validatePatchReceipt,
     normalizeFailureCode,
+    readOtBridgeStatus,
+    readOtBridgeEvents,
+    readOtBridgeErrorCode,
     getFailureMessageKey,
     buildPatchFilesRequest,
     canUseOtWarmStart,

package/extension/src/content/pageBridgeClient.js

@@ -21,9 +21,11 @@
     ['src/page/overleafProjectSnapshot.js', 'codex-overleaf-project-snapshot-script'],
     ['src/page/pageBridgeCapability.js', 'codex-overleaf-page-bridge-capability-script'],
     ['src/page/treeOperations.js', 'codex-overleaf-tree-operations-script', true],
+    ['src/page/textFileCreator.js', 'codex-overleaf-text-file-creator-script', true],
     ['src/page/binaryAssetUploader.js', 'codex-overleaf-binary-asset-uploader-script', true],
     ['src/page/snapshotRouter.js', 'codex-overleaf-snapshot-router-script'],
     ['src/page/writeGuard.js', 'codex-overleaf-write-guard-script', true],
+    ['src/page/trackedChangeCapture.js', 'codex-overleaf-tracked-change-capture-script', true],
     ['src/page/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],
     ['src/page/writebackRouter.js', 'codex-overleaf-writeback-router-script', true],
     ['src/pageBridge.js', 'codex-overleaf-page-bridge-script', true]

package/extension/src/content/runResultActions.js

@@ -107,7 +107,22 @@
       if (!copied) throw new Error('clipboard_copy_failed');
     }
 
-    return Object.freeze({ configureResultActions });
+    return Object.freeze({ configureResultActions, projectUndoAvailability });
+  }
+
+  function projectUndoAvailability(run, projectRunSettlement) {
+    const payload = run.recoveryPayload && typeof run.recoveryPayload === 'object'
+      ? run.recoveryPayload : run;
+    if (!Array.isArray(payload.appliedOperations)) return projectRunSettlement(run);
+    // Forward binary writes do not provide a rollback. Filter them only for
+    // display; preserve the canonical settlement and every real recovery field.
+    const appliedOperations = payload.appliedOperations.filter(operation =>
+      operation?.type !== 'binary-create' && operation?.type !== 'overwrite-binary');
+    if (appliedOperations.length === payload.appliedOperations.length) return projectRunSettlement(run);
+    return projectRunSettlement({
+      ...run,
+      recoveryPayload: { ...payload, appliedOperations }
+    });
   }
 
   return Object.freeze({ create });

package/extension/src/content/runTimelineView.js

@@ -932,7 +932,7 @@
       return;
     }
 
-    const projection = projectRunSettlement(run);
+    const projection = RunResultActions.projectUndoAvailability(run, projectRunSettlement);
     if (!projection.canUndo && run.undoStatus !== 'applied') {
       button.hidden = true;
       return;

package/extension/src/content/sessionForkController.js

@@ -16,19 +16,28 @@
       const source = findSource(previousState, runId);
       if (!source) return failFork('session_fork_source_missing', tr('forkRunUnavailable'));
       const { session, run, runIndex } = source;
-      if (run.status === 'running' || !session.codexThreadId || !run.codexTurnId) {
+      const draftThreadId = run.codexTurnId && run.interruptedDraft?.turnId === run.codexTurnId
+        ? run.interruptedDraft.threadId : '';
+      // Provider switches replace the session thread, not the selected node's origin.
+      const sourceThreadId = String(run.codexThreadId || draftThreadId || session.codexThreadId || '').trim();
+      if (run.status === 'running' || !sourceThreadId || !run.codexTurnId) {
         return failFork('session_fork_unavailable', tr('forkRunUnavailable'));
       }
-      const response = await sendBackgroundNative({
-        method: 'codex.thread.fork',
-        params: {
-          threadId: session.codexThreadId,
-          lastTurnId: run.codexTurnId,
-          speedTier: session.speedTier,
-          loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
-          loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false
-        }
-      });
+      let response;
+      try {
+        response = await sendBackgroundNative({
+          method: 'codex.thread.fork',
+          params: {
+            threadId: sourceThreadId,
+            lastTurnId: run.codexTurnId,
+            speedTier: session.speedTier,
+            loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
+            loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false
+          }
+        });
+      } catch (error) {
+        return failFork(error?.code || 'session_fork_failed', error?.message || tr('forkRunFailed'));
+      }
       if (!response?.ok || !response.result?.threadId) {
         return failFork(response?.error?.code || 'session_fork_failed', response?.error?.message || tr('forkRunFailed'));
       }

package/extension/src/content/trackedChangeCaptureController.js

@@ -0,0 +1,153 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafTrackedChangeCaptureController = api;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+  function create(deps = {}) {
+    const now = deps.now || (() => Date.now());
+    const defer = deps.setTimeout || setTimeout;
+    const cancelTimer = deps.clearTimeout || clearTimeout;
+    let timer = null, busy = false, disposed = false;
+    const runs = () => deps.getRuns() || [];
+    const pending = run => Array.isArray(run.trackedChangeCaptures)
+      && run.trackedChangeCaptures.some(capture => capture.state === 'pending');
+    const terminal = run => ['accepted', 'rejected'].includes(run.trackedChangeStatus)
+      || run.undoStatus === 'applied' || run.forkSnapshot === true;
+    function buildPostFiles(run) {
+      const expectedFiles = Array.isArray(run?.undoExpectedFiles) ? run.undoExpectedFiles : [];
+      const appliedOperations = Array.isArray(run?.appliedOperations) ? run.appliedOperations : [];
+      if (!expectedFiles.length || !appliedOperations.length) return [];
+      const postFilesByPath = deps.buildExpectedFilesAfterOperations({ files: expectedFiles }, appliedOperations);
+      const expectedPaths = new Set(expectedFiles.map(file => file?.path).filter(Boolean));
+      return Array.from(postFilesByPath.entries())
+        .filter(([path, content]) => expectedPaths.has(path) && typeof content === 'string')
+        .map(([path, content]) => ({ path, content }));
+    }
+    function hasLegacyUntrackedCheckpoint(run) {
+      if (!run || run.executionSnapshot || run.trackedChangeStatus || run.undoStatus === 'applied'
+        || run.forkSnapshot || run.undoTrackedChanges?.length || run.trackedChangeCaptures?.length) return false;
+      const operations = Array.isArray(run.undoOperations) ? run.undoOperations : [];
+      const before = Array.isArray(run.undoExpectedFiles) ? run.undoExpectedFiles : [];
+      if (!operations.length || !before.length || before.some(file => !file?.path || typeof file.content !== 'string')) return false;
+      const paths = new Set(before.map(file => file.path));
+      if (paths.size !== before.length || operations.some(op => op?.type !== 'edit' || !paths.has(op.path))) return false;
+      const complete = files => Array.isArray(files) && files.length === paths.size
+        && new Set(files.map(file => file?.path)).size === paths.size
+        && files.every(file => paths.has(file?.path) && typeof file.content === 'string');
+      const storedPost = run.undoBaseFiles;
+      try {
+        const post = buildPostFiles(run);
+        if (!complete(storedPost) || !complete(post)) return false;
+        const postByPath = new Map(post.map(file => [file.path, file.content]));
+        if (!storedPost.every(file => postByPath.get(file.path) === file.content)) return false;
+        const restored = deps.buildExpectedFilesAfterOperations({ files: storedPost }, operations);
+        // A legacy checkpoint must prove both directions; empty refs alone grant nothing.
+        return before.every(file => restored.get(file.path) === file.content);
+      } catch (_error) { return false; }
+    }
+    function schedule() {
+      if (disposed || timer !== null || busy || !runs().some(pending)) return;
+      timer = defer(() => {
+        timer = null;
+        flush().catch(error => deps.onError?.(error));
+      }, 500);
+    }
+    function record(run, captures) {
+      if (!Array.isArray(captures) || !captures.length) return;
+      const next = [...(run.trackedChangeCaptures || []), ...captures.filter(Boolean)];
+      if (next.every(capture => capture.state === 'observed')) return;
+      run.trackedChangeCaptures = next;
+      deps.notify?.(run, next.some(capture => capture.state === 'pending') ? 'pending' : 'needs_review', {
+        captures: next.map(capture => ({ path: capture.path, reason: capture.reason, ...capture.diagnostics }))
+      });
+      deps.persist().then(schedule).catch(error => deps.onError?.(error));
+    }
+    async function flush() {
+      if (disposed || busy) return;
+      busy = true;
+      try {
+        for (const run of runs().filter(pending)) {
+          if (terminal(run)) { run.trackedChangeCaptures = []; await deps.persist(); continue; }
+          if (run.runProjectId !== deps.getProjectId()) continue;
+          const newer = runs().some(other => other.id !== run.id
+            && other.runProjectId === run.runProjectId
+            && Date.parse(other.startedAt) > Date.parse(run.startedAt));
+          const original = run.trackedChangeCaptures;
+          const captures = original.map(capture => ({ ...capture }));
+          const postFiles = buildPostFiles(run);
+          for (let i = 0; i < captures.length; i++) {
+            const capture = captures[i];
+            if (capture.state !== 'pending') continue;
+            const expected = postFiles.find(file => file.path === capture.path);
+            if (newer || !expected || now() >= capture.expiresAt || run.status === 'cancelled') {
+              capture.state = 'needs_review';
+              capture.reason = newer ? 'capture_superseded' : !expected ? 'capture_baseline_missing'
+                : run.status === 'cancelled' ? 'capture_cancelled' : 'capture_expired';
+              continue;
+            }
+            let response;
+            try {
+              response = await deps.callPageBridge('reconcileTrackedChangeCapture', {
+                runProjectId: run.runProjectId, capture, expectedContent: expected.content
+              });
+            } catch (_error) {
+              response = null;
+            }
+            // Never patch a superseded hydrated record or another project's state.
+            if (disposed || deps.getProjectId() !== run.runProjectId
+              || !runs().includes(run) || terminal(run) || run.trackedChangeCaptures !== original) return;
+            const superseded = runs().some(other => other.id !== run.id
+              && other.runProjectId === run.runProjectId
+              && Date.parse(other.startedAt) > Date.parse(run.startedAt));
+            if (superseded || run.status === 'cancelled') {
+              captures[i] = { ...capture, state: 'needs_review', reason: 'capture_superseded' };
+            } else if (response?.capture?.path === capture.path
+              && response.capture.runProjectId === run.runProjectId
+              && ['observed', 'pending', 'needs_review'].includes(response.capture.state)) {
+              captures[i] = response.capture;
+            } else {
+              captures[i] = { ...capture, state: 'needs_review', reason: 'capture_bridge_unavailable' };
+            }
+          }
+          if (!runs().includes(run) || terminal(run) || deps.getProjectId() !== run.runProjectId) continue;
+          if (captures.length && captures.every(capture => capture.state === 'observed')) {
+            const refs = deps.normalizeTrackedChanges([
+              ...(run.undoTrackedChanges || []), ...captures.flatMap(capture => capture.refs || [])
+            ]);
+            if (refs.length) {
+              run.undoTrackedChanges = refs;
+              run.trackedChangeStatus = 'pending';
+              run.trackedChangeCaptures = [];
+              await deps.persist();
+              deps.refresh(run);
+              deps.notify?.(run, 'observed', { count: refs.length });
+              continue;
+            }
+          }
+          const changed = JSON.stringify(original.map(summary)) !== JSON.stringify(captures.map(summary));
+          if (changed) {
+            run.trackedChangeCaptures = captures;
+            await deps.persist();
+            if (!pending(run)) deps.notify?.(run, 'needs_review', {
+              reasons: captures.filter(capture => capture.state !== 'observed').map(capture => capture.reason)
+            });
+          }
+        }
+      } finally {
+        busy = false;
+        if (runs().some(run => pending(run) && run.runProjectId === deps.getProjectId())) schedule();
+      }
+    }
+    function summary(capture) {
+      return { state: capture.state, reason: capture.reason, refs: (capture.refs || []).map(ref => ref.key) };
+    }
+    function dispose() {
+      disposed = true;
+      if (timer !== null) cancelTimer(timer);
+      timer = null;
+    }
+    return { record, schedule, flush, dispose, buildPostFiles, hasLegacyUntrackedCheckpoint };
+  }
+  return { create };
+});

package/extension/src/content/writebackOrchestrator.js

@@ -18,6 +18,7 @@
   let tx;
   let getLocale;
   let appendRunEvent;
+  let appendRunRecordEvent;
   // In-flight background mirror refresh (v1.7.5) — see the writeback path.
   let pendingMirrorRefresh = null;
   let appendChangeSummary;
@@ -69,6 +70,34 @@
       : 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.');
+      }
+      if (getCurrentProjectId() === projectId) {
+        resetContextProject();
+        await callPageBridge('invalidateProjectSnapshot', { invalidateFileList: true });
+      }
+      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';
+    }).finally(() => {
+      if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
+    });
+    pendingMirrorRefresh = pending;
+    return pending;
+  }
+
   async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options = {}) {
     const runMode = options.mode || getState().mode;
     const runRequireReviewing = typeof options.requireReviewing === 'boolean'
@@ -822,6 +851,7 @@
       tx,
       getLocale,
       appendRunEvent,
+      appendRunRecordEvent,
       appendChangeSummary,
       appendCompletionReport,
       appendOperationsPreview,
@@ -867,6 +897,7 @@
     return {
       applySyncChangesToOverleaf,
       resolveCompileLogContext,
+      invalidateMirrorAfterUndo,
       getPendingMirrorRefresh: () => pendingMirrorRefresh
     };
   }