codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/shared/failureReasons.js

@@ -57,6 +57,11 @@
       fallbackUserMessage: 'Codex could not resolve the requested selection or context.',
       fallbackNextAction: 'Select the target again or specify the file/section explicitly.'
     },
+    selection_scope_violation: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'A generated change exceeded the attached selection and was blocked.',
+      fallbackNextAction: 'Select the intended region again and request only changes within it. Valid written parts can be undone.'
+    },
     base_file_missing_at_start: {
       stage: 'context', severity: 'error', defaultRetryable: true,
       fallbackUserMessage: 'A file needed for this task was missing during the initial project read.',
@@ -101,6 +106,26 @@
     },
 
     // 9.2 Preflight
+    sensitive_content_blocked: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'Sensitive content was found before sending, so Codex did not receive this request.',
+      fallbackNextAction: 'Remove the sensitive content, narrow @context, or enable explicit sensitive confirmation in Project Settings.'
+    },
+    governance_blocked: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'Project file rules blocked this write. Codex did not write the affected path.',
+      fallbackNextAction: 'Review the project file rules in Settings > Protection & privacy, then request changes within the allowed paths.'
+    },
+    governance_readonly: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'Project file rules marked a path in this operation read-only. Codex did not apply this operation.',
+      fallbackNextAction: 'Review the read-only paths in Settings > Protection & privacy, then request changes within the allowed paths.'
+    },
+    governance_writable_allowlist: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'A path in this operation is outside the configured writable paths. Codex did not apply this operation.',
+      fallbackNextAction: 'Review the writable paths in Settings > Protection & privacy, then request changes within those paths.'
+    },
     missing_base_file: {
       stage: 'preflight', severity: 'blocked', defaultRetryable: true,
       fallbackUserMessage: 'A write safety check needed a base file that is missing from the run snapshot.',
@@ -121,11 +146,26 @@
       fallbackUserMessage: 'The edit anchor matches multiple locations.',
       fallbackNextAction: 'Narrow the request or select a smaller region.'
     },
+    file_plan_confirmation_rejected: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The complete file plan was cancelled; no part was applied.',
+      fallbackNextAction: 'Review the intended changes and start a new run if you want to apply them.'
+    },
+    file_tree_controls_unavailable: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'Codex could not safely perform this file operation with the available Overleaf controls.',
+      fallbackNextAction: 'Check the file operation in Overleaf before starting a new task.'
+    },
     delete_confirmation_missing: {
       stage: 'preflight', severity: 'blocked', defaultRetryable: true,
       fallbackUserMessage: 'A destructive delete was not confirmed.',
       fallbackNextAction: 'Confirm the delete explicitly if intended.'
     },
+    delete_confirmation_rejected: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The deletion was cancelled and was not applied. Other allowed changes in this run may still proceed.',
+      fallbackNextAction: 'Review the other changes. If deletion is still intended, request it in a new task.'
+    },
     binary_write_blocked: {
       stage: 'preflight', severity: 'blocked', defaultRetryable: false,
       fallbackUserMessage: 'Codex tried to write unsupported binary content.',
@@ -197,6 +237,11 @@
     },
 
     // 9.4 Reviewing
+    reviewing_unavailable: {
+      stage: 'reviewing', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: "Track Changes is unavailable for this project. It depends on the project owner's Overleaf plan.",
+      fallbackNextAction: 'Turn off Track in the composer to write without tracked changes. Codex still records each change so you can undo it.'
+    },
     reviewing_state_unknown: {
       stage: 'reviewing', severity: 'blocked', defaultRetryable: true,
       fallbackUserMessage: 'Codex could not determine whether Reviewing/Track Changes is enabled.',
@@ -234,6 +279,21 @@
     },
 
     // 9.5 Undo
+    snapshot_undo_current_mismatch: {
+      stage: 'undo', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The current content or document identity does not match this run\'s undo checkpoint. Codex stopped Undo and kept the recovery data.',
+      fallbackNextAction: 'Inspect the file and any later edits before trying Undo again.'
+    },
+    snapshot_undo_open_failed: {
+      stage: 'undo', severity: 'blocked', defaultRetryable: true,
+      fallbackUserMessage: 'Codex could not open the file to restore its saved checkpoint.',
+      fallbackNextAction: 'Open the file in Overleaf, wait for it to load, then retry Undo.'
+    },
+    snapshot_undo_unavailable: {
+      stage: 'undo', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The saved checkpoint is unavailable for this Undo. Codex kept the remaining recovery data.',
+      fallbackNextAction: 'Inspect the file and the run details before continuing.'
+    },
     undo_preflight_content_drift: {
       stage: 'undo', severity: 'blocked', defaultRetryable: false,
       fallbackUserMessage: "Current content no longer matches this run's written content.",
@@ -303,6 +363,21 @@
       fallbackUserMessage: 'Native host version or capabilities do not match the extension.',
       fallbackNextAction: 'Update the native host.'
     },
