dsh-rewind-plugin 0.4.2 → 0.6.0

package/docs/format.md

@@ -0,0 +1,151 @@
+# Durable format
+
+The on-disk format of the dsh-rewind checkpoint store, pinned as a spec. The
+implementation is `src/snapshot.ts`; this document is the reference for what
+readers may rely on and what a future incompatible change must do. If the code
+and this spec disagree, the code wins and this spec is a bug.
+
+## State root
+
+The store root defaults to `<harness home>/rewind-snapshots/` — the dsh data
+directory (`~/.dsh/rewind-snapshots/` when `DSH_HOME` is unset) — overridable in
+order by the `snapshotDir` plugin config, then the `DSH_REWIND_SNAPSHOT_DIR`
+environment variable. It is a sibling of the workspace, never a subtree of it.
+Deleting the root only removes file backups; the store rebuilds from scratch.
+
+```
+<root>/
+└── <sessionId>/                        # safeSessionId(sessionId)
+    ├── <anchorSeq>/                    # decimal seq of the anchoring user/message
+    │   └── <callId>.json               # one committed before-backup
+    └── restore-journal-<opId>.json     # one restore-op journal
+```
+
+- `sessionId` is sanitized to `[a-zA-Z0-9._-]`; the bare values `.` and `..`
+  are replaced (`safeSessionId`) so a hostile id cannot traverse out of the
+  root.
+- `callId` is sanitized to `[a-zA-Z0-9._-]` (`safeFileId`).
+- `<anchorSeq>` is a decimal integer; directories with non-integer names are
+  ignored by readers.
+- Journal files are recognized by the `restore-journal-` prefix; everything
+  else ending in `.json` under the session dir is treated as a checkpoint
+  entry.
+
+## Checkpoint entry
+
+One JSON file per before-backup, named `<callId>.json`:
+
+```ts
+interface CheckpointEntry {
+  callId: string      // the tool call that mutated the file
+  anchorSeq: number   // seq of the user message anchoring the turn of the change
+  path: string        // resolved display path (absolute)
+  before: string | null // full content before the change; null = file was created
+  time: number        // epoch ms, strictly increasing within a store instance
+}
+```
+
+Semantics:
+
+- **`before` is the pre-edit state**: `null` means the call created the file.
+- **`anchorSeq` ties the backup to a user message**: rewinding to message N
+  applies every entry anchored at or after N (the boundary is inclusive).
+- **`time` is the ordering key within an anchor group**: it is monotonic per
+  store instance (bumped past the previous commit), so same-millisecond
+  commits stay capture-ordered and a re-read always picks the same "earliest"
+  entry per path.
+- Synthetic re-check entries (external edits/deletions seen at a user-message
+  boundary) use `callId = recheck-<anchorSeq>-<sha256(path) first 8 hex>`.
+
+### Dedup link entry
+
+A tracked file that records the same `before` content as its immediately-prior
+entry for that path is stored as a **link** instead of a full copy: the entry
+carries a `ref` (the `<anchorSeq>/<callId>.json` of that prior entry) and omits
+`before`, so identical content is never duplicated across entries. A reader
+resolves the `ref` back to the terminal real snapshot; `before: null` still
+means "the file was created". A `ref` is validated as a single-level,
+`<digits>/<callId>.json` relative reference (no traversal) so a corrupt or
+hostile ref cannot escape the store root when followed. Because links reference
+prior entries, `prune` materializes a surviving link whose `ref` lands on a
+group it is about to drop before deleting that group, so no kept link is left
+dangling.
+
+Real entries (with `before`) are unchanged and read identically before and
+after this addition; a link entry is a distinct kind that lacks `before`.
+
+## Restore journal
+
+One JSON file per restore operation, written **before any mutation** and
+updated as the pass applies:
+
+```ts
+interface RestoreJournal {
+  version: 1
+  id: string                    // `op-<base36 ms>-<random>`; file name suffix
+  sessionId: string
+  targetSeq: number             // rewind target the restore belongs to
+  startedAt: number             // epoch ms
+  finishedAt?: number           // set on a terminal state
+  state: 'running' | 'rollback-running' | 'completed' | 'rolled-back' | 'recovery-required'
+  actions: RestoreJournalAction[]
+  rollbackError?: string        // set when a rollback pass failed partway
+}
+
+interface RestoreJournalAction {
+  path: string
+  action: 'restore' | 'delete'  // restore = write `before` back; delete = unlink
+  before: string | null         // target content for restore; null for delete
+  rescue: string | null         // pre-restore disk state; null = file was absent
+  rescueError?: string          // set when the rescue capture failed (rollback skips it)
+  done: boolean                 // true once the action's fs op completed and was marked
+  failed?: string               // per-action failure message (the pass never aborts)
+}
+```
+
+States: `running` and `rollback-running` are non-terminal; a host restart turns
+them into `interrupted` (or `recovery-required` when the journal is corrupt or
+a rollback could not complete). `completed` / `rolled-back` are terminal.
+
+## Write guarantees
+
+- **Atomicity**: every JSON write serializes to a sibling `<target>.tmp` and
+  renames over the target. A crash between the two steps leaves only the temp
+  file — never a readable half-written target — and readers ignore temp files
+  (they do not end in `.json`). The next write of the same target overwrites
+  a leftover temp.
+- **Journal before mutation**: the rescue state of every planned path is
+  captured and the intent journal persisted atomically BEFORE the first fs
+  mutation; each action is marked `done` as it is applied.
+- **Disk is truth**: after a restart, reconciliation compares the real disk
+  against each action's goal (the restore target for `running` journals, the
+  rescue state for `rollback-running` / `recovery-required` ones). A path
+  whose disk already matches is marked done without being touched.
+- **Bounded storage**: `prune` keeps the newest 100 anchor groups per session
+  (`MAX_ANCHOR_GROUPS`), materializing any surviving dedup link that references
+  a group being dropped before deleting whole anchor directories; it also
+  recycles terminal journals (`completed` / `rolled-back`). Non-terminal and
+  corrupt journals are always kept. Across sessions, `pruneStale` removes whole
+  long-inactive session directories whose newest member stamp is older than a
+  configurable idle cutoff (default off), so the store root does not grow
+  without bound either.
+
+## Validation and failure policy
+
+- **Entries**: a missing or malformed entry is read as `undefined` (silently
+  skipped) — losing one backup, never the recovery path.
+- **Journals**: a corrupt or schema-invalid journal **fails loud** —
+  `reconcileRestores` reports it as `recovery-required` and never drops it,
+  because dropping it would silently erase the interrupted restore's recovery
+  record.
+- **Journal IO**: best-effort by design — if a journal cannot be written, the
+  restore proceeds with pre-journal semantics (crash safety degrades,
+  behavior does not).
+
+## Versioning policy
+
+The journal schema is `version: 1`. Checkpoint entries currently carry no
+version field. A future incompatible format must either bump the journal
+`version` (readers reject unknown values — there is no best-effort fallback or
+legacy coercion) or move the state root (e.g. `rewind-snapshots/v2`) and ship
+an explicit migration tool. Old-format data is never silently re-interpreted.

