@north-light/crouter 0.3.204 → 0.3.206

package/dist/shared/generated-context.js

@@ -1,27 +1,17 @@
-// generated-context.ts — the display contract for crouter-authored context messages.
+// Runtime-card grammar for crouter-authored context messages.
 //
-// The runtime sends these messages in the role that preserves their delivery
-// semantics: fresh-revive kickoffs, mid-run nudges, persona transitions, stop
-// guards, recovery prompts, and node inbox digests are user messages, while
-// bearings, situational updates, and held nudges are custom messages. Attached
-// views should still present all of them as generated context rather than as
-// ordinary human prompts. This pure module owns their stable identifiers,
-// producer formatting, and display classification so the terminal and web
-// renderers cannot drift.
-import { REVIEW_BOUNDARY_CUSTOM_TYPE } from '../core/runtime/session-visibility.js';
-export { REVIEW_BOUNDARY_CUSTOM_TYPE };
+// Every runtime message carries one whole-message envelope. customType only
+// controls delivery and visibility; parsing stays independent of runtime and clients.
 /** Custom message carrying the node's session-start bearings. */
 export const CONTEXT_INTRO_CUSTOM_TYPE = 'crtr-context';
 /** Custom message carrying an ambient situational-context update. */
 export const SITUATIONAL_CONTEXT_CUSTOM_TYPE = 'crtr-situational-context';
 /** Custom message used when a context-size nudge waits for the next turn. */
 export const CONTEXT_NUDGE_CUSTOM_TYPE = 'crtr-context-nudge';
-/** Opening text of a fresh-revive kickoff user message. */
+/** Custom message that opens a review companion's visible transcript. */
+export const REVIEW_BOUNDARY_CUSTOM_TYPE = 'crtr-review-boundary';
+/** Opening text of a pre-envelope fresh-revive kickoff user message. */
 export const REVIVE_KICKOFF_SENTINEL = 'You have been revived fresh after a context refresh';
-/** Prefix shared by the producer and the compatibility classifier for context nudges. */
-export const CONTEXT_NUDGE_PREFIX = '[crtr] Context ~';
-/** Runtime-authored continuation after a cleanly aborted turn survives a restart. */
-export const RUNTIME_RESTART_CONTINUATION = '<runtime-restart-continuation>\ncontinue\n</runtime-restart-continuation>';
 /** Generic completion mandate issued by the terminal-node stop guard. */
 export const STALL_REPROMPT = "You've stopped but you're not waiting on anyone and haven't finished. " +
     "Pipe the result to `crtr push final` through a single-quoted heredoc if the work is done, or use `crtr human send` if you are blocked or need the user.";
@@ -29,50 +19,166 @@ export const STALL_REPROMPT = "You've stopped but you're not waiting on anyone a
 export const AUTH_FAULT_RECOVERY_BODY = 'Provider credentials were just updated (a new login landed). Your previous turn stopped on a provider authentication failure. Continue from where you left off and retry the work that failed.';
 export const CONNECTION_FAULT_RECOVERY_BODY = 'The network connection is back online. Your previous turn stopped on a connection error (the network was down). Continue from where you left off and retry the work that failed.';
 export const PROVIDER_FAULT_RECOVERY_BODY = 'Your previous turn stopped on a provider fault. Continue from where you left off and retry the work that failed.';
-const PERSONA_TRANSITION_OPEN = '<persona-transition>';
-const PERSONA_TRANSITION_CLOSE = '</persona-transition>';
 const REVIEW_APPROVAL_OPEN = '<crtr-review-approval>';
 const REVIEW_APPROVAL_CLOSE = '</crtr-review-approval>';
 const MODEL_FALLBACK_RECOVERY_OPEN = '<model-fallback-recovery>';
 const MODEL_FALLBACK_RECOVERY_CLOSE = '</model-fallback-recovery>';
 const STRUCTURED_OUTPUT_REPROMPT_PREFIX = 'You must call the `submit` tool with a result matching the required schema before you can stop. You cannot finish or go dormant any other way while this request is pending.\n\nRequired schema:\n\n```json\n';
 const STRUCTURED_OUTPUT_REPROMPT_SUFFIX = '\n```';
