codex-overleaf-link 2.3.6 → 2.4.0

package/extension/src/content/generated/content.bundle.js

@@ -1,3 +1,4 @@
+if (typeof document !== 'undefined' && document.documentElement) document.documentElement.setAttribute('data-codex-overleaf-source-digest', "f146d7e07b67706193fa5fcff26d7c9719826ac745aec9b745dd95c52413d27c");
 (() => {
   // extension/entries/content-entry.mjs
   (function runClassicContentModule(module, exports, require2) {
@@ -7886,7 +7887,7 @@ ${block}`;
         if (!result || typeof result !== "object" || result.ok === false) return result;
         if (Array.isArray(result.skipped) && result.skipped.length > 0) return result;
         const expectedFiles = Array.isArray(run?.undoExpectedFiles) ? run.undoExpectedFiles : [];
-        if (!expectedFiles.length || isUndoVerifiedContentMatching(run, result)) return result;
+        if (!expectedFiles.length || isUndoVerifiedContentMatching(run, result, options2)) return result;
         const path = expectedFiles.find((entry) => typeof entry?.path === "string")?.path || "";
         appendSyntheticFailure(result, options2.buildFailure?.("undo_not_verified", { path, type: "undo" }, {
           changedDocument: true,
@@ -7895,12 +7896,13 @@ ${block}`;
         }), path, "undo_not_verified", "undo");
         return result;
       }
-      function isUndoVerifiedContentMatching(run, result) {
+      function isUndoVerifiedContentMatching(run, result, options2 = {}) {
         const expectedByPath = new Map((run?.undoExpectedFiles || []).filter((file) => typeof file?.path === "string" && typeof file?.content === "string").map((file) => [normalizeSettlementPath(file.path), file.content]).filter(([path]) => path));
         if (!expectedByPath.size) return true;
+        const postByPath = new Map((Array.isArray(options2?.postFiles) ? options2.postFiles : []).filter((file) => typeof file?.path === "string" && typeof file?.content === "string").map((file) => [normalizeSettlementPath(file.path), file.content]));
         const applied = Array.isArray(result?.applied) ? result.applied : [];
         return Array.from(expectedByPath).every(
-          ([path, expected]) => applied.some((entry) => isVerifiedUndoEntryForPath(entry, path, expected))
+          ([path, expected]) => applied.some((entry) => isVerifiedUndoEntryForPath(entry, path, expected, postByPath.get(path)))
         );
       }
       function isUndoResultEffectivelyApplied(run, result, undoOperations = []) {
@@ -7914,7 +7916,7 @@ ${block}`;
           (item) => isVerifiedUndoEntryForPath(item, path, expectedByPath.get(path))
         ));
       }
-      function isVerifiedUndoEntryForPath(entry, path, expectedContent) {
+      function isVerifiedUndoEntryForPath(entry, path, expectedContent, postContent) {
         const inner = entry?.result || {};
         if (inner.ok === false) return false;
         const normalizedPath = normalizeSettlementPath(path);
@@ -7929,7 +7931,12 @@ ${block}`;
           return inner.method === "overleaf-editor-undo" && inner.verified === true && inner.verifiedContent === expectedContent;
         }
         if (key === `snapshot-undo:${normalizedPath}`) {
-          return inner.verifiedContent === expectedContent;
+          if (inner.verifiedContent === expectedContent) return true;
+          const proof = inner.undoRebaseProof, before = proof?.beforeUndoContent;
+          if (inner.verified !== true || proof?.version !== 1 || normalizeSettlementPath(proof.path) !== normalizedPath || typeof before !== "string" || typeof postContent !== "string" || !postContent || typeof inner.verifiedContent !== "string") return false;
+          const start = before.indexOf(postContent);
+          if (start < 0 || before.indexOf(postContent, start + 1) >= 0) return false;
+          return inner.verifiedContent === before.slice(0, start) + expectedContent + before.slice(start + postContent.length);
         }
         return false;
       }
@@ -8775,6 +8782,7 @@ ${block}`;
           undoExpectedFiles: normalizeRunFiles(run.undoExpectedFiles),
           undoStatus: sanitizeAssistantVisibleText(run.undoStatus),
           nativeRequestId: sanitizeAssistantVisibleText(run.nativeRequestId),
+          codexThreadId: sanitizeAssistantVisibleText(run.codexThreadId),
           codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
           forkSnapshot: run.forkSnapshot === true,
           forkSourceRunId: sanitizeAssistantVisibleText(run.forkSourceRunId),
@@ -8792,6 +8800,9 @@ ${block}`;
         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;
       }
@@ -9226,6 +9237,7 @@ ${block}`;
           undoExpectedFiles: undoPayload.undoExpectedFiles,
           undoStatus: summarizeTextForStorage(run.undoStatus, "undo status"),
           nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
+          codexThreadId: normalizeTextField(run.codexThreadId, 160),
           codexTurnId: normalizeTextField(run.codexTurnId, 160),
           forkSnapshot: run.forkSnapshot === true,
           forkSourceRunId: normalizeTextField(run.forkSourceRunId, 160),
@@ -9558,6 +9570,7 @@ ${block}`;
         setActiveSession,
         updateActiveSession,
         normalizeRuns,
