codex-overleaf-link 2.3.5 → 2.4.0

package/extension/src/page/writebackRouter.js

@@ -392,54 +392,45 @@
       : result;
   }
 
-  async function applyOperationsWithNoTraceUndo(operations, options = {}) {
-    const initial = getReviewingState({});
-    if (isEditingConfirmedForNoTraceUndo(initial)) {
-      const result = await applyOperationsCore(operations, options);
-      return {
-        ...result,
-        reviewingPolicy: {
-          policy: 'no-trace-undo',
-          disabled: false,
-          restored: false,
-          reason: 'editing_already_confirmed'
-        }
-      };
-    }
-
-    const disabled = await setReviewingEnabled(false, { waitMs: 1800 });
-    if (!disabled.ok) {
-      return buildNoTraceUndoBlockedResult(operations, disabled);
-    }
+  async function confirmNoTraceUndoEditing() {
+    let changed = false;
+    let toggle = { ok: true, changed: false, enabled: false };
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (!isEditingConfirmedForNoTraceUndo(getReviewingState({}))) {
+        toggle = await setReviewingEnabled(false, { waitMs: 1800 });
+        if (!toggle.ok) return toggle;
+        changed = changed || toggle.changed === true;
+      }
+      await delay(180);
+      if (!isEditingConfirmedForNoTraceUndo(getReviewingState({}))) continue;
+      await delay(180);
+      if (isEditingConfirmedForNoTraceUndo(getReviewingState({})))
+        return { ...toggle, ok: true, changed, enabled: false };
+    }
+    return { ok: false, code: 'editing_not_confirmed',
+      reason: 'Overleaf Editing mode did not remain confirmed before undo; no undo write was started.' };
+  }
 
-    let result;
-    let applyError = null;
-    try {
-      result = await applyOperationsCore(operations, options);
-    } catch (error) {
-      applyError = error;
-    }
-    if (applyError) {
-      throw applyError;
+  async function applyOperationsWithNoTraceUndo(operations, options = {}) {
+    const disabled = await confirmNoTraceUndoEditing();
+    if (!disabled.ok) return buildNoTraceUndoBlockedResult(operations, disabled);
+    const result = await applyOperationsCore(operations, {
+      ...options, noTraceUndo: true, trackReviewingChanges: false
+    });
+    const reviewingPolicy = { policy: 'no-trace-undo', disabled: disabled.changed === true, restored: false,
+      reason: disabled.changed ? 'left_editing_after_undo' : 'editing_already_confirmed' };
+    if (disabled.changed) {
+      reviewingPolicy.leftEditing = true;
+      reviewingPolicy.disable = summarizeReviewingToggleResult(disabled);
     }
-
-    return {
-      ...result,
-      reviewingPolicy: {
-        policy: 'no-trace-undo',
-        disabled: true,
-        restored: false,
-        leftEditing: true,
-        reason: 'left_editing_after_undo',
-        disable: summarizeReviewingToggleResult(disabled)
-      }
-    };
+    return { ...result, reviewingPolicy };
   }
 
   async function applyOperationsCore(operations, options = {}) {
     const applied = [];
     const skipped = [];
     const trackedChanges = [];
+    const trackedChangeCaptures = [];
     const safeBaseFiles = normalizeBaseFilesForSafety(options.baseFiles);
     const baseFileLookup = window.CodexOverleafStaleGuard?.buildBaseFileLookup(safeBaseFiles);
     const baseBinaryFileLookup = buildBaseBinaryFileLookup(safeBaseFiles);
@@ -574,8 +565,10 @@
       let raceResult;
       if (operation.type === 'edit') {
         raceResult = await raceOpAgainstCancellation(applyEditOperation(operation, {
-          baseFileLookup,
-          trackReviewingChanges: options.trackReviewingChanges === true
+          baseFileLookup, runProjectId,
+          recheckWriteProject: writeGuardSurface ? () => writeGuardSurface.runWriteGuard({ runProjectId }) : null,
+          trackReviewingChanges: options.trackReviewingChanges === true,
+          noTraceUndo: options.noTraceUndo === true
         }));
       } else if (['binary-create', 'overwrite-binary'].includes(operation.type)) {
         raceResult = await raceOpAgainstCancellation(applyBinaryAssetOperation(operation, { baseFileLookup, baseBinaryFileLookup }));
@@ -604,6 +597,7 @@
         break;
       }
       const result = raceResult;
+      if (result.trackedChangeCapture) trackedChangeCaptures.push(result.trackedChangeCapture);
       if (operation.type === 'edit' && result.ok && Array.isArray(result.trackedChanges)) {
         trackedChanges.push(...result.trackedChanges);
       }
@@ -618,7 +612,8 @@
       ok: skipped.length === 0,
       applied,
       skipped,
-      trackedChanges: mergeTrackedChangeRefs(trackedChanges)
+      trackedChanges: trackedChangeCaptures.some(capture => capture.state !== 'observed') ? [] : mergeTrackedChangeRefs(trackedChanges),
+      trackedChangeCaptures
     };
   }
 
