codex-overleaf-link 2.6.0 → 2.6.5

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

@@ -1,4 +1,4 @@
-if (typeof document !== 'undefined' && document.documentElement) document.documentElement.setAttribute('data-codex-overleaf-source-digest', "0cf851b033afb0885464fd86506f423f35fe82d6da8c1f1644012350cab0ddc4");
+if (typeof document !== 'undefined' && document.documentElement) document.documentElement.setAttribute('data-codex-overleaf-source-digest', "91739cf894fed56c2880986120922d3b54bb423ab2d116705385da1d0fe518be");
 (() => {
   // extension/entries/content-entry.mjs
   (function runClassicContentModule(module, exports, require2) {
@@ -913,6 +913,13 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
           fallbackUserMessage: "The file changed while Codex was working.",
           fallbackNextAction: "Review the current file, then rerun the task."
         },
+        document_identity_mismatch: {
+          stage: "preflight",
+          severity: "blocked",
+          defaultRetryable: true,
+          fallbackUserMessage: "Codex could not confirm that the editor content belongs to the target file, so it was not used.",
+          fallbackNextAction: "Wait for the target file to open and settle, then retry. Reload Overleaf if this continues."
+        },
         patch_anchor_not_found: {
           stage: "preflight",
           severity: "blocked",
@@ -1213,6 +1220,13 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
           fallbackUserMessage: "Native host request failed.",
           fallbackNextAction: "Open diagnostics and retry."
         },
+        native_request_timeout: {
+          stage: "native",
+          severity: "error",
+          defaultRetryable: true,
+          fallbackUserMessage: "The local service did not respond.",
+          fallbackNextAction: "Retry, or open Diagnostics to check the local connection."
+        },
         native_protocol_incompatible: {
           stage: "native",
           severity: "blocked",
@@ -1311,6 +1325,13 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
           fallbackUserMessage: "The provider rate limit was reached.",
           fallbackNextAction: "Wait for the rate-limit window to recover and retry."
         },
+        provider_quota_exceeded: {
+          stage: "codex",
+          severity: "error",
+          defaultRetryable: true,
+          fallbackUserMessage: "The model provider quota or billing limit was reached.",
+          fallbackNextAction: "Check the provider account and plan, or switch model or provider before retrying."
+        },
         provider_connection_timeout: {
           stage: "codex",
           severity: "error",
@@ -2038,6 +2059,9 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
         "timeout": {
           "message": "timed out"
         },
+        "native_request_timeout": {
+          "code": "native_request_timeout"
+        },
         "output_limit": {
           "message": "output limit exceeded"
         },
@@ -2054,7 +2078,7 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
           "message": "unsupported_parameter reasoning.summary"
         },
         "storage_quota": {
-          "message": "quota"
+          "message": "storage quota"
         },
         "checkpoint": {
           "message": "checkpoint"
@@ -2092,6 +2116,9 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
         "provider_rate_limited": {
           "message": "provider_rate_limited"
         },
+        "provider_quota_exceeded": {
+          "message": "provider_quota_exceeded"
+        },
         "provider_connection_timeout": {
           "message": "provider_connection_timeout"
         },
@@ -2660,6 +2687,14 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
             nextEn: "Switch between Responses and Chat Completions, or test again with Auto detection.",
             code: "provider_protocol_incompatible"
           },
+          {
+            pattern: /provider_quota_exceeded|insufficient_quota|exceeded your current quota|(?:billing|usage|spend(?:ing)?|credit)[_ -]?(?:hard[_ -]?)?limit[_ -]?(?:reached|exceeded)|(?:billing|plan).{0,40}(?:quota|limit|exhausted)|(?:quota|credits?).{0,40}(?:billing|plan|exhausted|insufficient)/i,
+            conclusionZh: "\u6A21\u578B\u670D\u52A1\u7684\u914D\u989D\u6216\u8D26\u5355\u9650\u989D\u5DF2\u8FBE\u5230\u3002",
+            conclusionEn: "The model provider quota or billing limit was reached.",
+            nextZh: "\u8BF7\u68C0\u67E5\u6A21\u578B\u670D\u52A1\u8D26\u6237\u548C\u5957\u9910\uFF0C\u6216\u5207\u6362\u6A21\u578B\u6216\u6A21\u578B\u670D\u52A1\u540E\u91CD\u8BD5\u3002",
+            nextEn: "Check the provider account and plan, or switch model or provider before retrying.",
+            code: "provider_quota_exceeded"
+          },
           {
             pattern: /provider_rate_limited|rate limit was reached/i,
             conclusionZh: "\u8FD9\u8F6E\u6CA1\u6709\u5B8C\u6210\uFF1A\u7B2C\u4E09\u65B9\u6A21\u578B\u670D\u52A1\u89E6\u53D1\u4E86\u9650\u6D41\u3002",
@@ -2738,6 +2773,13 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
       function translateRawErrorCopy(message, context = {}) {
         const locale = normalizeLocale(context);
         const text = String(message || "");
+        if (context.code === "native_request_timeout" || /native_request_timeout/i.test(text)) {
+          return {
+            conclusion: textFor(locale, "\u672C\u673A\u670D\u52A1\u6CA1\u6709\u54CD\u5E94\u3002", "The local service did not respond."),
+            nextStep: textFor(locale, "\u8BF7\u91CD\u8BD5\uFF0C\u6216\u6253\u5F00\u300C\u8BCA\u65AD\u300D\u68C0\u67E5\u672C\u673A\u8FDE\u63A5\u3002", "Retry, or open Diagnostics to check the local connection."),
+            failureCode: "native_request_timeout"
+          };
+        }
         if (context.code === "codex_local_skill_unavailable" || /(?:The )?selected local Codex skill is unavailable/i.test(text)) {
           return {
             conclusion: textFor(locale, "\u6240\u9009 Codex \u672C\u5730\u6280\u80FD\u4E0D\u53EF\u7528\u6216\u5DF2\u5173\u95ED\uFF0C\u672C\u8F6E\u6CA1\u6709\u542F\u52A8\u3002", "The selected local Codex skill is unavailable or disabled. This run did not start."),
@@ -2835,7 +2877,7 @@ if (typeof document !== 'undefined' && document.documentElement) document.docume
             failureCode: "native_protocol_incompatible"
           };
         }
-        if (/quota|kQuotaBytes|QUOTA_BYTES/i.test(text)) {
+        if (/kQuotaBytes|QUOTA_BYTES|QuotaExceededError|storage quota/i.test(text)) {
           return {
             conclusion: textFor(locale, "Codex \u7ED3\u679C\u5DF2\u7ECF\u751F\u6210\uFF0C\u4F46\u672C\u5730\u4F1A\u8BDD\u8BB0\u5F55\u8D85\u51FA Chrome \u5B58\u50A8\u914D\u989D\u3002", "Codex produced a result, but local session history exceeded Chrome storage quota."),
             nextStep: textFor(locale, "\u8BF7\u5220\u9664\u4E00\u4E9B\u65E7 session\uFF0C\u6216\u5237\u65B0\u6269\u5C55\u540E\u91CD\u8BD5\uFF1B\u8FD9\u4E0D\u662F\u8BBA\u6587\u5206\u6790\u672C\u8EAB\u5931\u8D25\u3002", "Delete older sessions or reload the extension and retry. The paper analysis itself did not fail."),
@@ -4228,10 +4270,11 @@ ${block}`;
             continue;
           }
           seen.add(normalized);
-          result.push(normalized);
           if (result.length >= limit) {
+            result.truncated = true;
             break;
           }
+          result.push(normalized);
         }
         return result;
       }
@@ -4835,6 +4878,46 @@ ${block}`;
       }
     })(typeof globalThis !== "undefined" ? globalThis : window, function staleGuardFactory() {
       "use strict";
+      const DOCUMENT_PROVENANCE_OTHER_MIN = 0.9;
+      const DOCUMENT_PROVENANCE_CLAIMED_MAX = 0.5;
+      const DOCUMENT_PROVENANCE_EDGE_LIMIT = 64 * 1024;
+      function assessDocumentProvenance(input = {}) {
+        const { path, projectId, documentIdentity } = input || {};
+        if (documentIdentity !== void 0) {
+          const valid = documentIdentity && typeof documentIdentity === "object" && !Array.isArray(documentIdentity) && documentIdentity.version === 1 && documentIdentity.source === "cm-ranges-v1" && typeof projectId === "string" && projectId.length > 0 && documentIdentity.projectId === projectId && typeof path === "string" && path.length > 0 && documentIdentity.path === path && typeof documentIdentity.documentId === "string" && typeof documentIdentity.targetDocumentId === "string" && /^[a-f0-9]{24}$/.test(documentIdentity.documentId) && /^[a-f0-9]{24}$/.test(documentIdentity.targetDocumentId) && documentIdentity.documentId === documentIdentity.targetDocumentId;
+          return valid ? { ok: true, identityState: "match" } : { ok: false, code: "document_identity_mismatch", identityState: "mismatch" };
+        }
+        try {
+          const { path: path2, text, references } = input || {};
+          if (typeof text !== "string" || !references) return { ok: true, identityState: "fallback" };
+          const entries = references instanceof Map ? references : Object.entries(references);
+          const claimed = references instanceof Map ? references.get(path2) : Object.prototype.hasOwnProperty.call(references, path2) ? references[path2] : void 0;
+          if (text === claimed) return { ok: true, identityState: "fallback" };
+          let matchedPath, bestScore = -1;
+          for (const [otherPath, reference] of entries) {
+            if (otherPath === path2 || typeof reference !== "string") continue;
+            if (text === reference) return { ok: false, code: "document_identity_mismatch", identityState: "fallback", matchedPath: otherPath };
+            const score = documentSimilarity(text, reference);
+            if (score > bestScore) {
+              bestScore = score;
+              matchedPath = otherPath;
+            }
+          }
+          if (bestScore >= DOCUMENT_PROVENANCE_OTHER_MIN && (typeof claimed !== "string" || documentSimilarity(text, claimed) < DOCUMENT_PROVENANCE_CLAIMED_MAX)) {
+            return { ok: false, code: "document_identity_mismatch", identityState: "fallback", matchedPath };
+          }
+        } catch (_error) {
+        }
+        return { ok: true, identityState: "fallback" };
+      }
+      function documentSimilarity(left, right) {
+        const length = Math.min(left.length, right.length);
+        let prefix = 0, suffix = 0;
+        while (prefix < Math.min(length, DOCUMENT_PROVENANCE_EDGE_LIMIT) && left[prefix] === right[prefix]) prefix++;
+        while (suffix < Math.min(length - prefix, DOCUMENT_PROVENANCE_EDGE_LIMIT) && left[left.length - suffix - 1] === right[right.length - suffix - 1]) suffix++;
+        const denominator = Math.min(Math.max(left.length, right.length), 2 * DOCUMENT_PROVENANCE_EDGE_LIMIT);
+        return denominator ? (prefix + suffix) / denominator : 1;
+      }
       function buildBaseFileLookup(files) {
         if (!Array.isArray(files) || files.length === 0) {
           return null;
@@ -5053,6 +5136,7 @@ ${block}`;
         return String(value || "").replace(/\s+/g, " ").replace(/\\/g, "/").trim().replace(/^\/+/, "");
       }
       return {
+        assessDocumentProvenance,
         buildBaseFileLookup,
         checkOperationFreshness,
         prepareOperationPatches,
@@ -6446,6 +6530,8 @@ ${block}`;
           failureReason_provider_request_rejected_next: "Review the model ID, reasoning controls, tool support, and request overrides.",
           failureReason_provider_rate_limited_user: "The provider rate limit was reached.",
           failureReason_provider_rate_limited_next: "Wait for the rate-limit window to recover and retry.",
+          failureReason_provider_quota_exceeded_user: "The model provider quota or billing limit was reached.",
+          failureReason_provider_quota_exceeded_next: "Check the provider account and plan, or switch model or provider before retrying.",
           failureReason_provider_connection_timeout_user: "The provider connection timed out.",
           failureReason_provider_connection_timeout_next: "Check the endpoint and network, then retry.",
           failureReason_provider_dns_failed_user: "The provider hostname could not be resolved.",
@@ -6934,6 +7020,7 @@ ${block}`;
           queuedInputResume: "Resume",
           queuedInputRemove: "Remove",
           queuedInputAttachmentsUnsupported: "Queued follow-ups currently support text and @context. Remove binary attachments before queuing.",
+          attachmentsLoading: "Attachments are still loading",
           queuedInputError_empty_input: "Enter a follow-up first.",
           queuedInputError_input_too_long: "This follow-up is too long to queue.",
           queuedInputError_queue_full: "The follow-up queue is full.",
@@ -7054,6 +7141,8 @@ ${block}`;
           failureReason_accept_replay_failed_next: "Inspect the file in Overleaf, then retry.",
           failureReason_native_request_failed_user: "The request to the local Codex bridge failed.",
           failureReason_native_request_failed_next: "Open Diagnostics to check the bridge, then retry.",
+          failureReason_native_request_timeout_user: "The local service did not respond.",
+          failureReason_native_request_timeout_next: "Retry, or open Diagnostics to check the local connection.",
           failureReason_panel_reload_interrupted_user: "This run was interrupted by a page refresh.",
           failureReason_panel_reload_interrupted_next: "Edit and resend the task to continue.",
           failureReason_sensitive_content_blocked_user: "Sensitive content was found before sending, so Codex did not receive this request.",
@@ -7080,6 +7169,8 @@ ${block}`;
           failureReason_target_editor_not_ready_next: "Wait for Overleaf to finish loading, then retry.",
           failureReason_stale_source_changed_user: "{file} changed while Codex was working, so Codex did not overwrite it.",
           failureReason_stale_source_changed_next: "Review the current file, then rerun the task.",
+          failureReason_document_identity_mismatch_user: "Codex could not confirm that the editor content belongs to the target file, so it was not used.",
+          failureReason_document_identity_mismatch_next: "Wait for the target file to open and settle, then retry. Reload Overleaf if this continues.",
           failureReason_patch_anchor_not_found_user: "The edit anchor for {file} no longer matches current Overleaf content.",
           failureReason_patch_anchor_not_found_next: "Rerun the task against the current document.",
           failureReason_write_observed_mismatch_user: "Codex attempted to write {file}, but the content read back from Overleaf did not match the approved change.",
@@ -7146,6 +7237,7 @@ ${block}`;
           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_renameFailed: "Could not rename the conversation. Your title is still available to edit or copy.",
           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",
@@ -7330,6 +7422,8 @@ ${block}`;
           failureReason_provider_request_rejected_next: "\u8BF7\u68C0\u67E5\u6A21\u578B\u6807\u8BC6\u3001\u63A8\u7406\u8BBE\u7F6E\u3001\u5DE5\u5177\u652F\u6301\u53CA\u81EA\u5B9A\u4E49\u8BF7\u6C42\u53C2\u6570\u3002",
           failureReason_provider_rate_limited_user: "\u6A21\u578B\u670D\u52A1\u5DF2\u8FBE\u5230\u8BF7\u6C42\u9891\u7387\u9650\u5236\u3002",
           failureReason_provider_rate_limited_next: "\u8BF7\u7B49\u5F85\u9650\u6D41\u7A97\u53E3\u6062\u590D\u540E\u91CD\u8BD5\u3002",
+          failureReason_provider_quota_exceeded_user: "\u6A21\u578B\u670D\u52A1\u7684\u914D\u989D\u6216\u8D26\u5355\u9650\u989D\u5DF2\u8FBE\u5230\u3002",
+          failureReason_provider_quota_exceeded_next: "\u8BF7\u68C0\u67E5\u6A21\u578B\u670D\u52A1\u8D26\u6237\u548C\u5957\u9910\uFF0C\u6216\u5207\u6362\u6A21\u578B\u6216\u6A21\u578B\u670D\u52A1\u540E\u91CD\u8BD5\u3002",
           failureReason_provider_connection_timeout_user: "\u6A21\u578B\u670D\u52A1\u8FDE\u63A5\u8D85\u65F6\u3002",
           failureReason_provider_connection_timeout_next: "\u8BF7\u68C0\u67E5\u670D\u52A1\u7AEF\u70B9\u548C\u7F51\u7EDC\uFF0C\u7136\u540E\u91CD\u8BD5\u3002",
           failureReason_provider_dns_failed_user: "\u65E0\u6CD5\u89E3\u6790\u6A21\u578B\u670D\u52A1\u7684\u4E3B\u673A\u540D\u3002",
@@ -7818,6 +7912,7 @@ ${block}`;
           queuedInputResume: "\u7EE7\u7EED",
           queuedInputRemove: "\u5220\u9664",
           queuedInputAttachmentsUnsupported: "\u5F53\u524D\u6392\u961F\u6D88\u606F\u652F\u6301\u6587\u672C\u548C @context\uFF1B\u8BF7\u5148\u79FB\u9664\u4E8C\u8FDB\u5236\u9644\u4EF6\u3002",
+          attachmentsLoading: "\u9644\u4EF6\u8BFB\u53D6\u4E2D",
           queuedInputError_empty_input: "\u8BF7\u5148\u8F93\u5165\u540E\u7EED\u4EFB\u52A1\u3002",
           queuedInputError_input_too_long: "\u8FD9\u6761\u540E\u7EED\u4EFB\u52A1\u592A\u957F\uFF0C\u65E0\u6CD5\u6392\u961F\u3002",
           queuedInputError_queue_full: "\u540E\u7EED\u4EFB\u52A1\u961F\u5217\u5DF2\u6EE1\u3002",
@@ -7937,6 +8032,8 @@ ${block}`;
           failureReason_accept_replay_failed_next: "\u8BF7\u5728 Overleaf \u4E2D\u68C0\u67E5\u8BE5\u6587\u4EF6\u540E\u91CD\u8BD5\u3002",
           failureReason_native_request_failed_user: "\u5411\u672C\u5730 Codex bridge \u7684\u8BF7\u6C42\u5931\u8D25\u3002",
           failureReason_native_request_failed_next: "\u6253\u5F00\u300C\u8BCA\u65AD\u300D\u68C0\u67E5 bridge \u540E\u91CD\u8BD5\u3002",
+          failureReason_native_request_timeout_user: "\u672C\u673A\u670D\u52A1\u6CA1\u6709\u54CD\u5E94\u3002",
+          failureReason_native_request_timeout_next: "\u8BF7\u91CD\u8BD5\uFF0C\u6216\u6253\u5F00\u300C\u8BCA\u65AD\u300D\u68C0\u67E5\u672C\u673A\u8FDE\u63A5\u3002",
           failureReason_panel_reload_interrupted_user: "\u9875\u9762\u5237\u65B0\u5BFC\u81F4\u672C\u8F6E\u4E2D\u65AD\u3002",
           failureReason_panel_reload_interrupted_next: "\u53EF\u7F16\u8F91\u540E\u91CD\u53D1\u4EFB\u52A1\u4EE5\u7EE7\u7EED\u3002",
           failureReason_sensitive_content_blocked_user: "\u53D1\u9001\u524D\u53D1\u73B0\u654F\u611F\u5185\u5BB9\uFF0CCodex \u6CA1\u6709\u6536\u5230\u8FD9\u6B21\u8BF7\u6C42\u3002",
@@ -7963,6 +8060,8 @@ ${block}`;
           failureReason_target_editor_not_ready_next: "\u8BF7\u7B49 Overleaf \u52A0\u8F7D\u5B8C\u6210\u540E\u518D\u91CD\u8BD5\u3002",
           failureReason_stale_source_changed_user: "{file} \u5728\u4EFB\u52A1\u6267\u884C\u671F\u95F4\u88AB\u4FEE\u6539\u8FC7\uFF0CCodex \u6CA1\u6709\u8986\u76D6\u5B83\u3002",
           failureReason_stale_source_changed_next: "\u8BF7\u5148\u67E5\u770B\u5F53\u524D\u6587\u4EF6\u5185\u5BB9\uFF0C\u518D\u91CD\u65B0\u8FD0\u884C\u672C\u8F6E\u4EFB\u52A1\u3002",
+          failureReason_document_identity_mismatch_user: "Codex \u65E0\u6CD5\u786E\u8BA4\u7F16\u8F91\u5668\u5185\u5BB9\u5C5E\u4E8E\u76EE\u6807\u6587\u4EF6\uFF0C\u56E0\u6B64\u6CA1\u6709\u4F7F\u7528\u8FD9\u4E9B\u5185\u5BB9\u3002",
+          failureReason_document_identity_mismatch_next: "\u8BF7\u7B49\u76EE\u6807\u6587\u4EF6\u6253\u5F00\u5E76\u7A33\u5B9A\u540E\u91CD\u8BD5\uFF1B\u5982\u679C\u95EE\u9898\u6301\u7EED\uFF0C\u8BF7\u91CD\u65B0\u52A0\u8F7D Overleaf\u3002",
           failureReason_patch_anchor_not_found_user: "{file} \u7684\u4FEE\u6539\u951A\u70B9\u5DF2\u7ECF\u65E0\u6CD5\u548C\u5F53\u524D Overleaf \u5185\u5BB9\u5BF9\u9F50\u3002",
           failureReason_patch_anchor_not_found_next: "\u8BF7\u57FA\u4E8E\u5F53\u524D\u6587\u6863\u91CD\u65B0\u8FD0\u884C\u4EFB\u52A1\u3002",
           failureReason_write_observed_mismatch_user: "Codex \u5C1D\u8BD5\u5199\u5165 {file}\uFF0C\u4F46\u5199\u5165\u540E\u4ECE Overleaf \u8BFB\u56DE\u7684\u5185\u5BB9\u4E0E\u6279\u51C6\u7684\u6539\u52A8\u4E0D\u4E00\u81F4\u3002",
@@ -8029,6 +8128,7 @@ ${block}`;
           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_renameFailed: "\u6682\u65F6\u65E0\u6CD5\u91CD\u547D\u540D\u5BF9\u8BDD\uFF0C\u8F93\u5165\u7684\u6807\u9898\u4ECD\u4FDD\u7559\uFF0C\u53EF\u7EE7\u7EED\u7F16\u8F91\u6216\u590D\u5236\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",
@@ -9943,7 +10043,18 @@ ${block}`;
       const sameScope = (a, b) => a.accountScopeId === b.accountScopeId && a.projectId === b.projectId && a.generation === b.generation;
       function applySnapshot(options, sessions) {
         const previous = options.getState(), scope = options.getScope();
-        const next = options.normalize({ ...previous, sessions }, { restoreRunningRuns: false });
+        const input = sessions.length ? { ...previous, sessions } : {
+          ...previous,
+          session: null,
+          sessions: [],
+          runs: [],
+          activeSessionId: "",
+          task: "",
+          focusFiles: [],
+          selectionContext: null,
+          composerAttachments: []
+        };
+        const next = options.normalize(input, { restoreRunningRuns: false });
         const unchangedSnapshot = JSON.stringify(next);
         options.setState(next);
         try {
@@ -10029,6 +10140,10 @@ ${block}`;
         }
         const unsubscribe = Bridge.subscribe((change) => {
           const scope = getScope();
+          if (options.isDashboard?.()) {
+            if (scope.accountScopeId && change.accountScopeId === scope.accountScopeId) options.refreshDashboard?.();
+            return;
+          }
           if (!change.projectId || change.projectId === scope.projectId) {
             retryCount = 0;
             pending = true;
@@ -10072,6 +10187,7 @@ ${block}`;
     })(typeof globalThis !== "undefined" ? globalThis : this, function(QueuePolicy, SharedSessions) {
       "use strict";
       var META_PREFIX = "codex-overleaf-scoped-persistence-v1:";
+      var MIRROR_FENCE_PREFIX = "codex-overleaf-mirror-reuse-fence-v1:";
       var fallbackMeta = /* @__PURE__ */ new Map();
       var cleanPart = QueuePolicy.cleanPart;
       var normalizeMeta = QueuePolicy.normalizeMeta;
@@ -10127,7 +10243,35 @@ ${block}`;
           }
         };
       }
+      async function getMirrorReuseFences(scope, chromeApi) {
+        chromeApi = chromeApi || (typeof chrome !== "undefined" ? chrome : null);
+        if (!normalizeScope(scope).projectId || !chromeApi?.storage?.local) throw new Error("Mirror fence storage is unavailable.");
+        var prefix = MIRROR_FENCE_PREFIX + scopeKey(scope).slice(META_PREFIX.length) + ":";
+        var stored = await chromeApi.storage.local.get(null);
+        return Object.keys(stored || {}).filter((key) => key.startsWith(prefix)).map((key) => {
+          var generation = key.slice(prefix.length);
+          if (!/^[a-zA-Z0-9_-]{1,160}$/.test(generation) || stored[key]?.v !== 1 || stored[key].generation !== generation) {
+            throw new Error("Mirror fence storage contains an unreadable generation.");
+          }
+          return generation;
+        }).sort();
+      }
+      async function setMirrorReuseFence(scope, generation, chromeApi) {
+        chromeApi = chromeApi || (typeof chrome !== "undefined" ? chrome : null);
+        if (!normalizeScope(scope).projectId || !chromeApi?.storage?.local || !/^[a-zA-Z0-9_-]{1,160}$/.test(generation)) throw new Error("Mirror fence storage is unavailable.");
+        var key = MIRROR_FENCE_PREFIX + scopeKey(scope).slice(META_PREFIX.length) + ":" + generation;
+        await chromeApi.storage.local.set({ [key]: { v: 1, generation } });
+      }
+      async function clearMirrorReuseFences(scope, generations, chromeApi) {
+        chromeApi = chromeApi || (typeof chrome !== "undefined" ? chrome : null);
+        if (!normalizeScope(scope).projectId || !chromeApi?.storage?.local || !Array.isArray(generations) || generations.some((generation) => !/^[a-zA-Z0-9_-]{1,160}$/.test(generation))) throw new Error("Mirror fence storage is unavailable.");
+        var prefix = MIRROR_FENCE_PREFIX + scopeKey(scope).slice(META_PREFIX.length) + ":";
+        await chromeApi.storage.local.remove(generations.map((generation) => prefix + generation));
+      }
       return Object.freeze({
+        getMirrorReuseFences,
+        setMirrorReuseFence,
+        clearMirrorReuseFences,
         createBrowserAdapter,
         normalizeScope,
         scopeKey
@@ -14405,6 +14549,10 @@ ${block}`;
       "use strict";
       const EPOCH_KEY = "composer-attachment-draft:clear-epoch";
       const normalize = (value) => SessionState.normalizeComposerAttachmentsForPersistence(value);
+      function normalizeOmitted(value) {
+        const names = (Array.isArray(value?.names) ? value.names : []).filter((name) => typeof name === "string").map((name) => name.replace(/\0/g, "").trim().slice(0, 180)).filter(Boolean).slice(0, 8);
+        return { count: names.length, names };
+      }
       const scopeKey = (scope) => JSON.stringify([scope?.accountScopeId || "", scope?.projectId || ""]);
       function checkedScope(scope) {
         const accountScopeId = String(scope?.accountScopeId || "").trim();
@@ -14438,21 +14586,23 @@ ${block}`;
                     throw failure("account_scope_unavailable");
                   }
                   const revision = Number(previous?.revision) || 0;
-                  result = { epoch, clearedAt, revision, attachments: normalize(previous?.attachments) };
+                  result = { epoch, clearedAt, revision, attachments: normalize(previous?.attachments), omittedAttachments: normalizeOmitted(previous?.omittedAttachments) };
                   if (!value) return;
                   const attachments = normalize(value.attachments);
+                  const omittedAttachments = normalizeOmitted(value.omittedAttachments);
+                  const hasDraft = attachments.length || omittedAttachments.count;
                   if (value.epoch !== epoch) {
-                    if (!attachments.length) return;
+                    if (!hasDraft) return;
                     throw failure("composer_draft_cleared");
                   }
                   if (value.revision !== revision) {
-                    if (JSON.stringify(attachments) === JSON.stringify(result.attachments)) return;
+                    if (JSON.stringify(attachments) === JSON.stringify(result.attachments) && JSON.stringify(omittedAttachments) === JSON.stringify(result.omittedAttachments)) return;
                     throw failure("composer_draft_conflict");
                   }
-                  if (attachments.length && value.unbased && clearedAt && value.changedAt <= clearedAt) {
+                  if (hasDraft && value.unbased && clearedAt && value.changedAt <= clearedAt) {
                     throw failure("composer_draft_cleared");
                   }
-                  result = { epoch, clearedAt, revision: revision + 1, attachments };
+                  result = { epoch, clearedAt, revision: revision + 1, attachments, omittedAttachments };
                   store.put({ id, type: "composer-attachment-draft", ...scope, ...result });
                 } catch (caught) {
                   error = caught;
@@ -14522,7 +14672,11 @@ ${block}`;
         function hydrate(attachments) {
           syncScope();
           if (hydrated) return;
-          if (!changedVersion && !options.getAttachments().length) options.restore(normalize(attachments));
+          if (!changedVersion && !options.getAttachments().length) {
+            options.restore(normalize(attachments));
+            const omitted = normalizeOmitted(base?.omittedAttachments);
+            if (omitted.count) options.onRestoreOmittedAttachments?.(omitted);
+          }
           hydrated = true;
           publish();
         }
@@ -14547,10 +14701,11 @@ ${block}`;
             if (captured !== generation || scopeKey(options.getScope()) !== key || changedVersion === savedVersion) return;
             const version = changedVersion;
             const attachments = normalize(options.getAttachments());
+            const omittedAttachments = normalizeOmitted({ names: options.getOmittedAttachmentNames?.() });
             const unbased = dirtyUnbased, changedAt = dirtySince;
             if (!base) await load(scope);
             if (captured !== generation || scopeKey(options.getScope()) !== key) return;
-            const written = await options.write(checkedScope(scope), { ...base, attachments, unbased, changedAt });
+            const written = await options.write(checkedScope(scope), { ...base, attachments, omittedAttachments, unbased, changedAt });
             if (captured !== generation) return;
             base = written;
             savedVersion = version;
@@ -15851,6 +16006,95 @@ ${block}`;
         "selectedLocalSkillIdsByProject"
       ];
       var projectPreferenceLockTails = {};
+      var projectPreferenceBaselines = /* @__PURE__ */ new Map();
+      var projectPreferenceIntents = /* @__PURE__ */ new Map();
+      var projectPreferenceBaselineVersions = /* @__PURE__ */ new WeakMap();
+      function getProjectPreferenceBaseline(accountScopeId, projectId) {
+        var key = buildScopedProjectPreferenceKey(accountScopeId, projectId);
+        var baseline = copyPreferenceValue(projectPreferenceBaselines.get(key));
+        var intents = projectPreferenceIntents.get(key);
+        if (baseline && intents) projectPreferenceBaselineVersions.set(baseline, {
+          owner: intents,
+          versions: Object.assign({}, intents.acknowledged)
+        });
+        return baseline;
+      }
+      function adoptProjectPreferenceBaseline(prefs, accountScopeId, projectId) {
+        var key = buildScopedProjectPreferenceKey(accountScopeId, projectId);
+        if (key) {
+          projectPreferenceBaselines.set(key, copyPreferenceValue(prefs));
+          projectPreferenceIntents.set(key, { revision: 0, fields: {}, acknowledged: {} });
+        }
+      }
+      function captureProjectPreferenceWrite(input) {
+        var projectId = input.projectId;
+        var key = buildScopedProjectPreferenceKey(input.accountScopeId, projectId);
+        if (!key) return null;
+        var intents = projectPreferenceIntents.get(key);
+        if (!intents) {
+          intents = { revision: 0, fields: {}, acknowledged: {} };
+          projectPreferenceIntents.set(key, intents);
+        }
+        function values(prefs) {
+          return {
+            experimentalOtByProject: input.normalizeExperimentalOtByProject(prefs.experimentalOtByProject)[projectId] === true,
+            reviewingAvailabilityByProject: prefs.reviewingAvailabilityByProject?.[projectId],
+            governanceRulesByProject: input.normalizeGovernanceRulesByProject({
+              [projectId]: prefs.governanceRulesByProject?.[projectId] || {}
+            })[projectId],
+            customInstructionsByProject: input.normalizeCustomInstructionsByProject({
+              [projectId]: prefs.customInstructionsByProject?.[projectId] || ""
+            })[projectId]
+          };
+        }
+        var baseline = input.baseline || getProjectPreferenceBaseline(input.accountScopeId, projectId);
+        var captured = projectPreferenceBaselineVersions.get(baseline);
+        var versions = captured?.owner === intents ? captured.versions : {};
+        var previous = values(baseline || {});
+        var current = values(input.state);
+        var token = { key, owner: intents, projectId, fields: {}, versions: {}, written: [] };
+        for (var name of Object.keys(current)) {
+          var latest = intents.fields[name];
+          var reference = latest && latest.revision > (versions[name] || 0) ? latest.value : previous[name];
+          if (JSON.stringify(current[name]) !== JSON.stringify(reference)) {
+            latest = { revision: ++intents.revision, value: copyPreferenceValue(current[name]), dirty: true };
+            intents.fields[name] = latest;
+          }
+          token.fields[name] = latest && JSON.stringify(current[name]) === JSON.stringify(latest.value) ? latest : null;
+          token.versions[name] = latest?.revision || 0;
+        }
+        return token;
+      }
+      function projectPreferencePatch(token, accountScopeId, projectId) {
+        if (token.key !== buildScopedProjectPreferenceKey(accountScopeId, projectId)) {
+          throw Object.assign(new Error("Scoped project preferences require account and project identity."), {
+            code: "account_scope_unavailable"
+          });
+        }
+        var current = projectPreferenceIntents.get(token.key) === token.owner;
+        var patch = {};
+        token.written = [];
+        for (var name of Object.keys(token.fields)) {
+          var intent = token.fields[name];
+          var changed = current && intent?.dirty && token.owner.fields[name] === intent;
+          patch[name] = changed ? { [token.projectId]: copyPreferenceValue(intent.value) } : {};
+          if (changed) token.written.push(name);
+        }
+        return patch;
+      }
+      function completeProjectPreferenceWrite(token, prefs) {
+        if (projectPreferenceIntents.get(token.key) !== token.owner) return [];
+        for (var name of token.written) {
+          var intent = token.fields[name];
+          intent.dirty = false;
+          token.owner.acknowledged[name] = Math.max(token.owner.acknowledged[name] || 0, intent.revision);
+        }
+        projectPreferenceBaselines.set(token.key, copyPreferenceValue(prefs));
+        return Object.keys(token.fields).filter(function(name2) {
+          var latest = token.owner.fields[name2];
+          return (latest?.revision || 0) === token.versions[name2] && !latest?.dirty;
+        });
+      }
       function buildScopedProjectPreferenceKey(accountScopeId, projectId) {
         var account = compactScopePart(accountScopeId);
         var project = compactScopePart(projectId);
@@ -15984,6 +16228,7 @@ ${block}`;
           var visible = await StorageDb.claimSessionsForAccount(projectId, account, deleted);
           function result(currentPrefs, sessions2, migrated) {
             var wanted = currentPrefs.activeSessionByProject?.[projectId] || "";
+            adoptProjectPreferenceBaseline(currentPrefs, account, projectId);
             return {
               prefs: currentPrefs,
               sessions: sessions2,
@@ -16071,7 +16316,9 @@ ${block}`;
           return chrome.storage.local.get([PREFS_KEY]).then(function(stored) {
             var claimed = claimLegacyProjectPreferences(stored[PREFS_KEY] || {}, account, project);
             var next = mergeScopedProjectPreferences(claimed.prefs, prefs, account, project);
-            return chrome.storage.local.set({ [PREFS_KEY]: next });
+            return chrome.storage.local.set({ [PREFS_KEY]: next }).then(function() {
+              return buildProjectPreferenceView(next, account, project);
+            });
           });
         });
       }
@@ -16255,6 +16502,11 @@ ${block}`;
         runMigrationIfNeeded,
         savePrefs,
         loadPrefs,
+        getProjectPreferenceBaseline,
+        adoptProjectPreferenceBaseline,
+        captureProjectPreferenceWrite,
+        projectPreferencePatch,
+        completeProjectPreferenceWrite,
         loadSessionTombstones,
         addSessionTombstones,
         getDeletedSessionIds,
@@ -16507,7 +16759,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.6.0";
+      const BUILD_TARGET_VERSION = "2.6.5";
       const DEFAULT_CHROME_EXTENSION_ID = "illdpneeeopfffmiepaejglgmhpmdhdc";
       const REQUIRED_CAPABILITIES = Object.freeze([
         "bridgePing",
@@ -16824,7 +17076,7 @@ ${block}`;
       if (root) root.CodexOverleafPageRpcContract = api;
     })(typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : this, function() {
       "use strict";
-      var REVISION = "2026-10-19-mode-menu-switch-v52";
+      var REVISION = "2026-10-29-identity-v54";
       var METHODS = freezeCatalog({
         initializeCapability: entry("bridge.initialize", "control", "none", "default", false, "none"),
         probe: entry("bridge.probe", "read", "none", "default", false, "safe"),
@@ -17809,6 +18061,7 @@ ${block}`;
         return removeEmptySummaryFields(result);
       }
       function summarizeMirror(mirror = {}) {
+        mirror = mirror ?? { status: "unavailable" };
         const files = Array.isArray(mirror.files) ? mirror.files : [];
         const skippedFiles = Array.isArray(mirror.skippedFiles) ? mirror.skippedFiles : [];
         return removeEmptySummaryFields({
@@ -18258,21 +18511,22 @@ ${block}`;
         ["src/shared/projectFiles.js", "codex-overleaf-project-files-script"],
         ["src/shared/compatibility.js", "codex-overleaf-compatibility-page-script"],
         ["src/shared/pageRpcContract.js", "codex-overleaf-page-rpc-contract-script", true],
-        ["src/shared/staleGuard.js", "codex-overleaf-stale-guard-script"],
+        ["src/shared/staleGuard.js", "codex-overleaf-stale-guard-script", true],
+        ["src/shared/otText.js", "codex-overleaf-ot-text-script"],
         ["src/shared/compileAdapter.js", "codex-overleaf-compile-adapter-script"],
         ["src/shared/sensitiveScan.js", "codex-overleaf-sensitive-scan-script"],
         ["src/shared/auditRecords.js", "codex-overleaf-audit-records-script"],
         ["src/page/saveState.js", "codex-overleaf-save-state-script", true],
         ["src/page/overleafCapabilities.js", "codex-overleaf-capabilities-script", true],
         ["src/page/compileBridge.js", "codex-overleaf-compile-bridge-script"],
-        ["src/page/overleafEditor.js", "codex-overleaf-editor-script"],
-        ["src/page/overleafProjectSnapshot.js", "codex-overleaf-project-snapshot-script"],
+        ["src/page/overleafEditor.js", "codex-overleaf-editor-script", true],
+        ["src/page/overleafProjectSnapshot.js", "codex-overleaf-project-snapshot-script", true],
         ["src/page/pageBridgeCapability.js", "codex-overleaf-page-bridge-capability-script"],
         ["src/page/treeOperations.js", "codex-overleaf-tree-operations-script", true],
         ["src/page/ownedDirectoryCleanup.js", "codex-overleaf-owned-directory-cleanup-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/snapshotRouter.js", "codex-overleaf-snapshot-router-script", true],
         ["src/page/referenceProjects.js", "codex-overleaf-reference-projects-script", true],
         ["src/page/fileMover.js", "codex-overleaf-file-mover-script", true],
         ["src/page/writeGuard.js", "codex-overleaf-write-guard-script", true],
@@ -18287,7 +18541,6 @@ ${block}`;
         ["src/pageBridge.js", "codex-overleaf-page-bridge-script", true]
       ]);
       const OPTIONAL_OT_SCRIPTS = Object.freeze([
-        ["src/shared/otText.js", "codex-overleaf-ot-text-script"],
         ["src/page/overleafRealtimeObserver.js", "codex-overleaf-realtime-observer-script"]
       ]);
       function create(options = {}) {
@@ -18525,7 +18778,8 @@ ${block}`;
           try {
             compatibilityGate = await ensureForMethod(payload?.method, context);
             if (!compatibilityGate.ok) return compatibilityGate.response;
-            if (gatedMethods.has(payload?.method) && payload.method !== "mirror.invalidate") {
+            const independentCatalog = payload?.method === "codex.models" || payload?.method === "codex.providers.list";
+            if (gatedMethods.has(payload?.method) && payload.method !== "mirror.invalidate" && !independentCatalog) {
               options.throwIfCancellationRequested?.();
             }
             context.assertCurrent?.();
@@ -18617,7 +18871,7 @@ ${block}`;
             options.setDiagnosticsHealth?.(classification === "update-available" ? "warn" : "fail");
             options.setBadge?.(renderer.headerEl, {
               type: "update",
-              tooltip: tx("Native host update available", "Native host \u53EF\u66F4\u65B0"),
+              tooltip: compatibility.status === "native_unhealthy" ? tx("Codex Unavailable", "Codex \u4E0D\u53EF\u7528") : tx("Native host update available", "Native host \u53EF\u66F4\u65B0"),
               onClick: () => showUpdateGuidance(compatibility)
             });
             if (!compatibility?.native?.version) maybePromptFirstRunSetup();
@@ -18656,7 +18910,9 @@ ${block}`;
           const native = compatibility.native || {};
           const extensionVersion = compatibility.extensionVersion || Compatibility?.BUILD_TARGET_VERSION || "";
           const nativeVersion = compatibility.currentNativeVersion || compatibility.nativeVersion || native.version || tx("missing", "\u672A\u5B89\u88C5");
-          const command = resolveInstallCommand(compatibility);
+          const codexUnavailable = compatibility.status === "native_unhealthy";
+          const resolvedCommand = resolveInstallCommand(compatibility);
+          const command = codexUnavailable ? "" : resolvedCommand;
           const releaseUrl = compatibility.releaseUrl || "";
           const overlay = options.document.createElement("div");
           overlay.className = "codex-plugin-confirm";
@@ -18666,7 +18922,7 @@ ${block}`;
           const nativeMissing = !native.version;
           overlay.setAttribute(
             "aria-label",
-            nativeMissing ? tx("Set up the native host", "\u5B89\u88C5 Native host") : tx("Native host update available", "Native host \u53EF\u66F4\u65B0")
+            codexUnavailable ? tx("Codex Unavailable", "Codex \u4E0D\u53EF\u7528") : nativeMissing ? tx("Set up the native host", "\u5B89\u88C5 Native host") : tx("Native host update available", "Native host \u53EF\u66F4\u65B0")
           );
           const card = options.document.createElement("section");
           card.className = "codex-plugin-confirm-card";
@@ -18683,12 +18939,15 @@ ${block}`;
           brand.textContent = "Codex Overleaf Link";
           const title = options.document.createElement("div");
           title.className = "codex-plugin-confirm-title";
-          title.textContent = nativeMissing ? tx("One step left: install the native host", "\u8FD8\u5DEE\u4E00\u6B65\uFF1A\u5B89\u88C5 Native host") : tx("Native host update available", "Native host \u53EF\u66F4\u65B0");
+          title.textContent = codexUnavailable ? tx("Codex Unavailable", "Codex \u4E0D\u53EF\u7528") : nativeMissing ? tx("One step left: install the native host", "\u8FD8\u5DEE\u4E00\u6B65\uFF1A\u5B89\u88C5 Native host") : tx("Native host update available", "Native host \u53EF\u66F4\u65B0");
           titleWrap.append(brand, title);
           head.append(icon, titleWrap);
           const body = options.document.createElement("div");
           body.className = "codex-plugin-confirm-body";
-          body.textContent = [
+          body.textContent = codexUnavailable ? [
+            tx("The extension reached the native host, but local Codex was not found, so tasks cannot start.", "\u63D2\u4EF6\u5DF2\u7ECF\u8FDE\u4E0A native host\uFF0C\u4F46\u6CA1\u6709\u627E\u5230\u672C\u673A Codex\uFF0C\u6240\u4EE5\u4E0D\u80FD\u542F\u52A8\u4EFB\u52A1\u3002"),
+            tx("Make sure codex works in Terminal, then reload the extension.", "\u8BF7\u786E\u8BA4\u7EC8\u7AEF\u91CC\u53EF\u4EE5\u8FD0\u884C codex\uFF0C\u7136\u540E\u91CD\u65B0\u52A0\u8F7D\u6269\u5C55\u3002")
+          ].join("\n\n") : [
             nativeMissing ? tx(
               `Extension v${extensionVersion} is ready; Codex still needs its local bridge to read and edit this project.`,
               `\u6269\u5C55 v${extensionVersion} \u5DF2\u5C31\u7EEA\uFF1BCodex \u8FD8\u9700\u8981\u672C\u5730\u6865\u63A5\u7A0B\u5E8F\u624D\u80FD\u8BFB\u5199\u8FD9\u4E2A\u9879\u76EE\u3002`
@@ -18704,8 +18963,8 @@ ${block}`;
           const commandCode = options.document.createElement("code");
           commandCode.className = "codex-native-guidance-command";
           commandCode.textContent = command;
-          body.append(commandCode);
-          if (releaseUrl) {
+          if (!codexUnavailable) body.append(commandCode);
+          if (!codexUnavailable && releaseUrl) {
             const link = options.document.createElement("a");
             link.className = "codex-native-guidance-link";
             link.href = releaseUrl;
@@ -18731,7 +18990,8 @@ ${block}`;
           close.className = "codex-plugin-confirm-cancel";
           close.textContent = tx("Close", "\u5173\u95ED");
           close.addEventListener("click", () => overlay.remove());
-          actions.append(close, copy);
+          actions.append(close);
+          if (!codexUnavailable) actions.append(copy);
           card.append(head, body, actions);
           overlay.append(card);
           overlay.addEventListener("click", (event) => {
@@ -21929,7 +22189,8 @@ ${block}`;
           copy.append(text);
           const descriptions = {
             "annotated-rewrite": tx("Guided editing for document revisions.", "\u7528\u4E8E\u6587\u7A3F\u4FEE\u8BA2\u7684\u7F16\u8F91\u6D41\u7A0B\u3002"),
-            "parallel-subagents": tx("Split independent subtasks across multiple agents.", "\u5C06\u76F8\u4E92\u72EC\u7ACB\u7684\u5B50\u4EFB\u52A1\u5206\u914D\u7ED9\u591A\u4E2A agent\u3002")
+            "parallel-subagents": tx("Split independent subtasks across multiple agents.", "\u5C06\u76F8\u4E92\u72EC\u7ACB\u7684\u5B50\u4EFB\u52A1\u5206\u914D\u7ED9\u591A\u4E2A agent\u3002"),
+            "reviewer-response": tx("Map reviewer comments to evidence, edits and reply drafts.", "\u628A\u5BA1\u7A3F\u610F\u89C1\u5BF9\u5E94\u5230\u8BBA\u6587\u8BC1\u636E\u3001\u4FEE\u6539\u548C\u56DE\u590D\u8349\u7A3F\u3002")
           };
           const description = !local && descriptions[id] || (typeof skill.description === "string" ? skill.description.replace(/\s+/g, " ").trim() : "");
           if (description) {
@@ -21967,7 +22228,7 @@ ${block}`;
           row._refreshLocale = () => {
             if (sourceLabel) sourceLabel.textContent = sourceText();
             toggle.setAttribute("aria-label", accessibleSkillName + ": " + tr("codexOverleafSkillEnableToggle"));
-            const label = !local && id === "annotated-rewrite" ? tx("Guided editing for document revisions.", "\u7528\u4E8E\u6587\u7A3F\u4FEE\u8BA2\u7684\u7F16\u8F91\u6D41\u7A0B\u3002") : !local && id === "parallel-subagents" ? tx("Split independent subtasks across multiple agents.", "\u5C06\u76F8\u4E92\u72EC\u7ACB\u7684\u5B50\u4EFB\u52A1\u5206\u914D\u7ED9\u591A\u4E2A agent\u3002") : "";
+            const label = !local && id === "annotated-rewrite" ? tx("Guided editing for document revisions.", "\u7528\u4E8E\u6587\u7A3F\u4FEE\u8BA2\u7684\u7F16\u8F91\u6D41\u7A0B\u3002") : !local && id === "parallel-subagents" ? tx("Split independent subtasks across multiple agents.", "\u5C06\u76F8\u4E92\u72EC\u7ACB\u7684\u5B50\u4EFB\u52A1\u5206\u914D\u7ED9\u591A\u4E2A agent\u3002") : !local && id === "reviewer-response" ? tx("Map reviewer comments to evidence, edits and reply drafts.", "\u628A\u5BA1\u7A3F\u610F\u89C1\u5BF9\u5E94\u5230\u8BBA\u6587\u8BC1\u636E\u3001\u4FEE\u6539\u548C\u56DE\u590D\u8349\u7A3F\u3002") : "";
             const help = copy.querySelector(".codex-local-skill-description");
             if (label && help) {
               help.textContent = label;
@@ -22681,6 +22942,11 @@ ${block}`;
         async function executeUndo(runId) {
           let run = findRunRecord(runId);
           if (run) Object.assign(run, Modules.UndoOperations.prepareRunUndo(run));
+          const mirrorOwner = {
+            projectId: getRunProjectIdForWriteback(run),
+            runAccountScopeId: run?.runAccountScopeId || getAccountScopeId?.() || "",
+            sessionId: getState().activeSessionId
+          };
           const assertCurrent = undoOwner(run);
           let assertInputs = checkpointGuard(run, assertCurrent);
           if (!getRunUndoCount(run) || run.undoStatus === "applied") {
@@ -22765,9 +23031,9 @@ ${block}`;
             // Undo remains bound to its original project, including after navigation.
             runProjectId: getRunProjectIdForWriteback(run)
           });
+          writebackOrchestrator.invalidateMirrorAfterUndo(runId, mirrorOwner.projectId, result, mirrorOwner);
           run = assertInputs();
           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 }),
@@ -22793,6 +23059,11 @@ ${block}`;
           );
         }
         async function executeTrackedUndo(runId, run) {
+          const mirrorOwner = {
+            projectId: getRunProjectIdForWriteback(run),
+            runAccountScopeId: run?.runAccountScopeId || getAccountScopeId?.() || "",
+            sessionId: getState().activeSessionId
+          };
           const assertCurrent = undoOwner(run);
           let assertInputs = checkpointGuard(run, assertCurrent);
           const fileUndoOperations = Modules.UndoOperations.getFileUndoOperations(run);
@@ -22876,8 +23147,8 @@ ${block}`;
                   result: { ok: false, code: "undo_operation_failed", reason: error.message }
                 })) };
               }
-              run = assertInputs();
               result = Modules.UndoOperations.mergeFileUndoResult(result, createdResult, fileUndoOperations);
+              run = assertInputs();
             }
             appendRunRecordEvent(runId, {
               title: fileUndoOperations.length ? tr("undoResult", { applied: result.applied?.length || 0, skipped: result.skipped?.length || 0 }) : 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 }),
@@ -22905,7 +23176,7 @@ ${block}`;
             }
             await applyLegacyUndoSettlement(runId, result.ok === true && !result.skipped?.length ? "applied" : "partial", result);
           } finally {
-            if (result) writebackOrchestrator.invalidateMirrorAfterUndo(runId, getRunProjectIdForWriteback(run), result);
+            if (result) writebackOrchestrator.invalidateMirrorAfterUndo(runId, mirrorOwner.projectId, result, mirrorOwner);
           }
         }
         function reviewOwner(run) {
@@ -23593,7 +23864,7 @@ ${block}`;
         const maxAttachmentTotalBytes = Number(limits.maxAttachmentTotalBytes) || 32 * 1024 * 1024;
         const maxPreviewDataUrlChars = Number(limits.maxPreviewDataUrlChars) || 768 * 1024;
         let attachments = [];
-        const pendingAttachmentKeys = /* @__PURE__ */ new Set();
+        const pendingAttachmentKeys = /* @__PURE__ */ new Map();
         let pendingAttachmentBytes = 0;
         let attachmentGeneration = 0;
         let attachmentRevision = 0;
@@ -23661,8 +23932,15 @@ ${block}`;
                 continue;
               }
               attachmentRevision += 1;
-              pendingAttachmentKeys.add(dedupeKey);
+              pendingAttachmentKeys.set(dedupeKey, {
+                name: normalizeAttachmentName(file.name),
+                mimeType: String(file.type || ""),
+                size: fileSize,
+                loading: true
+              });
               pendingAttachmentBytes += fileSize;
+              renderComposerAttachments();
+              onChange();
               try {
                 const dataUrl = await readFileAsDataUrl(file, tx);
                 if (generation !== attachmentGeneration) return;
@@ -23690,6 +23968,8 @@ ${block}`;
                 if (generation === attachmentGeneration) {
                   pendingAttachmentBytes = Math.max(0, pendingAttachmentBytes - fileSize);
                   pendingAttachmentKeys.delete(dedupeKey);
+                  renderComposerAttachments();
+                  onChange();
                 }
               }
             }
@@ -23721,8 +24001,9 @@ ${block}`;
           if (!strip) {
             return;
           }
-          strip.hidden = attachments.length === 0;
-          renderAttachmentPreviewList(attachments, strip, {
+          const visibleAttachments = [...attachments, ...pendingAttachmentKeys.values()];
+          strip.hidden = visibleAttachments.length === 0;
+          renderAttachmentPreviewList(visibleAttachments, strip, {
             root: getPanel() || document.body,
             tr,
             tx,
@@ -23840,6 +24121,14 @@ ${block}`;
           renderComposerAttachments();
           return attachments.length;
         }
+        function getOmittedAttachmentNames() {
+          let persistedCount = 0;
+          return attachments.filter((attachment) => {
+            if ((attachment.contentBase64 || "").length > PERSIST_MAX_CONTENT_CHARS || persistedCount >= PERSIST_MAX_COUNT) return true;
+            persistedCount += 1;
+            return false;
+          }).map((attachment) => attachment.name);
+        }
         function restoreSubmittedAttachments(value, expectedRevision) {
           if (expectedRevision !== attachmentRevision || attachments.length || pendingAttachmentBytes || pendingAttachmentKeys.size) return false;
           if (!Array.isArray(value) || value.length > maxAttachments) return false;
@@ -23858,6 +24147,8 @@ ${block}`;
         }
         return {
           serializePersistableAttachments,
+          getOmittedAttachmentNames,
+          hasPendingReads: () => pendingAttachmentKeys.size > 0,
           restorePersistedAttachments,
           restoreSubmittedAttachments,
           getRevision: () => attachmentRevision,
@@ -23956,6 +24247,10 @@ ${block}`;
           const card = document.createElement("div");
           card.className = "codex-attachment-preview-card";
           card.dataset.kind = isImage ? "image" : "file";
+          if (attachment.loading) {
+            card.dataset.loading = "true";
+            card.setAttribute("aria-busy", "true");
+          }
           card.title = label + " \xB7 " + formatFileSize(attachment.size);
           if (isImage) {
             const preview = document.createElement("button");
@@ -23984,11 +24279,11 @@ ${block}`;
           if (!isImage) {
             const size = document.createElement("span");
             size.className = "codex-attachment-preview-size";
-            size.textContent = formatFileSize(attachment.size);
+            size.textContent = attachment.loading ? options.tx ? options.tx("Loading\u2026", "\u8BFB\u53D6\u4E2D\u2026") : "Loading\u2026" : formatFileSize(attachment.size);
             meta.append(size);
           }
           card.append(meta);
-          if (options.removable) {
+          if (options.removable && !attachment.loading) {
             const remove = document.createElement("button");
             remove.type = "button";
             remove.className = "codex-attachment-preview-remove";
@@ -24308,7 +24603,10 @@ ${block}`;
         }
         return compact;
       }
-      function setVisible(panelEl, visible) {
+      function setVisible(target, visible) {
+        const instance = target?._instance;
+        const panelEl = instance?.panelEl || target;
+        if (visible && instance) updateCompactMode(instance);
         panelEl?.classList?.toggle("is-open", Boolean(visible));
         document.documentElement.classList.toggle(ROOT_CLASS, Boolean(visible));
         const launcherEl = panelEl?.ownerDocument?.getElementById?.("codex-overleaf-launcher");
@@ -26355,18 +26653,7 @@ ${block}`;
           actions.innerHTML = instance.embedded ? "" : `<button type="button" class="codex-provider-secondary-button" data-provider-action="close">${escapeHtml(tx("Close", "\u5173\u95ED"))}</button>`;
           return;
         }
-        const active = provider.id && provider.id === getCurrentProjectProviderId(instance);
-        const isNew = !provider.id;
-        const destinationChanged = active && getCurrentBaseUrl(instance) !== provider.endpointDisclosureBaseUrl;
-        const actionState = getFooterActionState({
-          isNew,
-          active,
-          dirty: instance.dirty,
-          destinationChanged,
-          canSave: canSaveCurrentDraft(instance),
-          hasProject: instance.callbacks.hasCurrentProject?.() !== false,
-          canActivate: canActivateCurrentProvider(instance)
-        });
+        const actionState = getCurrentFooterActionState(instance);
         const saveDisabled = actionState.saveEnabled ? "" : ' disabled aria-disabled="true"';
         const useDisabled = actionState.useEnabled ? "" : ' disabled aria-disabled="true"';
         actions.innerHTML = `
@@ -26379,6 +26666,20 @@ ${block}`;
       ${actionState.showUse ? `<button type="button" class="codex-provider-primary-button" data-provider-action="use"${useDisabled}>${escapeHtml(tx("Use for this project", "\u7528\u4E8E\u5F53\u524D\u9879\u76EE"))}</button>` : ""}
     `;
       }
+      function getCurrentFooterActionState(instance) {
+        const provider = getSelectedProvider(instance);
+        const active = Boolean(provider?.id && provider.id === getCurrentProjectProviderId(instance));
+        return getFooterActionState({
+          isNew: !provider?.id,
+          active,
+          dirty: instance.dirty,
+          destinationChanged: active && getCurrentBaseUrl(instance) !== provider.endpointDisclosureBaseUrl,
+          disclosureAccepted: instance.root.querySelector("[data-provider-disclosure]")?.checked === true,
+          canSave: canSaveCurrentDraft(instance),
+          hasProject: instance.callbacks.hasCurrentProject?.() !== false,
+          canActivate: canActivateCurrentProvider(instance)
+        });
+      }
       function getFooterActionState(options = {}) {
         const isNew = options.isNew === true;
         const active = options.active === true;
@@ -26386,9 +26687,9 @@ ${block}`;
         return {
           showSave: isNew || dirty,
           showSaveAndUse: options.hasProject !== false && (isNew || dirty) && (!active || options.destinationChanged === true),
-          showUse: options.hasProject !== false && !isNew && !active && !dirty,
+          showUse: options.hasProject !== false && !isNew && (!active || options.destinationChanged === true) && !dirty,
           saveEnabled: options.canSave === true,
-          useEnabled: options.canActivate === true
+          useEnabled: options.canActivate === true && (!options.destinationChanged || options.disclosureAccepted === true)
         };
       }
       async function handleClick(instance, event) {
@@ -26574,6 +26875,11 @@ ${block}`;
           refreshTestState(instance);
           return;
         }
+        if (event.target.matches("[data-provider-disclosure]")) {
+          renderFooter(instance);
+          applyBusyState(instance);
+          return;
+        }
         if (event.target.matches("[data-provider-field]")) {
           const field = event.target.dataset.providerField;
           if (event.target.dataset.providerField === "apiKey") {
@@ -26744,8 +27050,7 @@ ${block}`;
       }
       function applyBusyState(instance) {
         const busy = Boolean(instance.busy && instance.busy !== "failed");
-        const canSave = canSaveCurrentDraft(instance);
-        const canActivate = canActivateCurrentProvider(instance);
+        const actionState = getCurrentFooterActionState(instance);
         instance.root.dataset.busy = instance.busy || "";
         for (const element of instance.root.querySelectorAll("input, select, textarea, button")) {
           if (element.matches("[data-provider-confirm-answer]")) {
@@ -26755,9 +27060,9 @@ ${block}`;
           } else if (element.matches('[data-provider-action="cancel-test"]')) {
             element.disabled = false;
           } else if (element.matches('[data-provider-action="save"], [data-provider-action="save-use"]')) {
-            element.disabled = busy || !canSave;
+            element.disabled = busy || !actionState.saveEnabled;
           } else if (element.matches('[data-provider-action="use"]')) {
-            element.disabled = busy || !canActivate;
+            element.disabled = busy || !actionState.useEnabled;
           } else {
             element.disabled = busy;
           }
@@ -28268,6 +28573,18 @@ ${block}`;
           });
         }
       }
+      function projectPreferenceValues(input, prefs, projectId) {
+        return {
+          experimentalOtByProject: input.normalizeExperimentalOtByProject(prefs.experimentalOtByProject)[projectId] === true,
+          reviewingAvailabilityByProject: prefs.reviewingAvailabilityByProject?.[projectId],
+          governanceRulesByProject: input.normalizeGovernanceRulesByProject({
+            [projectId]: prefs.governanceRulesByProject?.[projectId] || {}
+          })[projectId],
+          customInstructionsByProject: input.normalizeCustomInstructionsByProject({
+            [projectId]: prefs.customInstructionsByProject?.[projectId] || ""
+          })[projectId]
+        };
+      }
       async function persistPanelState(input) {
         var state = cloneSnapshot(input.state || {});
         var compactState = cloneSnapshot(input.compactState || {});
@@ -28293,6 +28610,14 @@ ${block}`;
         }
         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 preferenceBaseline = input.projectPreferenceBaseline || Migration.getProjectPreferenceBaseline?.(accountScopeId, projectId);
+        var preferenceWrite = input.projectPreferenceWrite || Migration.captureProjectPreferenceWrite?.({
+          ...input,
+          state,
+          baseline: preferenceBaseline,
+          accountScopeId,
+          projectId
+        });
         var latestPrefs = typeof Migration.loadPrefs === "function" ? await Migration.loadPrefs(accountScopeId, projectId) : {};
         var prefs = Object.assign(
           {},
@@ -28304,32 +28629,21 @@ ${block}`;
           projectId,
           compactState.activeSessionId || state.activeSessionId || ""
         );
-        prefs.experimentalOtByProject = Object.assign(
-          {},
-          latestPrefs && latestPrefs.experimentalOtByProject || {},
-          { [projectId]: input.normalizeExperimentalOtByProject(state.experimentalOtByProject)[projectId] === true }
-        );
-        prefs.reviewingAvailabilityByProject = Object.assign(
-          {},
-          latestPrefs?.reviewingAvailabilityByProject || {},
-          state.reviewingAvailabilityByProject || {}
-        );
-        prefs.governanceRulesByProject = Object.assign(
-          {},
-          latestPrefs && latestPrefs.governanceRulesByProject || {},
-          input.normalizeGovernanceRulesByProject(state.governanceRulesByProject)
-        );
-        var normalizedCustomProject = input.normalizeCustomInstructionsByProject({ [projectId]: "" });
-        var customProjectId = Object.keys(normalizedCustomProject)[0] || "";
-        var currentCustom = input.normalizeCustomInstructionsByProject(state.customInstructionsByProject);
-        prefs.customInstructionsByProject = Object.assign(
-          {},
-          latestPrefs && latestPrefs.customInstructionsByProject || {}
-        );
-        if (customProjectId) {
-          prefs.customInstructionsByProject[customProjectId] = Object.prototype.hasOwnProperty.call(currentCustom, customProjectId) ? currentCustom[customProjectId] : "";
+        var currentPreferences = projectPreferenceValues(input, state, projectId);
+        if (preferenceWrite) {
+          Object.assign(prefs, Migration.projectPreferencePatch(preferenceWrite, accountScopeId, projectId));
+        } else {
+          var baselinePreferences = projectPreferenceValues(input, preferenceBaseline || latestPrefs || {}, projectId);
+          for (var name of Object.keys(currentPreferences)) {
+            prefs[name] = JSON.stringify(currentPreferences[name]) === JSON.stringify(baselinePreferences[name]) ? {} : { [projectId]: currentPreferences[name] };
+          }
+        }
+        var savedPrefs = await Migration.savePrefs(prefs, accountScopeId, projectId);
+        if (savedPrefs) {
+          var fields = preferenceWrite ? Migration.completeProjectPreferenceWrite(preferenceWrite, savedPrefs) : Object.keys(currentPreferences);
+          var applied = input.applyProjectPreferences?.(savedPrefs, state, fields);
+          if (!preferenceWrite && applied !== false) Migration.adoptProjectPreferenceBaseline?.(savedPrefs, accountScopeId, projectId);
         }
-        await Migration.savePrefs(prefs, accountScopeId, projectId);
         var persistenceMeta = input.persistenceContext?.nextMeta || {};
         var queueTombstones = persistenceMeta.queueTombstones || {};
         var sessionTombstones = persistenceMeta.sessionTombstones || {};
@@ -28702,11 +29016,18 @@ ${block}`;
         const details = root.querySelector("[data-diagnostics-result-details]");
         const scroll = root.querySelector(".codex-diagnostics-result-scroll");
         const open = details?.open, scrollTop = scroll?.scrollTop;
-        const checks = Array.from(root.querySelectorAll(".codex-diagnostics-check"), (node) => node.open);
+        const checks = Array.from(root.querySelectorAll(".codex-diagnostics-check"), (node) => ({
+          open: node.open,
+          technicalOpen: node.querySelector(".codex-diagnostics-technical")?.open
+        }));
         showResult(instance, result);
         if (details) details.open = open;
         root.querySelectorAll(".codex-diagnostics-check").forEach((node, index) => {
-          if (index < checks.length) node.open = checks[index];
+          if (index < checks.length) {
+            node.open = checks[index].open;
+            const technical = node.querySelector(".codex-diagnostics-technical");
+            if (technical) technical.open = checks[index].technicalOpen;
+          }
         });
         if (scroll) scroll.scrollTop = scrollTop;
       }
@@ -28721,42 +29042,45 @@ ${block}`;
         root.hidden = false;
         root.dataset.status = result.status || "info";
         root.setAttribute("aria-label", result.title || t(instance, "diagnosticsResult"));
-        root.querySelector("[data-diagnostics-result-title]").textContent = result.title || t(instance, "diagnosticsResult");
+        const titleNode = root.querySelector("[data-diagnostics-result-title]");
+        const dot = document.createElement("span");
+        dot.className = "codex-diagnostics-status-dot";
+        dot.setAttribute("aria-hidden", "true");
+        const titleText = document.createElement("span");
+        titleText.className = "codex-diagnostics-result-title-text";
+        titleText.textContent = result.title || t(instance, "diagnosticsResult");
+        titleNode.replaceChildren(dot, titleText);
         root.querySelector("[data-diagnostics-result-subtitle]").textContent = result.subtitle || "";
         const body = root.querySelector("[data-diagnostics-result-body]");
         body.textContent = "";
-        if (result.summary) {
-          appendParagraph(body, result.summary);
+        const facts = Array.isArray(result.facts) ? result.facts.filter((fact) => fact?.label) : [];
+        const notes = [
+          ...Array.isArray(result.notes) ? result.notes : [],
+          ...Array.isArray(result.bullets) ? result.bullets : []
+        ].filter(Boolean);
+        const hasChecks = Array.isArray(result.checks) && result.checks.length > 0;
+        if (result.summary && !(result.status === "completed" && facts.length)) {
+          appendParagraph(body, result.summary, "codex-diagnostics-summary");
         }
-        if (Array.isArray(result.checks) && result.checks.length) {
-          renderCheckRows(body, result.checks);
-        } else if (!result.summary) {
+        if (hasChecks) {
+          renderCheckRows(instance, body, result.checks);
+        } else if (!result.summary && !facts.length && !notes.length) {
           appendParagraph(body, t(instance, "diagnosticsNoResult"));
         }
-        if (Array.isArray(result.bullets) && result.bullets.length) {
-          const list = document.createElement("ul");
-          for (const item of result.bullets) {
-            const li = document.createElement("li");
-            li.textContent = item;
-            list.append(li);
-          }
-          body.append(list);
+        if (facts.length) {
+          renderFacts(body, facts);
+        }
+        if (notes.length) {
+          renderNotes(body, notes);
         }
         if (result.nextStep) {
-          const next = document.createElement("p");
-          next.className = "codex-diagnostics-next-step";
-          next.textContent = `${t(instance, "nextStepPrefix")}${result.nextStep}`;
-          body.append(next);
+          appendNextStep(instance, body, result.nextStep, "p", "codex-diagnostics-next-step");
         }
         if (result.installCommand) {
           renderInstallCommand(instance, body, result.installCommand);
         }
         const details = root.querySelector("[data-diagnostics-result-details]");
-        const technical = root.querySelector("[data-diagnostics-result-technical]");
-        const technicalText = String(result.technical || "").trim();
-        details.open = false;
-        details.hidden = !technicalText;
-        technical.textContent = technicalText;
+        renderTechnicalDetails(details, result.technical);
         closeMenu(instance);
         openFloating(instance, root, 400);
         if (wasHidden) root.querySelector("[data-diagnostics-result-close]")?.focus({ preventScroll: true });
@@ -28829,13 +29153,13 @@ ${block}`;
       function renderInstallCommand(instance, container, command) {
         const wrap = document.createElement("div");
         wrap.className = "codex-install-command";
-        const label = document.createElement("div");
+        const head = document.createElement("div");
+        head.className = "codex-install-command-head";
+        const label = document.createElement("span");
         label.className = "codex-install-command-label";
         label.textContent = t(instance, "runInTerminal");
-        wrap.append(label);
         const code = document.createElement("code");
         code.textContent = command;
-        wrap.append(code);
         const copyButton = document.createElement("button");
         copyButton.type = "button";
         copyButton.textContent = t(instance, "copyInstallCommand");
@@ -28846,21 +29170,82 @@ ${block}`;
             copyButton.textContent = t(instance, "copyInstallCommand");
           }, 1400);
         });
-        wrap.append(copyButton);
+        head.append(label, copyButton);
+        wrap.append(head, code);
         container.append(wrap);
       }
-      function appendParagraph(container, text) {
+      function appendParagraph(container, text, className) {
         const paragraph = document.createElement("p");
+        if (className) {
+          paragraph.className = className;
+        }
         paragraph.textContent = text;
         container.append(paragraph);
       }
+      function appendNextStep(instance, container, text, tagName, className) {
+        const next = document.createElement(tagName);
+        next.className = className;
+        const label = document.createElement("span");
+        label.className = "codex-diagnostics-next-label";
+        label.textContent = t(instance, "nextStepPrefix");
+        next.append(label, document.createTextNode(text));
+        container.append(next);
+      }
+      function renderFacts(container, facts) {
+        const list = document.createElement("dl");
+        list.className = "codex-diagnostics-facts";
+        for (const fact of facts) {
+          const term = document.createElement("dt");
+          term.textContent = fact.label;
+          const value = document.createElement("dd");
+          const text = String(fact.value ?? "");
+          if (fact.kind === "path") {
+            value.textContent = shortenPath(text);
+            value.title = text;
+          } else {
+            value.textContent = text;
+          }
+          if (fact.tone) {
+            value.dataset.tone = fact.tone;
+          }
+          list.append(term, value);
+        }
+        container.append(list);
+      }
+      function shortenPath(path) {
+        if (path.length <= 36) {
+          return path;
+        }
+        const parts = path.split("/");
+        if (parts.length < 5) {
+          return path;
+        }
+        const short = `${parts.slice(0, 3).join("/")}/\u2026/${parts[parts.length - 1]}`;
+        return short.length < path.length ? short : path;
+      }
+      function renderNotes(container, notes) {
+        const list = document.createElement("ul");
+        list.className = "codex-diagnostics-notes";
+        for (const note of notes) {
+          const item = document.createElement("li");
+          item.textContent = note;
+          list.append(item);
+        }
+        container.append(list);
+      }
+      function renderTechnicalDetails(details, value) {
+        const text = String(value || "").trim();
+        details.open = false;
+        details.hidden = !text;
+        details.querySelector("pre").textContent = text;
+      }
       function healthBucket(status) {
         if (status === "completed" || status === "ok") return "ok";
         if (status === "warning" || status === "warn") return "warn";
         if (status === "failed" || status === "fail") return "fail";
         return "info";
       }
-      function renderCheckRows(container, checks) {
+      function renderCheckRows(instance, container, checks) {
         const list = document.createElement("div");
         list.className = "codex-diagnostics-checks";
         for (const check of checks) {
@@ -28870,15 +29255,15 @@ ${block}`;
           row.dataset.status = healthBucket(check.status);
           row.open = row.dataset.status === "warn" || row.dataset.status === "fail";
           const heading = document.createElement("summary");
-          const glyph = document.createElement("span");
-          glyph.className = "codex-diagnostics-check-glyph";
-          glyph.setAttribute("aria-hidden", "true");
+          const dot = document.createElement("span");
+          dot.className = "codex-diagnostics-check-dot";
+          dot.setAttribute("aria-hidden", "true");
           const textWrap = document.createElement("div");
           textWrap.className = "codex-diagnostics-check-text";
           const title = document.createElement("div");
           title.className = "codex-diagnostics-check-title";
           title.textContent = check.title || "";
-          heading.append(glyph, title);
+          heading.append(dot, title);
           if (check.summary) {
             const summary = document.createElement("div");
             summary.className = "codex-diagnostics-check-summary";
@@ -28886,10 +29271,19 @@ ${block}`;
             textWrap.append(summary);
           }
           if (check.nextStep) {
-            const next = document.createElement("div");
-            next.className = "codex-diagnostics-check-next";
-            next.textContent = `\u2192 ${check.nextStep}`;
-            textWrap.append(next);
+            appendNextStep(instance, textWrap, check.nextStep, "div", "codex-diagnostics-check-next");
+          }
+          if (check.installCommand) {
+            renderInstallCommand(instance, textWrap, check.installCommand);
+          }
+          if (check.technical) {
+            const details = document.createElement("details");
+            details.className = "codex-diagnostics-technical";
+            const summary = document.createElement("summary");
+            summary.textContent = t(instance, "technicalDetails");
+            details.append(summary, document.createElement("pre"));
+            renderTechnicalDetails(details, check.technical);
+            textWrap.append(details);
           }
           row.append(heading, textWrap);
           list.append(row);
@@ -29179,37 +29573,46 @@ ${block}`;
                 claimToken: claimedItem?.claimToken
               }
             });
-            const latestQueue = options.getQueue?.(sessionId) || originalQueue;
+            const latestQueue2 = options.getQueue?.(sessionId) || originalQueue;
             options.setQueue?.(
               sessionId,
-              dequeue(latestQueue, queueItemId, {
+              dequeue(latestQueue2, queueItemId, {
                 sessionId,
                 reason: status === "completed" ? "completed" : "continue_queue"
               })
             );
-          } else if (!shouldContinue) {
-            const paused = originalQueue.length ? Queue.pauseAll(originalQueue, status || "run_did_not_complete") : originalQueue;
+          }
+          const canStart = shouldContinue ? options.canStart?.(sessionId) : true;
+          const latestQueue = options.getQueue?.(sessionId) || originalQueue;
+          const inactive = shouldContinue && canStart !== "session_transition" && (canStart === false || options.isRunning?.()) && latestQueue.some((item) => item?.status === "queued");
+          if (!shouldContinue || inactive) {
+            const reason = inactive ? "session_inactive" : status || "run_did_not_complete";
+            const paused = latestQueue.length ? Queue.pauseAll(latestQueue, reason) : latestQueue;
             options.setQueue?.(sessionId, paused);
             try {
               await options.persist?.({
                 queueMutation: { type: "transition", sessionId }
               });
             } catch (error) {
-              const latestQueue = options.getQueue?.(sessionId) || paused;
+              const latestQueue2 = options.getQueue?.(sessionId) || paused;
               options.setQueue?.(
                 sessionId,
-                Queue.pauseAll(latestQueue, status || "run_did_not_complete")
+                Queue.pauseAll(latestQueue2, reason)
               );
               throw error;
             }
           }
           options.onChange?.(sessionId);
-          if (shouldContinue) {
+          if (shouldContinue && !inactive) {
             scheduleOne(sessionId);
           }
         }
         function scheduleOne(sessionId) {
-          if (scheduling || options.isRunning?.() || options.canStart?.(sessionId) === false) {
+          if (scheduling || options.isRunning?.()) {
+            return false;
+          }
+          const canStart = options.canStart?.(sessionId);
+          if (canStart === false || canStart === "session_transition") {
             return false;
           }
           const initialQueue = options.getQueue?.(sessionId) || [];
@@ -29326,7 +29729,7 @@ ${block}`;
           setQueue: (sessionId, pendingInputs) => options.setQueue?.(sessionId, pendingInputs),
           persist: (persistenceOptions) => options.save?.(persistenceOptions),
           isRunning: () => Boolean(options.getCurrentRun?.()),
-          canStart: (sessionId) => options.canStart?.(sessionId) !== false,
+          canStart: (sessionId) => options.canStart?.(sessionId),
           start: (item, sessionId) => startQueuedInput(item, sessionId),
           onChange: () => render(),
           onDequeued: (item, context) => options.removeGuidance?.(item.id, {
@@ -29565,7 +29968,8 @@ ${block}`;
         }
         async function startQueuedInput(item, sessionId) {
           const assertCanStart = () => {
-            if (options.canStart?.(sessionId) === false || options.getCurrentRun?.()) {
+            const canStart = options.canStart?.(sessionId);
+            if (canStart === false || canStart === "session_transition" || options.getCurrentRun?.()) {
               const error = new Error("Queued input cannot start in the current session.");
               error.code = "queue_session_not_active";
               throw error;
@@ -30845,6 +31249,33 @@ ${block}`;
             return null;
           }
         }
+        async function attachInstruction(action, selected) {
+          const selection = await attach("edit", selected);
+          if (!selection) return;
+          const task = deps.getPanel()?.querySelector("[data-task]");
+          if (!task) return;
+          if (task.value.trim()) {
+            deps.toast?.(tx("Kept your draft. The selection is attached for editing.", "\u5DF2\u4FDD\u7559\u4F60\u7684\u8349\u7A3F\uFF0C\u9009\u533A\u5DF2\u9644\u4E0A\uFF0C\u4EC5\u7F16\u8F91\u6B64\u5904\u3002"));
+            return;
+          }
+          const instructions = {
+            polish: tx(
+              "Polish the selected passage for clarity and flow. Keep the meaning, citations, labels and math unchanged.",
+              "\u6DA6\u8272\u9009\u4E2D\u6BB5\u843D\uFF0C\u8BA9\u8868\u8FBE\u66F4\u6E05\u6670\u6D41\u7545\uFF0C\u4FDD\u6301\u539F\u610F\u4EE5\u53CA\u5F15\u7528\u3001\u6807\u7B7E\u3001\u516C\u5F0F\u4E0D\u53D8\u3002"
+            ),
+            shorten: tx(
+              "Shorten the selected passage by about 20%. Keep citations, labels, math and the main claim unchanged.",
+              "\u5C06\u9009\u4E2D\u6BB5\u843D\u7CBE\u7B80\u7EA6 20%\uFF0C\u4FDD\u7559\u5F15\u7528\u3001\u6807\u7B7E\u3001\u516C\u5F0F\u548C\u6838\u5FC3\u8BBA\u70B9\u4E0D\u53D8\u3002"
+            ),
+            translate: tx(
+              "Translate the selected passage into English. Keep LaTeX commands, citations, labels and math unchanged.",
+              "\u5C06\u9009\u4E2D\u6BB5\u843D\u7FFB\u8BD1\u6210\u82F1\u6587\uFF0C\u4FDD\u7559 LaTeX \u547D\u4EE4\u3001\u5F15\u7528\u3001\u6807\u7B7E\u548C\u516C\u5F0F\u4E0D\u53D8\u3002"
+            )
+          };
+          task.value = instructions[action];
+          task.setSelectionRange(task.value.length, task.value.length);
+          task.dispatchEvent(new Event("input", { bubbles: true }));
+        }
         function editorFor(node) {
           const element = node?.nodeType === 1 ? node : node?.parentElement;
           const editor = element?.closest?.(".cm-editor");
@@ -30871,6 +31302,9 @@ ${block}`;
           toolbar.setAttribute("aria-label", tx("Selected text actions", "\u9009\u533A\u64CD\u4F5C"));
           toolbar.querySelector('[data-selection-action="reference"]').textContent = tx("Add to Chat", "\u52A0\u5165\u5BF9\u8BDD");
           toolbar.querySelector('[data-selection-action="edit"]').textContent = tx("Edit Selection", "\u4EC5\u7F16\u8F91\u6B64\u5904");
+          toolbar.querySelector('[data-selection-action="polish"]').textContent = tx("Polish", "\u6DA6\u8272");
+          toolbar.querySelector('[data-selection-action="shorten"]').textContent = tx("Shorten", "\u7CBE\u7B80");
+          toolbar.querySelector('[data-selection-action="translate"]').textContent = tx("Translate", "\u7FFB\u8BD1");
         }
         function ensureToolbar() {
           if (toolbar) return;
@@ -30880,8 +31314,8 @@ ${block}`;
           toolbar.setAttribute("role", "toolbar");
           toolbar.hidden = true;
           if (typeof toolbar.showPopover === "function") toolbar.setAttribute("popover", "manual");
-          for (const mode of ["reference", "edit"]) {
-            if (mode === "edit") {
+          for (const mode of ["reference", "edit", "polish", "shorten", "translate"]) {
+            if (mode === "edit" || mode === "polish") {
               const divider = document.createElement("span");
               divider.className = "codex-selection-action-divider";
               divider.setAttribute("aria-hidden", "true");
@@ -30892,7 +31326,9 @@ ${block}`;
             button.dataset.selectionAction = mode;
             button.addEventListener("click", () => {
               const selected = candidate;
-              if (selected) void attach(mode, selected);
+              if (!selected) return;
+              if (mode === "reference" || mode === "edit") void attach(mode, selected);
+              else void attachInstruction(mode, selected);
             });
             toolbar.append(button);
           }
@@ -37519,6 +37955,18 @@ ${block}`;
             renderText: buildMarkdownInlineNodesWithoutMath
           });
         }
+        function buildParsedTextNodes(value) {
+          const source = String(value || "");
+          if (!MathText?.buildMathNodes) {
+            return buildLineReferenceInlineNodes(source);
+          }
+          return MathText.buildMathNodes(source, {
+            document,
+            katex: window.katex,
+            macros: getMathMacros(),
+            renderText: buildLineReferenceInlineNodes
+          });
+        }
         function buildMarkdownInlineNodesWithoutMath(value) {
           const source = String(value || "");
           const nodes = [];
@@ -37911,15 +38359,8 @@ ${block}`;
                 document,
                 markdownIt: runtimeRoot.markdownit,
                 mathText: runtimeRoot.CodexOverleafMathText,
-                renderTextNodes: (text) => buildMarkdownInlineNodes(text),
-                renderLinkNodes: (label, href) => {
-                  const safeLabel = String(label || "");
-                  const target2 = String(href || "").trim();
-                  if (!/^https?:\/\//i.test(target2) && !resolveMarkdownLineReference(safeLabel, target2)) return buildMarkdownInlineNodes(safeLabel);
-                  return buildMarkdownInlineNodes(
-                    `[${safeLabel.replace(/]/g, "\\]")}](${target2.replace(/\)/g, "\\)")})`
-                  );
-                },
+                renderTextNodes: buildParsedTextNodes,
+                renderLinkNodes: buildMarkdownLinkNodes,
                 renderCodeNodes: (text) => buildInlineCodeNodes(text),
                 sanitizeText: sanitizeAssistantVisibleText,
                 createMathNode: (segment) => runtimeRoot.CodexOverleafMathText.createMathNode(
@@ -38199,7 +38640,12 @@ ${block}`;
             try {
               result = await spec.run({ collectOnly: true });
             } catch (error) {
-              result = projectableResult(() => ({ status: "failed", summary: tr("diagnosticsCheckErrored"), technical: error?.message || String(error) }));
+              result = projectableResult(() => ({
+                status: "failed",
+                summary: tr("diagnosticsCheckErrored"),
+                nextStep: tr("runOutcomeNext"),
+                technical: error?.message || String(error)
+              }));
             }
             const bucket = diagnosticsHealthBucket(result?.status);
             if (bucket === "fail") {
@@ -38214,7 +38660,9 @@ ${block}`;
                 status: result?.status || "info",
                 title: tr(spec.label),
                 summary: translated?.summary || translated?.subtitle || "",
-                nextStep: bucket === "ok" ? "" : translated?.nextStep || ""
+                nextStep: bucket === "ok" ? "" : translated?.nextStep || "",
+                installCommand: translated?.installCommand,
+                technical: translated?.technical
               };
             });
           }
@@ -38296,9 +38744,9 @@ ${block}`;
           const codexOk = environment.codex?.ok === true;
           const latexTools = environment.latex?.available || [];
           const latexOk = latexTools.length > 0;
-          const bullets = [
-            codexOk ? tx(`Codex available: ${environment.codex.path || "found on PATH"}`, `Codex \u53EF\u7528\uFF1A${environment.codex.path || "\u5DF2\u5728 PATH \u4E2D\u627E\u5230"}`) : tx("Codex was not found: the extension cannot start local Codex.", "Codex \u6CA1\u6709\u627E\u5230\uFF1A\u63D2\u4EF6\u4E0D\u80FD\u542F\u52A8\u672C\u5730 Codex\u3002"),
-            latexOk ? tx(`LaTeX tools available: ${latexTools.join(", ")}`, `LaTeX \u5DE5\u5177\u53EF\u7528\uFF1A${latexTools.join(", ")}`) : tx("LaTeX tools were not found: text editing works, but local compile checks are limited.", "LaTeX \u5DE5\u5177\u6CA1\u6709\u627E\u5230\uFF1A\u53EF\u4EE5\u7F16\u8F91\u6587\u672C\uFF0C\u4F46\u4E0D\u80FD\u5728\u672C\u5730\u7F16\u8BD1\u9A8C\u8BC1\u3002")
+          const facts = [
+            codexOk ? environment.codex.path ? { label: "Codex", value: environment.codex.path, kind: "path" } : { label: "Codex", value: tx("Found on PATH", "\u5DF2\u5728 PATH \u4E2D\u627E\u5230") } : { label: "Codex", value: tx("Not found", "\u672A\u627E\u5230"), tone: "fail" },
+            latexOk ? { label: "LaTeX", value: latexTools.join(", ") } : { label: "LaTeX", value: tx("Not found", "\u672A\u627E\u5230"), tone: "warn" }
           ];
           if (codexOk && latexOk) {
             return {
@@ -38306,7 +38754,7 @@ ${block}`;
               subtitle: tx("Codex and LaTeX are available.", "Codex \u548C LaTeX \u90FD\u53EF\u4EE5\u4F7F\u7528\u3002"),
               status: "completed",
               summary: tx("Codex is connected and local LaTeX tools are available. Codex can read, edit, and locally check this Overleaf project.", "Codex \u5DF2\u8FDE\u63A5\uFF0C\u672C\u673A LaTeX \u5DE5\u5177\u53EF\u7528\u3002\u4F60\u53EF\u4EE5\u8BA9 Codex \u8BFB\u53D6\u3001\u4FEE\u6539\u5E76\u672C\u5730\u68C0\u67E5 Overleaf \u9879\u76EE\u3002"),
-              bullets,
+              facts,
               technical: JSON.stringify(environment, null, 2)
             };
           }
@@ -38315,7 +38763,7 @@ ${block}`;
             subtitle: codexOk ? tx("Codex is available, but compile tools are incomplete.", "Codex \u53EF\u7528\uFF0C\u4F46\u7F16\u8BD1\u5DE5\u5177\u4E0D\u5B8C\u6574\u3002") : tx("Local Codex was not found.", "\u6CA1\u6709\u627E\u5230\u672C\u673A Codex\u3002"),
             status: codexOk ? "warning" : "failed",
             summary: codexOk ? tx("Local Codex can run, but LaTeX compile tools were not found. File edits are unaffected, but compile verification is limited.", "\u672C\u673A Codex \u53EF\u4EE5\u8FD0\u884C\uFF0C\u4F46\u6CA1\u6709\u627E\u5230 LaTeX \u7F16\u8BD1\u5DE5\u5177\uFF1B\u4FEE\u6539\u6587\u4EF6\u4E0D\u53D7\u5F71\u54CD\uFF0C\u7F16\u8BD1\u9A8C\u8BC1\u4F1A\u53D7\u9650\u3002") : tx("The extension reached the native host, but local Codex was not found, so tasks cannot start.", "\u63D2\u4EF6\u5DF2\u7ECF\u8FDE\u4E0A native host\uFF0C\u4F46\u6CA1\u6709\u627E\u5230\u672C\u673A Codex\uFF0C\u6240\u4EE5\u4E0D\u80FD\u542F\u52A8\u4EFB\u52A1\u3002"),
-            bullets,
+            facts,
             nextStep: codexOk ? tx("For compile verification, make sure latexmk or pdflatex is available on your Terminal PATH.", "\u5982\u9700\u7F16\u8BD1\u9A8C\u8BC1\uFF0C\u8BF7\u786E\u8BA4 latexmk \u6216 pdflatex \u5728\u7EC8\u7AEF PATH \u4E2D\u53EF\u7528\u3002") : tx("Make sure codex works in Terminal, then reload the extension.", "\u8BF7\u786E\u8BA4\u7EC8\u7AEF\u91CC\u53EF\u4EE5\u8FD0\u884C codex\uFF0C\u7136\u540E\u91CD\u65B0\u52A0\u8F7D\u6269\u5C55\u3002"),
             technical: JSON.stringify(environment, null, 2)
           };
@@ -38351,7 +38799,7 @@ ${block}`;
             subtitle: messages.subtitle,
             status: "failed",
             summary: messages.summary,
-            bullets: formatNativeCompatibilityBullets(compatibility),
+            facts: formatNativeCompatibilityFacts(compatibility, statusValue),
             nextStep: messages.nextStep,
             installCommand: compatibility.installCommand,
             technical: formatNativeCompatibilityTechnicalDetails(compatibility, response)
@@ -38389,14 +38837,24 @@ ${block}`;
               };
           }
         }
-        function formatNativeCompatibilityBullets(compatibility = {}) {
+        function formatNativeCompatibilityFacts(compatibility = {}, statusValue = "") {
           const native = compatibility.native || {};
           return [
-            tx(`Status: ${compatibility.status || "unknown"}`, `\u72B6\u6001\uFF1A${compatibility.status || "unknown"}`),
-            tx(`Classification: ${getNativeCompatibilityClassification(compatibility)}`, `\u517C\u5BB9\u5206\u7C7B\uFF1A${getNativeCompatibilityClassification(compatibility)}`),
-            tx(`Extension version: ${compatibility.extensionVersion || "unknown"}`, `\u6269\u5C55\u7248\u672C\uFF1A${compatibility.extensionVersion || "unknown"}`),
-            tx(`Native version: ${native.version || "unknown"}`, `Native \u7248\u672C\uFF1A${native.version || "unknown"}`),
-            tx(`Native protocol: ${formatNativeProtocolVersion(native)}`, `Native \u534F\u8BAE\uFF1A${formatNativeProtocolVersion(native)}`)
+            {
+              label: tx("Extension version", "\u6269\u5C55\u7248\u672C"),
+              value: compatibility.extensionVersion || "unknown",
+              tone: statusValue === "extension_too_old" ? "fail" : void 0
+            },
+            {
+              label: tx("Native version", "Native \u7248\u672C"),
+              value: native.version || "unknown",
+              tone: statusValue === "native_too_old" ? "fail" : void 0
+            },
+            {
+              label: tx("Native protocol", "Native \u534F\u8BAE"),
+              value: formatNativeProtocolVersion(native),
+              tone: statusValue === "protocol_unsupported" ? "fail" : void 0
+            }
           ];
         }
         function formatNativeProtocolVersion(native = {}) {
@@ -38457,7 +38915,7 @@ ${block}`;
                 subtitle: tr("diagnosticsOtSubtitle"),
                 status: "completed",
                 summary: tr("diagnosticsOtSummaryDisabled"),
-                bullets: [],
+                facts: [],
                 nextStep: "",
                 technical: ""
               };
@@ -38552,10 +39010,14 @@ failedAt: ${new Date(failure.at).toISOString()}`;
             subtitle: tr("diagnosticsOtSubtitle"),
             status: enabled && !fallback && !bridgeFailed ? "completed" : enabled || bridgeFailed ? "warning" : "completed",
             summary: tr(failureActive ? otWarmMirrorController.getFailureMessageKey(warmMirrorState.lastErrorCode) : enabled ? "diagnosticsOtSummaryEnabled" : "diagnosticsOtSummaryDisabled"),
-            bullets: [
-              `${tr("otStatus")}: ${formatOtStatusLabel(statusValue)}`,
-              `${tr("otFreshFiles")}: ${otFreshFileCount}`,
-              `${tr("otFallback")}: ${fallback ? tr("yes") : tr("no")}`
+            facts: [
+              { label: tr("otStatus"), value: formatOtStatusLabel(statusValue) },
+              { label: tr("otFreshFiles"), value: String(otFreshFileCount) },
+              {
+                label: tr("otFallback"),
+                value: fallback ? tr("yes") : tr("no"),
+                tone: enabled && fallback ? "warn" : void 0
+              }
             ],
             nextStep: fallback ? tr("diagnosticsOtNextStep") : "",
             technical: formatOtDiagnosticsTechnicalDetails({
@@ -38614,10 +39076,23 @@ failedAt: ${new Date(failure.at).toISOString()}`;
           const reviewingOk = probe?.reviewing?.ok === true;
           const writable = probe?.capabilities?.editor?.write !== false;
           const readable = probe?.editor?.ok === true;
-          const bullets = [
-            readable ? tx("Current file was read.", "\u5F53\u524D\u6587\u4EF6\u5DF2\u7ECF\u8BFB\u5230\u3002") : tx("Current file content has not been verified yet.", "\u8FD8\u6CA1\u6709\u786E\u8BA4\u5F53\u524D\u6587\u4EF6\u5185\u5BB9\u3002"),
-            writable ? tx("Editor write access will be verified again during writeback.", "\u5F53\u524D\u7F16\u8F91\u5668\u5199\u5165\u80FD\u529B\u4F1A\u5728\u5199\u5165\u65F6\u518D\u6B21\u9A8C\u8BC1\u3002") : tx("The current editor is not writable yet.", "\u5F53\u524D\u7F16\u8F91\u5668\u6682\u65F6\u4E0D\u53EF\u5199\u3002"),
-            reviewingOk ? tx("Reviewing/Track Changes status is verified.", "\u7559\u75D5/Reviewing \u72B6\u6001\u5DF2\u786E\u8BA4\u3002") : tx("Reviewing/Track Changes status is not verified yet.", "\u7559\u75D5/Reviewing \u72B6\u6001\u8FD8\u6CA1\u6709\u786E\u8BA4\u3002")
+          const reviewingNeeded = mode !== "ask";
+          const facts = [
+            {
+              label: tx("Current file", "\u5F53\u524D\u6587\u4EF6"),
+              value: readable ? tx("Read", "\u5DF2\u8BFB\u53D6") : tx("Not verified", "\u672A\u786E\u8BA4"),
+              tone: readable ? void 0 : "warn"
+            },
+            {
+              label: tx("Write access", "\u5199\u5165"),
+              value: writable ? tx("Checked again before writing", "\u5199\u5165\u524D\u4F1A\u518D\u6B21\u9A8C\u8BC1") : tx("Not writable yet", "\u6682\u4E0D\u53EF\u5199"),
+              tone: writable ? void 0 : "warn"
+            },
+            {
+              label: tx("Track changes", "\u7559\u75D5"),
+              value: reviewingOk ? tx("Verified", "\u5DF2\u786E\u8BA4") : tx("Not verified", "\u672A\u786E\u8BA4"),
+              tone: reviewingOk || !reviewingNeeded ? void 0 : "warn"
+            }
           ];
           if (readable && writable) {
             return {
@@ -38625,7 +39100,7 @@ failedAt: ${new Date(failure.at).toISOString()}`;
               subtitle: formatProbeStatusBar(probe),
               status: reviewingOk || mode === "ask" ? "completed" : "warning",
               summary: tx("The current Overleaf file can be read and written. The extension still verifies before writing to avoid overwriting new user or collaborator edits.", "\u5F53\u524D Overleaf \u6587\u4EF6\u53EF\u4EE5\u8BFB\u53D6\u548C\u5199\u5165\u3002\u5199\u5165\u524D\u63D2\u4EF6\u4ECD\u4F1A\u518D\u6B21\u9A8C\u8BC1\uFF0C\u907F\u514D\u8986\u76D6\u7528\u6237\u6216\u534F\u4F5C\u8005\u7684\u65B0\u6539\u52A8\u3002"),
-              bullets,
+              facts,
               nextStep: reviewingOk || mode === "ask" ? "" : tx("If you need tracked writes, turn on Overleaf Reviewing/Track Changes first.", "\u5982\u679C\u9700\u8981\u7559\u75D5\u5199\u5165\uFF0C\u8BF7\u5148\u5728 Overleaf \u5F00\u542F Reviewing/Track Changes\u3002"),
               technical: formatPageDiagnosticsTechnicalDetails(probe)
             };
@@ -38635,7 +39110,7 @@ failedAt: ${new Date(failure.at).toISOString()}`;
             subtitle: formatProbeStatusBar(probe),
             status: "warning",
             summary: readable ? tx("The extension read the current Overleaf file, but has not verified that the current editor can be written.", "\u63D2\u4EF6\u5DF2\u8BFB\u5230\u5F53\u524D Overleaf \u6587\u4EF6\uFF0C\u4F46\u8FD8\u6CA1\u6709\u786E\u8BA4\u5F53\u524D\u7F16\u8F91\u5668\u53EF\u4EE5\u5199\u5165\u3002") : tx("The extension has not verified that the current editor can be written. Usually this means no .tex file is open yet, or Overleaf is still loading.", "\u63D2\u4EF6\u6CA1\u6709\u786E\u8BA4\u5F53\u524D\u7F16\u8F91\u5668\u53EF\u4EE5\u5199\u5165\u3002\u901A\u5E38\u662F\u8FD8\u6CA1\u70B9\u5F00 .tex \u6587\u4EF6\uFF0C\u6216\u8005 Overleaf \u9875\u9762\u4ECD\u5728\u52A0\u8F7D\u3002"),
-            bullets,
+            facts,
             nextStep: tx("Open the target .tex file from the left Overleaf file tree, wait for the editor to load, then check again.", "\u5728 Overleaf \u5DE6\u4FA7\u6587\u4EF6\u6811\u70B9\u5F00\u8981\u5904\u7406\u7684 .tex \u6587\u4EF6\uFF0C\u7B49\u7F16\u8F91\u5668\u52A0\u8F7D\u5B8C\u6210\u540E\u91CD\u65B0\u68C0\u6D4B\u3002"),
             technical: formatPageDiagnosticsTechnicalDetails(probe)
           };
@@ -38648,10 +39123,10 @@ failedAt: ${new Date(failure.at).toISOString()}`;
           const warnings = getProjectSnapshotWarnings(project);
           const warningText = [...warnings.blocking, ...warnings.nonBlocking].map(formatProjectSnapshotWarning);
           const source = project?.capabilities?.method || "unknown";
-          const bullets = [
-            tx(`Text files: ${textCount}`, `\u6587\u672C\u6587\u4EF6\uFF1A${textCount} \u4E2A`),
-            tx(`Asset files: ${binaryCount}`, `\u8D44\u6E90\u6587\u4EF6\uFF1A${binaryCount} \u4E2A`),
-            project?.activePath ? tx(`Current file: ${project.activePath}`, `\u5F53\u524D\u6587\u4EF6\uFF1A${project.activePath}`) : tx("Current file: not detected", "\u5F53\u524D\u6587\u4EF6\uFF1A\u672A\u8BC6\u522B")
+          const facts = [
+            { label: tx("Text files", "\u6587\u672C\u6587\u4EF6"), value: tx(String(textCount), `${textCount} \u4E2A`) },
+            { label: tx("Asset files", "\u8D44\u6E90\u6587\u4EF6"), value: tx(String(binaryCount), `${binaryCount} \u4E2A`) },
+            { label: tx("Current file", "\u5F53\u524D\u6587\u4EF6"), value: project?.activePath || tx("Not detected", "\u672A\u8BC6\u522B") }
           ];
           if (fullProject && files.length) {
             return {
@@ -38662,7 +39137,8 @@ failedAt: ${new Date(failure.at).toISOString()}`;
                 `The extension read the full Overleaf project: ${textCount} text file(s)${binaryCount ? `, ${binaryCount} asset file(s)` : ""}.`,
                 `\u63D2\u4EF6\u5DF2\u8BFB\u5230\u5B8C\u6574 Overleaf \u9879\u76EE\uFF1A${textCount} \u4E2A\u6587\u672C\u6587\u4EF6${binaryCount ? `\uFF0C${binaryCount} \u4E2A\u8D44\u6E90\u6587\u4EF6` : ""}\u3002`
               ),
-              bullets: warningText.length ? [...bullets, ...warningText] : bullets,
+              facts,
+              notes: warningText,
               technical: formatProjectSnapshotLog(project)
             };
           }
@@ -38674,7 +39150,8 @@ failedAt: ${new Date(failure.at).toISOString()}`;
               `The full Overleaf project was not read. Currently read ${textCount} text file(s)${binaryCount ? `, ${binaryCount} asset file(s)` : ""}.`,
               `\u6CA1\u6709\u8BFB\u5230\u5B8C\u6574\u7684 Overleaf \u9879\u76EE\u3002\u5F53\u524D\u53EA\u8BFB\u5230 ${textCount} \u4E2A\u6587\u672C\u6587\u4EF6${binaryCount ? `\uFF0C${binaryCount} \u4E2A\u8D44\u6E90\u6587\u4EF6` : ""}\u3002`
             ) : tx("The full Overleaf project was not read, and no usable file content was available.", "\u6CA1\u6709\u8BFB\u5230\u5B8C\u6574\u7684 Overleaf \u9879\u76EE\uFF0C\u4E5F\u6CA1\u6709\u62FF\u5230\u53EF\u7528\u6587\u4EF6\u5185\u5BB9\u3002"),
-            bullets: warningText.length ? [...bullets, ...warningText] : bullets,
+            facts,
+            notes: warningText,
             nextStep: tx("Reload Overleaf and wait for the left file tree to load, then retry. If you only want one file, use + to add @file context.", "\u5237\u65B0 Overleaf \u9875\u9762\uFF0C\u7B49\u5DE6\u4FA7\u6587\u4EF6\u6811\u52A0\u8F7D\u5B8C\u6210\u540E\u91CD\u8BD5\uFF1B\u5982\u679C\u53EA\u60F3\u5904\u7406\u4E00\u4E2A\u6587\u4EF6\uFF0C\u53EF\u4EE5\u7528 + \u6DFB\u52A0 @file \u4E0A\u4E0B\u6587\u3002"),
             technical: formatProjectSnapshotLog(project)
           };
@@ -38886,7 +39363,7 @@ failedAt: ${new Date(failure.at).toISOString()}`;
             },
             platform: nativeDiagnostics.platform,
             nativeEnvironment: nativeDiagnostics.nativeEnvironment,
-            mirror,
+            mirror: mirror ?? { status: "unavailable" },
             auditLogs,
             run: activeRecord?.runProjectId === projectId && matchesAccount(activeRecord, currentRunView?.runAccountScopeId) ? activeRecord : recentRuns[0] || {},
             recentRuns,
@@ -39737,17 +40214,18 @@ ${AgentTranscript.formatFailureBlock(failure, locale, indent)}`;
           const existing = root.querySelector("[data-run-copy]");
           const button = existing.cloneNode(true);
           existing.replaceWith(button);
-          const finalAnswer = root.querySelector(".run-completion-report .run-final-answer");
-          const copyText = String(finalAnswer?.innerText || finalAnswer?.textContent || "").trim();
+          const available = Boolean(readConclusionText(root).trim());
           button.hidden = false;
-          button.disabled = !copyText;
+          button.disabled = !available;
           button.title = tr("copyConclusionTitle");
           button.setAttribute("aria-label", button.title);
           button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><g transform="translate(.75 .75)"><rect x="6.5" y="6.5" width="9" height="9" rx="2"/><path d="M13.5 6.5V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6.5a2 2 0 0 0 2 2h1.5"/></g></svg>';
-          if (!copyText) return;
+          if (!available) return;
           button.addEventListener("click", async (event) => {
             event.stopPropagation();
             try {
+              const copyText = readConclusionText(root);
+              if (!copyText.trim()) return;
               await writeClipboardText(copyText);
               button.title = tr("copyConclusionDone");
             } catch (_error) {
@@ -39756,6 +40234,47 @@ ${AgentTranscript.formatFailureBlock(failure, locale, indent)}`;
             button.setAttribute("aria-label", button.title);
           });
         }
+        function readConclusionText(root) {
+          const answer = root.querySelector(".run-completion-report .run-final-answer");
+          if (!answer) return "";
+          return extractConclusionText(answer).replace(/\u200b/g, "").replace(/[ \t]+$/gm, "").trim();
+        }
+        function extractConclusionText(node) {
+          if (node.nodeType === 3) return String(node.textContent || "").replace(/\s+/g, " ");
+          const tag = node.tagName?.toLowerCase();
+          if (tag === "br") return "\n";
+          if (tag === "pre" || tag === "code") return node.textContent || "";
+          if (node.classList?.contains("run-math")) {
+            const source = node.dataset.mathRendered === "false" ? node.textContent || "" : node.querySelector('annotation[encoding="application/x-tex"]')?.textContent || "";
+            const delimiter = node.dataset.mathDisplay === "block" ? "$$" : "$";
+            return source ? `${delimiter}${source}${delimiter}` : "";
+          }
+          const children = Array.from(node.childNodes || []);
+          if (tag === "ul" || tag === "ol") {
+            const start = Number(node.getAttribute("start") || 1);
+            return children.filter((child) => child.tagName?.toLowerCase() === "li").map((child, index) => `${tag === "ol" ? `${start + index}. ` : "- "}${extractConclusionText(child)}`).join("\n");
+          }
+          if (tag === "table") {
+            return Array.from(node.querySelectorAll("tr"), (row) => Array.from(
+              row.children,
+              (cell) => extractConclusionText(cell)
+            ).join("	")).join("\n");
+          }
+          let text = "";
+          let previousBlock = false;
+          for (const child of children) {
+            const value = extractConclusionText(child);
+            if (!value) continue;
+            const block = /^(p|h[1-6]|blockquote|ul|ol|pre|table|div)$/.test(child.tagName?.toLowerCase()) || child.dataset?.mathDisplay === "block";
+            if (text && (previousBlock || block)) {
+              const newlines = (text.match(/\n*$/)?.[0].length || 0) + (value.match(/^\n*/)?.[0].length || 0);
+              text += "\n".repeat(Math.max(0, 2 - newlines));
+            }
+            text += value;
+            previousBlock = block;
+          }
+          return text;
+        }
         async function writeClipboardText(text) {
           if (navigatorRef?.clipboard?.writeText) {
             await navigatorRef.clipboard.writeText(text);
@@ -44577,7 +45096,7 @@ ${lines}`
           normalizeSpeedTiersForSelect,
           retainSelectedModel
         } = Support;
-        let modelDiscovery = { status: "fallback", source: "fallback", fetchedAt: "" };
+        let modelDiscovery = { status: "fallback", source: "fallback", fetchedAt: "", provisional: true };
         let modelLoadGeneration = 0;
         function getModelDiscovery() {
           return modelDiscovery;
@@ -44621,22 +45140,18 @@ ${lines}`
           const modelSelect = getPanel()?.querySelector("[data-model]");
           const reasoningSelect = getPanel()?.querySelector("[data-reasoning]");
           const speedSelect = getPanel()?.querySelector("[data-speed]");
-          let changedInput = null;
-          if (choice.dataset.reasoningChoice && reasoningSelect) {
-            reasoningSelect.value = choice.dataset.reasoningChoice;
-            changedInput = reasoningSelect;
-          } else if (choice.dataset.modelChoice && modelSelect) {
-            modelSelect.value = choice.dataset.modelChoice;
-            changedInput = modelSelect;
+          const changedInput = choice.dataset.reasoningChoice ? reasoningSelect : choice.dataset.modelChoice ? modelSelect : choice.dataset.speedChoice ? speedSelect : null;
+          const value = choice.dataset.reasoningChoice || choice.dataset.modelChoice || choice.dataset.speedChoice;
+          const option = Array.from(changedInput?.options || []).find((item) => item.value === value);
+          if (!changedInput || changedInput.disabled || !option || option.disabled) return;
+          changedInput.value = value;
+          if (changedInput === modelSelect) {
             renderReasoningOptions(getRenderedModelEntries());
             renderSpeedOptions(getRenderedModelEntries());
-          } else if (choice.dataset.speedChoice && speedSelect) {
-            speedSelect.value = choice.dataset.speedChoice;
-            changedInput = speedSelect;
           }
           renderModelConfigChoices();
           updateModelDisplay();
-          await persistPanelInputs(changedInput ? { type: "change", target: changedInput } : void 0);
+          await persistPanelInputs({ type: "change", target: changedInput });
         }
         async function loadModelOptions(providerSelection, options = {}) {
           const generation = ++modelLoadGeneration;
@@ -44668,7 +45183,7 @@ ${lines}`
             }
             const sourceModels = hasDiscoveredModels ? response.result.models : fallbackModels;
             const preserveBuiltin = (selection?.providerId || "builtin") === "builtin" && (getState()?.providerId || "builtin") === "builtin";
-            const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel, { preserveUnavailable: preserveBuiltin });
+            const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel, { preserveUnavailable: preserveBuiltin }) || (responseProviderId && responseProviderId !== "builtin" ? retainSelectedModel(sourceModels, response.result?.defaultModelId) : "");
             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." });
@@ -44766,6 +45281,13 @@ ${lines}`
             return;
           }
           const selectedId = normalizeModelOptionId(selectedModel);
+          if (options.provisionalSelected === true) {
+            models = [...Array.isArray(models) ? models : []];
+            if (selectedId && !models.some((model) => normalizeModelOptionId(model?.id) === selectedId)) {
+              models.push({ id: selectedId, label: selectedId, unverified: true });
+            }
+            models = Support.preserveSelectedCapabilities(models, selectedId, getState(), true);
+          }
           modelSelect.textContent = "";
           modelSelect.disabled = false;
           let renderedSelected = false;
@@ -44887,7 +45409,8 @@ ${lines}`
             list.append(createModelConfigChoice({
               value: option.value,
               label: formatReasoningEffortLabel(option.value, reasoningSelect.dataset.presentation),
-              datasetName: "reasoningChoice"
+              datasetName: "reasoningChoice",
+              disabled: reasoningSelect.disabled || option.disabled
             }));
           }
         }
@@ -44903,7 +45426,8 @@ ${lines}`
             const choice = createModelConfigChoice({
               value: option.value,
               label: option.textContent || option.value,
-              datasetName: "modelChoice"
+              datasetName: "modelChoice",
+              disabled: modelSelect.disabled || option.disabled
             });
             choice.title = option.textContent || option.value;
             list.append(choice);
@@ -44920,15 +45444,16 @@ ${lines}`
             const choice = createModelConfigChoice({
               value: option.value,
               label: formatSpeedTierLabel(option.value),
-              datasetName: "speedChoice"
+              datasetName: "speedChoice",
+              disabled: speedSelect.disabled || option.disabled
             });
-            choice.disabled = speedSelect.disabled && speedSelect.options.length <= 1;
             list.append(choice);
           }
         }
-        function createModelConfigChoice({ value, label, datasetName }) {
+        function createModelConfigChoice({ value, label, datasetName, disabled = false }) {
           const button = document.createElement("button");
           button.type = "button";
+          button.disabled = disabled;
           button.className = "codex-model-config-choice";
           button.dataset[datasetName] = value;
           button.setAttribute("role", "menuitemradio");
@@ -45573,10 +46098,10 @@ ${lines}`
             restoreScrollTop: root ? root.scrollTop : 0
           };
         }
-        async function refreshDashboardView() {
+        async function refreshDashboardView(options = {}) {
           var panelEl = getPanel();
           if (panelEl && panelEl.dataset.view === "recent-projects") {
-            await renderRecentProjectsVariant(dashboardViewOptions());
+            await renderRecentProjectsVariant(Object.assign(dashboardViewOptions(), options));
           }
         }
         async function openDashboardConversation(projectId, record, row) {
@@ -45751,7 +46276,7 @@ ${lines}`
               var map = prefs.activeSessionByProject && typeof prefs.activeSessionByProject === "object" ? prefs.activeSessionByProject : {};
               map[projectId] = record.id;
               prefs.activeSessionByProject = map;
-              await Migration.savePrefs(prefs, accountScopeId, projectId);
+              await Migration.savePrefs({ activeSessionByProject: map }, accountScopeId, projectId);
             }
           } catch (_error) {
           }
@@ -45886,18 +46411,30 @@ ${lines}`
           input.focus();
           input.select();
           var settled = false;
-          var finish = function(commit) {
+          var finish = async function(commit) {
             if (settled) {
               return;
             }
             settled = true;
             var nextRaw = input.value;
-            input.remove();
-            titleEl.hidden = false;
             if (!commit || nextRaw.trim() === seed.trim()) {
+              input.remove();
+              titleEl.hidden = false;
+              return;
+            }
+            input.readOnly = true;
+            try {
+              await commitDashboardSessionRename(sessionsEl, projectId, record, nextRaw);
+            } catch (_error) {
+              settled = false;
+              input.readOnly = false;
+              showPluginToast(tr("recentProjects_renameFailed"), { status: "failed", sticky: true });
+              input.focus();
               return;
             }
-            commitDashboardSessionRename(sessionsEl, projectId, record, nextRaw).catch(function() {
+            input.remove();
+            titleEl.hidden = false;
+            await refreshDashboardView().catch(function() {
             });
           };
           input.addEventListener("keydown", function(event) {
@@ -45935,16 +46472,12 @@ ${lines}`
             });
           } catch (_error) {
           }
-          try {
-            if (StorageDb) {
-              await StorageDb.putRecord("sessions", StorageDb.buildSessionRecord(Object.assign({}, record, {
-                title: next.title,
-                titleSource: next.titleSource
-              })));
-            }
-          } catch (_error) {
+          if (StorageDb) {
+            await StorageDb.putRecord("sessions", StorageDb.buildSessionRecord(Object.assign({}, record, {
+              title: next.title,
+              titleSource: next.titleSource
+            }), { preserveRunActionPayload: true }));
           }
-          await refreshDashboardView();
         }
         function ensureRecentProjectsRoot() {
           if (!getPanel()) {
@@ -46166,6 +46699,7 @@ ${lines}`
           openProjectFromRow,
           renderRecentProjectRow,
           renderRecentProjectsVariant,
+          refreshDashboardView,
           mountDashboardShell,
           resetProjectNameCache,
           renderPerProjectVariant
@@ -47298,6 +47832,12 @@ ${lines}`
       let appendRunEvent;
       let appendRunRecordEvent;
       let pendingMirrorRefresh = null;
+      const mirrorSettlementOwners = /* @__PURE__ */ new Map();
+      const mirrorReuseFences = /* @__PURE__ */ new Map();
+      const mirrorFenceWrites = /* @__PURE__ */ new Map();
+      const mirrorFenceRevisions = /* @__PURE__ */ new Map();
+      const MIRROR_INVALIDATION_TIMEOUT_MS = 2e4;
+      const MIRROR_FENCE_STORAGE_TIMEOUT_MS = 2e3;
       let appendChangeSummary;
       let appendCompletionReport;
       let appendOperationsPreview;
@@ -47308,6 +47848,8 @@ ${lines}`
       let callPageBridge;
       let sendBackgroundNative;
       let getCurrentProjectId;
+      let getAccountScopeId;
+      let mirrorFenceStore;
       let resetContextProject;
       let sanitizeRunProjectSnapshot;
       let getAssistantAnswerForCurrentRun;
@@ -47345,34 +47887,169 @@ ${lines}`
       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.");
+      function mirrorFenceScope(projectId, accountScopeId = getAccountScopeId?.() || "") {
+        return { projectId, accountScopeId };
+      }
+      function mirrorFenceKey(scope) {
+        return JSON.stringify([scope.accountScopeId, scope.projectId]);
+      }
+      function getMirrorReuseFence(projectId, accountScopeId) {
+        return mirrorReuseFences.get(mirrorFenceKey(mirrorFenceScope(projectId, accountScopeId))) || null;
+      }
+      function updateMirrorReuseFence(scope, generations, unknown = false) {
+        const key = mirrorFenceKey(scope), current = mirrorReuseFences.get(key);
+        const ids = [...new Set(generations)].sort();
+        if (current && current.unknown === unknown && current.generations.join(":") === ids.join(":")) return current;
+        const fence = ids.length || unknown ? { scope, generations: ids, unknown, syncAttempted: false } : null;
+        if (fence) mirrorReuseFences.set(key, fence);
+        else mirrorReuseFences.delete(key);
+        mirrorFenceRevisions.set(key, (mirrorFenceRevisions.get(key) || 0) + 1);
+        return fence;
+      }
+      async function awaitMirrorFenceStorage(work) {
+        let timer;
+        try {
+          return await Promise.race([
+            Promise.resolve().then(work),
+            new Promise((_resolve, reject) => {
+              timer = setTimeout(() => reject(new Error("Mirror fence storage timed out.")), MIRROR_FENCE_STORAGE_TIMEOUT_MS);
+            })
+          ]);
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      async function refreshMirrorReuseFence(projectId, accountScopeId) {
+        const scope = mirrorFenceScope(projectId, accountScopeId), key = mirrorFenceKey(scope);
+        if (!mirrorFenceStore) return getMirrorReuseFence(projectId, scope.accountScopeId);
+        const revision = mirrorFenceRevisions.get(key) || 0;
+        try {
+          const stored = await awaitMirrorFenceStorage(() => mirrorFenceStore.getMirrorReuseFences(scope));
+          const writes = mirrorFenceWrites.get(key) || /* @__PURE__ */ new Map();
+          const changed = revision !== (mirrorFenceRevisions.get(key) || 0);
+          const generations = new Set(stored.filter((id) => !writes.get(id)?.retired));
+          for (const [id, write] of writes) {
+            if (!write.retired && (!write.persisted || changed)) generations.add(id);
           }
-          if (getCurrentProjectId() === projectId) {
-            resetContextProject();
-            await callPageBridge("invalidateProjectSnapshot", { invalidateFileList: true });
+          if (changed) for (const id of mirrorReuseFences.get(key)?.generations || []) {
+            if (!writes.get(id)?.retired) generations.add(id);
           }
-          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";
+          return updateMirrorReuseFence(scope, [...generations]);
+        } catch (_error) {
+          return updateMirrorReuseFence(scope, mirrorReuseFences.get(key)?.generations || [], true);
+        }
+      }
+      async function recordMirrorReuseFence(target) {
+        const scope = mirrorFenceScope(target.runProjectId, target.runAccountScopeId);
+        const key = mirrorFenceKey(scope);
+        const generation = globalThis.crypto?.randomUUID?.() || Date.now().toString(36) + "-" + Math.random().toString(36).slice(2) + "-" + Math.random().toString(36).slice(2);
+        const writes = mirrorFenceWrites.get(key) || /* @__PURE__ */ new Map();
+        mirrorFenceWrites.set(key, writes);
+        const write = { persisted: false, retired: false, clearAfterWrite: false };
+        writes.set(generation, write);
+        updateMirrorReuseFence(scope, [...mirrorReuseFences.get(key)?.generations || [], generation]);
+        const token = { scope, generation };
+        if (!mirrorFenceStore) return token;
+        const pending = Promise.resolve().then(() => mirrorFenceStore.setMirrorReuseFence(scope, generation));
+        pending.then(() => {
+          write.persisted = true;
+          mirrorFenceRevisions.set(key, (mirrorFenceRevisions.get(key) || 0) + 1);
+          if (write.clearAfterWrite) {
+            awaitMirrorFenceStorage(() => mirrorFenceStore.clearMirrorReuseFences(scope, [generation])).then(() => {
+              write.retired = true;
+            }).catch(() => {
+            });
+          }
+        }, () => {
+        });
+        try {
+          await awaitMirrorFenceStorage(() => pending);
+        } catch (_error) {
+        }
+        return token;
+      }
+      async function clearMirrorReuseFenceGenerations(scope, generations) {
+        const writes = mirrorFenceWrites.get(mirrorFenceKey(scope));
+        for (const id of generations) if (writes?.has(id)) writes.get(id).clearAfterWrite = true;
+        const clearing = Promise.resolve().then(() => mirrorFenceStore?.clearMirrorReuseFences(scope, generations));
+        clearing.then(() => {
+          for (const id of generations) if (writes?.has(id)) writes.get(id).retired = true;
+        }, () => {
+        });
+        await awaitMirrorFenceStorage(() => clearing);
+      }
+      async function settleFullMirrorSync(projectId, project, fence, response, options = {}) {
+        if (!fence || fence.unknown || getMirrorReuseFence(projectId, fence.scope.accountScopeId) !== fence || response?.ok !== true || project?.capabilities?.fullProjectSnapshot !== true || project.capabilities.contentComplete === false || project.capabilities.skipped?.length) return false;
+        try {
+          options.assertCurrent?.();
+          const status = await (options.sendNative || sendBackgroundNative)({ method: "mirror.status", params: { projectId } });
+          options.assertCurrent?.();
+          const current = await refreshMirrorReuseFence(projectId, fence.scope.accountScopeId);
+          options.assertCurrent?.();
+          if (getCurrentProjectId() !== projectId || current !== fence || status?.ok !== true || status.result?.exists !== true || status.result.dirty === true) return false;
+          await clearMirrorReuseFenceGenerations(fence.scope, fence.generations);
+          options.assertCurrent?.();
+          if (getMirrorReuseFence(projectId, fence.scope.accountScopeId) === fence) updateMirrorReuseFence(fence.scope, []);
+          return !await refreshMirrorReuseFence(projectId, fence.scope.accountScopeId);
+        } catch (_error) {
+          options.assertCurrent?.();
+          return false;
+        }
+      }
+      async function syncFencedMirror(projectId, project, options = {}) {
+        const fence = options.fence;
+        if (!fence || fence.unknown || getMirrorReuseFence(projectId, fence.scope.accountScopeId) !== fence || fence.syncAttempted || project?.id !== projectId || project.capabilities?.fullProjectSnapshot !== true || project.capabilities.contentComplete === false || project.capabilities.skipped?.length) return false;
+        options.assertCurrent();
+        fence.syncAttempted = true;
+        try {
+          const response = await options.sendNative({ method: "mirror.sync", params: { projectId, project } });
+          options.assertCurrent();
+          return await settleFullMirrorSync(projectId, project, fence, response, options);
+        } catch (_error) {
+          options.assertCurrent();
+          return false;
+        }
+      }
+      function trackWritebackMirror(work, target, onSettled) {
+        const key = JSON.stringify([target.runProjectId, target.sessionId, target.recordId]);
+        const owner = {};
+        mirrorSettlementOwners.set(key, owner);
+        const refresh = Promise.resolve(work).then(async (state) => {
+          if (mirrorSettlementOwners.get(key) !== owner) return state;
+          onSettled?.(state);
+          await onMirrorRefreshSettled?.({ ...target, state: state || "not-attempted" });
+          return state;
+        }).finally(() => {
+          if (mirrorSettlementOwners.get(key) === owner) mirrorSettlementOwners.delete(key);
+        });
+        const pending = Promise.allSettled([pendingMirrorRefresh, refresh]).then(([, result]) => {
+          if (result.status === "rejected") throw result.reason;
+          return result.value;
         }).finally(() => {
           if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
         });
         pendingMirrorRefresh = pending;
         return pending;
       }
+      function invalidateMirrorAfterUndo(runId, projectId, result = {}, owner = {}) {
+        if (!projectId || result?.changedDocument !== true && !result?.applied?.length) return Promise.resolve("not-attempted");
+        const target = {
+          recordId: runId,
+          runProjectId: projectId,
+          runAccountScopeId: owner.runAccountScopeId || getAccountScopeId?.() || "",
+          sessionId: owner.sessionId || ""
+        };
+        const pending = Promise.resolve(pendingMirrorRefresh).catch(() => {
+        }).then(() => invalidateWritebackMirror(target, {
+          pageFirst: true,
+          nativeTimeoutMs: MIRROR_INVALIDATION_TIMEOUT_MS,
+          undo: true
+        })).then((state) => state === "not-attempted" ? "invalidated" : state).finally(() => {
+          if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
+        });
+        pendingMirrorRefresh = pending;
+        return pending;
+      }
       function selectionViolationNextStep() {
         return tx(
           "Select the intended region again and request only changes within it. Valid written parts can be undone.",
@@ -47401,7 +48078,12 @@ ${lines}`
       }
       async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options = {}) {
         const activeRun = getCurrentRunView?.();
-        const saveTarget = { runProjectId: activeRun?.runProjectId || "", recordId: activeRun?.recordId || "", sessionId: activeRun?.sessionId || "" };
+        const saveTarget = {
+          runProjectId: activeRun?.runProjectId || "",
+          runAccountScopeId: activeRun?.runAccountScopeId || getAccountScopeId?.() || "",
+          recordId: activeRun?.recordId || "",
+          sessionId: activeRun?.sessionId || ""
+        };
         const runMode = options.mode || getState().mode;
         const runRequireReviewing = typeof options.requireReviewing === "boolean" ? options.requireReviewing : getState().requireReviewing === true;
         const assistantMessage = cleanFinalAnswer(options.assistantMessage || getAssistantAnswerForCurrentRun());
@@ -47694,28 +48376,57 @@ ${tx("Sync note: no changes were written to Overleaf; every change was blocked b
             skipped: skippedEntries.length
           }
         });
-        const confirmation = appliedPaths.length ? await verifyPostWriteSaveState(applied, project, saveTarget) : { verification: { ok: false, state: "not_checked", reason: "No applied writeback operations were returned." } };
+        let confirmation;
+        try {
+          confirmation = appliedPaths.length ? await verifyPostWriteSaveState(applied, project, saveTarget) : { verification: { ok: false, state: "not_checked", reason: "No applied writeback operations were returned." } };
+        } catch (error) {
+          if (!appliedPaths.length || error?.code !== "codex_cancelled" && error?.name !== "AbortError") throw error;
+          const saveVerification2 = {
+            ok: false,
+            state: "unknown_timeout",
+            signal: "unavailable",
+            reason: "Save confirmation was cancelled.",
+            recoveryReason: "codex_cancelled",
+            attempts: []
+          };
+          error.writebackOutcome = {
+            operations,
+            applied,
+            saveVerification: saveVerification2,
+            settlement: buildSettlement({ operations, applyResult: applied, saveVerification: saveVerification2, mirror: { state: "unknown" } })
+          };
+          trackWritebackMirror(
+            invalidateWritebackMirror(saveTarget, {
+              pageFirst: true,
+              nativeTimeoutMs: MIRROR_INVALIDATION_TIMEOUT_MS
+            }),
+            saveTarget,
+            (state) => {
+              error.writebackOutcome.settlement = buildSettlement({ operations, applyResult: applied, saveVerification: saveVerification2, mirror: { state } });
+            }
+          );
+          try {
+            await settleWritebackRecovery?.(applied, project, saveVerification2, saveTarget, runRequireReviewing);
+          } catch (recoveryError) {
+            appendRunRecordEvent?.(saveTarget.recordId, {
+              kind: "technical",
+              status: "warning",
+              title: tx("Writeback recovery persistence failed", "\u5199\u56DE\u6062\u590D\u4FE1\u606F\u4FDD\u5B58\u5931\u8D25"),
+              detail: { reason: recoveryError.message }
+            });
+          }
+          throw error;
+        }
         const saveVerification = confirmation.verification;
         await settleWritebackRecovery?.(applied, project, saveVerification, saveTarget, runRequireReviewing);
         if (appliedPaths.length) {
           appendPostWriteSaveVerificationWarning(saveVerification, saveTarget);
           appendRunEvent({ kind: "technical", title: "Post-write save confirmation", status: "info", detail: saveVerification });
         }
-        const mirrorSettlementTarget = saveTarget;
-        pendingMirrorRefresh = refreshProjectMirrorAfterWriteback(project, applied, saveVerification, { target: saveTarget, snapshot: confirmation.snapshot }).catch(async (error) => {
+        trackWritebackMirror(refreshProjectMirrorAfterWriteback(project, applied, saveVerification, { target: saveTarget, snapshot: confirmation.snapshot }).catch(async (error) => {
           appendRunRecordEvent(saveTarget.recordId, { kind: "technical", title: "Mirror refresh requires a fresh read", status: "info", detail: { reason: error.message } });
           return invalidateWritebackMirror(saveTarget);
-        }).then((state) => {
-          if (typeof onMirrorRefreshSettled !== "function") return;
-          return onMirrorRefreshSettled({
-            recordId: mirrorSettlementTarget?.recordId || "",
-            sessionId: mirrorSettlementTarget?.sessionId || "",
-            runProjectId: mirrorSettlementTarget?.runProjectId || "",
-            state: state || "not-attempted"
-          });
-        }).finally(() => {
-          pendingMirrorRefresh = null;
-        });
+        }), saveTarget);
         const compileSummary = appliedPaths.length ? await autoRecompileAfterWriteback(appliedPaths, saveVerification, {
           autoRecompile: options.autoRecompile,
           mode: runMode,
@@ -47782,7 +48493,9 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           // the run by inspecting the `applied.skipped` entries' failure codes.
           // Existing call sites that only read `summaryLine` / `hasSkippedOperations`
           // / `audit` are unaffected.
+          operations,
           applied,
+          saveVerification,
           settlement: buildSettlement({
             operations,
             applyResult: applied,
@@ -47831,27 +48544,65 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         if (target.recordId) appendRunRecordEvent(target.recordId, { title, status: "warning" });
         else appendRunEvent({ title, status: "warning" });
       }
-      async function invalidateWritebackMirror(target = {}) {
+      async function invalidateWritebackMirror(target = {}, options = {}) {
+        const invalidatePage = async () => {
+          if (getCurrentProjectId() !== target.runProjectId || target.runAccountScopeId && getAccountScopeId?.() !== target.runAccountScopeId) return true;
+          try {
+            resetContextProject();
+            const response = await callPageBridge("invalidateProjectSnapshot", { invalidateFileList: true, runProjectId: target.runProjectId });
+            return response?.ok === true;
+          } catch (_error) {
+            return false;
+          }
+        };
+        const pageInvalidation = options.pageFirst === true ? invalidatePage() : null;
+        const pendingFence = options.pageFirst === true && target.runProjectId ? await recordMirrorReuseFence(target) : null;
         let invalidated = false;
+        let failureReason = "Native host did not confirm mirror invalidation.";
+        let timer;
         try {
           if (target.runProjectId) {
-            const response = await sendBackgroundNative({ method: "mirror.invalidate", params: { projectId: target.runProjectId } });
+            const pending = sendBackgroundNative({ method: "mirror.invalidate", params: { projectId: target.runProjectId } });
+            pending.catch(() => {
+            });
+            const response = options.nativeTimeoutMs ? await Promise.race([
+              pending,
+              new Promise((resolve) => {
+                timer = setTimeout(() => resolve(null), options.nativeTimeoutMs);
+              })
+            ]) : await pending;
             invalidated = response?.ok === true && response.result?.invalidated === true;
+            if (!invalidated && response?.error?.message) failureReason = response.error.message;
           }
-        } catch (_error) {
+        } catch (error) {
+          failureReason = error?.message || failureReason;
+        } finally {
+          if (timer !== void 0) clearTimeout(timer);
         }
-        let pageInvalidated = getCurrentProjectId() !== target.runProjectId;
-        if (!pageInvalidated) {
-          resetContextProject();
-          try {
-            const response = await callPageBridge("invalidateProjectSnapshot", { invalidateFileList: true, runProjectId: target.runProjectId });
-            pageInvalidated = response?.ok === true;
-          } catch (_error) {
+        const pageInvalidated = await (pageInvalidation || invalidatePage());
+        if (invalidated && pageInvalidated) {
+          if (pendingFence) {
+            try {
+              await clearMirrorReuseFenceGenerations(pendingFence.scope, [pendingFence.generation]);
+              const current = getMirrorReuseFence(target.runProjectId, pendingFence.scope.accountScopeId);
+              if (current) updateMirrorReuseFence(
+                pendingFence.scope,
+                current.generations.filter((id) => id !== pendingFence.generation),
+                current.unknown
+              );
+              await refreshMirrorReuseFence(target.runProjectId, pendingFence.scope.accountScopeId);
+            } catch (_error) {
+            }
           }
+          return "not-attempted";
         }
-        if (invalidated && pageInvalidated) return "not-attempted";
+        if (target.runProjectId && !pendingFence) await recordMirrorReuseFence(target);
+        if (invalidated && !pageInvalidated) failureReason = "The page did not confirm snapshot invalidation.";
         const event = {
-          title: tx(
+          title: options.undo === true ? tx(
+            `Overleaf undo finished, but local mirror invalidation failed: ${failureReason}. 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${failureReason}\u3002\u8BF7\u5237\u65B0\u9879\u76EE\u6216\u91CD\u65B0\u8FDE\u63A5 Native Host \u540E\u518D\u8FD0\u884C\u3002`
+          ) : tx(
             "The local project cache could not be reset. Check the local connection before starting another task.",
             "\u672C\u5730\u9879\u76EE\u7F13\u5B58\u672A\u80FD\u91CD\u7F6E\u3002\u8BF7\u68C0\u67E5\u672C\u5730\u8FDE\u63A5\u540E\u518D\u5F00\u59CB\u4E0B\u4E00\u8F6E\u4EFB\u52A1\u3002"
           ),
@@ -47888,6 +48639,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         if (!Array.isArray(applied?.applied) || !applied.applied.length) {
           return "not-attempted";
         }
+        const mirrorFence = await refreshMirrorReuseFence(target.runProjectId, target.runAccountScopeId);
         if (!confirmation.snapshot && await tryConfirmMirrorWriteback(applied, target.runProjectId)) {
           appendRunEvent({
             title: tx(
@@ -47933,6 +48685,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           }
         });
         if (response?.ok) {
+          await settleFullMirrorSync(target.runProjectId, syncedProject, mirrorFence, response);
           appendRunEvent({
             title: tx("Local Codex workspace refreshed. The next run will start from the latest Overleaf content.", "\u5DF2\u5237\u65B0\u672C\u5730 Codex workspace\uFF0C\u4E0B\u4E00\u8F6E\u4F1A\u4ECE\u6700\u65B0 Overleaf \u5185\u5BB9\u5F00\u59CB\u3002"),
             status: "completed"
@@ -48139,6 +48892,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           getCurrentRunView
         } = deps);
         assetTransferBroker = deps.assetTransferBroker;
+        mirrorFenceStore = deps.mirrorFenceStore;
+        getAccountScopeId = deps.getAccountScopeId;
         stageWritebackRecovery = deps.stageWritebackRecovery;
         settleWritebackRecovery = deps.settleWritebackRecovery;
         onMirrorRefreshSettled = deps.onMirrorRefreshSettled;
@@ -48148,6 +48903,9 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           applySyncChangesToOverleaf,
           resolveCompileLogContext,
           invalidateMirrorAfterUndo,
+          getMirrorReuseFence,
+          refreshMirrorReuseFence,
+          syncFencedMirror,
           getPendingMirrorRefresh: () => pendingMirrorRefresh
         };
       }
@@ -48831,6 +49589,10 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             showPluginToast(tx("Nothing to refill: the original task text is unavailable.", "\u65E0\u6CD5\u56DE\u586B\uFF1A\u539F\u4EFB\u52A1\u6587\u672C\u4E0D\u53EF\u7528\u3002"));
             return;
           }
+          if (input.value.trim() && input.value.trim() !== task.trim()) {
+            showPluginToast(tx("Kept your draft. Clear the composer, then try again to refill this task.", "\u5DF2\u4FDD\u7559\u4F60\u7684\u8349\u7A3F\u3002\u6E05\u7A7A\u8F93\u5165\u6846\u540E\u518D\u8BD5\u4E00\u6B21\uFF0C\u5373\u53EF\u56DE\u586B\u8FD9\u6761\u4EFB\u52A1\u3002"));
+            return;
+          }
           prepareRetryReplacement?.(run || null, task);
           input.value = task;
           getState().task = task;
@@ -50195,9 +50957,21 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           input.dataset.styleFocus = "project-search";
           input.placeholder = tx("Search all Overleaf projects", "\u641C\u7D22\u5168\u90E8 Overleaf \u9879\u76EE");
           input.setAttribute("aria-label", input.placeholder);
-          input.addEventListener("input", () => {
+          let composing = false;
+          const updateResults = () => {
             query = input.value;
-            render();
+            const results = input.closest(".ws2-picker")?.querySelector(".ws2-projects");
+            if (results) renderProjectResults(results);
+          };
+          input.addEventListener("compositionstart", () => {
+            composing = true;
+          });
+          input.addEventListener("compositionend", () => {
+            composing = false;
+            updateResults();
+          });
+          input.addEventListener("input", (event) => {
+            if (!composing && !event.isComposing) updateResults();
           });
           search.append(input);
           panel.append(search);
@@ -50215,6 +50989,22 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           const list = node("div", "ws2-projects");
           list.setAttribute("role", "group");
           list.setAttribute("aria-label", tx("Overleaf projects", "Overleaf \u9879\u76EE"));
+          renderProjectResults(list);
+          panel.append(list);
+          const footer = node("div", "ws2-picker-footer");
+          footer.append(
+            node("span", "", tx(sources.length + " of 3 references selected", "\u5DF2\u9009 " + sources.length + " / 3 \u4EFD\u8D44\u6599")),
+            button(tx("Done", "\u5B8C\u6210"), () => {
+              pickerOpen = false;
+              render();
+            }, "ws2-button ws2-button-primary", "picker-done")
+          );
+          panel.append(footer);
+          return panel;
+        }
+        function renderProjectResults(list) {
+          const oldScroll = list.scrollTop;
+          list.replaceChildren();
           if (projectLoading) {
             const loading = node("div", "ws2-picker-state");
             loading.append(node("span", "ws2-pulse"), node("span", "", tx("Loading project directory\u2026", "\u6B63\u5728\u52A0\u8F7D\u9879\u76EE\u76EE\u5F55\u2026")));
@@ -50263,17 +51053,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               query ? tx("No projects match this search.", "\u6CA1\u6709\u5339\u914D\u7684\u9879\u76EE\u3002") : tx("No projects in this group.", "\u6B64\u5206\u7EC4\u6682\u65E0\u9879\u76EE\u3002")
             ));
           }
-          panel.append(list);
-          const footer = node("div", "ws2-picker-footer");
-          footer.append(
-            node("span", "", tx(sources.length + " of 3 references selected", "\u5DF2\u9009 " + sources.length + " / 3 \u4EFD\u8D44\u6599")),
-            button(tx("Done", "\u5B8C\u6210"), () => {
-              pickerOpen = false;
-              render();
-            }, "ws2-button ws2-button-primary", "picker-done")
-          );
-          panel.append(footer);
-          return panel;
+          list.scrollTop = oldScroll;
         }
         function renderSources() {
           const section = node("section", "ws2-library");
@@ -50381,6 +51161,36 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           }
           return section;
         }
+        function replaceAround(parent, fresh, retained, replacement) {
+          for (const child of Array.from(parent.childNodes)) {
+            if (child !== retained) child.remove();
+          }
+          let before = true;
+          for (const child of Array.from(fresh.childNodes)) {
+            if (child === replacement) before = false;
+            else parent.insertBefore(child, before ? retained : null);
+          }
+        }
+        function renderKeepingProjectSearch(content) {
+          const library = host.querySelector(".ws2-library");
+          const picker = library?.querySelector(".ws2-picker");
+          const search = picker?.querySelector(".ws2-search");
+          const nextLibrary = content.querySelector(".ws2-library");
+          const nextPicker = nextLibrary?.querySelector(".ws2-picker");
+          if (!search || !nextPicker) {
+            host.replaceChildren(content);
+            return false;
+          }
+          const input = search.querySelector("input");
+          const nextSearch = nextPicker.querySelector(".ws2-search");
+          input.placeholder = nextSearch.querySelector("input").placeholder;
+          input.setAttribute("aria-label", input.placeholder);
+          picker.setAttribute("aria-label", nextPicker.getAttribute("aria-label"));
+          replaceAround(picker, nextPicker, search, nextSearch);
+          replaceAround(library, nextLibrary, picker, nextPicker);
+          replaceAround(host, content, library, nextLibrary);
+          return document.activeElement === input;
+        }
         function render() {
           if (!host?.isConnected) return;
           alignScope();
@@ -50389,7 +51199,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           const heading = host.closest("[data-set-group]")?.querySelector("[data-writing-style-heading]");
           if (heading) heading.textContent = tx("Writing style", "\u5199\u4F5C\u98CE\u683C");
           host.classList.add("ws2");
-          host.replaceChildren();
+          const content = document.createDocumentFragment();
           const top = node("div", "ws2-heading");
           const copy = node("div", "ws2-heading-copy");
           const title = node("label", "ws2-title", tx("Write in My Style", "\u6CBF\u7528\u5199\u4F5C\u98CE\u683C"));
@@ -50409,7 +51219,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             void toggle(toggleInput.checked);
           });
           top.append(copy, toggleInput);
-          host.append(top);
+          content.append(top);
           if (meta?.ready) {
             const summary = node("div", "ws2-profile");
             const mark = node("span", "ws2-profile-icon");
@@ -50432,7 +51242,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             );
             view.disabled = previewBusy;
             summary.append(mark, info, view);
-            host.append(summary);
+            content.append(summary);
           }
           const editing = expanded || working();
           const manage = button(
@@ -50448,9 +51258,9 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           manage.setAttribute("aria-expanded", String(editing));
           manage.disabled = working();
           manage.append(icon("arrow"));
-          host.append(manage);
+          content.append(manage);
           if (editing) {
-            host.append(renderSources());
+            content.append(renderSources());
             if (working()) {
               const progress = node("div", "ws2-progress");
               progress.setAttribute("role", "status");
@@ -50472,7 +51282,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               }, "ws2-button", "cancel-generation");
               stop.disabled = cancelling;
               progress.append(stop);
-              host.append(progress);
+              content.append(progress);
             } else {
               const footer = node("div", "ws2-actions");
               const help = node("div", "ws2-action-copy");
@@ -50497,8 +51307,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               );
               generateButton.disabled = !scope || !meta || !sources.length || deps.isRunning();
               footer.append(generateButton);
-              host.append(footer);
-              if (deps.isRunning()) host.append(node("p", "ws2-caption", tx("Available after the current task finishes.", "\u5F53\u524D\u4EFB\u52A1\u7ED3\u675F\u540E\u53EF\u751F\u6210\u3002")));
+              content.append(footer);
+              if (deps.isRunning()) content.append(node("p", "ws2-caption", tx("Available after the current task finishes.", "\u5F53\u524D\u4EFB\u52A1\u7ED3\u675F\u540E\u53EF\u751F\u6210\u3002")));
             }
           }
           if (message || !meta) {
@@ -50512,12 +51322,13 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               void ensureLoaded(true).catch(() => {
               });
             }, "ws2-button", "retry-settings"));
-            host.append(status);
+            content.append(status);
           }
-          if (preview) host.append(renderPreview());
+          if (preview) content.append(renderPreview());
+          const searchKeptFocus = renderKeepingProjectSearch(content);
           const scroll = host.querySelector(".ws2-projects");
           if (scroll) scroll.scrollTop = oldScroll;
-          restoreFocus(focus);
+          if (!searchKeptFocus) restoreFocus(focus);
         }
         function mount(panel) {
           const next = panel?.querySelector("[data-writing-style-settings]");
@@ -51256,6 +52067,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           getSkippedEntries
         });
         const writebackOrchestrator = Modules.WritebackOrchestrator.create({
+          mirrorFenceStore: root.CodexOverleafModuleRegistry.resolve("ScopedPersistenceBrowserAdapter"),
+          getAccountScopeId: () => cachedAccountScopeId,
           tr,
           tx,
           getLocale,
@@ -51405,24 +52218,20 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
         });
         let dashboardRefreshTimer = null;
         function refreshDashboardSoon() {
-          if (panel?.dataset.view !== "recent-projects") {
+          if (panel?.dataset.view !== "recent-projects" || document.visibilityState !== "visible") {
             return;
           }
           clearTimeout(dashboardRefreshTimer);
           dashboardRefreshTimer = setTimeout(() => {
-            if (panel?.dataset.view !== "recent-projects") {
+            if (panel?.dataset.view !== "recent-projects" || document.visibilityState !== "visible") {
               return;
             }
-            if (panel.querySelector(".recent-projects-sessions input")) {
+            if (panel.querySelector(".recent-projects-session-rename-input")) {
               refreshDashboardSoon();
               return;
             }
             const expanded = Array.from(panel.querySelectorAll('[data-project-row-wrap][data-expanded="true"]')).map((wrap) => wrap.getAttribute("data-project-row-wrap")).filter(Boolean);
-            const rootEl = panel.querySelector("[data-recent-projects-root]");
-            recentProjects.renderRecentProjectsVariant({
-              restoreExpanded: expanded,
-              restoreScrollTop: rootEl ? rootEl.scrollTop : void 0
-            }).catch(() => {
+            recentProjects.refreshDashboardView({ restoreExpanded: expanded }).catch(() => {
             });
           }, 400);
         }
@@ -51993,7 +52802,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             primeCodexLocalSkillsCatalog().catch(() => {
             });
           }
-          PanelRenderer.setVisible(panel, true);
+          PanelRenderer.setVisible(panelRendererInstance, true);
         }
         let codexOverleafSkillsCatalogPromise = null;
         async function primeCodexOverleafSkillsCatalog({ required = false } = {}) {
@@ -52645,9 +53454,11 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               return;
             }
             let focusFiles = [...executionSnapshot.focusFiles];
+            const mirrorOwner = currentRunView, mirrorRouteGeneration = spaRouteGeneration;
             const warmStart = await awaitRunStep(resolveWarmRunStart({ focusFiles, mode: submittedMode }));
+            const mirrorFence = await awaitRunStep(writebackOrchestrator.refreshMirrorReuseFence(mirrorOwner.runProjectId, mirrorOwner.runAccountScopeId));
             let project = warmStart.project || null;
-            let useExistingMirror = warmStart.useExistingMirror;
+            let useExistingMirror = warmStart.useExistingMirror && !mirrorFence;
             let fileOverlays = warmStart.fileOverlays || null;
             let otWarmStart = warmStart.otWarmStart === true;
             if (!useExistingMirror) {
@@ -52656,6 +53467,17 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                 status: "running"
               });
               project = await awaitRunStep(getRunProjectSnapshot());
+              if (mirrorFence) {
+                const assertCurrent = () => {
+                  throwIfRunCancellationRequested();
+                  if (mirrorOwner !== currentRunView || mirrorRouteGeneration !== spaRouteGeneration || mirrorOwner.runProjectId !== getCurrentProjectId() || mirrorOwner.runAccountScopeId !== cachedAccountScopeId) throw createRunCancellationError();
+                };
+                await awaitRunStep(writebackOrchestrator.syncFencedMirror(mirrorOwner.runProjectId, project, {
+                  fence: mirrorFence,
+                  assertCurrent,
+                  sendNative: (payload) => nativeCompatibilityController.sendBackgroundNative(payload, { assertCurrent })
+                }));
+              }
             }
             throwIfRunCancellationRequested();
             if (!useExistingMirror) {
@@ -52800,7 +53622,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               skillInvocation: submittedSkillInvocation,
               submittedMode
             })));
-            if (!response.ok && response.error?.code === "mirror_stale" && useExistingMirror) {
+            if (!response.ok && ["mirror_stale", "document_identity_mismatch"].includes(response.error?.code) && useExistingMirror) {
               appendRunEvent({ title: tr("warmMirrorStaleRetryTitle"), status: "running" });
               const staleRetry = await awaitRunStep(prepareMirrorStaleRetry({
                 project: await awaitRunStep(getRunProjectSnapshot()),
@@ -53041,7 +53863,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             });
             runSettlementPersistence.applyToCurrentRun(syncOutcome.settlement);
             if (runCancellationRequested) {
-              throw createRunCancellationError();
+              throw Object.assign(createRunCancellationError(), { writebackOutcome: syncOutcome });
             }
             await finalizeAuditRecord(runAuditDraft, {
               ...syncOutcome.audit || {},
@@ -53130,7 +53952,10 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                   }),
                   nextStep: tr("failureReason_reviewing_unavailable_cancelled_next")
                 });
-              } else appendRunCancelledReport();
+              } else {
+                runSettlementPersistence.applyToCurrentRun(error.writebackOutcome?.settlement);
+                appendRunCancelledReport(error.writebackOutcome);
+              }
               await finishRunView(tx("Cancelled", "\u5DF2\u53D6\u6D88"), "cancelled");
               void finalizeAuditRecord(runAuditDraft, { resultStatus: "cancelled" });
               return;
@@ -53218,9 +54043,13 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             stopRunElapsedTick();
             await flushQueuedSaveState().catch(() => {
             });
+            if (settlement.continueQueue) {
+              settlement.continueQueue = await waitForCancelledNativeRun(settledView);
+            }
             currentRunView = null;
             runCancellationRequested = false;
             runCancellationController = null;
+            syncComposerSendAvailability();
             activeTurnControl.release(settlement.requestId);
             if (isExperimentalOtEnabled()) {
               try {
@@ -53640,7 +54469,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           if (state?.activeSessionId !== sessionId || !isProjectEditorRoute(window.location)) return false;
           if (sessionManager.isTransitioning()) {
             deferredSessionStart = { sessionId, scope: getComposerDraftScope() };
-            return false;
+            return "session_transition";
           }
           return true;
         }
@@ -53680,17 +54509,19 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             title: tx("Cancelling the current Codex task.", "\u6B63\u5728\u4E2D\u65AD\u5F53\u524D Codex \u4EFB\u52A1\u3002"),
             status: "running"
           });