-/** Mark an active persona transition without changing the guidance inside it. */
-export function formatPersonaTransition(guidance) {
-    return `${PERSONA_TRANSITION_OPEN}\n${guidance}\n${PERSONA_TRANSITION_CLOSE}`;
-}
-/** Mark a daemon-delivered review approval for compact viewer presentation. */
-export function formatReviewApproval(body) {
-    return `${REVIEW_APPROVAL_OPEN}\n${body}\n${REVIEW_APPROVAL_CLOSE}`;
-}
 /** Format the stop guard's dynamic structured-output mandate. */
 export function formatStructuredOutputReprompt(schema) {
     return `${STRUCTURED_OUTPUT_REPROMPT_PREFIX}${schema}${STRUCTURED_OUTPUT_REPROMPT_SUFFIX}`;
 }
-/** Mark a model-route fallback re-drive while retaining its full guidance. */
+/** Keep model-fallback guidance editable without making it a reader contract. */
 export function formatModelFallbackRecovery(previousModel, nextModel, reason) {
-    const guidance = reason === 'credential'
+    return reason === 'credential'
         ? `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.`;
-    return `${MODEL_FALLBACK_RECOVERY_OPEN}\n${guidance}\n${MODEL_FALLBACK_RECOVERY_CLOSE}`;
-}
-const AUTO_LOADED_CONTEXT_BLOCK = /<auto-loaded-context>([\s\S]*?)<\/auto-loaded-context>/;
-const YIELD_MESSAGE_BLOCK = /<yield-message>([\s\S]*?)<\/yield-message>/;
-/** The display-only disclosure body for a generated context card. The full
- * message remains in `body` for the model and transcript bookkeeping; the two
- * prompt-sized cards expose the one piece a person needs to inspect. */
-function unmarkReviewApprovals(body) {
-    return body.replaceAll(`${REVIEW_APPROVAL_OPEN}\n`, '').replaceAll(`\n${REVIEW_APPROVAL_CLOSE}`, '');
-}
-export function generatedContextExpandedBody(presentation) {
-    let body = presentation.body;
-    if (presentation.label === 'crtr context') {
-        body = AUTO_LOADED_CONTEXT_BLOCK.exec(body)?.[1]?.trim() ?? '';
+}
+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';
     }