package/docs/harness-reference.md

@@ -21,7 +21,7 @@
 
 Compatibility probes against these subsystems (test-driven investigation, the
 `compat-invariants` / `compat-interop` vitest suites + the `verify-host` real
-`/compact` chain): [compat-audit.md](compat-audit.md).
+`/compact` chain): [compat/audit.md](compat/audit.md).
 
 Also under `docs/` at the repo root: `persistence-catalog.md` (full
 `SessionEventMap`), `tool-catalog.md` (tool inventory), `config-catalog.md`
@@ -45,20 +45,24 @@ Also under `docs/` at the repo root: `persistence-catalog.md` (full
 
 ## Plugin source layout
 
+The module map below duplicates `AGENTS.md` (`Layout at a glance`), which is
+the canonical source; this block only adds the finer-grained client-side files
+and packaging entries.
+
 ```
 src/index.ts            host plugin: /rewind command + checkpoint pipeline (tools/execute|post-execute)
 src/rewind.ts           pure planning: target resolution, surface range, candidate listing
 src/snapshot.ts         checkpoint store (disk before-backups, restore/preview, bounded prune)
 src/session-cwd.ts      session-cwd resolution (fs-tools rule)
-src/client/index.ts     client plugin: per-message ↶ button + manual /rewind guard
+src/client/index.ts     client plugin: /rewind command decoration + per-message ↶ button portals
 src/client/popover.ts   mode-selection popover (both-mode impact confirm)
 src/client/hidden.ts    withdrawn-span computation (hiddenSeqsOf), pure
 src/client/locales.ts   zh / en copy (LocaleNamespaceMap)
 src/client/styles.ts    injected styles (dsh design tokens)
 scripts/build.mjs       esbuild: lib/index.js (host ESM) + lib/client.js (loader closure) + .d.ts
-scripts/verify-host.mjs end-to-end host verification (18 checks)
+scripts/verify-host.mjs end-to-end host verification (full check suite)
 tests/                  vitest suites (rewind / snapshot / hidden / session-cwd / integration)
-docs/                   maintainer docs: harness reference, troubleshooting, release steps
+docs/                   maintainer docs: contract/, compat/, release/ subdirectories
 assets/screenshots/     UI screenshots
 cordis.patch.yml        bundle patch (mounts the dual-face plugin row)
 package.json            dsh.bundle + dsh.client manifests, optional peerDependencies

package/docs/release/release.md

@@ -0,0 +1,69 @@
+# Release
+
+[简体中文](release.zh.md)
+
+## First release (manual, one-time)
+
+Trusted Publisher can only be configured once the package exists, so the first
+version is published locally:
+
+```sh
+npm login
+npm publish --access public
+```
+
+- If prompted for `EOTP`: complete the browser auth link the CLI prints, or
+  retry with a 6-digit code — `npm publish --otp=<code>`.
+- The first version carries no provenance (local path) — acceptable; every CI
+  release after that publishes with Sigstore/SLSA provenance automatically.
+
+## Configure Trusted Publisher (npmjs.com, one-time)
+
+Open `https://www.npmjs.com/package/dsh-rewind-plugin` → package **settings** →
+**Trusted Publisher**:
+
+| Field | Value |
+| --- | --- |
+| Provider | GitHub Actions |
+| Organization or user | `SiriLee` |
+| Repository | `dsh-rewind` (the GitHub repo, not the npm name) |
+| Workflow filename | `publish.yml` |
+| Environment | empty |
+| Allowed actions | `npm publish` |
+
+## Subsequent releases (CI, automatic)
+
+```sh
+npm version patch
+git push origin main --tags   # triggers .github/workflows/publish.yml
+```
+
+- The workflow verifies the tag matches `package.json`, runs typecheck + tests +
+  a full build + artifact verification, publishes with `--provenance`
+  (Sigstore), and creates a GitHub Release. It is **idempotent** — an already
+  published version is skipped.
+- CI (`.github/workflows/ci.yml`) runs `npm run check` — typecheck + tests +
+  build + artifact verification + a `npm pack --dry-run` — on every push / PR
+  across both Node engines boundary versions; the tarball layout is guarded by
+  `tests/package-layout.test.ts`.
+
+## DSH version alignment (peer range maintenance)
+
+DSH is still in rc; npm's prerelease matching rules require a peer range to
+share the host version's `[major, minor, patch]` tuple. So `peerDependencies`
+uses an OR-union covering every published rc tuple series
+(e.g. `^0.1.0-rc.6 || ^0.1.1-rc.2`), extended as DSH releases new tuples.
+
+- **When to update**: only when DSH releases a new tuple
+  (`0.1.1 → 0.1.2 → 0.2.x`); rc rolling within a tuple (`0.1.1-rc.2 → rc.3`)
+  needs nothing. All `@deepseek-ai/*` packages release together;
+  `npm view @deepseek-ai/dsh version` is the authoritative signal.
+- **Automatic detection**: `node scripts/check-dsh-version.mjs` compares the
+  latest npm version against the tuples the peers cover and reports whether an
+  extension is needed (exit 0 = nothing to do, exit 1 = update).
+- **Update steps**: append `|| ^<new-tuple>-rc.<n>` to every
+  `@deepseek-ai/dsh-*` peer → bump devDependencies to the latest → `npm
+  install` → `npm run check` → release.
+- **After DSH goes final**: final releases are not bound by the prerelease
+  tuple rule, so the peers can converge to a single stable range (e.g.
+  `^0.1.x`); this section can then be deleted.

package/docs/{release.md → release/release.zh.md}

@@ -1,53 +1,7 @@
-# Release
-
-## First release (manual, one-time)
-
-Trusted Publisher can only be configured once the package exists, so the first
-version is published locally:
-
-```sh
-npm login
-npm publish --access public
-```
-
-- If prompted for `EOTP`: complete the browser auth link the CLI prints, or
-  retry with a 6-digit code — `npm publish --otp=<code>`.
-- The first version carries no provenance (local path) — acceptable; every CI
-  release after that publishes with Sigstore/SLSA provenance automatically.
-
-## Configure Trusted Publisher (npmjs.com, one-time)
-
-Open `https://www.npmjs.com/package/dsh-rewind-plugin` → package **settings** →
-**Trusted Publisher**:
-
-| Field | Value |
-| --- | --- |
-| Provider | GitHub Actions |
-| Organization or user | `SiriLee` |
-| Repository | `dsh-rewind` (the GitHub repo, not the npm name) |
-| Workflow filename | `publish.yml` |
-| Environment | empty |
-| Allowed actions | `npm publish` |
-
-## Subsequent releases (CI, automatic)
-
-```sh
-npm version patch
-git push origin main --tags   # triggers .github/workflows/publish.yml
-```
-
-- The workflow verifies the tag matches `package.json`, runs typecheck + tests +
-  a full build + artifact verification, publishes with `--provenance`
-  (Sigstore), and creates a GitHub Release. It is **idempotent** — an already
-  published version is skipped.
-- CI (`.github/workflows/ci.yml`) runs the same checks on every push / PR, plus
-  a `npm pack --dry-run` sanity check that the tarball carries `lib/` and
-  `LICENSE`.
-
----
-
 # 发布流程
 
+[English](release.md)
+
 ## 首次发布（手动，一次性）
 
 Trusted Publisher 要求**包已存在**才能配置，因此首个版本走本地发布：
@@ -86,8 +40,9 @@ git push origin main --tags   # 触发 .github/workflows/publish.yml
 - workflow 校验 tag 与 `package.json` 版本一致，跑 typecheck + 测试 + 完整
   构建 + 产物验证，以 `--provenance`（Sigstore）发布并创建 GitHub Release。
   **幂等**——已发布的版本会跳过。
-- CI（`.github/workflows/ci.yml`）在每次 push / PR 跑相同检查，外加
-  `npm pack --dry-run` 校验 tarball 含 `lib/` 与 `LICENSE`。
+- CI（`.github/workflows/ci.yml`）在每次 push / PR 跑 `npm run check`——
+  typecheck + 测试 + 构建 + 产物验证 + `npm pack --dry-run`，且覆盖
+  engines 两个边界版本；tarball 布局由 `tests/package-layout.test.ts` 守护。
 
 ## DSH 版本适配（peer 范围维护）
 
@@ -102,7 +57,6 @@ OR 并集覆盖 DSH 已发布的每个 rc 元组系列（如 `^0.1.0-rc.6 || ^0.
 - **自动检测**：`node scripts/check-dsh-version.mjs` 对比 npm 最新版本与
   peer 覆盖的元组，输出是否需追加（exit 0 无需动作，exit 1 需要）。
 - **更新步骤**：给每个 `@deepseek-ai/dsh-*` peer 追加 `|| ^<新元组>-rc.<n>`
-  → devDependencies 同步升到最新 → `npm install` → `npm run typecheck` /
-  `npm test` / `npm run verify:host` → 发版。
+  → devDependencies 同步升到最新 → `npm install` → `npm run check` → 发版。
 - **正式版后收敛**：DSH 发布 final 版本后，正式版不受 prerelease 元组规则
   限制，peer 可收敛为稳定的 `^0.1.x` 单范围，此节即可删除。

package/docs/snapshot-auto-cleanup.md

@@ -0,0 +1,90 @@
+# Snapshot cleanup
+
+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.
+
+`/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 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` always starts as a preview; add `--apply` to make the change. `run` works
+whether or not automatic cleanup is on.
+
+## Settings
+
+The settings live in `<dsh home>/snapshot-cleanup.json`:
+
+```json
+{ "enabled": false, "maxAgeDays": 30 }
+```
+
+- `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

@@ -0,0 +1,57 @@
+# 快照清理
+
+插件会在每次修改文件前保存一份备份，方便你把代码回退到之前的状态。这些备份叫**快照**，按消息分组、按会话存放。
+
+`/snapshot-auto-cleanup` 帮你管理这些快照——既可以回收旧会话占用的磁盘，也可以清空**当前**会话、让它从"现在"重新开始记录回退历史。
+
+## 它能做什么
+
+**自动清理**（默认关闭）：插件会记住哪些会话你已不再使用，并定期移除它们的快照以节省磁盘。它**绝不**触碰你当前活跃的会话，也**绝不**触碰你的对话。
+
+**手动：**即使自动清理是关闭的，你也可以自己执行清理：
+
+- `/snapshot-auto-cleanup run [--apply]` — 先预演，再真正移除你已有一阵子没用的会话的快照。
+- `/snapshot-auto-cleanup run --current [--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` 一开始总是预演；加 `--apply` 才真正执行。`run` 无论自动清理是否开启都能用。
+
+## 设置
+
+设置保存在 `<dsh home>/snapshot-cleanup.json`：
+
+```json
+{ "enabled": false, "maxAgeDays": 30 }
+```
+
+- `enabled` — 是否运行自动清理（默认 `false`）。
+- `maxAgeDays` — 会话失活多少天后移除其快照（默认 `30`）。只接受正数，因此一个损坏的设置永远不可能"删掉一切"。
+
+你可以用环境变量 `DSH_SNAPSHOT_CLEANUP_CONFIG` 指向别的文件。该文件只在运行 `/snapshot-auto-cleanup` 时写入；文件缺失按安全默认值（关闭）处理。
+
+## 自动清理何时运行
+
+自动清理每次运行（宿主启动）**最多检查一次**，发生在首次活动时（你发出一条消息或某次工具调用完成），且仅在**已开启**且距上次检查**已满 24 小时**时才执行。这个 24 小时时钟会写入 `<dsh home>/snapshot-cleanup-last-sweep.json`，重启不会重置。它后台运行，从不阻塞你在做的事。
+
+想让改动立即生效，请用 `run`；自动清理要到下次运行才会采用新设置。
+
+## 安全
+
+- 只会移除回退用的**快照**（那份文件备份）。你的对话绝不会被动到，插件也绝不改写或删除你的会话历史。
+- 自动清理**永不**移除你**当前活跃**会话的快照——只清理已失活超过阈值的会话。
+- `run --current` 会清空当前会话的快照。这对该会话的文件回退历史是**不可逆**的：你无法回退到清空之前的代码状态，但你的对话保持完整，会话会从"现在"开始重新记录快照。
+
+## 已知限制
+
+插件每个会话只保留**最近 100 条消息**的快照。若你在一个很长的会话里多次回退或压缩，这 100 个名额常会被"已经无法再回退到"的消息占满，你可能无法回退到想要的位置。（Claude Code 也是同样行为。）想恢复到一个干净状态，运行 `/snapshot-auto-cleanup run --current --apply` 清空当前会话、重新开始。

package/lib/client.js

@@ -986,8 +986,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 +1012,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
@@ -1069,8 +1067,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
@@ -1105,66 +1102,12 @@ function apply(ctx) {
           });
         }
       }
-    });
-    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");