codex-overleaf-link 2.3.6 → 2.4.1

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', "b19a018ab6eb9c7bdca8cfad8ff6efcc4a30e80f81c3c0a2e89a7f78b6361d97");
 (() => {
   // extension/entries/content-entry.mjs
   (function runClassicContentModule(module, exports, require2) {
@@ -4582,14 +4583,39 @@ ${block}`;
           failureReason_editor_project_id_unavailable_next: "Refresh the Overleaf tab and retry; if it persists, reload the extension.",
           // Welcome-panel + write-guard: Recent-projects
           // variant copy. Spec §5.3–§5.5, §5.8, §5.10 are the source of truth.
-          recentProjects_welcome: "Codex Overleaf Link",
-          recentProjects_welcome_subtitle: "Open a project from the Overleaf list on the left to start.",
-          recentProjects_empty: "You haven't run any Codex sessions yet. Open a project from the Overleaf list on the left to start.",
-          recentProjects_sessions_empty: "No sessions in this project yet",
-          recentProjects_sessions_toggle: "Show / manage this project's sessions",
-          recentProjects_sessions_action: "View runs",
-          recentProjects_sessions_action_open: "Hide runs",
-          recentProjects_clearProject: "Delete all sessions for this project",
+          recentProjects_welcome: "Continue working",
+          recentProjects_focusEyebrow: "Last conversation",
+          recentProjects_historyHeading: "Other recent conversations",
+          recentProjects_historyHint: "Select to continue",
+          recentProjects_projectConversations: "View this project's conversations",
+          recentProjects_allProjects: "All projects",
+          recentProjects_showAllConversations: "View all {count} conversations",
+          recentProjects_unstarted: "Not started \xB7 {count}",
+          recentProjects_unstartedHint: "Empty conversations are kept here, without deleting their records.",
+          recentProjects_noStarted: "No conversation has been started yet. Empty conversations are available below.",
+          recentProjects_savedDraft: "Saved draft, ready to continue.",
+          recentProjects_attention: "Needs attention",
+          recentProjects_unavailableRecords: "Records with unavailable project links",
+          recentProjects_loadingHistory: "Loading conversations...",
+          recentProjects_loadFailed: "Conversation history could not be read. Please retry.",
+          recentProjects_continueHint: "Open this conversation without automatically starting a task.",
+          recentProjects_more: "More options",
+          recentProjects_continue: "Continue",
+          recentProjects_openProject: "Open project",
+          recentProjects_loadingConversation: "Loading conversation...",
+          recentProjects_noConversation: "No saved conversation",
+          recentProjects_noRuns: "No runs yet",
+          recentProjects_previewUnavailable: "Conversation unavailable",
+          recentProjects_previewUnavailableHint: "Saved conversation could not be loaded.",
+          recentProjects_conversationGone: "This conversation is no longer available. Choose another conversation from the refreshed list.",
+          recentProjects_continueFailed: "Could not open the conversation. Please try again.",
+          recentProjects_welcome_subtitle: "Conversations saved in this browser",
+          recentProjects_empty: "No conversations saved in this browser yet. Open an Overleaf project and start a Codex conversation.",
+          recentProjects_sessions_empty: "No saved conversations in this project",
+          recentProjects_sessions_toggle: "Show or manage this project's conversations",
+          recentProjects_sessions_action: "All conversations",
+          recentProjects_sessions_action_open: "Hide conversations",
+          recentProjects_clearProject: "Delete this project's conversations",
           recentProjects_clearProject_title: "Delete all Codex sessions for {project}?",
           recentProjects_clearProject_message: "This permanently deletes all {count} plugin sessions, run history, and matching plugin-local Codex thread history for {project}. It will not modify Overleaf files or global Codex history.",
           recentProjects_clearProject_confirm: "Delete all",
@@ -4605,15 +4631,17 @@ ${block}`;
           recentProjects_degraded: "Sign in to Overleaf to see your recent Codex projects.",
           recentProjects_row_projectLinkUnavailable: "Project link unavailable.",
           recentProjects_settings_entry: "Settings & Diagnostics",
-          recentProjects_badge_pending: "pending",
-          recentProjects_badge_accepted: "accepted",
-          recentProjects_badge_rejected: "rejected",
-          recentProjects_badge_needs_review: "pending",
-          recentProjects_badge_running: "running",
-          recentProjects_badge_completed: "completed",
-          recentProjects_badge_failed: "failed",
-          recentProjects_badge_interrupted: "interrupted",
-          recentProjects_badge_stale: "stale",
+          recentProjects_settingsTitle: "General Settings",
+          recentProjects_settingsSubtitle: "Manage Codex preferences and local history across all projects.",
+          recentProjects_badge_pending: "Last run pending",
+          recentProjects_badge_accepted: "Last changes accepted",
+          recentProjects_badge_rejected: "Last changes undone",
+          recentProjects_badge_needs_review: "Last run needs review",
+          recentProjects_badge_running: "Last recorded as running",
+          recentProjects_badge_completed: "Last run completed",
+          recentProjects_badge_failed: "Last run failed",
+          recentProjects_badge_interrupted: "Last run may have been interrupted",
+          recentProjects_badge_stale: "Last run status unconfirmed",
           recentProjects_unnamed: "Project \xB7 {prefix}",
           recentProjects_zombieRunningNote: "Marked as running, but it may be a leftover from an interrupted run.",
           recentProjects_zombieDeleteConfirm: "This session is marked as running. If no other tab is actually running it, you can delete it anyway.",
@@ -4621,9 +4649,9 @@ ${block}`;
           recentProjects_degraded_hint: "Could not identify the Overleaf account on this page, so the project list is hidden to avoid mixing accounts. This usually resolves on a reload.",
           recentProjects_sessionsCount: "{count} session(s)",
           recentProjects_welcome_stats: "{projects} projects \xB7 {sessions} Codex sessions",
-          recentProjects_badge_background_completed: "completed in background",
-          recentProjects_badge_needs_review_after_navigation: "pending",
-          recentProjects_badge_abandoned_after_navigation: "abandoned"
+          recentProjects_badge_background_completed: "Last run completed in background",
+          recentProjects_badge_needs_review_after_navigation: "Last run needs review",
+          recentProjects_badge_abandoned_after_navigation: "Last run stopped after navigation"
         },
         zh: {
           resizePanel: "\u62D6\u52A8\u8C03\u6574 Codex \u9762\u677F\u5BBD\u5EA6\uFF0C\u53CC\u51FB\u6062\u590D\u9ED8\u8BA4\u5BBD\u5EA6",
@@ -5121,14 +5149,39 @@ ${block}`;
           failureReason_editor_project_id_unavailable_next: "\u8BF7\u5237\u65B0 Overleaf \u9875\u9762\u540E\u91CD\u8BD5\uFF1B\u5982\u679C\u4ECD\u7136\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u52A0\u8F7D\u6269\u5C55\u3002",
           // Welcome-panel + write-guard: Recent-projects
           // variant copy. 见 spec §5.3–§5.5、§5.8、§5.10。
-          recentProjects_welcome: "Codex Overleaf Link",
-          recentProjects_welcome_subtitle: "\u4ECE\u5DE6\u4FA7 Overleaf \u9879\u76EE\u5217\u8868\u4E2D\u6253\u5F00\u4EFB\u610F\u9879\u76EE\u5373\u53EF\u5F00\u59CB\u3002",
-          recentProjects_empty: "\u4F60\u8FD8\u6CA1\u6709\u8FD0\u884C\u8FC7 Codex \u4F1A\u8BDD\u3002\u4ECE\u5DE6\u4FA7 Overleaf \u9879\u76EE\u5217\u8868\u4E2D\u6253\u5F00\u4EFB\u610F\u9879\u76EE\u5373\u53EF\u5F00\u59CB\u3002",
-          recentProjects_sessions_empty: "\u8BE5\u9879\u76EE\u8FD8\u6CA1\u6709\u4F1A\u8BDD",
-          recentProjects_sessions_toggle: "\u67E5\u770B/\u7BA1\u7406\u8BE5\u9879\u76EE\u7684\u4F1A\u8BDD",
-          recentProjects_sessions_action: "\u67E5\u770B\u4F1A\u8BDD",
-          recentProjects_sessions_action_open: "\u6536\u8D77\u4F1A\u8BDD",
-          recentProjects_clearProject: "\u5220\u9664\u8BE5\u9879\u76EE\u7684\u5168\u90E8\u4F1A\u8BDD",
+          recentProjects_welcome: "\u7EE7\u7EED\u5DE5\u4F5C",
+          recentProjects_focusEyebrow: "\u4E0A\u6B21\u5BF9\u8BDD",
+          recentProjects_historyHeading: "\u5176\u4ED6\u6700\u8FD1\u5BF9\u8BDD",
+          recentProjects_historyHint: "\u70B9\u51FB\u6761\u76EE\u7EE7\u7EED",
+          recentProjects_projectConversations: "\u67E5\u770B\u8BE5\u9879\u76EE\u7684\u5168\u90E8\u5BF9\u8BDD",
+          recentProjects_allProjects: "\u6240\u6709\u9879\u76EE",
+          recentProjects_showAllConversations: "\u67E5\u770B\u5168\u90E8 {count} \u6BB5\u5BF9\u8BDD",
+          recentProjects_unstarted: "\u672A\u5F00\u59CB \xB7 {count}",
+          recentProjects_unstartedHint: "\u7A7A\u767D\u5BF9\u8BDD\u6536\u7EB3\u5728\u8FD9\u91CC\uFF0C\u8BB0\u5F55\u4E0D\u4F1A\u88AB\u5220\u9664\u3002",
+          recentProjects_noStarted: "\u5C1A\u65E0\u5DF2\u5F00\u59CB\u7684\u5BF9\u8BDD\uFF0C\u7A7A\u767D\u5BF9\u8BDD\u53EF\u5728\u4E0B\u65B9\u5C55\u5F00\u3002",
+          recentProjects_savedDraft: "\u8349\u7A3F\u5DF2\u4FDD\u5B58\uFF0C\u53EF\u7EE7\u7EED\u8865\u5145\u3002",
+          recentProjects_attention: "\u9700\u8981\u67E5\u770B",
+          recentProjects_unavailableRecords: "\u9879\u76EE\u94FE\u63A5\u4E0D\u53EF\u7528\u7684\u8BB0\u5F55",
+          recentProjects_loadingHistory: "\u6B63\u5728\u52A0\u8F7D\u5BF9\u8BDD\u2026",
+          recentProjects_loadFailed: "\u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\u5BF9\u8BDD\u5386\u53F2\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+          recentProjects_continueHint: "\u4EC5\u6253\u5F00\u8FD9\u6BB5\u5BF9\u8BDD\uFF0C\u4E0D\u4F1A\u81EA\u52A8\u542F\u52A8\u4EFB\u52A1\u3002",
+          recentProjects_more: "\u66F4\u591A\u9009\u9879",
+          recentProjects_continue: "\u7EE7\u7EED",
+          recentProjects_openProject: "\u6253\u5F00\u9879\u76EE",
+          recentProjects_loadingConversation: "\u6B63\u5728\u52A0\u8F7D\u5BF9\u8BDD\u2026",
+          recentProjects_noConversation: "\u6682\u65E0\u4FDD\u5B58\u7684\u5BF9\u8BDD",
+          recentProjects_noRuns: "\u5C1A\u672A\u8FD0\u884C\u4EFB\u52A1",
+          recentProjects_previewUnavailable: "\u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\u5BF9\u8BDD",
+          recentProjects_previewUnavailableHint: "\u5DF2\u4FDD\u5B58\u7684\u5BF9\u8BDD\u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\u3002",
+          recentProjects_conversationGone: "\u8BE5\u5BF9\u8BDD\u5DF2\u4E0D\u53EF\u7528\uFF0C\u8BF7\u4ECE\u66F4\u65B0\u540E\u7684\u5217\u8868\u4E2D\u9009\u62E9\u5176\u4ED6\u5BF9\u8BDD\u3002",
+          recentProjects_continueFailed: "\u6682\u65F6\u65E0\u6CD5\u6253\u5F00\u5BF9\u8BDD\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+          recentProjects_welcome_subtitle: "\u5F53\u524D\u6D4F\u89C8\u5668\u4FDD\u5B58\u7684\u5BF9\u8BDD",
+          recentProjects_empty: "\u5F53\u524D\u6D4F\u89C8\u5668\u8FD8\u6CA1\u6709\u4FDD\u5B58\u7684\u5BF9\u8BDD\u3002\u6253\u5F00\u4E00\u4E2A Overleaf \u9879\u76EE\uFF0C\u4E0E Codex \u5F00\u59CB\u5BF9\u8BDD\u5373\u53EF\u3002",
+          recentProjects_sessions_empty: "\u8BE5\u9879\u76EE\u8FD8\u6CA1\u6709\u4FDD\u5B58\u7684\u5BF9\u8BDD",
+          recentProjects_sessions_toggle: "\u67E5\u770B\u6216\u7BA1\u7406\u8BE5\u9879\u76EE\u7684\u5BF9\u8BDD",
+          recentProjects_sessions_action: "\u5168\u90E8\u5BF9\u8BDD",
+          recentProjects_sessions_action_open: "\u6536\u8D77\u5BF9\u8BDD",
+          recentProjects_clearProject: "\u5220\u9664\u8BE5\u9879\u76EE\u7684\u5168\u90E8\u5BF9\u8BDD",
           recentProjects_clearProject_title: "\u5220\u9664 {project} \u7684\u5168\u90E8 Codex \u4F1A\u8BDD\uFF1F",
           recentProjects_clearProject_message: "\u8FD9\u4F1A\u6C38\u4E45\u5220\u9664 {project} \u7684\u5168\u90E8 {count} \u4E2A\u63D2\u4EF6\u4F1A\u8BDD\u3001\u8FD0\u884C\u5386\u53F2\u53CA\u5BF9\u5E94\u7684\u63D2\u4EF6\u672C\u5730 Codex \u7EBF\u7A0B\u5386\u53F2\u3002\u4E0D\u4F1A\u4FEE\u6539 Overleaf \u6587\u4EF6\u6216\u5168\u5C40 Codex \u5386\u53F2\u3002",
           recentProjects_clearProject_confirm: "\u5168\u90E8\u5220\u9664",
@@ -5144,15 +5197,17 @@ ${block}`;
           recentProjects_degraded: "\u8BF7\u767B\u5F55 Overleaf \u540E\u67E5\u770B\u4F60\u6700\u8FD1\u7684 Codex \u9879\u76EE\u3002",
           recentProjects_row_projectLinkUnavailable: "\u9879\u76EE\u94FE\u63A5\u4E0D\u53EF\u7528\u3002",
           recentProjects_settings_entry: "\u8BBE\u7F6E\u4E0E\u8BCA\u65AD",
-          recentProjects_badge_pending: "\u5F85\u5904\u7406",
-          recentProjects_badge_accepted: "\u5DF2\u63A5\u53D7",
-          recentProjects_badge_rejected: "\u5DF2\u64A4\u56DE",
-          recentProjects_badge_needs_review: "\u5F85\u5904\u7406",
-          recentProjects_badge_running: "\u8FD0\u884C\u4E2D",
-          recentProjects_badge_completed: "\u5DF2\u5B8C\u6210",
-          recentProjects_badge_failed: "\u5931\u8D25",
-          recentProjects_badge_interrupted: "\u5DF2\u4E2D\u65AD",
-          recentProjects_badge_stale: "\u4E45\u672A\u5904\u7406",
+          recentProjects_settingsTitle: "\u901A\u7528\u8BBE\u7F6E",
+          recentProjects_settingsSubtitle: "\u7BA1\u7406\u9002\u7528\u4E8E\u6240\u6709\u9879\u76EE\u7684 Codex \u504F\u597D\u8BBE\u7F6E\u4E0E\u672C\u5730\u5386\u53F2\u8BB0\u5F55\u3002",
+          recentProjects_badge_pending: "\u4E0A\u6B21\u8FD0\u884C\u5F85\u5904\u7406",
+          recentProjects_badge_accepted: "\u4E0A\u6B21\u4FEE\u6539\u5DF2\u63A5\u53D7",
+          recentProjects_badge_rejected: "\u4E0A\u6B21\u4FEE\u6539\u5DF2\u64A4\u56DE",
+          recentProjects_badge_needs_review: "\u4E0A\u6B21\u8FD0\u884C\u9700\u8981\u68C0\u67E5",
+          recentProjects_badge_running: "\u4E0A\u6B21\u8BB0\u5F55\u4E3A\u8FD0\u884C\u4E2D",
+          recentProjects_badge_completed: "\u4E0A\u6B21\u8FD0\u884C\u5DF2\u5B8C\u6210",
+          recentProjects_badge_failed: "\u4E0A\u6B21\u8FD0\u884C\u5931\u8D25",
+          recentProjects_badge_interrupted: "\u4E0A\u6B21\u8FD0\u884C\u53EF\u80FD\u5DF2\u4E2D\u65AD",
+          recentProjects_badge_stale: "\u4E0A\u6B21\u8FD0\u884C\u72B6\u6001\u672A\u786E\u8BA4",
           recentProjects_unnamed: "\u9879\u76EE \xB7 {prefix}",
           recentProjects_zombieRunningNote: "\u6807\u8BB0\u4E3A\u8FD0\u884C\u4E2D\uFF0C\u4F46\u53EF\u80FD\u662F\u88AB\u4E2D\u65AD\u540E\u7684\u6B8B\u7559\u3002",
           recentProjects_zombieDeleteConfirm: "\u8BE5\u4F1A\u8BDD\u6807\u8BB0\u4E3A\u8FD0\u884C\u4E2D\u3002\u5982\u679C\u786E\u8BA4\u6CA1\u6709\u5176\u4ED6\u6807\u7B7E\u9875\u5728\u8FD0\u884C\u5B83\uFF0C\u53EF\u4EE5\u76F4\u63A5\u5220\u9664\u3002",
@@ -5160,9 +5215,9 @@ ${block}`;
           recentProjects_degraded_hint: "\u65E0\u6CD5\u8BC6\u522B\u672C\u9875\u7684 Overleaf \u8D26\u53F7\uFF0C\u4E3A\u907F\u514D\u8D26\u53F7\u95F4\u4E32\u6570\u636E\u5DF2\u9690\u85CF\u9879\u76EE\u5217\u8868\u3002\u901A\u5E38\u5237\u65B0\u5373\u53EF\u6062\u590D\u3002",
           recentProjects_sessionsCount: "{count} \u4E2A\u4F1A\u8BDD",
           recentProjects_welcome_stats: "{projects} \u4E2A\u9879\u76EE \xB7 {sessions} \u4E2A Codex \u4F1A\u8BDD",
-          recentProjects_badge_background_completed: "\u540E\u53F0\u5DF2\u5B8C\u6210",
-          recentProjects_badge_needs_review_after_navigation: "\u5F85\u5904\u7406",
-          recentProjects_badge_abandoned_after_navigation: "\u5DF2\u4E2D\u6B62"
+          recentProjects_badge_background_completed: "\u4E0A\u6B21\u8FD0\u884C\u5DF2\u5728\u540E\u53F0\u5B8C\u6210",
+          recentProjects_badge_needs_review_after_navigation: "\u4E0A\u6B21\u8FD0\u884C\u9700\u8981\u68C0\u67E5",
+          recentProjects_badge_abandoned_after_navigation: "\u4E0A\u6B21\u8FD0\u884C\u5DF2\u5728\u79BB\u5F00\u9875\u9762\u540E\u505C\u6B62"
         }
       };
       function normalizeLocale(value) {
@@ -7886,7 +7941,7 @@ ${block}`;
         if (!result || typeof result !== "object" || result.ok === false) return result;
         if (Array.isArray(result.skipped) && result.skipped.length > 0) return result;
         const expectedFiles = Array.isArray(run?.undoExpectedFiles) ? run.undoExpectedFiles : [];
-        if (!expectedFiles.length || isUndoVerifiedContentMatching(run, result)) return result;
+        if (!expectedFiles.length || isUndoVerifiedContentMatching(run, result, options2)) return result;
         const path = expectedFiles.find((entry) => typeof entry?.path === "string")?.path || "";
         appendSyntheticFailure(result, options2.buildFailure?.("undo_not_verified", { path, type: "undo" }, {
           changedDocument: true,
@@ -7895,12 +7950,13 @@ ${block}`;
         }), path, "undo_not_verified", "undo");
         return result;
       }
