dsh-rewind-plugin 0.3.3 → 0.4.1

package/README.md

@@ -66,6 +66,7 @@ The plugin appends an **empty-content marker** `assistant/message` into the sess
 - The marker carries `sourceEventSeqs` covering every shadowed node, and `Session.append`'s surface rules validate the cut (a contiguous range on the current surface).
 - Because the marker is **empty**, the harness derives it to `null` — it never enters the model context and never renders as conversation content. Agent and user both see the conversation exactly as it was at the target.
 - The marker's **turn number reuses the last started turn** (`markerTurnOf`), never `lastTurn + 1`: the harness numbers its next real turn exactly `last turn/start + 1`, so a `maxTurn + 1` marker would sit *before* that `turn/start` — the client conversation builder rejects the ordering (`…turn-tail… received an update before its start Match`) and history load fails. Reusing an already-consumed turn makes the marker a harmless trailing update on the previous completed turn's tail — it can never collide with a future turn.
+- The marker rides a **ghost step frame** — its own `step/start` … `step/end` with a fresh step number (`markerStepOf`) — because the harness token-meter requires every `assistant/message` to sit inside an open step of the same turn/step; a bare idle-time marker would fail its replay and break `/compact` for the session.
 - The append-only log is **untouched** — every withdrawn event stays in the audit trail; only the model-visible surface is cut, so the next request derives its context from the target onward.
 
 A running turn (LLM thinking / streaming) is force-stopped first (`cancel({ kind: 'user' })`) and the rewind waits for quiescence; if it can't stop, the rewind is aborted with an error.
@@ -109,11 +110,19 @@ The essential difference: dsh-turn-rewind keeps the log immutable and therefore
 > This project and DeepSeek Harness are both in developer preview. Pin exact
 > versions in reproducible environments and review the behavior notes above.
 
+## Client contract
+
+Third-party DOM plugins that need to know which transcript rows a rewind
+withdrew should consume the stable, locale-independent helpers exported from
+`dsh-rewind-plugin/client` (`hiddenSeqsOf`, `targetSeqOfArgs`) — never parse
+`outcome.text`. The `data-dsh-rewind-hidden` attribute marks withdrawn rows
+(observational only). Details: [docs/client-contract.md](docs/client-contract.md).
+
 ## Known issues
 
-Rewinds created with versions `≤ v0.2.4` could corrupt client replay when followed by more conversation (a marker turn collides with the next `turn/start`). The offline repair tool ships **inside the npm package** (`dsh-rewind-repair`). This only affects sessions you already had before upgrading — a fresh install never hits it.
+Rewinds created with versions `≤ v0.2.4` could corrupt client replay when followed by more conversation (a marker turn collides with the next `turn/start`). Only pre-upgrade sessions are affected. The offline repair tool (`dsh-rewind-repair`) was shipped before v0.4.0 and is no longer provided from v0.4.0 on — install a pre-v0.4.0 release if you need it ([docs/troubleshooting.md](docs/troubleshooting.md)).
 
-Full instructions: [docs/troubleshooting.md](docs/troubleshooting.md)
+Rewinds from `≤ v0.3.3` appended a bare marker (no step frame); the harness token-meter rejects such a log on replay, so `/compact` fails for that session. Newer versions are compatible; affected old sessions have no online repair yet — start a new session.
 
 ## Security
 
@@ -125,12 +134,26 @@ This plugin only appends rewind-marker events to the session log; it never delet
 
 ```sh
 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 typecheck      # tsc on all three surfaces (host + client + client-test)
+npm test               # vitest: rewind / snapshot / hidden / session-cwd / integration / compat-invariants / compat-interop
 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
+node scripts/verify-host.mjs   # boot the BUILT host artifact end-to-end (incl. real /compact after rewind)
 ```
 
+`npm test` and `verify-host` include the **compatibility probe suites**
+([docs/compat-audit.md](docs/compat-audit.md)): scenario-generated logs drive the
+real harness packages (token-meter, compaction, session-stats/title/goal folds,
+resume preflight) through rewind markers and assert the compatibility
+invariants. A failing probe is a discovered incompatibility, not a mock
+artifact. One finding is recorded: **R-OPENSTEP** — a log carrying an
+unclosed `step/start` (crash leftover) makes any later step activity,
+including a rewind's ghost-step frame, break token-meter replay (and
+/compact). Harness `0.1.1-rc.2` fixes the crash path (`interruptedTurnClosers`
+closes leftover step/turn boundaries on load). A plugin-side guard was tried
+and reverted: it produced false positives on real session logs (rewind
+feature broken), so the plugin deliberately ships no guard — the residual
+risk (runtime-produced unclosed steps) is accepted.
+
 `prepare` runs the full build, so git installs and `npm pack` / `npm publish` always produce a complete `lib/` and the `LICENSE`.
 
 Maintainers: the module map and harness interface reference live in [docs/harness-reference.md](docs/harness-reference.md); publishing steps in [docs/release.md](docs/release.md).

package/README.zh.md

@@ -66,6 +66,7 @@ dsh plugin --profile web add dsh-rewind-plugin
 - 标记携带 `sourceEventSeqs` 覆盖所有被遮蔽节点，`Session.append` 的 surface 规则校验切割合法性（仅限当前 surface 上的连续区间）。
 - 因为标记**内容为空**，harness 会将其派生为 `null`——永不进入模型上下文、也永不渲染成对话内容。agent 与用户看到的对话都回到目标消息当时的样子。
 - 标记的 **turn 号复用最后一个已开始的回合**（`markerTurnOf`），而不是「最后回合 + 1」：harness 恰好用 `最后 turn/start + 1` 编号下一条真实回合。若标记也取这个数，日志里就会出现同一 turn 的 `assistant/message` 先于 `turn/start` 的乱序，客户端 conversation 构建器会以 `conversation Context …:turn-tail… received an update before its start Match` 拒绝重放——历史加载失败、整个对话从界面消失。复用已消费的 turn 号则标记只是上一个已完成回合尾部的一次无害追加，永不与新回合冲突。
