@crouton-kit/crouter 0.3.36 → 0.3.38

package/dist/commands/push.js

@@ -1,10 +1,8 @@
-// `crtr push` + `crtr feed` — the one verb up the graph, and its read side.
+// `crtr push` — the one verb up the graph.
 //
 //   crtr push update [body]   — routine progress to subscribers
 //   crtr push urgent [body]   — force-wake subscribers
 //   crtr push final  [body]   — finish: write result, mark node done, close window
-//   crtr feed read            — drain the caller's (or a named) inbox into a digest
-//   crtr feed peek            — live state of the nodes below you, cursor untouched
 //
 // "push" is THE verb a node uses to talk to its managers; the tier is the
 // subcommand. The caller's node is resolved from CRTR_NODE_ID (injected by the
@@ -13,8 +11,7 @@
 import { defineBranch, defineLeaf } from '../core/command.js';
 import { InputError, readStdinRaw } from '../core/io.js';
 import { push } from '../core/feed/feed.js';
-import { getNode, subscribersOf, subscriptionsOf, fullName } from '../core/canvas/index.js';
-import { readInboxSince, readInboxEntryById, readCursor, writeCursor, coalesce, } from '../core/feed/inbox.js';
+import { getNode, subscribersOf } from '../core/canvas/index.js';
 function requireCallerNode() {
     const id = process.env['CRTR_NODE_ID'];
     if (id === undefined || id.trim() === '') {
@@ -142,213 +139,6 @@ function makeTierLeaf(tier) {
     });
 }
 // ---------------------------------------------------------------------------