+        normalizeProjectReferenceFiles,
         prepareStateForStorage,
         estimateJsonBytes,
         computeSafeTaskSummary
@@ -9798,7 +9811,13 @@ ${block}`;
         } 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;
       }
       function emptyActionPayload() {
         return {
@@ -9826,6 +9845,37 @@ ${block}`;
         }
         return value.length * 2;
       }
+      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(value2) {
+            return typeof value2 === "string";
+          }).map(normalize);
+        }
+        return { executionSnapshot: compact };
+      }
       function compactProviderSnapshot(value) {
         return {
           providerId: typeof value.providerId === "string" && value.providerId ? value.providerId : "builtin",
@@ -9868,6 +9918,7 @@ ${block}`;
         compactRunsForStorage,
         compactRunActionPayload,
         compactProviderSnapshot,
+        compactRunExecutionSnapshot,
         hashString
       };
     });
@@ -9945,19 +9996,21 @@ ${block}`;
           require2("./storageRunActions"),
           require2("./runInputQueue"),
           require2("./settlementFacts"),
-          require2("./storageSessionClaims")
+          require2("./storageSessionClaims"),
+          require2("./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.");
       }
       var TARGET_SCHEMA_VERSION = 3;
@@ -10225,6 +10278,7 @@ ${block}`;
           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,
@@ -10264,8 +10318,8 @@ ${block}`;
         }
       }
       function deriveSafeTaskSummaryFromInput(input) {
-        var SessionState = loadSessionState();
-        if (!SessionState || !(SessionState.computeSafeTaskSummary instanceof Function)) {
+        var SessionState2 = loadSessionState();
+        if (!SessionState2 || !(SessionState2.computeSafeTaskSummary instanceof Function)) {
           return "";
         }
         var task = typeof input.task === "string" && input.task ? input.task : "";
@@ -10275,7 +10329,7 @@ ${block}`;
             task = firstRun.task;
           }
         }
-        return SessionState.computeSafeTaskSummary(task);
+        return SessionState2.computeSafeTaskSummary(task);
       }
       var _sessionStateCache = null;
       function loadSessionState() {
@@ -10560,12 +10614,7 @@ ${block}`;
         });
       }
       function compactRunsForStorage(runs, options2) {
-        return StorageRunActions.compactRunsForStorage(
-          runs,
-          options2,
-          SESSION_STORAGE_LIMITS.maxRunsPerSession,
-          compactRunForStorage
-        );
+        return StorageRunActions.compactRunsForStorage(runs, options2, SESSION_STORAGE_LIMITS.maxRunsPerSession, compactRunForStorage);
       }
       function compactRunForStorage(run, keepActionPayload) {
         var actionPayload = StorageRunActions.compactRunActionPayload(run, keepActionPayload);
@@ -10574,6 +10623,9 @@ ${block}`;
           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) : "",
@@ -10589,8 +10641,10 @@ ${block}`;
           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),
+          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)
@@ -11775,7 +11829,7 @@ ${block}`;
       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",
@@ -12078,7 +12132,7 @@ ${block}`;
       if (root) root.CodexOverleafPageRpcContract = api;
     })(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"),
@@ -12095,6 +12149,7 @@ ${block}`;
         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"),
@@ -13463,9 +13518,11 @@ ${block}`;
         ["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]
@@ -13665,7 +13722,9 @@ ${block}`;
         async function dispatch(payload, channelMethod) {
           const compatibilityGate = await ensureForMethod(payload?.method);
           if (!compatibilityGate.ok) return compatibilityGate.response;
-          if (gatedMethods.has(payload?.method)) options2.throwIfCancellationRequested?.();
+          if (gatedMethods.has(payload?.method) && payload.method !== "mirror.invalidate") {
+            options2.throwIfCancellationRequested?.();
+          }
           return nativeChannel[channelMethod](
             attachEvidence(payload, compatibilityGate.compatibility)
           );
@@ -14318,8 +14377,10 @@ ${block}`;
           merged.applied.push(...Array.isArray(result?.applied) ? result.applied : []);
           merged.skipped.push(...Array.isArray(result?.skipped) ? result.skipped : []);
           merged.trackedChanges.push(...Array.isArray(result?.trackedChanges) ? result.trackedChanges : []);
+          if (result?.trackedChangeCaptures?.length) (merged.trackedChangeCaptures || (merged.trackedChangeCaptures = [])).push(...result.trackedChangeCaptures);
           if (result?.ok !== true) merged.ok = false;
         }
+        if (merged.trackedChangeCaptures?.some((capture) => capture.state !== "observed")) merged.trackedChanges = [];
         if (merged.skipped.length) merged.ok = false;
         return merged;
       }
