@khorsheed/dsh-client-message-tools 0.2.0 → 0.3.1

package/lib/index.js

@@ -1,22 +1,30 @@
+import * as sessionApi from "@deepseek-ai/dsh-session";
 import { SessionSeq } from "@deepseek-ai/dsh-session";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { isAppendSurfaceEvent, isReplacementSurfaceEvent } from "@deepseek-ai/dsh-session/surface";
 //#region lib/types/marker.js
 /**
-* Shared message-tools markers: the plugin source tag stamped on withdrawal
-* replacement events, the `op` discriminator telling edit replacements, edit
-* triggers, and assistant-text restore replays apart from withdrawals and
-* user-message restores, the model-facing placeholder and trigger texts, and
-* the pure predicates both the Host service and the browser projection
-* consume. No new session event type is ever written — an
+* Shared message-tools markers: the producer-owned source kind stamped on
+* every message-tools event, the `op` discriminator telling edit
+* replacements, edit triggers, and assistant-text restore replays apart from
+* withdrawals and user-message restores, the model-facing placeholder and
+* trigger texts, and the pure predicates both the Host service and the
+* browser projection consume. No new session event type is ever written — an
 * out-of-harness event type cannot carry `ignorable: true` (Session.append
 * assigns the envelope), so a persisted unknown type would make
 * session-persistence refuse the log on reload. The events themselves are the
 * durable audit trail.
 * @module @khorsheed/dsh-client-message-tools/marker
 */
-/** Plugin source tag identifying every message-tools event. */
+/**
+* The producer-owned source kind identifying every message-tools event. It is
+* also the legacy wrapper's `plugin` value: released V3 logs carry
+* `{ kind: 'plugin', plugin: 'message-tools' }` (a pre-V4 host still serves
+* them verbatim), and the official V3→V4 migration rewrites those to
+* `kind: 'plugin:message-tools'` — {@link isMessageToolsSource} accepts all
+* three durable forms.
+*/
 const MESSAGE_TOOLS_PLUGIN = "message-tools";
 /**
 * Model-facing placeholder left on the surface in place of the withdrawn
@@ -33,49 +41,79 @@ const WITHDRAWN_NOTICE = "(用户撤回了这条消息及其后的所有内容)"
 const EDIT_TRIGGER_NOTICE = "(用户编辑了上一条消息，请按编辑后的内容重新回答)";
 /**
 * Model-facing frame preceding a replayed assistant text in a restore: the
-* replay lands as a user-role message (assistant/message cannot carry a
-* plugin source, and the session turn/step trace forbids ad-hoc assistant
-* appends), so the frame keeps the role honest for the model.
+* replay lands as a user-role message (assistant/message requires the model
+* source, and the session turn/step trace forbids ad-hoc assistant
+* appends), so the frame keeps the role honest for the model. On hosts whose
+* session fold carries the S12 `user/message` projection the frame never
+* reaches the model — the projection strips it and corrects the role at
+* derivation time; everywhere else it is the role-honesty device.
 */
 const RESTORED_ASSISTANT_NOTICE = "(以下是先前被撤回、现随恢复放回的助手回复)";
-/** The plugin-tagged source of an edit replacement (op: 'edit'). */
+/** The producer-owned source of a withdrawal replacement or a user-message restore replay (no op). */
+function messageToolsSource() {
+	return Object.freeze({ kind: MESSAGE_TOOLS_PLUGIN });
+}
+/** The producer-owned source of an edit replacement (op: 'edit'). */
 function editReplacementSource() {
 	return Object.freeze({
-		kind: "plugin",
-		plugin: MESSAGE_TOOLS_PLUGIN,
+		kind: MESSAGE_TOOLS_PLUGIN,
 		op: "edit"
 	});
 }
-/** The plugin-tagged source of an edit trigger message (op: 'edit-trigger'). */
+/** The producer-owned source of an edit trigger message (op: 'edit-trigger'). */
 function editTriggerSource() {
 	return Object.freeze({
-		kind: "plugin",
-		plugin: MESSAGE_TOOLS_PLUGIN,
+		kind: MESSAGE_TOOLS_PLUGIN,
 		op: "edit-trigger"
 	});
 }
-/** The plugin-tagged source of a restored assistant-text replay (op: 'restore-assistant'). */
+/** The producer-owned source of a restored assistant-text replay (op: 'restore-assistant'). */
 function restoreAssistantSource() {
 	return Object.freeze({
-		kind: "plugin",
-		plugin: MESSAGE_TOOLS_PLUGIN,
+		kind: MESSAGE_TOOLS_PLUGIN,
 		op: "restore-assistant"
 	});
 }