-// feed read — drain the inbox
-// ---------------------------------------------------------------------------
-const feedReadLeaf = defineLeaf({
-    name: 'read',
-    description: 'drain unread pointers into a digest',
-    whenToUse: 'you want to PROACTIVELY poll what the nodes you subscribe to — your children and anyone you follow — have reported before the watcher wakes you, draining the unread pointers in your inbox into one coalesced digest. NOTE: when a subscriber push wakes you, that wake message already IS this digest (the watcher drains your inbox to wake you), so don\'t re-run feed read to "open" it — dereference the refs in the digest you already have. Reach for it to poll before the next wake, to inspect another node\'s inbox, or to re-read the whole history after the cursor has advanced.',
-    help: {
-        name: 'feed read',
-        summary: 'drain unread inbox pointers for the caller (or a named node) into a compact digest',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node whose inbox to read. Defaults to CRTR_NODE_ID. Use to inspect a worker\'s inbox as an orchestrator.' },
-            { kind: 'flag', name: 'all', type: 'bool', required: false, default: false, constraint: 'Ignore the cursor and return everything from the start — use to re-read history the wake already drained.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'Node whose inbox was read.' },
-            { name: 'digest', type: 'string', required: true, constraint: 'Coalesced digest — paste directly into a prompt.' },
-            { name: 'entries', type: 'object[]', required: true, constraint: 'Raw InboxEntry objects.' },
-            { name: 'cursor', type: 'string', required: true, constraint: 'New cursor ISO written after draining.' },
-            { name: 'inbox_total', type: 'number', required: true, constraint: 'Total entries in the inbox (read + unread). Distinguishes a never-used inbox from one already drained at wake.' },
-        ],
-        outputKind: 'object',
-        effects: ['Advances nodes/<nodeId>/inbox.jsonl.cursor.', 'Read-only on inbox.jsonl itself.'],
-    },
-    run: async (input) => {
-        const nodeId = typeof input['node'] === 'string' && input['node'].trim() !== ''
-            ? input['node'].trim()
-            : requireCallerNode();
-        const cursor = input['all'] === true ? undefined : readCursor(nodeId);
-        const entries = readInboxSince(nodeId, cursor);
-        const total = readInboxSince(nodeId, undefined).length;
-        const newCursor = entries.length > 0 ? entries[entries.length - 1].ts : cursor ?? new Date().toISOString();
-        writeCursor(nodeId, newCursor);
-        return {
-            node_id: nodeId,
-            digest: coalesce(entries),
-            entries: entries,
-            cursor: newCursor,
-            inbox_total: total,
-        };
-    },
-    render: (r) => {
-        const n = Array.isArray(r['entries']) ? r['entries'].length : 0;
-        const rawDigest = typeof r['digest'] === 'string' ? r['digest'] : '';
-        if (n > 0 && rawDigest.trim() !== '') {
-            return `${n} unread pointer${n === 1 ? '' : 's'} drained from ${r['node_id']}'s inbox.\n\n${rawDigest.trim()}`;
-        }
-        // Empty drain has two distinct causes — say which, honestly. An inbox that
-        // already holds entries was drained when the watcher woke you (the wake
-        // message WAS that digest); a never-used inbox simply has nothing yet.
-        const total = typeof r['inbox_total'] === 'number' ? r['inbox_total'] : 0;
-        const explanation = total > 0
-            ? 'Your inbox is not empty, though. The watcher drains your inbox to wake you, so the entries you already saw in your wake message are the same ones you would read here; that is why this is empty. Re-read the whole history (full message bodies included) with `crtr feed read --all`, or dereference the refs from the wake digest you already have.'
-            : 'Your inbox is empty — nothing has arrived from your subscriptions yet. Expected while workers run: a worker that has not pushed yet leaves no pointer, and it will wake you the moment it does. The wake is automatic — just continue your own work or end your turn. (Reach for `crtr feed peek` only if you suspect a worker died, not to confirm a live one.)';
-        return `No unread pointers for ${r['node_id']} (unread=0).\n\n${explanation}`;
-    },
-});
-// ---------------------------------------------------------------------------
-// feed message — read one inbox message's full body back from the jsonl
-// ---------------------------------------------------------------------------
-const feedMessageLeaf = defineLeaf({
-    name: 'message',
-    description: 'print one inbox entry\'s full body by id',
-    whenToUse: 'a digest line ended in `… (clipped — full message: crtr feed message <id>)` — run it to read the rest of that direct message. The full body lives in your inbox.jsonl; this prints it verbatim by the entry\'s short id. Read-only: it does NOT advance your inbox cursor.',
-    help: {
-        name: 'feed message',
-        summary: 'print the full body of one inbox entry, addressed by the short id shown in a clipped digest line',
-        params: [
-            { kind: 'positional', name: 'id', required: true, constraint: 'The short entry id from the digest\'s `… (full message: …)` pointer.' },
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Whose inbox to read. Defaults to CRTR_NODE_ID; pass to read another node\'s inbox as an orchestrator.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'Node whose inbox was read.' },
-            { name: 'id', type: 'string', required: true, constraint: 'The requested entry id.' },
-            { name: 'found', type: 'boolean', required: true, constraint: 'True when an entry with that id exists.' },
-            { name: 'from', type: 'string', required: false, constraint: 'Sender of the message, when found.' },
-            { name: 'body', type: 'string', required: false, constraint: 'Full message body, when found.' },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: scans inbox.jsonl. Does NOT advance the cursor.'],
-    },
-    run: async (input) => {
-        const nodeId = typeof input['node'] === 'string' && input['node'].trim() !== ''
-            ? input['node'].trim()
-            : requireCallerNode();
-        const id = input['id'].trim();
-        const entry = readInboxEntryById(nodeId, id);
-        if (entry === undefined) {
-            return { node_id: nodeId, id, found: false };
-        }
-        const body = typeof entry.data?.['body'] === 'string' ? entry.data['body'] : entry.label;
-        return { node_id: nodeId, id, found: true, from: entry.from ?? 'system', body };
-    },
-    render: (r) => {
-        if (r['found'] !== true) {
-            return `No inbox entry with id ${r['id']} in ${r['node_id']}'s inbox. Re-read the digest with \`crtr feed read --all\`, or list raw entries to find the right id.`;
-        }
-        return `Full message ${r['id']} (from ${r['from']}):\n\n${r['body']}`;
-    },
-});
-// ---------------------------------------------------------------------------
-// feed peek — live state of the nodes below you, without draining anything
-// ---------------------------------------------------------------------------
-const STATUS_GLYPH = {
-    active: '●', idle: '○', done: '✓', dead: '✗', canceled: '⊘',
-};
-/** Coarse "Nm ago" age from an ISO timestamp — enough to read staleness at a glance. */
-function fmtAge(iso) {
-    const ms = Date.now() - new Date(iso).getTime();
-    if (!Number.isFinite(ms) || ms < 0)
-        return 'just now';
-    const s = Math.floor(ms / 1000);
-    if (s < 60)
-        return `${s}s ago`;
-    const m = Math.floor(s / 60);
-    if (m < 60)
-        return `${m}m ago`;
-    const h = Math.floor(m / 60);
-    if (h < 24)
-        return `${h}h ago`;
-    return `${Math.floor(h / 24)}d ago`;
-}
-const feedPeekLeaf = defineLeaf({
-    name: 'peek',
-    description: 'live state of the nodes below you, without draining anything',
-    whenToUse: 'you are about to end a turn and want to confirm your workers are running before you chill — peek shows every node you subscribe to (the workers below you) with its live status (working/idle/done/dead), how long it has run, its cycle count, and whether it has pushed yet, plus a one-line verdict on whether it is safe to yield. Non-destructive: it never advances your inbox cursor, so a later `feed read` still delivers undrained reports. Reach for it exactly when the feed reads empty but you have outstanding children — that empty feed is EXPECTED (a worker that has not pushed yet contributes no inbox pointer); peek confirms those workers are alive and running async so you can stop and wait instead of polling.',
-    help: {
-        name: 'feed peek',
-        summary: 'show the live state of every node you subscribe to (the workers below you) with a yield-or-not verdict; never drains the inbox',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node whose subscriptions to peek. Defaults to CRTR_NODE_ID. Use to inspect a worker\'s downstream as an orchestrator.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'Node that was peeked.' },
-            { name: 'unread', type: 'number', required: true, constraint: 'Inbox pointers not yet drained by `feed read`.' },
-            { name: 'children', type: 'object[]', required: true, constraint: 'One row per subscription: {node_id, kind, name, status, active, spawned, cycles, last_push}.' },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: reads canvas.db edges + node metas + inbox.jsonl.', 'Does NOT advance the inbox cursor — peek leaves the feed intact for a later `feed read`.'],
-    },
-    run: async (input) => {
-        const nodeId = typeof input['node'] === 'string' && input['node'].trim() !== ''
-            ? input['node'].trim()
-            : requireCallerNode();
-        // Read the WHOLE inbox to find each child's last push, but with no cursor
-        // write — peek is non-destructive by contract. `unread` is computed from the
-        // persisted cursor so peek can tell you a `feed read` would deliver something.
-        const all = readInboxSince(nodeId, undefined);
-        const unread = readInboxSince(nodeId, readCursor(nodeId)).length;
-        const children = subscriptionsOf(nodeId).map((s) => {
-            const n = getNode(s.node_id);
-            const fromMe = all.filter((e) => e.from === s.node_id);
-            const last = fromMe.length > 0 ? fromMe[fromMe.length - 1] : undefined;
-            return {
-                node_id: s.node_id,
-                kind: n?.kind ?? '?',
-                name: n !== null ? fullName(n) : s.node_id,
-                status: n?.status ?? 'dead',
-                active: s.active,
-                spawned: n?.created ?? s.created,
-                cycles: n?.cycles ?? 0,
-                last_push: last !== undefined
-                    ? { kind: last.kind, ts: last.ts, ref: last.ref ?? null, label: last.label }
-                    : null,
-            };
-        });
-        return { node_id: nodeId, unread, children };
-    },
-    render: (r) => {
-        const id = r['node_id'];
-        const unread = r['unread'] ?? 0;
-        const kids = r['children'] ?? [];
-        if (kids.length === 0) {
-            const tail = unread > 0
-                ? `${unread} unread report${unread === 1 ? '' : 's'} sit in your inbox — run \`crtr feed read\` to absorb ${unread === 1 ? 'it' : 'them'}.`
-                : 'If you spawned workers, they have finished and detached, or you never subscribed. Nothing will wake you.';
-            return `No nodes below you (0 subscriptions, ${unread} unread). ${tail}`;
-        }
-        const working = kids.filter((k) => k.status === 'active' || k.status === 'idle');
-        const liveWaking = working.filter((k) => k.active); // active sub to a live node = it will wake me
-        const done = kids.filter((k) => k.status === 'done' || k.status === 'canceled');
-        const dead = kids.filter((k) => k.status === 'dead');
-        let line;
-        if (dead.length > 0) {
-            line = `\u26a0 ${dead.length} below you ${dead.length === 1 ? 'is' : 'are'} dead and will NOT wake you. Inspect with \`crtr node inspect show <id>\`, then re-delegate or proceed without ${dead.length === 1 ? 'it' : 'them'}.`;
-        }
-        else if (liveWaking.length > 0) {
-            line = `Safe to yield \u2014 ${liveWaking.length} worker${liveWaking.length === 1 ? '' : 's'} running async will wake you on the next push. Nothing to do now; end your turn and chill.`;
-        }
-        else if (unread > 0) {
-            line = `Nothing still running, but ${unread} unread report${unread === 1 ? '' : 's'} \u2014 run \`crtr feed read\` to absorb ${unread === 1 ? 'it' : 'them'}, then continue or finish.`;
-        }
-        else {
-            line = 'Everything below you has finished and been drained \u2014 nothing is running. Continue your own work, or `crtr push final` to finish.';
-        }
-        const rows = kids.map((k) => {
-            const sub = k.active ? '' : ' (passive)';
-            const push = k.last_push !== null
-                ? `pushed ${fmtAge(k.last_push.ts)} [${k.last_push.kind}]${k.last_push.ref !== null ? ` ref:${k.last_push.ref}` : ''}`
-                : 'no push yet';
-            const glyph = STATUS_GLYPH[k.status] ?? '?';
-            return `- ${glyph} ${k.name}${sub} (${k.node_id}) \u00b7 ${k.kind} \u00b7 ${k.status} \u00b7 spawned ${fmtAge(k.spawned)} \u00b7 cyc ${k.cycles} \u00b7 ${push}`;
-        }).join('\n');
-        const summary = `${kids.length} node${kids.length === 1 ? '' : 's'} below you — ${working.length} working, ${done.length} done, ${dead.length} dead, ${unread} unread:`;
-        return `${line}\n\n${summary}\n${rows}`;
-    },
-});
-// ---------------------------------------------------------------------------
 // Registration
 // ---------------------------------------------------------------------------
 export function registerPush() {
@@ -367,19 +157,3 @@ export function registerPush() {
         children: [makeTierLeaf('update'), makeTierLeaf('urgent'), makeTierLeaf('final')],
     });
 }