-      function isUndoVerifiedContentMatching(run, result) {
+      function isUndoVerifiedContentMatching(run, result, options2 = {}) {
         const expectedByPath = new Map((run?.undoExpectedFiles || []).filter((file) => typeof file?.path === "string" && typeof file?.content === "string").map((file) => [normalizeSettlementPath(file.path), file.content]).filter(([path]) => path));
         if (!expectedByPath.size) return true;
+        const postByPath = new Map((Array.isArray(options2?.postFiles) ? options2.postFiles : []).filter((file) => typeof file?.path === "string" && typeof file?.content === "string").map((file) => [normalizeSettlementPath(file.path), file.content]));
         const applied = Array.isArray(result?.applied) ? result.applied : [];
         return Array.from(expectedByPath).every(
-          ([path, expected]) => applied.some((entry) => isVerifiedUndoEntryForPath(entry, path, expected))
+          ([path, expected]) => applied.some((entry) => isVerifiedUndoEntryForPath(entry, path, expected, postByPath.get(path)))
         );
       }
       function isUndoResultEffectivelyApplied(run, result, undoOperations = []) {
@@ -7914,7 +7970,7 @@ ${block}`;
           (item) => isVerifiedUndoEntryForPath(item, path, expectedByPath.get(path))
         ));
       }
-      function isVerifiedUndoEntryForPath(entry, path, expectedContent) {
+      function isVerifiedUndoEntryForPath(entry, path, expectedContent, postContent) {
         const inner = entry?.result || {};
         if (inner.ok === false) return false;
         const normalizedPath = normalizeSettlementPath(path);
@@ -7929,7 +7985,12 @@ ${block}`;
           return inner.method === "overleaf-editor-undo" && inner.verified === true && inner.verifiedContent === expectedContent;
         }
         if (key === `snapshot-undo:${normalizedPath}`) {
-          return inner.verifiedContent === expectedContent;
+          if (inner.verifiedContent === expectedContent) return true;
+          const proof = inner.undoRebaseProof, before = proof?.beforeUndoContent;
+          if (inner.verified !== true || proof?.version !== 1 || normalizeSettlementPath(proof.path) !== normalizedPath || typeof before !== "string" || typeof postContent !== "string" || !postContent || typeof inner.verifiedContent !== "string") return false;
+          const start = before.indexOf(postContent);
+          if (start < 0 || before.indexOf(postContent, start + 1) >= 0) return false;
+          return inner.verifiedContent === before.slice(0, start) + expectedContent + before.slice(start + postContent.length);
         }
         return false;
       }
@@ -8775,6 +8836,7 @@ ${block}`;
           undoExpectedFiles: normalizeRunFiles(run.undoExpectedFiles),
           undoStatus: sanitizeAssistantVisibleText(run.undoStatus),
           nativeRequestId: sanitizeAssistantVisibleText(run.nativeRequestId),
+          codexThreadId: sanitizeAssistantVisibleText(run.codexThreadId),
           codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
           forkSnapshot: run.forkSnapshot === true,
           forkSourceRunId: sanitizeAssistantVisibleText(run.forkSourceRunId),
@@ -8792,6 +8854,9 @@ ${block}`;
         if (run.changedDocument === true) {
           normalized.changedDocument = true;
         }
+        if (Array.isArray(run.trackedChangeCaptures) && run.trackedChangeCaptures.length && !run.forkSnapshot) {
+          normalized.trackedChangeCaptures = sanitizeAssistantVisibleValue(run.trackedChangeCaptures);
+        }
         applyTrackedChangeStatus(normalized, run.trackedChangeStatus);
         return normalized;
       }
@@ -9226,6 +9291,7 @@ ${block}`;
           undoExpectedFiles: undoPayload.undoExpectedFiles,
           undoStatus: summarizeTextForStorage(run.undoStatus, "undo status"),
           nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
+          codexThreadId: normalizeTextField(run.codexThreadId, 160),
           codexTurnId: normalizeTextField(run.codexTurnId, 160),
           forkSnapshot: run.forkSnapshot === true,
           forkSourceRunId: normalizeTextField(run.forkSourceRunId, 160),
@@ -9558,6 +9624,7 @@ ${block}`;
         setActiveSession,
         updateActiveSession,
         normalizeRuns,
+        normalizeProjectReferenceFiles,
         prepareStateForStorage,
         estimateJsonBytes,
         computeSafeTaskSummary
@@ -9798,7 +9865,13 @@ ${block}`;
         } catch (_error) {
           return empty;
         }
-        return getUtf8ByteLength(serialized) <= MAX_PERSISTED_ACTION_BYTES_PER_RUN ? payload : empty;
+        if (getUtf8ByteLength(serialized) > MAX_PERSISTED_ACTION_BYTES_PER_RUN) return empty;
+        const captures = cloneSerializableArray(run.trackedChangeCaptures);
+        if (captures.length) {
+          const extended = { ...payload, trackedChangeCaptures: captures };
+          if (getUtf8ByteLength(JSON.stringify(extended)) <= MAX_PERSISTED_ACTION_BYTES_PER_RUN) return extended;
+        }
+        return payload;
       }
       function emptyActionPayload() {
         return {
@@ -9826,6 +9899,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",
@@ -9854,6 +9958,56 @@ ${block}`;
         }
         return out;
       }
+      function mergeSessionReviewState(incoming, existing, reviewRunIds) {
+        if (!existing || incoming.id !== existing.id || incoming.projectId !== existing.projectId || !incoming.accountScopeId || incoming.accountScopeId !== existing.accountScopeId) return incoming;
+        var terminal = (run) => ["accepted", "rejected"].includes(run?.trackedChangeStatus);
+        var incomingRuns = new Map((incoming.runs || []).map((run) => [run.id, run]));
+        var existingRuns = new Map((existing.runs || []).map((run) => [run.id, run]));
+        var requestedIds = new Set(reviewRunIds || []);
+        var explicitReview = Array.from(requestedIds).some((id) => ["accepted", "rejected", "needs_review"].includes(incomingRuns.get(id)?.trackedChangeStatus));
+        var newer = (Date.parse(incoming.updatedAt) || 0) >= (Date.parse(existing.updatedAt) || 0);
+        if (!newer && !explicitReview) return incoming;
+        var base = newer ? incoming : existing;
+        var fields = [
+          "trackedChangeStatus",
+          "undoStatus",
+          "undoTrackedChanges",
+          "undoExpectedFiles",
+          "undoOperations",
+          "undoBaseFiles",
+          "appliedOperations",
+          "trackedChangeCaptures",
+          "settlement",
+          "settlementFacts"
+        ];
+        var changed = false;
+        var runs = (base.runs || []).map(function(run) {
+          var previous = existingRuns.get(run.id), candidate = incomingRuns.get(run.id);
+          var source = terminal(previous) ? previous : explicitReview && requestedIds.has(run.id) ? candidate : null;
+          if (!source || source === run) return run;
+          if (source.runProjectId && source.runProjectId !== incoming.projectId) return run;
+          var merged2 = { ...run };
+          for (var field of fields) {
+            if (Object.prototype.hasOwnProperty.call(source, field)) {
+              merged2[field] = JSON.parse(JSON.stringify(source[field]));
+            } else {
+              delete merged2[field];
+            }
+          }
+          changed = true;
+          return merged2;
+        });
+        if (!changed) return base;
+        var merged = { ...base, runs };
+        if (explicitReview && !newer) {
+          merged.updatedAt = new Date(Math.max(
+            Date.now(),
+            Date.parse(existing.updatedAt) || 0,
+            Date.parse(incoming.updatedAt) || 0
+          ) + 1).toISOString();
+        }
+        return merged;
+      }
       function hashString(value) {
         var hash = 2166136261;
         var text = String(value || "");
@@ -9865,9 +10019,11 @@ ${block}`;
       }
       return {
         compactStructuredEventValue,
+        mergeSessionReviewState,
         compactRunsForStorage,
         compactRunActionPayload,
         compactProviderSnapshot,
+        compactRunExecutionSnapshot,
         hashString
       };
     });
@@ -9945,19 +10101,21 @@ ${block}`;
           require2("./storageRunActions"),
           require2("./runInputQueue"),
           require2("./settlementFacts"),
-          require2("./storageSessionClaims")
+          require2("./storageSessionClaims"),
+          require2("./sessionState")
         );
       } else {
         root.CodexOverleafModuleRegistry.define("StorageDb", [
           "StorageRunActions",
           "RunInputQueue",
           "SettlementFacts",
-          "StorageSessionClaims"
+          "StorageSessionClaims",
+          "SessionState"
         ], factory);
       }
-    })(typeof globalThis !== "undefined" ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue, SettlementFacts, StorageSessionClaims) {
+    })(typeof globalThis !== "undefined" ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue, SettlementFacts, StorageSessionClaims, SessionState) {
       "use strict";
-      if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot || !StorageRunActions?.compactStructuredEventValue || !StorageRunActions?.hashString || !RunInputQueue?.compactForStorage || !SettlementFacts?.compactSettlementFacts || !StorageSessionClaims?.createSessionClaimer) {
+      if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot || !StorageRunActions?.compactRunExecutionSnapshot || !StorageRunActions?.compactStructuredEventValue || !StorageRunActions?.hashString || !RunInputQueue?.compactForStorage || !SettlementFacts?.compactSettlementFacts || !StorageSessionClaims?.createSessionClaimer) {
         throw new Error("Codex Overleaf storage run-action helpers are unavailable.");
       }
       var TARGET_SCHEMA_VERSION = 3;