-          const activeRequestId = nativeChannel.getActiveRequestId();
+          const activeRequestId = currentRunView.nativeRequestId;
           const projectKey = currentRunView?.runProjectId || getCurrentProjectId() || "";
           const cancelTargets = [];
-          if (activeRequestId || projectKey) {
+          if (activeRequestId != null && activeRequestId !== "") {
             cancelTargets.push(sendBackgroundNative({
               method: "codex.cancel",
               params: {
-                requestId: activeRequestId || void 0,
+                requestId: activeRequestId,
                 projectKey: projectKey || void 0
               }
             }));
+          } else {
+            cancelTargets.push(Promise.resolve(null));
           }
           cancelTargets.push(callPageBridge("cancelActiveWrite", {}).catch(() => ({ ok: false })));
           Promise.allSettled(cancelTargets).then((results) => {
@@ -53761,6 +54592,22 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             Promise.resolve(value).then((result) => settle(resolve, result), (error) => settle(reject, error));
           });
         }
+        async function waitForCancelledNativeRun(runView) {
+          const pending = runView?.pendingNativeRun;
+          if (!pending) return true;
+          const CANCELLED_NATIVE_SETTLEMENT_TIMEOUT_MS = 2e4;
+          let timer;
+          try {
+            return await Promise.race([
+              pending.then(() => true, () => true),
+              new Promise((resolve) => {
+                timer = setTimeout(() => resolve(false), CANCELLED_NATIVE_SETTLEMENT_TIMEOUT_MS);
+              })
+            ]);
+          } finally {
+            clearTimeout(timer);
+          }
+        }
         function isRunCancellationError(error = {}) {
           return error.code === "codex_cancelled" || /cancelled by the user|was cancelled/i.test(error.message || "");
         }
