dsh-edit-turn 0.2.21 → 0.3.1

package/lib/client.js

@@ -42,7 +42,7 @@ window.__ModuleLoader__.load({
     const RERUN_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.2.21'
+    const PLUGIN_VERSION = '0.3.1'
 
     // --- copy -----------------------------------------------------------------
 
@@ -64,6 +64,12 @@ window.__ModuleLoader__.load({
       'editor.save': '保存',
       'editor.rerun': '重跑',
       'editor.save-reply': '保存',
+      'editor.block': '编辑哪一块',
+      'editor.block.text': '正文',
+      'editor.block.reasoning': '思维链',
+      'editor.placeholder-block': '只改这一块；工具调用、其余内容和后续对话保持不变。',
+      'confirm.body-block': '确认后只替换这一块，工具调用、其他内容和后续对话保持不变。原始会话日志不会改写。',
+      'editor.patch-note': '思维链已改写（模型可见）',
       'editor.review': '确认执行',
       'editor.cancel': '取消',
       'editor.pending': '正在保存…',
@@ -77,6 +83,7 @@ window.__ModuleLoader__.load({
       'error.session-not-found': '找不到该会话的日志。',
       'error.busy': '该会话正在回复中，请等回复结束后再编辑。',
       'error.not-editable': '这条消息不支持编辑。',
+      'error.unsupported': '当前宿主不支持就地改写回复，需要走重放路径。',
       'error.already-rolled-back': '这条消息已经不在当前上下文里了。',
       'error.stale': '会话刚刚发生了变化，请重试。',
       'error.forbidden': '请求来源不被允许。',
@@ -112,6 +119,12 @@ window.__ModuleLoader__.load({
       'editor.save': 'Save',
       'editor.rerun': 'Re-run',
       'editor.save-reply': 'Save',
+      'editor.block': 'Block',
+      'editor.block.text': 'Answer',
+      'editor.block.reasoning': 'Reasoning',
+      'editor.placeholder-block': 'Only this block changes; tool calls, the rest of the reply and later turns stay.',
+      'confirm.body-block': 'Confirming replaces only this block; tool calls, the rest of the reply and later turns stay. The original session log is never rewritten.',
+      'editor.patch-note': 'Reasoning patched (model-visible)',
       'editor.review': 'Confirm',
       'editor.cancel': 'Cancel',
       'editor.pending': 'Working...',
@@ -125,6 +138,7 @@ window.__ModuleLoader__.load({
       'error.session-not-found': 'No session log was found for this id.',
       'error.busy': 'This session is still replying; wait for it to finish.',
       'error.not-editable': 'This message cannot be edited.',
+      'error.unsupported': 'This harness does not expose the in-place reply path; the replay path is needed.',
       'error.already-rolled-back': 'This message is no longer in the current context.',
       'error.stale': 'The session just changed; try again.',
       'error.forbidden': 'The request origin is not allowed.',
@@ -283,6 +297,12 @@ window.__ModuleLoader__.load({
       '.dshet-btn:disabled{cursor:default;opacity:.5}',
       '.dshet-btn-primary{border-color:var(--dsw-alias-button-primary-fill,var(--dshet-accent));background:var(--dsw-alias-button-primary-fill,var(--dshet-accent));color:var(--dsw-alias-label-primary-foreground,var(--dshet-on-accent))}',
       '.dshet-btn-primary:hover:not(:disabled){background:var(--dsw-alias-button-primary-fill,var(--dshet-accent));filter:brightness(1.08)}',
+      '.dshet-pick{display:flex;align-items:center;gap:8px;padding:8px 12px 0;font-size:12px;color:var(--dshet-ink-dim)}',
+      '.dshet-select{padding:3px 8px;border:1px solid var(--dshet-line);border-radius:8px;background:var(--dshet-field);color:var(--dshet-ink);font:inherit;font-size:12px;line-height:18px}',
+      '[data-dshet-patch]{white-space:pre-wrap}',
+      '.dshet-patch-note{margin:6px 0;padding:6px 10px;border:1px dashed var(--dshet-line);border-radius:10px;background:var(--dshet-panel);color:var(--dshet-ink-dim);font-size:12px;line-height:18px}',
+      '.dshet-patch-note summary{cursor:pointer}',
+      '.dshet-patch-note-body{margin:6px 0 0;white-space:pre-wrap;color:var(--dshet-ink);font-size:12px;line-height:18px}',
       '.dshet-notice{margin:4px 0;padding:6px 10px;border:1px solid var(--dshet-line);border-radius:8px;background:var(--dshet-panel);backdrop-filter:blur(18px) saturate(1.2);box-shadow:var(--dshet-shadow);color:var(--dsw-alias-state-error-primary,#c93a31);font-size:12px;line-height:19px}',
       '@media (prefers-reduced-motion:reduce){.dshet-collapsing{transition:none}.dshet-floating{transition:none}}',
     ].join('')
@@ -370,6 +390,15 @@ window.__ModuleLoader__.load({
           editable: new Map(),
           replies: new Map(),
           repliesByMessage: new Map(),
+          // Landed in-place reply patches, latest per block, and the same data
+          // indexed by seq for the in-place text display.
+          patches: [],
+          patchBySeq: new Map(),
+          replyMode: 'replay',
+          // The block being edited in the reply editor (null for a prompt).
+          blocks: [],
+          blockIndex: null,
+          blockKind: null,
           editing: null,
           draft: '',
           parts: [],
@@ -448,6 +477,22 @@ 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 in-place reply patches, latest per block. The model sees them
+            // through the host projection; this half uses them to draw the
+            // projected text over the recorded row.
+            const patches = []
+            const patchBySeq = new Map()
+            for (const patch of Array.isArray(data.patches) ? data.patches : []) {
+              if (!patch || typeof patch.seq !== 'number' || typeof patch.blockIndex !== 'number') continue
+              if (patch.kind !== 'text' && patch.kind !== 'reasoning') continue
+              const normalized = { seq: patch.seq, blockIndex: patch.blockIndex, kind: patch.kind, text: String(patch.text ?? '') }
+              const previous = patches.findIndex((entry) => entry.seq === normalized.seq && entry.blockIndex === normalized.blockIndex)
+              if (previous >= 0) patches[previous] = normalized
+              else patches.push(normalized)
+              let byBlock = patchBySeq.get(normalized.seq)
+              if (byBlock === undefined) { byBlock = new Map(); patchBySeq.set(normalized.seq, byBlock) }
+              byBlock.set(normalized.blockIndex, normalized)
+            }
             // 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.
@@ -466,6 +511,9 @@ window.__ModuleLoader__.load({
               editable,
               replies,
               repliesByMessage,
+              patches,
+              patchBySeq,
+              replyMode: data.mode === 'patch' ? 'patch' : 'replay',
               surfaceReady: true,
               loaded: true,
               loadError: false,
@@ -493,10 +541,34 @@ window.__ModuleLoader__.load({
         const same = this.editor !== null && this.editor.seq === target.seq && this.editor.mode === target.mode
         const previous = this.editorElement
         this.load()
-        this.editor = target
+        // A reply on the patch path carries its editable blocks; open the one
+        // the editor was asked for, or the answer text when none was named.
+        const replyBlocks = target.mode === 'reply' && Array.isArray(target.blocks) ? target.blocks : []
+        const requested = typeof target.blockIndex === 'number'
+          ? replyBlocks.find((block) => block.index === target.blockIndex)
+          : undefined
+        // Pressing the same pencil again keeps the block the user already
+        // switched to; only a fresh open picks the answer block by default.
+        const current = same && typeof this.editorBlockIndex === 'number'
+          ? replyBlocks.find((block) => block.index === this.editorBlockIndex)
+          : undefined
+        const chosen = current ?? requested ?? replyBlocks.find((block) => block.kind === 'text') ?? replyBlocks[0]
+        const normalized = replyBlocks.length > 0
+          ? {
+              ...target,
+              patch: true,
+              blocks: replyBlocks,
+              blockIndex: chosen === undefined ? undefined : chosen.index,
+              blockKind: chosen === undefined ? undefined : chosen.kind,
+            }
+          : target
+        this.editor = normalized
+        this.editorBlocks = replyBlocks
+        this.editorBlockIndex = chosen === undefined ? null : chosen.index
+        this.editorBlockKind = chosen === undefined ? null : chosen.kind
         if (!same) {
-          this.editorDraft = target.text
-          this.editorParts = blocksToParts(target, this.sessionId)
+          this.editorDraft = chosen === undefined ? target.text : chosen.text
+          this.editorParts = blocksToParts(normalized, this.sessionId)
         }
         this.confirming = false
         this.editorElement = null
@@ -513,7 +585,16 @@ window.__ModuleLoader__.load({
             /* focus is best-effort */
           }
         }
-        this.publish({ editing: target, draft: this.editorDraft, parts: this.editorParts.slice(), confirming: false, failure: null })
+        this.publish({
+          editing: normalized,
+          draft: this.editorDraft,
+          parts: this.editorParts.slice(),
+          blocks: replyBlocks,
+          blockIndex: this.editorBlockIndex,
+          blockKind: this.editorBlockKind,
+          confirming: false,
+          failure: null,
+        })
         this.probeSiblingRerun()
       }
 
@@ -541,6 +622,22 @@ window.__ModuleLoader__.load({
         if (this.view.siblingRerun !== next) this.publish({ siblingRerun: next })
       }
 
+      // Pick another block of the same reply. The editor is rebuilt by the
+      // block index in its marker; the draft becomes that block's current
+      // (already projected) text.
+      selectBlock(index) {
+        if (this.view.pending) return
+        const target = this.editor
+        if (target === null || !Array.isArray(target.blocks)) return
+        const block = target.blocks.find((entry) => entry.index === index)
+        if (block === undefined || block.kind === undefined) return
+        this.editorBlockIndex = block.index
+        this.editorBlockKind = block.kind
+        this.editorDraft = block.text
+        this.editorElement = null
+        this.publish({ draft: block.text, blockIndex: block.index, blockKind: block.kind, failure: null })
+      }
+
       close() {
         if (this.view.pending) return
         this.pendingRerun = false
@@ -553,7 +650,10 @@ window.__ModuleLoader__.load({
         this.editorParts = []
         this.confirming = false
         this.editorElement = null
-        this.publish({ editing: null, draft: '', parts: [], confirming: false, failure: null })
+        this.editorBlocks = []
+        this.editorBlockIndex = null
+        this.editorBlockKind = null
+        this.publish({ editing: null, draft: '', parts: [], blocks: [], blockIndex: null, blockKind: null, confirming: false, failure: null })
       }
 
       setDraft(value) {
@@ -683,6 +783,11 @@ window.__ModuleLoader__.load({
               messageId: typeof target.messageId === 'string' ? target.messageId : undefined,
               text,
               ...(parts === undefined ? {} : { parts }),
+              // The in-place reply path names one block; the host validates that
+              // it is still that kind at that index before writing the record.
+              ...(target.patch === true && typeof this.editorBlockIndex === 'number'
+                ? { blockIndex: this.editorBlockIndex, kind: this.editorBlockKind }
+                : {}),
             }),
           })
           const data = await res.json().catch(() => ({}))
@@ -724,6 +829,40 @@ window.__ModuleLoader__.load({
           // 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)
+          // The in-place path wrote one small record and touched no surface
+          // row: the reply stays where it is, and its block list is updated
+          // optimistically so the next render already shows the new text.
+          let patches = this.view.patches
+          let patchBySeq = this.view.patchBySeq
+          if (data.mode === 'patch' && data.target && typeof data.target.blockIndex === 'number') {
+            const targetPatch = {
+              seq: target.seq,
+              blockIndex: data.target.blockIndex,
+              kind: data.target.kind === 'reasoning' ? 'reasoning' : 'text',
+              text: String(data.target.text ?? ''),
+            }
+            patches = patches
+              .filter((entry) => !(entry.seq === targetPatch.seq && entry.blockIndex === targetPatch.blockIndex))
+              .concat([targetPatch])
+            patchBySeq = new Map(patchBySeq)
+            const byBlock = new Map(patchBySeq.get(targetPatch.seq) ?? [])
+            byBlock.set(targetPatch.blockIndex, targetPatch)
+            patchBySeq.set(targetPatch.seq, byBlock)
+            const entry = replies.get(target.seq)
+            if (entry !== undefined && Array.isArray(entry.blocks)) {
+              const blocks = entry.blocks.map((block) =>
+                block.index === targetPatch.blockIndex
+                  ? { ...block, text: targetPatch.text, patched: true }
+                  : block)
+              const text = blocks.filter((block) => block.kind === 'text').map((block) => block.text).join('\n')
+              replies.set(target.seq, {
+                ...entry,
+                blocks,
+                text,
+                patched: blocks.some((block) => block.patched === true),
+              })
+            }
+          }
           for (const entry of replies.values()) {
             if (hidden.has(entry.seq)) replies.delete(entry.seq)
           }
@@ -744,6 +883,11 @@ window.__ModuleLoader__.load({
             revisions,
             editable,
             replies,
+            patches,
+            patchBySeq,
+            blocks: [],
+            blockIndex: null,
+            blockKind: null,
             parts: [],
             failure: null,
           })
@@ -1965,6 +2109,8 @@ window.__ModuleLoader__.load({
         // saving would write, so both have to redraw the strip - and the chip
         // keys are enough to tell one list from another.
         view.parts.map((part) => part.key).join('.'),
+        // The selected reply block: switching blocks has to rebuild the box.
+        view.blockIndex === null || view.blockIndex === undefined ? '' : String(view.blockIndex),
       ].join('|')
     }
 
@@ -1973,9 +2119,10 @@ window.__ModuleLoader__.load({
     // from drifting apart in wording.
     function editorTexts(t, target) {
       const reply = target.mode === 'reply'
+      const block = reply && target.patch === true
       return {
         title: t(reply ? 'editor.title-reply' : 'editor.title'),
-        placeholder: t(reply ? 'editor.placeholder-reply' : 'editor.placeholder'),
+        placeholder: t(block ? 'editor.placeholder-block' : reply ? 'editor.placeholder-reply' : 'editor.placeholder'),
         warn: t(reply ? 'editor.warn-reply' : 'editor.warn.attachments'),
         // Saving writes the revision into the context; only the opt-in config asks
         // the model again, and the button says which one will happen.
@@ -2108,6 +2255,34 @@ window.__ModuleLoader__.load({
       box.dataset[EDITOR_ATTR] = '1'
       box.dataset.dshetFor = marker
 
+      // A reply on the patch path may carry several editable blocks (answer
+      // text and reasoning). The picker chooses which one this save targets;
+      // every option carries the block's CURRENT projected text, so switching
+      // never shows the recorded original over a landed patch.
+      if (target.mode === 'reply' && target.patch === true && Array.isArray(target.blocks) && target.blocks.length > 1) {
+        const picker = document.createElement('label')
+        picker.className = 'dshet-pick'
+        const caption = document.createElement('span')
+        caption.textContent = t('editor.block')
+        const select = document.createElement('select')
+        select.className = 'dshet-select'
+        select.disabled = view.pending || view.confirming
+        select.setAttribute('aria-label', t('editor.block'))
+        for (const block of target.blocks) {
+          const option = document.createElement('option')
+          option.value = String(block.index)
+          const kind = block.kind === 'reasoning' ? 'editor.block.reasoning' : 'editor.block.text'
+          option.textContent = t(kind)
+          option.selected = block.index === view.blockIndex
+          select.appendChild(option)
+        }
+        if (view.blockIndex !== null && view.blockIndex !== undefined) select.value = String(view.blockIndex)
+        select.addEventListener('change', () => controller.selectBlock(Number(select.value)))
+        picker.appendChild(caption)
+        picker.appendChild(select)
+        box.appendChild(picker)
+      }
+
       const area = document.createElement('textarea')
       area.rows = 1
       area.value = controller.editorDraft
@@ -2167,12 +2342,12 @@ window.__ModuleLoader__.load({
       if (view.confirming) {
         const note = document.createElement('p')
         note.className = 'dshet-note'
-        note.textContent = t('confirm.body')
+        note.textContent = t(target.mode === 'reply' && target.patch === true ? 'confirm.body-block' : 'confirm.body')
         box.appendChild(note)
       }
       // Shown when saving really would drop something: a reply's tool calls
       // always, and a prompt's blocks when this host cannot carry them.
-      if (target.attachments > 0 && !chips) {
+      if (target.attachments > 0 && !chips && !(target.mode === 'reply' && target.patch === true)) {
         const warn = document.createElement('p')
         warn.className = 'dshet-warn'
         warn.textContent = texts.warn
@@ -2264,6 +2439,318 @@ window.__ModuleLoader__.load({
       controller.load(true)
     }
 
+    // --- projected reply display ---------------------------------------------
+    //
+    // The host draws a reply from the recorded event, not from the projected
+    // message, so a landed patch would be invisible in the transcript. The
+    // projection is the model's copy; this is the reader's copy. Text blocks are
+    // replaced in place inside the host's own markdown container (the row,
+    // actions and tool cards stay untouched); a patched reasoning block gets a
+    // small note under the reply, because the host renders reasoning as a
+    // collapsed panel that may not be in the DOM at all.
+
+    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()
+    }
+
+    // Markdown syntax is not part of the rendered textContent. Strip the
+    // structural characters before comparing, so a reply that uses **bold** or
+    // a fenced block still matches its own recorded text.
+    function plainText(value) {
+      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
+      if (kids.length === 0) return false
+      let blocks = 0
+      for (const kid of kids) {
+        try {
+          if (kid.matches && kid.matches('p, pre, ul, ol, blockquote, h1, h2, h3, h4, h5, h6, table')) blocks += 1
+        } catch {
+          return false
+        }
+      }
+      return blocks >= 1 && blocks * 2 >= kids.length
+    }
+
+    function conversationRootForPatches() {
+      const root = document.querySelector('[data-slot="main.conversation"], [data-slot="conversation"]')
+      return root ?? document.body
+    }
+
+    function restorePatchedBlock(el) {
+      const saved = patchOriginals.get(el)
+      if (saved !== null && saved !== undefined) {
+        try {
+          if (typeof saved.html === 'string' && saved.html !== '') el.innerHTML = saved.html
+          else if (typeof saved.text === 'string') el.textContent = saved.text
+        } catch {
+          /* a detached row is not worth a throw */
+        }
+      }
+      el.removeAttribute(PATCH_ATTR)
+      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
+          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 */
+      }
+      const root = conversationRootForPatches()
+      if (root === null) return
+      const replies = view.replies instanceof Map ? view.replies : new Map()
+      const wantedText = new Map()
+      const wantedNotes = new Map()
+      for (const patch of Array.isArray(view.patches) ? view.patches : []) {
+        const reply = replies.get(patch.seq)
+        if (reply === undefined || !Array.isArray(reply.blocks)) continue
+        const block = reply.blocks.find((entry) => entry.index === patch.blockIndex)
+        if (block === undefined) continue
+        if (patch.kind === 'text') {
+          wantedText.set(`${patch.seq}:${patch.blockIndex}`, {
+            key: `${patch.seq}:${patch.blockIndex}`,
+            seq: patch.seq,
+            original: String(block.original ?? ''),
+            text: String(patch.text ?? ''),
+          })
+        } else if (patch.kind === 'reasoning') {
+          wantedNotes.set(`${patch.seq}:${patch.blockIndex}`, {
+            key: `${patch.seq}:${patch.blockIndex}`,
+            text: String(patch.text ?? ''),
+            reply,
+            block,
+          })
+        }
+      }
+
+      // 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}]`)]) {
+        const key = el.getAttribute(PATCH_ATTR)
+        const wanted = wantedText.get(key)
+        if (wanted === undefined) {
+          restorePatchedBlock(el)
+          continue
+        }
+        const shown = displayText(wanted.text)
+        if (normalizedText(el.textContent) !== normalizedText(shown)) {
+          el.textContent = shown
+        }
+      }
+      for (const note of [...root.querySelectorAll(`[${NOTE_ATTR}]`)]) {
+        const key = note.getAttribute(NOTE_ATTR)
+        if (!wantedNotes.has(key)) note.remove()
+      }
+      if (wantedText.size === 0 && wantedNotes.size === 0) return
+
+      const nodes = [...root.querySelectorAll('[data-slot="conversation.chat.node"]')]
+      const containers = []
+      for (const node of nodes) {
+        for (const el of node.querySelectorAll('*')) {
+          try {
+            if (isMarkdownContainer(el) && el.closest('.dshet-editor, .dshet-pick, .dshet-patch-note') === null) containers.push(el)
+          } catch {
+            /* a detached node is skipped */
+          }
+        }
+      }
+      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) {
+          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
+        for (const el of containers) {
+          if (el.getAttribute(PATCH_ATTR) !== null) continue
+          if (owner !== undefined) {
+            try {
+              if (el.closest('[data-chat-flow-key]') !== owner) continue
+            } catch {
+              /* no closest on this node: keep the global match */
+            }
+          }
+          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))
+          if (!exact && !prefix) continue
+          // Prefer the exact match, then the container closest in length: a
+          // nested paragraph and the whole markdown body can both match a
+          // prefix, and the paragraph is the one to rewrite.
+          const score = (exact ? 0 : 1000) + Math.abs(text.length - original.length)
+          if (score < bestScore) {
+            best = el
+            bestScore = score
+          }
+        }
+        if (best === null) best = findPatchTextFallback(owner, wanted)
+        if (best === null) continue
+        patchOriginals.set(best, { html: best.innerHTML, text: best.textContent })
+        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
+      // answer text (the panel itself may be collapsed and absent).
+      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 = matchText(wanted.reply.text)
+        for (const node of row === null ? nodes : []) {
+          const text = matchText(node.textContent)
+          if (text === '') continue
+          if (replyText !== '' && text.includes(replyText)) {
+            row = node
+            break
+          }
+          if (matchText(wanted.block.original) !== '' && text.includes(matchText(wanted.block.original))) {
+            row = node
+            break
+          }
+        }
+        if (note === undefined || note === null) {
+          note = document.createElement('details')
+          note.className = 'dshet-patch-note'
+          note.setAttribute(NOTE_ATTR, key)
+          const summary = document.createElement('summary')
+          summary.textContent = t('editor.patch-note')
+          const body = document.createElement('pre')
+          body.className = 'dshet-patch-note-body'
+          note.appendChild(summary)
+          note.appendChild(body)
+        }
+        const body = note.querySelector('.dshet-patch-note-body')
+        if (body !== null && body.textContent !== wanted.text) body.textContent = wanted.text
+        if (note.isConnected !== true && row !== null) row.after(note)
+      }
+    }
+
     function applyDom(snapshot, view, controller, t) {
       if (!snapshot || !snapshot.nodes || typeof snapshot.nodes.get !== 'function') return
       const animate = controller.consumeAnimate()
@@ -2329,6 +2816,13 @@ window.__ModuleLoader__.load({
         controller.editorBox = null
         controller.editorRow = null
       }
+      // Draw the projected reply text last: the host has just rebuilt the rows,
+      // and an override applied before that would be wiped by the rebuild.
+      try {
+        applyPatchDisplay(snapshot, view, t)
+      } catch (error) {
+        console.error('[dsh-edit-turn] patch display failed:', error)
+      }
       // Whatever of ours no row of this pass claimed is a ghost of an earlier
       // apply: the host rebuilt the row under it, or the bundle was reloaded
       // over it. Contract §5 - a button nobody can update must not pile up.
@@ -2398,10 +2892,11 @@ window.__ModuleLoader__.load({
           messageId: entry.messageId,
           text: typeof entry.text === 'string' ? entry.text : '',
           attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
-          // A reply edits text only on purpose: the tool calls and reasoning it
-          // carries stop being true the moment it is replaced, so they are not
-          // offered as chips (the editor warns about them instead).
-          blocks: [],
+          // On the in-place path the reply keeps its tool calls and other
+          // blocks, so the editor can offer each editable block (output text
+          // and reasoning). On the replay path there is no block picker: the
+          // whole reply is replaced.
+          ...(Array.isArray(entry.blocks) ? { blocks: entry.blocks, patch: true } : { blocks: [] }),
         })
       }
       // The config object is always an object: this runtime's `jsx` reads
@@ -2579,6 +3074,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()