@@ -653,12 +648,17 @@
       return editorReady;
     }
 
+    if (options.noTraceUndo === true) {
+      const editing = await confirmNoTraceUndoEditing();
+      if (!editing.ok) return buildNoTraceUndoBlockedResult([operation], editing).skipped[0].result;
+    }
     const trackReviewingChanges = options.trackReviewingChanges === true;
     const forbidTrackedChanges = options.forbidTrackedChanges === true;
     const observeTrackedChanges = trackReviewingChanges || forbidTrackedChanges;
     const operationPaths = collectOperationPaths([operation]);
+    const captureBaseline = trackReviewingChanges ? prepareTrackedChangeCapture(operation.path) : null;
     const trackedBefore = observeTrackedChanges
-      ? collectTrackedChangeRefsForPaths(operationPaths)
+      ? (captureBaseline?.refs || collectTrackedChangeRefsForPaths(operationPaths))
       : [];
     let current = editorReady.text;
     let freshness = window.CodexOverleafStaleGuard?.checkOperationFreshness(
@@ -752,6 +752,25 @@
       };
     }
 
+    if (options.noTraceUndo === true) {
+      const blocked = typeof options.recheckWriteProject === 'function'
+        ? await options.recheckWriteProject()
+        : { ok: false, code: 'editor_project_id_unavailable',
+          failure: buildPageFailure('editor_project_id_unavailable', { file: operation.path,
+            operationType: 'undo', changedDocument: false,
+            userMessage: 'The project identity guard is unavailable; the undo write was not applied.' }) };
+      if (blocked) return blocked.skipped?.[0]?.result || blocked;
+      if (getActiveFilePath() !== operation.path || readActiveEditorText() !== current) {
+        const reason = 'The editor changed while confirming Editing mode; the undo write was not applied.';
+        return { ok: false, code: 'stale_source_changed', reason,
+          failure: buildPageFailure('stale_source_changed', { file: operation.path,
+            operationType: 'undo', changedDocument: false, userMessage: reason }) };
+      }
+      if (!isEditingConfirmedForNoTraceUndo(getReviewingState({})))
+        return buildNoTraceUndoBlockedResult([operation], { ok: false, code: 'editing_not_confirmed',
+          reason: 'Overleaf left Editing mode before the undo write.' }).skipped[0].result;
+    }
+
     const result = Array.isArray(operation.patches) && operation.patches.length
       ? replaceActiveEditorPatches(operation.patches, nextContent)
       : replaceActiveEditorText(nextContent);
@@ -784,6 +803,7 @@
       return decorated;
     }
     const trackedChanges = [];
+    let trackedChangeCapture = null;
     if (observeTrackedChanges) {
       // Overleaf renders review markers asynchronously after the editor text
       // has already changed. A single 120 ms snapshot intermittently missed
@@ -791,10 +811,13 @@
       // Poll both paths: normal Reviewing writes get a shorter capture window,
       // while Accept replay keeps the longer safety window used to prove that
       // it did not create fresh tracked changes.
-      const trackedDiff = await waitForTrackedChangeDiff(trackedBefore, operationPaths, {
-        waitMs: forbidTrackedChanges ? 3600 : 1800,
-        intervalMs: 180
-      });
+      const trackedDiff = trackReviewingChanges
+        ? await captureTrackedWrite({ trackedBefore, captureBaseline, operation, beforeContent: current,
+          postContent: nextContent, runProjectId: options.runProjectId })
+        : await waitForTrackedChangeDiff(trackedBefore, operationPaths, {
+          waitMs: 3600, intervalMs: 180, stopOnFirst: true
+        });
+      trackedChangeCapture = trackedDiff.capture || null;
       trackedChanges.push(...trackedDiff.trackedChanges);
       if (forbidTrackedChanges && trackedChanges.length > 0) {
         return {
@@ -831,6 +854,7 @@
       ...result,
       verified: true,
       verifiedContent: nextContent,
+      trackedChangeCapture,
       trackedChanges: mergeTrackedChangeRefs(trackedChanges)
     };
   }
@@ -1352,6 +1376,8 @@
   }
 
   async function applyFileTreeOperation(operation, options = {}) {
+    const initialProjectId = treeOperations.getProjectId?.();
+    const initialCancellationSequence = readWriteCancellationSequence();
     const freshness = await checkFileTreeOperationFreshness(operation, options.baseFileLookup);
     if (!freshness.ok) {
       return freshness;
@@ -1400,8 +1426,21 @@
       }
     }
 
