dsh-edit-turn 0.1.1 → 0.2.1

package/README.md

@@ -25,6 +25,7 @@ DSH 的会话日志是 append-only 的事件流：说错的提示词、问偏的
 - **默认零上下文污染** —— 替换事件的载体是一个**空的 `system/message`**。官方格式文档里空的后置 system 节点是「dormant，不投影成任何消息」，所以回退后模型看到的上下文，和「对话真的停在那一点」完全一致，不会多出任何标记文本。
 - **轮边界安全** —— 遮蔽窗口右端固定为日志最后一个 surface 节点，左端固定为目标消息节点，因此助手消息（内含 tool_use）与它产生的 tool/result 永远一起走，**不可能留下悬空的调用/结果对**。
 - **重跑走官方准入路径** —— `ctx.sessionController.prompt()` 是唯一的口径：它会自己 resume 冷会话，并恰好开一个新轮次。
+- **模型回答也能编辑** —— 回答无法被"替换"：官方格式禁止 `assistant/message` 携带 `sourceEventSeqs`（已在真实校验器上验证）。做法是回退该回答及其后的内容，再**追加**一条带改写文本的助手消息——模型会把改写后的内容当成自己说过的话，对话可以继续。`source.editedBy` 会如实记录这段文字由插件写入。
 - **一次点击即执行** —— 保存后不再有二次确认。编辑器本身已经是用户主动打开的动作，面板里也写明了保存会丢弃哪些内容；想恢复两步确认可在 profile 里一行开启（`confirm: true`）。
 - **中英双语 UI**，跟随 DSH 当前语言。
 - **皮肤友好** —— 编辑器面板自带不透明表面（`--dshet-panel`）而不是借用主题的表面色变量。皮肤的本意就是让表面半透明、把插画透出来，而它只会给**自己的**元素补可读背景，插件类名不在其中；借用皮肤变量的面板会变成全透明，文字直接压在插画上。暗色分支走官方属性 `body[data-ds-dark-theme]`（与 `dsh-client-ui-theme` 及多个官方 UI 包一致），并用 `backdrop-filter` 与皮肤融合。
@@ -53,6 +54,10 @@ dsh plugin --profile web add /path/to/dsh-edit-turn
 
 编辑器里如果提示「这条消息包含图片或文件附件」，说明改写只保留文字，附件会被丢弃。
 
+**编辑模型的回答**：悬停任意一条模型回复，同样会出现编辑入口。改完点「保存替换」——这条回答被替换为你写的内容，它之后的内容一并移除，模型从此把你写的内容当成自己说过的话，对话可以继续下去。
+
+注意：回答里的**工具调用与思考过程**无法保留（替换后只留文字，编辑器会提示），因为工具调用的结果已经不再成立。
+
 ### 配置
 
 写在 profile 里即可覆盖默认值：
