@crouton-kit/crouter 0.3.37 → 0.3.39

package/dist/commands/profile/show.js

@@ -0,0 +1,50 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { defineLeaf } from '../../core/command.js';
+import { loadProfileManifest, profileRoot } from '../../core/profiles/manifest.js';
+import { CONFIG_FILE } from '../../types.js';
+export const showLeaf = defineLeaf({
+    name: 'show',
+    description: "one profile's manifest in full",
+    whenToUse: "you need a profile's full project list, id, and timestamps — after `profile list` narrows to a name, or to inspect what a node's bearings named as its profile.",
+    help: {
+        name: 'profile show',
+        summary: "print one profile's manifest plus its on-disk path and config.json location",
+        params: [
+            {
+                kind: 'positional',
+                name: 'profile',
+                required: true,
+                constraint: 'Exact profile id, or a unique manifest name. An ambiguous name fails listing every matching id.',
+            },
+        ],
+        output: [
+            { name: 'profile_id', type: 'string', required: true, constraint: 'Stable directory id.' },
+            { name: 'name', type: 'string', required: true, constraint: 'Manifest name.' },
+            { name: 'projects', type: 'string[]', required: true, constraint: 'Absolute project directories, in manifest order.' },
+            { name: 'created_at', type: 'string', required: true, constraint: 'ISO 8601 creation timestamp.' },
+            { name: 'last_used_at', type: 'string | null', required: true, constraint: 'ISO 8601 timestamp of the most recent selection, or null if never selected.' },
+            { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the profile directory.' },
+            { name: 'config_path', type: 'string', required: true, constraint: 'Absolute path to the profile\'s config.json (hand-edited the same way as user/project config.json — no profile-specific editor verb exists).' },
+            { name: 'config_exists', type: 'boolean', required: true, constraint: 'Whether config.json exists at that path yet.' },
+            { name: 'follow_up', type: 'string', required: true, constraint: 'Concrete next commands.' },
+        ],
+        outputKind: 'object',
+        effects: ['None. Read-only.'],
+    },
+    run: async (input) => {
+        const { profileId, manifest } = loadProfileManifest(input['profile']);
+        const configPath = join(profileRoot(profileId), CONFIG_FILE);
+        return {
+            profile_id: profileId,
+            name: manifest.name,
+            projects: manifest.projects,
+            created_at: manifest.created_at,
+            last_used_at: manifest.last_used_at,
+            path: profileRoot(profileId),
+            config_path: configPath,
+            config_exists: existsSync(configPath),
+            follow_up: `Add a project with \`crtr profile add-project ${profileId} --dir <path>\`, or rename with \`crtr profile rename ${profileId} --name <name>\`.`,
+        };
+    },
+});

package/dist/commands/profile.d.ts

@@ -0,0 +1,2 @@
+import type { BranchDef } from '../core/command.js';
+export declare function registerProfile(): BranchDef;

package/dist/commands/profile.js

@@ -0,0 +1,33 @@
+// `crtr profile` subtree — the profile store (spec §2.1/§2.5): agent
+// identities defined at the user root, each owning a manifest naming project
+// directories plus its own memory store. Flat leaves; no sub-branches — 7
+// verbs fits the 5-7 hard cap.
+//
+// Every verb but `new`/`list` takes <profile> as an exact id OR a unique
+// manifest name (never two positionals: `add-project`/`remove-project` pair
+// <profile> with `--dir`, `rename` pairs it with `--name`, matching the
+// one-positional-per-leaf argv contract used across the whole tree).
+import { defineBranch } from '../core/command.js';
+import { newLeaf } from './profile/new.js';
+import { listLeaf } from './profile/list.js';
+import { showLeaf } from './profile/show.js';
+import { addProjectLeaf } from './profile/add-project.js';
+import { removeProjectLeaf } from './profile/remove-project.js';
+import { renameLeaf } from './profile/rename.js';
+import { deleteLeaf } from './profile/delete.js';
+export function registerProfile() {
+    return defineBranch({
+        name: 'profile',
+        rootEntry: {
+            concept: 'an agent identity defined at the user root — a manifest naming project directories plus its own memory store',
+            desc: 'create, inspect, and manage profiles',
+            useWhen: 'creating a new agent identity, inspecting or listing existing ones, or changing a profile\u2019s project purview or display name. Selecting a profile for a running node (`--profile`, startup selection) lives elsewhere; this family only manages the manifest.',
+        },
+        help: {
+            name: 'profile',
+            summary: 'create, inspect, and manage profiles \u2014 agent identities with their own project purview and memory store',
+            model: '`new` creates one from a name (+ at most one initial `--project`). `list` inventories every profile as JSONL. `show` prints one manifest in full. `add-project` / `remove-project` mutate the ordered project list after creation, including mid-session on an already-running profile. `rename` changes only the manifest name \u2014 the profile_id is stable across a rename. `delete` removes a profile\u2019s directory (manifest + its own memory store) entirely and does not touch the project directories it pointed at. Every verb but `new`/`list` takes <profile> as an exact id or a unique manifest name; an ambiguous name fails listing every matching id.',
+        },
+        children: [newLeaf, listLeaf, showLeaf, addProjectLeaf, removeProjectLeaf, renameLeaf, deleteLeaf],
+    });
+}

package/dist/commands/sys/config.js

@@ -13,7 +13,6 @@ const TOP_LEVEL_KEYS = new Set([
     'max_panes_per_window',
     'canvasNav',
     'modelLadders',
-    'personaStrengths',
 ]);
 const MODEL_PROVIDERS = new Set(['anthropic', 'openai']);
 const MODEL_STRENGTHS = new Set(['ultra', 'strong', 'medium', 'light']);
@@ -105,20 +104,6 @@ function setNestedValue(cfg, key, rawValue, value) {
         }
         throw usage(`unsupported key path for set: ${key}`);
     }