@@ -10225,6 +10383,7 @@ ${block}`;
           codexThreadId: typeof input.codexThreadId === "string" ? input.codexThreadId : "",
           status: typeof input.status === "string" && input.status ? input.status : "active",
           focusFiles: normalizePathList(input.focusFiles),
+          projectReferenceFiles: SessionState.normalizeProjectReferenceFiles(input.projectReferenceFiles),
           pendingInputs: RunInputQueue.compactForStorage(input.pendingInputs, {
             normalizeField: normalizeTextField,
             normalizeDisplay: normalizeDisplayTextForStorage,
@@ -10264,8 +10423,8 @@ ${block}`;
         }
       }
       function deriveSafeTaskSummaryFromInput(input) {
-        var SessionState = loadSessionState();
-        if (!SessionState || !(SessionState.computeSafeTaskSummary instanceof Function)) {
+        var SessionState2 = loadSessionState();
+        if (!SessionState2 || !(SessionState2.computeSafeTaskSummary instanceof Function)) {
           return "";
         }
         var task = typeof input.task === "string" && input.task ? input.task : "";
@@ -10275,7 +10434,7 @@ ${block}`;
             task = firstRun.task;
           }
         }
-        return SessionState.computeSafeTaskSummary(task);
+        return SessionState2.computeSafeTaskSummary(task);
       }
       var _sessionStateCache = null;
       function loadSessionState() {
@@ -10560,12 +10719,7 @@ ${block}`;
         });
       }
       function compactRunsForStorage(runs, options2) {
-        return StorageRunActions.compactRunsForStorage(
-          runs,
-          options2,
-          SESSION_STORAGE_LIMITS.maxRunsPerSession,
-          compactRunForStorage
-        );
+        return StorageRunActions.compactRunsForStorage(runs, options2, SESSION_STORAGE_LIMITS.maxRunsPerSession, compactRunForStorage);
       }
       function compactRunForStorage(run, keepActionPayload) {
         var actionPayload = StorageRunActions.compactRunActionPayload(run, keepActionPayload);
@@ -10574,6 +10728,9 @@ ${block}`;
           task: normalizeDisplayTextForStorage(run.task || "untitled task", SESSION_STORAGE_LIMITS.taskChars),
           mode: typeof run.mode === "string" ? redactSecretLikeText(run.mode) : "",
           ...StorageRunActions.compactProviderSnapshot(run),
+          ...StorageRunActions.compactRunExecutionSnapshot(run, function(text) {
+            return normalizeTextField(text, 4096);
+          }),
           model: normalizeTextField(run.model, 80),
           reasoningEffort: typeof run.reasoningEffort === "string" ? redactSecretLikeText(run.reasoningEffort) : "",
           speedTier: typeof run.speedTier === "string" ? redactSecretLikeText(run.speedTier) : "",
@@ -10589,8 +10746,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)
@@ -11149,6 +11308,7 @@ ${block}`;
         clearStore,
         clearAllStores,
         buildSessionRecord,
+        mergeSessionReviewState: StorageRunActions.mergeSessionReviewState,
         buildTurnRecord,
         buildEventRecord,
         buildArtifactRecord,
@@ -11775,7 +11935,7 @@ ${block}`;
       const MIN_NATIVE_VERSION = "1.0.0";
       const MIN_COMPATIBLE_NATIVE_VERSION = "1.0.0";
       const MIN_COMPATIBLE_EXTENSION_VERSION = "1.0.0";
-      const BUILD_TARGET_VERSION = "2.3.6";
+      const BUILD_TARGET_VERSION = "2.4.1";
       const DEFAULT_CHROME_EXTENSION_ID = "illdpneeeopfffmiepaejglgmhpmdhdc";
       const REQUIRED_CAPABILITIES = Object.freeze([
         "bridgePing",
@@ -12078,7 +12238,7 @@ ${block}`;
       if (root) root.CodexOverleafPageRpcContract = api;
     })(typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : this, function() {
       "use strict";
-      var REVISION = "2026-08-04-page-rpc-contract-v15";
+      var REVISION = "2026-09-14-native-text-upload-v28";
       var METHODS = freezeCatalog({
         initializeCapability: entry("bridge.initialize", "control", "none", "default", false, "none"),
         probe: entry("bridge.probe", "read", "none", "default", false, "safe"),
@@ -12095,6 +12255,7 @@ ${block}`;
         binaryUploadCommit: entry("asset.write", "document", "required", "writeback", true, "no_retry"),
         binaryUploadAbort: entry("asset.stage", "cache", "none", "default", false, "idempotent"),
         jumpToPosition: entry("editor.navigate", "navigation", "required", "default", false, "idempotent"),
+        reconcileTrackedChangeCapture: entry("tracked_changes.read", "read", "required", "default", false, "safe"),
         rejectTrackedChanges: entry("tracked_changes.reject", "document", "required", "lifecycle", true, "no_retry"),
         acceptTrackedChanges: entry("tracked_changes.accept", "document", "required", "lifecycle", true, "no_retry"),
         triggerCompile: entry("compile.trigger", "page_state", "required", "compile", false, "no_retry"),
@@ -13463,9 +13624,11 @@ ${block}`;
         ["src/page/overleafProjectSnapshot.js", "codex-overleaf-project-snapshot-script"],
         ["src/page/pageBridgeCapability.js", "codex-overleaf-page-bridge-capability-script"],
         ["src/page/treeOperations.js", "codex-overleaf-tree-operations-script", true],
+        ["src/page/textFileCreator.js", "codex-overleaf-text-file-creator-script", true],
         ["src/page/binaryAssetUploader.js", "codex-overleaf-binary-asset-uploader-script", true],
         ["src/page/snapshotRouter.js", "codex-overleaf-snapshot-router-script"],
         ["src/page/writeGuard.js", "codex-overleaf-write-guard-script", true],
+        ["src/page/trackedChangeCapture.js", "codex-overleaf-tracked-change-capture-script", true],
         ["src/page/trackedChangesLifecycle.js", "codex-overleaf-tracked-changes-lifecycle-script", true],
         ["src/page/writebackRouter.js", "codex-overleaf-writeback-router-script", true],
         ["src/pageBridge.js", "codex-overleaf-page-bridge-script", true]
@@ -13665,7 +13828,9 @@ ${block}`;
         async function dispatch(payload, channelMethod) {
           const compatibilityGate = await ensureForMethod(payload?.method);
           if (!compatibilityGate.ok) return compatibilityGate.response;
-          if (gatedMethods.has(payload?.method)) options2.throwIfCancellationRequested?.();
+          if (gatedMethods.has(payload?.method) && payload.method !== "mirror.invalidate") {
+            options2.throwIfCancellationRequested?.();
+          }
           return nativeChannel[channelMethod](
             attachEvidence(payload, compatibilityGate.compatibility)
           );
@@ -14318,8 +14483,10 @@ ${block}`;
           merged.applied.push(...Array.isArray(result?.applied) ? result.applied : []);
           merged.skipped.push(...Array.isArray(result?.skipped) ? result.skipped : []);
           merged.trackedChanges.push(...Array.isArray(result?.trackedChanges) ? result.trackedChanges : []);
+          if (result?.trackedChangeCaptures?.length) (merged.trackedChangeCaptures || (merged.trackedChangeCaptures = [])).push(...result.trackedChangeCaptures);
           if (result?.ok !== true) merged.ok = false;
         }
+        if (merged.trackedChangeCaptures?.some((capture) => capture.state !== "observed")) merged.trackedChanges = [];
         if (merged.skipped.length) merged.ok = false;
         return merged;
       }
@@ -15315,6 +15482,8 @@ ${block}`;
         saveState = null,
         saveStateSoon = () => {
         },
+        onProjectFilesReady = () => {
+        },
         updateActiveSession = defaultUpdateActiveSession,
         callPageBridge = () => Promise.resolve({ ok: false }),
         getCurrentProjectId = () => "",
@@ -15478,6 +15647,7 @@ ${block}`;
             renderContextFiles(contextProject);
             if (isExactContextFileListProject(contextProject)) {
               setContextSyncState("exact-ready");
+              onProjectFilesReady(contextProject);
             } else if (contextSyncState !== "partial") {
               setContextSyncState("exact-loading");
               void enhanceContextFilesFromExactSnapshot({ loadId: contextLoadId });
@@ -15499,6 +15669,7 @@ ${block}`;
             contextProject = project;
             setContextSyncState(isExactContextFileListProject(project) ? "exact-ready" : "exact-loading");
             renderContextFiles(project);
+            if (isExactContextFileListProject(project)) onProjectFilesReady(project);
             if (!isExactContextFileListProject(project)) {
               void enhanceContextFilesFromExactSnapshot({
                 force: Boolean(options2.force),
@@ -15556,6 +15727,7 @@ ${block}`;
             contextProject = project;
             setContextSyncState("exact-ready");
             renderContextFiles(project);
+            onProjectFilesReady(project);
           } catch (_error) {
             if (loadId === contextLoadId) {
               setContextSyncState("partial");
@@ -16756,6 +16928,20 @@ ${block}`;
         })) return { ok: false, reason: "ot_event_expired" };
         return { ok: true };
       }
+      function readOtBridgeStatus(response) {
+        if (!response || response.ok === false) return "unavailable";
+        return response.state || response.status || response.result?.state || response.result?.status || "unavailable";
+      }
+      function readOtBridgeEvents(response) {
+        if (Array.isArray(response)) return response;
+        if (Array.isArray(response?.events)) return response.events;
+        if (Array.isArray(response?.result?.events)) return response.result.events;
+        return [];
+      }
+      function readOtBridgeErrorCode(response, fallback) {
+        const value = response?.lastErrorCode || response?.reason || response?.error?.code || response?.error || fallback;
+        return typeof value === "string" ? value : fallback;
+      }
       function normalizeFailureCode(value, fallback = "ot_error") {
         const code = typeof value === "string" ? value : value?.code;
         if (/^[a-z][a-z0-9_]{0,79}$/.test(code || "")) return code;
@@ -16833,6 +17019,9 @@ ${block}`;
         takePatchBatch,
         validatePatchReceipt,
         normalizeFailureCode,
+        readOtBridgeStatus,
+        readOtBridgeEvents,
+        readOtBridgeErrorCode,
         getFailureMessageKey,
         buildPatchFilesRequest,
         canUseOtWarmStart,
@@ -17976,8 +18165,8 @@ ${block}`;
         <div class="codex-custom-instructions-head">
           <button type="button" data-settings-back title="Back" aria-label="Back">\u2039</button>
           <div>
-            <div class="codex-custom-instructions-title" data-i18n="projectSettingsTitle">Project Settings</div>
-            <div class="codex-custom-instructions-subtitle" data-i18n="projectSettingsSubtitle">Customize how Codex behaves in this and all projects.</div>
+            <div class="codex-custom-instructions-title" data-settings-title data-i18n="projectSettingsTitle">Project Settings</div>
+            <div class="codex-custom-instructions-subtitle" data-settings-subtitle data-i18n="projectSettingsSubtitle">Customize how Codex behaves in this and all projects.</div>
           </div>
         </div>
         <div class="codex-project-settings-status" data-project-settings-status></div>
@@ -18235,6 +18424,7 @@ ${block}`;
         if (!root) {
           return;
         }
+        refreshSettingsScope(instance, root);
         const button = getButton(instance);
         if (button) {
           button.dataset.active = "true";
@@ -18242,6 +18432,17 @@ ${block}`;
         }
         root.querySelector("[data-custom-instructions-input]")?.focus?.();
       }
+      function refreshSettingsScope(instance, root) {
+        const accountScope = instance.container?.closest?.("[data-settings-scope]")?.dataset?.settingsScope === "account";
+        const prefix = accountScope ? "recentProjects_settings" : "projectSettings";
+        for (const [selector, suffix] of [["[data-settings-title]", "Title"], ["[data-settings-subtitle]", "Subtitle"]]) {
+          const label = root.querySelector(selector);
+          if (!label) continue;
+          const key = prefix + suffix;
+          label.setAttribute("data-i18n", key);
+          label.textContent = t(instance, key);
+        }
+      }
       function hide(target) {
         const instance = target?._instance || target;
         const root = getRoot(instance);
@@ -18269,6 +18470,7 @@ ${block}`;
         if (!root) {
           return;
         }
+        refreshSettingsScope(instance, root);
         if (Object.prototype.hasOwnProperty.call(state, "customInstructions")) {
           const input = root.querySelector("[data-custom-instructions-input]");
           if (input) {
@@ -20132,7 +20334,12 @@ ${block}`;
           await Promise.all(deletedExisting.map((record) => StorageDb.deleteRecord("sessions", record.id)));
         }
         const existingById = new Map(existingSessions.filter((record) => !deleted.has(record.id)).map((record) => [record.id, record]));
-        const writable = sessionRecords.filter((record) => {
+        const mergedRecords = sessionRecords.map((record) => StorageDb.mergeSessionReviewState?.(
+          record,
+          existingById.get(record.id),
+          options2.reviewRunIds
+        ) || record);
+        const writable = mergedRecords.filter((record) => {
           const existing = existingById.get(record.id);
           if (!existing) return true;
           return (Date.parse(record.updatedAt || "") || 0) >= (Date.parse(existing.updatedAt || "") || 0);
@@ -20188,6 +20395,41 @@ ${block}`;
         }
         return JSON.parse(JSON.stringify(value));
       }
+      async function applyReviewTransition({ getState, runId, transition, persist }) {
+        const targets = () => Array.from(/* @__PURE__ */ new Set([
+          ...getState().runs || [],
+          ...(getState().sessions || []).flatMap((session) => session.runs || [])
+        ])).filter((run) => run.id === runId);
+        const records = targets();
+        const sessions = (getState().sessions || []).filter((session) => (session.runs || []).some((run) => run.id === runId));
+        if (!records.length || !sessions.length) throw reviewPersistenceError();
+        const previous = cloneSnapshot(records[0]);
+        for (const record of records) Object.assign(record, cloneSnapshot(transition));
+        for (const session of sessions) {
+          session.updatedAt = new Date(Math.max(
+            Date.now(),
+            (Date.parse(session.updatedAt) || 0) + 1,
+            (Date.parse(session.lastActivityAt) || 0) + 1
+          )).toISOString();
+          session.lastActivityAt = session.updatedAt;
+        }
+        try {
+          await persist({ preserveRunActionPayload: true, reviewRunIds: [runId] });
+        } catch (error) {
+          for (const record of targets()) {
+            Object.assign(record, cloneSnapshot(previous), { trackedChangeStatus: "needs_review" });
+            for (const field of ["settlement", "settlementFacts"]) {
+              if (!Object.prototype.hasOwnProperty.call(previous, field)) delete record[field];
+            }
+          }
+          throw error;
+        }
+      }
+      function reviewPersistenceError() {
+        return Object.assign(new Error("The review outcome was not durably saved. Check Overleaf before retrying."), {
+          code: "review_state_not_persisted"
+        });
+      }
       async function persistPanelState(input) {
         var state = cloneSnapshot(input.state || {});
         var compactState = cloneSnapshot(input.compactState || {});
@@ -20206,6 +20448,8 @@ ${block}`;
             code: "stale_view"
           });
         }
+        var reviewRuns = (input.reviewRunIds || []).map((id) => (state.sessions || []).flatMap((session) => session.runs || []).find((run) => run.id === id));
+        if (reviewRuns.some((run) => !run)) throw reviewPersistenceError();
         var latestPrefs = typeof Migration.loadPrefs === "function" ? await Migration.loadPrefs(accountScopeId, projectId) : {};
         var prefs = Object.assign(
           {},
@@ -20261,19 +20505,23 @@ ${block}`;
             })
           }), { preserveRunActionPayload: true });
         });
-        await input.SessionPersistence.writeSessions({
+        var written = await input.SessionPersistence.writeSessions({
           Migration,
           StorageDb,
           projectId,
           accountScopeId,
           deletedSessionIds,
           sessionRecords,
+          reviewRunIds: input.reviewRunIds,
           queueClaims: persistenceMeta.queueClaims || {},
           queueTombstones,
           writerId: input.persistenceContext?.writerId || ""
         });
+        if (!reviewRuns.every((reviewRun) => (written || []).some((session) => (session.runs || []).some(
+          (run) => run.id === reviewRun.id && run.trackedChangeStatus === reviewRun.trackedChangeStatus
+        )))) throw reviewPersistenceError();
       }
-      return Object.freeze({ persistPanelState });
+      return Object.freeze({ persistPanelState, applyReviewTransition });
     });
   }).call(globalThis, void 0, void 0, void 0);
   (function runClassicContentModule63(module, exports, require2) {
@@ -20412,7 +20660,8 @@ ${block}`;
       }
       return Object.freeze({
         createController,
-        persistPanelState: PanelState?.persistPanelState || null
+        persistPanelState: PanelState?.persistPanelState || null,
+        applyReviewTransition: PanelState?.applyReviewTransition || null
       });
     });
   }).call(globalThis, void 0, void 0, void 0);
@@ -20428,7 +20677,8 @@ ${block}`;
           container,
           callbacks: options2.callbacks || {},
           i18n: options2.i18n || {},
-          dismissInstalled: false
+          dismissInstalled: false,
+          cleanup: []
         };
         container.innerHTML = `
       <div class="codex-diagnostics-wrap">
@@ -20512,6 +20762,11 @@ ${block}`;
           instance.callbacks.onBeforeOpen?.();
         }
         popover.hidden = !open;
+        if (open) {
+          openFloating(instance, popover, 300);
+        } else {
+          hideFloating(popover);
+        }
         button.dataset.active = open ? "true" : "false";
         button.setAttribute("aria-expanded", open ? "true" : "false");
       }
@@ -20522,7 +20777,7 @@ ${block}`;
         if (!popover || !button) {
           return;
         }
-        popover.hidden = true;
+        hideFloating(popover);
         button.dataset.active = "false";
         button.setAttribute("aria-expanded", "false");
       }
@@ -20530,7 +20785,7 @@ ${block}`;
         const instance = target?._instance || target;
         const result = instance?.container?.querySelector("[data-diagnostics-result]");
         if (result) {
-          result.hidden = true;
+          hideFloating(result);
         }
       }
       function showLoading(target, title, subtitle) {
@@ -20586,6 +20841,65 @@ ${block}`;
         details.open = false;
         details.hidden = !technicalText;
         technical.textContent = technicalText;
+        closeMenu(instance);
+        openFloating(instance, root, 560);
+      }
+      function openFloating(instance, element, preferredWidth) {
+        if (element.isConnected === false) return;
+        element.hidden = false;
+        if (typeof element.showPopover === "function") {
+          element.setAttribute("popover", "manual");
+          try {
+            if (!element.matches(":popover-open")) element.showPopover();
+          } catch (_error) {
+            element.removeAttribute("popover");
+          }
+        }
+        positionFloating(instance, element, preferredWidth);
+      }
+      function hideFloating(element) {
+        if (!element) return;
+        if (typeof element.hidePopover === "function" && element.getAttribute("popover") === "manual") {
+          try {
+            if (element.matches(":popover-open")) element.hidePopover();
+          } catch (_error) {
+            element.removeAttribute("popover");
+          }
+        }
+        element.hidden = true;
+      }
+      function positionFloating(instance, element, preferredWidth) {
+        if (!element || element.hidden) return;
+        const button = instance.container.querySelector("[data-diagnostics-menu]");
+        if (!button?.getBoundingClientRect || !element.getBoundingClientRect) return;
+        if (button.getClientRects && !button.getClientRects().length) {
+          closeMenu(instance);
+          closeResult(instance);
+          return;
+        }
+        const doc = instance.container.ownerDocument || document;
+        const view = doc.defaultView || window;
+        const viewport = view.visualViewport;
+        const width = viewport?.width || view.innerWidth || doc.documentElement?.clientWidth;
+        const height = viewport?.height || view.innerHeight || doc.documentElement?.clientHeight;
+        if (!(width > 0 && height > 0)) return;
+        const margin = 12;
+        const gap = 8;
+        const leftEdge = (viewport?.offsetLeft || 0) + margin;
+        const topEdge = (viewport?.offsetTop || 0) + margin;
+        const rightEdge = leftEdge + Math.max(0, width - margin * 2);
+        const bottomEdge = topEdge + Math.max(0, height - margin * 2);
+        element.style.width = `${Math.min(preferredWidth, Math.max(0, width - margin * 2))}px`;
+        element.style.maxHeight = `${Math.min(640, Math.max(0, height - margin * 2))}px`;
+        const anchor = button.getBoundingClientRect();
+        const bounds = element.getBoundingClientRect();
+        const below = Math.max(0, bottomEdge - anchor.bottom - gap);
+        const above = Math.max(0, anchor.top - topEdge - gap);
+        const desiredTop = bounds.height > below && above > below ? anchor.top - gap - bounds.height : anchor.bottom + gap;
+        element.style.left = `${Math.max(leftEdge, Math.min(anchor.right - bounds.width, rightEdge - bounds.width))}px`;
+        element.style.top = `${Math.max(topEdge, Math.min(desiredTop, bottomEdge - bounds.height))}px`;
+        element.style.right = "auto";
+        element.style.bottom = "auto";
       }
       function renderInstallCommand(instance, container, command) {
         const wrap = document.createElement("div");
@@ -20660,13 +20974,60 @@ ${block}`;
           return;
         }
         instance.dismissInstalled = true;
-        document.addEventListener("click", (event) => {
+        const doc = instance.container.ownerDocument || document;
+        const view = doc.defaultView || window;
+        const listen = (target, type, handler, options2) => {
+          if (!target?.addEventListener) return;
+          target.addEventListener(type, handler, options2);
+          instance.cleanup.push(() => target.removeEventListener(type, handler, options2));
+        };
+        listen(doc, "click", (event) => {
           const wrap = instance.container?.querySelector(".codex-diagnostics-wrap");
           if (!wrap || wrap.contains(event.target)) {
             return;
           }
           closeMenu(instance);
         }, true);
+        listen(doc, "keydown", (event) => {
+          if (event.key !== "Escape") return;
+          const menu = instance.container.querySelector("[data-diagnostics-popover]");
+          const result = instance.container.querySelector("[data-diagnostics-result]");
+          if (menu && !menu.hidden) closeMenu(instance);
+          else if (result && !result.hidden) closeResult(instance);
+          else return;
+          event.preventDefault();
+          event.stopPropagation();
+          instance.container.querySelector("[data-diagnostics-menu]")?.focus();
+        }, true);
+        let frame = null;
+        const reposition = () => {
+          frame = null;
+          positionFloating(instance, instance.container.querySelector("[data-diagnostics-popover]"), 300);
+          positionFloating(instance, instance.container.querySelector("[data-diagnostics-result]"), 560);
+        };
+        const schedule = () => {
+          if (frame !== null) return;
+          if (view.requestAnimationFrame) frame = view.requestAnimationFrame(reposition);
+          else reposition();
+        };
+        listen(view, "resize", schedule);
+        listen(doc, "scroll", schedule, true);
+        listen(view.visualViewport, "resize", schedule);
+        listen(view.visualViewport, "scroll", schedule);
+        if (typeof view.ResizeObserver === "function") {
+          const observer = new view.ResizeObserver(schedule);
+          for (const node of [
+            instance.container.closest("#codex-overleaf-panel") || instance.container,
+            instance.container.querySelector("[data-diagnostics-popover]"),
+            instance.container.querySelector("[data-diagnostics-result]")
+          ]) {
+            if (node) observer.observe(node);
+          }
+          instance.cleanup.push(() => observer.disconnect());
+        }
+        instance.cleanup.push(() => {
+          if (frame !== null) view.cancelAnimationFrame?.(frame);
+        });
       }
       const HEALTH_STATES = ["ok", "warn", "fail", "unknown"];
       function updateStatus(target, status = {}) {
@@ -20823,6 +21184,10 @@ ${block}`;
         return key;
       }
       function destroy(instance) {
+        closeMenu(instance);
+        closeResult(instance);
+        for (const cleanup of instance.cleanup || []) cleanup();
+        instance.cleanup = [];
         instance.container.textContent = "";
       }
       window.CodexOverleafDiagnosticsPanel = {
@@ -21290,6 +21655,7 @@ ${block}`;
               const raw = entry?.event || {};
               if (raw.type === "codex.turn.bound") {
                 session.codexThreadId = String(raw.detail?.threadId || session.codexThreadId || "");
+                record.codexThreadId = String(raw.detail?.threadId || record.codexThreadId || "");
                 record.codexTurnId = String(raw.detail?.turnId || record.codexTurnId || "");
                 record.nativeEventSeq = sequence;
                 continue;
@@ -29322,6 +29688,8 @@ failedAt: ${new Date(failure.at).toISOString()}`;
               lines.push(`CodeMirror: docLength=${view.docLength || 0}; dispatch=${Boolean(view.hasDispatch)}; source=${view.source || "unknown"}`);
             }
           }
+          const capture = probe?.trackedChangeCapture;
+          if (capture) lines.push(tx("Tracked ledger: ", "\u7559\u75D5\u8BB0\u5F55\uFF1A") + "source=" + capture.source + "; ready=" + capture.ready + "; count=" + capture.count + "; doc=" + (capture.docId || "none") + "; adapter=" + capture.adapter + "; reason=" + (capture.reason || "none"));
           const projectDiagnostics = probe?.projectDiagnostics;
           if (projectDiagnostics) {
             lines.push(`Project records: ${projectDiagnostics.docRecordCount || 0}; roots=${(projectDiagnostics.internalRootKeys || []).slice(0, 6).join(", ") || "none"}`);
@@ -29548,7 +29916,17 @@ failedAt: ${new Date(failure.at).toISOString()}`;
           textarea.remove();
           if (!copied) throw new Error("clipboard_copy_failed");
         }
-        return Object.freeze({ configureResultActions });
+        return Object.freeze({ configureResultActions, projectUndoAvailability });
+      }
+      function projectUndoAvailability(run, projectRunSettlement) {
+        const payload = run.recoveryPayload && typeof run.recoveryPayload === "object" ? run.recoveryPayload : run;
+        if (!Array.isArray(payload.appliedOperations)) return projectRunSettlement(run);
+        const appliedOperations = payload.appliedOperations.filter((operation) => operation?.type !== "binary-create" && operation?.type !== "overwrite-binary");
+        if (appliedOperations.length === payload.appliedOperations.length) return projectRunSettlement(run);
+        return projectRunSettlement({
+          ...run,
+          recoveryPayload: { ...payload, appliedOperations }
+        });
       }
       return Object.freeze({ create });
     });
