dsh-edit-turn 0.2.20 → 0.3.0

package/lib/index.js

@@ -51,6 +51,17 @@ import { randomUUID } from 'node:crypto'
 import { readFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import { defineTool } from '@deepseek-ai/dsh-tools'
+import * as sessionApi from '@deepseek-ai/dsh-session'
+import {
+  PATCH_TYPE,
+  buildPatchData,
+  editableBlocks,
+  kindOfBlock,
+  patchList,
+  patchProjection,
+  patchesOf,
+  projectedBlocks,
+} from './patch.js'
 
 const nodeRequire = createRequire(import.meta.url)
 const schemaPackage = (() => {
@@ -69,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.2.20'
+export const PLUGIN_VERSION = '0.3.0'
 
 // 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
@@ -145,6 +156,14 @@ export const Config =
          * step.
          */
         confirm: z.boolean().default(false),
+        /**
+         * How a reply edit lands. `auto` uses the in-place plugin-record
+         * projection when the host exposes it and falls back to the historical
+         * replay splice otherwise; `patch` refuses to run without the
+         * projection; `replay` always uses the old path. Prompt edits always use
+         * the official surface replacement.
+         */
+        replyMode: z.string().default('auto'),
       })
 
 // ---------------------------------------------------------------------------
@@ -237,6 +256,44 @@ export function turnIndex(events) {
   return turnOf
 }
 
+/**
+ * One turn bracket: its number, log range, first prompt and reply count.
+ *
+ * A turn NUMBER is not unique in a log - a replay reuses numbers on fresh
+ * brackets - so planning must locate the bracket that CONTAINS an event rather
+ * than the first bracket carrying its number (the same rule dsh-rerun-turn
+ * learned in 0.1.23; this is the same walk).
+ *
+ * @param events - complete contiguous raw event log.
+ * @returns one entry per `turn/start`, in log order.
+ */
+export function turnSpans(events) {
+  const spans = []
+  let open = null
+  for (const event of events) {
+    if (event.type === 'turn/start') {
+      open = {
+        turn: event.data && event.data.turn,
+        startSeq: event.seq,
+        endSeq: null,
+        promptSeq: null,
+        replies: 0,
+      }
+      spans.push(open)
+      continue
+    }
+    if (open === null) continue
+    if (event.type === 'turn/end') {
+      open.endSeq = event.seq
+      open = null
+      continue
+    }
+    if (event.type === 'user/message' && open.promptSeq === null) open.promptSeq = event.seq
+    if (event.type === 'assistant/message') open.replies += 1
+  }
+  return spans
+}
+
 /** The turn still awaiting its `turn/end`, or null when every turn closed. */
 export function openTurn(events) {
   let open = null
@@ -710,21 +767,27 @@ function resolveTarget(events, request) {
 }
 
 /**
- * Turn one UI target into the canonical rollback window.
+ * Turn one UI target into the canonical rollback window plus, for a reply, the
+ * replay range that puts the later turns back after the correction.
  *
- * The window is `[the addressed prompt .. the last surface node]`: the complete
- * remainder of the conversation in surface order. It is contiguous by
- * construction, it always ends on a completed turn's last node, and its left
- * edge is exactly the prompt being rewritten, so the surviving prefix ends on
- * the previous turn's boundary.
+ * A revised PROMPT is replaced in place: its window is the message alone, so
+ * the reply under it and everything after stay exactly where they were.
+ *
+ * A revised REPLY cannot be swapped in place - the format refuses
+ * `sourceEventSeqs` on an `assistant/message`, so a new reply can only be
+ * APPENDED. The window therefore runs from the addressed reply to the last
+ * surface node, and the correction is appended in a fresh turn. Everything the
+ * window took is replayed back behind the correction by
+ * {@link buildReplayWrites}: the same infix splice dsh-rerun-turn performs, with
+ * the user's text instead of a regenerated answer.
  *
  * @param events - complete contiguous raw event log.
  * @param surfaceNodes - current surface seqs in model order.
  * @param request - `{ seq?, messageId?, turn? }` (`turn` addresses a prompt only).
- * @returns `{ targetSeq, messageId, startSeq, endSeq, shadowed, mode, turn, step, provider, model, original, attachments }`.
+ * @returns `{ targetSeq, messageId, startSeq, endSeq, shadowed, mode, turn, step, provider, model, original, attachments, replayFrom, logTo, turnStart, turnEnd }`.
  * @throws {EditPlanError} with a stable code when the target cannot be planned.
  */
-export function planRollback(events, surfaceNodes, request) {
+export function planRollback(events, surfaceNodes, request, options = {}) {
   const nodeIndex = new Map(surfaceNodes.map((seq, index) => [seq, index]))
   const turnOf = turnIndex(events)
   const target = resolveTarget(events, request, turnOf)
@@ -737,31 +800,112 @@ export function planRollback(events, surfaceNodes, request) {
     throw new EditPlanError('not-editable', 'the system prompt head cannot be edited')
   }
   // Two editable kinds. A prompt is rewritten in place and the conversation
-  // continues; a reply is replaced and everything built on it goes with it.
+  // continues; a reply is either patched in place through the message projection
+  // or, on a host without it, replaced by an appended correction and a replay.
   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 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
+  const step = typeof data.step === 'number' ? data.step : 1
+  const contentBlocks = readMessageBlocks(target)
+
+  // The in-place path: one block of the reply, rewritten by a plugin record and
+  // its projection. Nothing leaves the surface, so there is no window and no
+  // replay; the tool calls and the other blocks stay exactly as recorded.
+  if (mode === 'reply' && options.patch === true) {
+    const patches = options.patches instanceof Map ? options.patches : new Map()
+    const blocks = projectedBlocks(message, target.seq, patches)
+    if (blocks.length === 0) {
+      throw new EditPlanError('not-editable', 'this reply has no editable block')
+    }
+    const wanted = typeof request.blockIndex === 'number'
+      ? blocks.find((block) => block.index === request.blockIndex)
+      : blocks.find((block) => block.kind === 'text') ?? blocks[0]
+    if (wanted === undefined) throw new EditPlanError('not-editable', 'the requested block does not exist')
+    if (typeof request.kind === 'string' && request.kind !== wanted.kind) {
+      throw new EditPlanError('not-editable', 'the requested block changed kind')
+    }
+    return {
+      targetSeq: target.seq,
+      messageId: messageIdOf(target),
+      mode: 'reply',
+      patch: true,
+      startSeq: null,
+      endSeq: null,
+      shadowed: [],
+      blockIndex: wanted.index,
+      kind: wanted.kind,
+      original: wanted.text,
+      // `blocks` here are the EDITOR's blocks (index/kind/text/original), not
+      // the raw content array; patch mode never rebuilds a message carrier.
+      blocks,
+      turn: typeof turn === 'number' ? turn : null,
+      step,
+      provider: source && typeof source.provider === 'string' ? source.provider : null,
+      model: source && typeof source.model === 'string' ? source.model : null,
+      attachments: contentBlocks.filter((block) => kindOfBlock(block) === null).length,
+    }
+  }
   const startIdx = nodeIndex.get(target.seq)
   // Two different windows, because the two edits mean different things.
   //
   // A revised PROMPT is replaced in place: only the message itself leaves the
-  // surface, so the reply under it and everything after stay exactly as they
-  // were - edit the wording, keep the conversation. A revised REPLY cannot do
-  // that (an answer invalidates whatever was built on it), so its window runs to
-  // the tail and the turn is closed again behind the correction.
+  // surface, so the reply under it and everything after stay exactly where they
+  // were - edit the wording, keep the conversation.
+  //
+  // A revised REPLY cannot be a replacement carrier (the format refuses
+  // `sourceEventSeqs` on an assistant message), so the correction is appended
+  // at the tail and everything from the addressed reply to the end must leave
+  // the surface first. `buildReplayWrites` then puts every later turn back,
+  // event by event, with fresh turn numbers and message ids - the model reads
+  // prefix + corrected reply + the same later turns, in order.
   const shadowed = mode === 'prompt' ? [target.seq] : surfaceNodes.slice(startIdx)
   if (shadowed.length === 0 || shadowed[0] !== target.seq) {
     throw new EditPlanError('not-editable', 'the target does not open a rollback window')
   }
+  // The replay range: the log range the shadow covers, and the bracket where
+  // the later turns start. A reply in the last turn has neither, and the edit
+  // degenerates to the old tail-less rollback (there is nothing to replay).
+  let replayFrom = null
+  let logTo = null
+  let turnStart = null
+  let turnEnd = null
+  if (mode === 'reply') {
+    const spans = turnSpans(events)
+    // A closed bracket that CONTAINS the reply. The fallback (the last bracket
+    // that starts before it) only matters for a malformed log with a bracket
+    // that never closed; a valid log always takes the containment branch.
+    const owning = spans.find(
+      (entry) => entry.endSeq !== null && entry.startSeq <= target.seq && target.seq <= entry.endSeq,
+    ) ?? spans.filter((entry) => entry.startSeq <= target.seq).at(-1)
+    if (owning !== undefined) {
+      turnStart = owning.startSeq
+      turnEnd = owning.endSeq
+    }
+    const lastShadowed = shadowed[shadowed.length - 1]
+    const bySeq = new Map(events.map((event) => [event.seq, event]))
+    logTo = lastShadowed
+    for (let seq = lastShadowed + 1; ; seq += 1) {
+      const event = bySeq.get(seq)
+      if (event === undefined) break
+      // The window already ends on the last surface node: only log-only events
+      // (step/turn closing records) can follow it.
+      if (isSurfaceEvent(event)) break
+      logTo = seq
+      if (event.type === 'turn/end') break
+    }
+    const owningIndex = owning === undefined ? -1 : spans.indexOf(owning)
+    const nextSpan = owningIndex >= 0 ? spans[owningIndex + 1] : undefined
+    if (nextSpan !== undefined && nextSpan.startSeq <= logTo) replayFrom = nextSpan.startSeq
+  }
   const { text, attachments } = readMessageText(target)
   // The blocks themselves travel with the plan: the carrier is rebuilt from
   // them, so no caller has to re-read the message to know what it carries.
-  const blocks = readMessageBlocks(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
+  const blocks = contentBlocks
   return {
     targetSeq: target.seq,
     messageId: messageIdOf(target),
@@ -769,18 +913,305 @@ export function planRollback(events, surfaceNodes, request) {
     endSeq: shadowed[shadowed.length - 1],
     shadowed,
     mode,
+    patch: false,
     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,
+    step,
     provider: source && typeof source.provider === 'string' ? source.provider : null,
     model: source && typeof source.model === 'string' ? source.model : null,
     original: text,
     attachments,
     blocks,
+    // Reply-only replay range. `replayFrom` is the next turn's bracket (null when
+    // the edited reply is in the last turn); `logTo` is the end of the last turn
+    // the window shadowed. Both are computed from the ORIGINAL log and stay valid
+    // while the correction is appended after it.
+    replayFrom,
+    logTo,
+    turnStart,
+    turnEnd,
+  }
+}
+
+// --- reply replay -----------------------------------------------------------
+//
+// A reply edit lands exactly like a rerun's infix splice: the shadow takes the
+// old answer and every later turn off the surface, the correction is appended in
+// a fresh turn, and this walk puts the later turns back as fresh copies. The
+// algorithm is the one dsh-rerun-turn ships (`buildReplayWrites` there); keep the
+// two in step - `test/replay-parity.test.js` compares their output on one log
+// when the sibling repository is checked out.
+
+/** Marker written into every replayed event's source. */
+export const REPLAY_MARKER = PLUGIN_ID
+
+/** Text that carries nothing a model could read (spaces, zero-width glue). */
+const INVISIBLE_TEXT_RE = /^[\s\u200b-\u200f\u2060\ufeff]*$/
+
+/**
+ * Whether content blocks carry anything readable.
+ * @param content - the `content` array of a message.
+ * @returns true when at least one block is not invisible text.
+ */
+export function hasReadableContent(content) {
+  if (!Array.isArray(content)) return false
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue
+    if (block.type !== 'text') return true
+    if (typeof block.text !== 'string' || !INVISIBLE_TEXT_RE.test(block.text)) return true
+  }
+  return false
+}
+
+/**
+ * Whether an event is a plugin's silent surface carrier rather than conversation.
+ *
+ * `dsh-delete-turn` writes one for a deletion and `dsh-rerun-turn` for a rerun's
+ * shadow - a `user/message` whose source kind is `plugin:<id>` and whose content
+ * is empty or invisible. A replay must retire it without a copy: it projects to
+ * no model message, so copying it would resurrect an empty user node.
+ *
+ * A rewritten prompt is NOT this shape: `dsh-edit-turn` keeps `kind: 'user'` and
+ * carries the user's wording, so it stays a real prompt and is copied.
+ *
+ * @param event - raw session event.
+ * @returns true for a text-free plugin replacement.
+ */
+export function isSilentPluginCarrier(event) {
+  if (!event || event.type !== 'user/message') return false
+  const data = event.data || {}
+  const source = data.source
+  if (!source || typeof source.kind !== 'string' || !source.kind.startsWith('plugin:')) return false
+  return !hasReadableContent(data.content)
+}
+
+/** Stamp one copied event's source with this plugin's replay markers. */
+function replaySource(source, replayId, originalSeq) {
+  return {
+    ...(source && typeof source === 'object' ? source : {}),
+    replayBy: REPLAY_MARKER,
+    replayId,
+    originalSeq,
   }
 }
 
+/**
+ * Build the replay writes for a reply edit's shadowed tail.
+ *
+ * Every shadowed event after the edited reply is copied verbatim except for:
+ * fresh turn numbers (the log requires them contiguous), fresh message ids,
+ * remapped `sourceEventSeqs` on tool results, dropped usage numbers and embedded
+ * streams, and the replay marker in each message source. System, developer and
+ * every log-only record are skipped: they describe the original run, not the
+ * conversation.
+ *
+ * Tool calls are copied only as complete pairs. A call whose result never landed
+ * (an interrupted turn) is dropped along with its advertisement in the copied
+ * assistant content, because the format refuses a turn that closes with an
+ * unresolved call. The inverse repair shape - a `TOOL_NOT_STARTED` result with no
+ * call event - is copied as-is and keeps its absent `sourceEventSeqs`: the
+ * validator accepts that repair only without one.
+ *
+ * @param events - complete contiguous raw event log (the pre-edit snapshot).
+ * @param plan - the planned window (`shadowed`, `replayFrom`, `logTo`).
+ * @param baseTurn - the first fresh turn number the replay may use.
+ * @param replayId - the operation identity recorded on every copy.
+ * @param startSeq - the seq the first write will land at (writes are appended
+ *   back to back, so each predicted seq is `startSeq` + its offset).
+ * @param promptCopied - parity with dsh-rerun-turn's builder: when true, the
+ *   plan's `promptSeq` is replayed too. A reply edit never shadows the prompt,
+ *   so its own plans leave this false.
+ * @returns an ordered `{ type, data, surfaceOp?, sourceEventSeqs? }` write list.
+ */
+export function buildReplayWrites(events, plan, baseTurn, replayId, startSeq, promptCopied = false) {
+  const shadowedSet = new Set(plan.shadowed)
+  const bySeq = new Map(events.map((event) => [event.seq, event]))
+  const turnOf = turnIndex(events)
+  const shadowedTurns = new Set()
+  for (const seq of plan.shadowed) {
+    const turn = turnOf.get(seq)
+    if (typeof turn === 'number') shadowedTurns.add(turn)
+  }
+  const included = (event) => {
+    if (isSurfaceEvent(event)) return shadowedSet.has(event.seq)
+    if (
+      event.type === 'turn/start' ||
+      event.type === 'turn/end' ||
+      event.type === 'step/start' ||
+      event.type === 'step/end' ||
+      event.type === 'tool/call'
+    ) {
+      return typeof event.data.turn === 'number' && shadowedTurns.has(event.data.turn)
+    }
+    return false
+  }
+  const range = []
+  // `replayFrom` is this plugin's plan field; `logFrom` is the name the sibling
+  // builder uses, accepted here so the parity test can feed one plan object.
+  const walkFrom = typeof plan.replayFrom === 'number' ? plan.replayFrom : plan.logFrom
+  for (let seq = walkFrom; seq <= plan.logTo; seq += 1) {
+    const event = bySeq.get(seq)
+    if (event === undefined) continue
+    if (included(event)) range.push(event)
+  }
+  // Tool pairing facts for the whole range, so assistant content can be
+  // corrected before anything is written.
+  const calledIds = new Set()
+  const resultIds = new Set()
+  const repairIds = new Set()
+  for (const event of range) {
+    if (event.type === 'tool/call') calledIds.add(event.data.callId)
+    else if (event.type === 'tool/result') {
+      resultIds.add(event.data.message && event.data.message.source ? event.data.message.source.callId : event.data.callId)
+      const error = event.data.error
+      if (error && error.name === 'ToolNotStartedError' && error.code === 'TOOL_NOT_STARTED' && event.sourceEventSeqs === undefined) {
+        repairIds.add(event.data.message && event.data.message.source ? event.data.message.source.callId : event.data.callId)
+      }
+    }
+  }
+  const healthyIds = new Set()
+  for (const id of calledIds) if (resultIds.has(id)) healthyIds.add(id)
+  for (const id of repairIds) if (!calledIds.has(id)) healthyIds.add(id)
+  const pairedResultIds = new Set()
+  for (const id of calledIds) if (resultIds.has(id)) pairedResultIds.add(id)
+  for (const id of repairIds) if (!calledIds.has(id)) pairedResultIds.add(id)
+
+  const writes = []
+  let predicted = startSeq
+  let nextTurn = baseTurn
+  const turnMap = new Map()
+  const assistantSeqById = new Map()
+  let lastAssistantSeq = null
+  const seqOf = () => {
+    const seq = predicted
+    predicted += 1
+    return seq
+  }
+  for (const event of range) {
+    const data = event.data || {}
+    if (event.type === 'turn/start') {
+      turnMap.set(data.turn, nextTurn)
+      writes.push({ type: 'turn/start', data: { turn: nextTurn } })
+      seqOf()
+      continue
+    }
+    if (event.type === 'turn/end') {
+      writes.push({ type: 'turn/end', data: { turn: turnMap.get(data.turn), reason: data.reason } })
+      seqOf()
+      nextTurn += 1
+      continue
+    }
+    if (event.type === 'step/start' || event.type === 'step/end') {
+      writes.push({ type: event.type, data: { turn: turnMap.get(data.turn), step: data.step } })
+      seqOf()
+      continue
+    }
+    if (event.type === 'user/message') {
+      if (event.seq === plan.promptSeq && promptCopied !== true) continue
+      // A silent carrier standing where a prompt was is bookkeeping, not
+      // conversation: retire it without a copy, exactly as rerun does.
+      if (isSilentPluginCarrier(event)) continue
+      writes.push({
+        type: 'user/message',
+        surfaceOp: 'append',
+        data: {
+          id: randomUUID(),
+          role: 'user',
+          content: data.content,
+          source: replaySource(data.source, replayId, event.seq),
+        },
+      })
+      seqOf()
+      continue
+    }
+    if (event.type === 'assistant/message') {
+      const message = data.message || {}
+      const source = { ...(message.source || {}) }
+      delete source.replayState
+      const content = Array.isArray(message.content)
+        ? message.content.filter((block) => !(block && block.type === 'tool-call' && !healthyIds.has(block.id)))
+        : []
+      writes.push({
+        type: 'assistant/message',
+        surfaceOp: 'append',
+        data: {
+          turn: turnMap.get(data.turn),
+          step: data.step,
+          message: {
+            id: randomUUID(),
+            role: 'assistant',
+            content,
+            source: replaySource(source, replayId, event.seq),
+          },
+          stream: [],
+          ...(data.interrupted === true ? { interrupted: true } : {}),
+        },
+      })
+      assistantSeqById.set(event.seq, predicted)
+      lastAssistantSeq = predicted
+      seqOf()
+      continue
+    }
+    if (event.type === 'tool/call') {
+      if (!pairedResultIds.has(data.callId)) continue
+      writes.push({
+        type: 'tool/call',
+        data: { turn: turnMap.get(data.turn), step: data.step, callId: data.callId, name: data.name, arguments: data.arguments },
+      })
+      seqOf()
+      continue
+    }
+    if (event.type === 'tool/result') {
+      const callId = data.message && data.message.source ? data.message.source.callId : data.callId
+      if (!pairedResultIds.has(callId)) continue
+      const message = data.message
+      const source = replaySource(message && message.source, replayId, event.seq)
+      // The TOOL_NOT_STARTED repair is accepted only without sourceEventSeqs;
+      // ordinary results remap theirs onto the copied assistant message.
+      let sourceEventSeqs
+      if (!repairIds.has(callId)) {
+        const remapped = Array.isArray(event.sourceEventSeqs)
+          ? event.sourceEventSeqs.map((seq) => assistantSeqById.get(seq)).filter((seq) => typeof seq === 'number')
+          : []
+        if (remapped.length > 0) sourceEventSeqs = remapped
+        else if (typeof lastAssistantSeq === 'number') sourceEventSeqs = [lastAssistantSeq]
+      }
+      const originalMessage = message || {}
+      const rest = { ...originalMessage }
+      delete rest.id
+      delete rest.content
+      delete rest.source
+      // The interrupted-repair carrier must keep its contract-shaped id
+      // (`interrupted-tool-result-<callId>-<n>`): the validator refuses a repair
+      // whose id does not match, and a random id breaks it. The suffix is the
+      // copy's own predicted seq, so the identity stays self-describing.
+      const messageId = repairIds.has(callId) ? `interrupted-tool-result-${callId}-${predicted}` : randomUUID()
+      writes.push({
+        type: 'tool/result',
+        surfaceOp: 'append',
+        ...(sourceEventSeqs === undefined ? {} : { sourceEventSeqs }),
+        data: {
+          turn: turnMap.get(data.turn),
+          step: data.step,
+          message: {
+            ...rest,
+            id: messageId,
+            content: originalMessage.content ?? [],
+            source,
+          },
+          ...(data.error === undefined ? {} : { error: data.error }),
+          ...(data.meta === undefined ? {} : { meta: data.meta }),
+        },
+      })
+      seqOf()
+      continue
+    }
+    // system/message, developer/message and every log-only record are skipped.
+  }
+  return writes
+}
+
 /**
  * Every human prompt that can currently be edited.
  *
@@ -826,34 +1257,48 @@ export function editableTurns(events, surfaceNodes, options = {}) {
 /**
  * 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.
+ * In patch mode (the in-place projection path) a reply is offered when it has
+ * any editable block - output text or a reasoning/thinking block - and the
+ * blocks travel with the entry so the editor can pick one. In the legacy replay
+ * mode only text is editable, and a reply without text is skipped.
  *
  * @param events - complete contiguous raw event log.
  * @param surfaceNodes - current surface seqs in model order.
+ * @param options - `{ patches, patch }`: landed patch overlays and whether the
+ *   deployment can write a patch record.
  * @returns one entry per editable reply, in conversation order.
  */
-export function editableReplies(events, surfaceNodes) {
+export function editableReplies(events, surfaceNodes, options = {}) {
   const nodeIndex = new Map(surfaceNodes.map((seq, index) => [seq, index]))
   const turnOf = turnIndex(events)
   const head = surfaceNodes[0]
+  const patches = options.patches instanceof Map ? options.patches : new Map()
+  const patch = options.patch === true
   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 data = event.data && typeof event.data === 'object' ? event.data : {}
+    const message = data.message && typeof data.message === 'object' ? data.message : data
+    const blocks = projectedBlocks(message, event.seq, patches)
+    if (blocks.length === 0) continue
+    const text = blocks.filter((block) => block.kind === 'text').map((block) => block.text).join('\n')
+    if (!patch && text.trim() === '') continue
+    if (patch && blocks.every((block) => block.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,
+      // For a reply these are the blocks a text-only rewrite would drop:
+      // tool calls and any other non-editable content.
+      attachments: readMessageBlocks(event).filter((block) => patch ? kindOfBlock(block) === null : !isTextBlock(block)).length,
+      patched: blocks.some((block) => block.patched),
+      // Present only where the editor can target one: the replay path can only
+      // replace the whole reply, so it has no block picker.
+      ...(patch ? { blocks } : {}),
     })
   }
   return out
@@ -1199,13 +1644,14 @@ async function stateOf(ctx, sessionId, config) {
   }
   const folded = foldSurface(events)
   const ledger = rollbackLedger(events)
+  const patches = patchesOf(events)
   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
   // editor promising to keep blocks the host would have to drop.
   const store = resolveAttachmentStore(ctx)
   const turns = editableTurns(events, folded.nodes, { preview: canPreviewAttachments(store) })
-  const replies = editableReplies(events, folded.nodes)
+  const replies = editableReplies(events, folded.nodes, { patches, patch: config.patch === true })
   noteRequest({
     kind: 'state',
     sessionId,
@@ -1227,6 +1673,11 @@ async function stateOf(ctx, sessionId, config) {
     surface: folded.nodes,
     turns,
     replies,
+    // 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),
+    mode: config.patch === true ? 'patch' : 'replay',
     live: Boolean(live),
     busy: isBusy(events),
     lastSeq: events.length > 0 ? events[events.length - 1].seq : -1,
@@ -1235,7 +1686,7 @@ async function stateOf(ctx, sessionId, config) {
     // path (a chip that may draw its own thumbnail); both are answered from a
     // live service probe, so the editor never promises what the host cannot do.
     capabilities: { attachments: store !== null, preview: canPreviewAttachments(store) },
-    config: { confirm: config.confirm },
+    config: { confirm: config.confirm, replyMode: config.replyMode, patch: config.patch === true },
     version: PLUGIN_VERSION,
   }
 }
@@ -1352,13 +1803,17 @@ async function applyEdit(ctx, sessionId, body, config) {
   if (isBusy(events)) throw new HttpError(409, 'busy', 'the session is still working')
 
   const surfaceNodes = surfaceOf(ctx, sessionId, events)
+  const patches = patchesOf(events)
+  const patchMode = config.patch === true
   let plan
   try {
     plan = planRollback(events, surfaceNodes, {
       seq: typeof body.seq === 'number' ? body.seq : undefined,
       messageId: typeof body.messageId === 'string' ? body.messageId : undefined,
       turn: typeof body.turn === 'number' ? body.turn : undefined,
-    })
+      blockIndex: typeof body.blockIndex === 'number' ? body.blockIndex : undefined,
+      kind: typeof body.kind === 'string' ? body.kind : undefined,
+    }, { patches, patch: patchMode })
   } catch (error) {
     if (error instanceof EditPlanError) {
       const status = error.code === 'not-editable' ? 400 : 409
@@ -1367,6 +1822,56 @@ async function applyEdit(ctx, sessionId, body, config) {
     throw error
   }
 
+  // The in-place reply path: one small plugin record, interpreted by this
+  // plugin's projection. Nothing leaves the surface, so there is no window to
+  // check, no turn to open and no tail to replay. The record is append-only and
+  // the original event keeps its bytes; the model sees the patched block on the
+  // next fold.
+  if (plan.patch === true) {
+    if (typeof sessionApi.appendPluginRecord !== 'function') {
+      throw new HttpError(409, 'unsupported', 'this harness does not expose plugin records; reply edits need the replay path')
+    }
+    if (text === plan.original) {
+      return {
+        kind: 'reply',
+        applied: false,
+        unchanged: true,
+        patch: true,
+        shadowed: [],
+        blockIndex: plan.blockIndex,
+        kindOfBlock: plan.kind,
+        original: plan.original,
+      }
+    }
+    let recordSeq
+    try {
+      recordSeq = sessionApi.appendPluginRecord(
+        session,
+        PATCH_TYPE,
+        buildPatchData([{ seq: plan.targetSeq, blockIndex: plan.blockIndex, kind: plan.kind, text }]),
+      )
+    } catch (error) {
+      throw new HttpError(409, 'stale', `the session refused the patch record: ${String((error && error.message) || error)}`)
+    }
+    const flush = await flushSession(ctx, session)
+    return {
+      kind: 'reply',
+      applied: true,
+      mode: 'patch',
+      patch: true,
+      recordSeq,
+      target: {
+        seq: plan.targetSeq,
+        blockIndex: plan.blockIndex,
+        kind: plan.kind,
+        text,
+        original: plan.original,
+      },
+      shadowed: [],
+      ...flush,
+    }
+  }
+
   // The live surface is the append authority; a node that vanished between the
   // read and this check means another writer landed first.
   for (const seq of plan.shadowed) {
@@ -1465,6 +1970,13 @@ async function applyEdit(ctx, sessionId, body, config) {
   // (it projects `lastTurn` from every turn/start it observes). A prompt edit
   // does not: `user/message` carries the revision and needs no turn.
   const editTurn = plan.mode === 'reply' ? nextTurnOf(events) : lastTurnOf(events)
+  // One identity for the whole reply splice: every copy the replay appends
+  // carries it, so a later reader (or a sibling plugin) can tell a replayed turn
+  // from the one it retired without re-deriving anything.
+  const replayId = plan.mode === 'reply' ? randomUUID() : null
+  // Resolved BEFORE the appends so the loop counter can be re-pointed in the
+  // same tick as the writes, not after an await that lets the loop start.
+  const loopAgent = plan.mode === 'reply' ? await resolveLoopAgent(ctx, sessionId) : undefined
   const carrier = buildCarrier(plan, editTurn, plan.mode === 'prompt' ? { ...config, carrier: 'user/message', markerText: text } : config, content)
   if (plan.mode === 'reply') {
     try {
@@ -1495,82 +2007,122 @@ async function applyEdit(ctx, sessionId, body, config) {
   } catch (error) {
     throw new HttpError(409, 'stale', `the surface refused the rollback: ${String((error && error.message) || error)}`)
   }
-  const flush = await flushSession(ctx, session)
 
-  // 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, editTurn, 1)
-    let appended
+  // A prompt edit saved here: the carrier that replaced the window IS the
+  // revised prompt, so the model reads it as the user's wording from here on.
+  // Nothing is prompted and nothing else needs writing.
+  if (plan.mode === 'prompt') {
+    const flush = await flushSession(ctx, session)
+    return {
+      kind: 'prompt',
+      replacementSeq: replacement.seq,
+      applied: true,
+      shadowed: plan.shadowed,
+      dropped,
+      // What the carrier now carries, described exactly the way /state describes
+      // it. The browser half adopts this for the row it re-draws before its own
+      // refresh lands - without it a second save could not know which blocks are
+      // still there and would rewrite the message text-only.
+      blocks: blockSummaries(content, canPreviewAttachments(store)),
+      ...flush,
+    }
+  }
+
+  // Step two of a reply edit: the correction itself, inside the turn just
+  // opened. An `assistant/message` may never carry `sourceEventSeqs`, so it can
+  // never be a replacement carrier (checked against the real validator, not
+  // assumed); it is appended in the same shape the agent loop records a reply,
+  // and the model goes on seeing the edited text as its own answer.
+  const correction = buildCorrection(plan, text, editTurn, 1)
+  let appended
+  try {
+    appended = session.append(correction.type, correction.data, { surfaceOp: 'append' })
+    // Close the step and the turn behind the corrected reply: the host anchors
+    // a turn's tail (duration, action strip) at its last `turn/end`, and the
+    // format only reads a step message inside an open turn and step.
+    session.append('step/end', { turn: editTurn, step: 1 })
+    session.append('turn/end', { turn: editTurn, reason: { kind: 'completed' } })
+  } catch (error) {
+    const failedFlush = await flushSession(ctx, session)
+    return {
+      kind: 'reply',
+      replacementSeq: replacement.seq,
+      applied: false,
+      applyError: `the corrected reply was refused: ${String((error && error.message) || error)}`,
+      shadowed: plan.shadowed,
+      dropped,
+      ...failedFlush,
+    }
+  }
+
+  // Step three: put every later turn back behind the correction, as fresh
+  // copies. This is the same infix splice dsh-rerun-turn performs after a
+  // regenerated answer - shadow the tail, write the new reply, replay what
+  // followed - with the user's text taking the place of the model call.
+  let replay = null
+  if (typeof plan.replayFrom === 'number' && typeof plan.logTo === 'number') {
+    const writes = buildReplayWrites(events, plan, editTurn + 1, replayId, session.seq)
+    let replayed = 0
+    let replayError = null
     try {
-      appended = session.append(correction.type, correction.data, { surfaceOp: 'append' })
-      // Close the step and the turn behind the corrected reply: the host anchors
-      // a turn's tail (duration, action strip) at its last `turn/end`, and the
-      // format only reads a step message inside an open turn and step.
-      session.append('step/end', { turn: editTurn, step: 1 })
-      session.append('turn/end', { turn: editTurn, reason: { kind: 'completed' } })
-    } catch (error) {
-      return {
-        kind: 'reply',
-        replacementSeq: replacement.seq,
-        applied: false,
-        applyError: `the corrected reply was refused: ${String((error && error.message) || error)}`,
-        shadowed: plan.shadowed,
-        dropped,
-        ...flush,
+      for (const write of writes) {
+        const options = {}
+        if (write.surfaceOp !== undefined) options.surfaceOp = write.surfaceOp
+        if (write.sourceEventSeqs !== undefined) options.sourceEventSeqs = write.sourceEventSeqs
+        session.append(write.type, write.data, options)
+        replayed += 1
       }
+    } catch (error) {
+      replayError = String((error && error.message) || error)
+    }
+    const playedMax = writes.reduce((max, write) => {
+      const turn = write.data && typeof write.data.turn === 'number' ? write.data.turn : 0
+      return turn > max ? turn : max
+    }, 0)
+    replay = {
+      id: replayId,
+      replayed,
+      total: writes.length,
+      turns: writes.reduce((count, write) => count + (write.type === 'turn/start' ? 1 : 0), 0),
+      ...(replayError === null ? {} : { error: replayError }),
+    }
+    // The replayed turns are closed in the log but were never opened by the
+    // live loop: re-point its idle counter at the highest one, synchronously.
+    const loopTurn = syncLoopTurn(loopAgent, playedMax > editTurn ? playedMax : editTurn)
+    if (loopTurn === 'unavailable') {
+      noteRequest({ kind: 'reply', sessionId, ok: replayError === null, loopTurn, turn: editTurn, replayId, replayed })
     }
     const corrected = await flushSession(ctx, session)
-    // The synthetic turn this edit opened is invisible to the live loop's own
-    // counter; without the sync its next run reuses that number and the log
-    // fails its next load. Only a reply edit opens a turn - a prompt edit does
-    // not, and needs nothing.
-    const loopAgent = await resolveLoopAgent(ctx, sessionId)
-    const loopTurn = syncLoopTurn(loopAgent, editTurn)
-    // `loopTurn` is the diagnostic the request ring records; the field is DELIBERATELY
-  // not called `code` - the static checks read `code:` as host error codes and
-  // must not start demanding a user-visible message for an internal sync state.
-  const syncNote = loopTurn
-  if (syncNote === 'unavailable') {
-    noteRequest({ kind: 'reply', sessionId, ok: true, loopTurn: syncNote, turn: editTurn })
-  }
     return {
       kind: 'reply',
       replacementSeq: replacement.seq,
       appendedSeq: appended.seq,
       applied: true,
       loopTurn,
+      replay,
       shadowed: plan.shadowed,
       dropped,
       ...corrected,
     }
   }
 
-  // The rollback above already did the whole job: the carrier that replaced the
-  // window *is* the revised prompt, so the model reads it as the user's wording
-  // from here on. Saving therefore costs no model call, always: regenerating
-  // the turn is a different operation with a different owner - the sibling
-  // plugin dsh-rerun-turn shadows the turn and regenerates it from the prompt
-  // the surface now shows, then replays what followed. Nothing here prompts.
+  // No later turn to replay: the correction is the last answer in the log.
+  // The synthetic turn still moved the loop's counter; sync it the same way.
+  const loopTurn = syncLoopTurn(loopAgent, editTurn)
+  if (loopTurn === 'unavailable') {
+    noteRequest({ kind: 'reply', sessionId, ok: true, loopTurn, turn: editTurn, replayId })
+  }
+  const corrected = await flushSession(ctx, session)
   return {
-    kind: 'prompt',
+    kind: 'reply',
     replacementSeq: replacement.seq,
+    appendedSeq: appended.seq,
     applied: true,
+    loopTurn,
+    replay: null,
     shadowed: plan.shadowed,
     dropped,
-    // What the carrier now carries, described exactly the way /state describes
-    // it. The browser half adopts this for the row it re-draws before its own
-    // refresh lands - without it a second save could not know which blocks are
-    // still there and would rewrite the message text-only.
-    blocks: blockSummaries(content, canPreviewAttachments(store)),
-    ...flush,
+    ...corrected,
   }
 }
 
@@ -1590,14 +2142,14 @@ function sessionIdFromExec(exec) {
   return undefined
 }
 
-function registerTool(ctx) {
+function registerTool(ctx, config) {
   const tools = ctx.get('tools')
   if (!tools || typeof tools.register !== 'function') return
   tools.register(
     defineTool({
       name: 'edit_turn_targets',
       description:
-        'List the user turns of a DeepSeek Harness session that the edit-turn plugin can rewrite and re-run, with each prompt\'s original text. Read-only: it changes nothing.',
+        'List the user turns and model replies of a DeepSeek Harness session that the edit-turn plugin can rewrite, with each message\'s current text and, for a reply, every editable block (output text and reasoning). A prompt is replaced where it stands; a reply block is patched in place when the host supports projections, otherwise the reply correction is appended and the later turns are replayed behind it. Read-only: it changes nothing.',
       parameters: {
         sessionId: {
           type: 'string',
@@ -1617,8 +2169,9 @@ function registerTool(ctx) {
         const events = await readEvents(ctx, sessionId)
         if (!events) throw new Error(`no session log for ${sessionId}`)
         const nodes = surfaceOf(ctx, sessionId, events)
+        const patches = patchesOf(events)
         const turns = editableTurns(events, nodes)
-        const replies = editableReplies(events, nodes)
+        const replies = editableReplies(events, nodes, { patches, patch: config && config.patch === true })
         const limit = typeof args.limit === 'number' && args.limit > 0 ? Math.floor(args.limit) : 20
         const shown = turns.slice(-limit)
         const shownReplies = replies.slice(-limit)
@@ -1632,10 +2185,13 @@ function registerTool(ctx) {
         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}`)
+          const blocks = Array.isArray(reply.blocks)
+            ? ` [${reply.blocks.map((block) => `${block.index}:${block.kind}${block.patched ? '*' : ''}`).join(', ')}]`
+            : ''
+          lines.push(`- reply (seq ${reply.seq}, ${reply.attachments} non-text part(s))${blocks}: ${preview}`)
         }
         if (replies.length > shownReplies.length) lines.push(`(${replies.length - shownReplies.length} earlier reply/replies omitted)`)
-        lines.push('editing a turn replaces its wording in place (no model call); editing a reply replaces its text and discards what follows. Re-running a turn is dsh-rerun-turn\'s button.')
+        lines.push('editing a turn replaces its wording in place (no model call); editing a reply block patches it in place when the host supports plugin-record projections, otherwise it replaces the reply and replays the tail. Re-running a turn is dsh-rerun-turn\'s button.')
         return lines.join('\n')
       },
     }),
@@ -1764,7 +2320,38 @@ export function apply(ctx, config) {
         : DEFAULT_MARKER,
     carrier: config && config.carrier === 'user/message' ? 'user/message' : 'system/message',
     confirm: config && typeof config.confirm === 'boolean' ? config.confirm : false,
+    replyMode: config && (config.replyMode === 'replay' || config.replyMode === 'patch') ? config.replyMode : 'auto',
+  }
+
+  // The in-place reply path needs two host seams: a plugin record with the
+  // `ignorable` envelope, and a message projection registry. Both are probed at
+  // load; when either is missing the reply path keeps the official replay
+  // splice, and `replyMode: 'patch'` turns that silence into a load error.
+  const sessionsService = ctx.get('sessions')
+  let patch = false
+  if (
+    resolved.replyMode !== 'replay' &&
+    typeof sessionApi.appendPluginRecord === 'function' &&
+    sessionsService &&
+    typeof sessionsService.registerMessageProjection === 'function'
+  ) {
+    try {
+      // A live reload (HMR, a re-applied bundle) leaves the previous
+      // registration in place: the registry rejects a second definition of the
+      // same type. Reuse ours instead of failing back to replay - the
+      // projection is a stateless pure function, so the old instance is exactly
+      // as good as a fresh one.
+      const registry = sessionsService.messageProjections
+      const existing = Array.isArray(registry)
+        ? registry.find((entry) => entry && entry.type === PATCH_TYPE)
+        : undefined
+      if (existing === undefined) sessionsService.registerMessageProjection(patchProjection())
+      patch = true
+    } catch (error) {
+      if (resolved.replyMode === 'patch') throw error
+    }
   }
+  resolved.patch = patch
 
   const registerRoutes = (webServer, fiber) => {
     fiber.effect(() =>
@@ -1843,7 +2430,19 @@ export function apply(ctx, config) {
             sendJson(res, 405, { ok: false, code: 'method', error: 'GET only' })
             return
           }
-          sendJson(res, 200, { ok: true, version: PLUGIN_VERSION, requests: recentRequests() })
+          sendJson(res, 200, {
+            ok: true,
+            version: PLUGIN_VERSION,
+            // How this deployment resolves a reply edit. `patch` means both
+            // host seams were found and the projection registered; `replay`
+            // means the historical splice is what a save will use.
+            mode: resolved.patch === true ? 'patch' : 'replay',
+            capabilities: {
+              pluginRecords: typeof sessionApi.appendPluginRecord === 'function',
+              projection: resolved.patch === true,
+            },
+            requests: recentRequests(),
+          })
         },
       }),
     )
@@ -1924,9 +2523,9 @@ export function apply(ctx, config) {
 
   const tools = ctx.get('tools')
   if (tools) {
-    registerTool(ctx)
+    registerTool(ctx, resolved)
   } else {
-    ctx.inject(['tools'], (sub) => registerTool(sub))
+    ctx.inject(['tools'], (sub) => registerTool(sub, resolved))
   }
 }