@north-light/crouter 0.3.206 → 0.3.208

package/dist/core/__tests__/canvas-inbox-watcher.test.js

@@ -106,7 +106,7 @@ test('coalesce renders one inbox card whose entries inline short report bodies a
     const card = parseCard({ role: 'user', content: digest });
     assert.notEqual(card, null);
     assert.equal(card.kind, 'inbox');
-    assert.deepEqual({ ...card.facts }, { senders: '1', updates: '1' });
+    assert.deepEqual({ ...card.facts }, {});
     assert.equal(card.senders.length, 1);
     assert.equal(card.senders[0].id, 'child');
     // The label is NOT reprinted above the body it duplicates.

package/dist/core/__tests__/helpers/broker-clients.d.ts

@@ -25,7 +25,9 @@ export interface RawClient {
 }
 export interface AttachKit {
     /** Connect a BrokerClient to a node's running broker, hello, await welcome. */
-    attach(id: string, role: ClientRole, clientId: string): Promise<Attached>;
+    attach(id: string, role: ClientRole, clientId: string, opts?: {
+        snapshotTail?: number;
+    }): Promise<Attached>;
     /** Attach (as `role`) and retry until the welcome satisfies `pred`. */
     attachUntil(id: string, role: ClientRole, clientId: string, pred: (a: Attached) => boolean, label: string): Promise<Attached>;
     /** A raw node:net peer. read:false leaves the socket PAUSED (G8 stalled viewer). */

package/dist/core/__tests__/helpers/broker-clients.js

@@ -37,7 +37,7 @@ export function createAttachKit(getH) {
     // awaitBoot returns once the boot proof is written — which is BEFORE the broker's
     // server.listen() binds view.sock — so a fresh attach can momentarily race the
     // bind; retry the connect on BrokerUnavailable until it is listening.
-    async function attach(id, role, clientId) {
+    async function attach(id, role, clientId, opts = {}) {
         const h = getH();
         await h.waitFor(() => existsSync(h.brokerSock(id)), { label: `view.sock for ${id}`, timeoutMs: 20_000 });
         const frames = [];
@@ -65,7 +65,12 @@ export function createAttachKit(getH) {
         // round-trip — so a welcome timeout cannot leak a connected socket past the test.
         liveClients.push({ close: () => client.close() });
         const waitFrame = (pred, label, timeoutMs = 15_000) => h.waitFor(() => frames.find(pred) ?? null, { label, timeoutMs });
-        client.send({ type: 'hello', role, client_id: clientId });
+        client.send({
+            type: 'hello',
+            role,
+            client_id: clientId,
+            ...(opts.snapshotTail === undefined ? {} : { snapshot_tail: opts.snapshotTail }),
+        });
         let welcome;
         try {
             welcome = (await waitFrame((f) => f.type === 'welcome', `welcome for ${clientId}`));

package/dist/core/__tests__/seam/broker-attach-multiclient.test.js

@@ -253,3 +253,12 @@ test('G10 — retained extension display state rides IN welcome.snapshot.display
     assert.equal(live.method, 'setStatus');
     assert.equal(live.statusText, 'painted while attached');
 });
+test('snapshot_tail is ignored when the session has no stable message ids', async () => {
+    const token = tok('snapshot-tail-no-ids');
+    h.fakeCmd(id, { cmd: 'stream', text: token });
+    const full = await attachUntil(id, 'observer', 'snapshot-tail-full', (a) => JSON.stringify(a.welcome.snapshot.messages).includes(token), 'full snapshot after a tail-less attach');
+    assert.equal(full.welcome.snapshot.messageIds, undefined, 'the fake session has no stable ids');
+    const tailed = await attach(id, 'observer', 'snapshot-tail-request', { snapshotTail: 1 });
+    assert.equal(tailed.welcome.snapshot.messageIds, undefined, 'the tail request cannot invent stable ids');
+    assert.deepEqual(tailed.welcome.snapshot.messages, full.welcome.snapshot.messages, 'a welcome without stable ids keeps the full history instead of stranding an unpageable tail');
+});

package/dist/core/__tests__/serial/broker-snapshot-history.test.js

@@ -34,7 +34,7 @@ import { CANVAS_EXTENSIONS } from '../../runtime/launch.js';
 import { buildBrokerSession, snapshotMessages } from '../../runtime/broker.js';
 import { createNode } from '../../canvas/canvas.js';
 import { closeDb } from '../../canvas/db.js';
-import { transcriptMarkdown } from '../../runtime/node-read.js';
+import { readNodeMessagesPage, transcriptMarkdown } from '../../runtime/node-read.js';
 // M-9 (broker.ts fault-and-die model gate): a boot with no cfg.model now calls
 // the REAL SDK's modelRegistry.getAvailable() and faults if it's empty, which it
 // always is on a host/CI runner with no authenticated provider. This test only
@@ -128,6 +128,57 @@ test('broker welcome snapshot serves the persisted history, not pi\u2019s sliced
         rmSync(cwd, { recursive: true, force: true });
     }
 });
+test('readNodeMessagesPage keeps a tool call with all following tool results across cursor pages', async () => {
+    const home = mkdtempSync(join(tmpdir(), 'crtr-page-tools-home-'));
+    const sessionCwd = mkdtempSync(join(tmpdir(), 'crtr-page-tools-session-'));
+    const prevHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+    closeDb();
+    try {
+        const seed = SessionManager.create(sessionCwd);
+        seed.appendMessage(userMsg('before the tool run'));
+        seed.appendMessage({
+            ...assistantMsg('calling tools'),
+            content: [
+                { type: 'toolCall', id: 'tool-1', name: 'read', arguments: { path: 'one.txt' } },
+                { type: 'toolCall', id: 'tool-2', name: 'read', arguments: { path: 'two.txt' } },
+            ],
+        });
+        seed.appendMessage({ role: 'toolResult', toolCallId: 'tool-1', toolName: 'read', content: [{ type: 'text', text: 'one' }], isError: false, timestamp: Date.now() });
+        seed.appendMessage({ role: 'toolResult', toolCallId: 'tool-2', toolName: 'read', content: [{ type: 'text', text: 'two' }], isError: false, timestamp: Date.now() });
+        seed.appendMessage(userMsg('after the tool run'));
+        seed.appendMessage(assistantMsg('finished'));
+        const sessionFile = seed.getSessionFile();
+        const nodeId = 'tool-page-boundary';
+        createNode({
+            node_id: nodeId,
+            name: nodeId,
+            created: new Date().toISOString(),
+            cwd: sessionCwd,
+            kind: 'general',
+            mode: 'base',
+            lifecycle: 'terminal',
+            status: 'active',
+            pi_session_file: sessionFile,
+        });
+        const newest = await readNodeMessagesPage(nodeId, { limit: 3 });
+        assert.equal(newest.messages[0].role, 'assistant', 'the page walks back from the tool-result cut to its call');
+        assert.deepEqual(newest.messages.slice(1, 3).map((message) => message.role), ['toolResult', 'toolResult'], 'all tool results share the page with their call');
+        assert.ok(newest.nextCursor, 'the widened page still has an older cursor');
+        const older = await readNodeMessagesPage(nodeId, { cursor: newest.nextCursor, limit: 3 });
+        const persisted = SessionManager.open(sessionFile).buildSessionContext().messages;
+        assert.deepEqual([...older.messages, ...newest.messages], persisted, 'cursor pages remain gap-free and non-overlapping after widening');
+        assert.deepEqual([...(older.messageIds ?? []), ...(newest.messageIds ?? [])], SessionManager.open(sessionFile).getEntries().map(({ id }) => id), 'stable ids remain aligned across the widened page boundary');
+    }
+    finally {
+        closeDb();
+        process.env['CRTR_HOME'] = prevHome;
+        if (prevHome === undefined)
+            delete process.env['CRTR_HOME'];
+        rmSync(home, { recursive: true, force: true });
+        rmSync(sessionCwd, { recursive: true, force: true });
+    }
+});
 // C3 (inline memory references, Wave 1A): transcriptMarkdown is the human-
 // facing render of a dormant node's persisted session. It must generically
 // skip any custom message whose `display === false` (the same hidden-guidance

package/dist/core/__tests__/serial/flagship-lifecycle.test.js

@@ -229,7 +229,7 @@ test('flagship: full node lifecycle — spawn, dormancy, one-hop wake, promote,
             const stop = evaluateStop(B, { pushedFinal: false, requestedHumanReply: false });
             assert.equal(stop.action, 'reprompt', 'orchestrator B with no live sub, no final → reprompt');
             assert.equal(stop.reason, 'stalled', 'classified stalled');
-            assert.equal(stop.action === 'reprompt' ? stop.message : '', formatCard('stop-guard', { reason: 'stalled' }, STALL_REPROMPT), 'the stall reprompt nudge, delivered as a whole-message stop-guard envelope');
+            assert.equal(stop.action === 'reprompt' ? stop.message : '', formatCard('stop-guard', {}, STALL_REPROMPT), 'the stall reprompt nudge, delivered as a whole-message stop-guard envelope');
         }
         // ===================================================================
         // S10 — B YIELDS. The real plain `node yield` verb sets intent=refresh

package/dist/core/canvas/paths.d.ts

@@ -59,8 +59,8 @@ export declare function reportsDir(nodeId: string): string;
 export declare function messagesDir(nodeId: string): string;
 export declare function nodeMetaPath(nodeId: string): string;
 export declare function inboxPath(nodeId: string): string;
-/** The node-owned ambient "current situation" sidecar — the latest hidden
- *  `<situational-context>` text injected into bearings/kickoff (see
+/** The node-owned ambient "current situation" sidecar — ONE rendered runtime
+ *  card, restated by the session-start bearings (see
  *  `runtime/situational-context.ts`), upserted in place rather than appended so
  *  only the newest applet/situation state is ever carried. Lives beside
  *  meta.json/inbox.jsonl (node-runtime state) rather than under context/ (the

package/dist/core/canvas/paths.js

@@ -137,8 +137,8 @@ export function nodeMetaPath(nodeId) {
 export function inboxPath(nodeId) {
     return join(nodeDir(nodeId), 'inbox.jsonl');
 }
-/** The node-owned ambient "current situation" sidecar — the latest hidden
- *  `<situational-context>` text injected into bearings/kickoff (see
+/** The node-owned ambient "current situation" sidecar — ONE rendered runtime
+ *  card, restated by the session-start bearings (see
  *  `runtime/situational-context.ts`), upserted in place rather than appended so
  *  only the newest applet/situation state is ever carried. Lives beside
  *  meta.json/inbox.jsonl (node-runtime state) rather than under context/ (the

package/dist/core/runtime/broker/fault-retry.js

@@ -208,12 +208,7 @@ export class FaultRetry {
                 return;
             if (unconfigured)
                 clearFault(this.deps.nodeId, { link: 'pi→provider' });
-            await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {
-                reason: 'model-fallback',
-                from: currentSpec,
-                to: resolved,
-                cause: unconfigured ? 'credential' : 'not-found',
-            }, formatModelFallbackRecovery(currentSpec, resolved, unconfigured ? 'credential' : 'not-found'))));
+            await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {}, formatModelFallbackRecovery(currentSpec, resolved, unconfigured ? 'credential' : 'not-found'))));
         })().catch((err) => {
             emitEvent({ level: 'debug', event: 'broker.runtime.diagnostic', fields: { message: `${unconfigured ? 'unconfigured-provider' : 'not_found'} fallback failed: ${err instanceof Error ? err.message : String(err)}` } });
         }).finally(() => {
@@ -300,6 +295,6 @@ export class FaultRetry {
         if (this.deps.installedGeneration() !== generation || this.deps.currentSession() !== candidateSession)
             return;
         recordFault(this.deps.nodeId, plan.fault);
-        await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', { reason: fault.kind === 'connection' ? 'connection' : 'provider' }, fault.kind === 'connection' ? CONNECTION_FAULT_RECOVERY_BODY : PROVIDER_FAULT_RECOVERY_BODY)));
+        await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {}, fault.kind === 'connection' ? CONNECTION_FAULT_RECOVERY_BODY : PROVIDER_FAULT_RECOVERY_BODY)));
     }
 }

package/dist/core/runtime/broker/frame-dispatch.js

@@ -1442,7 +1442,7 @@ export function createFrameDispatchContext(deps) {
                             fresh.since !== authFault.since)
                             return;
                         clearFault(nodeId, { link: 'pi→provider' });
-                        await authFaultSession.prompt(formatCard('recovery', { reason: 'auth' }, AUTH_FAULT_RECOVERY_BODY));
+                        await authFaultSession.prompt(formatCard('recovery', {}, AUTH_FAULT_RECOVERY_BODY));
                     }
                     catch (err) {
                         emitEvent({

package/dist/core/runtime/broker/tool-groups.js

@@ -4,7 +4,7 @@ import { jobDir } from '../../canvas/paths.js';
 import { readConfig } from '../../config.js';
 import { emitEvent } from '../../events/emit.js';
 import { atomicWriteJson, readJsonIfExists } from '../../fs-utils.js';
-import { assistantVisibleText, isTrueUserMessage, normalizeToolGroupSummaryRecord, } from '../../../shared/tool-groups.js';
+import { assistantVisibleText, isGroupBoundaryKind, isTrueUserMessage, normalizeToolGroupSummaryRecord, } from '../../../shared/tool-groups.js';
 import { generatedContextText, parseCard } from '../../../shared/generated-context.js';
 import { headlessToolGroupSummary, serializeToolGroup } from '../tool-group-summary.js';
 const PENDING_TOOL_SUMMARY_KEY_MAX_CHARS = 1_000;
@@ -140,11 +140,12 @@ export class ToolGroupTracker {
         if (item.display === false)
             return;
         const text = generatedContextText(item);
-        const kind = parseCard(item)?.kind;
-        const isBearingsOrRevive = kind === 'bearings' || kind === 'revive';
-        if (isBearingsOrRevive) {
-            if (this.openToolGroup !== undefined && text !== '')
-                this.openToolGroup.pieces.push({ type: 'text', text });
+        const card = parseCard(item);
+        // A boundary card ends the preceding run and becomes the next group's
+        // context, exactly as a person's message does; the viewer reads the same
+        // set, so both sides fold at the same seams.
+        if (card !== null && isGroupBoundaryKind(card.kind)) {
+            this.visibleBoundary(text);
             return;
         }
         const group = this.ensureOpenToolGroup();

package/dist/core/runtime/broker.js

@@ -359,13 +359,13 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
         const liveSession = rebind.session();
         const identified = snapshotMessages(liveSession, boundaryReviewId);
         const tail = normalizeSnapshotTail(client.snapshotTail);
+        // A tail is only usable with stable ids, which let its recipient page back
+        // to the omitted history.
         const retained = identified === undefined || tail === undefined ? identified : identified.slice(-tail);
         const messages = retained?.map(({ message }) => message)
-            ?? (tail === undefined
-                ? liveSession.sessionManager.buildSessionContext().messages
-                : liveSession.sessionManager.buildSessionContext().messages.slice(-tail));
+            ?? liveSession.sessionManager.buildSessionContext().messages;
         const fullToolGroupSummaries = toolGroups.summaries();
-        const retainedToolCallIds = tail === undefined ? undefined : toolCallIds(messages);
+        const retainedToolCallIds = retained !== undefined && tail !== undefined ? toolCallIds(messages) : undefined;
         const toolGroupSummaries = retainedToolCallIds === undefined
             ? fullToolGroupSummaries
             : Object.fromEntries(Object.entries(fullToolGroupSummaries).filter(([id]) => retainedToolCallIds.has(id)));

package/dist/core/runtime/kickoff.js

@@ -318,14 +318,8 @@ export function buildReviveKickoff(meta, bearings, wakeReason) {
     if (bearings.driftGuidance !== null) {
         parts.push(`<persona-transition>\nYour role was changed while you were away. ${bearings.driftGuidance}\n</persona-transition>`);
     }
-    // The whole kickoff is one runtime card. Its facts are what this producer
-    // knows about the revive, and they are the ONLY thing a reader may classify or
-    // summarize on — the prose above stays free to be reworded. The envelope is
-    // also what keeps a fresh revive out of canvas-goal-capture's first-real-input
-    // path, which would otherwise overwrite a bare root's mandate and rename it.
-    return formatCard('revive', {
-        mode: meta.mode,
-        ...(meta.cycle_pending === true ? { cycle: true } : {}),
-        ...(wakeReason === undefined ? {} : { wake: wakeReason.kind }),
-    }, `\n${parts.join('\n\n')}\n`);
+    // The envelope keeps a fresh revive out of canvas-goal-capture's
+    // first-real-input path, which would otherwise overwrite a bare root's
+    // mandate and rename it.
+    return formatCard('revive', {}, `\n${parts.join('\n\n')}\n`);
 }

package/dist/core/runtime/node-read.js

@@ -263,7 +263,13 @@ export async function readNodeMessagesPage(nodeId, { cursor, limit = 200 }) {
     }
     const { messages, identified } = await reconstructVisibleMessages(nodeId);
     const before = cursor === undefined ? messages.length : decodeMessagesCursor(cursor, messages.length);
-    const start = Math.max(0, before - limit);
+    let start = Math.max(0, before - limit);
+    while (start > 0
+        && typeof messages[start] === 'object'
+        && messages[start] !== null
+        && messages[start].role === 'toolResult') {
+        start--;
+    }
     const page = identified?.slice(start, before);
     return {
         messages: page?.map(({ message }) => message) ?? messages.slice(start, before),

package/dist/core/runtime/situational-context.d.ts

@@ -12,8 +12,6 @@ export declare function formatSituationalProse(prose: string): string;
  *  No-op for blank text, so a caller can pass through an optional/empty value
  *  with no guard at the call site. */
 export declare function appendSituationalContext(nodeId: string, text: string): void;
-/** Read the current situational context, or null if none was ever set. */
-export declare function readSituationalContext(nodeId: string): string | null;
 /** The node's stored situational card, verbatim, or null when none is set.
  *  The ONE read of the sidecar. A sidecar written before the card cut holds
  *  bare prose; that single legacy branch lives here alone and self-clears on

package/dist/core/runtime/situational-context.js

@@ -46,8 +46,9 @@ export function appendSituationalContext(nodeId, text) {
     mkdirSync(nodeDir(nodeId), { recursive: true });
     writeFileSync(situationalContextPath(nodeId), body + '\n', 'utf8');
 }
-/** Read the current situational context, or null if none was ever set. */
-export function readSituationalContext(nodeId) {
+/** Read the stored text, or null if none was ever set. Module-private:
+ *  `situationalContextEnvelope` is the one read, and it shape-checks. */
+function readSituationalContext(nodeId) {
     const p = situationalContextPath(nodeId);
     if (!existsSync(p))
         return null;

package/dist/core/runtime/situational-live.js

@@ -32,7 +32,7 @@ export async function setSituationalContextLive(nodeId, text) {
         throw new Error(`setSituationalContextLive: unknown node ${nodeId}`);
     const envelope = situationalContextEnvelope(nodeId);
     if (envelope === null)
-        return; // blank text — appendSituationalContext no-ops, nothing to deliver
+        return; // no sidecar at all — blank text on a node that never had one
     await deliverCustomMessageLive(nodeId, {
         customType: SITUATIONAL_CONTEXT_CUSTOM_TYPE,
         content: envelope,

package/dist/core/runtime/spawn.d.ts

@@ -67,10 +67,10 @@ export interface SpawnChildOpts {
     /** Preallocated node id, used when a managed worktree must be named before birth. */
     nodeId?: string;
     /** Hidden ambient "current situation" text — NOT the visible prompt/body.
-     *  Persisted via `appendSituationalContext` BEFORE launch so canvas-context-
-     *  intro's session_start bearings carry it as a `<situational-context>`
-     *  sibling from the node's very first turn. Passed through unchanged into a
-     *  scheduled node-birth command. Omit for no ambient context. */
+     *  Stored as a `situational` card BEFORE launch so canvas-context-intro's
+     *  session_start bearings nest it from the node's very first turn. Passed
+     *  through unchanged into a scheduled node-birth command. Omit for no
+     *  ambient context. */
     situationalContext?: string;
 }
 /** Resolve a `--fork-from` value to an ABSOLUTE `.jsonl` source path for the

package/dist/core/runtime/stop-guard.js

@@ -28,11 +28,11 @@ import { readOutputRequest } from './structured-output.js';
 export { STALL_REPROMPT } from '../../shared/generated-context.js';
 /** Format the stop guard's reprompt for a valid structured-output request. */
 function formatValidStructuredOutputReprompt(schema) {
-    return formatCard('stop-guard', { reason: 'structured-output' }, formatStructuredOutputReprompt(JSON.stringify(schema, null, 2)));
+    return formatCard('stop-guard', {}, formatStructuredOutputReprompt(JSON.stringify(schema, null, 2)));
 }
 /** Format the stop guard's reprompt for an invalid structured-output request file. */
 function formatInvalidStructuredOutputReprompt(error) {
-    return formatCard('stop-guard', { reason: 'structured-output' }, `Structured-output request file is invalid and cannot be used: ${error}\n\n` +
+    return formatCard('stop-guard', {}, `Structured-output request file is invalid and cannot be used: ${error}\n\n` +
         `You have two options:\n` +
         `1. Remove the invalid file (the output-schema.json in your node directory has been corrupted)\n` +
         `2. Fix the corruption if you know the original request schema\n\n` +
@@ -99,6 +99,6 @@ export function evaluateStop(nodeId, signals, backgroundJobsRunning = activeBack
     return {
         action: 'reprompt',
         reason: 'stalled',
-        message: formatCard('stop-guard', { reason: 'stalled' }, STALL_REPROMPT),
+        message: formatCard('stop-guard', {}, STALL_REPROMPT),
     };
 }

package/dist/daemon/messaging/node-message.d.ts

@@ -5,7 +5,10 @@ export interface NodeMessageDelivery {
     revived: boolean;
 }
 export interface RuntimeMessageCard {
-    kind: string;
+    /** A bare core kind only. This renders with `formatCard`, which leaves the
+     *  body raw — a namespaced kind's body is decoded on read (D12) and would be
+     *  corrupted. Extend the union rather than widening to `string`. */
+    kind: 'review-comment' | 'review-queued' | 'review-approval';
     facts: Record<string, string | number | boolean | undefined>;
 }
 /**

package/dist/daemon/review/comment-notify.js

@@ -70,14 +70,7 @@ export async function notifyComment(args) {
                 comment_id: args.comment.comment_id,
                 verb: args.verb,
             },
-            runtime: {
-                kind: 'review-comment',
-                facts: {
-                    review_id: args.review.review_id,
-                    comment_id: args.comment.comment_id,
-                    verb: args.verb,
-                },
-            },
+            runtime: { kind: 'review-comment', facts: {} },
         });
     }
     catch (error) {

package/dist/daemon/review/deliver.js

@@ -9,7 +9,7 @@ function approvalBody(review, resultPath) {
 }
 /** Render the immutable approval fact without replaying comment text. */
 export function renderApprovalMessage(review, resultPath) {
-    return formatCard('review-approval', { review: review.review_id, file: review.file }, approvalBody(review, resultPath));
+    return formatCard('review-approval', {}, approvalBody(review, resultPath));
 }
 function recordedFailedFanout(review, reportBasename) {
     const error = review.delivery_error;

package/dist/daemon/review/finish.js

@@ -164,7 +164,7 @@ async function noteSubmitQueued(review) {
             mode: 'quiet',
             label: 'human review submitted — result to follow',
             data: { review_id: review.review_id },
-            runtime: { kind: 'review-queued', facts: { review_id: review.review_id } },
+            runtime: { kind: 'review-queued', facts: {} },
             body: `The human submitted their review of \`${review.file}\`; the document is still being edited. `
                 + "You'll be notified with the result once the review completes. Nothing is needed from you now.",
         });

package/dist/pi-extensions/__tests__/canvas-stophook-agentend.test.js

@@ -409,7 +409,7 @@ test('stalled leaf (nothing live to await, no final) is still reprompted', async
     let shutdown = false;
     await settle(pi, stopEvent('I think I am basically done here'), { shutdown: () => { shutdown = true; } });
     assert.equal(pi.injected.length, 1, 'the stall reprompt fired');
-    assert.equal(pi.injected[0].content, `<runtime kind="stop-guard" reason="stalled">${STALL_REPROMPT}</runtime>`, 'reprompt carries the stall nudge to push final / ask');
+    assert.equal(pi.injected[0].content, `<runtime kind="stop-guard">${STALL_REPROMPT}</runtime>`, 'reprompt carries the stall nudge to push final / ask');
     assert.equal(pi.injected[0].deliverAs, 'followUp', 'reprompt delivered as a followUp');
     assert.equal(shutdown, false, 'a stalled leaf is NOT shut down — it is re-prompted to finish');
     assert.notEqual(getNode('leaf')?.intent, 'idle-release', 'a stalled leaf does not idle-release');

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

@@ -705,8 +705,10 @@ class CanvasInboxWatcher {
             });
         }, stage);
     }
-    /** The visible delivery and its own entry's one-shot cards in ONE send, so a
-     *  failed body never leaves its cards delivered and requeued for a resend. */
+    /** The visible delivery and its own entry's one-shot cards share ONE failure
+     *  unit: a throw anywhere requeues the whole entry, so a retry may repeat a
+     *  card already handed off (context is restatable; the human's body is not,
+     *  and it is sent last). */
     sendVisible(entries, cards, content, route, stage) {
         return this.sendDelivery('visible', entries, () => {
             if (route !== 'idle' && route !== 'steer' && route !== 'followUp') {

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

@@ -82,7 +82,7 @@ export function registerCanvasReviewBoundary(pi) {
             ].join('\n');
         pi.sendMessage({
             customType: REVIEW_BOUNDARY_CUSTOM_TYPE,
-            content: formatCard('review-boundary', { review: reviewId, file: targetFile }, content),
+            content: formatCard('review-boundary', {}, content),
             display: true,
             details: { reviewId, originNodeId, targetFile, kind: binding.kind ?? 'review' },
         });

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

@@ -1,14 +1,18 @@
 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' });
-    }
+import { formatCard, formatDataCard, formatInboxCard, parseCard } from '../generated-context.js';
+test('runtime cards preserve kind, facts, and their body encoding', () => {
+    const facts = { source: 'grammar', enabled: true, count: 2 };
+    const bare = parseCard({ role: 'user', content: formatCard('revive', facts, '<model-visible/>') });
+    assert.ok(bare);
+    assert.equal(bare.kind, 'revive');
+    assert.equal(bare.body, '<model-visible/>');
+    assert.deepEqual(bare.facts, { source: 'grammar', enabled: 'true', count: '2' });
+    const namespaced = parseCard({ role: 'user', content: formatDataCard('northlight:surface', facts, '<data body>') });
+    assert.ok(namespaced);
+    assert.equal(namespaced.kind, 'northlight:surface');
+    assert.equal(namespaced.body, '<data body>');
+    assert.deepEqual(namespaced.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';
@@ -58,21 +62,14 @@ test('an envelope wins over customType, with a custom-role fallback for old sess
     assert.ok(preEnvelope);
     assert.equal(preEnvelope.kind, 'bearings');
 });
-test('interactive review notices classify from their typed facts', () => {
-    const comment = parseCard({
+test('parsed cards expose only the shared semantic grammar', () => {
+    const card = parseCard({
         role: 'user',
-        content: formatCard('review-comment', { review_id: 'review-1', comment_id: 'comment-1', verb: 'create' }, 'Review comment created.'),
+        content: formatCard('review-comment', { review_id: 'review-1', comment_id: 'comment-1' }, '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');
+    assert.ok(card);
+    assert.deepEqual(card.facts, { review_id: 'review-1', comment_id: 'comment-1' });
+    assert.deepEqual(Object.keys(card).sort(), ['body', 'facts', 'kind', 'senders']);
 });
 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.';

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

@@ -58,24 +58,7 @@ export interface GeneratedCard {
     facts: Readonly<Record<string, string>>;
     body: string;
     senders: CardSender[];
-    label: string;
-    summary: 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'>>>>;
-}
-/** The closed crouter vocabulary, plus custom-role aliases for the same cards. */
-export declare const KIND_TABLE: Readonly<Record<string, CardKindDefinition>>;
-/** Contribute presentation for namespaced kinds this process will render.
- *  Idempotent and last-write-wins, so a re-imported module cannot fail a boot.
- *  A process that never registers is not degraded: an unregistered kind still
- *  parses and only falls back to the generic label and summary. */
-export declare function registerCardKinds(kinds: Readonly<Record<string, CardKindDefinition>>): void;
 /** Plain text from a generated message's string or text-block content. */
 export declare function generatedContextText(message: GeneratedContextMessageLike): string;
 /** Wrap a user-role runtime message in its whole-message card envelope. */
@@ -91,4 +74,3 @@ export declare function parseCard(message: GeneratedContextMessageLike): Generat
 /** 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 {};