dsh-edit-turn 0.2.20 → 0.2.21

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,16 +18,17 @@ DSH 的会话日志是 append-only 的事件流：说错的提示词、问偏的
 - 点击后在该消息下方就地展开编辑器，预填原文；
 - 保存后：**只有这一条消息被替换**——旧措辞从模型上下文里消失，改后的内容占住它的位置（因此后续每一轮读到的都是改后的版本）；
 - **它下面的助手回复、以及之后的全部对话，原样保留**，不重跑、不清空；
-- 装了姊妹插件 **dsh-rerun-turn** 时，编辑器里会多一个「**重跑**」：先保存这次修改，再让它用改后的提示词重新生成这一轮（后续轮次逐事件重放回来，不丢）。
+- **模型回答也能这样改**：改写后的回答落在原回答的位置，它后面的轮次**先回退、再逐事件重放回原位**——改一句回答不会把后面的对话丢掉；
+- 装了姊妹插件 **dsh-rerun-turn** 时，编辑器里会多一个「**重跑**」：先保存这次修改，再让它用改后的提示词重新生成这一轮（后续轮次同样逐事件重放回来，不丢）。
 
 ### 特性
 
 - **官方 seam，不改日志** —— 回退 = 追加一条带 `surfaceOp: { op: 'replace', startSeq, endSeq }` 的替换事件。原始事件全部留在会话文件里，只是不再进入 `deriveMessages()`。与官方 `/compact` 用的是同一套契约。
 - **改写内容就是载体本身** —— 提示词编辑落下的是一条 `user/message` 替换事件，内容就是你改后的那句话。它既让模型读到你改后的版本，也在转录里显示成你自己的气泡；平台不会把它当成新输入去回答（这一点踩过坑：**追加**一条 user 消息会触发平台自动回答，越改越多）。
 - **块随消息一起改（0.2.19）** —— 改写一条带图/带文件的消息不再只留文字：**用户没碰过的块原样搬**（逐字节复制，attachmentId、文件名、尺寸一个不改），**删掉的块不写**，**新加的块**经平台的附件服务录用后写进载体。代码里没有任何"这是图片/这是文件"的判断，唯一的判定是"这个块里有文字吗"，所以平台以后加的块类型自动适用。编辑器的非文字块显示成芯片（缩略图或名字 + 大小 + 删除按钮），另有一个「添加附件」入口；服务不在时退回旧行为（只改文字 + 继续显示那条警告）。
-- **窗口最小化** —— 提示词编辑只遮蔽目标那一格（`shadowed = [target.seq]`）；回复编辑才需要"到末尾"的窗口（回答变了，建立在它之上的一切都不再成立），因此助手消息（内含 tool_use）与它产生的 tool/result 永远一起走，**不可能留下悬空的调用/结果对**。
+- **窗口最小化 + 尾部重放** —— 提示词编辑只遮蔽目标那一格（`shadowed = [target.seq]`）；回复编辑因为新回答只能 append，窗口必须到末尾，**但被遮蔽的后续轮次不会消失**：它们会带着新 turn 号、新 messageId、原内容和 replay 标记逐事件重放回来（与 `dsh-rerun-turn` 的 infix splice 是同一套写法，两个仓库的 replay 输出有逐字段对照测试）。助手消息（内含 tool_use）与它产生的 tool/result 永远一起走，**不可能留下悬空的调用/结果对**。
 - **保存永不调用模型** —— 保存只写上下文，不产生任何模型调用。"改完立刻重答"是另一件事，交给姊妹插件 **dsh-rerun-turn**（它遮蔽该轮、用表面上的提示词重新生成、再把后续轮次逐事件重放回来）；本插件只在它装着时提供一个「重跑」按钮转发过去。
-- **模型回答也能编辑** —— 回答无法被"替换"：官方格式禁止 `assistant/message` 携带 `sourceEventSeqs`（已在真实校验器上验证）。做法是回退该回答及其后的内容，再**追加**一条带改写文本的助手消息——模型会把改写后的内容当成自己说过的话，对话可以继续。`source.editedBy` 会如实记录这段文字由插件写入。
+- **模型回答也能编辑** —— 回答无法被"替换"：官方格式禁止 `assistant/message` 携带 `sourceEventSeqs`（已在真实校验器上验证）。做法是回退该回答及其后的内容，**追加**一条带改写文本的助手消息，再把回退掉的后续轮次**逐事件重放**在它后面——模型读到的是「前缀 + 改写后的回答 + 原来的后续轮次」，对话可以继续。`source.editedBy` 记录改写文字由插件写入，重放事件另带 `replayBy` / `replayId` / `originalSeq`。
 - **改过的那条还能再改** —— 它仍然显示在原来的位置（由插件渲染成气泡），悬停就有编辑按钮。
 - **一次点击即执行** —— 保存后不再有二次确认（`confirm: true` 可恢复两步确认，确认步里会写明这次保存会丢弃什么）。编辑器本身已经是用户主动打开的动作，保存的后果在 README 与确认步里说明，输入框本身保持干净。
 - **中英双语 UI**，跟随 DSH 当前语言。
@@ -59,7 +60,7 @@ dsh plugin --profile web add /path/to/dsh-edit-turn
 编辑器里，消息带的图片与文件**各显示成一个芯片**（缩略图或文件名 + 大小 + 删除按钮）：不碰就原样保留，点删除就是不要它了；旁边还有一个「**添加附件**」（这条消息本来没有附件时也能用）。缩略图由本插件的只读路由按需取回；取不回来、或那些字节不是图片，芯片退回显示名字。**只有当这个部署没有附件存储时**，编辑器才会改回旧的那句话——「这条消息包含图片或文件附件，改写会丢弃它们，只保留文字」——并且不出现添加入口。
 **一字不改就按保存，什么都不会发生。** 编辑器预填的就是这条消息**现在**的文本，所以「打开编辑器、不输入、直接保存」等于没提出任何修改：宿主不写任何事件（不落替换、不开合成轮次、不追加回答），编辑器照常关闭、**一条提示都不显示**（0.2.20 起；这条提示此前压在输入框的占位文字上）。会话日志、轮次导轨、轨迹视图都保持原样——此前它照样落一条替换（一次会话里三条），改回答时还会多出一整个轮次（用户只发了两条消息，轨迹视图里却有四轮）。**「重跑」不受这条守卫影响**：文本没变但用户点的是「重跑」，宿主同样不写，重跑照常发起（用户的意图就是让这一轮重新生成）。
 
-**编辑模型的回答**：悬停任意一条模型回复，同样会出现编辑入口。改完点「保存」——这条回答被替换为你写的内容，它之后的内容一并移除，模型从此把你写的内容当成自己说过的话，对话可以继续下去。
+**编辑模型的回答**：悬停任意一条模型回复，同样会出现编辑入口。改完点「保存」——这条回答被替换为你写的内容；它后面的轮次先从上下文里回退，再逐事件重放回原位（新 turn 号、新 messageId、原内容），顺序与原来一致，模型从此把你写的内容当成自己说过的话，对话可以继续下去。
 
 注意：回答里的**工具调用与思考过程**无法保留（替换后只留文字，编辑器会提示），因为工具调用的结果已经不再成立。
 