+    codex_local_skill_unavailable: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: true,
+      fallbackUserMessage: 'The selected local Codex skill is unavailable or disabled. This run did not start.',
+      fallbackNextAction: 'Open Skills, select an available enabled skill, and submit again.'
+    },
+    codex_local_skills_failed: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: true,
+      fallbackUserMessage: 'Local Codex skills could not be loaded. This run did not start.',
+      fallbackNextAction: 'Open Skills to reload the local catalog, then submit again.'
+    },
+    codex_context_limit: {
+      stage: 'codex', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'This run stopped because the model context limit was exceeded.',
+      fallbackNextAction: 'Retry the task. If the context limit is reached again, use /compact or start a new conversation with less context.'
+    },
     codex_no_usable_result: {
       stage: 'codex', severity: 'error', defaultRetryable: true,
       fallbackUserMessage: 'Local Codex returned no usable final report or operations.',
@@ -445,6 +520,8 @@
    * @type {Record<string, string | ((result: any) => string)>}
    */
   const LEGACY_CODE_MAP = {
+    governance_blocked: result => result.reasonKey === 'readonly' ? 'governance_readonly'
+      : result.reasonKey === 'writable_allowlist' ? 'governance_writable_allowlist' : 'governance_blocked',
     path_not_found: 'target_file_not_found',
     file_open_failed: 'target_file_open_failed',
     editor_not_ready: 'target_editor_not_ready',
@@ -554,6 +631,7 @@
       nextAction: catalog.fallbackNextAction,
       evidence: {}
     };
+    if (canonicalCode === 'reviewing_unavailable') failure.changedDocument = false;
     if (legacyReason) {
       failure.technicalMessage = legacyReason;
     }
@@ -580,6 +658,262 @@
     return out;
   }
 
