@north-light/crouter 0.3.170 → 0.3.171

package/dist/core/termrender/version.d.ts

@@ -0,0 +1 @@
+export declare const TERMRENDER_VERSION = "4.12.6";

package/dist/core/termrender/version.js

@@ -0,0 +1 @@
+export const TERMRENDER_VERSION = '4.12.6';

package/dist/core/user-settings.d.ts

@@ -157,6 +157,20 @@ export declare const CONFIG_SETTINGS_COVERAGE: {
             setFromString: (config: ScopeConfig, raw: string) => string | null;
         };
     };
+    summarize_tool_calls: {
+        surface: "settings";
+        setting: {
+            key: "summarize_tool_calls";
+            label: string;
+            description: string;
+            valueConstraint: string;
+            applies: string;
+            order: number;
+            format: (config: ScopeConfig) => "off" | "on";
+            cycle: (config: ScopeConfig) => void;
+            setFromString: (config: ScopeConfig, raw: string) => string | null;
+        };
+    };
     keybindings: {
         surface: "specialized";
         owner: string;

package/dist/core/user-settings.js

@@ -223,6 +223,26 @@ export const CONFIG_SETTINGS_COVERAGE = {
             },
         },
     },
+    summarize_tool_calls: {
+        surface: 'settings',
+        setting: {
+            key: 'summarize_tool_calls',
+            label: 'Summarize tool calls',
+            description: 'Replace completed folded tool-call groups with a one-line broker summary when available.',
+            valueConstraint: 'true|false',
+            applies: 'Applies when the next visible message closes a tool-call group.',
+            order: 35,
+            format: (config) => config.summarize_tool_calls ? 'on' : 'off',
+            cycle: (config) => { config.summarize_tool_calls = !config.summarize_tool_calls; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'summarize_tool_calls');
+                if (typeof value === 'string')
+                    return value;
+                config.summarize_tool_calls = value;
+                return null;
+            },
+        },
+    },
     keybindings: { surface: 'specialized', owner: 'Keybindings tab' },
     modelLadders: { surface: 'specialized', owner: 'Models tab' },
     modelRoutes: { surface: 'specialized', owner: 'Models route declarations' },

package/dist/daemon/crtrd.js

@@ -63,7 +63,7 @@ import { createApiServer } from './api/server.js';
 // surface (tests, `commands/sys/daemon.ts`).
 import { pidfilePath } from './pidfile.js';
 export { readPidfile, isDaemonRunning } from './pidfile.js';
-import { globalHumanloopWarning } from '../core/runtime/package-health.js';
+import { rendererWarning } from '../core/runtime/package-health.js';
 import { DEFAULT_INTERVAL_MS } from './supervise-cadence.js';
 import { readConfig } from '../core/config.js';
 export { FAULT_QUIET_MS };
