dsh-rewind-plugin 0.2.5 → 0.2.7

package/README.md

@@ -4,7 +4,9 @@
 
 In-place conversation rewind for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness): the Claude Code `/rewind` semantics inside the **same session window** — cut the model context back to an earlier user message, and optionally restore workspace files from **disk-persisted before-backups**.
 
-> **Status:** published to npm (`dsh-rewind-plugin`, v0.2.5) via GitHub Actions Trusted Publishing + Sigstore provenance. Targets the web profile (`dsh --profile web`). Interaction mirrors Claude Code's rewind, adapted to dsh's real web UI.
+> **Status:** published to npm (`dsh-rewind-plugin`, v0.2.7) via GitHub Actions Trusted Publishing + Sigstore provenance. Targets the web profile (`dsh --profile web`). Interaction mirrors Claude Code's rewind, adapted to dsh's real web UI.
+>
+> **v0.2.7 highlights:** composer refill is event-driven (reopening a session never resurrects withdrawn text); subagent edits are not tracked (Claude Code alignment); concurrent rewinds are guarded; the code-restore option appears only when tracked changes exist (mixed host/client versions safe).
 
 [![npm version](https://img.shields.io/npm/v/dsh-rewind-plugin.svg)](https://www.npmjs.com/package/dsh-rewind-plugin)
 [![npm license](https://img.shields.io/npm/l/dsh-rewind-plugin.svg)](https://github.com/SiriLee/dsh-rewind/blob/main/LICENSE)
@@ -85,20 +87,26 @@ conversation**: the marker's turn number collided with the next real turn's
 `Failed to load history: conversation Context …:turn-tail… received an update before its start Match (internal)`
 and the history vanished. Rewinds created from 0.2.5 on no longer produce the
 collision, but **already-corrupted sessions need an offline repair** (the log is
-append-only — it cannot be rewritten in memory):
+append-only — it cannot be rewritten in memory).
+
+The repair tool ships **inside the npm package** (`dsh-rewind-repair`) — no
+source checkout needed:
 
 ```sh
 # 1. Fully quit dsh web / host first (while a session is resident in memory,
 #    a disk repair is overwritten by the next checkpoint)
-# 2. Run the offline repair script (scans every session under ~/.dsh/sessions,
+# 2. Run the offline repair (scans every session under ~/.dsh/sessions,
 #    rewriting each marker's turn back to the last started turn)
-node scripts/repair-markers.mjs            # default: scan ~/.dsh/sessions
-node scripts/repair-markers.mjs --dry-run  # report only, no writes
-node scripts/repair-markers.mjs --dir <sessions root>  # custom data dir
+npm exec --yes --package=dsh-rewind-plugin -- dsh-rewind-repair
+npm exec --yes --package=dsh-rewind-plugin -- dsh-rewind-repair -- --dry-run  # preview only
 # 3. Restart dsh web — the repaired sessions load their history again
 ```
 
-The script only rewrites the `data.turn` of `dsh-rewind` empty-marker events
+Or install it globally once (`npm i -g dsh-rewind-plugin`) and run
+`dsh-rewind-repair` directly; from a source checkout the same tool is
+`node scripts/repair-markers.mjs` (identical flags).
+
+The tool only rewrites the `data.turn` of `dsh-rewind` empty-marker events
 (keeping seqs, order, and the zstd frame structure intact), backs up the original
 file to `session.jsonl.zstd.bak-<timestamp>` before writing, and never touches
 any other event — safe to run repeatedly.
@@ -157,6 +165,7 @@ Rewinding to a message **withdraws** it and everything after it — the transcri
 ## Behavior details & limitations
 
 - Only **write-class tools** running while the plugin is active are tracked (`write` / `edit` / `str_replace_editor`). Changes made by `bash`, other tools, or external programs are not backed up and cannot be restored — the same limitation as Claude Code, which also defers such rollbacks to the user's git.
+- **Subagent edits are 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; the capture is skipped instead of recording to an unreachable store.
 - If a before-capture read fails (e.g. a permission error), that change is simply not backed up and a `both` rewind cannot restore it — the plugin logs a warning but **does not block the write**.
 - File restore/delete writes through the **real local filesystem**; under sandbox / remote backends path resolution may be restricted.
 - Symbolic links and hard links are not written through (they share the inode with another name; a restore would clobber both) — they are skipped and reported.

package/README.zh.md

@@ -4,7 +4,9 @@
 
 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 插件：**同一会话窗口的 in-place 对话回退**（Claude Code `/rewind` 语义）——把模型上下文剪回更早的一条用户消息，并可基于**落盘的写前备份**还原工作区文件。
 
-> **状态**：已发布 npm（`dsh-rewind-plugin`，v0.2.5），经 GitHub Actions Trusted Publishing + Sigstore provenance 构建发布。目标为 web 配置档（`dsh --profile web`）。交互以 Claude Code 的 rewind 为参考，并贴合 dsh Web 实际 UI。
+> **状态**：已发布 npm（`dsh-rewind-plugin`，v0.2.7），经 GitHub Actions Trusted Publishing + Sigstore provenance 构建发布。目标为 web 配置档（`dsh --profile web`）。交互以 Claude Code 的 rewind 为参考，并贴合 dsh Web 实际 UI。
+>
+> **v0.2.7 要点**：输入框回填改为事件驱动（重开会话不再复活已撤回文本）；子代理编辑不跟踪（对齐 Claude Code）；并发回退有防护；「回退代码」选项仅在存在跟踪变更时显示（兼容新旧 host/client 混合版本）。
 
 [![npm version](https://img.shields.io/npm/v/dsh-rewind-plugin.svg)](https://www.npmjs.com/package/dsh-rewind-plugin)
 [![npm license](https://img.shields.io/npm/l/dsh-rewind-plugin.svg)](https://github.com/SiriLee/dsh-rewind/blob/main/LICENSE)
@@ -83,18 +85,22 @@
 与下一条真实回合的 `turn/start` 编号冲突，重新打开会话时界面报
 `历史加载失败：conversation Context …:turn-tail… received an update before its start Match（internal）`，
 历史整段消失。0.2.5 起新的回退不再产生该冲突；但**已损坏的会话需要离线修复**（日志是
-append-only 的，不能在内存中改写）：
+append-only 的，不能在内存中改写）。
+
+修复工具**已随 npm 包发布**（`dsh-rewind-repair`）——无需下载源码：
 
 ```sh
 # 1. 先完全退出 dsh web / host（会话处于驻留内存时，磁盘修复会被下次 checkpoint 覆盖）
-# 2. 运行离线修复脚本（扫描 ~/.dsh/sessions 下所有会话，把标记 turn 改回最后一个已开始的回合）
-node scripts/repair-markers.mjs            # 默认扫描 ~/.dsh/sessions
-node scripts/repair-markers.mjs --dry-run  # 只报告不写盘
-node scripts/repair-markers.mjs --dir <sessions 根目录>  # 指定数据目录
+# 2. 运行离线修复（扫描 ~/.dsh/sessions 下所有会话，把标记 turn 改回最后一个已开始的回合）
+npm exec --yes --package=dsh-rewind-plugin -- dsh-rewind-repair
+npm exec --yes --package=dsh-rewind-plugin -- dsh-rewind-repair -- --dry-run  # 只预览不写盘
 # 3. 重启 dsh web，损坏的会话即可正常加载历史
 ```
 
-脚本只改写 `dsh-rewind` 空标记事件的 `data.turn` 字段（保持 seq / 顺序 / 帧结构不变），
+也可以全局安装一次（`npm i -g dsh-rewind-plugin`）后直接运行 `dsh-rewind-repair`；
+源码方式为 `node scripts/repair-markers.mjs`（参数相同）。
+
+工具只改写 `dsh-rewind` 空标记事件的 `data.turn` 字段（保持 seq / 顺序 / zstd 帧结构不变），
 改前自动备份原文件为 `session.jsonl.zstd.bak-<时间戳>`；不改动任何其它事件，可安全重复运行。
 
 ## 📦 安装
@@ -150,6 +156,7 @@ dsh plugin --profile web add github:SiriLee/dsh-rewind#<commit-sha>
 ## 行为细节与限制
 
 - 只跟踪**插件运行期间、经写类工具**的变更（`write` / `edit` / `str_replace_editor`）。`bash`、其他工具或外部程序的修改不在备份内、无法还原——与 Claude Code 相同，官方同样不覆盖，此类回退交由用户 git 处理。
+- **子代理（subagent）的编辑不跟踪**——与 Claude Code 相同。子代理运行在自己的会话里，其备份无法被父会话的回退还原；插件直接跳过捕获，而不是记录到永远读不到的位置。
 - 写前备份读取失败时（如权限错误）该次变更不会入备份，`both` 回退无法还原它——插件会在日志中警告，但**不会阻塞写操作**。
 - 文件还原/删除直写**真实本地文件系统**；sandbox / 远程 backend 下路径解析可能受限。
 - 符号链接与硬链接不写入（它们与另一名字共享 inode，还原会互相污染）——跳过并在结果中提示。

package/lib/client.js

@@ -38,6 +38,18 @@ function targetOfOutcome(text) {
   const match = text.match(/seq (\d+)/);
   return match !== null ? Number(match[1]) : void 0;
 }
+function isExecutedRewindCommand(node, seq) {
+  if (node.name !== "rewind" || node.outcome?.kind !== "success") return false;
+  if (node.outcome.sourceEventSeq === void 0) return false;
+  const args = node.args ?? "";
+  return new RegExp(`(?:^|\\s)@${seq}(?:\\s|$)`).test(args);
+}
+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");
+}
 function isPreviewCommand(command) {
   return (command.args ?? "").includes("preview");
 }
@@ -291,6 +303,9 @@ 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 findCommand(snapshot, match) {
   let found;
   for (const key of snapshot.chat.order) {
@@ -302,6 +317,18 @@ function findCommand(snapshot, match) {
   }
   return found;
 }
+function knownCommandSeqs(session, match) {
+  const known = /* @__PURE__ */ new Set();
+  const snapshot = session.getSnapshot();
+  for (const key of snapshot.chat.order) {
+    const node = snapshot.chat.nodes.get(key);
+    if (node !== void 0 && node.kind === "command") {
+      const command = node.data;
+      if (match(command)) known.add(command.seq);
+    }
+  }
+  return known;
+}
 function waitForCommand(session, match, timeoutMs = 8e3) {
   return new Promise((resolve) => {
     let settled = false;
@@ -328,9 +355,10 @@ function isPreviewFor(node, seq) {
   return node.name === "rewind" && args.includes("preview") && new RegExp(`(?:^|\\s)@${seq}(?=\\s|$)`).test(args);
 }
 async function previewImpact(session, seq) {
+  const known = knownCommandSeqs(session, (node) => isPreviewFor(node, seq));
   const result = await session.command(`/rewind preview @${seq} both`);
   if (!result.ok || result.value?.matched !== true) return null;
-  return waitForCommand(session, (node) => isPreviewFor(node, seq));
+  return waitForCommand(session, (node) => isPreviewFor(node, seq) && !known.has(node.seq));
 }
 function el(tag, className, text) {
   const node = document.createElement(tag);
@@ -375,11 +403,11 @@ function renderImpactStep(root, opts, back, cached) {
       impact.textContent = t("popover.impact.failed", { message: outcome.text ?? "unknown error" });
       return;
     }
-    impact.textContent = outcome.text ?? t("popover.impact.none");
+    impact.textContent = outcome.text === void 0 ? t("popover.impact.none") : stripImpactToken(outcome.text);
     confirm.disabled = false;
     confirm.addEventListener("click", () => {
       closePopover();
-      void session.command(`/rewind @${seq} both`);
+      opts.onRewind("both");
     });
   })().catch(() => {
     impact.textContent = t("popover.impact.failed", { message: "unexpected error" });
@@ -399,7 +427,7 @@ function openPopover(opts) {
       el("div", CLASS.popoverTarget, formatTarget(t, seq, time, preview)),
       modeOption(t("popover.chat"), t("popover.chat.hint"), () => {
         closePopover();
-        void session.command(`/rewind @${seq} chat`);
+        opts.onRewind("chat");
       })
     ];
     if (bothState.state === "noChanges") {
@@ -436,7 +464,6 @@ function openPopover(opts) {
   renderModes();
   document.body.append(root);
   position();
-  const hasFileImpact = (text) => text === void 0 || text.includes("\u5C06\u5F71\u54CD");
   void (async () => {
     const outcome = await previewImpact(session, seq);
     impactOutcome = outcome;
@@ -474,7 +501,7 @@ function openPopover(opts) {
 var name = "dsh-rewind";
 var inject = ["sessions", "locale"];
 var NS = "rewind";
-var USER_SEAT_SELECTOR = '[data-chat-flow-kind="user"]';
+var USER_SEAT_SELECTOR = '[data-chat-flow-kind="user"], [data-chat-flow-kind="steering"]';
 var CHAT_SEAT_SELECTOR = "[data-chat-anchor-key]";
 var ACTIONS_ROOT_SELECTOR = "[data-time-hover-root]";
 var COMPOSER_SELECTOR = "[data-input-scroll] textarea, textarea[data-phase]";
@@ -511,7 +538,6 @@ function apply(ctx) {
     style.dataset.plugin = "dsh-rewind";
     style.textContent = STYLE;
     document.head.appendChild(style);
-    const attached = /* @__PURE__ */ new WeakSet();
     const hidden = /* @__PURE__ */ new WeakSet();
     const buttons = /* @__PURE__ */ new Map();
     let observer = null;
@@ -529,16 +555,17 @@ function apply(ctx) {
     };
     const userNodeFor = (key, session) => {
       const node = session.getSnapshot().chat.nodes.get(key);
-      if (node === void 0 || node.kind !== "user") return void 0;
+      if (node === void 0 || node.kind !== "user" && node.kind !== "steering") return void 0;
       return node.data;
     };
     const attach = (seat) => {
       const key = seat.dataset.chatAnchorKey;
-      if (key === void 0 || attached.has(seat)) return;
+      if (key === void 0) return;
+      const existing = buttons.get(key);
+      if (existing !== void 0 && existing.isConnected) return;
       const hoverRoot = seat.querySelector(ACTIONS_ROOT_SELECTOR);
       const actions = hoverRoot?.lastElementChild;
       if (!(actions instanceof HTMLElement) || actions.querySelector("button") === null) return;
-      attached.add(seat);
       const button = document.createElement("button");
       button.type = "button";
       button.className = CLASS.button;
@@ -560,7 +587,10 @@ function apply(ctx) {
           time: node.time,
           preview: messagePreviewOf(node),
           anchor: button,
-          t
+          t,
+          onRewind: (mode) => {
+            void runRewindAndFill(session, node.seq, mode);
+          }
         });
       });
       actions.appendChild(button);
@@ -586,20 +616,6 @@ function apply(ctx) {
           hidden.delete(seat);
         }
       }
-      if (session !== void 0) {
-        const snap = session.getSnapshot();
-        if (!fillBaselineTaken && snap.chat.order.length > 0) {
-          fillBaselineTaken = true;
-          for (const key of snap.chat.order) {
-            const node = snap.chat.nodes.get(key);
-            if (node?.kind === "command") {
-              const command = node.data;
-              if (command.seq > fillBaselineSeq) fillBaselineSeq = command.seq;
-            }
-          }
-        }
-        fillComposerForRewind(session, filledTargets);
-      }
       if (hiddenSeqs.size > 0 || hiddenCount > 0) {
         console.info(
           `[dsh-rewind] hiding: ${hiddenCount} rows, seqs [${[...hiddenSeqs].slice(0, 20).join(", ")}${hiddenSeqs.size > 20 ? "\u2026" : ""}]`
@@ -609,24 +625,16 @@ function apply(ctx) {
         if (!hidden.has(seat)) attach(seat);
       }
     };
-    const filledTargets = /* @__PURE__ */ new Set();
-    let fillBaselineSeq = -1;
-    let fillBaselineTaken = false;
-    const fillComposerForRewind = (session, filled) => {
-      const snap = session.getSnapshot();
-      for (const key of snap.chat.order) {
-        const node = snap.chat.nodes.get(key);
-        if (node === void 0 || node.kind !== "command") continue;
-        const command = node.data;
-        if (command.name !== "rewind" || command.outcome?.kind !== "success") continue;
-        if (command.seq <= fillBaselineSeq) continue;
-        if (command.outcome.sourceEventSeq === void 0) continue;
-        const target = targetOfOutcome(command.outcome.text);
-        if (target === void 0 || filled.has(target)) continue;
-        const text = userTextAt(session, target);
-        if (text === void 0 || text === "") continue;
-        if (fillComposer(text)) filled.add(target);
-      }
+    const runRewindAndFill = async (session, seq, mode) => {
+      const known = knownCommandSeqs(session, (node) => isExecutedRewindCommand(node, seq));
+      const result = await session.command(`/rewind @${seq} ${mode}`);
+      if (!result.ok || result.value?.matched !== true) return;
+      const outcome = await waitForCommand(session, (node) => isExecutedRewindCommand(node, seq) && !known.has(node.seq), 2e4);
+      if (outcome === null || outcome.kind !== "success") return;
+      if (sessionFor() !== session) return;
+      const text = userTextAt(session, seq);
+      if (text === void 0 || text === "") return;
+      fillComposer(text);
     };
     const MANUAL_REWIND = /^\s*\/rewind(?:\s|$)/i;
     const composerTextarea = () => document.querySelector(COMPOSER_SELECTOR);

package/lib/index.js

@@ -309,7 +309,7 @@ function mutationPathOf(exec) {
 }
 function anchorSeqOf(session, cache) {
   const events = session.events;
-  const cached = cache.get(session.id);
+  const cached = cache.get(session);
   if (cached !== void 0 && cached.eventsLength === events.length) return cached.anchor;
   let anchor = cached?.anchor;
   for (let i = events.length - 1; i >= (cached?.eventsLength ?? 0); i--) {
@@ -318,7 +318,7 @@ function anchorSeqOf(session, cache) {
       break;
     }
   }
-  cache.set(session.id, { anchor, eventsLength: events.length });
+  cache.set(session, { anchor, eventsLength: events.length });
   return anchor;
 }
 async function resolveTarget(fs, path, cwd, signal) {
@@ -342,6 +342,8 @@ async function readTextOrUndefined(fs, target, signal) {
 }
 async function captureBefore(fs, exec, pending) {
   if (!TRACKED_TOOLS.has(exec.name)) return;
+  const header = exec.agent?.session.header;
+  if (header !== void 0 && (header.origin === "subagent" || (header.delegationDepth ?? 0) > 0)) return;
   const path = mutationPathOf(exec);
   if (path === void 0) return;
   const cwd = execSessionCwd(exec, path);
@@ -388,6 +390,7 @@ function formatPlan(plan, files) {
   } 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(`impact=${files.length}`);
   return lines.join("\n");
 }
 function resolveOrError(events, surface, raw) {
@@ -402,56 +405,81 @@ function renderFailures(failed) {
   return `\uFF1B${failed.length} \u4E2A\u6587\u4EF6\u8FD8\u539F\u5931\u8D25\uFF1A${failed.map((f) => `${f.path}\uFF08${f.message}\uFF09`).join("\u3001")}`;
 }
 async function waitForAgentIdle(agent, signal, timeoutMs = 15e3) {
-  const deadline = Date.now() + timeoutMs;
-  while (agent.status !== "idle") {
-    if (signal.aborted || Date.now() > deadline) return false;
-    await new Promise((resolve) => setTimeout(resolve, 50));
+  if (signal.aborted) return false;
+  let timer;
+  let onAbort;
+  try {
+    await Promise.race([
+      agent.whenIdle(),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error("rewind idle wait timed out")), timeoutMs);
+        onAbort = () => reject(new Error("rewind idle wait aborted"));
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
   }
-  return true;
 }
-async function executeRewind(ctx, store, invocation, rawTarget, mode) {
+async function executeRewind(ctx, store, invocation, rawTarget, mode, inflight) {
   const { agent } = invocation;
-  if (agent.status !== "idle") {
-    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" };
-    }
-  }
-  let plan;
-  try {
-    plan = resolveOrError(agent.session.events, agent.session.surface.nodes, rawTarget);
-  } catch (error) {
-    return rewindErrorResult(error);
+  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" };
   }
-  const marker = buildMarker();
-  let event;
+  inflight.add(sessionId);
   try {
-    event = agent.session.append("assistant/message", { turn: markerTurnOf(agent.session.events), step: 0, message: marker }, {
-      surfaceOp: { op: "replace", start: plan.surfaceStart, end: plan.surfaceEnd },
-      sourceEventSeqs: [...plan.shadowedSeqs]
-    });
-  } catch (error) {
+    if (agent.status !== "idle") {
+      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" };
+      }
+    }
+    if (invocation.signal.aborted) {
+      return { kind: "error", text: "\u56DE\u9000\u5DF2\u53D6\u6D88\u3002" };
+    }
+    let plan;
+    try {
+      plan = resolveOrError(agent.session.events, agent.session.surface.nodes, rawTarget);
+    } catch (error) {
+      return rewindErrorResult(error);
+    }
+    const marker = buildMarker();
+    let event;
+    try {
+      event = agent.session.append("assistant/message", { turn: markerTurnOf(agent.session.events), step: 0, message: marker }, {
+        surfaceOp: { op: "replace", start: plan.surfaceStart, end: plan.surfaceEnd },
+        sourceEventSeqs: [...plan.shadowedSeqs]
+      });
+    } 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`
+      };
+    }
+    let restore = "";
+    if (mode === "both") {
+      const outcome = await store.restoreAfter(agent.session.id, plan.targetSeq, (path) => unlink(path));
+      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";
+      restore += renderFailures(outcome.failed);
+    }
     return {
-      kind: "error",
-      text: `\u56DE\u9000\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}\u3002\u4F1A\u8BDD\u672A\u6539\u53D8\u3002`
+      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`,
+      sourceEventSeq: event.seq
     };
+  } finally {
+    inflight.delete(sessionId);
   }
-  let restore = "";
-  if (mode === "both") {
-    const outcome = await store.restoreAfter(agent.session.id, plan.targetSeq, (path) => unlink(path));
-    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";
-    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`,
-    sourceEventSeq: event.seq
-  };
 }
 function rewindErrorResult(error) {
   if (error instanceof RewindError) {
@@ -465,7 +493,7 @@ function rewindErrorResult(error) {
   }
   throw error;
 }
-async function handleRewind(ctx, store, invocation) {
+async function handleRewind(ctx, store, invocation, inflight) {
   const session = invocation.agent.session;
   const input = invocation.rawInput.trim();
   if (input === "") {
@@ -473,7 +501,7 @@ async function handleRewind(ctx, store, invocation) {
     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 executeRewind(ctx, store, invocation, `@${candidates[0].seq}`, "chat");
+    return executeRewind(ctx, store, invocation, `@${candidates[0].seq}`, "chat", inflight);
   }
   const parts = input.split(/\s+/);
   if (parts[0] === "preview") {
@@ -503,17 +531,18 @@ async function handleRewind(ctx, store, invocation) {
   /rewind ${target} both  \u56DE\u9000\u5BF9\u8BDD\u5E76\u8FD8\u539F\u6587\u4EF6`
     };
   }
-  return executeRewind(ctx, store, invocation, target, mode);
+  return executeRewind(ctx, store, invocation, target, mode, inflight);
 }
 function apply(ctx, config) {
   const store = new SnapshotStore(config?.snapshotDir);
   const pending = /* @__PURE__ */ new Map();
-  const anchorCache = /* @__PURE__ */ new Map();
+  const anchorCache = /* @__PURE__ */ new WeakMap();
+  const inflight = /* @__PURE__ */ new Set();
   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)
+      handler: (invocation) => handleRewind(ctx, store, invocation, inflight)
     });
   }, "dsh-rewind command");
   ctx.inject(["fs"], (scope) => {

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

@@ -5,7 +5,7 @@
  *
  * @module dsh-rewind/client/hidden
  */
-import type { ChatConversationViewNode } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ChatConversationViewNode, CommandNode } from '@deepseek-ai/dsh-client-runtime/client';
 /** Minimal chat snapshot reader the hiding logic needs. */
 export interface HiddenChat {
     readonly order: readonly string[];
@@ -15,6 +15,25 @@ export interface HiddenChat {
 }
 /** Extract the rewind target from a command outcome text ("已撤回 seq N..."). */
 export declare function targetOfOutcome(text: string | 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
+ * with a marker-carrying success outcome. The composer refill waits for
+ * exactly this node after the user confirms, so a history-loaded command can
+ * never trigger a fill.
+ */
+export declare function isExecutedRewindCommand(node: CommandNode, seq: number): boolean;
+/**
+ * Whether a preview outcome reports tracked file changes — the availability
+ * 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.
+ */
+export declare function hasFileImpact(text: string | undefined): boolean;
 /**
  * Anchor seqs that must be hidden from the rendered transcript so the user
  * sees the conversation as the agent sees it: every impact-preview flow node

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

@@ -7,6 +7,7 @@
  * @module dsh-rewind/client/popover
  */
 import type { SessionFace } from '@deepseek-ai/dsh-client-runtime/client';
+import type { CommandNode } from '@deepseek-ai/dsh-client-runtime/client';
 import type { RewindKey } from './locales.ts';
 type Translate = (key: RewindKey, params?: Record<string, unknown>) => string;
 export interface PopoverOptions {
@@ -17,9 +18,32 @@ export interface PopoverOptions {
     /** The button that opened the popover (outside-click ignore target). */
     readonly anchor: HTMLElement;
     readonly t: Translate;
+    /**
+     * Execute one rewind in the given mode. The popover closes itself first;
+     * the callback owns the command + composer-refill lifecycle (see
+     * runRewindAndFill in index.ts).
+     */
+    readonly onRewind: (mode: 'chat' | 'both') => void;
 }
 /** Close the current popover, if any. */
 export declare function closePopover(): void;
+/**
+ * Seqs of the command nodes currently matching `match`. Sample BEFORE issuing
+ * a new command of the same shape so the subsequent wait can exclude them: a
+ * repeated preview/rewind of the same target must not settle on the previous
+ * command's stale outcome (e.g. an older preview that found file changes,
+ * after those changes were already restored).
+ */
+export declare function knownCommandSeqs(session: SessionFace, match: (node: CommandNode) => boolean): Set<number>;
+/**
+ * Resolve the outcome of the newest matching rewind command by watching the
+ * session snapshot (command/run + command/done land as one CommandNode).
+ * @returns the outcome text-bearing node, or null on timeout.
+ */
+export declare function waitForCommand(session: SessionFace, match: (node: CommandNode) => boolean, timeoutMs?: number): Promise<{
+    kind: 'success' | 'error';
+    text?: string;
+} | null>;
 /** Open the mode-selection popover anchored near the given button. */
 export declare function openPopover(opts: PopoverOptions): void;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rewind-plugin",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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",
@@ -23,6 +23,9 @@
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
+  "bin": {
+    "dsh-rewind-repair": "scripts/repair-markers.mjs"
+  },
   "exports": {
     ".": {
       "types": "./lib/types/index.d.ts",
@@ -41,7 +44,8 @@
     "README.zh.md",
     "docs",
     "assets",
-    "LICENSE"
+    "LICENSE",
+    "scripts/repair-markers.mjs"
   ],
   "dsh": {
     "bundle": {

package/scripts/repair-markers.mjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+/**
+ * Offline repair for sessions corrupted by the ≤ 0.2.4 marker turn-number bug.
+ *
+ * Symptom: reopening a session shows
+ *   Failed to load history: conversation Context …:turn-tail… received an
+ *   update before its start Match (internal)
+ * and the history disappears. Root cause: the rewind marker was numbered
+ * `lastTurn + 1`, which is exactly how the harness numbers its NEXT real turn —
+ * so the log holds an `assistant/message` (the marker) BEFORE the `turn/start`
+ * of the same turn, and the client conversation-context builder rejects that
+ * ordering.
+ *
+ * This script rewrites ONLY the `data.turn` of `dsh-rewind` empty-marker events
+ * to the last turn/start that precedes them (a turn the harness has already
+ * consumed and can never reuse). It preserves:
+ *   - every other event byte-for-byte (seqs, times, surface metadata, …),
+ *   - the JSONL record order and line structure,
+ *   - the zstd multi-frame structure the persistence backend expects
+ *     (each frame is decoded, fixed, and re-compressed independently, with the
+ *     "last started turn" state threaded across frames).
+ *
+ * The original file is backed up to `session.jsonl.zstd.bak-<timestamp>` before
+ * the first write. Run with the host fully stopped (a resident session would
+ * overwrite the repaired file at its next checkpoint), then restart dsh web.
+ *
+ * Usage:
+ *   node scripts/repair-markers.mjs            # scan ~/.dsh/sessions
+ *   node scripts/repair-markers.mjs --dry-run  # report only, no writes
+ *   node scripts/repair-markers.mjs --dir <sessions root>
+ */
+
+import { readdirSync, readFileSync, writeFileSync, copyFileSync, statSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { zstdCompressSync, zstdDecompressSync } from 'node:zlib'
+
+const ZSTD_MAGIC = 0xfd2fb528
+const MARKER_SOURCE = { provider: 'dsh-rewind', model: 'rewind-marker' }
+const DEFAULT_ROOT = join(homedir(), '.dsh', 'sessions')
+
+/** @param {Buffer} buffer @returns {{start:number,end:number}[]} */
+function scanFrames(buffer) {
+  const frames = []
+  let offset = 0
+  while (offset < buffer.length) {
+    const start = offset
+    if (buffer.length - offset < 4 || buffer.readUInt32LE(offset) !== ZSTD_MAGIC) break
+    offset += 4
+    const next = buffer.indexOf(Buffer.from([0x28, 0xb5, 0x2f, 0xfd]), offset)
+    frames.push(next === -1 ? { start, end: buffer.length } : { start, end: next })
+    offset = next === -1 ? buffer.length : next
+  }
+  return frames
+}
+
+/**
+ * Rewrite marker turn numbers in ONE frame's JSONL text. Line-preserving: the
+ * fix never adds or removes lines, only rewrites a marker line's turn. State
+ * (`lastStarted`) is threaded across frames, because a marker in a later frame
+ * must know the turn/start events of earlier frames.
+ * @param {string} text - this frame's JSONL text.
+ * @param {{lastStarted:number}} state - running "last started turn" state.
+ * @returns {{text:string, changed:number}} the fixed text (identical when
+ *   nothing changed) and the number of rewritten markers in this frame.
+ */
+function fixMarkerTurns(text, state) {
+  const lines = text.split('\n')
+  let changed = 0
+  const out = []
+  for (const line of lines) {
+    if (line.trim() === '') {
+      out.push(line)
+      continue
+    }
+    let record
+    try {
+      record = JSON.parse(line)
+    } catch {
+      out.push(line) // keep unknown/torn lines verbatim
+      continue
+    }
+    if (record && record.type === 'turn/start' && Number.isSafeInteger(record.data?.turn)) {
+      if (record.data.turn > state.lastStarted) state.lastStarted = record.data.turn
+      out.push(line)
+      continue
+    }
+    const isMarker =
+      record?.type === 'assistant/message' &&
+      record.data?.message?.source?.provider === MARKER_SOURCE.provider &&
+      record.data?.message?.source?.model === MARKER_SOURCE.model
+    if (!isMarker) {
+      out.push(line)
+      continue
+    }
+    const badTurn = record.data.turn
+    if (badTurn === state.lastStarted) {
+      out.push(line) // already safe (post-0.2.5 marker) — idempotent
+      continue
+    }
+    changed += 1
+    out.push(JSON.stringify({ ...record, data: { ...record.data, turn: state.lastStarted } }))
+  }
+  return { text: out.join('\n'), changed }
+}
+
+/** Repair one session artifact file. @returns {string} a human summary line. */
+function repairFile(file, dryRun) {
+  const original = readFileSync(file)
+  const frames = scanFrames(original)
+  const state = { lastStarted: 0 }
+  const fixedTexts = []
+  let changed = 0
+  for (const frame of frames) {
+    const frameText = zstdDecompressSync(original.subarray(frame.start, frame.end)).toString('utf8')
+    const result = fixMarkerTurns(frameText, state)
+    changed += result.changed
+    fixedTexts.push(result.text)
+  }
+  if (changed === 0) return `  ok (no marker fix needed): ${file}`
+  if (dryRun) return `  would fix ${changed} marker(s): ${file}`
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-')
+  copyFileSync(file, `${file}.bak-${stamp}`)
+  // Preserve the zstd frame structure: one re-compressed frame per original
+  // frame, in order.
+  writeFileSync(file, Buffer.concat(fixedTexts.map(text => zstdCompressSync(Buffer.from(text)))))
+  return `  fixed ${changed} marker(s): ${file} (backup: ${file}.bak-${stamp})`
+}
+
+function collectSessions(root) {
+  const files = []
+  for (const project of readdirSync(root)) {
+    const projectDir = join(root, project)
+    let stat
+    try {
+      stat = statSync(projectDir)
+    } catch {
+      continue
+    }
+    if (!stat.isDirectory()) continue
+    for (const entry of readdirSync(projectDir)) {
+      const file = join(projectDir, entry, 'session.jsonl.zstd')
+      if (existsSync(file)) files.push(file)
+    }
+  }
+  return files
+}
+
+const args = process.argv.slice(2)
+const dryRun = args.includes('--dry-run')
+const dirIndex = args.indexOf('--dir')
+const root = dirIndex !== -1 && args[dirIndex + 1] !== undefined ? args[dirIndex + 1] : DEFAULT_ROOT
+
+if (!existsSync(root)) {
+  console.error(`sessions root not found: ${root}`)
+  process.exit(1)
+}
+
+console.log(`${dryRun ? '[dry-run] ' : ''}scanning ${root}`)
+const files = collectSessions(root)
+console.log(`${files.length} session artifact(s) found`)
+let fixedCount = 0
+for (const file of files) {
+  try {
+    const line = repairFile(file, dryRun)
+    if (!line.includes('no marker fix needed')) {
+      console.log(line)
+      fixedCount += 1
+    }
+  } catch (error) {
+    console.error(`  ERROR ${file}: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}
+console.log(fixedCount === 0
+  ? 'no corrupted sessions found — nothing to do'
+  : `${dryRun ? 'would repair' : 'repaired'} ${fixedCount} session(s). ${dryRun ? '' : 'Restart dsh web to reload the repaired histories.'}`)