@@ -82,7 +83,7 @@ dsh plugin --profile web add /path/to/dsh-edit-turn
 一次编辑就是**一条官方替换事件**。读事件流（`sessionQuery.readSession`，回退到活动会话的 `snapshotEvents()`），用官方折叠规则算出当前 surface 顺序，定位目标消息的节点，然后：
 
 - 提示词编辑：窗口 = **仅那一格**（`[target.seq]`），载体就是改后的文本；
-- 回复编辑：窗口 = `surface[目标下标 .. 末尾]`（回答变了，建立在它之上的一切都不再成立）；先在日志里**开一个新轮次**（`turn/start` + `step/start`），载体是空 `developer/message`（空内容不投影给模型），随后把改写文本作为一条助手消息追加进这个轮次，再 `step/end` + `turn/end` 收尾。
+- 回复编辑：窗口 = `surface[目标下标 .. 末尾]`（修正回答只能 append，所以窗口必须到末尾）；先在日志里**开一个新轮次**（`turn/start` + `step/start`），载体是空 `developer/message`（空内容不投影给模型），随后把改写文本作为一条助手消息追加进这个轮次，再 `step/end` + `turn/end` 收尾；最后用 `buildReplayWrites` 把窗口里**后续轮次**的 surface 事件逐条重放回来（新 turn 号、新 messageId、`replayBy` / `replayId` / `originalSeq` 标记）。重放规则与 `dsh-rerun-turn` 共用一套：tool call 与 result 必须成对、没等到结果的调用连同它的广告一起丢、`TOOL_NOT_STARTED` 修复保持不带 `sourceEventSeqs`、system / developer / 静默载体 / 日志-only 记录一律跳过。
 
 追加一条：
 
