dsh-rewind-plugin 0.2.9 → 0.3.1

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/candidates.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Pure candidate computation for the `/rewind` command decoration: which user
+ * messages the harness's popupSelect shell offers, withdrawn-row exclusion,
+ * preview truncation, and the mapping to popupSelect rows. The listing is a
+ * pure function of the session chat snapshot (`rewindCandidatesOf`) so it
+ * stays unit-testable in a node environment. Surface user/steering messages
+ * only, withdrawn (hidden) rows excluded, newest first — the top row is the
+ * default highlight, i.e. the most recent message and the most common rewind
+ * target.
+ *
+ * @module dsh-rewind/client/candidates
+ */
+import type { SelectOption } from '@deepseek-ai/dsh-client-ui-commands/client';
+import type { RewindKey } from './locales.ts';
+type Translate = (key: RewindKey, params?: Record<string, unknown>) => string;
+/** Preview length cap for candidate rows (matches the host's candidate list). */
+export declare const PREVIEW_CHARS = 80;
+/** One selectable rewind target. */
+export interface RewindCandidate {
+    /** Absolute log seq of the `user/message` event. */
+    readonly seq: number;
+    /** Unix epoch ms of the event. */
+    readonly time: number;
+    /** Truncated plain-text preview of the message content. */
+    readonly preview: string;
+}
+/** A chat snapshot subset the candidate listing reads (structural). */
+export interface CandidateChat {
+    readonly order: readonly string[];
+    readonly nodes: {
+        get(key: string): CandidateUserNode | undefined;
+    };
+}
+/** A user/steering row subset; only fields the listing reads are real. */
+export interface CandidateUserNode {
+    readonly kind: string;
+    readonly anchorSeq?: number;
+    readonly data: {
+        readonly seq: number;
+        readonly time: number;
+        readonly content: readonly {
+            type: string;
+            text?: unknown;
+        }[];
+    };
+}
+/** Join the text blocks of a user message into one plain preview. */
+export declare function messagePreviewOf(message: {
+    readonly content: readonly {
+        type: string;
+        text?: unknown;
+    }[];
+}): string;
+/** Format a candidate row's clock time (`HH:MM`), matching the host format. */
+export declare function formatCandidateTime(time: number): string;
+/**
+ * List the selectable rewind candidates of a session chat snapshot: user and
+ * steering rows still on the surface (not hidden by a previous rewind), the
+ * newest `limit` kept, newest first — the top row is the default highlight,
+ * i.e. the most recent message and the most common rewind target.
+ * @param snap - the session chat snapshot.
+ * @param hidden - anchor seqs withdrawn by rewinds (from `hiddenSeqsOf`).
+ * @param limit - maximum number of candidates to return.
+ */
+export declare function rewindCandidatesOf(snap: CandidateChat, hidden: ReadonlySet<number>, limit?: number): RewindCandidate[];
+/** The candidates of a live chat snapshot, withdrawn rows already excluded. */
+export declare function rewindCandidatesOfChat(snap: CandidateChat): RewindCandidate[];
+/**
+ * Map the candidates to popupSelect rows: the message preview as the row
+ * label (left) and the clock time as the detail (right) — the shell's native
+ * label/detail flex layout, with no recency numbers.
+ */
+export declare function rewindOptionsOf(snap: CandidateChat, t: Translate): SelectOption[];
+/** Resolve one candidate by log seq (the mode popover's re-entry after a pick). */
+export declare function candidateBySeq(snap: CandidateChat, seq: number): RewindCandidate | undefined;
+export {};