@khorsheed/dsh-client-message-tools 0.3.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
@@ -423,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 = (() => {
@@ -485,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.
 		*/
@@ -508,10 +655,7 @@ let MessageToolsService = (() => {
 					type: "text",
 					text: WITHDRAWN_NOTICE
 				}],
-				source: {
-					kind: "plugin",
-					plugin: MESSAGE_TOOLS_PLUGIN
-				}
+				source: messageToolsSource()
 			}), {
 				surfaceOp: {
 					op: "replace",
@@ -532,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.
 		*/
@@ -558,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",
@@ -586,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.

package/lib/typert.host.js

@@ -1,12 +1,14 @@
 /* Generated by @deepseek-ai/dsh-typert-generator from FaceModel — do not edit. */
 import { z } from 'zod'
 
-const _khorsheed_dsh_client_message_tools_messageTools_edit_parameter_0$schema = z.object({
+let _khorsheed_dsh_client_message_tools_messageTools_edit_parameter_0$schema$value
+const _khorsheed_dsh_client_message_tools_messageTools_edit_parameter_0$schema = () => (_khorsheed_dsh_client_message_tools_messageTools_edit_parameter_0$schema$value ??= z.object({
   'sessionId': z.intersection(z.string(), z.unknown()).readonly(),
   'targetSeq': z.number().readonly(),
   'text': z.string().readonly(),
-})
-const _khorsheed_dsh_client_message_tools_messageTools_edit_result$schema = z.union([z.object({
+}))
+let _khorsheed_dsh_client_message_tools_messageTools_edit_result$schema$value
+const _khorsheed_dsh_client_message_tools_messageTools_edit_result$schema = () => (_khorsheed_dsh_client_message_tools_messageTools_edit_result$schema$value ??= z.union([z.object({
   'ok': z.literal(true).readonly(),
   'value': z.object({
   'replacementSeq': z.number().readonly(),
@@ -25,12 +27,14 @@ const _khorsheed_dsh_client_message_tools_messageTools_edit_result$schema = z.un
 }), z.object({
   'code': z.literal("empty-text").readonly(),
 })]).readonly(),
-})])
-const _khorsheed_dsh_client_message_tools_messageTools_restore_parameter_0$schema = z.object({
+})]))
+let _khorsheed_dsh_client_message_tools_messageTools_restore_parameter_0$schema$value
+const _khorsheed_dsh_client_message_tools_messageTools_restore_parameter_0$schema = () => (_khorsheed_dsh_client_message_tools_messageTools_restore_parameter_0$schema$value ??= z.object({
   'sessionId': z.intersection(z.string(), z.unknown()).readonly(),
   'targetSeq': z.number().readonly(),
-})
-const _khorsheed_dsh_client_message_tools_messageTools_restore_result$schema = z.union([z.object({
+}))
+let _khorsheed_dsh_client_message_tools_messageTools_restore_result$schema$value
+const _khorsheed_dsh_client_message_tools_messageTools_restore_result$schema = () => (_khorsheed_dsh_client_message_tools_messageTools_restore_result$schema$value ??= z.union([z.object({
   'ok': z.literal(true).readonly(),
   'value': z.object({
   'restoredSeq': z.number().readonly(),
@@ -46,12 +50,14 @@ const _khorsheed_dsh_client_message_tools_messageTools_restore_result$schema = z
 }), z.object({
   'code': z.literal("not-withdrawn").readonly(),
 })]).readonly(),
-})])
-const _khorsheed_dsh_client_message_tools_messageTools_withdraw_parameter_0$schema = z.object({
+})]))
+let _khorsheed_dsh_client_message_tools_messageTools_withdraw_parameter_0$schema$value
+const _khorsheed_dsh_client_message_tools_messageTools_withdraw_parameter_0$schema = () => (_khorsheed_dsh_client_message_tools_messageTools_withdraw_parameter_0$schema$value ??= z.object({
   'sessionId': z.intersection(z.string(), z.unknown()).readonly(),
   'targetSeq': z.number().readonly(),
-})
-const _khorsheed_dsh_client_message_tools_messageTools_withdraw_result$schema = z.union([z.object({
+}))
+let _khorsheed_dsh_client_message_tools_messageTools_withdraw_result$schema$value
+const _khorsheed_dsh_client_message_tools_messageTools_withdraw_result$schema = () => (_khorsheed_dsh_client_message_tools_messageTools_withdraw_result$schema$value ??= z.union([z.object({
   'ok': z.literal(true).readonly(),
   'value': z.object({
   'replacementSeq': z.number().readonly(),
@@ -68,7 +74,7 @@ const _khorsheed_dsh_client_message_tools_messageTools_withdraw_result$schema =
 }), z.object({
   'code': z.literal("already-withdrawn").readonly(),
 })]).readonly(),
-})])
+})]))
 
 export const TYPERT = {
   package: '@khorsheed/dsh-client-message-tools',
@@ -90,16 +96,18 @@ export const TYPERT = {
           codec: {
             mode: 'strict',
             typeSymbol: '@khorsheed/dsh-client-message-tools/types#MessageToolsEditRequest',
-            schema: _khorsheed_dsh_client_message_tools_messageTools_edit_parameter_0$schema,
+            create: _khorsheed_dsh_client_message_tools_messageTools_edit_parameter_0$schema,
+            schema: _khorsheed_dsh_client_message_tools_messageTools_edit_parameter_0$schema(),
           },
         },
       ],
       result: {
         mode: 'strict',
         typeSymbol: '@khorsheed/dsh-client-message-tools/types#MessageToolsEditResult',
-        schema: _khorsheed_dsh_client_message_tools_messageTools_edit_result$schema,
+        create: _khorsheed_dsh_client_message_tools_messageTools_edit_result$schema,
+        schema: _khorsheed_dsh_client_message_tools_messageTools_edit_result$schema(),
       },