@@ -94,7 +95,7 @@ session.append('developer/message', { turn, step, message: { role: 'developer',
 })
 ```
 
-落盘后等一次持久化检查点（`sessions.flush`），保证重启也能看到。
+落盘后等一次持久化检查点（`sessions.flush`），保证重启也能看到。回复编辑的这条重放**不调模型**：它只是把已经记录的事件以新身份再 append 一遍，所以保存仍然是"一次点击、零模型调用"。
 
 **重跑不由本插件做。** "改完立刻重答"是姊妹插件 `dsh-rerun-turn` 的操作：它遮蔽该轮、用表面现在显示的提示词（也就是你改后的文本）重新生成，再把后续轮次逐事件重放回来。本插件只负责把编辑落地；编辑器里的「重跑」按钮仅在检测到它挂载时出现，点击后先保存、再调用它的 `POST /dsh-rerun-turn/apply`。它不在（例如桌面版没装）时，没有这个按钮。
 
@@ -132,14 +133,14 @@ session.append('developer/message', { turn, step, message: { role: 'developer',
 
 ### 验证状态
 
-本插件在 DSH `0.1.6-alpha.2` 与 `0.1.7-rc.1` 上完成以下验证：
+本插件在 DSH `0.2.1-rc.2`（真实校验器与真实会话）以及 `0.1.6-alpha.2` / `0.1.7-rc.1` 上完成以下验证：
 
 | 验证 | 命令 | 结果 |
 |---|---|---|
 | 运行中的实例是否真的挂载了本插件（只读路由守卫探针，无需 token） | `npm run probe:loaded [端口]` | 通过：`/state` 返 400、`/apply` 返 405 —— 这两个状态码只有本插件会返回 |
 | 浏览器半部到底问了什么、拿回了什么（只读诊断，含失败记录） | `GET /dsh-edit-turn/debug` | 通过：真实浏览器里确认客户端确实拿到 replies；并复现了旧 v3 会话的 session-not-found |
-| 官方 append **与读取**契约（真实校验器，进程内） | `npm run verify:contract` | 80 项通过（每段写入后都用加载器重读整份日志）：替换事件被接受、派生历史真的收缩、日志 append-only、工具结果与调用同进同退、空 developer 载体不产生模型消息、**连续两次回退都被接受**、**编辑模型回答的完整机制被接受**、**跨插件依赖的不变量（单节点窗口 / 同事件类型 / 全窗口 sourceEventSeqs / 每个替换都带 `editedBy` 标记 / 改写后的 `source.kind` 不是 `user` / 修正回复不带 `sourceEventSeqs`）** |
-| 纯逻辑 + 宿主集成 + 客户端 DOM 行为（真 HTTP、真校验器、桩服务、DOM 桩） | `npm test` | 182 项通过（含「文本没变 → 不写」的四条，以及块随消息一起改的 35 条：未动的块逐字节保留、删块少一块、文字位置不变、no-op 语义升级、附件服务缺失时降级且不写坏数据、自定义 `quote-card` 块的通用性、录用与拒绝、`/state` 的块描述与能力、附件字节路由、编辑器芯片/删除/添加/缩略图/降级警告） |
+| 官方 append **与读取**契约（真实校验器，进程内） | `npm run verify:contract` | 85 项通过（每段写入后都用加载器重读整份日志）：替换事件被接受、派生历史真的收缩、日志 append-only、工具结果与调用同进同退、空 developer 载体不产生模型消息、**连续两次回退都被接受**、**编辑模型回答的完整机制被接受**、**回复编辑后的尾部重放（后续提问/回答/tool 调用与结果按新 turn 号回到修正回答之后，顺序正确、日志仍可加载）**、**跨插件依赖的不变量（单节点窗口 / 同事件类型 / 全窗口 sourceEventSeqs / 每个替换都带 `editedBy` 标记 / 改写后的 `source.kind` 不是 `user` / 修正回复不带 `sourceEventSeqs`）** |
+| 纯逻辑 + 宿主集成 + 客户端 DOM 行为（真 HTTP、真校验器、桩服务、DOM 桩） | `npm test` | 188 项通过（含回复编辑的尾部重放用例：窗口/重放区间、新 turn 号与新 messageId、tool 调用与结果成对重映射、上一轮修正可再次编辑，以及与 `dsh-rerun-turn` builder 的逐字段对照；另含「文本没变 → 不写」的四条，以及块随消息一起改的 35 条：未动的块逐字节保留、删块少一块、文字位置不变、no-op 语义升级、附件服务缺失时降级且不写坏数据、自定义 `quote-card` 块的通用性、录用与拒绝、`/state` 的块描述与能力、附件字节路由、编辑器芯片/删除/添加/缩略图/降级警告） |
 | 客户端半部静态检查（注册、i18n 完整性、样式、皮肤可读性、版本三处同步、线协议、块契约） | `npm run verify:client` | 184 项全部通过（含 12 条新的块契约检查：能力上报、服务现场探测、录用是唯一建块路径、录用先于 append、**两侧都不特判块类型**、块逐字节复制、文字归位、`dropped` 上报、只在无服务时警告、芯片靠 `error` 事件自证） |
 | 实机前端产物校验（运行中的 DSH 是否在下发当前代码） | `npm run verify:live -- --token-file ~/path/to/dsh.log` | 全部通过（含**宿主节点形状锚点**） |
 | **真实浏览器渲染冒烟**（CDP 驱动已开着的标签页，只读） | `npm run verify:ui` | 全部通过：下发的字节就是刚改的字节、无槽位崩溃留下的空占位、回复铅笔在平台动作条里、被回滚的行保住动作条、**被回滚的用户行一定显示替代文本（消息不会凭空消失）**、**替代气泡一定排在时间/复制之上（顺序与正常消息一致）**、**改写后那颗铅笔一定在还活着的动作条末尾（已在原始会话、切走的会话、切回后三处现场确认）**、**回复铅笔一定排在动作条最左（复制之前，已现场确认）**、气泡上没有 `.dshet-floating` 压着文字、切走再切回入口仍在 |
@@ -225,6 +226,18 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
+**0.2.21** —— 回复编辑改成 infix splice：改一条中间的回答，后面的轮次不再被丢掉，而是重放回来（与 `dsh-rerun-turn` 同一套逻辑）。
+
+- **为什么要改**：0.2.20 的回复编辑是「从这条回答到末尾」的整段回退——改第一条回答，第 2、3 轮就一起消失。所谓「任意位置编辑」此前只对用户消息成立；用户消息的改写本身就在原位，不需要重放。
+- **改法**（宿主半侧）：
+  1. `planRollback` 的回复窗口仍到末尾（修正回答只能 append，尾部必须先离开 surface），但额外算出 `replayFrom`（目标轮之后的下一个 `turn/start` 括号）与 `logTo`（窗口最后一个轮的 `turn/end`）；
+  2. 新增 `buildReplayWrites`：把窗口里后续轮次的 surface 事件按新 turn 号、新 messageId 重放回去，并打 `replayBy` / `replayId` / `originalSeq` 标记。规则与 rerun 完全一致：tool call 与 result 成对、没等到结果的调用连同广告丢掉、`TOOL_NOT_STARTED` 修复保持不带 `sourceEventSeqs`、system/developer/静默载体与日志-only 记录一律跳过；`test/replay-parity.test.js` 把两个仓库的 builder 放在同一份日志上逐字段比对（sibling 不在时 skip）；
+  3. `applyEdit` 在「开轮 → 空载体替换窗口 → 追加修正回答 → 收尾」之后同步重放，并把活循环的轮次计数器推到重放出来的最高轮号；整批只在最后 flush 一次，避免留下「影子已持久化、修正却不在」的中间态；
+  4. 派生顺序变成「前缀 + 改写后的回答 + 原来的后续轮次」，日志仍然 append-only。
+- **测试**：`npm test` **189/189**、`npm run verify:contract` **85** 项、`npm run verify:client` **184** 项全绿；真实 `Session` 校验器上新增「改第一轮回答 → 后续轮次的提问、回答、tool call/result 全部重放回来且顺序正确、日志仍可加载」的用例；宿主集成测试改成断言重放标记与轮次号，并新增「改三段会话中间那一轮的回复，前后两轮都还在」；与 `dsh-rerun-turn` 的 `buildReplayWrites` 有逐字段对照测试。
+- **真实会话验证**（只读、不写盘）：在本机 4 个多轮会话上把整条 apply 路径跑在内存副本里——最多 11,013 个事件 / 130 轮，重放 687 条写入，全部被真实校验器接受、重新加载通过，改后的派生顺序是「前缀 + 改写回答 + 后续轮次」。
+- **诚实说明**：重放是同步 append（不调模型，毫秒级），没有 rerun 那套跨分钟的后台恢复流程；如果中途某条写入被校验器拒绝，响应会带 `replay.error` 与已写入条数，已经落地的副本保留，不会回滚成「什么都没有」。
+
 **0.2.20** —— 删掉「原样保存」时那条提示。只改提示，行为不变。
 
 - **症状**：一字不改按保存，宿主本来就不写任何事件（0.2.18 的守卫），但客户端还会弹一条「内容没有变化，未做任何修改。」——而它在真机上是**压在输入框的占位文字上**渲染的（截图可见重叠）。这条提示既没有信息量（用户刚做的动作就是"什么都没做"），位置也不对。
@@ -415,7 +428,7 @@ This plugin adds it:
 - clicking it opens an in-place editor below that message, pre-filled with the original text;
 - 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;
+- model replies are editable too: the corrected answer is appended as a fresh reply and **everything that followed is replayed back behind it** - event by event, with fresh turn numbers and message ids - so a reply edit never drops the rest of the conversation;
 - 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
@@ -423,11 +436,11 @@ This plugin adds it:
 - **Official seam, log untouched.** A rollback appends one replacement event carrying `surfaceOp: { op: 'replace', startSeq, endSeq }`. Every original event stays in the session file; it simply stops entering `deriveMessages()`. This is the same contract `/compact` uses.
 - **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).
 - **A revised message carries every block it carried (0.2.19).** A block the user did not touch is copied verbatim (a structured clone of the original block object: attachment ids, names, sizes and every field a later platform adds), a block they removed is not written, and a newly picked payload is admitted through the platform's attachment store before anything is appended. Nothing in the module names a block type - the only block test is "does this block carry text" - so a block kind the platform adds later works with no change here. The editor draws one chip per non-text block (a thumbnail when its bytes are reachable, otherwise its name and size, plus a remove button) and offers an "Add an attachment" entry; with no store mounted it falls back to the old warning and no picker.
-- **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.
+- **The smallest window that is correct, with a faithful replay.** A prompt edit shadows exactly one node (`shadowed = [target.seq]`); a reply edit shadows the reply through the end of the surface (a correction can only be appended, so the tail must leave first), and then replays every later turn back behind the correction with fresh turn numbers, fresh message ids and a `replayBy` / `replayId` / `originalSeq` marker. The walk is the same one `dsh-rerun-turn` performs after a rerun, and a parity test compares the two builders write for write. An assistant message (carrying its own tool_use blocks) and the tool/result it produced always leave together, so 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.
 - **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.
 - **A save that changes nothing writes nothing** (0.2.18). The layer that decides what to write compares the draft with the live text **verbatim**, through the same parse the editor was prefilled from (`readMessageText`, the one behind `/state`’s `turns[].text`), and answers `unchanged: true` before appending anything: no replacement event, no synthetic turn, no appended answer, no loop-counter sync. The flag is not a refusal - the route still answers 200, and the editor still starts the re-run when that was the button the user pressed. Nothing is announced for it either (0.2.20 removed the notice this used to draw): the editor closes like any save, and the screen is exactly as it was.
-- **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.
+- **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 correction is **appended** as a fresh reply - the model goes on treating it as its own - and the turns the rollback took leave the surface only to be **replayed** back behind it, in order, as fresh copies. `source.editedBy` records honestly that the plugin wrote those words; each replay event carries `replayBy`, `replayId` and `originalSeq`.
 - **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.
 - **Skin-friendly** - the editor paints its own opaque surface (`--dshet-panel`) instead of borrowing the theme's surface colours. A skin exists to make surfaces translucent so its artwork shows through, and it only compensates for *its own* elements; a plugin's class names are not on that list, so a panel that borrows those variables can end up fully transparent with text sitting straight on the art. The dark branch uses the official `body[data-ds-dark-theme]` hook (the same one `dsh-client-ui-theme` and several official UI packages use) and blends in with `backdrop-filter`.
@@ -579,7 +592,7 @@ The transcript only builds rows for **append surface events** (ui-chat's user an
 2. **The replacement event has the type of the target**: a `user/message` edit lands a `user/message` (a reply cannot be swapped in place — see 5);
 3. **`sourceEventSeqs` always lists the whole window**: the official validator demands complete coverage; one missing node and the append is refused;
 4. **Every replacement carries the semantic marker**: `source.editedBy === 'dsh-edit-turn'` — including the empty text-free `developer/message` carrier, so siblings can recognise rewrites by `editedBy` alone instead of inferring from the window shape;
-5. **A reply edit is a multi-node rollback plus an appended correction**, not an in-place swap: the old reply row keeping no entry is **by design** (the new row carries it). Do not add `sourceEventSeqs` to an `assistant/message` to keep the old row's entry — the official validator refuses it outright;
+5. **A reply edit is a multi-node rollback, an appended correction, and a replay of the tail**, not an in-place swap: the old reply row keeping no entry is **by design** (the new row carries it), and everything after it is re-appended with fresh identities and a replay marker. Do not add `sourceEventSeqs` to an `assistant/message` to keep the old row's entry — the official validator refuses it outright;
 6. **The block list is an optional, forward-compatible parameter**: `POST /apply` accepts `parts` (`[{ keep } | { add }]`), and **omitting it is exactly the 0.2.18 behaviour** (a text-only carrier), with the response's `dropped` stating whether that save left non-text blocks behind. `GET /state` answers `capabilities: { attachments, preview }` for what this deployment can admit and read, and `turns[].blocks` describes each block as `{ index, type, name?, mediaType?, bytes?, width?, height?, preview }` - read by field presence, never by type, so a sibling can do the same and a block kind the platform adds later needs no change anywhere;
 7. **The mapping is published**: `revisions[]` on `GET /dsh-edit-turn/state` gives `{ replacementSeq, startSeq, endSeq, shadowed }` (the field names the `POST /apply` response already used), and `hidden[]` lists `{ seq, turn, replacement }` per shadowed row. No sibling has to re-derive the ledger from the event stream.
 

package/lib/client.js

@@ -42,7 +42,7 @@ window.__ModuleLoader__.load({
     const RERUN_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.2.20'
+    const PLUGIN_VERSION = '0.2.21'
 
     // --- copy -----------------------------------------------------------------
 
@@ -59,7 +59,7 @@ window.__ModuleLoader__.load({
       'action.copied': '复制成功',
       'editor.title': '编辑这条消息',
       'editor.title-reply': '编辑这条回答',
-      'editor.placeholder': '改成你希望自己当时说的内容。保存后这条消息之后的轮次会从模型上下文中移除，改后的内容成为新的起点。',
+      'editor.placeholder': '改成你希望自己当时说的内容。保存后就地替换这条消息，后面的对话保持不变。',
       'editor.placeholder-reply': '改成你希望模型说过的内容，保存后它就成为这条回答。',
       'editor.save': '保存',
       'editor.rerun': '重跑',
@@ -71,7 +71,7 @@ window.__ModuleLoader__.load({
       'editor.warn-reply': '这条回答包含工具调用或思考过程，替换后它们会被一并移除。',
       'editor.attach.add': '添加附件',
       'editor.attach.remove': '移除这个附件',
-      'confirm.body': '确认后会立即执行：这条消息之后的内容会从模型上下文中移除。原始会话日志不会改写。',
+      'confirm.body': '确认后会立即执行：只有这条消息被替换，后面的对话保持不变。原始会话日志不会改写。',
       'error.invalid': '请求无效，请刷新后重试。',
       'error.session-not-active': '这个会话当前未激活，请先打开该会话再编辑。',
       'error.session-not-found': '找不到该会话的日志。',
@@ -96,6 +96,7 @@ window.__ModuleLoader__.load({
       'error.attachment-unreadable': '这个附件读不出来，请换一个文件。',
       'error.attachment-too-large': '这个文件太大，无法作为附件。',
       'error.too-large': '这次修改太大，服务器没有接收。',
+      'error.replay-partial': '已保存并改写了这条回答，但后面的轮次没能全部重放回来，请重新打开会话确认。',
     }
 
     const en = {
@@ -106,7 +107,7 @@ window.__ModuleLoader__.load({
       'action.copied': 'Copied',
       'editor.title': 'Edit this message',
       'editor.title-reply': 'Edit this reply',
-      'editor.placeholder': 'Saving rolls the conversation back to just before this message and this turn runs again.',
+      'editor.placeholder': 'Write what you want to have said. Saving replaces this message in place; the conversation after it stays as it is.',
       'editor.placeholder-reply': 'Write what you want the model to have said; saving makes it this reply.',
       'editor.save': 'Save',
       'editor.rerun': 'Re-run',
@@ -118,7 +119,7 @@ window.__ModuleLoader__.load({
       'editor.warn-reply': 'This reply carries tool calls or reasoning; replacing it removes them.',
       'editor.attach.add': 'Add an attachment',
       'editor.attach.remove': 'Remove this attachment',
-      'confirm.body': 'Confirming applies right away: everything after this message leaves the model context. The original session log is never rewritten.',
+      'confirm.body': 'Confirming applies right away: only this message is replaced; the conversation after it stays as it is. The original session log is never rewritten.',
       'error.invalid': 'Invalid request; refresh and try again.',
       'error.session-not-active': 'This session is not open in DSH; open it first.',
       'error.session-not-found': 'No session log was found for this id.',
@@ -143,6 +144,7 @@ window.__ModuleLoader__.load({
       'error.attachment-unreadable': 'That attachment could not be read; try another file.',
       'error.attachment-too-large': 'That file is too large to attach.',
       'error.too-large': 'That revision was too large for the host to accept.',
+      'error.replay-partial': 'Saved and corrected, but the turns after it could not all be replayed; reopen the session to check.',
     }
 
     // Every error code the host can return travels through here. A code is
@@ -775,6 +777,11 @@ window.__ModuleLoader__.load({
             // the only place the user can still be told (see applyEdit's
             // `dropped`).
             if (data.kind !== 'reply' && data.applied === true && data.dropped === true) this.notify('attachments-dropped')
+            // The correction landed, but replaying the turns behind it did not:
+            // the editor is already gone, so this is the only place left to say
+            // that the tail is missing from the context instead of silently
+            // hiding rows the user still expects.
+            if (data.applied === true && data.replay && data.replay.error) this.notify('replay-partial')
           }
           // Save first, re-run second - always: the sibling re-runs the turn
           // from the prompt the surface NOW shows, so the revised wording has

package/lib/index.js

@@ -69,7 +69,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.20'
+export const PLUGIN_VERSION = '0.2.21'
 
 // 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
@@ -237,6 +237,44 @@ export function turnIndex(events) {
   return turnOf
 }
 
+/**
+ * One turn bracket: its number, log range, first prompt and reply count.
+ *
+ * A turn NUMBER is not unique in a log - a replay reuses numbers on fresh
+ * brackets - so planning must locate the bracket that CONTAINS an event rather
+ * than the first bracket carrying its number (the same rule dsh-rerun-turn
+ * learned in 0.1.23; this is the same walk).
+ *
+ * @param events - complete contiguous raw event log.
+ * @returns one entry per `turn/start`, in log order.
+ */
+export function turnSpans(events) {
+  const spans = []
+  let open = null
+  for (const event of events) {
+    if (event.type === 'turn/start') {
+      open = {
+        turn: event.data && event.data.turn,
+        startSeq: event.seq,
+        endSeq: null,
+        promptSeq: null,
+        replies: 0,
+      }
+      spans.push(open)
+      continue
+    }
+    if (open === null) continue
+    if (event.type === 'turn/end') {
+      open.endSeq = event.seq
+      open = null
+      continue
+    }
+    if (event.type === 'user/message' && open.promptSeq === null) open.promptSeq = event.seq
+    if (event.type === 'assistant/message') open.replies += 1
+  }
+  return spans
+}
+
 /** The turn still awaiting its `turn/end`, or null when every turn closed. */
 export function openTurn(events) {
   let open = null
@@ -710,18 +748,24 @@ function resolveTarget(events, request) {
 }
 
 /**
- * Turn one UI target into the canonical rollback window.
+ * Turn one UI target into the canonical rollback window plus, for a reply, the
+ * replay range that puts the later turns back after the correction.
  *
- * The window is `[the addressed prompt .. the last surface node]`: the complete
- * remainder of the conversation in surface order. It is contiguous by
- * construction, it always ends on a completed turn's last node, and its left
- * edge is exactly the prompt being rewritten, so the surviving prefix ends on
- * the previous turn's boundary.
+ * A revised PROMPT is replaced in place: its window is the message alone, so
+ * the reply under it and everything after stay exactly where they were.
+ *
+ * A revised REPLY cannot be swapped in place - the format refuses
+ * `sourceEventSeqs` on an `assistant/message`, so a new reply can only be
+ * APPENDED. The window therefore runs from the addressed reply to the last
+ * surface node, and the correction is appended in a fresh turn. Everything the
+ * window took is replayed back behind the correction by
+ * {@link buildReplayWrites}: the same infix splice dsh-rerun-turn performs, with
+ * the user's text instead of a regenerated answer.
  *
  * @param events - complete contiguous raw event log.
  * @param surfaceNodes - current surface seqs in model order.
  * @param request - `{ seq?, messageId?, turn? }` (`turn` addresses a prompt only).
- * @returns `{ targetSeq, messageId, startSeq, endSeq, shadowed, mode, turn, step, provider, model, original, attachments }`.
+ * @returns `{ targetSeq, messageId, startSeq, endSeq, shadowed, mode, turn, step, provider, model, original, attachments, replayFrom, logTo, turnStart, turnEnd }`.
  * @throws {EditPlanError} with a stable code when the target cannot be planned.
  */
 export function planRollback(events, surfaceNodes, request) {
@@ -737,7 +781,8 @@ export function planRollback(events, surfaceNodes, request) {
     throw new EditPlanError('not-editable', 'the system prompt head cannot be edited')
   }
   // Two editable kinds. A prompt is rewritten in place and the conversation
-  // continues; a reply is replaced and everything built on it goes with it.
+  // continues; a reply is replaced by an appended correction and the tail is
+  // replayed behind it.
   const mode = isHumanPrompt(target) ? 'prompt' : isAssistantReply(target) ? 'reply' : null
   if (mode === null) {
     throw new EditPlanError('not-editable', 'only your own messages and the model replies can be edited')
@@ -746,14 +791,54 @@ export function planRollback(events, surfaceNodes, request) {
   // Two different windows, because the two edits mean different things.
   //
   // A revised PROMPT is replaced in place: only the message itself leaves the
-  // surface, so the reply under it and everything after stay exactly as they
-  // were - edit the wording, keep the conversation. A revised REPLY cannot do
-  // that (an answer invalidates whatever was built on it), so its window runs to
-  // the tail and the turn is closed again behind the correction.
+  // surface, so the reply under it and everything after stay exactly where they
+  // were - edit the wording, keep the conversation.
+  //
+  // A revised REPLY cannot be a replacement carrier (the format refuses
+  // `sourceEventSeqs` on an assistant message), so the correction is appended
+  // at the tail and everything from the addressed reply to the end must leave
+  // the surface first. `buildReplayWrites` then puts every later turn back,
+  // event by event, with fresh turn numbers and message ids - the model reads
+  // prefix + corrected reply + the same later turns, in order.
   const shadowed = mode === 'prompt' ? [target.seq] : surfaceNodes.slice(startIdx)
   if (shadowed.length === 0 || shadowed[0] !== target.seq) {
     throw new EditPlanError('not-editable', 'the target does not open a rollback window')
   }
+  // The replay range: the log range the shadow covers, and the bracket where
+  // the later turns start. A reply in the last turn has neither, and the edit
+  // degenerates to the old tail-less rollback (there is nothing to replay).
+  let replayFrom = null
+  let logTo = null
+  let turnStart = null
+  let turnEnd = null
+  if (mode === 'reply') {
+    const spans = turnSpans(events)
+    // A closed bracket that CONTAINS the reply. The fallback (the last bracket
+    // that starts before it) only matters for a malformed log with a bracket
+    // that never closed; a valid log always takes the containment branch.
+    const owning = spans.find(
+      (entry) => entry.endSeq !== null && entry.startSeq <= target.seq && target.seq <= entry.endSeq,
+    ) ?? spans.filter((entry) => entry.startSeq <= target.seq).at(-1)
+    if (owning !== undefined) {
+      turnStart = owning.startSeq
+      turnEnd = owning.endSeq
+    }
+    const lastShadowed = shadowed[shadowed.length - 1]
+    const bySeq = new Map(events.map((event) => [event.seq, event]))
+    logTo = lastShadowed
+    for (let seq = lastShadowed + 1; ; seq += 1) {
+      const event = bySeq.get(seq)
+      if (event === undefined) break
+      // The window already ends on the last surface node: only log-only events
+      // (step/turn closing records) can follow it.
+      if (isSurfaceEvent(event)) break
+      logTo = seq
+      if (event.type === 'turn/end') break
+    }
+    const owningIndex = owning === undefined ? -1 : spans.indexOf(owning)
+    const nextSpan = owningIndex >= 0 ? spans[owningIndex + 1] : undefined
+    if (nextSpan !== undefined && nextSpan.startSeq <= logTo) replayFrom = nextSpan.startSeq
+  }
   const { text, attachments } = readMessageText(target)
   // The blocks themselves travel with the plan: the carrier is rebuilt from
   // them, so no caller has to re-read the message to know what it carries.
@@ -778,7 +863,293 @@ export function planRollback(events, surfaceNodes, request) {
     original: text,
     attachments,
     blocks,
+    // Reply-only replay range. `replayFrom` is the next turn's bracket (null when
+    // the edited reply is in the last turn); `logTo` is the end of the last turn
+    // the window shadowed. Both are computed from the ORIGINAL log and stay valid
+    // while the correction is appended after it.
+    replayFrom,
+    logTo,
+    turnStart,
+    turnEnd,
+  }
+}
+
+// --- reply replay -----------------------------------------------------------
+//
+// A reply edit lands exactly like a rerun's infix splice: the shadow takes the
+// old answer and every later turn off the surface, the correction is appended in
+// a fresh turn, and this walk puts the later turns back as fresh copies. The
+// algorithm is the one dsh-rerun-turn ships (`buildReplayWrites` there); keep the
+// two in step - `test/replay-parity.test.js` compares their output on one log
+// when the sibling repository is checked out.
+
+/** Marker written into every replayed event's source. */
+export const REPLAY_MARKER = PLUGIN_ID
+
+/** Text that carries nothing a model could read (spaces, zero-width glue). */
+const INVISIBLE_TEXT_RE = /^[\s\u200b-\u200f\u2060\ufeff]*$/
+
+/**
+ * Whether content blocks carry anything readable.
+ * @param content - the `content` array of a message.
+ * @returns true when at least one block is not invisible text.
+ */
+export function hasReadableContent(content) {
+  if (!Array.isArray(content)) return false
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue
+    if (block.type !== 'text') return true
+    if (typeof block.text !== 'string' || !INVISIBLE_TEXT_RE.test(block.text)) return true
+  }
+  return false
+}
+
+/**
+ * Whether an event is a plugin's silent surface carrier rather than conversation.
+ *
+ * `dsh-delete-turn` writes one for a deletion and `dsh-rerun-turn` for a rerun's
+ * shadow - a `user/message` whose source kind is `plugin:<id>` and whose content
+ * is empty or invisible. A replay must retire it without a copy: it projects to
+ * no model message, so copying it would resurrect an empty user node.
+ *
+ * A rewritten prompt is NOT this shape: `dsh-edit-turn` keeps `kind: 'user'` and
+ * carries the user's wording, so it stays a real prompt and is copied.
+ *
+ * @param event - raw session event.
+ * @returns true for a text-free plugin replacement.
+ */
+export function isSilentPluginCarrier(event) {
+  if (!event || event.type !== 'user/message') return false
+  const data = event.data || {}
+  const source = data.source
+  if (!source || typeof source.kind !== 'string' || !source.kind.startsWith('plugin:')) return false
+  return !hasReadableContent(data.content)
+}
+
+/** Stamp one copied event's source with this plugin's replay markers. */
+function replaySource(source, replayId, originalSeq) {
+  return {
+    ...(source && typeof source === 'object' ? source : {}),
+    replayBy: REPLAY_MARKER,
+    replayId,
+    originalSeq,
+  }
+}
+
+/**
+ * Build the replay writes for a reply edit's shadowed tail.
+ *
+ * Every shadowed event after the edited reply is copied verbatim except for:
+ * fresh turn numbers (the log requires them contiguous), fresh message ids,
+ * remapped `sourceEventSeqs` on tool results, dropped usage numbers and embedded
+ * streams, and the replay marker in each message source. System, developer and
+ * every log-only record are skipped: they describe the original run, not the
+ * conversation.
+ *
+ * Tool calls are copied only as complete pairs. A call whose result never landed
+ * (an interrupted turn) is dropped along with its advertisement in the copied
+ * assistant content, because the format refuses a turn that closes with an
+ * unresolved call. The inverse repair shape - a `TOOL_NOT_STARTED` result with no
+ * call event - is copied as-is and keeps its absent `sourceEventSeqs`: the
+ * validator accepts that repair only without one.
+ *
+ * @param events - complete contiguous raw event log (the pre-edit snapshot).
+ * @param plan - the planned window (`shadowed`, `replayFrom`, `logTo`).
+ * @param baseTurn - the first fresh turn number the replay may use.
+ * @param replayId - the operation identity recorded on every copy.
+ * @param startSeq - the seq the first write will land at (writes are appended
+ *   back to back, so each predicted seq is `startSeq` + its offset).
+ * @param promptCopied - parity with dsh-rerun-turn's builder: when true, the
+ *   plan's `promptSeq` is replayed too. A reply edit never shadows the prompt,
+ *   so its own plans leave this false.
+ * @returns an ordered `{ type, data, surfaceOp?, sourceEventSeqs? }` write list.
+ */
+export function buildReplayWrites(events, plan, baseTurn, replayId, startSeq, promptCopied = false) {
+  const shadowedSet = new Set(plan.shadowed)
+  const bySeq = new Map(events.map((event) => [event.seq, event]))
+  const turnOf = turnIndex(events)
+  const shadowedTurns = new Set()
+  for (const seq of plan.shadowed) {
+    const turn = turnOf.get(seq)
+    if (typeof turn === 'number') shadowedTurns.add(turn)
+  }
+  const included = (event) => {
+    if (isSurfaceEvent(event)) return shadowedSet.has(event.seq)
+    if (
+      event.type === 'turn/start' ||
+      event.type === 'turn/end' ||
+      event.type === 'step/start' ||
+      event.type === 'step/end' ||
+      event.type === 'tool/call'
+    ) {
+      return typeof event.data.turn === 'number' && shadowedTurns.has(event.data.turn)
+    }
+    return false
+  }
+  const range = []
+  // `replayFrom` is this plugin's plan field; `logFrom` is the name the sibling
+  // builder uses, accepted here so the parity test can feed one plan object.
+  const walkFrom = typeof plan.replayFrom === 'number' ? plan.replayFrom : plan.logFrom
+  for (let seq = walkFrom; seq <= plan.logTo; seq += 1) {
+    const event = bySeq.get(seq)
+    if (event === undefined) continue
+    if (included(event)) range.push(event)
+  }
+  // Tool pairing facts for the whole range, so assistant content can be
+  // corrected before anything is written.
+  const calledIds = new Set()
+  const resultIds = new Set()
+  const repairIds = new Set()
+  for (const event of range) {
+    if (event.type === 'tool/call') calledIds.add(event.data.callId)
+    else if (event.type === 'tool/result') {
+      resultIds.add(event.data.message && event.data.message.source ? event.data.message.source.callId : event.data.callId)
+      const error = event.data.error
+      if (error && error.name === 'ToolNotStartedError' && error.code === 'TOOL_NOT_STARTED' && event.sourceEventSeqs === undefined) {
+        repairIds.add(event.data.message && event.data.message.source ? event.data.message.source.callId : event.data.callId)
+      }
+    }
+  }
+  const healthyIds = new Set()
+  for (const id of calledIds) if (resultIds.has(id)) healthyIds.add(id)
+  for (const id of repairIds) if (!calledIds.has(id)) healthyIds.add(id)
+  const pairedResultIds = new Set()
+  for (const id of calledIds) if (resultIds.has(id)) pairedResultIds.add(id)
+  for (const id of repairIds) if (!calledIds.has(id)) pairedResultIds.add(id)
+
+  const writes = []
+  let predicted = startSeq
+  let nextTurn = baseTurn
+  const turnMap = new Map()
+  const assistantSeqById = new Map()
+  let lastAssistantSeq = null
+  const seqOf = () => {
+    const seq = predicted
+    predicted += 1
+    return seq
+  }
+  for (const event of range) {
+    const data = event.data || {}
+    if (event.type === 'turn/start') {
+      turnMap.set(data.turn, nextTurn)
+      writes.push({ type: 'turn/start', data: { turn: nextTurn } })
+      seqOf()
+      continue
+    }
+    if (event.type === 'turn/end') {
+      writes.push({ type: 'turn/end', data: { turn: turnMap.get(data.turn), reason: data.reason } })
+      seqOf()
+      nextTurn += 1
+      continue
+    }
+    if (event.type === 'step/start' || event.type === 'step/end') {
+      writes.push({ type: event.type, data: { turn: turnMap.get(data.turn), step: data.step } })
+      seqOf()
+      continue
+    }
+    if (event.type === 'user/message') {
+      if (event.seq === plan.promptSeq && promptCopied !== true) continue
+      // A silent carrier standing where a prompt was is bookkeeping, not
+      // conversation: retire it without a copy, exactly as rerun does.
+      if (isSilentPluginCarrier(event)) continue
+      writes.push({
+        type: 'user/message',
+        surfaceOp: 'append',
+        data: {
+          id: randomUUID(),
+          role: 'user',
+          content: data.content,
+          source: replaySource(data.source, replayId, event.seq),
+        },
+      })
+      seqOf()
+      continue
+    }
+    if (event.type === 'assistant/message') {
+      const message = data.message || {}
+      const source = { ...(message.source || {}) }
+      delete source.replayState
+      const content = Array.isArray(message.content)
+        ? message.content.filter((block) => !(block && block.type === 'tool-call' && !healthyIds.has(block.id)))
+        : []
+      writes.push({
+        type: 'assistant/message',
+        surfaceOp: 'append',
+        data: {
+          turn: turnMap.get(data.turn),
+          step: data.step,
+          message: {
+            id: randomUUID(),
+            role: 'assistant',
+            content,
+            source: replaySource(source, replayId, event.seq),
+          },
+          stream: [],
+          ...(data.interrupted === true ? { interrupted: true } : {}),
+        },
+      })
+      assistantSeqById.set(event.seq, predicted)
+      lastAssistantSeq = predicted
+      seqOf()
+      continue
+    }
+    if (event.type === 'tool/call') {
+      if (!pairedResultIds.has(data.callId)) continue
+      writes.push({
+        type: 'tool/call',
+        data: { turn: turnMap.get(data.turn), step: data.step, callId: data.callId, name: data.name, arguments: data.arguments },
+      })
+      seqOf()
+      continue
+    }
+    if (event.type === 'tool/result') {
+      const callId = data.message && data.message.source ? data.message.source.callId : data.callId
+      if (!pairedResultIds.has(callId)) continue
+      const message = data.message
+      const source = replaySource(message && message.source, replayId, event.seq)
+      // The TOOL_NOT_STARTED repair is accepted only without sourceEventSeqs;
+      // ordinary results remap theirs onto the copied assistant message.
+      let sourceEventSeqs
+      if (!repairIds.has(callId)) {
+        const remapped = Array.isArray(event.sourceEventSeqs)
+          ? event.sourceEventSeqs.map((seq) => assistantSeqById.get(seq)).filter((seq) => typeof seq === 'number')
+          : []
+        if (remapped.length > 0) sourceEventSeqs = remapped
+        else if (typeof lastAssistantSeq === 'number') sourceEventSeqs = [lastAssistantSeq]
+      }
+      const originalMessage = message || {}
+      const rest = { ...originalMessage }
+      delete rest.id
+      delete rest.content
+      delete rest.source
+      // The interrupted-repair carrier must keep its contract-shaped id
+      // (`interrupted-tool-result-<callId>-<n>`): the validator refuses a repair
+      // whose id does not match, and a random id breaks it. The suffix is the
+      // copy's own predicted seq, so the identity stays self-describing.
+      const messageId = repairIds.has(callId) ? `interrupted-tool-result-${callId}-${predicted}` : randomUUID()
+      writes.push({
+        type: 'tool/result',
+        surfaceOp: 'append',
+        ...(sourceEventSeqs === undefined ? {} : { sourceEventSeqs }),
+        data: {
+          turn: turnMap.get(data.turn),
+          step: data.step,
+          message: {
+            ...rest,
+            id: messageId,
+            content: originalMessage.content ?? [],
+            source,
+          },
+          ...(data.error === undefined ? {} : { error: data.error }),
+          ...(data.meta === undefined ? {} : { meta: data.meta }),
+        },
+      })
+      seqOf()
+      continue
+    }
+    // system/message, developer/message and every log-only record are skipped.
   }
+  return writes
 }
 
 /**
@@ -1465,6 +1836,13 @@ async function applyEdit(ctx, sessionId, body, config) {
   // (it projects `lastTurn` from every turn/start it observes). A prompt edit
   // does not: `user/message` carries the revision and needs no turn.
   const editTurn = plan.mode === 'reply' ? nextTurnOf(events) : lastTurnOf(events)
+  // One identity for the whole reply splice: every copy the replay appends
+  // carries it, so a later reader (or a sibling plugin) can tell a replayed turn
+  // from the one it retired without re-deriving anything.
+  const replayId = plan.mode === 'reply' ? randomUUID() : null
+  // Resolved BEFORE the appends so the loop counter can be re-pointed in the
+  // same tick as the writes, not after an await that lets the loop start.
+  const loopAgent = plan.mode === 'reply' ? await resolveLoopAgent(ctx, sessionId) : undefined
   const carrier = buildCarrier(plan, editTurn, plan.mode === 'prompt' ? { ...config, carrier: 'user/message', markerText: text } : config, content)
   if (plan.mode === 'reply') {
     try {
@@ -1495,82 +1873,122 @@ async function applyEdit(ctx, sessionId, body, config) {
   } catch (error) {
     throw new HttpError(409, 'stale', `the surface refused the rollback: ${String((error && error.message) || error)}`)
   }
-  const flush = await flushSession(ctx, session)
 
-  // Step two depends on what was edited.
-  //
-  // Rewriting a reply cannot swap the text in place - an `assistant/message` may
-  // never carry `sourceEventSeqs`, so it can never be a replacement carrier
-  // (checked against the real validator, not assumed). The correction is
-  // appended instead, in the same shape the agent loop records a reply, so the
-  // model goes on seeing the edited text as its own answer and the conversation
-  // continues from there. Nothing is re-run: the answer was fixed, the model was
-  // not asked again.
-  if (plan.mode === 'reply') {
-    const correction = buildCorrection(plan, text, editTurn, 1)
-    let appended
+  // A prompt edit saved here: the carrier that replaced the window IS the
+  // revised prompt, so the model reads it as the user's wording from here on.
+  // Nothing is prompted and nothing else needs writing.
+  if (plan.mode === 'prompt') {
+    const flush = await flushSession(ctx, session)
+    return {
+      kind: 'prompt',
+      replacementSeq: replacement.seq,
+      applied: true,
+      shadowed: plan.shadowed,
+      dropped,
+      // What the carrier now carries, described exactly the way /state describes
+      // it. The browser half adopts this for the row it re-draws before its own
+      // refresh lands - without it a second save could not know which blocks are
+      // still there and would rewrite the message text-only.
+      blocks: blockSummaries(content, canPreviewAttachments(store)),
+      ...flush,
+    }
+  }
+
+  // Step two of a reply edit: the correction itself, inside the turn just
+  // opened. An `assistant/message` may never carry `sourceEventSeqs`, so it can
+  // never be a replacement carrier (checked against the real validator, not
+  // assumed); it is appended in the same shape the agent loop records a reply,
+  // and the model goes on seeing the edited text as its own answer.
+  const correction = buildCorrection(plan, text, editTurn, 1)
+  let appended
+  try {
+    appended = session.append(correction.type, correction.data, { surfaceOp: 'append' })
+    // Close the step and the turn behind the corrected reply: the host anchors
+    // a turn's tail (duration, action strip) at its last `turn/end`, and the
+    // format only reads a step message inside an open turn and step.
+    session.append('step/end', { turn: editTurn, step: 1 })
+    session.append('turn/end', { turn: editTurn, reason: { kind: 'completed' } })
+  } catch (error) {
+    const failedFlush = await flushSession(ctx, session)
+    return {
+      kind: 'reply',
+      replacementSeq: replacement.seq,
+      applied: false,
+      applyError: `the corrected reply was refused: ${String((error && error.message) || error)}`,
+      shadowed: plan.shadowed,
+      dropped,
+      ...failedFlush,
+    }
+  }
+
+  // Step three: put every later turn back behind the correction, as fresh
+  // copies. This is the same infix splice dsh-rerun-turn performs after a
+  // regenerated answer - shadow the tail, write the new reply, replay what
+  // followed - with the user's text taking the place of the model call.
+  let replay = null
+  if (typeof plan.replayFrom === 'number' && typeof plan.logTo === 'number') {
+    const writes = buildReplayWrites(events, plan, editTurn + 1, replayId, session.seq)
+    let replayed = 0
+    let replayError = null
     try {
-      appended = session.append(correction.type, correction.data, { surfaceOp: 'append' })
-      // Close the step and the turn behind the corrected reply: the host anchors
-      // a turn's tail (duration, action strip) at its last `turn/end`, and the
-      // format only reads a step message inside an open turn and step.
-      session.append('step/end', { turn: editTurn, step: 1 })
-      session.append('turn/end', { turn: editTurn, reason: { kind: 'completed' } })
-    } catch (error) {
-      return {
-        kind: 'reply',
-        replacementSeq: replacement.seq,
-        applied: false,
-        applyError: `the corrected reply was refused: ${String((error && error.message) || error)}`,
-        shadowed: plan.shadowed,
-        dropped,
-        ...flush,
+      for (const write of writes) {
+        const options = {}
+        if (write.surfaceOp !== undefined) options.surfaceOp = write.surfaceOp
+        if (write.sourceEventSeqs !== undefined) options.sourceEventSeqs = write.sourceEventSeqs
+        session.append(write.type, write.data, options)
+        replayed += 1
       }
+    } catch (error) {
+      replayError = String((error && error.message) || error)
+    }
+    const playedMax = writes.reduce((max, write) => {
+      const turn = write.data && typeof write.data.turn === 'number' ? write.data.turn : 0
+      return turn > max ? turn : max
+    }, 0)
+    replay = {
+      id: replayId,
+      replayed,
+      total: writes.length,
+      turns: writes.reduce((count, write) => count + (write.type === 'turn/start' ? 1 : 0), 0),
+      ...(replayError === null ? {} : { error: replayError }),
+    }
+    // The replayed turns are closed in the log but were never opened by the
+    // live loop: re-point its idle counter at the highest one, synchronously.
+    const loopTurn = syncLoopTurn(loopAgent, playedMax > editTurn ? playedMax : editTurn)
+    if (loopTurn === 'unavailable') {
+      noteRequest({ kind: 'reply', sessionId, ok: replayError === null, loopTurn, turn: editTurn, replayId, replayed })
     }
     const corrected = await flushSession(ctx, session)
-    // The synthetic turn this edit opened is invisible to the live loop's own
-    // counter; without the sync its next run reuses that number and the log
-    // fails its next load. Only a reply edit opens a turn - a prompt edit does
-    // not, and needs nothing.
-    const loopAgent = await resolveLoopAgent(ctx, sessionId)
-    const loopTurn = syncLoopTurn(loopAgent, editTurn)
-    // `loopTurn` is the diagnostic the request ring records; the field is DELIBERATELY
-  // not called `code` - the static checks read `code:` as host error codes and
-  // must not start demanding a user-visible message for an internal sync state.
-  const syncNote = loopTurn
-  if (syncNote === 'unavailable') {
-    noteRequest({ kind: 'reply', sessionId, ok: true, loopTurn: syncNote, turn: editTurn })
-  }
     return {
       kind: 'reply',
       replacementSeq: replacement.seq,
       appendedSeq: appended.seq,
       applied: true,
       loopTurn,
+      replay,
       shadowed: plan.shadowed,
       dropped,
       ...corrected,
     }
   }
 
-  // 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. 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.
+  // No later turn to replay: the correction is the last answer in the log.
+  // The synthetic turn still moved the loop's counter; sync it the same way.
+  const loopTurn = syncLoopTurn(loopAgent, editTurn)
+  if (loopTurn === 'unavailable') {
+    noteRequest({ kind: 'reply', sessionId, ok: true, loopTurn, turn: editTurn, replayId })
+  }
+  const corrected = await flushSession(ctx, session)
   return {
-    kind: 'prompt',
+    kind: 'reply',
     replacementSeq: replacement.seq,
+    appendedSeq: appended.seq,
     applied: true,
+    loopTurn,
+    replay: null,
     shadowed: plan.shadowed,
     dropped,
-    // What the carrier now carries, described exactly the way /state describes
-    // it. The browser half adopts this for the row it re-draws before its own
-    // refresh lands - without it a second save could not know which blocks are
-    // still there and would rewrite the message text-only.
-    blocks: blockSummaries(content, canPreviewAttachments(store)),
-    ...flush,
+    ...corrected,
   }
 }
 
@@ -1597,7 +2015,7 @@ function registerTool(ctx) {
     defineTool({
       name: 'edit_turn_targets',
       description:
-        'List the user turns of a DeepSeek Harness session that the edit-turn plugin can rewrite and re-run, with each prompt\'s original text. Read-only: it changes nothing.',
+        'List the user turns and model replies of a DeepSeek Harness session that the edit-turn plugin can rewrite, with each message\'s current text. A prompt is replaced where it stands; a reply correction is appended and every later turn is replayed back behind it, with no model call. Read-only: it changes nothing.',
       parameters: {
         sessionId: {
           type: 'string',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.2.20",
-  "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.",
+  "version": "0.2.21",
+  "description": "Edit any message in DeepSeek Harness in place: a prompt is replaced where it stands, a model reply is corrected and every later turn is replayed back behind it - the same infix splice dsh-rerun-turn performs after a rerun, with no model call. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {