dsh-rewind-plugin 0.2.9 → 0.3.1

package/README.md

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

package/README.zh.md

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

package/lib/client.js

@@ -32,14 +32,10 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/client/portals.tsx
-var import_react = require("react");
-var import_react_dom = require("react-dom");
-
 // src/client/hidden.ts
-function targetOfOutcome(text) {
-  if (text === void 0) return void 0;
-  const match = text.match(/seq (\d+)/);
+function targetSeqOfArgs(args) {
+  if (args === void 0 || args === null) return void 0;
+  const match = args.match(/@(\d+)/);
   return match !== null ? Number(match[1]) : void 0;
 }
 function isExecutedRewindCommand(node, seq) {
@@ -52,7 +48,7 @@ function hasFileImpact(text) {
   if (text === void 0) return true;
   const match = text.match(/impact=(\d+)/);
   if (match !== null) return Number(match[1]) > 0;
-  return text.includes("\u5C06\u5F71\u54CD");
+  return false;
 }
 function isPreviewCommand(command) {
   return (command.args ?? "").includes("preview");
@@ -73,7 +69,7 @@ function hiddenSeqsOf(snap) {
     const marker = command.outcome.sourceEventSeq;
     if (marker === void 0) continue;
     hidden.add(command.seq);
-    const target = targetOfOutcome(command.outcome.text);
+    const target = targetSeqOfArgs(command.args);
     if (target !== void 0) {
       spans.push({ start: target, end: marker });
     }
@@ -89,6 +85,48 @@ function hiddenSeqsOf(snap) {
   return hidden;
 }
 
+// src/client/candidates.ts
+var PREVIEW_CHARS = 80;
+function messagePreviewOf(message) {
+  const text = message.content.map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").join("").replace(/\s+/g, " ").trim();
+  return text.length <= PREVIEW_CHARS ? text : `${text.slice(0, PREVIEW_CHARS - 1)}\u2026`;
+}
+function formatCandidateTime(time) {
+  const d = new Date(time);
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  return `${hh}:${mm}`;
+}
+function rewindCandidatesOf(snap, hidden, limit = 10) {
+  const candidates = [];
+  for (let i = snap.order.length - 1; i >= 0 && candidates.length < limit; i--) {
+    const key = snap.order[i];
+    if (key === void 0) continue;
+    const node = snap.nodes.get(key);
+    if (node === void 0 || node.kind !== "user" && node.kind !== "steering") continue;
+    if (hidden.has(node.anchorSeq ?? node.data.seq)) continue;
+    candidates.push({
+      seq: node.data.seq,
+      time: node.data.time,
+      preview: messagePreviewOf(node.data)
+    });
+  }
+  return candidates;
+}
+function rewindCandidatesOfChat(snap) {
+  return rewindCandidatesOf(snap, hiddenSeqsOf(snap));
+}
+function rewindOptionsOf(snap, t) {
+  return rewindCandidatesOfChat(snap).map((candidate) => ({
+    id: String(candidate.seq),
+    label: candidate.preview || t("popover.noText"),
+    detail: formatCandidateTime(candidate.time)
+  }));
+}
+function candidateBySeq(snap, seq) {
+  return rewindCandidatesOfChat(snap).find((candidate) => candidate.seq === seq);
+}
+
 // src/client/styles.ts
 var CLASS = {
   button: "dsh-rewind-btn",
@@ -266,8 +304,14 @@ function formatTarget(t, seq, time, preview) {
   const previewText = preview.length > 0 ? preview : t("popover.noText");
   return `seq ${seq} \xB7 ${hh}:${mm} \xB7 ${previewText}`;
 }
-function stripImpactToken(text) {
-  return text.replace(/\n?impact=\d+\s*$/, "");
+function parseImpactList(text) {
+  const restores = [];
+  const deletes = [];
+  for (const line of text.split("\n")) {
+    if (line.startsWith("restore:")) restores.push(line.slice("restore:".length));
+    else if (line.startsWith("delete:")) deletes.push(line.slice("delete:".length));
+  }
+  return { restores, deletes };
 }
 function findCommand(snapshot, match) {
   let found;
@@ -339,6 +383,20 @@ function modeOption(label, hint, onClick) {
   button.addEventListener("click", onClick);
   return button;
 }
+function focusableButtons(root) {
+  return Array.from(root.querySelectorAll("button")).filter((button) => !button.disabled && !button.classList.contains(CLASS.popoverGhost));
+}
+function focusFirst(root) {
+  focusableButtons(root)[0]?.focus();
+}
+function moveFocus(root, dir) {
+  const buttons = focusableButtons(root);
+  if (buttons.length === 0) return;
+  const active = document.activeElement;
+  const index = active instanceof HTMLButtonElement ? buttons.indexOf(active) : -1;
+  const next = index === -1 ? dir === 1 ? 0 : buttons.length - 1 : (index + dir + buttons.length) % buttons.length;
+  buttons[next]?.focus();
+}
 function renderImpactStep(root, opts, back, cached) {
   const { session, seq, t } = opts;
   const impact = el("div", CLASS.popoverImpact, t("popover.impact.loading"));
@@ -356,6 +414,7 @@ function renderImpactStep(root, opts, back, cached) {
   confirm.disabled = true;
   actions.append(confirm);
   root.replaceChildren(impact, actions);
+  focusFirst(root);
   void (async () => {
     const outcome = cached ?? await previewImpact(session, seq);
     if (outcome === null) {
@@ -366,8 +425,22 @@ function renderImpactStep(root, opts, back, cached) {
       impact.textContent = t("popover.impact.failed", { message: outcome.text ?? "unknown error" });
       return;
     }
-    impact.textContent = outcome.text === void 0 ? t("popover.impact.none") : stripImpactToken(outcome.text);
+    if (outcome.text === void 0) {
+      impact.textContent = t("popover.impact.none");
+    } else {
+      const { restores, deletes } = parseImpactList(outcome.text);
+      if (restores.length === 0 && deletes.length === 0) {
+        impact.textContent = t("popover.impact.none");
+      } else {
+        const lines = [
+          ...restores.map((path) => t("popover.impact.restore", { path })),
+          ...deletes.map((path) => t("popover.impact.delete", { path }))
+        ];
+        impact.textContent = lines.join("\n");
+      }
+    }
     confirm.disabled = false;
+    confirm.focus();
     confirm.addEventListener("click", () => {
       closePopover();
       opts.onRewind("both");
@@ -384,7 +457,9 @@ function openPopover(opts) {
   root.setAttribute("aria-label", t("popover.title"));
   let bothState = { state: "loading" };
   let impactOutcome = null;
+  let step = "modes";
   const renderModes = () => {
+    step = "modes";
     const children = [
       el("div", CLASS.popoverTitle, t("popover.title")),
       el("div", CLASS.popoverTarget, formatTarget(t, seq, time, preview)),
@@ -399,9 +474,7 @@ function openPopover(opts) {
       const option = modeOption(
         t("popover.both"),
         bothState.state === "loading" ? t("popover.checking") : t("popover.both.hint"),
-        () => {
-          renderImpactStep(root, opts, renderModes, impactOutcome);
-        }
+        renderImpact
       );
       if (bothState.state === "loading") option.disabled = true;
       children.push(option);
@@ -415,6 +488,11 @@ function openPopover(opts) {
     actions.append(cancel);
     children.push(actions);
     root.replaceChildren(...children);
+    focusFirst(root);
+  };
+  const renderImpact = () => {
+    step = "impact";
+    renderImpactStep(root, opts, renderModes, impactOutcome);
   };
   const position = () => {
     const rect = anchor.getBoundingClientRect();
@@ -427,6 +505,7 @@ function openPopover(opts) {
   renderModes();
   document.body.append(root);
   position();
+  focusFirst(root);
   void (async () => {
     const outcome = await previewImpact(session, seq);
     impactOutcome = outcome;
@@ -447,25 +526,40 @@ function openPopover(opts) {
     closePopover();
   };
   const onKeyDown = (event) => {
-    if (event.key === "Escape") closePopover();
+    if (event.key === "ArrowDown") {
+      event.preventDefault();
+      event.stopPropagation();
+      moveFocus(root, 1);
+      return;
+    }
+    if (event.key === "ArrowUp") {
+      event.preventDefault();
+      event.stopPropagation();
+      moveFocus(root, -1);
+      return;
+    }
+    if (event.key === "Escape") {
+      event.preventDefault();
+      event.stopPropagation();
+      if (step === "impact") renderModes();
+      else closePopover();
+    }
   };
   const deferred = setTimeout(() => {
     document.addEventListener("pointerdown", onPointerDown);
-    document.addEventListener("keydown", onKeyDown);
+    document.addEventListener("keydown", onKeyDown, true);
   }, 0);
   disposeOutside = () => {
     clearTimeout(deferred);
     document.removeEventListener("pointerdown", onPointerDown);
-    document.removeEventListener("keydown", onKeyDown);
+    document.removeEventListener("keydown", onKeyDown, true);
   };
 }
 
 // src/client/portals.tsx
+var import_react = require("react");
+var import_react_dom = require("react-dom");
 var import_jsx_runtime = require("react/jsx-runtime");
-function messagePreviewOf(node) {
-  const text = node.content.map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").join("").replace(/\s+/g, " ").trim();
-  return text.length <= 80 ? text : `${text.slice(0, 79)}\u2026`;
-}
 function userTextAt(session, seq) {
   const snap = session.getSnapshot();
   for (const key of snap.chat.order) {
@@ -663,9 +757,11 @@ var zh = {
   "popover.impact.loading": "\u6B63\u5728\u83B7\u53D6\u5F71\u54CD\u6E05\u5355\u2026",
   "popover.impact.failed": "\u65E0\u6CD5\u83B7\u53D6\u5F71\u54CD\u6E05\u5355\uFF1A{message}",
   "popover.impact.none": "\u76EE\u6807\u4E4B\u540E\u6CA1\u6709\u8DDF\u8E2A\u5230\u7684\u5199\u7C7B\u53D8\u66F4\uFF0C\u65E0\u9700\u8FD8\u539F\u6587\u4EF6\u3002",
+  "popover.impact.restore": "\u8FD8\u539F {path}",
+  "popover.impact.delete": "\u5220\u9664 {path}",
   "popover.confirm": "\u786E\u8BA4\u56DE\u9000",
   "popover.back": "\u8FD4\u56DE",
-  "guard.hint": "/rewind \u547D\u4EE4\u4E0D\u652F\u6301\u624B\u52A8\u8F93\u5165\uFF0C\u8BF7\u4F7F\u7528\u6D88\u606F\u65C1\u7684 \u21B6 \u56DE\u9000\u6309\u94AE"
+  "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"
 };
 var en = {
   "button.aria": "Rewind to this message",
@@ -682,14 +778,16 @@ var en = {
   "popover.impact.loading": "Fetching impact list\u2026",
   "popover.impact.failed": "Could not fetch the impact list: {message}",
   "popover.impact.none": "No tracked file changes after the target; nothing to restore.",
+  "popover.impact.restore": "Restore {path}",
+  "popover.impact.delete": "Delete {path}",
   "popover.confirm": "Confirm rewind",
   "popover.back": "Back",
-  "guard.hint": "/rewind cannot be typed manually \u2014 use the \u21B6 button on a message to rewind."
+  "guard.hint": "/rewind takes no typed arguments \u2014 enter /rewind to open the rewind picker."
 };
 
 // src/client/index.ts
 var name = "dsh-rewind";
-var inject = ["slots", "sessions", "locale"];
+var inject = ["slots", "sessions", "locale", "commandUi"];
 var NS = "rewind";
 var HEADER_ACTIONS_SLOT = "conversation.session.header.actions";
 var COMPOSER_SELECTOR2 = "[data-input-scroll] textarea, textarea[data-phase]";
@@ -715,11 +813,58 @@ function apply(ctx) {
       },
       createRewindBridge({ sessionOf, currentSessionId, t, subscribeLocale })
     ));
-    const MANUAL_REWIND = /^\s*\/rewind(?:\s|$)/i;
+    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);
+      return chat !== void 0 && rewindCandidatesOfChat(chat).length > 0;
+    };
+    const composerAnchor = () => {
+      const textarea = composerTextarea();
+      const card = textarea?.closest("[data-composer-card]");
+      return card ?? textarea ?? document.body;
+    };
+    yield commandUi.decorate({
+      name: "rewind",
+      // 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
+      // own decoration convention (see ui-permission-presets).
+      available: (session) => hasCandidates(session.sessionId),
+      ui: {
+        kind: "popupSelect",
+        options: (session) => {
+          const chat = chatOf(session.sessionId);
+          return Promise.resolve(chat === void 0 ? [] : rewindOptionsOf(chat, t));
+        },
+        onSelect: (option, session) => {
+          const face = sessionOf(session.sessionId);
+          const chat = chatOf(session.sessionId);
+          const candidate = chat !== void 0 ? candidateBySeq(chat, Number(option.id)) : void 0;
+          if (face === void 0 || candidate === void 0) return;
+          openPopover({
+            session: face,
+            seq: candidate.seq,
+            time: candidate.time,
+            preview: candidate.preview,
+            anchor: composerAnchor(),
+            t,
+            onRewind: (mode) => {
+              void runRewindAndFill(face, candidate.seq, mode, currentSessionId);
+            }
+          });
+        }
+      }
+    });
+    const PARAM_REWIND = /^\s*\/rewind\s+\S+/i;
     const composerTextarea = () => document.querySelector(COMPOSER_SELECTOR2);
-    const hasBlockedRewindDraft = () => {
+    const hasParamRewindDraft = () => {
       const textarea = composerTextarea();
-      return textarea !== null && MANUAL_REWIND.test(textarea.value);
+      return textarea !== null && PARAM_REWIND.test(textarea.value);
     };
     let guardHintEl = null;
     let guardHintTimer;
@@ -744,15 +889,18 @@ function apply(ctx) {
         guardHintTimer = void 0;
       }, 3200);
     };
-    const onKeyDownGuard = (event) => {
-      if (event.key !== "Enter" || event.shiftKey || event.isComposing) return;
-      if (!hasBlockedRewindDraft()) return;
+    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 || !hasBlockedRewindDraft()) return;
+      if (event.button !== 0 || !hasParamRewindDraft()) return;
       const target = event.target;
       if (!(target instanceof Element)) return;
       const button = target.closest("button");
@@ -762,9 +910,7 @@ function apply(ctx) {
       const all = card.querySelectorAll("button");
       if (all[all.length - 1] !== button) return;
       if (button.querySelector("rect") !== null) return;
-      event.preventDefault();
-      event.stopPropagation();
-      showGuardHint();
+      onParamRewindSubmit(event);
     };
     document.addEventListener("keydown", onKeyDownGuard, true);
     document.addEventListener("click", onClickGuard, true);