+- 标记自带**幽灵步骤框架**——自己的 `step/start` … `step/end`，step 号取该回合未用过的新号（`markerStepOf`）：harness 的 token-meter 重放要求每条 `assistant/message` 位于打开的 step 内，裸标记则会让该会话的 `/compact` 失效。
 - append-only 日志**不被改写**——审计轨迹完整保留每条被撤回的事件，只有模型可见的 surface 被剪掉，下一条请求从目标消息起派生上下文。
 
 若 agent 正在运行（LLM 思考/流式输出），会先强制停止（`cancel({ kind: 'user' })`）并等待 quiescence 再回退；停不下来则中止并报错。
@@ -98,7 +99,7 @@ dsh plugin --profile web add dsh-rewind-plugin
 | 跟踪范围 | 仅写类工具编辑（同 Claude Code） | 任意 Git 管理文件（要求 Git worktree） |
 | 公共服务 API | 无——聚焦单用途插件 | 有——`ctx.changeLedger` 服务 + `/turn-rewind` HTTP 端点 |
 
-本质区别：dsh-turn-rewind 因保持日志不可变而必须派生新会话；本插件用空标记**就地剪掉**模型可见 surface，于是原对话在同一个窗口继续——这段并不平凡的实现（见[已知问题](#已知问题)）正是 dsh-turn-rewind 绕开的部分。
+本质区别：dsh-turn-rewind 因保持日志不可变而必须派生新会话；本插件用空标记**就地剪掉**模型可见 surface，于是原对话在同一个窗口继续——这段并不平凡的实现正是 dsh-turn-rewind 绕开的部分。
 
 ## 兼容性
 
@@ -109,11 +110,19 @@ dsh plugin --profile web add dsh-rewind-plugin
 > 本项目与 DeepSeek Harness 均处于开发者预览阶段。可复现环境请 pin 精确版本，
 > 并阅读上述行为说明。
 
+## 客户端契约
+
+需要获知哪些转录行被回退撤回的第三方 DOM 插件，应使用
+`dsh-rewind-plugin/client` 导出的稳定、与本地化无关的纯函数
+（`hiddenSeqsOf`、`targetSeqOfArgs`），切勿解析 `outcome.text`。
+`data-dsh-rewind-hidden` 属性标记被撤回的行（仅观测性）。
+详见：[docs/client-contract.zh.md](docs/client-contract.zh.md)。
+
 ## 已知问题
 
-`v0.2.4` 及之前版本创建的回退在随后继续对话时可能损坏客户端重放（标记 turn 与下一个 `turn/start` 撞号）。离线修复工具**已随 npm 包内置**（`dsh-rewind-repair`）。只影响升级前就已存在的旧会话——全新安装永不触发。
+`v0.2.4` 及之前版本创建的回退在随后继续对话时可能损坏客户端重放（标记 turn 与下一个 `turn/start` 撞号）。只影响升级前就已存在的旧会话。离线修复工具（`dsh-rewind-repair`）在 v0.4.0 之前随包提供，此后不再提供——需要修复的用户可安装 v0.4.0 之前的版本（[完整步骤](docs/troubleshooting.zh.md)）。
 
-完整步骤见：[docs/troubleshooting.zh.md](docs/troubleshooting.zh.md)
+`v0.3.3` 及之前版本的回退以裸标记追加（无步骤框架），token-meter 重放会拒绝该日志，`/compact` 对该会话失效。新版本均已兼容；已受影响的旧会话暂不提供在线修复——请新建会话。
 
 ## 安全
 
@@ -125,7 +134,7 @@ dsh plugin --profile web add dsh-rewind-plugin
 
 ```sh
 npm install            # devDeps 来自 npm registry
-npm run typecheck      # tsc 双面编译（host + client）
+npm run typecheck      # tsc 三面编译（host + client + client-test）
 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   # 端到端验证构建产物

package/docs/client-contract.md

@@ -0,0 +1,56 @@
+# Client contract — rewind visibility
+
+How third-party DOM plugins learn **which transcript rows a rewind withdrew**.
+This is the only sanctioned answer to that question; anything not listed here
+is internal and may change without notice.
+
+## Stability tiers
+
+| Channel | Stability | Consumers |
+| --- | --- | --- |
+| `/rewind` command `args` `@<seq>` | ✅ stable, semver-protected | machine |
+| `outcome.sourceEventSeq` (marker log seq) | ✅ stable, semver-protected | machine |
+| `data-dsh-rewind-hidden` attribute | ✅ stable name; observational only | DOM plugins |
+| `outcome.text` | ❌ **not** stable — human copy, never parse | — |
+
+## The sanctioned machine channel
+
+`dsh-rewind-plugin/client` exports the pure, locale-independent computation
+the plugin itself uses (it never reads the DOM or host copy):
+
+```ts
+import { hiddenSeqsOf, type HiddenChat } from 'dsh-rewind-plugin/client'
+
+const chat = session.getSnapshot().chat
+const hidden = hiddenSeqsOf(chat as HiddenChat) // Set<number> of anchor seqs
+```
+
+`hiddenSeqsOf` hides every internal probe row (`preview` / `__candidates`),
+every successful executed `/rewind` row, and every message inside its
+`[target, marker]` span (each rewind cuts one span; spans stay separate).
+`targetSeqOfArgs` is exported for consumers that only need the target from a
+command's `args`. Reuse these instead of re-deriving the logic (cf.
+dsh-chat-timeline#6).
+
+## DOM attribute
+
+Each withdrawn row carries `data-dsh-rewind-hidden="true"` while hidden,
+removed on un-hide. Contract:
+
+- The **attribute name** is stable; treat the value as opaque.
+- It is **observational only** — rewind hides via `style.display`; the
+  attribute records the cause, not the mechanism. Do not write it, and do
+  not expect it on rows outside rewind's control (third-party own elements).
+
+## Explicit non-contract
+
+`outcome.text` is human-facing copy. Its wording changes freely with
+localization; parsing it is a bug. The `impact=<n>` trailer on preview text
+is machine-readable and stable but outside this contract's scope.
+
+## Maintenance rules
+
+- Any change to the meaning of `@<seq>` / `sourceEventSeq` /
+  `data-dsh-rewind-hidden` updates this document in the same PR.
+- Breaking a listed stability tier is a minor/major version bump.
+- `scripts/build.mjs` asserts the export surface on every build.

package/docs/client-contract.zh.md

@@ -0,0 +1,54 @@
+# 客户端契约 — 回退可见性
+
+第三方 DOM 插件如何获知**哪些转录行被回退撤回**。这是该问题的唯一权威
+答案；未在此列出的内容均属内部实现，可随时变更，恕不另行通知。
+
+## 稳定性分级
+
+| 通道 | 稳定性 | 适用方 |
+| --- | --- | --- |
+| `/rewind` 命令 `args` 中的 `@<seq>` | ✅ 稳定，受 semver 保护 | 机器 |
+| `outcome.sourceEventSeq`（marker 日志 seq） | ✅ 稳定，受 semver 保护 | 机器 |
+| `data-dsh-rewind-hidden` 属性 | ✅ 属性名稳定；仅观测性 | DOM 插件 |
+| `outcome.text` | ❌ **不**稳定 — 人类可读文案，禁止解析 | — |
+
+## 唯一机器通道
+
+`dsh-rewind-plugin/client` 导出插件自身所用的纯函数计算，与本地化无关
+（不读取 DOM，也不解析 host 文案）：
+
+```ts
+import { hiddenSeqsOf, type HiddenChat } from 'dsh-rewind-plugin/client'
+
+const chat = session.getSnapshot().chat
+const hidden = hiddenSeqsOf(chat as HiddenChat) // 被隐藏的 anchor seq 集合
+```
+
+`hiddenSeqsOf` 隐藏所有内部探针行（`preview` / `__candidates`）、所有成功
+执行的 `/rewind` 行，以及每条回退 `[target, marker]` 区间内的消息（每次
+回退切一条区间，区间互不合并）。只需从命令 `args` 取 target 时，可用同样
+导出的 `targetSeqOfArgs`。请复用这些实现，勿自行重写（参见
+dsh-chat-timeline#6）。
+
+## DOM 属性
+
+每条被撤回的行在隐藏期间带有 `data-dsh-rewind-hidden="true"`，取消隐藏时
+移除。契约如下：
+
+- **属性名**稳定；值视为不透明。
+- 仅**观测性**标记 — rewind 通过 `style.display` 隐藏，该属性记录的是
+  原因而非机制。不要写它；也不要在 rewind 控制范围之外（第三方自建元素）
+  期望它存在。
+
+## 明确非契约
+
+`outcome.text` 是面向人类用户的文案，措辞随本地化自由变更，解析它即视为
+bug。preview 文案中的 `impact=<n>` 尾注是机器可读且稳定的，但不属于本
+契约范围。
+
+## 维护规则
+
+- 任何改变 `@<seq>` / `sourceEventSeq` / `data-dsh-rewind-hidden` 语义的
+  改动，必须在同一 PR 中更新本文档。
+- 破坏已承诺的稳定性分级属于 minor/major 版本变更。
+- `scripts/build.mjs` 在每次构建时断言导出面。

package/docs/compat-audit.md

@@ -0,0 +1,137 @@
+# 兼容性排查记录（compat-audit）
+
+> 排查方式：**测试即排查**。`tests/compat-invariants.test.ts`、`tests/compat-interop.test.ts`
+> 与 `scripts/verify-host.mjs` 中的探针，把插件的真实执行路径插入 DSH 各子系统的
+> **真实消费路径**（真实 `@deepseek-ai/*` 包），断言兼容性不变量。探针失败即发现，
+> 进入「修复 / 钉住 / 记录」闭环。
+>
+> 针对版本：npm `@deepseek-ai/*@0.1.1-rc.2`（与 `package-lock.json` 一致）；
+> 源码参考：`oss/deepseek-harness` 本地 fork。
+>
+> 版本适配说明：peerDependencies 采用 OR 并集（如 `^0.1.0-rc.6 || ^0.1.1-rc.2`），
+> 覆盖 DSH 已发布的 rc 元组系列。npm 的 prerelease 匹配规则要求候选与范围内比较器
+> **同 `[major, minor, patch]` 元组**，因此 DSH 每次发布新元组（如未来的 `0.1.2-rc.x`、
+> `0.2.x`）时需追加并集项；同元组内 rc 滚动（如 `0.1.1-rc.2 → rc.3`）无需动作。
+> 判断信号：`npm view @deepseek-ai/dsh version`；流程见 `scripts/check-dsh-version.mjs`。
+
+## 「完全适配」的可执行定义（不变量）
+
+| 不变量 | 含义 | 探针位置 |
+|---|---|---|
+| I1 日志可重放 | rewind 后日志过 token-meter 重放、`Session.create`（resume preflight 同款校验）均不抛 | `compat-invariants` I1、`verify-host` 12/13 |
+| I2 surface 一致 | 切割后 surface 无重复节点、节点存在于日志、被撤目标不再回到 surface、`deriveMessages()` 合法 | `compat-invariants` I2 |
+| I3 step/turn 结构合法 | 客户端 turn-tail 顺序、step/start 唯一、step/end 与 assistant/message 均有配对 step/start、无幽灵 turn | `compat-invariants` I3、`helpers.assertTurnTailOrdering` |
+| I4 折叠服务安全 | stats / title / goal / projection 对含 marker 日志折叠不抛且值可预测 | `compat-invariants` I4 |
+| I5 compact 互操作 | 取消 turn 遗留的 tool-call 被 rewind 遮蔽后配对恢复平衡；跨 checkpoint 的 rewind 明确拒绝；rewind 后 compact 事务合法 | `compat-interop` I5、`verify-host` 12/14 |
+| I6 工具管线正确 | before-快照捕获/提交/恢复正确（既有 `snapshot.test.ts` + `verify-host` 4-8）；取消时序不悬挂 | `verify-host` 4-8、15 |
+| I7 客户端顺序合法 | 含工具 turn、rewind marker、幽灵 step 的日志满足客户端 builder 顺序 | `compat-interop` I7 |
+| I8 运行时安全 | rewind/compact 组合不留下悬空 step/turn 帧 | `verify-host` 15 |
+
+## 发现的兼容性问题
+
+### R-OPENSTEP：日志存在未闭合 step 时，rewind 会破坏 token-meter 重放（**harness 侧问题；插件守卫已尝试并回退**）
+
+> **根因（harness 侧）**：崩溃遗留的未闭合 step 会让 token-meter 重放拒绝任何后续
+> step 活动。DSH `0.1.1-rc.2` 已在加载时用 `interruptedTurnClosers`
+> （`dsh-session/repair`）自动闭合崩溃遗留的 step/turn/tool 边界——**崩溃路径已根治**。
+>
+> **插件守卫（已尝试并回退）**：曾实现 `hasOpenStep` + `planRewind` 前置拒绝
+> （`open-step`），但在**真实会话日志上产生误判**（正常回退被拒、GUI 验证功能缺失），
+> 已 revert（`177ec14`）。结论：**插件不设守卫**，接受残余风险（运行中第三方插件
+> 产生未闭合 step 时，rewind 可能破坏 /compact——该日志本身已异常，继续对话同样触发）。
+> 根治方向在 harness（token-meter 对未闭合 step 的恢复），不在插件。
+
+#### 未闭合 `step/start` 的具体触发情况（源码确认）
+
+全仓**只有一处** append `step/start`：`packages/core/agent-loop/src/agent.ts:279`（官方包内
+无其他生产者；`session/end-seed` 等修复只做 torn-write 截断，不处理逻辑未闭合）。
+
+| # | 触发路径 | 现实性 | 依据 |
+|---|---|---|---|
+| P1 | **进程非优雅终止**：`step/start` 经 write-behind 批量落盘（`session-persistence/src/write-behind.ts`，`maxDelayMs` 后写一批）→ step 执行中（LLM 流式/工具，秒级到分钟级）→ SIGKILL / OOM-kill / 断电 / WSL 强关 → `step/end`（在 `finally`，进程活着才执行）未落盘 | **最现实** | `agent.ts:292` finally；write-behind 批量；torn-write 修复只截断写一半的行 |
+| P2 | **第三方插件 bug**：官方包只有 agent-loop 一个生产者，但外部插件可任意 `session.append('step/start', …)` 不闭合 | 可能 | 公开 `Session.append` |
+| P3 | **手工编辑会话文件**：改 `~/.dsh/…/session.jsonl[.zstd]`（zstd 需解压/重压；plaintext 配置可直接改） | 可能但费事 | `persistence-jsonl/format.ts`（`JsonlCompression = 'zstd' \| 'none'`） |
+| P4 | **append 自身故障**：`finally` 里 `append('step/end')` 抛错（payload 是纯数字，几乎不可能） | 理论 | `agent.ts:292` |
+
+**放大机制（rewind 不是唯一触发者）**：崩溃后 resume，agent-loop `turn()` 直接
+`phase.turn + 1` 开新 turn（`agent.ts:251-255`），**不闭合遗留 step**——所以「继续对话」
+（新 `step/start`）同样踩中 token-meter 校验。影响范围精确界定：
+
+- **对话本身不受影响**（请求路径不调用 `tokenMeter.measure`，全仓仅 compaction-basic 调用）；
+- **手动 `/compact` 永久报错**（`compactNow` 首步 `measure()` 抛原始错误）；
+- **自动压缩永久静默失效**（`agent/pre-step` 钩子 catch 后仅 warn，对话继续）；
+- **rewind 的角色**：若用户先 rewind（而非继续对话），幽灵 step/start 成为第一个踩中者，
+  且插件无防御性检测——把「局部异常日志」升级为「用户可感知的 /compact 失效」。
+
+### G3（已确认：合理行为，非缺陷）：rewind 让 token-meter 的 usage 锚点短暂失效
+
+- **机制**：rewind 的 marker 是日志最后一条 `assistant/message` 且无 `usage`，token-meter
+  的 `_sync` 重放以它收尾，把 `MeasurementAnchor.baseline` 从 provider 实测 `usage` 覆盖为
+  启发式 `estimated`——直到下一条带 usage 的真实消息才恢复（探针验证了完整链条：
+  `usage → rewind → estimated → 真实 turn → usage`）。
+- **定性（已确认）**：marker 语义上就是空消息，不携带 usage 是正确的；锚点短暂退回估算
+  是该语义的自然结果，且短暂、自愈、不破坏功能。**属于预期行为，不修复**。
+- **探针**：`tests/compat-gaps.test.ts` → `G3`（钉住该行为，防止未来 harness 变更改变它）。
+
+## 已验证兼容的面（探针通过）
+
+- **token-meter 重放**（含 marker + 幽灵 step 帧 + 多次 rewind + 交错真实 turn + compact 叠加）。
+- **compaction 事务**：`toolPairingBalancedBefore/After` 对 marker 切割后的 surface 恒平衡；
+  真实 `/compact` 命令（`command-compact` + `compaction-basic`，stub summarizer）可在 rewind
+  marker 之上落地 `compaction/start…end` 并保持可重放；小 surface 时 `/compact` 合法 no-op。
+- **resume 重放**：`Session.create(id, events)` 对含 rewind/compact 的日志重放通过。
+- **session-stats**：ghost step 帧只 +1 step、不新增 phantom turn（复用 turn 号）。
+- **session-title / goal fold**：marker 不干扰 `foldSessionTitle` / `foldGoal`。
+- **客户端顺序**：turn-tail ordering + step/start 唯一性对工具 turn + marker 日志成立。
+- **跨 compact checkpoint 的 rewind**：`RewindError('not-on-surface')` 明确拒绝，不崩溃。
+- **plan-mode**：`hasOpenTurn` 只配对 `turn/start`/`turn/end`，marker 不产生 `turn/start`，
+  激活 plan 期间 rewind 无影响（静态审查确认）。
+- **agent-loop 取消**：`finally` 保证 step/turn 闭合，rewind 的 force-stop 路径不悬挂帧。
+
+## 已知边界（行为差异，非崩溃，文档化）
+
+- **session-stats / session-telemetry 折叠完整日志**：rewind 后统计**不回退**——`turns` /
+  `steps` / `llmMs` 仍含被撤内容；telemetry 逐条上报 marker 与幽灵 step 帧（归入被复用
+  的旧 turn）。这是「折叠完整日志」的预期语义，探针钉住该行为。
+- **token-meter usage 锚点短暂失效**（G3）：rewind 后 baseline 退回启发式 `estimated`，
+  下一条真实 usage 调用恢复（探针钉住）。
+- **被撤内容仍可搜索、可导出**：session-query 全文搜索与 `/export` 基于原始日志，
+  rewind 只切 surface，被撤消息仍在其中（README 已声明）。
+- **session-title 自动重生成**：标题由 surface 派生，rewind 后自动标题可能变化。
+- **取消 turn 中已写盘但未提交快照的文件**：rewind both 无法恢复（工具副作用时序，
+  Claude Code 同限制）。
+- **附件消息被遮蔽后文件残留**：attachment 存储不随 surface 清理（`dsh-attachment-local`
+  未装，未自动化验证）。
+
+## 未覆盖边界（需要额外端到端层，不阻塞）
+
+- 真实 LLM 流式与自动标题生成（L2 stub 化）。
+- 真实 SQLite 索引生命周期（`dsh-session-query-sqlite` 未安装、含原生依赖）。
+- 浏览器端实际渲染 replay（客户端契约已由 `client-contract.test.ts` 覆盖逻辑层）。
+- 真实 JSONL 持久化往返（`dsh-session-persistence-jsonl` 依赖 native `koffi`；往返验证的是
+  harness 自身 zstd/JSON 编解码，插件不参与，价值/成本不划算，未安装）。
+- session-reference 的 `SessionReferenceResolver.prepare` 需完整 session-query 服务；其数据
+  基础（current-surface 投影）已由 G1 探针（`foldSurface` 转换）覆盖。
+- telemetry 管道（`dsh-session-telemetry-otel`）与附件 provider（`dsh-attachment-local`）。
+- 运行中的 workflow/jobs 被 rewind 取消：工具契约要求 observe `exec.signal` 并 settle
+  （`packages/core/tools/src/index.ts`），rewind 触发的是 harness 标准取消，非插件特有——
+  静态确认，未实测真实 workflow。
+
+## 排查矩阵（子系统 × 不变量）
+
+| DSH 子系统 | I1 | I2 | I3 | I4 | I5 | I6 | I7 | I8 |
+|---|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+| 会话内核（append/surface/deriveMessages） | ✓ | ✓ | ✓ | — | ✓ | — | ✓ | ✓ |
+| token-meter | ✓ | — | ✓ | — | ✓ | — | — | — |
+| compaction（事务/命令/tool-pairing） | ✓ | — | — | — | ✓ | — | — | ✓ |
+| session-stats / projection | — | — | ✓ | ✓ | — | — | — | — |
+| session-title | — | — | — | ✓ | — | — | — | — |
+| goal | — | — | — | ✓ | — | — | — | — |
+| resume / session-query 重放 | ✓ | — | ✓ | — | — | — | ✓ | — |
+| 工具管线（快照/恢复） | — | — | — | — | — | ✓ | — | ✓ |
+| 客户端顺序 | — | — | ✓ | — | — | — | ✓ | — |
+| plan-mode | — | — | — | — | — | — | — | ✓（静态） |
+
+✓ = 探针通过；— = 不适用。R-OPENSTEP 见上（harness 已修、插件不设守卫）。G3 见「已知边界」。
+缺口探针 `tests/compat-gaps.test.ts`：G1 surface 分类（`foldSurface` current/shadowed/log-only）
+与 G2 projection checkpoint 均验证通过；G3 钉住 token-meter baseline 行为差异。

package/docs/harness-reference.md

@@ -12,6 +12,16 @@
 - [commands.md](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/commands.md) — command registration (`ctx.commands.register`, `CommandInvocation`, `CommandResult`)
 - [tools.md](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/tools.md) — tool execution seam (`tools/pre-execute` / `tools/post-execute`, `ToolExecution`)
 - [session-query.md](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/session-query.md) — session query / `foldSurface` read-only interfaces
+- [token-meter.md](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/token-meter.md) — replay-aware token meter (`TokenMeter.measure`, surface pricing)
+- [compaction.md](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/compaction.md) — compaction seam / `compaction/*` events / `BasicCompactionEngine` (`summarize()` hook)
+- [session-projection.md](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/session-projection.md) — projection registry (`SessionProjectionRegistry.snapshot/checkpoint`)
+- [session-stats](https://github.com/deepseek-ai/deepseek-harness/blob/main/packages/session/session-stats) — whole-log stats projection (folds ALL events; rewind does not roll back counts)
+- [session-title.md](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/session-title.md) — durable title state (`foldSessionTitle`)
+- [goal.md](https://github.com/deepseek-ai/deepseek-harness/blob/main/docs/subsystems/goal.md) — goal fold (`foldGoal`) and round admission
+
+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).
 
 Also under `docs/` at the repo root: `persistence-catalog.md` (full
 `SessionEventMap`), `tool-catalog.md` (tool inventory), `config-catalog.md`
@@ -47,7 +57,6 @@ 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/repair-markers.mjs  offline marker-turn repair tool (ships as `dsh-rewind-repair`)
 tests/                  vitest suites (rewind / snapshot / hidden / session-cwd / integration)
 docs/                   maintainer docs: harness reference, troubleshooting, release steps
 assets/screenshots/     UI screenshots

package/docs/release.md

@@ -88,3 +88,21 @@ git push origin main --tags   # 触发 .github/workflows/publish.yml
   **幂等**——已发布的版本会跳过。
 - CI（`.github/workflows/ci.yml`）在每次 push / PR 跑相同检查，外加
   `npm pack --dry-run` 校验 tarball 含 `lib/` 与 `LICENSE`。
+
+## DSH 版本适配（peer 范围维护）
+
+DSH 仍在 rc 阶段，npm 的 prerelease 匹配规则要求 peer 范围与宿主版本
+**同 `[major, minor, patch]` 元组**才能匹配。因此 peerDependencies 采用
+OR 并集覆盖 DSH 已发布的每个 rc 元组系列（如 `^0.1.0-rc.6 || ^0.1.1-rc.2`），
+并随 DSH 发版追加。
+
+- **何时需要更新**：仅当 DSH 发布新元组（`0.1.1 → 0.1.2 → 0.2.x`）时；
+  同元组内 rc 滚动（`0.1.1-rc.2 → rc.3`）无需动作。DSH 所有包同版本发布，
+  `npm view @deepseek-ai/dsh version` 即权威信号。
+- **自动检测**：`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` → 发版。
+- **正式版后收敛**：DSH 发布 final 版本后，正式版不受 prerelease 元组规则
+  限制，peer 可收敛为稳定的 `^0.1.x` 单范围，此节即可删除。

package/docs/troubleshooting.md

@@ -4,36 +4,41 @@
 
 ## History load failure: `…turn-tail… received an update before its start Match`
 
-Versions `≤ 0.2.4` corrupted client replay when a rewind was **followed by further
-conversation**: the marker's turn number collided with the next real turn's
-`turn/start`, so reopening the session showed
+Rewinds from `≤ 0.2.4` collided with the next real turn's `turn/start`, so reopening the session showed
 
 ```
 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).
-
-The repair tool ships **inside the npm package** (`dsh-rewind-repair`) — no
-source checkout needed:
+and the history vanished. Rewinds from `0.2.5` on no longer collide; already-corrupted sessions need an offline repair (the log is append-only). The repair tool (`dsh-rewind-repair`) is no longer shipped from v0.4.0 — install a pre-v0.4.0 release to get it (fully quit dsh web / host first, then):
 
 ```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 (scans every session under ~/.dsh/sessions,
-#    rewriting each marker's turn back to the last started turn)
-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
+npm exec --yes --package=dsh-rewind-plugin@0.3.3 -- dsh-rewind-repair
+npm exec --yes --package=dsh-rewind-plugin@0.3.3 -- dsh-rewind-repair -- --dry-run  # preview only
 ```
 
-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.
+It only rewrites the marker events' `data.turn` (seqs, order, and zstd frame structure intact) and backs up the original file before writing — safe to run repeatedly. From a source checkout of a pre-v0.4.0 tag: `node scripts/repair-markers.mjs` (identical flags).
+
+## Known compatibility boundaries
+
+Behavioral notes verified by the compatibility probe suites
+([compat-audit.md](compat-audit.md)) — none of these is a crash:
+
+- **Session stats / telemetry do not roll back**: whole-log folds count the
+  withdrawn turns, and telemetry records the rewind's marker and ghost-step
+  frame under the reused turn. Expected whole-log semantics.
+- **Withdrawn messages stay searchable and exported**: rewind cuts only the
+  model-visible surface; full-text search and `/export` still see the raw log.
+- **Session titles may regenerate** after a rewind (title derives from the
+  current surface).
+- **Files written by a cancelled tool call** (write happened, no result, no
+  snapshot commit) cannot be restored by "conversation and code".
+
+**R-OPENSTEP** (harness-side, plugin does not guard): a session log carrying
+an *unclosed* `step/start` (a crash before the agent loop's `finally` closed
+the step) makes any later step activity break token-meter replay (and
+`/compact`). Harness `0.1.1-rc.2` fixes the crash path on load
+(`interruptedTurnClosers` closes leftover step/turn boundaries). A plugin-side
+up-front rejection was implemented and **reverted** (false positives broke the
+rewind feature on real session logs, `177ec14`); the residual runtime-produced
+risk is accepted. Tracked in the compat-audit.

package/docs/troubleshooting.zh.md

@@ -4,28 +4,11 @@
 
 ## 历史加载失败：`…turn-tail… received an update before its start Match`
 
-0.2.4 及之前版本在回退**之后继续对话**的场景下会损坏会话的客户端重放：标记的 turn 号
-与下一条真实回合的 `turn/start` 编号冲突，重新打开会话时界面报
-
-```
-历史加载失败：conversation Context …:turn-tail… received an update before its start Match（internal）
-```
-
-历史整段消失。0.2.5 起新的回退不再产生该冲突；但**已损坏的会话需要离线修复**（日志是
-append-only 的，不能在内存中改写）。
-
-修复工具**已随 npm 包发布**（`dsh-rewind-repair`）——无需下载源码：
+0.2.4 及之前版本的回退与下一条真实回合的 `turn/start` 撞号，重开会话时历史整段消失。0.2.5 起的新回退不再产生该冲突；**已损坏的旧会话需离线修复**（日志是 append-only 的）。修复工具（`dsh-rewind-repair`）v0.4.0 起不再随包提供——安装 v0.4.0 之前的版本即可获取（先完全退出 dsh web / host，然后）：
 
 ```sh
-# 1. 先完全退出 dsh web / host（会话处于驻留内存时，磁盘修复会被下次 checkpoint 覆盖）
-# 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，损坏的会话即可正常加载历史
+npm exec --yes --package=dsh-rewind-plugin@0.3.3 -- dsh-rewind-repair
+npm exec --yes --package=dsh-rewind-plugin@0.3.3 -- dsh-rewind-repair -- --dry-run  # 只预览不写盘
 ```
 
-也可以全局安装一次（`npm i -g dsh-rewind-plugin`）后直接运行 `dsh-rewind-repair`；
-源码方式为 `node scripts/repair-markers.mjs`（参数相同）。
-
-工具只改写 `dsh-rewind` 空标记事件的 `data.turn` 字段（保持 seq / 顺序 / zstd 帧结构不变），
-改前自动备份原文件为 `session.jsonl.zstd.bak-<时间戳>`；不改动任何其它事件，可安全重复运行。
+工具只改写标记事件的 `data.turn`（保持 seq / 顺序 / zstd 帧结构不变），改前自动备份原文件——可安全重复运行。源码方式：v0.4.0 之前的 tag 下 `node scripts/repair-markers.mjs`（参数相同）。

package/lib/client.js

@@ -27,8 +27,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   apply: () => apply,
+  hiddenSeqsOf: () => hiddenSeqsOf,
   inject: () => inject,
-  name: () => name
+  name: () => name,
+  targetSeqOfArgs: () => targetSeqOfArgs
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -575,6 +577,8 @@ function openPopover(opts) {
     ];
     if (bothState.state === "noChanges") {
       children.push(el("div", CLASS.popoverImpact, t("popover.noChanges")));
+    } else if (bothState.state === "error") {
+      children.push(el("div", CLASS.popoverImpact, t("popover.impact.failed", { message: bothState.message })));
     } else {
       const option = modeOption(
         t("popover.both"),
@@ -628,6 +632,8 @@ function openPopover(opts) {
     impactOutcome = outcome;
     if (outcome !== null && outcome.kind === "success") {
       bothState = { state: hasFileImpact(outcome.text) ? "hasChanges" : "noChanges" };
+    } else if (outcome !== null && outcome.kind === "error") {
+      bothState = { state: "error", message: outcome.text ?? "unknown error" };
     }
     renderModes();
     shell.position();
@@ -695,12 +701,31 @@ async function runRewindAndFill(session, seq, mode, currentSessionId) {
   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 (outcome === null) return;
+  if (outcome.kind !== "success") {
+    showHint(outcome.text ?? "rewind failed");
+    return;
+  }
   if (currentSessionId() !== session.sessionId) return;
   const text = userTextAt(session, seq);
   if (text === void 0 || text === "") return;
   fillComposer(text);
 }
+function showHint(text) {
+  const textarea = document.querySelector(COMPOSER_SELECTOR);
+  const hint = document.createElement("div");
+  hint.className = CLASS.guardHint;
+  hint.setAttribute("role", "status");
+  hint.textContent = text;
+  document.body.appendChild(hint);
+  if (textarea !== null) {
+    const card = textarea.closest("[data-composer-card]");
+    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`;
+  }
+  window.setTimeout(() => hint.remove(), 3200);
+}
 var COMPOSER_SELECTOR = "[data-input-scroll] textarea, textarea[data-phase]";
 var USER_SEAT_SELECTOR = '[data-chat-flow-kind="user"][data-chat-anchor-key], [data-chat-flow-kind="steering"][data-chat-anchor-key]';
 var CHAT_SEAT_SELECTOR = "[data-chat-anchor-key]";

package/lib/index.js

@@ -90,6 +90,15 @@ function markerTurnOf(events) {
   }
   return lastStarted;
 }
+function markerStepOf(events, turn) {
+  let lastStarted = 0;
+  for (const event of events) {
+    if (event.type === "step/start" && event.data.turn === turn && event.data.step > lastStarted) {
+      lastStarted = event.data.step;
+    }
+  }
+  return lastStarted + 1;
+}
 function isUserMessageEvent(event) {
   return event.type === "user/message";
 }
@@ -686,10 +695,19 @@ async function executeRewind(ctx, store, fs, invocation, rawTarget, mode, inflig
     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]
-      });
+      const turn = markerTurnOf(agent.session.events);
+      const step = markerStepOf(agent.session.events, turn);
+      agent.session.append("step/start", { turn, step });
+      try {
+        event = agent.session.append("assistant/message", { turn, step, message: marker }, {
+          surfaceOp: { op: "replace", start: plan.surfaceStart, end: plan.surfaceEnd },
+          sourceEventSeqs: [...plan.shadowedSeqs]
+        });
+      } catch (error) {
+        agent.session.append("step/end", { turn, step });
+        throw error;
+      }
+      agent.session.append("step/end", { turn, step });
     } catch (error) {
       return {
         kind: "error",

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

@@ -35,3 +35,8 @@ export declare const inject: string[];
  * @param ctx - client root context carrying `slots`, `sessions`, `locale` and `commandUi`.
  */
 export declare function apply(ctx: ClientContext): void;
+/**
+ * Public contract — rewind visibility. Stable, semver-protected; the rest of
+ * this module is internal. See `docs/client-contract.md`.
+ */
+export { hiddenSeqsOf, targetSeqOfArgs, type HiddenChat } from './hidden.ts';

package/lib/types/rewind.d.ts

@@ -9,6 +9,24 @@
  * transcript) is untouched; only the model-visible surface is cut, so the
  * next request derives its context from the target message onward.
  *
