@north-light/crouter 0.3.164 → 0.3.166

package/dist/core/runtime/tmux.js

@@ -11,7 +11,7 @@ import { spawnSync } from 'node:child_process';
 import { readFileSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { BINDING_CATALOG, formatGesture, resolveUserKeybindings, } from '../keybindings/index.js';
+import { ATTACH_CONTROL_BINDINGS, BINDING_CATALOG, encodeAttachControlInput, formatGesture, resolveUserKeybindings, } from '../keybindings/index.js';
 import { bundledPiCommandForShell } from './pi-cli.js';
 import { surfaceTmuxStyleArgs } from './surface-bg.js';
 import { inboxToggleTmuxCommand } from '@crouton-kit/humanloop';
@@ -554,6 +554,13 @@ function menuActionCommand(action) {
                 menu: `send-keys -t '#{pane_id}' ${shellQuote(keys)}`,
             };
         }
+        case 'literal-input': {
+            const input = escapeTmuxFormats(action.input);
+            return {
+                argv: ['send-keys', '-l', input],
+                menu: `send-keys -l -t '#{pane_id}' ${shellQuote(input)}`,
+            };
+        }
         case 'command': return chordCommand(action.run);
         case 'direct': return directCommand(action.run);
         case 'popup': return chordCommand(action.run, true);
@@ -640,6 +647,22 @@ function resolvedMenuActions(bindings) {
         if (entry !== undefined)
             entries.set(id, entry);
     }
+    for (const { menuId, actionId } of ATTACH_CONTROL_BINDINGS) {
+        const definition = BINDING_CATALOG.find((candidate) => candidate.id === actionId);
+        if (definition === undefined)
+            throw new Error(`missing attach binding definition ${actionId}`);
+        entries.set(menuId, {
+            description: definition.name.toLowerCase(),
+            action: { kind: 'literal-input', input: encodeAttachControlInput(actionId) },
+        });
+    }
+    const attachItems = boundMenuItems(ATTACH_CONTROL_BINDINGS.map(({ menuId }) => menuId), entries, bindings);
+    if (attachItems.length > 0) {
+        entries.set('crtr.tmux.menu.attach', {
+            description: 'attach ›',
+            action: { kind: 'submenu', title: ' attach ', items: attachItems },
+        });
+    }
     const showItems = boundMenuItems([
         'crtr.tmux.menu.metadata',
         'crtr.tmux.menu.context',
@@ -687,6 +710,7 @@ function menuItems(bindings, entries) {
         'crtr.tmux.menu.view-settings',
     ]));
     addGroup('Current node', boundItems([
+        'crtr.tmux.menu.attach',
         'crtr.tmux.menu.background-bash',
         'crtr.tmux.menu.file-review',
         'crtr.tmux.menu.pin',
@@ -865,8 +889,11 @@ export function installTmuxBindings(bindings = resolveUserKeybindings()) {
     for (const definition of BINDING_CATALOG) {
         if (definition.pair?.field !== 'menu')
             continue;
+        const paired = BINDING_CATALOG.find((candidate) => candidate.id === definition.pair?.pairedId);
+        if (paired?.pair?.field !== 'global')
+            continue;
         const menuId = definition.id;
-        const globalId = definition.pair.pairedId;
+        const globalId = paired.id;
         const entry = menuActions.get(menuId);
         const command = entry === undefined ? null : menuActionCommand(entry.action);
         if (command === null)

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/prompts/review.js

@@ -48,8 +48,10 @@ seams to fall between — skip it for self-contained specs.
 
 For larger specs touching established patterns, optionally spawn a Task
 agent (\`general-purpose\`, \`sonnet\`) to cross-check the spec's design
-against \`CLAUDE.md\` / \`.claude/rules/*.md\` and the files it references,
-looking for contradictions with project conventions. Skip for small specs.
+against the applicable project memory documents (discover them with
+\`crtr memory list\` and load them with \`crtr memory read\`) and the files they
+reference, looking for contradictions with project conventions. Skip for small
+specs.
 
 ## Calibration
 

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;