@north-light/crouter 0.3.207 → 0.3.209

package/dist/migrations/registry.js

@@ -0,0 +1,19 @@
+// The ordered state-migration registry — ONE list for both lanes, so a cut
+// that spans canvas-db and document stores ships as adjacent entries.
+//
+// Authoring contract (each migration is one file, `NNN-<desc>.ts`, appended
+// here in order):
+//   • Idempotent. A convergent migration re-runs on every `crtr sys migrate`,
+//     so applying it to an already-migrated store must plan zero changes. A
+//     journaled migration runs once per database via user_version, but its
+//     body must still tolerate a crash-resume re-run of any filesystem work.
+//   • Journaled filesystem steps are crash-resumable: fs writes happen outside
+//     the db transaction, so a step interrupted mid-fs-work must complete
+//     (never corrupt) when the chain re-runs it.
+//   • Migration files import ONLY fs/frontmatter utilities (the fs-only
+//     memory resolver included) and these types — never canvas-db or canvas
+//     accessors. `DatabaseSync` arrives as a parameter; import it type-only.
+//     This keeps the registry legal in every CLI leaf's import graph (the
+//     build's V-1 gate).
+import { surfacesFrontmatterMigration } from './001-surfaces-frontmatter.js';
+export const STATE_MIGRATIONS = [surfacesFrontmatterMigration];

package/dist/migrations/types.d.ts

@@ -0,0 +1,40 @@
+import type { DatabaseSync } from 'node:sqlite';
+export interface JournaledMigration {
+    lane: 'journaled';
+    description: string;
+    /** Runs inside the canvas-db migration transaction. Filesystem work under
+     *  `canvasHome` is OUTSIDE that transaction — it must be crash-resumable
+     *  (a re-run after a partial application completes rather than corrupts). */
+    apply(db: DatabaseSync, canvasHome: string): void;
+}
+export interface ConvergentMigration {
+    lane: 'convergent';
+    description: string;
+    /** Pure planning: return the full new text of each doc to rewrite. The
+     *  runner filters no-op changes and performs the writes. */
+    apply(store: StoreSnapshot): DocChange[];
+}
+export type StateMigration = JournaledMigration | ConvergentMigration;
+/** One parsed markdown doc in a store snapshot. */
+export interface StoreDoc {
+    /** Absolute file path. */
+    path: string;
+    /** Path relative to the store root, `/`-separated. */
+    relPath: string;
+    /** Full file text as read from disk. */
+    source: string;
+    /** Parsed frontmatter record (null when the file has no frontmatter block). */
+    frontmatter: Record<string, unknown> | null;
+    body: string;
+}
+/** Every parseable `.md` doc under one memory-store root. */
+export interface StoreSnapshot {
+    root: string;
+    docs: StoreDoc[];
+}
+/** One planned rewrite: the full new file text for `path`. */
+export interface DocChange {
+    path: string;
+    /** Complete replacement text for the file. */
+    after: string;
+}

package/dist/migrations/types.js

@@ -0,0 +1,11 @@
+// State-migration shapes. Two lanes, split by which store owns the state:
+//
+//   journaled  — canvas-db state. Runs inside the db's ordered migration chain
+//                (core/canvas/db.ts appends these to MIGRATIONS), so each step
+//                gets the chain's BEGIN IMMEDIATE/COMMIT + user_version gating
+//                and runs exactly once per database.
+//   convergent — on-disk memory documents. No journal exists over a user's
+//                stores (files appear, sync in, get hand-edited), so these
+//                CONVERGE instead: every run re-scans and rewrites whatever
+//                still matches the old shape. `crtr sys migrate` is the runner.
+export {};

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-context-intro.d.ts

@@ -1,4 +1,5 @@
 import { CONTEXT_INTRO_CUSTOM_TYPE } from '../shared/generated-context.js';
+import { type InjectedDocs } from '../core/substrate/injected-store.js';
 /** The `customType` stamped on the injected session message. Used both to write
  *  the entry and to detect it on resume (the idempotency guard). Defined beside
  *  the block builder in `core/runtime/bearings.ts` because the warm-pool claim's
@@ -68,7 +69,7 @@ interface PiLike {
 }
 /** Build the full bearings baseline for a conversation without inherited
  *  crouter context. Exported for testing. */
-export declare function buildContextIntro(nodeId: string, seen?: Set<string>): Promise<string>;
+export declare function buildContextIntro(nodeId: string, seen?: InjectedDocs): Promise<string>;
 /** Build the compact node-scoped update for a fork whose copied branch already
  *  carries a full crouter baseline. Exported for testing. */
 export declare function buildForkContextIntro(nodeId: string): Promise<string>;

package/dist/pi-extensions/canvas-doc-substrate.d.ts