+    const nativeOperation = { create: deps.createTextFile, delete: deps.deleteTextFile }[operation.type];
+    if (typeof nativeOperation === 'function' && (operation.type === 'delete' || typeof operation.content === 'string')) {
+      const isCurrent = () => Boolean(initialProjectId) && treeOperations.getProjectId?.() === initialProjectId
+        && readWriteCancellationSequence() === initialCancellationSequence;
+      const created = await nativeOperation(operation, { isCurrent, expectedContent: options.baseFileLookup?.get(operation.path) });
+      if (!created.ok) return created;
+      if (!isCurrent() || created.verified !== true || created.verification !== 'overleaf-zip') {
+        return { ...fileTreeVerificationFailed(operation, 'Server receipt is missing or stale.'), changedDocument: true };
+      }
+      recordFileTreeOperationSuccess(operation, options.baseFileLookup);
+      return { ok: true, method: created.method, verified: true };
+    }
     return {
       ok: false,
+      code: 'file_tree_controls_unavailable',
       reason: 'No supported Overleaf file-tree method was detected'
     };
   }
@@ -1847,6 +1886,8 @@
       acceptTrackedChanges,
       rejectTrackedChanges,
       collectTrackedChangeRefsForPaths,
+      prepareTrackedChangeCapture, getTrackedChangeCaptureStatus,
+      captureTrackedWrite, reconcileTrackedChangeCapture,
       waitForTrackedChangeDiff
     } = trackedChangesLifecycleModule.create({
       window,
@@ -1868,6 +1909,9 @@
       buildPageFailure,
       delay,
       getActiveFilePath,
+      getProjectId: () => treeOperations.getProjectId?.() || '',
+      getCodeMirrorEditorView: deps.getCodeMirrorEditorView,
+      getTrackedChangeDocumentId: deps.getTrackedChangeDocumentId,
       getReviewingState,
       isEditorUndoControl,
       isInsideCodexPanel,
@@ -1885,6 +1929,8 @@
 
     return {
       applyOperations: applyOperationsForBridge,
+      getTrackedChangeCaptureStatus,
+      reconcileTrackedChangeCapture,
       rejectTrackedChanges,
       acceptTrackedChanges,
       verifySaveState

package/extension/src/pageBridge.js

@@ -67,7 +67,14 @@
     treeOperations,
     window
   });
+  const textFileCreator = requirePageModule('CodexOverleafTextFileCreator').create({
+    window, document, treeOperations, snapshotRouter,
+    collectElements, ensureEditing, ensureReviewing, readActiveEditorText, readWriteCancellationSequence,
+    uploadHelpers: requirePageModule('CodexOverleafBinaryAssetUploader')
+  });
   binaryAssetUploader = requirePageModule('CodexOverleafBinaryAssetUploader').create({
+    prepareUploadParent: textFileCreator.prepareUploadParent,
+    findFolderNode: textFileCreator.findFolderNode,
     document,
     snapshotRouter,
     treeOperations,
@@ -86,6 +93,8 @@
     window
   });
   writebackRouter = requirePageModule('CodexOverleafWritebackRouter').create({
+    createTextFile: textFileCreator.createFile,
+    deleteTextFile: textFileCreator.deleteFile,
     activeEditorIdentityChanged,
     clickNode,
     collectElements,
@@ -93,8 +102,14 @@
     compileBridge,
     delay,
     diagnosticsRevision: PAGE_BRIDGE_INSTALL_REVISION,
-    ensureEditing,
-    ensureReviewing,
+    getCodeMirrorEditorView,
+    getTrackedChangeDocumentId: filePath => {
+      const ids = new Set(collectDocRecords({ includeWindowGlobals: true })
+        .filter(record => record.path === filePath && typeof record.id === 'string' && record.id).map(record => record.id));
+      return ids.size === 1 ? Array.from(ids)[0] : '';
+    },
+    ensureEditing: params => textFileCreator.ensureWriteMode(false, params),
+    ensureReviewing: params => textFileCreator.ensureWriteMode(true, params),
     // Cross-world cancel: the router's per-op loop polls this each iteration
     // and aborts remaining ops when the value bumps. content-side cancel
     // invokes pageBridge.cancelActiveWrite which calls bumpWriteCancellationSequence.
@@ -205,20 +220,28 @@
       return { ok: true };
     },
     createCheckpoint: params => createCheckpoint(params.label),
-    ensureReviewing,
-    ensureEditing,
-    applyOperations: params => applyOperations(params.operations || [], {
+    ensureReviewing: params => textFileCreator.ensureWriteMode(true, params),
+    ensureEditing: params => textFileCreator.ensureWriteMode(false, params),
+    applyOperations: async params => {
+      if (params.reviewingPolicy === 'no-trace-undo') {
+        const prepared = await textFileCreator.prepareEditor(params);
+        if (prepared.ok !== true) return { applied: [], changedDocument: false,
+          skipped: (params.operations || []).map(operation => ({ operation, result: prepared })) };
+      }
+      return applyOperations(params.operations || [], {
         baseFiles: params.baseFiles || null,
         reviewingPolicy: params.reviewingPolicy || '',
         requireReviewing: params.requireReviewing === true,
         requireEditing: params.requireEditing === true,
         runProjectId: typeof params.runProjectId === 'string' ? params.runProjectId : ''
-      }),
+      });
+    },
     binaryUploadBegin: params => binaryAssetUploader.begin(params),
     binaryUploadAppend: params => binaryAssetUploader.append(params),
     binaryUploadCommit: params => binaryAssetUploader.commit(params),
     binaryUploadAbort: params => binaryAssetUploader.abort(params),
     jumpToPosition,
+    reconcileTrackedChangeCapture: params => writebackRouter.reconcileTrackedChangeCapture(params),
     rejectTrackedChanges,
     acceptTrackedChanges,
     triggerCompile: params => compileBridge.triggerCompile(params),
@@ -430,6 +453,7 @@
       editor,
       capabilities: pageRpcContract.withCapabilityReport(collectPageCapabilities(editor)),
       editorDiagnostics: buildEditorDiagnostics(editor),
+      trackedChangeCapture: writebackRouter.getTrackedChangeCaptureStatus?.(),
       projectDiagnostics: {
         internalRootKeys: collectInternalRootKeys(),
         docRecordCount: docRecords.length,
@@ -559,40 +583,26 @@
         reason: 'jumpToPosition requires a non-empty file path'
       };
     }
-    if (!projectPathExists(filePath)) {
-      return {
-        ok: false,
-        code: 'path_not_found',
-        reason: `Could not find ${filePath} in the Overleaf project`,
-        path: filePath,
-        failure: buildPageBridgeFailure('target_file_not_found', {
-          file: filePath,
-          operationType: 'jump',
-          changedDocument: false,
-          userMessage: `Codex could not find ${filePath} in this Overleaf project.`,
-          evidence: { originalCode: 'path_not_found', writeStarted: false }
-        })
-      };
-    }
-
     const navigating = getActiveFilePath() !== filePath;
     const previousEditorIdentity = navigating ? getActiveEditorIdentity() : null;
 
     if (navigating) {
       const opened = await openFileByPath(filePath);
       if (!opened.ok) {
+        const missing = !projectPathExists(filePath);
+        const code = missing ? 'path_not_found' : 'file_open_failed';
         return {
           ok: false,
-          code: 'file_open_failed',
+          code,
           reason: opened.reason || `Could not open ${filePath}`,
           path: filePath,
-          failure: buildPageBridgeFailure('target_file_open_failed', {
+          failure: buildPageBridgeFailure(missing ? 'target_file_not_found' : 'target_file_open_failed', {
             file: filePath,
             operationType: 'jump',
             changedDocument: false,
             userMessage: `Codex could not open ${filePath} in Overleaf.`,
             technicalMessage: opened.reason || '',
-            evidence: { originalCode: 'file_open_failed', writeStarted: false }
+            evidence: { originalCode: code, writeStarted: false }
           })
         };
       }
@@ -830,10 +840,35 @@
     return current.node !== previous.node;
   }
 
+  function readCurrentEditorMode() {
+    const selector = '.toolbar-editor .review-mode-switcher > .review-mode-switcher-toggle-button';
+    const controls = uniqueNodes(collectElements(selector, 16)).filter(node =>
+      String(node.className || '').split(/\s+/).includes('review-mode-switcher-toggle-button')
+      && node.ownerDocument === document && !isInsideCodexPanel(node));
+    if (!controls.length) return '';
+    const modes = controls.filter(node => {
+      const style = window.getComputedStyle?.(node);
+      return node.isConnected !== false && !node.hidden && !node.closest?.('[hidden],[aria-hidden="true"]')
+        && (node.getClientRects?.().length || 0) > 0 && style?.visibility !== 'hidden'
+        && style?.display !== 'none' && style?.opacity !== '0';
+    }).map(node => {
+      const classes = String(node.className || '').split(/\s+/);
+      const values = [node.getAttribute('aria-label'),
+        node.querySelector?.('.review-mode-switcher-toggle-label')?.textContent]
+        .map(value => normalizeReviewingSignalText(value).toLowerCase())
+        .filter(value => value === 'editing' || value === 'reviewing');
+      for (const mode of ['editing', 'reviewing']) if (classes.includes(mode)) values.push(mode);
+      return values.length && values.every(mode => mode === values[0]) ? values[0] : 'unknown';
+    });
+    return modes.length && modes.every(mode => mode === modes[0]) ? modes[0] : 'unknown';
+  }
+
   function getReviewingState(params = {}) {
     const signals = collectReviewingSignals({ ...params, manualOverride: false });
+    const editorMode = readCurrentEditorMode();
     return {
       signals,
+      ...(editorMode ? { editorMode } : {}),
       reviewing: window.CodexOverleafReviewing.detectReviewingFromSignals(signals)
     };
   }
@@ -986,6 +1021,7 @@
   }
 
   function isReviewingConfirmedForWrite(state = {}) {
+    if (state.editorMode) return state.editorMode === 'reviewing';
     const reviewing = state.reviewing || {};
     if (!reviewing.ok || reviewing.status === 'manual-override') {
       return false;
@@ -1015,6 +1051,7 @@
   }
 
   function isEditingConfirmedForNoTraceUndo(state = {}) {
+    if (state.editorMode) return state.editorMode === 'editing';
     if (isReviewingConfirmedForWrite(state)) {
       return false;
     }

package/extension/src/shared/compatibility.js

@@ -12,7 +12,7 @@
   const MIN_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_EXTENSION_VERSION = '1.0.0';
-  const BUILD_TARGET_VERSION = '2.3.5';
+  const BUILD_TARGET_VERSION = '2.4.0';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',

package/extension/src/shared/i18n.js

@@ -40,20 +40,31 @@
       diagnosticsPageSubtitle: 'Current file, write access, track changes',
       diagnosticsSnapshotTitle: 'Check Project Read',
       diagnosticsSnapshotSubtitle: 'Full project, assets, read source',
-      diagnosticsOtTitle: 'Check Experimental OT Mirror',
+      diagnosticsOtTitle: 'Check OT Mirror',
       diagnosticsOtSubtitle: 'Status, fresh files, fallback',
       diagnosticsExportTitle: 'Export Diagnostics',
       diagnosticsExportSubtitle: 'Redacted audit and environment bundle',
       diagnosticsExportDone: 'Diagnostics bundle exported.',
-      diagnosticsOtSummaryEnabled: 'Experimental OT is enabled. Codex will use the OT-warmed mirror only when matching files are fresh; otherwise it falls back to the normal project read path.',
-      diagnosticsOtSummaryDisabled: 'Experimental OT is disabled, so Codex is using the normal project read path.',
-      diagnosticsOtNextStep: 'If you expected OT warm reads, turn on OT and wait for the status to show Live before relying on it.',
-      experimentalOtMenuTitle: 'Experimental OT Mirror',
-      experimentalOtMenuSubtitle: 'Experimental — speeds up reading the file you are editing; Codex falls back to normal reading whenever unsure.',
-      experimentalOtConfirmTitle: 'Experimental OT Mirror',
-      experimentalOtConfirmMessage: 'Experimental: tracks the current Overleaf editor and warms the local mirror so Codex can read recent focused-file edits faster. Codex uses it only when file scope is clear and the mirror is fresh; otherwise it falls back to normal project reading.',
+      diagnosticsOtSummaryEnabled: 'OT Mirror is enabled. Codex will use the OT-warmed mirror only when matching files are fresh; otherwise it falls back to the normal project read path.',
+      diagnosticsOtSummaryDisabled: 'OT Mirror is disabled, so Codex is using the normal project read path.',
+      diagnosticsOtNextStep: 'Observer status describes warming availability. File scope and freshness are checked again before each run.',
+      experimentalOtMenuTitle: 'OT Mirror',
+      otSettingsTitle: 'Project cache',
+      contextLoadingTitle: 'Context loading',
+      runFeedbackFailedTitle: 'Needs attention',
+      runFeedbackPartialTitle: 'Partially completed',
+      runFeedbackUnconfirmedTitle: 'Write status needs review',
+      runFeedbackGeneric: 'Open the run details for the reported cause and the next step.',
+      runFeedbackUnconfirmed: 'Some changes may already be in Overleaf. Check the document before retrying.',
+      runFeedbackUnconfirmedResult: 'Not fully confirmed. Review Overleaf before retrying.',
+      runFeedbackReviewFile: 'Review {file} in Overleaf',
+      runFeedbackReviewDetails: 'Review run details',
+      runFeedbackDetailsUnavailable: 'Detailed steps are unavailable for this older run.',
+      experimentalOtMenuSubtitle: 'Warms recent edits to the active text file locally. File scope and freshness are checked before reuse.',
+      experimentalOtConfirmTitle: 'Enable OT Mirror?',
+      experimentalOtConfirmMessage: 'Observes the active text editor and warms its local mirror. This is read-only with respect to Overleaf and does not upload assets. Each run checks file scope and freshness before reuse; normal project reading remains the fallback.',
       experimentalOtConfirmEnable: 'Turn on',
-      experimentalOtEnabledToast: 'Experimental OT Mirror is on. Use @file for the cleanest warm-mirror test.',
+      experimentalOtEnabledToast: 'OT Mirror requested for this project. Its status shows whether warming is available.',
       diagnosticsSnapshotLoading: 'Checking whether the extension can read the full Overleaf project.',
       diagnosticsSnapshotErrorSummary: 'Overleaf may still be loading, or the page API did not return project files yet.',
       diagnosticsNativeLoading: 'Checking whether local Codex, Native Host, and LaTeX tools are available.',
@@ -326,18 +337,27 @@
       requireReviewingTitle: 'When enabled, Codex checks or switches Overleaf Reviewing/Track Changes before writing. Deletes still require confirmation.',
       autoCompile: 'Compile',
       autoCompileTitle: 'After Codex writes, click Overleaf Recompile and record the compile result for this task. Ask mode will not trigger it.',
-      experimentalOtWarmMirror: 'Experimental OT warm mirror',
+      experimentalOtWarmMirror: 'OT warm mirror',
       experimentalOtWarmMirrorShort: 'OT',
-      experimentalOtWarmMirrorTitle: 'Experimental read-only OT mirror warming. If unavailable, stale, or inconsistent, Codex falls back to the normal project read path.',
+      experimentalOtWarmMirrorTitle: 'Read-only local text warming. File scope and freshness are checked before reuse; normal project reading remains the fallback.',
       otStatus: 'OT status',
-      otFreshFiles: 'OT fresh files',
-      otFallback: 'Fallback',
+      otFreshFiles: 'Files with recent OT evidence',
+      otFallback: 'Read fallback',
       otStatusOff: 'Off',
-      otStatusStarting: 'Start',
-      otStatusObserving: 'Live',
-      otStatusUnavailable: 'N/A',
-      otStatusStale: 'Stale',
-      otStatusInconsistent: 'Check',
+      otStatusStarting: 'Connecting',
+      otStatusObserving: 'Observing current editor',
+      otStatusUnavailable: 'Unavailable',
+      otStatusStale: 'Warming paused; awaiting verification',
+      otStatusInconsistent: 'Needs verification',
+      otFailureBridge: 'The page connection needs to be restored. Reload the extension and Overleaf before retrying.',
+      otFailureObserver: 'The editor observer is unavailable. The next run will try normal project reading.',
+      otFailureEditor: 'The active editor could not be read. Warming is paused; the next run will try normal project reading.',
+      otFailureFileLimit: 'This file exceeds the 1 MiB warming limit. The next run will try normal project reading.',
+      otFailureQueueLimit: 'The mirror queue reached its limit. Warming is paused; the next run will try normal project reading.',
+      otFailureExpired: 'The observation is too old to reuse. The next run will try normal project reading.',
+      otFailureMirror: 'The mirror update was not fully confirmed. The next run will try normal project reading.',
+      otFailureGeneric: 'Mirror warming could not continue. The next run will try normal project reading.',
+      otFailureNextStep: 'Resolve the reported cause, then enable OT again. If the page connection is unavailable, reload the extension and Overleaf first.',
       modelSourceFallback: 'fallback',
       modelSourceDiscovered: 'discovered',
       modelSourceFailed: 'failed',
@@ -560,20 +580,31 @@
       diagnosticsPageSubtitle: '当前文件、写入能力、留痕状态',
       diagnosticsSnapshotTitle: '检查项目读取',
       diagnosticsSnapshotSubtitle: '完整项目、资源文件、读取来源',
-      diagnosticsOtTitle: '检查实验性 OT Mirror',
+      diagnosticsOtTitle: '检查 OT Mirror',
       diagnosticsOtSubtitle: '状态、新鲜文件、回退路径',
       diagnosticsExportTitle: '导出诊断信息',
       diagnosticsExportSubtitle: '已脱敏的审计和环境信息包',
       diagnosticsExportDone: '诊断信息已导出。',
-      diagnosticsOtSummaryEnabled: '实验性 OT 已开启。只有匹配文件是新鲜状态时，Codex 才会使用 OT 预热 mirror；否则会回退到常规项目读取路径。',
-      diagnosticsOtSummaryDisabled: '实验性 OT 已关闭，Codex 会使用常规项目读取路径。',
-      diagnosticsOtNextStep: '如果你希望使用 OT 预热读取，请开启 OT，并等状态显示为“实时”后再依赖它。',
-      experimentalOtMenuTitle: '实验性 OT Mirror',
-      experimentalOtMenuSubtitle: '实验性——加快读取你正在编辑的文件；拿不准时自动回退到普通读取。',
-      experimentalOtConfirmTitle: '实验性 OT Mirror',
-      experimentalOtConfirmMessage: '实验性：实时跟踪当前 Overleaf 编辑器，把改动预热到本地 mirror，让 Codex 更快读到最近的当前文件改动。只有文件范围明确且 mirror 新鲜时才会使用；否则自动回退到普通项目读取。',
+      diagnosticsOtSummaryEnabled: 'OT Mirror 已开启。只有匹配文件是新鲜状态时，Codex 才会使用 OT 预热镜像；否则会回退到常规项目读取路径。',
+      diagnosticsOtSummaryDisabled: 'OT Mirror 已关闭，Codex 会使用常规项目读取路径。',
+      diagnosticsOtNextStep: '观测状态说明预热是否可用；每次任务开始前仍会重新校验文件范围和新鲜度。',
+      experimentalOtMenuTitle: 'OT Mirror',
+      otSettingsTitle: '项目缓存',
+      contextLoadingTitle: '上下文加载',
+      runFeedbackFailedTitle: '需要处理',
+      runFeedbackPartialTitle: '部分完成',
+      runFeedbackUnconfirmedTitle: '写入状态待确认',
+      runFeedbackGeneric: '可在本轮详情中查看具体原因和后续处理方式。',
+      runFeedbackUnconfirmed: '部分改动可能已经写入 Overleaf，重试前请先检查文档。',
+      runFeedbackUnconfirmedResult: '结果尚未完全确认，请检查 Overleaf 后再决定是否重试。',
+      runFeedbackReviewFile: '在 Overleaf 检查 {file}',
+      runFeedbackReviewDetails: '查看运行步骤',
+      runFeedbackDetailsUnavailable: '这条历史记录没有可展开的详细步骤。',
+      experimentalOtMenuSubtitle: '在本地预热当前文本文件的最近改动，复用前重新校验文件范围和新鲜度。',
+      experimentalOtConfirmTitle: '开启 OT Mirror？',
+      experimentalOtConfirmMessage: '观测当前文本编辑器并预热本地镜像。此功能不会写回 Overleaf，也不负责上传资产。每次任务复用前都会校验文件范围和新鲜度，不满足条件时尝试常规项目读取。',
       experimentalOtConfirmEnable: '开启',
-      experimentalOtEnabledToast: '实验性 OT Mirror 已开启。使用 @file 可以最清楚地测试 warm mirror。',
+      experimentalOtEnabledToast: '已为当前项目请求开启 OT Mirror，可用情况见状态提示。',
       diagnosticsSnapshotLoading: '确认插件能否读取完整 Overleaf 项目。',
       diagnosticsSnapshotErrorSummary: '这通常是 Overleaf 页面还没加载完成，或者当前页面接口暂时没有返回项目文件。',
       diagnosticsNativeLoading: '确认本机 Codex、Native Host 和 LaTeX 工具是否可用。',
@@ -846,18 +877,27 @@
       requireReviewingTitle: '开启后，写入前会确认并尝试切到 Overleaf Reviewing/Track Changes；删除仍需确认。',
       autoCompile: '编译',
       autoCompileTitle: 'Codex 写入后自动点击 Overleaf Recompile，并把编译结果记录到本轮任务。只问不改时不会触发。',
-      experimentalOtWarmMirror: '实验性 OT 预热镜像',
+      experimentalOtWarmMirror: 'OT 预热镜像',
       experimentalOtWarmMirrorShort: 'OT',
-      experimentalOtWarmMirrorTitle: '实验性只读 OT 镜像预热；不可用、过期或不一致时会回退到常规项目读取。',
+      experimentalOtWarmMirrorTitle: '只读本地文本预热；复用前校验文件范围和新鲜度，常规项目读取作为回退路径。',
       otStatus: 'OT 状态',
-      otFreshFiles: 'OT 新鲜文件',
-      otFallback: '回退',
-      otStatusOff: '关',
-      otStatusStarting: '启动',
-      otStatusObserving: '实时',
-      otStatusUnavailable: '不可用',
-      otStatusStale: '过期',
-      otStatusInconsistent: '需检查',
+      otFreshFiles: '近期有 OT 校验证据的文件',
+      otFallback: '读取回退',
+      otStatusOff: '未开启',
+      otStatusStarting: '正在连接',
+      otStatusObserving: '正在观测当前编辑器',
+      otStatusUnavailable: '暂不可用',
+      otStatusStale: '预热暂缓，等待重新校验',
+      otStatusInconsistent: '需重新校验',
+      otFailureBridge: '页面连接需要恢复，请先重新加载扩展并刷新 Overleaf，再重试。',
+      otFailureObserver: '编辑器观察器暂不可用，下次任务将尝试常规项目读取。',
+      otFailureEditor: '当前编辑器内容尚不可读，预热已暂停；下次任务将尝试常规项目读取。',
+      otFailureFileLimit: '文件超过 1 MiB 预热上限，下次任务将尝试常规项目读取。',
+      otFailureQueueLimit: '镜像队列达到容量上限，预热已暂停；下次任务将尝试常规项目读取。',
+      otFailureExpired: '观测记录已过期，下次任务将尝试常规项目读取。',
+      otFailureMirror: '镜像更新尚未完整确认，下次任务将尝试常规项目读取。',
+      otFailureGeneric: '镜像预热未能继续，下次任务将尝试常规项目读取。',
+      otFailureNextStep: '处理所显示的原因后重新开启 OT；若页面连接不可用，请先重新加载扩展并刷新 Overleaf。',
       modelSourceFallback: '备用列表',
       modelSourceDiscovered: '已发现',
       modelSourceFailed: '获取失败',

package/extension/src/shared/managedUpdateProjection.js

@@ -26,7 +26,7 @@
   ]);
 
   const PHASE_TIMEOUTS = Object.freeze({
-    checking: 30 * 1000,
+    checking: 60 * 1000,
     downloading: 2 * 60 * 1000,
     applying: 90 * 1000,
     awaiting_health: 2 * 60 * 1000,

package/extension/src/shared/otText.js

@@ -279,7 +279,6 @@
 
   function normalizePath(value) {
     return String(value || '')
-      .replace(/\s+/g, ' ')
       .replace(/\\/g, '/')
       .trim()
       .replace(/^\/+/, '');

package/extension/src/shared/pageRpcContract.js

@@ -5,7 +5,7 @@
 })(typeof window !== 'undefined' ? window : (typeof globalThis !== 'undefined' ? globalThis : this), function () {
   'use strict';
 
-  var REVISION = '2026-08-04-page-rpc-contract-v15';
+  var REVISION = '2026-09-14-native-text-upload-v28';
   var METHODS = freezeCatalog({
     initializeCapability: entry('bridge.initialize', 'control', 'none', 'default', false, 'none'),
     probe: entry('bridge.probe', 'read', 'none', 'default', false, 'safe'),
@@ -22,6 +22,7 @@
     binaryUploadCommit: entry('asset.write', 'document', 'required', 'writeback', true, 'no_retry'),
     binaryUploadAbort: entry('asset.stage', 'cache', 'none', 'default', false, 'idempotent'),
     jumpToPosition: entry('editor.navigate', 'navigation', 'required', 'default', false, 'idempotent'),
+    reconcileTrackedChangeCapture: entry('tracked_changes.read', 'read', 'required', 'default', false, 'safe'),
     rejectTrackedChanges: entry('tracked_changes.reject', 'document', 'required', 'lifecycle', true, 'no_retry'),
     acceptTrackedChanges: entry('tracked_changes.accept', 'document', 'required', 'lifecycle', true, 'no_retry'),
     triggerCompile: entry('compile.trigger', 'page_state', 'required', 'compile', false, 'no_retry'),