codex-overleaf-link 2.3.6 → 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.6';
+  const BUILD_TARGET_VERSION = '2.4.0';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',

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'),

package/extension/src/shared/sessionState.js

@@ -636,7 +636,7 @@
       undoExpectedFiles: normalizeRunFiles(run.undoExpectedFiles),
       undoStatus: sanitizeAssistantVisibleText(run.undoStatus),
       nativeRequestId: sanitizeAssistantVisibleText(run.nativeRequestId),
-      codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
+      codexThreadId: sanitizeAssistantVisibleText(run.codexThreadId), codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
       forkSnapshot: run.forkSnapshot === true,
       forkSourceRunId: sanitizeAssistantVisibleText(run.forkSourceRunId),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
@@ -656,6 +656,9 @@
     if (run.changedDocument === true) {
       normalized.changedDocument = true;
     }
+    if (Array.isArray(run.trackedChangeCaptures) && run.trackedChangeCaptures.length && !run.forkSnapshot) {
+      normalized.trackedChangeCaptures = sanitizeAssistantVisibleValue(run.trackedChangeCaptures);
+    }
     applyTrackedChangeStatus(normalized, run.trackedChangeStatus);
 
     return normalized;
@@ -1215,7 +1218,7 @@
       undoExpectedFiles: undoPayload.undoExpectedFiles,
       undoStatus: summarizeTextForStorage(run.undoStatus, 'undo status'),
       nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
-      codexTurnId: normalizeTextField(run.codexTurnId, 160),
+      codexThreadId: normalizeTextField(run.codexThreadId, 160), codexTurnId: normalizeTextField(run.codexTurnId, 160),
       forkSnapshot: run.forkSnapshot === true,
       forkSourceRunId: normalizeTextField(run.forkSourceRunId, 160),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
@@ -1627,6 +1630,7 @@
     setActiveSession,
     updateActiveSession,
     normalizeRuns,
+    normalizeProjectReferenceFiles,
     prepareStateForStorage,
     estimateJsonBytes,
     computeSafeTaskSummary

package/extension/src/shared/storageDb.js

@@ -1,18 +1,19 @@
 (function initStorageDb(root, factory) {
   if (typeof module === 'object' && module.exports) {
     module.exports = factory(require('./storageRunActions'), require('./runInputQueue'),
-      require('./settlementFacts'), require('./storageSessionClaims'));
+      require('./settlementFacts'), require('./storageSessionClaims'), require('./sessionState'));
   } else {
     root.CodexOverleafModuleRegistry.define('StorageDb', [
       'StorageRunActions',
       'RunInputQueue',
       'SettlementFacts',
-      'StorageSessionClaims'
+      'StorageSessionClaims',
+      'SessionState'
     ], factory);
   }
-})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue, SettlementFacts, StorageSessionClaims) {
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue, SettlementFacts, StorageSessionClaims, SessionState) {
   'use strict';
-  if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot || !StorageRunActions?.compactStructuredEventValue || !StorageRunActions?.hashString || !RunInputQueue?.compactForStorage || !SettlementFacts?.compactSettlementFacts || !StorageSessionClaims?.createSessionClaimer) {
+  if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot || !StorageRunActions?.compactRunExecutionSnapshot || !StorageRunActions?.compactStructuredEventValue || !StorageRunActions?.hashString || !RunInputQueue?.compactForStorage || !SettlementFacts?.compactSettlementFacts || !StorageSessionClaims?.createSessionClaimer) {
     throw new Error('Codex Overleaf storage run-action helpers are unavailable.');
   }
   // IndexedDB versions are monotonic; v2.0 RC profiles have already opened v3.
@@ -279,6 +280,7 @@
       codexThreadId: typeof input.codexThreadId === 'string' ? input.codexThreadId : '',
       status: typeof input.status === 'string' && input.status ? input.status : 'active',
       focusFiles: normalizePathList(input.focusFiles),