@@ -15315,6 +15376,8 @@ ${block}`;
         saveState = null,
         saveStateSoon = () => {
         },
+        onProjectFilesReady = () => {
+        },
         updateActiveSession = defaultUpdateActiveSession,
         callPageBridge = () => Promise.resolve({ ok: false }),
         getCurrentProjectId = () => "",
@@ -15478,6 +15541,7 @@ ${block}`;
             renderContextFiles(contextProject);
             if (isExactContextFileListProject(contextProject)) {
               setContextSyncState("exact-ready");
+              onProjectFilesReady(contextProject);
             } else if (contextSyncState !== "partial") {
               setContextSyncState("exact-loading");
               void enhanceContextFilesFromExactSnapshot({ loadId: contextLoadId });
@@ -15499,6 +15563,7 @@ ${block}`;
             contextProject = project;
             setContextSyncState(isExactContextFileListProject(project) ? "exact-ready" : "exact-loading");
             renderContextFiles(project);
+            if (isExactContextFileListProject(project)) onProjectFilesReady(project);
             if (!isExactContextFileListProject(project)) {
               void enhanceContextFilesFromExactSnapshot({
                 force: Boolean(options2.force),
@@ -15556,6 +15621,7 @@ ${block}`;
             contextProject = project;
             setContextSyncState("exact-ready");
             renderContextFiles(project);
+            onProjectFilesReady(project);
           } catch (_error) {
             if (loadId === contextLoadId) {
               setContextSyncState("partial");
@@ -16756,6 +16822,20 @@ ${block}`;
         })) return { ok: false, reason: "ot_event_expired" };
         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;
@@ -16833,6 +16913,9 @@ ${block}`;
         takePatchBatch,
         validatePatchReceipt,
         normalizeFailureCode,
+        readOtBridgeStatus,
+        readOtBridgeEvents,
+        readOtBridgeErrorCode,
         getFailureMessageKey,
         buildPatchFilesRequest,
         canUseOtWarmStart,
@@ -20428,7 +20511,8 @@ ${block}`;
           container,
           callbacks: options2.callbacks || {},
           i18n: options2.i18n || {},
-          dismissInstalled: false
+          dismissInstalled: false,
+          cleanup: []
         };
         container.innerHTML = `
       <div class="codex-diagnostics-wrap">
@@ -20512,6 +20596,11 @@ ${block}`;
           instance.callbacks.onBeforeOpen?.();
         }
         popover.hidden = !open;
+        if (open) {
+          openFloating(instance, popover, 300);
+        } else {
+          hideFloating(popover);
+        }
         button.dataset.active = open ? "true" : "false";
         button.setAttribute("aria-expanded", open ? "true" : "false");
       }
@@ -20522,7 +20611,7 @@ ${block}`;
         if (!popover || !button) {
           return;
         }
-        popover.hidden = true;
+        hideFloating(popover);
         button.dataset.active = "false";
         button.setAttribute("aria-expanded", "false");
       }
@@ -20530,7 +20619,7 @@ ${block}`;
         const instance = target?._instance || target;
         const result = instance?.container?.querySelector("[data-diagnostics-result]");
         if (result) {
-          result.hidden = true;
+          hideFloating(result);
         }
       }
       function showLoading(target, title, subtitle) {
@@ -20586,6 +20675,65 @@ ${block}`;
         details.open = false;
         details.hidden = !technicalText;
         technical.textContent = technicalText;
+        closeMenu(instance);
+        openFloating(instance, root, 560);
+      }
+      function openFloating(instance, element, preferredWidth) {
+        if (element.isConnected === false) return;
+        element.hidden = false;
+        if (typeof element.showPopover === "function") {
+          element.setAttribute("popover", "manual");
+          try {
+            if (!element.matches(":popover-open")) element.showPopover();
+          } catch (_error) {
+            element.removeAttribute("popover");
+          }
+        }
+        positionFloating(instance, element, preferredWidth);
+      }
+      function hideFloating(element) {
+        if (!element) return;
+        if (typeof element.hidePopover === "function" && element.getAttribute("popover") === "manual") {
+          try {
+            if (element.matches(":popover-open")) element.hidePopover();
+          } catch (_error) {
+            element.removeAttribute("popover");
+          }
+        }
+        element.hidden = true;
+      }
+      function positionFloating(instance, element, preferredWidth) {
+        if (!element || element.hidden) return;
+        const button = instance.container.querySelector("[data-diagnostics-menu]");
+        if (!button?.getBoundingClientRect || !element.getBoundingClientRect) return;
+        if (button.getClientRects && !button.getClientRects().length) {
+          closeMenu(instance);
+          closeResult(instance);
+          return;
+        }
+        const doc = instance.container.ownerDocument || document;
+        const view = doc.defaultView || window;
+        const viewport = view.visualViewport;
+        const width = viewport?.width || view.innerWidth || doc.documentElement?.clientWidth;
+        const height = viewport?.height || view.innerHeight || doc.documentElement?.clientHeight;
+        if (!(width > 0 && height > 0)) return;
+        const margin = 12;
+        const gap = 8;
+        const leftEdge = (viewport?.offsetLeft || 0) + margin;
+        const topEdge = (viewport?.offsetTop || 0) + margin;
+        const rightEdge = leftEdge + Math.max(0, width - margin * 2);
+        const bottomEdge = topEdge + Math.max(0, height - margin * 2);
+        element.style.width = `${Math.min(preferredWidth, Math.max(0, width - margin * 2))}px`;
+        element.style.maxHeight = `${Math.min(640, Math.max(0, height - margin * 2))}px`;
+        const anchor = button.getBoundingClientRect();
+        const bounds = element.getBoundingClientRect();
+        const below = Math.max(0, bottomEdge - anchor.bottom - gap);
+        const above = Math.max(0, anchor.top - topEdge - gap);
+        const desiredTop = bounds.height > below && above > below ? anchor.top - gap - bounds.height : anchor.bottom + gap;
+        element.style.left = `${Math.max(leftEdge, Math.min(anchor.right - bounds.width, rightEdge - bounds.width))}px`;
+        element.style.top = `${Math.max(topEdge, Math.min(desiredTop, bottomEdge - bounds.height))}px`;
+        element.style.right = "auto";
+        element.style.bottom = "auto";
       }
       function renderInstallCommand(instance, container, command) {
         const wrap = document.createElement("div");
@@ -20660,13 +20808,60 @@ ${block}`;
           return;
         }
         instance.dismissInstalled = true;
-        document.addEventListener("click", (event) => {
+        const doc = instance.container.ownerDocument || document;
+        const view = doc.defaultView || window;
+        const listen = (target, type, handler, options2) => {
+          if (!target?.addEventListener) return;
+          target.addEventListener(type, handler, options2);
+          instance.cleanup.push(() => target.removeEventListener(type, handler, options2));
+        };
+        listen(doc, "click", (event) => {
           const wrap = instance.container?.querySelector(".codex-diagnostics-wrap");
           if (!wrap || wrap.contains(event.target)) {
             return;
           }
           closeMenu(instance);
         }, true);
+        listen(doc, "keydown", (event) => {
+          if (event.key !== "Escape") return;
+          const menu = instance.container.querySelector("[data-diagnostics-popover]");
+          const result = instance.container.querySelector("[data-diagnostics-result]");
+          if (menu && !menu.hidden) closeMenu(instance);
+          else if (result && !result.hidden) closeResult(instance);
+          else return;
+          event.preventDefault();
+          event.stopPropagation();
+          instance.container.querySelector("[data-diagnostics-menu]")?.focus();
+        }, true);
+        let frame = null;
+        const reposition = () => {
+          frame = null;
+          positionFloating(instance, instance.container.querySelector("[data-diagnostics-popover]"), 300);
+          positionFloating(instance, instance.container.querySelector("[data-diagnostics-result]"), 560);
+        };
+        const schedule = () => {
+          if (frame !== null) return;
+          if (view.requestAnimationFrame) frame = view.requestAnimationFrame(reposition);
+          else reposition();
+        };
+        listen(view, "resize", schedule);
+        listen(doc, "scroll", schedule, true);
+        listen(view.visualViewport, "resize", schedule);
+        listen(view.visualViewport, "scroll", schedule);
+        if (typeof view.ResizeObserver === "function") {
+          const observer = new view.ResizeObserver(schedule);
+          for (const node of [
+            instance.container.closest("#codex-overleaf-panel") || instance.container,
+            instance.container.querySelector("[data-diagnostics-popover]"),
+            instance.container.querySelector("[data-diagnostics-result]")
+          ]) {
+            if (node) observer.observe(node);
+          }
+          instance.cleanup.push(() => observer.disconnect());
+        }
+        instance.cleanup.push(() => {
+          if (frame !== null) view.cancelAnimationFrame?.(frame);
+        });
       }
       const HEALTH_STATES = ["ok", "warn", "fail", "unknown"];
       function updateStatus(target, status = {}) {
@@ -20823,6 +21018,10 @@ ${block}`;
         return key;
       }
       function destroy(instance) {
+        closeMenu(instance);
+        closeResult(instance);
+        for (const cleanup of instance.cleanup || []) cleanup();
+        instance.cleanup = [];
         instance.container.textContent = "";
       }
       window.CodexOverleafDiagnosticsPanel = {
@@ -21290,6 +21489,7 @@ ${block}`;
               const raw = entry?.event || {};
               if (raw.type === "codex.turn.bound") {
                 session.codexThreadId = String(raw.detail?.threadId || session.codexThreadId || "");
+                record.codexThreadId = String(raw.detail?.threadId || record.codexThreadId || "");
                 record.codexTurnId = String(raw.detail?.turnId || record.codexTurnId || "");
                 record.nativeEventSeq = sequence;
                 continue;
@@ -29322,6 +29522,8 @@ failedAt: ${new Date(failure.at).toISOString()}`;
               lines.push(`CodeMirror: docLength=${view.docLength || 0}; dispatch=${Boolean(view.hasDispatch)}; source=${view.source || "unknown"}`);
             }
           }
