codex-overleaf-link 1.3.5 → 1.3.7

package/README.md

@@ -3,7 +3,7 @@
   <h1>Codex Overleaf Link</h1>
   <p><strong>Empower Overleaf with Codex.</strong></p>
   <p>
-    <img src="https://img.shields.io/badge/version-1.3.5-blue" alt="version">
+    <img src="https://img.shields.io/badge/version-1.3.7-blue" alt="version">
     <img src="https://img.shields.io/badge/platform-macOS%20%2F%20Windows%20%2F%20Linux-lightgrey" alt="platform">
     <img src="https://img.shields.io/badge/chrome-MV3-green" alt="chrome manifest v3">
     <img src="https://img.shields.io/badge/node-%3E%3D20-brightgreen" alt="node version">
@@ -27,42 +27,45 @@ Codex Overleaf Link bridges the two: it adds a Codex panel directly inside Overl
 
 ## Install
 
-Codex Overleaf Link has two pieces, installed separately:
+Codex Overleaf Link has two parts: a **native host** (a local Node bridge) and the **Chrome extension**. Pick one of the two install paths below, then open Overleaf.
 
-- **Native host** — installed and updated with the pinned npm package. npm installs, updates, uninstalls, and diagnoses the native host *only*; it never installs the Chrome extension.
-- **Chrome extension** — loaded manually as an unpacked extension from the GitHub Release zip (or a source checkout). The bundled extension key gives the official build a stable id, so normal installs do not need `--extension-id`.
+Either way, the final **Load unpacked** click is manual — Chrome does not let any installer or script load an unpacked extension for you.
 
-**1. Install or update the native host:**
+### Option A — installer script (recommended)
+
+One command installs the native host **and** sets up the extension: the script registers the native host, places the extension folder at `~/Codex Overleaf Link Extension`, copies that path to your clipboard, and opens `chrome://extensions` for you.
+
+macOS / Linux:
 
 ```bash
-npm exec --yes codex-overleaf-link@1.3.5 -- install-native
+CODEX_OVERLEAF_REF=v1.3.7 bash -c "$(curl -fsSL https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.3.7/install.sh)"
 ```
 