-/** Read the op discriminator off a message source (absent on legacy events). */
+/** Read the op discriminator off a message source (absent on plain withdrawal/restore events). */
 function messageToolsOp(source) {
 	const op = source?.op;
 	return op === "edit" || op === "edit-trigger" || op === "restore-assistant" ? op : void 0;
 }
 /**
+* Whether a durable source belongs to message-tools, in every form the log
+* can hold: the current producer-owned kind (`message-tools`), the V3→V4
+* migrated kind (`plugin:message-tools` — released V3 files rewritten once by
+* the official migration), and the released V3 wrapper a pre-V4 host still
+* serves verbatim (`{ kind: 'plugin', plugin: 'message-tools' }`).
+* @param source - the persisted message source to test.
+* @returns true when the source names this producer.
+*/
+function isMessageToolsSource(source) {
+	if (typeof source !== "object" || source === null) return false;
+	const record = source;
+	return record.kind === "message-tools" || record.kind === `plugin:message-tools` || record.kind === "plugin" && record.plugin === "message-tools";
+}
+/**
+* Strip the model-facing restore frame from a replayed assistant text for
+* DISPLAY: the frame belongs to the model context (role honesty), never to
+* the transcript row. Texts without the frame pass through unchanged.
+* @param text - the replayed content's joined text.
+* @returns the display text without the frame prefix.
+*/
+function stripRestoreAssistantFrame(text) {
+	const prefix = `${RESTORED_ASSISTANT_NOTICE}\n`;
+	return text.startsWith(prefix) ? text.slice(prefix.length) : text;
+}
+/**
 * Whether the event is a message-tools WITHDRAWAL replacement: a
-* `user/message` surface replacement whose source carries this plugin's tag
-* and no `op` discriminator (legacy and current withdrawals both).
+* `user/message` surface replacement whose source names this producer
+* (any durable form — see {@link isMessageToolsSource}) with no `op`
+* discriminator.
 * @param event - the session event to test.
 * @returns the event narrowed to a withdrawal replacement when matched.
 */
 function isMessageToolsReplacement(event) {
-	return event.type === "user/message" && isReplacementSurfaceEvent(event) && event.data.source.kind === "plugin" && event.data.source.plugin === "message-tools" && messageToolsOp(event.data.source) === void 0;
+	return event.type === "user/message" && isReplacementSurfaceEvent(event) && isMessageToolsSource(event.data.source) && messageToolsOp(event.data.source) === void 0;
 }
 /**
 * Whether the event is a message-tools EDIT replacement: a `user/message`
@@ -84,7 +122,7 @@ function isMessageToolsReplacement(event) {
 * @returns the event narrowed to an edit replacement when matched.
 */
 function isMessageToolsEdit(event) {
-	return event.type === "user/message" && isReplacementSurfaceEvent(event) && event.data.source.kind === "plugin" && event.data.source.plugin === "message-tools" && messageToolsOp(event.data.source) === "edit";
+	return event.type === "user/message" && isReplacementSurfaceEvent(event) && isMessageToolsSource(event.data.source) && messageToolsOp(event.data.source) === "edit";
 }
 /**
 * Whether the event is a message-tools restore: an append-surface
@@ -93,7 +131,7 @@ function isMessageToolsEdit(event) {
 * @returns the event narrowed to a message-tools restore when matched.
 */
 function isMessageToolsRestore(event) {
-	return event.type === "user/message" && event.surfaceOp === "append" && event.data.source.kind === "plugin" && event.data.source.plugin === "message-tools" && messageToolsOp(event.data.source) === void 0;
+	return event.type === "user/message" && event.surfaceOp === "append" && isMessageToolsSource(event.data.source) && messageToolsOp(event.data.source) === void 0;
 }
 /**
 * Whether the event is a message-tools ASSISTANT-text restore replay: an
@@ -103,7 +141,115 @@ function isMessageToolsRestore(event) {
 * @returns the event narrowed to a restore-assistant replay when matched.
 */
 function isMessageToolsRestoreAssistant(event) {
-	return event.type === "user/message" && event.surfaceOp === "append" && event.data.source.kind === "plugin" && event.data.source.plugin === "message-tools" && messageToolsOp(event.data.source) === "restore-assistant";
+	return event.type === "user/message" && event.surfaceOp === "append" && isMessageToolsSource(event.data.source) && messageToolsOp(event.data.source) === "restore-assistant";
+}
+//#endregion
+//#region lib/types/restore-projection.js
+/**
+* The `user/message` projection correcting restore replays at derivation
+* time. It registers on the SHARED user-message vocabulary (a custom event
+* type could never persist — S2), so the fold calls `project` synchronously
+* for EVERY user message, inside append validation: it must be a pure
+* pass-through (empty map) for anything without the restore mark, and it must
+* NEVER throw — a throw atomically rejects the candidate append, so a
+* throwing projection would break ordinary user messages instance-wide. Any
+* malformed durable payload therefore also yields an empty map.
+*/
+const restoreAssistantProjection = {
+	type: "user/message",
+	project(event, context) {
+		try {
+			const source = event.data?.source;
+			if (messageToolsOp(source) !== "restore-assistant") return /* @__PURE__ */ new Map();
+			const committed = context.events[event.seq - context.baseSeq];
+			const message = context.messages.get(event.seq) ?? (committed?.type === "user/message" ? committed.data : void 0) ?? event.data;
+			const content = message.content.map((block) => block.type === "text" && typeof block.text === "string" ? {
+				...block,
+				text: stripRestoreAssistantFrame(block.text)
+			} : block);
+			return /* @__PURE__ */ new Map([[event.seq, {
+				...message,
+				role: "assistant",
+				content
+			}]]);
+		} catch {
+			return /* @__PURE__ */ new Map();
+		}
+	}
+};
+/** One synthetic user/message event for the fold-semantics probe. */
+function probeEvent(seq, text, source) {
+	return {
+		type: "user/message",
+		seq: SessionSeq(seq),
+		time: 0,
+		data: createUserMessage({
+			content: [{
+				type: "text",
+				text
+			}],
+			source
+		}),
+		surfaceOp: "append"
+	};
+}
+/**
+* Whether this host's surface fold can carry a `user/message` projection at
+* all. 0.1.6-alpha.1 routes every event of a projected type through the
+* projection plan and never joins it to the surface (probe-verified): a
+* registered user/message projection would silently drop EVERY user message
+* from the model context. This probe folds two synthetic events through the
+* real `foldSurface` and accepts only the composing semantics the design
+* needs — plain messages keep their node, and a restore replay keeps its
+* node AND derives assistant-role with the frame stripped — so the channel
+* stays dormant on 0.1.6-alpha.1 and lights up by itself on a host whose
+* fold composes. Pure, synchronous, side-effect-free.
+* @param fold - the host's surface fold, injectable for tests.
+* @param derive - the host's single-event derivation, injectable for tests.
+* @returns true when a registered user/message projection is safe.
+*/
+function restoreProjectionFoldSupported(fold = sessionApi.foldSurface, derive = sessionApi.deriveEventMessage) {
+	try {
+		if (typeof fold !== "function" || typeof derive !== "function") return false;
+		const events = [probeEvent(0, "probe", { kind: "user" }), probeEvent(1, `${RESTORED_ASSISTANT_NOTICE}\nprobe answer`, restoreAssistantSource())];
+		const folded = fold(events, [restoreAssistantProjection]);
+		if (folded.nodes.length !== events.length) return false;
+		const derived = derive(events[1], folded.projectedMessages);
+		return derived?.role === "assistant" && derived.content.some((block) => block.type === "text" && block.text === "probe answer");
+	} catch {
+		return false;
+	}
+}
+/**
+* Probe and register the restore-assistant projection, degrading to the
+* framed user-role channel (which the durable events already carry) whenever
+* the host cannot carry the projection: pre-0.1.6 (`registerMessageProjection`
+* absent), a fold that cannot compose projections with surface membership, or
+* a registration conflict (the projection slot is one-per-type per instance —
+* a future official projection claiming user/message throws, and the plugin
+* must not take the instance down with it).
+* @param ctx - host context carrying the session store.
+* @param foldSupported - fold-semantics probe, injectable for tests.
+* @returns true when the projection channel is active.
+*/
+function registerRestoreProjection(ctx, foldSupported = restoreProjectionFoldSupported) {
+	const sessions = ctx.sessions;
+	if (typeof sessions.registerMessageProjection !== "function") {
+		ctx.logger.info("message-tools: host has no sessions.registerMessageProjection — restored assistant text stays in the framed user-role channel");
+		return false;
+	}
+	if (!foldSupported()) {
+		ctx.logger.warn("message-tools: host message-projection fold drops projected user/message events from the surface — restored assistant text stays in the framed user-role channel");
+		return false;
+	}
+	try {
+		const dispose = sessions.registerMessageProjection(restoreAssistantProjection);
+		ctx.effect(() => () => dispose(), "message-tools: restore-assistant projection");
+		return true;
+	} catch {
+		ctx.logger.warn("message-tools: a user/message message-projection is already registered — restored assistant text stays in the framed user-role channel");
+		return false;
+	}
 }
 //#endregion
 //#region lib/types/withdraw.js