+ * Marker shape (v0.3.4+): the marker is an EMPTY `assistant/message` with a
+ * replace `surfaceOp`, wrapped in its own step frame —
+ *
+ *   step/start (turn, step) → assistant/message (marker) → step/end (turn, step)
+ *
+ * The step frame exists because the harness token-meter replays the log and
+ * requires every `assistant/message` to sit inside an OPEN step whose
+ * `(turn, step)` matches exactly (`token meter: assistant/message at seq N
+ * has no matching step/start event` otherwise) — a bare marker appended while
+ * idle (every step already closed) makes every later measure() call throw,
+ * which disables /compact and automatic compaction. The frame's `turn` is the
+ * LAST STARTED turn (`markerTurnOf`) and `step` is that turn's next unused
+ * step number (`markerStepOf`): never a reused one, or the client
+ * conversation assembler sees a duplicate `step/start` and rejects the log
+ * with "received more than one start Match". The agent loop numbers its own
+ * steps from memory (each new turn restarts at 1), so the ghost step can
+ * never collide with a future real step.
+ *
  * @module dsh-rewind/rewind
  */
 import type { SessionEvent, UserMessage } from '@deepseek-ai/dsh-session';
@@ -89,6 +107,25 @@ export declare const DEFAULT_CANDIDATE_LIMIT = 50;
  * @returns a turn number the harness can never reuse for a future `turn/start`.
  */
 export declare function markerTurnOf(events: readonly SessionEvent[]): number;