@@ -17,7 +17,8 @@ interface ToolResultEventLike {
     toolName: string;
     isError?: boolean;
     /** The tool's resolved input. For `read` it carries the file path under
-     *  `path` (or the legacy `file_path`). Typed loosely; narrowed at use. */
+     *  `path` (or the legacy `file_path`); for `bash`, the command string under
+     *  `command`. Typed loosely; narrowed at use. */
     input?: unknown;
     content: ContentBlockLike[];
 }

package/dist/pi-extensions/canvas-doc-substrate.js

@@ -15,12 +15,14 @@
 //      a capability. Falls back to appending when the anchor is absent. (The `<memory kind="knowledge">`
 //      catalog rides the bearings message instead — see core/substrate/render.ts.)
 //
-//   2. tool_result (gated on `read`) — the ON-READ half. For each non-error
-//      `read`, evaluates explicit `applies-to` globs (plus `read-when` metadata)
-//      across the resolved corpus and any project stores enclosing the read
-//      file. Matches render at their file-read rung in `<auto-loaded-context>`
-//      before the file contents. A transcript-scoped realpath set deduplicates
-//      repeated reads and resumed broker processes.
+//   2. tool_result (gated on `read` and `bash`) — the EVENT half. For each
+//      non-error `read`, evaluates the read file against every doc's `read`
+//      surfaces entries across the resolved corpus and any project stores
+//      enclosing the read file; for each non-error `bash`, evaluates the
+//      executed command string against every doc's `command` entries. Matches
+//      render at their matched rung in `<auto-loaded-context>` before the
+//      tool output. A transcript-scoped (realpath → rung) map deduplicates
+//      repeated deliveries and resumed broker processes.
 //
 // Both handler bodies are wrapped in try/catch and degrade to INERT on error —
 // a substrate bug must never brick node boot or break a `read`, only quietly
@@ -34,9 +36,9 @@ import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
 import { renderPreferencesFromState } from '../core/runtime/broker-extension-render.js';
-import { renderOnReadDocsForSubject } from '../core/substrate/on-read.js';
+import { renderOnCommandDocsForSubject, renderOnReadDocsForSubject } from '../core/substrate/on-read.js';
 import { clearSessionCache } from '../core/substrate/session-cache.js';
-import { loadInjectedDocs, saveInjectedDocs, sharedInjectedDocs } from '../core/substrate/injected-store.js';
+import { loadInjectedDocs, mergeInjectedDocs, saveInjectedDocs, sharedInjectedDocs } from '../core/substrate/injected-store.js';
 import { autoLoadedContextInner, mergeAutoLoadedContext } from './envelope-merge.js';
 // ---------------------------------------------------------------------------
 // Extension
