dsh-rewind-plugin 0.3.0 → 0.3.1

package/README.md

@@ -53,6 +53,8 @@ For contributors: install from a local checkout or a pinned commit — `dsh plug
 
 **Command-line entry**: type a bare `/rewind` and press Enter to open the candidate picker; selecting a target continues the same flow as the button.
 
+Both the candidate picker and the mode popover support the keyboard: ↑↓ to move, Enter to confirm, Esc to cancel/back.
+
 Rewinds can be repeated (each appends a marker to the log). A rewind cannot be undone through the plugin, but the withdrawn messages can be recovered by manually editing the session log. The file-restore action is not re-backed up.
 
 ## How it works
@@ -74,17 +76,16 @@ The plugin tracks the write-class tools — `write`, `edit`, `str_replace_editor
 
 1. **Before-capture** at `tools/execute` (the around-dispatch stage): the target file is read; the resolved path + content are held in a pending map. This stage runs only after any pre-execute approval gate let the call through — an `ask` short-circuit (dsh-edit-approval) **cannot skip** the backup, and a denied call never records. If the read fails (e.g. a permission error), the change is simply not backed up — the plugin warns in the log but **does not block the write**.
 2. **Disk commit** at `tools/post-execute`: the before-backup is written under the turn's anchor message seq (`~/.dsh/rewind-snapshots/<session>/<anchor seq>/<callId>.json`).
-3. **Restore** (`/rewind @<seq> both`): every backup anchored at or after the target applies — modified files are written back to their **earliest** captured before-state, files created after the target are deleted, symbolic / hard links are skipped (they share an inode with another name; restoring through one would clobber both). Writes go through plain `node:fs`, independent of the fs service — under sandbox / remote backends, path resolution may be restricted.
+3. **Restore** (`/rewind @<seq> both`): every backup anchored at or after the target applies once reconciled with the current disk — modified files are written back to their **earliest** captured before-state, files created after the target are deleted, files already matching the target state are left untouched (idempotent). Symbolic / hard links are skipped (they share an inode with another name; restoring through one would clobber both). Writes go through plain `node:fs`, independent of the fs service — under sandbox / remote backends, path resolution may be restricted.
 4. A tool body that **throws** skips `tools/post-execute`; a `tools/result` safety net clears the pending capture so nothing leaks in memory.
 
 Backups persist across host restarts, bounded to the newest 100 anchor groups per session.
 
 ## What it deliberately does NOT do
 
-- **Whole-tree / git-first snapshots** — only write-class tool edits are backed up. `bash`, other tools, and external edits are not tracked and cannot be restored: the same limitation as Claude Code, which defers such rollbacks to the user's git.
+- **Whole-tree / git-first snapshots** — only write-class tool edits plus external changes to already-tracked files are backed up; files never touched by a tool are not restored: the same limitation as Claude Code, which defers such rollbacks to the user's git.
 - **Subagent edits** — not tracked (same as Claude Code): a subagent runs its own session, so its backups could never be restored by a rewind of the parent session.
 - **Fork / branch rewind and `/compact`** — the harness already provides these ("branch in new chat", compact).
-- **Keyboard shortcuts** (esc+esc rewind menu) — planned as a follow-up.
 
 ## Comparison with similar projects
 
@@ -116,7 +117,7 @@ Full instructions: [docs/troubleshooting.md](docs/troubleshooting.md)
 
 ## Security
 
-This plugin only appends rewind-marker events to the session log; it never deletes or rewrites logged history. File writes happen only when you choose "conversation and code" — before-backups and restores stay under `~/.dsh/rewind-snapshots/`. It never touches your git repository, makes no network requests, and accesses no credentials.
+This plugin only appends rewind-marker events to the session log; it never deletes or rewrites logged history. Workspace files are written only when you choose "conversation and code"; backups and restores stay under `~/.dsh/rewind-snapshots/`. It never touches your git repository, makes no network requests, and accesses no credentials.
 
 > **Note:** a rewind only hides messages from view — the exported session log (`/export`) still contains them, and this plugin cannot alter exports. To remove a conversation completely, delete its session file.
 
@@ -127,7 +128,7 @@ npm install            # devDeps from the npm registry
 npm run typecheck      # tsc on both compilation surfaces (host + client)
 npm test               # vitest: rewind / snapshot / hidden / session-cwd / integration
 npm run build          # esbuild: lib/index.js (host ESM) + lib/client.js (loader closure) + .d.ts
-node scripts/verify-host.mjs   # boot the BUILT host artifact end-to-end (18 checks)
+node scripts/verify-host.mjs   # boot the BUILT host artifact end-to-end
 ```
 
 `prepare` runs the full build, so git installs and `npm pack` / `npm publish` always produce a complete `lib/` and the `LICENSE`.

package/README.zh.md

@@ -53,6 +53,8 @@ dsh plugin --profile web add dsh-rewind-plugin
 
 **命令行入口**：输入裸 `/rewind` 回车打开候选面板，选择目标后流程与按钮一致。
 
+候选面板与模式弹层均支持键盘操作：↑↓ 移动、Enter 确认、Esc 取消/返回。
+
 回退可重复进行（每次追加一条标记到日志）。回退无法通过插件撤销，但可以手动编辑会话日志恢复。文件还原动作不再记录新备份。
 
 ## 原理
@@ -74,17 +76,16 @@ dsh plugin --profile web add dsh-rewind-plugin
 
 1. **写前备份**（`tools/execute`，around-dispatch 阶段）：读取目标文件，把解析后的路径与内容放入 pending 表。此阶段只在任何 pre-execute 审批门放行之后运行——审批 `ask` 短路（dsh-edit-approval）**无法跳过**备份，被拒绝的调用也不会记录。若读取失败（如权限错误），该次变更直接不入备份——插件只在日志中警告，**不会阻塞写操作**。
 2. **落盘提交**（`tools/post-execute`）：备份按当前轮**锚点消息 seq** 写入 `~/.dsh/rewind-snapshots/<会话>/<锚点 seq>/<callId>.json`。
-3. **还原**（`/rewind @<seq> both`）：锚点 ≥ 目标的每条备份生效——被修改的文件写回其**最早一次**捕获的 before 内容，目标之后新建的文件被删除，符号/硬链接跳过（它们与另一名字共享 inode，透过一个还原会误伤两个）。写入走纯 `node:fs`，不经 fs 服务——sandbox / 远程 backend 下路径解析可能受限。
+3. **还原**（`/rewind @<seq> both`）：锚点 ≥ 目标的备份与磁盘**对账后生效**（改过的写回最早 before、新建的删除、一致的跳过——幂等）。符号/硬链接跳过（它们与另一名字共享 inode，透过一个还原会误伤两个）。写入走纯 `node:fs`，不经 fs 服务——sandbox / 远程 backend 下路径解析可能受限。
 4. 工具体**抛异常**会跳过 `tools/post-execute`；`tools/result` 兜底清掉 pending，避免内存泄漏。
 
 备份跨 host 重启持久化，每会话有界保留最近 100 组锚点。
 
 ## 明确不做的事
 
-- **整树 / git-first 快照**——只备份写类工具编辑。`bash`、其他工具与外部程序的修改不在备份内、无法还原：与 Claude Code 相同，官方同样不覆盖，此类回退交由用户 git 处理。
+- **整树 / git-first 快照**——只备份写类工具编辑及已追踪文件的外部改动；从未被工具碰过的文件不还原：与 Claude Code 相同，此类回退交由用户 git 处理。
 - **子代理（subagent）的编辑**——不跟踪（同 Claude Code）：子代理运行在自己的会话里，其备份无法被父会话的回退还原。
 - **fork / 分支回退与 `/compact`**——harness 已内置（「在新对话中分支」、compact）。
-- **快捷键**（esc+esc 打开回退菜单）——规划中的后续项。
 
 ## 与同类项目对比
 
@@ -116,7 +117,7 @@ dsh plugin --profile web add dsh-rewind-plugin
 
 ## 安全
 
-本插件只向会话日志追加回退标记事件，从不删除或改写已记录的历史。文件写入仅在你选择「回退对话和代码」时发生，备份与还原都限定在 `~/.dsh/rewind-snapshots/` 内。不触碰你的 git 仓库，无网络请求，不访问任何凭据。
+本插件只向会话日志追加回退标记事件，从不删除或改写已记录的历史。工作区文件仅在「回退对话和代码」时被改写，备份与还原都限定在 `~/.dsh/rewind-snapshots/` 内。不触碰你的 git 仓库，无网络请求，不访问任何凭据。
 
 > **注意：** 回退只是把消息从视图中隐藏——导出的会话日志（`/export`）仍包含撤回前的内容，本插件无法改动导出。要彻底删除对话，请删除对应的会话文件。
 
@@ -127,7 +128,7 @@ npm install            # devDeps 来自 npm registry
 npm run typecheck      # tsc 双面编译（host + client）
 npm test               # vitest：rewind / snapshot / hidden / session-cwd / 集成
 npm run build          # esbuild：lib/index.js（host ESM）+ lib/client.js（loader 闭包）+ .d.ts
-node scripts/verify-host.mjs   # 端到端验证构建产物（18 项检查）
+node scripts/verify-host.mjs   # 端到端验证构建产物
 ```
 
 `prepare` 执行完整构建，所以 git 安装与 `npm pack` / `npm publish` 总会产出完整的 `lib/` 与 `LICENSE`。