-    else if (presentation.kind === 'revive') {
-        body = YIELD_MESSAGE_BLOCK.exec(body)?.[1]?.trim() ?? '';
+}
+/** 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;
+    }
+}
+const XML_ATTRIBUTE_NAME = /^[A-Za-z_:][A-Za-z0-9_:.-]*$/;
+const ATTRIBUTE_RE = /\s+([A-Za-z_:][A-Za-z0-9_:.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/gy;
+function escapeXmlAttribute(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&apos;');
+}
+function escapeXmlText(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+function unescapeXmlAttribute(value) {
+    return value.replace(/&(?:amp|lt|gt|quot|apos);/g, (entity) => ({
+        '&amp;': '&',
+        '&lt;': '<',
+        '&gt;': '>',
+        '&quot;': '"',
+        '&apos;': "'",
+    })[entity]);
+}
+function parseAttributes(source) {
+    const attributes = {};
+    ATTRIBUTE_RE.lastIndex = 0;
+    let index = 0;
+    while (index < source.length) {
+        if (/^\s*$/.test(source.slice(index)))
+            break;
+        ATTRIBUTE_RE.lastIndex = index;
+        const match = ATTRIBUTE_RE.exec(source);
+        if (match === null)
+            return null;
+        const [, key, doubleQuoted, singleQuoted] = match;
+        if (key === undefined || Object.hasOwn(attributes, key))
+            return null;
+        attributes[key] = unescapeXmlAttribute(doubleQuoted ?? singleQuoted ?? '');
+        index = ATTRIBUTE_RE.lastIndex;
     }
-    return unmarkReviewApprovals(body);
+    return attributes;
+}
+function formatAttributes(attributes) {
+    return Object.entries(attributes)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => {
+        if (!XML_ATTRIBUTE_NAME.test(key))
+            throw new Error(`Invalid XML attribute name: ${key}`);
+        return ` ${key}="${escapeXmlAttribute(String(value))}"`;
+    })
+        .join('');
 }
 /** Plain text from a generated message's string or text-block content. */
 export function generatedContextText(message) {
@@ -81,62 +187,148 @@ export function generatedContextText(message) {
     if (!Array.isArray(message.content))
         return '';
     return message.content
-        .filter((block) => typeof block === 'object' &&
-        block !== null &&
-        block.type === 'text' &&
-        typeof block.text === 'string')
+        .filter((block) => typeof block === 'object'
+        && block !== null
+        && block.type === 'text'
+        && typeof block.text === 'string')
         .map((block) => block.text)
         .join('');
 }
-/** Format the runtime's visible context-size guidance. */
-export function formatContextNudge(note) {
-    return `[crtr] ${note}`;
-}
-function nudgeSummary(body) {
-    const size = body.match(/^\[crtr\]\s+Context\s+(~\d+k)\b/)?.[1];
-    return size === undefined ? 'context-window guidance' : `Context ${size}`;
-}
-// Stable header emitted by core/feed/inbox.ts coalesce(). Human-authored inbox
-// messages are deliberately delivered verbatim and never carry this header.
-// Senders are node ids, the two reserved words, or the daemon itself (crtrd —
-// review notes and other daemon-originated node messages).
-const INBOX_HEADER_RE = /^From ([a-z0-9]+(?:-[a-z0-9]+)+|system|human|crtrd) — (\d+) update/m;
-const INBOX_HEADERS_RE = /^From ([a-z0-9]+(?:-[a-z0-9]+)+|system|human|crtrd) — (\d+) update/gm;
-// Entry lines inside a section, rendered by core/runtime/broker/inbox.ts as
-// `  [<kind>]`. A final is the one kind that ends the sender's node.
-const FINISHED_ENTRY_RE = /^ {2}\[(?:final|completed)\]/m;
-export function isInboxDigest(text) {
-    return INBOX_HEADER_RE.test(text);
-}
-export function extractInboxSender(text) {
-    return INBOX_HEADER_RE.exec(text)?.[1] ?? null;
-}
-/** Node ids whose section of this digest reports a finished node. Sections are
- *  delimited by their `From <sender>` headers, so a final never attaches to the
- *  neighbouring sender. */
-export function inboxFinishedSenders(text) {
-    const headers = [...text.matchAll(INBOX_HEADERS_RE)];
+/** Wrap a user-role runtime message in its whole-message card envelope. */
+export function formatCard(kind, facts, body) {
+    if (kind === '')
+        throw new Error('Runtime card kind is required');
+    if (Object.hasOwn(facts, 'kind'))
+        throw new Error('Runtime card facts cannot replace kind');
+    return `<runtime${formatAttributes({ kind, ...facts })}>${body}</runtime>`;
+}
+/** Wrap a card whose body is DATA, not markup — the only escape on the API
+ *  path, so a caller can neither emit a malformed card nor smuggle markup into
+ *  one. `formatCard` keeps its raw body for the trusted crouter producers that
+ *  deliberately nest markup (bearings blocks, the inbox `<from>`/`<entry>`
+ *  grammar `parseInboxBody` depends on). */
+export function formatDataCard(kind, facts, body) {
+    return formatCard(kind, facts, escapeXmlText(body));
+}
+function parseInboxBody(body) {
     const senders = [];
-    for (const [index, header] of headers.entries()) {
-        const start = header.index ?? 0;
-        const end = headers[index + 1]?.index ?? text.length;
-        const sender = header[1];
-        if (sender !== undefined && FINISHED_ENTRY_RE.test(text.slice(start, end)))
-            senders.push(sender);
+    const fromRe = /<from\b([^>]*)>([\s\S]*?)<\/from>/g;
+    for (const fromMatch of body.matchAll(fromRe)) {
+        const attributes = parseAttributes(fromMatch[1] ?? '');
+        if (attributes?.id === undefined || attributes.updates === undefined)
+            continue;
+        const updates = Number(attributes.updates);
+        if (!Number.isFinite(updates))
+            continue;
+        const entries = [];
+        const entryBody = fromMatch[2] ?? '';
+        const entryRe = /<entry\b([^>]*)>([\s\S]*?)<\/entry>/g;
+        for (const entryMatch of entryBody.matchAll(entryRe)) {
+            const entryAttributes = parseAttributes(entryMatch[1] ?? '');
+            if (entryAttributes?.kind === undefined)
+                continue;
+            const disposition = entryAttributes.disposition === 'human-answer' || entryAttributes.disposition === 'human-canceled'
+                ? entryAttributes.disposition
+                : 'report';
+            entries.push({
+                kind: entryAttributes.kind,
+                disposition,
+                body: unescapeXmlAttribute(entryMatch[2] ?? ''),
+                ...(entryAttributes.ref === undefined ? {} : { ref: entryAttributes.ref }),
+            });
+        }
+        senders.push({
+            id: attributes.id,
+            ...(attributes.name === undefined ? {} : { name: attributes.name }),
+            updates,
+            finished: attributes.finished === 'true' || entries.some((entry) => entry.kind === 'final'),
+            entries,
+        });
     }
     return senders;
 }
-function inboxSummary(body) {
-    const headers = [...body.matchAll(INBOX_HEADERS_RE)];
-    if (headers.length === 0)
-        return 'node update';
-    const updates = headers.reduce((total, match) => total + Number(match[2] ?? 0), 0);
-    if (headers.length === 1) {
-        const sender = headers[0]?.[1] ?? 'system';
-        return `${updates} update${updates === 1 ? '' : 's'} from ${sender}`;
+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,
+    };
+}
+/** Parse a whole-message runtime envelope, regardless of delivery role. */
+function parseEnvelope(text) {
+    const opening = /^<runtime\b([^>]*)>/.exec(text);
+    if (opening === null || !text.endsWith('</runtime>'))
+        return null;
+    const attributes = parseAttributes(opening[1] ?? '');
+    if (attributes?.kind === undefined)
+        return null;
+    const raw = text.slice(opening[0].length, -'</runtime>'.length);
+    const { kind, ...factValues } = attributes;
+    const facts = Object.freeze(factValues);
+    // A namespaced kind can only have been produced through the API path, whose
+    // renderer is `formatDataCard`, so its body is escaped by construction and
+    // decodes here. A bare kind's body is raw markup written by a core producer.
+    const body = kind.includes(':') ? unescapeXmlAttribute(raw) : raw;
+    return cardFor(kind, facts, body, kind === 'inbox' ? parseInboxBody(body) : []);
+}
+/** Parse a runtime envelope, with pre-envelope customType compatibility. */
+export function parseCard(message) {
+    const text = generatedContextText(message);
+    const envelope = parseEnvelope(text);
+    if (envelope !== null)
+        return envelope;
+    if (message.role !== 'custom')
+        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 `${updates} updates from ${headers.length} senders`;
+    return null;
+}
+/** Format a complete inbox card from report bodies resolved by the caller. */
+export function formatInboxCard(sections) {
+    const body = sections.map((section) => {
+        const updates = section.updates ?? section.entries.length;
+        const finished = section.finished ?? section.entries.some((entry) => entry.kind === 'final');
+        const entries = section.entries.map((entry) => {
+            const disposition = entry.disposition === 'human-answer' || entry.disposition === 'human-canceled'
+                ? entry.disposition
+                : undefined;
+            return `<entry${formatAttributes({ kind: entry.kind, ref: entry.ref, disposition })}>${escapeXmlText(entry.body)}</entry>`;
+        }).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);
 }
+// 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
+// callers one week after that date; after deletion, pre-cut scrollback
+// misattributes and that cost is accepted.
+const LEGACY_RESTART_CONTINUATION = '<runtime-restart-continuation>\ncontinue\n</runtime-restart-continuation>';
+const CONTEXT_NUDGE_PREFIX = '[crtr] Context ~';
+const PERSONA_TRANSITION_OPEN = '<persona-transition>';
+const PERSONA_TRANSITION_CLOSE = '</persona-transition>';
+const INBOX_SENDER_ID = '[a-z0-9]+(?:-[a-z0-9]+)+';
+const INBOX_HEADER_RE = new RegExp(`^From (?:(.+?) \\[(${INBOX_SENDER_ID})\\]|(${INBOX_SENDER_ID}|system|human|crtrd)) — (\\d+) update`, 'm');
 function isPersonaTransition(body) {
     return body.startsWith(`${PERSONA_TRANSITION_OPEN}\n`) && body.endsWith(`\n${PERSONA_TRANSITION_CLOSE}`);
 }
@@ -159,92 +351,26 @@ function isStructuredOutputReprompt(body) {
 const MODEL_CREDENTIAL_RECOVERY_RE = /^The previous model \([^\n]+\) had no usable provider credential, so you were automatically switched to [^\n]+\. Continue the task from where the failed turn left off\.$/;
 const MODEL_NOT_FOUND_RECOVERY_RE = /^The previous model \([^\n]+\) was unavailable \(provider 404 not_found\), so you were automatically switched to [^\n]+\. Continue the task from where the failed turn left off\.$/;
 function isModelFallbackRecovery(body) {
-    if (!body.startsWith(`${MODEL_FALLBACK_RECOVERY_OPEN}\n`)
-        || !body.endsWith(`\n${MODEL_FALLBACK_RECOVERY_CLOSE}`)) {
+    if (!body.startsWith(`${MODEL_FALLBACK_RECOVERY_OPEN}\n`) || !body.endsWith(`\n${MODEL_FALLBACK_RECOVERY_CLOSE}`)) {
         return false;
     }
     const guidance = body.slice(MODEL_FALLBACK_RECOVERY_OPEN.length + 1, -(MODEL_FALLBACK_RECOVERY_CLOSE.length + 1));
     return MODEL_CREDENTIAL_RECOVERY_RE.test(guidance) || MODEL_NOT_FOUND_RECOVERY_RE.test(guidance);
 }
-/** Exact producer-owned marker for the continuation a successor broker inserts
- * after a runtime restart. Other recovery bodies intentionally do not match. */
-export function isRuntimeRestartContinuation(message) {
-    return message.role === 'user' && generatedContextText(message) === RUNTIME_RESTART_CONTINUATION;
-}
-function recoverySummary(body) {
-    if (body === AUTH_FAULT_RECOVERY_BODY)
-        return 'provider credentials updated';
-    if (body === CONNECTION_FAULT_RECOVERY_BODY)
-        return 'network connection restored';
-    if (body === PROVIDER_FAULT_RECOVERY_BODY)
-        return 'provider retry';
-    if (body === RUNTIME_RESTART_CONTINUATION)
-        return 'continuing from where it left off';
-    if (isModelFallbackRecovery(body))
-        return 'model route changed';
-    return null;
+function isRecoveryBody(body) {
+    return body === AUTH_FAULT_RECOVERY_BODY
+        || body === CONNECTION_FAULT_RECOVERY_BODY
+        || body === PROVIDER_FAULT_RECOVERY_BODY
+        || body === LEGACY_RESTART_CONTINUATION
+        || isModelFallbackRecovery(body);
 }
-/**
- * Classify a crouter-generated context message for display. The checks are
- * exact producer-owned contracts: custom messages use their customType, and
- * user messages use stable sentinels or the same exact formatter/constants as
- * their producers. Ordinary user prompts remain ordinary user prompts.
- */
-export function generatedContextPresentation(message) {
-    const body = generatedContextText(message);
-    if (message.role === 'custom') {
-        if (message.customType === REVIEW_BOUNDARY_CUSTOM_TYPE) {
-            return { kind: 'bearings', label: 'review boundary', summary: 'earlier conversation is not shown', body };
-        }
-        if (message.customType === CONTEXT_INTRO_CUSTOM_TYPE) {
-            return { kind: 'bearings', label: 'crtr context', summary: 'orienting bearings', body };
-        }
-        if (message.customType === SITUATIONAL_CONTEXT_CUSTOM_TYPE) {
-            return {
-                kind: 'situational',
-                label: 'situational context',
-                summary: 'ambient context update',
-                body,
-            };
-        }
-        if (message.customType === CONTEXT_NUDGE_CUSTOM_TYPE) {
-            return { kind: 'context-nudge', label: 'crtr', summary: nudgeSummary(body), body };
-        }
-        return null;
-    }
-    if (message.role !== 'user')
-        return null;
-    if (body.startsWith(REVIVE_KICKOFF_SENTINEL)) {
-        return { kind: 'revive', label: 'crtr revive', summary: 'fresh context kickoff', body };
-    }
-    if (body.startsWith(CONTEXT_NUDGE_PREFIX)) {
-        return { kind: 'context-nudge', label: 'crtr', summary: nudgeSummary(body), body };
-    }
-    if (isInboxDigest(body)) {
-        return { kind: 'inbox', label: 'crtr inbox', summary: inboxSummary(body), body };
-    }
-    if (isReviewApproval(body)) {
-        return { kind: 'review-approval', label: 'crtr review', summary: 'review approved by the user', body };
-    }
-    if (isPersonaTransition(body)) {
-        return {
-            kind: 'persona-transition',
-            label: 'crtr persona',
-            summary: 'runtime role update',
-            body,
-        };
-    }
-    if (body === STALL_REPROMPT || isStructuredOutputReprompt(body)) {
-        return {
-            kind: 'stop-guard',
-            label: 'crtr stop guard',
-            summary: body === STALL_REPROMPT ? 'completion required' : 'structured output required',
-            body,
-        };
-    }
-    const recovery = recoverySummary(body);
-    if (recovery !== null) {
-        return { kind: 'recovery', label: 'crouter continuation', summary: recovery, body };
-    }
-    return null;
+export function isLegacyRuntimeText(text) {
+    return text.startsWith(REVIVE_KICKOFF_SENTINEL)
+        || text.startsWith(CONTEXT_NUDGE_PREFIX)
+        || INBOX_HEADER_RE.test(text)
+        || isReviewApproval(text)
+        || isPersonaTransition(text)
+        || text === STALL_REPROMPT
+        || isStructuredOutputReprompt(text)
+        || isRecoveryBody(text);
 }

package/dist/shared/tool-groups.js

@@ -1,7 +1,7 @@
 // Shared transcript-boundary rules for broker-owned tool-group summaries.
 // Keep this independent of renderer state: both live event tracking and snapshot
 // reconstruction must agree on which prose closes a run of tools.
-import { generatedContextPresentation, generatedContextText } from './generated-context.js';
+import { generatedContextText, isLegacyRuntimeText, parseCard } from './generated-context.js';
 const TOOL_GROUP_SUMMARY_KEYS = new Set(['bullets', 'filesDeleted']);
 const MAX_TOOL_GROUP_BULLETS = 5;
 const MAX_TOOL_GROUP_BULLET_LENGTH = 1_000;
@@ -53,5 +53,6 @@ export function assistantVisibleText(message) {
 /** A person-authored user message closes the preceding group. Runtime-generated
  * user context retains role=user for delivery semantics but is not human prose. */
 export function isTrueUserMessage(message) {
-    return message.role === 'user' && generatedContextPresentation(message) === null;
+    const text = generatedContextText(message);
+    return message.role === 'user' && parseCard(message) === null && !isLegacyRuntimeText(text);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.204",
+  "version": "0.3.206",
   "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.204",
+  "version": "0.3.206",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.204",
+      "version": "0.3.206",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/scripts/postinstall.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { patchPiTreeRootOrdering } from './patch-pi-tree-root-ordering.mjs';
@@ -34,6 +35,14 @@ async function main() {
     console.warn('[crtr postinstall] pi tree-root-ordering patch failed (non-fatal):', error?.message ?? error);
   }
   if (process.env.CI) return;
+  // A published tarball always ships `dist/`; a source checkout being installed
+  // never does, and its runtime generation comes from an explicit
+  // `npm run build && npm run install-runtime` afterwards. Staging an unbuilt
+  // tree can only fail its smoke validation.
+  if (!existsSync(join(ROOT, 'dist', 'index.js'))) {
+    console.log('crouter source checkout installed. Run `npm run build && npm run install-runtime` to produce a runtime generation.');
+    return;
+  }
   try {
     await installRuntime();
   } catch (error) {