dsh-edit-turn 0.2.0 → 0.2.1

package/README.md

@@ -110,11 +110,12 @@ 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` 上完成以下验证：
 
 | 验证 | 命令 | 结果 |
 |---|---|---|
 | 运行中的实例是否真的挂载了本插件（只读路由守卫探针，无需 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` | 全部通过 |
@@ -149,6 +150,22 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 - **进行中拒绝编辑**：未闭合的轮次或正在压缩时返回 `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** —— 首版：回退并重跑你自己发过的消息。
 
 ### 姊妹插件
 
@@ -158,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`（直接依赖）。
 

package/lib/client.js

@@ -30,7 +30,7 @@ window.__ModuleLoader__.load({
     const ROUTE_PREFIX = '/dsh-edit-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.2.0'
+    const PLUGIN_VERSION = '0.2.1'
 
     // --- copy -----------------------------------------------------------------
 
@@ -216,6 +216,7 @@ window.__ModuleLoader__.load({
           hidden: new Map(),
           editable: new Map(),
           replies: new Map(),
+          repliesByMessage: new Map(),
           editing: null,
           draft: '',
           confirming: false,
@@ -278,13 +279,19 @@ window.__ModuleLoader__.load({
             // 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') replies.set(reply.seq, reply)
+              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,
@@ -431,34 +438,26 @@ window.__ModuleLoader__.load({
     // 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.
+    // 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) return null
+      if (!node || node.kind !== 'user') return null
       const data = node.data || {}
       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
-      }
+      push(data.seq)
+      push(node.anchorSeq)
       for (const seq of candidates) {
         if (view.hidden.has(seq)) continue
-        const entry = view.editable.get(seq) || view.replies.get(seq)
+        const entry = view.editable.get(seq)
         if (!entry) continue
         return {
           seq,
-          mode: view.editable.has(seq) ? 'prompt' : 'reply',
+          mode: 'prompt',
           turn: entry.turn,
           messageId: entry.messageId,
           text: typeof entry.text === 'string' ? entry.text : '',
@@ -468,6 +467,13 @@ window.__ModuleLoader__.load({
       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
     // shadowed however the host UI chose to group them.
     function seqsFor(node) {
@@ -559,7 +565,7 @@ window.__ModuleLoader__.load({
       rowActions.delete(row)
     }
 
-    function injectRowAction(row, target, controller, t) {
+    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) {
@@ -569,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)
@@ -583,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')
@@ -754,14 +767,62 @@ window.__ModuleLoader__.load({
         const hidden = isRowHidden(view.hidden, seqsFor(node))
         setRowHidden(row, hidden, animate)
         const target = hidden ? null : targetFor(node, view)
-        if (target !== null) injectRowAction(row, target, controller, t)
-        else removeRowAction(row)
+        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)
         }
@@ -769,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 }) {
@@ -835,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.2.0'
+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
@@ -595,16 +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),
-    replies: editableReplies(events, folded.nodes),
+    turns,
+    replies,
     live: Boolean(live),
     busy: isBusy(events),
     lastSeq: events.length > 0 ? events[events.length - 1].seq : -1,
@@ -752,6 +784,13 @@ async function applyEdit(ctx, sessionId, body, config) {
     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',
@@ -1013,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.2.0",
+  "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",