dsh-edit-turn 0.1.1 → 0.2.0

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 里即可覆盖默认值：
@@ -109,11 +114,13 @@ await ctx.sessionController.prompt({ requestId, sessionId, mode: 'queue', conten
 
 | 验证 | 命令 | 结果 |
 |---|---|---|
-| 官方 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 —— 这两个状态码只有本插件会返回 |
+| 官方 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,7 +140,9 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 已知限制
 
-- **只支持人类输入的消息**。注入的上下文行、助手消息、系统提示词都不提供编辑入口。
+- 可以编辑**你自己输入的消息**与**模型的回答**；注入的上下文行与系统提示词没有编辑入口。
+- 编辑一条回答会把它替换为**纯文本**：该回答里的工具调用与思考过程会被移除（编辑器会提示），因为它们的结果已不再成立。
+- 编辑一条用户消息会重跑那一轮；编辑一条模型回答只替换内容，**不会**重新问模型。
 - **编辑会丢弃该消息之后的全部轮次**（MVP 语义，和 ChatGPT 的编辑一致）。想保留原文形成分支，需要走 `sessionController.fork({ sessionId, atSeq })`，尚未实现。
 - **只改写文本**。消息里含图片/文件附件时，改写后只保留文字（编辑器会提示）。
 - **会话必须当前在 DSH 中打开**，否则返回 `409 session-not-active`。
@@ -182,6 +191,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 +221,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 +295,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 +340,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.0'
 
     // --- 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,7 @@ window.__ModuleLoader__.load({
         this.view = Object.freeze({
           hidden: new Map(),
           editable: new Map(),
+          replies: new Map(),
           editing: null,
           draft: '',
           confirming: false,
@@ -259,9 +274,17 @@ 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()
+            for (const reply of Array.isArray(data.replies) ? data.replies : []) {
+              if (reply && typeof reply.seq === 'number') replies.set(reply.seq, reply)
+            }
             this.publish({
               hidden,
               editable,
+              replies,
               surfaceReady: true,
               loaded: true,
               loadError: false,
@@ -350,6 +373,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 +391,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 +428,44 @@ 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) {
-      if (!node || node.kind !== 'user') return null
+    // The editable target of a Chat view node, or null when the row stands for
+    // something that cannot be rewritten.
+    //
+    // Two kinds are offered: a human prompt (rewritten, then the turn re-runs)
+    // and a model reply (rewritten in place, discarding everything after it).
+    // A step row can span several surface nodes, and the reply seq sits on
+    // `finalNode` for an assistant step while a user row carries it on `data`,
+    // so both candidates are tried rather than assumed.
+    function targetFor(node, view) {
+      if (!node) 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)
+      }
+      if (node.kind === 'user') {
+        push(data.seq)
+        push(node.anchorSeq)
+      } else if (node.kind === 'assistant-step') {
+        push(data.finalNode && data.finalNode.seq)
+        push(node.anchorSeq)
+      } else {
+        return null
       }
+      for (const seq of candidates) {
+        if (view.hidden.has(seq)) continue
+        const entry = view.editable.get(seq) || view.replies.get(seq)
+        if (!entry) continue
+        return {
+          seq,
+          mode: view.editable.has(seq) ? 'prompt' : 'reply',
+          turn: entry.turn,
+          messageId: entry.messageId,
+          text: typeof entry.text === 'string' ? entry.text : '',
+          attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
+        }
+      }
+      return null
     }
 
     // Every surface seq a row stands for, so one rollback can hide the rows it
@@ -507,7 +560,7 @@ window.__ModuleLoader__.load({
     }
 
     function injectRowAction(row, target, controller, t) {
-      const label = t('action.edit')
+      const label = t(target.mode === 'reply' ? 'action.edit-reply' : 'action.edit')
       let entry = rowActions.get(row)
       if (!entry) {
         const host = document.createElement('span')
@@ -567,8 +620,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 +648,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 +656,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 +702,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,7 +753,7 @@ 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)
+        const target = hidden ? null : targetFor(node, view)
         if (target !== null) injectRowAction(row, target, controller, t)
         else removeRowAction(row)
         if (

package/lib/index.js

@@ -48,7 +48,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.1.1'
+export const PLUGIN_VERSION = '0.2.0'
 
 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 +219,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 +245,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 +281,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 +357,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 +373,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 +386,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 +440,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
 // ---------------------------------------------------------------------------
@@ -535,6 +604,7 @@ async function stateOf(ctx, sessionId, config) {
     edits: ledger.edits.length,
     surface: folded.nodes,
     turns: editableTurns(events, folded.nodes),
+    replies: editableReplies(events, folded.nodes),
     live: Boolean(live),
     busy: isBusy(events),
     lastSeq: events.length > 0 ? events[events.length - 1].seq : -1,
@@ -564,7 +634,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 +645,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 +738,47 @@ 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' })
+    } 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 +798,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 +808,7 @@ async function applyEdit(ctx, sessionId, body, config) {
   }
 
   return {
+    kind: 'prompt',
     replacementSeq: replacement.seq,
     promptAccepted: true,
     shadowed: plan.shadowed,
@@ -716,16 +860,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')
       },
     }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "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": {