+          const capture = probe?.trackedChangeCapture;
+          if (capture) lines.push(tx("Tracked ledger: ", "\u7559\u75D5\u8BB0\u5F55\uFF1A") + "source=" + capture.source + "; ready=" + capture.ready + "; count=" + capture.count + "; doc=" + (capture.docId || "none") + "; adapter=" + capture.adapter + "; reason=" + (capture.reason || "none"));
           const projectDiagnostics = probe?.projectDiagnostics;
           if (projectDiagnostics) {
             lines.push(`Project records: ${projectDiagnostics.docRecordCount || 0}; roots=${(projectDiagnostics.internalRootKeys || []).slice(0, 6).join(", ") || "none"}`);
@@ -29548,7 +29750,17 @@ failedAt: ${new Date(failure.at).toISOString()}`;
           textarea.remove();
           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);
+        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 });
     });
@@ -30580,7 +30792,7 @@ ${conclusion}` : `${label} ${conclusion}`;
             configureLifecycleUndoButton(button, run);
             return;
           }
-          const projection = projectRunSettlement(run);
+          const projection = RunResultActions.projectUndoAvailability(run, projectRunSettlement);
           if (!projection.canUndo && run.undoStatus !== "applied") {
             button.hidden = true;
             return;
@@ -31578,19 +31790,26 @@ ${conclusion}` : `${label} ${conclusion}`;
           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 : "";
+          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"));
           }
@@ -32027,11 +32246,45 @@ ${conclusion}` : `${label} ${conclusion}`;
       function formatCompactModelLabel(label) {
         return String(label || "").replace(/^gpt[-\s]*/i, "");
       }
-      function retainSelectedModel(models, selectedModel) {
+      function retainSelectedModel(models, selectedModel, options2 = {}) {
         const selectedId = normalizeModelOptionId(selectedModel);
         if (!selectedId) return "";
+        if (options2.preserveUnavailable === true) return selectedId;
         return (Array.isArray(models) ? models : []).some((model) => normalizeModelOptionId(typeof model === "string" ? model : model?.id) === selectedId) ? selectedId : "";
       }
+      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");
@@ -32100,6 +32353,8 @@ ${conclusion}` : `${label} ${conclusion}`;
         normalizeReasoningEffortsForSelect,
         normalizeSpeedTiersForSelect,
         retainSelectedModel,
+        preserveSelectedCapabilities,
+        getRenderedModelEntries,
         shouldUseBuiltInFallback
       };
       return api;
@@ -32222,7 +32477,8 @@ ${conclusion}` : `${label} ${conclusion}`;
               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." });
@@ -32231,9 +32487,10 @@ ${conclusion}` : `${label} ${conclusion}`;
                 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 || "",
@@ -32259,15 +32516,16 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
         }
         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", "\u6A21\u578B\u4E0D\u53EF\u7528");
             option.disabled = true;
             modelSelect.append(option);
-            modelSelect.value = "";
+            modelSelect.value = selectedModel;
             modelSelect.disabled = true;
           }
           modelDiscovery = {
@@ -32277,8 +32535,18 @@ ${conclusion}` : `${label} ${conclusion}`;
             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();
         }
@@ -32286,9 +32554,9 @@ ${conclusion}` : `${label} ${conclusion}`;
           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",
@@ -33653,6 +33921,7 @@ ${conclusion}` : `${label} ${conclusion}`;
         let currentOtStatus = "off";
         let otTogglePending = false;
         let otSyncRequestId = 0;
+        let otStartRetryCount = 0;
         let otWarmMirrorProjectId = "";
         let lastExperimentalOtProjectId = "";
         let otWarmMirrorState = {
@@ -33802,6 +34071,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           const projectId = getCurrentProjectId();
           otWarmMirrorState.failureActive = false;
           lastExperimentalOtProjectId = projectId;
+          otStartRetryCount = 0;
           setExperimentalOtEnabledForProject(projectId, checkbox.checked);
           updateExperimentalOtToggleControl(checkbox.checked);
           const savedBadge = getPanel()?.querySelector('details[data-set-group="experimental"] [data-set-saved]');
@@ -33877,8 +34147,10 @@ ${conclusion}` : `${label} ${conclusion}`;
             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;
         }
@@ -33905,23 +34177,31 @@ ${conclusion}` : `${label} ${conclusion}`;
           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;
-          }
+          updateExperimentalOtToggleControl(isExperimentalOtEnabledForProject(projectId));
           updateOtStatusDisplay("unavailable");
-          saveStateSoon();
           try {
             await callPageBridge("stopOtObserver", { projectId });
           } catch (_error) {
           }
+          scheduleOtStartRetry(projectId, requestId);
+        }
+        function scheduleOtStartRetry(projectId, requestId) {
+          const retryDelays = [1e3, 3e3, 6e3];
+          const canRetry = () => isCurrentOtSync(requestId, projectId) && getCurrentProjectId() === projectId && isExperimentalOtEnabledForProject(projectId) && !getCurrentRunView();
+          if (!canRetry() || otStartRetryCount >= retryDelays.length) return;
+          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) {
           if (!projectId || otWarmMirrorState.projectId === projectId) {
@@ -33929,6 +34209,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
           clearOtEventPolling({ clearPatchQueue: true });
           otWarmMirrorState.projectId = projectId;
+          otStartRetryCount = 0;
           otWarmMirrorState.lastPatchAt = 0;
           otWarmMirrorState.lastErrorCode = "";
           otWarmMirrorState.failureActive = false;
@@ -33992,6 +34273,7 @@ ${conclusion}` : `${label} ${conclusion}`;
               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);
@@ -34022,20 +34304,10 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
         }
         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);
@@ -34511,6 +34783,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       let tx;
       let getLocale;
       let appendRunEvent;
+      let appendRunRecordEvent;
       let pendingMirrorRefresh = null;
       let appendChangeSummary;
       let appendCompletionReport;
@@ -34557,6 +34830,34 @@ ${conclusion}` : `${label} ${conclusion}`;
       function buildSettlement(input = {}) {
         return writebackSettlement?.settle instanceof Function ? writebackSettlement.settle(input) : 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 \u64A4\u9500\u5DF2\u5B8C\u6210\uFF0C\u4F46\u672C\u5730\u955C\u50CF\u5931\u6548\u5904\u7406\u5931\u8D25\uFF1A${error.message}\u3002\u8BF7\u5237\u65B0\u9879\u76EE\u6216\u91CD\u65B0\u8FDE\u63A5 Native Host \u540E\u518D\u8FD0\u884C\u3002`
+            )
+          });
+          return "failed";
+        }).finally(() => {
+          if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
+        });
+        pendingMirrorRefresh = pending;
+        return pending;
+      }
       async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options2 = {}) {
         const runMode = options2.mode || getState().mode;
         const runRequireReviewing = typeof options2.requireReviewing === "boolean" ? options2.requireReviewing : getState().requireReviewing === true;
@@ -35209,6 +35510,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           tx,
           getLocale,
           appendRunEvent,
+          appendRunRecordEvent,
           appendChangeSummary,
           appendCompletionReport,
           appendOperationsPreview,
@@ -35254,6 +35556,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         return {
           applySyncChangesToOverleaf,
           resolveCompileLogContext,
+          invalidateMirrorAfterUndo,
           getPendingMirrorRefresh: () => pendingMirrorRefresh
         };
       }
@@ -35261,6 +35564,153 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
     })();
   }).call(globalThis, void 0, void 0, void 0);
   (function runClassicContentModule94(module, exports, require2) {
+    (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);
+            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;
+                }
+                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 };
+    });
+  }).call(globalThis, void 0, void 0, void 0);
+  (function runClassicContentModule95(module, exports, require2) {
     (function initCodexOverleafRunSettlementPersistence(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -35303,7 +35753,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       return Object.freeze({ create });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule95(module, exports, require2) {
+  (function runClassicContentModule96(module, exports, require2) {
     (function initPostNavigationSettlementPersistence(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -35395,7 +35845,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       return Object.freeze({ persist, persistRequired });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule96(module, exports, require2) {
+  (function runClassicContentModule97(module, exports, require2) {
     (function initCodexOverleafPanelMaintenance() {
       "use strict";
       function create(deps = {}) {
@@ -35726,7 +36176,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       window.CodexOverleafPanelMaintenance = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule97(module, exports, require2) {
+  (function runClassicContentModule98(module, exports, require2) {
     (function initCodexOverleafUpdateIdle(root) {
       "use strict";
       function create(options2 = {}) {
@@ -35794,7 +36244,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       root.CodexOverleafUpdateIdle = Object.freeze({ create });
     })(typeof window !== "undefined" ? window : globalThis);
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule98(module, exports, require2) {
+  (function runClassicContentModule99(module, exports, require2) {
     (function initCodexOverleafUpdateNotice(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("../shared/managedUpdateProjection"));
@@ -36259,7 +36709,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       return Object.freeze({ mount });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule99(module, exports, require2) {
+  (function runClassicContentModule100(module, exports, require2) {
     (function initCodexOverleafContentRuntime(root) {
       "use strict";
       function init(dependencies2) {
@@ -36312,6 +36762,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           "mirror.sync",
           "mirror.patchFiles",
           "mirror.confirmWriteback",
+          "mirror.invalidate",
           "mirror.scanSensitive",
           "codex.history.clearPlugin",
           "skills.list",
@@ -36812,6 +37263,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           RUN_SNAPSHOT_ZIP_TIMEOUT_MS,
           getState: () => state,
           getCurrentRunView: () => currentRunView,
+          appendRunRecordEvent,
           onMirrorRefreshSettled: runSettlementPersistence.settleMirrorRefresh
         });
         const {
@@ -37013,6 +37465,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           },
           saveState,
           saveStateSoon,
+          onProjectFilesReady: refreshHistoricalProjectReferences,
           updateActiveSession,
           callPageBridge,
           getCurrentProjectId,
@@ -38483,15 +38936,19 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             setRunning(false);
             nativeChannel.clearActiveRequest();
             stopRunElapsedTick();
-            if (isExperimentalOtEnabled()) {
-              await resumeOtWarmMirror("run-settled");
-            }
             await flushQueuedSaveState().catch(() => {
             });
             currentRunView = null;
             runCancellationRequested = false;
             runCancellationController = null;
             activeTurnControl.release(settlement.requestId);
+            if (isExperimentalOtEnabled()) {
+              try {
+                await resumeOtWarmMirror("run-settled");
+              } catch (_error) {
+                updateOtStatusDisplay("unavailable");
+              }
+            }
             if (settlement.requestId) {
               activeTurnControl.acknowledge(settlement.requestId).catch(() => {
               });
@@ -41060,6 +41517,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                 title: session.title || "",
                 titleSource: session.titleSource || "auto",
                 focusFiles: session.focusFiles || [],
+                projectReferenceFiles: session.projectReferenceFiles || [],
                 codexThreadId: session.codexThreadId || "",
                 createdAt: session.createdAt,
                 updatedAt: session.updatedAt,
@@ -41371,15 +41829,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           renderSessionList();
         }
         function getRenderedModelEntries() {
-          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"
-          }));
+          return Modules.ModelPickerSupport.getRenderedModelEntries(panel);
         }
         async function selectMode(mode) {
           if (!["ask", "auto"].includes(mode)) {
@@ -41500,6 +41950,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           applySessionLabel();
           renderSessionList();
           renderRunHistory(options2);
+          getTrackedChangeCaptureController().schedule();
           renderContextSelection();
           renderContextSummary();
           if (!composerAttachmentsRestoredOnce && Array.isArray(state.composerAttachments) && state.composerAttachments.length && !composerAttachmentController.getAttachmentsForRun?.().length && typeof composerAttachmentController.restorePersistedAttachments === "function") {
@@ -41578,6 +42029,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             undoStatus: "",
             queueItemId,
             nativeRequestId: "",
+            codexThreadId: "",
             codexTurnId: "",
             nativeEventSeq: 0,
             executionSnapshot: executionSnapshot ? RunExecutionSnapshot.cloneSnapshot(executionSnapshot) : void 0,
@@ -41716,6 +42168,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           currentRunView.activeTurn = { threadId, turnId };
           const record = findRunRecord(currentRunView.recordId, currentRunView.sessionId);
           if (record) {
+            record.codexThreadId = threadId;
             record.codexTurnId = turnId;
             record.nativeEventSeq = Math.max(Number(record.nativeEventSeq || 0), Number(journalSeq || 0));
           }
@@ -42029,6 +42482,12 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           }
           return files;
         }
+        function refreshHistoricalProjectReferences(project) {
+          if (!project?.id || String(project.id) !== getCurrentProjectId()) return;
+          state = updateActiveSession(state, { projectReferenceFiles: captureProjectReferenceFiles(project) });
+          saveStateSoon();
+          if (!currentRunView && !trackedChangeInFlight.size) renderRunHistory({ preserveScroll: true });
+        }
         function persistCurrentProjectReferenceFiles(project) {
           const projectFiles = captureProjectReferenceFiles(project);
           if (currentRunView) {
@@ -42143,6 +42602,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             runProjectId: getRunProjectIdForWriteback(run)
           });
           const undoApplied = isUndoResultEffectivelyApplied(run, result);
+          writebackOrchestrator.invalidateMirrorAfterUndo(runId, getRunProjectIdForWriteback(run), result);
           appendUndoReviewingPolicyEvent(runId, result.reviewingPolicy);
           appendRunRecordEvent(runId, {
             title: tr("undoResult", { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }),
@@ -42195,11 +42655,14 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             detail: { [tr("detailWillUndo")]: trackedUndo ? formatTrackedChangeFiles(run.undoTrackedChanges) : formatTrackedUndoFiles(run) }
           });
           let result;
+          let trackedUndoPostFilesAtDispatch;
           try {
+            trackedUndoPostFilesAtDispatch = buildTrackedUndoPostFiles(run);
             result = await callPageBridge("rejectTrackedChanges", {
               trackedChanges: run.undoTrackedChanges || [],
               expectedFiles: run.undoExpectedFiles || [],
-              postFiles: buildTrackedUndoPostFiles(run),
+              postFiles: trackedUndoPostFilesAtDispatch,
+              untrackedUndo: run.executionSnapshot ? run.executionSnapshot.requireReviewing === false && ["submitted", "legacy-captured"].includes(run.executionSnapshot.source) : getTrackedChangeCaptureController().hasLegacyUntrackedCheckpoint(run),
               // Welcome-panel + write-guard:
               // bind the reject to the run's original project. If the user has
               // navigated away the page-side guard refuses with
@@ -42211,6 +42674,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               trackedChangeInFlight.delete(runId);
             }
           }
+          writebackOrchestrator.invalidateMirrorAfterUndo(runId, getRunProjectIdForWriteback(run), result);
           appendRunRecordEvent(runId, {
             title: trackedUndo ? tr("undoTrackedResult", { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }) : tr("undoNativeResult", { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }),
             status: result.skipped?.length ? "failed" : "completed",
@@ -42228,7 +42692,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           });
           if (lifecycleReject) {
             WritebackSettlement.attachUndoNotVerifiedFailure(run, result, {
-              buildFailure: buildContentFailure
+              buildFailure: buildContentFailure,
+              postFiles: trackedUndoPostFilesAtDispatch
             });
             applyTrackedChangeSettlement(runId, "reject", result);
             return;
@@ -42408,6 +42873,28 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         function attachVerifiedContentToOperation(operation, result) {
           return WritebackSettlement.attachVerifiedContentToOperation(operation, result);
         }
+        let trackedChangeCaptureController = null;
+        function getTrackedChangeCaptureController() {
+          return trackedChangeCaptureController || (trackedChangeCaptureController = Modules.TrackedChangeCaptureController.create({
+            getRuns: () => (state.sessions || []).flatMap((session) => session.runs || []),
+            getProjectId: () => window.location.pathname.match(/^\/project\/([^/]+)/)?.[1] || "",
+            buildExpectedFilesAfterOperations,
+            normalizeTrackedChanges: normalizeApplyTrackedChanges,
+            callPageBridge,
+            persist: () => flushQueuedSaveState({ preserveRunActionPayload: true }),
+            refresh: (run) => refreshRunCardControls(run.id),
+            notify: (run, kind, detail) => appendRunRecordEvent(run.id, {
+              title: {
+                pending: tx("Files written; confirming tracked changes.", "\u6587\u4EF6\u5DF2\u5199\u5165\uFF0C\u6B63\u5728\u786E\u8BA4\u7559\u75D5\u8BB0\u5F55\u3002"),
+                observed: tx("Tracked changes confirmed; Accept is available.", "\u7559\u75D5\u8BB0\u5F55\u5DF2\u786E\u8BA4\uFF0C\u53EF\u4EE5\u63A5\u53D7\u6539\u52A8\u3002"),
+                needs_review: tx("Tracked changes could not be safely attributed. Review them in Overleaf; Undo is preserved.", "\u7559\u75D5\u5F52\u5C5E\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5728 Overleaf \u5BA1\u9605\uFF1B\u539F\u6709\u64A4\u9500\u80FD\u529B\u5DF2\u4FDD\u7559\u3002")
+              }[kind],
+              status: "info",
+              detail
+            }),
+            onError: (error) => appendPlainLog(tx("Tracked-change confirmation unavailable: ", "\u7559\u75D5\u786E\u8BA4\u6682\u4E0D\u53EF\u7528\uFF1A") + error.message)
+          }));
+        }
         function recordUndoFromApply(project, applyResult) {
           const appliedEntries = getAppliedEntries(applyResult);
           if (!currentRunView?.recordId || !appliedEntries.length) {
@@ -42444,6 +42931,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             if (combinedTrackedChanges.length) {
               record.trackedChangeStatus = "pending";
             }
+            getTrackedChangeCaptureController().record(record, applyResult?.trackedChangeCaptures);
             refreshRunCardControls(record.id);
             if (combinedTrackedChanges.length) {
               appendRunEvent({
@@ -42505,28 +42993,10 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           return WritebackSettlement.normalizeApplyTrackedChanges(changes);
         }
         function selectExpectedFilesForTrackedUndo(project, operations = [], trackedChanges = [], previousExpectedFiles = []) {
-          return WritebackSettlement.selectExpectedFilesForTrackedUndo(
-            project,
-            operations,
-            trackedChanges,
-            previousExpectedFiles
-          );
+          return WritebackSettlement.selectExpectedFilesForTrackedUndo(project, operations, trackedChanges, previousExpectedFiles);
         }
         function buildTrackedUndoPostFiles(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 = 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
-          }));
+          return getTrackedChangeCaptureController().buildPostFiles(run);
         }
         function hasTrackedEditorUndo(run) {
           return buildTrackedUndoPostFiles(run).length > 0;
@@ -43103,7 +43573,7 @@ Reason: ${item.reason || "No reason provided"}`),
       root.CodexOverleafContentRuntime = { init };
     })(typeof window !== "undefined" ? window : globalThis);
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule100(module, exports, require2) {
+  (function runClassicContentModule101(module, exports, require2) {
     (function initCodexOverleafLegacyGlobalRegistry(root, factory) {
       "use strict";
       const api = factory();
@@ -43179,6 +43649,7 @@ Reason: ${item.reason || "No reason provided"}`),
         "StorageMigration",
         "Summary",
         "Theme",
+        "TrackedChangeCaptureController",
         "UndoOperations",
         "UpdateIdle",
         "UpdateNotice",