+      projectReferenceFiles: SessionState.normalizeProjectReferenceFiles(input.projectReferenceFiles),
       pendingInputs: RunInputQueue.compactForStorage(input.pendingInputs, {
         normalizeField: normalizeTextField,
         normalizeDisplay: normalizeDisplayTextForStorage,
@@ -650,20 +652,15 @@
   }
 
   function compactRunsForStorage(runs, options) {
-    return StorageRunActions.compactRunsForStorage(
-      runs,
-      options,
-      SESSION_STORAGE_LIMITS.maxRunsPerSession,
-      compactRunForStorage
-    );
+    return StorageRunActions.compactRunsForStorage(runs, options, SESSION_STORAGE_LIMITS.maxRunsPerSession, compactRunForStorage);
   }
-
   function compactRunForStorage(run, keepActionPayload) {
     var actionPayload = StorageRunActions.compactRunActionPayload(run, keepActionPayload);
     var compact = {
       id: run.id,
       task: normalizeDisplayTextForStorage(run.task || 'untitled task', SESSION_STORAGE_LIMITS.taskChars),
       mode: typeof run.mode === 'string' ? redactSecretLikeText(run.mode) : '', ...StorageRunActions.compactProviderSnapshot(run),
+      ...StorageRunActions.compactRunExecutionSnapshot(run, function (text) { return normalizeTextField(text, 4096); }),
       model: normalizeTextField(run.model, 80),
       reasoningEffort: typeof run.reasoningEffort === 'string' ? redactSecretLikeText(run.reasoningEffort) : '',
       speedTier: typeof run.speedTier === 'string' ? redactSecretLikeText(run.speedTier) : '',
@@ -679,9 +676,10 @@
       undoBaseFiles: actionPayload.undoBaseFiles,
       undoTrackedChanges: actionPayload.undoTrackedChanges,
       undoExpectedFiles: actionPayload.undoExpectedFiles,
+      ...(actionPayload.trackedChangeCaptures ? { trackedChangeCaptures: actionPayload.trackedChangeCaptures } : {}),
       undoStatus: normalizeDisplayTextForStorage(run.undoStatus, SESSION_STORAGE_LIMITS.statusTextChars),
       nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
-      codexTurnId: normalizeTextField(run.codexTurnId, 160),
+      codexThreadId: normalizeTextField(run.codexThreadId, 160), codexTurnId: normalizeTextField(run.codexTurnId, 160),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
       queueItemId: normalizeTextField(run.queueItemId, 160)
     };

package/extension/src/shared/storageRunActions.js

@@ -70,7 +70,13 @@
     } catch (_error) {
       return empty;
     }
-    return getUtf8ByteLength(serialized) <= MAX_PERSISTED_ACTION_BYTES_PER_RUN ? payload : empty;
+    if (getUtf8ByteLength(serialized) > MAX_PERSISTED_ACTION_BYTES_PER_RUN) return empty;
+    const captures = cloneSerializableArray(run.trackedChangeCaptures);
+    if (captures.length) {
+      const extended = { ...payload, trackedChangeCaptures: captures };
+      if (getUtf8ByteLength(JSON.stringify(extended)) <= MAX_PERSISTED_ACTION_BYTES_PER_RUN) return extended;
+    }
+    return payload; // Optional capture evidence must never evict a mature Undo payload.
   }
 
   function emptyActionPayload() {
@@ -102,6 +108,27 @@
     return value.length * 2;
   }
 
+  // Persist only execution metadata; never infer a missing historical setting.
+  function compactRunExecutionSnapshot(run, normalizeString) {
+    var snapshot = run && run.executionSnapshot;
+    if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot)) return {};
+    var normalize = typeof normalizeString === 'function' ? normalizeString : String;
+    var compact = {};
+    var fields = ['schemaVersion', 'mode', 'providerId', 'providerRevision', 'model',
+      'reasoningEffort', 'speedTier', 'autoRecompile', 'requireReviewing', 'capturedAt', 'source'];
+    for (var key of fields) {
+      if (!Object.prototype.hasOwnProperty.call(snapshot, key)) continue;
+      var value = snapshot[key];
+      if (typeof value === 'string') compact[key] = normalize(value);
+      else if (value === null || typeof value === 'number' || typeof value === 'boolean') compact[key] = value;
+    }
+    if (Array.isArray(snapshot.focusFiles)) {
+      compact.focusFiles = snapshot.focusFiles.slice(0, 100)
+        .filter(function (value) { return typeof value === 'string'; }).map(normalize);
+    }
+    return { executionSnapshot: compact };
+  }
+
   function compactProviderSnapshot(value) {
     return {
       providerId: typeof value.providerId === 'string' && value.providerId ? value.providerId : 'builtin',
@@ -147,6 +174,7 @@
     compactRunsForStorage: compactRunsForStorage,
     compactRunActionPayload: compactRunActionPayload,
     compactProviderSnapshot: compactProviderSnapshot,
+    compactRunExecutionSnapshot: compactRunExecutionSnapshot,
     hashString: hashString
   };
 });