dsh-edit-turn 0.2.1 → 0.2.5

package/lib/index.js

@@ -22,25 +22,37 @@
 //      admission path. It resumes the Session when cold and starts exactly one
 //      new turn from the revised text.
 //
-// The replacement carrier defaults to an EMPTY `system/message`. The official
-// format documents an empty later system node as dormant - "empty later nodes
-// are dormant and project to no message" - so the rollback adds nothing the
-// model can see and the derived context after an edit is exactly what it would
-// be had the conversation really stopped at the edit point. `carrier:
-// 'user/message'` switches to a short marker text instead; that shape is what
-// an equivalent plugin already runs in production, so it is the fallback.
-// Either way `sourceEventSeqs` must list the complete shadowed node set, which
+// The silent replacement carrier is an EMPTY `developer/message` (0.2.5;
+// before that an empty `system/message`, which no reader accepts - see the
+// README). Empty content projects to no model message, so the rollback adds
+// nothing the model can see and the derived context after an edit is exactly
+// what it would be had the conversation really stopped at the edit point.
+// `sourceEventSeqs` must list the complete shadowed node set, which
 // is why an `assistant/message` carrier is impossible (it forbids
 // `sourceEventSeqs` outright).
 //
-// The module imports only `@deepseek-ai/schemastery` and
-// `@deepseek-ai/dsh-tools` (both declared). Every DSH service is resolved
-// through the cordis context at call time, so the plugin still loads on a
-// profile that lacks one and degrades to a clear HTTP failure instead.
+// The module resolves `@deepseek-ai/schemastery` defensively. `dsh-tools` is a
+// host-provided peer (the loader resolves it for every plugin), but the schema
+// package is a regular dependency: when it cannot be resolved - a pruned
+// package cache, an installation that skipped dependencies - a static import
+// takes the whole plugin down and the feature simply disappears from the UI
+// with nothing but a line on the host's stdout to explain it. A guarded require
+// degrades to "no config form, defaults apply" instead, which costs a settings
+// surface rather than the feature. Every field is optional in `apply` anyway.
 import { randomUUID } from 'node:crypto'
-import z from '@deepseek-ai/schemastery'
+import { createRequire } from 'node:module'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 
+const nodeRequire = createRequire(import.meta.url)
+const schemaPackage = (() => {
+  try {
+    return nodeRequire('@deepseek-ai/schemastery')
+  } catch {
+    return null
+  }
+})()
+const z = schemaPackage === null ? null : (schemaPackage.default ?? schemaPackage)
+
 /** Plugin id shared by the host and browser halves. */
 export const PLUGIN_ID = 'dsh-edit-turn'
 
@@ -48,7 +60,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.1'
+export const PLUGIN_VERSION = '0.2.5'
 
 // 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
@@ -82,16 +94,32 @@ const FLUSH_DEADLINE_MS = 5_000
  */
 const DEFAULT_MARKER = '[dsh-edit-turn] The user revised an earlier message. Every turn after that message was rolled back; the revised message follows. Send your reply to the revised message.'
 
-/** Deployment policy for the rollback. */
-export const Config = z.object({
-  markerText: z.string().default(DEFAULT_MARKER),
-  /**
-   * Whether the client asks for a second confirmation before applying. Off by
-   * default: the editor is already an explicit action the user opened, and the
-   * panel states what saving does. Set it to `true` to require the extra step.
-   */
-  confirm: z.boolean().default(false),
-})
+/**
+ * Deployment policy for the rollback.
+ *
+ * `undefined` when the schema package could not be resolved - DSH then hands
+ * `apply` no config at all, and every field below is read with the same default
+ * there, so the plugin behaves identically minus the settings form.
+ */
+export const Config =
+  z === null
+    ? undefined
+    : z.object({
+        markerText: z.string().default(DEFAULT_MARKER),
+        /**
+         * Whether the client asks for a second confirmation before applying. Off
+         * by default: the editor is already an explicit action the user opened, and
+         * the panel states what saving does. Set it to `true` to require the extra
+         * step.
+         */
+        confirm: z.boolean().default(false),
+        /**
+         * Whether saving a revised prompt also runs the turn again. Off by default:
+         * the revision becomes the standing wording and waits for the next message,
+         * so saving costs no model call. Set it to `true` to re-run on save.
+         */
+        rerun: z.boolean().default(false),
+      })
 
 // ---------------------------------------------------------------------------
 // pure session-log logic (no DSH SDK imports; unit-testable under node --test)
