@north-light/crouter 0.3.164 → 0.3.165

package/dist/core/scope.d.ts

@@ -25,11 +25,6 @@ export declare function requireScopeRoot(scope: Scope): string;
 export declare function ensureProjectScopeRoot(startDir?: string): string;
 export declare function pluginsDir(scope: Scope): string | null;
 export declare function marketplacesDir(scope: Scope): string | null;
-export declare function configuredClisDir(scope: Scope): string | null;
-/** The configured-CLIs cache parent dir under an EXACT scope-root dir. Used to
- *  address per-root caches when multiple project roots are visible; the single
- *  source of the `configured-clis` path segment. */
-export declare function configuredClisDirForRoot(scopeRootDir: string): string;
 /** Where substrate memory documents live per scope. Builtin memory is the
  *  special case — its own package dir (builtinMemoryRoot), since the builtin
  *  scope has no scopeRoot — mirroring viewsDir's builtin handling. User and

package/dist/core/scope.js

@@ -195,16 +195,6 @@ export function marketplacesDir(scope) {
     const root = scopeRoot(scope);
     return root ? join(root, 'marketplaces') : null;
 }
-export function configuredClisDir(scope) {
-    const root = scopeRoot(scope);
-    return root ? configuredClisDirForRoot(root) : null;
-}
-/** The configured-CLIs cache parent dir under an EXACT scope-root dir. Used to
- *  address per-root caches when multiple project roots are visible; the single
- *  source of the `configured-clis` path segment. */
-export function configuredClisDirForRoot(scopeRootDir) {
-    return join(scopeRootDir, 'configured-clis');
-}
 /** Where substrate memory documents live per scope. Builtin memory is the
  *  special case — its own package dir (builtinMemoryRoot), since the builtin
  *  scope has no scopeRoot — mirroring viewsDir's builtin handling. User and

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

@@ -0,0 +1,193 @@
+import type { ScopeConfig } from '../types.js';
+export interface UserSettingDefinition<Key extends string = string> {
+    key: Key;
+    label: string;
+    description: string;
+    valueConstraint: string;
+    applies: string;
+    order: number;
+    format: (config: ScopeConfig) => string;
+    cycle: (config: ScopeConfig, delta: number) => void;
+    /** Mutate `config` from a CLI string, returning a user-facing validation error on failure. */
+    setFromString: (config: ScopeConfig, raw: string) => string | null;
+}
+/**
+ * Exhaustive settings-surface coverage for ScopeConfig. Primitive preferences
+ * are required by the type to define a Settings row; structured registries must
+ * name the specialized surface that owns them. Adding a config field therefore
+ * fails typecheck until its user-facing settings coverage is decided. The
+ * auto_update nested record is exhaustive for the same reason.
+ */
+export declare const CONFIG_SETTINGS_COVERAGE: {
+    schema_version: {
+        surface: "specialized";
+        owner: string;
+    };
+    marketplaces: {
+        surface: "specialized";
+        owner: string;
+    };
+    plugins: {
+        surface: "specialized";
+        owner: string;
+    };
+    auto_update: {
+        surface: "settings";
+        settings: {
+            crtr: {
+                key: "auto_update.crtr";
+                label: string;
+                description: string;
+                valueConstraint: string;
+                applies: string;
+                order: number;
+                format: (config: ScopeConfig) => "notify" | "apply" | "off";
+                cycle: (config: ScopeConfig, delta: number) => void;
+                setFromString: (config: ScopeConfig, raw: string) => "auto_update.crtr must be notify, apply, or false" | null;
+            };
+            content: {
+                key: "auto_update.content";
+                label: string;
+                description: string;
+                valueConstraint: string;
+                applies: string;
+                order: number;
+                format: (config: ScopeConfig) => "notify" | "apply" | "off";
+                cycle: (config: ScopeConfig, delta: number) => void;
+                setFromString: (config: ScopeConfig, raw: string) => "auto_update.content must be notify, apply, or false" | null;
+            };
+            interval_hours: {
+                key: "auto_update.interval_hours";
+                label: string;
+                description: string;
+                valueConstraint: string;
+                applies: string;
+                order: number;
+                format: (config: ScopeConfig) => string;
+                cycle: (config: ScopeConfig, delta: number) => void;
+                setFromString: (config: ScopeConfig, raw: string) => string | null;
+            };
+        };
+    };
+    max_panes_per_window: {
+        surface: "settings";
+        setting: {
+            key: "max_panes_per_window";
+            label: string;
+            description: string;
+            valueConstraint: string;
+            applies: string;
+            order: number;
+            format: (config: ScopeConfig) => string;
+            cycle: (config: ScopeConfig, delta: number) => void;
+            setFromString: (config: ScopeConfig, raw: string) => string | null;
+        };
+    };
+    auto_open_child_viewers: {
+        surface: "settings";
+        setting: {
+            key: "auto_open_child_viewers";
+            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;
+        };
+    };
+    brokerThresholds: {
+        surface: "specialized";
+        owner: string;
+    };
+    completion_bell: {
+        surface: "settings";
+        setting: {
+            key: "completion_bell";
+            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;
+        };
+    };
+    live_cycles: {
+        surface: "settings";
+        setting: {
+            key: "live_cycles";
+            label: string;
+            description: string;
+            valueConstraint: string;
+            applies: string;
+            order: number;
+            format: (config: ScopeConfig) => string;
+            cycle: (config: ScopeConfig, delta: number) => void;
+            setFromString: (config: ScopeConfig, raw: string) => string | null;
+        };
+    };
+    condensed_history: {
+        surface: "settings";
+        setting: {
+            key: "condensed_history";
+            label: string;
+            description: string;
+            valueConstraint: string;
+            applies: string;
+            order: number;
+            format: (config: ScopeConfig) => "user" | "none" | "agent" | "both";
+            cycle: (config: ScopeConfig, delta: number) => void;
+            setFromString: (config: ScopeConfig, raw: string) => string | null;
+        };
+    };
+    fold_finished_tools: {
+        surface: "settings";
+        setting: {
+            key: "fold_finished_tools";
+            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;
+    };
+    modelLadders: {
+        surface: "specialized";
+        owner: string;
+    };
+    modelRoutes: {
+        surface: "specialized";
+        owner: string;
+    };
+    modelRouting: {
+        surface: "specialized";
+        owner: string;
+    };
+    kinds: {
+        surface: "specialized";
+        owner: string;
+    };
+    remoteCanvas: {
+        surface: "specialized";
+        owner: string;
+    };
+    spawnEnv: {
+        surface: "specialized";
+        owner: string;
+    };
+};
+/** The exhaustive top-level key list used by config persistence and help. */
+export declare const SCOPE_CONFIG_KEYS: (keyof ScopeConfig)[];
+/** The single row registry shared by `sys setup` and `sys config set`. */
+export declare const USER_SETTINGS: readonly UserSettingDefinition[];
+export declare function findUserSetting(key: string): UserSettingDefinition | undefined;

package/dist/core/user-settings.js

@@ -0,0 +1,252 @@
+import { CONDENSED_HISTORY_MODES } from '../types.js';
+function cycleChoice(choices, current, delta) {
+    const index = choices.indexOf(current);
+    const start = index >= 0 ? index : 0;
+    return choices[(start + delta + choices.length) % choices.length];
+}
+function cycleNumber(choices, current, delta) {
+    const exact = choices.indexOf(current);
+    if (exact >= 0)
+        return choices[(exact + delta + choices.length) % choices.length];
+    if (delta >= 0)
+        return choices.find((choice) => choice > current) ?? choices[0];
+    return [...choices].reverse().find((choice) => choice < current) ?? choices[choices.length - 1];
+}
+function booleanFromString(raw, key) {
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    return `${key} must be true or false`;
+}
+function nonNegativeIntegerFromString(raw, key) {
+    if (!/^\d+$/.test(raw))
+        return `${key} must be an integer >= 0`;
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value))
+        return `${key} must be an integer >= 0`;
+    return value;
+}
+function positiveIntegerFromString(raw, key) {
+    const value = nonNegativeIntegerFromString(raw, key);
+    if (typeof value === 'string' || value < 1)
+        return `${key} must be an integer >= 1`;
+    return value;
+}
+const AUTO_UPDATE_MODES = [false, 'notify', 'apply'];
+const UPDATE_INTERVAL_HOURS = [0, 1, 6, 12, 24, 48, 72, 168];
+const MAX_PANES = [1, 2, 3, 4, 5, 6, 8, 10, 12];
+const LIVE_CYCLES = [1, 2, 3, 4, 5, 6];
+/**
+ * Exhaustive settings-surface coverage for ScopeConfig. Primitive preferences
+ * are required by the type to define a Settings row; structured registries must
+ * name the specialized surface that owns them. Adding a config field therefore
+ * fails typecheck until its user-facing settings coverage is decided. The
+ * auto_update nested record is exhaustive for the same reason.
+ */
+export const CONFIG_SETTINGS_COVERAGE = {
+    schema_version: { surface: 'specialized', owner: 'internal schema migration' },
+    marketplaces: { surface: 'specialized', owner: 'Plugins and pkg market commands' },
+    plugins: { surface: 'specialized', owner: 'Plugins tab and pkg plugin commands' },
+    auto_update: {
+        surface: 'settings',
+        settings: {
+            crtr: {
+                key: 'auto_update.crtr',
+                label: 'crouter updates',
+                description: 'Notify about crouter releases, install them automatically, or turn checks off.',
+                valueConstraint: 'true|false|notify|apply; true stores notify',
+                applies: 'Applies on the next crouter command.',
+                order: 70,
+                format: (config) => config.auto_update.crtr === false ? 'off' : config.auto_update.crtr,
+                cycle: (config, delta) => { config.auto_update.crtr = cycleChoice(AUTO_UPDATE_MODES, config.auto_update.crtr, delta); },
+                setFromString: (config, raw) => {
+                    const value = raw === 'true' ? 'notify' : raw;
+                    if (value !== 'notify' && value !== 'apply' && value !== 'false')
+                        return 'auto_update.crtr must be notify, apply, or false';
+                    config.auto_update.crtr = value === 'false' ? false : value;
+                    return null;
+                },
+            },
+            content: {
+                key: 'auto_update.content',
+                label: 'Content updates',
+                description: 'Notify about plugin and marketplace updates, apply them automatically, or turn checks off.',
+                valueConstraint: 'false|notify|apply',
+                applies: 'Applies on the next crouter command.',
+                order: 80,
+                format: (config) => config.auto_update.content === false ? 'off' : config.auto_update.content,
+                cycle: (config, delta) => { config.auto_update.content = cycleChoice(AUTO_UPDATE_MODES, config.auto_update.content, delta); },
+                setFromString: (config, raw) => {
+                    if (raw !== 'notify' && raw !== 'apply' && raw !== 'false')
+                        return 'auto_update.content must be notify, apply, or false';
+                    config.auto_update.content = raw === 'false' ? false : raw;
+                    return null;
+                },
+            },
+            interval_hours: {
+                key: 'auto_update.interval_hours',
+                label: 'Update interval',
+                description: 'Minimum hours between automatic update checks. Zero checks on every command.',
+                valueConstraint: 'integer >= 0',
+                applies: 'Applies on the next crouter command.',
+                order: 90,
+                format: (config) => `${config.auto_update.interval_hours}h`,
+                cycle: (config, delta) => { config.auto_update.interval_hours = cycleNumber(UPDATE_INTERVAL_HOURS, config.auto_update.interval_hours, delta); },
+                setFromString: (config, raw) => {
+                    const value = nonNegativeIntegerFromString(raw, 'auto_update.interval_hours');
+                    if (typeof value === 'string')
+                        return value;
+                    config.auto_update.interval_hours = value;
+                    return null;
+                },
+            },
+        },
+    },
+    max_panes_per_window: {
+        surface: 'settings',
+        setting: {
+            key: 'max_panes_per_window',
+            label: 'Maximum panes',
+            description: 'Maximum human-review panes placed in one tmux window before using another window.',
+            valueConstraint: 'integer >= 1',
+            applies: 'Applies to the next pane placement.',
+            order: 20,
+            format: (config) => String(config.max_panes_per_window),
+            cycle: (config, delta) => { config.max_panes_per_window = cycleNumber(MAX_PANES, config.max_panes_per_window, delta); },
+            setFromString: (config, raw) => {
+                const value = positiveIntegerFromString(raw, 'max_panes_per_window');
+                if (typeof value === 'string')
+                    return value;
+                config.max_panes_per_window = value;
+                return null;
+            },
+        },
+    },
+    auto_open_child_viewers: {
+        surface: 'settings',
+        setting: {
+            key: 'auto_open_child_viewers',
+            label: 'Open child panes',
+            description: 'Open each managed child beside its watched parent. Off keeps new children running in the background.',
+            valueConstraint: 'true|false',
+            applies: 'Applies to the next managed child created; independent roots still open their attended viewer.',
+            order: 10,
+            format: (config) => config.auto_open_child_viewers ? 'on' : 'off',
+            cycle: (config) => { config.auto_open_child_viewers = !config.auto_open_child_viewers; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'auto_open_child_viewers');
+                if (typeof value === 'string')
+                    return value;
+                config.auto_open_child_viewers = value;
+                return null;
+            },
+        },
+    },
+    brokerThresholds: { surface: 'specialized', owner: 'Broker limits tab' },
+    completion_bell: {
+        surface: 'settings',
+        setting: {
+            key: 'completion_bell',
+            label: 'Completion bell',
+            description: 'Ring a short sound when the node in an attached viewer finishes a turn.',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next turn end.',
+            order: 40,
+            format: (config) => config.completion_bell ? 'on' : 'off',
+            cycle: (config) => { config.completion_bell = !config.completion_bell; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'completion_bell');
+                if (typeof value === 'string')
+                    return value;
+                config.completion_bell = value;
+                return null;
+            },
+        },
+    },
+    live_cycles: {
+        surface: 'settings',
+        setting: {
+            key: 'live_cycles',
+            label: 'Live cycles',
+            description: 'Trailing refresh cycles rendered at full fidelity; older cycles condense to text.',
+            valueConstraint: 'integer >= 1',
+            applies: 'Applies on the next attach.',
+            order: 50,
+            format: (config) => String(config.live_cycles),
+            cycle: (config, delta) => { config.live_cycles = cycleNumber(LIVE_CYCLES, config.live_cycles, delta); },
+            setFromString: (config, raw) => {
+                const value = positiveIntegerFromString(raw, 'live_cycles');
+                if (typeof value === 'string')
+                    return value;
+                config.live_cycles = value;
+                return null;
+            },
+        },
+    },
+    condensed_history: {
+        surface: 'settings',
+        setting: {
+            key: 'condensed_history',
+            label: 'Condensed history',
+            description: 'Messages retained from condensed cycles. Tool calls are never kept.',
+            valueConstraint: CONDENSED_HISTORY_MODES.join('|'),
+            applies: 'Applies on the next attach.',
+            order: 60,
+            format: (config) => config.condensed_history,
+            cycle: (config, delta) => { config.condensed_history = cycleChoice(CONDENSED_HISTORY_MODES, config.condensed_history, delta); },
+            setFromString: (config, raw) => {
+                if (!CONDENSED_HISTORY_MODES.includes(raw))
+                    return `condensed_history must be one of: ${CONDENSED_HISTORY_MODES.join('|')}`;
+                config.condensed_history = raw;
+                return null;
+            },
+        },
+    },
+    fold_finished_tools: {
+        surface: 'settings',
+        setting: {
+            key: 'fold_finished_tools',
+            label: 'Fold finished tools',
+            description: 'Fold every settled tool call to its call line. Toggle live with /fold-tools.',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next attach.',
+            order: 30,
+            format: (config) => config.fold_finished_tools ? 'on' : 'off',
+            cycle: (config) => { config.fold_finished_tools = !config.fold_finished_tools; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'fold_finished_tools');
+                if (typeof value === 'string')
+                    return value;
+                config.fold_finished_tools = value;
+                return null;
+            },
+        },
+    },
+    keybindings: { surface: 'specialized', owner: 'Keybindings tab' },
+    modelLadders: { surface: 'specialized', owner: 'Models tab' },
+    modelRoutes: { surface: 'specialized', owner: 'Models route declarations' },
+    modelRouting: { surface: 'specialized', owner: 'Models route declarations' },
+    kinds: { surface: 'specialized', owner: 'Models tab and kind registry' },
+    remoteCanvas: { surface: 'specialized', owner: 'canvas config commands' },
+    spawnEnv: { surface: 'specialized', owner: 'spawn environment allow-list' },
+};
+/** The exhaustive top-level key list used by config persistence and help. */
+export const SCOPE_CONFIG_KEYS = Object.keys(CONFIG_SETTINGS_COVERAGE);
+function collectUserSettings() {
+    const out = [];
+    for (const coverage of Object.values(CONFIG_SETTINGS_COVERAGE)) {
+        if (coverage.surface !== 'settings')
+            continue;
+        if ('setting' in coverage)
+            out.push(coverage.setting);
+        else
+            out.push(...Object.values(coverage.settings));
+    }
+    return out.sort((a, b) => a.order - b.order);
+}
+/** The single row registry shared by `sys setup` and `sys config set`. */
+export const USER_SETTINGS = collectUserSettings();
+export function findUserSetting(key) {
+    return USER_SETTINGS.find((setting) => setting.key === key);
+}