@@ -1845,13 +1845,12 @@ export async function runDaemon(opts = {}) {
         operationIdContext.fresh(() => {
             emitEvent({ level: 'info', event: 'daemon.install_id.resolved', fields: { install_id: installId } });
         });
-        // The tmux inbox binding resolves a PATH-global `hl`, while crouter imports
-        // its bundled humanloop library. The health probe is advisory; setup repairs
-        // a stale executable without blocking supervision.
+        // The pinned termrender renderer is an advisory dependency; setup repairs
+        // an unprovisioned venv without blocking supervision.
         operationIdContext.fresh(() => {
             let warning;
             try {
-                warning = globalHumanloopWarning();
+                warning = rendererWarning();
             }
             catch {
                 return;
@@ -1860,7 +1859,7 @@ export async function runDaemon(opts = {}) {
                 emitEvent({
                     level: 'warn',
                     event: 'daemon.startup.warning',
-                    fields: { stage: 'global_humanloop', warning: warning.slice(0, 2_048) },
+                    fields: { stage: 'termrender', warning: warning.slice(0, 2_048) },
                 });
             }
         });

package/dist/index.d.ts

@@ -24,4 +24,6 @@ export type { BuildEnvelopeInput, ErrorClass, ErrorClassCode, ErrorClassHints, E
 export { validateCommandManifest } from './core/command-manifests/manifest.js';
 export type { CommandManifestValidation, ValidatedCommandManifest } from './core/command-manifests/manifest.js';
 export type { CommandManifestIssue, TransportKind } from './core/command-manifests/schema.js';
+export { validatePluginBundle } from './core/command-plugins/bundle.js';
+export type { BundleIssue, PluginBundleValidation, ValidatedBundle } from './core/command-plugins/bundle.js';
 export { SUBTREE_NAMES } from './build-root.js';

package/dist/index.js

@@ -44,4 +44,5 @@ export { nowIso } from './core/fs-utils.js';
 export { validateOperationId, buildEnvelope, operationIdContext, errorClassCodes, serializeEventRecord, errorClassFromError, } from './core/events/index.js';
 // ── Command-manifest compatibility ───────────────────────────────────────
 export { validateCommandManifest } from './core/command-manifests/manifest.js';
+export { validatePluginBundle } from './core/command-plugins/bundle.js';
 export { SUBTREE_NAMES } from './build-root.js';

package/dist/pi-extensions/__tests__/canvas-structured-output.test.d.ts

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

package/dist/pi-extensions/__tests__/canvas-structured-output.test.js

@@ -0,0 +1,63 @@
+// Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-structured-output.test.ts
+//
+// Regression: Codex strict function schemas require every property in `required`.
+import { after, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { convertResponsesTools } from '@earendil-works/pi-ai/api/openai-responses-shared';
+import { writeOutputSchema } from '../../core/runtime/structured-output.js';
+import registerCanvasStructuredOutput from '../canvas-structured-output.js';
+const previous = {
+    home: process.env['CRTR_HOME'],
+    nodeId: process.env['CRTR_NODE_ID'],
+};
+let home;
+after(() => {
+    if (home !== undefined)
+        rmSync(home, { recursive: true, force: true });
+    if (previous.home === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = previous.home;
+    if (previous.nodeId === undefined)
+        delete process.env['CRTR_NODE_ID'];
+    else
+        process.env['CRTR_NODE_ID'] = previous.nodeId;
+});
+test('optional submit fields remain optional through a strict provider tool schema', () => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-structured-output-'));
+    process.env['CRTR_HOME'] = home;
+    process.env['CRTR_NODE_ID'] = 'structured-output-test';
+    const schema = {
+        type: 'object',
+        properties: {
+            status: { type: 'string' },
+            commit: { type: 'string' },
+            verification: { type: 'string' },
+            blocker: { type: 'string' },
+        },
+        required: ['status', 'verification'],
+        additionalProperties: false,
+    };
+    writeOutputSchema('structured-output-test', 'oneoff', schema);
+    let definition;
+    registerCanvasStructuredOutput({
+        registerTool(tool) {
+            definition = tool;
+        },
+        on() { },
+    });
+    assert.ok(definition, 'the pending request registers submit');
+    const parameters = definition['parameters'];
+    assert.deepEqual(parameters.required, ['status', 'commit', 'verification', 'blocker']);
+    assert.deepEqual(parameters.properties.commit, { anyOf: [{ type: 'string' }, { type: 'null' }] });
+    assert.deepEqual(parameters.properties.blocker, { anyOf: [{ type: 'string' }, { type: 'null' }] });
+    assert.deepEqual(schema.required, ['status', 'verification'], 'the stored request keeps its original optionality');
+    const [providerTool] = convertResponsesTools([definition], {
+        strict: false,
+        supportsStrictMode: true,
+    });
+    assert.equal(providerTool['strict'], true);
+});

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

@@ -44,7 +44,7 @@ import { clearStopSignals, consumeStopSignals } from '../core/runtime/stop-signa
 import { cliClient } from '../commands/api-client.js';
 import { focusOf, tearDownNode } from '../core/runtime/placement.js';
 import { readCursor, readInboxSince } from '../core/feed/inbox.js';
-import { CONTEXT_NUDGE_CUSTOM_TYPE, formatContextNudge } from '../shared/generated-context.js';
+import { CONTEXT_NUDGE_CUSTOM_TYPE, formatContextNudge, formatPersonaTransition } from '../shared/generated-context.js';
 /** Universal upper bound for an unfocused broker parked without runnable work. */
 export const UNATTENDED_PARK_MS = (() => {
     const testOverride = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
@@ -720,7 +720,7 @@ export function registerCanvasStophook(pi) {
         try {
             const drift = personaDrift(nodeId);
             if (drift !== null) {
-                pi.sendUserMessage(drift.guidance, { deliverAs: 'steer' });
+                pi.sendUserMessage(formatPersonaTransition(drift.guidance), { deliverAs: 'steer' });
                 commitPersonaAck(nodeId, drift.to);
             }
         }

package/dist/pi-extensions/canvas-structured-output.js

@@ -27,6 +27,50 @@ function retireTool(pi) {
         /* best-effort; the execute handler is inert when no schema file exists */
     }
 }
+function strictToolSchema(schema) {
+    const transform = (value) => {
+        if (Array.isArray(value))
+            return value.map(transform);
+        if (value === null || typeof value !== 'object')
+            return value;
+        const source = value;
+        const transformed = {};
+        for (const [key, child] of Object.entries(source)) {
+            if (key === 'properties' && child !== null && typeof child === 'object' && !Array.isArray(child)) {
+                transformed[key] = Object.fromEntries(Object.entries(child).map(([name, property]) => [name, transform(property)]));
+            }
+            else {
+                transformed[key] = transform(child);
+            }
+        }
+        const properties = transformed['properties'];
+        if (properties === null || typeof properties !== 'object' || Array.isArray(properties))
+            return transformed;
+        const required = new Set(Array.isArray(source['required']) ? source['required'].filter((name) => typeof name === 'string') : []);
+        transformed['properties'] = Object.fromEntries(Object.entries(properties).map(([name, property]) => [
+            name,
+            required.has(name) ? property : { anyOf: [property, { type: 'null' }] },
+        ]));
+        transformed['required'] = Object.keys(properties);
+        return transformed;
+    };
+    return transform(schema);
+}
+function omitStrictNulls(value, schema) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value) || schema === null || typeof schema !== 'object' || Array.isArray(schema))
+        return value;
+    const source = schema;
+    const properties = source['properties'];
+    if (properties === null || typeof properties !== 'object' || Array.isArray(properties))
+        return value;
+    const requiredNames = source['required'];
+    const required = new Set(Array.isArray(requiredNames) ? requiredNames.filter((name) => typeof name === 'string') : []);
+    return Object.fromEntries(Object.entries(value).flatMap(([name, child]) => {
+        if (child === null && !required.has(name) && Object.hasOwn(properties, name))
+            return [];
+        return [[name, omitStrictNulls(child, properties[name])]];
+    }));
+}
 function toolDescription(request) {
     if (request.mode === 'terminal') {
         return 'Submit your final structured result. Calling this ends your run: the result is recorded and a final report is pushed automatically — do NOT call `crtr push final` yourself.';
@@ -66,11 +110,10 @@ export function registerCanvasStructuredOutput(pi) {
                         'Use submit to answer the pending one-off structured-output request before stopping or going dormant.',
                         'After one-off submit succeeds, continue with any remaining work normally.',
                     ],
-                parameters: request.schema,
-                // pi 0.82 can ask the provider to constrain sampling to the tool's JSON schema.
-                // `prefer` degrades silently on a model without strict tool support (`require`
-                // would fail the whole request); crouter's server-side validation and stop-guard
-                // stay authoritative either way — this only makes a malformed submission rarer.
+                // OpenAI strict tools require every property to be required. Optional fields
+                // become nullable in the provider-only schema and null is removed before the
+                // original result is persisted.
+                parameters: strictToolSchema(request.schema),
                 constrainedSampling: { type: 'json_schema', strict: 'prefer' },
                 async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
                     const current = readOutputRequest(nodeId);
@@ -88,8 +131,9 @@ export function registerCanvasStructuredOutput(pi) {
                             details: { submitted: false, reason: 'schema_replaced' },
                         };
                     }
+                    const result = omitStrictNulls(params, current.schema);
                     const resultPath = outputResultPath(nodeId);
-                    const json = JSON.stringify(params, null, 2);
+                    const json = JSON.stringify(result, null, 2);
                     mkdirSync(dirname(resultPath), { recursive: true });
                     writeFileSync(resultPath, `${json}\n`, 'utf8');
                     const body = reportBody(resultPath, json);
@@ -114,7 +158,7 @@ export function registerCanvasStructuredOutput(pi) {
                         catch { /* ignore */ }
                         return {
                             content: [{ type: 'text', text: `Structured output submitted and finalized: ${resultPath}` }],
-                            details: { submitted: true, mode: current.mode, resultPath, result: params },
+                            details: { submitted: true, mode: current.mode, resultPath, result },
                             terminate: true,
                         };
                     }
@@ -124,7 +168,7 @@ export function registerCanvasStructuredOutput(pi) {
                     retireTool(pi);
                     return {
                         content: [{ type: 'text', text: `Structured output submitted: ${resultPath}` }],
-                        details: { submitted: true, mode: current.mode, resultPath, result: params },
+                        details: { submitted: true, mode: current.mode, resultPath, result },
                     };
                 },
             });

package/dist/pi-extensions/summary-tool.d.ts

@@ -0,0 +1,33 @@
+interface PiLike {
+    registerTool: (definition: Record<string, unknown>) => void;
+}
+export declare const SUBMIT_SUMMARY_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly bullets: {
+            readonly type: "array";
+            readonly description: "One to five very short, plain-English outcome strings without bullet markers, identifiers, or operational bookkeeping.";
+            readonly minItems: 1;
+            readonly maxItems: 5;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 120;
+            };
+        };
+        readonly nodesSpawned: {
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly description: "Count of nodes created during the supplied segment, or zero when none are evidenced.";
+        };
+        readonly filesEdited: {
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly description: "Count of distinct files created, modified, or deleted during the supplied segment, or zero when none are evidenced.";
+        };
+    };
+    readonly required: readonly ["bullets", "nodesSpawned", "filesEdited"];
+    readonly additionalProperties: false;
+};
+export declare function registerSummaryTool(pi: PiLike): void;
+export default registerSummaryTool;