@@ -233,7 +261,13 @@ export function messageIdOf(event) {
 export function isHumanPrompt(event) {
   if (!event || event.type !== 'user/message') return false
   const data = event.data
-  return Boolean(data && data.source && data.source.kind === 'user')
+  if (!data || !data.source) return false
+  if (data.source.kind === 'user') return true
+  // A message this plugin rewrote stands in a human's place: it is the wording
+  // the user is asking with now, so it stays editable (edit it again) even though
+  // its source records that the plugin wrote it. The distinct kind also keeps the
+  // platform from treating it as fresh input to answer.
+  return data.source.kind === `plugin:${PLUGIN_ID}` && data.source.editedBy === PLUGIN_ID
 }
 
 /**
@@ -313,6 +347,16 @@ export function rollbackLedger(events) {
   return { hidden, edits }
 }
 
+/** The turn number the format expects next: the last one opened, plus one. */
+export function nextTurnOf(events) {
+  let last = 0
+  for (const event of events) {
+    const turn = event.data && event.data.turn
+    if (typeof turn === 'number' && turn > last) last = turn
+  }
+  return last + 1
+}
+
 /** Highest turn number recorded in the log, or undefined for an empty log. */
 export function lastTurnOf(events) {
   let last
@@ -390,14 +434,21 @@ export function planRollback(events, surfaceNodes, request) {
   if (target.seq === surfaceNodes[0]) {
     throw new EditPlanError('not-editable', 'the system prompt head cannot be edited')
   }
-  // Two editable kinds, two outcomes: rewriting a prompt re-runs the turn;
-  // rewriting a reply replaces the answer and lets the conversation continue.
+  // 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.
   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 startIdx = nodeIndex.get(target.seq)
-  const shadowed = surfaceNodes.slice(startIdx)
+  // 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.
+  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')
   }
@@ -436,18 +487,22 @@ export function planRollback(events, surfaceNodes, request) {
  * @returns one entry per editable prompt, in conversation order.
  */
 export function editableTurns(events, surfaceNodes) {
-  const nodeIndex = new Map(surfaceNodes.map((seq, index) => [seq, index]))
+  const eventBySeq = new Map(events.map((event) => [event.seq, event]))
   const turnOf = turnIndex(events)
   const head = surfaceNodes[0]
   const out = []
-  for (const event of events) {
-    if (!isHumanPrompt(event)) continue
-    if (!nodeIndex.has(event.seq)) continue
-    if (event.seq === head) continue
+  // Surface order, not log order: a prompt rewritten in place travels as a
+  // replace-carrier, which is APPENDED at the end of the log while standing at
+  // the surface position of the wording it replaced. Walking `events` would
+  // report the revision as the newest message in the conversation.
+  for (const seq of surfaceNodes) {
+    const event = eventBySeq.get(seq)
+    if (!event || !isHumanPrompt(event)) continue
+    if (seq === head) continue
     const { text, attachments } = readMessageText(event)
-    const turn = turnOf.get(event.seq)
+    const turn = turnOf.get(seq)
     out.push({
-      seq: event.seq,
+      seq,
       turn: typeof turn === 'number' ? turn : null,
       messageId: messageIdOf(event) ?? null,
       text,
@@ -634,13 +689,18 @@ async function stateOf(ctx, sessionId, config) {
   return {
     hidden: ledger.hidden,
     edits: ledger.edits.length,
+    // The window record behind every hidden entry, with the same field names the
+    // apply response uses (`replacementSeq`, `shadowed`, plus the window bounds).
+    // Published so a sibling plugin can follow a rewritten message to its live
+    // node without re-deriving the ledger from the log itself.
+    revisions: ledger.edits,
     surface: folded.nodes,
     turns,
     replies,
     live: Boolean(live),
     busy: isBusy(events),
     lastSeq: events.length > 0 ? events[events.length - 1].seq : -1,
-    config: { confirm: config.confirm },
+    config: { confirm: config.confirm, rerun: config.rerun === true },
     version: PLUGIN_VERSION,
   }
 }
@@ -656,17 +716,24 @@ async function stateOf(ctx, sessionId, config) {
 export function buildCarrier(plan, lastTurn, config) {
   const silent = config.carrier !== 'user/message'
   if (silent) {
-    // An empty later system node is dormant and projects to no model message.
+    // The silent carrier is an empty message that projects to no model message.
+    // It has to be a `developer/message`: the format admits only system-prompt
+    // sources on `system/message`, so an empty plugin-owned system node (what
+    // this used to append) made every session that contained one unreadable -
+    // `SessionFormatError` on load, after a perfectly accepted append. An empty
+    // developer message is legal, dormant, and a replacement never gets a row
+    // of its own (rows are built for append events only), so it is invisible in
+    // the transcript too.
     return {
-      type: 'system/message',
+      type: 'developer/message',
       data: {
         turn: typeof lastTurn === 'number' ? lastTurn : 0,
         step: 1,
         message: {
           id: randomUUID(),
-          role: 'system',
+          role: 'developer',
           content: [],
-          source: { kind: `plugin:${PLUGIN_ID}` },
+          source: { kind: `plugin:${PLUGIN_ID}`, editedBy: PLUGIN_ID },
         },
       },
     }
@@ -677,7 +744,7 @@ export function buildCarrier(plan, lastTurn, config) {
       id: randomUUID(),
       role: 'user',
       content: [{ type: 'text', text: config.markerText }],
-      source: { kind: `plugin:${PLUGIN_ID}` },
+      source: { kind: `plugin:${PLUGIN_ID}`, editedBy: PLUGIN_ID },
     },
   }
 }
@@ -694,19 +761,21 @@ export function buildCarrier(plan, lastTurn, config) {
  * ordinary reply, while `editedBy` records honestly that the text was written by
  * the plugin and not produced by the model.
  *
- * @param plan - the planned window, for the original's turn/step/provider.
+ * @param plan - the planned window, for the original's provider/model.
  * @param text - the replacement text.
+ * @param turn - the turn the correction lands in (the freshly opened one).
+ * @param step - the step the correction lands in.
  * @returns `{ type, data }` for `session.append`, to be marked `surfaceOp: 'append'`.
  */
-export function buildCorrection(plan, text) {
+export function buildCorrection(plan, text, turn, step) {
   const source = { kind: 'model', editedBy: PLUGIN_ID }
   if (typeof plan.provider === 'string' && plan.provider !== '') source.provider = plan.provider
   if (typeof plan.model === 'string' && plan.model !== '') source.model = plan.model
   return {
     type: 'assistant/message',
     data: {
-      turn: typeof plan.turn === 'number' ? plan.turn : 0,
-      step: typeof plan.step === 'number' ? plan.step : 1,
+      turn: typeof turn === 'number' ? turn : 0,
+      step: typeof step === 'number' ? step : 1,
       message: {
         id: randomUUID(),
         role: 'assistant',
@@ -753,14 +822,40 @@ async function applyEdit(ctx, sessionId, body, config) {
     if (!surfaceNodes.includes(seq)) throw new HttpError(409, 'stale', 'the session changed, retry')
   }
 
-  const carrier = buildCarrier(plan, lastTurnOf(events), config)
+  // A revised prompt has to (a) replace the old wording in the model context and
+  // (b) NOT be answered. The platform answers any user message it finds on the
+  // surface, so the revision cannot be *appended* - appending one made the loop
+  // answer it, and the next save added another copy (three "你好" bubbles). It
+  // travels as the rollback's replacement instead: a replace-type carrier, which
+  // removes the old prompt and stands in its place, in one event.
+  // A reply edit needs somewhere to land: `assistant/message` (and any message
+  // with a step coordinate) is only readable inside an OPEN turn and step, and
+  // opening one in the log is what advances the runtime's own turn counter too
+  // (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)
+  const carrier = buildCarrier(plan, editTurn, plan.mode === 'prompt' ? { ...config, carrier: 'user/message', markerText: text } : config)
+  if (plan.mode === 'reply') {
+    try {
+      session.append('turn/start', { turn: editTurn })
+      session.append('step/start', { turn: editTurn, step: 1 })
+    } catch (error) {
+      return {
+        kind: 'reply',
+        applied: false,
+        applyError: `could not open a turn for the correction: ${String((error && error.message) || error)}`,
+        shadowed: plan.shadowed,
+      }
+    }
+  }
   let replacement
   try {
     // A replacement carrier has to be a surface event with non-empty
     // `sourceEventSeqs` coverage of the whole shadowed window. An assistant
     // message forbids `sourceEventSeqs` outright, so the carrier is either an
-    // empty `system/message` (default, dormant, invisible) or a short
-    // `user/message` marker.
+    // empty `developer/message` (default: dormant, invisible to the model, and
+    // never given a row of its own because rows are built for appends) or a
+    // short `user/message` marker.
     replacement = session.append(carrier.type, carrier.data, {
       surfaceOp: { op: 'replace', startSeq: plan.startSeq, endSeq: plan.endSeq },
       sourceEventSeqs: plan.shadowed,
@@ -780,17 +875,15 @@ async function applyEdit(ctx, sessionId, body, config) {
   // 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)
+    const correction = buildCorrection(plan, text, editTurn, 1)
     let appended
     try {
       appended = session.append(correction.type, correction.data, { surfaceOp: 'append' })
-      // Close the turn again, now that the corrected reply is the last thing in
-      // it. The host anchors a turn's tail (its duration and action strip) at the
-      // turn's LAST `turn/end`, so a correction appended after the old one lands
-      // OUTSIDE the turn and the tail renders above the corrected text. These two
-      // events put the tail back behind it, exactly as a normal turn ends.
-      session.append('step/end', { turn: appended.data.turn, step: appended.data.step })
-      session.append('turn/end', { turn: appended.data.turn, reason: { kind: 'completed' } })
+      // 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',
@@ -812,15 +905,31 @@ async function applyEdit(ctx, sessionId, body, config) {
     }
   }
 
-  // A rewritten prompt is re-run through the only official prompt path, which
-  // also resumes a cold Session and starts exactly one new turn.
+  // 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 and nothing has to be prompted. Saving therefore costs no model
+  // call - which is the point. `rerun: true` restores the older behaviour of
+  // asking the model right away (through the one official prompt path, which also
+  // resumes a cold Session and starts exactly one new turn).
+  if (config.rerun !== true) {
+    return {
+      kind: 'prompt',
+      replacementSeq: replacement.seq,
+      applied: true,
+      reran: false,
+      shadowed: plan.shadowed,
+      ...flush,
+    }
+  }
+
   const controller = ctx.get('sessionController')
   if (!controller || typeof controller.prompt !== 'function') {
     return {
       kind: 'prompt',
       replacementSeq: replacement.seq,
-      promptAccepted: false,
-      promptError: 'sessionController.prompt unavailable',
+      applied: true,
+      reran: false,
+      rerunError: 'sessionController.prompt unavailable',
       shadowed: plan.shadowed,
       ...flush,
     }
@@ -839,8 +948,9 @@ async function applyEdit(ctx, sessionId, body, config) {
     return {
       kind: 'prompt',
       replacementSeq: replacement.seq,
-      promptAccepted: false,
-      promptError: String((error && error.message) || error),
+      applied: true,
+      reran: false,
+      rerunError: String((error && error.message) || error),
       shadowed: plan.shadowed,
       ...flush,
     }
@@ -849,7 +959,8 @@ async function applyEdit(ctx, sessionId, body, config) {
   return {
     kind: 'prompt',
     replacementSeq: replacement.seq,
-    promptAccepted: true,
+    applied: true,
+    reran: true,
     shadowed: plan.shadowed,
     ...flush,
   }
@@ -1029,6 +1140,7 @@ 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,
+    rerun: config && config.rerun === true,
   }
 
   const registerRoutes = (webServer, fiber) => {
@@ -1090,8 +1202,26 @@ export function apply(ctx, config) {
           }
           try {
             const sessionId = requireSessionId(typeof body.sessionId === 'string' ? body.sessionId.trim() : '')
-            sendJson(res, 200, { ok: true, ...(await applyEdit(ctx, sessionId, body, resolved)) })
+            const result = await applyEdit(ctx, sessionId, body, resolved)
+            // Recorded so the next "the button does nothing" can be answered
+            // from here: an apply that never appears was never sent - the click
+            // was lost in the browser half, not refused by this one.
+            noteRequest({
+              kind: 'apply',
+              sessionId,
+              ok: true,
+              edit: result.kind,
+              seq: typeof body.seq === 'number' ? body.seq : null,
+              replacement: typeof result.replacementSeq === 'number' ? result.replacementSeq : null,
+            })
+            sendJson(res, 200, { ok: true, ...result })
           } catch (error) {
+            noteRequest({
+              kind: 'apply',
+              sessionId: typeof body.sessionId === 'string' ? body.sessionId.trim() : null,
+              ok: false,
+              code: error && error.code ? String(error.code) : 'internal',
+            })
             failure(res, error)
           }
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.2.1",
+  "version": "0.2.5",
   "description": "Edit any user turn in DeepSeek Harness and re-run it: an inline editor on the message row rolls the conversation back to just before that turn through the official surface-replace contract, then re-prompts the agent with the revised text. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",
@@ -40,11 +40,15 @@
     "verify:live": "node tools/verify-live-client.mjs",
     "verify:profile": "bash tools/verify-dsh-plugin.sh",
     "probe:loaded": "node tools/probe-loaded.mjs",
-    "check": "npm run test && npm run verify:contract && npm run verify:client"
+    "check": "npm run test && npm run verify:contract && npm run verify:client",
+    "verify:ui": "node tools/verify-live-ui.mjs"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"
   },
+  "devDependencies": {
+    "@deepseek-ai/dsh-session": "^0.1.7-rc.2"
+  },
   "peerDependencies": {
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.7 || ^0.1.1-rc.2 || ^0.1.2-alpha.2 || ^0.1.3-alpha.2 || ^0.1.5-alpha.1",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.7 || ^0.1.1-rc.2 || ^0.1.2-alpha.2 || ^0.1.3-alpha.2 || ^0.1.5-alpha.1"