@@ -53894,21 +54741,25 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             method: "codex.run",
             params
           }, compatibilityGate.compatibility));
-          if (currentRunView) {
-            currentRunView.nativeRequestId = tracked.id;
-            const record = findRunRecord(currentRunView.recordId, currentRunView.sessionId);
+          if (owner) {
+            owner.nativeRequestId = tracked.id;
+            owner.pendingNativeRun = tracked.promise;
+            const record = findRunRecord(owner.recordId, owner.sessionId);
             if (record) {
               record.nativeRequestId = tracked.id;
             }
             activeTurnControl.bind({
               requestId: tracked.id,
-              projectKey: currentRunView.runProjectId,
-              clientRunId: currentRunView.recordId,
-              sessionId: currentRunView.sessionId
+              projectKey: owner.runProjectId,
+              clientRunId: owner.recordId,
+              sessionId: owner.sessionId
             });
             saveStateSoon();
           }
           return tracked.promise.finally(() => {
+            if (owner?.pendingNativeRun === tracked.promise) {
+              owner.pendingNativeRun = null;
+            }
             if (currentRunView?.nativeRequestId === tracked.id) {
               currentRunView.activeTurn = null;
               renderPendingInputs();
@@ -54046,8 +54897,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             tx
           }).run(options);
         }
-        function appendRunCancelledReport() {
-          const hasQueuedFollowUp = (getActiveSession(state)?.pendingInputs || []).some((item) => item?.status === "queued");
+        function appendRunCancelledReport(writebackOutcome = {}, continueQueue = true) {
+          const hasQueuedFollowUp = continueQueue && (getActiveSession(state)?.pendingInputs || []).some((item) => item?.status === "queued");
           appendRunEvent({
             title: tx("Current Codex task was cancelled.", "\u5DF2\u4E2D\u65AD\u5F53\u524D Codex \u4EFB\u52A1\u3002"),
             status: "info",
@@ -54057,8 +54908,9 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             conclusionKey: "cancelled",
             conclusion: tx("This run was cancelled. It did not continue syncing or writing to Overleaf.", "\u8FD9\u8F6E\u5DF2\u4E2D\u65AD\uFF0C\u6CA1\u6709\u7EE7\u7EED\u540C\u6B65\u6216\u5199\u5165 Overleaf\u3002"),
             status: "cancelled",
-            operations: [],
-            applyResults: [],
+            operations: writebackOutcome.operations || [],
+            applyResults: writebackOutcome.applied ? [writebackOutcome.applied] : [],
+            saveVerification: writebackOutcome.saveVerification,
             nextStep: hasQueuedFollowUp ? tx("The first queued follow-up will start next.", "\u63A5\u4E0B\u6765\u4F1A\u81EA\u52A8\u542F\u52A8\u961F\u9996\u7684\u540E\u7EED\u4EFB\u52A1\u3002") : tx("Edit the task and run again.", "\u53EF\u4EE5\u4FEE\u6539\u4EFB\u52A1\u540E\u91CD\u65B0\u8FD0\u884C\u3002")
           });
         }
@@ -54077,11 +54929,13 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           }
           const hasInput = Boolean(String(panel?.querySelector("[data-task]")?.value || "").trim());
           const running = typeof runningOverride === "boolean" ? runningOverride : Boolean(currentRunView);
+          const runningInActiveSession = running && (!currentRunView || currentRunView.sessionId === state?.activeSessionId);
           const transitioning = sessionManager.isTransitioning();
-          const action = running && (!hasInput || transitioning) ? "cancel" : "send";
-          const label = action === "cancel" ? tr("cancelRun") : running ? tr("queueNextInput") : tr("send");
+          const action = runningInActiveSession && (!hasInput || transitioning) ? "cancel" : "send";
+          const attachmentsLoading = composerAttachmentController.hasPendingReads();
+          const label = action === "cancel" ? tr("cancelRun") : attachmentsLoading ? tr("attachmentsLoading") : running && hasInput ? tr("queueNextInput") : tr("send");
           runButton.dataset.action = action;
-          runButton.disabled = action === "cancel" ? runCancellationRequested : !hasInput || transitioning;
+          runButton.disabled = action === "cancel" ? runCancellationRequested : !hasInput || transitioning || attachmentsLoading;
           runButton.title = label;
           runButton.setAttribute("aria-label", label);
           if (currentRunView?.writebackRetry && hasInput && action !== "cancel") runButton.disabled = true;
@@ -54091,6 +54945,10 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             if (event.key === "Enter" && !event.isComposing && event.keyCode !== 229) event.preventDefault();
             return;
           }