-      sourceLocation: {"file":"packages/message-tools/src/index.ts","line":135,"column":9},
+      sourceLocation: {"file":"packages/message-tools/src/index.ts","line":140,"column":9},
     },
     {
       id: '@khorsheed/dsh-client-message-tools#messageTools/restore',
@@ -115,16 +123,18 @@ export const TYPERT = {
           codec: {
             mode: 'strict',
             typeSymbol: '@khorsheed/dsh-client-message-tools/types#MessageToolsRestoreRequest',
-            schema: _khorsheed_dsh_client_message_tools_messageTools_restore_parameter_0$schema,
+            create: _khorsheed_dsh_client_message_tools_messageTools_restore_parameter_0$schema,
+            schema: _khorsheed_dsh_client_message_tools_messageTools_restore_parameter_0$schema(),
           },
         },
       ],
       result: {
         mode: 'strict',
         typeSymbol: '@khorsheed/dsh-client-message-tools/types#MessageToolsRestoreResult',
-        schema: _khorsheed_dsh_client_message_tools_messageTools_restore_result$schema,
+        create: _khorsheed_dsh_client_message_tools_messageTools_restore_result$schema,
+        schema: _khorsheed_dsh_client_message_tools_messageTools_restore_result$schema(),
       },
-      sourceLocation: {"file":"packages/message-tools/src/index.ts","line":97,"column":9},
+      sourceLocation: {"file":"packages/message-tools/src/index.ts","line":102,"column":9},
     },
     {
       id: '@khorsheed/dsh-client-message-tools#messageTools/withdraw',
@@ -140,25 +150,27 @@ export const TYPERT = {
           codec: {
             mode: 'strict',
             typeSymbol: '@khorsheed/dsh-client-message-tools/types#MessageToolsWithdrawRequest',
-            schema: _khorsheed_dsh_client_message_tools_messageTools_withdraw_parameter_0$schema,
+            create: _khorsheed_dsh_client_message_tools_messageTools_withdraw_parameter_0$schema,
+            schema: _khorsheed_dsh_client_message_tools_messageTools_withdraw_parameter_0$schema(),
           },
         },
       ],
       result: {
         mode: 'strict',
         typeSymbol: '@khorsheed/dsh-client-message-tools/types#MessageToolsWithdrawResult',
-        schema: _khorsheed_dsh_client_message_tools_messageTools_withdraw_result$schema,
+        create: _khorsheed_dsh_client_message_tools_messageTools_withdraw_result$schema,
+        schema: _khorsheed_dsh_client_message_tools_messageTools_withdraw_result$schema(),
       },