+  // Display projection only: these aliases and exact historical templates do
+  // not enter the canonical catalog, persistence, retry or recovery decisions.
+  const REVIEW_DISPLAY_CODES = new Set([
+    'missing_tracked_changes', 'tracked_change_file_open_failed', 'tracked_change_reject_control_not_found',
+    'tracked_change_reject_not_confirmed', 'tracked_change_accept_control_not_found', 'tracked_change_accept_not_confirmed',
+    'tracked_change_editor_undo_open_failed', 'tracked_change_editor_undo_current_mismatch', 'editor_undo_control_not_found',
+    'editor_undo_no_progress', 'editor_undo_max_iterations', 'tracked_change_undo_max_iterations',
+    'tracked_change_undo_verify_open_failed', 'tracked_change_undo_verify_failed', 'accept_missing_run_content',
+    'accept_editor_undo_unavailable', 'accept_editing_not_confirmed', 'accept_editing_not_stable',
+    'accept_replay_rollback_missing_content', 'review_scope_unavailable', 'review_request_unverified',
+    'review_owner_disconnected', 'review_deadline_exceeded', 'review_cancelled',
+    'review_project_changed', 'tracked_change_not_found', 'snapshot_undo_current_mismatch',
+    'snapshot_undo_open_failed', 'snapshot_undo_unavailable', 'file_tree_controls_unavailable',
+    'native_untracked_undo_pending_changes'
+  ]);
+  const REVIEW_DISPLAY_TEMPLATES = [
+    ['governance_readonly', 'Project governance marked this path read-only, so Codex did not write it.'],
+    ['governance_readonly', '项目治理规则将此路径标记为只读，因此 Codex 没有写入。'],
+    ['governance_readonly', '项目文件规则将此操作涉及的路径标记为只读。Codex 未执行此操作。'],
+    ['governance_writable_allowlist', 'Project governance allows writes only to configured writable patterns, and this path is outside that allowlist.'],
+    ['governance_writable_allowlist', '项目治理规则只允许写入配置的可写路径，此路径不在允许范围内。'],
+    ['governance_writable_allowlist', '此操作涉及的路径不在配置的可写路径范围内。Codex 未执行此操作。'],
+    ['governance_blocked', 'Project governance blocked this write.'],
+    ['governance_blocked', '项目治理规则阻止了此写入。'],
+    ['governance_blocked', '项目文件规则阻止了此次写入。Codex 未写入受影响的路径。'],
+    ["missing_tracked_changes", "这轮写入没有可识别的 Overleaf 留痕记录；为避免制造新的红线，Codex 没有执行文本补丁撤销。"],
+    ["missing_tracked_changes", "No matching Overleaf tracked-change records were found for this run, so Codex did not undo with text patches."],
+    ["missing_tracked_changes", "No matching Overleaf tracked-change records were found for this run. Codex did not undo with text patches."],
+    ["missing_tracked_changes", "这轮写入没有可识别的 Overleaf 留痕记录；Codex 没有执行文本补丁撤销。"],
+    ["tracked_change_file_open_failed", "无法打开 {file} 来查找这轮写入的留痕记录；Codex 没有用文本补丁伪撤销。"],
+    ["tracked_change_file_open_failed", "无法打开 {file} 来继续拒绝这轮留痕记录；请在 Overleaf 审阅面板手动处理。"],
+    ["tracked_change_file_open_failed", "Could not open {file} to find this run's tracked changes. Handle them manually in the Overleaf review tools."],
+    ["tracked_change_file_open_failed", "Could not open the file to find this run's tracked changes. Handle them manually in the Overleaf review tools."],
+    ["tracked_change_file_open_failed", "Could not open the file to find this run's tracked changes. Check it in the Overleaf review panel."],
+    ["tracked_change_file_open_failed", "无法打开文件来查找这轮写入的留痕记录；请在 Overleaf 审阅面板检查。"],
+    ["tracked_change_reject_control_not_found", "找到了这轮写入的留痕记录，但没有找到对应的 Reject/拒绝按钮；Codex 没有用文本补丁伪撤销。"],
+    ["tracked_change_reject_control_not_found", "还有 {file} 的留痕记录未处理，但没有找到对应的 Reject/拒绝按钮；请在 Overleaf 审阅面板手动拒绝。"],
+    ["tracked_change_reject_control_not_found", "Some tracked changes in {file} remain, but the matching Reject button was not found. Reject them manually in Overleaf."],
+    ["tracked_change_reject_control_not_found", "Some tracked changes remain, but the matching Reject button was not found. Reject them manually in Overleaf."],
+    ["tracked_change_reject_control_not_found", "Some tracked changes remain, but the matching Reject button was not found. Check them in the Overleaf review panel."],
+    ["tracked_change_reject_control_not_found", "仍有留痕记录未处理，但未找到对应的拒绝按钮；请在 Overleaf 审阅面板检查。"],
+    ["tracked_change_reject_not_confirmed", "Codex 点击了 Reject/拒绝，但 Overleaf 页面仍显示这条留痕记录；请在 Overleaf 审阅面板手动拒绝。"],
+    ["tracked_change_reject_not_confirmed", "Codex clicked Reject, but Overleaf still shows this tracked change. Reject it manually in the Overleaf review panel."],
+    ["tracked_change_reject_not_confirmed", "Codex clicked Reject, but Overleaf still shows this tracked change. Check it in the Overleaf review panel."],
+    ["tracked_change_reject_not_confirmed", "Codex 已点击拒绝，但 Overleaf 仍显示该留痕记录；请在审阅面板检查。"],
+    ["tracked_change_accept_control_not_found", "Some tracked changes in {file} remain, but the matching Accept button was not found. Accept them manually in Overleaf."],
+    ["tracked_change_accept_control_not_found", "Some tracked changes remain, but the matching Accept button was not found. Accept them manually in Overleaf."],
+    ["tracked_change_accept_control_not_found", "Some tracked changes remain, but the matching Accept button was not found. Check them in the Overleaf review panel."],
+    ["tracked_change_accept_control_not_found", "仍有留痕记录未处理，但未找到对应的接受按钮；请在 Overleaf 审阅面板检查。"],
+    ["tracked_change_accept_not_confirmed", "Codex clicked Accept, but Overleaf still shows this tracked change. Accept it manually in the Overleaf review panel."],
+    ["tracked_change_accept_not_confirmed", "Codex clicked Accept, but Overleaf still shows this tracked change. Check it in the Overleaf review panel."],
+    ["tracked_change_accept_not_confirmed", "Codex 已点击接受，但 Overleaf 仍显示该留痕记录；请在审阅面板检查。"],
+    ["tracked_change_editor_undo_open_failed", "无法打开 {file} 来执行 Overleaf 原生撤销。"],
+    ["tracked_change_editor_undo_open_failed", "Could not open {file} for Overleaf native undo."],
+    ["tracked_change_editor_undo_open_failed", "Could not open the file for Overleaf native undo."],
+    ["tracked_change_editor_undo_open_failed", "Could not open the file for Overleaf native Undo."],
+    ["tracked_change_editor_undo_open_failed", "无法打开文件来执行 Overleaf 原生撤销。"],
+    ["tracked_change_editor_undo_current_mismatch", "{file} 当前内容已经不是本轮写入后的内容；为避免撤掉你的后续修改，Codex 不使用 Overleaf 原生撤销。"],
+    ["tracked_change_editor_undo_current_mismatch", "{file} no longer matches this run's written content, so Codex did not use Overleaf native undo."],
+    ["tracked_change_editor_undo_current_mismatch", "The current content no longer matches this run's written content, so Codex did not use Overleaf native undo."],
+    ["tracked_change_editor_undo_current_mismatch", "The current content no longer matches this run's written content. Codex stopped native Undo to preserve later edits."],
+    ["tracked_change_editor_undo_current_mismatch", "当前内容与本轮写入后的内容不一致；Codex 已停止原生撤销，以保留后续编辑。"],
+    ["editor_undo_control_not_found", "没有找到 Overleaf 编辑器自己的 Undo/撤销按钮，无法一次性撤销 {file} 的本轮留痕。"],
+    ["editor_undo_control_not_found", "Could not find Overleaf's editor Undo button to undo this run in {file}."],
+    ["editor_undo_control_not_found", "Could not find Overleaf's editor Undo button to undo this run."],
+    ["editor_undo_control_not_found", "未找到 Overleaf 编辑器的撤销按钮，无法撤销本轮改动。"],
+    ["editor_undo_no_progress", "Codex 点击了 Overleaf Undo/撤销，但 {file} 内容没有变化。"],
+    ["editor_undo_no_progress", "Codex clicked Overleaf Undo, but {file} did not change."],
+    ["editor_undo_no_progress", "Codex clicked Overleaf Undo, but the file did not change."],
+    ["editor_undo_no_progress", "Codex 已点击 Overleaf 撤销，但文件内容没有变化。"],
+    ["editor_undo_max_iterations", "{file} 经过多次 Overleaf 原生撤销后仍未回到本轮写入前内容，已停止以避免撤销其它修改。"],
+    ["editor_undo_max_iterations", "{file} did not return to its pre-run content after repeated Overleaf native undo steps. Codex stopped to avoid undoing other edits."],
+    ["editor_undo_max_iterations", "The file did not return to its pre-run content after repeated Overleaf native undo steps. Codex stopped to avoid undoing other edits."],
+    ["editor_undo_max_iterations", "The file did not return to its pre-run content after repeated native Undo steps. Codex stopped to avoid undoing other edits."],
+    ["editor_undo_max_iterations", "经过多次原生撤销后，文件仍未恢复到本轮写入前的内容；Codex 已停止，以免撤销其他编辑。"],
+    ["tracked_change_undo_max_iterations", "{file} 仍有未完成的留痕记录；Codex 已停止以避免误拒绝其它改动。"],
+    ["tracked_change_undo_max_iterations", "{file} still has tracked changes after the reject sweep, so Codex stopped to avoid mis-rejecting other edits."],
+    ["tracked_change_undo_max_iterations", "{file} still has tracked changes after the per-expected-file reject sweep, so Codex stopped to avoid mis-rejecting other edits."],
+    ["tracked_change_undo_max_iterations", "{file} still has tracked changes left. Codex stopped to avoid rejecting unrelated edits."],
+    ["tracked_change_undo_max_iterations", "Tracked changes are still left. Codex stopped to avoid rejecting unrelated edits."],
+    ["tracked_change_undo_max_iterations", "仍有未处理的留痕记录；Codex 已停止，以免误拒绝其他编辑。"],
+    ["tracked_change_undo_verify_open_failed", "撤销后无法打开 {file} 验证内容；请刷新 Overleaf 后检查。"],
+    ["tracked_change_undo_verify_open_failed", "Could not open {file} after undo to verify content. Reload Overleaf and check manually."],
+    ["tracked_change_undo_verify_open_failed", "Could not open the file after undo to verify content. Reload Overleaf and check manually."],
+    ["tracked_change_undo_verify_open_failed", "Could not open the file after Undo to verify its content. Reload Overleaf and check it."],
+    ["tracked_change_undo_verify_open_failed", "撤销后无法打开文件验证内容；请刷新 Overleaf 后检查。"],
+    ["tracked_change_undo_verify_failed", "{file} 拒绝留痕后内容没有回到写入前状态；请在 Overleaf 审阅面板检查这轮修改。"],
+    ["tracked_change_undo_verify_failed", "{file} did not return to its pre-run content after rejecting tracked changes. Check this run's changes in the Overleaf review panel."],
+    ["tracked_change_undo_verify_failed", "The file did not return to its pre-run content after rejecting tracked changes. Check this run's changes in the Overleaf review panel."],
+    ["tracked_change_undo_verify_failed", "拒绝留痕后，文件内容仍未恢复到写入前状态；请在 Overleaf 审阅面板检查本轮修改。"],
+    ["accept_missing_run_content", "这轮写入没有可识别的写入前/写入后内容；Codex 没有把留痕改动接受为永久文本。"],
+    ["accept_missing_run_content", "{file} 缺少写入前/写入后内容；Codex 没有重放本轮改动。"],
+    ["accept_missing_run_content", "The pre-write or post-write content is unavailable. Codex did not replay or accept the tracked changes."],
+    ["accept_missing_run_content", "缺少写入前或写入后的内容；Codex 未重放或接受留痕改动。"],
+    ["accept_editor_undo_unavailable", "没有可执行的 Overleaf 原生撤销或安全快照回滚来清掉本轮留痕；Codex 没有接受这轮改动。"],
+    ["accept_editor_undo_unavailable", "Native Undo and a safe checkpoint rollback are unavailable. Codex did not accept this run."],
+    ["accept_editor_undo_unavailable", "原生撤销及安全的检查点回滚均不可用；Codex 未接受本轮改动。"],
+    ["accept_editing_not_confirmed", "无法确认 Overleaf 已切换到 Editing 模式；Codex 没有把本轮改动重写为永久文本。"],
+    ["accept_editing_not_confirmed", "切换后仍未能确认 Overleaf 处于 Editing 模式；为避免重写又留下留痕，Codex 没有重放本轮改动。"],
+    ["accept_editing_not_confirmed", "本次操作前未能确认 Overleaf 处于 Editing 模式；为避免重写又留下留痕，Codex 没有继续重放本轮剩余改动。"],
+    ["accept_editing_not_confirmed", "Codex could not re-confirm Editing mode before replaying {file}; Codex stopped to avoid landing a tracked write."],
+    ["accept_editing_not_confirmed", "Codex could not confirm Editing mode for the untracked Accept replay, so the run was not finalized."],
+    ["accept_editing_not_confirmed", "Codex could not switch Overleaf to Editing mode for the untracked Accept replay, so the run was not finalized."],
+    ["accept_editing_not_confirmed", "Codex toggled Overleaf to Editing, but the post-toggle state did not positively confirm Editing — Codex did not replay the run."],
+    ["accept_editing_not_confirmed", "Codex could not confirm Overleaf Editing mode. It stopped replaying this run to avoid creating new tracked changes."],
+    ["accept_editing_not_confirmed", "无法确认 Overleaf 已进入编辑模式；Codex 已停止重放本轮改动，以免产生新的留痕。"],
+    ["accept_editing_not_stable", "Overleaf Editing mode did not remain stable long enough for an untracked Accept All replay; Codex did not replay this write."],
+    ["accept_editing_not_stable", "Overleaf Editing mode did not remain stable long enough for an untracked Accept replay. Codex did not replay this write."],
+    ["accept_editing_not_stable", "Overleaf 编辑模式未保持稳定，无法无留痕地重放接受的改动；Codex 未重放此次写入。"],
+    ["accept_replay_rollback_missing_content", "Accept All detected fresh tracked changes, but could not roll back because the pre/post content was unavailable."],
+    ["accept_replay_rollback_missing_content", "Accept created fresh tracked changes, but rollback could not run because the pre-write or post-write content was unavailable."],
+    ["accept_replay_rollback_missing_content", "接受改动时产生了新的留痕，但缺少写入前或写入后的内容，无法回滚。"],
+    ["review_scope_unavailable", "The native tracked-change scope could not be safely isolated. No review mutation was attempted. Use Overleaf Review to handle the changes individually."],
+    ["review_scope_unavailable", "The native tracked-change scope could not be safely isolated. No review mutation was attempted. Check the changes individually in Overleaf Review."],
+    ["review_scope_unavailable", "无法安全确认本轮原生留痕的范围；尚未尝试审阅写入。请在 Overleaf 审阅面板逐项检查。"],
+    ["review_request_unverified", "The native review request could not be fully verified; some target changes may already be accepted. No text replay was attempted. Check Overleaf Review before retrying."],
+    ["review_request_unverified", "原生审阅请求未能完全核实，部分目标改动可能已接受；未尝试文本重放。请先在 Overleaf 审阅面板检查，再决定是否重试。"],
+    ["review_owner_disconnected", "The Undo owner disconnected; no further review writes were started."],
+    ["review_owner_disconnected", "撤销操作的连接已断开；未再启动后续审阅写入。"],
+    ["review_deadline_exceeded", "The review time budget expired; no further review writes were started."],
+    ["review_deadline_exceeded", "The review time budget expired."],
+    ["review_deadline_exceeded", "审阅操作已超时；未再启动后续审阅写入。"],
+    ["review_cancelled", "The review was cancelled; no further review writes were started."],
+    ["review_cancelled", "审阅操作已取消；未再启动后续审阅写入。"],
+    ["review_project_changed", "The original review project is no longer active."],
+    ["review_project_changed", "原审阅项目已不再处于活动状态。"],
+    ["tracked_change_not_found", "没有在 Overleaf 页面里找到这轮写入对应的留痕记录；Codex 没有用文本补丁伪撤销。"],
+    ["tracked_change_not_found", "No matching tracked changes were found on the Overleaf page for this run."],
+    ["tracked_change_not_found", "No matching tracked changes were found on the Overleaf page for this run. Codex did not undo with text patches."],
+    ["snapshot_undo_current_mismatch", "{file} 当前内容或文档身份与本轮撤销检查点不一致；Codex 保留恢复材料并停止撤销。"],
+    ["snapshot_undo_current_mismatch", "{file} 当前内容已经不是本轮写入后的内容；为避免覆盖你的后续修改，Codex 不执行快照撤销。"],
+    ["snapshot_undo_current_mismatch", "The current content or document identity does not match this run's undo checkpoint. Codex stopped Undo and kept the recovery data."],
+    ["snapshot_undo_current_mismatch", "当前内容或文档身份与本轮撤销检查点不一致；Codex 已停止撤销并保留恢复材料。"],
+    ["snapshot_undo_open_failed", "无法打开 {file} 来执行快照撤销。"],
+    ["snapshot_undo_open_failed", "Codex could not open the file to restore its saved checkpoint."],
+    ["snapshot_undo_open_failed", "Codex 无法打开文件来恢复已保存的检查点。"],
+    ["snapshot_undo_unavailable", "The saved checkpoint is unavailable for this undo."],
+    ["snapshot_undo_unavailable", "The saved checkpoint is unavailable for this Undo. Codex kept the remaining recovery data."],
+    ["snapshot_undo_unavailable", "本次撤销所需的检查点不可用；Codex 已保留剩余恢复材料。"]
+  ].sort((a, b) => Number(a[1].includes('{file}')) - Number(b[1].includes('{file}')))
+    .map(([code, template]) => ({ code, template,
+      pattern: new RegExp('^' + template.split('{file}').map(part => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('(.+)') + '$') }));
+
+  function safeDisplayProjectPath(value) {
+    if (typeof value !== 'string' || !value || value.length > 300 || /[\r\n]/.test(value)) return '';
+    const path = value.replace(/\\/g, '/');
+    return !path.startsWith('/') && !/^[A-Za-z]:/.test(path) && !path.split('/').includes('..') ? path : '';
+  }
+
+  function isContextLimitError(message, code) {
+    const text = String(message || '');
+    return ['codex_context_limit', 'context_length_exceeded', 'context_window_exceeded'].includes(code)
+      || /\b(?:codex_context_limit|context_length_exceeded|context_window_exceeded)\b/i.test(text)
+      || /Codex ran out of room in the model['’]s context window/i.test(text)
+      || /maximum context length is \d+ tokens[\s\S]*?(?:you requested|resulted in) \d+ tokens/i.test(text);
+  }
+
+  function recoverDisplayFailure(failure, allowFilePrefix = true) {
+    if (!failure || typeof failure !== 'object') return failure;
+    if (failure.code === 'codex_no_usable_result' && failure.stage === 'codex'
+      && isContextLimitError(failure.technicalMessage)) return { ...failure, code: 'codex_context_limit',
+        userMessage: FAILURE_CODE_CATALOG.codex_context_limit.fallbackUserMessage,
+        nextAction: FAILURE_CODE_CATALOG.codex_context_limit.fallbackNextAction };
+    const originalCode = failure.evidence?.originalCode;
+    const displayCodeAllowed = code => REVIEW_DISPLAY_CODES.has(code)
+      && (code !== 'native_untracked_undo_pending_changes'
+        || (failure.changedDocument !== true && failure.mayHaveMutated !== true && failure.evidence?.writeStarted !== true));
+    const explicitCode = displayCodeAllowed(originalCode) ? originalCode
+      : displayCodeAllowed(failure.code) ? failure.code : '';
+    const message = String(failure.userMessage || '');
+    for (const { code, pattern } of REVIEW_DISPLAY_TEMPLATES) {
+      if (explicitCode && code !== explicitCode) continue;
+      const match = pattern.exec(message);
+      if (!match) continue;
+      const captured = ['当前文件', 'The target file', 'the next file'].includes(match[1]) ? '' : match[1];
+      if (captured && safeDisplayProjectPath(captured) !== captured) continue;
+      return { ...failure, code, file: failure.file || captured || '' };
+    }
+    // Catalog defaults are also product-owned exact messages in older compact
+    // records. Recover only a display code; their old retry semantics stay put.
+    const catalogCode = Object.keys(FAILURE_CODE_CATALOG).find(code => code !== 'unknown_legacy_failure'
+      && FAILURE_CODE_CATALOG[code].fallbackUserMessage === message);
+    if (!explicitCode && catalogCode) return { ...failure, code: catalogCode };
+    // Earlier formatters persisted "file: message". Only accept one safe file
+    // prefix whose complete remaining body resolves to a known product message.
+    const prefixed = allowFilePrefix && /^([^:\r\n]+): (.+)$/.exec(message);
+    if (prefixed && safeDisplayProjectPath(prefixed[1]) === prefixed[1]) {
+      const body = { ...failure, userMessage: prefixed[2], file: failure.file || prefixed[1] };
+      const recovered = recoverDisplayFailure(body, false);
+      if (recovered !== body && recovered.code !== 'unknown_legacy_failure') return recovered;
+    }
+    return explicitCode ? { ...failure, code: explicitCode } : failure;
+  }
+
+  // A single renderer prevents the Notice and expanded results from using
+  // different code lists or emitting a dynamic filename twice.
+  function formatFailureReasonForDisplay(failure, locale, i18nLookup) {
+    const display = recoverDisplayFailure(failure);
+    const lookup = typeof i18nLookup === 'function' ? i18nLookup : () => undefined;
+    const messageCode = getFailureMessageCode(display);
+    const key = messageCode ? 'failureReason_' + messageCode + '_user' : '';
+    const template = key ? lookup(key) : '';
+    const file = safeDisplayProjectPath(display?.file);
+    const localized = localizeFailureReason(display ? { ...display, file } : display, locale, lookup);
+    const message = template?.includes('{file}') ? localized.userMessage
+      : [file, localized.userMessage].filter(Boolean).join(': ');
+    return { ...localized, code: display?.code, message, file, localized: Boolean(template && template !== key) };
+  }
+
+  function getFailureMessageCode(failure) {
+    // Reload recovery retains its historical retry code. Only its presentation
+    // identifies the page interruption instead of a failed bridge request.
+    if (failure?.code === 'native_request_failed' && failure.source === 'panel_reload') {
+      return 'panel_reload_interrupted';
+    }
+    return typeof failure?.code === 'string' ? failure.code : '';
+  }
+
+  function localizeFailureMessage(message, locale, i18nLookup) {
+    return formatFailureReasonForDisplay({ code: 'unknown_legacy_failure', userMessage: message }, locale, i18nLookup).message;
+  }
+
+  // Writeback consumers share catalog normalization, including file context,
+  // while retaining the mutation evidence carried by older result envelopes.
+  function normalizeWritebackFailure(result, operation) {
+    if (!result || typeof result !== 'object' || (!result.failure && !result.code && result.ok !== false)) return null;
+    const failure = normalizeFailureReason(result, operation);
+    const explicit = result.failure && typeof result.failure === 'object' ? result.failure : {};
+    const changedDocument = typeof explicit.changedDocument === 'boolean' ? explicit.changedDocument : result.changedDocument;
+    if (typeof changedDocument === 'boolean') failure.changedDocument = changedDocument;
+    if (explicit.mayHaveMutated === true || result.mayHaveMutated === true) failure.mayHaveMutated = true;
+    const terminalState = explicit.terminalState || result.terminalState;
+    if (ALLOWED_SEVERITY_PER_TERMINAL[terminalState]?.has(failure.severity)) failure.terminalState = terminalState;
+    // An unrecognized transport code can still carry a valid write-stage hint.
+    if (failure.code === 'unknown_legacy_failure') {
+      const stage = explicit.stage || result.stage;
+      if (FAILURE_STAGES.has(stage)) failure.stage = stage;
+    }
+    return failure;
+  }
+
+  function isUnconfirmedWriteFailure(failure) {
+    if (!failure || typeof failure !== 'object') return false;
+    return failure.terminalState === 'needs_review' || failure.mayHaveMutated === true
+      || ['write_timeout', 'partial_write_needs_review', 'writeback_result_unconfirmed', 'write_result_missing'].includes(failure.code)
+      || (failure.changedDocument === true && ['write', 'verify', 'undo', 'accept'].includes(failure.stage));
+  }
+
+  // A potentially changed document needs review before unrelated blockers can
+  // offer a retry. Keep the generic severity/stage order within each group.
+  function selectPrimaryWritebackFailure(failures) {
+    if (!Array.isArray(failures)) return null;
+    const review = failures.filter(isUnconfirmedWriteFailure);
+    return selectPrimaryFailure(review.length ? review : failures);
+  }
+
   function buildFallbackFailureReason(code, op) {
     const catalog = FAILURE_CODE_CATALOG[code] || FAILURE_CODE_CATALOG.unknown_legacy_failure;
     return augmentWithOperation({
@@ -648,10 +982,15 @@
    */
   function localizeFailureReason(failure, locale, i18nLookup) {
     void locale;
-    const lookup = i18nLookup instanceof Function ? i18nLookup : function noopLookup() { return undefined; };
-    const code = failure && typeof failure.code === 'string' ? failure.code : '';
+    failure = recoverDisplayFailure(failure);
+    const lookup = key => {
+      const value = typeof i18nLookup === 'function' ? i18nLookup(key) : undefined;
+      return value && value !== key ? value : undefined;
+    };
+    const code = getFailureMessageCode(failure);
     const userTemplate = code ? lookup('failureReason_' + code + '_user') : undefined;
-    const nextTemplate = code ? lookup('failureReason_' + code + '_next') : undefined;
+    const nextTemplate = (code ? lookup('failureReason_' + code + '_next') : undefined)
+      || (REVIEW_DISPLAY_CODES.has(code) ? lookup('failureReason_review_detail_next') : undefined);
     const userMessage = userTemplate
       ? interpolateFailureTemplate(userTemplate, failure)
       : (failure && failure.userMessage) || '';
@@ -682,7 +1021,13 @@
     STAGE_TIE_BREAKER_ORDER,
     validateFailureReason,
     normalizeFailureReason,
+    normalizeWritebackFailure,
+    isUnconfirmedWriteFailure,
+    selectPrimaryWritebackFailure,
     selectPrimaryFailure,
-    localizeFailureReason
+    localizeFailureReason,
+    formatFailureReasonForDisplay,
+    localizeFailureMessage,
+    isContextLimitError
   };
 });

package/extension/src/shared/globalPreferences.js

@@ -11,17 +11,29 @@
   const PATCH_MESSAGE = 'codex-overleaf/global-preferences/patch';
   const DEFAULTS = Object.freeze({ theme: 'dark', locale: 'en', preloadProjectContext: true,
     loadCodexLocalSkills: true, loadCodexOverleafSkills: true });
-  const FIELDS = Object.freeze([...Object.keys(DEFAULTS), 'codexOverleafSkillEnabled']);
+  const SKILL_MAP_FIELDS = Object.freeze(['codexOverleafSkillEnabled', 'codexLocalSkillEnabled']);
+  const FIELDS = Object.freeze([...Object.keys(DEFAULTS), ...SKILL_MAP_FIELDS]);
+  const MAX_SKILL_PREFERENCES = 200;
 
   function validSkillId(id) {
     return /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(id)
       && !['__proto__', 'prototype', 'constructor'].includes(id) && !id.includes('..');
   }
 
+  function normalizeSkillEnabledMap(value) {
+    const result = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return result;
+    for (const [id, enabled] of Object.entries(value)) {
+      if (validSkillId(id) && typeof enabled === 'boolean') result[id] = enabled;
+    }
+    if (Object.keys(result).length > MAX_SKILL_PREFERENCES) throw new Error('Too many skill preferences.');
+    return result;
+  }
+
   function pick(value = {}) {
-    const skills = {};
-    for (const [id, enabled] of Object.entries(value.codexOverleafSkillEnabled || {}).slice(0, 200)) {
-      if (validSkillId(id) && typeof enabled === 'boolean') skills[id] = enabled;
+    const overleafSkills = {};
+    for (const [id, enabled] of Object.entries(value.codexOverleafSkillEnabled || {}).slice(0, MAX_SKILL_PREFERENCES)) {
+      if (validSkillId(id) && typeof enabled === 'boolean') overleafSkills[id] = enabled;
     }
     return {
       theme: ['dark', 'light', 'auto'].includes(value.theme) ? value.theme : 'dark',
@@ -29,7 +41,8 @@
       preloadProjectContext: value.preloadProjectContext !== false,
       loadCodexLocalSkills: value.loadCodexLocalSkills !== false,
       loadCodexOverleafSkills: value.loadCodexOverleafSkills !== false,
-      codexOverleafSkillEnabled: skills
+      codexOverleafSkillEnabled: overleafSkills,
+      codexLocalSkillEnabled: normalizeSkillEnabledMap(value.codexLocalSkillEnabled)
     };
   }
 
@@ -43,8 +56,8 @@
         || typeof DEFAULTS[key] === 'boolean' && typeof item !== 'boolean') {
         throw new Error('Invalid global preference: ' + key);
       }
-      if (key === 'codexOverleafSkillEnabled') {
-        if (!item || typeof item !== 'object' || Array.isArray(item) || Object.keys(item).length > 200) {
+      if (SKILL_MAP_FIELDS.includes(key)) {
+        if (!item || typeof item !== 'object' || Array.isArray(item) || Object.keys(item).length > MAX_SKILL_PREFERENCES) {
           throw new Error('Invalid skill preference map.');
         }
         for (const [id, enabled] of Object.entries(item)) {
@@ -57,9 +70,12 @@
   }
 
   function applyPatch(values, patch) {
-    return { ...pick(values), ...patch, codexOverleafSkillEnabled: {
-      ...pick(values).codexOverleafSkillEnabled, ...(patch.codexOverleafSkillEnabled || {})
-    } };
+    const previous = pick(values);
+    const result = { ...previous, ...patch };
+    for (const field of SKILL_MAP_FIELDS) {
+      result[field] = normalizeSkillEnabledMap({ ...previous[field], ...(patch[field] || {}) });
+    }
+    return result;
   }
 
   function changedKeys(left, right) {
@@ -71,7 +87,9 @@
       throw new Error('Invalid global preference revision.');
     }
     validatePatch(value.values);
-    if (!FIELDS.every(key => Object.hasOwn(value.values, key))) throw new Error('Incomplete global preferences.');
+    // The local-skill map was added within v1; existing complete v1 snapshots
+    // inherit their source defaults until an explicit preference is saved.
+    if (!FIELDS.filter(key => key !== 'codexLocalSkillEnabled').every(key => Object.hasOwn(value.values, key))) throw new Error('Incomplete global preferences.');
     return { schemaVersion: 1, revision: value.revision, values: pick(value.values) };
   }
 
@@ -95,7 +113,6 @@
         const patch = validatePatch(input);
         const previous = await read();
         const values = applyPatch(previous.values, patch);
-        if (Object.keys(values.codexOverleafSkillEnabled).length > 200) throw new Error('Too many skill preferences.');
         if (!changedKeys(previous.values, values).length) return previous;
         const snapshot = { schemaVersion: 1, revision: previous.revision + 1, values };
         await storage.set({ [STORAGE_KEY]: snapshot });
@@ -127,5 +144,5 @@
   }
 
   return Object.freeze({ STORAGE_KEY, LEGACY_KEY, READ_MESSAGE, PATCH_MESSAGE, FIELDS,
-    pick, validatePatch, validateSnapshot, applyPatch, changedKeys, createStore, installBackground });
+    normalizeSkillEnabledMap, pick, validatePatch, validateSnapshot, applyPatch, changedKeys, createStore, installBackground });
 });