-export function registerFeed() {
-    return defineBranch({
-        name: 'feed',
-        rootEntry: {
-            concept: 'the read side of the spine — pointers your subscriptions have pushed',
-            desc: 'drain your inbox feed into a digest',
-            useWhen: 'catching up on what the nodes you subscribe to have reported',
-        },
-        help: {
-            name: 'feed',
-            summary: 'read the per-node inbox feed',
-            model: 'Each node has an inbox.jsonl that accumulates ~30-token pointers from publishers it subscribes to. The watcher drains this inbox to wake you, so the wake message you receive ALREADY IS the coalesced digest \u2014 dereference the reports that matter by reading their ref paths (a push carries a ref; a direct message inlines a bounded body preview, and when that clips it ends in `crtr feed message <id>` to read the full text back from the jsonl). `feed read` is for PROACTIVELY polling before a wake (it advances the cursor); after a wake it reads empty because the cursor already moved \u2014 use `--all` to re-read history. An empty feed is normal while workers run \u2014 a worker that has not pushed leaves no pointer \u2014 so use `feed peek` to see the live state of the nodes below you (and whether to yield) without draining anything.',
-        },
-        children: [feedReadLeaf, feedMessageLeaf, feedPeekLeaf],
-    });
-}

package/dist/commands/revive.js