+          if (composerAttachmentController.hasPendingReads() && event.key === "Enter" && !event.shiftKey && !event.isComposing && event.keyCode !== 229) {
+            event.preventDefault();
+            return;
+          }
           if (handleSlashMenuKeydown(event)) {
             return;
           }
@@ -54140,7 +54998,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             if (!isCodexOverleafSkillEnabled(id)) {
               continue;
             }
-            const title = String(skill?.title || skill?.name || id).trim().slice(0, 80) || id;
+            const title = id === "reviewer-response" ? tx("Reviewer response", "\u5BA1\u7A3F\u56DE\u590D") : String(skill?.title || skill?.name || id).trim().slice(0, 80) || id;
             commands.push({
               id: `skill:${id}`,
               kind: "codex-overleaf-skill",
@@ -54754,6 +55612,8 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           setState: (next) => {
             state = next;
           },
+          isDashboard: () => panel?.dataset.view === "recent-projects",
+          refreshDashboard: refreshDashboardSoon,
           // An in-flight Accept/Undo keeps its view until it settles; refresh applies afterwards.
           isBusy: () => Boolean(pendingDraftSave || readLiveRunViewForSaveStateGuard() || trackedChangeInFlight.size || runReviewController?.hasActiveReview?.() || document.querySelector("dialog[open]")),
           hasLocalDraft: (current) => Boolean(current.task) && composerDraftEditedHere,
@@ -55593,8 +56453,9 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             )
           };
         }
