dsh-rewind-plugin 0.5.0 → 0.6.1

package/docs/snapshot-auto-cleanup.md

@@ -1,71 +1,90 @@
-# Snapshot auto-cleanup
+# Snapshot cleanup
 
-The rewind store writes one on-disk `before` backup per tracked file change,
-grouped by its anchor message. Snapshots are deduped within a session and capped
-at the newest 100 anchor groups, but across sessions that are no longer active
-the store can
-still grow without bound. `snapshot-auto-cleanup` is an OPTIONAL global policy
-(off by default) that removes the whole snapshot directory of a session that has
-been **long-inactive** — untouched past a configurable idle cutoff.
+The plugin saves a backup of each file before it's edited, so you can rewind your
+code to an earlier point. These backups are called **snapshots**, and they're
+grouped by message and stored per session.
 
-It only ever removes the whole snapshot **directory** of a long-inactive session.
-It never touches the active session's snapshots, never touches the conversation
-log, and leaves snapshot data within the idle cutoff alone.
+`/snapshot-auto-cleanup` helps you manage those snapshots — whether you want to
+reclaim disk space from old sessions or clear the **current** session so its
+rewind history starts fresh.
+
+## What it does
+
+**Automatic cleanup** (off by default): the plugin can remember which sessions
+you've stopped using, and now and then remove their snapshots to keep disk usage
+down. It never touches your active session, and it never touches your
+conversation.
+
+**Manual:** even with automatic cleanup off, you can run the cleanup yourself:
+
+- `/snapshot-auto-cleanup run [--apply]` — preview, then actually remove the
+  snapshots of sessions you haven't used for a while.
+- `/snapshot-auto-cleanup run --current [--apply]` — preview, then actually
+  clear the **current** session's snapshots. This resets its rewind history to
+  "from now on" (your conversation is unaffected). If a turn is currently
+  running, the plugin pauses it first, then clears.
 
 ## Commands
 
 ```
-/snapshot-auto-cleanup                  show status (enabled, max-age, config path)
-/snapshot-auto-cleanup on|off           enable/disable the automatic sweep
-/snapshot-auto-cleanup max-age <days>   set the idle cutoff (positive integer)
-/snapshot-auto-cleanup run              dry-run: list what would be removed
-/snapshot-auto-cleanup run --apply      actually remove those sessions
+/snapshot-auto-cleanup                       show the current settings
+/snapshot-auto-cleanup on|off                turn automatic cleanup on or off
+/snapshot-auto-cleanup max-age <days>        how many idle days before a session's snapshots are removed
+/snapshot-auto-cleanup run                   preview what the automatic cleanup would remove
+/snapshot-auto-cleanup run --apply           actually remove those snapshots
+/snapshot-auto-cleanup run --current         preview clearing this session's snapshots
+/snapshot-auto-cleanup run --current --apply actually clear this session's snapshots
 ```
 
-`run` is a manual escape hatch and works whether or not the automatic cleanup is
-`on`. `run` defaults to a dry-run; add `--apply` to execute.
+`run` always starts as a preview; add `--apply` to make the change. `run` works
+whether or not automatic cleanup is on.
 
-## Config file
+## Settings
 
-The policy is persisted to `~/.dsh/snapshot-cleanup.json`:
+The settings live in `<dsh home>/snapshot-cleanup.json`:
 
 ```json
 { "enabled": false, "maxAgeDays": 30 }
 ```
 