package/lib/client.js

@@ -33,9 +33,9 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/client/hidden.ts
-function targetOfOutcome(text) {
-  if (text === void 0) return void 0;
-  const match = text.match(/seq (\d+)/);
+function targetSeqOfArgs(args) {
+  if (args === void 0 || args === null) return void 0;
+  const match = args.match(/@(\d+)/);
   return match !== null ? Number(match[1]) : void 0;
 }
 function isExecutedRewindCommand(node, seq) {
@@ -48,7 +48,7 @@ function hasFileImpact(text) {
   if (text === void 0) return true;
   const match = text.match(/impact=(\d+)/);
   if (match !== null) return Number(match[1]) > 0;
-  return text.includes("\u5C06\u5F71\u54CD");
+  return false;
 }
 function isPreviewCommand(command) {
   return (command.args ?? "").includes("preview");
@@ -69,7 +69,7 @@ function hiddenSeqsOf(snap) {
     const marker = command.outcome.sourceEventSeq;
     if (marker === void 0) continue;
     hidden.add(command.seq);
-    const target = targetOfOutcome(command.outcome.text);
+    const target = targetSeqOfArgs(command.args);
     if (target !== void 0) {
       spans.push({ start: target, end: marker });
     }
@@ -304,8 +304,14 @@ function formatTarget(t, seq, time, preview) {
   const previewText = preview.length > 0 ? preview : t("popover.noText");
   return `seq ${seq} \xB7 ${hh}:${mm} \xB7 ${previewText}`;
 }
-function stripImpactToken(text) {
-  return text.replace(/\n?impact=\d+\s*$/, "");
+function parseImpactList(text) {
+  const restores = [];
+  const deletes = [];
+  for (const line of text.split("\n")) {
+    if (line.startsWith("restore:")) restores.push(line.slice("restore:".length));
+    else if (line.startsWith("delete:")) deletes.push(line.slice("delete:".length));
+  }
+  return { restores, deletes };
 }
 function findCommand(snapshot, match) {
   let found;
@@ -419,7 +425,20 @@ function renderImpactStep(root, opts, back, cached) {
       impact.textContent = t("popover.impact.failed", { message: outcome.text ?? "unknown error" });
       return;
     }
-    impact.textContent = outcome.text === void 0 ? t("popover.impact.none") : stripImpactToken(outcome.text);
+    if (outcome.text === void 0) {
+      impact.textContent = t("popover.impact.none");
+    } else {
+      const { restores, deletes } = parseImpactList(outcome.text);
+      if (restores.length === 0 && deletes.length === 0) {
+        impact.textContent = t("popover.impact.none");
+      } else {
+        const lines = [
+          ...restores.map((path) => t("popover.impact.restore", { path })),
+          ...deletes.map((path) => t("popover.impact.delete", { path }))
+        ];
+        impact.textContent = lines.join("\n");
+      }
+    }
     confirm.disabled = false;
     confirm.focus();
     confirm.addEventListener("click", () => {
@@ -738,6 +757,8 @@ var zh = {
   "popover.impact.loading": "\u6B63\u5728\u83B7\u53D6\u5F71\u54CD\u6E05\u5355\u2026",
   "popover.impact.failed": "\u65E0\u6CD5\u83B7\u53D6\u5F71\u54CD\u6E05\u5355\uFF1A{message}",
   "popover.impact.none": "\u76EE\u6807\u4E4B\u540E\u6CA1\u6709\u8DDF\u8E2A\u5230\u7684\u5199\u7C7B\u53D8\u66F4\uFF0C\u65E0\u9700\u8FD8\u539F\u6587\u4EF6\u3002",
+  "popover.impact.restore": "\u8FD8\u539F {path}",
+  "popover.impact.delete": "\u5220\u9664 {path}",
   "popover.confirm": "\u786E\u8BA4\u56DE\u9000",
   "popover.back": "\u8FD4\u56DE",
   "guard.hint": "/rewind \u624B\u52A8\u8F93\u5165\u4E0D\u63A5\u53D7\u53C2\u6570\uFF0C\u8BF7\u76F4\u63A5\u8F93\u5165 /rewind \u6253\u5F00\u56DE\u9000\u83DC\u5355"
@@ -757,6 +778,8 @@ var en = {
   "popover.impact.loading": "Fetching impact list\u2026",
   "popover.impact.failed": "Could not fetch the impact list: {message}",
   "popover.impact.none": "No tracked file changes after the target; nothing to restore.",
+  "popover.impact.restore": "Restore {path}",
+  "popover.impact.delete": "Delete {path}",
   "popover.confirm": "Confirm rewind",
   "popover.back": "Back",
   "guard.hint": "/rewind takes no typed arguments \u2014 enter /rewind to open the rewind picker."

package/lib/index.js

@@ -1,6 +1,74 @@
 // src/index.ts
 import { createAssistantMessage } from "@deepseek-ai/dsh-llm";
 import { unlink } from "node:fs/promises";
+import { settingsNamespace } from "@deepseek-ai/dsh-settings";
+
+// src/locales.ts
+var en = {
+  "usage.title": "Usage:",
+  "usage.noArgs": "  /rewind                       (no args) withdraw the most recent user message",
+  "usage.seq": "  /rewind @<seq> chat|both      rewind to the given message (chat = conversation only / both = conversation + files)",
+  "usage.blocked": "  Manual /rewind input is intercepted; use the \u21B6 button next to a message",
+  "describeTarget.seq": "seq {seq}",
+  "describeTarget.index": "message {index}",
+  "plan.rewinding": "Rewind to seq {targetSeq}, removing {count} node(s) from the model context (conversation log kept).",
+  "plan.affects": "Affects {count} file(s):",
+  "plan.restore": "restore {path}",
+  "plan.delete": "delete {path}",
+  "plan.noChanges": "No restorable changes after the target.",
+  "error.invalidTarget": 'Cannot parse target "{raw}" (expected <index> or @<seq>)',
+  "failures.suffix": "; {count} file(s) failed to restore: {list}",
+  "failures.item": "{path} ({message})",
+  "inflight": "A rewind is already running for this session; please wait.",
+  "stopFailed": "Could not stop the running agent; rewind cancelled. Please try again.",
+  "cancelled": "Rewind cancelled.",
+  "failed": "Rewind failed: {error}. The session is unchanged.",
+  "restore.count": "restored {count} file(s)",
+  "delete.count": "deleted {count} file(s)",
+  "skip.count": "skipped {count} link(s)",
+  "noRestorable": "; no restorable write-class changes after the target",
+  "success": "Withdrawn seq {targetSeq} and everything after it (conversation returned to earlier){restore}.",
+  "noUserMessages": "This session has no rewindable user messages yet.",
+  "chooseMode": "Rewind to {target}. Choose a mode:\n  /rewind {target} chat  conversation only\n  /rewind {target} both  conversation + file restore",
+  "command.description": "Rewind the conversation back to an earlier user message (optionally restoring files)"
+};
+var zh = {
+  "usage.title": "\u7528\u6CD5\uFF1A",
+  "usage.noArgs": "  /rewind                       \uFF08\u65E0\u53C2\u6570\uFF09\u64A4\u56DE\u6700\u8FD1\u4E00\u6761\u7528\u6237\u6D88\u606F",
+  "usage.seq": "  /rewind @<seq> chat|both      \u56DE\u9000\u5230\u6307\u5B9A\u6D88\u606F\uFF08chat \u4EC5\u5BF9\u8BDD / both \u5BF9\u8BDD+\u6587\u4EF6\uFF09",
+  "usage.blocked": "  \u624B\u52A8\u8F93\u5165 /rewind \u4F1A\u88AB\u62E6\u622A\uFF0C\u8BF7\u4F7F\u7528\u6D88\u606F\u65C1\u7684\u300C\u56DE\u9000\u300D\u6309\u94AE",
+  "describeTarget.seq": "seq {seq}",
+  "describeTarget.index": "\u7B2C {index} \u6761\u6D88\u606F",
+  "plan.rewinding": "\u5C06\u56DE\u9000\u5230 seq {targetSeq}\uFF0C\u4ECE\u6A21\u578B\u4E0A\u4E0B\u6587\u79FB\u9664 {count} \u4E2A\u8282\u70B9\uFF08\u5BF9\u8BDD\u65E5\u5FD7\u4FDD\u7559\uFF09\u3002",
+  "plan.affects": "\u5C06\u5F71\u54CD {count} \u4E2A\u6587\u4EF6\uFF1A",
+  "plan.restore": "\u8FD8\u539F {path}",
+  "plan.delete": "\u5220\u9664 {path}",
+  "plan.noChanges": "\u76EE\u6807\u4E4B\u540E\u6CA1\u6709\u9700\u8981\u8FD8\u539F\u7684\u53D8\u66F4\u3002",
+  "error.invalidTarget": '\u65E0\u6CD5\u89E3\u6790\u76EE\u6807 "{raw}"\uFF08\u5E94\u4E3A <\u5E8F\u53F7> \u6216 @<seq>\uFF09',
+  "failures.suffix": "\uFF1B{count} \u4E2A\u6587\u4EF6\u8FD8\u539F\u5931\u8D25\uFF1A{list}",
+  "failures.item": "{path}\uFF08{message}\uFF09",
+  "inflight": "\u8BE5\u4F1A\u8BDD\u5DF2\u6709\u4E00\u4E2A\u56DE\u9000\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7A0D\u5019\u3002",
+  "stopFailed": "\u65E0\u6CD5\u505C\u6B62\u8FD0\u884C\u4E2D\u7684 agent\uFF0C\u56DE\u9000\u5DF2\u53D6\u6D88\u3002\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002",
+  "cancelled": "\u56DE\u9000\u5DF2\u53D6\u6D88\u3002",
+  "failed": "\u56DE\u9000\u5931\u8D25\uFF1A{error}\u3002\u4F1A\u8BDD\u672A\u6539\u53D8\u3002",
+  "restore.count": "\u8FD8\u539F {count} \u4E2A\u6587\u4EF6",
+  "delete.count": "\u5220\u9664 {count} \u4E2A\u6587\u4EF6",
+  "skip.count": "\u8DF3\u8FC7 {count} \u4E2A\u94FE\u63A5",
+  "noRestorable": "\uFF1B\u76EE\u6807\u4E4B\u540E\u6CA1\u6709\u53EF\u8FD8\u539F\u7684\u5199\u7C7B\u53D8\u66F4",
+  "success": "\u5DF2\u64A4\u56DE seq {targetSeq} \u53CA\u4E4B\u540E\u5185\u5BB9\uFF08\u5BF9\u8BDD\u5DF2\u56DE\u5230\u6B64\u524D\uFF09{restore}\u3002",
+  "noUserMessages": "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u53EF\u56DE\u9000\u7684\u7528\u6237\u6D88\u606F\u3002",
+  "chooseMode": "\u5C06\u56DE\u9000\u5230 {target}\u3002\u9009\u62E9\u6A21\u5F0F\uFF1A\n  /rewind {target} chat  \u4EC5\u56DE\u9000\u5BF9\u8BDD\n  /rewind {target} both  \u56DE\u9000\u5BF9\u8BDD\u5E76\u8FD8\u539F\u6587\u4EF6",
+  "command.description": "\u5728\u540C\u7A97\u53E3\u5185\u5C06\u5BF9\u8BDD\u56DE\u9000\u5230\u66F4\u65E9\u7684\u7528\u6237\u6D88\u606F\uFF08\u53EF\u540C\u65F6\u8FD8\u539F\u6587\u4EF6\uFF09"
+};
+var HOST_DICTS = { en, zh };
+function translate(lang, key, params = {}) {
+  const dict = HOST_DICTS[lang] ?? en;
+  let text = dict[key] ?? key;
+  for (const [name2, value] of Object.entries(params)) {
+    text = text.split(`{${name2}}`).join(String(value));
+  }
+  return text;
+}
 
 // src/rewind.ts
 var RewindError = class extends Error {
@@ -105,12 +173,24 @@ function execSessionCwd(exec, requestedPath) {
 }
 
 // src/snapshot.ts
+import { createHash } from "node:crypto";
 import { lstat, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 var DEFAULT_SNAPSHOT_ROOT = join(homedir(), ".dsh", "rewind-snapshots");
 var SNAPSHOT_ROOT_ENV = "DSH_REWIND_SNAPSHOT_DIR";
 var MAX_ANCHOR_GROUPS = 100;
+var defaultProbe = {
+  async readText(path) {
+    try {
+      return await readFile(path, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  },
+  isLink: isLinkPath
+};
 function safeFileId(callId) {
   return callId.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
@@ -212,43 +292,99 @@ var SnapshotStore = class _SnapshotStore {
     }
     return earliest;
   }
-  /** Per-file restore impact for the earliest entry at/after the target. */
-  async impactsAfter(sessionId, targetSeq) {
-    return [...(await this.earliestEntries(sessionId, targetSeq)).values()].sort((a, b) => a.path.localeCompare(b.path)).map((entry) => ({
-      path: entry.path,
-      action: entry.before === null ? "delete" : "restore"
-    }));
-  }
   /**
-   * Restore the workspace to the target message's checkpoint: for every path
-   * with entries anchored at or after it, apply the EARLIEST entry — write the
-   * before content back, or delete the file when it was created after the
-   * target. Symlinked and hard-linked paths are skipped (reported, never
-   * written through); a restored file's parent directory is created when it
-   * was deleted after the backup. Failures are per-file and never abort the
-   * pass.
+   * The single source of truth for BOTH the impact preview and the restore
+   * pass: reconcile the earliest recorded entry per path (at/after the
+   * target) against the CURRENT on-disk state, and plan only the actions
+   * that would actually change the disk. This is the Claude Code model —
+   * `fileHistoryGetDiffStats` / `applySnapshot` both compare against the
+   * live filesystem (`checkOriginFileChanged`) and count only real
+   * differences, so a rewind whose target state already matches the disk is
+   * a no-op with zero impact.
+   *
+   * - `before === null` (the file did not exist at the target) plans a
+   *   `delete` ONLY when the file currently exists; an already-absent file
+   *   is a no-op — this kills the "ghost impact" of replaying an entry a
+   *   previous rewind already consumed.
+   * - `before === 'X'` plans a `restore` ONLY when the current content
+   *   differs from X (or the file is missing); identical content is a no-op
+   *   — this keeps repeated rewinds idempotent.
+   * - Symlinked / hard-linked paths are never planned (they are reported as
+   *   skipped by the restore pass, never written through).
+   * - A probe failure (e.g. a permission error reading the file) plans the
+   *   action conservatively as if the file differed, so an unreadable file
+   *   is never silently dropped from the restore.
+   *
+   * @param sessionId - session whose snapshot store to plan against.
+   * @param targetSeq - rewind target; entries anchored at/after it apply.
+   * @param probe - current-disk state probe (defaults to the real FS).
+   * @returns the planned actions plus the link paths that were skipped.
    */
-  async restoreAfter(sessionId, targetSeq, deleteFile) {
-    const restored = [];
-    const deleted = [];
+  async planRestore(sessionId, targetSeq, probe) {
+    const actions = [];
     const skipped = [];
-    const failed = [];
     for (const entry of (await this.earliestEntries(sessionId, targetSeq)).values()) {
       try {
-        if (await isLinkPath(entry.path)) {
+        if (await probe.isLink(entry.path)) {
           skipped.push(entry.path);
           continue;
         }
+        const current = await probe.readText(entry.path);
         if (entry.before === null) {
-          await deleteFile(entry.path);
-          deleted.push(entry.path);
+          if (current !== void 0) actions.push({ path: entry.path, action: "delete" });
+        } else if (current !== entry.before) {
+          actions.push({ path: entry.path, action: "restore", before: entry.before });
+        }
+      } catch (error) {
+        if (entry.before === null) {
+          actions.push({ path: entry.path, action: "delete" });
+        } else {
+          actions.push({ path: entry.path, action: "restore", before: entry.before });
+        }
+      }
+    }
+    return { actions, skipped };
+  }
+  /** Per-file restore impact: only actions that would actually change the disk. */
+  async impactsAfter(sessionId, targetSeq, probe = defaultProbe) {
+    const { actions } = await this.planRestore(sessionId, targetSeq, probe);
+    return actions.sort((a, b) => a.path.localeCompare(b.path)).map((action) => ({ path: action.path, action: action.action }));
+  }
+  /**
+   * Restore the workspace to the target message's checkpoint: execute exactly
+   * the actions {@link planRestore} derived from the record + current disk
+   * reconciliation — write the before content back, or delete the file when
+   * it was created after the target and still exists. Symlinked and
+   * hard-linked paths are skipped (reported, never written through); a
+   * restored file's parent directory is created when it was deleted after
+   * the backup; a delete whose file is ALREADY absent is a silent no-op (not
+   * a failure — the target state is already reached). Failures are per-file
+   * and never abort the pass.
+   */
+  async restoreAfter(sessionId, targetSeq, deleteFile, probe = defaultProbe) {
+    const restored = [];
+    const deleted = [];
+    const skipped = [];
+    const failed = [];
+    const { actions, skipped: skippedPaths } = await this.planRestore(sessionId, targetSeq, probe);
+    skipped.push(...skippedPaths);
+    for (const action of actions) {
+      try {
+        if (action.action === "delete") {
+          try {
+            await deleteFile(action.path);
+          } catch (error) {
+            if (error.code !== "ENOENT") throw error;
+            continue;
+          }
+          deleted.push(action.path);
         } else {
-          await mkdir(dirname(entry.path), { recursive: true });
-          await writeFile(entry.path, entry.before, "utf8");
-          restored.push(entry.path);
+          await mkdir(dirname(action.path), { recursive: true });
+          await writeFile(action.path, action.before, "utf8");
+          restored.push(action.path);
         }
       } catch (error) {
-        failed.push({ path: entry.path, message: error instanceof Error ? error.message : String(error) });
+        failed.push({ path: action.path, message: error instanceof Error ? error.message : String(error) });
       }
     }
     return { restored, deleted, skipped, failed };
@@ -283,19 +419,64 @@ var SnapshotStore = class _SnapshotStore {
       throw error;
     }
   }
+  /**
+   * All distinct paths ever recorded for a session — the "tracked files"
+   * set. Mirrors Claude Code's global `trackedFiles` collection (files stay
+   * tracked once a write-class tool touched them), derived from the disk
+   * entries so no extra persistence is needed.
+   */
+  async trackedPaths(sessionId) {
+    const paths = /* @__PURE__ */ new Set();
+    for (const entry of await this.entriesAfter(sessionId, 0)) {
+      paths.add(entry.path);
+    }
+    return paths;
+  }
 };
+function hashPath(path) {
+  return createHash("sha256").update(path).digest("hex").slice(0, 8);
+}
+async function reconcileTracked(store, sessionId, anchorSeq, tracked, states, probe = defaultProbe) {
+  let recorded = 0;
+  for (const path of tracked) {
+    try {
+      if (await probe.isLink(path)) continue;
+      const current = await probe.readText(path);
+      const state = current ?? null;
+      const prev = states.get(path);
+      if (prev === void 0 || prev !== state) {
+        await store.recordEntry(sessionId, {
+          callId: `recheck-${anchorSeq}-${hashPath(path)}`,
+          anchorSeq,
+          path,
+          before: state
+        });
+        states.set(path, state);
+        recorded++;
+      }
+    } catch {
+    }
+  }
+  return recorded;
+}
 
 // src/index.ts
 var name = "dsh-rewind";
 var inject = ["commands", "tools"];
 var TRACKED_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "str_replace_editor"]);
 var MUTATING_EDITOR_COMMANDS = /* @__PURE__ */ new Set(["create", "str_replace", "insert"]);
-var USAGE = [
-  "Usage:",
-  "  /rewind                       \uFF08\u65E0\u53C2\u6570\uFF09\u64A4\u56DE\u6700\u8FD1\u4E00\u6761\u7528\u6237\u6D88\u606F",
-  "  /rewind @<seq> chat|both      \u56DE\u9000\u5230\u6307\u5B9A\u6D88\u606F\uFF08chat \u4EC5\u5BF9\u8BDD / both \u5BF9\u8BDD+\u6587\u4EF6\uFF09",
-  "  \u624B\u52A8\u8F93\u5165 /rewind \u4F1A\u88AB\u62E6\u622A\uFF0C\u8BF7\u4F7F\u7528\u6D88\u606F\u65C1\u7684\u300C\u56DE\u9000\u300D\u6309\u94AE"
-].join("\n");
+var activeLocale = "en";
+function t(key, params) {
+  return translate(activeLocale, key, params);
+}
+function usage() {
+  return [
+    t("usage.title"),
+    t("usage.noArgs"),
+    t("usage.seq"),
+    t("usage.blocked")
+  ].join("\n");
+}
 function mutationPathOf(exec) {
   const args = exec.arguments;
   if (exec.name === "write" || exec.name === "edit") {
@@ -352,7 +533,7 @@ async function captureBefore(fs, exec, pending) {
   const before = await readTextOrUndefined(fs, target, exec.signal);
   pending.set(`${exec.agent?.id ?? "anon"}:${exec.callId}`, { path: target.displayPath, before });
 }
-async function commitEntry(store, pending, anchorCache, exec, result) {
+async function commitEntry(store, pending, anchorCache, trackedBySession, exec, result) {
   const key = `${exec.agent?.id ?? "anon"}:${exec.callId}`;
   const capture = pending.get(key);
   if (capture === void 0) return;
@@ -368,6 +549,12 @@ async function commitEntry(store, pending, anchorCache, exec, result) {
     path: capture.path,
     before: capture.before ?? null
   });
+  let tracked = trackedBySession.get(agent.session.id);
+  if (tracked === void 0) {
+    tracked = /* @__PURE__ */ new Set();
+    trackedBySession.set(agent.session.id, tracked);
+  }
+  tracked.add(capture.path);
 }
 function buildMarker() {
   return createAssistantMessage({
@@ -376,33 +563,62 @@ function buildMarker() {
   });
 }
 function describeTarget(target) {
-  return target.kind === "seq" ? `seq ${target.seq}` : `\u7B2C ${target.index} \u6761\u6D88\u606F`;
+  return target.kind === "seq" ? t("describeTarget.seq", { seq: target.seq }) : t("describeTarget.index", { index: target.index });
 }
 function formatPlan(plan, files) {
   const lines = [
-    `\u5C06\u56DE\u9000\u5230 seq ${plan.targetSeq}\uFF0C\u4ECE\u6A21\u578B\u4E0A\u4E0B\u6587\u79FB\u9664 ${plan.shadowedSeqs.length} \u4E2A\u8282\u70B9\uFF08\u5BF9\u8BDD\u65E5\u5FD7\u4FDD\u7559\uFF09\u3002`
+    t("plan.rewinding", { targetSeq: plan.targetSeq, count: plan.shadowedSeqs.length })
   ];
   if (files.length > 0) {
-    lines.push(`\u5C06\u5F71\u54CD ${files.length} \u4E2A\u6587\u4EF6\uFF1A`);
+    lines.push(t("plan.affects", { count: files.length }));
     for (const file of files) {
-      lines.push(`  ${file.action === "restore" ? "\u8FD8\u539F" : "\u5220\u9664"} ${file.path}`);
+      lines.push(`  ${file.action === "restore" ? t("plan.restore", { path: file.path }) : t("plan.delete", { path: file.path })}`);
     }
   } else {
-    lines.push("\u76EE\u6807\u4E4B\u540E\u6CA1\u6709\u5FEB\u7167\u8BB0\u5F55\u7684\u5199\u7C7B\u53D8\u66F4\uFF0C\u65E0\u9700\u8FD8\u539F\u6587\u4EF6\u3002");
+    lines.push(t("plan.noChanges"));
   }
   lines.push(`impact=${files.length}`);
+  for (const file of files) {
+    lines.push(`${file.action}:${file.path}`);
+  }
   return lines.join("\n");
 }
 function resolveOrError(events, surface, raw) {
   const target = parseRewindTarget(raw);
   if (target === void 0) {
-    throw new RewindError("invalid-index", `\u65E0\u6CD5\u89E3\u6790\u76EE\u6807 "${raw}"\uFF08\u5E94\u4E3A <\u5E8F\u53F7> \u6216 @<seq>\uFF09`);
+    throw new RewindError("invalid-index", t("error.invalidTarget", { raw }));
   }
   return planRewind(events, surface, target);
 }
 function renderFailures(failed) {
   if (failed.length === 0) return "";
-  return `\uFF1B${failed.length} \u4E2A\u6587\u4EF6\u8FD8\u539F\u5931\u8D25\uFF1A${failed.map((f) => `${f.path}\uFF08${f.message}\uFF09`).join("\u3001")}`;
+  return t("failures.suffix", {
+    count: failed.length,
+    list: failed.map((f) => t("failures.item", { path: f.path, message: f.message })).join("\u3001")
+  });
+}
+async function resolveObservationTarget(fs, path) {
+  try {
+    return await fs.resolve(path);
+  } catch {
+    return void 0;
+  }
+}
+async function syncRestoreObservations(ctx, fs, agent, outcome) {
+  if (fs === void 0) return;
+  const actor = { agent };
+  for (const path of outcome.deleted) {
+    const target = await resolveObservationTarget(fs, path);
+    if (target === void 0) continue;
+    ctx.emit("fs/observed", target, { kind: "absent" }, actor);
+  }
+  for (const path of outcome.restored) {
+    const target = await resolveObservationTarget(fs, path);
+    if (target === void 0) continue;
+    const info = await fs.stat(target);
+    if (info === void 0) continue;
+    ctx.emit("fs/observed", target, { kind: "present", version: info.version }, actor);
+  }
 }
 async function waitForAgentIdle(agent, signal, timeoutMs = 15e3) {
   if (signal.aborted) return false;
@@ -425,11 +641,11 @@ async function waitForAgentIdle(agent, signal, timeoutMs = 15e3) {
     if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
   }
 }
-async function executeRewind(ctx, store, invocation, rawTarget, mode, inflight) {
+async function executeRewind(ctx, store, fs, invocation, rawTarget, mode, inflight) {
   const { agent } = invocation;
   const sessionId = agent.session.id;
   if (inflight.has(sessionId)) {
-    return { kind: "error", text: "\u8BE5\u4F1A\u8BDD\u5DF2\u6709\u4E00\u4E2A\u56DE\u9000\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7A0D\u5019\u3002" };
+    return { kind: "error", text: t("inflight") };
   }
   inflight.add(sessionId);
   try {
@@ -437,11 +653,11 @@ async function executeRewind(ctx, store, invocation, rawTarget, mode, inflight)
       agent.cancel({ kind: "user" });
       const stopped = await waitForAgentIdle(agent, invocation.signal);
       if (!stopped) {
-        return { kind: "error", text: "\u65E0\u6CD5\u505C\u6B62\u8FD0\u884C\u4E2D\u7684 agent\uFF0C\u56DE\u9000\u5DF2\u53D6\u6D88\u3002\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002" };
+        return { kind: "error", text: t("stopFailed") };
       }
     }
     if (invocation.signal.aborted) {
-      return { kind: "error", text: "\u56DE\u9000\u5DF2\u53D6\u6D88\u3002" };
+      return { kind: "error", text: t("cancelled") };
     }
     let plan;
     try {
@@ -459,22 +675,23 @@ async function executeRewind(ctx, store, invocation, rawTarget, mode, inflight)
     } catch (error) {
       return {
         kind: "error",
-        text: `\u56DE\u9000\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}\u3002\u4F1A\u8BDD\u672A\u6539\u53D8\u3002`
+        text: t("failed", { error: error instanceof Error ? error.message : String(error) })
       };
     }
     let restore = "";
     if (mode === "both") {
       const outcome = await store.restoreAfter(agent.session.id, plan.targetSeq, (path) => unlink(path));
+      await syncRestoreObservations(ctx, fs, agent, outcome);
       const parts = [];
-      if (outcome.restored.length > 0) parts.push(`\u8FD8\u539F ${outcome.restored.length} \u4E2A\u6587\u4EF6`);
-      if (outcome.deleted.length > 0) parts.push(`\u5220\u9664 ${outcome.deleted.length} \u4E2A\u6587\u4EF6`);
-      if (outcome.skipped.length > 0) parts.push(`\u8DF3\u8FC7 ${outcome.skipped.length} \u4E2A\u94FE\u63A5`);
-      restore = parts.length > 0 ? `\uFF1B${parts.join("\u3001")}` : "\uFF1B\u76EE\u6807\u4E4B\u540E\u6CA1\u6709\u53EF\u8FD8\u539F\u7684\u5199\u7C7B\u53D8\u66F4";
+      if (outcome.restored.length > 0) parts.push(t("restore.count", { count: outcome.restored.length }));
+      if (outcome.deleted.length > 0) parts.push(t("delete.count", { count: outcome.deleted.length }));
+      if (outcome.skipped.length > 0) parts.push(t("skip.count", { count: outcome.skipped.length }));
+      restore = parts.length > 0 ? `\uFF1B${parts.join("\u3001")}` : t("noRestorable");
       restore += renderFailures(outcome.failed);
     }
     return {
       kind: "success",
-      text: `\u5DF2\u64A4\u56DE seq ${plan.targetSeq} \u53CA\u4E4B\u540E\u5185\u5BB9\uFF08\u5BF9\u8BDD\u5DF2\u56DE\u5230\u6B64\u524D\uFF09${restore}\u3002`,
+      text: t("success", { targetSeq: plan.targetSeq, restore }),
       sourceEventSeq: event.seq
     };
   } finally {
@@ -484,7 +701,7 @@ async function executeRewind(ctx, store, invocation, rawTarget, mode, inflight)
 function rewindErrorResult(error) {
   if (error instanceof RewindError) {
     const text = {
-      "no-user-messages": "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u53EF\u56DE\u9000\u7684\u7528\u6237\u6D88\u606F\u3002",
+      "no-user-messages": t("noUserMessages"),
       "invalid-index": error.message,
       "not-a-user-message": error.message,
       "not-on-surface": error.message
@@ -493,20 +710,20 @@ function rewindErrorResult(error) {
   }
   throw error;
 }
-async function handleRewind(ctx, store, invocation, inflight) {
+async function handleRewind(ctx, store, fs, invocation, inflight) {
   const session = invocation.agent.session;
   const input = invocation.rawInput.trim();
   if (input === "") {
     const candidates = listRewindCandidates(session.events, session.surface.nodes, 1);
     if (candidates.length === 0) {
-      return { kind: "error", text: "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u53EF\u56DE\u9000\u7684\u7528\u6237\u6D88\u606F\u3002" };
+      return { kind: "error", text: t("noUserMessages") };
     }
-    return executeRewind(ctx, store, invocation, `@${candidates[0].seq}`, "chat", inflight);
+    return executeRewind(ctx, store, fs, invocation, `@${candidates[0].seq}`, "chat", inflight);
   }
   const parts = input.split(/\s+/);
   if (parts[0] === "preview") {
     const target2 = parts[1];
-    if (target2 === void 0) return { kind: "error", text: USAGE };
+    if (target2 === void 0) return { kind: "error", text: usage() };
     let plan;
     try {
       plan = resolveOrError(session.events, session.surface.nodes, target2);
@@ -519,34 +736,66 @@ async function handleRewind(ctx, store, invocation, inflight) {
   const target = parts[0];
   const mode = parts[1];
   if (mode !== void 0 && mode !== "chat" && mode !== "both") {
-    return { kind: "error", text: USAGE };
+    return { kind: "error", text: usage() };
   }
   if (mode === void 0) {
     const parsed = parseRewindTarget(target);
-    if (parsed === void 0) return { kind: "error", text: USAGE };
+    if (parsed === void 0) return { kind: "error", text: usage() };
     return {
       kind: "success",
-      text: `\u5C06\u56DE\u9000\u5230 ${describeTarget(parsed)}\u3002\u9009\u62E9\u6A21\u5F0F\uFF1A
-  /rewind ${target} chat  \u4EC5\u56DE\u9000\u5BF9\u8BDD
-  /rewind ${target} both  \u56DE\u9000\u5BF9\u8BDD\u5E76\u8FD8\u539F\u6587\u4EF6`
+      text: t("chooseMode", { target: describeTarget(parsed) })
     };
   }
-  return executeRewind(ctx, store, invocation, target, mode, inflight);
+  return executeRewind(ctx, store, fs, invocation, target, mode, inflight);
 }
 function apply(ctx, config) {
   const store = new SnapshotStore(config?.snapshotDir);
   const pending = /* @__PURE__ */ new Map();
   const anchorCache = /* @__PURE__ */ new WeakMap();
   const inflight = /* @__PURE__ */ new Set();
+  const trackedBySession = /* @__PURE__ */ new Map();
+  const statesBySession = /* @__PURE__ */ new Map();
+  let fsService;
+  ctx.inject(["settings"], (settingsCtx) => {
+    const section = settingsCtx.settings.get(settingsNamespace("locale"));
+    if (section?.preference === "zh" || section?.preference === "en") {
+      activeLocale = section.preference;
+    }
+  });
   ctx.effect(function* () {
     yield ctx.commands.register({
       name: "rewind",
-      description: "\u5728\u540C\u7A97\u53E3\u5185\u5C06\u5BF9\u8BDD\u56DE\u9000\u5230\u66F4\u65E9\u7684\u7528\u6237\u6D88\u606F\uFF08\u53EF\u540C\u65F6\u8FD8\u539F\u6587\u4EF6\uFF09",
-      handler: (invocation) => handleRewind(ctx, store, invocation, inflight)
+      description: t("command.description"),
+      handler: (invocation) => handleRewind(ctx, store, fsService, invocation, inflight)
     });
   }, "dsh-rewind command");
+  ctx.on("session/event", (session, event) => {
+    if (event.type !== "user/message") return;
+    const header = session.header;
+    if (header.origin === "subagent" || (header.delegationDepth ?? 0) > 0) return;
+    void (async () => {
+      try {
+        const sessionId = session.id;
+        let tracked = trackedBySession.get(sessionId);
+        if (tracked === void 0) {
+          tracked = await store.trackedPaths(sessionId);
+          trackedBySession.set(sessionId, tracked);
+        }
+        if (tracked.size === 0) return;
+        let states = statesBySession.get(sessionId);
+        if (states === void 0) {
+          states = /* @__PURE__ */ new Map();
+          statesBySession.set(sessionId, states);
+        }
+        await reconcileTracked(store, sessionId, event.seq, tracked, states);
+      } catch (error) {
+        ctx.logger.warn(`[dsh-rewind] boundary re-check failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    })();
+  }, { global: true });
   ctx.inject(["fs"], (scope) => {
     const fs = scope.fs;
+    fsService = fs;
     scope.on("tools/execute", async (exec, next) => {
       try {
         await captureBefore(fs, exec, pending);
@@ -557,7 +806,7 @@ function apply(ctx, config) {
     });
     scope.on("tools/post-execute", async (exec, result, next) => {
       try {
-        await commitEntry(store, pending, anchorCache, exec, result);
+        await commitEntry(store, pending, anchorCache, trackedBySession, exec, result);
       } catch (error) {
         ctx.logger.warn(`[dsh-rewind] checkpoint commit failed for ${exec.name}: ${error instanceof Error ? error.message : String(error)}`);
       }

package/lib/types/client/hidden.d.ts

@@ -13,8 +13,12 @@ export interface HiddenChat {
         get(key: string): ChatConversationViewNode | undefined;
     };
 }
-/** Extract the rewind target from a command outcome text ("已撤回 seq N..."). */
-export declare function targetOfOutcome(text: string | undefined): number | undefined;
+/**
+ * Extract the rewind target seq from a `/rewind` command's structured `args`
+ * (e.g. `@5 chat`, `preview @5 both`). Locale-independent — never parses the
+ * host's human outcome copy.
+ */
+export declare function targetSeqOfArgs(args: string | null | undefined): number | undefined;
 /**
  * True when a `/rewind` command node is an EXECUTED rewind for `seq` — the
  * admission form the popover drives (`@<seq> chat` / `both`) that settled
@@ -28,10 +32,10 @@ export declare function isExecutedRewindCommand(node: CommandNode, seq: number):
  * of the "rewind conversation and code" option (Claude Code hides the
  * code-restore options when the checkpoint has no tracked changes).
  *
- * Prefers the machine-readable `impact=<n>` trailer the current host appends
- * to preview text. Older host output (or a history-loaded preview row from
- * before the trailer existed) has none, so it falls back to the human copy
- * ("将影响 …") to keep mixed-version deployments correct.
+ * Reads ONLY the machine-readable `impact=<n>` trailer the host appends to
+ * preview text. Older host output without the trailer is treated as having no
+ * changes (never guesses from human copy). Unknown/absent text degrades to
+ * always-show so a working option is never hidden on a failed probe.
  */
 export declare function hasFileImpact(text: string | undefined): boolean;
 /**

package/lib/types/client/locales.d.ts

@@ -15,6 +15,8 @@ export declare const zh: {
     'popover.impact.loading': string;
     'popover.impact.failed': string;
     'popover.impact.none': string;
+    'popover.impact.restore': string;
+    'popover.impact.delete': string;
     'popover.confirm': string;
     'popover.back': string;
     'guard.hint': string;
@@ -43,6 +45,8 @@ export declare const en: {
     'popover.impact.loading': string;
     'popover.impact.failed': string;
     'popover.impact.none': string;
+    'popover.impact.restore': string;
+    'popover.impact.delete': string;
     'popover.confirm': string;
     'popover.back': string;
     'guard.hint': string;

package/lib/types/locales.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Host-side localization for dsh-rewind's `/rewind` command output and command
+ * description.
+ *
+ * Architecture (matches the dsh ecosystem): the HOST half of a dual-face
+ * plugin has no locale service — only the browser client carries one. The host
+ * therefore renders its command-adjacent copy from a durable user preference
+ * (`ctx.settings` → `locale.preference`, registered by dsh-client-locale),
+ * defaulting to English — the ecosystem's neutral default language (the harness
+ * `FALLBACK_LOCALE` and the language dsh's own host commands use, e.g.
+ * dsh-plan-mode). See packages/client/locale in deepseek-harness.
+ *
+ * The client half (`src/client/locales.ts`) owns all interactive UI copy via
+ * `ctx.locale` + `t()`; the host's human text is a machine channel the client
+ * renders through machine tokens (`impact=<n>`, `args` @seq), never by parsing
+ * host prose.
+ *
+ * English is the key-set source of truth; zh is checked complete against it.
+ *
+ * @module dsh-rewind/locales
+ */
+/** Host-side supported locale ids, mirroring the harness's shipped locales. */
+export type HostLocaleId = 'zh' | 'en';
+/** English dictionary — the key-set source of truth (neutral default). */
+export declare const en: {
+    'usage.title': string;
+    'usage.noArgs': string;
+    'usage.seq': string;
+    'usage.blocked': string;
+    'describeTarget.seq': string;
+    'describeTarget.index': string;
+    'plan.rewinding': string;
+    'plan.affects': string;
+    'plan.restore': string;
+    'plan.delete': string;
+    'plan.noChanges': string;
+    'error.invalidTarget': string;
+    'failures.suffix': string;
+    'failures.item': string;
+    inflight: string;
+    stopFailed: string;
+    cancelled: string;
+    failed: string;
+    'restore.count': string;
+    'delete.count': string;
+    'skip.count': string;
+    noRestorable: string;
+    success: string;
+    noUserMessages: string;
+    chooseMode: string;
+    'command.description': string;
+};
+/** The host rewind dictionary key union. */
+export type HostKey = keyof typeof en;
+/** Chinese dictionary, checked complete against the en key set. */
+export declare const zh: Record<HostKey, string>;
+/** The host dictionaries keyed by locale id. */
+export declare const HOST_DICTS: Record<HostLocaleId, Record<HostKey, string>>;
+/**
+ * Render one dictionary key with `{name}` template interpolation. Unknown
+ * params are ignored; a missing key falls back to the raw key so a dictionary
+ * gap is visible instead of blank.
+ * @param lang - the active locale.
+ * @param key - the dictionary key.
+ * @param params - `{name}` substitution values.
+ */
+export declare function translate(lang: HostLocaleId, key: HostKey, params?: Record<string, string | number>): string;

package/lib/types/snapshot.d.ts

@@ -65,6 +65,34 @@ export interface RestoreOutcome {
 }
 /** Deletes one file by its real path (node:fs, bypassing the fs service). */
 export type DeleteFile = (path: string) => Promise<void>;
+/**
+ * Current-on-disk state probe used by restore planning. Injected so the plan
+ * logic runs against a fake FS in tests; the production default reads the
+ * real file system with plain `node:fs` (see {@link defaultProbe}).
+ */
+export interface DiskProbe {
+    /**
+     * Full text of the file, or undefined when the file does not exist.
+     * Any thrown error is treated as a probe failure: restore planning then
+     * conservatively treats the file as DIFFERING from its record (a restore
+     * still attempts the write / a delete still attempts the unlink), so an
+     * unreadable file is never silently skipped.
+     */
+    readText(path: string): Promise<string | undefined>;
+    /** True when the path is a symlink or a hard link (never planned/restored). */
+    isLink(path: string): Promise<boolean>;
+}
+/** One restore action the planner derived from record + disk reconciliation. */
+export type PlannedAction = {
+    readonly path: string;
+    readonly action: 'restore';
+    readonly before: string;
+} | {
+    readonly path: string;
+    readonly action: 'delete';
+};
+/** Production probe: real reads via node:fs, links detected by lstat + nlink. */
+export declare const defaultProbe: DiskProbe;
 /**
  * On-disk checkpoint store. Every write goes straight through `node:fs`, so a
  * restore reliably lands on the real file system.
@@ -94,18 +122,49 @@ export declare class SnapshotStore {
      * single source of truth for both restore and impact preview.
      */
     private earliestEntries;
-    /** Per-file restore impact for the earliest entry at/after the target. */
-    impactsAfter(sessionId: string, targetSeq: number): Promise<FileImpact[]>;
     /**
-     * Restore the workspace to the target message's checkpoint: for every path
-     * with entries anchored at or after it, apply the EARLIEST entry — write the
-     * before content back, or delete the file when it was created after the
-     * target. Symlinked and hard-linked paths are skipped (reported, never
-     * written through); a restored file's parent directory is created when it
-     * was deleted after the backup. Failures are per-file and never abort the
-     * pass.
+     * The single source of truth for BOTH the impact preview and the restore
+     * pass: reconcile the earliest recorded entry per path (at/after the
+     * target) against the CURRENT on-disk state, and plan only the actions
+     * that would actually change the disk. This is the Claude Code model —
+     * `fileHistoryGetDiffStats` / `applySnapshot` both compare against the
+     * live filesystem (`checkOriginFileChanged`) and count only real
+     * differences, so a rewind whose target state already matches the disk is
+     * a no-op with zero impact.
+     *
+     * - `before === null` (the file did not exist at the target) plans a
+     *   `delete` ONLY when the file currently exists; an already-absent file
+     *   is a no-op — this kills the "ghost impact" of replaying an entry a
+     *   previous rewind already consumed.
+     * - `before === 'X'` plans a `restore` ONLY when the current content
+     *   differs from X (or the file is missing); identical content is a no-op
+     *   — this keeps repeated rewinds idempotent.
+     * - Symlinked / hard-linked paths are never planned (they are reported as
+     *   skipped by the restore pass, never written through).
+     * - A probe failure (e.g. a permission error reading the file) plans the
+     *   action conservatively as if the file differed, so an unreadable file
+     *   is never silently dropped from the restore.
+     *
+     * @param sessionId - session whose snapshot store to plan against.
+     * @param targetSeq - rewind target; entries anchored at/after it apply.
+     * @param probe - current-disk state probe (defaults to the real FS).
+     * @returns the planned actions plus the link paths that were skipped.
+     */
+    private planRestore;
+    /** Per-file restore impact: only actions that would actually change the disk. */
+    impactsAfter(sessionId: string, targetSeq: number, probe?: DiskProbe): Promise<FileImpact[]>;
+    /**
+     * Restore the workspace to the target message's checkpoint: execute exactly
+     * the actions {@link planRestore} derived from the record + current disk
+     * reconciliation — write the before content back, or delete the file when
+     * it was created after the target and still exists. Symlinked and
+     * hard-linked paths are skipped (reported, never written through); a
+     * restored file's parent directory is created when it was deleted after
+     * the backup; a delete whose file is ALREADY absent is a silent no-op (not
+     * a failure — the target state is already reached). Failures are per-file
+     * and never abort the pass.
      */
-    restoreAfter(sessionId: string, targetSeq: number, deleteFile: DeleteFile): Promise<RestoreOutcome>;
+    restoreAfter(sessionId: string, targetSeq: number, deleteFile: DeleteFile, probe?: DiskProbe): Promise<RestoreOutcome>;
     /**
      * Drop the session's oldest anchor groups beyond `keep` (default
      * {@link MAX_ANCHOR_GROUPS}), deleting their whole directories.
@@ -113,4 +172,42 @@ export declare class SnapshotStore {
     prune(sessionId: string, keep?: number): Promise<void>;
     /** True when a path exists on disk (used by tests and diagnostics). */
     exists(path: string): Promise<boolean>;
+    /**
+     * All distinct paths ever recorded for a session — the "tracked files"
+     * set. Mirrors Claude Code's global `trackedFiles` collection (files stay
+     * tracked once a write-class tool touched them), derived from the disk
+     * entries so no extra persistence is needed.
+     */
+    trackedPaths(sessionId: string): Promise<Set<string>>;
 }
+/**
+ * Re-check every tracked file at a user-message boundary and record the
+ * current on-disk state for any file whose state changed since it was last
+ * seen — Claude Code's `fileHistoryMakeSnapshot` re-stats every tracked file
+ * at each user message and snapshots the new state (changed files get a new
+ * backup version, deleted files a null marker). Here the "new version" is a
+ * plain before-backup entry anchored at the boundary message, so an EXTERNAL
+ * edit or deletion (never seen by the write-class tool capture) enters the
+ * record and can be restored by a later rewind.
+ *
+ * Semantics: the recorded `before` is the file's state at the boundary —
+ * the state the boundary message's turn starts from, exactly like the
+ * tool-captured entries. An entry is written only when the state differs
+ * from the last-seen state (`states`); the FIRST sighting of a path always
+ * records (a restart leaves `states` empty, so the first boundary after a
+ * restart unconditionally records the current state — redundant but correct,
+ * mirroring Claude's resume-then-re-stat behavior).
+ *
+ * Symlinked / hard-linked paths are never re-checked (restores skip them).
+ * A probe failure skips the file with a warning-level no-op; it never
+ * aborts the boundary pass.
+ *
+ * @param store - the session's snapshot store.
+ * @param sessionId - session whose tracked files to re-check.
+ * @param anchorSeq - the boundary user-message seq (entry anchor).
+ * @param tracked - the session's tracked path set (read-only here).
+ * @param states - per-path last-seen state (path → content, null = absent).
+ * @param probe - current-disk state probe (defaults to the real FS).
+ * @returns the number of entries recorded.
+ */
+export declare function reconcileTracked(store: SnapshotStore, sessionId: string, anchorSeq: number, tracked: ReadonlySet<string>, states: Map<string, string | null>, probe?: DiskProbe): Promise<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rewind-plugin",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "DeepSeek Harness plugin: in-place conversation rewind in the same session window (Claude Code /rewind semantics) with optional workspace file restore",
   "keywords": [
     "deepseek-harness",
@@ -82,6 +82,7 @@
     "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-sandbox": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.8",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
   },
   "peerDependenciesMeta": {
@@ -115,6 +116,9 @@
     "@deepseek-ai/dsh-session": {
       "optional": true
     },
+    "@deepseek-ai/dsh-settings": {
+      "optional": true
+    },
     "@deepseek-ai/dsh-tools": {
       "optional": true
     }
@@ -132,6 +136,7 @@
     "@deepseek-ai/dsh-llm": "^0.1.0-rc.7",
     "@deepseek-ai/dsh-sandbox": "^0.1.0-rc.7",
     "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.8",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.7",
     "@types/node": "^24.0.0",
     "@types/react": "^18.3.31",