@@ -164,8 +164,8 @@ export const reviveLeaf = defineLeaf({
                     next: 'Use --now only on a node the canvas shows as hanging (⚠). For a routine relaunch, omit --now.',
                 });
             }
-            // Mirror the daemon's faultRecoveryVerdict, which never kills a BUSY engine: a
-            // node mid-turn (busy marker present) is making progress, not wedged —
+            // The daemon never kills a BUSY engine (its verdict paths all return 'leave'
+            // on a live busy marker): a node mid-turn is making progress, not wedged —
             // refuse rather than SIGTERM it mid-flight.
             if (isBusy(nodeId)) {
                 throw new InputError({

package/dist/commands/{canvas-tmux-spread.js → surface-tmux-spread.js}

@@ -1,7 +1,10 @@
-// `crtr canvas tmux-spread <node>` — explode the local subtree into a tiled grid.
+// `crtr surface tmux-spread <node>` — explode the local subtree into a tiled grid.
 //
-// Bound by the alt+c → `e` chord (config: prefixBinds['e'].run = "canvas
-// tmux-spread {self}"). It "expands" the graph you are watching: the caller's
+// A genuine viewer-placement decision (tile every live viewer in a subtree into
+// one window), so it lives under `surface` alongside view/attach/workspace/web.
+// Also bound to the `/graph` view's `e` key (src/pi-extensions/canvas-nav.ts),
+// which shells this leaf directly for the cursor node. It "expands" the graph
+// you are watching: the caller's
 // own viewer pane is broken out into a BRAND-NEW window, then a surface-attach
 // viewer pane is tiled beside it for every broker-alive node in the local
 // subtree (ancestry root → self → descendants), so the user lands on a single
@@ -48,16 +51,16 @@ function brokerAlive(meta) {
 export const tmuxSpreadLeaf = defineLeaf({
     name: 'tmux-spread',
     description: 'break the caller\'s pane into a new window and tile a viewer for every broker-alive node in the local subtree',
-    whenToUse: 'you want the whole live subtree you are watching on one tiled tmux window at once — bound to the alt+c → e chord; rarely run by hand',
+    whenToUse: 'you want the whole live subtree you are watching on one tiled tmux window at once, instead of hunting down each node\'s viewer by hand — also bound to the `/graph` view\'s `e` key',
     help: {
-        name: 'canvas tmux-spread',
+        name: 'surface tmux-spread',
         summary: 'Explode the local subtree into a tiled grid: break the caller\'s viewer pane into a brand-new window, then tile a surface-attach viewer pane beside it for every broker-alive node (status active/idle + live pi_pid) in the ancestry-root subtree, most-recently-active first, capped at 8 panes',
         params: [
             {
                 kind: 'positional',
                 name: 'node',
                 required: true,
-                constraint: 'The spread anchor (self) — its ancestry root + descendants define the subtree to tile. The alt+c chord passes {self}.',
+                constraint: 'The spread anchor (self) — its ancestry root + descendants define the subtree to tile. Passed as {self} by the `/graph` view\'s `e` key.',
             },
             {
                 kind: 'flag',

package/dist/commands/surface.js

@@ -8,6 +8,7 @@ import { registerView } from './view.js';
 import { registerWorkspace } from './workspace.js';
 import { registerWeb } from '../clients/web/web-cmd.js';
 import { registerAttach } from '../clients/attach/attach-cmd.js';
+import { tmuxSpreadLeaf } from './surface-tmux-spread.js';
 function namespaceForSurface(node) {
     node.help.name = `surface ${node.help.name}`;
     if (node.kind === 'branch') {
@@ -36,8 +37,8 @@ export function registerSurface() {
         help: {
             name: 'surface',
             summary: 'open and manage screen-facing surfaces',
-            model: 'Four entrypoints share the screen-facing space. `view` hosts a standalone raw-ANSI surface in tmux; `attach` connects this pane to a node broker; `workspace` lays out the left rail plus chat pane in one tmux window; `web` serves the browser shell and broker relay. Pick the family by host and layout, then choose the leaf that matches the action.',
+            model: 'Five entrypoints share the screen-facing space. `view` hosts a standalone raw-ANSI surface in tmux; `attach` connects this pane to a node broker; `workspace` lays out the left rail plus chat pane in one tmux window; `web` serves the browser shell and broker relay; `tmux-spread` tiles a viewer for every live node in a local subtree into one new window. Pick the family by host and layout, then choose the leaf that matches the action.',
         },
-        children: [view, attach, workspace, web],
+        children: [view, attach, workspace, web, tmuxSpreadLeaf],
     });
 }

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/daemon.d.ts

@@ -0,0 +1,2 @@
+import type { BranchDef } from '../../core/command.js';
+export declare const daemonBranch: BranchDef;

package/dist/commands/{daemon.js → sys/daemon.js}

@@ -1,4 +1,4 @@
-// `crtr canvas daemon` — thin supervisor daemon management.
+// `crtr sys daemon` — thin supervisor daemon management.
 //
 // The daemon (crtrd) polls active+idle nodes and handles engine-container exit
 // (a tmux pane or a headless broker process):
@@ -6,10 +6,10 @@
 //   • refresh-yield (intent=refresh) → fresh respawn
 //
 // This subtree starts, checks, and stops the daemon process.
-import { defineLeaf, defineBranch } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { spawnDaemon } from '../daemon/manage.js';
-import { readPidfile, isPidAlive } from '../daemon/crtrd.js';
+import { defineLeaf, defineBranch } from '../../core/command.js';
+import { InputError } from '../../core/io.js';
+import { spawnDaemon } from '../../daemon/manage.js';
+import { readPidfile, isPidAlive } from '../../daemon/crtrd.js';
 // ---------------------------------------------------------------------------
 // daemon start
 // ---------------------------------------------------------------------------
@@ -18,7 +18,7 @@ const daemonStart = defineLeaf({
     description: 'start the daemon in the background',
     whenToUse: 'bringing the crtrd supervisor up for the first time in a session so node window-exits get handled (no-op if it is already running)',
     help: {
-        name: 'canvas daemon start',
+        name: 'sys daemon start',
         summary: 'start the crtrd supervisor daemon in the background (no-op if already running)',
         params: [],
         output: [
@@ -43,9 +43,9 @@ const daemonStart = defineLeaf({
 const daemonStatus = defineLeaf({
     name: 'status',
     description: 'check whether the daemon is running',
-    whenToUse: 'checking whether the crtrd supervisor is running — e.g. confirming supervision is up before relying on auto-revive',
+    whenToUse: 'operator/dev diagnostic — probing whether the crtrd supervisor process is alive while troubleshooting revive/supervision behavior',
     help: {
-        name: 'canvas daemon status',
+        name: 'sys daemon status',
         summary: 'check whether the crtrd supervisor daemon is currently running',
         params: [],
         output: [
@@ -71,7 +71,7 @@ const daemonStop = defineLeaf({
     description: 'stop the running daemon',
     whenToUse: 'shutting the crtrd supervisor down, ending auto-revival of nodes on window exit',
     help: {
-        name: 'canvas daemon stop',
+        name: 'sys daemon stop',
         summary: 'send SIGTERM to the crtrd supervisor daemon',
         params: [],
         output: [
@@ -100,16 +100,16 @@ const daemonStop = defineLeaf({
     },
 });
 // ---------------------------------------------------------------------------
-// Export — mounted under `crtr canvas`
+// Export — mounted under `crtr sys`
 // ---------------------------------------------------------------------------
 export const daemonBranch = defineBranch({
     name: 'daemon',
     description: 'manage the crtrd supervisor process',
     whenToUse: 'managing the crtrd supervisor that auto-revives nodes on window exit — start it, check its status, or stop it',
     help: {
-        name: 'canvas daemon',
+        name: 'sys daemon',
         summary: 'manage the crtrd canvas supervisor daemon',
-        model: 'crtrd is a thin background daemon that polls active+idle nodes and acts on window exit: crashed windows become dead; refresh-yield windows get a fresh respawn. It holds no orchestration logic — just process supervision.',
+        model: 'crtrd is a thin background daemon that polls active+idle nodes and acts on window exit: crashed windows become dead; refresh-yield windows get a fresh respawn. It holds no orchestration logic — just process supervision. start/stop/status are operator/dev self-management, not something a normal agent turn needs to check.',
     },
     children: [daemonStart, daemonStatus, daemonStop],
 });

package/dist/commands/sys/doctor.js

@@ -71,6 +71,7 @@ function faultRemediation(fault) {
         auth: 're-authenticate',
         protocol: 'fix the protocol mismatch',
         other: 'fix the underlying issue',
+        wedged: 'read `crtr memory read wedged-child-on-runaway-bash` and, if a runaway subprocess is to blame, kill the subprocess (not the node)',
     };
     const progress = fault.retry.disposition === 'auto'
         ? fault.retry.by === 'client'

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',