-    if (topKey === 'personaStrengths') {
-        if (parts.length !== 2) {
-            throw usage(`unsupported key path for set: ${key}`);
-        }
-        const persona = parts[1];
-        if (persona.trim() === '' || persona !== persona.trim()) {
-            throw usage(`personaStrengths.<persona-kind> must be a non-empty persona kind without leading or trailing whitespace`);
-        }
-        if (!isModelStrength(rawValue)) {
-            throw usage(`personaStrengths.<persona-kind> must be ultra, strong, medium, or light`);
-        }
-        cfg.personaStrengths[persona] = rawValue;
-        return;
-    }
     if (parts.length === 1) {
         cfg[topKey] = value;
         return;
@@ -136,12 +121,12 @@ function setNestedValue(cfg, key, rawValue, value) {
 const configGet = defineLeaf({
     name: 'get',
     description: 'read a config value by key',
-    whenToUse: 'you want to read a single config value by its dotted key — the current auto_update policy, max_panes_per_window, the canvasNav prefix key, model ladders, or persona strengths — optionally from a specific scope. Use sys config set instead to change a value, sys config path to locate the file for hand-editing.',
+    whenToUse: 'you want to read a single config value by its dotted key — the current auto_update policy, max_panes_per_window, the canvasNav prefix key, or model ladders — optionally from a specific scope. Use sys config set instead to change a value, sys config path to locate the file for hand-editing.',
     help: {
         name: 'sys config get',
         summary: 'read a config value by dotted key',
         params: [
-            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Top-level keys: auto_update, marketplaces, plugins, max_panes_per_window, canvasNav, modelLadders, personaStrengths (read whole; edit canvasNav.prefixBinds/graphBinds in config.json directly).' },
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Top-level keys: auto_update, marketplaces, plugins, max_panes_per_window, canvasNav, modelLadders (read whole; edit canvasNav.prefixBinds/graphBinds in config.json directly).' },
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to read from. Default: user.' },
         ],
         output: [
@@ -166,12 +151,12 @@ const configGet = defineLeaf({
 const configSet = defineLeaf({
     name: 'set',
     description: 'write a config value by key',
-    whenToUse: 'you want to change a crtr setting — flip auto_update.crtr or auto_update.content to notify, apply, or off, raise max_panes_per_window, rebind canvasNav.prefixKey, set model ladders, or map persona strengths — written to the user or project scope. Use sys config get instead to read a value; the canvasNav record tables are not settable here, so edit config.json directly (sys config path) for those.',
+    whenToUse: 'you want to change a crtr setting — flip auto_update.crtr or auto_update.content to notify, apply, or off, raise max_panes_per_window, rebind canvasNav.prefixKey, or set model ladders — written to the user or project scope. Use sys config get instead to read a value; the canvasNav record tables are not settable here, so edit config.json directly (sys config path) for those.',
     help: {
         name: 'sys config set',
         summary: 'write a config value by dotted key',
         params: [
-            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Supported: auto_update.crtr, auto_update.content, auto_update.interval_hours, max_panes_per_window, canvasNav.prefixKey, modelLadders.defaultProvider, modelLadders.<anthropic|openai>.<ultra|strong|medium|light>, personaStrengths.<persona-kind>. The canvasNav.prefixBinds/graphBinds record tables are not settable here — edit config.json directly (`crtr sys config path`).' },
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Supported: auto_update.crtr, auto_update.content, auto_update.interval_hours, max_panes_per_window, canvasNav.prefixKey, modelLadders.defaultProvider, modelLadders.<anthropic|openai>.<ultra|strong|medium|light>. The canvasNav.prefixBinds/graphBinds record tables are not settable here — edit config.json directly (`crtr sys config path`).' },
             { kind: 'flag', name: 'value', type: 'string', required: true, constraint: 'value VALUE — string, required. Stored as-is if quoted; coerced to number or boolean when unambiguous.' },
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to write to. Default: user.' },
         ],
@@ -240,10 +225,10 @@ const configPath = defineLeaf({
 export const configBranch = defineBranch({
     name: 'config',
     description: 'read and write configuration',
-    whenToUse: 'inspecting or changing crtr settings — read a value with sys config get, change one with sys config set (auto_update policy, max_panes_per_window, canvasNav.prefixKey, model ladders, persona strengths), or locate config.json with sys config path to hand-edit the record tables set cannot reach.',
+    whenToUse: 'inspecting or changing crtr settings — read a value with sys config get, change one with sys config set (auto_update policy, max_panes_per_window, canvasNav.prefixKey, model ladders), or locate config.json with sys config path to hand-edit the record tables set cannot reach.',
     help: {
         name: 'sys config',
-        summary: 'read and write crtr configuration, including model ladders and persona strengths',
+        summary: 'read and write crtr configuration, including model ladders',
     },
     children: [configGet, configSet, configPath],
 });

package/dist/commands/sys/prompt-review.js

@@ -3,8 +3,10 @@ import { join } from 'node:path';
 import { defineLeaf } from '../../core/command.js';
 import { InputError, readStdinRaw } from '../../core/io.js';
 import { workspaceRoot } from '../../core/artifact.js';
-import { availableKinds, kindWhenToUse, subPersonasFor } from '../../core/personas/index.js';
-import { resolvePromptReview } from '../../core/personas/resolve.js';
+import { getNode } from '../../core/canvas/index.js';
+import { readMergedLaunchConfig, subKindsAvailableTo } from '../../core/config.js';
+import { LAUNCH_SYSTEM_PROMPT } from '../../core/runtime/launch.js';
+import { renderPreferencesForSubject, renderKnowledgeBlock, scopeForCwd, spineDepth, profileNameFor, } from '../../core/substrate/index.js';
 function resolveLifecycle(mode, lifecycle) {
     if (lifecycle !== undefined)
         return lifecycle;
@@ -41,24 +43,47 @@ function parseBool(value, field, defaultValue) {
 function optionalString(value) {
     return typeof value === 'string' && value.trim() !== '' ? value : null;
 }
-function normaliseKindList() {
-    return availableKinds().map((kind) => ({ kind, whenToUse: kindWhenToUse(kind) }));
+function approxTokens(text) {
+    return Math.ceil(text.length / 4);
 }
-function normaliseSubPersonaList(kind) {
-    return subPersonasFor(kind).map((sub) => ({ kind: sub.kind, whenToUse: sub.whenToUse }));
+function topLevelKinds() {
+    const registry = readMergedLaunchConfig().kinds;
+    return Object.entries(registry)
+        .filter(([kind]) => !kind.includes('/'))
+        .map(([kind, cfg]) => ({ kind, whenToUse: cfg.whenToUse }))
+        .sort((a, b) => a.kind.localeCompare(b.kind));
+}
+function subKindsFor(kind) {
+    return subKindsAvailableTo(kind);
 }
 function reviewList() {
-    const kinds = normaliseKindList();
+    const kinds = topLevelKinds();
     const subPersonas = {};
     for (const { kind } of kinds)
-        subPersonas[kind] = normaliseSubPersonaList(kind);
+        subPersonas[kind] = subKindsFor(kind);
+    return { kinds, modes: ['base', 'orchestrator'], lifecycles: ['terminal', 'resident'], subPersonas };
+}
+function buildReviewSubject(kind, mode, lifecycle, hasManager, nodeId) {
+    const node = nodeId !== null ? getNode(nodeId) : null;
+    const cwd = node?.cwd ?? process.cwd();
     return {
-        kinds,
-        modes: ['base', 'orchestrator'],
-        lifecycles: ['terminal', 'resident'],
-        subPersonas,
+        kind,
+        mode,
+        lifecycle,
+        hasManager,
+        cwd,
+        scope: scopeForCwd(cwd),
+        orchestration: { depth: node !== null ? spineDepth(node.node_id) : 0 },
+        profile: profileNameFor(node?.profile_id),
     };
 }
+function spliceIntoScaffold(scaffold, block) {
+    const anchor = '\n\nGuidelines:';
+    const idx = scaffold.indexOf(anchor);
+    if (idx === -1)
+        return `${scaffold}\n\n${block}`;
+    return `${scaffold.slice(0, idx)}\n\n${block}${scaffold.slice(idx)}`;
+}
 function promptReviewPath() {
     const dir = workspaceRoot();
     const reviewsDir = join(dir, 'prompt-reviews');
@@ -118,14 +143,62 @@ function resolveDeck(input) {
     const mode = input['mode'] ?? 'base';
     const lifecycle = resolveLifecycle(mode, input['lifecycle']);
     const hasManager = parseBool(input['hasManager'], 'hasManager', true);
-    const node = optionalString(input['node']);
+    const nodeId = optionalString(input['node']);
     if (kind === undefined || kind.trim() === '') {
         throw new InputError({ error: 'missing_parameter', message: 'kind is required', field: 'kind', next: 'Pass --kind <kind> or use --list.' });
     }
-    return resolvePromptReview(kind, mode, {
-        lifecycle,
-        hasManager,
-    }, node ?? undefined);
+    const node = nodeId !== null ? getNode(nodeId) : null;
+    const subject = buildReviewSubject(kind, mode, lifecycle, hasManager, node?.node_id ?? null);
+    const { block, contentDocs, tree } = renderPreferencesForSubject(subject);
+    const layers = [
+        {
+            id: 'launch-scaffold', label: 'Launch scaffold', group: 'generated',
+            source: 'generated: launch scaffold', sourcePath: null, scope: 'generated',
+            included: true, condition: null, text: LAUNCH_SYSTEM_PROMPT,
+            tokens: approxTokens(LAUNCH_SYSTEM_PROMPT), chars: LAUNCH_SYSTEM_PROMPT.length,
+        },
+        ...contentDocs.map((d) => ({
+            id: d.name, label: d.name, group: 'substrate',
+            source: `memory: ${d.name}`, sourcePath: d.path, scope: d.scope,
+            included: true, condition: null, text: d.body,
+            tokens: approxTokens(d.body), chars: d.body.length,
+        })),
+    ];
+    if (tree !== '') {
+        layers.push({
+            id: 'preference-catalog', label: 'Preference catalog (routing entries)', group: 'substrate',
+            source: 'generated: preference catalog', sourcePath: null, scope: 'generated',
+            included: true, condition: null, text: tree, tokens: approxTokens(tree), chars: tree.length,
+        });
+    }
+    if (node !== null) {
+        const knowledge = renderKnowledgeBlock(node.node_id);
+        if (knowledge !== '') {
+            layers.push({
+                id: 'memory-knowledge', label: 'Memory (knowledge) — context message, not system prompt',
+                group: 'substrate', source: 'runtime-spliced', sourcePath: null, scope: 'runtime',
+                included: false, condition: 'session_start context message, not the system prompt',
+                text: knowledge, tokens: approxTokens(knowledge), chars: knowledge.length,
+            });
+        }
+    }
+    const assembled = spliceIntoScaffold(LAUNCH_SYSTEM_PROMPT, block);
+    const sources = [];
+    const seen = new Set();
+    for (const d of contentDocs) {
+        const key = `${d.scope}:${d.path}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        sources.push({ id: d.name, label: d.name, path: d.path, scope: d.scope });
+    }
+    return {
+        config: { kind, mode, lifecycle, hasManager, node: node?.node_id ?? null },
+        layers,
+        assembled,
+        total: { tokens: approxTokens(assembled), chars: assembled.length },
+        sources,
+    };
 }
 export const promptReviewLeaf = defineLeaf({
     name: 'prompt-review',

package/dist/core/canvas/canvas.js

@@ -21,7 +21,7 @@ import { ensureHome, ensureNodeDirs, nodeMetaPath, nodeDir, nodesRoot, jobDir, }
 /** The identity keys meta.json persists. Listed explicitly so no runtime field
  *  can ever leak onto disk even when a fully-hydrated NodeMeta is handed in. */
 const IDENTITY_KEYS = [
-    'node_id', 'name', 'description', 'cycles', 'created', 'cwd', 'host_kind', 'kind', 'mode',
+    'node_id', 'name', 'description', 'cycles', 'created', 'cwd', 'host_kind', 'profile_id', 'kind', 'mode',
     'lifecycle', 'persona_ack', 'parent', 'spawned_by', 'fork_from', 'passive_default',
     'pi_session_id', 'pi_session_file', 'model_override', 'launch',
 ];
@@ -101,13 +101,13 @@ function writeMeta(meta) {
  *  state. A fresh insert takes the schema defaults for runtime. */
 function upsertRow(meta) {
     openDb()
-        .prepare(`INSERT INTO nodes (node_id, name, kind, mode, lifecycle, cwd, host_kind, parent, created)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        .prepare(`INSERT INTO nodes (node_id, name, kind, mode, lifecycle, cwd, host_kind, profile_id, parent, created)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(node_id) DO UPDATE SET
          name=excluded.name, kind=excluded.kind, mode=excluded.mode,
          lifecycle=excluded.lifecycle, cwd=excluded.cwd, host_kind=excluded.host_kind,
-         parent=excluded.parent`)
-        .run(meta.node_id, meta.name, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.host_kind ?? null, meta.parent ?? null, meta.created);
+         profile_id=excluded.profile_id, parent=excluded.parent`)
+        .run(meta.node_id, meta.name, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.host_kind ?? null, meta.profile_id ?? null, meta.parent ?? null, meta.created);
 }
 /** Seed a node's row at BIRTH: identity columns + runtime columns taken from the
  *  incoming meta (defaults: status='active', the rest null). The only writer
@@ -116,17 +116,17 @@ function upsertRow(meta) {
 function seedRow(meta) {
     openDb()
         .prepare(`INSERT INTO nodes
-         (node_id, name, kind, mode, lifecycle, cwd, host_kind, parent, created,
+         (node_id, name, kind, mode, lifecycle, cwd, host_kind, profile_id, parent, created,
           status, intent, pi_pid, "window", tmux_session, pane)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(node_id) DO UPDATE SET
          name=excluded.name, kind=excluded.kind, mode=excluded.mode,
          lifecycle=excluded.lifecycle, cwd=excluded.cwd, host_kind=excluded.host_kind,
-         parent=excluded.parent,
+         profile_id=excluded.profile_id, parent=excluded.parent,
          status=excluded.status, intent=excluded.intent, pi_pid=excluded.pi_pid,
          "window"=excluded."window", tmux_session=excluded.tmux_session,
          pane=excluded.pane`)
-        .run(meta.node_id, meta.name, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.host_kind ?? null, meta.parent ?? null, meta.created, meta.status ?? 'active', meta.intent ?? null, meta.pi_pid ?? null, meta.window ?? null, meta.tmux_session ?? null, meta.pane ?? null);
+        .run(meta.node_id, meta.name, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.host_kind ?? null, meta.profile_id ?? null, meta.parent ?? null, meta.created, meta.status ?? 'active', meta.intent ?? null, meta.pi_pid ?? null, meta.window ?? null, meta.tmux_session ?? null, meta.pane ?? null);
 }
 function rowFrom(r) {
     return {
@@ -138,6 +138,7 @@ function rowFrom(r) {
         status: r['status'],
         cwd: r['cwd'],
         host_kind: r['host_kind'] ?? null,
+        profile_id: r['profile_id'] ?? null,
         parent: r['parent'] ?? null,
         created: r['created'],
         intent: r['intent'] ?? null,

package/dist/core/canvas/db.js

@@ -349,6 +349,16 @@ CREATE TABLE IF NOT EXISTS canvas_meta (
 );
 `);
 }
+/** v11 — additive identity column `profile_id`: the profile-directory id
+ *  (`<slug>-<id>`) a node runs under, chosen once at spawn (inherited from the
+ *  spawner, or `--profile`). Durable IDENTITY mirrored from meta.json like
+ *  `cwd`/`host_kind` (NOT runtime like `pane`), so it survives an index rebuild
+ *  via the `IDENTITY_KEYS`/`upsertRow` path. Defaults NULL (root/no-profile);
+ *  no data backfill. Additive, forward-only. */
+function addProfileIdColumn(db) {
+    const columns = nodeColumns(db);
+    addNodeColumnIfMissing(db, columns, 'profile_id', `ALTER TABLE nodes ADD COLUMN profile_id TEXT;`);
+}
 /** The ordered migration list. Index `i` is migration version `i + 1`; the db's
  *  `user_version` tracks how many have been applied. Append only. */
 export const MIGRATIONS = [
@@ -362,6 +372,7 @@ export const MIGRATIONS = [
     /* v8 */ addHostKindColumn,
     /* v9 */ migrateWakeupsToTriggers,
     /* v10 */ addCanvasMetaTable,
+    /* v11 */ addProfileIdColumn,
 ];
 /** Bring `db` up to the latest schema version. Reads `user_version`, runs each
  *  pending migration in order, and bumps `user_version` after each so the work

package/dist/core/canvas/history.js

@@ -404,6 +404,7 @@ export function nodeArtifacts(nodeId, types) {
         status: node.status,
         cwd: node.cwd,
         host_kind: node.host_kind ?? null,
+        profile_id: node.profile_id ?? null,
         parent: node.parent ?? null,
         created: node.created,
         intent: node.intent ?? null,

package/dist/core/canvas/types.d.ts

@@ -58,6 +58,13 @@ export interface NodeIdentity {
      *  `cwd`, re-derived on index rebuild), NOT live runtime like `pane`.
      *  NULL ⇒ 'tmux' (every pre-broker node). */
     host_kind?: 'tmux' | 'broker' | null;
+    /** The profile this node runs under, a stable profile-directory id
+     *  (`<slug>-<id>`, see `core/profiles/manifest.ts`). Durable IDENTITY mirrored
+     *  to the row (like `cwd`/`host_kind`), NOT re-derived by `rebuildIndex()` —
+     *  it is chosen once at spawn (inherited from the spawner, or `--profile`) and
+     *  is the runtime→resolver seam (`CRTR_PROFILE_ID`) the memory/gate substrate
+     *  reads. NULL for a root/no-profile node — never invent a literal root id. */
+    profile_id?: string | null;
     /** Role the node was born as: explore | developer | plan | review | general… */
     kind: string;
     mode: Mode;
@@ -161,6 +168,9 @@ export interface NodeRow {
     cwd: string;
     /** Which HOST launches + supervises this node; see NodeIdentity.host_kind. */
     host_kind: 'tmux' | 'broker' | null;
+    /** The profile this node runs under; see NodeIdentity.profile_id. NULL for a
+     *  root/no-profile node. */
+    profile_id: string | null;
     parent: string | null;
     created: string;
     /** Authoritative runtime columns (see NodeRuntime). */

package/dist/core/config.d.ts

@@ -1,4 +1,4 @@
-import type { Scope, ScopeConfig, ScopeState } from '../types.js';
+import type { Scope, ScopeConfig, ScopeState, KindConfig, ModelLaddersConfig } from '../types.js';
 export declare function configPath(scope: Scope): string | null;
 export declare function statePath(scope: Scope): string | null;
 export declare function readConfig(scope: Scope): ScopeConfig;
@@ -6,5 +6,48 @@ export declare function readState(scope: Scope): ScopeState;
 export declare function writeConfig(scope: Scope, config: ScopeConfig): void;
 export declare function writeState(scope: Scope, state: ScopeState): void;
 export declare function ensureScopeInitialized(scope: Scope, root: string): void;
+export interface MergedLaunchConfig {
+    kinds: Record<string, KindConfig>;
+    modelLadders: ModelLaddersConfig;
+}
+/** Merge launch knobs (`kinds`, `modelLadders`) across scopes in
+ *  project stack > profile > user > builtin precedence — the same precedence
+ *  order used for memory resolution. A kind or ladder cell declared at a
+ *  more-specific scope shadows the same key from a less-specific scope; the
+ *  project STACK (`findProjectScopeRoots` — every ancestor `.crouter/`,
+ *  widened by a selected profile's `projects`) layers nearest-root-strongest;
+ *  a key no scope declares falls through to the builtin default registry
+ *  (`defaultScopeConfig().kinds` / `.modelLadders`).
+ *
+ *  Layers RAW (un-defaulted) partial config per scope, not `readConfig(scope)`
+ *  — `readConfig` already fills in every default kind for a scope that
+ *  customizes even one, so naively overlaying two already-defaulted
+ *  `ScopeConfig.kinds` objects would let an untouched project-scope kind
+ *  (silently defaulted) clobber a real user-scope customization of that same
+ *  kind. Layering the raw partials avoids that.
+ *
+ *  Callers (launch, kind registry) go through this function rather than
+ *  `readConfig` directly, so `ScopeConfig.kinds`/`modelLadders`/tools/
+ *  extensions/`availableTo` all honor the same profile + multi-project
+ *  precedence. */
+export declare function readMergedLaunchConfig(): MergedLaunchConfig;
+/** The effective `KindConfig` for one full kind string (top-level, e.g.
+ *  `developer`, or sub-kind, e.g. `plan/reviewers/security`), across
+ *  project > user > builtin precedence. Returns `undefined` for a kind no
+ *  scope registers — existence is deliberately NOT validated here (kind
+ *  existence/launch-menu enumeration is a Phase 3 caller concern); this only
+ *  resolves the config for a kind the caller already knows about. */
+export declare function resolveKindConfig(kind: string): KindConfig | undefined;
+/** The sub-kinds available to spawn FROM a given top-level kind — every
+ *  registered sub-kind (full path contains `/`) whose `availableTo` (default:
+ *  its own top-level ancestor, e.g. `plan/reviewers/security` defaults to
+ *  `['plan']`) includes `kind` or `'*'`. The single source both `sys
+ *  prompt-review --list`'s `subPersonas` metadata and the live sub-persona
+ *  spawn-menu splice (`core/substrate/render.ts`) read, so the two can never
+ *  drift apart. Sorted by full kind name for stable rendering. */
+export declare function subKindsAvailableTo(kind: string): {
+    kind: string;
+    whenToUse: string;
+}[];
 export declare function updateConfig(scope: Scope, mutate: (cfg: ScopeConfig) => void): ScopeConfig;
 export declare function updateState(scope: Scope, mutate: (s: ScopeState) => void): ScopeState;