+/**
+ * Step number for the rewind marker's ghost step frame.
+ *
+ * The marker's `assistant/message` must be wrapped in `step/start` …
+ * `step/end` of the SAME `(turn, step)` so the harness token-meter replay
+ * accepts it (see the module doc). The step number MUST be a step this turn
+ * has never started: the client conversation assembler treats `step/start`
+ * as the start of an `assistant-step` context keyed `turn:step`, so reusing
+ * an already-started step number makes the log replay throw "received more
+ * than one start Match" and the history disappears from the UI. Reusing
+ * `lastStep + 1` is always safe: the harness numbers a turn's steps from
+ * memory (each new turn restarts at 1), so the ghost step can never collide
+ * with a future real step of this turn.
+ *
+ * @param events - the full session event log.
+ * @param turn - the marker's turn (normally `markerTurnOf(events)`).
+ * @returns the smallest step number this turn has never started (≥ 1).
+ */
+export declare function markerStepOf(events: readonly SessionEvent[], turn: number): number;
 /** Narrow an event to a user message. */
 export declare function isUserMessageEvent(event: SessionEvent): event is SessionEvent<'user/message'>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rewind-plugin",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "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,9 +23,6 @@
   "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",
@@ -44,8 +41,7 @@
     "README.zh.md",
     "docs",
     "assets",
-    "LICENSE",
-    "scripts/repair-markers.mjs"
+    "LICENSE"
   ],
   "dsh": {
     "bundle": {
@@ -63,7 +59,7 @@
   },
   "scripts": {
     "build": "node scripts/build.mjs",
-    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.client.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.client.json && tsc --noEmit -p tsconfig.client-test.json",
     "test": "vitest run",
     "verify:host": "node scripts/verify-host.mjs",
     "prepare": "npm run build"
@@ -73,17 +69,17 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-commands": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-commands": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-fs": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-sandbox": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-commands": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-fs": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-sandbox": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.8 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6 || ^0.1.1-rc.2"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
@@ -125,19 +121,27 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-client-ui-commands": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-client-ui-input-trigger": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-commands": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-fs": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-sandbox": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-locale": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-commands": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-input-trigger": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-command-compact": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-compaction": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-compaction-basic": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-fs": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-goal": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-sandbox": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-stats": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-title": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-token-meter": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
     "@types/node": "^24.0.0",
     "@types/react": "^18.3.31",
     "@types/react-dom": "^18.3.7",

package/scripts/repair-markers.mjs

@@ -1,176 +0,0 @@
-#!/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.'}`)