-- `enabled` — whether the automatic sweeps run (default `false`).
-- `maxAgeDays` — how many idle days before a long-inactive session's snapshot dir is
-  removed (default `30`; `0`/negative are rejected, so a broken config can never
-  delete everything).
-
-Override the path with the `DSH_SNAPSHOT_CLEANUP_CONFIG` environment variable.
-The file is written only by the `/snapshot-auto-cleanup` command. A missing file
-reads as the safe default (off); a missing or corrupt file makes a sweep
-**fail-closed** (delete nothing) and log a warning, and is surfaced when you run
-the command again.
-
-## When it runs
-
-The 24h window is anchored on a **persisted** last-sweep time
-(`~/.dsh/snapshot-cleanup-last-sweep.json`), so a host restart does not reset
-it: the auto-sweep checks **once per process run**, on the first session
-activity of a window (a user message or a completed tool call), and cleans only
-when enabled **and** >=24h since the last sweep. It runs in the background and
-never blocks the activity that triggered it. Because the check happens once per
-run, a change that takes effect immediately is best applied with
-`/snapshot-auto-cleanup run`; editing the config file by hand (or enabling after
-the run's first activity) takes effect on the next run.
-
-## Safety and boundaries
-
-- Removes only whole **long-inactive** session dirs; the active session and the
-  conversation log are never touched.
-- "Inactive" is judged by mtime: a session still being written to keeps scrolling
-  its newest member stamp forward, so it is never old enough to be pruned.
-- Dedup `ref` links are session-relative, so removing a whole dir cannot dangle a
-  link elsewhere.
-- Trade-off: enabling auto-cleanup means a session resumed after a long idle gap
-  will rewind only from its remaining (newest 100) anchors; its old snapshots are
-  gone. The conversation log is never affected.
-- Deleting the whole store dir manually stays safe (it is recreated on the next
-  capture); auto-cleanup just scopes that removal to long-inactive sessions.
+- `enabled` — whether automatic cleanup runs (default `false`).
+- `maxAgeDays` — how many idle days before a session's snapshots are removed
+  (default `30`). Only positive numbers are accepted, so a broken setting can
+  never delete everything.
+
+You can point the plugin at a different file with the `DSH_SNAPSHOT_CLEANUP_CONFIG`
+environment variable. The file is changed only when you turn cleanup on/off or
+set `max-age`; a missing file reads as the safe default (off).
+
+## When automatic cleanup runs
+
+Automatic cleanup checks at most **once per run** (a restart lets it check again),
+on the first session activity (a message you send or a tool call that finishes),
+and only when it's enabled and at least 24 hours have passed since the last
+check. The 24-hour clock is saved to `<dsh home>/snapshot-cleanup-last-sweep.json`,
+so restarting doesn't reset it. It runs in the background and never blocks
+what you're doing.
+
+If you want a change to take effect right away, use `run`; automatic cleanup
+picks up a fresh setting on the next run.
+
+## Safety
+
+- Only rewind **snapshots** (the file backups) are ever removed. Your
+  conversation is never touched, and the plugin never rewrites or deletes your
+  session history.
+- Automatic cleanup never removes your **active** session's snapshots — only
+  sessions that have been idle past the cutoff.
+- `run --current` clears the current session's snapshots. This is one-way for
+  that session's file-rewind history: you can't rewind code to before the clear,
+  but your conversation stays intact, and the session starts recording fresh
+  snapshots from now on.
+
+## Known limitation
+
+The plugin keeps the most recent **100 messages'** snapshots per session. If you
+rewind or compact a lot in one long session, those 100 slots can be taken up by
+messages that are no longer reachable, so you may find you can't rewind as far
+back as you'd like. (Claude Code behaves the same way.) To get back to a clean
+state, run `/snapshot-auto-cleanup run --current --apply` to clear the current
+session and start fresh.

package/docs/snapshot-auto-cleanup.zh.md

@@ -1,42 +1,57 @@
-# 快照自动清理
+# 快照清理
 
-回退插件为每次被跟踪的文件修改写入一份磁盘 `before` 备份，并按其锚点消息分组。快照在**同一会话**内去重、且保留最近 100 组锚点，但跨**已不再活跃的会话**时存储仍会无界增长。`snapshot-auto-cleanup` 是**可选**的全局策略（默认关闭）：把**长期不活跃**（失活超过可配置阈值）的会话快照**整目录**移除。
+插件会在每次修改文件前保存一份备份，方便你把代码回退到之前的状态。这些备份叫**快照**，按消息分组、按会话存放。
 
-它只会移除**长期不活跃**会话的整个快照目录，绝不触碰活动会话的快照、绝不触碰对话日志，也保留仍在阈值内的快照数据。
+`/snapshot-auto-cleanup` 帮你管理这些快照——既可以回收旧会话占用的磁盘，也可以清空**当前**会话、让它从"现在"重新开始记录回退历史。
+
+## 它能做什么
+
+**自动清理**（默认关闭）：插件会记住哪些会话你已不再使用，并定期移除它们的快照以节省磁盘。它**绝不**触碰你当前活跃的会话，也**绝不**触碰你的对话。
+
+**手动：**即使自动清理是关闭的，你也可以自己执行清理：
+
+- `/snapshot-auto-cleanup run [--apply]` — 先预演，再真正移除你已有一阵子没用的会话的快照。
+- `/snapshot-auto-cleanup run --current [--apply]` — 先预演，再真正清空**当前**会话的快照。这会让它从"现在"重新开始记录回退历史（你的对话不受影响）。若此刻有正在进行中的回合，插件会先暂停它，再清空。
 
 ## 命令
 
 ```
-/snapshot-auto-cleanup                 查看状态（是否开启、max-age、配置路径）
-/snapshot-auto-cleanup on|off          开启/关闭自动清理
-/snapshot-auto-cleanup max-age <天数>  设置失活阈值（正整数）
-/snapshot-auto-cleanup run             预演：列出将移除哪些会话
-/snapshot-auto-cleanup run --apply     真正移除这些会话
+/snapshot-auto-cleanup                       查看当前设置
+/snapshot-auto-cleanup on|off                开启/关闭自动清理
+/snapshot-auto-cleanup max-age <天数>        会话失活多少天后移除其快照
+/snapshot-auto-cleanup run                   预演：看自动清理会移除什么
+/snapshot-auto-cleanup run --apply           真正移除这些快照
+/snapshot-auto-cleanup run --current         预演：看清空本会话快照会怎样
+/snapshot-auto-cleanup run --current --apply 真正清空本会话快照
 ```
 
-`run` 是手动逃生舱，无论自动清理是否为 `on` 都能用；默认只预演，加 `--apply` 才执行。
+`run` 一开始总是预演；加 `--apply` 才真正执行。`run` 无论自动清理是否开启都能用。
 
-## 配置文件
+## 设置
 
-策略持久化到 `~/.dsh/snapshot-cleanup.json`：
+设置保存在 `<dsh home>/snapshot-cleanup.json`：
 
 ```json
 { "enabled": false, "maxAgeDays": 30 }
 ```
 
 - `enabled` — 是否运行自动清理（默认 `false`）。
-- `maxAgeDays` — 失活多少天后移除某**长期不活跃**会话的快照目录（默认 `30`；`0`/负数会被拒绝，因此损坏的配置不可能导致"删除一切"）。
+- `maxAgeDays` — 会话失活多少天后移除其快照（默认 `30`）。只接受正数，因此一个损坏的设置永远不可能"删掉一切"。
+
+你可以用环境变量 `DSH_SNAPSHOT_CLEANUP_CONFIG` 指向别的文件。该文件只在运行 `/snapshot-auto-cleanup` 时写入；文件缺失按安全默认值（关闭）处理。
+
+## 自动清理何时运行
+
+自动清理每次运行（宿主启动）**最多检查一次**，发生在首次活动时（你发出一条消息或某次工具调用完成），且仅在**已开启**且距上次检查**已满 24 小时**时才执行。这个 24 小时时钟会写入 `<dsh home>/snapshot-cleanup-last-sweep.json`，重启不会重置。它后台运行，从不阻塞你在做的事。
 
-可用环境变量 `DSH_SNAPSHOT_CLEANUP_CONFIG` 覆盖路径。该文件只由 `/snapshot-auto-cleanup` 命令写入。文件缺失按安全默认（关闭）处理；缺失或损坏会令一次清扫**fail-closed**（不删任何东西）并写入警告，再次运行命令时会有所提示。
+想让改动立即生效，请用 `run`；自动清理要到下次运行才会采用新设置。
 
-## 运行时机
+## 安全
 
-24 小时窗口锚定在**持久化**的上次清扫时间（`~/.dsh/snapshot-cleanup-last-sweep.json`）上，因此宿主重启不会重置：自动清扫在**每次运行只检查一次**，于某个窗口的首次会话活动（一条用户消息或一次工具调用完成）时执行，且仅在**已启用**且距上次清扫 **>=24 小时**时才清理。它后台运行，从不阻塞触发它的活动。由于每次运行只检查一次，想让改动立即生效最好用 `/snapshot-auto-cleanup run`；手动编辑配置文件（或在本次运行的首次活动之后才开启）会到下次运行才生效。
+- 只会移除回退用的**快照**（那份文件备份）。你的对话绝不会被动到，插件也绝不改写或删除你的会话历史。
+- 自动清理**永不**移除你**当前活跃**会话的快照——只清理已失活超过阈值的会话。
+- `run --current` 会清空当前会话的快照。这对该会话的文件回退历史是**不可逆**的：你无法回退到清空之前的代码状态，但你的对话保持完整，会话会从"现在"开始重新记录快照。
 
-## 安全与边界
+## 已知限制
 
-- 只移除**长期不活跃**会话的整目录；活动会话与对话日志永不触碰。
-- "不活跃"以 mtime 判定：仍在写入的会话会不断把"最新成员"时间戳往后推，因此永远到不了可被清理的失活阈值。
-- 去重 `ref` 链接是会话内相对的，所以移除整目录不会让别处产生悬空链接。
-- 权衡：开启自动清理后，某个长时间闲置才被重新打开的会话，只能从剩余（最近 100 组）锚点回退，旧快照已不存在；对话日志永不受影响。
-- 手动删除整个存储目录依然安全（下次捕获时自动重建）；自动清理只是把这种删除限定到长期不活跃的会话。
+插件每个会话只保留**最近 100 条消息**的快照。若你在一个很长的会话里多次回退或压缩，这 100 个名额常会被"已经无法再回退到"的消息占满，你可能无法回退到想要的位置。（Claude Code 也是同样行为。）想恢复到一个干净状态，运行 `/snapshot-auto-cleanup run --current --apply` 清空当前会话、重新开始。

package/lib/client.js

@@ -35,6 +35,11 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/client/hidden.ts
+function chatSnapshotOf(face, chatView) {
+  const legacy = face?.getSnapshot().chat;
+  if (legacy !== void 0) return legacy;
+  return chatView?.getSnapshot() ?? void 0;
+}
 function targetSeqOfArgs(args) {
   if (args === void 0 || args === null) return void 0;
   const match = args.match(/@(\d+)/);
@@ -333,10 +338,11 @@ function parseImpactList(text) {
   }
   return { restores, deletes };
 }
-function findCommand(snapshot, match) {
+function findCommand(chat, match) {
+  if (chat === void 0) return void 0;
   let found;
-  for (const key of snapshot.chat.order) {
-    const node = snapshot.chat.nodes.get(key);
+  for (const key of chat.order) {
+    const node = chat.nodes.get(key);
     if (node !== void 0 && node.kind === "command") {
       const command = node.data;
       if (match(command)) found = command;
@@ -344,11 +350,12 @@ function findCommand(snapshot, match) {
   }
   return found;
 }
-function knownCommandSeqs(session, match) {
+function knownCommandSeqs(session, chatOf, match) {
   const known = /* @__PURE__ */ new Set();
-  const snapshot = session.getSnapshot();
-  for (const key of snapshot.chat.order) {
-    const node = snapshot.chat.nodes.get(key);
+  const chat = chatOf(session);
+  if (chat === void 0) return known;
+  for (const key of chat.order) {
+    const node = chat.nodes.get(key);
     if (node !== void 0 && node.kind === "command") {
       const command = node.data;
       if (match(command)) known.add(command.seq);
@@ -356,7 +363,7 @@ function knownCommandSeqs(session, match) {
   }
   return known;
 }
-function waitForCommand(session, match, timeoutMs = 8e3) {
+function waitForCommand(session, chatOf, match, timeoutMs = 8e3) {
   return new Promise((resolve) => {
     let settled = false;
     const settle = (value) => {
@@ -367,7 +374,7 @@ function waitForCommand(session, match, timeoutMs = 8e3) {
       resolve(value);
     };
     const check = () => {
-      const node = findCommand(session.getSnapshot(), match);
+      const node = findCommand(chatOf(session), match);
       if (node?.outcome !== null && node?.outcome !== void 0) {
         settle({ kind: node.outcome.kind, text: node.outcome.text });
       }
@@ -381,11 +388,11 @@ function isPreviewFor(node, seq) {
   const args = node.args ?? "";
   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));
+async function previewImpact(session, chatOf, seq) {
+  const known = knownCommandSeqs(session, chatOf, (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) && !known.has(node.seq));
+  return waitForCommand(session, chatOf, (node) => isPreviewFor(node, seq) && !known.has(node.seq));
 }
 function el(tag, className, text) {
   const node = document.createElement(tag);
@@ -436,7 +443,7 @@ function renderImpactStep(root, opts, back, cached) {
   root.replaceChildren(impact, actions);
   focusFirst(root);
   void (async () => {
-    const outcome = cached ?? await previewImpact(session, seq);
+    const outcome = cached ?? await previewImpact(session, opts.chatOf, seq);
     if (outcome === null) {
       impact.textContent = t("popover.impact.failed", { message: "preview command failed or timed out" });
       return;
@@ -555,10 +562,10 @@ function openPopover(opts) {
     openRetractPopover(opts);
     return;
   }
-  const { session, seq, time, preview, anchor, t } = opts;
+  const { session, seq, time, preview, anchor, t, chatOf } = opts;
   const onRewind = opts.onRewind;
   if (seq === void 0 || time === void 0 || onRewind === void 0) return;
-  const durableOpts = { session, seq, time, preview, anchor, t, onRewind };
+  const durableOpts = { session, seq, time, preview, anchor, t, chatOf, onRewind };
   const root = el("div", CLASS.popover);
   root.setAttribute("role", "dialog");
   root.setAttribute("aria-label", t("popover.title"));
@@ -628,7 +635,7 @@ function openPopover(opts) {
   popoverEl = root;
   disposeOutside = shell.dispose;
   void (async () => {
-    const outcome = await previewImpact(session, seq);
+    const outcome = await previewImpact(session, chatOf, seq);
     impactOutcome = outcome;
     if (outcome !== null && outcome.kind === "success") {
       bothState = { state: hasFileImpact(outcome.text) ? "hasChanges" : "noChanges" };
@@ -670,10 +677,10 @@ function retractSpan(steering, targetId) {
 
 // src/client/portals.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-function userTextAt(session, seq) {
-  const snap = session.getSnapshot();
-  for (const key of snap.chat.order) {
-    const node = snap.chat.nodes.get(key);
+function userTextAt(chat, seq) {
+  if (chat === void 0) return void 0;
+  for (const key of chat.order) {
+    const node = chat.nodes.get(key);
     if (node === void 0 || node.kind !== "user") continue;
     const user = node.data;
     if (user.seq === seq) {
@@ -691,23 +698,23 @@ function fillComposer(text) {
   textarea.focus();
   return true;
 }
-function userNodeOf(session, key) {
-  const node = session.getSnapshot().chat.nodes.get(key);
+function userNodeOf(chat, key) {
+  const node = chat?.nodes.get(key);
   if (node === void 0 || node.kind !== "user" && node.kind !== "steering") return void 0;
   return node.data;
 }
-async function runRewindAndFill(session, seq, mode, currentSessionId) {
-  const known = knownCommandSeqs(session, (node) => isExecutedRewindCommand(node, seq));
+async function runRewindAndFill(session, seq, mode, currentSessionId, chatOf) {
+  const known = knownCommandSeqs(session, chatOf, (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);
+  const outcome = await waitForCommand(session, chatOf, (node) => isExecutedRewindCommand(node, seq) && !known.has(node.seq), 2e4);
   if (outcome === null) return;
   if (outcome.kind !== "success") {
     showHint(outcome.text ?? "rewind failed");
     return;
   }
   if (currentSessionId() !== session.sessionId) return;
-  const text = userTextAt(session, seq);
+  const text = userTextAt(chatOf(session), seq);
   if (text === void 0 || text === "") return;
   fillComposer(text);
 }
@@ -794,7 +801,7 @@ function sameTargets(left, right) {
     return other.kind === "pending" && target.itemId === other.itemId;
   });
 }
-function RewindPortals({ sessionId, sessionOf, currentSessionId, t, subscribeLocale }) {
+function RewindPortals({ sessionId, sessionOf, chatOf, currentSessionId, t, subscribeLocale }) {
   const [targets, setTargets] = (0, import_react.useState)([]);
   const hidden = (0, import_react.useRef)(/* @__PURE__ */ new WeakSet());
   const [, forceRender] = (0, import_react.useReducer)((count) => count + 1, 0);
@@ -812,12 +819,12 @@ function RewindPortals({ sessionId, sessionOf, currentSessionId, t, subscribeLoc
         return;
       }
       const snapshot = session.getSnapshot();
-      const chat = snapshot.chat;
-      const hiddenSeqs = hiddenSeqsOf(chat);
+      const chat = chatOf(session);
+      const hiddenSeqs = chat === void 0 ? /* @__PURE__ */ new Set() : hiddenSeqsOf(chat);
       let hiddenCount = 0;
-      for (const seat of document.querySelectorAll(CHAT_SEAT_SELECTOR)) {
+      for (const seat of chat === void 0 ? [] : document.querySelectorAll(CHAT_SEAT_SELECTOR)) {
         const key = seat.dataset.chatAnchorKey;
-        const anchor = key !== void 0 ? chat.nodes.get(key)?.anchorSeq : void 0;
+        const anchor = key !== void 0 ? chat?.nodes.get(key)?.anchorSeq : void 0;
         if (anchor !== void 0 && hiddenSeqs.has(anchor)) {
           seat.style.display = "none";
           seat.dataset.dshRewindHidden = "true";
@@ -834,7 +841,8 @@ function RewindPortals({ sessionId, sessionOf, currentSessionId, t, subscribeLoc
           `[dsh-rewind] hiding: ${hiddenCount} rows, seqs [${[...hiddenSeqs].slice(0, 20).join(", ")}${hiddenSeqs.size > 20 ? "\u2026" : ""}]`
         );
       }
-      const next = [...collectTargets(chat, hiddenSeqs), ...collectPendingTargets(snapshot)];
+      const durable = chat === void 0 ? [] : collectTargets(chat, hiddenSeqs);
+      const next = [...durable, ...collectPendingTargets(snapshot)];
       setTargets((current) => sameTargets(current, next) ? current : next);
     };
     const queueRefresh = () => {
@@ -860,6 +868,7 @@ function RewindPortals({ sessionId, sessionOf, currentSessionId, t, subscribeLoc
         target,
         sessionId,
         sessionOf,
+        chatOf,
         t
       },
       target.key
@@ -869,6 +878,7 @@ function RewindPortals({ sessionId, sessionOf, currentSessionId, t, subscribeLoc
         target,
         sessionId,
         sessionOf,
+        chatOf,
         currentSessionId,
         t
       },
@@ -878,7 +888,7 @@ function RewindPortals({ sessionId, sessionOf, currentSessionId, t, subscribeLoc
     target.key
   ));
 }
-function RewindButton({ target, sessionId, sessionOf, currentSessionId, t }) {
+function RewindButton({ target, sessionId, sessionOf, chatOf, currentSessionId, t }) {
   const onClick = (event) => {
     event.stopPropagation();
     const session = sessionOf(sessionId);
@@ -886,17 +896,18 @@ function RewindButton({ target, sessionId, sessionOf, currentSessionId, t }) {
       console.warn("[dsh-rewind] rewind button clicked with no session binding");
       return;
     }
-    const node = userNodeOf(session, target.key);
+    const node = userNodeOf(chatOf(session), target.key);
     if (node === void 0) return;
     openPopover({
       session,
+      chatOf,
       seq: node.seq,
       time: node.time,
       preview: messagePreviewOf(node),
       anchor: event.currentTarget,
       t,
       onRewind: (mode) => {
-        void runRewindAndFill(session, node.seq, mode, currentSessionId);
+        void runRewindAndFill(session, node.seq, mode, currentSessionId, chatOf);
       }
     });
   };
@@ -927,13 +938,14 @@ async function retractPending(session, itemId, text) {
     fillComposer(text);
   }
 }
-function RetractButton({ target, sessionId, sessionOf, t }) {
+function RetractButton({ target, sessionId, sessionOf, chatOf, t }) {
   const onClick = (event) => {
     event.stopPropagation();
     const session = sessionOf(sessionId);
     if (session === void 0) return;
     openPopover({
       session,
+      chatOf,
       preview: target.preview,
       anchor: event.currentTarget,
       t,
@@ -986,8 +998,7 @@ var zh = {
   "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"
+  "popover.back": "\u8FD4\u56DE"
 };
 var en = {
   "button.aria": "Rewind to this message",
@@ -1013,8 +1024,7 @@ var en = {
   "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."
+  "popover.back": "Back"
 };
 
 // src/client/index.ts
@@ -1034,6 +1044,17 @@ function apply(ctx) {
     const sessionOf = (sessionId) => ctx.sessions.binding(sessionId)?.session;
     const currentSessionId = () => ctx.sessions.list.getSnapshot().current;
     const subscribeLocale = (cb) => ctx.locale.subscribe(cb);
+    const uiConversation = () => ctx.get("uiConversation");
+    const CHAT_VIEW = "chat";
+    const chatOf = (session) => {
+      if (session === void 0) return void 0;
+      try {
+        const view = uiConversation()?.binding(session.sessionId).target(CHAT_VIEW);
+        return chatSnapshotOf(session, view);
+      } catch {
+        return void 0;
+      }
+    };
     const slots = ctx.slots;
     yield slots.inject(HEADER_ACTIONS_SLOT, () => slots.register(
       {
@@ -1043,23 +1064,19 @@ function apply(ctx) {
         id: "dsh-rewind-portals",
         order: 1e3
       },
-      createRewindBridge({ sessionOf, currentSessionId, t, subscribeLocale })
+      createRewindBridge({ sessionOf, chatOf, currentSessionId, t, subscribeLocale })
     ));
     const commandUi = ctx.get("commandUi");
-    const chatOf = (sessionId) => {
-      if (sessionId === void 0) return void 0;
-      const face = sessionOf(sessionId);
-      return face === void 0 ? void 0 : face.getSnapshot().chat;
-    };
     const hasCandidates = (sessionId) => {
-      const chat = chatOf(sessionId);
+      const face = sessionId === void 0 ? void 0 : sessionOf(sessionId);
+      const chat = chatOf(face);
       return chat !== void 0 && rewindCandidatesOfChat(chat).length > 0;
     };
-    const fetchHostCandidates = async (face) => {
-      const known = knownCommandSeqs(face, (node) => isCandidateCommand(node));
+    const fetchHostCandidates = async (face, chatOf2) => {
+      const known = knownCommandSeqs(face, chatOf2, (node) => isCandidateCommand(node));
       const result = await face.command("/rewind __candidates");
       if (!result.ok || result.value?.matched !== true) return void 0;
-      const outcome = await waitForCommand(face, (node) => isCandidateCommand(node) && !known.has(node.seq));
+      const outcome = await waitForCommand(face, chatOf2, (node) => isCandidateCommand(node) && !known.has(node.seq));
       if (outcome === null || outcome.kind !== "success" || outcome.text === void 0) return void 0;
       return rewindCandidatesFromHostText(outcome.text);
     };
@@ -1069,8 +1086,7 @@ function apply(ctx) {
       const card = textarea?.closest("[data-composer-card]");
       return card ?? textarea ?? document.body;
     };
-    yield commandUi.decorate({
-      name: "rewind",
+    const rewindPopupSpec = {
       // The picker exists exactly while the surface has a reachable user
       // message: a fresh session (no candidates) falls through to the host
       // command, which fails with "no user messages" — matching the harness's
@@ -1081,7 +1097,7 @@ function apply(ctx) {
         options: async (session) => {
           const face = sessionOf(session.sessionId);
           if (face === void 0) return [];
-          const candidates = await fetchHostCandidates(face);
+          const candidates = await fetchHostCandidates(face, chatOf);
           if (candidates !== void 0) hostCandidatesCache.set(session.sessionId, candidates);
           return candidates === void 0 ? [] : rewindOptionsFromCandidates(candidates, t);
         },
@@ -1094,77 +1110,24 @@ function apply(ctx) {
           if (candidate === void 0) return;
           openPopover({
             session: face,
+            chatOf,
             seq: candidate.seq,
             time: candidate.time,
             preview: candidate.preview,
             anchor: composerAnchor(),
             t,
             onRewind: (mode) => {
-              void runRewindAndFill(face, candidate.seq, mode, currentSessionId);
+              void runRewindAndFill(face, candidate.seq, mode, currentSessionId, chatOf);
             }
           });
         }
       }
-    });
-    const PARAM_REWIND = /^\s*\/rewind\s+\S+/i;
-    const composerTextarea = () => document.querySelector(COMPOSER_SELECTOR2);
-    const hasParamRewindDraft = () => {
-      const textarea = composerTextarea();
-      return textarea !== null && PARAM_REWIND.test(textarea.value);
-    };
-    let guardHintEl = null;
-    let guardHintTimer;
-    const showGuardHint = () => {
-      if (guardHintEl !== null) guardHintEl.remove();
-      if (guardHintTimer !== void 0) window.clearTimeout(guardHintTimer);
-      const textarea = composerTextarea();
-      if (textarea === null) return;
-      const card = textarea.closest("[data-composer-card]");
-      const hint = document.createElement("div");
-      hint.className = "dsh-rewind-guard-hint";
-      hint.setAttribute("role", "status");
-      hint.textContent = t("guard.hint");
-      document.body.appendChild(hint);
-      const rect = card instanceof HTMLElement ? card.getBoundingClientRect() : textarea.getBoundingClientRect();
-      hint.style.left = `${Math.round(rect.left)}px`;
-      hint.style.bottom = `${Math.round(window.innerHeight - rect.top + 8)}px`;
-      guardHintEl = hint;
-      guardHintTimer = window.setTimeout(() => {
-        hint.remove();
-        if (guardHintEl === hint) guardHintEl = null;
-        guardHintTimer = void 0;
-      }, 3200);
     };
-    const onParamRewindSubmit = (event) => {
-      if (!hasParamRewindDraft()) return;
-      event.preventDefault();
-      event.stopPropagation();
-      showGuardHint();
-    };
-    const onKeyDownGuard = (event) => {
-      if (event.key !== "Enter" || event.shiftKey || event.isComposing) return;
-      onParamRewindSubmit(event);
-    };
-    const onClickGuard = (event) => {
-      if (event.button !== 0 || !hasParamRewindDraft()) return;
-      const target = event.target;
-      if (!(target instanceof Element)) return;
-      const button = target.closest("button");
-      if (button === null) return;
-      const card = button.closest("[data-composer-card]");
-      if (card === null) return;
-      const all = card.querySelectorAll("button");
-      if (all[all.length - 1] !== button) return;
-      if (button.querySelector("rect") !== null) return;
-      onParamRewindSubmit(event);
-    };
-    document.addEventListener("keydown", onKeyDownGuard, true);
-    document.addEventListener("click", onClickGuard, true);
+    for (const name2 of ["rewind", "undo"]) {
+      yield commandUi.decorate({ name: name2, ...rewindPopupSpec });
+    }
+    const composerTextarea = () => document.querySelector(COMPOSER_SELECTOR2);
     yield () => {
-      document.removeEventListener("keydown", onKeyDownGuard, true);
-      document.removeEventListener("click", onClickGuard, true);
-      if (guardHintEl !== null) guardHintEl.remove();
-      if (guardHintTimer !== void 0) window.clearTimeout(guardHintTimer);
       style.remove();
     };
   }, "dsh-rewind client lifecycle");