@@ -105,15 +110,18 @@ await ctx.sessionController.prompt({ requestId, sessionId, mode: 'queue', conten
 
 ### 验证状态
 
-本插件在 DSH `0.1.6-alpha.2` 上完成以下验证（全部**零模型调用**）：
+本插件在 DSH `0.1.6-alpha.2` 与 `0.1.7-rc.1` 上完成以下验证：
 
 | 验证 | 命令 | 结果 |
 |---|---|---|
-| 官方 append 契约（真实校验器，进程内） | `npm run verify:contract` | 46 项通过：替换事件被接受、派生历史真的收缩、日志 append-only、工具结果与调用同进同退、空 system 载体不产生模型消息、**连续两次回退都被接受** |
-| 纯逻辑 + 宿主集成 + 客户端 DOM 行为（真 HTTP、真校验器、桩服务、DOM 桩） | `npm test` | 63 项通过 |
-| 客户端半部静态检查（注册、i18n 完整性、样式、**皮肤可读性**、版本三处同步、线协议） | `npm run verify:client` | 全部通过 |
-| 实机前端产物校验（运行中的 DSH 是否在下发当前代码） | `npm run verify:live -- --token-file ~/path/to/dsh.log` | 全部通过 |
+| 运行中的实例是否真的挂载了本插件（只读路由守卫探针，无需 token） | `npm run probe:loaded [端口]` | 通过：`/state` 返 400、`/apply` 返 405 —— 这两个状态码只有本插件会返回 |
+| 浏览器半部到底问了什么、拿回了什么（只读诊断，含失败记录） | `GET /dsh-edit-turn/debug` | 通过：真实浏览器里确认客户端确实拿到 replies；并复现了旧 v3 会话的 session-not-found |
+| 官方 append 契约（真实校验器，进程内） | `npm run verify:contract` | 61 项通过：替换事件被接受、派生历史真的收缩、日志 append-only、工具结果与调用同进同退、空 system 载体不产生模型消息、**连续两次回退都被接受**、**编辑模型回答的完整机制被接受** |
+| 纯逻辑 + 宿主集成 + 客户端 DOM 行为（真 HTTP、真校验器、桩服务、DOM 桩） | `npm test` | 83 项通过 |
+| 客户端半部静态检查（注册、i18n 完整性、样式、皮肤可读性、版本三处同步、线协议） | `npm run verify:client` | 全部通过 |
+| 实机前端产物校验（运行中的 DSH 是否在下发当前代码） | `npm run verify:live -- --token-file ~/path/to/dsh.log` | 全部通过（含**宿主节点形状锚点**） |
 | 真实 profile 安装 / 补丁合成 / 启动 / 工具契约 / 路由守卫 | `npm run verify:profile` | 全部通过 |
+| **真实浏览器端到端**（agent-browser 驱动 Chrome 打开运行实例） | 手动 | 已完成：模型回答行出现「编辑这条回答」、点开编辑器预填真实回复原文、取消后网络层 0 个 apply 请求。截图见 `docs/reply-editor-in-browser.png` |
 
 `verify:live` 针对**正在运行的实例**：用 DSH 启动时打印的 token 换取鉴权 cookie，读启动页里的客户端模块组，把含本插件的那一组下载下来，断言插件自己的标记确实在其中。它证明的是「浏览器刷新后会拿到当前代码」，而不是「源码看起来没问题」——前端改动后这是唯一能确认已生效的自动手段。
 
@@ -133,13 +141,31 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 已知限制
 
-- **只支持人类输入的消息**。注入的上下文行、助手消息、系统提示词都不提供编辑入口。
+- 可以编辑**你自己输入的消息**与**模型的回答**；注入的上下文行与系统提示词没有编辑入口。
+- 编辑一条回答会把它替换为**纯文本**：该回答里的工具调用与思考过程会被移除（编辑器会提示），因为它们的结果已不再成立。
+- 编辑一条用户消息会重跑那一轮；编辑一条模型回答只替换内容，**不会**重新问模型。
 - **编辑会丢弃该消息之后的全部轮次**（MVP 语义，和 ChatGPT 的编辑一致）。想保留原文形成分支，需要走 `sessionController.fork({ sessionId, atSeq })`，尚未实现。
 - **只改写文本**。消息里含图片/文件附件时，改写后只保留文字（编辑器会提示）。
 - **会话必须当前在 DSH 中打开**，否则返回 `409 session-not-active`。
 - **进行中拒绝编辑**：未闭合的轮次或正在压缩时返回 `409 busy`。
 - **回退是持久的，隐藏不是**。回退写进日志后，模型上下文永久改变；转录里那些行的隐藏是本插件客户端半部做的。卸载插件后，旧行会重新显示出来（而模型上下文里的回退仍然生效）——因为替换事件是官方事件，不会随插件消失。
 - 回退后**系统提示词保持不变**（窗口永不包含 surface 节点 0，该节点也永不可编辑）。
+- **旧会话（v3 格式日志）在 DSH 0.1.7 下读不到**：DSH 的会话读取层对这类日志返回 `session-not-found`，本插件因此在其中完全不工作（表现为没有编辑入口）。新写的会话是 v4，正常。
+
+### 更新日志
+
+**0.2.1** —— 修 0.1.7 上的两处界面问题，并补上让问题可自证的诊断手段。
+
+- 修复：模型回复的编辑入口改注册进官方插槽 `conversation.chat.assistant-actions`，与平台自己的 复制 / 赞 / 踩 / 分支 / 用量 同排（此前是 DOM 注入，位置不一致、且会随工具调用行卸载而闪烁）。
+- 修复：编辑模型回答后**重新闭合该轮**（`step/end` + `turn/end`）。此前修正消息被追加到 `turn/end` 之后、落在轮外，导致那一轮的尾巴（用时、动作条）渲染到回复正文**上面**。
+- 修复：DSH 0.1.7 兼容——会话格式 v4 的 producer-owned source kind（`plugin:<id>`）、助手消息文本取自 `data.message.content`。
+- 新增：只读诊断路由 `GET /dsh-edit-turn/debug`；`npm run probe:loaded [端口]`。
+
+**0.2.0** —— 可以编辑模型的回答。回退该回答及其后内容，再追加一条带改写文本的助手消息（回答无法原地替换：官方格式禁止 `assistant/message` 携带 `sourceEventSeqs`）。不重跑模型；`source.editedBy` 如实标记文字由插件写入。
+
+**0.1.1** —— 去掉多余的二次确认（默认一次点击即执行）；修皮肤下界面可读性。
+
+**0.1.0** —— 首版：回退并重跑你自己发过的消息。
 
 ### 姊妹插件
 
@@ -149,7 +175,7 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 兼容性
 
-- `dsh.engines.dsh`: `>=0.1.6-alpha.2`（本插件依赖该版本的消息行定义与 surface 语义，并已在此版本实测）。
+- `dsh.engines.dsh`: `>=0.1.6-alpha.2`（本插件依赖该版本的消息行定义与 surface 语义；`0.1.6-alpha.2` 与 `0.1.7-rc.1` 均已实测）。
 - 客户端依赖：`dsh-client-locale`、`dsh-client-ui-chat`、`dsh-client-ui-conversation`、`dsh-client-ui-primitives`。
 - 宿主依赖：`dsh-settings`、`dsh-tools`（peer）；`@deepseek-ai/schemastery`（直接依赖）。
 
@@ -182,6 +208,7 @@ This plugin adds it:
 - **Zero context pollution by default.** The replacement carrier is an **empty `system/message`**. The official format documents empty later system nodes as dormant, projecting to no message, so the context after an edit is exactly what it would be had the conversation really stopped there - no marker text is added.
 - **Turn-boundary safe.** The shadow window always ends at the last surface node and always opens at the addressed message, so an assistant message (which carries its own tool_use blocks) and the tool/result it produced are shadowed together. A dangling call/result pair is impossible.
 - **Official re-run.** `ctx.sessionController.prompt()` is the only prompt admission path; it resumes a cold Session itself and opens exactly one new turn.
+- **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. The editor is already an explicit action the user opened, and the panel states what saving discards; a profile can restore the two-step flow with `confirm: true`.
 - **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`.
@@ -211,6 +238,15 @@ Restart the DSH process that serves that profile to pick it up.
 If the editor warns that the message carries attachments, the rewrite keeps the
 text only and drops them.
 
+**Editing what the model said.** Hover any model reply and the same edit action
+appears. Click "Save replacement" - the reply is replaced with your text,
+everything after it is removed, and the model goes on treating your words as its
+own, so the conversation can continue from there.
+
+Note that **tool calls and reasoning inside that reply cannot survive** the
+replacement (only text is kept, and the editor warns first): their results are no
+longer valid once you have changed what the model said.
+
 ### Configuration
 
 ```yaml
@@ -276,11 +312,13 @@ Verified against DSH `0.1.6-alpha.2`, entirely **without model calls**:
 
 | Check | Command | Result |
 |---|---|---|
-| Official append contract against the real validator, in process | `npm run verify:contract` | 46 checks pass: the replacement is accepted, the derived history really shrinks, the log stays append-only, a tool result leaves with its call, the empty system carrier adds no model message, **two consecutive rollbacks are both accepted** |
-| Pure logic, host integration and browser-half DOM behaviour (real HTTP, real validator, stubbed services, DOM stub) | `npm test` | 63 tests pass |
+| Is the plugin actually mounted in a running instance? (read-only route-guard probe, no token needed) | `npm run probe:loaded [port]` | pass: `/state` answers 400 and `/apply` answers 405 - status codes only this plugin produces |
+| Official append contract against the real validator, in process | `npm run verify:contract` | 61 checks pass: the replacement is accepted, the derived history really shrinks, the log stays append-only, a tool result leaves with its call, the empty system carrier adds no model message, **two consecutive rollbacks are both accepted**, **the whole reply-editing mechanism is accepted** |
+| Pure logic, host integration and browser-half DOM behaviour (real HTTP, real validator, stubbed services, DOM stub) | `npm test` | 83 tests pass |
 | Browser-half static checks (registration, i18n completeness, styles, skin legibility, three-way version sync, wire contract) | `npm run verify:client` | all pass |
-| Live client artifact (is the running DSH serving the current code?) | `npm run verify:live -- --token-file ~/path/to/dsh.log` | all pass |
+| Live client artifact (is the running DSH serving the current code?) | `npm run verify:live -- --token-file ~/path/to/dsh.log` | all pass, **including anchors on the host's node shapes** |
 | Real profile: install, patch composition, boot, tool contract, route guards | `npm run verify:profile` | all pass |
+| **Real browser, end to end** (agent-browser drives Chrome at a running instance) | manual | done: an edit action appears on model reply rows, the editor opens pre-filled with the real reply, and cancelling leaves zero `apply` requests. See `docs/reply-editor-in-browser.png` |
 
 `verify:live` targets an instance that is **already running**: it exchanges the
 token DSH printed on boot for an auth cookie, reads the client module groups out
@@ -319,7 +357,9 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### Known limitations
 
-- **Human messages only.** Injected context rows, assistant messages and the system prompt offer no edit entry.
+- **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 re-runs that turn; editing a model reply does not ask the model again** - it only replaces the text.
 - **An edit discards every later turn** (the MVP semantic, matching ChatGPT's edit). 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`.

package/lib/client.js

@@ -30,22 +30,28 @@ window.__ModuleLoader__.load({
     const ROUTE_PREFIX = '/dsh-edit-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.1.1'
+    const PLUGIN_VERSION = '0.2.1'
 
     // --- copy -----------------------------------------------------------------
 
     const zh = {
       'action.edit': '编辑这条消息并重跑',
+      'action.edit-reply': '编辑这条回答',
       'editor.title': '编辑这条消息',
-      'editor.placeholder': '修改后确认，会话将回退到这条消息之前并重新跑这一轮。',
+      'editor.title-reply': '编辑这条回答',
+      'editor.placeholder': '修改后保存，会话将回退到这条消息之前并重新跑这一轮。',
+      'editor.placeholder-reply': '改成你希望模型说过的内容，保存后它就成为这条回答。',
       'editor.save': '保存并重跑',
-      'editor.review': '确认回退',
+      'editor.save-reply': '保存替换',
+      'editor.review': '确认执行',
       'editor.cancel': '取消',
-      'editor.pending': '正在回退并重跑…',
+      'editor.pending': '正在执行…',
       'editor.warn.attachments': '这条消息包含图片或文件附件，改写会丢弃它们，只保留文字。',
+      'editor.warn-reply': '这条回答包含工具调用或思考过程，替换后它们会被一并移除。',
       'editor.hint': '保存后，这条消息之后的全部内容（含当轮回复与工具调用）会从模型上下文中移除，并从这里重新开始。原始会话日志不会改写。',
-      'confirm.title': '确认回退并重跑？',
-      'confirm.body': '这条消息之后的全部内容会从模型上下文中移除，然后用你改写后的内容重新跑这一轮。原始会话日志保持不变。',
+      'editor.hint-reply': '保存后，这条回答会被替换为你写的内容，它之后的内容一并移除。模型会把你写的内容当成自己说过的话，对话可以继续下去。原始会话日志不会改写。',
+      'confirm.title': '确认执行？',
+      'confirm.body': '确认后会立即执行：这条消息之后的内容会从模型上下文中移除。原始会话日志不会改写。',
       'error.invalid': '请求无效，请刷新后重试。',
       'error.session-not-active': '这个会话当前未激活，请先打开该会话再编辑。',
       'error.session-not-found': '找不到该会话的日志。',
@@ -57,22 +63,29 @@ window.__ModuleLoader__.load({
       'error.method': '请求方式不被接受，请刷新后重试。',
       'error.generic': '编辑失败，请重试。',
       'error.prompt': '已回退，但重跑没有启动。请手动发送改写后的内容。',
+      'error.reply': '已回退，但替换没有落地。请重试。',
       'error.empty': '改写后的内容不能为空。',
       'error.internal': '服务器内部错误，请稍后重试。',
     }
 
     const en = {
       'action.edit': 'Edit this message and re-run',
+      'action.edit-reply': 'Edit this reply',
       'editor.title': 'Edit this message',
-      'editor.placeholder': 'Confirm after editing: the conversation rolls back to just before this message and this turn runs again.',
+      '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-reply': 'Write what you want the model to have said; saving makes it this reply.',
       'editor.save': 'Save and re-run',
-      'editor.review': 'Confirm rollback',
+      'editor.save-reply': 'Save replacement',
+      'editor.review': 'Confirm',
       'editor.cancel': 'Cancel',
-      'editor.pending': 'Rolling back and re-running...',
+      'editor.pending': 'Working...',
       'editor.warn.attachments': 'This message carries image or file attachments; rewriting keeps the text only.',
+      'editor.warn-reply': 'This reply carries tool calls or reasoning; replacing it removes them.',
       'editor.hint': 'Saving removes everything after this message (including that turn\'s reply and tool calls) from the model context and starts again from here. The original session log is never rewritten.',
-      'confirm.title': 'Roll back and re-run?',
-      'confirm.body': 'Everything after this message leaves the model context, then this turn runs again from your revised text. The original session log stays untouched.',
+      'editor.hint-reply': 'Saving replaces this reply with your text and removes everything after it. The model goes on treating your words as its own, so the conversation can continue from here. The original session log is never rewritten.',
+      'confirm.title': 'Confirm?',
+      'confirm.body': 'Confirming applies right away: everything after this message leaves the model context. 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.',
@@ -84,6 +97,7 @@ window.__ModuleLoader__.load({
       'error.method': 'The request method is not accepted; refresh and try again.',
       'error.generic': 'The edit failed; try again.',
       '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.internal': 'The host hit an internal error; try again shortly.',
     }
@@ -201,6 +215,8 @@ window.__ModuleLoader__.load({
         this.view = Object.freeze({
           hidden: new Map(),
           editable: new Map(),
+          replies: new Map(),
+          repliesByMessage: new Map(),
           editing: null,
           draft: '',
           confirming: false,
@@ -259,9 +275,23 @@ window.__ModuleLoader__.load({
             for (const turn of Array.isArray(data.turns) ? data.turns : []) {
               if (turn && typeof turn.seq === 'number') editable.set(turn.seq, turn)
             }
+            // The model's replies are editable too, as a separate list: they are
+            // rewritten rather than re-run, so the editor words the consequence
+            // differently.
+            const replies = new Map()
+            const repliesByMessage = new Map()
+            for (const reply of Array.isArray(data.replies) ? data.replies : []) {
+              if (!reply || typeof reply.seq !== 'number') continue
+              replies.set(reply.seq, reply)
+              // The official assistant-actions strip hands us a messageId, so
+              // replies are indexed by it too.
+              if (typeof reply.messageId === 'string' && reply.messageId !== '') repliesByMessage.set(reply.messageId, reply)
+            }
             this.publish({
               hidden,
               editable,
+              replies,
+              repliesByMessage,
               surfaceReady: true,
               loaded: true,
               loadError: false,
@@ -350,6 +380,13 @@ window.__ModuleLoader__.load({
           for (const entry of editable.values()) {
             if (hidden.has(entry.seq)) editable.delete(entry.seq)
           }
+          // A reply edit shadows its own reply too, so it leaves the editable
+          // replies here and re-enters through the next /state refresh (the
+          // appended correction is itself an editable reply).
+          const replies = new Map(this.view.replies)
+          for (const entry of replies.values()) {
+            if (hidden.has(entry.seq)) replies.delete(entry.seq)
+          }
           this.animateOnce = true
           this.editor = null
           this.editorDraft = ''
@@ -361,11 +398,13 @@ window.__ModuleLoader__.load({
             confirming: false,
             hidden,
             editable,
+            replies,
             failure: null,
           })
           // The rollback has landed, so the editor is gone with its row: a
-          // failed re-run has to be reported somewhere that survives that.
-          if (data.promptAccepted === false) this.notify('prompt')
+          // 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.promptAccepted === false) this.notify('prompt')
         } catch {
           this.publish({ pending: false, failure: 'generic' })
         }
@@ -396,23 +435,43 @@ window.__ModuleLoader__.load({
 
     // --- row targets ----------------------------------------------------------
 
-    // The editable target of a Chat view node, or null when the row is not a
-    // human prompt the user can rewrite.
-    function targetFor(node, editable, hidden) {
+    // The editable target of a Chat view node, or null when the row stands for
+    // something that cannot be rewritten.
+    //
+    // Only human prompts come through here: a reply's entry comes from the
+    // official assistant-actions strip instead, which is where the host puts
+    // every other action for that row. Injecting one here used to put the pencil
+    // in a different place from every other reply action.
+    function targetFor(node, view) {
       if (!node || node.kind !== 'user') return null
       const data = node.data || {}
-      const seq = typeof data.seq === 'number' ? data.seq : node.anchorSeq
-      if (typeof seq !== 'number') return null
-      if (hidden.has(seq)) return null
-      const entry = editable.get(seq)
-      if (!entry) return null
-      return {
-        seq,
-        turn: entry.turn,
-        messageId: entry.messageId,
-        text: typeof entry.text === 'string' ? entry.text : '',
-        attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
+      const candidates = []
+      const push = (value) => {
+        if (typeof value === 'number' && !candidates.includes(value)) candidates.push(value)
+      }
+      push(data.seq)
+      push(node.anchorSeq)
+      for (const seq of candidates) {
+        if (view.hidden.has(seq)) continue
+        const entry = view.editable.get(seq)
+        if (!entry) continue
+        return {
+          seq,
+          mode: 'prompt',
+          turn: entry.turn,
+          messageId: entry.messageId,
+          text: typeof entry.text === 'string' ? entry.text : '',
+          attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
+        }
       }
+      return null
+    }
+
+    // The element that carries the turn-tail marker: either the flow-keyed row
+    // itself or a wrapper inside it. Its own action strip is a direct child.
+    function rootOfTurnTail(row) {
+      if (typeof row.matches === 'function' && row.matches('[data-turn-tail]')) return row
+      return row.querySelector('[data-turn-tail]')
     }
 
     // Every surface seq a row stands for, so one rollback can hide the rows it
@@ -506,8 +565,8 @@ window.__ModuleLoader__.load({
       rowActions.delete(row)
     }
 
-    function injectRowAction(row, target, controller, t) {
-      const label = t('action.edit')
+    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')
@@ -516,6 +575,11 @@ window.__ModuleLoader__.load({
         button.type = 'button'
         button.className = 'dshet-action dshet-row-action'
         button.innerHTML = ICON_MARKUP
+        // 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 }
         rowActions.set(row, entry)
@@ -530,7 +594,9 @@ window.__ModuleLoader__.load({
         event.stopPropagation()
         controller.open(target)
       }
-      const anchor = row.querySelector('[class*="_actions"]')
+      // A caller that already picked the right bar (the turn tail's own strip)
+      // hands it over; otherwise the first actions container in the row wins.
+      const anchor = options.anchor ?? row.querySelector('[class*="_actions"]')
       if (anchor) {
         host.classList.remove('dshet-floating')
         row.classList.remove('dshet-row')
@@ -567,8 +633,23 @@ window.__ModuleLoader__.load({
       ].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) {
+      const reply = target.mode === 'reply'
+      return {
+        title: t(reply ? 'editor.title-reply' : 'editor.title'),
+        placeholder: t(reply ? 'editor.placeholder-reply' : 'editor.placeholder'),
+        hint: t(reply ? 'editor.hint-reply' : 'editor.hint'),
+        warn: t(reply ? 'editor.warn-reply' : 'editor.warn.attachments'),
+        save: t(reply ? 'editor.save-reply' : 'editor.save'),
+      }
+    }
+
     function renderEditor(row, controller, view, t) {
       const target = view.editing
+      const texts = editorTexts(t, target)
       const marker = editorMarker(target, view)
       const existing = row.querySelector('.dshet-editor')
       if (existing && existing.dataset.dshetFor === marker) return
@@ -580,7 +661,7 @@ window.__ModuleLoader__.load({
 
       const title = document.createElement('p')
       title.className = 'dshet-editor-title'
-      title.textContent = view.confirming ? t('confirm.title') : t('editor.title')
+      title.textContent = view.confirming ? t('confirm.title') : texts.title
       box.appendChild(title)
 
       const area = document.createElement('textarea')
@@ -588,20 +669,20 @@ window.__ModuleLoader__.load({
       area.value = controller.editorDraft
       area.disabled = view.pending || view.confirming
       area.spellcheck = false
-      area.setAttribute('aria-label', t('editor.title'))
-      if (!view.confirming) area.placeholder = t('editor.placeholder')
+      area.setAttribute('aria-label', texts.title)
+      if (!view.confirming) area.placeholder = texts.placeholder
       area.addEventListener('input', () => controller.setDraft(area.value))
       box.appendChild(area)
 
       const note = document.createElement('p')
       note.className = 'dshet-note'
-      note.textContent = view.confirming ? t('confirm.body') : t('editor.hint')
+      note.textContent = view.confirming ? t('confirm.body') : texts.hint
       box.appendChild(note)
 
       if (target.attachments > 0) {
         const warn = document.createElement('p')
         warn.className = 'dshet-warn'
-        warn.textContent = t('editor.warn.attachments')
+        warn.textContent = texts.warn
         box.appendChild(warn)
       }
       if (typeof view.failure === 'string' && view.failure !== '') {
@@ -634,7 +715,7 @@ window.__ModuleLoader__.load({
         ? t('editor.pending')
         : view.confirming
           ? t('editor.review')
-          : t('editor.save')
+          : texts.save
       submit.disabled = view.pending
       submit.onclick = (event) => {
         event.preventDefault()
@@ -685,15 +766,63 @@ window.__ModuleLoader__.load({
         if (!node) continue
         const hidden = isRowHidden(view.hidden, seqsFor(node))
         setRowHidden(row, hidden, animate)
-        const target = hidden ? null : targetFor(node, view.editable, view.hidden)
-        if (target !== null) injectRowAction(row, target, controller, t)
-        else removeRowAction(row)
+        const target = hidden ? null : targetFor(node, view)
+        if (target !== null) {
+          injectRowAction(row, target, controller, t)
+        } else if (!hidden && node.kind === 'turn-tail') {
+          // A reply's entry belongs in the host's own action strip, and that is
+          // where it is registered. A slot entry that never renders leaves no
+          // trace at all, though - no error, no gap - so the same pencil is also
+          // offered through the turn tail's own strip, and only while that strip
+          // does not already carry one. Both land in the platform's own bar, so
+          // the position is identical either way.
+          const covered = seqsFor(node).find((seq) => view.replies.has(seq) && !view.hidden.has(seq))
+          // The strip lives inside the turn-tail root (`data-turn-tail`) as its
+          // LAST direct child, while the row carrying the flow key may be a
+          // wrapper around that root. Bounding the search by the tail root keeps
+          // the tool-call bars inside the tail out of reach: those unmount as a
+          // call expands, so a pencil parked there blinks, and it is not where
+          // the reply's actions live anyway.
+          const tailRoot = rootOfTurnTail(row)
+          const bar =
+            covered === undefined || tailRoot === null
+              ? undefined
+              : Array.from(tailRoot.children)
+                  .reverse()
+                  .find((child) => typeof child.className === 'string' && child.className.includes('_actions'))
+          const slotPencil = bar === undefined ? null : bar.querySelector('.dshet-row-action:not([data-dshet-fallback])')
+          if (covered !== undefined && bar !== undefined && slotPencil === null) {
+            const entry = view.replies.get(covered)
+            injectRowAction(
+              row,
+              {
+                seq: covered,
+                mode: 'reply',
+                turn: entry.turn,
+                messageId: entry.messageId,
+                text: typeof entry.text === 'string' ? entry.text : '',
+                attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
+              },
+              controller,
+              t,
+              { fallback: true, anchor: bar },
+            )
+          } else {
+            // Either the strip's own entry is already there, or this row holds
+            // nothing editable: any spare pencil of ours has to go.
+            removeRowAction(row)
+          }
+        } else {
+          removeRowAction(row)
+        }
+        // The editor anchors to whichever row covers the seq being edited, not to
+        // the row that owns the entry: a reply's entry now lives in the turn-tail
+        // action strip, while its editor still belongs under the reply text.
         if (
           !hidden &&
           view.editing !== null &&
           typeof view.editing.seq === 'number' &&
-          target !== null &&
-          target.seq === view.editing.seq
+          seqsFor(node).includes(view.editing.seq)
         ) {
           renderEditor(row, controller, view, t)
         }
@@ -701,6 +830,40 @@ window.__ModuleLoader__.load({
       if (view.editing === null) clearEditor()
     }
 
+    // The reply edit entry, registered in the host's own assistant-actions strip.
+    //
+    // It has to live there rather than be injected next to the message: the host
+    // renders that strip per assistant message, hands the entry the messageId, and
+    // keeps the platform's own reveal behaviour (always for the latest turn, hover
+    // for older ones). Injecting instead put the pencil in a different place from
+    // where every other action for that row lives, which is what users noticed.
+    function ReplyActionEntry({ messageId, controller, useEditTurn, t }) {
+      const view = useEditTurn((state) => state)
+      const entry = view.repliesByMessage.get(messageId)
+      if (entry === undefined || view.hidden.has(entry.seq)) return null
+      const label = t('action.edit-reply')
+      const open = (event) => {
+        event.preventDefault()
+        event.stopPropagation()
+        controller.open({
+          seq: entry.seq,
+          mode: 'reply',
+          turn: entry.turn,
+          messageId: entry.messageId,
+          text: typeof entry.text === 'string' ? entry.text : '',
+          attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
+        })
+      }
+      return jsx('button', {
+        type: 'button',
+        className: 'dshet-action dshet-row-action',
+        'aria-label': label,
+        title: label,
+        onClick: open,
+        children: jsx(PencilIcon, null),
+      })
+    }
+
     // --- react entries --------------------------------------------------------
 
     function OverlayEntry({ useChat, useEditTurn, controller, t }) {
@@ -767,6 +930,25 @@ window.__ModuleLoader__.load({
         'dsh-edit-turn: per-session controllers',
       )
 
+      // A reply's edit entry lives in the official assistant-actions strip, one
+      // entry per assistant message. order 5 puts it ahead of the feedback
+      // entries (order 10), so the pencil sits with the leading icons.
+      ctx.slots.inject('conversation.chat.assistant-actions', () =>
+        ctx.slots.register(
+          {
+            name: 'conversation.chat.assistant-actions',
+            id: 'edit-turn-reply',
+            order: 5,
+            locale: NS,
+            inject: (sessionId) => ({
+              hooks: { editTurn: controllerFor(sessionId) },
+              controller: controllerFor(sessionId),
+            }),
+          },
+          ReplyActionEntry,
+        ),
+      )
+
       ctx.slots.inject('conversation.input.overlay', () =>
         ctx.slots.register(
           {

package/lib/index.js

@@ -48,7 +48,24 @@ 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.1.1'
+export const PLUGIN_VERSION = '0.2.1'
+
+// 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
+// browser half's own state is otherwise invisible from the host side.
+const REQUEST_LOG_LIMIT = 40
+const requestLog = []
+
+/** Record one request for the diagnostic route. */
+export function noteRequest(entry) {
+  requestLog.push({ at: Date.now(), ...entry })
+  if (requestLog.length > REQUEST_LOG_LIMIT) requestLog.shift()
+}
+
+/** The recorded requests, oldest first. */
+export function recentRequests() {
+  return requestLog.slice()
+}
 
 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
@@ -219,6 +236,23 @@ export function isHumanPrompt(event) {
   return Boolean(data && data.source && data.source.kind === 'user')
 }
 
+/**
+ * Whether an event is a reply the model produced.
+ *
+ * Editing one of these is a different operation from editing a prompt: the
+ * official append contract refuses to let an `assistant/message` carry
+ * `sourceEventSeqs` ("assistant/message embeds its source stream"), so a reply
+ * can never be the replacement carrier of a rollback. The rollback is therefore
+ * followed by appending the corrected text as a new assistant message, and the
+ * model goes on seeing it as its own answer.
+ *
+ * @param event - raw session event.
+ * @returns true for an assistant reply.
+ */
+export function isAssistantReply(event) {
+  return Boolean(event) && event.type === 'assistant/message'
+}
+
 /**
  * Read the plain text of a message payload, plus how many non-text parts it
  * carries. Editing is text-only, so a caller must be told when a rewrite would
@@ -228,7 +262,11 @@ export function isHumanPrompt(event) {
  */
 export function readMessageText(event) {
   const data = (event && event.data) || {}
-  const blocks = Array.isArray(data.content) ? data.content : []
+  // `user/message` carries its message fields on `data`; the other three surface
+  // types nest them under `data.message`. Both shapes have to read the same way
+  // now that the model's replies are editable too.
+  const message = data.message && typeof data.message === 'object' ? data.message : data
+  const blocks = Array.isArray(message.content) ? message.content : []
   let text = ''
   let attachments = 0
   for (const block of blocks) {
@@ -260,7 +298,7 @@ export function rollbackLedger(events) {
     const event = bySeq.get(replacement.seq)
     const data = event && event.data
     const source = data && (data.source || (data.message && data.message.source))
-    if (!source || source.kind !== 'plugin' || source.plugin !== PLUGIN_ID) continue
+    if (!(source && (source.kind === `plugin:${PLUGIN_ID}` || (source.kind === 'plugin' && source.plugin === PLUGIN_ID)))) continue
     for (const seq of replacement.shadowed) {
       const turn = turnOf.get(seq)
       hidden.push({ seq, turn: typeof turn === 'number' ? turn : null, replacement: replacement.seq })
@@ -336,8 +374,8 @@ function resolveTarget(events, request) {
  *
  * @param events - complete contiguous raw event log.
  * @param surfaceNodes - current surface seqs in model order.
- * @param request - `{ seq?, messageId?, turn? }`.
- * @returns `{ targetSeq, startSeq, endSeq, shadowed, turn, original, attachments }`.
+ * @param request - `{ seq?, messageId?, turn? }` (`turn` addresses a prompt only).
+ * @returns `{ targetSeq, messageId, startSeq, endSeq, shadowed, mode, turn, step, provider, model, original, attachments }`.
  * @throws {EditPlanError} with a stable code when the target cannot be planned.
  */
 export function planRollback(events, surfaceNodes, request) {
@@ -352,8 +390,11 @@ export function planRollback(events, surfaceNodes, request) {
   if (target.seq === surfaceNodes[0]) {
     throw new EditPlanError('not-editable', 'the system prompt head cannot be edited')
   }
-  if (!isHumanPrompt(target)) {
-    throw new EditPlanError('not-editable', 'only messages you typed can be edited and re-run')
+  // Two editable kinds, two outcomes: rewriting a prompt re-runs the turn;
+  // rewriting a reply replaces the answer and lets the conversation continue.
+  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')
   }
   const startIdx = nodeIndex.get(target.seq)
   const shadowed = surfaceNodes.slice(startIdx)
@@ -362,13 +403,22 @@ export function planRollback(events, surfaceNodes, request) {
   }
   const { text, attachments } = readMessageText(target)
   const turn = turnOf.get(target.seq)
+  const data = target.data && typeof target.data === 'object' ? target.data : {}
+  const message = data.message && typeof data.message === 'object' ? data.message : data
+  const source = message.source && typeof message.source === 'object' ? message.source : null
   return {
     targetSeq: target.seq,
     messageId: messageIdOf(target),
     startSeq: shadowed[0],
     endSeq: shadowed[shadowed.length - 1],
     shadowed,
+    mode,
     turn: typeof turn === 'number' ? turn : null,
+    // The appended correction is keyed by turn:step in the client's reducer, so a
+    // missing step would make two corrections collide on "undefined:undefined".
+    step: typeof data.step === 'number' ? data.step : 1,
+    provider: source && typeof source.provider === 'string' ? source.provider : null,
+    model: source && typeof source.model === 'string' ? source.model : null,
     original: text,
     attachments,
   }
@@ -407,6 +457,42 @@ export function editableTurns(events, surfaceNodes) {
   return out
 }
 
+/**
+ * Every model reply that can currently be rewritten.
+ *
+ * Replies with no text at all are skipped: a step that only produced tool calls
+ * has nothing to put in a text editor. A reply that carries tool calls *and*
+ * text is offered, because replacing it drops those calls along with it - the
+ * client warns about that, and the calls cannot survive a rewrite anyway.
+ *
+ * @param events - complete contiguous raw event log.
+ * @param surfaceNodes - current surface seqs in model order.
+ * @returns one entry per editable reply, in conversation order.
+ */
+export function editableReplies(events, surfaceNodes) {
+  const nodeIndex = new Map(surfaceNodes.map((seq, index) => [seq, index]))
+  const turnOf = turnIndex(events)
+  const head = surfaceNodes[0]
+  const out = []
+  for (const event of events) {
+    if (!isAssistantReply(event)) continue
+    if (!nodeIndex.has(event.seq)) continue
+    if (event.seq === head) continue
+    const { text, attachments } = readMessageText(event)
+    if (text.trim() === '') continue
+    const turn = turnOf.get(event.seq)
+    out.push({
+      seq: event.seq,
+      turn: typeof turn === 'number' ? turn : null,
+      messageId: messageIdOf(event) ?? null,
+      text,
+      // For a reply these are the non-text blocks: tool calls and reasoning.
+      attachments,
+    })
+  }
+  return out
+}
+
 // ---------------------------------------------------------------------------
 // host service plumbing
 // ---------------------------------------------------------------------------
@@ -526,15 +612,31 @@ async function flushSession(ctx, session) {
 
 async function stateOf(ctx, sessionId, config) {
   const events = await readEvents(ctx, sessionId)
-  if (!events) throw new HttpError(404, 'session-not-found', 'no session log for this id')
+  if (!events) {
+    noteRequest({ kind: 'state', sessionId, ok: false, code: 'session-not-found' })
+    throw new HttpError(404, 'session-not-found', 'no session log for this id')
+  }
   const folded = foldSurface(events)
   const ledger = rollbackLedger(events)
   const live = findLiveSession(ctx, sessionId)
+  const turns = editableTurns(events, folded.nodes)
+  const replies = editableReplies(events, folded.nodes)
+  noteRequest({
+    kind: 'state',
+    sessionId,
+    ok: true,
+    events: events.length,
+    turns: turns.length,
+    replies: replies.length,
+    hidden: ledger.hidden.length,
+    live: Boolean(live),
+  })
   return {
     hidden: ledger.hidden,
     edits: ledger.edits.length,
     surface: folded.nodes,
-    turns: editableTurns(events, folded.nodes),
+    turns,
+    replies,
     live: Boolean(live),
     busy: isBusy(events),
     lastSeq: events.length > 0 ? events[events.length - 1].seq : -1,
@@ -564,7 +666,7 @@ export function buildCarrier(plan, lastTurn, config) {
           id: randomUUID(),
           role: 'system',
           content: [],
-          source: { kind: 'plugin', plugin: PLUGIN_ID },
+          source: { kind: `plugin:${PLUGIN_ID}` },
         },
       },
     }
@@ -575,7 +677,43 @@ export function buildCarrier(plan, lastTurn, config) {
       id: randomUUID(),
       role: 'user',
       content: [{ type: 'text', text: config.markerText }],
-      source: { kind: 'plugin', plugin: PLUGIN_ID },
+      source: { kind: `plugin:${PLUGIN_ID}` },
+    },
+  }
+}
+
+/**
+ * The new assistant message that carries an edited reply.
+ *
+ * A reply cannot be swapped in place - the validator refuses `sourceEventSeqs`
+ * on an `assistant/message` - so the correction is appended as a fresh reply.
+ * `turn`/`step` are always set because the client keys a reply node by
+ * `turn:step`; leaving them out would make two corrections collide.
+ *
+ * `source.kind` stays `model` so the entry renders and projects exactly like an
+ * ordinary reply, while `editedBy` records honestly that the text was written by
+ * the plugin and not produced by the model.
+ *
+ * @param plan - the planned window, for the original's turn/step/provider.
+ * @param text - the replacement text.
+ * @returns `{ type, data }` for `session.append`, to be marked `surfaceOp: 'append'`.
+ */
+export function buildCorrection(plan, text) {
+  const source = { kind: 'model', editedBy: PLUGIN_ID }
+  if (typeof plan.provider === 'string' && plan.provider !== '') source.provider = plan.provider
+  if (typeof plan.model === 'string' && plan.model !== '') source.model = plan.model
+  return {
+    type: 'assistant/message',
+    data: {
+      turn: typeof plan.turn === 'number' ? plan.turn : 0,
+      step: typeof plan.step === 'number' ? plan.step : 1,
+      message: {
+        id: randomUUID(),
+        role: 'assistant',
+        content: [{ type: 'text', text }],
+        source,
+      },
+      stream: [],
     },
   }
 }
@@ -632,11 +770,54 @@ async function applyEdit(ctx, sessionId, body, config) {
   }
   const flush = await flushSession(ctx, session)
 
-  // Step two: admit the revised prompt. This is the only official prompt path,
-  // so it also resumes a cold Session and starts exactly one new turn.
+  // 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)
+    let appended
+    try {
+      appended = session.append(correction.type, correction.data, { surfaceOp: 'append' })
+      // Close the turn again, now that the corrected reply is the last thing in
+      // it. The host anchors a turn's tail (its duration and action strip) at the
+      // turn's LAST `turn/end`, so a correction appended after the old one lands
+      // OUTSIDE the turn and the tail renders above the corrected text. These two
+      // events put the tail back behind it, exactly as a normal turn ends.
+      session.append('step/end', { turn: appended.data.turn, step: appended.data.step })
+      session.append('turn/end', { turn: appended.data.turn, 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,
+        ...flush,
+      }
+    }
+    const corrected = await flushSession(ctx, session)
+    return {
+      kind: 'reply',
+      replacementSeq: replacement.seq,
+      appendedSeq: appended.seq,
+      applied: true,
+      shadowed: plan.shadowed,
+      ...corrected,
+    }
+  }
+
+  // A rewritten prompt is re-run through the only official prompt path, which
+  // also resumes a cold Session and starts exactly one new turn.
   const controller = ctx.get('sessionController')
   if (!controller || typeof controller.prompt !== 'function') {
     return {
+      kind: 'prompt',
       replacementSeq: replacement.seq,
       promptAccepted: false,
       promptError: 'sessionController.prompt unavailable',
@@ -656,6 +837,7 @@ async function applyEdit(ctx, sessionId, body, config) {
     )
   } catch (error) {
     return {
+      kind: 'prompt',
       replacementSeq: replacement.seq,
       promptAccepted: false,
       promptError: String((error && error.message) || error),
@@ -665,6 +847,7 @@ async function applyEdit(ctx, sessionId, body, config) {
   }
 
   return {
+    kind: 'prompt',
     replacementSeq: replacement.seq,
     promptAccepted: true,
     shadowed: plan.shadowed,
@@ -716,16 +899,24 @@ function registerTool(ctx) {
         if (!events) throw new Error(`no session log for ${sessionId}`)
         const nodes = surfaceOf(ctx, sessionId, events)
         const turns = editableTurns(events, nodes)
+        const replies = editableReplies(events, nodes)
         const limit = typeof args.limit === 'number' && args.limit > 0 ? Math.floor(args.limit) : 20
         const shown = turns.slice(-limit)
+        const shownReplies = replies.slice(-limit)
         const lines = [
-          `session ${sessionId}: ${turns.length} editable turn(s), ${isBusy(events) ? 'BUSY' : 'idle'}`,
+          `session ${sessionId}: ${turns.length} editable turn(s), ${replies.length} editable reply/replies, ${isBusy(events) ? 'BUSY' : 'idle'}`,
         ]
         for (const turn of shown) {
           const preview = turn.text.length > 160 ? `${turn.text.slice(0, 160)}...` : turn.text
           lines.push(`- turn ${turn.turn} (seq ${turn.seq}, ${turn.attachments} attachment(s)): ${preview}`)
         }
         if (turns.length > shown.length) lines.push(`(${turns.length - shown.length} earlier turn(s) omitted)`)
+        for (const reply of shownReplies) {
+          const preview = reply.text.length > 160 ? `${reply.text.slice(0, 160)}...` : reply.text
+          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.')
         return lines.join('\n')
       },
     }),
@@ -861,6 +1052,24 @@ export function apply(ctx, config) {
       }),
     )
 
+    // Read-only diagnostics. The browser half's own state cannot be observed
+    // from here, so the next best thing is an honest record of what its requests
+    // asked for and what they got back.
+    fiber.effect(() =>
+      webServer.register({
+        kind: 'exact',
+        path: `${ROUTE_PREFIX}/debug`,
+        handler: (req, res) => {
+          if (!guard(req, res)) return
+          if (req.method !== 'GET') {
+            sendJson(res, 405, { ok: false, code: 'method', error: 'GET only' })
+            return
+          }
+          sendJson(res, 200, { ok: true, version: PLUGIN_VERSION, requests: recentRequests() })
+        },
+      }),
+    )
+
     fiber.effect(() =>
       webServer.register({
         kind: 'exact',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "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",
@@ -39,6 +39,7 @@
     "verify:client": "node tools/verify-client-static.mjs",
     "verify:live": "node tools/verify-live-client.mjs",
     "verify:profile": "bash tools/verify-dsh-plugin.sh",
+    "probe:loaded": "node tools/probe-loaded.mjs",
     "check": "npm run test && npm run verify:contract && npm run verify:client"
   },
   "dependencies": {