package/dist/index.d.ts

@@ -21,3 +21,7 @@ export type { CrtrError } from './core/errors.js';
 export { nowIso } from './core/fs-utils.js';
 export { validateOperationId, buildEnvelope, operationIdContext, errorClassCodes, serializeEventRecord, errorClassFromError, } from './core/events/index.js';
 export type { BuildEnvelopeInput, ErrorClass, ErrorClassCode, ErrorClassHints, EventComponent, EventEnvelope, EventError, EventField, EventLevel, EventOutcome, OperationId, OperationIdContext, RetryDisposition, } from './core/events/index.js';
+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 { SUBTREE_NAMES } from './build-root.js';

package/dist/index.js

@@ -42,3 +42,6 @@ export { nowIso } from './core/fs-utils.js';
 // Pure envelope helpers only. Local source binding and canonical append remain
 // internal so package consumers cannot select crouter runtime file paths.
 export { validateOperationId, buildEnvelope, operationIdContext, errorClassCodes, serializeEventRecord, errorClassFromError, } from './core/events/index.js';
+// ── Command-manifest compatibility ───────────────────────────────────────
+export { validateCommandManifest } from './core/command-manifests/manifest.js';
+export { SUBTREE_NAMES } from './build-root.js';

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

@@ -44,6 +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';
 /** 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'];
@@ -696,12 +697,12 @@ export function registerCanvasStophook(pi) {
             const at = contextTokens !== null ? steerBand(contextTokens) : null;
             if (at !== null && !firedBands.has(at)) {
                 firedBands.add(at);
-                const note = `[crtr] ${steerNote(at, lifecycle, mode)}`;
+                const note = formatContextNudge(steerNote(at, lifecycle, mode));
                 if (runContinues) {
                     pi.sendUserMessage(note, { deliverAs: 'steer' });
                 }
                 else {
-                    pi.sendMessage({ customType: 'crtr-context-nudge', content: note, display: true }, { deliverAs: 'nextTurn' });
+                    pi.sendMessage({ customType: CONTEXT_NUDGE_CUSTOM_TYPE, content: note, display: true }, { deliverAs: 'nextTurn' });
                 }
             }
         }

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

@@ -0,0 +1,34 @@
+/** Custom message carrying the node's session-start bearings. */
+export declare const CONTEXT_INTRO_CUSTOM_TYPE = "crtr-context";
+/** Custom message carrying an ambient situational-context update. */
+export declare const SITUATIONAL_CONTEXT_CUSTOM_TYPE = "crtr-situational-context";
+/** Custom message used when a context-size nudge waits for the next turn. */
+export declare const CONTEXT_NUDGE_CUSTOM_TYPE = "crtr-context-nudge";
+/** Opening text of a fresh-revive kickoff user message. */
+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 ~";
+export interface GeneratedContextMessageLike {
+    role?: string;
+    customType?: string;
+    content?: unknown;
+}
+export interface GeneratedContextPresentation {
+    kind: 'bearings' | 'situational' | 'revive' | 'context-nudge' | 'inbox';
+    label: string;
+    summary: string;
+    body: string;
+}
+/** Plain text from a generated message's string or text-block content. */
+export declare function generatedContextText(message: GeneratedContextMessageLike): string;
+/** Format the runtime's visible context-size guidance. */
+export declare function formatContextNudge(note: string): string;
+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.
+ */
+export declare function generatedContextPresentation(message: GeneratedContextMessageLike): GeneratedContextPresentation | null;

package/dist/shared/generated-context.js

@@ -0,0 +1,98 @@
+// 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
+// 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.
+/** 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. */
+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 ~';
+/** Plain text from a generated message's string or text-block content. */
+export function generatedContextText(message) {
+    if (typeof message.content === 'string')
+        return message.content;
+    if (!Array.isArray(message.content))
+        return '';
+    return message.content
+        .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.
+const INBOX_HEADER_RE = /^From ([a-z0-9]+(?:-[a-z0-9]+)+|system|human) — (\d+) update/m;
+export function isInboxDigest(text) {
+    return INBOX_HEADER_RE.test(text);
+}
+export function extractInboxSender(text) {
+    return INBOX_HEADER_RE.exec(text)?.[1] ?? null;
+}
+function inboxSummary(body) {
+    const headers = [...body.matchAll(/^From ([a-z0-9]+(?:-[a-z0-9]+)+|system|human) — (\d+) update/gm)];
+    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}`;
+    }
+    return `${updates} updates from ${headers.length} senders`;
+}
+/**
+ * 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.
+ */
+export function generatedContextPresentation(message) {
+    const body = generatedContextText(message);
+    if (message.role === 'custom') {
+        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 };
+    }
+    return null;
+}