dsh-edit-turn 0.3.0 → 0.3.2

package/README.md

@@ -164,7 +164,7 @@ ctx.sessions.registerMessageProjection({
 | 运行中的实例是否真的挂载了本插件（只读路由守卫探针，无需 token） | `npm run probe:loaded [端口]` | 通过：`/state` 返 400、`/apply` 返 405 —— 这两个状态码只有本插件会返回 |
 | 浏览器半部到底问了什么、拿回了什么（只读诊断，含失败记录） | `GET /dsh-edit-turn/debug` | 通过：真实浏览器里确认客户端确实拿到 replies；并复现了旧 v3 会话的 session-not-found |
 | 官方 append **与读取**契约（真实校验器，进程内） | `npm run verify:contract` | 96 项通过（每段写入后都用加载器重读整份日志）：替换事件被接受、派生历史真的收缩、日志 append-only、工具结果与调用同进同退、空 developer 载体不产生模型消息、**连续两次回退都被接受**、**编辑模型回答的完整机制被接受**、**回复编辑后的尾部重放（后续提问/回答/tool 调用与结果按新 turn 号回到修正回答之后，顺序正确、日志仍可加载）**、**跨插件依赖的不变量（单节点窗口 / 同事件类型 / 全窗口 sourceEventSeqs / 每个替换都带 `editedBy` 标记 / 改写后的 `source.kind` 不是 `user` / 修正回复不带 `sourceEventSeqs`）**，以及**就地补丁：一条 ignorable 记录、surface 不变、去掉投影后原文回来、后续轮次与 tool 结果不动、第二条记录可叠加** |
-| 纯逻辑 + 宿主集成 + 客户端 DOM 行为（真 HTTP、真校验器、桩服务、DOM 桩） | `npm test` | 205 项通过（含回复编辑的尾部重放用例：窗口/重放区间、新 turn 号与新 messageId、tool 调用与结果成对重映射、上一轮修正可再次编辑，以及与 `dsh-rerun-turn` builder 的逐字段对照；另含「文本没变 → 不写」的四条，以及块随消息一起改的 35 条：未动的块逐字节保留、删块少一块、文字位置不变、no-op 语义升级、附件服务缺失时降级且不写坏数据、自定义 `quote-card` 块的通用性、录用与拒绝、`/state` 的块描述与能力、附件字节路由、编辑器芯片/删除/添加/缩略图/降级警告） |
+| 纯逻辑 + 宿主集成 + 客户端 DOM 行为（真 HTTP、真校验器、桩服务、DOM 桩） | `npm test` | 213 项通过（含回复编辑的尾部重放用例：窗口/重放区间、新 turn 号与新 messageId、tool 调用与结果成对重映射、上一轮修正可再次编辑，以及与 `dsh-rerun-turn` builder 的逐字段对照；另含「文本没变 → 不写」的四条，以及块随消息一起改的 35 条：未动的块逐字节保留、删块少一块、文字位置不变、no-op 语义升级、附件服务缺失时降级且不写坏数据、自定义 `quote-card` 块的通用性、录用与拒绝、`/state` 的块描述与能力、附件字节路由、编辑器芯片/删除/添加/缩略图/降级警告） |
 | 客户端半部静态检查（注册、i18n 完整性、样式、皮肤可读性、版本三处同步、线协议、块契约） | `npm run verify:client` | 184 项全部通过（含 12 条块契约检查：能力上报、服务现场探测、录用是唯一建块路径、录用先于 append、**两侧都不特判块类型**、块逐字节复制、文字归位、`dropped` 上报、只在无服务时警告、芯片靠 `error` 事件自证） |
 | 实机前端产物校验（运行中的 DSH 是否在下发当前代码） | `npm run verify:live -- --token-file ~/path/to/dsh.log` | 全部通过（含**宿主节点形状锚点**） |
 | **真实浏览器渲染冒烟**（CDP 驱动已开着的标签页，只读） | `npm run verify:ui` | 全部通过：下发的字节就是刚改的字节、无槽位崩溃留下的空占位、回复铅笔在平台动作条里、被回滚的行保住动作条、**被回滚的用户行一定显示替代文本（消息不会凭空消失）**、**替代气泡一定排在时间/复制之上（顺序与正常消息一致）**、**改写后那颗铅笔一定在还活着的动作条末尾（已在原始会话、切走的会话、切回后三处现场确认）**、**回复铅笔一定排在动作条最左（复制之前，已现场确认）**、气泡上没有 `.dshet-floating` 压着文字、切走再切回入口仍在 |
@@ -250,6 +250,23 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
+**0.3.2** —— 修复编辑器在长回答或页面底部时位置错误、按钮点不到的问题。
+
+- **视口钳制**：编辑框优先放在行下方；放不下就翻到行上方；行比屏幕高、底部在视口外时钉在视口底部，不再跟着行跑到屏幕外。
+- **自身滚动**：编辑框有 `max-height` 和 `overflow-y:auto`，保存/取消所在的 footer 用 `position:sticky` 固定，长草稿也能滚到按钮。
+- **宽度/左边界**也按视口钳制，窄窗口不会被推出屏幕。
+- **测试**：`npm test` **213/213**、`npm run verify:contract` **96** 项、`npm run verify:client` **184** 项。
+
+**0.3.1** —— 修复 0.3.0 的显示与跨插件清理问题。
+
+- **编辑后看不到变化**：`turn-process` 行和 `assistant-step` 行都覆盖同一个 seq，旧的 DOM 映射按文档顺序先拿到过程行，补丁落到没有正文的行上。现在优先 assistant 行；极短回答是裸文本节点时也有兜底。
+- **Markdown 匹配**：原文有 `**1**`、渲染后是 `1。`，旧比较把 `**` 换成空格后变成 `1 。`，逐字比较失败。现在比较忽略全部空白；显示时去掉 `**`、反引号和标题标记，不把 Markdown 源码画在正文里。
+- **React 重渲染**：会清掉补丁元素的属性和样式但保留文本；现在按 `seq:block` 记住元素，连续第二次编辑仍能更新并能在补丁消失时恢复原文。
+- **过时补丁**：目标已被 rerun 退役的 patch 不再出现在 `/state.patches`。
+- **轮次丢失**：prompt 替换载体在 turn 括号之外追加，`turnIndex` 取不到轮次；现在从 `sourceEventSeqs` 继承被替换的轮次。
+- **诊断**：客户端在 `<html>` 上写 `data-dshet-version`，可确认页面实际跑的客户端版本。
+- **测试**：`npm test` **210/210**、`npm run verify:contract` **96** 项、`npm run verify:client` **184** 项。
+
 **0.3.0** —— 回复编辑不再重放：用官方 plugin record + message projection 就地打补丁，正文与思维链都能改，日志每次只多一条小记录。
 
 - **为什么改**：0.2.21 的回复编辑虽然保住了后续轮次，但代价是「遮蔽到末尾 + 逐事件重放」——改一条中间回答，日志会多出整段副本，轮次号、messageId 全换，工具调用/思维链也留不住。用户要的是「像改提示词一样改回答」，而不是一次 infix splice。

package/lib/client.js

@@ -42,7 +42,7 @@ window.__ModuleLoader__.load({
     const RERUN_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.3.0'
+    const PLUGIN_VERSION = '0.3.2'
 
     // --- copy -----------------------------------------------------------------
 
@@ -262,7 +262,7 @@ window.__ModuleLoader__.load({
       // positioned under its row by `placeEditor`.
       '.dshet-layer{position:fixed;left:0;top:0;right:0;bottom:0;pointer-events:none;z-index:40}',
       '.dshet-layer .dshet-editor{position:absolute;pointer-events:auto}',
-      '.dshet-editor{margin:0;border:1px solid var(--dshet-line);border-radius:16px;background:var(--dshet-panel);backdrop-filter:blur(18px) saturate(1.2);box-shadow:var(--dshet-shadow);color:var(--dshet-ink);transition:border-color .12s}',
+      '.dshet-editor{display:flex;flex-direction:column;max-height:calc(100vh - 16px);overflow-y:auto;overscroll-behavior:contain;margin:0;border:1px solid var(--dshet-line);border-radius:16px;background:var(--dshet-panel);backdrop-filter:blur(18px) saturate(1.2);box-shadow:var(--dshet-shadow);color:var(--dshet-ink);transition:border-color .12s}',
       '.dshet-editor:focus-within{border-color:var(--dsw-alias-button-primary-fill,var(--dshet-accent))}',
       '.dshet-editor textarea{display:block;width:100%;min-height:47px;max-height:46vh;overflow-y:auto;resize:none;box-sizing:border-box;padding:11px 14px 0;border:0;background:transparent;color:inherit;font:inherit;font-size:var(--dsh-content-font-size,14px);line-height:calc(22px + var(--dsh-content-font-delta,0px));outline:none}',
       '.dshet-editor textarea::placeholder{color:var(--dshet-ink-dim)}',
@@ -290,7 +290,7 @@ window.__ModuleLoader__.load({
       '.dshet-note{color:var(--dshet-ink-dim)}',
       '.dshet-warn{color:var(--dsw-alias-state-warning-primary,#a2650a)}',
       '.dshet-error{color:var(--dsw-alias-state-error-primary,#c93a31)}',
-      '.dshet-footer{display:flex;align-items:center;justify-content:flex-end;gap:8px;padding:4px 10px 10px}',
+      '.dshet-footer{position:sticky;bottom:0;z-index:1;display:flex;align-items:center;justify-content:flex-end;gap:8px;padding:4px 10px 10px;background:var(--dshet-panel);backdrop-filter:blur(18px) saturate(1.2)}',
       '.dshet-btn{padding:6px 16px;border:1px solid var(--dshet-line);border-radius:999px;background:var(--dshet-field);color:var(--dshet-ink);font:inherit;font-size:13px;line-height:20px;cursor:pointer;transition:background-color .12s,border-color .12s}',
       '.dshet-btn:hover:not(:disabled){background:var(--dshet-hover)}',
       '.dshet-btn:focus-visible{outline:2px solid var(--dsw-alias-button-primary-fill,var(--dshet-accent));outline-offset:2px}',
@@ -1945,13 +1945,51 @@ window.__ModuleLoader__.load({
     // Put the box under the row it belongs to: same width, just below its lower
     // edge. Called on render and whenever the page scrolls or resizes, since
     // the layer is fixed to the viewport.
+    function viewportSize() {
+      const win = typeof window === 'undefined' ? undefined : window
+      const doc = typeof document === 'undefined' ? undefined : document
+      const width = (win !== undefined && win.innerWidth) ||
+        (doc !== undefined && doc.documentElement && doc.documentElement.clientWidth) || 0
+      const height = (win !== undefined && win.innerHeight) ||
+        (doc !== undefined && doc.documentElement && doc.documentElement.clientHeight) || 0
+      return { width, height }
+    }
+
+    // Put the box under the row it belongs to: same width, just below its lower
+    // edge. The layer is fixed to the viewport, so a row near the bottom (or one
+    // taller than the screen) used to push the footer - and its save button -
+    // past the bottom edge where nothing could reach it. Flip above the row when
+    // there is room, otherwise pin the box to the bottom of the viewport and let
+    // its own scrollbar carry the content; the footer stays sticky either way.
     function placeEditor(row, box) {
       const layer = ensureEditorLayer()
       if (box.parentElement !== layer) layer.appendChild(box)
       const rect = row.getBoundingClientRect()
-      box.style.left = `${Math.round(rect.left)}px`
-      box.style.top = `${Math.round(rect.bottom + 6)}px`
-      box.style.width = `${Math.round(rect.width)}px`
+      const viewport = viewportSize()
+      const margin = 8
+      const width = viewport.width > 0
+        ? Math.max(1, Math.min(Math.max(200, rect.width || 0), viewport.width - margin * 2))
+        : Math.max(200, rect.width || 0)
+      box.style.width = `${Math.round(width)}px`
+      const measured = box.getBoundingClientRect()
+      const height = (measured && measured.height) || box.offsetHeight || 0
+      let top = rect.bottom + 6
+      if (viewport.height > 0 && height > 0) {
+        const maxTop = Math.max(margin, viewport.height - height - margin)
+        if (top + height > viewport.height - margin) {
+          const above = rect.top - height - 6
+          top = above >= margin ? above : maxTop
+        }
+        // A row taller than the screen has its bottom above the viewport after
+        // the user scrolls to its action bar; without this clamp the box follows
+        // it off-screen and the buttons become unreachable again.
+        top = Math.max(margin, Math.min(top, maxTop))
+      }
+      let left = rect.left
+      if (viewport.width > 0 && left + width > viewport.width - margin) left = viewport.width - width - margin
+      if (left < margin) left = margin
+      box.style.left = `${Math.round(left)}px`
+      box.style.top = `${Math.round(top)}px`
     }
 
     // Grow the textarea to its content, the way a normal input box behaves.
@@ -2297,8 +2335,16 @@ window.__ModuleLoader__.load({
         // "eats" pinyin.
         if (event.isComposing === true) return
         fitEditorHeight(area)
+        const row = controller.editorRow
+        const box = controller.editorBox
+        if (row !== null && box !== null && box.isConnected === true) placeEditor(row, box)
+      })
+      area.addEventListener('compositionend', () => {
+        fitEditorHeight(area)
+        const row = controller.editorRow
+        const box = controller.editorBox
+        if (row !== null && box !== null && box.isConnected === true) placeEditor(row, box)
       })
-      area.addEventListener('compositionend', () => fitEditorHeight(area))
       area.addEventListener('focus', () => {
         controller.editorFocus = true
       })
@@ -2408,11 +2454,11 @@ window.__ModuleLoader__.load({
       footer.appendChild(submit)
       box.appendChild(footer)
 
-      placeEditor(row, box)
       controller.editorBox = box
       controller.editorRow = row
       controller.editorElement = area
       fitEditorHeight(area)
+      placeEditor(row, box)
       if (!view.confirming && !view.pending && (fresh || wasFocused)) {
         try {
           area.focus()
@@ -2452,6 +2498,11 @@ window.__ModuleLoader__.load({
     const PATCH_ATTR = 'data-dshet-patch'
     const NOTE_ATTR = 'data-dshet-patch-note'
     const patchOriginals = new WeakMap()
+    // React may re-render the assistant container and reset its attributes and
+    // style while leaving the text node we replaced. Remember the element by
+    // seq:block so the next pass can restore the marker and, on a later edit,
+    // update it without having to re-find the original text (which is gone).
+    const patchedElements = new Map()
 
     function normalizedText(value) {
       return String(value ?? '').replace(/\s+/g, ' ').trim()
@@ -2464,6 +2515,27 @@ window.__ModuleLoader__.load({
       return normalizedText(String(value ?? '').replace(/[`*_#>~[\]()!|]/g, ' ').replace(/\s+/g, ' '))
     }
 
+    // Identity, not display: markdown emphasis (`**1**`) renders as `1。`, and
+    // the spaces left by stripping the markers must not defeat the comparison.
+    // Whitespace carries no block identity here, so remove it entirely.
+    function matchText(value) {
+      return plainText(value).replace(/\s+/g, '')
+    }
+
+    // What the reader sees for a patched block. The model context keeps the
+    // raw Markdown the editor wrote; the transcript should not show the markers
+    // as literal text (`**1**`), which is what made a successful edit look like
+    // an unrendered draft. This is deliberately minimal: bold, inline code and
+    // headings are unwrapped; everything else stays as written.
+    function displayText(value) {
+      return String(value ?? '')
+        .replace(/```[\s\S]*?```/g, (fence) => fence.replace(/^```[^\n]*\n?/gm, '').replace(/```$/gm, ''))
+        .replace(/`([^`]*)`/g, '$1')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/__([^_]+)__/g, '$1')
+        .replace(/^#{1,6}\s+/gm, '')
+    }
+
     function isMarkdownContainer(el) {
       if (el === null || el === undefined || !el.children) return false
       const kids = el.children
@@ -2498,18 +2570,69 @@ window.__ModuleLoader__.load({
       el.style.whiteSpace = ''
     }
 
+    // A short reply can be a bare text node (or a span) rather than the
+    // block-level markdown container the picker looks for. Match the deepest
+    // element in the owning row whose whole text is exactly the recorded text;
+    // never a button, a timestamp, our own chrome, or an ancestor that merely
+    // contains the text.
+    function findPatchTextFallback(owner, wanted) {
+      if (owner === null || owner === undefined || typeof owner.querySelectorAll !== 'function') return null
+      const original = matchText(wanted.original)
+      if (original === '') return null
+      let scope = owner
+      try {
+        const node = owner.querySelector('[data-slot="conversation.chat.node"]')
+        if (node !== null && node !== undefined) scope = node
+      } catch {
+        /* keep the row as the scope */
+      }
+      for (const el of scope.querySelectorAll('*')) {
+        if (el === scope) continue
+        if (el.getAttribute(PATCH_ATTR) !== null) continue
+        try {
+          if (el.closest('.dshet-editor, .dshet-action, .dshet-pick, .dshet-patch-note, button, time') !== null) continue
+        } catch {
+          continue
+        }
+        const text = matchText(el.textContent)
+        if (text !== original) continue
+        let deeper = false
+        for (const child of el.children ?? []) {
+          if (matchText(child.textContent) === text) {
+            deeper = true
+            break
+          }
+        }
+        if (!deeper) return el
+      }
+      return null
+    }
+
     function applyPatchDisplay(snapshot, view, t) {
       // Map a reply seq to the host row that draws it, so a short answer like
       // "好的" cannot be matched in a different row. Fall back to a global
       // search when the row is not mounted (virtualised histories).
       const rowBySeq = new Map()
+      // A turn-process row also covers the turn's assistant seq (seqsFor reads
+      // its anchor), and it comes before the assistant row in document order.
+      // First-win mapping therefore pointed the patch at the process row, whose
+      // subtree has no message body: zero matches. Prefer the row that actually
+      // draws the message; the process/tail rows are only a last resort.
+      const rowRank = new Map()
       try {
         for (const row of document.querySelectorAll('[data-chat-flow-key]')) {
           const key = row.getAttribute('data-chat-flow-key')
           if (!key || !snapshot || !snapshot.nodes || typeof snapshot.nodes.get !== 'function') continue
           const node = snapshot.nodes.get(key)
           if (!node) continue
-          for (const seq of seqsFor(node)) if (!rowBySeq.has(seq)) rowBySeq.set(seq, row)
+          const rank = node.kind === 'assistant-step' ? 0 : node.kind === 'user' ? 1 : 2
+          for (const seq of seqsFor(node)) {
+            const previous = rowRank.get(seq)
+            if (previous === undefined || rank < previous) {
+              rowBySeq.set(seq, row)
+              rowRank.set(seq, rank)
+            }
+          }
         }
       } catch {
         /* a host shape this pass cannot read falls back below */
@@ -2541,6 +2664,13 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // A patch that no longer exists must give the host's recorded text back,
+      // even when a re-render already stripped our marker from the element.
+      for (const [key, el] of [...patchedElements]) {
+        if (wantedText.has(key)) continue
+        patchedElements.delete(key)
+        if (el.isConnected === true) restorePatchedBlock(el)
+      }
       // Remove overrides whose patch is gone (or was superseded by a prompt
       // rollback). The original HTML is what the host rendered.
       for (const el of [...root.querySelectorAll(`[${PATCH_ATTR}]`)]) {
@@ -2550,8 +2680,9 @@ window.__ModuleLoader__.load({
           restorePatchedBlock(el)
           continue
         }
-        if (normalizedText(el.textContent) !== normalizedText(wanted.text)) {
-          el.textContent = wanted.text
+        const shown = displayText(wanted.text)
+        if (normalizedText(el.textContent) !== normalizedText(shown)) {
+          el.textContent = shown
         }
       }
       for (const note of [...root.querySelectorAll(`[${NOTE_ATTR}]`)]) {
@@ -2572,13 +2703,33 @@ window.__ModuleLoader__.load({
         }
       }
       for (const [key, wanted] of wantedText) {
+        const owner = rowBySeq.get(wanted.seq)
+        const remembered = patchedElements.get(key)
+        if (remembered !== undefined) {
+          const stillThere = remembered.isConnected === true &&
+            (owner === undefined || remembered.closest('[data-chat-flow-key]') === owner)
+          if (!stillThere) {
+            patchedElements.delete(key)
+          } else {
+            const shown = displayText(wanted.text)
+            if (normalizedText(remembered.textContent) !== normalizedText(shown)) {
+              remembered.textContent = shown
+            }
+            if (remembered.getAttribute(PATCH_ATTR) !== key) remembered.setAttribute(PATCH_ATTR, key)
+            remembered.style.whiteSpace = 'pre-wrap'
+            continue
+          }
+        }
         const done = [...root.querySelectorAll(`[${PATCH_ATTR}]`)].find((el) => el.getAttribute(PATCH_ATTR) === key)
-        if (done !== undefined) continue
-        const original = plainText(wanted.original)
+        if (done !== undefined) {
+          patchedElements.set(key, done)
+          if (done.style.whiteSpace !== 'pre-wrap') done.style.whiteSpace = 'pre-wrap'
+          continue
+        }
+        const original = matchText(wanted.original)
         if (original === '') continue
         let best = null
         let bestScore = Infinity
-        const owner = rowBySeq.get(wanted.seq)
         for (const el of containers) {
           if (el.getAttribute(PATCH_ATTR) !== null) continue
           if (owner !== undefined) {
@@ -2588,7 +2739,7 @@ window.__ModuleLoader__.load({
               /* no closest on this node: keep the global match */
             }
           }
-          const text = plainText(el.textContent)
+          const text = matchText(el.textContent)
           if (text === '') continue
           const exact = text === original
           const prefix = text.startsWith(original.slice(0, 60)) || original.startsWith(text.slice(0, 60))
@@ -2602,11 +2753,13 @@ window.__ModuleLoader__.load({
             bestScore = score
           }
         }
+        if (best === null) best = findPatchTextFallback(owner, wanted)
         if (best === null) continue
         patchOriginals.set(best, { html: best.innerHTML, text: best.textContent })
-        best.textContent = wanted.text
+        best.textContent = displayText(wanted.text)
         best.setAttribute(PATCH_ATTR, key)
         best.style.whiteSpace = 'pre-wrap'
+        patchedElements.set(key, best)
       }
 
       // Reasoning notes: put one under the reply row, found by the reply's own
@@ -2614,15 +2767,15 @@ window.__ModuleLoader__.load({
       for (const [key, wanted] of wantedNotes) {
         let note = [...root.querySelectorAll(`[${NOTE_ATTR}]`)].find((el) => el.getAttribute(NOTE_ATTR) === key)
         let row = rowBySeq.get(wanted.reply.seq) ?? null
-        const replyText = plainText(wanted.reply.text)
+        const replyText = matchText(wanted.reply.text)
         for (const node of row === null ? nodes : []) {
-          const text = plainText(node.textContent)
+          const text = matchText(node.textContent)
           if (text === '') continue
           if (replyText !== '' && text.includes(replyText)) {
             row = node
             break
           }
-          if (plainText(wanted.block.original) !== '' && text.includes(plainText(wanted.block.original))) {
+          if (matchText(wanted.block.original) !== '' && text.includes(matchText(wanted.block.original))) {
             row = node
             break
           }
@@ -2967,6 +3120,14 @@ window.__ModuleLoader__.load({
     // --- plugin ---------------------------------------------------------------
 
     function apply(ctx) {
+      // Diagnostic only: the host restart does not reload the page's JS, so a
+      // stale client bundle and a live host can coexist. This marker says which
+      // browser half actually ran (the old bundle has none).
+      try {
+        document.documentElement.dataset.dshetVersion = PLUGIN_VERSION
+      } catch {
+        /* a non-DOM host is not worth failing over */
+      }
       ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dsh-edit-turn: dictionaries')
 
       const controllers = new Map()

package/lib/index.js

@@ -80,7 +80,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.3.0'
+export const PLUGIN_VERSION = '0.3.2'
 
 // 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
@@ -1239,7 +1239,20 @@ export function editableTurns(events, surfaceNodes, options = {}) {
     if (!event || !isHumanPrompt(event)) continue
     if (seq === head) continue
     const { text, attachments } = readMessageText(event)
-    const turn = turnOf.get(seq)
+    // A replacement carrier is appended after its original turn's bracket has
+    // closed, so turnIndex cannot name its turn. It still stands at that
+    // prompt's position in the conversation: inherit the turn from the event
+    // it replaced, or the editor's turn list loses the row (turn: null).
+    let turn = turnOf.get(seq)
+    if (typeof turn !== 'number' && Array.isArray(event.sourceEventSeqs)) {
+      for (const source of event.sourceEventSeqs) {
+        const inherited = turnOf.get(source)
+        if (typeof inherited === 'number') {
+          turn = inherited
+          break
+        }
+      }
+    }
     out.push({
       seq,
       turn: typeof turn === 'number' ? turn : null,
@@ -1645,6 +1658,13 @@ async function stateOf(ctx, sessionId, config) {
   const folded = foldSurface(events)
   const ledger = rollbackLedger(events)
   const patches = patchesOf(events)
+  // A patch whose target has been retired (a later rerun shadowed it) is inert:
+  // the projection skips it and no row can show it. Reporting it in /state made
+  // the browser draw a patch that could never land, and made "which patches are
+  // live" ambiguous. Keep the internal map for the replies; publish the active
+  // subset only.
+  const surfaceSet = new Set(folded.nodes)
+  const activePatches = new Map([...patches].filter(([seq]) => surfaceSet.has(seq)))
   const live = findLiveSession(ctx, sessionId)
   // Probed per request: the editor offers what THIS deployment can do right
   // now, so a store that is unmounted (or not yet mounted) cannot leave the
@@ -1676,7 +1696,7 @@ async function stateOf(ctx, sessionId, config) {
     // The landed in-place patches, latest per block. The browser half uses them
     // to draw the projected text in place of the recorded one; the model already
     // sees them through the host projection.
-    patches: patchList(patches),
+    patches: patchList(activePatches),
     mode: config.patch === true ? 'patch' : 'replay',
     live: Boolean(live),
     busy: isBusy(events),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Edit any message in DeepSeek Harness in place: a prompt is replaced where it stands; a model reply block (answer text or reasoning) is patched through a plugin record and a message projection, so the turn stays where it is, later turns are untouched and the log grows by one small record. Falls back to the replay splice on hosts without the projection API. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",