@khorsheed/dsh-client-message-tools 0.3.0 → 0.3.2

package/lib/types/client/withdrawn-node.js

@@ -33,7 +33,7 @@ export const withdrawnDividerDefinition = {
     },
     start: (_context, match) => {
         const event = match.event;
-        if (!isMessageToolsReplacement(event)) {
+        if (event.type !== 'user/message' || !isMessageToolsReplacement(event)) {
             throw new Error('message-tools-withdrawn start requires a message-tools replacement event');
         }
         return { seq: event.seq, hiddenStartSeq: event.surfaceOp.startSeq };
@@ -59,7 +59,7 @@ export const editedMessageDefinition = {
     },
     start: (_context, match) => {
         const event = match.event;
-        if (!isMessageToolsEdit(event)) {
+        if (event.type !== 'user/message' || !isMessageToolsEdit(event)) {
             throw new Error('message-tools-edited start requires a message-tools edit replacement event');
         }
         return {
@@ -94,6 +94,21 @@ export function foldHiddenRanges(nodes) {
     pairs.sort((left, right) => left[0] - right[0]);
     return pairs.flat();
 }
+/**
+ * Fold one message's content blocks into the gallery slot's image input, in
+ * source order. Only `type: 'image'` blocks with an attachment qualify; a
+ * withdrawn user message must keep its images visible in the divider replay
+ * (they are exactly what the withdrawal hid).
+ */
+function imageSources(blocks) {
+    const images = [];
+    for (const block of blocks) {
+        const b = block;
+        if (b.type === 'image' && b.attachment !== undefined)
+            images.push({ attachment: b.attachment });
+    }
+    return images;
+}
 /** Join text blocks into one plain string. */
 function joinText(blocks) {
     return blocks
@@ -121,7 +136,7 @@ function joinAssistantText(blocks) {
 }
 /**
  * The restore-row Definition: one single-event Context per message-tools
- * user-message restore event (append-surface, plugin-tagged), replaying the
+ * user-message restore event (append-surface, producer-tagged), replaying the
  * withdrawn message's content at the tail.
  */
 export const restoredMessageDefinition = {
@@ -134,7 +149,7 @@ export const restoredMessageDefinition = {
     },
     start: (_context, match) => {
         const event = match.event;
-        if (!isMessageToolsRestore(event)) {
+        if (event.type !== 'user/message' || !isMessageToolsRestore(event)) {
             throw new Error('message-tools-restored start requires a message-tools restore event');
         }
         return {
@@ -167,7 +182,7 @@ export const restoredAssistantMessageDefinition = {
     },
     start: (_context, match) => {
         const event = match.event;
-        if (!isMessageToolsRestoreAssistant(event)) {
+        if (event.type !== 'user/message' || !isMessageToolsRestoreAssistant(event)) {
             throw new Error('message-tools-restored-assistant start requires a restore-assistant replay event');
         }
         return {
@@ -186,7 +201,7 @@ export const restoredAssistantMessageDefinition = {
  * Count the user-visible messages hidden by one withdrawn span. This mirrors
  * {@link collectWithdrawnEntries}: context injections, tool calls, turn tails,
  * and other UI chrome are not counted as “messages”, while restored/edited
- * rows and reasoning-only assistant steps are.
+ * rows, reasoning-only assistant steps, and image-only user messages are.
  * @param nodes - every materialized chat node.
  * @param startSeq - first hidden seq (inclusive).
  * @param endSeq - the divider's seq (exclusive).
@@ -196,12 +211,12 @@ export function countHiddenInSpan(nodes, startSeq, endSeq) {
     return collectWithdrawnEntries(nodes, startSeq, endSeq).length;
 }
 /**
- * Collect the read-only replay of one withdrawn span: user originals and
- * assistant text, in anchor order. Other kinds carry no user-readable text
- * and are skipped. Assistant-step data is kind-keyed (`data.blocks`, with
- * `data.finalNode.blocks` once settled — `conversation-nodes/assistant.ts`),
- * not type-keyed like message content. Reads the live node store — call from
- * event handlers.
+ * Collect the read-only replay of one withdrawn span: user originals (text
+ * and attached images alike) and assistant text, in anchor order. Other kinds
+ * carry no user-readable content and are skipped. Assistant-step data is
+ * kind-keyed (`data.blocks`, with `data.finalNode.blocks` once settled —
+ * `conversation-nodes/assistant.ts`), not type-keyed like message content.
+ * Reads the live node store — call from event handlers.
  * @param nodes - every materialized chat node.
  * @param startSeq - first hidden seq (inclusive).
  * @param endSeq - the divider's seq (exclusive).
@@ -216,27 +231,30 @@ export function collectWithdrawnEntries(nodes, startSeq, endSeq) {
         if (node.kind === 'user' || node.kind === 'steering' || node.kind === 'message-tools-edited') {
             const content = node.data.content ?? [];
             const text = joinText(content);
-            if (text !== '')
-                entries.push({ kind: 'user', text });
+            const images = imageSources(content);
+            if (text !== '' || images.length > 0)
+                entries.push({ kind: 'user', text, images });
             continue;
         }
         if (node.kind === 'message-tools-restored') {
-            const text = node.data.text ?? '';
-            if (text !== '')
-                entries.push({ kind: 'user', text });
+            const data = node.data;
+            const text = data.text ?? '';
+            const images = imageSources(data.content ?? []);
+            if (text !== '' || images.length > 0)
+                entries.push({ kind: 'user', text, images });
             continue;
         }
         if (node.kind === 'message-tools-restored-assistant') {
             const text = node.data.text ?? '';
             if (text !== '')
-                entries.push({ kind: 'assistant', text });
+                entries.push({ kind: 'assistant', text, images: [] });
             continue;
         }
         if (node.kind === 'assistant-step') {
             const data = node.data;
             const text = joinAssistantText(data.finalNode?.blocks ?? data.blocks ?? []);
             if (text !== '')
-                entries.push({ kind: 'assistant', text });
+                entries.push({ kind: 'assistant', text, images: [] });
         }
     }
     return entries;

package/lib/types/index.d.ts

@@ -21,7 +21,7 @@ declare module '@deepseek-ai/cordis' {
 /**
  * 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.
  */
 export declare class MessageToolsService extends TypertRemoteService {
@@ -32,7 +32,7 @@ export declare class MessageToolsService extends TypertRemoteService {
     constructor(ctx: Context);
     /**
      * 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.
      */
@@ -40,14 +40,14 @@ export declare class MessageToolsService extends TypertRemoteService {
     /**
      * 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.
      */
@@ -57,7 +57,7 @@ export declare class MessageToolsService extends TypertRemoteService {
      * 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/types/index.js

@@ -36,12 +36,13 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
 import { SessionSeq } from '@deepseek-ai/dsh-session';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
-import { EDIT_TRIGGER_NOTICE, MESSAGE_TOOLS_PLUGIN, WITHDRAWN_NOTICE, editReplacementSource, editTriggerSource, restoreAssistantSource, } from './marker.js';
+import { EDIT_TRIGGER_NOTICE, WITHDRAWN_NOTICE, editReplacementSource, editTriggerSource, messageToolsSource, restoreAssistantSource, } from './marker.js';
+import { registerRestoreProjection } from './restore-projection.js';
 import { planEdit, planRestore, planWithdrawal } from './withdraw.js';
 /**
  * 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 = (() => {
@@ -68,10 +69,14 @@ let MessageToolsService = (() => {
         constructor(ctx) {
             super(ctx, 'messageTools');
             __runInitializers(this, _instanceExtraInitializers);
+            // Seam registry S12: on a host whose session fold can carry a user/message
+            // projection, restore replays derive assistant-role without the frame;
+            // every degrade path leaves the framed user-role channel verbatim.
+            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.
          */
@@ -84,7 +89,7 @@ let MessageToolsService = (() => {
                 return { ok: false, error: { code: planned.code } };
             const replacement = session.append('user/message', createUserMessage({
                 content: [{ type: 'text', text: WITHDRAWN_NOTICE }],
-                source: { kind: 'plugin', plugin: MESSAGE_TOOLS_PLUGIN },
+                source: messageToolsSource(),
             }), {
                 surfaceOp: { op: 'replace', startSeq: SessionSeq(planned.plan.start), endSeq: SessionSeq(planned.plan.end) },
                 sourceEventSeqs: planned.plan.sourceEventSeqs.map(seq => SessionSeq(seq)),
@@ -98,14 +103,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.
          */
@@ -121,7 +126,7 @@ let MessageToolsService = (() => {
                 const message = entry.role === 'user'
                     ? createUserMessage({
                         content: [...entry.content],
-                        source: { kind: 'plugin', plugin: MESSAGE_TOOLS_PLUGIN },
+                        source: messageToolsSource(),
                     })
                     : createUserMessage({
                         content: [{ type: 'text', text: entry.text }],
@@ -141,7 +146,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/types/marker.d.ts

@@ -1,7 +1,23 @@
-import type { MessageSource } from '@deepseek-ai/dsh-llm/message';
+import type { ContextFormed, MessageSource } from '@deepseek-ai/dsh-llm/message';
 import type { SessionEvent } from '@deepseek-ai/dsh-session/types';
-/** 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.
+ */
 export declare const MESSAGE_TOOLS_PLUGIN = "message-tools";
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        /** message-tools producer: withdrawal/edit replacements, edit triggers, restore replays. */
+        'message-tools': {
+            kind: 'message-tools';
+            readonly op?: MessageToolsOp;
+        } & ContextFormed;
+    }
+}
 /**
  * Model-facing placeholder left on the surface in place of the withdrawn
  * span. The span itself is hidden from the model; this minimal user message
@@ -17,21 +33,36 @@ export declare const WITHDRAWN_NOTICE = "(\u7528\u6237\u64A4\u56DE\u4E86\u8FD9\u
 export declare const EDIT_TRIGGER_NOTICE = "(\u7528\u6237\u7F16\u8F91\u4E86\u4E0A\u4E00\u6761\u6D88\u606F\uFF0C\u8BF7\u6309\u7F16\u8F91\u540E\u7684\u5185\u5BB9\u91CD\u65B0\u56DE\u7B54)";
 /**
  * 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.
  */
 export declare const RESTORED_ASSISTANT_NOTICE = "(\u4EE5\u4E0B\u662F\u5148\u524D\u88AB\u64A4\u56DE\u3001\u73B0\u968F\u6062\u590D\u653E\u56DE\u7684\u52A9\u624B\u56DE\u590D)";
-/** The `op` discriminator on a message-tools plugin source. */
+/** The `op` discriminator on a message-tools source. */
 export type MessageToolsOp = 'edit' | 'edit-trigger' | 'restore-assistant';
-/** 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). */
+export declare function messageToolsSource(): MessageSource;
+/** The producer-owned source of an edit replacement (op: 'edit'). */
 export declare function editReplacementSource(): MessageSource;
-/** The plugin-tagged source of an edit trigger message (op: 'edit-trigger'). */
+/** The producer-owned source of an edit trigger message (op: 'edit-trigger'). */
 export declare function editTriggerSource(): MessageSource;
-/** 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'). */
 export declare function restoreAssistantSource(): MessageSource;
-/** 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). */
 export declare function messageToolsOp(source: unknown): MessageToolsOp | undefined;
+/**
+ * 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.
+ */
+export declare function isMessageToolsSource(source: unknown): boolean;
 /**
  * Strip the model-facing restore frame from a replayed assistant text for
  * DISPLAY: the frame belongs to the model context (role honesty), never to
@@ -56,8 +87,9 @@ export type MessageToolsRestoreEvent = SessionEvent<'user/message'> & {
 };
 /**
  * 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.
  */
@@ -78,7 +110,7 @@ export declare function isMessageToolsEdit(event: SessionEvent): event is Messag
 export declare function isMessageToolsRestore(event: SessionEvent): event is MessageToolsRestoreEvent;
 /**
  * Whether the event is a message-tools edit trigger: the minimal
- * plugin-sourced message that starts the regeneration turn after an edit.
+ * producer-sourced message that starts the regeneration turn after an edit.
  * @param event - the session event to test.
  * @returns the event narrowed to an edit trigger when matched.
  */

package/lib/types/marker.js

@@ -1,10 +1,10 @@
 /**
- * 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
@@ -12,7 +12,14 @@
  * @module @khorsheed/dsh-client-message-tools/marker
  */
 import { isReplacementSurfaceEvent } from '@deepseek-ai/dsh-session/surface';
-/** 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.
+ */
 export const MESSAGE_TOOLS_PLUGIN = 'message-tools';
 /**
  * Model-facing placeholder left on the surface in place of the withdrawn
@@ -29,28 +36,52 @@ export const WITHDRAWN_NOTICE = '(用户撤回了这条消息及其后的所有
 export 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.
  */
 export 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). */
+export function messageToolsSource() {
+    return Object.freeze({ kind: MESSAGE_TOOLS_PLUGIN });
+}
+/** The producer-owned source of an edit replacement (op: 'edit'). */
 export function editReplacementSource() {
-    return Object.freeze({ kind: 'plugin', plugin: MESSAGE_TOOLS_PLUGIN, op: 'edit' });
+    return Object.freeze({ 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'). */
 export function editTriggerSource() {
-    return Object.freeze({ kind: 'plugin', plugin: MESSAGE_TOOLS_PLUGIN, op: 'edit-trigger' });
+    return Object.freeze({ 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'). */
 export function restoreAssistantSource() {
-    return Object.freeze({ kind: 'plugin', plugin: MESSAGE_TOOLS_PLUGIN, op: 'restore-assistant' });
+    return Object.freeze({ 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). */
 export function messageToolsOp(source) {
     const op = source?.op;
     return op === 'edit' || op === 'edit-trigger' || op === 'restore-assistant' ? op : undefined;
 }
+/**
+ * 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.
+ */
+export function isMessageToolsSource(source) {
+    if (typeof source !== 'object' || source === null)
+        return false;
+    const record = source;
+    return record.kind === MESSAGE_TOOLS_PLUGIN
+        || record.kind === `plugin:${MESSAGE_TOOLS_PLUGIN}`
+        || (record.kind === 'plugin' && record.plugin === MESSAGE_TOOLS_PLUGIN);
+}
 /**
  * Strip the model-facing restore frame from a replayed assistant text for
  * DISPLAY: the frame belongs to the model context (role honesty), never to
@@ -64,16 +95,16 @@ export function stripRestoreAssistantFrame(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.
  */
 export function isMessageToolsReplacement(event) {
     return event.type === 'user/message'
         && isReplacementSurfaceEvent(event)
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === undefined;
 }
 /**
@@ -85,8 +116,7 @@ export function isMessageToolsReplacement(event) {
 export function isMessageToolsEdit(event) {
     return event.type === 'user/message'
         && isReplacementSurfaceEvent(event)
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === 'edit';
 }
 /**
@@ -98,21 +128,19 @@ export function isMessageToolsEdit(event) {
 export function isMessageToolsRestore(event) {
     return event.type === 'user/message'
         && event.surfaceOp === 'append'
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === undefined;
 }
 /**
  * Whether the event is a message-tools edit trigger: the minimal
- * plugin-sourced message that starts the regeneration turn after an edit.
+ * producer-sourced message that starts the regeneration turn after an edit.
  * @param event - the session event to test.
  * @returns the event narrowed to an edit trigger when matched.
  */
 export function isMessageToolsTrigger(event) {
     return event.type === 'user/message'
         && event.surfaceOp === 'append'
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === 'edit-trigger';
 }
 /**
@@ -125,7 +153,6 @@ export function isMessageToolsTrigger(event) {
 export function isMessageToolsRestoreAssistant(event) {
     return event.type === 'user/message'
         && event.surfaceOp === 'append'
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === 'restore-assistant';
 }

package/lib/types/restore-projection.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Restore-assistant message projection (seam registry S12): the pure
+ * `user/message` interpreter that rewrites a restore replay's derived message
+ * to assistant role with the model-facing frame stripped, plus the
+ * registration helper that probes the host for the capability and degrades to
+ * the framed user-role channel when it cannot carry the projection. The
+ * durable log is identical on both channels — the restore append keeps its
+ * `restore-assistant` source mark and its frame prefix; only the model-facing
+ * derivation differs.
+ * @module @khorsheed/dsh-client-message-tools/restore-projection
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import * as sessionApi from '@deepseek-ai/dsh-session';
+import type { SessionMessageProjection } from '@deepseek-ai/dsh-session';
+/**
+ * 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.
+ */
+export declare const restoreAssistantProjection: SessionMessageProjection<'user/message'>;
+/**
+ * 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.
+ */
+export declare function restoreProjectionFoldSupported(fold?: typeof sessionApi.foldSurface | undefined, derive?: typeof sessionApi.deriveEventMessage | undefined): boolean;
+/**
+ * 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.
+ */
+export declare function registerRestoreProjection(ctx: Context, foldSupported?: () => boolean): boolean;
+//# sourceMappingURL=restore-projection.d.ts.map