dsh-edit-turn 0.2.21 → 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.21'
+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'),
       })
 
 // ---------------------------------------------------------------------------
@@ -768,7 +787,7 @@ function resolveTarget(events, request) {
  * @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)
@@ -781,12 +800,56 @@ 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 by an appended correction and the tail is
-  // replayed behind 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.
   //
@@ -842,11 +905,7 @@ export function planRollback(events, surfaceNodes, request) {
   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),
@@ -854,10 +913,11 @@ 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,
@@ -1197,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
@@ -1570,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,
@@ -1598,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,
@@ -1606,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,
   }
 }
@@ -1723,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
@@ -1738,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) {
@@ -2008,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 and model replies of a DeepSeek Harness session that the edit-turn plugin can rewrite, with each message\'s current text. A prompt is replaced where it stands; a reply correction is appended and every later turn is replayed back behind it, with no model call. 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',
@@ -2035,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)
@@ -2050,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')
       },
     }),
@@ -2182,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(() =>
@@ -2261,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(),
+          })
         },
       }),
     )
@@ -2342,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))
   }
 }
 

package/lib/patch.js

@@ -0,0 +1,260 @@
+// In-place reply edits through a plugin-owned session record and a message
+// projection.
+//
+// The host refuses to let an `assistant/message` be a surface-replacement
+// carrier (it may never carry `sourceEventSeqs`), so a corrected reply cannot be
+// put back at its own position with a surface event. The official seam for that
+// case is a message projection: append a log-only plugin record, then register a
+// pure projection for its type that rewrites the model-visible message at the
+// target seq. Nothing leaves the surface, so there is nothing to replay and the
+// log grows by one small record per edit.
+//
+// `appendPluginRecord` writes the record with the `ignorable` envelope the
+// persistence gate requires (DSH >= 0.2.1-rc.2). The projection is registered
+// through `ctx.sessions.registerMessageProjection` and is fiber-owned: unloading
+// the plugin removes it, and the record is then skipped, so the original text
+// comes back. That is the deliberate trade against the surface path: prompt
+// edits are official events that outlive the plugin, patch edits are an overlay
+// that needs its owner.
+
+/** The plugin record type. The grammar requires the `plugin:` namespace. */
+export const PATCH_TYPE = 'plugin:dsh-edit-turn/patch'
+
+/** Patch payload version. */
+export const PATCH_VERSION = 1
+
+/** Block kinds this plugin can edit, mapped to the recorded block types. */
+const KIND_TO_TYPES = {
+  text: ['text'],
+  reasoning: ['reasoning', 'thinking'],
+}
+
+/**
+ * The editable kind of one content block.
+ * @param block - one message content block.
+ * @returns 'text' | 'reasoning' | null.
+ */
+export function kindOfBlock(block) {
+  if (!block || typeof block !== 'object') return null
+  if (block.type === 'text' && typeof block.text === 'string') return 'text'
+  if ((block.type === 'reasoning' || block.type === 'thinking') && typeof block.text === 'string') return 'reasoning'
+  return null
+}
+
+/**
+ * Every block of a message an editor may target, in message order.
+ * @param message - a message payload with a `content` array.
+ * @returns `[{ index, kind, text }]`.
+ */
+export function editableBlocks(message) {
+  const content = message && Array.isArray(message.content) ? message.content : []
+  const out = []
+  for (let index = 0; index < content.length; index += 1) {
+    const block = content[index]
+    const kind = kindOfBlock(block)
+    if (kind === null) continue
+    out.push({ index, kind, text: block.text })
+  }
+  return out
+}
+
+/** A non-negative safe integer, matching the host's seq/blockIndex checks. */
+function isIndex(value) {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0)
+}
+
+/**
+ * Validate one patch payload (shape and target grammar).
+ * @param data - the record payload.
+ * @returns the same payload when valid.
+ * @throws when malformed.
+ */
+export function validatePatchData(data) {
+  if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error(`${PATCH_TYPE}: data must be an object`)
+  }
+  if (data.version !== PATCH_VERSION) {
+    throw new Error(`${PATCH_TYPE}: unsupported version ${String(data.version)}`)
+  }
+  if (!Array.isArray(data.targets) || data.targets.length === 0) {
+    throw new Error(`${PATCH_TYPE}: targets must be a nonempty array`)
+  }
+  for (const target of data.targets) {
+    if (target === null || typeof target !== 'object' || Array.isArray(target)) {
+      throw new Error(`${PATCH_TYPE}: each target must be an object`)
+    }
+    if (!isIndex(target.seq)) throw new Error(`${PATCH_TYPE}: target seq must be a non-negative safe integer`)
+    if (!isIndex(target.blockIndex)) throw new Error(`${PATCH_TYPE}: target blockIndex must be a non-negative safe integer`)
+    if (!(target.kind in KIND_TO_TYPES)) throw new Error(`${PATCH_TYPE}: target kind must be text or reasoning`)
+    if (typeof target.text !== 'string') throw new Error(`${PATCH_TYPE}: target text must be a string`)
+  }
+  return data
+}
+
+/**
+ * Build a validated patch payload.
+ * @param targets - `[{ seq, blockIndex, kind, text }]`.
+ * @returns the payload for `appendPluginRecord`.
+ */
+export function buildPatchData(targets) {
+  const data = {
+    version: PATCH_VERSION,
+    targets: targets.map((target) => ({
+      seq: target.seq,
+      blockIndex: target.blockIndex,
+      kind: target.kind,
+      text: target.text,
+    })),
+  }
+  validatePatchData(data)
+  return data
+}
+
+/**
+ * Apply the targets that belong to one seq to one message.
+ *
+ * Targets are grouped by the caller: a record may carry several blocks of the
+ * same message, and they all have to land in one projected message. A target
+ * whose block is gone (or changed kind) is skipped; the rest still apply.
+ *
+ * @param message - the base message payload.
+ * @param targets - validated targets, all for this message.
+ * @returns a patched message copy.
+ */
+export function applyTargetsToMessage(message, targets) {
+  const content = Array.isArray(message.content) ? message.content.slice() : []
+  for (const target of targets) {
+    const block = content[target.blockIndex]
+    const kind = kindOfBlock(block)
+    if (kind === null || kind !== target.kind) continue
+    const patched = { ...block, text: target.text }
+    if (kind === 'reasoning') {
+      // The signature signs the original text; keep it and some providers
+      // reject the whole request. The recorded block keeps its signature; the
+      // projected copy drops it, exactly like the disk path does.
+      delete patched.signature
+      delete patched.thinkingSignature
+    }
+    content[target.blockIndex] = patched
+  }
+  return { ...message, content }
+}
+
+/**
+ * The message projection for this plugin's record type.
+ *
+ * Pure and never throws: a projection error fails the whole session fold, which
+ * would make the session unreadable. A malformed record or a target that is no
+ * longer on the surface is simply skipped.
+ *
+ * Several records compose: the base for one target is the message the previous
+ * projections already produced (`context.messages`), falling back to the
+ * recorded message, so editing block A and later block B keeps both edits.
+ *
+ * @returns `{ type, project(event, context) }` for the host registry.
+ */
+export function patchProjection() {
+  return {
+    type: PATCH_TYPE,
+    project(event, context) {
+      const out = new Map()
+      let data
+      try {
+        data = validatePatchData(event && event.data)
+      } catch {
+        return out
+      }
+      const nodes = new Set(Array.isArray(context && context.nodes) ? context.nodes : [])
+      const events = Array.isArray(context && context.events) ? context.events : []
+      const baseSeq = typeof (context && context.baseSeq) === 'number' ? context.baseSeq : 0
+      const messages = context && context.messages
+      const groups = new Map()
+      for (const target of data.targets) {
+        // A retired target is not in the model context any more: editing it
+        // would be a no-op for the conversation.
+        if (!nodes.has(target.seq)) continue
+        const group = groups.get(target.seq)
+        if (group === undefined) groups.set(target.seq, [target])
+        else group.push(target)
+      }
+      for (const [seq, targets] of groups) {
+        const source = events[seq - baseSeq]
+        if (!source || source.type !== 'assistant/message') continue
+        const previous = messages && typeof messages.get === 'function' ? messages.get(seq) : undefined
+        const base = previous && typeof previous === 'object' ? previous : source.data && source.data.message
+        if (!base || !Array.isArray(base.content)) continue
+        try {
+          out.set(seq, applyTargetsToMessage(base, targets))
+        } catch {
+          // Keep the rest of the record; a broken target must not take the
+          // session's whole fold down.
+        }
+      }
+      return out
+    },
+  }
+}
+
+/**
+ * Read every landed patch from the log, latest per (seq, blockIndex).
+ * @param events - complete contiguous event log.
+ * @returns `Map<seq, Map<blockIndex, { kind, text }>>`.
+ */
+export function patchesOf(events) {
+  const out = new Map()
+  for (const event of events) {
+    if (!event || event.type !== PATCH_TYPE) continue
+    let data
+    try {
+      data = validatePatchData(event.data)
+    } catch {
+      continue
+    }
+    for (const target of data.targets) {
+      let byBlock = out.get(target.seq)
+      if (byBlock === undefined) {
+        byBlock = new Map()
+        out.set(target.seq, byBlock)
+      }
+      byBlock.set(target.blockIndex, { kind: target.kind, text: target.text })
+    }
+  }
+  return out
+}
+
+/**
+ * The latest patch per block as a flat list for the browser half.
+ * @param patches - `patchesOf(events)`.
+ * @returns `[{ seq, blockIndex, kind, text }]`.
+ */
+export function patchList(patches) {
+  const out = []
+  for (const [seq, byBlock] of patches) {
+    for (const [blockIndex, patch] of byBlock) {
+      out.push({ seq, blockIndex, kind: patch.kind, text: patch.text })
+    }
+  }
+  return out.sort((a, b) => a.seq - b.seq || a.blockIndex - b.blockIndex)
+}
+
+/**
+ * One message's blocks with the landed patch text applied.
+ * @param message - the recorded message payload.
+ * @param seq - the event seq that carries the message.
+ * @param patches - `patchesOf(events)`.
+ * @returns `[{ index, kind, text, original, patched }]`.
+ */
+export function projectedBlocks(message, seq, patches) {
+  const byBlock = patches.get(seq)
+  return editableBlocks(message).map((block) => {
+    const patch = byBlock && byBlock.get(block.index)
+    const applied = patch !== undefined && patch.kind === block.kind ? patch.text : block.text
+    return {
+      index: block.index,
+      kind: block.kind,
+      text: applied,
+      original: block.text,
+      patched: applied !== block.text,
+    }
+  })
+}