dsh-edit-turn 0.2.11 → 0.2.14

package/README.md

@@ -1,6 +1,6 @@
 # dsh-edit-turn
 
-**DeepSeek Harness 的「编辑某一轮」插件 —— 点用户消息旁的编辑按钮，就地改写那一句。保存即生效：改后的内容成为模型后续读到的版本，这一条消息下面的对话原样不动。** 改写走官方 surface-replace 契约（一条替换事件同时完成"删旧 + 立新"，被替换的内容从模型上下文里消失），**默认不重跑模型**。会话日志是 append-only 的，**原始字节一个都不改写**。
+**DeepSeek Harness 的「编辑某一轮」插件 —— 点用户消息旁的编辑按钮，就地改写那一句。保存即生效：改后的内容成为模型后续读到的版本，这一条消息下面的对话原样不动。** 改写走官方 surface-replace 契约（一条替换事件同时完成"删旧 + 立新"，被替换的内容从模型上下文里消失），**保存本身永不调用模型**。会话日志是 append-only 的，**原始字节一个都不改写**。
 
 [中文](#中文) · [English](#english)
 
@@ -18,14 +18,14 @@ DSH 的会话日志是 append-only 的事件流：说错的提示词、问偏的
 - 点击后在该消息下方就地展开编辑器，预填原文；
 - 保存后：**只有这一条消息被替换**——旧措辞从模型上下文里消失，改后的内容占住它的位置（因此后续每一轮读到的都是改后的版本）；
 - **它下面的助手回复、以及之后的全部对话，原样保留**，不重跑、不清空；
-- 想让它立刻按改后的内容重新回答，把 `rerun` 打开即可。
+- 装了姊妹插件 **dsh-rerun-turn** 时，编辑器里会多一个「**重跑**」：先保存这次修改，再让它用改后的提示词重新生成这一轮（后续轮次逐事件重放回来，不丢）。
 
 ### 特性
 
 - **官方 seam，不改日志** —— 回退 = 追加一条带 `surfaceOp: { op: 'replace', startSeq, endSeq }` 的替换事件。原始事件全部留在会话文件里，只是不再进入 `deriveMessages()`。与官方 `/compact` 用的是同一套契约。
 - **改写内容就是载体本身** —— 提示词编辑落下的是一条 `user/message` 替换事件，内容就是你改后的那句话。它既让模型读到你改后的版本，也在转录里显示成你自己的气泡；平台不会把它当成新输入去回答（这一点踩过坑：**追加**一条 user 消息会触发平台自动回答，越改越多）。
 - **窗口最小化** —— 提示词编辑只遮蔽目标那一格（`shadowed = [target.seq]`）；回复编辑才需要"到末尾"的窗口（回答变了，建立在它之上的一切都不再成立），因此助手消息（内含 tool_use）与它产生的 tool/result 永远一起走，**不可能留下悬空的调用/结果对**。
-- **默认不重跑模型** —— 保存只写上下文，不产生任何模型调用。想"改完立刻重答"，配置 `rerun: true`：那会走官方准入路径 `ctx.sessionController.prompt()`（它会自己 resume 冷会话，并恰好开一个新轮次）。
+- **保存永不调用模型** —— 保存只写上下文，不产生任何模型调用。"改完立刻重答"是另一件事，交给姊妹插件 **dsh-rerun-turn**（它遮蔽该轮、用表面上的提示词重新生成、再把后续轮次逐事件重放回来）；本插件只在它装着时提供一个「重跑」按钮转发过去。
 - **模型回答也能编辑** —— 回答无法被"替换"：官方格式禁止 `assistant/message` 携带 `sourceEventSeqs`（已在真实校验器上验证）。做法是回退该回答及其后的内容，再**追加**一条带改写文本的助手消息——模型会把改写后的内容当成自己说过的话，对话可以继续。`source.editedBy` 会如实记录这段文字由插件写入。
 - **改过的那条还能再改** —— 它仍然显示在原来的位置（由插件渲染成气泡），悬停就有编辑按钮。
 - **一次点击即执行** —— 保存后不再有二次确认（`confirm: true` 可恢复两步确认，确认步里会写明这次保存会丢弃什么）。编辑器本身已经是用户主动打开的动作，保存的后果在 README 与确认步里说明，输入框本身保持干净。
@@ -50,7 +50,7 @@ dsh plugin --profile web add /path/to/dsh-edit-turn
 ### 使用
 
 1. 把鼠标移到你想改的那条**用户消息**上，点右侧的编辑图标（铅笔）。
-2. 消息下方展开编辑器，原文已预填。改完点「**保存**」——**一次点击即执行**：旧措辞从模型上下文里移除，改后的内容占住它的位置，**不叫模型**。（配置 `rerun: true` 时按钮为「保存并重跑」。）
+2. 消息下方展开编辑器，原文已预填。改完点「**保存**」——**一次点击即执行**：旧措辞从模型上下文里移除，改后的内容占住它的位置，**不叫模型**。装了 `dsh-rerun-turn` 时旁边还有一个「**重跑**」：先保存，再让那一轮用改后的内容重新生成（后续轮次不丢）。
 3. 编辑器收起，那条消息就地变成你改后的内容；它下面的回复与之后的对话**原样不动**。
 
 编辑器是**平台输入框那样的一个圆角盒子**：输入区在上、取消与主按钮在右下，聚焦时整圈描边高亮；**随文字长高**（空的时候不留空白），没有标题栏、没有常驻说明、没有拖拽手柄。键盘也和输入框一致：**Enter 保存、Shift+Enter 换行、Esc 取消**（确认步里 Esc 是退回上一步）。**输入法优先**：组合中的 Enter 与"候选选词的 Enter"（`isComposing` 或 `keyCode 229`，平台自己的输入框也是这两条一起挡）都不会被当成保存，组合期间也不重排输入框——此前少挡了 229 那半，拼音选词按回车会直接保存/关闭，看起来就是"打不了中文"。
@@ -69,13 +69,11 @@ dsh plugin --profile web add /path/to/dsh-edit-turn
 - id: dsh-edit-turn
   config:
     confirm: false              # 默认 false：一次点击即执行；置 true 才要求二次确认
-    rerun: false                # 默认 false：保存只写上下文；置 true 则同时重跑该轮
 ```
 
 | 字段 | 默认 | 含义 |
 |---|---|---|
 | `confirm` | `false` | 客户端保存后是否先要求一次确认。默认**关闭**（一次点击即执行：编辑器本身已是用户主动打开的动作；设为 `true` 时确认步里会写明这次保存会丢弃什么）； |
-| `rerun` | `false` | 保存后是否立刻重跑该轮。默认**关闭**：改后的内容进上下文即可，等你下次发消息时模型才读到它。设为 `true` 则保存即重跑（走官方 `sessionController.prompt()`）。 |
 
 ### 工作原理
 
@@ -96,11 +94,7 @@ session.append('developer/message', { turn, step, message: { role: 'developer',
 
 落盘后等一次持久化检查点（`sessions.flush`），保证重启也能看到。
 
-**第二步（可选）：重跑。** 默认不做。`rerun: true` 时：
-
-```js
-await ctx.sessionController.prompt({ requestId, sessionId, mode: 'queue', content: [{ type: 'text', text: 新内容 }] })
-```
+**重跑不由本插件做。** "改完立刻重答"是姊妹插件 `dsh-rerun-turn` 的操作：它遮蔽该轮、用表面现在显示的提示词（也就是你改后的文本）重新生成，再把后续轮次逐事件重放回来。本插件只负责把编辑落地；编辑器里的「重跑」按钮仅在检测到它挂载时出现，点击后先保存、再调用它的 `POST /dsh-rerun-turn/apply`。它不在（例如桌面版没装）时，没有这个按钮。
 
 **为什么不做文件截断？** 因为那不是官方能力。`dsh-session-persistence-jsonl` 只暴露残帧崩溃修复用的 `truncateTornTail`，正常路径下「Committed events are never rewritten」；运行中的宿主把会话放在内存 append-only 日志 + 投影缓存里，改磁盘不会让它重新读取。截断还会破坏 `sourceEventSeqs` 的 `[start,end]` 压缩表示与多帧 zstd 结构。surface-replace 是官方为这件事准备的机制。
 
@@ -109,7 +103,7 @@ await ctx.sessionController.prompt({ requestId, sessionId, mode: 'queue', conten
 | 类型 | 名称 | 说明 |
 |---|---|---|
 | 路由 | `GET /dsh-edit-turn/state?sessionId=` | 可编辑轮次、已遮蔽行账本（`hidden` + `revisions`）、surface、忙碌状态 |
-| 路由 | `POST /dsh-edit-turn/apply` | `{ sessionId, seq \| messageId \| turn, text }` → 写入改后内容（`rerun: true` 时另加重跑）；响应含 `applied` / `reran` / `shadowed` / `replacementSeq` |
+| 路由 | `POST /dsh-edit-turn/apply` | `{ sessionId, seq \| messageId \| turn, text }` → 写入改后内容；响应含 `applied` / `shadowed` / `replacementSeq` |
 | 工具 | `edit_turn_targets` | 只读：列出该会话当前可编辑的轮次与原文（供 agent 自查） |
 | 前端 | `conversation.input.overlay` | 每会话控制器：编辑入口、就地编辑器、被遮蔽行的隐藏账本 |
 
@@ -170,7 +164,7 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 - 可以编辑**你自己输入的消息**与**模型的回答**；注入的上下文行与系统提示词没有编辑入口。
 - 编辑一条回答会把它替换为**纯文本**：该回答里的工具调用与思考过程会被移除（编辑器会提示），因为它们的结果已不再成立。
-- 编辑一条用户消息**只替换那一条**，**默认不重跑模型**（`rerun: true` 才会保存后立刻重跑）；编辑一条模型回答只替换内容，同样不问模型。
+- 编辑一条用户消息**只替换那一条**，**保存永不调用模型**；编辑一条模型回答只替换内容，同样不问模型。想立刻重答，用 `dsh-rerun-turn` 的「重跑」。
 - **提示词编辑只动那一条**：它下面的回复与之后的对话**原样保留**。**回复编辑**才会移除该回答及其后的内容——回答变了，建立在它之上的一切都不再成立。想保留原文形成分支，需要走 `sessionController.fork({ sessionId, atSeq })`，尚未实现。
 - **只改写文本**。消息里含图片/文件附件时，改写后只保留文字（编辑器会提示）。
 - **会话必须当前在 DSH 中打开**，否则返回 `409 session-not-active`。
@@ -219,6 +213,26 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
+**0.2.14** —— 修「重新 apply 时上一次注入的节点不清理 → 同一条消息行上堆出多个宿主」（互操作契约 I3 / §5）。只修 Bug，交互语义不变。
+
+- **修复：重新 apply（HMR / 现场重载 / 插件开关 / bundle 组重载）会在同一行里再种一个编辑宿主，而不是复用上一次那个**。旧宿主的身份记在模块实例的 WeakMap 里，实例一换就认不出；于是每 apply 一次，那条操作条里就多一个「编辑这条消息」的笔。真机 CDP 探针实测同一 strip 里 `dshet-action-host` 多达 **7 个**、children 一度到 17（页面重载后回到 1、stripKids = 5），用户看到的是「一行上出现 3 个重跑按钮」。现在**每个注入节点都带命名空间属性**（宿主 `data-dshet-action-host="1"`、浮层根 `data-dshet-layer="1"`、编辑框 `data-dshet-editor="1"`、替代气泡 `data-dshet-revision="1"`），注入前先按属性在行内查一次、查到就**复用**——并且把它重新指到**当前**控制器（激活函数挂在按钮元素上、按下时才读，不再是上次那份捕获了旧闭包的监听；否则复用的笔点开的是已退休的控制器，表现就是「点了没反应」）。每趟 DOM pass 结束还会清掉「本次实例没有认领的」同命名空间宿主，正是那 7 个的直接来源；扫描只认自己的命名空间，兄弟插件的按钮永远不在候选里（I3）。
+- **修复：卸载时不再把自己的注入节点留在页面上**。fiber dispose（`ctx.effect` 的清理）现在按属性选择器**全局**扫掉本插件的注入节点（宿主 / 替代气泡 / 编辑框 / 浮层根），并把**只属于自己**的隐藏交还给宿主行（`data-dshet-hidden` / `data-dshet-collapsed` / 折叠中途的内联样式），恢复可见前照旧先问归属（I4）；React 自己渲染的节点（提示条、回答动作条里那支笔）**不扫**——从 React 手里抽走节点会让它在卸载时抛错。
+- **English**: re-applying the bundle (HMR, a live reload, a plugin toggle) over the same page no longer plants a second edit-action host on the row - every injected node now carries a namespace attribute, an existing host is looked up in the row and reused (with its activation re-pointed at the controller that is mounted now, read off the button at press time), any host this apply instance did not claim is swept at the end of the pass, and disposing the fiber removes every node this plugin injected (hosts, revision bubbles, the editor and its layer root) while handing back only its own row/child hiding - React-owned nodes are deliberately left to the reconciler.
+- 本版：`npm test` 126/126、`npm run verify:contract` 80/80、`npm run verify:client` 157/157 全绿（exit 0，`npm run check` 连跑两次同结果）；新增 5 条 DOM 用例与 12 条静态检查；5 条新用例已用「把三处修复改回旧写法」验证必红——旧代码下那条 strip 里的宿主数正好是 **7**（与探针一致），卸载后宿主数仍是 1（等于不清理）。
+
+**0.2.13** —— 隐藏归因（互操作契约 I4）+ 兄弟探测硬化（I5）。只修 Bug，交互语义不变。
+
+- **修复：别人隐藏的行，本插件不再替它显示出来**。回退的「恢复可见」分支无条件把 `row.style.display` 清成 `''`——那一行若正被 **dsh-delete-turn**（`data-dshdt-hidden`）或 **dsh-rerun-turn**（`data-dsrr-hidden`）按归属属性隐藏着，本插件一恢复就把别人的隐藏一并抹掉（行"复活"）。现在按契约 §4 在本地拷入 `foreignHideOn(row,'dshet')`：恢复前先确认没有别的归属属性，有则**保持 `display:none`**，只交还本插件自己那份隐藏。同理，折叠子节点时只有**本插件亲手写下**的 `display:none` 才打 `data-dshet-collapsed` 标记，恢复时也不会把别的插件留下的 `none` 重新显示出来。
+- **修复：兄弟探测的过期答案不再覆盖新答案**（探测令牌，编辑器连开两次时不再闪一下又消失）；`fetch` 抛错仍归入「缺席」且不打印任何日志（I5），探测结果为 `unknown` 时依旧不渲染重跑按钮。
+- **English**: rows another plugin is keeping hidden are no longer un-hidden by this plugin's restore pass (`foreignHideOn(row, 'dshet')`, contract §4), a `display:none` this plugin did not write is no longer claimed by the collapse marker, and a sibling-probe answer older than the newest probe can no longer take the re-run button back out; a failed probe stays silent and absent.
+- 本版：`npm test` 121/121、`npm run verify:contract` 80/80、`npm run verify:client` 145/145 全绿（exit 0）；新增 7 条 DOM 用例与 5 条静态检查，三条新用例已用「改回旧代码」验证必红。
+
+**0.2.12** —— 编辑器里的「重跑」（转发给 dsh-rerun-turn），并删除旧的 `rerun` 配置。
+
+- **新增：「重跑」按钮（提示词编辑专用）**。装了姊妹插件 **dsh-rerun-turn** 时，取消/保存 旁多一个「重跑」：先走本插件的保存（就地替换、不花模型调用），紧接着调用它的 `POST /dsh-rerun-turn/apply { sessionId, seq: 该轮作答 }`——它按表面现在显示的提示词（你改后的文本）重新生成，并把后续轮次逐事件重放回来。探测方式与它的加载器探针一致（不带 sessionId 请求它的 `/state`：400=装着、404=没装），**没装就没有这个按钮**（例如桌面版没装时）。回答编辑不加这个按钮——回答动作条里本来就有它自己的 ↻。**它的 apply 不接受改写文本，所以顺序永远是先保存、后重跑**；该轮没有可重跑的作答、或它拒绝（`not-rerunnable`/`already-retired`/`busy`/`rerunning`…）时，按错误码提示，不影响已经落地的保存。
+- **删除：旧的 `rerun: true` 配置及其实现**。旧路径在保存后用 `sessionController.prompt()` 在末尾追加一条同文提问——那不是"重跑这一轮"，语义不干净（会在上下文里多出一条重复提问）。现在 `POST /apply` 的响应不再有 `reran` / `rerunError`，`/state` 的 `config` 不再有 `rerun`，i18n 的「保存并重跑」与文档一并移除；**保存永不调用模型**，重跑一律交给 dsh-rerun-turn。
+- **诚实修正（流程问题）**：静态检查里「编辑器锚定到替代行」那条断言自 0.2.7 起写的还是被替换前的旧表达式（`view.revisions.get(seq)`，代码已改为 `headRevision(...)`），**一直红着**；我在那几轮里只 grep「全部通过」而漏看 `✗`，所以 0.2.7–0.2.11 的提交说明里"静态全绿"的说法**有一处不实**（单测、契约、真机冒烟这些当时确实都过，功能未受影响）。本条断言已按现表达式修正，并且从此用**退出码**判定 `npm run check`。本版：114 单测 / 80 契约 / 静态（exit 0）/ verify:live / verify:ui 全绿。
+
 **0.2.11** —— 修「字怎么变大了」。
 
 - **修复：改写后的气泡与编辑器不跟随平台的"内容字号"设置**。平台的气泡用 `font-size: var(--dsh-content-font-size,14px)` + `line-height: calc(22px + var(--dsh-content-font-delta,0px))`；我们的替代气泡写成 `font:inherit`（继承了行的 16px，比气泡的 15px 大），编辑器又写死 15px——读者一改内容字号，两处都对不上，看起来就是"字变大了"。现在两者都取平台同一个变量/公式（该变量定义在 body 上，编辑器所在的浮层是其子节点，可直接继承）。
@@ -336,7 +350,7 @@ This plugin adds it:
 - saving **replaces that one message in place**: only the old wording leaves the model context, the revised text takes its place, and every later turn is answered against the new version;
 - **the reply under it and the whole conversation after it stay exactly as they were** - nothing is re-run and nothing is cleared;
 - model replies are editable too: replacing one rolls back that answer and everything built on it (a changed answer invalidates what followed) and appends your text as a fresh reply;
-- turn `rerun` on if you do want the edited turn answered again right away.
+- with the sister plugin **dsh-rerun-turn** installed, the editor also offers a "**Re-run**" button: it saves your change first, then has that plugin regenerate the turn from the revised prompt (replaying what followed, so nothing after it is lost).
 
 ### Features
 
@@ -344,7 +358,7 @@ This plugin adds it:
 - **The revision is the carrier.** A prompt edit lands a `user/message` replacement whose content **is** your revised text: it updates the model context and shows in the transcript in place of the old wording. The platform does not answer it as a new input (that was tried: *appending* a user message makes the platform reply, and the next save added another copy). Reply edits stay silent too: their carrier is an empty `developer/message` - the format admits only system-prompt sources on `system/message`, and an empty plugin-owned system node is exactly what used to make sessions unreadable (see below).
 - **The smallest window that is correct.** A prompt edit shadows exactly one node (`shadowed = [target.seq]`); a reply edit shadows the reply through the end of the surface - a changed answer invalidates everything built on it - which also keeps an assistant message (carrying its own tool_use blocks) and the tool/result it produced together. A dangling call/result pair is impossible.
 - **A rewritten message stays editable.** It still shows where the original stood, and hovering it offers the pencil again.
-- **No model call by default.** Saving only writes the context. `rerun: true` restores the old behaviour and goes through the one official prompt admission path, `ctx.sessionController.prompt()`.
+- **Saving never calls the model.** It only writes the context. Regenerating a turn after the edit is a different operation, owned by the sister plugin **dsh-rerun-turn** (it shadows the turn, regenerates from the prompt the surface now shows, and replays the turns that followed); this plugin only forwards to it, through the "Re-run" button, when it is mounted.
 - **The model's replies are editable too.** A reply cannot be swapped in place: the format refuses `sourceEventSeqs` on an `assistant/message` (verified against the real validator). The answer is rolled back together with everything after it, and the corrected text is **appended** as a fresh reply - the model goes on treating it as its own. `source.editedBy` records honestly that the plugin wrote those words.
 - **One click applies** - no second confirmation by default. The editor is already an explicit action the user opened; with `confirm: true` the confirmation step states what this save will discard, while the input box itself stays clean.
 - **Bilingual UI** that follows the current DSH locale.
@@ -368,7 +382,7 @@ Restart the DSH process that serves that profile to pick it up.
 ### Usage
 
 1. Hover the **user message** you want to change and click the pencil action.
-2. An editor opens below it with the original text pre-filled. Click "**Save**" - **one click applies**: the old wording leaves the model context and the revised text takes its place. **No model call.** (`rerun: true` shows "Save and re-run" instead.)
+2. An editor opens below it with the original text pre-filled. Click "**Save**" - **one click applies**: the old wording leaves the model context and the revised text takes its place. **No model call.** With `dsh-rerun-turn` installed there is also a "**Re-run**" button: save first, then let that turn regenerate from your revised wording (nothing after it is lost).
 3. The editor closes and the message shows your text in place; the reply under it and everything after it stay exactly where they were.
 
 The editor is **shaped like the platform's own input box**: one rounded
@@ -397,13 +411,11 @@ longer valid once you have changed what the model said.
 - id: dsh-edit-turn
   config:
     confirm: false              # default: apply in one click; true restores the two-step flow
-    rerun: false                # default: saving only writes the context; true re-runs the turn
 ```
 
 | Field | Default | Meaning |
 |---|---|---|
 | `confirm` | `false` | Whether the client asks for a second confirmation before applying. Off by default - one click applies, because the editor is already an explicit action the user opened; with `true` the confirmation step states what this save will discard. |
-| `rerun` | `false` | Whether the edited turn is re-run right after saving. Off by default: the revision enters the context and the model reads it on your next message. `true` re-runs through the official `sessionController.prompt()`. |
 
 ### How it works
 
@@ -434,11 +446,7 @@ session.append('developer/message', { turn, step, message: { role: 'developer',
 The append then waits for the official durability checkpoint (`sessions.flush`)
 so a reload or a DSH restart still sees the rollback.
 
-**Step two (optional): the re-run.** Off by default; `rerun: true` turns it on.
-
-```js
-await ctx.sessionController.prompt({ requestId, sessionId, mode: 'queue', content: [{ type: 'text', text }] })
-```
+**The re-run is not this plugin's operation.** Regenerating the turn is the sister plugin `dsh-rerun-turn`'s job: it shadows the turn, regenerates from the prompt the surface now shows (your revised text), and replays the turns that followed. This plugin only lands the edit; its editor offers a "Re-run" button when that plugin is detected, and the button chains save-then-`POST /dsh-rerun-turn/apply`. Without it (the desktop profile, say) there is no such button.
 
 **Why not truncate the log?** Because that is not an official capability.
 `dsh-session-persistence-jsonl` exposes only `truncateTornTail`, for crash
@@ -454,7 +462,7 @@ for exactly this.
 | Kind | Name | Purpose |
 |---|---|---|
 | Route | `GET /dsh-edit-turn/state?sessionId=` | Editable turns, the hidden-row ledger (`hidden` + `revisions`), the surface, busy state |
-| Route | `POST /dsh-edit-turn/apply` | `{ sessionId, seq \| messageId \| turn, text }` → write the revised text (`rerun: true` re-runs too); the response carries `applied` / `reran` / `shadowed` / `replacementSeq` |
+| Route | `POST /dsh-edit-turn/apply` | `{ sessionId, seq \| messageId \| turn, text }` → write the revised text; the response carries `applied` / `shadowed` / `replacementSeq` |
 | Tool | `edit_turn_targets` | Read-only: list the session's editable turns and their text |
 | Client | `conversation.input.overlay` | Per-session controller: edit entry, in-place editor, hidden-row ledger |
 
@@ -703,8 +711,8 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 - **Human prompts and model replies** are both editable; injected context rows and the system prompt offer no edit entry.
 - **Editing a reply replaces it with plain text**: the tool calls and reasoning inside it are removed (the editor warns first), because their results are no longer valid.
-- **Editing a user message replaces that one message and leaves the rest of the conversation untouched - no re-run unless `rerun: true`**; editing a model reply only replaces the text and never asks the model again.
-- **A prompt edit touches only that message.** The reply under it and the whole conversation after it are kept - no re-run unless `rerun: true`. A **reply edit** removes that answer and everything built on it, because a changed answer invalidates what followed. Keeping the original as a branch needs `sessionController.fork({ sessionId, atSeq })`, which is not implemented.
+- **Editing a user message replaces that one message and leaves the rest of the conversation untouched; saving never calls the model.** For an immediate answer, use `dsh-rerun-turn`'s "Re-run"; editing a model reply only replaces the text, too.
+- **A prompt edit touches only that message.** The reply under it and the whole conversation after it are kept; saving never calls the model. A **reply edit** removes that answer and everything built on it, because a changed answer invalidates what followed. Keeping the original as a branch needs `sessionController.fork({ sessionId, atSeq })`, which is not implemented.
 - **Text only.** A message carrying image or file attachments keeps its text and drops them (the editor warns first).
 - **The session must be open in DSH**, otherwise the route answers `409 session-not-active`.
 - **Running work is refused**: an unclosed turn or an in-flight compaction answers `409 busy`.

package/lib/client.js

@@ -28,9 +28,13 @@ window.__ModuleLoader__.load({
 
     const NS = 'dsh-edit-turn'
     const ROUTE_PREFIX = '/dsh-edit-turn'
+    // The sibling that owns re-running: it shadows a turn and regenerates it
+    // from the prompt the surface now shows, then replays what followed. The
+    // editor's re-run button is only offered when it is mounted.
+    const RERUN_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.2.11'
+    const PLUGIN_VERSION = '0.2.14'
 
     // --- copy -----------------------------------------------------------------
 
@@ -42,7 +46,7 @@ window.__ModuleLoader__.load({
       'editor.placeholder': '改成你希望自己当时说的内容。保存后这条消息之后的轮次会从模型上下文中移除，改后的内容成为新的起点。',
       'editor.placeholder-reply': '改成你希望模型说过的内容，保存后它就成为这条回答。',
       'editor.save': '保存',
-      'editor.save-rerun': '保存并重跑',
+      'editor.rerun': '重跑',
       'editor.save-reply': '保存',
       'editor.review': '确认执行',
       'editor.cancel': '取消',
@@ -63,6 +67,11 @@ window.__ModuleLoader__.load({
       'error.prompt': '已回退，但改后的内容没能写进上下文。请重试。',
       'error.reply': '已回退，但替换没有落地。请重试。',
       'error.empty': '改写后的内容不能为空。',
+      'error.rerun-nothing': '已保存，但这一轮没有可重跑的作答。',
+      'error.rerun-unavailable': '已保存，但重跑没有开始，请稍后重试。',
+      'error.not-rerunnable': '这一轮没有可重跑的作答。',
+      'error.already-retired': '这一轮的内容已经不在当前上下文里了。',
+      'error.rerunning': '已经有一次重跑在进行中，请等它结束。',
       'error.internal': '服务器内部错误，请稍后重试。',
     }
 
@@ -74,7 +83,7 @@ window.__ModuleLoader__.load({
       'editor.placeholder': 'Saving rolls the conversation back to just before this message and this turn runs again.',
       'editor.placeholder-reply': 'Write what you want the model to have said; saving makes it this reply.',
       'editor.save': 'Save',
-      'editor.save-rerun': 'Save and re-run',
+      'editor.rerun': 'Re-run',
       'editor.save-reply': 'Save',
       'editor.review': 'Confirm',
       'editor.cancel': 'Cancel',
@@ -95,6 +104,11 @@ window.__ModuleLoader__.load({
       'error.prompt': 'Rolled back, but the re-run did not start. Send the revised text manually.',
       'error.reply': 'Rolled back, but the replacement did not land. Try again.',
       'error.empty': 'The revised message cannot be empty.',
+      'error.rerun-nothing': 'Saved, but this turn has no reply that can be re-run.',
+      'error.rerun-unavailable': 'Saved, but the re-run did not start; try again.',
+      'error.not-rerunnable': 'This turn has no reply that can be re-run.',
+      'error.already-retired': 'This turn is no longer part of the current context.',
+      'error.rerunning': 'A re-run is already in flight; wait for it to finish.',
       'error.internal': 'The host hit an internal error; try again shortly.',
     }
 
@@ -270,6 +284,11 @@ window.__ModuleLoader__.load({
         this.editorFocus = false
         this.editorDraft = ''
         this.clearTimer = null
+        this.pendingRerun = false
+        this.siblingRerun = 'unknown'
+        // Bumped on every probe: an answer older than the newest probe is stale
+        // and must not move the button.
+        this.probeToken = 0
         this.confirming = false
         this.noticeTimer = null
         this.view = Object.freeze({
@@ -290,7 +309,9 @@ window.__ModuleLoader__.load({
           // Matches the host's default: one click applies. Only an explicit
           // `confirm: true` in the profile turns the second step back on.
           confirmStep: false,
-          rerun: false,
+          // Whether the sibling that owns re-running (dsh-rerun-turn) is
+          // mounted; probed when an editor opens, updated only on change.
+          siblingRerun: 'unknown',
           revision: 0,
         })
       }
@@ -369,9 +390,6 @@ window.__ModuleLoader__.load({
               loaded: true,
               loadError: false,
               confirmStep: !(data.config && data.config.confirm === false),
-              // Off by default: saving writes the revision into the context and waits
-              // for the next message rather than spending a model call.
-              rerun: Boolean(data.config && data.config.rerun === true),
             })
           })
           .catch(() => {
@@ -409,10 +427,36 @@ window.__ModuleLoader__.load({
           }
         }
         this.publish({ editing: target, draft: this.editorDraft, confirming: false, failure: null })
+        this.probeSiblingRerun()
+      }
+
+      // The sibling is probed the way our own loader is probed: its state route
+      // answers 400 without a sessionId when it is mounted, 404 when the route
+      // does not exist. A change is published - the editor's marker carries it,
+      // so the button appears (or never does).
+      async probeSiblingRerun() {
+        const token = (this.probeToken += 1)
+        let status = 0
+        try {
+          const response = await fetch(`${RERUN_PREFIX}/state`, { headers: { accept: 'application/json' } })
+          status = response.status
+        } catch {
+          // A sibling that is not mounted is not an error (I5): a rejected
+          // fetch, a timeout and a 404 all land in 'absent', and none of them
+          // logs anything.
+          status = 0
+        }
+        // Two opens before the first answer arrived: the slower probe used to
+        // land second and take the button back out. Only the newest speaks.
+        if (token !== this.probeToken) return
+        const next = status === 400 || status === 405 ? 'present' : 'absent'
+        this.siblingRerun = next
+        if (this.view.siblingRerun !== next) this.publish({ siblingRerun: next })
       }
 
       close() {
         if (this.view.pending) return
+        this.pendingRerun = false
         this.editorElement = null
         this.editorBox = null
         this.editorRow = null
@@ -429,6 +473,17 @@ window.__ModuleLoader__.load({
       }
 
       review() {
+        this.pendingRerun = false
+        this.runReview()
+      }
+
+      /** The same save, plus the intent to re-run the turn afterwards. */
+      reviewRerun() {
+        this.pendingRerun = true
+        this.runReview()
+      }
+
+      runReview() {
         if (this.editorDraft.trim() === '') {
           this.publish({ failure: 'empty' })
           return
@@ -450,6 +505,8 @@ window.__ModuleLoader__.load({
       async confirm() {
         const target = this.editor
         if (target === null || this.view.pending) return
+        const rerunIntent = this.pendingRerun
+        this.pendingRerun = false
         const text = this.editorDraft
         if (text.trim() === '') {
           this.publish({ failure: 'empty' })
@@ -526,6 +583,11 @@ window.__ModuleLoader__.load({
           // failed second half has to be reported somewhere that survives that.
           if (data.kind === 'reply' && data.applied === false) this.notify('reply')
           if (data.kind !== 'reply' && data.applied === false) this.notify('prompt')
+          // Save first, re-run second - always: the sibling re-runs the turn
+          // from the prompt the surface NOW shows, so the revised wording has
+          // to be on the surface before it is asked to regenerate. Not
+          // awaited: its own client takes the screen from here.
+          if (rerunIntent) this.startSiblingRerun(target.turn)
           // The view above is complete enough to render, but the host is the
           // authority on what the session now looks like: only its answer knows
           // how many rows the platform decided to draw, and what the appended
@@ -538,6 +600,37 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // Hand the re-run to the sibling: find the turn's reply through its own
+      // state (the freshest view of what it can rerun) and ask it to start.
+      async startSiblingRerun(turn) {
+        try {
+          const response = await fetch(
+            `${RERUN_PREFIX}/state?sessionId=${encodeURIComponent(this.sessionId)}`,
+            { headers: { accept: 'application/json' } },
+          )
+          const state = response.ok ? await response.json().catch(() => ({})) : {}
+          const replies = Array.isArray(state.replies)
+            ? state.replies.filter((entry) => entry && entry.turn === turn && typeof entry.seq === 'number')
+            : []
+          if (replies.length === 0) {
+            this.notify('rerun-nothing')
+            return
+          }
+          const head = replies.reduce((best, entry) => (entry.seq > best.seq ? entry : best))
+          const started = await fetch(`${RERUN_PREFIX}/apply`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ sessionId: this.sessionId, seq: head.seq }),
+          })
+          const result = await started.json().catch(() => ({}))
+          if (!started.ok || !result.ok) {
+            this.notify(result && result.code ? String(result.code) : 'rerun-unavailable')
+          }
+        } catch {
+          this.notify('rerun-unavailable')
+        }
+      }
+
       notify(code) {
         if (this.noticeTimer !== null) window.clearTimeout(this.noticeTimer)
         this.publish({ notice: code })
@@ -653,6 +746,132 @@ window.__ModuleLoader__.load({
 
     const rowActions = new WeakMap()
 
+    // --- injected-node namespace ----------------------------------------------
+    //
+    // The host reloads this bundle in place: a new module instance with fresh
+    // closures, a fresh WeakMap and a fresh editor layer, over the DOM the
+    // previous instance left behind. Nothing in an instance can recognise its
+    // predecessor's nodes by identity, so every node this half injects carries
+    // its namespace in an attribute as well as in its class (contract I3): the
+    // attribute is what a reload looks for (reuse it, never plant a second) and
+    // what a real unload sweeps away. The class forms stay as fallbacks - a
+    // bundle older than this one injected the same nodes with the class alone.
+    const HOST_ATTR = 'dshetActionHost'
+    const LAYER_ATTR = 'dshetLayer'
+    const EDITOR_ATTR = 'dshetEditor'
+    const HOST_SELECTOR = '[data-dshet-action-host="1"],.dshet-action-host'
+    const LAYER_SELECTOR = '[data-dshet-layer="1"],.dshet-layer'
+    // The live activation of an injected action, kept on the button element
+    // itself: see `wireAction`.
+    const ACTIVATE = 'dshetActivate'
+    // Everything this half creates itself. The React-owned nodes are NOT in here
+    // on purpose (the notice banner, the reply entry in the assistant-actions
+    // strip): the host unmounts those through its own reconciler, and pulling a
+    // node out from under React makes it throw on the way out.
+    const OWN_NODE_SELECTOR = [
+      HOST_SELECTOR,
+      LAYER_SELECTOR,
+      '[data-dshet-editor="1"],.dshet-editor',
+      '[data-dshet-revision="1"],.dshet-revision',
+    ].join(',')
+
+    // The action hosts this module instance stands behind. A host carrying the
+    // namespace that no pass of this instance claimed cannot be positioned or
+    // updated by anyone: it is a leftover of an apply that is gone, and
+    // `dropUnclaimedHosts` takes it out.
+    const liveHosts = new WeakSet()
+
+    /** Does this node still hang in a tree? A parentless host is one nobody can see. */
+    function hasParent(node) {
+      return node !== null && node !== undefined && node.parentElement !== null && node.parentElement !== undefined
+    }
+
+    /** Is this one of our action hosts - by namespace attribute, or by class? */
+    function isActionHost(node) {
+      if (node === null || node === undefined) return false
+      const className = typeof node.className === 'string' ? node.className : ''
+      if (/(^|\s)dshet-action-host(\s|$)/.test(className)) return true
+      if (typeof node.matches === 'function') {
+        try {
+          return node.matches(HOST_SELECTOR) === true
+        } catch {
+          return false
+        }
+      }
+      return false
+    }
+
+    /** Every action host of ours inside `scope`, the scope itself included. */
+    function actionHostsIn(scope) {
+      const out = []
+      if (scope === null || scope === undefined) return out
+      if (isActionHost(scope)) out.push(scope)
+      if (typeof scope.querySelectorAll === 'function') {
+        for (const node of scope.querySelectorAll(HOST_SELECTOR)) {
+          if (!out.includes(node)) out.push(node)
+        }
+      }
+      return out
+    }
+
+    /** The button inside an injected host, wherever a previous apply left it. */
+    function actionButtonIn(host) {
+      for (const child of host.children) {
+        const className = typeof child.className === 'string' ? child.className : ''
+        if (child.tagName === 'BUTTON' || /(^|\s)dshet-action(\s|$)/.test(className)) return child
+      }
+      return null
+    }
+
+    function createActionHost() {
+      const host = document.createElement('span')
+      host.className = 'dshet-action-host'
+      host.dataset[HOST_ATTR] = '1'
+      return host
+    }
+
+    function createActionButton() {
+      const button = document.createElement('button')
+      button.type = 'button'
+      button.className = 'dshet-action dshet-row-action'
+      button.innerHTML = ICON_MARKUP
+      return button
+    }
+
+    /**
+     * Wire the press/click pair onto an injected action.
+     *
+     * The action itself is NOT captured here: it is read off the button at press
+     * time (`ACTIVATE`). A reloaded bundle reuses the very node the retired one
+     * injected - that is what the namespace is for - and it wires that node
+     * again, so the handler has to reach the controller that is mounted NOW.
+     * A captured closure would open the retired controller, which does nothing
+     * at all and reads exactly like a dead pencil.
+     */
+    function wireAction(button) {
+      pressable(button, () => {
+        const activate = button[ACTIVATE]
+        if (typeof activate === 'function') activate()
+      })
+    }
+
+    /** The pencil host a previous apply injected into this row, if there is one (I3). */
+    function adoptActionHost(row) {
+      const hosts = actionHostsIn(row)
+      if (hosts.length === 0) return null
+      // The first one wins: a second host in the same row is a ghost of an
+      // earlier apply, and the sweep at the end of this pass removes it.
+      const host = hosts[0]
+      if (host.dataset !== undefined && host.dataset[HOST_ATTR] !== '1') host.dataset[HOST_ATTR] = '1'
+      let button = actionButtonIn(host)
+      if (button === null) {
+        button = createActionButton()
+        host.appendChild(button)
+      }
+      wireAction(button)
+      return { host, button, target: null }
+    }
+
     // Show a rewritten prompt where its original row is.
     //
     // The bubble is cloned from a real user bubble's classes at runtime - the
@@ -696,7 +915,6 @@ window.__ModuleLoader__.load({
         return node.kind !== 'user'
       }
       const bubble = existing === null ? cloneUserBubble(row) : existing
-      if (existing === null) bubble.dataset.dshetRevision = '1'
       {
         const key = row.getAttribute('data-chat-flow-key')
         if (typeof key === 'string' && key !== '' && bubble.dataset[REVISION_FOR] !== key) {
@@ -740,6 +958,10 @@ window.__ModuleLoader__.load({
     function cloneUserBubble(row) {
       const bubble = document.createElement('div')
       bubble.className = 'dshet-revision'
+      // Namespace attribute as well as the class: a reloaded bundle finds this
+      // bubble by attribute (it has no memory of the node), and an unload sweeps
+      // it by the same selector.
+      bubble.dataset.dshetRevision = '1'
       if (row !== null && row !== undefined) {
         const key = row.getAttribute('data-chat-flow-key')
         if (typeof key === 'string' && key !== '') bubble.dataset[REVISION_FOR] = key
@@ -855,8 +1077,13 @@ window.__ModuleLoader__.load({
           if (hide) {
             // Written only when the value changes: this runs on every DOM pass,
             // and an attribute write the observer can see would never settle.
-            if (child.style.display !== 'none') child.style.display = 'none'
-            if (child.dataset.dshetCollapsed !== '1') child.dataset.dshetCollapsed = '1'
+            // The marker is written only for a `none` this plugin wrote (I4):
+            // a child another plugin had already displayed away is left
+            // untouched, so the restore pass cannot take that hiding back out.
+            if (child.style.display !== 'none') {
+              child.style.display = 'none'
+              if (child.dataset.dshetCollapsed !== '1') child.dataset.dshetCollapsed = '1'
+            }
           } else if (child.dataset.dshetCollapsed === '1') {
             child.style.display = ''
             delete child.dataset.dshetCollapsed
@@ -867,6 +1094,25 @@ window.__ModuleLoader__.load({
       return true
     }
 
+    // Attribution for the hiding below (contract §4). Another plugin writes its
+    // own marker on a row it displayed away (delete-turn 'dshdt', rerun-turn
+    // 'dsrr'); this half resets `display` for its OWN hide only, and a row
+    // another plugin is keeping away stays away.
+    const HIDE_OWNERS = [
+      ['dshdt', 'data-dshdt-hidden', 'dshdtHidden'],
+      ['dshet', 'data-dshet-hidden', 'dshetHidden'],
+      ['dsrr', 'data-dsrr-hidden', 'dsrrHidden'],
+    ]
+    /** Is anyone but `own` claiming a hide on this row? */
+    function foreignHideOn(row, own) {
+      for (const [key, attr, prop] of HIDE_OWNERS) {
+        if (key === own) continue
+        if (row.dataset?.[prop] === '1') return true
+        if (typeof row.hasAttribute === 'function' && row.hasAttribute(attr)) return true
+      }
+      return false
+    }
+
     function setRowHidden(row, hide, animate) {
       // A turn tail is not a message row. It is the strip a turn's end renders
       // (duration, usage, actions); when the turn behind it is rolled back the
@@ -917,7 +1163,10 @@ window.__ModuleLoader__.load({
       delete row.dataset.dshetHidden
       if (row.dataset.dshetKeepActions === '1') delete row.dataset.dshetKeepActions
       row.classList.remove('dshet-collapsing')
-      row.style.display = ''
+      // I4: dropping our marker ends OUR hide. `display` is only ours to clear
+      // while no other plugin's hide marker stands - a row a sibling displayed
+      // away stays away, whatever this half would prefer.
+      row.style.display = foreignHideOn(row, 'dshet') ? 'none' : ''
       row.style.height = ''
       row.style.opacity = ''
       row.style.marginTop = ''
@@ -929,6 +1178,7 @@ window.__ModuleLoader__.load({
     function removeRowAction(row) {
       const entry = rowActions.get(row)
       if (!entry) return
+      liveHosts.delete(entry.host)
       entry.host.remove()
       rowActions.delete(row)
     }
@@ -936,28 +1186,47 @@ window.__ModuleLoader__.load({
     function injectRowAction(row, target, controller, t, options = {}) {
       const label = t(target.mode === 'reply' ? 'action.edit-reply' : 'action.edit')
       let entry = rowActions.get(row)
-      if (!entry) {
-        const host = document.createElement('span')
-        host.className = 'dshet-action-host'
-        const button = document.createElement('button')
-        button.type = 'button'
-        button.className = 'dshet-action dshet-row-action'
-        button.innerHTML = ICON_MARKUP
+      // An entry whose host lost its parent is not an entry any more: another
+      // apply swept the node away (or the host took it out with the container it
+      // was in), and a pass that only repositions it would leave this row with
+      // no pencil at all.
+      if (entry !== undefined && !hasParent(entry.host)) {
+        rowActions.delete(row)
+        entry = undefined
+      }
+      // I3: a host a previous apply injected into this row is REUSED, never
+      // doubled. The WeakMap cannot find it - a reloaded bundle starts with an
+      // empty one - so the namespace attribute is what does.
+      if (entry === undefined) {
+        const adopted = adoptActionHost(row)
+        if (adopted !== null) entry = adopted
+      }
+      if (entry === undefined) {
+        const host = createActionHost()
+        const button = createActionButton()
         // The marker goes on the BUTTON, not only on its wrapper: the pass that
         // looks for the official strip's entry queries buttons, so a marker one
         // level up made this pencil look like the strip's own and it deleted
         // itself - then the next pass put it back, which reads as flicker.
-        if (options.fallback === true) button.dataset.dshetFallback = '1'
         host.appendChild(button)
         entry = { host, button, target }
-        // Wired once, and the action reads the CURRENT target off the entry: the
-        // pass runs again on every snapshot, and re-wiring would reset the
-        // press guard between a pointerdown and the click it swallows.
-        pressable(button, () => controller.open(entry.target))
+        // The action reads the CURRENT target off the entry and the CURRENT
+        // controller off the button, so re-wiring on a later apply is harmless
+        // and a reloaded bundle can take this very node over.
+        wireAction(button)
         rowActions.set(row, entry)
       }
       entry.target = target
       const { host, button } = entry
+      // The fallback marker mirrors the placement chosen below: a host adopted
+      // from a gutter placement must not keep claiming one it no longer has.
+      if (options.fallback === true) {
+        if (button.dataset.dshetFallback !== '1') button.dataset.dshetFallback = '1'
+      } else if (button.dataset !== undefined && button.dataset.dshetFallback !== undefined) {
+        delete button.dataset.dshetFallback
+      }
+      button[ACTIVATE] = () => controller.open(entry.target)
+      liveHosts.add(host)
       if (button.getAttribute('aria-label') !== label) {
         button.setAttribute('aria-label', label)
         button.setAttribute('title', label)
@@ -995,6 +1264,37 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /**
+     * One pencil per row, however often the bundle is applied over the same DOM.
+     *
+     * Every pass registers the host it stands behind in `liveHosts`. A host that
+     * carries this plugin's namespace and was claimed by NO pass of this
+     * instance cannot be positioned or updated by anyone: it is the leftover of
+     * an apply that is gone (a reload, a plugin toggle, a bundle-group swap),
+     * and left alone the bar collects one more of them per apply - the observed
+     * report was seven action hosts and seventeen children in a single strip,
+     * which the user reads as three re-run buttons on one row. Only nodes
+     * carrying this plugin's own namespace are ever considered (I3).
+     *
+     * The DOM pass runs on every snapshot, so a ghost is taken out on the first
+     * pass after the reload that produced it.
+     */
+    function dropUnclaimedHosts() {
+      if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return
+      let hosts = []
+      try {
+        hosts = document.querySelectorAll(HOST_SELECTOR)
+      } catch {
+        return
+      }
+      for (const host of hosts) {
+        if (liveHosts.has(host)) continue
+        try {
+          host.remove()
+        } catch {}
+      }
+    }
+
     // The platform's own action icons all carry a hashed class ending in
     // `_action`; the clock, the usage pill and anything this plugin adds do not
     // (ours are hyphenated). Matching that suffix avoids CSS-module hashes
@@ -1026,12 +1326,32 @@ window.__ModuleLoader__.load({
     let editorLayer = null
     function ensureEditorLayer() {
       if (editorLayer !== null && editorLayer.isConnected === true) return editorLayer
+      // A reloaded bundle starts with no layer of its own; the one the previous
+      // instance left is the same node doing the same job, so it is adopted
+      // rather than doubled (I3). The instance that left it takes it out with
+      // its own sweep when it is disposed.
+      const existing = ownLayer()
+      if (existing !== null && existing.isConnected !== false) {
+        editorLayer = existing
+        return editorLayer
+      }
       editorLayer = document.createElement('div')
       editorLayer.className = 'dshet-layer'
+      editorLayer.dataset[LAYER_ATTR] = '1'
       document.body.appendChild(editorLayer)
       return editorLayer
     }
 
+    /** The editor layer a previous apply left on the page, if there is one. */
+    function ownLayer() {
+      if (typeof document === 'undefined' || typeof document.querySelector !== 'function') return null
+      try {
+        return document.querySelector(LAYER_SELECTOR)
+      } catch {
+        return null
+      }
+    }
+
     // Put the box under the row it belongs to: same width, just below its lower
     // edge. Called on render and whenever the page scrolls or resizes, since
     // the layer is fixed to the viewport.
@@ -1101,13 +1421,16 @@ window.__ModuleLoader__.load({
         view.confirming ? 1 : 0,
         view.pending ? 1 : 0,
         view.failure === null ? '' : view.failure,
+        // The re-run button appears when the sibling probe lands; without it in
+        // the marker the editor would never be rebuilt to show the button.
+        view.siblingRerun === 'present' ? 'r' : 'n',
       ].join('|')
     }
 
     // Every string the editor shows depends on what is being edited: a prompt is
     // re-run, a reply is replaced. Keeping them in one place keeps the two modes
     // from drifting apart in wording.
-    function editorTexts(t, target, rerun) {
+    function editorTexts(t, target) {
       const reply = target.mode === 'reply'
       return {
         title: t(reply ? 'editor.title-reply' : 'editor.title'),
@@ -1115,13 +1438,13 @@ window.__ModuleLoader__.load({
         warn: t(reply ? 'editor.warn-reply' : 'editor.warn.attachments'),
         // Saving writes the revision into the context; only the opt-in config asks
         // the model again, and the button says which one will happen.
-        save: t(reply ? 'editor.save-reply' : rerun === true ? 'editor.save-rerun' : 'editor.save'),
+        save: t(reply ? 'editor.save-reply' : 'editor.save'),
       }
     }
 
     function renderEditor(row, controller, view, t) {
       const target = view.editing
-      const texts = editorTexts(t, target, view.rerun)
+      const texts = editorTexts(t, target)
       const marker = editorMarker(target, view)
       const existing = controller.editorBox !== null && controller.editorBox.isConnected === true
         ? controller.editorBox
@@ -1147,6 +1470,7 @@ window.__ModuleLoader__.load({
       clearEditor()
       const box = document.createElement('div')
       box.className = 'dshet-editor'
+      box.dataset[EDITOR_ATTR] = '1'
       box.dataset.dshetFor = marker
 
       const area = document.createElement('textarea')
@@ -1243,6 +1567,20 @@ window.__ModuleLoader__.load({
       })
 
       footer.appendChild(cancel)
+      // The re-run button belongs to the sibling (dsh-rerun-turn): it appears
+      // only when that plugin is mounted, only for a prompt edit, and only
+      // outside the confirmation step - the intent is carried through it. Save
+      // first, re-run second, always. A reply edit has no re-run here: the
+      // action strip of the reply carries the sibling's own button.
+      if (target.mode === 'prompt' && view.siblingRerun === 'present' && view.confirming !== true) {
+        const rerun = document.createElement('button')
+        rerun.type = 'button'
+        rerun.className = 'dshet-btn dshet-rerun'
+        rerun.textContent = t('editor.rerun')
+        rerun.disabled = view.pending
+        pressable(rerun, () => controller.reviewRerun())
+        footer.appendChild(rerun)
+      }
       footer.appendChild(submit)
       box.appendChild(footer)
 
@@ -1342,6 +1680,10 @@ window.__ModuleLoader__.load({
         controller.editorBox = null
         controller.editorRow = null
       }
+      // Whatever of ours no row of this pass claimed is a ghost of an earlier
+      // apply: the host rebuilt the row under it, or the bundle was reloaded
+      // over it. Contract §5 - a button nobody can update must not pile up.
+      dropUnclaimedHosts()
     }
 
     // A snapshot this entry can read, or null when the controller cannot be
@@ -1517,6 +1859,65 @@ window.__ModuleLoader__.load({
       })
     }
 
+    // --- unload -----------------------------------------------------------------
+
+    /**
+     * Take back everything this half put on the page.
+     *
+     * Runs when the plugin is disposed - a reload, a toggle, a bundle-group swap
+     * - and it works by NAMESPACE, never by identity: the WeakMap and the layer
+     * reference die with the module instance, the attributes on the nodes do
+     * not, and the instance that replaces this one starts with no memory of them
+     * at all. That is exactly why a reload used to leave a second pencil (and a
+     * third, and a fourth) in the same bar.
+     *
+     * Only nodes this plugin created are removed, and only state this plugin
+     * wrote is taken back (I3, I4): a row another plugin is keeping away stays
+     * away, and the host's own buttons never move.
+     */
+    function releaseInjectedNodes() {
+      if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return
+      const each = (selector, act) => {
+        let nodes = []
+        try {
+          nodes = document.querySelectorAll(selector)
+        } catch {
+          return
+        }
+        for (const node of nodes) {
+          try {
+            act(node)
+          } catch {}
+        }
+      }
+      // 1. The platform's own rows go back to how this half found them. These
+      //    markers are this plugin's own writes, so this is its own state - and
+      //    only its own: the restore path asks the attribution guard first (I4).
+      each('[data-dshet-hidden="1"]', (row) => setRowHidden(row, false))
+      each('[data-dshet-collapsed="1"]', (child) => {
+        child.style.display = ''
+        delete child.dataset.dshetCollapsed
+      })
+      // A row caught mid-collapse keeps the inline height and opacity this half
+      // wrote, and nothing after this would ever clear them.
+      each('.dshet-collapsing', (row) => {
+        row.classList.remove('dshet-collapsing')
+        row.style.height = ''
+        row.style.opacity = ''
+        row.style.marginTop = ''
+        row.style.marginBottom = ''
+        row.style.paddingTop = ''
+        row.style.paddingBottom = ''
+      })
+      // 2. Every node this half created goes with it: the injected pencils, the
+      //    bubbles standing in for rewritten prompts, the editor and the layer
+      //    it is hosted on. React's own nodes are deliberately not in the
+      //    selector - the host unmounts those, and pulling one out from under
+      //    React makes it throw on the way out.
+      each(OWN_NODE_SELECTOR, (node) => node.remove())
+      editorLayer = null
+    }
+
     // --- plugin ---------------------------------------------------------------
 
     function apply(ctx) {
@@ -1535,6 +1936,11 @@ window.__ModuleLoader__.load({
         () => () => {
           for (const controller of controllers.values()) controller.dispose()
           controllers.clear()
+          // The DOM this half injected is not owned by the controllers: it
+          // outlives them, and the next apply has no way to find it except by
+          // namespace. An unload that does not take it out is what left one more
+          // pencil in the bar on every reload (I3, contract §5).
+          releaseInjectedNodes()
         },
         'dsh-edit-turn: per-session controllers',
       )

package/lib/index.js

@@ -18,11 +18,8 @@
 //      tool/result it produced are always shadowed together: no call/result
 //      pair can be left dangling.
 //
-//   2. RE-RUN - `ctx.sessionController.prompt(...)`, the one official prompt
-//      admission path. It resumes the Session when cold and starts exactly one
-//      new turn from the revised text.
 //
-// The silent replacement carrier is an EMPTY `developer/message` (0.2.11;
+// The silent replacement carrier is an EMPTY `developer/message` (0.2.12;
 // before that an empty `system/message`, which no reader accepts - see the
 // README). Empty content projects to no model message, so the rollback adds
 // nothing the model can see and the derived context after an edit is exactly
@@ -60,7 +57,7 @@ export const PLUGIN_ID = 'dsh-edit-turn'
 export const name = PLUGIN_ID
 
 /** Keep in sync with package.json and lib/client.js. */
-export const PLUGIN_VERSION = '0.2.11'
+export const PLUGIN_VERSION = '0.2.14'
 
 // A ring of the last few requests, answering "did the browser half even ask, and
 // what did it get?" without needing its console. Read-only diagnostics: the
@@ -82,7 +79,6 @@ export function recentRequests() {
 const ROUTE_PREFIX = '/dsh-edit-turn'
 const SESSION_ID_RE = /^(session-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
 const MAX_TEXT = 200_000
-const PROMPT_DEADLINE_MS = 30_000
 const FLUSH_DEADLINE_MS = 5_000
 
 /**
@@ -113,12 +109,6 @@ export const Config =
          * step.
          */
         confirm: z.boolean().default(false),
-        /**
-         * Whether saving a revised prompt also runs the turn again. Off by default:
-         * the revision becomes the standing wording and waits for the next message,
-         * so saving costs no model call. Set it to `true` to re-run on save.
-         */
-        rerun: z.boolean().default(false),
       })
 
 // ---------------------------------------------------------------------------
@@ -700,7 +690,7 @@ async function stateOf(ctx, sessionId, config) {
     live: Boolean(live),
     busy: isBusy(events),
     lastSeq: events.length > 0 ? events[events.length - 1].seq : -1,
-    config: { confirm: config.confirm, rerun: config.rerun === true },
+    config: { confirm: config.confirm },
     version: PLUGIN_VERSION,
   }
 }
@@ -907,60 +897,14 @@ async function applyEdit(ctx, sessionId, body, config) {
 
   // The rollback above already did the whole job: the carrier that replaced the
   // window *is* the revised prompt, so the model reads it as the user's wording
-  // from here on and nothing has to be prompted. Saving therefore costs no model
-  // call - which is the point. `rerun: true` restores the older behaviour of
-  // asking the model right away (through the one official prompt path, which also
-  // resumes a cold Session and starts exactly one new turn).
-  if (config.rerun !== true) {
-    return {
-      kind: 'prompt',
-      replacementSeq: replacement.seq,
-      applied: true,
-      reran: false,
-      shadowed: plan.shadowed,
-      ...flush,
-    }
-  }
-
-  const controller = ctx.get('sessionController')
-  if (!controller || typeof controller.prompt !== 'function') {
-    return {
-      kind: 'prompt',
-      replacementSeq: replacement.seq,
-      applied: true,
-      reran: false,
-      rerunError: 'sessionController.prompt unavailable',
-      shadowed: plan.shadowed,
-      ...flush,
-    }
-  }
-  try {
-    await controller.prompt(
-      {
-        requestId: randomUUID(),
-        sessionId,
-        mode: 'queue',
-        content: [{ type: 'text', text }],
-      },
-      AbortSignal.timeout(PROMPT_DEADLINE_MS),
-    )
-  } catch (error) {
-    return {
-      kind: 'prompt',
-      replacementSeq: replacement.seq,
-      applied: true,
-      reran: false,
-      rerunError: String((error && error.message) || error),
-      shadowed: plan.shadowed,
-      ...flush,
-    }
-  }
-
+  // from here on. Saving therefore costs no model call, always: regenerating
+  // the turn is a different operation with a different owner - the sibling
+  // plugin dsh-rerun-turn shadows the turn and regenerates it from the prompt
+  // the surface now shows, then replays what followed. Nothing here prompts.
   return {
     kind: 'prompt',
     replacementSeq: replacement.seq,
     applied: true,
-    reran: true,
     shadowed: plan.shadowed,
     ...flush,
   }
@@ -1027,7 +971,7 @@ function registerTool(ctx) {
           lines.push(`- reply (seq ${reply.seq}, ${reply.attachments} non-text part(s)): ${preview}`)
         }
         if (replies.length > shownReplies.length) lines.push(`(${replies.length - shownReplies.length} earlier reply/replies omitted)`)
-        lines.push('editing a turn re-runs it; editing a reply replaces its text and discards what follows.')
+        lines.push('editing a turn replaces its wording in place (no model call); editing a reply replaces its text and discards what follows. Re-running a turn is dsh-rerun-turn\'s button.')
         return lines.join('\n')
       },
     }),
@@ -1140,7 +1084,6 @@ export function apply(ctx, config) {
         : DEFAULT_MARKER,
     carrier: config && config.carrier === 'user/message' ? 'user/message' : 'system/message',
     confirm: config && typeof config.confirm === 'boolean' ? config.confirm : false,
-    rerun: config && config.rerun === true,
   }
 
   const registerRoutes = (webServer, fiber) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.2.11",
+  "version": "0.2.14",
   "description": "Edit any user turn in DeepSeek Harness and re-run it: an inline editor on the message row rolls the conversation back to just before that turn through the official surface-replace contract, then re-prompts the agent with the revised text. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",
@@ -21,7 +21,6 @@
     "edit",
     "message",
     "turn",
-    "rerun",
     "surface-replace",
     "rollback"
   ],