package/extension/src/shared/governanceRules.js

@@ -203,43 +203,10 @@
   }
 
   function normalizeSafeProjectPathFallback(value) {
-    if (typeof value !== 'string' || /[\u0000-\u001f\u007f]/.test(value)) {
-      return '';
-    }
-    const trimmed = value.trim();
-    if (!trimmed || trimmed.startsWith('/') || trimmed.includes('\\') || /^[A-Za-z]:/.test(trimmed)) {
-      return '';
-    }
-    let decoded = trimmed;
-    for (let index = 0; index < 3; index += 1) {
-      if (/%(?:2f|5c)/i.test(decoded)) {
-        return '';
-      }
-      let next;
-      try {
-        next = decodeURIComponent(decoded);
-      } catch (_error) {
-        return '';
-      }
-      if (next === decoded) {
-        break;
-      }
-      decoded = next;
-    }
-    if (/[\u0000-\u001f\u007f]/.test(decoded)
-      || decoded.startsWith('/')
-      || decoded.includes('\\')
-      || /^[A-Za-z]:/.test(decoded)) {
-      return '';
-    }
-    const normalized = decoded.replace(/\/+/g, '/').trim();
-    if (!normalized) {
-      return '';
-    }
-    const segments = normalized.split('/');
-    return segments.some(segment => !segment || segment === '.' || segment === '..')
-      ? ''
-      : normalized;
+    if (typeof value !== 'string' || !value || value.length > 2048 || value.trim() !== value
+      || /[\u0000-\u001f\u007f]/.test(value) || value.startsWith('/')
+      || value.includes('\\') || /^[A-Za-z]:/.test(value)) return '';
+    return value.split('/').some(segment => !segment || segment === '.' || segment === '..') ? '' : value;
   }
 
   return {