package/dist/pi-extensions/summary-tool.js

@@ -0,0 +1,62 @@
+// summary-tool.ts — structured-output seam for broker-owned tool-group summaries.
+// Loaded only by the headless summary subprocess. A file is the return channel
+// because pi print-mode owns stdout.
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+export const SUBMIT_SUMMARY_SCHEMA = {
+    type: 'object',
+    properties: {
+        bullets: {
+            type: 'array',
+            description: 'One to five very short, plain-English outcome strings without bullet markers, identifiers, or operational bookkeeping.',
+            minItems: 1,
+            maxItems: 5,
+            items: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 120,
+            },
+        },
+        nodesSpawned: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Count of nodes created during the supplied segment, or zero when none are evidenced.',
+        },
+        filesEdited: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Count of distinct files created, modified, or deleted during the supplied segment, or zero when none are evidenced.',
+        },
+    },
+    required: ['bullets', 'nodesSpawned', 'filesEdited'],
+    additionalProperties: false,
+};
+export function registerSummaryTool(pi) {
+    const out = process.env['CRTR_SUMMARY_RESULT_FILE'];
+    if (out === undefined || out.trim() === '')
+        return;
+    pi.registerTool({
+        name: 'submit_summary',
+        label: 'Submit summary',
+        description: 'Submit the structured tool-group activity recap exactly once, then stop.',
+        parameters: SUBMIT_SUMMARY_SCHEMA,
+        // Anthropic's constrained-sampling subset rejects the array/range keywords
+        // this contract requires; ordinary tool calling accepts the complete schema.
+        constrainedSampling: false,
+        execute(_id, params) {
+            try {
+                mkdirSync(dirname(out), { recursive: true });
+                writeFileSync(out, JSON.stringify(params ?? {}), 'utf8');
+            }
+            catch {
+                // A missing result is a failed summary; callers never invent one.
+            }
+            return {
+                content: [{ type: 'text', text: 'Recorded.' }],
+                details: { recorded: true },
+                terminate: true,
+            };
+        },
+    });
+}
+export default registerSummaryTool;

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