@@ -226,10 +372,10 @@ function joinAssistantMessageText(blocks) {
 * (the message left the surface through another producer, e.g. compaction).
 *
 * `sourceEventSeqs` is authoritative for the shadowed *surface* nodes, but an
-* interrupted assistant step may exist only as `assistant/chunk` events (no
-* `assistant/message` ever landed). Those chunks are not surface nodes, so
-* they are absent from `sourceEventSeqs`. The replacement's own `start` and
-* `seq` delimit the whole withdrawn log interval — `[start, seq)` — and are
+* interrupted assistant step may exist only as `assistant/attempt` events (no
+* `assistant/message` ever landed). Attempts are not surface nodes, so
+* they are absent from `sourceEventSeqs`. The replacement's own `startSeq` and
+* `seq` delimit the whole withdrawn log interval — `[startSeq, seq)` — and are
 * still read from the replacement itself, never guessed from another producer.
 */
 function findWithdrawnSpan(events, targetSeq) {
@@ -238,7 +384,7 @@ function findWithdrawnSpan(events, targetSeq) {
 		if (event === void 0 || !isMessageToolsReplacement(event)) continue;
 		if (event.sourceEventSeqs?.includes(targetSeq) !== true) continue;
 		const span = [];
-		for (let seq = event.surfaceOp.start; seq < event.seq; seq++) span.push(seq);
+		for (let seq = event.surfaceOp.startSeq; seq < event.seq; seq++) span.push(seq);
 		return span;
 	}
 }
@@ -249,50 +395,23 @@ function findWithdrawnSpan(events, targetSeq) {
 * restore-assistant replays already carry the frame). Skipped: withdrawal
 * placeholders, edit triggers, other plugin context, and tool calls/results.
 *
-* Assistant text normally comes from `assistant/message` surface events. A
-* turn that was interrupted before finalization may never emit
-* `assistant/message`; its visible content survives only as `assistant/chunk`
-* rows. Those chunks are folded into one assistant replay per step when no
-* final `assistant/message` exists for that step, so withdrawing/restoring an
-* interrupted reply does not lose the partial assistant content.
+* Assistant text normally comes from `assistant/message` surface events (a
+* cancelled turn finalizes its delivered prefix there with `interrupted:
+* true`). An attempt that committed no surface message — failed, retried, or
+* stream-error — settles as an `assistant/attempt` log event carrying its
+* exact compact stream. Each such attempt folds into one assistant replay
+* when no final `assistant/message` exists for that step, so
+* withdrawing/restoring an interrupted reply does not lose the partial
+* assistant content. A retried step's earlier attempts are superseded by the
+* step's final message and do not replay.
 */
 function replayEntries(events, spanSeqs) {
 	const entries = [];
-	let pending;
 	const finalizedSteps = /* @__PURE__ */ new Set();
-	const flushPending = () => {
-		if (pending === void 0) return;
-		if (!pending.finalized) {
-			const text = [...pending.text.values()].join("");
-			const reasoning = [...pending.reasoning.values()].join("");
-			const replay = text !== "" ? text : reasoning;
-			if (replay !== "") entries.push({
-				role: "assistant",
-				text: `${RESTORED_ASSISTANT_NOTICE}\n${replay}`,
-				sourceSeq: pending.sourceSeq
-			});
-		}
-		pending = void 0;
-	};
-	const pushChunk = (event) => {
-		if (finalizedSteps.has(`${event.data.turn}:${event.data.step}`)) return;
-		if (pending === void 0 || pending.turn !== event.data.turn || pending.step !== event.data.step) {
-			flushPending();
-			pending = {
-				turn: event.data.turn,
-				step: event.data.step,
-				sourceSeq: event.seq,
-				text: /* @__PURE__ */ new Map(),
-				reasoning: /* @__PURE__ */ new Map(),
-				finalized: false
-			};
-		}
-		const chunk = event.data.chunk;
-		if (chunk.type === "text-delta") pending.text.set(chunk.index, (pending.text.get(chunk.index) ?? "") + chunk.text);
-		else if (chunk.type === "block-end" && chunk.block.type === "text") pending.text.set(chunk.index, chunk.block.text);
-		else if (chunk.type === "reasoning-delta") pending.reasoning.set(chunk.index, (pending.reasoning.get(chunk.index) ?? "") + chunk.text);
-		else if (chunk.type === "block-end" && chunk.block.type === "reasoning") pending.reasoning.set(chunk.index, chunk.block.text);
-	};
+	for (const seq of spanSeqs) {
+		const event = events[seq];
+		if (event?.type === "assistant/message") finalizedSteps.add(`${event.data.turn}:${event.data.step}`);
+	}
 	const pushAssistantText = (text, sourceSeq) => {
 		if (text !== "") entries.push({
 			role: "assistant",
@@ -304,7 +423,6 @@ function replayEntries(events, spanSeqs) {
 		const event = events[seq];
 		if (event === void 0) continue;
 		if (isMessageToolsEdit(event)) {
-			flushPending();
 			entries.push({
 				role: "user",
 				content: event.data.content,
@@ -312,12 +430,12 @@ function replayEntries(events, spanSeqs) {
 			});
 			continue;
 		}
-		if (event.type === "assistant/chunk") {
-			pushChunk(event);
+		if (event.type === "assistant/attempt") {
+			if (finalizedSteps.has(`${event.data.turn}:${event.data.step}`)) continue;
+			pushAssistantText(joinAttemptStreamText(event.data.stream), seq);
 			continue;
 		}
 		if (event.type === "user/message") {
-			flushPending();
 			if (event.surfaceOp !== "append") continue;
 			if (event.data.source.kind === "user" || isMessageToolsRestore(event)) entries.push({
 				role: "user",
@@ -332,17 +450,40 @@ function replayEntries(events, spanSeqs) {
 			continue;
 		}
 		if (event.type === "assistant/message") {
-			finalizedSteps.add(`${event.data.turn}:${event.data.step}`);
-			if (pending !== void 0 && pending.turn === event.data.turn && pending.step === event.data.step) pending.finalized = true;
-			flushPending();
 			pushAssistantText(joinAssistantMessageText(event.data.message.content), seq);
 			continue;
 		}
 	}
-	flushPending();
 	return entries;
 }
 /**
+* Join one attempt's compact stream into its visible text. Text deltas win;
+* reasoning is the fallback so an attempt that streamed only reasoning does
+* not lose the only assistant content the user saw (the same preference
+* {@link joinAssistantMessageText} applies to finalized messages). Packed
+* delta runs append per block index; a raw `block-end` record carries the
+* assembled block and replaces its index's accumulated deltas. Tool-call
+* runs never replay (their side effects are not replayable).
+*/
+function joinAttemptStreamText(stream) {
+	const text = /* @__PURE__ */ new Map();
+	const reasoning = /* @__PURE__ */ new Map();
+	const append = (map, index, fragment) => {
+		map.set(index, (map.get(index) ?? "") + fragment);
+	};
+	for (const record of stream) if (record.type === "text-chunks") append(text, record.index, record.texts.join(""));
+	else if (record.type === "reasoning-chunks") append(reasoning, record.index, record.texts.join(""));
+	else if (record.type === "chunk") {
+		const chunk = record.chunk;
+		if (chunk.type === "text-delta") append(text, chunk.index, chunk.text);
+		else if (chunk.type === "reasoning-delta") append(reasoning, chunk.index, chunk.text);
+		else if (chunk.type === "block-end" && chunk.block.type === "text") text.set(chunk.index, chunk.block.text);
+		else if (chunk.type === "block-end" && chunk.block.type === "reasoning") reasoning.set(chunk.index, chunk.block.text);
+	}
+	const joined = [...text.values()].join("");
+	return joined !== "" ? joined : [...reasoning.values()].join("");
+}
+/**
 * Plan a restore: the target must be an editable user message (the same
 * vocabulary as withdrawal — original, restore replay, or edit replacement)
 * that is no longer on the live surface (i.e. withdrawn). Restoring an edit
@@ -428,7 +569,7 @@ var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializ
 /**
 * messageTools Remote service: appends the withdrawal replacement to the
 * owning Session and flushes it durable. The replacement event's
-* plugin-tagged source is the audit trail; no new session event type is
+* producer-owned source is the audit trail; no new session event type is
 * introduced, so session reload stays safe for harnesses without this plugin.
 */
 let MessageToolsService = (() => {
@@ -490,10 +631,11 @@ let MessageToolsService = (() => {
 		constructor(ctx) {
 			super(ctx, "messageTools");
 			__runInitializers(this, _instanceExtraInitializers);
+			registerRestoreProjection(ctx);
 		}
 		/**
 		* Withdraw a user message: replace it and every surface node after it with
-		* a minimal plugin-sourced placeholder, hiding the span from the model.
+		* a minimal producer-sourced placeholder, hiding the span from the model.
 		* @param request - session identity and target message seq.
 		* @returns the replacement receipt, or a rejection from the closed failure union.
 		*/
@@ -513,15 +655,12 @@ let MessageToolsService = (() => {
 					type: "text",
 					text: WITHDRAWN_NOTICE
 				}],
-				source: {
-					kind: "plugin",
-					plugin: MESSAGE_TOOLS_PLUGIN
-				}
+				source: messageToolsSource()
 			}), {
 				surfaceOp: {
 					op: "replace",
-					start: SessionSeq(planned.plan.start),
-					end: SessionSeq(planned.plan.end)
+					startSeq: SessionSeq(planned.plan.start),
+					endSeq: SessionSeq(planned.plan.end)
 				},
 				sourceEventSeqs: planned.plan.sourceEventSeqs.map((seq) => SessionSeq(seq))
 			});
@@ -537,14 +676,14 @@ let MessageToolsService = (() => {
 		/**
 		* Restore a withdrawn span: replay every replayable entry of it (user
 		* messages verbatim — including the last edit's new text — and framed
-		* assistant text; tool calls/results never replay) as fresh plugin-tagged
-		* `user/message` appends at the conversation tail, in original order, each
-		* citing its original event in `sourceEventSeqs`. The surface replace model
-		* is positional — a replaced span folds into one node — so the span cannot
-		* be restored in place; the replayed entries are simply the newest messages
-		* the model sees. Assistant text replays as framed user-role messages:
-		* `assistant/message` cannot carry a plugin source and the turn/step trace
-		* forbids assistant appends outside a step.
+		* assistant text; tool calls/results never replay) as fresh
+		* producer-sourced `user/message` appends at the conversation tail, in
+		* original order, each citing its original event in `sourceEventSeqs`. The
+		* surface replace model is positional — a replaced span folds into one
+		* node — so the span cannot be restored in place; the replayed entries are
+		* simply the newest messages the model sees. Assistant text replays as
+		* framed user-role messages: `assistant/message` requires the model source
+		* and the turn/step trace forbids assistant appends outside a step.
 		* @param request - session identity and withdrawn message seq.
 		* @returns the restore receipt, or a rejection from the closed failure union.
 		*/
@@ -563,10 +702,7 @@ let MessageToolsService = (() => {
 			for (const entry of planned.plan.entries) {
 				const message = entry.role === "user" ? createUserMessage({
 					content: [...entry.content],
-					source: {
-						kind: "plugin",
-						plugin: MESSAGE_TOOLS_PLUGIN
-					}
+					source: messageToolsSource()
 				}) : createUserMessage({
 					content: [{
 						type: "text",
@@ -591,7 +727,7 @@ let MessageToolsService = (() => {
 		* with the edited text itself (no placeholder, no tail duplicate — the
 		* edited text appears exactly once, in the replacement event), then start a
 		* regeneration turn. The harness has no wake-without-append path, so the
-		* turn is started by `agent.followup` carrying a minimal plugin-sourced
+		* turn is started by `agent.followup` carrying a minimal producer-sourced
 		* trigger message (the ankh-guard/schedule pattern); the trigger is not the
 		* edited text and lands once, as itself.
 		* @param request - session identity, target seq, edited text.
@@ -617,8 +753,8 @@ let MessageToolsService = (() => {
 			}), {
 				surfaceOp: {
 					op: "replace",
-					start: SessionSeq(planned.plan.start),
-					end: SessionSeq(planned.plan.end)
+					startSeq: SessionSeq(planned.plan.start),
+					endSeq: SessionSeq(planned.plan.end)
 				},
 				sourceEventSeqs: planned.plan.sourceEventSeqs.map((seq) => SessionSeq(seq))
 			});