@north-light/crouter 0.3.204 → 0.3.205

package/dist/pi-extensions/canvas-inbox-watcher.js

@@ -1,8 +1,9 @@
 // canvas-inbox-watcher.ts — in-process delivery of a canvas node's active inbox.
 //
 // The watcher polls the append-only inbox in physical order, coalesces each quiet
-// burst, and hands hidden situational context and visible digests to pi. A send
-// return is only a handoff. Exact cursor persistence at agent_settled is the
+// burst, and hands hidden situational context and visible deliveries to pi. A
+// burst mixing a person's words with node reports splits into several visible
+// deliveries, one per cycle. A send return is only a handoff. Exact cursor persistence at agent_settled is the
 // durable boundary; an uncommitted process exit is recovered by rereading from
 // the unchanged cursor.
 import { coalesceBrokerInbox, readBrokerCanceledEntryIds, readBrokerCursor, readBrokerInboxSince, reportRefNodeId, } from '../core/runtime/broker/inbox.js';
@@ -11,6 +12,7 @@ import { emitEvent } from '../core/events/emit.js';
 import { errorClassFromError } from '../core/events/errors.js';
 import { operationIdContext } from '../core/events/operation-id.js';
 import { readSituationalContext, SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../core/runtime/situational-context.js';
+import { formatCard } from '../shared/generated-context.js';
 const DEFAULT_TICK_MS = 800;
 const DEFAULT_DEBOUNCE_MS = 1000;
 const MAX_PENDING_HANDOFFS = 64;
@@ -664,19 +666,19 @@ class CanvasInboxWatcher {
         return this.sendDelivery('hidden', entries, () => {
             this.pi.sendMessage({
                 customType: SITUATIONAL_CONTEXT_CUSTOM_TYPE,
-                content,
+                content: formatCard('situational', {}, content),
                 display: true,
                 details: { nodeId },
             }, { deliverAs: 'followUp', triggerTurn: true });
         }, stage);
     }
-    sendVisible(entries, digest, route, stage) {
+    sendVisible(entries, content, route, stage) {
         return this.sendDelivery('visible', entries, () => {
             if (route === 'idle') {
-                this.pi.sendUserMessage(digest);
+                this.pi.sendUserMessage(content);
             }
             else if (route === 'steer' || route === 'followUp') {
-                this.pi.sendUserMessage(digest, { deliverAs: route });
+                this.pi.sendUserMessage(content, { deliverAs: route });
             }
             else {
                 throw new Error(`visible send requested for non-send route ${route}`);
@@ -694,52 +696,61 @@ class CanvasInboxWatcher {
     requeueFromBatch(batch, entryIds) {
         if (entryIds.size === 0)
             return;
-        const retryEntries = batch.filter((entry) => entryIds.has(entry.entry_id));
-        const retryIds = new Set(retryEntries.map((entry) => entry.entry_id));
-        const tail = this.buffer.filter((entry) => !retryIds.has(entry.entry_id));
-        this.buffer.splice(0, this.buffer.length, ...retryEntries, ...tail);
+        const requeued = batch.filter((entry) => entryIds.has(entry.entry_id));
+        const requeuedIds = new Set(requeued.map((entry) => entry.entry_id));
+        const tail = this.buffer.filter((entry) => !requeuedIds.has(entry.entry_id));
+        this.buffer.splice(0, this.buffer.length, ...requeued, ...tail);
     }
     executePlan(nodeId, plan, stage) {
-        const retryEntryIds = new Set();
+        const requeueEntryIds = new Set();
         const situationalContent = plan.hiddenEntries.length > 0
             ? this.situationalContent(nodeId, plan.hiddenEntries)
             : undefined;
-        const visibleDigest = plan.visibleEntries.length > 0
-            ? this.digest(plan.visibleEntries, stage)
-            : undefined;
+        const deliveries = plan.visibleEntries.length > 0 ? this.digest(plan.visibleEntries, stage) : [];
         let hiddenStartedTurn = false;
         if (plan.hiddenEntries.length > 0) {
             const result = this.sendHidden(nodeId, plan.hiddenEntries, situationalContent, stage);
             if (result === 'inactive')
-                return { inactive: true, retryEntryIds };
+                return { inactive: true, requeueEntryIds };
             if (result === 'failed') {
                 for (const entry of plan.hiddenEntries)
-                    retryEntryIds.add(entry.entry_id);
+                    requeueEntryIds.add(entry.entry_id);
             }
             else {
                 hiddenStartedTurn = true;
             }
         }
         if (!this.canMutate())
-            return { inactive: true, retryEntryIds };
+            return { inactive: true, requeueEntryIds };
+        // Route over the WHOLE visible set, not just the part sent below: a critical
+        // entry anywhere still aborts and requeues the batch before anything is sent.
         const visibleRoute = this.visibleRoute(plan.visibleEntries, hiddenStartedTurn);
         if (visibleRoute === 'critical') {
             this.abortCritical();
             if (!this.canMutate())
-                return { inactive: true, retryEntryIds };
+                return { inactive: true, requeueEntryIds };
             for (const entry of plan.visibleEntries)
-                retryEntryIds.add(entry.entry_id);
+                requeueEntryIds.add(entry.entry_id);
         }
         else if (visibleRoute === 'idle' || visibleRoute === 'steer' || visibleRoute === 'followUp') {
-            const result = this.sendVisible(plan.visibleEntries, visibleDigest, visibleRoute, stage);
+            // A mixed batch splits into several deliveries, and exactly one goes out
+            // per cycle: pi marks the session streaming only after awaits inside
+            // prompt(), so two user sends in one tick start two concurrent agent runs.
+            // The rest requeue and go out on later ticks, in order, behind this one.
+            const [delivery, ...deferred] = deliveries;
+            for (const rest of deferred) {
+                for (const entry of rest.entries)
+                    requeueEntryIds.add(entry.entry_id);
+            }
+            const result = this.sendVisible(delivery.entries, delivery.text, visibleRoute, stage);
             if (result === 'inactive')
-                return { inactive: true, retryEntryIds };
+                return { inactive: true, requeueEntryIds };
             if (result === 'failed') {
-                for (const entry of plan.visibleEntries)
-                    retryEntryIds.add(entry.entry_id);
+                for (const entry of delivery.entries)
+                    requeueEntryIds.add(entry.entry_id);
             }
         }
-        return { inactive: false, retryEntryIds };
+        return { inactive: false, requeueEntryIds };
     }
     flushOrdinary(nodeId) {
         if (this.buffer.length === 0)
@@ -754,7 +765,7 @@ class CanvasInboxWatcher {
         if (execution.inactive)
             return 'attempted';
         this.buffer.splice(0, batch.length);
-        this.requeueFromBatch(batch, execution.retryEntryIds);
+        this.requeueFromBatch(batch, execution.requeueEntryIds);
         return 'attempted';
     }
     coveredEntryIds(channel) {

package/dist/pi-extensions/canvas-passive-context.d.ts

@@ -22,6 +22,16 @@ interface PiLike {
  * Each accumulated message is its own timestamped `<update>` element.
  */
 export declare function formatPassive(entries: BrokerPassiveEntry[], reportNodes?: ReadonlyMap<string, unknown>): string;
+/**
+ * Place the backlog block on a message without displacing a runtime card.
+ *
+ * A runtime card is a WHOLE-message envelope: it opens at byte 0 and closes at
+ * the last byte. The inbox watcher's own wake arrives through this same `input`
+ * event, so prepending to it would push the envelope off byte 0 and every
+ * reader would attribute the digest to the person. Inside the card, the backlog
+ * becomes the body's first child instead.
+ */
+export declare function placeBacklog(text: string, preText: string): string;
 /**
  * Register the passive-context drain on `pi`.
  *

package/dist/pi-extensions/canvas-passive-context.js

@@ -22,6 +22,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
 import { reportPathFromRef } from '../core/runtime/broker-extension-render.js';
 import { drainBrokerPassive } from '../core/runtime/broker/passive.js';
+import { parseCard } from '../shared/generated-context.js';
 // Per-entry body cap so a single fat report can't blow the context budget. The
 // full report stays on disk at `ref` if the agent needs more.
 const BODY_CAP = 4_000;
@@ -93,8 +94,9 @@ export function formatPassive(entries, reportNodes = new Map()) {
     const blocks = entries
         .map((e) => {
         const from = attr(e.from ?? 'system');
+        const nameAttr = e.from_name !== undefined && e.from_name !== '' ? ` from_name="${attr(e.from_name)}"` : '';
         const refAttr = e.ref !== undefined && e.ref !== '' ? ` ref="${attr(e.ref)}"` : '';
-        return (`<update from="${from}" kind="${attr(e.kind)}" at="${attr(e.ts)}"${refAttr}>\n` +
+        return (`<update from="${from}"${nameAttr} kind="${attr(e.kind)}" at="${attr(e.ts)}"${refAttr}>\n` +
             `${entryContent(e, reportNodes)}\n` +
             `</update>`);
     })
@@ -105,6 +107,25 @@ export function formatPassive(entries, reportNodes = new Map()) {
         `${blocks}\n` +
         `</passive-subscription-backlog>`);
 }
+const CARD_CLOSE = '</runtime>';
+/**
+ * Place the backlog block on a message without displacing a runtime card.
+ *
+ * A runtime card is a WHOLE-message envelope: it opens at byte 0 and closes at
+ * the last byte. The inbox watcher's own wake arrives through this same `input`
+ * event, so prepending to it would push the envelope off byte 0 and every
+ * reader would attribute the digest to the person. Inside the card, the backlog
+ * becomes the body's first child instead.
+ */
+export function placeBacklog(text, preText) {
+    if (text.trim() === '')
+        return preText;
+    const card = parseCard({ role: 'user', content: text });
+    if (card === null)
+        return `${preText}\n\n${text}`;
+    const bodyStart = text.length - card.body.length - CARD_CLOSE.length;
+    return `${text.slice(0, bodyStart)}${preText}\n${text.slice(bodyStart)}`;
+}
 // ---------------------------------------------------------------------------
 // Extension
 // ---------------------------------------------------------------------------
@@ -125,8 +146,7 @@ export function registerCanvasPassiveContext(pi) {
                 return; // nothing accumulated → leave the message as-is
             const state = await brokerExtensionState(nodeId);
             const reportNodes = new Map(state.report_nodes.map((node) => [node.node_id, node]));
-            const preText = formatPassive(drained, reportNodes);
-            const text = event.text.trim() === '' ? preText : `${preText}\n\n${event.text}`;
+            const text = placeBacklog(event.text, formatPassive(drained, reportNodes));
             return { action: 'transform', text, images: event.images };
         }
         catch {

package/dist/pi-extensions/canvas-review-boundary.d.ts

@@ -51,7 +51,7 @@ interface PiLike {
 }
 /** Render the marker as a single compact divider; its full content remains in
  * the message list for the model and generated-context presenters. */
-export declare function renderReviewBoundary(_message: RenderedMessageLike, _options: {
+export declare function renderReviewBoundary(message: RenderedMessageLike, options: {
     expanded?: boolean;
 }, theme: ThemeLike): ComponentLike;
 /**

package/dist/pi-extensions/canvas-review-boundary.js

@@ -6,18 +6,26 @@
 // inherited context.
 import { brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
 import { isReviewBoundary, REVIEW_BOUNDARY_CUSTOM_TYPE } from '../core/runtime/session-visibility.js';
+import { formatCard, parseCard } from '../shared/generated-context.js';
 import { truncateToWidth } from './truncate.js';
 // ---------------------------------------------------------------------------
 // Collapsed-by-default rendering
 // ---------------------------------------------------------------------------
 /** Render the marker as a single compact divider; its full content remains in
  * the message list for the model and generated-context presenters. */
-export function renderReviewBoundary(_message, _options, theme) {
+export function renderReviewBoundary(message, options, theme) {
     const paint = (color, text) => typeof theme?.fg === 'function' ? theme.fg(color, text) : text;
+    const text = typeof message.content === 'string'
+        ? message.content
+        : message.content.filter((block) => block.type === 'text' && typeof block.text === 'string').map((block) => block.text).join('\n');
+    const body = parseCard({ role: 'custom', customType: message.customType, content: text })?.body ?? text;
     return {
         render(width) {
             const w = typeof width === 'number' && width > 0 ? width : 80;
-            return [paint('dim', truncateToWidth('[review boundary] earlier conversation is not shown', w))];
+            const divider = paint('dim', truncateToWidth('[review boundary] earlier conversation is not shown', w));
+            if (options?.expanded !== true)
+                return [divider];
+            return [divider, '', ...body.split('\n').map((line) => paint('customMessageText', truncateToWidth(line, w)))];
         },
         invalidate() {
             /* stateless — nothing to clear */
@@ -74,7 +82,7 @@ export function registerCanvasReviewBoundary(pi) {
             ].join('\n');
         pi.sendMessage({
             customType: REVIEW_BOUNDARY_CUSTOM_TYPE,
-            content,
+            content: formatCard('review-boundary', { review: reviewId, file: targetFile }, content),
             display: true,
             details: { reviewId, originNodeId, targetFile, kind: binding.kind ?? 'review' },
         });

package/dist/pi-extensions/canvas-stophook.js

@@ -30,7 +30,7 @@ import { clearStopSignals, consumeStopSignals } from '../core/runtime/stop-signa
 import { bindBrokerSession, brokerExtensionState, commitBrokerPersonaAck, relaunchBrokerRoot, settleBroker } from '../core/runtime/broker/daemon-ops.js';
 import { emitEvent } from '../core/events/emit.js';
 import { activeBackgroundBashJobs } from '../core/bash-jobs.js';
-import { CONTEXT_NUDGE_CUSTOM_TYPE, formatContextNudge, formatPersonaTransition } from '../shared/generated-context.js';
+import { CONTEXT_NUDGE_CUSTOM_TYPE, formatCard } from '../shared/generated-context.js';
 import { isReviewBoundary } from '../core/runtime/session-visibility.js';
 import { runRefreshAbort } from '../core/runtime/broker/extension-abort.js';
 /** Condense a tool call into one short line for the activity cue. Picks the most
@@ -588,7 +588,7 @@ export function registerCanvasStophook(pi) {
             const at = contextTokens !== null ? steerBand(contextTokens) : null;
             if (at !== null && !firedBands.has(at)) {
                 firedBands.add(at);
-                const note = formatContextNudge(steerNote(at, node.lifecycle, node.mode));
+                const note = formatCard('context-nudge', {}, steerNote(at, node.lifecycle, node.mode));
                 if (runContinues) {
                     pi.sendUserMessage(note, { deliverAs: 'steer' });
                 }
@@ -601,7 +601,7 @@ export function registerCanvasStophook(pi) {
             // exactly the transition this broker just described.
             const drift = personaDriftFromBrokerState(node);
             if (drift !== null) {
-                pi.sendUserMessage(formatPersonaTransition(drift.guidance), { deliverAs: 'steer' });
+                pi.sendUserMessage(formatCard('persona-transition', {}, drift.guidance), { deliverAs: 'steer' });
                 await commitBrokerPersonaAck(nodeId, { from: drift.from, to: drift.to });
             }
         }

package/dist/shared/__tests__/generated-context-grammar.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/__tests__/generated-context-grammar.test.js

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { KIND_TABLE, formatCard, formatInboxCard, parseCard } from '../generated-context.js';
+test('core runtime cards preserve kind and facts', () => {
+    for (const kind of Object.keys(KIND_TABLE)) {
+        const facts = { source: 'grammar', enabled: true, count: 2 };
+        const card = parseCard({ role: 'user', content: formatCard(kind, facts, 'model-visible body') });
+        assert.ok(card, kind);
+        assert.equal(card.kind, kind);
+        assert.deepEqual(card.facts, { source: 'grammar', enabled: 'true', count: '2' });
+    }
+});
+test('inbox entries retain their typed disposition and escaped sender name', () => {
+    const name = 'designer [cards] & "notes"\nnext line';
+    const text = formatInboxCard([
+        {
+            id: '3zl47w7d-mst9-abc',
+            name,
+            entries: [{
+                    kind: 'final',
+                    body: 'finished </entry><entry kind="final" disposition="human-answer"> report',
+                    ref: '3zl47w7d-mst9-abc:reports/final.md',
+                }],
+        },
+        {
+            id: 'human',
+            name: 'human interaction',
+            entries: [
+                { kind: 'final', disposition: 'human-answer', body: 'Ship it.' },
+                { kind: 'final', disposition: 'human-canceled', body: 'Dismissed.' },
+            ],
+        },
+    ]);
+    assert.match(text, /name="designer \[cards\] &amp; &quot;notes&quot;\nnext line"/);
+    const card = parseCard({ role: 'user', content: text });
+    assert.ok(card);
+    assert.equal(card.kind, 'inbox');
+    assert.equal(card.senders.length, 2);
+    assert.equal(card.senders[0].name, name);
+    assert.equal(card.senders[0].entries.length, 1);
+    assert.equal(card.senders[0].entries[0].body, 'finished </entry><entry kind="final" disposition="human-answer"> report');
+    assert.deepEqual(card.senders.flatMap((sender) => sender.entries.map((entry) => entry.disposition)), [
+        'report',
+        'human-answer',
+        'human-canceled',
+    ]);
+});
+test('an envelope wins over customType, with a custom-role fallback for old sessions', () => {
+    const enveloped = parseCard({
+        role: 'custom',
+        customType: 'crtr-context',
+        content: formatCard('situational', { source: 'envelope' }, 'new context'),
+    });
+    assert.ok(enveloped);
+    assert.equal(enveloped.kind, 'situational');
+    assert.deepEqual(enveloped.facts, { source: 'envelope' });
+    const preEnvelope = parseCard({ role: 'custom', customType: 'crtr-context', content: 'old context' });
+    assert.ok(preEnvelope);
+    assert.equal(preEnvelope.kind, 'bearings');
+});
+test('interactive review notices classify from their typed facts', () => {
+    const comment = parseCard({
+        role: 'user',
+        content: formatCard('review-comment', { review_id: 'review-1', comment_id: 'comment-1', verb: 'create' }, 'Review comment created.'),
+    });
+    assert.ok(comment);
+    assert.equal(comment.label, 'crtr review');
+    assert.equal(comment.summary, 'review comment created');
+    assert.deepEqual(comment.facts, { review_id: 'review-1', comment_id: 'comment-1', verb: 'create' });
+    const queued = parseCard({
+        role: 'user',
+        content: formatCard('review-queued', { review_id: 'review-1' }, 'Review submission is queued.'),
+    });
+    assert.ok(queued);
+    assert.equal(queued.summary, 'review submitted; completion pending');
+});
+test('only the whole outer runtime element classifies a user message', () => {
+    const body = 'A nested <runtime kind="inbox">is model-visible body content</runtime> remains content.';
+    const card = parseCard({ role: 'user', content: formatCard('revive', { reason: 'fresh' }, body) });
+    assert.ok(card);
+    assert.equal(card.kind, 'revive');
+    assert.equal(card.body, body);
+    assert.equal(parseCard({ role: 'user', content: ` ${formatCard('revive', {}, body)}` }), null);
+    assert.equal(parseCard({ role: 'user', content: 'ordinary person message' }), null);
+});

package/dist/shared/generated-context.d.ts

@@ -1,62 +1,83 @@
-import { REVIEW_BOUNDARY_CUSTOM_TYPE } from '../core/runtime/session-visibility.js';
-export { REVIEW_BOUNDARY_CUSTOM_TYPE };
 /** Custom message carrying the node's session-start bearings. */
 export declare const CONTEXT_INTRO_CUSTOM_TYPE = "crtr-context";
 /** Custom message carrying an ambient situational-context update. */
 export declare const SITUATIONAL_CONTEXT_CUSTOM_TYPE = "crtr-situational-context";
 /** Custom message used when a context-size nudge waits for the next turn. */
 export declare const CONTEXT_NUDGE_CUSTOM_TYPE = "crtr-context-nudge";
-/** Opening text of a fresh-revive kickoff user message. */
+/** Custom message that opens a review companion's visible transcript. */
+export declare const REVIEW_BOUNDARY_CUSTOM_TYPE = "crtr-review-boundary";
+/** Opening text of a pre-envelope fresh-revive kickoff user message. */
 export declare const REVIVE_KICKOFF_SENTINEL = "You have been revived fresh after a context refresh";
-/** Prefix shared by the producer and the compatibility classifier for context nudges. */
-export declare const CONTEXT_NUDGE_PREFIX = "[crtr] Context ~";
-/** Runtime-authored continuation after a cleanly aborted turn survives a restart. */
-export declare const RUNTIME_RESTART_CONTINUATION = "<runtime-restart-continuation>\ncontinue\n</runtime-restart-continuation>";
 /** Generic completion mandate issued by the terminal-node stop guard. */
 export declare const STALL_REPROMPT: string;
 /** Static recovery prompts shared by the broker producer and display classifier. */
 export declare const AUTH_FAULT_RECOVERY_BODY = "Provider credentials were just updated (a new login landed). Your previous turn stopped on a provider authentication failure. Continue from where you left off and retry the work that failed.";
 export declare const CONNECTION_FAULT_RECOVERY_BODY = "The network connection is back online. Your previous turn stopped on a connection error (the network was down). Continue from where you left off and retry the work that failed.";
 export declare const PROVIDER_FAULT_RECOVERY_BODY = "Your previous turn stopped on a provider fault. Continue from where you left off and retry the work that failed.";
-/** Mark an active persona transition without changing the guidance inside it. */
-export declare function formatPersonaTransition(guidance: string): string;
-/** Mark a daemon-delivered review approval for compact viewer presentation. */
-export declare function formatReviewApproval(body: string): string;
+export type ModelFallbackRecoveryReason = 'credential' | 'not-found';
 /** Format the stop guard's dynamic structured-output mandate. */
 export declare function formatStructuredOutputReprompt(schema: string): string;
-export type ModelFallbackRecoveryReason = 'credential' | 'not-found';
-/** Mark a model-route fallback re-drive while retaining its full guidance. */
+/** Keep model-fallback guidance editable without making it a reader contract. */
 export declare function formatModelFallbackRecovery(previousModel: string, nextModel: string, reason: ModelFallbackRecoveryReason): string;
 export interface GeneratedContextMessageLike {
     role?: string;
     customType?: string;
     content?: unknown;
 }
-export interface GeneratedContextPresentation {
-    kind: 'bearings' | 'situational' | 'revive' | 'context-nudge' | 'inbox' | 'review-approval' | 'persona-transition' | 'stop-guard' | 'recovery';
+export type CardEntryDisposition = 'report' | 'human-answer' | 'human-canceled';
+export interface CardEntry {
+    disposition: CardEntryDisposition;
+    kind: string;
+    body: string;
+    ref?: string;
+}
+export interface CardSender {
+    id: string;
+    name?: string;
+    updates: number;
+    finished: boolean;
+    entries: CardEntry[];
+}
+/** An already-resolved inbox entry supplied to the pure digest formatter. */
+export interface InboxCardEntry {
+    kind: string;
+    body: string;
+    ref?: string;
+    disposition?: CardEntryDisposition;
+}
+/** An already-resolved sender section supplied to the pure digest formatter. */
+export interface InboxCardSection {
+    id: string;
+    name?: string;
+    entries: readonly InboxCardEntry[];
+    updates?: number;
+    finished?: boolean;
+}
+export interface GeneratedCard {
+    kind: string;
+    facts: Readonly<Record<string, string>>;
+    body: string;
+    senders: CardSender[];
     label: string;
     summary: string;
-    /** The unmodified, model-visible message content. */
-    body: string;
+    expandable: boolean;
+}
+type CardSummary = (facts: Readonly<Record<string, string>>) => string;
+export interface CardKindDefinition {
+    label: string;
+    summary: CardSummary;
+    expandable: boolean;
+    customTypes?: Readonly<Record<string, Partial<Pick<CardKindDefinition, 'label' | 'summary' | 'expandable'>>>>;
 }
-export declare function generatedContextExpandedBody(presentation: GeneratedContextPresentation): string;
+/** The closed crouter vocabulary, plus custom-role aliases for the same cards. */
+export declare const KIND_TABLE: Readonly<Record<string, CardKindDefinition>>;
 /** Plain text from a generated message's string or text-block content. */
 export declare function generatedContextText(message: GeneratedContextMessageLike): string;
-/** Format the runtime's visible context-size guidance. */
-export declare function formatContextNudge(note: string): string;
-export declare function isInboxDigest(text: string): boolean;
-export declare function extractInboxSender(text: string): string | null;
-/** Node ids whose section of this digest reports a finished node. Sections are
- *  delimited by their `From <sender>` headers, so a final never attaches to the
- *  neighbouring sender. */
-export declare function inboxFinishedSenders(text: string): string[];
-/** Exact producer-owned marker for the continuation a successor broker inserts
- * after a runtime restart. Other recovery bodies intentionally do not match. */
-export declare function isRuntimeRestartContinuation(message: GeneratedContextMessageLike): boolean;
-/**
- * Classify a crouter-generated context message for display. The checks are
- * exact producer-owned contracts: custom messages use their customType, and
- * user messages use stable sentinels or the same exact formatter/constants as
- * their producers. Ordinary user prompts remain ordinary user prompts.
- */
-export declare function generatedContextPresentation(message: GeneratedContextMessageLike): GeneratedContextPresentation | null;
+/** Wrap a user-role runtime message in its whole-message card envelope. */
+export declare function formatCard(kind: string, facts: Record<string, string | number | boolean | undefined>, body: string): string;
+/** Parse a runtime envelope, with pre-envelope customType compatibility. */
+export declare function parseCard(message: GeneratedContextMessageLike): GeneratedCard | null;
+/** Format a complete inbox card from report bodies resolved by the caller. */
+export declare function formatInboxCard(sections: readonly InboxCardSection[]): string;
+export declare function isLegacyRuntimeText(text: string): boolean;
+export {};