-**2. Load the extension:** Download `codex-overleaf-link-extension-v1.3.5.zip` from the [v1.3.5 GitHub Release](https://github.com/Ghqqqq/codex-overleaf-link/releases/tag/v1.3.5) and unzip it to a stable local folder. In `chrome://extensions`, enable **Developer mode**, click **Load unpacked**, and select that folder.
-
-**3. Open any Overleaf project.** The Codex panel appears on the right; confirm the native host is connected from the panel diagnostics.
+Windows PowerShell:
 
-Start in Ask mode; switch to Suggest mode for reviewed edits, or Auto mode once project governance and checkpoint settings are ready for direct writeback.
+```powershell
+iwr https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.3.7/install.ps1 -OutFile install.ps1
+$env:CODEX_OVERLEAF_REF='v1.3.7'
+powershell -ExecutionPolicy Bypass -File install.ps1
+```
 
-If Chrome assigns a custom build a different id, rerun the native install with `--extension-id <chrome-extension-id>` so the native manifest `allowed_origins` entry matches.
+Then, in the `chrome://extensions` tab the script opened: enable **Developer mode**, click **Load unpacked**, and choose the prepared extension folder (its path is already on your clipboard). That is the only manual step.
 
-### Source installer fallback
+### Option B — npm (native host only)
 
-If npm is unavailable, use the release-pinned script for your platform. These also serve development and source-checkout installs.
-
-macOS / Linux:
+`npm exec` installs and updates the **native host only** — it does not include the Chrome extension. Use it if you prefer a pinned npm package to a source checkout.
 
 ```bash
-CODEX_OVERLEAF_REF=v1.3.5 bash -c "$(curl -fsSL https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.3.5/install.sh)"
+npm exec --yes codex-overleaf-link@1.3.7 -- install-native
 ```
 
-Windows PowerShell:
+Then add the extension yourself: download `codex-overleaf-link-extension-v1.3.7.zip` from the [v1.3.7 GitHub Release](https://github.com/Ghqqqq/codex-overleaf-link/releases/tag/v1.3.7), unzip it to a stable folder, and in `chrome://extensions` enable **Developer mode**, click **Load unpacked**, and select that folder.
 
-```powershell
-iwr https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.3.5/install.ps1 -OutFile install.ps1
-$env:CODEX_OVERLEAF_REF='v1.3.5'
-powershell -ExecutionPolicy Bypass -File install.ps1
-```
+### Open Overleaf
+
+Open any Overleaf project — the Codex panel appears on the right; confirm the native host is connected from the panel diagnostics. Start in Ask mode; switch to Suggest mode for reviewed edits, or Auto mode once project governance and checkpoint settings are ready for direct writeback.
+
+The bundled extension key gives the official build a stable id, so normal installs do not need `--extension-id`. If Chrome assigns a custom build a different id, rerun the native install with `--extension-id <chrome-extension-id>` so the native manifest `allowed_origins` entry matches.
 
 <details>
 <summary><strong>Manual checkout install</strong> (custom location)</summary>
@@ -83,27 +86,25 @@ npm installs, updates, uninstalls, and diagnoses the native host only. npm does
 
 | Action | Command |
 |--------|---------|
-| Install / update | `npm exec --yes codex-overleaf-link@1.3.5 -- install-native` |
-| Diagnose | `npm exec --yes codex-overleaf-link@1.3.5 -- doctor` |
-| Uninstall | `npm exec --yes codex-overleaf-link@1.3.5 -- uninstall-native` |
+| Install / update | `npm exec --yes codex-overleaf-link@1.3.7 -- install-native` |
+| Diagnose | `npm exec --yes codex-overleaf-link@1.3.7 -- doctor` |
+| Uninstall | `npm exec --yes codex-overleaf-link@1.3.7 -- uninstall-native` |
 
 Use `--extension-id <chrome-extension-id>` only for a custom/dev unpacked extension id that differs from the official bundled id.
 
 ## Update
 
-For a deterministic v1.3.5 update, run the pinned npm install command above. This is also the native mismatch recovery command shown by the popup and panel when they report **Native host update required** — it fixes extension/native version mismatch and native protocol mismatch.
-
-If npm is unavailable, run the [source installer fallback](#source-installer-fallback) for your platform. After updating, reload the extension in `chrome://extensions` and refresh the Overleaf page.
+To update, re-run any of the [native host installers](#install) — they install and update the same way. This is also the native mismatch recovery command shown by the popup and panel when they report **Native host update required**; it fixes extension/native version mismatch and native protocol mismatch. After updating, reload the extension in `chrome://extensions` and refresh the Overleaf page.
 
 ## GitHub Release Artifacts
 
-The v1.3.5 GitHub Release contains:
+The v1.3.7 GitHub Release contains:
 
-- `codex-overleaf-link-extension-v1.3.5.zip`: loadable Chrome extension package for manual unpacked installation.
-- `codex-overleaf-native-host-v1.3.5.tar.gz`: native host runtime files used by the installer and release verification.
-- `codex-overleaf-link-1.3.5.tgz`: npm native host CLI package for pinned install, doctor, and uninstall flows.
-- `install.sh`: release-pinned macOS / Linux installer that defaults to `v1.3.5` when run directly from the release artifact.
-- `install.ps1`: release-pinned Windows PowerShell installer that defaults to `v1.3.5` when run directly from the release artifact.
+- `codex-overleaf-link-extension-v1.3.7.zip`: loadable Chrome extension package for manual unpacked installation.
+- `codex-overleaf-native-host-v1.3.7.tar.gz`: native host runtime files used by the installer and release verification.
+- `codex-overleaf-link-1.3.7.tgz`: npm native host CLI package for pinned install, doctor, and uninstall flows.
+- `install.sh`: release-pinned macOS / Linux installer that defaults to `v1.3.7` when run directly from the release artifact.
+- `install.ps1`: release-pinned Windows PowerShell installer that defaults to `v1.3.7` when run directly from the release artifact.
 - `uninstall-native-host.mjs`: native host uninstaller that removes the Chrome Native Messaging manifest, bridge executable, and runtime copy.
 - `nativeHostPlatform.js`, `manifest.js`, `runtimeInstaller.js`: helper files required by the loose uninstaller asset.
 - `SHA256SUMS` and `release-manifest.json`: checksum and artifact metadata for release verification.
@@ -114,7 +115,7 @@ The v1.3.5 GitHub Release contains:
 Remove the native host (use `--browser chromium` on Linux Chromium):
 
 ```bash
-npm exec --yes codex-overleaf-link@1.3.5 -- uninstall-native
+npm exec --yes codex-overleaf-link@1.3.7 -- uninstall-native
 ```
 
 The same command works on Windows PowerShell. If you installed from a manual checkout or source installer, you can also run `npm run uninstall:native` inside the repo, use `node ~/.codex-overleaf/source/scripts/uninstall-native-host.mjs` on macOS / Linux, or use `node $env:LOCALAPPDATA\CodexOverleaf\source\scripts\uninstall-native-host.mjs` on Windows PowerShell.
@@ -149,13 +150,13 @@ Then remove the extension from `chrome://extensions`. To delete local data: on m
 Linux Chromium install or update:
 
 ```bash
-CODEX_OVERLEAF_REF=v1.3.5 bash -c "$(curl -fsSL https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.3.5/install.sh)" -- --browser chromium
+CODEX_OVERLEAF_REF=v1.3.7 bash -c "$(curl -fsSL https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.3.7/install.sh)" -- --browser chromium
 ```
 
 Linux Chromium uninstall:
 
 ```bash
-npm exec --yes codex-overleaf-link@1.3.5 -- uninstall-native --browser chromium
+npm exec --yes codex-overleaf-link@1.3.7 -- uninstall-native --browser chromium
 ```
 
 ## Features
@@ -166,6 +167,7 @@ npm exec --yes codex-overleaf-link@1.3.5 -- uninstall-native --browser chromium
 - **Diff review** — per-file diff view before accepting changes.
 - **Undo checkpoint** — one-click revert of browser writes.
 - **Track Changes integration** — optionally enables Overleaf Reviewing before writing.
+- **Accept / Undo per run** — when a run wrote in Reviewing mode, accept or revert all of its tracked changes from the run card in one click. Accept replays the run's edits as untracked text via Overleaf's native undo path, with stable-Editing waits and an automatic rollback if Overleaf reintroduces tracked changes during the replay.
 - **Auto-recompile** — triggers Overleaf recompile after writeback; logs compile errors as context.
 - **@ context** — attach specific files, `@compile-log`, or `@current-section` to the prompt.
 - **Composer attachments and binary writeback** — paste or drop PDFs, images, and files into the composer as turn-scoped Codex context, and review Codex-created assets before creating or replacing them in Overleaf.
@@ -284,10 +286,10 @@ Composer attachments are turn-scoped Codex context. Limits are 8 attachments per
 
 **Native host missing or update required**
 
-Run the pinned npm native-host installer, reload the extension in `chrome://extensions`, then refresh the Overleaf tab. This also fixes extension/native version mismatch and native protocol mismatch. If npm is unavailable, use the [source installer fallback](#source-installer-fallback) for your platform.
+Re-run any [native host installer](#install), reload the extension in `chrome://extensions`, then refresh the Overleaf tab. This also fixes extension/native version mismatch and native protocol mismatch.
 
 ```bash
-npm exec --yes codex-overleaf-link@1.3.5 -- install-native
+npm exec --yes codex-overleaf-link@1.3.7 -- install-native
 ```
 
 **The Windows popup or panel shows a Bash recovery command**
@@ -336,8 +338,8 @@ Use this matrix for release-candidate signoff and compatibility reports. Record
 | Browser/channel/version | Google Chrome channel and version. | Google Chrome channel and version. | Google Chrome channel and version. | Chromium channel/package and version. |
 | Install mode | Manual unpacked extension from GitHub Release zip or checkout. | Manual unpacked extension from GitHub Release zip or checkout. | Manual unpacked extension from GitHub Release zip or checkout. | Manual unpacked extension from GitHub Release zip or checkout; native host installed with `--browser chromium`. |
 | Extension id | Bundled id `illdpneeeopfffmiepaejglgmhpmdhdc`, or actual custom id passed with `--extension-id`. | Bundled id `illdpneeeopfffmiepaejglgmhpmdhdc`, or actual custom id passed with `--extension-id`. | Bundled id `illdpneeeopfffmiepaejglgmhpmdhdc`, or actual custom id passed with `--extension-id`. | Bundled id `illdpneeeopfffmiepaejglgmhpmdhdc`, or actual custom id passed with `--extension-id`. |
-| Installer/update command | `npm exec --yes codex-overleaf-link@1.3.5 -- install-native` | `npm exec --yes codex-overleaf-link@1.3.5 -- install-native` | `npm exec --yes codex-overleaf-link@1.3.5 -- install-native` | `npm exec --yes codex-overleaf-link@1.3.5 -- install-native --browser chromium` |
-| Uninstall command | `npm exec --yes codex-overleaf-link@1.3.5 -- uninstall-native` | `npm exec --yes codex-overleaf-link@1.3.5 -- uninstall-native` | `npm exec --yes codex-overleaf-link@1.3.5 -- uninstall-native` | `npm exec --yes codex-overleaf-link@1.3.5 -- uninstall-native --browser chromium` |
+| Installer/update command | `npm exec --yes codex-overleaf-link@1.3.7 -- install-native` | `npm exec --yes codex-overleaf-link@1.3.7 -- install-native` | `npm exec --yes codex-overleaf-link@1.3.7 -- install-native` | `npm exec --yes codex-overleaf-link@1.3.7 -- install-native --browser chromium` |
+| Uninstall command | `npm exec --yes codex-overleaf-link@1.3.7 -- uninstall-native` | `npm exec --yes codex-overleaf-link@1.3.7 -- uninstall-native` | `npm exec --yes codex-overleaf-link@1.3.7 -- uninstall-native` | `npm exec --yes codex-overleaf-link@1.3.7 -- uninstall-native --browser chromium` |
 | Manifest/registry path | `~/Library/Application Support/Google/Chrome/NativeMessagingHosts/com.codex.overleaf.json` | `HKCU\Software\Google\Chrome\NativeMessagingHosts\com.codex.overleaf` -> `%LOCALAPPDATA%\CodexOverleaf\native-host-runtime\com.codex.overleaf.json` | `~/.config/google-chrome/NativeMessagingHosts/com.codex.overleaf.json` | `~/.config/chromium/NativeMessagingHosts/com.codex.overleaf.json` |
 | Bridge/runtime/source path | Bridge `~/.codex-overleaf/codex-overleaf-bridge`; runtime `~/.codex-overleaf/native-host-runtime`; source `~/.codex-overleaf/source`. | Bridge `%LOCALAPPDATA%\CodexOverleaf\codex-overleaf-bridge.cmd`; runtime `%LOCALAPPDATA%\CodexOverleaf\native-host-runtime`; source `%LOCALAPPDATA%\CodexOverleaf\source`. | Bridge `~/.codex-overleaf/codex-overleaf-bridge`; runtime `~/.codex-overleaf/native-host-runtime`; source `~/.codex-overleaf/source`. | Bridge `~/.codex-overleaf/codex-overleaf-bridge`; runtime `~/.codex-overleaf/native-host-runtime`; source `~/.codex-overleaf/source`. |
 | Node/Git/Codex/TeX | Node.js >= 20; Git; Codex CLI installed and logged in; TeX optional. | Node.js >= 20; Git; Codex CLI installed and logged in; TeX optional. | Node.js >= 20; Git; Codex CLI installed and logged in; TeX optional. | Node.js >= 20; Git; Codex CLI installed and logged in; TeX optional. |

package/extension/src/shared/compatibility.js

@@ -12,7 +12,7 @@
   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 = '1.3.5';
+  const BUILD_TARGET_VERSION = '1.3.7';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',

package/extension/src/shared/i18n.js

@@ -123,6 +123,24 @@
       undoCheckpointMissingReason: 'This run wrote while Reviewing/Track Changes was enabled, but the extension could not reliably identify the tracked changes generated by Overleaf. To avoid creating new redlines with text patches, automatic undo is disabled.',
       undoCheckpointMissingNext: 'Reject this run manually in Overleaf review tools, or rerun and try again.',
       undoCheckpointPlain: 'Undo point created: this run has {count} reversible write(s)',
+      runAcceptTracked: 'Accept changes',
+      runAcceptTrackedTitle: 'Accept this run\'s Overleaf tracked changes',
+      runAcceptTrackedConfirm: 'Confirm accept',
+      runAcceptTrackedCancel: 'Cancel',
+      runAcceptTrackedConfirming: 'Accepting…',
+      runAcceptTrackedDone: 'Accepted',
+      runAcceptTrackedDoneTitle: 'This run\'s tracked changes have been accepted',
+      runAcceptTrackedStarted: 'Starting to accept this run\'s Overleaf tracked changes',
+      runAcceptTrackedResult: 'Accept result: accepted {applied} tracked change(s), skipped {skipped}',
+      runAcceptTrackedFailed: 'Accept changes could not be completed',
+      runAcceptTrackedFailedReason: 'Overleaf editor content has drifted from this run\'s writeback, so Codex did not change the document. The run stays pending — retry Accept changes.',
+      runAcceptTrackedStepEditorUndo: 'Accept step 1/6 — Overleaf editor-undo of this run\'s tracked writeback',
+      runAcceptTrackedStepModeBefore: 'Accept step 2/6 — Reviewing/Track Changes state read BEFORE the Editing toggle',
+      runAcceptTrackedStepForceEditing: 'Accept step 3/6 — forcing Editing mode (Track Changes OFF) for the untracked replay',
+      runAcceptTrackedStepReplayStart: 'Accept step 4/6 — per-operation re-check of Editing mode before writing {path}',
+      runAcceptTrackedStepReplayDone: 'Accept step 5/6 — untracked replay write completed for {path}',
+      runAcceptTrackedStepRestoreReviewing: 'Accept step 6/6 — restoring the prior Reviewing/Track Changes mode',
+      detailAccepted: 'Accepted',
       deleteFilePromptTitle: 'Allow Codex to delete files?',
       deleteFilePromptMessage: '{files}\n\nOther changes can still sync if deletion is not confirmed.',
       deleteFileConfirm: 'Allow delete',
@@ -277,7 +295,10 @@
       refreshProbeFailed: 'Refresh failed. Reload Overleaf and try again.',
       processedFailed: 'Failed {elapsed}',
       processing: 'Running {elapsed}',
-      processed: 'Done {elapsed}'
+      processed: 'Done {elapsed}',
+      restoredRunStoppedTitle: 'Stopped tracking this run after a page refresh',
+      restoredRunStoppedDetail: 'The plugin reloaded while this run was still marked in progress. It has been marked interrupted to avoid showing a stale status — run the task again to continue.',
+      restoredRunStoppedStatus: 'Stopped tracking after a page refresh'
     },
     zh: {
       resizePanel: '拖动调整 Codex 面板宽度，双击恢复默认宽度',
@@ -391,6 +412,24 @@
       undoCheckpointMissingReason: '本轮是在 Reviewing/Track Changes 下写入的，但插件没有可靠识别 Overleaf 生成的留痕记录。为了避免用文本补丁制造新的红线，自动撤销已禁用。',
       undoCheckpointMissingNext: '请在 Overleaf 审阅面板手动拒绝这轮建议，或重新运行后再尝试。',
       undoCheckpointPlain: '已创建撤销点：可撤销本轮 {count} 项写入',
+      runAcceptTracked: '接受改动',
+      runAcceptTrackedTitle: '接受本轮 Overleaf 留痕改动',
+      runAcceptTrackedConfirm: '确认接受',
+      runAcceptTrackedCancel: '取消',
+      runAcceptTrackedConfirming: '接受中…',
+      runAcceptTrackedDone: '已接受',
+      runAcceptTrackedDoneTitle: '本轮留痕改动已被接受',
+      runAcceptTrackedStarted: '开始接受本轮 Overleaf 留痕改动',
+      runAcceptTrackedResult: '接受结果：已接受 {applied} 条留痕，跳过 {skipped} 条',
+      runAcceptTrackedFailed: '没有完成接受改动',
+      runAcceptTrackedFailedReason: 'Overleaf 编辑器内容已经和本轮写入不一致，Codex 没有改动文档。本轮仍为待处理状态——请重新点击接受改动。',
+      runAcceptTrackedStepEditorUndo: '接受步骤 1/6 — 通过 Overleaf 编辑器撤销，回退本轮留痕写入',
+      runAcceptTrackedStepModeBefore: '接受步骤 2/6 — 强制切换 Editing 之前读取的 Reviewing/Track Changes 状态',
+      runAcceptTrackedStepForceEditing: '接受步骤 3/6 — 强制切换到 Editing 模式（Track Changes OFF）以便重放为永久文本',
+      runAcceptTrackedStepReplayStart: '接受步骤 4/6 — 写入 {path} 前再次校验 Editing 模式',
+      runAcceptTrackedStepReplayDone: '接受步骤 5/6 — 已完成 {path} 的无留痕重放写入',
+      runAcceptTrackedStepRestoreReviewing: '接受步骤 6/6 — 恢复之前的 Reviewing/Track Changes 模式',
+      detailAccepted: '已接受',
       deleteFilePromptTitle: '允许 Codex 删除文件？',
       deleteFilePromptMessage: '{files}\n\n未确认删除时，其它改动仍可继续同步。',
       deleteFileConfirm: '允许删除',
@@ -545,7 +584,10 @@
       refreshProbeFailed: '检测失败：请刷新 Overleaf 页面后重试',
       processedFailed: '处理失败 {elapsed}',
       processing: '处理中 {elapsed}',
-      processed: '已处理 {elapsed}'
+      processed: '已处理 {elapsed}',
+      restoredRunStoppedTitle: '页面刷新后已停止跟踪这轮任务',
+      restoredRunStoppedDetail: '插件重新加载时发现这轮任务还标记为处理中。为了避免继续显示过期状态，已把它标记为中断；可以重新运行任务。',
+      restoredRunStoppedStatus: '页面刷新后已停止跟踪'
     }
   };
 

package/extension/src/shared/sessionState.js

@@ -7,6 +7,10 @@
 })(typeof globalThis !== 'undefined' ? globalThis : window, function sessionStateFactory() {
   'use strict';
 
+  const i18n = (typeof module === 'object' && module.exports)
+    ? require('./i18n')
+    : (typeof globalThis !== 'undefined' ? globalThis : window).CodexOverleafI18n;
+
   const DEFAULT_PANEL_STATE = {
     mode: 'confirm',
     model: 'gpt-5.4',
@@ -34,6 +38,12 @@
   const VALID_LOCALES = new Set(['en', 'zh']);
   const VALID_EVENT_STATUSES = new Set(['info', 'running', 'completed', 'failed', 'warning', 'blocked', 'skipped', 'pending']);
   const VALID_TITLE_SOURCES = new Set(['auto', 'manual']);
+  const VALID_TRACKED_CHANGE_STATUS = new Set([
+    'pending',
+    'accepted',
+    'rejected'
+  ]);
+  const TERMINAL_TRACKED_CHANGE_STATUS = new Set(['accepted', 'rejected']);
   const LEGACY_DEFAULT_SESSION_TITLE = 'New task';
   const SESSION_AUTO_TITLE_CHARS = 24;
   const MAX_RUN_EVENTS = 300;
@@ -111,8 +121,9 @@
     state.task = typeof state.task === 'string' ? state.task : '';
     state.model = typeof state.model === 'string' && state.model ? state.model : DEFAULT_PANEL_STATE.model;
     state.customInstructionsByProject = normalizeCustomInstructionsByProject(state.customInstructionsByProject);
-    state.runs = normalizeRuns(state.runs, options);
-    state.sessions = normalizeSessions(state, input, options);
+    const localizedOptions = { ...options, locale: state.locale };
+    state.runs = normalizeRuns(state.runs, localizedOptions);
+    state.sessions = normalizeSessions(state, input, localizedOptions);
     state.activeSessionId = resolveActiveSessionId(state.sessions, input.activeSessionId);
 
     return mirrorActiveSession(state);
@@ -499,17 +510,18 @@
 
   function normalizeRun(run, options = {}) {
     const shouldStopRestoredRun = options.restoreRunningRuns === true && run.status === 'running';
+    const locale = options.locale || i18n.DEFAULT_LOCALE;
     const events = normalizeRunEvents(run.events);
     if (shouldStopRestoredRun) {
       events.push({
-        title: '页面刷新后已停止跟踪这轮任务',
+        title: i18n.t(locale, 'restoredRunStoppedTitle'),
         status: 'failed',
-        detail: '插件重新加载时发现这轮任务还标记为处理中。为了避免继续显示过期状态，已把它标记为中断；可以重新运行任务。',
+        detail: i18n.t(locale, 'restoredRunStoppedDetail'),
         timestamp: new Date().toISOString()
       });
     }
 
-    return {
+    const normalized = {
       id: run.id,
       task: sanitizeAssistantVisibleText(run.task) || 'untitled task',
       mode: typeof run.mode === 'string' ? run.mode : '',
@@ -517,7 +529,7 @@
       reasoningEffort: typeof run.reasoningEffort === 'string' ? run.reasoningEffort : '',
       speedTier: typeof run.speedTier === 'string' ? run.speedTier : '',
       status: shouldStopRestoredRun ? 'failed' : normalizeRunStatus(run.status),
-      statusText: shouldStopRestoredRun ? '页面刷新后已停止跟踪' : sanitizeAssistantVisibleText(run.statusText),
+      statusText: shouldStopRestoredRun ? i18n.t(locale, 'restoredRunStoppedStatus') : sanitizeAssistantVisibleText(run.statusText),
       startedAt: typeof run.startedAt === 'string' ? run.startedAt : '',
       finishedAt: shouldStopRestoredRun ? new Date().toISOString() : typeof run.finishedAt === 'string' ? run.finishedAt : '',
       events: events.slice(-MAX_RUN_EVENTS),
@@ -529,6 +541,57 @@
       undoExpectedFiles: normalizeRunFiles(run.undoExpectedFiles),
       undoStatus: sanitizeAssistantVisibleText(run.undoStatus)
     };
+
+    applyTrackedChangeStatus(normalized, run.trackedChangeStatus);
+
+    return normalized;
+  }
+
+  // Resolves `trackedChangeStatus` on an already-normalized run via three ordered
+  // steps: (1) value recovery, (2) migration of pre-feature runs, (3) terminal
+  // payload cleanup. Mutates `run` in place. Idempotent: re-running it on its own
+  // output yields the same result.
+  function applyTrackedChangeStatus(run, rawStatus) {
+    const hasRefs = run.undoTrackedChanges.length > 0;
+    const hasRawStatus = rawStatus !== undefined && rawStatus !== null && rawStatus !== '';
+
+    // Step 1 — value recovery. Keep a stable value; recover any other present
+    // value (corruption, an old persisted `partial_accept` / `partial_reject` /
+    // `resolved_elsewhere`, a stray in-flight value) to `pending` (with refs)
+    // or drop it. An absent value falls through.
+    let status;
+    if (VALID_TRACKED_CHANGE_STATUS.has(rawStatus)) {
+      status = rawStatus;
+    } else if (hasRawStatus) {
+      status = hasRefs ? 'pending' : undefined;
+    } else {
+      status = undefined;
+    }
+
+    // Step 1 — reload reconciliation. A non-terminal status (`pending`) with no
+    // refs is the post-reload state of an un-acted tracked-change run: the heavy refs are
+    // never persisted, so without them there is nothing to act on. Drop it so
+    // the run returns to the legacy-undo world. A terminal status with no refs
+    // is kept — step 3 already empties terminal payloads and the label stays
+    // meaningful.
+    if (!hasRefs && status !== undefined && !TERMINAL_TRACKED_CHANGE_STATUS.has(status)) {
+      status = undefined;
+    }
+
+    // Step 2 — migration of pre-feature runs (no status after step 1).
+    if (status === undefined && hasRefs) {
+      status = run.undoStatus === 'applied' ? 'rejected' : 'pending';
+    }
+
+    // Step 3 — terminal payload cleanup; keeps `trackedChangeStatus`.
+    if (TERMINAL_TRACKED_CHANGE_STATUS.has(status)) {
+      run.undoTrackedChanges = [];
+      run.undoExpectedFiles = [];
+    }
+
+    if (status !== undefined) {
+      run.trackedChangeStatus = status;
+    }
   }
 
   function normalizeRunStatus(status) {
@@ -855,7 +918,7 @@
 
   function compactRunForStorage(run, limits, keepUndoPayload) {
     const undoPayload = compactUndoPayload(run, limits, keepUndoPayload);
-    return {
+    const compact = {
       id: run.id,
       task: summarizeTextForStorage(run.task || 'untitled task', 'run task'),
       mode: typeof run.mode === 'string' ? run.mode : '',
@@ -875,6 +938,10 @@
       undoExpectedFiles: undoPayload.undoExpectedFiles,
       undoStatus: summarizeTextForStorage(run.undoStatus, 'undo status')
     };
+    if (VALID_TRACKED_CHANGE_STATUS.has(run.trackedChangeStatus)) {
+      compact.trackedChangeStatus = run.trackedChangeStatus;
+    }
+    return compact;
   }
 
   function compactRunEvents(events, limits) {

package/extension/src/shared/storageDb.js

@@ -38,6 +38,11 @@
     skipped: true,
     pending: true
   };
+  var VALID_TRACKED_CHANGE_STATUSES = {
+    pending: true,
+    accepted: true,
+    rejected: true
+  };
   var SECRET_REDACTION_PATTERNS = [
     /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
     /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi,
@@ -542,7 +547,7 @@
   }
 
   function compactRunForStorage(run) {
-    return {
+    var compact = {
       id: run.id,
       task: normalizeDisplayTextForStorage(run.task || 'untitled task', SESSION_STORAGE_LIMITS.taskChars),
       mode: typeof run.mode === 'string' ? redactSecretLikeText(run.mode) : '',
@@ -562,6 +567,10 @@
       undoExpectedFiles: [],
       undoStatus: normalizeDisplayTextForStorage(run.undoStatus, SESSION_STORAGE_LIMITS.statusTextChars)
     };
+    if (VALID_TRACKED_CHANGE_STATUSES[run.trackedChangeStatus] === true) {
+      compact.trackedChangeStatus = run.trackedChangeStatus;
+    }
+    return compact;
   }
 
   function compactRunEventsForStorage(events) {

package/extension/src/shared/undoOperations.js

@@ -223,7 +223,15 @@
       if (typeof current !== 'string') {
         return;
       }
-      if (typeof operation.replaceAll === 'string') {
+      // The writeback already verified the editor content it produced. When
+      // that authoritative post-write content is available, trust it instead
+      // of re-deriving the result by re-applying patches: a wide patch's
+      // `expected` spans a whole paragraph, so it silently fails to re-apply
+      // against any base that drifted even slightly from the patch's base,
+      // and the result would otherwise collapse to the un-patched content.
+      if (typeof operation.verifiedContent === 'string') {
+        filesByPath.set(operation.path, operation.verifiedContent);
+      } else if (typeof operation.replaceAll === 'string') {
         filesByPath.set(operation.path, operation.replaceAll);
       } else if (Array.isArray(operation.patches) && operation.patches.length) {
         const patched = applyTextPatches(current, operation.patches);

package/native-host/src/textPatch.js

@@ -7,12 +7,53 @@ function computeTextPatches(oldText, newText) {
     return [];
   }
 
-  const linePatches = computeLineAnchoredPatches(oldValue, newValue);
-  if (linePatches.length) {
-    return linePatches;
+  const groups = computeLineAnchoredChangeGroups(oldValue, newValue);
+  if (!groups.length) {
+    return [computeSingleTextPatch(oldValue, newValue)];
   }
 
-  return [computeSingleTextPatch(oldValue, newValue)];
+  const patches = [];
+  for (const group of groups) {
+    patches.push(...computeNaturalGroupPatches(group));
+  }
+  return patches.length ? patches : [computeSingleTextPatch(oldValue, newValue)];
+}
+
+// Computes the natural-granularity patches for one changed group (spec
+// "Algorithm sketch"). Builds token patches and metrics, classifies the group,
+// then dispatches to the matching builder. `singleGroupPatch` already returns
+// a one-element array; `computeParagraphPatches` / `computeSentencePatches`
+// return an array or `null`, so a null/empty result falls back to a single
+// group patch. `coalesceTokenPatches` always returns a non-empty array when it
+// receives non-empty token patches.
+function computeNaturalGroupPatches(group) {
+  const tokenPatches = computeTokenAnchoredPatches(
+    group.oldText,
+    group.newText,
+    group.oldStart
+  );
+  const metrics = computeGroupMetrics(group, tokenPatches);
+  const { type } = classifyChangedGroup(group, tokenPatches, metrics);
+
+  if (type === 'annotated_block') {
+    return singleGroupPatch(group);
+  }
+  if (type === 'paragraph_rewrite') {
+    const paragraphPatches = computeParagraphPatches(group);
+    return (paragraphPatches && paragraphPatches.length)
+      ? paragraphPatches
+      : singleGroupPatch(group);
+  }
+  if (type === 'sentence_rewrite') {
+    const sentencePatches = computeSentencePatches(group, tokenPatches);
+    return (sentencePatches && sentencePatches.length)
+      ? sentencePatches
+      : singleGroupPatch(group);
+  }
+  if (type === 'small_edit' && tokenPatches && tokenPatches.length) {
+    return coalesceTokenPatches(group, tokenPatches);
+  }
+  return singleGroupPatch(group);
 }
 
 function computeSingleTextPatch(oldValue, newValue, offset = 0) {
@@ -41,7 +82,7 @@ function computeSingleTextPatch(oldValue, newValue, offset = 0) {
   };
 }
 
-function computeLineAnchoredPatches(oldValue, newValue) {
+function computeLineAnchoredChangeGroups(oldValue, newValue) {
   const oldParts = splitTextParts(oldValue);
   const newParts = splitTextParts(newValue);
   const MAX_PARTS = 5000;
@@ -58,7 +99,7 @@ function computeLineAnchoredPatches(oldValue, newValue) {
   }
 
   const edits = computePartEdits(oldParts, newParts);
-  const patches = [];
+  const groups = [];
   let oldOffset = 0;
   let newOffset = 0;
   let group = null;
@@ -91,20 +132,13 @@ function computeLineAnchoredPatches(oldValue, newValue) {
   }
   flushGroup();
 
-  return patches;
+  return groups;
 
   function flushGroup() {
     if (!group) {
       return;
     }
-    if (group.oldText !== group.newText) {
-      const tokenPatches = computeTokenAnchoredPatches(group.oldText, group.newText, group.oldStart);
-      if (tokenPatches) {
-        patches.push(...tokenPatches);
-      } else {
-        patches.push(computeSingleTextPatch(group.oldText, group.newText, group.oldStart));
-      }
-    }
+    groups.push(group);
     group = null;
   }
 }
@@ -282,6 +316,625 @@ function computePartEdits(oldParts, newParts) {
   return edits;
 }
 
+function countNonEmptyLines(text) {
+  const value = String(text ?? '');
+  let count = 0;
+  for (const line of value.split('\n')) {
+    if (line.trim() !== '') {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+function countSentenceTerminators(text) {
+  const value = String(text ?? '');
+  let count = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === '。' || char === '？' || char === '！') {
+      count += 1;
+      continue;
+    }
+    if (char === '.' || char === '?' || char === '!') {
+      if (
+        char === '.'
+        && /[0-9]/.test(value[index - 1] || '')
+        && /[0-9]/.test(value[index + 1] || '')
+      ) {
+        // Decimal point inside a number such as `1.23` is not a boundary.
+        continue;
+      }
+      count += 1;
+    }
+  }
+  return count;
+}
+
+function hasOriginalMarkerLine(text) {
+  return String(text ?? '')
+    .split('\n')
+    .some(line => /^\s*%\s*\[original\]\s*$/.test(line));
+}
+
+function hasLaterRevisedMarkerLine(text) {
+  const lines = String(text ?? '').split('\n');
+  const originalIndex = lines.findIndex(line => /^\s*%\s*\[original\]\s*$/.test(line));
+  if (originalIndex === -1) {
+    return false;
+  }
+  return lines.some((line, index) => (
+    index > originalIndex && /^\s*%\s*\[revised\]\s*$/.test(line)
+  ));
+}
+
+function hasAnyAnnotatedMarker(text) {
+  return String(text ?? '')
+    .split('\n')
+    .some(line => (
+      /^\s*%\s*\[original\]\s*$/.test(line) || /^\s*%\s*\[revised\]\s*$/.test(line)
+    ));
+}
+
+function splitParagraphs(text) {
+  const value = String(text ?? '');
+  const separator = /\n\s*\n/g;
+  const segments = [];
+  let lastIndex = 0;
+  let match = separator.exec(value);
+
+  while (match) {
+    segments.push({ text: value.slice(lastIndex, match.index), start: lastIndex });
+    segments.push({ text: match[0], start: match.index });
+    lastIndex = match.index + match[0].length;
+    match = separator.exec(value);
+  }
+  segments.push({ text: value.slice(lastIndex), start: lastIndex });
+
+  return segments;
+}
+
+// Lowercase abbreviations whose trailing `.` is conservatively NOT a sentence
+// boundary. The word ending in the dot is matched case-insensitively, so this
+// also covers `Fig.`, `Eq.`, `No.`, etc.
+const NON_TERMINAL_ABBREVIATIONS = new Set([
+  'e.g', 'i.e', 'cf', 'vs', 'etc', 'al', 'fig', 'figs', 'eq', 'eqs', 'sec',
+  'secs', 'thm', 'lem', 'def', 'prop', 'cor', 'ref', 'no', 'vol', 'pp',
+  'ch', 'app', 'resp', 'approx', 'mr', 'ms', 'mrs', 'dr', 'prof', 'st'
+]);
+
+function isLatexCommandStart(text, index) {
+  return text[index] === '\\' && /[A-Za-z@]/.test(text[index + 1] || '');
+}
+
+// True when the contiguous non-whitespace run containing `index` looks like a
+// URL (has a scheme such as `https://`, or starts with `www.`). A `.` inside
+// such a run is never a confident sentence boundary.
+function isInsideUrl(text, index) {
+  let runStart = index;
+  while (runStart > 0 && !/\s/.test(text[runStart - 1])) {
+    runStart -= 1;
+  }
+  let runEnd = index;
+  while (runEnd < text.length && !/\s/.test(text[runEnd])) {
+    runEnd += 1;
+  }
+  const run = text.slice(runStart, runEnd);
+  return /:\/\//.test(run) || /^www\./i.test(run);
+}
+
+// True when the `.` at `index` completes a known abbreviation such as `e.g.`
+// or `Fig.` rather than ending a sentence.
+function completesAbbreviation(text, index) {
+  let wordStart = index;
+  while (wordStart > 0 && /[A-Za-z.]/.test(text[wordStart - 1])) {
+    wordStart -= 1;
+  }
+  const word = text.slice(wordStart, index).toLowerCase();
+  return word.length > 0 && NON_TERMINAL_ABBREVIATIONS.has(word);
+}
+
+// True when the ASCII terminator `.` `?` `!` at `index` is a confident
+// sentence boundary: it must be followed by whitespace, end-of-string, or a
+// LaTeX command boundary, and must not sit inside a decimal number, a URL, or
+// a known abbreviation.
+function isConfidentAsciiBoundary(text, index) {
+  const next = text[index + 1];
+  const followedByBoundary = next === undefined
+    || /\s/.test(next)
+    || isLatexCommandStart(text, index + 1);
+  if (!followedByBoundary) {
+    return false;
+  }
+  if (text[index] === '.') {
+    const prev = text[index - 1];
+    if (/[0-9]/.test(prev || '') && /[0-9]/.test(next || '')) {
+      // Decimal point inside a number such as `1.23`.
+      return false;
+    }
+    if (isInsideUrl(text, index)) {
+      return false;
+    }
+    if (completesAbbreviation(text, index)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Splits `text` into ordered sentence spans `[{text, start, end}]` that
+// partition the input exactly (concatenated they equal `text`). Each span
+// includes its trailing terminator and the whitespace up to the next
+// sentence. Conservative: when no confident boundary is found the whole input
+// is returned as a single span.
+function splitSentences(text) {
+  const value = String(text ?? '');
+  if (value.length === 0) {
+    return [{ text: '', start: 0, end: 0 }];
+  }
+
+  const spans = [];
+  let spanStart = 0;
+  let index = 0;
+
+  while (index < value.length) {
+    const char = value[index];
+    let isBoundary = false;
+
+    if (char === '。' || char === '？' || char === '！') {
+      // CJK terminators are unambiguous: they never appear in decimals, URLs,
+      // or LaTeX command names, so they always end a sentence.
+      isBoundary = true;
+    } else if (char === '.' || char === '?' || char === '!') {
+      isBoundary = isConfidentAsciiBoundary(value, index);
+    }
+
+    if (isBoundary) {
+      // Absorb trailing whitespace up to the next sentence into this span.
+      let spanEnd = index + 1;
+      while (spanEnd < value.length && /\s/.test(value[spanEnd])) {
+        spanEnd += 1;
+      }
+      if (spanEnd < value.length) {
+        spans.push({
+          text: value.slice(spanStart, spanEnd),
+          start: spanStart,
+          end: spanEnd
+        });
+        spanStart = spanEnd;
+        index = spanEnd;
+        continue;
+      }
+    }
+
+    index += 1;
+  }
+
+  spans.push({
+    text: value.slice(spanStart),
+    start: spanStart,
+    end: value.length
+  });
+
+  return spans;
+}
+
+function computeGroupMetrics(group, tokenPatches) {
+  const oldNonEmptyLineCount = countNonEmptyLines(group.oldText);
+  const newNonEmptyLineCount = countNonEmptyLines(group.newText);
+
+  return {
+    oldNonEmptyLineCount,
+    newNonEmptyLineCount,
+    maxNonEmptyLineCount: Math.max(oldNonEmptyLineCount, newNonEmptyLineCount),
+    changedSpanChars: Math.max(group.oldText.length, group.newText.length),
+    tokenPatchCount: tokenPatches === null ? null : tokenPatches.length,
+    totalTokenChangedChars: tokenPatches === null
+      ? null
+      : tokenPatches.reduce((sum, patch) => (
+          sum + Math.max(patch.to - patch.from, patch.insert.length)
+        ), 0),
+    oldSentenceTerminatorCount: countSentenceTerminators(group.oldText),
+    newSentenceTerminatorCount: countSentenceTerminators(group.newText)
+  };
+}
+
+// Resolves the sentence-span quantities used by the `isSentenceRewrite`
+// predicate (the design spec leaves them undefined). It segments the changed
+// group's OLD text into sentence spans and checks whether every token patch's
+// old range maps within a single span.
+//
+// Returns:
+// - `fitsOneSpan`: true iff exactly one sentence span contains every token
+//   patch's old range (relative to the group).
+// - `spanChars` / `spanTokenCount`: the char length / token count of that
+//   single span when `fitsOneSpan` is true; `0` otherwise (irrelevant then).
+// - `spanStart` / `spanEnd`: the group-relative `[start,end)` offsets of that
+//   single span when `fitsOneSpan` is true; `0` otherwise (irrelevant then).
+//
+// When `tokenPatches` is `null` or empty, `fitsOneSpan` is false.
+function resolveTokenPatchSentenceSpan(group, tokenPatches) {
+  const empty = {
+    fitsOneSpan: false,
+    spanChars: 0,
+    spanTokenCount: 0,
+    spanStart: 0,
+    spanEnd: 0
+  };
+  if (tokenPatches === null || tokenPatches.length === 0) {
+    return empty;
+  }
+
+  const sentenceSpans = splitSentences(group.oldText);
+  let containingSpan = null;
+
+  for (const span of sentenceSpans) {
+    const containsEveryPatch = tokenPatches.every(patch => {
+      const relativeFrom = patch.from - group.oldStart;
+      const relativeTo = patch.to - group.oldStart;
+      return relativeFrom >= span.start && relativeTo <= span.end;
+    });
+    if (!containsEveryPatch) {
+      continue;
+    }
+    if (containingSpan !== null) {
+      // More than one span contains every patch (possible for a zero-length
+      // patch sitting on a span boundary). Not a confident single sentence.
+      return empty;
+    }
+    containingSpan = span;
+  }
+
+  if (containingSpan === null) {
+    return empty;
+  }
+  return {
+    fitsOneSpan: true,
+    spanChars: containingSpan.text.length,
+    spanTokenCount: splitTextTokens(containingSpan.text).length,
+    spanStart: containingSpan.start,
+    spanEnd: containingSpan.end
+  };
+}
+
+// Classifies a changed group into a natural review granularity. Pure function.
+//
+// `group` is `{oldStart, oldText, newText}`; `tokenPatches` is the array from
+// `computeTokenAnchoredPatches(group.oldText, group.newText, group.oldStart)`
+// or `null`; `metrics` is the object from `computeGroupMetrics(group,
+// tokenPatches)`.
+//
+// Returns `{type}` where `type` is one of `annotated_block`,
+// `paragraph_rewrite`, `sentence_rewrite`, `small_edit`, `fallback`. The
+// predicates are evaluated in first-match order: annotated_block →
+// paragraph_rewrite → sentence_rewrite → small_edit → fallback. When
+// `tokenPatches === null`, every token-dependent predicate is false, so the
+// only reachable results are `annotated_block`, `paragraph_rewrite` (via the
+// line-count or sentence-terminator branch), and `fallback`.
+function classifyChangedGroup(group, tokenPatches, metrics) {
+  const newGroupText = group.newText;
+  const {
+    maxNonEmptyLineCount,
+    changedSpanChars,
+    tokenPatchCount,
+    totalTokenChangedChars,
+    oldSentenceTerminatorCount,
+    newSentenceTerminatorCount
+  } = metrics;
+
+  const isAnnotatedBlock = hasOriginalMarkerLine(newGroupText)
+    && hasLaterRevisedMarkerLine(newGroupText)
+    && maxNonEmptyLineCount >= 3;
+  if (isAnnotatedBlock) {
+    return { type: 'annotated_block' };
+  }
+
+  const isDenseTokenRewrite = tokenPatches !== null
+    && tokenPatchCount >= 6
+    && changedSpanChars >= 160
+    && tokenPatchCount / Math.max(1, maxNonEmptyLineCount) >= 2;
+
+  const isParagraphRewrite = !isAnnotatedBlock
+    && (
+      maxNonEmptyLineCount >= 3
+      || (oldSentenceTerminatorCount >= 2 && newSentenceTerminatorCount >= 2)
+      || isDenseTokenRewrite
+    );
+  if (isParagraphRewrite) {
+    return { type: 'paragraph_rewrite' };
+  }
+
+  const sentenceSpan = resolveTokenPatchSentenceSpan(group, tokenPatches);
+
+  const isSentenceRewrite = !isAnnotatedBlock
+    && !isParagraphRewrite
+    && tokenPatches !== null
+    && tokenPatchCount >= 3
+    && sentenceSpan.fitsOneSpan
+    && (sentenceSpan.spanChars >= 80 || sentenceSpan.spanTokenCount >= 12);
+  if (isSentenceRewrite) {
+    return { type: 'sentence_rewrite' };
+  }
+
+  const isSmallEdit = !isAnnotatedBlock
+    && !isParagraphRewrite
+    && !isSentenceRewrite
+    && tokenPatches !== null
+    && (
+      tokenPatchCount <= 2
+      || (
+        totalTokenChangedChars < 80
+        && maxNonEmptyLineCount <= 2
+        && !hasAnyAnnotatedMarker(newGroupText)
+      )
+    );
+  if (isSmallEdit) {
+    return { type: 'small_edit' };
+  }
+
+  return { type: 'fallback' };
+}
+
+// The single-patch fallback for a whole changed group (spec algorithm sketch).
+// Returns a one-element array so callers can treat every builder uniformly.
+// The patch's `from`/`to` are absolute offsets into the full original text:
+// `computeSingleTextPatch` adds `group.oldStart` to its segment-local offsets.
+function singleGroupPatch(group) {
+  return [computeSingleTextPatch(group.oldText, group.newText, group.oldStart)];
+}
+
+// Builds paragraph-level patches for a changed group (spec §4).
+//
+// Segments `group.oldText` and `group.newText` with `splitParagraphs`, which
+// yields alternating [content, separator, content, ...] segments. When both
+// sides share the SAME separator structure (same segment count and identical
+// separator segments) the content paragraphs are paired positionally and one
+// patch is emitted per changed pair, with `from`/`to` as absolute offsets
+// (`group.oldStart` + the old paragraph segment's start). A single-paragraph
+// group is the degenerate case of this rule: one pair, one patch.
+//
+// Returns `null` when pairing is ambiguous (separator counts differ or a
+// separator segment changed), so the caller can fall back to a group patch.
+function computeParagraphPatches(group) {
+  const oldSegments = splitParagraphs(group.oldText);
+  const newSegments = splitParagraphs(group.newText);
+
+  if (oldSegments.length !== newSegments.length) {
+    return null;
+  }
+  // splitParagraphs always yields an odd count: content at even indices,
+  // blank-line separators at odd indices. Every separator must be unchanged
+  // for positional pairing of the content paragraphs to be sound.
+  for (let index = 1; index < oldSegments.length; index += 2) {
+    if (oldSegments[index].text !== newSegments[index].text) {
+      return null;
+    }
+  }
+
+  const patches = [];
+  for (let index = 0; index < oldSegments.length; index += 2) {
+    const oldParagraph = oldSegments[index];
+    const newParagraph = newSegments[index];
+    if (oldParagraph.text === newParagraph.text) {
+      continue;
+    }
+    patches.push(computeSingleTextPatch(
+      oldParagraph.text,
+      newParagraph.text,
+      group.oldStart + oldParagraph.start
+    ));
+  }
+  return patches;
+}
+
+// Builds a single sentence-level patch for a `sentence_rewrite` group (spec
+// §5). Every token patch lies inside one confident sentence span `[a,b)` of
+// `group.oldText`. Because all token changes are inside that span, the regions
+// `group.oldText.slice(0,a)` and `group.oldText.slice(b)` are unchanged, so
+// `group.newText` is `prefix + <new sentence> + suffix` with the same prefix
+// and suffix; `<new sentence>` is derived by stripping them.
+//
+// Returns `[patch]` whose `from`/`to` cover only that old sentence span
+// (absolute offsets), or `null` when the single span cannot be identified or
+// the unchanged prefix/suffix do not actually match (defensive).
+function computeSentencePatches(group, tokenPatches) {
+  const span = resolveTokenPatchSentenceSpan(group, tokenPatches);
+  if (!span.fitsOneSpan) {
+    return null;
+  }
+
+  const { spanStart, spanEnd } = span;
+  const oldPrefix = group.oldText.slice(0, spanStart);
+  const oldSuffix = group.oldText.slice(spanEnd);
+  const oldSentence = group.oldText.slice(spanStart, spanEnd);
+
+  // The regions outside the sentence span must be byte-identical between old
+  // and new text; otherwise a change leaked outside the span and a single
+  // sentence patch would be wrong.
+  if (
+    !group.newText.startsWith(oldPrefix)
+    || !group.newText.endsWith(oldSuffix)
+    || group.newText.length < oldPrefix.length + oldSuffix.length
+  ) {
+    return null;
+  }
+
+  const newSentence = group.newText.slice(
+    oldPrefix.length,
+    group.newText.length - oldSuffix.length
+  );
+  return [computeSingleTextPatch(
+    oldSentence,
+    newSentence,
+    group.oldStart + spanStart
+  )];
+}
+
+// Short function words whose presence inside a coalescing gap does not block a
+// merge. Combined with pure punctuation and whitespace, these define a gap
+// that is "mostly" connective filler (spec §7).
+const COALESCE_FILLER_WORDS = new Set([
+  'a', 'an', 'the', 'and', 'or', 'but', 'nor', 'so', 'yet', 'of', 'to', 'in',
+  'on', 'at', 'by', 'as', 'is', 'are', 'was', 'were', 'be', 'for', 'with',
+  'that', 'this', 'it', 'its', 'we', 'our'
+]);
+
+// True when the gap text between two token patches is short connective filler:
+// only whitespace, punctuation, and short function words. An empty gap counts
+// as filler.
+function isCoalesceFillerGap(gap) {
+  if (gap.length > 40) {
+    return false;
+  }
+  for (const token of splitTextTokens(gap)) {
+    const text = token.text;
+    if (/^\s+$/.test(text)) {
+      continue;
+    }
+    if (!/[A-Za-z0-9]/.test(text)) {
+      // Pure punctuation / symbols.
+      continue;
+    }
+    if (COALESCE_FILLER_WORDS.has(text.toLowerCase())) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+// Conservative safety-net coalescing of token patches (spec §7). Adjacent
+// token patches are merged when they lie in the same sentence span of
+// `group.oldText`, the gap between them is at most 40 chars of whitespace /
+// punctuation / short function words, and that sentence span contains at
+// least 3 token patches. A merged patch spans `[firstFrom, lastTo)` with
+// `expected` the original slice and `insert` the merged inserts interleaved
+// with the unchanged gap text. When nothing qualifies the token patches are
+// returned unchanged. Absolute offsets are preserved throughout.
+function coalesceTokenPatches(group, tokenPatches) {
+  if (tokenPatches === null || tokenPatches.length < 3) {
+    return tokenPatches;
+  }
+
+  const spans = splitSentences(group.oldText);
+  // Index of the sentence span that fully contains a patch's group-relative
+  // range, or -1 when it is not cleanly inside any single span.
+  const spanOf = patch => {
+    const relativeFrom = patch.from - group.oldStart;
+    const relativeTo = patch.to - group.oldStart;
+    return spans.findIndex(span => (
+      relativeFrom >= span.start && relativeTo <= span.end
+    ));
+  };
+
+  // Count patches per sentence span so the ">= 3 in the span" gate can be
+  // checked before merging any run.
+  const patchesPerSpan = new Map();
+  for (const patch of tokenPatches) {
+    const spanIndex = spanOf(patch);
+    patchesPerSpan.set(spanIndex, (patchesPerSpan.get(spanIndex) || 0) + 1);
+  }
+
+  const result = [];
+  let run = [];
+  let runSpanIndex = -1;
+
+  const flushRun = () => {
+    if (run.length === 0) {
+      return;
+    }
+    if (run.length === 1) {
+      result.push(run[0]);
+    } else {
+      result.push(mergeTokenPatchRun(group, run));
+    }
+    run = [];
+  };
+
+  for (const patch of tokenPatches) {
+    const spanIndex = spanOf(patch);
+    const eligibleSpan = spanIndex !== -1 && patchesPerSpan.get(spanIndex) >= 3;
+
+    if (run.length === 0) {
+      run = eligibleSpan ? [patch] : [];
+      runSpanIndex = eligibleSpan ? spanIndex : -1;
+      if (!eligibleSpan) {
+        result.push(patch);
+      }
+      continue;
+    }
+
+    const prev = run[run.length - 1];
+    const gap = group.oldText.slice(
+      prev.to - group.oldStart,
+      patch.from - group.oldStart
+    );
+    const mergeable = eligibleSpan
+      && spanIndex === runSpanIndex
+      && isCoalesceFillerGap(gap);
+
+    if (mergeable) {
+      run.push(patch);
+      continue;
+    }
+
+    flushRun();
+    run = eligibleSpan ? [patch] : [];
+    runSpanIndex = eligibleSpan ? spanIndex : -1;
+    if (!eligibleSpan) {
+      result.push(patch);
+    }
+  }
+  flushRun();
+
+  return result;
+}
+
+// Merges a run of >= 2 adjacent token patches into one patch spanning
+// `[firstFrom, lastTo)`. `expected` is the original-text slice (the patches'
+// expecteds interleaved with the unchanged gap text); `insert` is the patches'
+// inserts interleaved with the same gap text.
+function mergeTokenPatchRun(group, run) {
+  const first = run[0];
+  const last = run[run.length - 1];
+  let expected = first.expected;
+  let insert = first.insert;
+
+  for (let index = 1; index < run.length; index += 1) {
+    const prev = run[index - 1];
+    const current = run[index];
+    const gap = group.oldText.slice(
+      prev.to - group.oldStart,
+      current.from - group.oldStart
+    );
+    expected += gap + current.expected;
+    insert += gap + current.insert;
+  }
+
+  return {
+    from: first.from,
+    to: last.to,
+    expected,
+    insert
+  };
+}
+
 module.exports = {
-  computeTextPatches
+  computeTextPatches,
+  computeSingleTextPatch,
+  computeLineAnchoredChangeGroups,
+  computeTokenAnchoredPatches,
+  computeGroupMetrics,
+  classifyChangedGroup,
+  splitParagraphs,
+  splitSentences,
+  hasOriginalMarkerLine,
+  hasLaterRevisedMarkerLine,
+  hasAnyAnnotatedMarker,
+  countNonEmptyLines,
+  countSentenceTerminators,
+  singleGroupPatch,
+  computeParagraphPatches,
+  computeSentencePatches,
+  coalesceTokenPatches
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-overleaf-link",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
   "license": "MIT",
   "type": "commonjs",