@north-light/crouter 0.3.207 → 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/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/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/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-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 {};

package/dist/shared/generated-context.js

@@ -35,98 +35,13 @@ export function formatModelFallbackRecovery(previousModel, nextModel, reason) {
         ? `The previous model (${previousModel}) had no usable provider credential, so you were automatically switched to ${nextModel}. Continue the task from where the failed turn left off.`
         : `The previous model (${previousModel}) was unavailable (provider 404 not_found), so you were automatically switched to ${nextModel}. Continue the task from where the failed turn left off.`;
 }
-function countFact(facts, key) {
-    const value = facts[key];
-    if (value === undefined || !/^(?:0|[1-9]\d*)$/.test(value))
-        return null;
-    return Number(value);
-}
-function inboxSummary(facts) {
-    const updates = countFact(facts, 'updates');
-    const senders = countFact(facts, 'senders');
-    if (updates === null)
-        return 'inbox update';
-    if (senders === null || senders <= 1)
-        return `${updates === 1 ? 'message' : `${updates} messages`} received`;
-    return `${updates} messages received from ${senders} nodes`;
-}
-function recoverySummaryFromFacts(facts) {
-    switch (facts.reason) {
-        case 'model-fallback': return 'model route changed';
-        case 'connection': return 'network connection restored';
-        case 'provider': return 'provider retry';
-        case 'auth': return 'provider credentials updated';
-        default: return 'runtime recovery';
-    }
-}
-function reviewCommentSummary(facts) {
-    switch (facts.verb) {
-        case 'create': return 'review comment created';
-        case 'edit': return 'review comment edited';
-        case 'resolve': return 'review comment resolved';
-        case 'reopen': return 'review comment reopened';
-        case 'delete': return 'review comment deleted';
-        default: return 'review comment updated';
-    }
-}
-/** The closed crouter vocabulary, plus custom-role aliases for the same cards. */
-export const KIND_TABLE = {
-    inbox: { label: 'crtr inbox', summary: inboxSummary, expandable: true },
-    revive: { label: 'crtr revive', summary: () => 'fresh context kickoff', expandable: true },
-    'restart-continuation': { label: 'crouter continuation', summary: () => 'continuing from where it left off', expandable: true },
-    'stop-guard': {
-        label: 'crtr stop guard',
-        summary: (facts) => facts.reason === 'structured-output' ? 'structured output required' : 'completion required',
-        expandable: true,
-    },
-    recovery: { label: 'crouter continuation', summary: recoverySummaryFromFacts, expandable: true },
-    'persona-transition': { label: 'crtr persona', summary: () => 'runtime role update', expandable: true },
-    'review-approval': { label: 'crtr review', summary: () => 'review approved by the user', expandable: true },
-    'review-comment': { label: 'crtr review', summary: reviewCommentSummary, expandable: true },
-    'review-queued': { label: 'crtr review', summary: () => 'review submitted; completion pending', expandable: true },
-    'context-nudge': {
-        label: 'crtr',
-        summary: (facts) => facts.size === undefined ? 'context-window guidance' : `Context ${facts.size}`,
-        expandable: true,
-        customTypes: { [CONTEXT_NUDGE_CUSTOM_TYPE]: {} },
-    },
-    bearings: {
-        label: 'crtr context',
-        summary: () => 'orienting bearings',
-        expandable: true,
-        customTypes: { [CONTEXT_INTRO_CUSTOM_TYPE]: {} },
-    },
-    'review-boundary': {
-        label: 'review boundary',
-        summary: () => 'earlier conversation is not shown',
-        expandable: true,
-        customTypes: { [REVIEW_BOUNDARY_CUSTOM_TYPE]: {} },
-    },
-    situational: {
-        label: 'situational context',
-        summary: () => 'ambient context update',
-        expandable: true,
-        customTypes: { [SITUATIONAL_CONTEXT_CUSTOM_TYPE]: {} },
-    },
-};
-const GENERIC_CARD = {
-    label: 'crtr runtime',
-    summary: () => 'runtime context',
-    expandable: true,
-};
-/** Kinds contributed by a product or plugin, in whatever process renders them. */
-const KIND_REGISTRY = {};
-/** 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 function registerCardKinds(kinds) {
-    for (const [kind, definition] of Object.entries(kinds)) {
-        // Bare kinds are crouter core's closed vocabulary. A product claiming one
-        // is a programming error at boot, not a runtime condition to tolerate.
-        if (!kind.includes(':'))
-            throw new Error(`Runtime card kind must be namespaced (contain ':'): ${kind}`);
-        KIND_REGISTRY[kind] = definition;
+function legacyCustomTypeKind(customType) {
+    switch (customType) {
+        case CONTEXT_NUDGE_CUSTOM_TYPE: return 'context-nudge';
+        case CONTEXT_INTRO_CUSTOM_TYPE: return 'bearings';
+        case REVIEW_BOUNDARY_CUSTOM_TYPE: return 'review-boundary';
+        case SITUATIONAL_CONTEXT_CUSTOM_TYPE: return 'situational';
+        default: return undefined;
     }
 }
 const XML_ATTRIBUTE_NAME = /^[A-Za-z_:][A-Za-z0-9_:.-]*$/;
@@ -248,16 +163,7 @@ function parseInboxBody(body) {
     return senders;
 }
 function cardFor(kind, facts, body, senders) {
-    const definition = KIND_TABLE[kind] ?? KIND_REGISTRY[kind] ?? GENERIC_CARD;
-    return {
-        kind,
-        facts,
-        body,
-        senders,
-        label: definition.label,
-        summary: definition.summary(facts),
-        expandable: definition.expandable,
-    };
+    return { kind, facts, body, senders };
 }
 /** Parse a whole-message runtime envelope, regardless of delivery role. */
 function parseEnvelope(text) {
@@ -286,22 +192,13 @@ export function parseCard(message) {
         return null;
     // Pre-envelope custom-message fallback for old sessions. New custom messages
     // classify through their envelope; customType is delivery metadata only.
-    for (const [kind, definition] of Object.entries(KIND_TABLE)) {
-        const override = message.customType === undefined ? undefined : definition.customTypes?.[message.customType];
-        if (override === undefined)
-            continue;
-        const facts = Object.freeze({});
-        return {
-            kind,
-            facts,
-            body: text,
-            senders: [],
-            label: override.label ?? definition.label,
-            summary: (override.summary ?? definition.summary)(facts),
-            expandable: override.expandable ?? definition.expandable,
-        };
-    }
-    return null;
+    const kind = legacyCustomTypeKind(message.customType);
+    return kind === undefined ? null : {
+        kind,
+        facts: Object.freeze({}),
+        body: text,
+        senders: [],
+    };
 }
 /** Format a complete inbox card from report bodies resolved by the caller. */
 export function formatInboxCard(sections) {
@@ -316,8 +213,7 @@ export function formatInboxCard(sections) {
         }).join('\n');
         return `<from${formatAttributes({ id: section.id, name: section.name, updates, finished: finished || undefined })}>${entries}</from>`;
     }).join('\n');
