dsh-edit-turn 0.2.21 → 0.3.1

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.1'
 
 // A ring of the last few requests, answering "did the browser half even ask, and
 // what did it get?" without needing its console. Read-only diagnostics: the
@@ -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,
@@ -1179,7 +1239,20 @@ export function editableTurns(events, surfaceNodes, options = {}) {
     if (!event || !isHumanPrompt(event)) continue
     if (seq === head) continue
     const { text, attachments } = readMessageText(event)
-    const turn = turnOf.get(seq)
+    // A replacement carrier is appended after its original turn's bracket has
+    // closed, so turnIndex cannot name its turn. It still stands at that
+    // prompt's position in the conversation: inherit the turn from the event
+    // it replaced, or the editor's turn list loses the row (turn: null).
+    let turn = turnOf.get(seq)
+    if (typeof turn !== 'number' && Array.isArray(event.sourceEventSeqs)) {
+      for (const source of event.sourceEventSeqs) {
+        const inherited = turnOf.get(source)
+        if (typeof inherited === 'number') {
+          turn = inherited
+          break
+        }
+      }
+    }
     out.push({
       seq,
       turn: typeof turn === 'number' ? turn : null,
@@ -1197,34 +1270,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 +1657,21 @@ async function stateOf(ctx, sessionId, config) {
   }
   const folded = foldSurface(events)
   const ledger = rollbackLedger(events)
+  const patches = patchesOf(events)
+  // A patch whose target has been retired (a later rerun shadowed it) is inert:
+  // the projection skips it and no row can show it. Reporting it in /state made
+  // the browser draw a patch that could never land, and made "which patches are
+  // live" ambiguous. Keep the internal map for the replies; publish the active
+  // subset only.
+  const surfaceSet = new Set(folded.nodes)
+  const activePatches = new Map([...patches].filter(([seq]) => surfaceSet.has(seq)))
   const live = findLiveSession(ctx, sessionId)
   // Probed per request: the editor offers what THIS deployment can do right
   // now, so a store that is unmounted (or not yet mounted) cannot leave the
   // 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 +1693,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(activePatches),
+    mode: config.patch === true ? 'patch' : 'replay',
     live: Boolean(live),
     busy: isBusy(events),
     lastSeq: events.length > 0 ? events[events.length - 1].seq : -1,
@@ -1606,7 +1706,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 +1823,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 +1842,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 +2162,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 +2189,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 +2205,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 +2340,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 +2450,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 +2543,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))
   }
 }