-      sourceLocation: {"file":"packages/message-tools/src/index.ts","line":63,"column":9},
+      sourceLocation: {"file":"packages/message-tools/src/index.ts","line":68,"column":9},
     },
   ],
   model: {
     "services": [
       {
-        "description": "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 introduced, so session reload stays safe for harnesses without this plugin.",
+        "description": "messageTools Remote service: appends the withdrawal replacement to the owning Session and flushes it durable. The replacement event's producer-owned source is the audit trail; no new session event type is introduced, so session reload stays safe for harnesses without this plugin.",
         "summary": "messageTools Remote service: appends the withdrawal replacement to the owning Session and flushes it durable.",
         "tags": [],
-        "jsDoc": "/**\n * messageTools Remote service: appends the withdrawal replacement to the\n * owning Session and flushes it durable. The replacement event's\n * plugin-tagged source is the audit trail; no new session event type is\n * introduced, so session reload stays safe for harnesses without this plugin.\n */",
+        "jsDoc": "/**\n * messageTools Remote service: appends the withdrawal replacement to the\n * owning Session and flushes it durable. The replacement event's\n * producer-owned source is the audit trail; no new session event type is\n * introduced, so session reload stays safe for harnesses without this plugin.\n */",
         "key": "messageTools",
         "exportName": "MessageToolsService",
         "members": [
@@ -166,22 +178,22 @@ export const TYPERT = {
             "kind": "method",
             "name": "withdraw",
             "signature": "@Remote('withdraw') async withdraw(request: MessageToolsWithdrawRequest): Promise<MessageToolsWithdrawResult>",
-            "summary": "Withdraw a user message: replace it and every surface node after it with a minimal plugin-sourced placeholder, hiding the span from the model.",
-            "jsDoc": "/**\n * Withdraw a user message: replace it and every surface node after it with\n * a minimal plugin-sourced placeholder, hiding the span from the model.\n * @param request - session identity and target message seq.\n * @returns the replacement receipt, or a rejection from the closed failure union.\n */"
+            "summary": "Withdraw a user message: replace it and every surface node after it with a minimal producer-sourced placeholder, hiding the span from the model.",
+            "jsDoc": "/**\n * Withdraw a user message: replace it and every surface node after it with\n * a minimal producer-sourced placeholder, hiding the span from the model.\n * @param request - session identity and target message seq.\n * @returns the replacement receipt, or a rejection from the closed failure union.\n */"
           },
           {
             "kind": "method",
             "name": "restore",
             "signature": "@Remote('restore') async restore(request: MessageToolsRestoreRequest): Promise<MessageToolsRestoreResult>",
-            "summary": "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`.",
-            "jsDoc": "/**\n * Restore a withdrawn span: replay every replayable entry of it (user\n * messages verbatim — including the last edit's new text — and framed\n * assistant text; tool calls/results never replay) as fresh plugin-tagged\n * `user/message` appends at the conversation tail, in original order, each\n * citing its original event in `sourceEventSeqs`. The surface replace model\n * is positional — a replaced span folds into one node — so the span cannot\n * be restored in place; the replayed entries are simply the newest messages\n * the model sees. Assistant text replays as framed user-role messages:\n * `assistant/message` cannot carry a plugin source and the turn/step trace\n * forbids assistant appends outside a step.\n * @param request - session identity and withdrawn message seq.\n * @returns the restore receipt, or a rejection from the closed failure union.\n */"
+            "summary": "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 producer-sourced `user/message` appends at the conversation tail, in original order, each citing its original event in `sourceEventSeqs`.",
+            "jsDoc": "/**\n * Restore a withdrawn span: replay every replayable entry of it (user\n * messages verbatim — including the last edit's new text — and framed\n * assistant text; tool calls/results never replay) as fresh\n * producer-sourced `user/message` appends at the conversation tail, in\n * original order, each citing its original event in `sourceEventSeqs`. The\n * surface replace model is positional — a replaced span folds into one\n * node — so the span cannot be restored in place; the replayed entries are\n * simply the newest messages the model sees. Assistant text replays as\n * framed user-role messages: `assistant/message` requires the model source\n * and the turn/step trace forbids assistant appends outside a step.\n * @param request - session identity and withdrawn message seq.\n * @returns the restore receipt, or a rejection from the closed failure union.\n */"
           },
           {
             "kind": "method",
             "name": "edit",
             "signature": "@Remote('edit') async edit(request: MessageToolsEditRequest): Promise<MessageToolsEditResult>",
             "summary": "Edit a user message in place: replace it and every surface node after it 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.",
-            "jsDoc": "/**\n * Edit a user message in place: replace it and every surface node after it\n * with the edited text itself (no placeholder, no tail duplicate — the\n * edited text appears exactly once, in the replacement event), then start a\n * regeneration turn. The harness has no wake-without-append path, so the\n * turn is started by `agent.followup` carrying a minimal plugin-sourced\n * trigger message (the ankh-guard/schedule pattern); the trigger is not the\n * edited text and lands once, as itself.\n * @param request - session identity, target seq, edited text.\n * @returns the replacement receipt and whether the turn was triggered, or a rejection.\n */"
+            "jsDoc": "/**\n * Edit a user message in place: replace it and every surface node after it\n * with the edited text itself (no placeholder, no tail duplicate — the\n * edited text appears exactly once, in the replacement event), then start a\n * regeneration turn. The harness has no wake-without-append path, so the\n * turn is started by `agent.followup` carrying a minimal producer-sourced\n * trigger message (the ankh-guard/schedule pattern); the trigger is not the\n * edited text and lands once, as itself.\n * @param request - session identity, target seq, edited text.\n * @returns the replacement receipt and whether the turn was triggered, or a rejection.\n */"
           }
         ],
         "types": [