-        async function getRunProjectSnapshot() {
+        async function getRunProjectSnapshot(expectedProjectId = getCurrentProjectId()) {
           const project = await callPageBridge("getProjectSnapshot", {
+            projectId: expectedProjectId,
             force: true,
             maxAgeMs: 0,
             preferLightweight: true,
@@ -55606,11 +56467,12 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             zipTimeoutMs: RUN_SNAPSHOT_ZIP_TIMEOUT_MS,
             focusFiles: getActiveFocusFiles()
           });
-          const sanitizedProject = sanitizeRunProjectSnapshot(project);
+          const sanitizedProject = sanitizeRunProjectSnapshot(project, expectedProjectId);
           if (sanitizedProject?.capabilities?.fullProjectSnapshot || sanitizedProject?.capabilities?.pathIdentityComplete === false) {
             return sanitizedProject;
           }
           const pageStateProject = await callPageBridge("getProjectSnapshot", {
+            projectId: expectedProjectId,
             force: true,
             maxAgeMs: 0,
             preferLightweight: true,
@@ -55620,16 +56482,22 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             includeBinaryFiles: false,
             focusFiles: getActiveFocusFiles()
           });
-          const sanitizedPageStateProject = sanitizeRunProjectSnapshot(pageStateProject);
+          const sanitizedPageStateProject = sanitizeRunProjectSnapshot(pageStateProject, expectedProjectId);
           if (sanitizedPageStateProject?.capabilities?.fullProjectSnapshot) {
             return sanitizedPageStateProject;
           }
           return sanitizedProject;
         }
-        function sanitizeRunProjectSnapshot(project) {
+        function sanitizeRunProjectSnapshot(project, expectedProjectId = project?.id) {
           if (!project || typeof project !== "object") return project;
+          if (project.id !== expectedProjectId) return { ...project, files: [], capabilities: {
+            ...project.capabilities,
+            fullProjectSnapshot: false,
+            skipped: [{ path: "", reason: "document_identity_mismatch" }]
+          } };
           const normalize = Modules.ProjectFiles.normalizeSafeProjectPath;
-          const files = Array.isArray(project.files) ? project.files : [];
+          const files = Array.isArray(project.files) ? project.files.map((file) => file?.documentIdentity === void 0 ? file : { ...file, documentIdentity: snapshotDocumentIdentity(file.documentIdentity, file.path, project.id) }) : [];
+          project = { ...project, files };
           const counts = /* @__PURE__ */ new Map();
           for (const file of files) {
             const path = normalize(file?.path);
@@ -55669,12 +56537,16 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           };
         }
         async function getMirrorFreshness() {
+          const projectId = getCurrentProjectId(), accountScopeId = cachedAccountScopeId;
+          if (await writebackOrchestrator.refreshMirrorReuseFence(projectId, accountScopeId)) return null;
+          if (getCurrentProjectId() !== projectId || cachedAccountScopeId !== accountScopeId) return null;
           try {
             const response = await sendBackgroundNative({
               method: "mirror.status",
-              params: { projectId: getCurrentProjectId() }
+              params: { projectId }
             });
-            if (response?.ok) {
+            const fence = await writebackOrchestrator.refreshMirrorReuseFence(projectId, accountScopeId);
+            if (response?.ok && !fence && getCurrentProjectId() === projectId && cachedAccountScopeId === accountScopeId) {
               return response.result;
             }
           } catch (error) {
@@ -55702,7 +56574,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             return { useExistingMirror: false, reason: "missing_focus_overlay" };
           }
           const mirrorStatus = await getMirrorFreshness();
-          const mirrorHealth2 = Modules.MirrorHealth.classifyMirrorHealth(mirrorStatus);
+          const mirrorHealth2 = Modules.MirrorHealth.classifyMirrorHealth(mirrorStatus || {});
           if (!mirrorStatus?.exists || !mirrorHealth2.reusable) {
             return { useExistingMirror: false, reason: "mirror_not_fresh", mirrorStatus };
           }
@@ -55727,12 +56599,27 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           });
           const seen = /* @__PURE__ */ new Set();
           return candidates.filter(
-            (file) => typeof file.content === "string" && Modules.ProjectFiles.isUsableProjectFileContent(file.content) && file.path && !seen.has(file.path) && seen.add(file.path)
+            (file) => typeof file.content === "string" && (Modules.ProjectFiles.isUsableProjectFileContent(file.content) || file.content === "") && file.path && !seen.has(file.path) && seen.add(file.path)
           ).map((file) => ({
             path: file.path,
-            content: file.content
+            content: file.content,
+            kind: "text",
+            source: file.source,
+            ...file.documentIdentity !== void 0 ? { documentIdentity: snapshotDocumentIdentity(file.documentIdentity, file.path, project.id) } : {}
           }));
         }
+        function snapshotDocumentIdentity(identity, path, projectId) {
+          if (!identity || identity.version !== 1 || identity.source !== "cm-ranges-v1" || identity.path !== path || identity.projectId !== projectId || typeof identity.documentId !== "string" || !/^[a-f0-9]{24}$/.test(identity.documentId) || typeof identity.targetDocumentId !== "string" || !/^[a-f0-9]{24}$/.test(identity.targetDocumentId) || typeof identity.contentSha256 !== "string" || !/^[a-f0-9]{64}$/.test(identity.contentSha256)) return null;
+          return {
+            version: 1,
+            source: "cm-ranges-v1",
+            projectId,
+            path,
+            documentId: identity.documentId,
+            targetDocumentId: identity.targetDocumentId,
+            contentSha256: identity.contentSha256
+          };
+        }
         function normalizeSnapshotPath(path) {
           return Modules.ProjectFiles.normalizeSafeProjectPath(path);
         }
@@ -55954,10 +56841,15 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             if (!accountScopeId || isScopedPersistenceIdentityFailure(error)) {
               throw error;
             }
+            const fallbackProjectId = getCurrentProjectId();
+            const fallbackGeneration = spaRouteGeneration;
             const fallbackKey = buildScopedFallbackStorageKey(storageKey, accountScopeId);
             const stored = await chrome.storage.local.get([fallbackKey]);
             const fallback = stored[fallbackKey] || {};
             if (fallback?.__codexOverleafCompactFallback === true && fallback.__codexOverleafFallbackAccountScopeId === accountScopeId) {
+              if (accountScopeId === cachedAccountScopeId && fallbackProjectId === getCurrentProjectId() && fallbackGeneration === spaRouteGeneration) {
+                Modules.StorageMigration.adoptProjectPreferenceBaseline(fallback, accountScopeId, fallbackProjectId);
+              }
               return {
                 mode: fallback.mode || "",
                 providerId: fallback.providerId || "builtin",
@@ -56024,7 +56916,20 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             compactState.customInstructionsByProject = state.customInstructionsByProject;
             compactState.reviewingAvailabilityByProject = state.reviewingAvailabilityByProject;
             compactState.governanceRulesByProject = state.governanceRulesByProject;
+            const projectPreferenceBaseline = Migration.getProjectPreferenceBaseline(
+              options?.draftScope?.accountScopeId || cachedAccountScopeId,
+              projectId
+            );
             const stateSnapshot = typeof structuredClone === "function" ? structuredClone(state) : JSON.parse(JSON.stringify(state));
+            const projectPreferenceWrite = Migration.captureProjectPreferenceWrite({
+              state: stateSnapshot,
+              baseline: projectPreferenceBaseline,
+              accountScopeId: options?.draftScope?.accountScopeId || cachedAccountScopeId,
+              projectId,
+              normalizeExperimentalOtByProject,
+              normalizeGovernanceRulesByProject,
+              normalizeCustomInstructionsByProject
+            });
             const consumedSession = liveRunView?.draftConsumption && liveRunView.runProjectId === projectId && liveRunView.runAccountScopeId === cachedAccountScopeId ? stateSnapshot.sessions?.find((session) => session.id === liveRunView.sessionId) : null;
             if (consumedSession?.task === "") consumedSession.draftConsumption = { ...liveRunView.draftConsumption };
             const compactStateSnapshot = typeof structuredClone === "function" ? structuredClone(compactState) : JSON.parse(JSON.stringify(compactState));
@@ -56044,6 +56949,27 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                 normalizeExperimentalOtByProject,
                 normalizeGovernanceRulesByProject,
                 normalizeCustomInstructionsByProject,
+                projectPreferenceBaseline,
+                projectPreferenceWrite,
+                applyProjectPreferences: (prefs, captured, fields) => {
+                  if (retentionScope.accountScopeId !== cachedAccountScopeId || retentionScope.projectId !== getCurrentProjectId() || retentionScope.generation !== spaRouteGeneration) return false;
+                  const adopted = [];
+                  for (const field of fields) {
+                    if (JSON.stringify(state[field]?.[projectId]) !== JSON.stringify(captured[field]?.[projectId])) continue;
+                    if (JSON.stringify(state[field]?.[projectId]) === JSON.stringify(prefs[field]?.[projectId])) continue;
+                    state[field] = { ...state[field], ...prefs[field] };
+                    if (!Object.hasOwn(prefs[field] || {}, projectId)) delete state[field][projectId];
+                    adopted.push(field);
+                  }
+                  if (adopted.includes("customInstructionsByProject")) syncCustomInstructionsEditorForProject(projectId);
+                  if (adopted.includes("governanceRulesByProject")) syncProjectSettingsEditorForProject();
+                  if (adopted.includes("experimentalOtByProject")) syncExperimentalOtToggleForProject(projectId);
+                  if (adopted.includes("reviewingAvailabilityByProject")) {
+                    syncReviewingTooltip();
+                    syncProbeStatus();
+                  }
+                  return true;
+                },
                 persistenceContext
               });
               if (!options?.draftScope) {
@@ -56441,11 +57367,17 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           if (!composerDraftPersistence) composerDraftPersistence = Modules.ComposerAttachmentDraft.createController({
             getScope: () => ({ accountScopeId: cachedAccountScopeId, projectId: getCurrentProjectId() }),
             getAttachments: () => composerAttachmentController.serializePersistableAttachments(),
+            getOmittedAttachmentNames: () => composerAttachmentController.getOmittedAttachmentNames(),
             setAttachments: (value) => {
               state.composerAttachments = value;
+              syncComposerSendAvailability();
             },
             clear: () => composerAttachmentController.clear({ notify: false }),
             restore: (value) => composerAttachmentController.restorePersistedAttachments(value),
+            onRestoreOmittedAttachments: ({ count, names }) => appendPlainLog(tx(
+              `${count} attachment${count === 1 ? "" : "s"} could not be saved in the draft. Reattach before sending: ${names.join(", ")}.`,
+              `${count} \u4E2A\u9644\u4EF6\u672A\u80FD\u4FDD\u5B58\u5230\u8349\u7A3F\u4E2D\uFF0C\u8BF7\u5728\u53D1\u9001\u524D\u91CD\u65B0\u6DFB\u52A0\uFF1A${names.join("\u3001")}\u3002`
+            )),
             read: (scope) => Modules.StorageDb.readComposerAttachmentDraft(scope),
             write: (scope, value) => Modules.StorageDb.writeComposerAttachmentDraft(scope, value),
             scheduleSave: () => saveStateSoon()
@@ -56534,7 +57466,9 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           writingStyleSettings.sync();
           applyPanelTheme(getThemePreference());
           if ((state.providerId || "builtin") === "builtin" && !modelSelectHasOption(state.model)) {
-            renderModelOptions(getModelCatalog().FALLBACK_MODELS, state.model);
+            renderModelOptions(getModelCatalog().FALLBACK_MODELS, state.model, {
+              provisionalSelected: getModelDiscovery().provisional === true
+            });
           }
           panel.querySelector("[data-model]").value = state.model;
           const renderedModels = getRenderedModelEntries();
@@ -57444,11 +58378,13 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
           if (!record || record.forkSnapshot || !owner || owner.projectId !== getCurrentProjectId() || owner.accountScopeId !== cachedAccountScopeId || owner.sessionId !== session.id || owner.runId !== record.id || record.undoStatus === "applied" || record.trackedChangeStatus === "rejected") return;
           const originalStatus = record.status;
           const retryAutoRecompile = typeof record.executionSnapshot?.autoRecompile === "boolean" ? record.executionSnapshot.autoRecompile : void 0;
-          const live = () => findRunRecord(runId, session.id) || record;
+          const generation = spaRouteGeneration;
+          const isOwnerScope = () => generation === spaRouteGeneration && owner.projectId === getCurrentProjectId() && owner.accountScopeId === cachedAccountScopeId;
+          const live = () => isOwnerScope() && findRunRecord(runId, session.id) || record;
           let finished = false;
+          let retryOutcome = null;
           runCancellationRequested = false;
           runCancellationController = new AbortController();
-          const generation = spaRouteGeneration;
           const requestId = record.nativeRequestId || `writeback:${owner.sessionId}:${runId}`;
           const ownerToken = crypto.randomUUID();
           const retryView = {
@@ -57466,7 +58402,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             if (runCancellationRequested || currentRunView !== retryView) {
               throw Object.assign(new Error("Save checking was cancelled."), { code: "codex_cancelled" });
             }
-            if (generation !== spaRouteGeneration || owner.projectId !== getCurrentProjectId() || owner.accountScopeId !== cachedAccountScopeId) {
+            if (!isOwnerScope()) {
               throw Object.assign(new Error("The project or account changed."), { code: "aborted_project_changed" });
             }
           };
@@ -57492,6 +58428,10 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
               runProcess: root2?.querySelector("[data-run-process]"),
               processLabel: root2?.querySelector("[data-run-process-summary]")
             });
+            const pendingMirror = getPendingMirrorRefresh?.();
+            if (pendingMirror) await awaitRunStep(pendingMirror.catch(() => {
+            }));
+            assertOwner();
             if (intent?.requestId) {
               const receipt = await callPageBridge("getWritebackReceipt", { requestId: intent.requestId, runProjectId: owner.projectId });
               if (receipt?.state === "running") throw new Error(tx("The previous upload is still finishing. Try again shortly.", "\u4E0A\u4E00\u8F6E\u4E0A\u4F20\u4ECD\u5728\u6536\u5C3E\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002"));
@@ -57510,6 +58450,7 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
                   assistantMessage: tx("Retried the remaining file transfers for this task.", "\u5DF2\u91CD\u8BD5\u672C\u8F6E\u672A\u5B8C\u6210\u7684\u6587\u4EF6\u540C\u6B65\u3002")
                 }
               );
+              retryOutcome = result;
               assertOwner();
               if (result.settlement?.facts) live().settlement = WritebackSettlement.mergeRetrySettlement(live().settlement, result.settlement.facts);
               await finishRunView(
@@ -57533,6 +58474,17 @@ ${tx("Writeback note: Codex could not confirm any Overleaf write result entries,
             }
             await flushQueuedSaveState();
           } catch (error) {
+            const outcome = error.writebackOutcome || retryOutcome;
+            const current = findRunRecord(runId, session.id);
+            if (outcome && (runCancellationRequested || isRunCancellationError(error)) && currentRunView === retryView && isOwnerScope() && current && !current.forkSnapshot && current.runProjectId === owner.projectId) {
+              if (outcome.settlement?.facts) current.settlement = WritebackSettlement.mergeRetrySettlement(
+                current.settlement,
+                outcome.settlement.facts
+              );
+              appendRunCancelledReport(outcome, false);
+              await finishRunView(tx("Cancelled", "\u5DF2\u53D6\u6D88"), "cancelled");
+              finished = true;
+            }
             showPluginToast(error.message || String(error));
           } finally {
             if (currentRunView !== retryView) {