@@ -8,13 +8,28 @@ export declare const CONTEXT_NUDGE_CUSTOM_TYPE = "crtr-context-nudge";
 export declare const REVIVE_KICKOFF_SENTINEL = "You have been revived fresh after a context refresh";
 /** Prefix shared by the producer and the compatibility classifier for context nudges. */
 export declare const CONTEXT_NUDGE_PREFIX = "[crtr] Context ~";
+/** Runtime-authored continuation after a cleanly aborted turn survives a restart. */
+export declare const RUNTIME_RESTART_CONTINUATION = "<runtime-restart-continuation>\ncontinue\n</runtime-restart-continuation>";
+/** Generic completion mandate issued by the terminal-node stop guard. */
+export declare const STALL_REPROMPT: string;
+/** Static recovery prompts shared by the broker producer and display classifier. */
+export declare const AUTH_FAULT_RECOVERY_BODY = "Provider credentials were just updated (a new login landed). Your previous turn stopped on a provider authentication failure. Continue from where you left off and retry the work that failed.";
+export declare const CONNECTION_FAULT_RECOVERY_BODY = "The network connection is back online. Your previous turn stopped on a connection error (the network was down). Continue from where you left off and retry the work that failed.";
+export declare const PROVIDER_FAULT_RECOVERY_BODY = "Your previous turn stopped on a provider fault. Continue from where you left off and retry the work that failed.";
+/** Mark an active persona transition without changing the guidance inside it. */
+export declare function formatPersonaTransition(guidance: string): string;
+/** Format the stop guard's dynamic structured-output mandate. */
+export declare function formatStructuredOutputReprompt(schema: string): string;
+export type ModelFallbackRecoveryReason = 'credential' | 'not-found';
+/** Mark a model-route fallback re-drive while retaining its full guidance. */
+export declare function formatModelFallbackRecovery(previousModel: string, nextModel: string, reason: ModelFallbackRecoveryReason): string;
 export interface GeneratedContextMessageLike {
     role?: string;
     customType?: string;
     content?: unknown;
 }
 export interface GeneratedContextPresentation {
-    kind: 'bearings' | 'situational' | 'revive' | 'context-nudge' | 'inbox';
+    kind: 'bearings' | 'situational' | 'revive' | 'context-nudge' | 'inbox' | 'persona-transition' | 'stop-guard' | 'recovery';
     label: string;
     summary: string;
     body: string;
@@ -27,8 +42,8 @@ export declare function isInboxDigest(text: string): boolean;
 export declare function extractInboxSender(text: string): string | null;
 /**
  * Classify a crouter-generated context message for display. The checks are
- * exact producer-owned contracts: custom messages use their customType; the two
- * user-message forms use the same stable sentinel/prefix their producers own.
- * Ordinary user prompts never match and remain ordinary user prompts.
+ * exact producer-owned contracts: custom messages use their customType, and
+ * user messages use stable sentinels or the same exact formatter/constants as
+ * their producers. Ordinary user prompts remain ordinary user prompts.
  */
 export declare function generatedContextPresentation(message: GeneratedContextMessageLike): GeneratedContextPresentation | null;

package/dist/shared/generated-context.js

@@ -1,11 +1,13 @@
 // generated-context.ts — the display contract for crouter-authored context messages.
 //
 // The runtime sends these messages in the role that preserves their delivery
-// semantics: fresh-revive kickoffs, mid-run nudges, and node inbox digests are user messages,
-// while bearings, situational updates, and held nudges are custom messages. Attached
+// 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 and
-// display classification so the terminal and web renderers cannot drift.
+// ordinary human prompts. This pure module owns their stable identifiers,
+// producer formatting, and display classification so the terminal and web
+// renderers cannot drift.
 /** 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. */
@@ -16,6 +18,36 @@ export const CONTEXT_NUDGE_CUSTOM_TYPE = 'crtr-context-nudge';
 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 ask` if you are blocked or need the user.";
+/** Static recovery prompts shared by the broker producer and display classifier. */
+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 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}`;
+}
+/** 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. */
+export function formatModelFallbackRecovery(previousModel, nextModel, reason) {
+    const guidance = 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}`;
+}
 /** Plain text from a generated message's string or text-block content. */
 export function generatedContextText(message) {
     if (typeof message.content === 'string')
@@ -58,11 +90,50 @@ function inboxSummary(body) {
     }
     return `${updates} updates from ${headers.length} senders`;
 }
+function isPersonaTransition(body) {
+    return body.startsWith(`${PERSONA_TRANSITION_OPEN}\n`) && body.endsWith(`\n${PERSONA_TRANSITION_CLOSE}`);
+}
+function isStructuredOutputReprompt(body) {
+    if (!body.startsWith(STRUCTURED_OUTPUT_REPROMPT_PREFIX) || !body.endsWith(STRUCTURED_OUTPUT_REPROMPT_SUFFIX)) {
+        return false;
+    }
+    const schema = body.slice(STRUCTURED_OUTPUT_REPROMPT_PREFIX.length, -STRUCTURED_OUTPUT_REPROMPT_SUFFIX.length);
+    try {
+        JSON.parse(schema);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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}`)) {
+        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);
+}
+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 'runtime restarted';
+    if (isModelFallbackRecovery(body))
+        return 'model route changed';
+    return null;
+}
 /**
  * Classify a crouter-generated context message for display. The checks are
- * exact producer-owned contracts: custom messages use their customType; the two
- * user-message forms use the same stable sentinel/prefix their producers own.
- * Ordinary user prompts never match and remain ordinary user prompts.
+ * 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);
@@ -94,5 +165,25 @@ export function generatedContextPresentation(message) {
     if (isInboxDigest(body)) {
         return { kind: 'inbox', label: 'crtr inbox', summary: inboxSummary(body), 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: 'crtr recovery', summary: recovery, body };
+    }
     return null;
 }

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

@@ -0,0 +1,23 @@
+/** Broker-generated activity recap for one completed tool-call group. */
+export interface ToolGroupSummary {
+    bullets: string[];
+    nodesSpawned: number;
+    filesEdited: number;
+}
+export interface ToolGroupMessageLike {
+    role?: string;
+    content?: unknown;
+    customType?: string;
+}
+/** 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;
+/** Validate sidecar/snapshot entries independently so one malformed or legacy
+ * value never collapses any otherwise valid group. */
+export declare function normalizeToolGroupSummaryRecord(value: unknown): Record<string, ToolGroupSummary>;
+/** Text a renderer presents as an assistant bubble. Thinking and tool-call
+ * blocks deliberately do not count: only visible prose establishes a boundary. */
+export declare function assistantVisibleText(message: ToolGroupMessageLike): string;
+/** 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 declare function isTrueUserMessage(message: ToolGroupMessageLike): boolean;

package/dist/shared/tool-groups.js

@@ -0,0 +1,60 @@
+// 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';
+const TOOL_GROUP_SUMMARY_KEYS = new Set(['bullets', 'nodesSpawned', 'filesEdited']);
+const MAX_TOOL_GROUP_BULLETS = 5;
+const MAX_TOOL_GROUP_BULLET_LENGTH = 1_000;
+/** 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 function normalizeToolGroupSummary(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    const record = value;
+    const keys = Object.keys(record);
+    if (keys.length !== TOOL_GROUP_SUMMARY_KEYS.size || !keys.every((key) => TOOL_GROUP_SUMMARY_KEYS.has(key))) {
+        return null;
+    }
+    if (!Array.isArray(record.bullets) || record.bullets.length === 0)
+        return null;
+    if (!record.bullets.every((bullet) => typeof bullet === 'string' && bullet.trim() !== ''))
+        return null;
+    if (typeof record.nodesSpawned !== 'number' || !Number.isSafeInteger(record.nodesSpawned) || record.nodesSpawned < 0)
+        return null;
+    if (typeof record.filesEdited !== 'number' || !Number.isSafeInteger(record.filesEdited) || record.filesEdited < 0)
+        return null;
+    return {
+        bullets: record.bullets
+            .slice(0, MAX_TOOL_GROUP_BULLETS)
+            .map((bullet) => bullet.trim().slice(0, MAX_TOOL_GROUP_BULLET_LENGTH).trimEnd()),
+        nodesSpawned: record.nodesSpawned,
+        filesEdited: record.filesEdited,
+    };
+}
+/** Validate sidecar/snapshot entries independently so one malformed or legacy
+ * value never collapses any otherwise valid group. */
+export function normalizeToolGroupSummaryRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return {};
+    const summaries = {};
+    for (const [key, candidate] of Object.entries(value)) {
+        if (key.trim() === '')
+            continue;
+        const summary = normalizeToolGroupSummary(candidate);
+        if (summary !== null)
+            summaries[key] = summary;
+    }
+    return summaries;
+}
+/** Text a renderer presents as an assistant bubble. Thinking and tool-call
+ * blocks deliberately do not count: only visible prose establishes a boundary. */
+export function assistantVisibleText(message) {
+    if (message.role !== 'assistant')
+        return '';
+    return generatedContextText(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;
+}