@@ -86,7 +88,13 @@ export function registerCanvasDocSubstrate(pi) {
     pi.on('before_agent_start', async (event) => {
         try {
             const state = await brokerExtensionState(nodeId);
-            const block = renderPreferencesFromState(state);
+            // Merge the on-disk set first so this save never clobbers an
+            // out-of-process delivery (the daemon's warm-spare bearings push), then
+            // seed each rendered preference at its boot rung. Boot renders every
+            // agent run and never skips; re-seeding at the same rung is idempotent.
+            mergeInjectedDocs(injectedDocs, loadInjectedDocs(nodeId));
+            const block = renderPreferencesFromState(state, injectedDocs);
+            saveInjectedDocs(nodeId, injectedDocs);
             if (block === '')
                 return; // nothing eligible — leave the prompt untouched
             const idx = event.systemPrompt.indexOf(TOOLS_ANCHOR);
@@ -101,43 +109,58 @@ export function registerCanvasDocSubstrate(pi) {
             return; // inert on error — never brick node boot
         }
     });
-    // 2. ON-READ half — augment a non-error `read` result with surfacing docs.
+    // 2. EVENT half — augment a non-error `read` with docs matched by the read
+    //    file, and a non-error `bash` with docs matched by the command string.
     pi.on('tool_result', async (event, ctx) => {
         try {
-            if (event.toolName !== 'read' || event.isError === true)
+            if (event.isError === true)
                 return;
-            const input = event.input;
-            const rawPath = input?.path ?? input?.file_path;
-            if (rawPath === undefined || rawPath === '')
+            let injected;
+            if (event.toolName === 'read') {
+                const input = event.input;
+                const rawPath = input?.path ?? input?.file_path;
+                if (rawPath === undefined || rawPath === '')
+                    return;
+                // Resolve to an absolute path (renderOnReadDocsForSubject realpaths it).
+                // pi's read tool expands a leading `~`, but event.input keeps the raw
+                // form, so expand it ourselves before resolving against the session cwd.
+                const cwd = typeof ctx?.cwd === 'string' && ctx.cwd !== '' ? ctx.cwd : process.cwd();
+                const expanded = rawPath.startsWith('~') ? join(homedir(), rawPath.slice(1)) : rawPath;
+                const absFile = resolve(cwd, expanded);
+                const state = await brokerExtensionState(nodeId);
+                // Merge the on-disk set: an out-of-process delivery (the daemon's
+                // warm-spare claim pushes bearings — including workspace-open docs —
+                // into the live session and persists what it delivered) must dedup here
+                // too. Cheap: one tiny JSON read per tool result.
+                mergeInjectedDocs(injectedDocs, loadInjectedDocs(nodeId));
+                injected = renderOnReadDocsForSubject(state.subject, absFile, injectedDocs);
+            }
+            else if (event.toolName === 'bash') {
+                const input = event.input;
+                const command = input?.command;
+                if (typeof command !== 'string' || command.trim() === '')
+                    return;
+                const state = await brokerExtensionState(nodeId);
+                mergeInjectedDocs(injectedDocs, loadInjectedDocs(nodeId));
+                injected = renderOnCommandDocsForSubject(state.subject, command, injectedDocs);
+            }
+            else {
                 return;
-            // Resolve to an absolute path (renderOnReadDocsForSubject realpaths it).
-            // pi's read tool expands a leading `~`, but event.input keeps the raw
-            // form, so expand it ourselves before resolving against the session cwd.
-            const cwd = typeof ctx?.cwd === 'string' && ctx.cwd !== '' ? ctx.cwd : process.cwd();
-            const expanded = rawPath.startsWith('~') ? join(homedir(), rawPath.slice(1)) : rawPath;
-            const absFile = resolve(cwd, expanded);
-            const state = await brokerExtensionState(nodeId);
-            // Merge the on-disk set: an out-of-process delivery (the daemon's
-            // warm-spare claim pushes bearings — including workspace-open docs —
-            // into the live session and persists what it delivered) must dedup here
-            // too. Cheap: one tiny JSON read per `read`.
-            for (const real of loadInjectedDocs(nodeId))
-                injectedDocs.add(real);
-            const injected = renderOnReadDocsForSubject(state.subject, absFile, injectedDocs);
+            }
             if (injected === '')
-                return; // nothing surfaced — pass the read through unchanged
-            // A doc surfaced → renderOnReadDocs grew injectedDocs; persist the set so
-            // the dedup survives a later dormancy → revive(resume).
+                return; // nothing surfaced — pass the result through unchanged
+            // A doc surfaced → the render grew injectedDocs; persist the set so the
+            // dedup survives a later dormancy → revive(resume).
             saveInjectedDocs(nodeId, injectedDocs);
-            // Fold into any existing auto-loaded-context block from sibling read hooks;
-            // otherwise prepend one quiet block ahead of the file contents.
+            // Fold into any existing auto-loaded-context block from sibling hooks;
+            // otherwise prepend one quiet block ahead of the tool output.
             const inner = autoLoadedContextInner(injected);
             if (inner === null)
                 return;
             return { content: mergeAutoLoadedContext([inner], event.content) };
         }
         catch {
-            return; // inert on error — a bug must degrade a read, never break it
+            return; // inert on error — a bug must degrade a tool result, never break it
         }
     });
 }

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.209",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.207",
+  "version": "0.3.209",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.207",
+      "version": "0.3.209",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/dist/core/substrate/ceiling.d.ts

@@ -1,17 +0,0 @@
-import { type Rung, type SubstrateDoc } from './schema.js';
-/** The reserved basename (no extension) that marks a directory's index doc. */
-export declare const INDEX_NAME = "INDEX";
-/** Does this path-derived name denote a directory INDEX (`taste/INDEX`, or a
- *  top-level `INDEX`)? */
-export declare function isIndexName(name: string): boolean;
-/** The directory an INDEX doc represents: `taste/INDEX` → `taste`, `INDEX` → ''. */
-export declare function indexDirOf(name: string): string;
-/** Returns the display path corresponding to a canonical logical identifier. */
-export declare function displayName(name: string): string;
-/** Build the dir → governing-INDEX map. Precedence is first-occurrence-wins, so
- *  callers MUST pass docs precedence-ordered (project > user > builtin) — the
- *  highest-precedence INDEX governs a dir, mirroring the memory resolver. */
-export declare function buildCeilingIndex(docs: SubstrateDoc[]): Map<string, SubstrateDoc>;
-/** A doc's effective system-prompt rung after applying every ancestor INDEX
- * ceiling. A `none` ancestor hides the whole subtree from the boot catalog. */
-export declare function effectiveSystemPromptRung(doc: SubstrateDoc, ceil: Map<string, SubstrateDoc>): Rung;