@@ -30580,7 +30958,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;
@@ -30596,11 +30974,11 @@ ${conclusion}` : `${label} ${conclusion}`;
         }
         function configureLifecycleUndoButton(button, run) {
           const status = run.trackedChangeStatus || "";
+          const inFlight = trackedChangeInFlight.get(run.id);
           const projection = projectRunSettlement(run);
           if (status === "needs_review") {
-            const inFlight2 = trackedChangeInFlight.get(run.id);
             button.hidden = false;
-            button.disabled = !projection.canUndo || inFlight2 === "reject" || inFlight2 === "accept";
+            button.disabled = !projection.canUndo || inFlight === "reject" || inFlight === "accept";
             button.textContent = tr("undoRun");
             button.title = tr("undoRunTitle");
             button.addEventListener("click", (event) => {
@@ -30609,25 +30987,24 @@ ${conclusion}` : `${label} ${conclusion}`;
             });
             return;
           }
-          if (status === "rejected") {
+          if (status === "rejected" && !inFlight) {
             button.hidden = false;
             button.disabled = true;
             button.textContent = tr("undoApplied");
             button.title = tr("undoAppliedTitle");
             return;
           }
-          if (status === "accepted") {
+          if (status === "accepted" && !inFlight) {
             button.hidden = false;
             button.disabled = true;
             button.textContent = tr("undoRun");
             button.title = tr("undoRunTitle");
             return;
           }
-          if (status !== "pending") {
+          if (status !== "pending" && !inFlight) {
             button.hidden = true;
             return;
           }
-          const inFlight = trackedChangeInFlight.get(run.id);
           button.hidden = false;
           button.disabled = !projection.canUndo || inFlight === "reject" || inFlight === "accept";
           button.textContent = tr("undoRun");
@@ -30653,12 +31030,12 @@ ${conclusion}` : `${label} ${conclusion}`;
             return;
           }
           const status = run.trackedChangeStatus || "";
+          const inFlight = trackedChangeInFlight.get(run.id);
           const projection = projectRunSettlement(run);
           if (status === "needs_review") {
-            const inFlight2 = trackedChangeInFlight.get(run.id);
             button.hidden = false;
-            button.disabled = !projection.canAccept || inFlight2 === "accept" || inFlight2 === "reject";
-            if (inFlight2 === "accept") {
+            button.disabled = !projection.canAccept || inFlight === "accept" || inFlight === "reject";
+            if (inFlight === "accept") {
               button.textContent = tr("runAcceptTrackedConfirming");
               button.title = tr("runAcceptTrackedConfirming");
               return;
@@ -30668,25 +31045,24 @@ ${conclusion}` : `${label} ${conclusion}`;
             wireAcceptInlineConfirm(button, run.id);
             return;
           }
-          if (status === "accepted") {
+          if (status === "accepted" && !inFlight) {
             button.hidden = false;
             button.disabled = true;
             button.textContent = tr("runAcceptTrackedDone");
             button.title = tr("runAcceptTrackedDoneTitle");
             return;
           }
-          if (status === "rejected") {
+          if (status === "rejected" && !inFlight) {
             button.hidden = false;
             button.disabled = true;
             button.textContent = tr("runAcceptTracked");
             button.title = tr("runAcceptTrackedTitle");
             return;
           }
-          if (status !== "pending") {
+          if (status !== "pending" && !inFlight) {
             button.hidden = true;
             return;
           }
-          const inFlight = trackedChangeInFlight.get(run.id);
           button.hidden = false;
           button.disabled = !projection.canAccept || inFlight === "accept" || inFlight === "reject";
           if (inFlight === "accept") {
@@ -31578,19 +31954,26 @@ ${conclusion}` : `${label} ${conclusion}`;
           const source = findSource(previousState, runId);
           if (!source) return failFork("session_fork_source_missing", tr("forkRunUnavailable"));
           const { session, run, runIndex } = source;
-          if (run.status === "running" || !session.codexThreadId || !run.codexTurnId) {
+          const draftThreadId = run.codexTurnId && run.interruptedDraft?.turnId === run.codexTurnId ? run.interruptedDraft.threadId : "";
+          const sourceThreadId = String(run.codexThreadId || draftThreadId || session.codexThreadId || "").trim();
+          if (run.status === "running" || !sourceThreadId || !run.codexTurnId) {
             return failFork("session_fork_unavailable", tr("forkRunUnavailable"));
           }
-          const response = await sendBackgroundNative({
-            method: "codex.thread.fork",
-            params: {
-              threadId: session.codexThreadId,
-              lastTurnId: run.codexTurnId,
-              speedTier: session.speedTier,
-              loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
-              loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false
-            }
-          });
+          let response;
+          try {
+            response = await sendBackgroundNative({
+              method: "codex.thread.fork",
+              params: {
+                threadId: sourceThreadId,
+                lastTurnId: run.codexTurnId,
+                speedTier: session.speedTier,
+                loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
+                loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false
+              }
+            });
+          } catch (error) {
+            return failFork(error?.code || "session_fork_failed", error?.message || tr("forkRunFailed"));
+          }
           if (!response?.ok || !response.result?.threadId) {
             return failFork(response?.error?.code || "session_fork_failed", response?.error?.message || tr("forkRunFailed"));
           }
@@ -32027,11 +32410,45 @@ ${conclusion}` : `${label} ${conclusion}`;
       function formatCompactModelLabel(label) {
         return String(label || "").replace(/^gpt[-\s]*/i, "");
       }
-      function retainSelectedModel(models, selectedModel) {
+      function retainSelectedModel(models, selectedModel, options2 = {}) {
         const selectedId = normalizeModelOptionId(selectedModel);
         if (!selectedId) return "";
+        if (options2.preserveUnavailable === true) return selectedId;
         return (Array.isArray(models) ? models : []).some((model) => normalizeModelOptionId(typeof model === "string" ? model : model?.id) === selectedId) ? selectedId : "";
       }
+      function preserveSelectedCapabilities(models, selectedModel, preferences = {}, provisional = false) {
+        const selectedId = normalizeModelOptionId(selectedModel);
+        const saved = preferences || {};
+        return (Array.isArray(models) ? models : []).map((model) => {
+          if (model.id !== selectedId || !provisional && !model.unverified) return model;
+          const reasoningEfforts = normalizeReasoningEffortsForSelect([
+            ...model.reasoningEfforts || [],
+            saved.reasoningEffort
+          ]);
+          const speedTiers = normalizeSpeedTiersForSelect(model.speedTiers);
+          const speed = ["standard", "fast"].includes(saved.speedTier) ? saved.speedTier : "";
+          if (speed && !speedTiers.includes(speed)) speedTiers.push(speed);
+          return {
+            ...model,
+            unverified: true,
+            reasoningEfforts,
+            speedTiers,
+            defaultReasoningEffort: reasoningEfforts.includes(saved.reasoningEffort) ? saved.reasoningEffort : model.defaultReasoningEffort,
+            defaultSpeedTier: speed || model.defaultSpeedTier || "standard"
+          };
+        });
+      }
+      function getRenderedModelEntries(panel) {
+        return Array.from(panel?.querySelector("[data-model]")?.options || []).map((option) => ({
+          id: option.value,
+          label: option.textContent,
+          reasoningEfforts: (option.dataset.reasoningEfforts || "").split(",").filter(Boolean),
+          defaultReasoningEffort: option.dataset.defaultReasoningEffort || "",
+          reasoningPresentation: option.dataset.reasoningPresentation || "",
+          speedTiers: (option.dataset.speedTiers || "standard").split(",").filter(Boolean),
+          defaultSpeedTier: option.dataset.defaultSpeedTier || "standard"
+        }));
+      }
       function shouldUseBuiltInFallback(response) {
         const providerId = normalizeModelOptionId(response?.result?.providerId);
         return response?.ok === true && (!providerId || providerId === "builtin");
@@ -32100,6 +32517,8 @@ ${conclusion}` : `${label} ${conclusion}`;
         normalizeReasoningEffortsForSelect,
         normalizeSpeedTiersForSelect,
         retainSelectedModel,
+        preserveSelectedCapabilities,
+        getRenderedModelEntries,
         shouldUseBuiltInFallback
       };
       return api;
@@ -32222,7 +32641,8 @@ ${conclusion}` : `${label} ${conclusion}`;
               return { stale: false, error: response?.error || { code: "provider_models_unavailable" } };
             }
             const sourceModels = hasDiscoveredModels ? response.result.models : fallbackModels;
-            const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel);
+            const preserveBuiltin = (selection?.providerId || "builtin") === "builtin" && (getState()?.providerId || "builtin") === "builtin";
+            const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel, { preserveUnavailable: preserveBuiltin });
             const normalized = modelCatalog.normalizeDiscoveredModels({ models: sourceModels, selectedModel: retainedSelectedModel });
             if (normalized.usedFallback && response.result?.providerId && response.result.providerId !== "builtin") {
               applyUnavailableModelOptions({ code: "provider_model_catalog_invalid", message: "The active provider returned no usable models." });
@@ -32231,9 +32651,10 @@ ${conclusion}` : `${label} ${conclusion}`;
                 error: { code: "provider_model_catalog_invalid", message: "The active provider returned no usable models." }
               };
             }
-            renderModelOptions(normalized.models, retainedSelectedModel, { allowUnknownSelected: false });
+            const renderedModels = preserveBuiltin ? Support.preserveSelectedCapabilities(normalized.models, retainedSelectedModel, getState(), !hasDiscoveredModels || response.result?.source === "fallback") : normalized.models;
+            renderModelOptions(renderedModels, retainedSelectedModel, { allowUnknownSelected: false });
             modelDiscovery = {
-              status: hasDiscoveredModels && !normalized.usedFallback ? "discovered" : "fallback",
+              status: hasDiscoveredModels && !normalized.usedFallback && response.result?.source !== "fallback" ? "discovered" : "fallback",
               source: hasDiscoveredModels ? response.result?.source || "unknown" : "fallback",
               fetchedAt: hasDiscoveredModels ? response.result?.fetchedAt || "" : "",
               errorCode: hasDiscoveredModels ? "" : response?.error?.code || "",
@@ -32259,15 +32680,16 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
         }
         function applyUnavailableModelOptions(error) {
+          const selectedModel = resolveSelectedModel();
           const modelSelect = getPanel()?.querySelector("[data-model]");
           if (modelSelect) {
             modelSelect.textContent = "";
             const option = document.createElement("option");
-            option.value = resolveSelectedModel();
+            option.value = selectedModel;
             option.textContent = tx("Models unavailable", "\u6A21\u578B\u4E0D\u53EF\u7528");
             option.disabled = true;
             modelSelect.append(option);
-            modelSelect.value = "";
+            modelSelect.value = selectedModel;
             modelSelect.disabled = true;
           }
           modelDiscovery = {
@@ -32277,8 +32699,18 @@ ${conclusion}` : `${label} ${conclusion}`;
             errorCode: error?.code || "",
             errorMessage: error?.message || (error ? String(error) : "")
           };
-          renderReasoningOptions([]);
-          renderSpeedOptions([]);
+          const pendingModels = Support.preserveSelectedCapabilities(
+            [{ id: selectedModel, unverified: true }],
+            selectedModel,
+            getState(),
+            true
+          );
+          renderReasoningOptions(pendingModels);
+          renderSpeedOptions(pendingModels);
+          for (const selector of ["[data-reasoning]", "[data-speed]"]) {
+            const input = getPanel()?.querySelector(selector);
+            if (input) input.disabled = true;
+          }
           renderModelConfigChoices();
           updateModelDisplay();
         }
@@ -32286,9 +32718,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",
@@ -32723,6 +33155,7 @@ ${conclusion}` : `${label} ${conclusion}`;
         });
         const PROJECT_NAME_CACHE_STORAGE_KEY = "projectNameCacheByAccount";
         let projectNameCacheMirror = {};
+        let dashboardRenderGeneration = 0;
         function loadProjectNameCacheFromStorage() {
           return new Promise(function(resolve) {
             try {
@@ -32806,7 +33239,7 @@ ${conclusion}` : `${label} ${conclusion}`;
               await persistProjectNameCacheToStorage();
               var visibleList = getPanel() && getPanel().querySelector("[data-recent-projects-list]");
               if (visibleList) {
-                var rows = visibleList.querySelectorAll("[data-recent-projects-row]");
+                var rows = visibleList.querySelectorAll("[data-project-id]");
                 for (var k = 0; k < rows.length; k++) {
                   var row = rows[k];
                   var rowPid = row.getAttribute("data-project-id");
@@ -32815,6 +33248,7 @@ ${conclusion}` : `${label} ${conclusion}`;
                     var cached = lookupProjectName(rowPid);
                     if (cached) {
                       nameEl.textContent = cached;
+                      nameEl.title = cached;
                     }
                   }
                 }
@@ -32883,54 +33317,47 @@ ${conclusion}` : `${label} ${conclusion}`;
           var hr = Math.round(min / 60);
           if (hr < 24) return tx(hr + " hr ago", hr + " \u5C0F\u65F6\u524D");
           var day = Math.round(hr / 24);
-          if (day < 30) return tx(day + " day ago", day + " \u5929\u524D");
+          if (day < 30) return tx(day + (day === 1 ? " day ago" : " days ago"), day + " \u5929\u524D");
           var month = Math.round(day / 30);
           if (month < 12) return tx(month + " mo ago", month + " \u4E2A\u6708\u524D");
           var year = Math.round(month / 12);
           return tx(year + " yr ago", year + " \u5E74\u524D");
         }
-        function textNode(text, className) {
-          var el = document.createElement("span");
-          if (className) {
-            el.className = className;
-          }
-          el.textContent = text == null ? "" : String(text);
+        function createViewElement(tag, className, text) {
+          var el = document.createElement(tag);
+          if (className) el.className = className;
+          if (text !== void 0) el.textContent = text;
           return el;
         }
-        function renderWelcomeHeader(stats) {
-          var el = document.createElement("div");
-          el.className = "recent-projects-welcome";
+        function createViewButton(label, onClick, attribute, className) {
+          var button = createViewElement("button", className, label);
+          button.type = "button";
+          if (attribute) button.setAttribute(attribute, "");
+          if (onClick) button.addEventListener("click", onClick);
+          return button;
+        }
+        function textNode(text, className) {
+          return createViewElement("span", className, text == null ? "" : String(text));
+        }
+        function renderWelcomeHeader() {
+          var el = createViewElement("div", "recent-projects-welcome");
           el.setAttribute("data-recent-projects-welcome", "");
-          var title = document.createElement("div");
-          title.className = "recent-projects-welcome-title";
-          title.textContent = tr("recentProjects_welcome");
-          var subtitle = document.createElement("div");
-          subtitle.className = "recent-projects-welcome-subtitle";
-          subtitle.textContent = stats && stats.projectCount ? tr("recentProjects_welcome_stats", { projects: stats.projectCount, sessions: stats.sessionTotal }) : tr("recentProjects_welcome_subtitle");
-          el.appendChild(title);
-          el.appendChild(subtitle);
+          el.appendChild(textNode("CODEX", "recent-projects-eyebrow"));
+          el.appendChild(textNode(tr("recentProjects_welcome"), "recent-projects-welcome-title"));
+          el.appendChild(textNode(tr("recentProjects_welcome_subtitle"), "recent-projects-welcome-subtitle"));
           return el;
         }
         function renderEmptyState() {
-          var el = document.createElement("div");
-          el.className = "recent-projects-empty";
+          var el = createViewElement("div", "recent-projects-empty", tr("recentProjects_empty"));
           el.setAttribute("data-recent-projects-empty", "");
-          el.textContent = tr("recentProjects_empty");
           return el;
         }
         function renderDegradedState() {
-          var el = document.createElement("div");
-          el.className = "recent-projects-degraded";
+          var el = createViewElement("div", "recent-projects-degraded");
           el.setAttribute("data-recent-projects-degraded", "");
-          var hint = document.createElement("div");
-          hint.textContent = tr("recentProjects_degraded_hint");
+          var hint = createViewElement("div", "", tr("recentProjects_degraded_hint"));
           el.appendChild(hint);
-          var retry = document.createElement("button");
-          retry.type = "button";
-          retry.className = "recent-projects-show-all";
-          retry.setAttribute("data-recent-projects-retry", "");
-          retry.textContent = tr("recentProjects_retryScope");
-          retry.addEventListener("click", function() {
+          var retry = createViewButton(tr("recentProjects_retryScope"), function() {
             if (typeof refreshAccountScopeId === "function") {
               Promise.resolve(refreshAccountScopeId()).then(function() {
                 return renderRecentProjectsVariant();
@@ -32939,24 +33366,17 @@ ${conclusion}` : `${label} ${conclusion}`;
             } else {
               renderRecentProjectsVariant();
             }
-          });
+          }, "data-recent-projects-retry", "recent-projects-show-all");
           el.appendChild(retry);
           return el;
         }
         function renderSettingsEntry(options2) {
           var scope = options2 && options2.scope === "account" ? "account" : "project";
-          var entry = document.createElement("button");
-          entry.type = "button";
-          entry.className = "recent-projects-settings-entry";
-          entry.setAttribute("data-recent-projects-settings-entry", "");
-          entry.setAttribute("data-settings-scope", scope);
-          var label = document.createElement("span");
-          label.className = "recent-projects-settings-entry-label";
-          label.textContent = tr("recentProjects_settings_entry");
-          entry.appendChild(label);
-          entry.addEventListener("click", function() {
+          var entry = createViewButton(void 0, function() {
             openSettingsInScope(scope);
-          });
+          }, "data-recent-projects-settings-entry", "recent-projects-settings-entry");
+          entry.setAttribute("data-settings-scope", scope);
+          entry.appendChild(textNode(tr("recentProjects_settings_entry"), "recent-projects-settings-entry-label"));
           return entry;
         }
         function openSettingsInScope(scope) {
@@ -32979,10 +33399,8 @@ ${conclusion}` : `${label} ${conclusion}`;
         function renderStatusBadge(status) {
           var safeStatus = typeof status === "string" && STATUS_BADGE_CLASS[status] ? status : "pending";
           var cls = STATUS_BADGE_CLASS[safeStatus];
-          var el = document.createElement("span");
-          el.className = "recent-projects-row-badge " + cls;
+          var el = textNode(tr("recentProjects_badge_" + safeStatus), "recent-projects-row-badge " + cls);
           el.setAttribute("data-status", safeStatus);
-          el.textContent = tr("recentProjects_badge_" + safeStatus);
           return el;
         }
         function isValidProjectId(id) {
@@ -32994,121 +33412,137 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
           window.location.assign("https://www.overleaf.com/project/" + encodeURIComponent(projectId));
         }
+        function renderActionsMenu(buttons) {
+          var menu = createViewElement("details", "recent-projects-menu");
+          var trigger = createViewElement("summary", "", "\u22EF");
+          trigger.title = tr("recentProjects_more");
+          trigger.setAttribute("aria-label", tr("recentProjects_more"));
+          var actions = document.createElement("div");
+          actions.setAttribute("data-recent-menu-actions", "");
+          buttons.forEach(function(button) {
+            actions.appendChild(button);
+          });
+          actions.addEventListener("click", function(event) {
+            if (event.target.closest("button")) {
+              menu.open = false;
+              trigger.focus();
+            }
+          }, true);
+          menu.appendChild(trigger);
+          menu.appendChild(actions);
+          menu.addEventListener("keydown", function(event) {
+            if (event.key === "Escape") {
+              event.preventDefault();
+              event.stopPropagation();
+              menu.open = false;
+              trigger.focus();
+            }
+          });
+          menu.addEventListener("focusout", function(event) {
+            if (event.relatedTarget && !menu.contains(event.relatedTarget)) menu.open = false;
+          });
+          return menu;
+        }
+        function conversationActivity(record) {
+          return String(record && (record.lastActivityAt || record.updatedAt || record.createdAt) || "");
+        }
+        function conversationHasContent(record) {
+          return ["runs", "history", "pendingInputs"].some(function(key) {
+            return Array.isArray(record[key]) && record[key].length > 0;
+          }) || ["task", "safeTaskSummary", "codexThreadId"].some(function(key) {
+            return typeof record[key] === "string" && Boolean(record[key].trim());
+          }) || record.titleSource === "manual" && typeof record.title === "string" && Boolean(record.title.trim());
+        }
+        function conversationStatus(record) {
+          if (!StorageDb || !Array.isArray(record.runs) || !record.runs.length) return "";
+          return settleDashboardRunStatus(StorageDb.derivePrimaryStatusBadge(record), conversationActivity(record));
+        }
+        function projectDisplayName(projectId) {
+          return lookupProjectName(projectId) || (isValidProjectId(projectId) ? tr("recentProjects_unnamed", { prefix: projectId.slice(0, 8) }) : tr("recentProjects_row_projectLinkUnavailable"));
+        }
+        async function loadDashboardConversations(scope) {
+          if (!scope || !StorageDb) throw new Error("Conversation storage is unavailable.");
+          var results = await Promise.all([StorageDb.getAllSessions(), SessionPersistence.loadTombstones()]);
+          var records = results[0];
+          var deletedByProject = results[1] || {};
+          if (!Array.isArray(records)) throw new Error("Conversation history could not be read.");
+          return records.filter(function(record) {
+            if (!record || typeof record.id !== "string" || !record.id || record.accountScopeUnavailable === true) return false;
+            var deletedIds = Object.prototype.hasOwnProperty.call(deletedByProject, record.projectId) ? deletedByProject[record.projectId] : [];
+            return SessionPersistence.isVisibleRecord(record, Array.isArray(deletedIds) ? deletedIds : [], scope);
+          }).sort(function(a, b) {
+            var aTime = Date.parse(conversationActivity(a)) || 0;
+            var bTime = Date.parse(conversationActivity(b)) || 0;
+            return bTime - aTime || String(a.id).localeCompare(String(b.id));
+          });
+        }
+        function dashboardViewOptions() {
+          var root = getPanel() && getPanel().querySelector("[data-recent-projects-root]");
+          var drafts = root && root.querySelector("[data-unstarted-conversations]");
+          return {
+            accountScopeId: root && root.dataset.accountScopeId || "",
+            projectFilter: root && root.dataset.projectFilter || "",
+            showAll: Boolean(root && root.dataset.showAll === "true"),
+            draftsOpen: Boolean(drafts && drafts.open),
+            restoreScrollTop: root ? root.scrollTop : 0
+          };
+        }
+        async function refreshDashboardView() {
+          var panelEl = getPanel();
+          if (panelEl && panelEl.dataset.view === "recent-projects") {
+            await renderRecentProjectsVariant(dashboardViewOptions());
+          }
+        }
+        async function openDashboardConversation(projectId, record, row) {
+          var scope = record.accountScopeId;
+          var panelEl = getPanel();
+          if (!scope || scope !== getCachedAccountScopeId() || !isValidProjectId(projectId) || !panelEl || panelEl.dataset.view !== "recent-projects" || row.getAttribute("aria-busy") === "true") return;
+          row.setAttribute("aria-busy", "true");
+          var resume = row.querySelector("[data-session-resume]");
+          if (resume) resume.disabled = true;
+          try {
+            var records = await loadProjectSessionRecords(projectId);
+            if (scope !== getCachedAccountScopeId() || panelEl !== getPanel() || panelEl.dataset.view !== "recent-projects" || row.isConnected === false) return;
+            var selected = records.find(function(candidate) {
+              return candidate.id === record.id;
+            });
+            if (!selected) {
+              await refreshDashboardView();
+              showPluginToast(tr("recentProjects_conversationGone"), { status: "warning" });
+              return;
+            }
+            await activateSessionAndOpenProject(projectId, selected);
+          } catch (_error) {
+            if (scope === getCachedAccountScopeId() && row.isConnected !== false) {
+              showPluginToast(tr("recentProjects_continueFailed"), { status: "warning" });
+            }
+          } finally {
+            row.removeAttribute("aria-busy");
+            if (resume) resume.disabled = false;
+          }
+        }
         function renderRecentProjectRow(row) {
           var projectId = row && row.projectId;
           var valid = isValidProjectId(projectId);
-          var el = document.createElement("button");
-          el.type = "button";
-          el.className = "recent-projects-row";
-          el.setAttribute("data-recent-projects-row", "");
-          el.setAttribute("data-project-id", projectId || "");
-          if (!valid) {
-            el.disabled = true;
-            el.setAttribute("aria-disabled", "true");
-          }
-          var name = lookupProjectName(projectId);
-          if (!name) {
-            name = isValidProjectId(projectId) ? tr("recentProjects_unnamed", { prefix: projectId.slice(0, 8) }) : tr("recentProjects_row_projectLinkUnavailable");
-          }
-          var nameNode = textNode(name, "recent-projects-row-name");
-          nameNode.title = name;
-          el.appendChild(nameNode);
-          var rowTime = textNode(formatRelativeTime(row && row.lastActivityAt), "recent-projects-row-time");
-          rowTime.setAttribute("data-rel-time", String(row && row.lastActivityAt || ""));
-          el.appendChild(rowTime);
-          var sessionCount = Number(row && row.sessionCount) || 0;
-          if (sessionCount > 1) {
-            el.appendChild(textNode(tr("recentProjects_sessionsCount", { count: sessionCount }), "recent-projects-row-sessions"));
-          }
-          el.appendChild(renderStatusBadge(settleDashboardRunStatus(row && row.primaryStatusBadge, row && row.lastActivityAt)));
-          if (valid) {
-            el.addEventListener("click", function() {
-              openProjectFromRow(projectId);
+          var wrap = createViewElement("div", "recent-projects-row-wrap recent-projects-unavailable-row");
+          wrap.setAttribute("data-project-id", projectId || "");
+          var link = createViewButton(void 0, null, "data-recent-projects-row", "recent-projects-row");
+          link.setAttribute("data-project-id", projectId || "");
+          link.disabled = !valid;
+          link.appendChild(textNode(projectDisplayName(projectId), "recent-projects-row-name"));
+          if (valid) link.addEventListener("click", function() {
+            openProjectFromRow(projectId);
+          });
+          var cleanup = createViewButton(tr(valid ? "recentProjects_clearProject" : "recentProjects_cleanup"), function() {
+            if (valid) projectSessionCleanup.clearProjectSessions(projectId, projectDisplayName(projectId)).catch(function() {
             });
-          } else {
-            el.appendChild(textNode(tr("recentProjects_row_projectLinkUnavailable"), "recent-projects-row-warning"));
-          }
-          if (!valid) {
-            var deadWrap = document.createElement("div");
-            deadWrap.className = "recent-projects-row-wrap";
-            var deadHead = document.createElement("div");
-            deadHead.className = "recent-projects-row-head";
-            var cleanup = document.createElement("button");
-            cleanup.type = "button";
-            cleanup.className = "recent-projects-row-cleanup";
-            cleanup.setAttribute("data-row-cleanup", "");
-            cleanup.title = tr("recentProjects_cleanup");
-            cleanup.setAttribute("aria-label", tr("recentProjects_cleanup"));
-            cleanup.textContent = "\xD7";
-            cleanup.addEventListener("click", function() {
-              cleanupDeadProjectEntry(projectId).catch(function() {
-              });
+            else cleanupDeadProjectEntry(projectId).catch(function() {
             });
-            deadHead.appendChild(el);
-            deadHead.appendChild(cleanup);
-            deadWrap.appendChild(deadHead);
-            return deadWrap;
-          }
-          var wrap = document.createElement("div");
-          wrap.className = "recent-projects-row-wrap";
-          wrap.setAttribute("data-project-row-wrap", projectId);
-          var expand = document.createElement("button");
-          expand.type = "button";
-          expand.className = "recent-projects-row-expand";
-          expand.setAttribute("data-row-expand", "");
-          expand.setAttribute("aria-expanded", "false");
-          var sessionsElId = "codex-project-sessions-" + String(projectId || "").slice(0, 24);
-          expand.setAttribute("aria-controls", sessionsElId);
-          expand.title = tr("recentProjects_sessions_toggle");
-          expand.setAttribute("aria-label", tr("recentProjects_sessions_toggle"));
-          expand.textContent = tr("recentProjects_sessions_action");
-          var head = document.createElement("div");
-          head.className = "recent-projects-row-head";
-          var clear = document.createElement("button");
-          clear.type = "button";
-          clear.className = "recent-projects-row-clear";
-          clear.setAttribute("data-project-clear", "");
-          clear.title = tr("recentProjects_clearProject");
-          clear.setAttribute("aria-label", tr("recentProjects_clearProject"));
-          clear.textContent = "\xD7";
-          clear.addEventListener("click", function(event) {
-            event.stopPropagation();
-            projectSessionCleanup.clearProjectSessions(projectId, name).catch(function() {
-            });
-          });
-          head.appendChild(el);
-          head.appendChild(expand);
-          head.appendChild(clear);
-          var sessionsEl = document.createElement("div");
-          sessionsEl.className = "recent-projects-sessions";
-          sessionsEl.setAttribute("data-project-sessions", "");
-          sessionsEl.id = sessionsElId;
-          sessionsEl.setAttribute("role", "region");
-          sessionsEl.setAttribute("aria-label", tr("recentProjects_sessions_toggle"));
-          sessionsEl.hidden = true;
-          expand.addEventListener("click", function() {
-            toggleProjectSessions(wrap, projectId);
-          });
-          wrap.appendChild(head);
-          wrap.appendChild(sessionsEl);
+          }, valid ? "data-project-clear" : "data-row-cleanup");
+          wrap.appendChild(link);
+          wrap.appendChild(renderActionsMenu([cleanup]));
           return wrap;
         }
-        function toggleProjectSessions(wrap, projectId) {
-          var sessionsEl = wrap.querySelector("[data-project-sessions]");
-          var expand = wrap.querySelector("[data-row-expand]");
-          if (!sessionsEl || !expand) {
-            return;
-          }
-          var opening = sessionsEl.hidden;
-          sessionsEl.hidden = !opening;
-          expand.setAttribute("aria-expanded", opening ? "true" : "false");
-          expand.textContent = tr(opening ? "recentProjects_sessions_action_open" : "recentProjects_sessions_action");
-          wrap.setAttribute("data-expanded", opening ? "true" : "false");
-          if (opening) {
-            renderProjectSessions(sessionsEl, projectId).catch(function() {
-            });
-          }
-        }
         function sessionRecordDisplayTitle(record) {
           if (record && typeof record.title === "string" && record.title.trim()) {
             return record.title.trim();
@@ -33130,87 +33564,90 @@ ${conclusion}` : `${label} ${conclusion}`;
             return String(b.updatedAt || b.createdAt || "").localeCompare(String(a.updatedAt || a.createdAt || ""));
           });
         }
-        async function renderProjectSessions(sessionsEl, projectId) {
-          sessionsEl.innerHTML = "";
-          var sessionsLoading = document.createElement("div");
-          sessionsLoading.className = "recent-projects-loading";
-          sessionsLoading.textContent = tx("Loading sessions\u2026", "\u6B63\u5728\u52A0\u8F7D\u4F1A\u8BDD\u2026");
-          sessionsEl.appendChild(sessionsLoading);
-          var records = [];
-          try {
-            records = await loadProjectSessionRecords(projectId);
-          } catch (_error) {
-            records = [];
-          }
-          sessionsLoading.remove();
-          if (!records.length) {
-            sessionsEl.appendChild(textNode(tr("recentProjects_sessions_empty"), "recent-projects-sessions-empty"));
-            return;
-          }
-          for (var i = 0; i < records.length; i++) {
-            sessionsEl.appendChild(renderProjectSessionRow(sessionsEl, projectId, records[i]));
-          }
-        }
-        function renderProjectSessionRow(sessionsEl, projectId, record) {
+        function renderProjectSessionRow(sessionsEl, projectId, record, options2) {
+          var featured = Boolean(options2 && options2.featured);
           var running = Boolean(StorageDb) && settleDashboardRunStatus(StorageDb.derivePrimaryStatusBadge(record), record.updatedAt || record.lastActivityAt) === "running";
-          var row = document.createElement("div");
-          row.className = "recent-projects-session-row";
+          var row = createViewElement("div", "recent-projects-session-row" + (featured ? " recent-projects-focus" : ""));
           row.setAttribute("data-project-session-row", record.id);
-          if (running) {
-            row.setAttribute("data-running", "true");
-          }
+          row.setAttribute("data-project-id", projectId);
+          if (running) row.setAttribute("data-running", "true");
           var title = textNode(sessionRecordDisplayTitle(record), "recent-projects-session-title");
-          title.title = sessionRecordDisplayTitle(record);
-          var time = textNode(formatRelativeTime(record.updatedAt || record.createdAt), "recent-projects-session-time");
-          time.setAttribute("data-rel-time", String(record.updatedAt || record.createdAt || ""));
-          var rename = document.createElement("button");
-          rename.type = "button";
-          rename.className = "recent-projects-session-action";
-          rename.setAttribute("data-session-rename-dash", "");
-          rename.title = tr("renameSession");
-          rename.setAttribute("aria-label", tr("renameSession"));
-          rename.textContent = "\u270E";
-          var del = document.createElement("button");
-          del.type = "button";
-          del.className = "recent-projects-session-action recent-projects-session-action--delete";
-          del.setAttribute("data-session-delete-dash", "");
-          del.title = tr("deleteSession");
-          del.setAttribute("aria-label", tr("deleteSession"));
-          del.textContent = "\xD7";
-          if (running) {
-            rename.disabled = true;
-            del.title = tr("recentProjects_zombieRunningNote");
+          title.title = title.textContent;
+          var copy = createViewElement("div", "recent-projects-session-copy");
+          var meta = createViewElement("div", "recent-projects-session-meta");
+          var project = textNode(projectDisplayName(projectId), "recent-projects-row-name");
+          project.title = project.textContent;
+          meta.appendChild(project);
+          var time = textNode(formatRelativeTime(conversationActivity(record)), "recent-projects-session-time");
+          time.setAttribute("data-rel-time", conversationActivity(record));
+          time.title = conversationActivity(record);
+          var status = conversationStatus(record);
+          var footer = featured ? createViewElement("div", "recent-projects-focus-footer") : null;
+          if (featured) {
+            meta.insertBefore(textNode(tr("recentProjects_focusEyebrow"), "recent-projects-focus-eyebrow"), project);
+            copy.appendChild(meta);
+            copy.appendChild(title);
+            footer.appendChild(status ? renderStatusBadge(status) : textNode(tr("recentProjects_savedDraft"), "recent-projects-row-badge"));
+          } else {
+            copy.appendChild(title);
+            copy.appendChild(meta);
+            if (["failed", "needs_review", "interrupted", "stale", "needs_review_after_navigation", "abandoned_after_navigation"].indexOf(status) !== -1) {
+              var attention = textNode(tr("recentProjects_attention"), "recent-projects-session-attention");
+              attention.title = tr("recentProjects_badge_" + status);
+              meta.appendChild(attention);
+            }
           }
-          rename.addEventListener("click", function() {
+          meta.appendChild(time);
+          row.appendChild(copy);
+          var rename = createViewButton(tr("renameSession"), function() {
             beginDashboardSessionRename(sessionsEl, projectId, record, row, title);
-          });
-          del.addEventListener("click", function() {
+          }, "data-session-rename-dash");
+          rename.title = rename.textContent;
+          rename.setAttribute("aria-label", rename.textContent);
+          if (running) rename.disabled = true;
+          var del = createViewButton(tr("deleteSession"), function() {
             deleteDashboardSession(sessionsEl, projectId, record).catch(function() {
             });
+          }, "data-session-delete-dash");
+          del.title = running ? tr("recentProjects_zombieRunningNote") : del.textContent;
+          del.setAttribute("aria-label", del.textContent);
+          var projectConversations = createViewButton(tr("recentProjects_projectConversations"), function() {
+            renderRecentProjectsVariant({ projectFilter: projectId, showAll: true, restoreScrollTop: 0 }).catch(function() {
+            });
+          }, "data-project-conversations");
+          var openProject = createViewButton(tr("recentProjects_openProject"), function() {
+            openProjectFromRow(projectId);
           });
-          row.appendChild(title);
-          row.appendChild(time);
-          row.appendChild(rename);
-          row.appendChild(del);
-          row.classList.add("recent-projects-session-row--linked");
-          row.setAttribute("role", "button");
-          row.tabIndex = 0;
+          var clear = createViewButton(tr("recentProjects_clearProject"), function() {
+            projectSessionCleanup.clearProjectSessions(projectId, projectDisplayName(projectId)).catch(function() {
+            });
+          }, "data-project-clear");
+          row.appendChild(renderActionsMenu([rename, del, projectConversations, openProject, clear]));
           var activate = function() {
-            activateSessionAndOpenProject(projectId, record).catch(function() {
+            openDashboardConversation(projectId, record, row).catch(function() {
             });
           };
-          row.addEventListener("click", function(event) {
-            if (event.target.closest("button") || event.target.closest("input")) {
-              return;
-            }
-            activate();
-          });
-          row.addEventListener("keydown", function(event) {
-            if (event.key === "Enter") {
-              event.preventDefault();
-              activate();
-            }
-          });
+          if (featured) {
+            row.setAttribute("role", "group");
+            row.setAttribute("aria-label", tr("recentProjects_focusEyebrow"));
+            var resume = createViewButton(tr("recentProjects_continue"), activate, "data-session-resume", "recent-projects-continue");
+            resume.title = tr("recentProjects_continueHint");
+            footer.appendChild(resume);
+            row.appendChild(footer);
+          } else {
+            row.classList.add("recent-projects-session-row--linked");
+            row.setAttribute("role", "button");
+            row.tabIndex = 0;
+            row.addEventListener("click", function(event) {
+              if (!event.target.closest("button, input, details")) activate();
+            });
+            row.addEventListener("keydown", function(event) {
+              if (event.target === row && (event.key === "Enter" || event.key === " ")) {
+                event.preventDefault();
+                activate();
+              }
+            });
+          }
           return row;
         }
         async function activateSessionAndOpenProject(projectId, record) {
@@ -33341,11 +33778,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           } catch (error) {
             showPluginToast(tr("deleteSessionHistoryFailedToast", { message: error.message }), { status: "warning", sticky: true });
           }
-          var rootForScroll = getPanel() && getPanel().querySelector("[data-recent-projects-root]");
-          await renderRecentProjectsVariant({
-            expandProjectId: projectId,
-            restoreScrollTop: rootForScroll ? rootForScroll.scrollTop : void 0
-          });
+          await refreshDashboardView();
         }
         function beginDashboardSessionRename(sessionsEl, projectId, record, row, titleEl) {
           if (row.querySelector("input")) {
@@ -33358,7 +33791,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           input.className = "recent-projects-session-rename-input";
           input.value = seed;
           titleEl.hidden = true;
-          row.insertBefore(input, titleEl);
+          titleEl.parentElement.insertBefore(input, titleEl);
           input.focus();
           input.select();
           var settled = false;
@@ -33420,7 +33853,7 @@ ${conclusion}` : `${label} ${conclusion}`;
             }
           } catch (_error) {
           }
-          await renderProjectSessions(sessionsEl, projectId);
+          await refreshDashboardView();
         }
         function ensureRecentProjectsRoot() {
           if (!getPanel()) {
@@ -33430,9 +33863,13 @@ ${conclusion}` : `${label} ${conclusion}`;
           if (existing) {
             return existing;
           }
-          var rootEl = document.createElement("section");
-          rootEl.className = "recent-projects-root";
+          var rootEl = createViewElement("section", "recent-projects-root");
           rootEl.setAttribute("data-recent-projects-root", "");
+          rootEl.addEventListener("click", function(event) {
+            rootEl.querySelectorAll(".recent-projects-menu[open]").forEach(function(menu) {
+              if (!menu.contains(event.target)) menu.open = false;
+            });
+          });
           getPanel().appendChild(rootEl);
           return rootEl;
         }
@@ -33469,116 +33906,152 @@ ${conclusion}` : `${label} ${conclusion}`;
             return;
           }
           rootEl.appendChild(renderWelcomeHeader());
-          var loading = document.createElement("div");
-          loading.className = "recent-projects-loading";
-          loading.textContent = tx("Loading projects\u2026", "\u6B63\u5728\u52A0\u8F7D\u9879\u76EE\u2026");
+          var loading = createViewElement("div", "recent-projects-loading", tx("Loading projects\u2026", "\u6B63\u5728\u52A0\u8F7D\u9879\u76EE\u2026"));
           rootEl.appendChild(loading);
         }
         async function renderRecentProjectsVariant(options2) {
-          if (!getPanel()) {
-            return;
-          }
-          getPanel().dataset.view = "recent-projects";
+          var panelEl = getPanel();
+          var editorMatch = String(window.location && window.location.pathname || "").match(/^\/project\/([a-f0-9]{24})(?:\/|$)/);
+          if (!panelEl || editorMatch && isValidProjectId(editorMatch[1])) return;
+          var previous = dashboardViewOptions();
+          options2 = Object.assign({}, previous, options2 || {});
+          var generation = ++dashboardRenderGeneration;
+          panelEl.dataset.view = "recent-projects";
           startRelativeTimeTicker();
           var rootEl = ensureRecentProjectsRoot();
-          if (!rootEl) {
-            return;
-          }
-          rootEl.innerHTML = "";
-          rootEl.appendChild(renderWelcomeHeader());
+          if (!rootEl) return;
           var accountScopeId = (window.codexOverleafDeriveAccountScopeId || function() {
             return null;
           })();
+          if (previous.accountScopeId !== accountScopeId) {
+            options2.projectFilter = "";
+            options2.showAll = options2.draftsOpen = false;
+          }
+          var projectFilter = isValidProjectId(options2.projectFilter) ? options2.projectFilter : "";
+          rootEl.dataset.accountScopeId = accountScopeId || "";
+          rootEl.dataset.projectFilter = projectFilter;
+          rootEl.dataset.showAll = options2.showAll ? "true" : "false";
+          rootEl.innerHTML = "";
+          rootEl.appendChild(renderWelcomeHeader());
           if (!accountScopeId) {
             rootEl.appendChild(renderDegradedState());
             rootEl.appendChild(renderSettingsEntry({ scope: "account" }));
-            opportunisticEnrichmentFromDom().catch(function() {
-            });
             return;
           }
-          var listContainer = document.createElement("div");
-          listContainer.className = "recent-projects-list";
+          if (projectFilter) {
+            var filterBar = createViewElement("div", "recent-projects-filter");
+            var back = createViewButton(tr("recentProjects_allProjects"), function() {
+              renderRecentProjectsVariant({ projectFilter: "", showAll: false, restoreScrollTop: 0 }).catch(function() {
+              });
+            });
+            filterBar.appendChild(back);
+            var filterName = textNode(projectDisplayName(projectFilter));
+            filterName.title = filterName.textContent;
+            filterBar.appendChild(filterName);
+            rootEl.appendChild(filterBar);
+          }
+          var listContainer = createViewElement("div", "recent-projects-list");
           listContainer.setAttribute("data-recent-projects-list", "");
           rootEl.appendChild(listContainer);
-          var listLoading = document.createElement("div");
-          listLoading.className = "recent-projects-loading";
-          listLoading.textContent = tx("Loading projects\u2026", "\u6B63\u5728\u52A0\u8F7D\u9879\u76EE\u2026");
-          listContainer.appendChild(listLoading);
+          var loading = textNode(tr("recentProjects_loadingHistory"), "recent-projects-loading");
+          listContainer.appendChild(loading);
+          function stillCurrent() {
+            return generation === dashboardRenderGeneration && getPanel() === panelEl && panelEl.dataset.view === "recent-projects" && rootEl.isConnected !== false && getCachedAccountScopeId() === accountScopeId;
+          }
+          var records;
           try {
             await loadProjectNameCacheFromStorage();
+            records = await loadDashboardConversations(accountScopeId);
           } catch (_error) {
+            if (!stillCurrent()) return;
+            loading.textContent = tr("recentProjects_loadFailed");
+            var retry = createViewButton(tr("recentProjects_retryScope"), function() {
+              renderRecentProjectsVariant(options2).catch(function() {
+              });
+            }, null, "recent-projects-show-all");
+            listContainer.appendChild(retry);
+            rootEl.appendChild(renderSettingsEntry({ scope: "account" }));
+            return;
           }
-          var rows = [];
-          var showAll = Boolean(options2 && options2.showAll);
-          var pageLimit = 10;
-          try {
-            if (StorageDb) {
-              var deletedSessionIdsByProject = await SessionPersistence.loadTombstones();
-              rows = await StorageDb.listRecentProjectsAcrossAccount({
-                accountScopeId,
-                limit: showAll ? 500 : pageLimit + 1,
-                deletedSessionIdsByProject
+          if (!stillCurrent()) return;
+          loading.remove();
+          var validRecords = records.filter(function(record) {
+            return isValidProjectId(record.projectId) && (!projectFilter || record.projectId === projectFilter);
+          });
+          var started = validRecords.filter(conversationHasContent);
+          var unstarted = validRecords.filter(function(record) {
+            return !conversationHasContent(record);
+          });
+          if (started.length) {
+            listContainer.appendChild(renderProjectSessionRow(listContainer, started[0].projectId, started[0], { featured: true }));
+            if (started.length > 1) {
+              var heading = createViewElement("div", "recent-projects-history-heading");
+              heading.appendChild(textNode(tr("recentProjects_historyHeading")));
+              heading.appendChild(textNode(tr("recentProjects_historyHint")));
+              listContainer.appendChild(heading);
+              var historyList = createViewElement("div", "recent-projects-history-list");
+              var history = options2.showAll ? started.slice(1) : started.slice(1, 10);
+              history.forEach(function(record) {
+                historyList.appendChild(renderProjectSessionRow(historyList, record.projectId, record));
               });
+              listContainer.appendChild(historyList);
+              if (!options2.showAll && started.length > 10) {
+                var more = createViewButton(tr("recentProjects_showAllConversations", { count: started.length }), function() {
+                  renderRecentProjectsVariant({ showAll: true }).catch(function() {
+                  });
+                }, "data-recent-projects-show-all", "recent-projects-show-all");
+                listContainer.appendChild(more);
+              }
             }
-          } catch (_error) {
-            rows = [];
-          }
-          listLoading.remove();
-          var restoreExpanded = Array.isArray(options2 && options2.restoreExpanded) ? options2.restoreExpanded : [];
-          var welcomeSubtitle = rootEl.querySelector(".recent-projects-welcome-subtitle");
-          if (welcomeSubtitle && rows && rows.length) {
-            var sessionTotal = 0;
-            for (var st = 0; st < rows.length; st++) {
-              sessionTotal += Number(rows[st].sessionCount) || 1;
-            }
-            welcomeSubtitle.textContent = tr("recentProjects_welcome_stats", {
-              projects: rows.length,
-              sessions: sessionTotal
-            });
-          }
-          var hasMore = !showAll && rows && rows.length > pageLimit;
-          var visibleRows = hasMore ? rows.slice(0, pageLimit) : rows;
-          if (!visibleRows || !visibleRows.length) {
-            listContainer.appendChild(renderEmptyState());
           } else {
-            for (var i = 0; i < visibleRows.length; i++) {
-              listContainer.appendChild(renderRecentProjectRow(visibleRows[i]));
-            }
-          }
-          if (hasMore) {
-            var showAllButton = document.createElement("button");
-            showAllButton.type = "button";
-            showAllButton.className = "recent-projects-show-all";
-            showAllButton.setAttribute("data-recent-projects-show-all", "");
-            showAllButton.textContent = tx("Show all projects", "\u67E5\u770B\u5168\u90E8\u9879\u76EE");
-            showAllButton.addEventListener("click", function() {
-              renderRecentProjectsVariant(Object.assign({}, options2, { showAll: true }));
+            var empty = renderEmptyState();
+            if (unstarted.length) empty.textContent = tr("recentProjects_noStarted");
+            listContainer.appendChild(empty);
+          }
+          if (unstarted.length) {
+            let populateDrafts = function() {
+              if (draftsBuilt || !stillCurrent()) return;
+              draftsBuilt = true;
+              drafts.appendChild(textNode(tr("recentProjects_unstartedHint"), "recent-projects-drafts-hint"));
+              unstarted.forEach(function(record) {
+                drafts.appendChild(renderProjectSessionRow(drafts, record.projectId, record));
+              });
+            };
+            var drafts = createViewElement("details", "recent-projects-drafts");
+            drafts.setAttribute("data-unstarted-conversations", "");
+            var summary = createViewElement("summary", "", tr("recentProjects_unstarted", { count: unstarted.length }));
+            drafts.appendChild(summary);
+            var draftsBuilt = false;
+            drafts.addEventListener("toggle", function() {
+              if (drafts.open) populateDrafts();
             });
-            listContainer.appendChild(showAllButton);
-          }
-          rootEl.appendChild(renderSettingsEntry({ scope: "account" }));
-          var expandProjectId = options2 && options2.expandProjectId;
-          var toReopen = restoreExpanded.slice();
-          if (expandProjectId && toReopen.indexOf(expandProjectId) === -1) {
-            toReopen.push(expandProjectId);
-          }
-          for (var reopenIndex = 0; reopenIndex < toReopen.length; reopenIndex++) {
-            var wrap = listContainer.querySelector('[data-project-row-wrap="' + toReopen[reopenIndex] + '"]');
-            if (wrap) {
-              toggleProjectSessions(wrap, toReopen[reopenIndex]);
+            listContainer.appendChild(drafts);
+            if (options2.draftsOpen) {
+              drafts.open = true;
+              populateDrafts();
             }
           }
-          if (options2 && Number.isFinite(options2.restoreScrollTop)) {
-            rootEl.scrollTop = options2.restoreScrollTop;
-            var scrollerParent = rootEl.parentElement;
-            if (scrollerParent && scrollerParent.scrollHeight > scrollerParent.clientHeight) {
-              scrollerParent.scrollTop = options2.restoreScrollTop;
-            }
+          if (!projectFilter) {
+            var invalid = records.filter(function(record) {
+              return !isValidProjectId(record.projectId);
+            });
+            var invalidIds = /* @__PURE__ */ new Set();
+            if (invalid.length) listContainer.appendChild(textNode(tr("recentProjects_unavailableRecords"), "recent-projects-history-heading"));
+            invalid.forEach(function(record) {
+              var id = String(record.projectId || "");
+              if (!invalidIds.has(id)) {
+                invalidIds.add(id);
+                listContainer.appendChild(renderRecentProjectRow({ projectId: record.projectId }));
+              }
+            });
           }
+          rootEl.appendChild(renderSettingsEntry({ scope: "account" }));
+          if (Number.isFinite(options2.restoreScrollTop)) rootEl.scrollTop = options2.restoreScrollTop;
           opportunisticEnrichmentFromDom().catch(function() {
           });
         }
         function renderPerProjectVariant() {
+          dashboardRenderGeneration++;
           if (!getPanel()) {
             return;
           }
@@ -33653,6 +34126,7 @@ ${conclusion}` : `${label} ${conclusion}`;
         let currentOtStatus = "off";
         let otTogglePending = false;
         let otSyncRequestId = 0;
+        let otStartRetryCount = 0;
         let otWarmMirrorProjectId = "";
         let lastExperimentalOtProjectId = "";
         let otWarmMirrorState = {
@@ -33802,6 +34276,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           const projectId = getCurrentProjectId();
           otWarmMirrorState.failureActive = false;
           lastExperimentalOtProjectId = projectId;
+          otStartRetryCount = 0;
           setExperimentalOtEnabledForProject(projectId, checkbox.checked);
           updateExperimentalOtToggleControl(checkbox.checked);
           const savedBadge = getPanel()?.querySelector('details[data-set-group="experimental"] [data-set-saved]');
@@ -33877,8 +34352,10 @@ ${conclusion}` : `${label} ${conclusion}`;
             await pauseOtWarmMirror(pauseAfterStart.reason || "paused");
             return response;
           }
-          otWarmMirrorState.failureActive = false;
+          if (status === "starting") recordOtFailure("missing_active_path", "start");
+          else otWarmMirrorState.failureActive = false;
           updateOtStatusDisplay(status);
+          otStartRetryCount = 0;
           scheduleOtEventPolling(projectId, { immediate: true });
           return response;
         }
@@ -33905,23 +34382,31 @@ ${conclusion}` : `${label} ${conclusion}`;
           clearOtEventPolling({ clearPatchQueue: true });
           recordOtFailure(readOtBridgeErrorCode(response, "ot_start_failed"), "start");
           otWarmMirrorState.suspended = true;
-          setExperimentalOtEnabledForProject(projectId, false);
-          const experimentalOtCheckbox = getPanel()?.querySelector("[data-experimental-ot]");
-          if (experimentalOtCheckbox) {
-            experimentalOtCheckbox.checked = false;
-          }
+          updateExperimentalOtToggleControl(isExperimentalOtEnabledForProject(projectId));
           updateOtStatusDisplay("unavailable");
-          saveStateSoon();
           try {
             await callPageBridge("stopOtObserver", { projectId });
           } catch (_error) {
           }
+          scheduleOtStartRetry(projectId, requestId);
+        }
+        function scheduleOtStartRetry(projectId, requestId) {
+          const retryDelays = [1e3, 3e3, 6e3];
+          const canRetry = () => isCurrentOtSync(requestId, projectId) && getCurrentProjectId() === projectId && isExperimentalOtEnabledForProject(projectId) && !getCurrentRunView();
+          if (!canRetry() || otStartRetryCount >= retryDelays.length) return;
+          const delayMs = retryDelays[otStartRetryCount++];
+          otWarmMirrorState.pollTimer = window.setTimeout(() => {
+            otWarmMirrorState.pollTimer = null;
+            if (!canRetry()) return;
+            syncOtWarmMirrorController().catch(() => {
+              if (getCurrentProjectId() === projectId && isExperimentalOtEnabledForProject(projectId)) {
+                updateOtStatusDisplay("unavailable");
+              }
+            });
+          }, delayMs);
         }
         function readOtBridgeStatus(response) {
-          if (!response || response.ok === false) {
-            return "unavailable";
-          }
-          return response.state || response.status || response.result?.state || response.result?.status || "unavailable";
+          return otWarmMirrorController.readOtBridgeStatus(response);
         }
         function ensureOtWarmMirrorStateProject(projectId) {
           if (!projectId || otWarmMirrorState.projectId === projectId) {
@@ -33929,6 +34414,7 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
           clearOtEventPolling({ clearPatchQueue: true });
           otWarmMirrorState.projectId = projectId;
+          otStartRetryCount = 0;
           otWarmMirrorState.lastPatchAt = 0;
           otWarmMirrorState.lastErrorCode = "";
           otWarmMirrorState.failureActive = false;
@@ -33992,6 +34478,7 @@ ${conclusion}` : `${label} ${conclusion}`;
               return statusResponse;
             }
             const status = readOtBridgeStatus(statusResponse);
+            if (status === "observing" && otWarmMirrorState.lastFailure?.phase === "start") Object.assign(otWarmMirrorState, { failureActive: false, lastErrorCode: "", lastFailure: null });
             if (["unavailable", "inconsistent"].includes(status)) recordOtFailure(readOtBridgeErrorCode(statusResponse, "ot_observer_unavailable"), "observe");
             if (status) {
               updateOtStatusDisplay(status);
@@ -34022,20 +34509,10 @@ ${conclusion}` : `${label} ${conclusion}`;
           }
         }
         function readOtBridgeEvents(response) {
-          if (Array.isArray(response)) {
-            return response;
-          }
-          if (Array.isArray(response?.events)) {
-            return response.events;
-          }
-          if (Array.isArray(response?.result?.events)) {
-            return response.result.events;
-          }
-          return [];
+          return otWarmMirrorController.readOtBridgeEvents(response);
         }
         function readOtBridgeErrorCode(response, fallback) {
-          const value = response?.lastErrorCode || response?.reason || response?.error?.code || response?.error || fallback;
-          return typeof value === "string" ? value : fallback;
+          return otWarmMirrorController.readOtBridgeErrorCode(response, fallback);
         }
         function recordOtFailure(code, phase) {
           code = otWarmMirrorController.normalizeFailureCode(code);
@@ -34511,6 +34988,7 @@ ${conclusion}` : `${label} ${conclusion}`;
       let tx;
       let getLocale;
       let appendRunEvent;
+      let appendRunRecordEvent;
       let pendingMirrorRefresh = null;
       let appendChangeSummary;
       let appendCompletionReport;
@@ -34557,6 +35035,34 @@ ${conclusion}` : `${label} ${conclusion}`;
       function buildSettlement(input = {}) {
         return writebackSettlement?.settle instanceof Function ? writebackSettlement.settle(input) : null;
       }
+      function invalidateMirrorAfterUndo(runId, projectId, result = {}) {
+        if (!projectId || result?.changedDocument !== true && !result?.applied?.length) return Promise.resolve("not-attempted");
+        const pending = Promise.resolve(pendingMirrorRefresh).catch(() => {
+        }).then(async () => {
+          const response = await sendBackgroundNative({ method: "mirror.invalidate", params: { projectId } });
+          if (!response?.ok || response.result?.invalidated !== true) {
+            throw new Error(response?.error?.message || "Native host did not confirm mirror invalidation.");
+          }
+          if (getCurrentProjectId() === projectId) {
+            resetContextProject();
+            await callPageBridge("invalidateProjectSnapshot", { invalidateFileList: true });
+          }
+          return "invalidated";
+        }).catch((error) => {
+          appendRunRecordEvent?.(runId, {
+            status: "warning",
+            title: tx(
+              `Overleaf undo finished, but local mirror invalidation failed: ${error.message}. Refresh this project or reconnect the native host before running again.`,
+              `Overleaf \u64A4\u9500\u5DF2\u5B8C\u6210\uFF0C\u4F46\u672C\u5730\u955C\u50CF\u5931\u6548\u5904\u7406\u5931\u8D25\uFF1A${error.message}\u3002\u8BF7\u5237\u65B0\u9879\u76EE\u6216\u91CD\u65B0\u8FDE\u63A5 Native Host \u540E\u518D\u8FD0\u884C\u3002`
+            )
+          });
+          return "failed";
+        }).finally(() => {
+          if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
+        });
+        pendingMirrorRefresh = pending;
+        return pending;
+      }
       async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options2 = {}) {
         const runMode = options2.mode || getState().mode;
         const runRequireReviewing = typeof options2.requireReviewing === "boolean" ? options2.requireReviewing : getState().requireReviewing === true;
@@ -35209,6 +35715,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           tx,
           getLocale,
           appendRunEvent,
+          appendRunRecordEvent,
           appendChangeSummary,
           appendCompletionReport,
           appendOperationsPreview,
@@ -35254,6 +35761,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         return {
           applySyncChangesToOverleaf,
           resolveCompileLogContext,
+          invalidateMirrorAfterUndo,
           getPendingMirrorRefresh: () => pendingMirrorRefresh
         };
       }
@@ -35261,6 +35769,153 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
     })();
   }).call(globalThis, void 0, void 0, void 0);
   (function runClassicContentModule94(module, exports, require2) {
+    (function(root, factory) {
+      const api = factory();
+      if (typeof module === "object" && module.exports) module.exports = api;
+      if (root) root.CodexOverleafTrackedChangeCaptureController = api;
+    })(typeof window !== "undefined" ? window : globalThis, function() {
+      "use strict";
+      function create(deps = {}) {
+        const now = deps.now || (() => Date.now());
+        const defer = deps.setTimeout || setTimeout;
+        const cancelTimer = deps.clearTimeout || clearTimeout;
+        let timer = null, busy = false, disposed = false;
+        const runs = () => deps.getRuns() || [];
+        const pending = (run) => Array.isArray(run.trackedChangeCaptures) && run.trackedChangeCaptures.some((capture) => capture.state === "pending");
+        const terminal = (run) => ["accepted", "rejected"].includes(run.trackedChangeStatus) || run.undoStatus === "applied" || run.forkSnapshot === true;
+        function buildPostFiles(run) {
+          const expectedFiles = Array.isArray(run?.undoExpectedFiles) ? run.undoExpectedFiles : [];
+          const appliedOperations = Array.isArray(run?.appliedOperations) ? run.appliedOperations : [];
+          if (!expectedFiles.length || !appliedOperations.length) return [];
+          const postFilesByPath = deps.buildExpectedFilesAfterOperations({ files: expectedFiles }, appliedOperations);
+          const expectedPaths = new Set(expectedFiles.map((file) => file?.path).filter(Boolean));
+          return Array.from(postFilesByPath.entries()).filter(([path, content]) => expectedPaths.has(path) && typeof content === "string").map(([path, content]) => ({ path, content }));
+        }
+        function hasLegacyUntrackedCheckpoint(run) {
+          if (!run || run.executionSnapshot || run.trackedChangeStatus || run.undoStatus === "applied" || run.forkSnapshot || run.undoTrackedChanges?.length || run.trackedChangeCaptures?.length) return false;
+          const operations = Array.isArray(run.undoOperations) ? run.undoOperations : [];
+          const before = Array.isArray(run.undoExpectedFiles) ? run.undoExpectedFiles : [];
+          if (!operations.length || !before.length || before.some((file) => !file?.path || typeof file.content !== "string")) return false;
+          const paths = new Set(before.map((file) => file.path));
+          if (paths.size !== before.length || operations.some((op) => op?.type !== "edit" || !paths.has(op.path))) return false;
+          const complete = (files) => Array.isArray(files) && files.length === paths.size && new Set(files.map((file) => file?.path)).size === paths.size && files.every((file) => paths.has(file?.path) && typeof file.content === "string");
+          const storedPost = run.undoBaseFiles;
+          try {
+            const post = buildPostFiles(run);
+            if (!complete(storedPost) || !complete(post)) return false;
+            const postByPath = new Map(post.map((file) => [file.path, file.content]));
+            if (!storedPost.every((file) => postByPath.get(file.path) === file.content)) return false;
+            const restored = deps.buildExpectedFilesAfterOperations({ files: storedPost }, operations);
+            return before.every((file) => restored.get(file.path) === file.content);
+          } catch (_error) {
+            return false;
+          }
+        }
+        function schedule() {
+          if (disposed || timer !== null || busy || !runs().some(pending)) return;
+          timer = defer(() => {
+            timer = null;
+            flush().catch((error) => deps.onError?.(error));
+          }, 500);
+        }
+        function record(run, captures) {
+          if (!Array.isArray(captures) || !captures.length) return;
+          const next = [...run.trackedChangeCaptures || [], ...captures.filter(Boolean)];
+          if (next.every((capture) => capture.state === "observed")) return;
+          run.trackedChangeCaptures = next;
+          deps.notify?.(run, next.some((capture) => capture.state === "pending") ? "pending" : "needs_review", {
+            captures: next.map((capture) => ({ path: capture.path, reason: capture.reason, ...capture.diagnostics }))
+          });
+          deps.persist().then(schedule).catch((error) => deps.onError?.(error));
+        }
+        async function flush() {
+          if (disposed || busy) return;
+          busy = true;
+          try {
+            for (const run of runs().filter(pending)) {
+              if (terminal(run)) {
+                run.trackedChangeCaptures = [];
+                await deps.persist();
+                continue;
+              }
+              if (run.runProjectId !== deps.getProjectId()) continue;
+              const newer = runs().some((other) => other.id !== run.id && other.runProjectId === run.runProjectId && Date.parse(other.startedAt) > Date.parse(run.startedAt));
+              const original = run.trackedChangeCaptures;
+              const captures = original.map((capture) => ({ ...capture }));
+              const postFiles = buildPostFiles(run);
+              for (let i = 0; i < captures.length; i++) {
+                const capture = captures[i];
+                if (capture.state !== "pending") continue;
+                const expected = postFiles.find((file) => file.path === capture.path);
+                if (newer || !expected || now() >= capture.expiresAt || run.status === "cancelled") {
+                  capture.state = "needs_review";
+                  capture.reason = newer ? "capture_superseded" : !expected ? "capture_baseline_missing" : run.status === "cancelled" ? "capture_cancelled" : "capture_expired";
+                  continue;
+                }
+                let response;
+                try {
+                  response = await deps.callPageBridge("reconcileTrackedChangeCapture", {
+                    runProjectId: run.runProjectId,
+                    capture,
+                    expectedContent: expected.content
+                  });
+                } catch (_error) {
+                  response = null;
+                }
+                if (disposed || deps.getProjectId() !== run.runProjectId || !runs().includes(run) || terminal(run) || run.trackedChangeCaptures !== original) return;
+                const superseded = runs().some((other) => other.id !== run.id && other.runProjectId === run.runProjectId && Date.parse(other.startedAt) > Date.parse(run.startedAt));
+                if (superseded || run.status === "cancelled") {
+                  captures[i] = { ...capture, state: "needs_review", reason: "capture_superseded" };
+                } else if (response?.capture?.path === capture.path && response.capture.runProjectId === run.runProjectId && ["observed", "pending", "needs_review"].includes(response.capture.state)) {
+                  captures[i] = response.capture;
+                } else {
+                  captures[i] = { ...capture, state: "needs_review", reason: "capture_bridge_unavailable" };
+                }
+              }
+              if (!runs().includes(run) || terminal(run) || deps.getProjectId() !== run.runProjectId) continue;
+              if (captures.length && captures.every((capture) => capture.state === "observed")) {
+                const refs = deps.normalizeTrackedChanges([
+                  ...run.undoTrackedChanges || [],
+                  ...captures.flatMap((capture) => capture.refs || [])
+                ]);
+                if (refs.length) {
+                  run.undoTrackedChanges = refs;
+                  run.trackedChangeStatus = "pending";
+                  run.trackedChangeCaptures = [];
+                  await deps.persist();
+                  deps.refresh(run);
+                  deps.notify?.(run, "observed", { count: refs.length });
+                  continue;
+                }
+              }
+              const changed = JSON.stringify(original.map(summary)) !== JSON.stringify(captures.map(summary));
+              if (changed) {
+                run.trackedChangeCaptures = captures;
+                await deps.persist();
+                if (!pending(run)) deps.notify?.(run, "needs_review", {
+                  reasons: captures.filter((capture) => capture.state !== "observed").map((capture) => capture.reason)
+                });
+              }
+            }
+          } finally {
+            busy = false;
+            if (runs().some((run) => pending(run) && run.runProjectId === deps.getProjectId())) schedule();
+          }
+        }
+        function summary(capture) {
+          return { state: capture.state, reason: capture.reason, refs: (capture.refs || []).map((ref) => ref.key) };
+        }
+        function dispose() {
+          disposed = true;
+          if (timer !== null) cancelTimer(timer);
+          timer = null;
+        }
+        return { record, schedule, flush, dispose, buildPostFiles, hasLegacyUntrackedCheckpoint };
+      }
+      return { create };
+    });
+  }).call(globalThis, void 0, void 0, void 0);
+  (function runClassicContentModule95(module, exports, require2) {
     (function initCodexOverleafRunSettlementPersistence(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -35303,7 +35958,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       return Object.freeze({ create });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule95(module, exports, require2) {
+  (function runClassicContentModule96(module, exports, require2) {
     (function initPostNavigationSettlementPersistence(root, factory) {
       const api = factory();
       if (typeof module === "object" && module.exports) module.exports = api;
@@ -35395,7 +36050,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       return Object.freeze({ persist, persistRequired });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule96(module, exports, require2) {
+  (function runClassicContentModule97(module, exports, require2) {
     (function initCodexOverleafPanelMaintenance() {
       "use strict";
       function create(deps = {}) {
@@ -35506,11 +36161,12 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           }
           const requestId = ++storageUsageRequestId;
           const projectId = getCurrentProjectId?.();
-          const isCurrent = () => requestId === storageUsageRequestId && projectId === getCurrentProjectId?.() && getSettingsPanelInstance()?.container?.querySelector("[data-storage-usage]") === node;
+          const settingsScope = getPanel?.()?.dataset?.settingsScope;
+          const isCurrent = () => requestId === storageUsageRequestId && projectId === getCurrentProjectId?.() && settingsScope === getPanel?.()?.dataset?.settingsScope && 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(
+          const counts = settingsScope === "account" ? tx("All projects in this browser", "\u5F53\u524D\u6D4F\u89C8\u5668\u4E2D\u7684\u6240\u6709\u9879\u76EE") : tx(
             `${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`
           );
@@ -35726,7 +36382,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       window.CodexOverleafPanelMaintenance = { create };
     })();
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule97(module, exports, require2) {
+  (function runClassicContentModule98(module, exports, require2) {
     (function initCodexOverleafUpdateIdle(root) {
       "use strict";
       function create(options2 = {}) {
@@ -35794,7 +36450,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       root.CodexOverleafUpdateIdle = Object.freeze({ create });
     })(typeof window !== "undefined" ? window : globalThis);
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule98(module, exports, require2) {
+  (function runClassicContentModule99(module, exports, require2) {
     (function initCodexOverleafUpdateNotice(root, factory) {
       if (typeof module === "object" && module.exports) {
         module.exports = factory(require2("../shared/managedUpdateProjection"));
@@ -36259,7 +36915,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
       return Object.freeze({ mount });
     });
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule99(module, exports, require2) {
+  (function runClassicContentModule100(module, exports, require2) {
     (function initCodexOverleafContentRuntime(root) {
       "use strict";
       function init(dependencies2) {
@@ -36312,6 +36968,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           "mirror.sync",
           "mirror.patchFiles",
           "mirror.confirmWriteback",
+          "mirror.invalidate",
           "mirror.scanSensitive",
           "codex.history.clearPlugin",
           "skills.list",
@@ -36812,6 +37469,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           RUN_SNAPSHOT_ZIP_TIMEOUT_MS,
           getState: () => state,
           getCurrentRunView: () => currentRunView,
+          appendRunRecordEvent,
           onMirrorRefreshSettled: runSettlementPersistence.settleMirrorRefresh
         });
         const {
@@ -37013,6 +37671,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           },
           saveState,
           saveStateSoon,
+          onProjectFilesReady: refreshHistoricalProjectReferences,
           updateActiveSession,
           callPageBridge,
           getCurrentProjectId,
@@ -38483,15 +39142,19 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             setRunning(false);
             nativeChannel.clearActiveRequest();
             stopRunElapsedTick();
-            if (isExperimentalOtEnabled()) {
-              await resumeOtWarmMirror("run-settled");
-            }
             await flushQueuedSaveState().catch(() => {
             });
             currentRunView = null;
             runCancellationRequested = false;
             runCancellationController = null;
             activeTurnControl.release(settlement.requestId);
+            if (isExperimentalOtEnabled()) {
+              try {
+                await resumeOtWarmMirror("run-settled");
+              } catch (_error) {
+                updateOtStatusDisplay("unavailable");
+              }
+            }
             if (settlement.requestId) {
               activeTurnControl.acknowledge(settlement.requestId).catch(() => {
               });
@@ -41060,6 +41723,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,
@@ -41125,6 +41789,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             const urlProjectId = getCurrentProjectId();
             const projectId = projectIdOverride || urlProjectId;
             if (!projectId) {
+              if (options2?.reviewRunIds?.length) throw new Error("Review persistence lost its project.");
               return;
             }
             const liveRunView = readLiveRunViewForSaveStateGuard();
@@ -41133,6 +41798,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                 "Skipped saveState: run is in flight on a different project than the current URL; settlement owns persistence.",
                 "\u5DF2\u8DF3\u8FC7 saveState\uFF1A\u672C\u6B21\u8FD0\u884C\u6240\u5C5E\u9879\u76EE\u4E0E\u5F53\u524D URL \u4E0D\u4E00\u81F4\uFF0C\u5199\u56DE\u7531 settlement \u8D1F\u8D23\u3002"
               ));
+              if (options2?.reviewRunIds?.length) throw new Error("Review persistence project changed.");
               return;
             }
             const compactState = prepareStateForStorage(state, { onAggressive: notifyAggressiveCompactionOnce });
@@ -41150,6 +41816,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               compactState: compactStateSnapshot,
               projectId,
               deletedSessionIds: options2?.deletedSessionIds,
+              reviewRunIds: options2?.reviewRunIds,
               Migration,
               StorageDb,
               SessionPersistence: Modules.SessionPersistence,
@@ -41175,17 +41842,17 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                 },
                 persistScopedState
               );
-              if (!committed.ok && (options2?.queueMutation || options2?.queueMutations?.length || committed.reason !== "stale_view")) {
+              if (!committed.ok && (options2?.reviewRunIds?.length || options2?.queueMutation || options2?.queueMutations?.length || committed.reason !== "stale_view")) {
                 throw Object.assign(new Error(`Scoped persistence failed: ${committed.reason}`), {
                   code: committed.reason
                 });
               }
             }
           } catch (error) {
-            if (error?.code === "account_scope_unavailable" && !options2?.queueMutation && !(Array.isArray(options2?.queueMutations) && options2.queueMutations.length)) {
+            if (error?.code === "account_scope_unavailable" && !options2?.reviewRunIds?.length && !options2?.queueMutation && !(Array.isArray(options2?.queueMutations) && options2.queueMutations.length)) {
               return;
             }
-            if (options2?.queueMutation || options2?.queueMutations?.length) {
+            if (options2?.reviewRunIds?.length || options2?.queueMutation || options2?.queueMutations?.length) {
               throw error;
             }
             let fallbackError = null;
@@ -41284,6 +41951,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             if (isStorageQuotaError(error)) {
               emitStorageQuotaFailure(error, null);
             }
+            if (persistenceOptions?.reviewRunIds?.length) throw error;
             appendPlainLog(tx(`Failed to save session state: ${formatStateSaveError(error)}`, `\u4FDD\u5B58\u4F1A\u8BDD\u72B6\u6001\u5931\u8D25\uFF1A${formatStateSaveError(error)}`));
           }).finally(() => {
             if (saveStateInFlightPromise === runPromise) {
@@ -41330,6 +41998,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             ...current || {},
             ...incoming,
             queueMutation: void 0,
+            reviewRunIds: Array.from(/* @__PURE__ */ new Set([...current?.reviewRunIds || [], ...incoming?.reviewRunIds || []])),
             queueMutations,
             deletedSessionIds: Array.from(/* @__PURE__ */ new Set([
               ...current?.deletedSessionIds || [],
@@ -41371,15 +42040,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           renderSessionList();
         }
         function getRenderedModelEntries() {
-          return Array.from(panel?.querySelector("[data-model]")?.options || []).map((option) => ({
-            id: option.value,
-            label: option.textContent,
-            reasoningEfforts: (option.dataset.reasoningEfforts || "").split(",").filter(Boolean),
-            defaultReasoningEffort: option.dataset.defaultReasoningEffort || "",
-            reasoningPresentation: option.dataset.reasoningPresentation || "",
-            speedTiers: (option.dataset.speedTiers || "standard").split(",").filter(Boolean),
-            defaultSpeedTier: option.dataset.defaultSpeedTier || "standard"
-          }));
+          return Modules.ModelPickerSupport.getRenderedModelEntries(panel);
         }
         async function selectMode(mode) {
           if (!["ask", "auto"].includes(mode)) {
@@ -41500,6 +42161,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           applySessionLabel();
           renderSessionList();
           renderRunHistory(options2);
+          getTrackedChangeCaptureController().schedule();
           renderContextSelection();
           renderContextSummary();
           if (!composerAttachmentsRestoredOnce && Array.isArray(state.composerAttachments) && state.composerAttachments.length && !composerAttachmentController.getAttachmentsForRun?.().length && typeof composerAttachmentController.restorePersistedAttachments === "function") {
@@ -41578,6 +42240,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             undoStatus: "",
             queueItemId,
             nativeRequestId: "",
+            codexThreadId: "",
             codexTurnId: "",
             nativeEventSeq: 0,
             executionSnapshot: executionSnapshot ? RunExecutionSnapshot.cloneSnapshot(executionSnapshot) : void 0,
@@ -41716,6 +42379,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           currentRunView.activeTurn = { threadId, turnId };
           const record = findRunRecord(currentRunView.recordId, currentRunView.sessionId);
           if (record) {
+            record.codexThreadId = threadId;
             record.codexTurnId = turnId;
             record.nativeEventSeq = Math.max(Number(record.nativeEventSeq || 0), Number(journalSeq || 0));
           }
@@ -42029,6 +42693,12 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           }
           return files;
         }
+        function refreshHistoricalProjectReferences(project) {
+          if (!project?.id || String(project.id) !== getCurrentProjectId()) return;
+          state = updateActiveSession(state, { projectReferenceFiles: captureProjectReferenceFiles(project) });
+          saveStateSoon();
+          if (!currentRunView && !trackedChangeInFlight.size) renderRunHistory({ preserveScroll: true });
+        }
         function persistCurrentProjectReferenceFiles(project) {
           const projectFiles = captureProjectReferenceFiles(project);
           if (currentRunView) {
@@ -42143,6 +42813,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 }),
@@ -42194,46 +42865,50 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             status: "running",
             detail: { [tr("detailWillUndo")]: trackedUndo ? formatTrackedChangeFiles(run.undoTrackedChanges) : formatTrackedUndoFiles(run) }
           });
-          let result;
           try {
-            result = await callPageBridge("rejectTrackedChanges", {
+            const trackedUndoPostFilesAtDispatch = buildTrackedUndoPostFiles(run);
+            const 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
               // `aborted_project_changed` and the document is left untouched.
               runProjectId: getRunProjectIdForWriteback(run)
             });
+            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",
+              detail: {
+                [trackedUndo ? tr("detailRejected") : tr("detailUndone")]: (result.applied || []).map((item) => ({
+                  [tr("detailFile")]: item.trackedChange?.path || tr("unknownFile"),
+                  [tr("detailRecord")]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key
+                })),
+                [tr("detailSkipped")]: (result.skipped || []).map((item) => ({
+                  [tr("detailFile")]: item.trackedChange?.path || tr("unknownFile"),
+                  [tr("detailRecord")]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key || "",
+                  [tr("detailReason")]: formatBridgeResultReason(item.result, item.trackedChange?.path)
+                }))
+              }
+            });
+            if (lifecycleReject) {
+              WritebackSettlement.attachUndoNotVerifiedFailure(run, result, {
+                buildFailure: buildContentFailure,
+                postFiles: trackedUndoPostFilesAtDispatch
+              });
+              await applyTrackedChangeSettlement(runId, "reject", result);
+              return;
+            }
+            applyLegacyUndoSettlement(runId, result.skipped?.length ? "partial" : "applied", result);
           } finally {
             if (lifecycleReject) {
               trackedChangeInFlight.delete(runId);
+              refreshRunCardControls(runId);
             }
           }
-          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",
-            detail: {
-              [trackedUndo ? tr("detailRejected") : tr("detailUndone")]: (result.applied || []).map((item) => ({
-                [tr("detailFile")]: item.trackedChange?.path || tr("unknownFile"),
-                [tr("detailRecord")]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key
-              })),
-              [tr("detailSkipped")]: (result.skipped || []).map((item) => ({
-                [tr("detailFile")]: item.trackedChange?.path || tr("unknownFile"),
-                [tr("detailRecord")]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key || "",
-                [tr("detailReason")]: formatBridgeResultReason(item.result, item.trackedChange?.path)
-              }))
-            }
-          });
-          if (lifecycleReject) {
-            WritebackSettlement.attachUndoNotVerifiedFailure(run, result, {
-              buildFailure: buildContentFailure
-            });
-            applyTrackedChangeSettlement(runId, "reject", result);
-            return;
-          }
-          applyLegacyUndoSettlement(runId, result.skipped?.length ? "partial" : "applied", result);
         }
         async function acceptRun(runId) {
           const run = findRunRecord(runId);
@@ -42257,50 +42932,50 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             status: "running",
             detail: { [tr("detailAccepted")]: formatTrackedChangeFiles(run.undoTrackedChanges) }
           });
-          let result;
           try {
-            result = await callPageBridge("acceptTrackedChanges", {
+            const result = await callPageBridge("acceptTrackedChanges", {
               trackedChanges: run.undoTrackedChanges || [],
               expectedFiles: run.undoExpectedFiles || [],
               postFiles: buildTrackedUndoPostFiles(run),
               appliedOperations: Array.isArray(run.appliedOperations) ? run.appliedOperations : [],
               runProjectId: getRunProjectIdForWriteback(run)
             });
-          } finally {
-            trackedChangeInFlight.delete(runId);
-          }
-          appendAcceptDiagnosticEvents(runId, Array.isArray(result.diagnostics) ? result.diagnostics : []);
-          appendRunRecordEvent(runId, {
-            title: tr("runAcceptTrackedResult", { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }),
-            status: result.skipped?.length ? "failed" : "completed",
-            detail: {
-              [tr("detailAccepted")]: (result.applied || []).map((item) => ({
-                [tr("detailFile")]: item.trackedChange?.path || tr("unknownFile"),
-                [tr("detailRecord")]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key
-              })),
-              [tr("detailSkipped")]: (result.skipped || []).map((item) => ({
-                [tr("detailFile")]: item.trackedChange?.path || tr("unknownFile"),
-                [tr("detailRecord")]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key || "",
-                [tr("detailReason")]: formatBridgeResultReason(item.result, item.trackedChange?.path)
-              }))
-            }
-          });
-          if (result.ok === false) {
+            appendAcceptDiagnosticEvents(runId, Array.isArray(result.diagnostics) ? result.diagnostics : []);
             appendRunRecordEvent(runId, {
-              title: tr("runAcceptTrackedFailed"),
-              status: "failed",
+              title: tr("runAcceptTrackedResult", { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }),
+              status: result.skipped?.length ? "failed" : "completed",
               detail: {
-                [tr("detailReason")]: tr("runAcceptTrackedFailedReason")
+                [tr("detailAccepted")]: (result.applied || []).map((item) => ({
+                  [tr("detailFile")]: item.trackedChange?.path || tr("unknownFile"),
+                  [tr("detailRecord")]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key
+                })),
+                [tr("detailSkipped")]: (result.skipped || []).map((item) => ({
+                  [tr("detailFile")]: item.trackedChange?.path || tr("unknownFile"),
+                  [tr("detailRecord")]: item.trackedChange?.label || item.trackedChange?.id || item.trackedChange?.key || "",
+                  [tr("detailReason")]: formatBridgeResultReason(item.result, item.trackedChange?.path)
+                }))
               }
             });
-            if (!WritebackSettlement.isSuccessfulTrackedChangeSettlement(result)) {
-              refreshRunCardControls(runId);
+            if (result.ok === false) {
+              appendRunRecordEvent(runId, {
+                title: tr("runAcceptTrackedFailed"),
+                status: "failed",
+                detail: {
+                  [tr("detailReason")]: tr("runAcceptTrackedFailedReason")
+                }
+              });
+              if (!WritebackSettlement.isSuccessfulTrackedChangeSettlement(result)) {
+                refreshRunCardControls(runId);
+              }
             }
+            WritebackSettlement.attachAcceptNotVerifiedFailure(run, result, {
+              buildFailure: buildContentFailure
+            });
+            await applyTrackedChangeSettlement(runId, "accept", result);
+          } finally {
+            trackedChangeInFlight.delete(runId);
+            refreshRunCardControls(runId);
           }
-          WritebackSettlement.attachAcceptNotVerifiedFailure(run, result, {
-            buildFailure: buildContentFailure
-          });
-          applyTrackedChangeSettlement(runId, "accept", result);
         }
         function getRunProjectIdForWriteback(run) {
           return typeof run?.runProjectId === "string" && run.runProjectId ? run.runProjectId : "";
@@ -42331,7 +43006,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             FailureReasons
           );
         }
-        function applyTrackedChangeSettlement(runId, kind, result) {
+        async function applyTrackedChangeSettlement(runId, kind, result) {
           const run = findRunRecord(runId);
           const settlement = WritebackSettlement.settleTrackedChangeLifecycle({
             kind,
@@ -42340,12 +43015,14 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             failureReasons: FailureReasons
           });
           if (settlement.decision === "blocked") {
-            refreshRunCardControls(runId);
             return;
           }
-          Object.assign(run, WritebackSettlement.applySettlementTransition(run, settlement));
-          saveStateSoon();
-          refreshRunCardControls(runId);
+          await Modules.ScopedPersistenceCoordinator.applyReviewTransition({
+            getState: () => state,
+            runId,
+            transition: WritebackSettlement.applySettlementTransition(run, settlement),
+            persist: flushQueuedSaveState
+          });
         }
         function getRunUndoCount(run) {
           if (!run) {
@@ -42408,6 +43085,28 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         function attachVerifiedContentToOperation(operation, result) {
           return WritebackSettlement.attachVerifiedContentToOperation(operation, result);
         }
+        let trackedChangeCaptureController = null;
+        function getTrackedChangeCaptureController() {
+          return trackedChangeCaptureController || (trackedChangeCaptureController = Modules.TrackedChangeCaptureController.create({
+            getRuns: () => (state.sessions || []).flatMap((session) => session.runs || []),
+            getProjectId: () => window.location.pathname.match(/^\/project\/([^/]+)/)?.[1] || "",
+            buildExpectedFilesAfterOperations,
+            normalizeTrackedChanges: normalizeApplyTrackedChanges,
+            callPageBridge,
+            persist: () => flushQueuedSaveState({ preserveRunActionPayload: true }),
+            refresh: (run) => refreshRunCardControls(run.id),
+            notify: (run, kind, detail) => appendRunRecordEvent(run.id, {
+              title: {
+                pending: tx("Files written; confirming tracked changes.", "\u6587\u4EF6\u5DF2\u5199\u5165\uFF0C\u6B63\u5728\u786E\u8BA4\u7559\u75D5\u8BB0\u5F55\u3002"),
+                observed: tx("Tracked changes confirmed; Accept is available.", "\u7559\u75D5\u8BB0\u5F55\u5DF2\u786E\u8BA4\uFF0C\u53EF\u4EE5\u63A5\u53D7\u6539\u52A8\u3002"),
+                needs_review: tx("Tracked changes could not be safely attributed. Review them in Overleaf; Undo is preserved.", "\u7559\u75D5\u5F52\u5C5E\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5728 Overleaf \u5BA1\u9605\uFF1B\u539F\u6709\u64A4\u9500\u80FD\u529B\u5DF2\u4FDD\u7559\u3002")
+              }[kind],
+              status: "info",
+              detail
+            }),
+            onError: (error) => appendPlainLog(tx("Tracked-change confirmation unavailable: ", "\u7559\u75D5\u786E\u8BA4\u6682\u4E0D\u53EF\u7528\uFF1A") + error.message)
+          }));
+        }
         function recordUndoFromApply(project, applyResult) {
           const appliedEntries = getAppliedEntries(applyResult);
           if (!currentRunView?.recordId || !appliedEntries.length) {
@@ -42444,6 +43143,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             if (combinedTrackedChanges.length) {
               record.trackedChangeStatus = "pending";
             }
+            getTrackedChangeCaptureController().record(record, applyResult?.trackedChangeCaptures);
             refreshRunCardControls(record.id);
             if (combinedTrackedChanges.length) {
               appendRunEvent({
@@ -42505,28 +43205,10 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           return WritebackSettlement.normalizeApplyTrackedChanges(changes);
         }
         function selectExpectedFilesForTrackedUndo(project, operations = [], trackedChanges = [], previousExpectedFiles = []) {
-          return WritebackSettlement.selectExpectedFilesForTrackedUndo(
-            project,
-            operations,
-            trackedChanges,
-            previousExpectedFiles
-          );
+          return WritebackSettlement.selectExpectedFilesForTrackedUndo(project, operations, trackedChanges, previousExpectedFiles);
         }
         function buildTrackedUndoPostFiles(run) {
-          const expectedFiles = Array.isArray(run?.undoExpectedFiles) ? run.undoExpectedFiles : [];
-          const appliedOperations = Array.isArray(run?.appliedOperations) ? run.appliedOperations : [];
-          if (!expectedFiles.length || !appliedOperations.length) {
-            return [];
-          }
-          const postFilesByPath = buildExpectedFilesAfterOperations(
-            { files: expectedFiles },
-            appliedOperations
-          );
-          const expectedPaths = new Set(expectedFiles.map((file) => file?.path).filter(Boolean));
-          return Array.from(postFilesByPath.entries()).filter(([path, content]) => expectedPaths.has(path) && typeof content === "string").map(([path, content]) => ({
-            path,
-            content
-          }));
+          return getTrackedChangeCaptureController().buildPostFiles(run);
         }
         function hasTrackedEditorUndo(run) {
           return buildTrackedUndoPostFiles(run).length > 0;
@@ -43103,7 +43785,7 @@ Reason: ${item.reason || "No reason provided"}`),
       root.CodexOverleafContentRuntime = { init };
     })(typeof window !== "undefined" ? window : globalThis);
   }).call(globalThis, void 0, void 0, void 0);
-  (function runClassicContentModule100(module, exports, require2) {
+  (function runClassicContentModule101(module, exports, require2) {
     (function initCodexOverleafLegacyGlobalRegistry(root, factory) {
       "use strict";
       const api = factory();
@@ -43179,6 +43861,7 @@ Reason: ${item.reason || "No reason provided"}`),
         "StorageMigration",
         "Summary",
         "Theme",
+        "TrackedChangeCaptureController",
         "UndoOperations",
         "UpdateIdle",
         "UpdateNotice",