-    const updates = sections.reduce((total, section) => total + (section.updates ?? section.entries.length), 0);
-    return formatCard('inbox', { senders: sections.length, updates }, body);
+    return formatCard('inbox', {}, body);
 }
 // LEGACY — landed 2026-08-14. Pre-envelope runtime text, kept ONLY so old
 // scrollback is not attributed to the person. Delete this section and its

package/dist/shared/tool-groups.d.ts

@@ -11,6 +11,7 @@ export interface ToolGroupMessageLike {
     content?: unknown;
     customType?: string;
 }
+export declare function isGroupBoundaryKind(kind: string): boolean;
 /** Validate the one durable summary shape and cap its display-sized fields.
  * Invalid entries are absent rather than adapted, so their calls stay visible. */
 export declare function normalizeToolGroupSummary(value: unknown): ToolGroupSummary | null;

package/dist/shared/tool-groups.js

@@ -2,6 +2,13 @@
 // Keep this independent of renderer state: both live event tracking and snapshot
 // reconstruction must agree on which prose closes a run of tools.
 import { generatedContextText, isLegacyRuntimeText, parseCard } from './generated-context.js';
+/** Card kinds that close a run of tools instead of joining one. The broker
+ * segments and the viewer folds on the same seams, so this one answer is shared;
+ * everything else about a card is the display's own business. */
+const GROUP_BOUNDARY_KINDS = new Set(['restart-continuation', 'review-boundary']);
+export function isGroupBoundaryKind(kind) {
+    return GROUP_BOUNDARY_KINDS.has(kind);
+}
 const TOOL_GROUP_SUMMARY_KEYS = new Set(['bullets', 'filesDeleted']);
 const MAX_TOOL_GROUP_BULLETS = 5;
 const MAX_TOOL_GROUP_BULLET_LENGTH = 1_000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.207",
+  "version": "0.3.208",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",