codex-overleaf-link 2.3.5 → 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) {
@@ -3895,7 +3896,7 @@ ${block}`;
         return sha256Hex(utf8Bytes(value));
       }
       function normalizePath(value) {
-        return String(value || "").replace(/\s+/g, " ").replace(/\\/g, "/").trim().replace(/^\/+/, "");
+        return String(value || "").replace(/\\/g, "/").trim().replace(/^\/+/, "");
       }
       function normalizeText(value) {
         return String(value ?? "");
@@ -4114,20 +4115,31 @@ ${block}`;
           diagnosticsPageSubtitle: "Current file, write access, track changes",
           diagnosticsSnapshotTitle: "Check Project Read",
           diagnosticsSnapshotSubtitle: "Full project, assets, read source",
-          diagnosticsOtTitle: "Check Experimental OT Mirror",
+          diagnosticsOtTitle: "Check OT Mirror",
           diagnosticsOtSubtitle: "Status, fresh files, fallback",
           diagnosticsExportTitle: "Export Diagnostics",
           diagnosticsExportSubtitle: "Redacted audit and environment bundle",
           diagnosticsExportDone: "Diagnostics bundle exported.",
-          diagnosticsOtSummaryEnabled: "Experimental OT is enabled. Codex will use the OT-warmed mirror only when matching files are fresh; otherwise it falls back to the normal project read path.",
-          diagnosticsOtSummaryDisabled: "Experimental OT is disabled, so Codex is using the normal project read path.",
-          diagnosticsOtNextStep: "If you expected OT warm reads, turn on OT and wait for the status to show Live before relying on it.",
-          experimentalOtMenuTitle: "Experimental OT Mirror",
-          experimentalOtMenuSubtitle: "Experimental \u2014 speeds up reading the file you are editing; Codex falls back to normal reading whenever unsure.",
-          experimentalOtConfirmTitle: "Experimental OT Mirror",
-          experimentalOtConfirmMessage: "Experimental: tracks the current Overleaf editor and warms the local mirror so Codex can read recent focused-file edits faster. Codex uses it only when file scope is clear and the mirror is fresh; otherwise it falls back to normal project reading.",
+          diagnosticsOtSummaryEnabled: "OT Mirror is enabled. Codex will use the OT-warmed mirror only when matching files are fresh; otherwise it falls back to the normal project read path.",
+          diagnosticsOtSummaryDisabled: "OT Mirror is disabled, so Codex is using the normal project read path.",
+          diagnosticsOtNextStep: "Observer status describes warming availability. File scope and freshness are checked again before each run.",
+          experimentalOtMenuTitle: "OT Mirror",
+          otSettingsTitle: "Project cache",
+          contextLoadingTitle: "Context loading",
+          runFeedbackFailedTitle: "Needs attention",
+          runFeedbackPartialTitle: "Partially completed",
+          runFeedbackUnconfirmedTitle: "Write status needs review",
+          runFeedbackGeneric: "Open the run details for the reported cause and the next step.",
+          runFeedbackUnconfirmed: "Some changes may already be in Overleaf. Check the document before retrying.",
+          runFeedbackUnconfirmedResult: "Not fully confirmed. Review Overleaf before retrying.",
+          runFeedbackReviewFile: "Review {file} in Overleaf",
+          runFeedbackReviewDetails: "Review run details",
+          runFeedbackDetailsUnavailable: "Detailed steps are unavailable for this older run.",
+          experimentalOtMenuSubtitle: "Warms recent edits to the active text file locally. File scope and freshness are checked before reuse.",
+          experimentalOtConfirmTitle: "Enable OT Mirror?",
+          experimentalOtConfirmMessage: "Observes the active text editor and warms its local mirror. This is read-only with respect to Overleaf and does not upload assets. Each run checks file scope and freshness before reuse; normal project reading remains the fallback.",
           experimentalOtConfirmEnable: "Turn on",
-          experimentalOtEnabledToast: "Experimental OT Mirror is on. Use @file for the cleanest warm-mirror test.",
+          experimentalOtEnabledToast: "OT Mirror requested for this project. Its status shows whether warming is available.",
           diagnosticsSnapshotLoading: "Checking whether the extension can read the full Overleaf project.",
           diagnosticsSnapshotErrorSummary: "Overleaf may still be loading, or the page API did not return project files yet.",
           diagnosticsNativeLoading: "Checking whether local Codex, Native Host, and LaTeX tools are available.",
@@ -4400,18 +4412,27 @@ ${block}`;
           requireReviewingTitle: "When enabled, Codex checks or switches Overleaf Reviewing/Track Changes before writing. Deletes still require confirmation.",
           autoCompile: "Compile",
           autoCompileTitle: "After Codex writes, click Overleaf Recompile and record the compile result for this task. Ask mode will not trigger it.",
-          experimentalOtWarmMirror: "Experimental OT warm mirror",
+          experimentalOtWarmMirror: "OT warm mirror",
           experimentalOtWarmMirrorShort: "OT",
-          experimentalOtWarmMirrorTitle: "Experimental read-only OT mirror warming. If unavailable, stale, or inconsistent, Codex falls back to the normal project read path.",
+          experimentalOtWarmMirrorTitle: "Read-only local text warming. File scope and freshness are checked before reuse; normal project reading remains the fallback.",
           otStatus: "OT status",
-          otFreshFiles: "OT fresh files",
-          otFallback: "Fallback",
+          otFreshFiles: "Files with recent OT evidence",
+          otFallback: "Read fallback",
           otStatusOff: "Off",
-          otStatusStarting: "Start",
-          otStatusObserving: "Live",
-          otStatusUnavailable: "N/A",
-          otStatusStale: "Stale",
-          otStatusInconsistent: "Check",
+          otStatusStarting: "Connecting",
+          otStatusObserving: "Observing current editor",
+          otStatusUnavailable: "Unavailable",
+          otStatusStale: "Warming paused; awaiting verification",
+          otStatusInconsistent: "Needs verification",
+          otFailureBridge: "The page connection needs to be restored. Reload the extension and Overleaf before retrying.",
+          otFailureObserver: "The editor observer is unavailable. The next run will try normal project reading.",
+          otFailureEditor: "The active editor could not be read. Warming is paused; the next run will try normal project reading.",
+          otFailureFileLimit: "This file exceeds the 1 MiB warming limit. The next run will try normal project reading.",
+          otFailureQueueLimit: "The mirror queue reached its limit. Warming is paused; the next run will try normal project reading.",
+          otFailureExpired: "The observation is too old to reuse. The next run will try normal project reading.",
+          otFailureMirror: "The mirror update was not fully confirmed. The next run will try normal project reading.",
+          otFailureGeneric: "Mirror warming could not continue. The next run will try normal project reading.",
+          otFailureNextStep: "Resolve the reported cause, then enable OT again. If the page connection is unavailable, reload the extension and Overleaf first.",
           modelSourceFallback: "fallback",
           modelSourceDiscovered: "discovered",
           modelSourceFailed: "failed",
@@ -4634,20 +4655,31 @@ ${block}`;
           diagnosticsPageSubtitle: "\u5F53\u524D\u6587\u4EF6\u3001\u5199\u5165\u80FD\u529B\u3001\u7559\u75D5\u72B6\u6001",
           diagnosticsSnapshotTitle: "\u68C0\u67E5\u9879\u76EE\u8BFB\u53D6",
           diagnosticsSnapshotSubtitle: "\u5B8C\u6574\u9879\u76EE\u3001\u8D44\u6E90\u6587\u4EF6\u3001\u8BFB\u53D6\u6765\u6E90",
-          diagnosticsOtTitle: "\u68C0\u67E5\u5B9E\u9A8C\u6027 OT Mirror",
+          diagnosticsOtTitle: "\u68C0\u67E5 OT Mirror",
           diagnosticsOtSubtitle: "\u72B6\u6001\u3001\u65B0\u9C9C\u6587\u4EF6\u3001\u56DE\u9000\u8DEF\u5F84",
           diagnosticsExportTitle: "\u5BFC\u51FA\u8BCA\u65AD\u4FE1\u606F",
           diagnosticsExportSubtitle: "\u5DF2\u8131\u654F\u7684\u5BA1\u8BA1\u548C\u73AF\u5883\u4FE1\u606F\u5305",
           diagnosticsExportDone: "\u8BCA\u65AD\u4FE1\u606F\u5DF2\u5BFC\u51FA\u3002",
-          diagnosticsOtSummaryEnabled: "\u5B9E\u9A8C\u6027 OT \u5DF2\u5F00\u542F\u3002\u53EA\u6709\u5339\u914D\u6587\u4EF6\u662F\u65B0\u9C9C\u72B6\u6001\u65F6\uFF0CCodex \u624D\u4F1A\u4F7F\u7528 OT \u9884\u70ED mirror\uFF1B\u5426\u5219\u4F1A\u56DE\u9000\u5230\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u8DEF\u5F84\u3002",
-          diagnosticsOtSummaryDisabled: "\u5B9E\u9A8C\u6027 OT \u5DF2\u5173\u95ED\uFF0CCodex \u4F1A\u4F7F\u7528\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u8DEF\u5F84\u3002",
-          diagnosticsOtNextStep: "\u5982\u679C\u4F60\u5E0C\u671B\u4F7F\u7528 OT \u9884\u70ED\u8BFB\u53D6\uFF0C\u8BF7\u5F00\u542F OT\uFF0C\u5E76\u7B49\u72B6\u6001\u663E\u793A\u4E3A\u201C\u5B9E\u65F6\u201D\u540E\u518D\u4F9D\u8D56\u5B83\u3002",
-          experimentalOtMenuTitle: "\u5B9E\u9A8C\u6027 OT Mirror",
-          experimentalOtMenuSubtitle: "\u5B9E\u9A8C\u6027\u2014\u2014\u52A0\u5FEB\u8BFB\u53D6\u4F60\u6B63\u5728\u7F16\u8F91\u7684\u6587\u4EF6\uFF1B\u62FF\u4E0D\u51C6\u65F6\u81EA\u52A8\u56DE\u9000\u5230\u666E\u901A\u8BFB\u53D6\u3002",
-          experimentalOtConfirmTitle: "\u5B9E\u9A8C\u6027 OT Mirror",
-          experimentalOtConfirmMessage: "\u5B9E\u9A8C\u6027\uFF1A\u5B9E\u65F6\u8DDF\u8E2A\u5F53\u524D Overleaf \u7F16\u8F91\u5668\uFF0C\u628A\u6539\u52A8\u9884\u70ED\u5230\u672C\u5730 mirror\uFF0C\u8BA9 Codex \u66F4\u5FEB\u8BFB\u5230\u6700\u8FD1\u7684\u5F53\u524D\u6587\u4EF6\u6539\u52A8\u3002\u53EA\u6709\u6587\u4EF6\u8303\u56F4\u660E\u786E\u4E14 mirror \u65B0\u9C9C\u65F6\u624D\u4F1A\u4F7F\u7528\uFF1B\u5426\u5219\u81EA\u52A8\u56DE\u9000\u5230\u666E\u901A\u9879\u76EE\u8BFB\u53D6\u3002",
+          diagnosticsOtSummaryEnabled: "OT Mirror \u5DF2\u5F00\u542F\u3002\u53EA\u6709\u5339\u914D\u6587\u4EF6\u662F\u65B0\u9C9C\u72B6\u6001\u65F6\uFF0CCodex \u624D\u4F1A\u4F7F\u7528 OT \u9884\u70ED\u955C\u50CF\uFF1B\u5426\u5219\u4F1A\u56DE\u9000\u5230\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u8DEF\u5F84\u3002",
+          diagnosticsOtSummaryDisabled: "OT Mirror \u5DF2\u5173\u95ED\uFF0CCodex \u4F1A\u4F7F\u7528\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u8DEF\u5F84\u3002",
+          diagnosticsOtNextStep: "\u89C2\u6D4B\u72B6\u6001\u8BF4\u660E\u9884\u70ED\u662F\u5426\u53EF\u7528\uFF1B\u6BCF\u6B21\u4EFB\u52A1\u5F00\u59CB\u524D\u4ECD\u4F1A\u91CD\u65B0\u6821\u9A8C\u6587\u4EF6\u8303\u56F4\u548C\u65B0\u9C9C\u5EA6\u3002",
+          experimentalOtMenuTitle: "OT Mirror",
+          otSettingsTitle: "\u9879\u76EE\u7F13\u5B58",
+          contextLoadingTitle: "\u4E0A\u4E0B\u6587\u52A0\u8F7D",
+          runFeedbackFailedTitle: "\u9700\u8981\u5904\u7406",
+          runFeedbackPartialTitle: "\u90E8\u5206\u5B8C\u6210",
+          runFeedbackUnconfirmedTitle: "\u5199\u5165\u72B6\u6001\u5F85\u786E\u8BA4",
+          runFeedbackGeneric: "\u53EF\u5728\u672C\u8F6E\u8BE6\u60C5\u4E2D\u67E5\u770B\u5177\u4F53\u539F\u56E0\u548C\u540E\u7EED\u5904\u7406\u65B9\u5F0F\u3002",
+          runFeedbackUnconfirmed: "\u90E8\u5206\u6539\u52A8\u53EF\u80FD\u5DF2\u7ECF\u5199\u5165 Overleaf\uFF0C\u91CD\u8BD5\u524D\u8BF7\u5148\u68C0\u67E5\u6587\u6863\u3002",
+          runFeedbackUnconfirmedResult: "\u7ED3\u679C\u5C1A\u672A\u5B8C\u5168\u786E\u8BA4\uFF0C\u8BF7\u68C0\u67E5 Overleaf \u540E\u518D\u51B3\u5B9A\u662F\u5426\u91CD\u8BD5\u3002",
+          runFeedbackReviewFile: "\u5728 Overleaf \u68C0\u67E5 {file}",
+          runFeedbackReviewDetails: "\u67E5\u770B\u8FD0\u884C\u6B65\u9AA4",
+          runFeedbackDetailsUnavailable: "\u8FD9\u6761\u5386\u53F2\u8BB0\u5F55\u6CA1\u6709\u53EF\u5C55\u5F00\u7684\u8BE6\u7EC6\u6B65\u9AA4\u3002",
+          experimentalOtMenuSubtitle: "\u5728\u672C\u5730\u9884\u70ED\u5F53\u524D\u6587\u672C\u6587\u4EF6\u7684\u6700\u8FD1\u6539\u52A8\uFF0C\u590D\u7528\u524D\u91CD\u65B0\u6821\u9A8C\u6587\u4EF6\u8303\u56F4\u548C\u65B0\u9C9C\u5EA6\u3002",
+          experimentalOtConfirmTitle: "\u5F00\u542F OT Mirror\uFF1F",
+          experimentalOtConfirmMessage: "\u89C2\u6D4B\u5F53\u524D\u6587\u672C\u7F16\u8F91\u5668\u5E76\u9884\u70ED\u672C\u5730\u955C\u50CF\u3002\u6B64\u529F\u80FD\u4E0D\u4F1A\u5199\u56DE Overleaf\uFF0C\u4E5F\u4E0D\u8D1F\u8D23\u4E0A\u4F20\u8D44\u4EA7\u3002\u6BCF\u6B21\u4EFB\u52A1\u590D\u7528\u524D\u90FD\u4F1A\u6821\u9A8C\u6587\u4EF6\u8303\u56F4\u548C\u65B0\u9C9C\u5EA6\uFF0C\u4E0D\u6EE1\u8DB3\u6761\u4EF6\u65F6\u5C1D\u8BD5\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
           experimentalOtConfirmEnable: "\u5F00\u542F",
-          experimentalOtEnabledToast: "\u5B9E\u9A8C\u6027 OT Mirror \u5DF2\u5F00\u542F\u3002\u4F7F\u7528 @file \u53EF\u4EE5\u6700\u6E05\u695A\u5730\u6D4B\u8BD5 warm mirror\u3002",
+          experimentalOtEnabledToast: "\u5DF2\u4E3A\u5F53\u524D\u9879\u76EE\u8BF7\u6C42\u5F00\u542F OT Mirror\uFF0C\u53EF\u7528\u60C5\u51B5\u89C1\u72B6\u6001\u63D0\u793A\u3002",
           diagnosticsSnapshotLoading: "\u786E\u8BA4\u63D2\u4EF6\u80FD\u5426\u8BFB\u53D6\u5B8C\u6574 Overleaf \u9879\u76EE\u3002",
           diagnosticsSnapshotErrorSummary: "\u8FD9\u901A\u5E38\u662F Overleaf \u9875\u9762\u8FD8\u6CA1\u52A0\u8F7D\u5B8C\u6210\uFF0C\u6216\u8005\u5F53\u524D\u9875\u9762\u63A5\u53E3\u6682\u65F6\u6CA1\u6709\u8FD4\u56DE\u9879\u76EE\u6587\u4EF6\u3002",
           diagnosticsNativeLoading: "\u786E\u8BA4\u672C\u673A Codex\u3001Native Host \u548C LaTeX \u5DE5\u5177\u662F\u5426\u53EF\u7528\u3002",
@@ -4920,18 +4952,27 @@ ${block}`;
           requireReviewingTitle: "\u5F00\u542F\u540E\uFF0C\u5199\u5165\u524D\u4F1A\u786E\u8BA4\u5E76\u5C1D\u8BD5\u5207\u5230 Overleaf Reviewing/Track Changes\uFF1B\u5220\u9664\u4ECD\u9700\u786E\u8BA4\u3002",
           autoCompile: "\u7F16\u8BD1",
           autoCompileTitle: "Codex \u5199\u5165\u540E\u81EA\u52A8\u70B9\u51FB Overleaf Recompile\uFF0C\u5E76\u628A\u7F16\u8BD1\u7ED3\u679C\u8BB0\u5F55\u5230\u672C\u8F6E\u4EFB\u52A1\u3002\u53EA\u95EE\u4E0D\u6539\u65F6\u4E0D\u4F1A\u89E6\u53D1\u3002",
-          experimentalOtWarmMirror: "\u5B9E\u9A8C\u6027 OT \u9884\u70ED\u955C\u50CF",
+          experimentalOtWarmMirror: "OT \u9884\u70ED\u955C\u50CF",
           experimentalOtWarmMirrorShort: "OT",
-          experimentalOtWarmMirrorTitle: "\u5B9E\u9A8C\u6027\u53EA\u8BFB OT \u955C\u50CF\u9884\u70ED\uFF1B\u4E0D\u53EF\u7528\u3001\u8FC7\u671F\u6216\u4E0D\u4E00\u81F4\u65F6\u4F1A\u56DE\u9000\u5230\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
+          experimentalOtWarmMirrorTitle: "\u53EA\u8BFB\u672C\u5730\u6587\u672C\u9884\u70ED\uFF1B\u590D\u7528\u524D\u6821\u9A8C\u6587\u4EF6\u8303\u56F4\u548C\u65B0\u9C9C\u5EA6\uFF0C\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u4F5C\u4E3A\u56DE\u9000\u8DEF\u5F84\u3002",
           otStatus: "OT \u72B6\u6001",
-          otFreshFiles: "OT \u65B0\u9C9C\u6587\u4EF6",
-          otFallback: "\u56DE\u9000",
-          otStatusOff: "\u5173",
-          otStatusStarting: "\u542F\u52A8",
-          otStatusObserving: "\u5B9E\u65F6",
-          otStatusUnavailable: "\u4E0D\u53EF\u7528",
-          otStatusStale: "\u8FC7\u671F",
-          otStatusInconsistent: "\u9700\u68C0\u67E5",
+          otFreshFiles: "\u8FD1\u671F\u6709 OT \u6821\u9A8C\u8BC1\u636E\u7684\u6587\u4EF6",
+          otFallback: "\u8BFB\u53D6\u56DE\u9000",
+          otStatusOff: "\u672A\u5F00\u542F",
+          otStatusStarting: "\u6B63\u5728\u8FDE\u63A5",
+          otStatusObserving: "\u6B63\u5728\u89C2\u6D4B\u5F53\u524D\u7F16\u8F91\u5668",
+          otStatusUnavailable: "\u6682\u4E0D\u53EF\u7528",
+          otStatusStale: "\u9884\u70ED\u6682\u7F13\uFF0C\u7B49\u5F85\u91CD\u65B0\u6821\u9A8C",
+          otStatusInconsistent: "\u9700\u91CD\u65B0\u6821\u9A8C",
+          otFailureBridge: "\u9875\u9762\u8FDE\u63A5\u9700\u8981\u6062\u590D\uFF0C\u8BF7\u5148\u91CD\u65B0\u52A0\u8F7D\u6269\u5C55\u5E76\u5237\u65B0 Overleaf\uFF0C\u518D\u91CD\u8BD5\u3002",
+          otFailureObserver: "\u7F16\u8F91\u5668\u89C2\u5BDF\u5668\u6682\u4E0D\u53EF\u7528\uFF0C\u4E0B\u6B21\u4EFB\u52A1\u5C06\u5C1D\u8BD5\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
+          otFailureEditor: "\u5F53\u524D\u7F16\u8F91\u5668\u5185\u5BB9\u5C1A\u4E0D\u53EF\u8BFB\uFF0C\u9884\u70ED\u5DF2\u6682\u505C\uFF1B\u4E0B\u6B21\u4EFB\u52A1\u5C06\u5C1D\u8BD5\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
+          otFailureFileLimit: "\u6587\u4EF6\u8D85\u8FC7 1 MiB \u9884\u70ED\u4E0A\u9650\uFF0C\u4E0B\u6B21\u4EFB\u52A1\u5C06\u5C1D\u8BD5\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
+          otFailureQueueLimit: "\u955C\u50CF\u961F\u5217\u8FBE\u5230\u5BB9\u91CF\u4E0A\u9650\uFF0C\u9884\u70ED\u5DF2\u6682\u505C\uFF1B\u4E0B\u6B21\u4EFB\u52A1\u5C06\u5C1D\u8BD5\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
+          otFailureExpired: "\u89C2\u6D4B\u8BB0\u5F55\u5DF2\u8FC7\u671F\uFF0C\u4E0B\u6B21\u4EFB\u52A1\u5C06\u5C1D\u8BD5\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
+          otFailureMirror: "\u955C\u50CF\u66F4\u65B0\u5C1A\u672A\u5B8C\u6574\u786E\u8BA4\uFF0C\u4E0B\u6B21\u4EFB\u52A1\u5C06\u5C1D\u8BD5\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
+          otFailureGeneric: "\u955C\u50CF\u9884\u70ED\u672A\u80FD\u7EE7\u7EED\uFF0C\u4E0B\u6B21\u4EFB\u52A1\u5C06\u5C1D\u8BD5\u5E38\u89C4\u9879\u76EE\u8BFB\u53D6\u3002",
+          otFailureNextStep: "\u5904\u7406\u6240\u663E\u793A\u7684\u539F\u56E0\u540E\u91CD\u65B0\u5F00\u542F OT\uFF1B\u82E5\u9875\u9762\u8FDE\u63A5\u4E0D\u53EF\u7528\uFF0C\u8BF7\u5148\u91CD\u65B0\u52A0\u8F7D\u6269\u5C55\u5E76\u5237\u65B0 Overleaf\u3002",
           modelSourceFallback: "\u5907\u7528\u5217\u8868",
           modelSourceDiscovered: "\u5DF2\u53D1\u73B0",
           modelSourceFailed: "\u83B7\u53D6\u5931\u8D25",
@@ -7846,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,
@@ -7855,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 = []) {
@@ -7874,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);
@@ -7889,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;
       }
@@ -8108,6 +8155,106 @@ ${block}`;
     });
   }).call(globalThis, void 0, void 0, void 0);
   (function runClassicContentModule27(module, exports, require2) {
+    (function initSessionTitle(root, factory) {
+      if (typeof module === "object" && module.exports) {
+        module.exports = factory();
+      } else {
+        root.CodexOverleafModuleRegistry.define("SessionTitle", [], factory);
+      }
+    })(typeof globalThis !== "undefined" ? globalThis : window, function sessionTitleFactory() {
+      "use strict";
+      const INPUT_LIMIT = 12e3;
+      const STORAGE_LIMIT = 80;
+      const segmenter = typeof Intl !== "undefined" && typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+      const FILE_TOKEN = /@file:(?:"([^"]+)"|'([^']+)'|([^\s]+))/g;
+      function derive(runs, task, options2 = {}) {
+        let fallback = "";
+        for (const run of Array.isArray(runs) ? runs : []) {
+          const candidate = fromPrompt(run?.task, options2);
+          fallback || (fallback = candidate);
+          if (candidate && !isGeneric(candidate)) return candidate;
+        }
+        const draft = fromPrompt(task, options2);
+        return draft && !isGeneric(draft) ? draft : fallback || draft;
+      }
+      function fromPrompt(value, { sanitize = (text) => text, maxChars = 24 } = {}) {
+        if (typeof value !== "string" || !value.trim()) return "";
+        const source = String(sanitize(value.slice(0, INPUT_LIMIT)) || "");
+        let fence = null;
+        let fallback = "";
+        for (const rawLine of source.split(/\r?\n/)) {
+          const line = rawLine.trim();
+          const marker = /^(`{3,}|~{3,})(.*)$/.exec(line);
+          if (marker) {
+            if (!fence) {
+              fence = marker[1];
+              const language = marker[2].trim().match(/^[A-Za-z0-9_+-]{1,24}\b/)?.[0] || "code";
+              fallback || (fallback = `${language} snippet`);
+            } else if (marker[1][0] === fence[0] && marker[1].length >= fence.length && !marker[2].trim()) {
+              fence = null;
+            }
+            continue;
+          }
+          if (fence || !line || /^>/.test(line)) continue;
+          const withoutContext = line.replace(FILE_TOKEN, " ").replace(/@(context|compile-log)\b/g, " ").trim();
+          const cleaned = cleanLine(line);
+          if (!withoutContext || /^https?:\/\/\S+$/i.test(line)) {
+            fallback || (fallback = cleaned);
+            continue;
+          }
+          for (const sentence of cleaned.split(/[\u3002\uff01\uff1f]+/u)) {
+            const candidate = sentence.trim().replace(/[,;:\uff0c\uff1b\uff1a]+$/u, "").trim();
+            if (!/[\p{L}\p{N}]/u.test(candidate) || isScaffolding(candidate)) continue;
+            fallback || (fallback = candidate);
+            if (!isGeneric(candidate)) return shorten(candidate, maxChars);
+          }
+        }
+        return shorten(fallback, maxChars);
+      }
+      function cleanLine(value) {
+        return value.replace(/^#{1,6}\s+/, "").replace(/^(?:[-*+]\s+|\d+\.\s+|\d+[)\u3001]\s*)/, "").replace(FILE_TOKEN, (_match, quoted, singleQuoted, bare) => String(quoted || singleQuoted || bare || "").replace(/\\/g, "/").split("/").pop()).replace(/@(context|compile-log)\b/g, " ").replace(/!?\[([^\]]*)\]\([^\n)]*\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/https?:\/\/\S+/gi, (address) => {
+          try {
+            return new URL(address).hostname;
+          } catch (_error) {
+            return "";
+          }
+        }).replace(/\[(?:REDACTED_SECRET|local path(?::\d+)?)\]/gi, " ").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "").replace(/\s+/g, " ").trim().replace(/^(?:\u8bf7(?:\u4f60)?\u5e2e\u6211|\u8bf7\u4f60|\u5e2e\u6211|\u9ebb\u70e6\u4f60(?:\u5e2e\u6211)?|\u9ebb\u70e6\u5e2e\u6211|please\s+)\s*/i, "");
+      }
+      function isScaffolding(value) {
+        return /^(?:my request(?: for [^:]+)?|request|task|context|files(?: mentioned by [^:]+)?|attachments|\u6211\u7684\u8bf7\u6c42|\u9700\u6c42|\u4efb\u52a1|\u4e0a\u4e0b\u6587|\u9644\u4ef6|\u6587\u4ef6)$/i.test(value);
+      }
+      function isGeneric(value) {
+        const text = String(value || "").trim().replace(/[\s.!?\u3002\uff1f\uff01\u2026]+$/u, "");
+        if (!text || Array.from(text).length < 2) return true;
+        return /^(?:ok(?:ay)?|yes|no|go|done|continue|proceed|thanks?|thank you|hello|hi|test|new task|untitled task|\u597d(?:\u7684)?|\u53ef\u4ee5|\u7ee7\u7eed|\u786e\u8ba4|\u786e\u5b9a|\u6536\u5230|\u8c22\u8c22|\u6d4b\u8bd5|\u6267\u884c|\u662f\u7684|\u4f60\u597d)$/i.test(text) || /^[A-Za-z0-9_+-]{1,24} snippet$/i.test(text) || /^[^\s]+\.(?:tex|bib|md|txt|pdf|svg|png|jpe?g|webp)(?::\d+)?$/i.test(text) || /^(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}$/i.test(text);
+      }
+      function shorten(value, maxChars) {
+        const title = String(value || "").trim();
+        if (!title) return "";
+        const chars = Number.isFinite(maxChars) && maxChars > 0 ? Math.min(40, Math.floor(maxChars)) : 24;
+        const maxUnits = chars * 2;
+        const glyphs = segmenter ? Array.from(segmenter.segment(title), (item) => item.segment) : Array.from(title);
+        const width = (glyph) => /[^\u0000-\u00ff]/u.test(glyph) ? 2 : 1;
+        if (title.length <= STORAGE_LIMIT && glyphs.reduce((total, glyph) => total + width(glyph), 0) <= maxUnits) return title;
+        let prefix = "";
+        let units = 0;
+        let index = 0;
+        for (; index < glyphs.length; index++) {
+          const glyph = glyphs[index];
+          if (units + width(glyph) > maxUnits - 2 || prefix.length + glyph.length > STORAGE_LIMIT - 1) break;
+          prefix += glyph;
+          units += width(glyph);
+        }
+        const boundary = prefix.lastIndexOf(" ");
+        if (/[A-Za-z0-9]$/.test(prefix) && /^[A-Za-z0-9]/.test(glyphs[index] || "") && boundary >= prefix.length * 0.6) {
+          prefix = prefix.slice(0, boundary);
+        }
+        return prefix.trimEnd().replace(/[,;:\uff0c\uff1b\uff1a]+$/u, "") + "\u2026";
+      }
+      return Object.freeze({ derive, fromPrompt, isGeneric });
+    });
+  }).call(globalThis, void 0, void 0, void 0);
+  (function runClassicContentModule28(module, exports, require2) {
     (function initSessionState(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(
@@ -8115,16 +8262,17 @@ ${block}`;
           require2("./settlementFacts"),
           require2("./runInputQueue"),
           require2("./lineReferences"),
-          require2("./pathRedaction")
+          require2("./pathRedaction"),
+          require2("./sessionTitle")
         );
       } else {
         root.CodexOverleafModuleRegistry.define(
           "SessionState",
-          ["I18n", "SettlementFacts", "RunInputQueue", "LineReferences", "PathRedaction"],
+          ["I18n", "SettlementFacts", "RunInputQueue", "LineReferences", "PathRedaction", "SessionTitle"],
           factory
         );
       }
-    })(typeof globalThis !== "undefined" ? globalThis : window, function sessionStateFactory(i18n, SettlementFacts, RunInputQueue, LineReferences, PathRedaction) {
+    })(typeof globalThis !== "undefined" ? globalThis : window, function sessionStateFactory(i18n, SettlementFacts, RunInputQueue, LineReferences, PathRedaction, SessionTitle) {
       "use strict";
       const DEFAULT_PANEL_STATE = {
         mode: "ask",
@@ -8446,6 +8594,9 @@ ${block}`;
           if (session.titleSource === "manual" && patch.titleSource !== "manual" && Object.prototype.hasOwnProperty.call(patch, "title")) {
             next.title = session.title;
             next.titleSource = "manual";
+          } else if (session.titleSource === "auto" && patch.titleSource !== "manual" && typeof patch.title === "string" && patch.title.trim() && session.runs?.length && SessionTitle.isGeneric(sanitizeAutoTitle(patch.title)) && !SessionTitle.isGeneric(sanitizeAutoTitle(session.title))) {
+            next.title = session.title;
+            next.titleSource = "auto";
           }
           return normalizeSession({
             ...next
@@ -8507,12 +8658,7 @@ ${block}`;
         }, sessions[0]);
       }
       function deriveSessionTitle(runs, task) {
-        const taskTitle = sanitizeAutoTitle(task);
-        if (taskTitle) {
-          return taskTitle;
-        }
-        const firstRunTask = Array.isArray(runs) && runs.length ? runs[0]?.task : "";
-        return sanitizeAutoTitle(firstRunTask);
+        return SessionTitle.derive(runs, task, { sanitize: sanitizeAssistantVisibleText, maxChars: SESSION_AUTO_TITLE_CHARS });
       }
       function renameSession(state, sessionId, rawTitle, options2 = {}) {
         const sessions = Array.isArray(state?.sessions) ? state.sessions : [];
@@ -8542,14 +8688,13 @@ ${block}`;
         if (titleSource === "manual") {
           return normalizeTextField(rawTitle === LEGACY_DEFAULT_SESSION_TITLE ? "" : rawTitle, STORAGE_DEFAULT_LIMITS.sessionTitleChars);
         }
-        return sanitizeAutoTitle(rawTitle === LEGACY_DEFAULT_SESSION_TITLE ? "" : rawTitle) || derivedTitle || "";
+        const current = sanitizeAutoTitle(rawTitle === LEGACY_DEFAULT_SESSION_TITLE ? "" : rawTitle);
+        if (!current || SessionTitle.isGeneric(current)) return derivedTitle || current || "";
+        if (current.endsWith("\u2026") && derivedTitle.startsWith(current.slice(0, -1))) return derivedTitle;
+        return current;
       }
       function sanitizeAutoTitle(value) {
-        const title = sanitizeAssistantVisibleText(value).replace(/@file:[^\s]+/g, " ").replace(/@(context|compile-log)\b/g, " ").replace(/\s+/g, " ").trim();
-        if (!title) {
-          return "";
-        }
-        return title.length > SESSION_AUTO_TITLE_CHARS ? `${title.slice(0, SESSION_AUTO_TITLE_CHARS - 1)}\u2026` : title;
+        return SessionTitle.fromPrompt(value, { sanitize: sanitizeAssistantVisibleText, maxChars: SESSION_AUTO_TITLE_CHARS });
       }
       function isDisplayableSession(session) {
         if (!session?.id) {
@@ -8637,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),
@@ -8654,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;
       }
@@ -9088,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),
@@ -9420,13 +9570,14 @@ ${block}`;
         setActiveSession,
         updateActiveSession,
         normalizeRuns,
+        normalizeProjectReferenceFiles,
         prepareStateForStorage,
         estimateJsonBytes,
         computeSafeTaskSummary
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule28(module, exports, require2) {
+  (function runClassicContentModule29(module, exports, require2) {
     (function initStorageKeys(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -9454,7 +9605,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule29(module, exports, require2) {
+  (function runClassicContentModule30(module, exports, require2) {
     (function initStaleGuard(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -9605,7 +9756,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule30(module, exports, require2) {
+  (function runClassicContentModule31(module, exports, require2) {
     (function initStorageRunActions(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -9660,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 {
@@ -9688,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",
@@ -9730,11 +9918,12 @@ ${block}`;
         compactRunsForStorage,
         compactRunActionPayload,
         compactProviderSnapshot,
+        compactRunExecutionSnapshot,
         hashString
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule31(module, exports, require2) {
+  (function runClassicContentModule32(module, exports, require2) {
     (function initStorageSessionClaims(root, factory) {
       var api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -9800,26 +9989,28 @@ ${block}`;
       return Object.freeze({ createSessionClaimer });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule32(module, exports, require2) {
+  (function runClassicContentModule33(module, exports, require2) {
     (function initStorageDb(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(
           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;
@@ -10087,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,
@@ -10126,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 : "";
@@ -10137,7 +10329,7 @@ ${block}`;
             task = firstRun.task;
           }
         }
-        return SessionState.computeSafeTaskSummary(task);
+        return SessionState2.computeSafeTaskSummary(task);
       }
       var _sessionStateCache = null;
       function loadSessionState() {
@@ -10422,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);
@@ -10436,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) : "",
@@ -10451,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)
@@ -11025,7 +11217,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule33(module, exports, require2) {
+  (function runClassicContentModule34(module, exports, require2) {
     (function initStorageMigration(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("./storageDb"));
@@ -11480,7 +11672,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule34(module, exports, require2) {
+  (function runClassicContentModule35(module, exports, require2) {
     (function initCompileAdapter(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -11623,7 +11815,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule35(module, exports, require2) {
+  (function runClassicContentModule36(module, exports, require2) {
     (function initCodexOverleafCompatibility(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -11637,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.5";
+      const BUILD_TARGET_VERSION = "2.4.0";
       const DEFAULT_CHROME_EXTENSION_ID = "illdpneeeopfffmiepaejglgmhpmdhdc";
       const REQUIRED_CAPABILITIES = Object.freeze([
         "bridgePing",
@@ -11933,14 +12125,14 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule36(module, exports, require2) {
+  (function runClassicContentModule37(module, exports, require2) {
     (function(root, factory) {
       var api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
       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"),
@@ -11957,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"),
@@ -12064,7 +12257,7 @@ ${block}`;
       });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule37(module, exports, require2) {
+  (function runClassicContentModule38(module, exports, require2) {
     (function initCodexOverleafManagedUpdateProjection(root) {
       "use strict";
       const PHASE_ALIASES = Object.freeze({
@@ -12090,7 +12283,7 @@ ${block}`;
         "deferred"
       ]);
       const PHASE_TIMEOUTS = Object.freeze({
-        checking: 30 * 1e3,
+        checking: 60 * 1e3,
         downloading: 2 * 60 * 1e3,
         applying: 90 * 1e3,
         awaiting_health: 2 * 60 * 1e3,
@@ -12370,7 +12563,7 @@ ${block}`;
       });
     })(typeof window !== "undefined" ? window : globalThis);
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule38(module, exports, require2) {
+  (function runClassicContentModule39(module, exports, require2) {
     (function initGovernanceRules(root, factory) {
       if (typeof module === "object" && module.exports) {
         let projectFiles = null;
@@ -12587,7 +12780,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule39(module, exports, require2) {
+  (function runClassicContentModule40(module, exports, require2) {
     (function initSensitiveScan(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -12697,7 +12890,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule40(module, exports, require2) {
+  (function runClassicContentModule41(module, exports, require2) {
     (function initAuditRecords(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -13223,7 +13416,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule41(module, exports, require2) {
+  (function runClassicContentModule42(module, exports, require2) {
     (function initCodexOverleafNativeChannel(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -13302,7 +13495,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule42(module, exports, require2) {
+  (function runClassicContentModule43(module, exports, require2) {
     (function initCodexOverleafPageBridgeClient(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -13325,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]
@@ -13505,7 +13700,7 @@ ${block}`;
       });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule43(module, exports, require2) {
+  (function runClassicContentModule44(module, exports, require2) {
     (function initCodexOverleafNativeCompatibilityController(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -13527,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)
           );
@@ -13784,7 +13981,7 @@ ${block}`;
       return Object.freeze({ create });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule44(module, exports, require2) {
+  (function runClassicContentModule45(module, exports, require2) {
     (function initCodexOverleafWritebackController(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -14049,7 +14246,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule45(module, exports, require2) {
+  (function runClassicContentModule46(module, exports, require2) {
     (function initCodexOverleafAssetTransferBroker(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -14180,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;
       }
@@ -14211,7 +14410,7 @@ ${block}`;
       return { create, mergeApplyResults };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule46(module, exports, require2) {
+  (function runClassicContentModule47(module, exports, require2) {
     (function initCodexOverleafReviewHunks(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -14430,7 +14629,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule47(module, exports, require2) {
+  (function runClassicContentModule48(module, exports, require2) {
     (function initCodexOverleafDiffReviewPanel(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("./reviewHunks"));
@@ -15157,7 +15356,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule48(module, exports, require2) {
+  (function runClassicContentModule49(module, exports, require2) {
     (function initCodexOverleafContextTray(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("../shared/projectFiles"));
@@ -15177,6 +15376,8 @@ ${block}`;
         saveState = null,
         saveStateSoon = () => {
         },
+        onProjectFilesReady = () => {
+        },
         updateActiveSession = defaultUpdateActiveSession,
         callPageBridge = () => Promise.resolve({ ok: false }),
         getCurrentProjectId = () => "",
@@ -15340,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 });
@@ -15361,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),
@@ -15418,6 +15621,7 @@ ${block}`;
             contextProject = project;
             setContextSyncState("exact-ready");
             renderContextFiles(project);
+            onProjectFilesReady(project);
           } catch (_error) {
             if (loadId === contextLoadId) {
               setContextSyncState("partial");
@@ -15905,7 +16109,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule49(module, exports, require2) {
+  (function runClassicContentModule50(module, exports, require2) {
     (function initCodexOverleafLocalSkillsPanel(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -16136,7 +16340,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule50(module, exports, require2) {
+  (function runClassicContentModule51(module, exports, require2) {
     (function initCodexOverleafRunController(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -16366,7 +16570,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule51(module, exports, require2) {
+  (function runClassicContentModule52(module, exports, require2) {
     (function initCodexOverleafMirrorHealth(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -16450,7 +16654,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule52(module, exports, require2) {
+  (function runClassicContentModule53(module, exports, require2) {
     (function initCodexOverleafOtWarmMirrorController(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -16462,6 +16666,12 @@ ${block}`;
       const OT_POLL_INTERVAL_MS = 1e3;
       const OT_PATCH_DEBOUNCE_MS = 500;
       const OT_MAX_PATCH_BATCH = 25;
+      const OT_FRESHNESS_MAX_AGE_MS = 3e4;
+      const OT_MAX_FILE_BYTES = 1024 * 1024;
+      const OT_MAX_PENDING_EVENTS = 64;
+      const OT_MAX_PENDING_BYTES = 4 * 1024 * 1024;
+      const OT_MAX_BATCH_BYTES = 2 * 1024 * 1024;
+      const encoder = typeof TextEncoder === "function" ? new TextEncoder() : null;
       const PAUSE_STATES = /* @__PURE__ */ new Set(["running", "writing", "undoing", "compiling"]);
       function buildPatchFilesRequest({ projectId, events, nativeCompatibility } = {}) {
         const files = [];
@@ -16513,13 +16723,14 @@ ${block}`;
         }
         return { pause: false };
       }
-      function canUseOtWarmStart({ enabled, focusFiles, mirrorStatus } = {}) {
+      function canUseOtWarmStart({ enabled, focusFiles, mirrorStatus, now = Date.now() } = {}) {
         if (!enabled) {
           return { ok: false, reason: "disabled" };
         }
         if (!mirrorStatus || mirrorStatus.exists !== true) {
           return { ok: false, reason: "mirror_missing" };
         }
+        if (mirrorStatus.dirty === true) return { ok: false, reason: "mirror_dirty" };
         const normalizedFocusFiles = normalizePaths(focusFiles);
         if (!normalizedFocusFiles.length) {
           return { ok: false, reason: "no_focus_files" };
@@ -16529,6 +16740,8 @@ ${block}`;
           if (file?.state !== "fresh") {
             continue;
           }
+          const age = now - Date.parse(file.observedAt ?? file.lastPatchAt ?? "");
+          if (!Number.isFinite(age) || age < 0 || age > OT_FRESHNESS_MAX_AGE_MS) continue;
           const filePath = normalizePath(file.path);
           if (filePath) {
             freshFiles.add(filePath);
@@ -16544,6 +16757,102 @@ ${block}`;
         }
         return { ok: false, reason: "missing_ot_fresh_focus" };
       }
+      function textBytes(value) {
+        const text = String(value || "");
+        return encoder ? encoder.encode(text).byteLength : text.length * 3;
+      }
+      function patchBytes(event) {
+        return textBytes(event.nextContent) + textBytes(event.path) + 512;
+      }
+      function queuePatchEvents(queue, events, now = Date.now()) {
+        if (!Array.isArray(events) || events.length > OT_MAX_PENDING_EVENTS) return { ok: false, reason: "ot_queue_limit" };
+        const next = Array.isArray(queue) ? queue.slice() : [];
+        let bytes = next.reduce((sum, event) => sum + patchBytes(event), 0);
+        if (next.length > OT_MAX_PENDING_EVENTS || bytes > OT_MAX_PENDING_BYTES) return { ok: false, reason: "ot_queue_limit" };
+        for (const input of events) {
+          const path = normalizePath(input?.path);
+          const time = typeof input?.observedAt === "number" ? input.observedAt : Date.parse(input?.observedAt || "");
+          if (!isSafeRelativePath(path) || path.length > 1024 || typeof input?.nextContent !== "string" || typeof input.baseHash !== "string" || !input.baseHash || input.baseHash.length > 128) {
+            return { ok: false, reason: "ot_event_invalid" };
+          }
+          if (!Number.isFinite(time) || now - time < 0 || now - time > OT_FRESHNESS_MAX_AGE_MS) return { ok: false, reason: "ot_event_expired" };
+          if (textBytes(input.nextContent) > OT_MAX_FILE_BYTES) return { ok: false, reason: "ot_file_limit" };
+          const event = {
+            path,
+            baseHash: input.baseHash,
+            nextContent: input.nextContent,
+            nextHash: typeof input.nextHash === "string" && input.nextHash.length <= 128 ? input.nextHash : "",
+            observedAt: new Date(time).toISOString()
+          };
+          if (isPrimitiveMetadata(input.observedVersion) && String(input.observedVersion).length <= 128) event.observedVersion = input.observedVersion;
+          const tail = next[next.length - 1];
+          if (tail?.path === path && tail.nextHash && tail.nextHash === event.baseHash) {
+            event.baseHash = tail.baseHash;
+            bytes -= patchBytes(next.pop());
+          }
+          if (event.nextHash !== event.baseHash) {
+            next.push(event);
+            bytes += patchBytes(event);
+          }
+          if (next.length > OT_MAX_PENDING_EVENTS || bytes > OT_MAX_PENDING_BYTES) return { ok: false, reason: "ot_queue_limit" };
+        }
+        return { ok: true, queue: next, bytes };
+      }
+      function takePatchBatch(queue) {
+        let bytes = 0;
+        let count = 0;
+        while (count < Math.min(queue.length, OT_MAX_PATCH_BATCH)) {
+          const size = patchBytes(queue[count]);
+          if (bytes + size > OT_MAX_BATCH_BYTES) break;
+          bytes += size;
+          count += 1;
+        }
+        return queue.splice(0, count);
+      }
+      function validatePatchReceipt(events, result = {}, now = Date.now()) {
+        if (Array.isArray(result.skippedFiles) && result.skippedFiles.length || Number(result.skippedCount || 0) > 0) {
+          return { ok: false, reason: "mirror_patch_skipped" };
+        }
+        if (!events.length || Number(result.appliedCount) !== events.length || !Array.isArray(result.appliedFiles) || result.appliedFiles.length !== events.length || !result.appliedFiles.every((file, index) => normalizePath(file?.path) === events[index].path && (!events[index].nextHash || file.hash === events[index].nextHash))) {
+          return { ok: false, reason: "mirror_patch_invalid_result" };
+        }
+        if (events.some((event) => {
+          const time = Date.parse(event.observedAt);
+          return !Number.isFinite(time) || time > now || now - time > OT_FRESHNESS_MAX_AGE_MS;
+        })) 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;
+        if (/page bridge|capability|bridge timed out/i.test(String(code || ""))) return "ot_bridge_unavailable";
+        return fallback;
+      }
+      function getFailureMessageKey(value) {
+        const code = normalizeFailureCode(value);
+        if (/bridge|ot_status|ot_events/.test(code)) return "otFailureBridge";
+        if (/missing_ot_text|observer_create|observer_unavailable/.test(code)) return "otFailureObserver";
+        if (code === "ot_file_limit") return "otFailureFileLimit";
+        if (code === "ot_queue_limit") return "otFailureQueueLimit";
+        if (code === "ot_event_expired") return "otFailureExpired";
+        if (/editor|active_path|document/.test(code)) return "otFailureEditor";
+        if (/mirror|hash|baseline/.test(code)) return "otFailureMirror";
+        return "otFailureGeneric";
+      }
       function normalizePath(value) {
         return String(value ?? "").trim().replace(/^@file:/i, "").trim().replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\/+/, "");
       }
@@ -16595,6 +16904,19 @@ ${block}`;
         OT_POLL_INTERVAL_MS,
         OT_PATCH_DEBOUNCE_MS,
         OT_MAX_PATCH_BATCH,
+        OT_FRESHNESS_MAX_AGE_MS,
+        OT_MAX_FILE_BYTES,
+        OT_MAX_PENDING_EVENTS,
+        OT_MAX_PENDING_BYTES,
+        OT_MAX_BATCH_BYTES,
+        queuePatchEvents,
+        takePatchBatch,
+        validatePatchReceipt,
+        normalizeFailureCode,
+        readOtBridgeStatus,
+        readOtBridgeEvents,
+        readOtBridgeErrorCode,
+        getFailureMessageKey,
         buildPatchFilesRequest,
         canUseOtWarmStart,
         normalizePath,
@@ -16603,7 +16925,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule53(module, exports, require2) {
+  (function runClassicContentModule54(module, exports, require2) {
     (function initComposerAttachments(global) {
       "use strict";
       function createComposerAttachmentController(options2 = {}) {
@@ -17063,7 +17385,7 @@ ${block}`;
       };
     })(window);
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule54(module, exports, require2) {
+  (function runClassicContentModule55(module, exports, require2) {
     (function initCodexOverleafPanelRenderer() {
       "use strict";
       const ROOT_CLASS = "codex-overleaf-panel-mounted";
@@ -17464,7 +17786,7 @@ ${block}`;
       };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule55(module, exports, require2) {
+  (function runClassicContentModule56(module, exports, require2) {
     (function initCodexOverleafSessionPanel() {
       "use strict";
       function create(options2 = {}) {
@@ -17700,7 +18022,7 @@ ${block}`;
       };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule56(module, exports, require2) {
+  (function runClassicContentModule57(module, exports, require2) {
     (function initCodexOverleafSettingsPanel() {
       "use strict";
       function codexIcon(name) {
@@ -17794,18 +18116,18 @@ ${block}`;
           </details>
           <details class="codex-set-group" data-set-group="experimental">
             <summary class="codex-set-group-head">
-              <span class="codex-set-group-title">${codexSetIcon("flask")}<span data-i18n="experimentalTitle">Experimental</span></span>
+              <span class="codex-set-group-title">${codexSetIcon("database")}<span data-i18n="otSettingsTitle">Project cache</span></span>
               <span class="codex-set-saved" data-set-saved hidden>\u2713 <span data-i18n="settingsSaved">Saved</span></span>
             </summary>
             <div class="codex-set-card">
               <label class="codex-project-settings-row codex-project-settings-row--switch">
                 <span class="codex-project-settings-row-label">
-                  <span data-i18n="experimentalOtMenuTitle">Experimental OT Mirror</span>
-                  <small class="codex-set-row-sub" data-i18n="experimentalOtMenuSubtitle">Experimental \u2014 speeds up reading the file you are editing; Codex falls back to normal reading whenever unsure.</small>
+                  <span data-i18n="experimentalOtMenuTitle">OT Mirror</span>
+                  <small class="codex-set-row-sub" data-i18n="experimentalOtMenuSubtitle">Warms recent edits to the active text file locally. File scope and freshness are checked before reuse.</small>
                 </span>
                 <input type="checkbox" class="codex-switch" data-experimental-ot>
               </label>
-              <p class="codex-set-row-help" data-experimental-ot-menu-status></p>
+              <p class="codex-set-row-help" data-experimental-ot-menu-status aria-live="polite"></p>
             </div>
           </details>
         </div>
@@ -17858,17 +18180,25 @@ ${block}`;
               <button type="button" class="codex-set-btn" data-provider-settings-open data-i18n="providerSettingsConfigure">Configure</button>
             </div>
           </details>
+          <details class="codex-set-group" data-set-group="context-loading" open>
+            <summary class="codex-set-group-head">
+              <span class="codex-set-group-title">${codexSetIcon("database")}<span data-i18n="contextLoadingTitle">Context loading</span></span>
+              <span class="codex-set-saved" data-set-saved hidden>\u2713 <span data-i18n="settingsSaved">Saved</span></span>
+            </summary>
+            <div class="codex-set-card">
+              <label class="codex-project-settings-row codex-project-settings-row--switch">
+                <span class="codex-project-settings-row-label" data-i18n="preloadProjectContextTitle">Preload project context</span>
+                <input type="checkbox" class="codex-switch" data-preload-project-context>
+              </label>
+              <p class="codex-set-row-help" data-i18n="preloadProjectContextDescription">Fetch the exact project file list in the background after an Overleaf project becomes idle.</p>
+            </div>
+          </details>
           <details class="codex-set-group" data-set-group="updates" open>
             <summary class="codex-set-group-head">
               <span class="codex-set-group-title">${codexSetIcon("software")}<span data-i18n="softwareUpdatesTitle">Software updates</span></span>
             </summary>
             <div class="codex-set-card" data-update-settings>
               <div class="codex-set-row">
-                <label class="codex-project-settings-row codex-project-settings-row--switch">
-                  <span class="codex-project-settings-row-label" data-i18n="preloadProjectContextTitle">Preload project context</span>
-                  <input type="checkbox" class="codex-switch" data-preload-project-context>
-                </label>
-                <p class="codex-set-row-help" data-i18n="preloadProjectContextDescription">Fetch the exact project file list in the background after an Overleaf project becomes idle.</p>
                 <p class="codex-set-row-help" data-update-settings-summary data-i18n="softwareUpdatesHelp">Automatically checks signed stable releases for the Extension and Native Host.</p>
                 <p class="codex-set-note" data-update-settings-state aria-live="polite" hidden></p>
                 <button type="button" class="codex-set-btn" data-check-updates data-i18n="checkForUpdates">Check for updates</button>
@@ -17933,6 +18263,9 @@ ${block}`;
             instance.callbacks.onHistoryOpen?.();
           }
         });
+        container.querySelector("[data-storage-card]")?.addEventListener("toggle", (event) => {
+          if (event.target.open) instance.callbacks.onStorageOpen?.();
+        });
         container.querySelector("[data-history-filter]")?.addEventListener("input", () => instance.callbacks.onHistoryFilter?.());
         container.querySelector("[data-experimental-ot]")?.addEventListener("click", (event) => instance.callbacks.onOtToggleClick?.(event));
         const customInstructionsInput = container.querySelector("[data-custom-instructions-input]");
@@ -17943,7 +18276,12 @@ ${block}`;
         for (const selector of ["[data-governance-readonly-patterns]", "[data-governance-writable-patterns]", "[data-sensitive-check-enabled]", "[data-sensitive-confirm-allowed]", "[data-preload-project-context]", "[data-load-codex-local-skills]", "[data-load-codex-overleaf-skills]", "[data-theme-select]", "[data-language-select]"]) {
           const element = container.querySelector(selector);
           element?.addEventListener?.("change", (event) => {
-            Promise.resolve(instance.callbacks.onInputChange?.(event)).then(() => flashSaved(instance, event)).catch(() => {
+            Promise.resolve(instance.callbacks.onInputChange?.(event)).then(() => {
+              flashSaved(instance, event);
+              if (selector === "[data-language-select]" && container.querySelector("[data-storage-card]")?.open) {
+                instance.callbacks.onStorageOpen?.();
+              }
+            }).catch(() => {
             });
           });
           element?.addEventListener?.("input", (event) => {
@@ -17958,6 +18296,9 @@ ${block}`;
         }
         setupGroupPersistence(instance);
         return {
+          get container() {
+            return instance.container;
+          },
           show: () => show(instance),
           hide: () => hide(instance),
           loadState: (state) => loadState(instance, state),
@@ -18218,7 +18559,7 @@ ${block}`;
       };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule57(module, exports, require2) {
+  (function runClassicContentModule58(module, exports, require2) {
     (function initCodexOverleafProviderSettingsDialog() {
       "use strict";
       const CODEX_BLOSSOM_PATH = "M13.798 23.976a5.7 5.7 0 0 1-2.26-.456 6.1 6.1 0 0 1-1.903-1.27 5.7 5.7 0 0 1-1.88.311 5.75 5.75 0 0 1-2.95-.79 6.2 6.2 0 0 1-2.188-2.159q-.81-1.366-.809-3.045 0-.695.19-1.51a6.4 6.4 0 0 1-1.475-2.038A5.95 5.95 0 0 1 0 10.573Q0 9.278.547 8.08q.547-1.2 1.523-2.062a5.5 5.5 0 0 1 2.307-1.223A5.7 5.7 0 0 1 5.472 2.35 6.1 6.1 0 0 1 7.565.623 5.8 5.8 0 0 1 10.206 0q1.19 0 2.26.456a6.1 6.1 0 0 1 1.903 1.27 5.7 5.7 0 0 1 1.88-.311q1.594 0 2.95.79a6 6 0 0 1 2.165 2.159q.832 1.366.832 3.045 0 .695-.19 1.51a6.3 6.3 0 0 1 1.475 2.062q.523 1.15.523 2.422a5.9 5.9 0 0 1-.547 2.493q-.547 1.2-1.546 2.086a5.4 5.4 0 0 1-2.284 1.199 5.56 5.56 0 0 1-1.118 2.445 5.9 5.9 0 0 1-2.07 1.727 5.8 5.8 0 0 1-2.64.623m-5.876-2.997q1.19 0 2.07-.504l4.472-2.589a.53.53 0 0 0 .238-.455v-2.062L8.945 18.7a.96.96 0 0 1-1.047 0l-4.496-2.613a.7.7 0 0 1-.024.168v.287q0 1.224.571 2.254a4.24 4.24 0 0 0 1.642 1.583q1.047.6 2.331.599m.238-3.908a.6.6 0 0 0 .262.072q.118 0 .238-.072l1.784-1.031-5.734-3.357q-.522-.312-.523-.935V6.545a4.3 4.3 0 0 0-1.903 1.63 4.25 4.25 0 0 0-.714 2.398q0 1.176.595 2.254.594 1.08 1.546 1.63zm5.638 5.323q1.26 0 2.284-.576a4.3 4.3 0 0 0 1.618-1.582q.595-1.008.595-2.254v-5.179a.47.47 0 0 0-.238-.431l-1.808-1.055v6.689q0 .624-.524.935l-4.496 2.613a4.3 4.3 0 0 0 2.57.84m.904-8.776v-3.26l-2.688-1.535-2.712 1.535v3.26l2.712 1.535zM7.756 5.97q0-.623.523-.935l4.496-2.613a4.3 4.3 0 0 0-2.569-.84q-1.26 0-2.284.576A4.3 4.3 0 0 0 6.304 3.74q-.57 1.008-.57 2.254v5.155q0 .287.237.455l1.785 1.055zM19.84 17.43a4.16 4.16 0 0 0 1.88-1.63 4.33 4.33 0 0 0 .713-2.397q0-1.176-.595-2.254-.594-1.08-1.546-1.63l-4.449-2.59q-.143-.096-.261-.072a.46.46 0 0 0-.238.072L13.56 7.936l5.758 3.38a.9.9 0 0 1 .38.384q.143.216.143.528zM15.059 5.25q.524-.335 1.047 0l4.52 2.662V7.48q0-1.15-.57-2.181A4.14 4.14 0 0 0 18.46 3.62q-1.023-.623-2.379-.623-1.19 0-2.07.503L9.54 6.09a.53.53 0 0 0-.238.455v2.062z";
@@ -19152,7 +19493,7 @@ ${block}`;
       window.CodexOverleafProviderSettingsDialog = { create, getFooterActionState };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule58(module, exports, require2) {
+  (function runClassicContentModule59(module, exports, require2) {
     (function initCodexOverleafProjectProviderSelection() {
       "use strict";
       function create(deps = {}) {
@@ -19209,7 +19550,7 @@ ${block}`;
       window.CodexOverleafProjectProviderSelection = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule59(module, exports, require2) {
+  (function runClassicContentModule60(module, exports, require2) {
     (function initCodexOverleafProviderSettingsCoordinator() {
       "use strict";
       function create(options2 = {}) {
@@ -19273,6 +19614,7 @@ ${block}`;
         return {
           open: () => open(instance),
           refreshSummary: () => refreshSummary(instance),
+          renderSummary: () => updateSettingsSummary(instance),
           ensureLoaded: () => ensureLoaded(instance),
           getRunSelection: (providerId) => instance.loaded ? Profiles.buildRunSelection(instance.catalog, providerId || instance.getSelectedProviderId()) : null,
           getProviderSnapshot: (providerId) => getProviderSnapshot(instance, providerId),
@@ -19819,7 +20161,7 @@ ${block}`;
       window.CodexOverleafProviderSettingsCoordinator = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule60(module, exports, require2) {
+  (function runClassicContentModule61(module, exports, require2) {
     (function initCodexOverleafSessionPersistence(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("../shared/storageMigration"));
@@ -19913,7 +20255,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule61(module, exports, require2) {
+  (function runClassicContentModule62(module, exports, require2) {
     (function(root, factory) {
       var api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -20017,7 +20359,7 @@ ${block}`;
       return Object.freeze({ persistPanelState });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule62(module, exports, require2) {
+  (function runClassicContentModule63(module, exports, require2) {
     (function(root, factory) {
       var api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -20062,7 +20404,7 @@ ${block}`;
       return Object.freeze({ create });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule63(module, exports, require2) {
+  (function runClassicContentModule64(module, exports, require2) {
     (function(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(
@@ -20157,7 +20499,7 @@ ${block}`;
       });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule64(module, exports, require2) {
+  (function runClassicContentModule65(module, exports, require2) {
     (function initCodexOverleafDiagnosticsPanel() {
       "use strict";
       function create(options2 = {}) {
@@ -20169,7 +20511,8 @@ ${block}`;
           container,
           callbacks: options2.callbacks || {},
           i18n: options2.i18n || {},
-          dismissInstalled: false
+          dismissInstalled: false,
+          cleanup: []
         };
         container.innerHTML = `
       <div class="codex-diagnostics-wrap">
@@ -20196,7 +20539,7 @@ ${block}`;
             <small data-i18n="diagnosticsSnapshotSubtitle">Full project, assets, read source</small>
           </button>
           <button type="button" data-diagnostics-ot>
-            <span data-i18n="diagnosticsOtTitle">Check Experimental OT Mirror</span>
+            <span data-i18n="diagnosticsOtTitle">Check OT Mirror</span>
             <small data-i18n="diagnosticsOtSubtitle">Status, fresh files, fallback</small>
           </button>
           <button type="button" data-diagnostics-export>
@@ -20253,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");
       }
@@ -20263,7 +20611,7 @@ ${block}`;
         if (!popover || !button) {
           return;
         }
-        popover.hidden = true;
+        hideFloating(popover);
         button.dataset.active = "false";
         button.setAttribute("aria-expanded", "false");
       }
@@ -20271,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) {
@@ -20327,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");
@@ -20401,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 = {}) {
@@ -20564,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 = {
@@ -20585,7 +21043,7 @@ ${block}`;
       };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule65(module, exports, require2) {
+  (function runClassicContentModule66(module, exports, require2) {
     (function initCodexOverleafRunQueueScheduler(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("../shared/runInputQueue"));
@@ -20913,7 +21371,7 @@ ${block}`;
       return { create, createCoordinator };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule66(module, exports, require2) {
+  (function runClassicContentModule67(module, exports, require2) {
     (function initCodexOverleafActiveTurnControl(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -21031,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;
@@ -21082,7 +21541,7 @@ ${block}`;
       return { create };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule67(module, exports, require2) {
+  (function runClassicContentModule68(module, exports, require2) {
     (function initCodexOverleafPendingInputView(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -21184,7 +21643,7 @@ ${block}`;
       return { create };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule68(module, exports, require2) {
+  (function runClassicContentModule69(module, exports, require2) {
     (function initCodexOverleafComposerPanel() {
       "use strict";
       function create(options2 = {}) {
@@ -21443,7 +21902,7 @@ ${block}`;
       };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule69(module, exports, require2) {
+  (function runClassicContentModule70(module, exports, require2) {
     (function initCodexOverleafTheme(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory();
@@ -21514,7 +21973,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule70(module, exports, require2) {
+  (function runClassicContentModule71(module, exports, require2) {
     !(function(e, t) {
       "object" == typeof exports && "object" == typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define([], t) : "object" == typeof exports ? exports.katex = t() : e.katex = t();
     })("undefined" != typeof self ? self : this, function() {
@@ -24934,7 +25393,7 @@ ${block}`;
       })();
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule71(module, exports, require2) {
+  (function runClassicContentModule72(module, exports, require2) {
     !(function(t, e) {
       "object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define([], e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).markdownit = e();
     })(this, function() {
@@ -27006,7 +27465,7 @@ ${block}`;
       }, Ke;
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule72(module, exports, require2) {
+  (function runClassicContentModule73(module, exports, require2) {
     (function initCodexOverleafMathText(root) {
       "use strict";
       const DELIMITERS = Object.freeze([
@@ -27391,7 +27850,7 @@ ${block}`;
       }
     })(typeof window !== "undefined" ? window : globalThis);
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule73(module, exports, require2) {
+  (function runClassicContentModule74(module, exports, require2) {
     (function initCodexOverleafMarkdownDomRenderer(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) {
@@ -27879,7 +28338,7 @@ ${block}`;
       };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule74(module, exports, require2) {
+  (function runClassicContentModule75(module, exports, require2) {
     (function initCodexOverleafMarkdownText() {
       "use strict";
       function create(deps = {}) {
@@ -28506,7 +28965,7 @@ ${block}`;
       window.CodexOverleafMarkdownText = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule75(module, exports, require2) {
+  (function runClassicContentModule76(module, exports, require2) {
     (function initCodexOverleafDiagnosticsController() {
       "use strict";
       function create(deps = {}) {
@@ -28823,6 +29282,16 @@ ${block}`;
               nextStep: "",
               technical: ""
             };
+            const mirrorState = getOtWarmMirrorState?.() || {};
+            if (mirrorState.failureActive && mirrorState.lastFailure) {
+              const failure = mirrorState.lastFailure;
+              disabledResult.status = "warning";
+              disabledResult.summary = tr(otWarmMirrorController.getFailureMessageKey(failure.code));
+              disabledResult.nextStep = tr("otFailureNextStep");
+              disabledResult.technical = `lastErrorCode: ${failure.code}
+phase: ${failure.phase}
+failedAt: ${new Date(failure.at).toISOString()}`;
+            }
             if (options2.collectOnly) {
               return disabledResult;
             }
@@ -28877,6 +29346,7 @@ ${block}`;
           const queuedEventCount = normalizeOtDiagnosticsCount(otStatus?.queuedEventCount);
           const lastEventAt = formatOtDiagnosticValue(otStatus?.lastEventAt, tr("noneValue"));
           const warmMirrorState = getOtWarmMirrorState() || {};
+          const failureActive = warmMirrorState.failureActive === true;
           const lastOtPatchAt = formatOtDiagnosticValue(mirrorStatus?.lastOtPatchAt || warmMirrorState.lastPatchAt, tr("noneValue"));
           const lastOtErrorCode = formatOtDiagnosticValue(mirrorStatus?.lastOtErrorCode || warmMirrorState.lastErrorCode, tr("noneValue"));
           const lastErrorCode = formatOtDiagnosticValue(otStatus?.lastErrorCode || otStatus?.reason || otStatus?.error, tr("noneValue"));
@@ -28888,12 +29358,12 @@ ${block}`;
           const bridgeFailed = otStatus?.ok === false;
           const focusFiles = getActiveFocusFiles();
           const otWarmStart = otWarmMirrorController?.canUseOtWarmStart?.({ enabled, focusFiles, mirrorStatus }) || { ok: false };
-          const fallback = !enabled || statusValue !== "observing" || bridgeFailed || otWarmStart?.ok !== true;
+          const fallback = !enabled || failureActive || statusValue !== "observing" || bridgeFailed || otWarmStart?.ok !== true;
           return {
             title: tr("diagnosticsOtTitle"),
             subtitle: tr("diagnosticsOtSubtitle"),
             status: enabled && !fallback && !bridgeFailed ? "completed" : enabled || bridgeFailed ? "warning" : "completed",
-            summary: tr(enabled ? "diagnosticsOtSummaryEnabled" : "diagnosticsOtSummaryDisabled"),
+            summary: tr(failureActive ? otWarmMirrorController.getFailureMessageKey(warmMirrorState.lastErrorCode) : enabled ? "diagnosticsOtSummaryEnabled" : "diagnosticsOtSummaryDisabled"),
             bullets: [
               `${tr("otStatus")}: ${formatOtStatusLabel(statusValue)}`,
               `${tr("otFreshFiles")}: ${otFreshFileCount}`,
@@ -29052,6 +29522,8 @@ ${block}`;
               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"}`);
@@ -29075,7 +29547,7 @@ ${block}`;
       window.CodexOverleafDiagnosticsController = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule76(module, exports, require2) {
+  (function runClassicContentModule77(module, exports, require2) {
     (function initCodexOverleafRunGuidanceView() {
       "use strict";
       const LEGACY_GUIDANCE_TITLES = /* @__PURE__ */ new Set([
@@ -29115,7 +29587,7 @@ ${block}`;
       };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule77(module, exports, require2) {
+  (function runClassicContentModule78(module, exports, require2) {
     (function initCodexOverleafRunGuidanceController() {
       "use strict";
       function create(deps = {}) {
@@ -29178,7 +29650,7 @@ ${block}`;
       window.CodexOverleafRunGuidanceController = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule78(module, exports, require2) {
+  (function runClassicContentModule79(module, exports, require2) {
     (function initCodexOverleafRunResultActions(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -29278,18 +29750,239 @@ ${block}`;
           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 });
+    });
+  }).call(globalThis, void 0, void 0, void 0);
+  (function runClassicContentModule80(module, exports, require2) {
+    (function initRunScrollLayout(root, factory) {
+      if (typeof module === "object" && module.exports) {
+        module.exports = factory();
+      } else {
+        root.CodexOverleafModuleRegistry.define("RunScrollLayout", [], factory);
+      }
+    })(typeof window !== "undefined" ? window : globalThis, function runScrollLayoutFactory() {
+      "use strict";
+      const READING_ANCHORS = ".run-final-answer p, .run-final-answer li, .run-final-answer pre, .run-final-answer h1, .run-final-answer h2, .run-final-answer h3, .run-stream p, .run-stream li, .run-stream pre, [data-run-task], [data-run-status]";
+      function create({ getScroller, onLayoutChange, isFollowing = () => true, window: host = globalThis } = {}) {
+        let current = null;
+        let resizeObserver = null;
+        let mutationObserver = null;
+        let anchor = null;
+        let extent = "";
+        function measure() {
+          return current ? `${current.scrollHeight}:${current.clientHeight}` : "";
+        }
+        function captureAnchor(force = false) {
+          if (!current || isFollowing()) {
+            anchor = null;
+            return;
+          }
+          if (!force && extent !== measure()) return;
+          const bounds = current.getBoundingClientRect?.();
+          if (!bounds) return;
+          const nodes = current.querySelectorAll?.(READING_ANCHORS) || [];
+          anchor = null;
+          for (const node of nodes) {
+            const rect = node.getBoundingClientRect();
+            if (rect.height > 0 && rect.bottom > bounds.top && rect.top < bounds.bottom) {
+              anchor = { node, offset: rect.top - bounds.top };
+              break;
+            }
+          }
+        }
+        function restoreAnchor() {
+          if (isFollowing() || !anchor || !current.contains?.(anchor.node)) return;
+          const rect = anchor.node.getBoundingClientRect();
+          if (!rect.height) return;
+          const delta = rect.top - current.getBoundingClientRect().top - anchor.offset;
+          if (Math.abs(delta) > 0.5) current.scrollTop += delta;
+        }
+        function snapshot() {
+          captureAnchor();
+          const run = anchor?.node.closest?.("[data-run-id]");
+          return {
+            scrollTop: current?.scrollTop || 0,
+            runId: run?.dataset?.runId || "",
+            index: run ? Array.from(run.querySelectorAll(READING_ANCHORS)).indexOf(anchor.node) : -1,
+            offset: anchor?.offset || 0
+          };
+        }
+        function restore(reading) {
+          if (!current || !reading) return;
+          current.scrollTop = reading.scrollTop;
+          const run = Array.from(current.querySelectorAll?.("[data-run-id]") || []).find((node2) => node2.dataset.runId === reading.runId);
+          const node = run?.querySelectorAll(READING_ANCHORS)[reading.index];
+          anchor = node ? { node, offset: reading.offset } : null;
+          restoreAnchor();
+          extent = measure();
+          captureAnchor(true);
+        }
+        function dispose() {
+          resizeObserver?.disconnect();
+          mutationObserver?.disconnect();
+          resizeObserver = null;
+          mutationObserver = null;
+          current = null;
+          anchor = null;
+          extent = "";
+        }
+        function notify() {
+          if (!current) return;
+          const active = getScroller();
+          if (active !== current) {
+            bind(active);
+            return;
+          }
+          restoreAnchor();
+          extent = measure();
+          onLayoutChange(current);
+          captureAnchor(true);
+        }
+        function bind(scroller) {
+          if (scroller === current) return;
+          dispose();
+          if (!scroller || typeof host.ResizeObserver !== "function") return;
+          current = scroller;
+          extent = measure();
+          captureAnchor(true);
+          resizeObserver = new host.ResizeObserver(notify);
+          resizeObserver.observe(scroller);
+          for (const child of scroller.children || []) resizeObserver.observe(child);
+          if (typeof host.MutationObserver === "function") {
+            mutationObserver = new host.MutationObserver((records) => {
+              if (current !== scroller) return;
+              for (const record of records) {
+                for (const node of record.removedNodes) {
+                  if (node.nodeType === 1) resizeObserver.unobserve(node);
+                }
+                for (const node of record.addedNodes) {
+                  if (node.nodeType === 1) resizeObserver.observe(node);
+                }
+              }
+              notify();
+            });
+            mutationObserver.observe(scroller, { childList: true });
+          }
+        }
+        return Object.freeze({ bind, dispose, captureAnchor, snapshot, restore });
       }
       return Object.freeze({ create });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule79(module, exports, require2) {
+  (function runClassicContentModule81(module, exports, require2) {
+    (function initRunFailureNotice(root, factory) {
+      if (typeof module === "object" && module.exports) {
+        module.exports = factory();
+      } else {
+        root.CodexOverleafModuleRegistry.define("RunFailureNotice", [], factory);
+      }
+    })(typeof window !== "undefined" ? window : globalThis, function runFailureNoticeFactory() {
+      "use strict";
+      const REVIEW_CODES = /* @__PURE__ */ new Set(["write_timeout", "partial_write_needs_review"]);
+      const CANCEL_CODES = /* @__PURE__ */ new Set(["cancelled", "user_cancelled", "codex_cancelled"]);
+      function create({
+        tr,
+        projectRunSettlement,
+        sanitizeText = (value) => value,
+        document: documentRef = globalThis.document
+      } = {}) {
+        const notices = /* @__PURE__ */ new WeakMap();
+        function append(report, event = {}, run = {}) {
+          const projection = typeof projectRunSettlement === "function" && run ? projectRunSettlement(run) : null;
+          const failure = projection?.primaryFailure || event.failure;
+          if (report.dataset.status === "cancelled" || CANCEL_CODES.has(failure?.code)) return;
+          const facts = run?.settlement || run?.settlementFacts || {};
+          const unconfirmed = REVIEW_CODES.has(failure?.code) || facts.documentEffect === "possibly-changed" || facts.evidence?.applied === "unknown" && facts.evidence?.settled === "needs-review";
+          const partial = facts.evidence?.applied === "partial" || run?.partialWriteback === true;
+          if (!failure && !unconfirmed && !partial && report.dataset.status !== "failed") return;
+          const notice = documentRef.createElement("aside");
+          notice.className = "run-feedback";
+          notice.dataset.tone = unconfirmed || partial || failure?.terminalState === "degraded" || failure?.terminalState === "needs_review" ? "warning" : "error";
+          notice.setAttribute("role", "note");
+          const heading = documentRef.createElement("strong");
+          heading.className = "run-feedback__title";
+          heading.textContent = tr(unconfirmed ? "runFeedbackUnconfirmedTitle" : partial ? "runFeedbackPartialTitle" : "runFeedbackFailedTitle");
+          const message = documentRef.createElement("p");
+          const detail = typeof failure?.userMessage === "string" ? failure.userMessage : "";
+          const file = safeProjectPath(failure?.file);
+          message.textContent = sanitizeText([file, detail].filter(Boolean).join(": ").slice(0, 1e3)) || tr("runFeedbackGeneric");
+          notice.append(heading, message);
+          if (unconfirmed) {
+            const warning = documentRef.createElement("p");
+            warning.textContent = tr("runFeedbackUnconfirmed");
+            notice.append(warning);
+          }
+          notices.set(report, { notice, unconfirmed, failure, file });
+          report.append(notice);
+        }
+        function formatMetaValue(report, row) {
+          if (!notices.get(report)?.unconfirmed) return row.value;
+          const key = String(row.key || "").toLowerCase().replace(/[^a-z]/g, "");
+          const label = String(row.label || "").trim().toLowerCase();
+          if (key === "writeresult" || key === "next" || ["write result", "next", "\u5199\u5165\u7ED3\u679C", "\u4E0B\u4E00\u6B65"].includes(label)) {
+            return tr("runFeedbackUnconfirmedResult");
+          }
+          return row.value;
+        }
+        function prepareRecovery(report, { openFile } = {}) {
+          const info = notices.get(report);
+          const target = info?.notice || report;
+          if (!info?.unconfirmed) return { target, handled: false };
+          const canOpen = Boolean(info.file && typeof openFile === "function");
+          const button = documentRef.createElement("button");
+          button.type = "button";
+          button.className = "run-final-answer__recovery-action";
+          button.dataset.recoveryFor = info.failure?.code || "write_unconfirmed";
+          button.textContent = tr(canOpen ? "runFeedbackReviewFile" : "runFeedbackReviewDetails", { file: info.file });
+          button.addEventListener("click", (event) => {
+            event.stopPropagation();
+            if (canOpen) {
+              openFile(info.file);
+              return;
+            }
+            const process = report.closest?.("[data-run-id]")?.querySelector?.("[data-run-process]");
+            if (process) {
+              process.open = true;
+              process.scrollIntoView?.({ block: "nearest" });
+            } else {
+              button.disabled = true;
+              button.title = tr("runFeedbackDetailsUnavailable");
+            }
+          });
+          target.append(button);
+          return { target, handled: true };
+        }
+        return Object.freeze({ append, formatMetaValue, prepareRecovery });
+      }
+      function safeProjectPath(value) {
+        if (typeof value !== "string") return "";
+        const path = value.replace(/\\/g, "/");
+        return path && !path.startsWith("/") && !/^[A-Za-z]:/.test(path) && !path.split("/").includes("..") ? path.slice(0, 300) : "";
+      }
+      return Object.freeze({ create });
+    });
+  }).call(globalThis, void 0, void 0, void 0);
+  (function runClassicContentModule82(module, exports, require2) {
     (function initCodexOverleafRunTimelineView() {
       "use strict";
       function create(deps = {}) {
         const {
           RunGuidanceView,
           RunResultActions,
+          RunScrollLayout,
+          RunFailureNotice,
           tr,
           tx,
           getLocale,
@@ -29323,17 +30016,25 @@ ${block}`;
         } = deps;
         let logAutoFollow = true;
         let userScrollIntentUntil = 0;
+        let userScrollExtent = "";
         let scrollLogRafId = 0;
         let scrollLogPendingForce = false;
         let jumpToLatestButton = null;
         let unreadSinceDetach = 0;
         let runElapsedTimer = null;
+        const scrollLayout = RunScrollLayout?.create({
+          getScroller: getLogScrollContainer,
+          isFollowing: () => logAutoFollow,
+          onLayoutChange: (scroller) => logAutoFollow ? scrollLogToBottom() : updateJumpToLatestButton(scroller)
+        });
+        const failureNotice = RunFailureNotice?.create({ tr, projectRunSettlement, sanitizeText: sanitizeAssistantVisibleText });
         function resetAutoFollow() {
           logAutoFollow = true;
           userScrollIntentUntil = 0;
         }
         function bindLogAutoFollow() {
           const scroller = getLogScrollContainer();
+          scrollLayout?.bind(scroller);
           if (!scroller || scroller.dataset.autoFollowBound === "true") {
             return;
           }
@@ -29343,15 +30044,14 @@ ${block}`;
           scroller.addEventListener("pointerdown", markUserScrollIntent, { passive: true });
           scroller.addEventListener("keydown", (event) => {
             if (["ArrowUp", "ArrowDown", "PageUp", "PageDown", "Home", "End", " "].includes(event.key)) {
-              markUserScrollIntent();
+              markUserScrollIntent(event);
             }
           });
           scroller.addEventListener("scroll", () => {
-            if (Date.now() <= userScrollIntentUntil) {
+            if (Date.now() <= userScrollIntentUntil && userScrollExtent === `${scroller.scrollHeight}:${scroller.clientHeight}`) {
               logAutoFollow = isLogNearBottom(scroller);
-            } else if (isLogNearBottom(scroller)) {
-              logAutoFollow = true;
             }
+            scrollLayout?.captureAnchor();
             updateJumpToLatestButton(scroller);
           }, { passive: true });
         }
@@ -29382,6 +30082,7 @@ ${block}`;
           if (!el) {
             return;
           }
+          if (el.dataset) el.dataset.logAutoFollow = logAutoFollow ? "true" : "false";
           const button = ensureJumpToLatestButton();
           if (!button) {
             return;
@@ -29404,8 +30105,16 @@ ${block}`;
         function getLogScrollContainer() {
           return getPanel()?.querySelector("[data-log]") || getPanel()?.querySelector("[data-main]");
         }
-        function markUserScrollIntent() {
+        function markUserScrollIntent(event) {
+          const scroller = getLogScrollContainer();
+          if (!scroller || event?.type === "pointerdown" && event.target !== scroller) return;
+          if (event?.target?.closest?.('input, textarea, select, [contenteditable="true"]')) return;
           userScrollIntentUntil = Date.now() + 1200;
+          userScrollExtent = `${scroller.scrollHeight}:${scroller.clientHeight}`;
+          if (event?.type === "wheel" && event.deltaY < 0 || ["ArrowUp", "PageUp", "Home"].includes(event?.key)) {
+            logAutoFollow = false;
+            scrollLogPendingForce = false;
+          }
         }
         function isLogNearBottom(log) {
           if (!log) {
@@ -29424,7 +30133,7 @@ ${block}`;
             userScrollIntentUntil = 0;
             unreadSinceDetach = 0;
             scrollLogPendingForce = true;
-          } else if (!(logAutoFollow || isLogNearBottom(scroller))) {
+          } else if (!logAutoFollow) {
             updateJumpToLatestButton(scroller);
             return;
           }
@@ -29433,7 +30142,7 @@ ${block}`;
             if (!el) {
               return;
             }
-            if (scrollLogPendingForce || logAutoFollow || isLogNearBottom(el)) {
+            if (scrollLogPendingForce || logAutoFollow) {
               setLogScrollPosition(el);
             }
             scrollLogPendingForce = false;
@@ -29509,11 +30218,12 @@ ${block}`;
           }
           return tr("processed", { elapsed });
         }
-        function renderRunHistory() {
+        function renderRunHistory(options2 = {}) {
           const log = getPanel()?.querySelector("[data-log]");
           if (!log) {
             return;
           }
+          const reading = options2.preserveScroll === true && !logAutoFollow ? scrollLayout?.snapshot() || { scrollTop: log.scrollTop } : null;
           log.replaceChildren();
           if (!getState().runs?.length) {
             const empty = document.createElement("div");
@@ -29542,7 +30252,11 @@ ${block}`;
           for (const run of runs) {
             log.append(renderRunCard(run));
           }
-          scrollLogToBottom({ force: true });
+          if (reading) {
+            log.scrollTop = reading.scrollTop;
+            scrollLayout?.restore(reading);
+            updateJumpToLatestButton(log);
+          } else scrollLogToBottom({ force: true });
         }
         function renderRunCard(run) {
           const root = document.createElement("section");
@@ -29817,7 +30531,7 @@ ${block}`;
             if (row.key) dt.dataset.metaKey = row.key;
             const dd = document.createElement("dd");
             dd.className = "run-final-answer__meta-value";
-            dd.textContent = row.value;
+            dd.textContent = failureNotice?.formatMetaValue(report, row) ?? row.value;
             metaBlock.append(dt, dd);
           }
           if (metaBlock.children.length) {
@@ -29890,6 +30604,7 @@ ${lines}`
               decorateCompletionReport(main, { tx });
               report.append(main);
             }
+            failureNotice?.append(report, event, run);
             appendCompletionMetaBlock(report, structured.meta);
             appendCompileFix(report);
             appendRejectedRedo(report);
@@ -29905,6 +30620,7 @@ ${lines}`
           report.append(body);
           appendCompileFix(report);
           appendRejectedRedo(report);
+          failureNotice?.append(report, event, run);
           appendCompletionMetaBlock(report, split.meta);
           appendRecoveryActionForFailure(report, event, run);
           return report;
@@ -29958,6 +30674,9 @@ ${conclusion}` : `${label} ${conclusion}`;
           return button;
         }
         function appendRecoveryActionForFailure(report, event, run) {
+          const recovery = failureNotice?.prepareRecovery(report, { openFile: openProjectFileForFailure });
+          if (recovery?.handled) return;
+          report = recovery?.target || report;
           const failureCode = event?.failure?.code || "";
           if (RETRYABLE_FAILURE_CODES.has(failureCode) && typeof refillComposerForRetry === "function") {
             const retry = buildRecoveryButton(
@@ -30073,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;
@@ -30255,7 +30974,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafRunTimelineView = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule80(module, exports, require2) {
+  (function runClassicContentModule83(module, exports, require2) {
     (function initCodexOverleafProjectSettingsCoordinator() {
       "use strict";
       function create(deps = {}) {
@@ -30584,7 +31303,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafProjectSettingsCoordinator = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule81(module, exports, require2) {
+  (function runClassicContentModule84(module, exports, require2) {
     (function initCodexOverleafSessionMenuView() {
       "use strict";
       function create(deps = {}) {
@@ -30789,7 +31508,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafSessionMenuView = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule82(module, exports, require2) {
+  (function runClassicContentModule85(module, exports, require2) {
     (function initCodexOverleafSessionManager() {
       "use strict";
       function create(deps = {}) {
@@ -31048,7 +31767,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafSessionManager = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule83(module, exports, require2) {
+  (function runClassicContentModule86(module, exports, require2) {
     (function initCodexOverleafSessionForkController(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -31071,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"));
           }
@@ -31177,7 +31903,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       return { copyRunSnapshot, create };
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule84(module, exports, require2) {
+  (function runClassicContentModule87(module, exports, require2) {
     (function initCodexOverleafApplyResultFormatters() {
       "use strict";
       function create(deps = {}) {
@@ -31497,7 +32223,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafApplyResultFormatters = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule85(module, exports, require2) {
+  (function runClassicContentModule88(module, exports, require2) {
     (function initCodexOverleafModelPickerSupport(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("../shared/models"));
@@ -31520,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");
@@ -31593,12 +32353,14 @@ ${conclusion}` : `${label} ${conclusion}`;
         normalizeReasoningEffortsForSelect,
         normalizeSpeedTiersForSelect,
         retainSelectedModel,
+        preserveSelectedCapabilities,
+        getRenderedModelEntries,
         shouldUseBuiltInFallback
       };
       return api;
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule86(module, exports, require2) {
+  (function runClassicContentModule89(module, exports, require2) {
     (function initCodexOverleafModelPicker() {
       "use strict";
       function create(deps = {}) {
@@ -31715,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." });
@@ -31724,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 || "",
@@ -31752,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 = {
@@ -31770,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();
         }
@@ -31779,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",
@@ -32076,7 +32851,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafModelPicker = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule87(module, exports, require2) {
+  (function runClassicContentModule90(module, exports, require2) {
     (function initCodexOverleafProjectSessionCleanup() {
       "use strict";
       const FRESH_RUNNING_WINDOW_MS = 30 * 60 * 1e3;
@@ -32176,7 +32951,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafProjectSessionCleanup = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule88(module, exports, require2) {
+  (function runClassicContentModule91(module, exports, require2) {
     (function initCodexOverleafRecentProjects() {
       "use strict";
       function create(deps = {}) {
@@ -33102,7 +33877,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafRecentProjects = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule89(module, exports, require2) {
+  (function runClassicContentModule92(module, exports, require2) {
     (function initCodexOverleafOtWarmMirror() {
       "use strict";
       function create(deps = {}) {
@@ -33144,7 +33919,9 @@ ${conclusion}` : `${label} ${conclusion}`;
           RUN_SNAPSHOT_ZIP_TIMEOUT_MS
         } = deps;
         let currentOtStatus = "off";
+        let otTogglePending = false;
         let otSyncRequestId = 0;
+        let otStartRetryCount = 0;
         let otWarmMirrorProjectId = "";
         let lastExperimentalOtProjectId = "";
         let otWarmMirrorState = {
@@ -33155,7 +33932,10 @@ ${conclusion}` : `${label} ${conclusion}`;
           patchQueue: [],
           lastStatus: "off",
           lastPatchAt: 0,
-          lastErrorCode: ""
+          lastErrorCode: "",
+          failureActive: false,
+          lastFailure: null,
+          suspended: false
         };
         let mirrorPrefetchState = {
           inFlight: null,
@@ -33237,7 +34017,10 @@ ${conclusion}` : `${label} ${conclusion}`;
         async function handleExperimentalOtToggleClick(event) {
           const clicked = event?.currentTarget || event?.target;
           const targetEnabled = clicked && typeof clicked.checked === "boolean" ? clicked.checked : void 0;
+          const projectId = getCurrentProjectId();
           event.preventDefault();
+          await new Promise((resolve) => window.setTimeout(resolve, 0));
+          if (projectId !== getCurrentProjectId()) return;
           await toggleExperimentalOtCheckbox(targetEnabled);
         }
         async function handleExperimentalOtToggleKeydown(event) {
@@ -33249,28 +34032,35 @@ ${conclusion}` : `${label} ${conclusion}`;
         }
         async function toggleExperimentalOtCheckbox(targetEnabled) {
           const checkbox = getPanel()?.querySelector("[data-experimental-ot]");
-          if (!checkbox) {
+          if (!checkbox || otTogglePending) {
             return;
           }
-          const nextEnabled = typeof targetEnabled === "boolean" ? targetEnabled : !checkbox.checked;
-          if (nextEnabled) {
-            closeDiagnosticsMenu();
-            const approved = await showPluginConfirm({
-              title: tr("experimentalOtConfirmTitle"),
-              message: tr("experimentalOtConfirmMessage"),
-              confirmLabel: tr("experimentalOtConfirmEnable"),
-              cancelLabel: tr("confirmDefaultCancel")
-            });
-            if (!approved) {
-              return;
+          const projectId = getCurrentProjectId();
+          otTogglePending = true;
+          try {
+            const nextEnabled = typeof targetEnabled === "boolean" ? targetEnabled : !checkbox.checked;
+            if (nextEnabled) {
+              closeDiagnosticsMenu();
+              const approved = await showPluginConfirm({
+                title: tr("experimentalOtConfirmTitle"),
+                message: tr("experimentalOtConfirmMessage"),
+                confirmLabel: tr("experimentalOtConfirmEnable"),
+                cancelLabel: tr("confirmDefaultCancel")
+              });
+              if (!approved) {
+                return;
+              }
+            } else {
+              closeDiagnosticsMenu();
             }
-          } else {
-            closeDiagnosticsMenu();
-          }
-          checkbox.checked = nextEnabled;
-          handleExperimentalOtToggleChange({ currentTarget: checkbox });
-          if (nextEnabled) {
-            showPluginToast(tr("experimentalOtEnabledToast"), { status: "info" });
+            if (projectId !== getCurrentProjectId() || checkbox !== getPanel()?.querySelector("[data-experimental-ot]")) return;
+            checkbox.checked = nextEnabled;
+            handleExperimentalOtToggleChange({ currentTarget: checkbox });
+            if (nextEnabled) {
+              showPluginToast(tr("experimentalOtEnabledToast"), { status: "info" });
+            }
+          } finally {
+            otTogglePending = false;
           }
         }
         function handleExperimentalOtToggleChange(event) {
@@ -33279,7 +34069,9 @@ ${conclusion}` : `${label} ${conclusion}`;
             return;
           }
           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]');
@@ -33295,7 +34087,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           updateOtStatusDisplay(checkbox.checked ? currentOtStatus === "off" ? "starting" : currentOtStatus : "off");
           syncOtWarmMirrorController().catch((error) => {
             updateOtStatusDisplay("unavailable");
-            appendPlainLog(tx(`Experimental OT warm mirror unavailable: ${error.message}`, `\u5B9E\u9A8C\u6027 OT \u9884\u70ED\u955C\u50CF\u4E0D\u53EF\u7528\uFF1A${error.message}`));
+            appendPlainLog(tx(`OT warm mirror unavailable: ${error.message}`, `OT \u9884\u70ED\u955C\u50CF\u4E0D\u53EF\u7528\uFF1A${error.message}`));
           });
           saveStateSoon();
         }
@@ -33313,6 +34105,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           otWarmMirrorProjectId = projectId;
           ensureOtWarmMirrorStateProject(projectId);
           if (enabled) {
+            otWarmMirrorState.suspended = false;
             const pause = otWarmMirrorController?.shouldPauseOtWarmMirror?.({ running: Boolean(getCurrentRunView()) }) || { pause: false };
             if (pause.pause) {
               clearOtEventPolling({ clearPatchQueue: true });
@@ -33324,7 +34117,12 @@ ${conclusion}` : `${label} ${conclusion}`;
           } else {
             clearOtEventPolling({ clearPatchQueue: true });
           }
-          const response = enabled ? await callPageBridge("startOtObserver", { projectId }) : await callPageBridge("stopOtObserver", {});
+          let response;
+          try {
+            response = enabled ? await callPageBridge("startOtObserver", { projectId }) : await callPageBridge("stopOtObserver", {});
+          } catch (error) {
+            response = { ok: false, error: otWarmMirrorController.normalizeFailureCode(error?.code || error?.message, "ot_bridge_unavailable") };
+          }
           if (!isCurrentOtSync(requestId, projectId) || getCurrentProjectId() !== projectId) {
             if (enabled) {
               await handleStaleOtStartResponse(projectId, requestId);
@@ -33341,7 +34139,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
           const status = readOtBridgeStatus(response);
           if (!isSuccessfulOtBridgeResponse(response) || status === "unavailable") {
-            handleFailedOtStart(projectId, requestId);
+            await handleFailedOtStart(projectId, requestId, response);
             return response;
           }
           const pauseAfterStart = otWarmMirrorController?.shouldPauseOtWarmMirror?.({ running: Boolean(getCurrentRunView()) }) || { pause: false };
@@ -33349,7 +34147,10 @@ ${conclusion}` : `${label} ${conclusion}`;
             await pauseOtWarmMirror(pauseAfterStart.reason || "paused");
             return response;
           }
+          if (status === "starting") recordOtFailure("missing_active_path", "start");
+          else otWarmMirrorState.failureActive = false;
           updateOtStatusDisplay(status);
+          otStartRetryCount = 0;
           scheduleOtEventPolling(projectId, { immediate: true });
           return response;
         }
@@ -33369,24 +34170,38 @@ ${conclusion}` : `${label} ${conclusion}`;
             await syncOtWarmMirrorController();
           }
         }
-        function handleFailedOtStart(projectId, requestId) {
+        async function handleFailedOtStart(projectId, requestId, response) {
           if (!isCurrentOtSync(requestId, projectId) || getCurrentProjectId() !== projectId) {
             return;
           }
           clearOtEventPolling({ clearPatchQueue: true });
-          setExperimentalOtEnabledForProject(projectId, false);
-          const experimentalOtCheckbox = getPanel()?.querySelector("[data-experimental-ot]");
-          if (experimentalOtCheckbox) {
-            experimentalOtCheckbox.checked = false;
-          }
+          recordOtFailure(readOtBridgeErrorCode(response, "ot_start_failed"), "start");
+          otWarmMirrorState.suspended = true;
+          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.getState() || response.status || response.result?.getState() || response.result?.status || "unavailable";
+          return otWarmMirrorController.readOtBridgeStatus(response);
         }
         function ensureOtWarmMirrorStateProject(projectId) {
           if (!projectId || otWarmMirrorState.projectId === projectId) {
@@ -33394,8 +34209,12 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
           clearOtEventPolling({ clearPatchQueue: true });
           otWarmMirrorState.projectId = projectId;
+          otStartRetryCount = 0;
           otWarmMirrorState.lastPatchAt = 0;
           otWarmMirrorState.lastErrorCode = "";
+          otWarmMirrorState.failureActive = false;
+          otWarmMirrorState.lastFailure = null;
+          otWarmMirrorState.suspended = false;
           otWarmMirrorState.lastStatus = currentOtStatus;
         }
         function clearOtEventPolling(options2 = {}) {
@@ -33429,7 +34248,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           }, delayMs);
         }
         function canPollOtWarmMirror(projectId) {
-          return Boolean(projectId && otWarmMirrorController?.shouldPauseOtWarmMirror && otWarmMirrorController?.buildPatchFilesRequest && isExperimentalOtEnabledForProject(projectId) && otWarmMirrorProjectId === projectId && getCurrentProjectId() === projectId);
+          return Boolean(projectId && otWarmMirrorController?.shouldPauseOtWarmMirror && otWarmMirrorController?.buildPatchFilesRequest && isExperimentalOtEnabledForProject(projectId) && otWarmMirrorProjectId === projectId && getCurrentProjectId() === projectId && !otWarmMirrorState.suspended);
         }
         async function pollOtEvents(projectId = otWarmMirrorState.projectId || getCurrentProjectId()) {
           if (!canPollOtWarmMirror(projectId)) {
@@ -33449,11 +34268,13 @@ ${conclusion}` : `${label} ${conclusion}`;
               return { ok: false, skipped: true, reason: "project_changed" };
             }
             if (!isSuccessfulOtBridgeResponse(statusResponse)) {
-              otWarmMirrorState.lastErrorCode = readOtBridgeErrorCode(statusResponse, "get_ot_status_failed");
+              recordOtFailure(readOtBridgeErrorCode(statusResponse, "get_ot_status_failed"), "observe");
               updateOtStatusDisplay("unavailable");
               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);
             }
@@ -33462,7 +34283,7 @@ ${conclusion}` : `${label} ${conclusion}`;
               return { ok: false, skipped: true, reason: "project_changed" };
             }
             if (!isSuccessfulOtBridgeResponse(drainResponse)) {
-              otWarmMirrorState.lastErrorCode = readOtBridgeErrorCode(drainResponse, "drain_ot_events_failed");
+              recordOtFailure(readOtBridgeErrorCode(drainResponse, "drain_ot_events_failed"), "observe");
               updateOtStatusDisplay("unavailable");
               return drainResponse;
             }
@@ -33472,7 +34293,8 @@ ${conclusion}` : `${label} ${conclusion}`;
             }
             return drainResponse;
           } catch (error) {
-            otWarmMirrorState.lastErrorCode = error?.code || error?.message || "ot_poll_failed";
+            if (!canPollOtWarmMirror(projectId)) return { ok: false, skipped: true, reason: "project_changed" };
+            recordOtFailure(error?.code || error?.message || "ot_poll_failed", "observe");
             updateOtStatusDisplay("unavailable");
             return { ok: false, error };
           } finally {
@@ -33482,27 +34304,33 @@ ${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);
+          otWarmMirrorState.lastErrorCode = code;
+          otWarmMirrorState.failureActive = true;
+          otWarmMirrorState.lastFailure = { code, phase, at: Date.now() };
         }
         function queueOtPatchEvents(events, projectId = getCurrentProjectId()) {
           if (!Array.isArray(events) || !events.length || !canPollOtWarmMirror(projectId)) {
             return;
           }
           ensureOtWarmMirrorStateProject(projectId);
-          otWarmMirrorState.patchQueue.push(...events);
+          const queued = otWarmMirrorController.queuePatchEvents(otWarmMirrorState.patchQueue, events);
+          if (!queued.ok) {
+            recordOtFailure(queued.reason, "queue");
+            clearOtEventPolling({ clearPatchQueue: true });
+            otWarmMirrorState.suspended = true;
+            updateOtStatusDisplay("inconsistent");
+            void callPageBridge("stopOtObserver", { projectId }).catch(() => {
+            });
+            return;
+          }
+          otWarmMirrorState.patchQueue = queued.queue;
           scheduleOtPatchFlush(projectId);
         }
         function scheduleOtPatchFlush(projectId = otWarmMirrorState.projectId || getCurrentProjectId(), options2 = {}) {
@@ -33536,11 +34364,18 @@ ${conclusion}` : `${label} ${conclusion}`;
             clearOtEventPolling({ clearPatchQueue: false });
             return { ok: false, skipped: true, reason: pause.reason || "paused" };
           }
-          const maxBatch = Math.max(1, Number(otWarmMirrorController?.OT_MAX_PATCH_BATCH) || 25);
-          const batch = otWarmMirrorState.patchQueue.splice(0, maxBatch);
+          let batch = otWarmMirrorController.takePatchBatch(otWarmMirrorState.patchQueue);
           if (!batch.length) {
             return { ok: true, skipped: true, reason: "empty_batch" };
           }
+          const fresh = otWarmMirrorController.queuePatchEvents([], batch);
+          if (!fresh.ok) {
+            recordOtFailure(fresh.reason, "queue");
+            clearOtEventPolling({ clearPatchQueue: true });
+            updateOtStatusDisplay("inconsistent");
+            return { ok: false, skipped: true, reason: fresh.reason };
+          }
+          batch = fresh.queue;
           otWarmMirrorState.flushing = true;
           try {
             const request = {
@@ -33554,40 +34389,35 @@ ${conclusion}` : `${label} ${conclusion}`;
               return { ok: false, skipped: true, reason: "project_changed" };
             }
             const response = await sendBackgroundNative(request);
+            if (!canPollOtWarmMirror(projectId)) return { ok: false, skipped: true, reason: "project_changed" };
             if (!response?.ok) {
-              otWarmMirrorState.lastErrorCode = response?.error?.code || response?.error?.message || "mirror_patch_failed";
+              recordOtFailure(response?.error?.code || "mirror_patch_failed", "flush");
               updateOtStatusDisplay("inconsistent");
               return response;
             }
-            const result = response.result || {};
-            const skippedFiles = Array.isArray(result?.skippedFiles) ? result.skippedFiles : [];
-            const skippedCount = Number.isFinite(Number(result?.skippedCount)) ? Number(result.skippedCount) : skippedFiles.length;
-            if (skippedFiles.length || skippedCount > 0) {
-              otWarmMirrorState.lastErrorCode = "mirror_patch_skipped";
-              updateOtStatusDisplay("inconsistent");
-              return response;
-            }
-            const appliedFiles = Array.isArray(result?.appliedFiles) ? result.appliedFiles : null;
-            const appliedCount = Number.isFinite(Number(result?.appliedCount)) ? Number(result.appliedCount) : NaN;
-            if (!appliedFiles || !Number.isFinite(appliedCount) || appliedCount <= 0 || appliedFiles.length !== appliedCount) {
-              otWarmMirrorState.lastErrorCode = "mirror_patch_invalid_result";
+            const receipt = otWarmMirrorController.validatePatchReceipt(batch, response.result);
+            if (!receipt.ok) {
+              recordOtFailure(receipt.reason, "flush");
               updateOtStatusDisplay("inconsistent");
               return response;
             }
             otWarmMirrorState.lastPatchAt = Date.now();
             otWarmMirrorState.lastErrorCode = "";
-            if (canPollOtWarmMirror(projectId)) {
+            otWarmMirrorState.failureActive = false;
+            if (canPollOtWarmMirror(projectId) && !getCurrentRunView()) {
               updateOtStatusDisplay("observing");
             }
             return response;
           } catch (error) {
-            otWarmMirrorState.lastErrorCode = error?.code || error?.message || "mirror_patch_failed";
+            if (!canPollOtWarmMirror(projectId)) return { ok: false, skipped: true, reason: "project_changed" };
+            recordOtFailure(error?.code || "mirror_patch_failed", "flush");
             updateOtStatusDisplay("inconsistent");
             return { ok: false, error };
           } finally {
             otWarmMirrorState.flushing = false;
-            if (otWarmMirrorState.patchQueue.length && canPollOtWarmMirror(projectId) && !getCurrentRunView()) {
-              scheduleOtPatchFlush(projectId, { immediate: true });
+            const nextProjectId = otWarmMirrorState.projectId;
+            if (otWarmMirrorState.patchQueue.length && canPollOtWarmMirror(nextProjectId) && !getCurrentRunView()) {
+              scheduleOtPatchFlush(nextProjectId, { immediate: true });
             }
           }
         }
@@ -33627,12 +34457,12 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
         }
         function updateOtStatusDisplay(status = currentOtStatus) {
-          const normalized = normalizeOtStatus(status);
+          const normalized = otWarmMirrorState.failureActive && status === "observing" ? "inconsistent" : normalizeOtStatus(status);
           currentOtStatus = normalized;
           otWarmMirrorState.lastStatus = normalized;
           const statusElement = getPanel()?.querySelector("[data-ot-status]");
           if (statusElement) {
-            const label = formatOtStatusLabel(normalized);
+            const label = formatOtStatusLabel(normalized) + (otWarmMirrorState.failureActive ? ": " + tr(otWarmMirrorController.getFailureMessageKey(otWarmMirrorState.lastErrorCode)) : "");
             statusElement.textContent = formatOtToggleStatusText(label);
             statusElement.dataset.otStatus = normalized;
             statusElement.title = formatOtToggleStatusText(label);
@@ -33780,37 +34610,23 @@ ${conclusion}` : `${label} ${conclusion}`;
           return health.reusable === true;
         }
         async function resolveWarmRunStart(taskContext = {}) {
+          const projectId = getCurrentProjectId();
           const focusFiles = taskContext.focusFiles || [];
           const mode = taskContext.mode || getState()?.mode;
           const mirrorStatus = await getMirrorFreshness();
+          if (getCurrentProjectId() !== projectId) return { useExistingMirror: false, reason: "project_changed" };
           const otWarmStart = otWarmMirrorController.canUseOtWarmStart({
-            enabled: isExperimentalOtEnabled(),
+            enabled: isExperimentalOtEnabled() && !otWarmMirrorState.failureActive,
             focusFiles,
             mirrorStatus
           });
-          if (otWarmStart.ok) {
-            return {
-              useExistingMirror: true,
-              warmStart: true,
-              otWarmStart: true,
-              reason: "ot_focus_fresh",
-              mirrorStatus,
-              focusFiles: otWarmStart.focusFiles,
-              project: {
-                capabilities: {
-                  fullProjectSnapshot: false,
-                  method: "ot-warm-mirror"
-                },
-                files: []
-              }
-            };
-          }
-          if (!mirrorStatus?.exists || !isMirrorReusable(mirrorStatus)) {
+          if (!mirrorStatus?.exists || !otWarmStart.ok && !isMirrorReusable(mirrorStatus)) {
             return { useExistingMirror: false, reason: "mirror_not_fresh", mirrorStatus };
           }
           let overlayProject = null;
           try {
             overlayProject = await callPageBridge("getProjectSnapshot", {
+              projectId,
               force: true,
               maxAgeMs: 0,
               preferLightweight: true,
@@ -33824,6 +34640,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           } catch (error) {
             return { useExistingMirror: false, reason: "overlay_probe_failed", mirrorStatus };
           }
+          if (getCurrentProjectId() !== projectId) return { useExistingMirror: false, reason: "project_changed" };
           const fileOverlays = buildSnapshotFileOverlays(overlayProject, focusFiles);
           if (!fileOverlays.length) {
             return { useExistingMirror: false, reason: "missing_current_overlay", mirrorStatus };
@@ -33837,7 +34654,9 @@ ${conclusion}` : `${label} ${conclusion}`;
           return {
             useExistingMirror: true,
             warmStart: true,
-            reason: mode === "ask" ? "warm_whole_project_ask" : "warm_whole_project",
+            otWarmStart: otWarmStart.ok,
+            focusFiles,
+            reason: otWarmStart.ok ? "ot_focus_fresh" : mode === "ask" ? "warm_whole_project_ask" : "warm_whole_project",
             mirrorStatus,
             fileOverlays,
             project: overlayProject
@@ -33922,7 +34741,7 @@ ${conclusion}` : `${label} ${conclusion}`;
             return syncOtWarmMirrorController();
           }).catch((error) => {
             updateOtStatusDisplay("unavailable");
-            appendPlainLog(tx(`Experimental OT warm mirror unavailable: ${error.message}`, `\u5B9E\u9A8C\u6027 OT \u9884\u70ED\u955C\u50CF\u4E0D\u53EF\u7528\uFF1A${error.message}`));
+            appendPlainLog(tx(`OT warm mirror unavailable: ${error.message}`, `OT \u9884\u70ED\u955C\u50CF\u4E0D\u53EF\u7528\uFF1A${error.message}`));
           });
         }
         return {
@@ -33957,13 +34776,14 @@ ${conclusion}` : `${label} ${conclusion}`;
       window.CodexOverleafOtWarmMirror = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule90(module, exports, require2) {
+  (function runClassicContentModule93(module, exports, require2) {
     (function initCodexOverleafWritebackOrchestrator() {
       "use strict";
       let tr;
       let tx;
       let getLocale;
       let appendRunEvent;
+      let appendRunRecordEvent;
       let pendingMirrorRefresh = null;
       let appendChangeSummary;
       let appendCompletionReport;
@@ -34010,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;
@@ -34662,6 +35510,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           tx,
           getLocale,
           appendRunEvent,
+          appendRunRecordEvent,
           appendChangeSummary,
           appendCompletionReport,
           appendOperationsPreview,
@@ -34707,13 +35556,161 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         return {
           applySyncChangesToOverleaf,
           resolveCompileLogContext,
+          invalidateMirrorAfterUndo,
           getPendingMirrorRefresh: () => pendingMirrorRefresh
         };
       }
       window.CodexOverleafWritebackOrchestrator = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule91(module, exports, require2) {
+  (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;
@@ -34756,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 runClassicContentModule92(module, exports, require2) {
+  (function runClassicContentModule96(module, exports, require2) {
     (function initPostNavigationSettlementPersistence(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -34848,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 runClassicContentModule93(module, exports, require2) {
+  (function runClassicContentModule97(module, exports, require2) {
     (function initCodexOverleafPanelMaintenance() {
       "use strict";
       function create(deps = {}) {
@@ -34951,30 +35948,43 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             list.append(row);
           }
         }
+        let storageUsageRequestId = 0;
         function refreshStorageUsageSummary() {
           const node = getSettingsPanelInstance()?.container?.querySelector("[data-storage-usage]");
           if (!node) {
             return;
           }
-          const sessionCount = Array.isArray(getState()?.sessions) ? getState().sessions.length : 0;
-          const runCount = Array.isArray(getState()?.runs) ? getState().runs.length : 0;
+          const requestId = ++storageUsageRequestId;
+          const projectId = getCurrentProjectId?.();
+          const isCurrent = () => requestId === storageUsageRequestId && projectId === getCurrentProjectId?.() && getSettingsPanelInstance()?.container?.querySelector("[data-storage-usage]") === node;
+          const current = getState();
+          const sessionCount = Array.isArray(current?.sessions) ? current.sessions.length : 0;
+          const runCount = Array.isArray(current?.runs) ? current.runs.length : 0;
           const counts = tx(
-            `${sessionCount} session(s) \xB7 ${runCount} recent run(s) kept`,
-            `${sessionCount} \u4E2A\u4F1A\u8BDD \xB7 \u4FDD\u7559\u6700\u8FD1 ${runCount} \u8F6E\u8FD0\u884C`
+            `${sessionCount} loaded session(s) in this project \xB7 ${runCount} run(s) in the active session`,
+            `\u5F53\u524D\u9879\u76EE\u5DF2\u52A0\u8F7D ${sessionCount} \u4E2A\u4F1A\u8BDD \xB7 \u5F53\u524D\u4F1A\u8BDD ${runCount} \u8F6E\u8FD0\u884C`
           );
+          node.removeAttribute?.("data-i18n");
           node.textContent = counts;
-          const estimate = navigator.storage?.estimate?.();
-          if (estimate?.then) {
-            estimate.then((info) => {
-              const usage = Number(info?.usage);
-              if (Number.isFinite(usage) && usage >= 0) {
-                const mb = usage / (1024 * 1024);
-                const size = mb >= 1 ? `${mb.toFixed(1)} MB` : `${Math.max(1, Math.round(usage / 1024))} KB`;
-                node.textContent = tx(`${counts} \xB7 ~${size} used on this site`, `${counts} \xB7 \u672C\u7AD9\u70B9\u7EA6\u5360\u7528 ${size}`);
-              }
-            }).catch(() => {
-            });
-          }
+          const unavailable = () => {
+            if (isCurrent()) node.textContent = tx(`${counts} \xB7 Site storage estimate unavailable`, `${counts} \xB7 \u672C\u7AD9\u70B9\u5BB9\u91CF\u6682\u65E0\u6CD5\u4F30\u7B97`);
+          };
+          let timer;
+          const estimate = Promise.resolve().then(() => navigator.storage?.estimate?.());
+          const deadline = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(null), 2e3);
+          });
+          return Promise.race([estimate, deadline]).then((info) => {
+            if (!isCurrent()) return;
+            const usage = info?.usage;
+            if (!Number.isFinite(usage) || usage < 0) {
+              unavailable();
+              return;
+            }
+            const mb = usage / (1024 * 1024);
+            const size = usage === 0 ? "0 KB" : mb >= 1 ? `${mb.toFixed(1)} MB` : `${Math.max(1, Math.round(usage / 1024))} KB`;
+            node.textContent = tx(`${counts} \xB7 Site total ~${size}`, `${counts} \xB7 \u672C\u7AD9\u70B9\u603B\u5360\u7528\u7EA6 ${size}`);
+          }).catch(unavailable).finally(() => clearTimeout(timer));
         }
         async function clearAllHistoryWithConfirm() {
           if (getCurrentRunView()) {
@@ -35166,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 runClassicContentModule94(module, exports, require2) {
+  (function runClassicContentModule98(module, exports, require2) {
     (function initCodexOverleafUpdateIdle(root) {
       "use strict";
       function create(options2 = {}) {
@@ -35234,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 runClassicContentModule95(module, exports, require2) {
+  (function runClassicContentModule99(module, exports, require2) {
     (function initCodexOverleafUpdateNotice(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("../shared/managedUpdateProjection"));
@@ -35322,7 +36332,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             install: "codex-overleaf/consent-update-install",
             retry: "codex-overleaf/consent-update-check",
             later: "codex-overleaf/consent-update-later",
-            dismiss: "codex-overleaf/consent-update-dismiss"
+            dismiss: "codex-overleaf/consent-update-dismiss",
+            reload: "codex-overleaf/consent-update-reload"
           }[action]);
         } catch (error) {
           currentView = await reconcileAfterActionError(error, {
@@ -35435,7 +36446,10 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         const stateName = currentView?.state?.state || "idle";
         let requestedAction = "check";
         try {
-          if (stateName === "update_available") {
+          if (["reload_required", "reload_tabs_required"].includes(stateName)) {
+            requestedAction = "reload";
+            currentView = await request("codex-overleaf/consent-update-reload");
+          } else if (stateName === "update_available") {
             requestedAction = "install";
             currentView = await request("codex-overleaf/consent-update-install");
           } else if (["failed", "rolled_back"].includes(stateName)) {
@@ -35494,7 +36508,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           command.textContent = manualUpdateCommand(state);
           body.append(recovery, command);
         }
-        if (!["update_available", "failed", "rolled_back"].includes(state.state)) {
+        if (!["update_available", "failed", "rolled_back", "reload_required", "reload_tabs_required"].includes(state.state)) {
           const bar = document.createElement("div");
           bar.className = "codex-update-notice-progress" + (progress.determinate ? "" : " is-indeterminate");
           bar.setAttribute("role", "progressbar");
@@ -35540,7 +36554,11 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         );
         let statusText = "";
         let buttonText = tx("Check for updates", "\u68C0\u67E5\u66F4\u65B0");
-        if (stateName === "checking") {
+        if (["reload_required", "reload_tabs_required"].includes(stateName)) {
+          summaryText = tx(`Installed v${latestVersion}; running extension v${currentVersion}.`, `\u5DF2\u5B89\u88C5 v${latestVersion}\uFF1B\u6269\u5C55\u5F53\u524D\u8FD0\u884C v${currentVersion}\u3002`);
+          statusText = getCopy(state).detail;
+          buttonText = stateName === "reload_required" ? tx("Reload extension", "\u91CD\u65B0\u52A0\u8F7D\u6269\u5C55") : tx("Refresh Overleaf tabs", "\u5237\u65B0 Overleaf \u6807\u7B7E\u9875");
+        } else if (stateName === "checking") {
           statusText = tx("Checking the latest stable release\u2026", "\u6B63\u5728\u68C0\u67E5\u6700\u65B0\u7A33\u5B9A\u7248\u672C\u2026");
           buttonText = tx("Checking\u2026", "\u68C0\u67E5\u4E2D\u2026");
         } else if (stateName === "update_available") {
@@ -35565,6 +36583,9 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       }
       function visibleActions(state) {
         if (actionInFlight) return [];
+        if (["reload_required", "reload_tabs_required"].includes(state)) {
+          return [{ id: "reload", label: state === "reload_required" ? tx("Reload extension", "\u91CD\u65B0\u52A0\u8F7D\u6269\u5C55") : tx("Refresh Overleaf tabs", "\u5237\u65B0 Overleaf \u6807\u7B7E\u9875"), primary: true }];
+        }
         if (state === "update_available") {
           return [
             { id: "later", label: tx("Later", "\u7A0D\u540E"), primary: false },
@@ -35589,6 +36610,16 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         const target = state.latestVersion ? "v" + state.latestVersion : "";
         const blocker = blockersCopy(state.blockers?.length ? state.blockers : [state.blocker]);
         return {
+          reload_required: {
+            eyebrow: tx("Installed, awaiting reload", "\u5DF2\u5B89\u88C5\uFF0C\u7B49\u5F85\u52A0\u8F7D"),
+            title: target,
+            detail: state.message || tx("The new files are installed. Reload the extension when Overleaf is saved and idle.", "\u65B0\u7248\u6587\u4EF6\u5DF2\u5B89\u88C5\uFF0C\u8BF7\u5728 Overleaf \u4FDD\u5B58\u5E76\u7A7A\u95F2\u540E\u91CD\u65B0\u52A0\u8F7D\u6269\u5C55\u3002")
+          },
+          reload_tabs_required: {
+            eyebrow: tx("Updated runtime is ready", "\u65B0\u7248\u8FD0\u884C\u7EC4\u4EF6\u5DF2\u5C31\u7EEA"),
+            title: target,
+            detail: state.message || tx("Refresh the saved, idle Overleaf tabs to load the updated panel.", "\u5237\u65B0\u5DF2\u4FDD\u5B58\u4E14\u7A7A\u95F2\u7684 Overleaf \u6807\u7B7E\u9875\u4EE5\u52A0\u8F7D\u65B0\u7248\u9762\u677F\u3002")
+          },
           update_available: {
             eyebrow: tx("Update available", "\u53D1\u73B0\u65B0\u7248\u672C"),
             title: target,
@@ -35678,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 runClassicContentModule96(module, exports, require2) {
+  (function runClassicContentModule100(module, exports, require2) {
     (function initCodexOverleafContentRuntime(root) {
       "use strict";
       function init(dependencies2) {
@@ -35731,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",
@@ -36072,6 +37104,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         const runTimelineView = Modules.RunTimelineView.create({
           RunGuidanceView: Modules.RunGuidanceView,
           RunResultActions: runResultActions,
+          RunScrollLayout: Modules.RunScrollLayout,
+          RunFailureNotice: Modules.RunFailureNotice,
           tr,
           tx,
           getLocale,
@@ -36229,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 {
@@ -36430,6 +37465,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           },
           saveState,
           saveStateSoon,
+          onProjectFilesReady: refreshHistoricalProjectReferences,
           updateActiveSession,
           callPageBridge,
           getCurrentProjectId,
@@ -36473,6 +37509,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           }
         });
         let panel = null;
+        let probeStatusSnapshot = null;
         let panelRendererInstance = null;
         let sessionPanelInstance = null;
         let settingsPanelInstance = null;
@@ -36646,7 +37683,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           });
           syncOtWarmMirrorController().catch((error) => {
             updateOtStatusDisplay("unavailable");
-            appendPlainLog(tx(`Failed to sync experimental OT warm mirror: ${error.message}`, `\u540C\u6B65\u5B9E\u9A8C\u6027 OT \u9884\u70ED\u955C\u50CF\u5931\u8D25\uFF1A${error.message}`));
+            appendPlainLog(tx(`Failed to sync OT warm mirror: ${error.message}`, `\u540C\u6B65 OT \u9884\u70ED\u955C\u50CF\u5931\u8D25\uFF1A${error.message}`));
           });
           await refreshProbe({ quiet: true });
         }
@@ -36869,6 +37906,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                 onProvidersOpen: () => providerSettingsCoordinator.open(),
                 onClearAllHistory: () => clearAllHistoryWithConfirm(),
                 onHistoryOpen: () => renderAuditHistoryPanel(),
+                onStorageOpen: () => refreshStorageUsageSummary(),
                 onHistoryFilter: () => applyAuditHistoryFilter(),
                 // Experimental OT mirror: a single visible switch whose click is
                 // intercepted so the confirm-before-enable flow still runs.
@@ -37095,6 +38133,17 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           updateModelDisplay();
           renderSessionList();
           renderContextSelection();
+          const probeStatus = panel.querySelector("[data-probe-status]");
+          if (probeStatus?.dataset.refreshing === "true") probeStatus.textContent = tr("refreshProbeLoading");
+          else if (probeStatus && probeStatusSnapshot?.projectId === getCurrentProjectId()) {
+            const { failed, probe, userInitiated } = probeStatusSnapshot;
+            const text = failed ? tr("refreshProbeFailed") : formatProbeStatusBar(probe);
+            probeStatus.textContent = userInitiated && !failed ? tr("refreshProbeDone", { status: text }) : text;
+            if (!failed) updateExistingProbeNotice(probe);
+          }
+          updateSkillsEntrySummary();
+          providerSettingsCoordinator.renderSummary();
+          if (settingsPanelInstance?.container?.querySelector("[data-storage-card]")?.open) refreshStorageUsageSummary();
         }
         function setElementTitleAndAria(selector, title, ariaLabel) {
           const element = panel?.querySelector(selector);
@@ -37817,7 +38866,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                 }
               }
               await saveState();
-              applyStateToPanel();
+              applyStateToPanel({ preserveScroll: true });
             } catch (persistenceError) {
               appendRunEvent({
                 title: tx("Codex result was generated, but saving local session history failed.", "Codex \u7ED3\u679C\u5DF2\u751F\u6210\uFF0C\u4F46\u4FDD\u5B58\u672C\u5730\u4F1A\u8BDD\u8BB0\u5F55\u5931\u8D25\u3002"),
@@ -37887,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(() => {
               });
@@ -39948,6 +41001,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           return { safe, skipped };
         }
         async function refreshProbe(options2 = {}) {
+          const projectId = getCurrentProjectId();
           const userInitiated = options2.userInitiated === true;
           if (userInitiated) {
             setRefreshProbeLoading(true);
@@ -39962,6 +41016,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             const probe = await callPageBridge("probe", {
               manualOverride: state?.requireReviewing === false
             });
+            if (projectId !== getCurrentProjectId()) return null;
+            probeStatusSnapshot = { projectId, probe, userInitiated };
             const status = panel?.querySelector("[data-probe-status]");
             if (status) {
               status.textContent = userInitiated ? tr("refreshProbeDone", { status: formatProbeStatusBar(probe) }) : formatProbeStatusBar(probe);
@@ -39978,6 +41034,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             if (!userInitiated) {
               throw error;
             }
+            if (projectId !== getCurrentProjectId()) return null;
+            probeStatusSnapshot = { projectId, failed: true };
             const status = panel?.querySelector("[data-probe-status]");
             if (status) {
               status.textContent = tr("refreshProbeFailed");
@@ -40459,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,
@@ -40770,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)) {
@@ -40864,7 +41915,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           state = updateActiveSession(state, { task: "" });
           saveStateSoon();
         }
-        function applyStateToPanel() {
+        function applyStateToPanel(options2 = {}) {
           applyPanelTheme(getThemePreference());
           if ((state.providerId || "builtin") === "builtin" && !modelSelectHasOption(state.model)) {
             renderModelOptions(getModelCatalog().FALLBACK_MODELS, state.model);
@@ -40898,7 +41949,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           syncModeControls();
           applySessionLabel();
           renderSessionList();
-          renderRunHistory();
+          renderRunHistory(options2);
+          getTrackedChangeCaptureController().schedule();
           renderContextSelection();
           renderContextSummary();
           if (!composerAttachmentsRestoredOnce && Array.isArray(state.composerAttachments) && state.composerAttachments.length && !composerAttachmentController.getAttachmentsForRun?.().length && typeof composerAttachmentController.restorePersistedAttachments === "function") {
@@ -40977,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,
@@ -41115,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));
           }
@@ -41428,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) {
@@ -41542,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 }),
@@ -41594,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
@@ -41610,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",
@@ -41627,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;
@@ -41807,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) {
@@ -41843,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({
@@ -41904,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;
@@ -42502,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 runClassicContentModule97(module, exports, require2) {
+  (function runClassicContentModule101(module, exports, require2) {
     (function initCodexOverleafLegacyGlobalRegistry(root, factory) {
       "use strict";
       const api = factory();
@@ -42560,6 +43631,8 @@ Reason: ${item.reason || "No reason provided"}`),
         "RunInputQueue",
         "RunQueueScheduler",
         "RunResultActions",
+        "RunScrollLayout",
+        "RunFailureNotice",
         "RunSettlementPersistence",
         "RunTimelineView",
         "ScopedPersistenceCoordinator",
@@ -42576,6 +43649,7 @@ Reason: ${item.reason || "No reason provided"}`),
         "StorageMigration",
         "Summary",
         "Theme",
+        "TrackedChangeCaptureController",
         "UndoOperations",
         "UpdateIdle",
         "UpdateNotice",