@north-light/crouter 0.3.173 → 0.3.175

package/dist/commands/node.js

@@ -1,2068 +1,14 @@
-// `crtr node` — create, inspect, message, connect, and manage canvas nodes.
-// Screen-facing node-viewer navigation lives under `crtr surface node`; reports
-// flow through `crtr push`, and scheduled commands live under `crtr cron`.
-import { defineLeaf, defineBranch } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { inboxHint } from '../core/keybindings/index.js';
-import { writeClipboardText } from '../core/clipboard-text.js';
-import { mark } from '../core/timing.js';
-import { displayMessage } from '../core/runtime/tmux-chrome.js';
-import { parseWhen } from '../core/wake.js';
-import { parseOutputSchemaValue } from '../core/runtime/structured-output.js';
-import { nodeSnapshotLeaf } from './node-snapshot.js';
-import { nodeTranscriptLeaf } from './node-transcript.js';
-import { nodeContextLeaf } from './node-context.js';
-import { nodeArtifactsLeaf } from './node-inspect-artifacts.js';
+// `crtr node` — create, inspect, message, and manage canvas nodes.
+import { defineBranch } from '../core/command.js';
+import { nodeNew } from './node/create.js';
+import { nodeInspect, nodeFork } from './node/inspect.js';
+import { nodeLifecycle, nodeConfig, nodePromote, nodeYield } from './node/lifecycle.js';
+import { nodeMessage } from './node/message.js';
+import { nodeWaitBranch } from './node/wait.js';
+import { nodeSubscription } from './node/subscription.js';
+import { nodeBash } from './node/bash.js';
+import { pyramidSlash } from './node/pyramid.js';
 import { nodeWorktreeBranch } from './node-worktree.js';
-import { nodeReviveLeaf } from './node-lifecycle-revive.js';
-// Pure tmux primitives (tmux.js is openDb-free) — routed through the sanctioned
-// placement-tmux seam (§5.1 lint: commands never import the tmux driver directly).
-import { shellQuote, currentTmux, renameWindow, displayPopup, windowOfPane, getPaneOption, setPaneOption, respawnPaneSync, closePane, listLivePanes, openNodeWindow, selectWindow, selectPane, switchClient, paneLocation, paneExists, splitWindow, selectLayout, ensureSession, } from '../core/runtime/placement-tmux.js';
-import { isPidAlive } from '../core/canvas/pid.js';
-import { fullName } from '../core/canvas/labels.js';
-import { contextDir } from '../core/canvas/paths.js';
-import { readMergedLaunchConfig } from '../core/config.js';
-import { loadProfileManifest } from '../core/profiles/manifest.js';
-import { profilesStateBlock } from '../core/profiles/state-block.js';
-import { stateBlock } from '../core/help.js';
-import { fuzzyMatch } from '../core/canvas/browse/model.js';
-import { loadPins, savePins } from '../core/canvas/browse/pins.js';
-import { existsSync, writeFileSync } from 'node:fs';
-import { activeBackgroundBashJobs, backgroundRunningBashJobs, bashJobPaths, formatBashElapsed, jobStartedAtMs, readJobPgid, tailJobLog } from '../core/bash-jobs.js';
-// The API seam — every canvas mutation/read routes through the daemon (B-1).
-import { cliClient, cliCanvasSource, ApiCanvasSource, rethrowAsCliError, getNodeOrNull } from './api-client.js';
-// Past this much context, an ORCHESTRATOR that spawns a managed child is better
-// off yielding than holding its fat window open for the child's result: the
-// child's finish revives it fresh against its roadmap, so a clean window absorbs
-// the result instead of this bloated one. Below the steering bands (130k+) on
-// purpose — catch it at spawn, before the window is critically full.
-const YIELD_NUDGE_THRESHOLD = 100_000;
-const STD_CHILD_FOLLOW_UP = "Do not wait, poll, or duplicate this child's assignment in your own context — there is no result to await, stopping will not strand you, and duplicated work wastes the delegated context. You're auto-subscribed, so its finish wakes you on its own. Two moves only: do other independent work right now, or stop and end your turn — the wake brings you back.";
-/** Decision road sign for a managed (non-root) child. Normally STD_CHILD_FOLLOW_UP,
- *  but when the SPAWNER is an orchestrator whose context has already grown past
- *  YIELD_NUDGE_THRESHOLD, steer it to yield now and let its fresh revive handle
- *  the child's result. */
-export async function childFollowUp(spawnerId) {
-    if (spawnerId === undefined || spawnerId === '')
-        return STD_CHILD_FOLLOW_UP;
-    const spawner = await getNodeOrNull(spawnerId);
-    if (spawner === null || spawner.mode !== 'orchestrator')
-        return STD_CHILD_FOLLOW_UP;
-    const ctxTokens = spawner.context_tokens ?? null;
-    if (ctxTokens === null || ctxTokens < YIELD_NUDGE_THRESHOLD)
-        return STD_CHILD_FOLLOW_UP;
-    const k = Math.round(ctxTokens / 1000);
-    return `Child spawned — you're auto-subscribed, so its finish wakes you on its own; never wait, poll, or duplicate the child's assignment in your own context. But you're an orchestrator already carrying ~${k}k of context: rather than hold this window open for the result, checkpoint context/roadmap.md and \`crtr node yield\` now. Yielding ends this turn, and the child's completion then revives you fresh against your roadmap — let that clean revive absorb the result instead of this bloated context.`;
-}
-/** Validate a `--kind` against the installed personas; throws a listing InputError. */
-function assertKind(kind) {
-    const kinds = Object.keys(readMergedLaunchConfig().kinds).sort();
-    if (!kinds.includes(kind)) {
-        throw new InputError({ error: 'unknown_kind', message: `unknown kind: ${kind}`, field: 'kind', next: `Valid kinds: ${kinds.join(', ')}.` });
-    }
-}
-/** A live `<kinds count=N>` state element — one `<kind> — <whenToUse>` line per
- *  installed top-level persona kind (project > user > builtin), lazily built so
- *  it reflects the caller's cwd/project scope. Appended to `node new -h` and
- *  `node promote -h` so custom kinds appear in help. Soft-fails via the renderer.
- *
- *  Keep this block cheap and caller-agnostic: help should not depend on the
- *  running node's current persona env, which can lag after polymorph. Sub-kinds
- *  (e.g. `plan/reviewers/security`) are OMITTED here — `KindConfig.availableTo`
- *  defaults to the sub-kind's own top-level ancestor, and this generic block has
- *  no single ancestor to check against, so only an explicit `availableTo: ['*']`
- *  sub-kind (universally available) earns a place in this list. A direct launch
- *  by full sub-kind string is always valid regardless (visibility-only
- *  filtering) — discover the roster for a specific kind via
- *  `crtr sys prompt-review --list --kind <kind>`. */
-function kindsStateBlock() {
-    const registry = readMergedLaunchConfig().kinds;
-    const kinds = Object.keys(registry)
-        .filter((k) => {
-        const slash = k.indexOf('/');
-        if (slash === -1)
-            return true;
-        const availableTo = registry[k]?.availableTo ?? [k.slice(0, slash)];
-        return availableTo.includes('*');
-    })
-        .sort();
-    const lines = kinds
-        .map((k) => {
-        const w = registry[k]?.whenToUse ?? '';
-        return w ? `${k} — ${w}` : k;
-    })
-        .join('\n');
-    return stateBlock('kinds', { count: kinds.length }, lines);
-}
-// ---------------------------------------------------------------------------
-// Local viewer placement — pure tmux tails.
-//
-// The daemon owns the broker launch + the view.sock readiness wait (via
-// `ensureAttach`); these helpers own ONLY the on-screen viewer pane. A node's
-// ONE viewer is identified by scanning live panes for the `@crtr_node` tag a
-// `crtr surface attach` viewer self-sets on connect — the pure-tmux equivalent
-// of placement.ts's focus-rows DB registry (which the CLI can no longer reach).
-// ---------------------------------------------------------------------------
-/** Env handed to a viewer/root pane — passthrough CRTR_HOME so it targets the
- *  same canvas home as the caller. */
-function viewerEnv() {
-    const crtrHome = process.env['CRTR_HOME'];
-    return crtrHome !== undefined ? { CRTR_HOME: crtrHome } : {};
-}
-/** The live viewer pane for `nodeId` (the pane a surface-attach viewer tagged
- *  `@crtr_node`), or undefined. Pure tag scan over live panes. */
-function viewerPaneOf(nodeId) {
-    const panes = listLivePanes();
-    if (panes === null)
-        return undefined;
-    for (const pane of panes) {
-        if (getPaneOption(pane, '@crtr_node') === nodeId)
-            return pane;
-    }
-    return undefined;
-}
-/** Open a fresh surface-attach viewer SPLIT beside `callerPane` and rebalance
- *  its window to even side-by-side widths. Pure tmux. */
-function openBesideCaller(callerPane, nodeId, cwd, callerSession, revived) {
-    const opened = splitWindow(callerPane, { cwd, env: viewerEnv(), command: `crtr surface attach to ${nodeId}` });
-    if (opened === null)
-        return { focused: false, session: null, inPlace: false, revived };
-    const loc = paneLocation(opened);
-    if (loc !== null)
-        selectLayout(loc.window, 'even-horizontal');
-    selectPane(opened);
-    return { focused: true, session: loc?.session ?? callerSession, inPlace: false, revived };
-}
-/** Bring a node's ONE viewer forefront beside (or navigated to) the caller —
- *  the pure-tmux port of placement.ts `focus()`. The server (`ensureAttach`)
- *  owns the broker revive + the view.sock accept-wait; the `@crtr_node` pane tag
- *  is the viewer registry. crtr is tmux-only: no caller pane ⇒ not focused. */
-export async function focusViewer(nodeId, opts) {
-    const callerPane = opts.pane ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane;
-    if (callerPane === undefined || callerPane === '') {
-        return { focused: false, session: null, inPlace: false, revived: false };
-    }
-    // (a) Server ensures the broker engine is alive + its view.sock accepts.
-    const attach = await cliClient().ensureAttach(nodeId).catch(rethrowAsCliError);
-    const revived = attach.revived;
-    const callerSession = paneLocation(callerPane)?.session ?? null;
-    // (b0) --in-place → the caller pane BECOMES this node's viewer, replacing what
-    //      it showed. Must be driven from OUTSIDE that pane's process tree.
-    if (opts.inPlace === true) {
-        const priorNodeId = getPaneOption(callerPane, '@crtr_node');
-        const existing = viewerPaneOf(nodeId);
-        if (existing !== undefined && existing !== callerPane && paneExists(existing))
-            closePane(existing);
-        try {
-            setPaneOption(callerPane, '@crtr_node', '');
-        }
-        catch { /* best-effort */ }
-        const window = windowOfPane(callerPane);
-        const env = priorNodeId !== undefined && priorNodeId !== ''
-            ? { ...viewerEnv(), CRTR_ATTACH_ROSTER: priorNodeId }
-            : viewerEnv();
-        const ok = respawnPaneSync({ pane: callerPane, cwd: opts.cwd, env, command: `crtr surface attach to ${nodeId}` });
-        if (ok && window !== null)
-            renameWindow(window, opts.name);
-        return { focused: ok, session: callerSession, inPlace: true, revived };
-    }
-    // (b) --new-pane → always a fresh viewer beside the caller; drop any prior
-    //     viewer this node holds elsewhere (one viewer per node).
-    if (opts.newPane === true) {
-        const prior = viewerPaneOf(nodeId);
-        if (prior !== undefined && paneExists(prior))
-            closePane(prior);
-        return openBesideCaller(callerPane, nodeId, opts.cwd, callerSession, revived);
-    }
-    // (c) Reuse the node's existing tagged viewer wherever it already lives.
-    const existing = viewerPaneOf(nodeId);
-    if (existing !== undefined) {
-        const loc = paneLocation(existing);
-        if (loc !== null) {
-            switchClient(loc.session);
-            selectWindow(loc.session, loc.window);
-            selectPane(existing);
-            return { focused: true, session: loc.session, inPlace: true, revived };
-        }
-    }
-    // (d) No live viewer → open one beside the caller.
-    return openBesideCaller(callerPane, nodeId, opts.cwd, callerSession, revived);
-}
-/** Open a viewer for a freshly-spawned --root node in a FRESH WINDOW in the
- *  caller's current tmux session (the --root spawn-viewer path). Pure tmux; the
- *  broker is already launching server-side, so the attach pane self-polls the
- *  cold socket. Returns the opened window/session, empty when not in tmux. */
-function openSpawnViewer(nodeId, cwd, name) {
-    const loc = currentTmux();
-    const session = loc?.session;
-    if (session === undefined || session === '')
-        return {};
-    ensureSession(session, cwd);
-    const opened = openNodeWindow({ session, name, cwd, env: viewerEnv(), command: `crtr surface attach to ${nodeId}` });
-    if (opened === null)
-        return {};
-    selectWindow(session, opened.window);
-    selectPane(opened.pane);
-    return { window: opened.window, session };
-}
-// ---------------------------------------------------------------------------
-// node new — spawn a terminal worker as a detached headless broker under the root
-// ---------------------------------------------------------------------------
-const nodeCreationEngine = defineLeaf({
-    name: 'new',
-    description: 'create and start a node immediately',
-    whenToUse: 'you need a managed child or independent root to start immediately',
-    tier: 'important',
-    help: {
-        name: 'node new',
-        summary: 'create a node immediately and start its detached broker',
-        params: [
-            { kind: 'stdin', name: 'prompt', required: false, constraint: 'First user message. Required unless --no-kickoff is given.' },
-            { kind: 'flag', name: 'kind', type: 'string', required: false, default: 'general', constraint: 'Persona kind. The <kinds> list below names every top-level installable kind.' },
-            { kind: 'flag', name: 'mode', type: 'enum', choices: ['base', 'orchestrator'], required: false, default: 'base', constraint: 'Persona mode. base for hands-on work; orchestrator when the unit itself needs decomposition across children.' },
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Directory the node is pinned to. Defaults to the caller cwd.' },
-            { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Display name. Defaults to the kind.' },
-            { kind: 'flag', name: 'parent', type: 'string', required: false, constraint: 'Parent node id. Defaults to the calling node.' },
-            { kind: 'flag', name: 'node-id', type: 'string', required: false, constraint: 'Exact id for the new node; lowercase letters, digits, and hyphens only, at most 128 characters. Rejected if already present.' },
-            { kind: 'flag', name: 'root', type: 'bool', required: false, constraint: 'Spawn an independent resident root with no parent or subscription. Mutually exclusive with --worktree.' },
-            { kind: 'flag', name: 'worktree', type: 'string', required: false, constraint: 'Local base branch for a crouter-managed worktree for this child. Mutually exclusive with --root.' },
-            { kind: 'flag', name: 'fork-from', type: 'string', required: false, constraint: 'Fork the new node from an existing node id, absolute session path, or partial pi session uuid.' },
-            { kind: 'flag', name: 'model', type: 'string', required: false, constraint: 'Durable model override: provider/id, provider/tier, tier, or family alias.' },
-            { kind: 'flag', name: 'profile', type: 'string', required: false, constraint: 'Profile id or unique profile name. Omit to inherit the caller profile.' },
-            { kind: 'flag', name: 'situational-context', type: 'string', required: false, constraint: 'Hidden ambient context appended to injected bearings, never visible chat.' },
-            { kind: 'flag', name: 'no-kickoff', type: 'bool', required: false, constraint: 'With --root, start the broker and session idle without a first message or model turn. Mutually exclusive with a prompt and --mode orchestrator.' },
-            { kind: 'flag', name: 'output-schema', type: 'string', required: false, constraint: 'Path to a JSON Schema file, or inline JSON beginning with `{`. The node must submit a conforming result to finish.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'New node id.' },
-            { name: 'name', type: 'string', required: true, constraint: 'Display name.' },
-            { name: 'status', type: 'string', required: true, constraint: 'Always "active".' },
-            { name: 'window', type: 'string', required: false, constraint: 'tmux window id when a viewer opens.' },
-            { name: 'session', type: 'string', required: false, constraint: 'tmux session when a viewer opens.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Managed child: continue unrelated work or stop; its final report wakes you. Root: hand it off; no report wakes you.' },
-        ],
-        dynamicState: () => [kindsStateBlock(), profilesStateBlock()].join('\n'),
-        outputKind: 'object',
-        effects: [
-            'Creates nodes/<id>/ in the canvas home, indexes the node in canvas.db, and starts its detached broker engine.',
-            'A managed child creates an active parent subscription; --root creates an independent node with spawned_by provenance and no parent subscription.',
-            '--worktree creates a managed worktree. --output-schema writes nodes/<id>/output-schema.json. --no-kickoff starts an idle root without a first model turn.',
-            'An in-tmux root opens a viewer. When auto_open_child_viewers is true, a managed child opens beside a live spawner viewer; false leaves it running in the background.',
-        ],
-    },
-    run: async (input) => {
-        const prompt = input['prompt'] ?? '';
-        const noKickoff = input['noKickoff'] === true;
-        if (!noKickoff && prompt.trim() === '') {
-            throw new InputError({ error: 'empty_prompt', message: 'a prompt is required (stdin or positional)', next: 'Pipe a task on stdin or pass it as an argument, or pass --no-kickoff to spawn an idle node with none.' });
-        }
-        if (noKickoff && prompt.trim() !== '') {
-            throw new InputError({ error: 'no_kickoff_with_prompt', message: '--no-kickoff cannot be combined with a prompt', field: 'no-kickoff', next: 'Drop --no-kickoff, or drop the prompt.' });
-        }
-        const kind = input['kind'] ?? 'general';
-        const mode = (input['mode'] ?? 'base');
-        const cwd = input['cwd'] ?? process.cwd();
-        const name = input['name'];
-        const parent = input['parent'];
-        const root = input['root'] === true;
-        const worktreeBaseRaw = input['worktree'];
-        if (worktreeBaseRaw !== undefined && worktreeBaseRaw.trim() === '') {
-            throw new InputError({ error: 'worktree_base_required', message: '--worktree requires a base branch', field: 'worktree', next: 'Pass an existing local branch that landing can fast-forward.' });
-        }
-        const worktreeBase = worktreeBaseRaw?.trim();
-        const forkFrom = input['forkFrom'];
-        const modelSpec = input['model']?.trim();
-        if (modelSpec === '') {
-            throw new InputError({ error: 'empty_spec', message: 'a model spec is required', field: 'model', next: 'Pass a provider/id, provider/tier, tier, or family alias.' });
-        }
-        const profile = input['profile'];
-        const situationalContextRaw = input['situationalContext']?.trim();
-        const situationalContext = situationalContextRaw !== undefined && situationalContextRaw !== '' ? situationalContextRaw : undefined;
-        const outputSchemaParsed = parseOutputSchemaValue(input['outputSchema']);
-        const outputSchema = outputSchemaParsed !== null ? JSON.stringify(outputSchemaParsed) : null;
-        const nodeId = input['nodeId']?.trim();
-        if (root && worktreeBase !== undefined) {
-            throw new InputError({ error: 'worktree_root_conflict', message: '--worktree is mutually exclusive with --root', field: 'worktree', next: 'Drop either --root or --worktree.' });
-        }
-        if (noKickoff && !root) {
-            throw new InputError({ error: 'no_kickoff_requires_root', message: '--no-kickoff is only valid with --root', field: 'no-kickoff', next: 'Add --root, or drop --no-kickoff and provide a prompt.' });
-        }
-        if (noKickoff && mode === 'orchestrator') {
-            throw new InputError({ error: 'no_kickoff_orchestrator_unsupported', message: '--no-kickoff cannot be combined with --mode orchestrator', field: 'no-kickoff', next: 'Drop --no-kickoff and provide a prompt, or spawn in base mode.' });
-        }
-        const parentId = parent ?? process.env['CRTR_NODE_ID'];
-        mark('node_new.create_start', { root });
-        const detail = await cliClient().createNode({
-            kind,
-            mode,
-            cwd,
-            ...(name !== undefined ? { name } : {}),
-            prompt,
-            ...(root ? { root: true } : { parent: parentId ?? null }),
-            ...(worktreeBase !== undefined ? { worktree: worktreeBase } : {}),
-            ...(forkFrom !== undefined ? { fork_from: forkFrom } : {}),
-            ...(modelSpec !== undefined ? { model: modelSpec } : {}),
-            ...(profile !== undefined ? { profile } : {}),
-            ...(situationalContext !== undefined ? { situational_context: situationalContext } : {}),
-            ...(noKickoff ? { no_kickoff: true } : {}),
-            ...(outputSchema !== null ? { output_schema: outputSchema } : {}),
-            ...(nodeId !== undefined && nodeId !== '' ? { node_id: nodeId } : {}),
-            // A bare `--root --no-kickoff` create is exactly what the warm pool holds
-            // ready; every other shape is rejected server-side and cold-spawns.
-            ...(root ? { prefer_warm: true } : {}),
-        }).catch(rethrowAsCliError);
-        mark('node_new.node_created', { node: detail.node_id });
-        let placement = {};
-        if (root)
-            placement = openSpawnViewer(detail.node_id, detail.cwd, detail.name);
-        if (root)
-            mark('node_new.viewer_window_opened');
-        return {
-            node_id: detail.node_id,
-            name: detail.name,
-            window: placement.window,
-            session: placement.session,
-            status: detail.status,
-            follow_up: root
-                ? (noKickoff
-                    ? 'Independent root spawned idle. No kickoff turn ran; hand it off or attach and prompt it. No report wakes you.'
-                    : 'Independent root spawned. You are not subscribed, so its finish does not wake you; hand it off and move on.')
-                : await childFollowUp(parentId),
-        };
-    },
-    render: (r) => {
-        const win = r['window'] ? ` in window ${r['window']}` : '';
-        const lines = [`Spawned "${r['name']}" (${r['node_id']}) — ${r['status']}${win}.`];
-        if (r['session'])
-            lines.push(`- session: ${r['session']}`);
-        lines.push('', String(r['follow_up']));
-        return lines.join('\n');
-    },
-});
-function paramsFor(source, names) {
-    const selected = new Set(names);
-    return (source ?? []).filter((param) => selected.has(param.name));
-}
-function outputsFor(source, names) {
-    const selected = new Set(names);
-    return source.filter((field) => selected.has(field.name));
-}
-function constrainParams(params, constraints) {
-    return params.map((param) => constraints[param.name] === undefined ? param : { ...param, constraint: constraints[param.name] });
-}
-function constrainOutputs(outputs, constraints) {
-    return outputs.map((field) => constraints[field.name] === undefined ? field : { ...field, constraint: constraints[field.name] });
-}
-const nodeNew = defineLeaf({
-    name: 'new',
-    description: 'create and start a node immediately',
-    whenToUse: 'you need a managed child or independent root to start immediately',
-    tier: 'important',
-    help: {
-        ...nodeCreationEngine.help,
-        name: 'node new',
-        summary: 'create a node immediately and start its detached broker',
-        guide: undefined,
-        params: constrainParams(paramsFor(nodeCreationEngine.help.params, ['prompt', 'kind', 'mode', 'cwd', 'name', 'parent', 'node-id', 'root', 'worktree', 'fork-from', 'model', 'profile', 'situational-context', 'no-kickoff', 'output-schema']), {
-            prompt: 'First user message. Required unless --no-kickoff is given.',
-            cwd: 'Directory the node is pinned to. Defaults to the caller cwd.',
-            'node-id': 'Exact id for the new node; lowercase letters, digits, and hyphens only, at most 128 characters. Rejected if already present.',
-            'situational-context': 'Hidden ambient context appended to injected bearings, never visible chat.',
-            'no-kickoff': 'With --root, start the broker and session idle without a first message or model turn. Mutually exclusive with a prompt and --mode orchestrator.',
-            'output-schema': 'Path to a JSON Schema file, or inline JSON beginning with `{`. The node must submit a conforming result to finish.',
-            worktree: 'Local base branch for a crouter-managed worktree for this child. Mutually exclusive with --root.',
-        }),
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'New node id.' },
-            { name: 'name', type: 'string', required: true, constraint: 'Display name.' },
-            { name: 'status', type: 'string', required: true, constraint: 'Always "active".' },
-            { name: 'window', type: 'string', required: false, constraint: 'tmux window id when a viewer opens.' },
-            { name: 'session', type: 'string', required: false, constraint: 'tmux session when a viewer opens.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Managed child: continue unrelated work or stop; its final report wakes you. Root: hand it off; no report wakes you.' },
-        ],
-        effects: [
-            'Creates nodes/<id>/ in the canvas home, indexes the node in canvas.db, and starts its detached broker engine.',
-            'A managed child creates an active parent subscription; its pushes wake the parent. --root creates an independent node with spawned_by provenance and no parent subscription.',
-            '--worktree creates a managed worktree at ~/.crouter/canvas/worktrees/<node-id>/ on a new crtr/<node-id> branch. --output-schema writes nodes/<id>/output-schema.json. --no-kickoff starts an idle root without a first model turn.',
-            'An in-tmux root opens a viewer in the current tmux session. When auto_open_child_viewers is true, a managed child opens beside a live spawner viewer; false leaves it running in the background.'
-        ],
-    },
-    run: async (input, context) => {
-        const result = await nodeCreationEngine.run(input, context);
-        if (result === undefined)
-            return;
-        const { node_id, name, window, session, status, follow_up } = result;
-        return { node_id, name, window, session, status, follow_up };
-    },
-    render: nodeCreationEngine.render,
-});
-function requireNonBlankDiscriminant(input, name) {
-    const value = input[name];
-    if (value !== undefined && (typeof value !== 'string' || value.trim() === '')) {
-        const flag = name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-        throw new InputError({ error: 'empty_discriminant', message: `--${flag} must contain non-whitespace text`, received: typeof value === 'string' ? value : String(value), field: flag, next: `Pass a non-empty --${flag} value, or omit the flag.` });
-    }
-}
-// ---------------------------------------------------------------------------
-// node inspect list — the active canvas (or a status slice)
-// ---------------------------------------------------------------------------
-const nodeList = defineLeaf({
-    name: 'list',
-    description: 'list nodes on the canvas',
-    whenToUse: 'you want a flat roster of the nodes on the canvas, sliced by displayed name, status, kind, mode, lifecycle, profile, cwd, and graph scope (--under a node, for that node plus its subscription descendants). The filters AND together. Use `node inspect show` instead to drill into one node and its spine neighbors, `canvas dashboard` for the tree shape, and `canvas attention` to find nodes blocked on a human',
-    help: {
-        name: 'node inspect list',
-        summary: 'list nodes on the canvas, filtered by any combination of attribute slices and a graph-scope (--under) that AND together',
-        params: [
-            { kind: 'flag', name: 'status', type: 'string', required: false, constraint: 'Filter status (comma-separated for several; accepted values: active, idle, done, dead, canceled). NOTE: `active` means the engine process is live (never closed), NOT that the node is generating right now — an active node is usually dormant between turns. To tell working-vs-idle, check the pi session-file mtime or CPU, not status.' },
-            { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: 'Filter by persona kind (comma-separated for several). The <kinds> list below names every top-level installable kind; a sub-kind (e.g. plan/reviewers/security) filters too even though it is not listed.' },
-            { kind: 'flag', name: 'mode', type: 'string', required: false, constraint: 'Filter by mode (comma-separated for several; accepted values: base, orchestrator).' },
-            { kind: 'flag', name: 'lifecycle', type: 'string', required: false, constraint: 'Filter by lifecycle (comma-separated for several; accepted values: terminal, resident).' },
-            { kind: 'flag', name: 'profile', type: 'string', required: false, constraint: 'Filter by profile. On the local canvas, accepts an exact profile id or a unique manifest name from the <profiles> list below. Against a remote canvas, pass the exact profile id carried by its node rows.' },
-            { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Filter by the displayed node label (handle plus generated description) with the canvas browser’s case-insensitive fuzzy subsequence match.' },
-            { kind: 'flag', name: 'cwd', type: 'string', required: false, constraint: 'Filter to nodes pinned to this exact cwd (absolute path). Roster is canvas-wide (all cwds) by default.' },
-            { kind: 'flag', name: 'under', type: 'string', required: false, constraint: 'Graph scope: restrict to this node and its subscription descendants (the sub-DAG reachable downward — its reports, theirs, …). This is "one initiative / my subtree". ANDs with every attribute filter above, narrowing any of them to this subtree.' },
-            { kind: 'flag', name: 'canvas', type: 'string', required: false, constraint: 'Read from the named remote canvas target (see `crtr canvas config list`) instead of the local canvas. Overrides `crtr canvas use`.' },
-        ],
-        output: [
-            { name: 'nodes', type: 'object[]', required: true, constraint: 'Rows include {node_id, name, kind, mode, lifecycle, status, cwd, profile_id, parent, created}. `name` is the displayed node label searched by --name and shown in canvas views. `profile_id` is the stable profile-directory id (null only for historical no-profile nodes).' },
-        ],
-        outputKind: 'object',
-        dynamicState: () => [kindsStateBlock(), profilesStateBlock()].join('\n'),
-        effects: ['Read-only: lists nodes through the daemon API.'],
-    },
-    run: async (input) => {
-        const csv = (k) => {
-            const raw = input[k];
-            return raw !== undefined && raw !== '' ? raw.split(',').map((s) => s.trim()).filter((s) => s !== '') : undefined;
-        };
-        const status = csv('status');
-        const kinds = csv('kind');
-        const modes = csv('mode');
-        const lifecycles = csv('lifecycle');
-        const profile = input['profile'];
-        const name = input['name'];
-        const cwd = input['cwd'];
-        const under = input['under'];
-        // Profile names are local manifest state. A remote roster instead carries
-        // stable profile ids, which remain meaningful without mirroring manifests.
-        const canvasSource = cliCanvasSource({ canvasName: input['canvas'] });
-        const remote = !(canvasSource instanceof ApiCanvasSource);
-        const profileId = profile === undefined
-            ? undefined
-            : remote
-                ? profile
-                : loadProfileManifest(profile).profileId;
-        // Graph scope (--under): self + subscription descendants. Validate the anchor
-        // so a typo'd id is a structured error, not a silently-empty roster.
-        let scope;
-        if (under !== undefined && under !== '') {
-            if (await canvasSource.getNode(under).catch(rethrowAsCliError) === null) {
-                throw new InputError({ error: 'not_found', message: `no node: ${under}`, next: 'List nodes with `crtr node inspect list`, then pass a real id to --under.' });
-            }
-            scope = new Set([under, ...(await canvasSource.view(under))]);
-        }
-        const rows = (await canvasSource.listNodes(status !== undefined ? { status } : undefined).catch(rethrowAsCliError)).filter((row) => {
-            if (scope !== undefined && !scope.has(row.node_id))
-                return false;
-            if (kinds !== undefined && !kinds.includes(row.kind))
-                return false;
-            if (modes !== undefined && !modes.includes(row.mode))
-                return false;
-            if (lifecycles !== undefined && !lifecycles.includes(row.lifecycle))
-                return false;
-            if (profileId !== undefined && row.profile_id !== profileId)
-                return false;
-            if (cwd !== undefined && cwd !== '' && row.cwd !== cwd)
-                return false;
-            return true;
-        });
-        const namedRows = (await Promise.all(rows.map(async (row) => {
-            const meta = await canvasSource.getNode(row.node_id);
-            return { ...row, name: fullName(meta ?? row) };
-        }))).filter((row) => name === undefined || name === '' || fuzzyMatch(name, row.name));
-        // Fault diagnosis lives on the local canvas views, not this roster.
-        const nodes = namedRows;
-        return { nodes };
-    },
-});
-// ---------------------------------------------------------------------------
-// node inspect show — a node + its place in the spine
-// ---------------------------------------------------------------------------
-// Enrich a bare subscription edge with the neighbor's name/kind/status so a
-// debugger reads who a report/manager IS without a second `show` per id.
-async function enrichNeighborFromSource(source, ref) {
-    const n = await source.getNode(ref.node_id);
-    return {
-        node_id: ref.node_id,
-        name: n ? fullName(n) : '(missing)',
-        kind: n?.kind ?? '?',
-        status: n ? (n.intent ? `${n.status}/${n.intent}` : n.status) : '?',
-        active: ref.active,
-    };
-}
-/** Symbol-keyed marker set on a remote-passthrough `node inspect show` result so
- *  `render()` below can tell it came from a remote canvas without adding an
- *  enumerable field — `JSON.stringify` (the `--json` path) skips symbol keys,
- *  so this is invisible to machine output. */
-const REMOTE_SHOW_MARKER = Symbol('remote-show');
-const nodeShow = defineLeaf({
-    name: 'show',
-    description: 'show a node + its spine neighbors, artifacts, and drill-in pointers',
-    whenToUse: 'you want one node in depth — the debugging entrypoint: a glanceable meta slice, named spine neighbors, artifact and pending-cron counts, and exact drill-in paths. Use `node inspect list` for the flat roster or `canvas dashboard` for the whole-tree shape',
-    help: {
-        name: 'node inspect show',
-        summary: 'show a node in depth — meta slice, named neighbors, artifact/pending-cron counts, and drill-in pointers',
-        params: [
-            { kind: 'positional', name: 'node', required: true, constraint: 'Node id.' },
-            { kind: 'flag', name: 'canvas', type: 'string', required: false, constraint: 'Read from the named remote canvas target (see `crtr canvas config list`) instead of the local canvas. Overrides `crtr canvas use`.' },
-        ],
-        output: [
-            { name: 'node', type: 'object', required: true, constraint: 'The full node meta (system prompt + every telemetry field). The render surfaces a glanceable slice; `--json` carries the complete dump.' },
-            { name: 'reports', type: 'object[]', required: true, constraint: 'Who this node subscribes to (its reports/down), each enriched with {node_id, name, kind, status, active} — these are typically its spawned children.' },
-            { name: 'managers', type: 'object[]', required: true, constraint: 'Who subscribes to this node (its managers/up), same enriched shape.' },
-            { name: 'artifacts', type: 'object', required: true, constraint: 'Counts of what the node left on disk by corpus: {report, doc, roadmap}. Enumerate them with `node inspect artifacts <id>`.' },
-            { name: 'pending_crons', type: 'number', required: true, constraint: 'How many pending crons were created by this node. Inspect with `crtr cron list`.' },
-            { name: 'paths', type: 'object', required: true, constraint: 'Resolved on-disk locations: {context_dir, reports_dir, session_file} — read these directly to debug.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'The concrete next commands to drill deeper.' },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: reads the node, its edges and artifacts, and pending crons through crtrd.'],
-        // The node meta object inlines the full system prompt + every telemetry
-        // field — a machine-readable dump we suppress from the viewer preview; the
-        // render below surfaces only a glanceable slice. Same preview rationale as
-        // canvas snapshot / node inspect snapshot.
-        preview: { suppressOutput: true },
-    },
-    run: async (input) => {
-        const id = input['node'];
-        const canvasName = input['canvas'];
-        const canvasSource = cliCanvasSource({ canvasName });
-        // Remote branch: `node inspect show` already computes this exact
-        // {node, reports, managers, artifacts, pending_crons, paths, follow_up}
-        // shape in-guest — passthrough it verbatim rather than re-deriving
-        // artifacts/crons/paths from LOCAL disk (which would be meaningless for
-        // a remote node id). The `render` below works unchanged on either branch
-        // since it only reads generic fields off the returned object.
-        if (!(canvasSource instanceof ApiCanvasSource)) {
-            const passthrough = await canvasSource.rawShow(id);
-            if (passthrough === null) {
-                throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list --canvas <name>`.' });
-            }
-            const result = passthrough;
-            result[REMOTE_SHOW_MARKER] = true;
-            return result;
-        }
-        // Raw DTO carries paths + session file + edges the lossy NodeMeta projection
-        // drops; fetch it directly (a 404 maps to the clean not_found contract).
-        const node = await cliClient()
-            .getNode(id)
-            .catch((err) => rethrowAsCliError(err, 'List nodes with `crtr node inspect list`.'));
-        const reports = await Promise.all((await canvasSource.subscriptionsOf(id)).map((ref) => enrichNeighborFromSource(canvasSource, ref)));
-        const managers = await Promise.all((await canvasSource.subscribersOf(id)).map((ref) => enrichNeighborFromSource(canvasSource, ref)));
-        const arts = await cliClient().getArtifacts(id);
-        const artifacts = {
-            report: arts.artifacts.filter((a) => a.source.startsWith('report')).length,
-            doc: arts.artifacts.filter((a) => a.source === 'doc').length,
-            roadmap: arts.artifacts.filter((a) => a.source === 'roadmap').length,
-        };
-        const pending_crons = (await cliClient().listCrons().catch(rethrowAsCliError)).filter((cron) => cron.created_by === id).length;
-        const paths = {
-            context_dir: node.paths.context_dir,
-            reports_dir: node.paths.reports_dir,
-            session_file: node.pi_session_file ?? null,
-        };
-        // Auto-gathered drill-in pointers: the exact commands a debugger reaches for
-        // next, populated only when there is actually something behind them.
-        const hints = [];
-        const artTotal = artifacts.report + artifacts.doc + artifacts.roadmap;
-        if (artTotal > 0)
-            hints.push(`Read its ${artTotal} artifact(s): \`crtr node inspect artifacts ${id}\` → each ref feeds \`crtr canvas history read <ref>\`.`);
-        hints.push(`Browse its context + reports dirs (and its subscriptions') in nvim: \`crtr node inspect context ${id}\`.`);
-        if (paths.session_file)
-            hints.push(`Read the raw conversation transcript: ${paths.session_file}`);
-        hints.push(`On-disk context dir (ls/read directly): ${paths.context_dir}`);
-        if (pending_crons > 0)
-            hints.push(`It created ${pending_crons} pending cron(s): \`crtr cron list\`.`);
-        if (reports.length > 0)
-            hints.push(`Drill into a child/report: \`crtr node inspect show <node_id>\` (${reports.map((r) => r['node_id']).join(', ')}).`);
-        hints.push(`Full machine dump (system prompt + all telemetry): \`crtr --json node inspect show ${id}\`.`);
-        return { node, reports, managers, artifacts, pending_crons, paths, follow_up: hints.join('\n') };
-    },
-    render: (r) => {
-        const node = r['node'];
-        const id = String(node['node_id']);
-        const pid = node['pi_pid'];
-        const isRemoteShow = Boolean(r[REMOTE_SHOW_MARKER]);
-        const alive = isRemoteShow ? 'remote (liveness not checked locally)' : (isPidAlive(pid) ? 'alive' : 'dead');
-        const intent = node['intent'] ? `/${String(node['intent'])}` : '';
-        const parts = [];
-        // 1) Glanceable meta slice — the debug-critical fields, not the full dump.
-        parts.push(`# ${fullName(node)}  (${id})`);
-        const meta = [
-            `- kind/mode/lifecycle: ${node['kind']} / ${node['mode']} / ${node['lifecycle']}`,
-            `- status: ${node['status']}${intent}`,
-            `- broker pid: ${pid ?? '(none)'} — ${alive}`,
-            `- cwd: ${node['cwd']}`,
-            `- host: ${node['host_kind']}` + (node['profile_id'] ? ` · profile ${node['profile_id']}` : ''),
-            `- cycles: ${node['cycles']} · created ${node['created']}`,
-        ];
-        if (node['parent'])
-            meta.push(`- parent: ${node['parent']}`);
-        if (node['waiting_for'])
-            meta.push(`- waiting for message: ${node['waiting_for']}`);
-        parts.push(meta.join('\n'));
-        // 2) Neighbor tables (reports down, managers up), pre-enriched with names.
-        const table = (label, rows) => {
-            if (rows.length === 0)
-                return `${label}: none`;
-            const cols = ['node_id', 'name', 'kind', 'status', 'active'];
-            const head = `| ${cols.join(' | ')} |`;
-            const sep = `| ${cols.map(() => '---').join(' | ')} |`;
-            const body = rows.map((row) => `| ${cols.map((c) => String(row[c] ?? '').replace(/\|/g, '\\|').replace(/\n/g, ' ')).join(' | ')} |`).join('\n');
-            return `${rows.length} ${label}:\n\n${head}\n${sep}\n${body}`;
-        };
-        parts.push(table('reports (down — subscriptions, usually children)', r['reports']));
-        parts.push(table('managers (up — subscribers)', r['managers']));
-        // 3) On-disk footprint at a glance.
-        const a = r['artifacts'];
-        parts.push(`artifacts: ${a['report']} report(s), ${a['doc']} doc(s), ${a['roadmap']} roadmap · ${r['pending_crons']} pending cron(s)`);
-        // 4) Auto-gathered drill-in pointers.
-        parts.push(`Drill deeper:\n${String(r['follow_up'])}`);
-        return parts.join('\n\n');
-    },
-});
-// ---------------------------------------------------------------------------
-// node fork — branch a conversation + durable context into an idle root
-// ---------------------------------------------------------------------------
-const nodeFork = defineLeaf({
-    name: 'fork',
-    description: 'fork a node into an independent idle root with the same conversation and durable context',
-    whenToUse: 'a conversation has already accumulated the context you want, and you want a new human-driven branch beside it without sending a prompt or inheriting any graph-management responsibility. This copies the conversation and durable context, then waits for the fork’s first real user message to supply its mandate. Use `node new --fork-from` instead when spawning a managed worker with an immediate task',
-    help: {
-        name: 'node fork',
-        summary: 'create an independent resident root from a node’s conversation and durable context, with no kickoff prompt or model turn',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Source node id. Mutually exclusive with --pane; one of them is required.' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane showing the source node. Mutually exclusive with --node; one of them is required. The prefix menu passes this for you and the new viewer splits beside this pane.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The new independent root id.' },
-            { name: 'focused', type: 'boolean', required: true, constraint: 'True when a new viewer pane opened beside the caller; false outside tmux.' },
-            { name: 'session', type: 'string', required: false, constraint: 'The tmux session containing the new viewer, when one opened.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Creates a resident base-mode root with the source node’s copied pi conversation, cwd, profile, kind, model override, and durable context files. Top-level initial-prompt.md, yield-message.md, and result.json are omitted.',
-            'Copies no parent, subscriptions, subscribers, children, crons, worktree, situational context, or lifecycle responsibility. Sends no prompt and consumes no model turn; the first real user message becomes the fork’s mandate.',
-            'Inside tmux, opens and focuses a surface-attach viewer as an even-horizontal split in the source pane’s window. Outside tmux, the root is still created but no interactive fallback opens.',
-        ],
-    },
-    run: async (input) => {
-        const pane = input['pane'];
-        const explicitNode = input['node'];
-        if (explicitNode !== undefined && pane !== undefined) {
-            throw new InputError({ error: 'conflicting_target', message: '--node and --pane are mutually exclusive', next: 'Pass the source node id or its viewer pane, not both.' });
-        }
-        let sourceId = explicitNode;
-        if (sourceId === undefined && pane !== undefined)
-            sourceId = nodeInPane(pane);
-        if (sourceId === undefined || sourceId === '') {
-            throw new InputError({ error: 'no_node', message: 'no source node was provided or found in the pane', next: 'Pass --node <id>, or --pane <pane-id> for a pane showing a node.' });
-        }
-        const detail = await cliClient().forkNode(sourceId).catch(rethrowAsCliError);
-        const placement = await focusViewer(detail.node_id, {
-            cwd: detail.cwd,
-            name: detail.name,
-            ...(pane !== undefined ? { pane } : {}),
-            newPane: true,
-        });
-        return { node_id: detail.node_id, focused: placement.focused, session: placement.session };
-    },
-    render: (result) => {
-        const placement = result['focused'] === true
-            ? ` Viewer opened beside the source${result['session'] ? ` in session ${result['session']}` : ''}.`
-            : ' No viewer opened because no tmux pane was available.';
-        return `Forked independent idle root ${result['node_id']}.${placement} It will make no model call until its first real user message.`;
-    },
-});
-// ---------------------------------------------------------------------------
-// node inspect — read the graph (list, show, context)
-// ---------------------------------------------------------------------------
-const nodeInspect = defineBranch({
-    name: 'inspect',
-    description: 'read one node — its graph position, context, and artifacts',
-    whenToUse: 'reading everything about ONE node you can name: enumerate the roster (`list`), inspect a node and its spine neighbors (`show`), browse its on-disk context dir (`context`), or list its reports/docs as refs (`artifacts`). Use `canvas dashboard` instead to render the whole tree SHAPE, or `canvas attention` to find which nodes are blocked on a human',
-    help: {
-        name: 'node inspect',
-        summary: 'read one node (or the roster) — topology, context dir, and artifacts',
-    },
-    children: [nodeList, nodeShow, nodeSnapshotLeaf, nodeTranscriptLeaf, nodeContextLeaf, nodeArtifactsLeaf],
-});
-// ---------------------------------------------------------------------------
-// surface node focus — bring a node's viewer forefront (across roots if needed)
-// ---------------------------------------------------------------------------
-export const surfaceNodeFocusLeaf = defineLeaf({
-    name: 'focus',
-    description: 'bring a node into view without accidentally reviving finished work',
-    whenToUse: 'you want to bring a specific node into view — live nodes open or move their viewer beside your current pane; completed, canceled, or crashed nodes open their saved transcript instead. Use `node lifecycle revive` only when you deliberately want to relaunch a dormant agent. Use `surface node cycle` to walk neighbors, and `node message send` to steer without leaving where you are',
-    help: {
-        name: 'surface node focus',
-        summary: 'bring a node into view — attach to a live broker, or open a saved transcript for a non-live node without reviving it',
-        params: [
-            { kind: 'positional', name: 'node', required: true, constraint: 'Node id to focus.' },
-            { kind: 'flag', name: 'new-pane', type: 'bool', required: false, constraint: 'Always open a NEW viewer SIDE-BY-SIDE with your current pane instead of moving/reusing the node\'s existing viewer. Two agents on screen at once (F4).' },
-            { kind: 'flag', name: 'in-place', type: 'bool', required: false, constraint: 'Re-exec the --pane pane ONTO this node, REPLACING whatever viewer it showed (a swap in place, not a split beside). Backs the attach viewer\'s subagent scroll+swap (↓ into the reports roster, Enter dives into the child right in your pane). MUST be driven from OUTSIDE that pane\'s process tree (e.g. `tmux run-shell`) — respawn-pane -k kills whatever runs in it. Mutually exclusive with --new-pane.' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id to focus beside (default: caller TMUX_PANE). Used by the canvas browser popup to focus back into the originating pane.' },
-        ],
-        output: [
-            { name: 'focused', type: 'boolean', required: true, constraint: 'True when the node\'s viewer was brought into view.' },
-            { name: 'session', type: 'string', required: false, constraint: 'The tmux session the viewer lives in.' },
-            { name: 'revived', type: 'boolean', required: true, constraint: 'True when focusing a live node had to relaunch its broker; false for a saved-transcript inspection.' },
-            { name: 'in_place', type: 'boolean', required: true, constraint: 'True when an existing viewer was navigated to (no new pane); false when a fresh viewer pane was opened or moved beside you.' },
-        ],
-        outputKind: 'object',
-        effects: ['For active/idle nodes: opens/moves the one surface-attach viewer beside the caller, or navigates to its existing viewer.', 'For done/dead/canceled nodes: opens a read-only saved transcript popup. It does not launch a broker or change node status.', 'With --new-pane/--in-place on a live node: controls whether the viewer splits beside or replaces the caller pane.'],
-    },
-    run: async (input) => {
-        const id = input['node'];
-        const node = await cliClient()
-            .getNode(id)
-            .catch((err) => rethrowAsCliError(err, 'List nodes with `crtr node inspect list`.'));
-        // A kind:'human' node is a control-plane ASK (a humanloop deck on the human's
-        // screen), NOT a pi conversation — it has no session. Reviving one boots a
-        // confused blank "you have been revived" pi, so refuse rather than focus it.
-        // (The nav/resume UIs already hide human nodes; this guards a hand-typed id.)
-        if (node.kind === 'human') {
-            throw new InputError({
-                error: 'not_focusable',
-                message: `node ${id} is a human-ask (kind:human), not a conversation — it has no pi session to focus.`,
-                next: `The pending question is queued for the human (${inboxHint()} opens the inbox); see it with \`crtr human list\`, or retract it with \`crtr human cancel ${id}\`.`,
-            });
-        }
-        // Opening history is not resuming work. A terminal/canceled/crashed node has
-        // no live broker to attach to, so show its persisted transcript in a popup;
-        // `node lifecycle revive` remains the explicit state-changing operation.
-        if (node.status !== 'active' && node.status !== 'idle') {
-            const pane = input['pane'] ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane;
-            const focused = pane !== undefined && pane !== ''
-                ? displayPopup(pane, node.cwd, `crtr node inspect transcript ${shellQuote(id)}`)
-                : false;
-            return { focused, session: null, revived: false, in_place: false };
-        }
-        // Local viewer tail: open/move the broker-backed viewer beside the caller.
-        // The server (ensureAttach) owns the revive + view.sock wait; pure tmux ops
-        // own the pane placement.
-        const res = await focusViewer(id, {
-            cwd: node.cwd,
-            name: node.name,
-            pane: input['pane'],
-            newPane: input['newPane'] === true,
-            inPlace: input['inPlace'] === true,
-        });
-        return { focused: res.focused, session: res.session, revived: res.revived, in_place: res.inPlace };
-    },
-});
-// ---------------------------------------------------------------------------
-// node lifecycle recycle — FINALIZE the agent in your pane + recycle it into a fresh root
-// (push its last report as a `final` → mark it done, then boot a fresh resident
-// `crtr` root in the SAME pane; see recycleNode in runtime/recycle.ts). NOT
-// bound to any Alt+C key/menu — d/D there route to `node lifecycle demote` (±--detach),
-// the flip-to-terminal-IN-PLACE action that keeps the agent running.
-// ---------------------------------------------------------------------------
-/** The node "in front of you" in a tmux pane, resolved PURELY from the pane's
- *  `@crtr_node` tag. Defaults to $TMUX_PANE / the caller's current pane when
- *  `pane` is omitted — shared by `node lifecycle recycle` / `node lifecycle
- *  demote` / `node config --lifecycle` / `node lifecycle close` / `surface node cycle`,
- *  and the `canvas chord` leaf.
- *
- *  A `crtr surface attach` viewer self-tags its pane with the node it views
- *  (`@crtr_node`) — the tag IS the handle (a broker engine runs DETACHED with
- *  window=null, so there is no window→node fallback). Kept SYNC + tag-only: the
- *  re-plumbed CLI no longer reads canvas state to confirm the tagged node is
- *  still live, so a stale tag (attach SIGKILLed without clearing) resolves until
- *  the pane is respawned. Callers that mutate then re-validate the id via the
- *  API (getNode 404 → clean error). */
-export function nodeInPane(pane) {
-    const resolvePane = pane ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane;
-    if (resolvePane === undefined || resolvePane === '')
-        return undefined;
-    const tagged = getPaneOption(resolvePane, '@crtr_node');
-    return tagged !== undefined && tagged !== '' ? tagged : undefined;
-}
-const nodeBashBackground = defineLeaf({
-    name: 'background',
-    description: 'hand the focused node’s running bash command to its background job system',
-    whenToUse: 'the tmux prefix menu invokes this when a foreground bash command should stop blocking the agent immediately but keep running as a file-backed background job',
-    tier: 'hidden',
-    help: {
-        name: 'node bash background',
-        summary: 'hand every running foreground bash command for one node to its file-backed background job system',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node whose running bash command to background. Defaults to the node in --pane, else the caller (CRTR_NODE_ID).' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane showing the target node, when --node is omitted. Defaults to $TMUX_PANE. The prefix menu passes this for you.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The target node.' },
-            { name: 'backgrounded', type: 'number', required: true, constraint: 'Number of running bash commands handed off.' },
-            { name: 'job_ids', type: 'string[]', required: true, constraint: 'File-backed job ids now running independently of the agent tool call.' },
-            { name: 'jobs', type: 'object[]', required: true, constraint: 'Per handed-off job {job_id, elapsed_ms} — the foreground elapsed time in milliseconds at the moment of handoff.' },
-        ],
-        outputKind: 'object',
-        effects: ['Signals every foreground bash command currently running for the node to return from its tool call immediately while its detached supervisor keeps the command running.', 'Each handed-off command retains its log under the node context jobs directory and sends the node an urgent inbox message when it exits, which steers the node mid-turn.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        let id = input['node'];
-        if (id === undefined || id === '')
-            id = nodeInPane(pane);
-        if (id === undefined || id === '')
-            id = process.env['CRTR_NODE_ID'];
-        if (id === undefined || id === '') {
-            throw new InputError({ error: 'no_node', message: 'no node found for the bash handoff', next: 'Run from inside a node, pass --node <id>, or --pane <pane>.' });
-        }
-        if ((await getNodeOrNull(id)) === null) {
-            throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
-        }
-        const jobs = backgroundRunningBashJobs(contextDir(id));
-        const now = Date.now();
-        const elapsed = jobs.map((job) => ({ job_id: job.jobId, elapsed_ms: now - (jobStartedAtMs(job.jobId) ?? now) }));
-        const toast = jobs.length === 0
-            ? 'crtr: no running bash command'
-            : jobs.length === 1
-                ? `crtr: bash handed off · ${formatBashElapsed(elapsed[0].elapsed_ms)}`
-                : `crtr: bash handed off (${jobs.length})`;
-        displayMessage(toast, pane);
-        return { node_id: id, backgrounded: jobs.length, job_ids: jobs.map((job) => job.jobId), jobs: elapsed };
-    },
-    render: (result) => {
-        if (result['backgrounded'] === 0)
-            return `No foreground bash command is running for ${result['node_id']}.`;
-        const jobs = result['jobs'];
-        const oldestElapsedMs = Math.max(...jobs.map((job) => job.elapsed_ms));
-        return `Handed ${result['backgrounded']} bash command(s) to the background job system for ${result['node_id']} · ran ${formatBashElapsed(oldestElapsedMs)} in the foreground.`;
-    },
-});
-const nodeBashList = defineLeaf({
-    name: 'list',
-    description: 'list a node’s live background bash jobs',
-    whenToUse: 'the Inspector’s jobs section reads this to show what a node handed off to the background',
-    tier: 'hidden',
-    help: {
-        name: 'node bash list',
-        summary: 'read every still-running background bash job owned by one node',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node whose background jobs to list. Defaults to the node in --pane, else the caller (CRTR_NODE_ID).' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane showing the target node, when --node is omitted. Defaults to $TMUX_PANE.' },
-            { kind: 'flag', name: 'tail', type: 'int', required: false, default: 0, constraint: 'Include this many trailing log lines per job (0 = none).' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The target node.' },
-            { name: 'jobs', type: 'object[]', required: true, constraint: 'Oldest-first {job_id, command, started_at, elapsed_ms, log_path, pgid, log_tail} for every live background job.' },
-        ],
-        outputKind: 'object',
-        effects: ['Reads the node context jobs directory. Changes nothing.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        let id = input['node'];
-        if (id === undefined || id === '')
-            id = nodeInPane(pane);
-        if (id === undefined || id === '')
-            id = process.env['CRTR_NODE_ID'];
-        if (id === undefined || id === '') {
-            throw new InputError({ error: 'no_node', message: 'no node found for the bash job list', next: 'Run from inside a node, pass --node <id>, or --pane <pane>.' });
-        }
-        const node = await getNodeOrNull(id);
-        if (node === null) {
-            throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
-        }
-        const now = Date.now();
-        const tail = Math.max(0, Math.trunc(Number(input['tail'] ?? 0)));
-        const dir = contextDir(node.node_id);
-        const jobs = activeBackgroundBashJobs(dir).map((job) => ({
-            job_id: job.jobId,
-            command: job.command,
-            started_at: new Date(job.startedAtMs).toISOString(),
-            elapsed_ms: now - job.startedAtMs,
-            log_path: job.logPath,
-            pgid: readJobPgid(dir, job.jobId) ?? null,
-            log_tail: tailJobLog(job.logPath, tail),
-        }));
-        return { node_id: node.node_id, jobs };
-    },
-    render: (result) => {
-        const jobs = result['jobs'];
-        if (jobs.length === 0)
-            return `No background bash jobs for ${result['node_id']}.`;
-        return jobs.map((job) => `${job.job_id} · ${formatBashElapsed(job.elapsed_ms)} · ${job.command.split('\n')[0]}\n  log: ${job.log_path}`).join('\n');
-    },
-});
-/** SIGTERM the job's process group, give it a moment, then SIGKILL. Returns
- *  false only when the group was already gone at the first signal. */
-function stopJobGroup(pgid) {
-    try {
-        process.kill(-pgid, 'SIGTERM');
-    }
-    catch {
-        return false;
-    }
-    return true;
-}
-const nodeBashKill = defineLeaf({
-    name: 'kill',
-    description: 'stop one of a node’s background bash jobs',
-    whenToUse: 'a human watching the Inspector or the attach cockpit’s bash row wants a long-running background job to stop now, or an agent is abandoning work it backgrounded',
-    tier: 'hidden',
-    help: {
-        name: 'node bash kill',
-        summary: 'terminate a background bash job’s process group and tell the owning node it was canceled',
-        params: [
-            { kind: 'positional', name: 'job', required: true, constraint: 'Job id, as reported by node bash list.' },
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node owning the job. Defaults to the node in --pane, else the caller (CRTR_NODE_ID).' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane showing the target node, when --node is omitted. Defaults to $TMUX_PANE.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The owning node.' },
-            { name: 'job_id', type: 'string', required: true, constraint: 'The job that was stopped.' },
-            { name: 'signaled', type: 'boolean', required: true, constraint: 'True when the process group was still alive and received SIGTERM.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Sends SIGTERM (then SIGKILL) to the job’s whole process group, stopping the command and anything it forked.',
-            'Records the job’s exit so it stops showing as live, and sends the owning node an urgent inbox message saying the job was stopped — which steers that node mid-turn.',
-        ],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        let id = input['node'];
-        if (id === undefined || id === '')
-            id = nodeInPane(pane);
-        if (id === undefined || id === '')
-            id = process.env['CRTR_NODE_ID'];
-        if (id === undefined || id === '') {
-            throw new InputError({ error: 'no_node', message: 'no node found for the bash job', next: 'Run from inside a node, pass --node <id>, or --pane <pane>.' });
-        }
-        const node = await getNodeOrNull(id);
-        if (node === null) {
-            throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
-        }
-        const jobId = input['job'];
-        const dir = contextDir(node.node_id);
-        const paths = bashJobPaths(dir, jobId);
-        if (!existsSync(paths.dir)) {
-            throw new InputError({ error: 'not_found', message: `no background job ${jobId} for ${node.node_id}`, next: 'List live jobs with `crtr node bash list`.' });
-        }
-        const pgid = readJobPgid(dir, jobId);
-        if (pgid === undefined) {
-            throw new InputError({
-                error: 'not_stoppable',
-                message: `job ${jobId} recorded no process group`,
-                next: `It started before crtr persisted one. Stop it by hand, then it will disappear from the list. Log: ${paths.jobLog}`,
-            });
-        }
-        const signaled = stopJobGroup(pgid);
-        // The supervisor shares the group it leads, so it usually dies with the
-        // command and never writes job.exit. Record the cancellation ourselves —
-        // that sentinel is what retires the job from every live-jobs read.
-        await new Promise((r) => setTimeout(r, 400));
-        try {
-            process.kill(-pgid, 'SIGKILL');
-        }
-        catch { /* already gone */ }
-        if (!existsSync(paths.jobExit))
-            writeFileSync(paths.jobExit, '143\n');
-        await cliClient().sendMessage(node.node_id, {
-            body: `Background bash job ${jobId} was stopped by the human before it finished. Log: ${paths.jobLog}  Command: ${paths.cmdSh}`,
-            tier: 'urgent',
-        });
-        return { node_id: node.node_id, job_id: jobId, signaled };
-    },
-    render: (result) => `Canceled background bash job ${result['job_id']} for ${result['node_id']}${result['signaled'] === true ? '' : ' (its process group was already gone)'}.`,
-});
-const nodeBash = defineBranch({
-    name: 'bash',
-    description: 'control file-backed bash jobs owned by a node',
-    whenToUse: 'a running bash command must be handed off, listed, or stopped — the tmux prefix menu backgrounds, the Inspector’s jobs section lists and cancels',
-    tier: 'hidden',
-    help: {
-        name: 'node bash',
-        summary: 'control file-backed bash jobs owned by a node',
-    },
-    children: [nodeBashBackground, nodeBashList, nodeBashKill],
-});
-export const surfaceNodeIdLeaf = defineLeaf({
-    name: 'id',
-    description: 'copy the focused node id to the system clipboard',
-    whenToUse: 'you need the id of the node in a tmux pane for a follow-up command or external reference',
-    help: {
-        name: 'surface node id',
-        summary: 'copy the node resolved from a tmux pane to the system clipboard',
-        params: [
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id whose focused node to copy. Defaults to $TMUX_PANE / your current pane.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The focused node id copied to the system clipboard.' },
-        ],
-        outputKind: 'object',
-        effects: ['Writes the focused node id to the system clipboard and shows a transient tmux confirmation.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        const nodeId = nodeInPane(pane);
-        if (nodeId === undefined) {
-            displayMessage('crtr: no node in pane', pane);
-            throw new InputError({ error: 'no_node', message: 'no node found in this pane', next: 'Pass --pane <pane-id> for a pane showing an active node.' });
-        }
-        if (!writeClipboardText(nodeId)) {
-            displayMessage('crtr: copy failed', pane);
-            throw new InputError({ error: 'clipboard_write_failed', message: 'could not write the node id to the system clipboard', next: 'Make a system clipboard tool available, then retry.' });
-        }
-        displayMessage('crtr: node id copied', pane);
-        return { node_id: nodeId };
-    },
-    render: (r) => `Copied node id: ${r['node_id']}`,
-});
-export const surfaceNodePinLeaf = defineLeaf({
-    name: 'pin',
-    description: 'pin or unpin the node in a tmux pane in the canvas navigator',
-    whenToUse: 'you want the conversation in this pane starred at the top of your canvas navigator (the same pin `canvas browse` toggles), without opening the navigator to do it',
-    help: {
-        name: 'surface node pin',
-        summary: 'toggle the canvas-navigator pin on the node resolved from a tmux pane — a local, per-user view preference that sorts the node to the top of your navigator and fills its Pinned tab, mutating nothing on the canvas',
-        params: [
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id whose focused node to pin. Defaults to $TMUX_PANE / your current pane.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The node whose pin was toggled.' },
-            { name: 'pinned', type: 'boolean', required: true, constraint: 'True when the node is now pinned, false when the pin was removed.' },
-        ],
-        outputKind: 'object',
-        effects: ['Toggles the node in the per-user navigator pin set and shows a transient tmux confirmation.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        const nodeId = nodeInPane(pane);
-        if (nodeId === undefined) {
-            displayMessage('crtr: no node in pane', pane);
-            throw new InputError({ error: 'no_node', message: 'no node found in this pane', next: 'Pass --pane <pane-id> for a pane showing an active node.' });
-        }
-        const pins = loadPins();
-        const pinned = !pins.has(nodeId);
-        if (pinned)
-            pins.add(nodeId);
-        else
-            pins.delete(nodeId);
-        savePins(pins);
-        displayMessage(pinned ? 'crtr: conversation pinned' : 'crtr: conversation unpinned', pane);
-        return { node_id: nodeId, pinned };
-    },
-    render: (r) => (r['pinned'] === true ? `Pinned ${r['node_id']} in the canvas navigator.` : `Unpinned ${r['node_id']}.`),
-});
-const nodeRecycle = defineLeaf({
-    name: 'recycle',
-    description: 'finish the agent in your pane + recycle it into a fresh root',
-    whenToUse: 'you are at an agent\'s pane and done with it: finish it cleanly and recycle the pane in one move — push its last message as a final report to everyone waiting on it, mark it done, then boot a fresh crtr root in the same pane to keep working. The human-driver way to end an agent and immediately start over in place. Use `node lifecycle demote` instead to put it on a finishing track IN PLACE (flip terminal, keep it running) without ending it now, `node lifecycle close` to tear a node and its subtree down WITHOUT finishing (no report, revivable), and `push final` when the agent should finish ITSELF from inside its own turn',
-    help: {
-        name: 'node lifecycle recycle',
-        summary: 'finish the agent in your current pane and recycle the pane — push its last message as a final report to everyone waiting on it, mark it done, then boot a fresh crtr root in the same pane',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node to finish. Defaults to the node occupying --pane (or your current pane).' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id to recycle. Defaults to $TMUX_PANE / your current pane. The Alt+C menu passes this for you.' },
-        ],
-        output: [
-            { name: 'recycled', type: 'boolean', required: true, constraint: 'True when the pane was recycled into a fresh root.' },
-            { name: 'node_id', type: 'string', required: false, constraint: 'The finished node.' },
-            { name: 'finalized', type: 'boolean', required: false, constraint: 'True when a final report was pushed to its subscribers.' },
-            { name: 'delivered', type: 'number', required: false, constraint: 'How many subscribers/managers received the final report.' },
-            { name: 'new_root', type: 'string', required: false, constraint: 'The fresh root node booted into the pane.' },
-        ],
-        outputKind: 'object',
-        effects: ['Pushes a final report from the node (fans out to all subscribers) and marks it done.', 'Kills the agent\'s pi and respawns a fresh resident root in the same tmux pane.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        let id = input['node'];
-        if (id === undefined || id === '') {
-            // Derive the node from the pane: which node's window holds it?
-            id = nodeInPane(pane);
-        }
-        if (id === undefined || id === '') {
-            throw new InputError({ error: 'no_node', message: 'no node found in this pane to finish', next: 'Pass --node <id>, or run from inside the agent\'s pane.' });
-        }
-        const detail = await cliClient()
-            .getNode(id)
-            .catch((err) => rethrowAsCliError(err, 'List nodes with `crtr node inspect list`.'));
-        // The server finalizes the node + spawns a fresh root (pane-less); the local
-        // tail re-execs the caller's pane onto a fresh `crtr` root so the human keeps
-        // working in place.
-        const recycled = await cliClient().recycleNode(id).catch(rethrowAsCliError);
-        const newRoot = recycled.node_id;
-        let paneRecycled = false;
-        if (pane !== undefined && pane !== '') {
-            paneRecycled = respawnPaneSync({ pane, cwd: detail.cwd, env: viewerEnv(), command: 'crtr' });
-        }
-        return { recycled: paneRecycled, node_id: id, finalized: true, delivered: undefined, new_root: newRoot };
-    },
-    render: (r) => {
-        if (r['recycled'] !== true) {
-            // A broker recycle that finalized + spawned a fresh root but whose new
-            // broker never served its socket: the state DID change (node finished, root
-            // born), only the viewer re-attach failed — say so, don't call it a no-op.
-            if (r['finalized'] === true && r['new_root']) {
-                return `Finished ${r['node_id']} and spawned a fresh broker root (${r['new_root']}), but its viewer did not attach — the new broker did not come up. Re-focus the root to view it.`;
-            }
-            return `Recycle failed for ${r['node_id'] ?? '?'} — not in tmux, or no agent in this pane.`;
-        }
-        const lines = [`Recycled the pane — finished ${r['node_id']}.`, `- finalized: ${r['finalized']}`];
-        if (r['finalized'] === true)
-            lines.push(`- delivered: ${r['delivered']}`);
-        if (r['new_root'])
-            lines.push(`- new root: ${r['new_root']}`);
-        return lines.join('\n');
-    },
-});
-// ---------------------------------------------------------------------------
-// node lifecycle close — close a node + cascade-cancel its exclusive subtree (Alt+C → x)
-// ---------------------------------------------------------------------------
-const nodeClose = defineLeaf({
-    name: 'close',
-    description: 'close a node + cascade-cancel its exclusive subtree (revivable)',
-    whenToUse: 'you want to tear a node down WITHOUT finishing it, cascade-cancelling every descendant it exclusively owns: abandoning a line of work, killing a stuck or wrong-turn subtree, clearing a branch you no longer need. Windows die but nothing is deleted — each closed node keeps its pi session and can be revived later (`node lifecycle revive`). Use `node lifecycle recycle` instead to FINISH the agent in your pane with a final report, and `push final` when a worker should end its own work normally (Alt+C → x)',
-    help: {
-        name: 'node lifecycle close',
-        summary: 'close a node and cascade-cancel its subtree — kill its tmux window plus those of every descendant it EXCLUSIVELY owns (down the subscribes_to spine), mark them all canceled, and leave each a notice it reads on resume. A descendant still subscribed to by a manager outside the subtree is left running. Nothing is deleted: every closed node keeps its pi session and can be revived later (`crtr node lifecycle revive`)',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node to close. Defaults to the node occupying --pane (or your current pane).' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id whose node to close. Defaults to $TMUX_PANE / your current pane. The Alt+C menu passes this for you.' },
-        ],
-        output: [
-            { name: 'closed', type: 'boolean', required: true, constraint: 'True when the node (and its exclusive subtree) was closed.' },
-            { name: 'node_id', type: 'string', required: false, constraint: 'The node that was closed — the cascade root.' },
-            { name: 'count', type: 'number', required: false, constraint: 'How many nodes were closed (root + cascaded descendants).' },
-            { name: 'closed_ids', type: 'string[]', required: false, constraint: 'All closed node ids, kill order (leaves first, root last).' },
-            { name: 'spared', type: 'string[]', required: false, constraint: 'Descendants left alive because a manager outside the subtree still subscribes to them.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Marks the node and its exclusive descendants `canceled` and clears intent (the daemon never revives a canceled node).',
-            'Kills each closed node\'s tmux window; their pi sessions and canvas edges persist for a later revive.',
-            'Appends a cancellation notice to each closed node\'s inbox, surfaced on its next resume.',
-        ],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        let id = input['node'];
-        if (id === undefined || id === '')
-            id = nodeInPane(pane);
-        if (id === undefined || id === '') {
-            throw new InputError({ error: 'no_node', message: 'no node found in this pane to close', next: 'Pass --node <id>, or run from inside the agent\'s pane.' });
-        }
-        const res = await cliClient()
-            .closeNode(id)
-            .catch((err) => rethrowAsCliError(err, 'List nodes with `crtr node inspect list`.'));
-        return { closed: true, node_id: res.root, count: res.closed.length, closed_ids: res.closed, spared: res.spared };
-    },
-    render: (r) => {
-        if (r['closed'] !== true)
-            return 'Close failed — no node found in this pane to close.';
-        const spared = r['spared']?.length ?? 0;
-        return `Closed ${r['node_id']} and its exclusive subtree — ${r['count']} node(s) closed${spared > 0 ? `, ${spared} spared (still managed from outside the subtree)` : ''}.`;
-    },
-});
-// ---------------------------------------------------------------------------
-// node config — reconfigure a node's settings headlessly (model/lifecycle/kind/mode/name)
-// ---------------------------------------------------------------------------
-const nodeConfig = defineLeaf({
-    name: 'config',
-    description: 'reconfigure a node\'s settings headlessly — model, lifecycle (terminal/resident), kind, mode, name',
-    whenToUse: 'you want to reconfigure a node\'s settings headlessly after spawn — swap its model/provider, flip it terminal↔resident (interactable), respecialize its kind, switch base↔orchestrator mode, or rename it — without opening its viewer. The durable attribute setter; reuses the same recipes a revive reads. Use `node promote` for the opinionated self-promotion path, and `node lifecycle` for teardown actions (recycle/close/demote).',
-    help: {
-        name: 'node config',
-        summary: 'reconfigure a node\'s settings headlessly — model, lifecycle, kind, mode, name',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Target node id. Defaults to the node in --pane, else CRTR_NODE_ID.' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id to resolve the node from. Defaults to $TMUX_PANE.' },
-            { kind: 'flag', name: 'model', type: 'string', required: false, constraint: 'Model spec: exact provider/id, capability tier (ultra|strong|medium|light), family alias (opus|sonnet|haiku), or a free-text substring when the broker is live. Dormant nodes require a provider/id, tier, or alias.' },
-            { kind: 'flag', name: 'lifecycle', type: 'enum', choices: ['terminal', 'resident'], required: false, constraint: 'Set lifecycle headlessly without closing the viewer. terminal owes a final and reaps when done; resident stays interactable and wakes on inbox/human.' },
-            { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: 'Persona kind. The <kinds> list below names every top-level installable kind and when to use each; a sub-kind (e.g. plan/reviewers/security) is valid too by exact path but not listed here.' },
-            { kind: 'flag', name: 'mode', type: 'enum', choices: ['base', 'orchestrator'], required: false, constraint: 'Set persona mode headlessly. base is hands-on; orchestrator holds a roadmap and delegates. orchestrator seeds a roadmap scaffold if absent.' },
-            { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Rename the node; if the node has a live window, also rename that viewer window.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The reconfigured node.' },
-            { name: 'model', type: 'string', required: false, constraint: 'The resolved model, present only when --model changed it.' },
-            { name: 'lifecycle', type: 'string', required: false, constraint: 'The new lifecycle, present only when --lifecycle changed it.' },
-            { name: 'kind', type: 'string', required: false, constraint: 'The new kind, present only when --kind changed it.' },
-            { name: 'mode', type: 'string', required: false, constraint: 'The new mode, present only when --mode changed it.' },
-            { name: 'name', type: 'string', required: false, constraint: 'The new name, present only when --name changed it.' },
-            { name: 'applied', type: 'string[]', required: false, constraint: 'The fields that changed, in application order.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Model change first: live broker switches over its socket; dormant node persists the durable recipe (model_override + launch.model).',
-            'Kind, mode, and lifecycle changes rebuild the launch spec from the fresh node meta; setting mode to orchestrator seeds a roadmap scaffold if absent.',
-            'Name changes update the row and, when the node already has a live window, rename that viewer window to the new full name.',
-        ],
-        dynamicState: () => kindsStateBlock(),
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        const nodeId = await resolveLifecycleNode(input, pane);
-        // Validate the model spec's SHAPE client-side (the server owns the
-        // live/dormant resolution branch); build the patch from the flags set. The
-        // kind is validated against the caller's installed personas here for the
-        // clean listing error, and re-validated server-side against the TARGET
-        // node's scope as a backstop.
-        const modelSpec = input['model']?.trim();
-        if (modelSpec === '') {
-            throw new InputError({ error: 'empty_spec', message: 'a model spec is required', field: 'model', next: 'Pass a `provider/id`, a tier (ultra|strong|medium|light), an alias (opus|sonnet|haiku), or a substring.' });
-        }
-        const kindSpec = input['kind']?.trim();
-        const lifecycleSpec = input['lifecycle']?.trim();
-        const modeSpec = input['mode']?.trim();
-        const nameSpec = input['name'];
-        if (kindSpec !== undefined)
-            assertKind(kindSpec);
-        if (lifecycleSpec !== undefined && lifecycleSpec.toLowerCase() !== 'terminal' && lifecycleSpec.toLowerCase() !== 'resident') {
-            throw new InputError({ error: 'bad_lifecycle', message: `invalid lifecycle: ${lifecycleSpec}`, field: 'lifecycle', next: 'Pass `terminal` or `resident`.' });
-        }
-        if (modeSpec !== undefined && modeSpec.toLowerCase() !== 'base' && modeSpec.toLowerCase() !== 'orchestrator') {
-            throw new InputError({ error: 'bad_mode', message: `invalid mode: ${modeSpec}`, field: 'mode', next: 'Pass `base` or `orchestrator`.' });
-        }
-        const applied = [];
-        const patch = {};
-        if (modelSpec !== undefined) {
-            patch.model = modelSpec;
-            applied.push('model');
-        }
-        if (kindSpec !== undefined) {
-            patch.kind = kindSpec;
-            applied.push('kind');
-        }
-        if (lifecycleSpec !== undefined) {
-            patch.lifecycle = lifecycleSpec.toLowerCase();
-            applied.push('lifecycle');
-        }
-        if (modeSpec !== undefined) {
-            patch.mode = modeSpec.toLowerCase();
-            applied.push('mode');
-        }
-        if (nameSpec !== undefined) {
-            patch.name = nameSpec;
-            applied.push('name');
-        }
-        if (applied.length === 0) {
-            throw new InputError({ error: 'no_change', message: 'no config changes requested', next: 'Pass at least one of --model, --lifecycle, --kind, --mode, --name.' });
-        }
-        const detail = await cliClient()
-            .patchConfig(nodeId, patch)
-            .catch((err) => rethrowAsCliError(err, 'List nodes with `crtr node inspect list`.'));
-        const result = { node_id: nodeId, applied };
-        if (applied.includes('model'))
-            result.model = detail.model_override ?? modelSpec;
-        if (applied.includes('lifecycle'))
-            result.lifecycle = detail.lifecycle;
-        if (applied.includes('kind'))
-            result.kind = detail.kind;
-        if (applied.includes('mode'))
-            result.mode = detail.mode;
-        if (applied.includes('name'))
-            result.name = detail.name;
-        return result;
-    },
-    render: (r) => {
-        const bits = [];
-        if (r['model'] !== undefined)
-            bits.push(`model=${r['model']}`);
-        if (r['lifecycle'] !== undefined)
-            bits.push(`lifecycle=${r['lifecycle']}`);
-        if (r['kind'] !== undefined)
-            bits.push(`kind=${r['kind']}`);
-        if (r['mode'] !== undefined)
-            bits.push(`mode=${r['mode']}`);
-        if (r['name'] !== undefined)
-            bits.push(`name=${r['name']}`);
-        return `Configured ${r['node_id']} — ${bits.join(', ')}`;
-    },
-});
-// ---------------------------------------------------------------------------
-// surface node cycle — DFS-walk the canvas one viewer at a time (Alt+] / Alt+[)
-// ---------------------------------------------------------------------------
-/** Every live node in DFS pre-order across the whole forest. The spawn tree is
- *  the `parent` field; children inherit their parent's row order (created), so
- *  the walk descends into a node's children before moving to its siblings —
- *  exactly "next in pre-order is your first child". Roots are live nodes with no
- *  live parent (a done/dead parent orphans its live children up to the top).
- *  Cycle-safe: a final pass appends any node a cycle kept from being reached. */
-async function liveDfsOrder() {
-    const rows = await cliCanvasSource().listNodes({ status: ['active', 'idle'] }).catch(rethrowAsCliError); // ORDER BY created
-    const liveIds = new Set(rows.map((r) => r.node_id));
-    const childrenOf = new Map();
-    for (const r of rows) {
-        const p = r.parent;
-        if (p != null && liveIds.has(p)) {
-            const arr = childrenOf.get(p) ?? [];
-            arr.push(r.node_id);
-            childrenOf.set(p, arr);
-        }
-    }
-    const out = [];
-    const seen = new Set();
-    const visit = (id) => {
-        if (seen.has(id))
-            return;
-        seen.add(id);
-        out.push(id);
-        for (const c of childrenOf.get(id) ?? [])
-            visit(c);
-    };
-    for (const r of rows)
-        if (r.parent == null || !liveIds.has(r.parent))
-            visit(r.node_id);
-    for (const r of rows)
-        visit(r.node_id); // stragglers (parent cycles)
-    return out;
-}
-export const surfaceNodeCycleLeaf = defineLeaf({
-    name: 'cycle',
-    description: 'DFS-walk to the next/prev live node\'s viewer',
-    whenToUse: 'sweeping the canvas one viewer at a time, descending into children before siblings (bound to Alt+] forward / Alt+[ back). Use `surface node focus` instead to jump straight to a named node',
-    help: {
-        name: 'surface node cycle',
-        summary: 'focus the next/previous live node\'s viewer in DFS pre-order — the canvas walked one viewer at a time, descending into a node\'s children before its siblings (bound to Alt+] forward / Alt+[ back)',
-        params: [
-            { kind: 'flag', name: 'dir', type: 'enum', choices: ['next', 'prev'], required: false, default: 'next', constraint: 'Direction along the pre-order: next (Alt+], rightward/deeper into children) or prev (Alt+[, back). Wraps at the ends.' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane to cycle FROM. Defaults to $TMUX_PANE / your current pane. The Alt+] / Alt+[ bindings pass this for you.' },
-        ],
-        output: [
-            { name: 'focused', type: 'boolean', required: true, constraint: 'True when the neighbor was brought into view.' },
-            { name: 'node_id', type: 'string', required: false, constraint: 'The node now in front of you.' },
-            { name: 'name', type: 'string', required: false, constraint: 'Its display name.' },
-            { name: 'from', type: 'string', required: false, constraint: 'The node you cycled away from.' },
-        ],
-        outputKind: 'object',
-        effects: ['Brings the neighbor\'s viewer forefront beside the caller (like `surface node focus`); the viewer you were watching drops to the background.', 'Relaunches the neighbor\'s broker first if it was dormant.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane ?? undefined;
-        const dir = (input['dir'] ?? 'next');
-        const fromId = nodeInPane(pane);
-        if (fromId === undefined)
-            return { focused: false };
-        const order = await liveDfsOrder();
-        const i = order.indexOf(fromId);
-        if (i === -1 || order.length < 2)
-            return { focused: false, node_id: fromId, from: fromId };
-        const step = dir === 'next' ? 1 : -1;
-        const targetId = order[(i + step + order.length) % order.length];
-        const target = await getNodeOrNull(targetId);
-        if (target === null)
-            return { focused: false, from: fromId };
-        // Placement brings the neighbor's viewer forefront beside the caller; the
-        // server (ensureAttach, inside focusViewer) relaunches its broker if dormant.
-        const res = await focusViewer(targetId, { cwd: target.cwd, name: target.name, pane });
-        return { focused: res.focused, node_id: targetId, name: target.name, from: fromId };
-    },
-    render: (r) => r['focused'] === true
-        ? `Cycled to "${r['name'] ?? ''}" (${r['node_id']}) — from ${r['from'] ?? '?'}.`
-        : 'No other live node to focus.',
-});
-// ---------------------------------------------------------------------------
-// Shared implementation engine for the intent-specific message, deadline, and
-// message leaves below. This descriptor is internal and is never registered.
-// ---------------------------------------------------------------------------
-/** Resolve the calling node for a self-anchored deadline cron. */
-function armerId() {
-    const id = process.env['CRTR_NODE_ID'];
-    if (id === undefined || id === '') {
-        throw new InputError({ error: 'no_node', message: 'no node to anchor a deadline cron (CRTR_NODE_ID unset)', next: 'Run from inside a node.' });
-    }
-    return id;
-}
-/** Build ParseOpts, including `tz` only when actually provided. */
-function parseOpts(now, tz) {
-    return tz !== undefined && tz.trim() !== '' ? { tz, now } : { now };
-}
-/** Map a time-grammar error to the rendered error block. */
-function throwTimeError(e) {
-    const next = {
-        wake_in_past: 'Pick a future instant — a positive duration ("5m","2h") or an ISO time later than now.',
-        bad_when: 'Use a duration ("5m","1h30m"), a zoned ISO ("2026-06-07T09:00:00Z"), or a bare ISO ("2026-06-07T09:00").',
-        bad_cadence: 'Use a duration ("6h"), a 5-field cron ("0 9 * * *"), or an @alias ("@daily").',
-        unknown_zone: 'Pass --tz with an IANA zone name (e.g. "America/New_York").',
-        cadence_too_fast: 'Use a cadence of at least 60s (e.g. "1m","5m","1h").',
-    };
-    throw new InputError({ error: e.code, message: e.message, received: e.received, next: next[e.code] ?? 'Fix the time value and retry.' });
-}
-/** A human ETA hint like " (~5m)" from a fire-at ISO relative to now. '' if past. */
-function etaHint(fireAt, now) {
-    const ms = new Date(fireAt).getTime() - now.getTime();
-    if (!Number.isFinite(ms) || ms <= 0)
-        return '';
-    const mins = Math.round(ms / 60_000);
-    if (mins < 60)
-        return ` (~${mins}m)`;
-    const hrs = Math.round(ms / 3_600_000);
-    if (hrs < 48)
-        return ` (~${hrs}h)`;
-    return ` (~${Math.round(ms / 86_400_000)}d)`;
-}
-/** Resolve a message target: exactly one of --to/--self. */
-async function resolveMsgTarget(input) {
-    const to = input['to']?.trim();
-    const self = input['self'] === true;
-    const hasTo = to !== undefined && to !== '';
-    if (hasTo === self) {
-        throw new InputError({
-            error: 'bad_target',
-            message: hasTo && self ? '--to and --self are mutually exclusive' : 'exactly one of --to or --self is required',
-            next: 'Pass --to <node-id> or --self.',
-        });
-    }
-    if (self) {
-        const id = process.env['CRTR_NODE_ID'];
-        if (id === undefined || id === '') {
-            throw new InputError({ error: 'no_node', message: 'no node to target with --self (CRTR_NODE_ID unset)', next: 'Run from inside a node, or pass --to <node-id>.' });
-        }
-        return { targetId: id, isSelf: true };
-    }
-    const exists = await getNodeOrNull(to);
-    if (exists === null) {
-        throw new InputError({ error: 'not_found', message: `no node: ${to}`, field: 'to', next: 'List nodes with `crtr node inspect list`.' });
-    }
-    return { targetId: to, isSelf: false };
-}
-const nodeMessageEngine = defineLeaf({
-    name: 'message-engine',
-    description: 'internal engine for immediate node messages',
-    whenToUse: 'internal only',
-    help: {
-        name: 'node message-engine',
-        summary: 'deliver an immediate inbox message or fresh-revive a node',
-        params: [
-            { kind: 'stdin', name: 'body', required: false, constraint: 'Visible message body. Required unless --fresh, --output-schema, or --situational-context is supplied.' },
-            { kind: 'flag', name: 'to', type: 'string', required: false, constraint: 'Target an existing node by id. Exactly one of --to or --self is required.' },
-            { kind: 'flag', name: 'self', type: 'bool', required: false, constraint: 'Target the calling node. Exactly one of --to or --self is required.' },
-            { kind: 'flag', name: 'tier', type: 'enum', choices: ['critical', 'urgent', 'normal', 'deferred'], required: false, default: 'normal', constraint: 'Delivery urgency. Deferred never wakes an idle node.' },
-            { kind: 'flag', name: 'fresh', type: 'bool', required: false, constraint: 'Fresh-revive the target now with no inbox entry. Forbidden with a body, --tier, or --output-schema.' },
-            { kind: 'flag', name: 'output-schema', type: 'string', required: false, constraint: 'Path to a JSON Schema file, or inline JSON beginning with `{`. Grants a one-off submit tool.' },
-            { kind: 'flag', name: 'situational-context', type: 'string', required: false, constraint: 'Non-empty hidden ambient context delivered beside the message, or alone.' },
-            { kind: 'flag', name: 'reopen', type: 'bool', required: false, constraint: 'Clear a finalized target latch before delivery or fresh revive.' },
-        ],
-        output: [
-            { name: 'target', type: 'string', required: true, constraint: 'self or the target node id.' },
-            { name: 'delivered', type: 'boolean', required: false, constraint: 'True when an inbox message was delivered.' },
-            { name: 'revived', type: 'boolean', required: false, constraint: 'True when the target was revived.' },
-            { name: 'guidance', type: 'string', required: true, constraint: 'Immediate action confirmation.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'An inbox message appends one entry. Wake-capable tiers may revive a dormant target; deferred waits for its next natural cycle.',
-            'A fresh revive starts the target now with no inbox entry.',
-        ],
-    },
-    run: async (input) => {
-        const situationalContextSupplied = input['situationalContext'] !== undefined;
-        const situationalContextRaw = input['situationalContext']?.trim();
-        if (situationalContextSupplied && situationalContextRaw === '') {
-            throw new InputError({ error: 'empty_situational_context', message: '--situational-context must contain non-whitespace text', field: 'situational-context', next: 'Pass non-whitespace text, or omit --situational-context.' });
-        }
-        const { targetId, isSelf } = await resolveMsgTarget(input);
-        const bodyRaw = input['body'];
-        const body = bodyRaw !== undefined ? bodyRaw.trim() : undefined;
-        const hasBody = body !== undefined && body !== '';
-        const tierRaw = input['tier'];
-        const hasTier = tierRaw !== undefined && tierRaw !== '';
-        const fresh = input['fresh'] === true;
-        const outputSchemaParsed = parseOutputSchemaValue(input['outputSchema']);
-        const outputSchema = outputSchemaParsed !== null ? JSON.stringify(outputSchemaParsed) : null;
-        const hasSituational = situationalContextRaw !== undefined && situationalContextRaw !== '';
-        const reopen = input['reopen'] === true;
-        if (fresh && (hasBody || hasTier || outputSchema !== null)) {
-            throw new InputError({ error: 'bad_fresh_combo', message: '--fresh cannot combine with a body, --tier, or --output-schema', next: 'Drop the conflicting input; --fresh is a revive, not a message.' });
-        }
-        if (outputSchema !== null && tierRaw === 'deferred') {
-            throw new InputError({ error: 'output_schema_deferred_tier', message: '--output-schema cannot combine with --tier deferred because the target must answer', field: 'tier', next: 'Use normal, urgent, or critical tier, or drop --output-schema.' });
-        }
-        const target = isSelf ? 'self' : targetId;
-        const senderFrom = process.env['CRTR_NODE_ID'];
-        const client = cliClient();
-        if (fresh) {
-            const res = await client.sendMessage(targetId, {
-                body: '',
-                fresh: true,
-                ...(reopen ? { reopen: true } : {}),
-                ...(hasSituational ? { situational_context: situationalContextRaw } : {}),
-                ...(senderFrom !== undefined ? { from: senderFrom } : {}),
-            }).catch(rethrowAsCliError);
-            return { target, revived: res.revived, guidance: `Fresh-revived ${isSelf ? 'yourself' : targetId} now.` };
-        }
-        if (!hasBody && !hasSituational && outputSchema === null) {
-            throw new InputError({ error: 'empty_body', message: 'a message body is required unless --output-schema or --situational-context is supplied', field: 'body', next: 'Pass the message on stdin, or supply one of the documented alternatives.' });
-        }
-        const tier = (hasTier ? tierRaw : 'normal');
-        const res = await client.sendMessage(targetId, {
-            body: body ?? '',
-            tier,
-            ...(reopen ? { reopen: true } : {}),
-            ...(hasSituational ? { situational_context: situationalContextRaw } : {}),
-            ...(outputSchema !== null ? { output_schema: outputSchema } : {}),
-            ...(senderFrom !== undefined ? { from: senderFrom } : {}),
-        }).catch(rethrowAsCliError);
-        const guidance = res.revived
-            ? 'Delivered — the dormant target was revived to receive it.'
-            : tier === 'deferred'
-                ? "Delivered — held for the target's next natural cycle; not revived."
-                : 'Delivered.';
-        return { target, delivered: true, revived: res.revived, guidance };
-    },
-    render: (r) => String(r['guidance']),
-});
-async function runMessageEngine(input, context, outputNames) {
-    const result = await nodeMessageEngine.run(input, context);
-    if (result === undefined)
-        return;
-    return Object.fromEntries(outputNames.filter((name) => result[name] !== undefined).map((name) => [name, result[name]]));
-}
-function messageLeaf(name, path, description, whenToUse, paramNames, outputNames, effects, paramConstraints = {}, outputConstraints = {}) {
-    return defineLeaf({
-        name,
-        description,
-        whenToUse,
-        help: {
-            ...nodeMessageEngine.help,
-            name: path,
-            summary: description,
-            guide: undefined,
-            params: constrainParams(paramsFor(nodeMessageEngine.help.params, paramNames), paramConstraints),
-            output: constrainOutputs(outputsFor(nodeMessageEngine.help.output, outputNames), outputConstraints),
-            effects,
-        },
-        run: (input, context) => runMessageEngine(input, context, outputNames),
-        render: nodeMessageEngine.render,
-    });
-}
-const nodeMessageSend = messageLeaf('send', 'node message send', 'deliver an inbox message to an existing node immediately', 'you need to steer or inform a node now without creating an ongoing subscription', ['body', 'to', 'self', 'tier', 'situational-context', 'reopen'], ['target', 'delivered', 'revived', 'guidance'], ['Appends one inbox entry. Critical, urgent, and normal delivery may revive a dormant target; deferred waits for its next natural cycle.']);
-nodeMessageSend.help.params = (nodeMessageSend.help.params ?? []).map((param) => param.name === 'reopen' && param.kind === 'flag' ? { ...param, hidden: true } : param);
-const nodeMessageRequestBase = messageLeaf('request', 'node message request', 'deliver an immediate typed-output request to an existing node', 'the target must answer once through a submit tool constrained by a JSON Schema', ['body', 'to', 'self', 'tier', 'output-schema', 'situational-context', 'reopen'], ['target', 'delivered', 'revived', 'guidance'], ['Installs the one-off submit schema before appending the request.']);
-const nodeMessageRequest = {
-    ...nodeMessageRequestBase,
-    help: {
-        ...nodeMessageRequestBase.help,
-        params: (nodeMessageRequestBase.help.params ?? []).map((param) => {
-            if (param.name === 'output-schema')
-                return { ...param, required: true };
-            if (param.name === 'tier' && param.kind === 'flag')
-                return { ...param, choices: ['critical', 'urgent', 'normal'] };
-            if (param.name === 'reopen' && param.kind === 'flag')
-                return { ...param, hidden: true };
-            return param;
-        }),
-    },
-    run: (input, context) => {
-        requireNonBlankDiscriminant(input, 'outputSchema');
-        return runMessageEngine(input, context, ['target', 'delivered', 'revived', 'guidance']);
-    },
-};
-function deadlineHeredoc(body, nodeId) {
-    let delimiter = 'CRTR_DEADLINE';
-    let suffix = 0;
-    const lines = new Set(body.split('\n'));
-    while (lines.has(delimiter))
-        delimiter = `CRTR_DEADLINE_${++suffix}`;
-    return `crtr node message send --to ${shellQuote(nodeId)} --tier urgent <<'${delimiter}'\n${body}\n${delimiter}`;
-}
-const nodeWaitDeadline = defineLeaf({
-    name: 'deadline',
-    description: 'race this node’s next wake against one urgent deadline cron',
-    whenToUse: 'you are waiting on an event nothing can push for, so a self-scheduled deadline must settle the wait',
-    help: {
-        name: 'node wait deadline',
-        summary: 'arm one cancel-on-wake deadline cron for this node',
-        params: [
-            { kind: 'stdin', name: 'body', required: true, constraint: 'Policy delivered urgently to this node if the deadline fires first.' },
-            { kind: 'flag', name: 'until', type: 'string', required: true, constraint: 'Future duration, zoned ISO timestamp, or bare ISO timestamp interpreted in --tz or host-local time.' },
-            { kind: 'flag', name: 'tz', type: 'string', required: false, constraint: 'IANA timezone for a bare ISO --until value.' },
-        ],
-        output: [
-            { name: 'id', type: 'string', required: true, constraint: 'The armed cron id.' },
-            { name: 'name', type: 'string', required: true, constraint: 'The cron label.' },
-            { name: 'fires_at', type: 'string', required: true, constraint: 'Absolute UTC deadline.' },
-            { name: 'guidance', type: 'string', required: true, constraint: 'How to inspect the cron and dorm.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Arms one anchored cancel-on-wake cron. Any wake of this node cancels it; otherwise it urgently sends the body to this node at the deadline.',
-            'Re-arming replaces this node’s pending deadline rather than stacking a second.',
-        ],
-    },
-    run: async (input) => {
-        const self = armerId();
-        const body = typeof input['body'] === 'string' ? input['body'].trim() : '';
-        if (body === '')
-            throw new InputError({ error: 'empty_body', message: 'a deadline body is required', field: 'body', next: 'Pass the timeout policy on stdin.' });
-        const until = typeof input['until'] === 'string' ? input['until'].trim() : '';
-        if (until === '')
-            throw new InputError({ error: 'missing_until', message: '--until is required', field: 'until', next: 'Pass a future duration or timestamp.' });
-        const tz = typeof input['tz'] === 'string' && input['tz'].trim() !== '' ? input['tz'] : undefined;
-        const now = new Date();
-        const parsed = parseWhen(until, parseOpts(now, tz));
-        if ('error' in parsed)
-            throwTimeError(parsed.error);
-        const profile = process.env['CRTR_PROFILE_ID'];
-        // One deadline per node: the arm seam REPLACES this node's pending
-        // cancel-on-wake cron rather than stacking a second one (see armCron in
-        // core/canvas/crons.ts, where the invariant is enforced for every caller).
-        const cron = await cliClient().armCron({
-            name: `deadline:${self}`,
-            command: deadlineHeredoc(body, self),
-            fire_at: parsed.fireAt,
-            recur: null,
-            tz: tz ?? null,
-            created_by: self,
-            cwd: process.cwd(),
-            profile: profile !== undefined && profile !== '' ? profile : null,
-            scope: 'profile',
-            on_output: 'on-failure',
-            sink: null,
-            tier: 'normal',
-            expires_at: null,
-            anchor_node: self,
-            cancel_on_wake: true,
-            run_timeout_s: 300,
-            overlap: 'skip',
-        }).catch(rethrowAsCliError);
-        const guidance = `Deadline cron armed for ${cron.fire_at}${etaHint(cron.fire_at, now)}. End your turn to dorm; any earlier wake cancels it. Inspect pending schedules with \`crtr cron list\`.`;
-        return { id: cron.cron_id, name: cron.name, fires_at: cron.fire_at, guidance };
-    },
-    render: (r) => `Deadline cron armed — ${r['name']} (${r['id']}), fires ${r['fires_at']}.\n\n${r['guidance']}`,
-});
-const nodeMessage = defineBranch({
-    name: 'message',
-    description: 'deliver immediate inbox work to an existing node',
-    whenToUse: 'you need one immediate delivery: send ordinary information, or request one schema-constrained result',
-    help: { name: 'node message', summary: 'deliver now; choose ordinary delivery or a typed-output obligation' },
-    children: [nodeMessageSend, nodeMessageRequest],
-});
-// ---------------------------------------------------------------------------
-// node subscription — wire the subscribes_to spine between any pair
-// ---------------------------------------------------------------------------
-/** Resolve the subscriber: explicit --subscriber wins, else the calling node. */
-function resolveSubscriber(input) {
-    const sub = input['subscriber'] ?? process.env['CRTR_NODE_ID'];
-    if (sub === undefined || sub === '') {
-        throw new InputError({ error: 'no_subscriber', message: 'no subscriber (set CRTR_NODE_ID or pass --subscriber)', field: 'subscriber', next: 'Run from inside a node, or pass --subscriber <id>.' });
-    }
-    return sub;
-}
-const nodeSubscribe = defineLeaf({
-    name: 'add',
-    description: 'wire a subscribes_to edge between any pair (active or --passive)',
-    whenToUse: 'you want to make one node receive another node’s pushes, actively or passively. Managed-child creation already adds its active edge; use this for other subscriber-to-publisher pairs',
-    help: {
-        name: 'node subscription add',
-        summary: 'wire a subscribes_to edge so one node receives another\'s pushes — the subscriber can be you (default) or, with --subscriber, ANY node, to ANY publisher. Re-running flips an existing edge\'s active/passive mode.',
-        params: [
-            { kind: 'positional', name: 'publisher', required: true, constraint: 'The node to subscribe TO — whose pushes get delivered to the subscriber.' },
-            { kind: 'flag', name: 'subscriber', type: 'string', required: false, constraint: 'Who receives the pushes. Defaults to the calling node (CRTR_NODE_ID). Pass any node id to wire a third party.' },
-            { kind: 'flag', name: 'passive', type: 'bool', required: false, constraint: 'Passive subscription: pushes ACCUMULATE without waking the subscriber, then auto-inject as timestamped XML pre-text on its next message. Omit for an active (wake-on-push) subscription.' },
-        ],
-        output: [
-            { name: 'subscribed', type: 'boolean', required: true, constraint: 'True when the edge was created/updated.' },
-            { name: 'subscriber', type: 'string', required: true, constraint: 'The receiving node.' },
-            { name: 'publisher', type: 'string', required: true, constraint: 'The node being subscribed to.' },
-            { name: 'mode', type: 'string', required: true, constraint: '"active" (wakes on push) or "passive" (accumulates, no wake).' },
-        ],
-        outputKind: 'object',
-        effects: ['Upserts a subscribes_to edge in canvas.db (active flag set from --passive).', 'Passive edges never wake the subscriber and do not hold it alive (excluded from the stop-guard).'],
-    },
-    run: async (input) => {
-        const publisher = input['publisher'];
-        const subscriber = resolveSubscriber(input);
-        const passive = input['passive'] === true;
-        if (subscriber === publisher) {
-            throw new InputError({ error: 'self_subscribe', message: 'a node cannot subscribe to itself', next: 'Pick a different publisher.' });
-        }
-        await cliClient()
-            .subscribe(subscriber, { target: publisher, active: !passive })
-            .catch((err) => rethrowAsCliError(err));
-        return { subscribed: true, subscriber, publisher, mode: passive ? 'passive' : 'active' };
-    },
-    render: (r) => `Subscribed ${r['subscriber']} → ${r['publisher']} (${r['mode']}).`,
-});
-const nodeUnsubscribe = defineLeaf({
-    name: 'remove',
-    description: 'drop a subscribes_to edge',
-    whenToUse: 'you want to stop one node receiving a publisher’s pushes; removal is idempotent',
-    help: {
-        name: 'node subscription remove',
-        summary: 'drop a subscribes_to edge — the subscriber (you by default, or any node via --subscriber) stops receiving the publisher\'s pushes.',
-        params: [
-            { kind: 'positional', name: 'publisher', required: true, constraint: 'The node to stop subscribing to.' },
-            { kind: 'flag', name: 'subscriber', type: 'string', required: false, constraint: 'Who to detach. Defaults to the calling node (CRTR_NODE_ID).' },
-        ],
-        output: [
-            { name: 'unsubscribed', type: 'boolean', required: true, constraint: 'True when the edge was removed (idempotent — also true if none existed).' },
-            { name: 'subscriber', type: 'string', required: true, constraint: 'The detached node.' },
-            { name: 'publisher', type: 'string', required: true, constraint: 'The node it stopped subscribing to.' },
-        ],
-        outputKind: 'object',
-        effects: ['Deletes the subscribes_to edge from canvas.db.'],
-    },
-    run: async (input) => {
-        const publisher = input['publisher'];
-        const subscriber = resolveSubscriber(input);
-        await cliClient()
-            .unsubscribe(subscriber, publisher)
-            .catch((err) => rethrowAsCliError(err));
-        return { unsubscribed: true, subscriber, publisher };
-    },
-    render: (r) => `Unsubscribed ${r['subscriber']} from ${r['publisher']}.`,
-});
-const nodeSubscription = defineBranch({
-    name: 'subscription',
-    description: 'manage push-delivery edges between nodes',
-    whenToUse: 'you need an ongoing active or passive subscriber-to-publisher delivery edge that spawn did not create, or need to remove one',
-    help: { name: 'node subscription', summary: 'add or remove subscriber-to-publisher push-delivery edges' },
-    children: [nodeSubscribe, nodeUnsubscribe],
-});
-// ---------------------------------------------------------------------------
-// node promote — become an orchestrator (the worker→orchestrator polymorph)
-// ---------------------------------------------------------------------------
-const nodePromote = defineLeaf({
-    name: 'promote',
-    description: 'become an orchestrator of a chosen kind',
-    whenToUse: 'the remaining work contains independent units that can run in parallel, and the task is large enough that coordinating and integrating them will materially improve intelligence, productivity, or elapsed throughput. Become a long-lived, roadmap-holding orchestrator whose primary job is steering those children across refreshes (`node yield`). Keep sequential or tightly coupled work in base mode even when it spans phases or context windows; spawning one helper does not itself require promotion',
-    tier: 'important',
-    help: {
-        name: 'node promote',
-        summary: 'promote yourself to an orchestrator when worthwhile parallel delegation should make coordination your primary job; task duration, sequential phases, or one helper do not qualify. Mode only — lifecycle stays as-is unless you pass --resident',
-        params: [
-            { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: 'Specialize as this kind of orchestrator. The <kinds> list below names every top-level installable kind and when to use each; a sub-kind (e.g. plan/reviewers/security) is valid too by exact path but not listed here. For an exact composed persona list, use `crtr sys prompt-review --list --kind <kind>` with the target kind. Defaults to your current kind. Promoting from a generic kind? CHOOSE a concrete one — it sets the orchestrator persona you revive into.' },
-            { kind: 'flag', name: 'resident', type: 'bool', required: false, constraint: 'ALSO flip lifecycle→resident: make the node interactable — it stays dormant, woken by inbox/human, and is never forced to submit a final. Omit to stay terminal/orchestrator (delegates + holds a roadmap, but still owes a final up the spine and reaps when done).' },
-            { kind: 'flag', name: 'model', type: 'enum', choices: ['ultra', 'strong'], required: false, constraint: 'Change the model you run on, by capability tier: `ultra` (frontier — reserve for high-taste judgment or enormous work: speccing, planning something large, e2e-testing something hard to test) or `strong` (opus — regular dev work). Omit to keep your current model. An orchestrator steering work is never weaker than opus, so these are the only two choices; the change is durable across future revives.' },
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node to promote. Defaults to the caller (CRTR_NODE_ID).' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The promoted node.' },
-            { name: 'kind', type: 'string', required: true, constraint: 'The kind it now orchestrates as.' },
-            { name: 'mode', type: 'string', required: true, constraint: 'Now "orchestrator".' },
-            { name: 'model', type: 'string', required: false, constraint: 'The model tier it now runs on, present only when you changed it with --model.' },
-            { name: 'lifecycle', type: 'string', required: true, constraint: '"resident" if you passed --resident, else unchanged (typically "terminal").' },
-            { name: 'roadmap_written', type: 'boolean', required: true, constraint: 'True if a roadmap scaffold was seeded by this call.' },
-            { name: 'roadmap_path', type: 'string', required: true, constraint: 'Absolute path to your roadmap doc (context/roadmap.md) — edit it to author your plan.' },
-            { name: 'goal_path', type: 'string', required: true, constraint: 'Absolute path to your goal doc (context/initial-prompt.md) — the mandate you were spawned with.' },
-        ],
-        dynamicState: () => kindsStateBlock(),
-        outputKind: 'object',
-        effects: ['Flips mode→orchestrator + kind→chosen (lifecycle unchanged unless --resident, which also flips lifecycle→resident); --model durably pins the model tier; rewrites the launch spec to that kind\'s orchestrator persona; seeds context/roadmap.md scaffold if absent.', 'Your new-role guidance is injected automatically at the turn boundary by the persona injector — the command no longer returns it.'],
-    },
-    run: async (input) => {
-        const id = input['node'] ?? process.env['CRTR_NODE_ID'];
-        if (id === undefined || id === '')
-            throw new InputError({ error: 'no_node', message: 'no node to promote (set CRTR_NODE_ID or pass --node)', next: 'Run from inside a node, or pass --node <id>.' });
-        const kind = input['kind'];
-        if (kind !== undefined)
-            assertKind(kind);
-        const model = input['model'];
-        const resident = input['resident'] === true;
-        const detail = await cliClient()
-            .promoteNode(id, { ...(kind !== undefined ? { kind } : {}), ...(resident ? { resident: true } : {}), ...(model !== undefined ? { model } : {}) })
-            .catch((err) => rethrowAsCliError(err));
-        return {
-            node_id: detail.node_id,
-            kind: detail.kind,
-            mode: detail.mode,
-            lifecycle: detail.lifecycle,
-            ...(model !== undefined && detail.model_override != null ? { model: detail.model_override } : {}),
-            roadmap_written: detail.roadmap_written ?? false,
-            roadmap_path: detail.roadmap_path ?? '',
-            goal_path: detail.goal_path ?? '',
-        };
-    },
-});
-// ---------------------------------------------------------------------------
-// Shared lifecycle plumbing — the single implementation behind BOTH `node
-// lifecycle demote` (the friendly terminal-only verb that pairs with `node
-// promote`) and `node config --lifecycle` (the low-level orthogonal flip, which
-// also does resident).
-// ---------------------------------------------------------------------------
-/** Resolve the node a demote/config command acts on: explicit --node, else
- *  the node occupying --pane (the Alt+C menu passes #{pane_id}), else the caller
- *  (CRTR_NODE_ID). Throws a rendered error when none resolves or it is unknown. */
-async function resolveLifecycleNode(input, pane) {
-    let id = input['node'];
-    if (id === undefined || id === '')
-        id = nodeInPane(pane);
-    if (id === undefined || id === '')
-        id = process.env['CRTR_NODE_ID'];
-    if (id === undefined || id === '')
-        throw new InputError({ error: 'no_node', message: 'no node (set CRTR_NODE_ID, pass --node, or run from the agent\'s pane)', next: 'Run from inside a node, pass --node <id>, or --pane <pane>.' });
-    const exists = await getNodeOrNull(id);
-    if (exists === null)
-        throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
-    return id;
-}
-/** Set a node's lifecycle axis and, with `detach`, close its foreground viewer
- *  pane (the broker engine keeps running). Rebuilds the launch spec so a future
- *  revive comes back with the new lifecycle's prompt baked in (the live session
- *  is steered by the persona injector; this fixes the static prompt the daemon
- *  replays). Spine is fixed by parent-ness, so it carries through unchanged.
- *  The ONE implementation `node lifecycle demote` (always terminal) and
- *  `node config --lifecycle` (the passed value) both call — no duplication. */
-async function setLifecycle(id, value, opts) {
-    // The server owns the lifecycle flip + launch-spec rebuild (handleConfig).
-    const detail = await cliClient()
-        .patchConfig(id, { lifecycle: value })
-        .catch((err) => rethrowAsCliError(err));
-    // --detach: stop foregrounding the agent by closing its viewer pane (the
-    // broker engine keeps generating off-screen); now terminal, it pushes a final
-    // up the spine when it finishes, and a later `focus` reattaches a viewer. The
-    // pure-tmux tail owns the pane; the empty-shell reap is dropped (residual).
-    let detached = false;
-    if (opts.detach === true) {
-        const viewer = viewerPaneOf(id) ?? opts.pane;
-        if (viewer !== undefined && viewer !== '' && paneExists(viewer))
-            detached = closePane(viewer);
-    }
-    return { node_id: detail.node_id, lifecycle: detail.lifecycle, detached };
-}
-// ---------------------------------------------------------------------------
-// node lifecycle demote — flip a node to TERMINAL in place (the friendly half
-// of the promote/demote pair; bound to Alt+C → d, and → D with --detach). It
-// stays focused and running but now owes a final up the spine. A terminal-only
-// skin over the shared setLifecycle plumbing; `node config --lifecycle` is the
-// orthogonal low-level command (it also does resident). See vision F5.
-// ---------------------------------------------------------------------------
-const nodeDemote = defineLeaf({
-    name: 'demote',
-    description: 'demote a node to terminal in place; it stays focused and running but now owes a final; --detach also closes its viewer (broker keeps running off-screen)',
-    whenToUse: 'you are watching a resident/interactive node and want to put it on a finishing track WITHOUT disturbing it: flip it terminal IN PLACE — it keeps its viewer and your focus, keeps running, but now owes a final report up the spine and reaps when done. The friendly counterpart to `node promote`. You can also let go entirely and close its viewer so the agent finishes off-screen on its broker. Use `node lifecycle recycle` instead to FINISH it now and reboot a fresh root in its pane, and `node config --lifecycle` for the orthogonal low-level flip (incl. terminal→resident)',
-    help: {
-        name: 'node lifecycle demote',
-        summary: 'demote a node to terminal IN PLACE — it stays focused and running but now owes a final up the spine and reaps when done. Pairs with `node promote` (mode↑); `--detach` also closes its viewer (the broker engine keeps running off-screen)',
-        params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node to demote. Defaults to the node in --pane, else the caller (CRTR_NODE_ID).' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id whose node to demote, when --node is omitted. Defaults to $TMUX_PANE. The Alt+C menu passes this for you.' },
-            { kind: 'flag', name: 'detach', type: 'bool', required: false, constraint: 'After flipping terminal, stop foregrounding the agent by closing its viewer pane. The broker engine keeps generating off-screen and — now terminal — pushes a final up the spine when done; a later `focus` reattaches a viewer. The Alt+C → D move.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The demoted node.' },
-            { name: 'lifecycle', type: 'string', required: true, constraint: 'Always "terminal" after a demote.' },
-            { name: 'detached', type: 'boolean', required: false, constraint: 'True when --detach closed the agent\'s viewer pane (broker keeps running).' },
-        ],
-        outputKind: 'object',
-        effects: ['Flips the node\'s lifecycle→terminal and rebuilds its launch spec so a future revive boots terminal — it stays focused and running, now owing a final up the spine.', 'The persona injector delivers the transition guidance at the next turn boundary (or on the node\'s next revive if it is dormant).', 'With --detach: closes the agent\'s viewer pane WITHOUT touching the broker engine — it keeps generating off-screen, reconnectable by a later `focus`.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        const id = await resolveLifecycleNode(input, pane);
-        const res = await setLifecycle(id, 'terminal', { pane, detach: input['detach'] === true });
-        return { node_id: res.node_id, lifecycle: res.lifecycle, detached: res.detached };
-    },
-    render: (r) => `Demoted ${r['node_id']} — lifecycle now ${r['lifecycle']} (in place)${r['detached'] === true ? ', viewer closed (broker still running off-screen)' : ''}.`,
-});
-// ---------------------------------------------------------------------------
-// node lifecycle — recycle, close, or demote a node
-// ---------------------------------------------------------------------------
-const nodeLifecycle = defineBranch({
-    name: 'lifecycle',
-    description: 'lifecycle actions — recycle, close, demote, or revive a node',
-    whenToUse: 'you are ending, transitioning, or bringing back one node you can name: finish the agent in your pane and reboot a fresh root (`recycle`), tear a node + its exclusive subtree down without finishing (`close`), flip a node onto a finishing track in place (`demote`), or bring a dormant node back (`revive`). To merely SET the terminal/resident attribute headlessly use `node config --lifecycle`; to FINISH from inside a node\'s own turn use `crtr push final`; to mass-reconnect EVERY disconnected node at once use `canvas revive --all`.',
-    help: {
-        name: 'node lifecycle',
-        summary: 'end, transition, or revive a node — recycle the pane, close + cascade-cancel a subtree, demote to terminal in place, or revive a dormant node',
-    },
-    children: [nodeRecycle, nodeClose, nodeDemote, nodeReviveLeaf],
-});
-// ---------------------------------------------------------------------------
-// node yield — refresh: discard context, revive fresh in the same mode against roadmap or goal
-// ---------------------------------------------------------------------------
-const nodeYield = defineLeaf({
-    name: 'yield',
-    description: 'refresh your context, same mode, against your roadmap or goal',
-    whenToUse: 'your context is filling but the mandate remains; refresh in the same mode, or combine the refresh with promotion when meaningful independent work can run in parallel and coordinating it should become your primary job',
-    help: {
-        name: 'node yield',
-        summary: 'request a fresh context window against your roadmap or original goal; mode stays unchanged unless --promote is passed',
-        guide: 'Persist anything needed after refresh and send any pending human question before invoking; in-flight asks survive the refresh.',
-        params: [
-            { kind: 'flag', name: 'promote', type: 'bool', required: false, constraint: 'Also become an orchestrator as you refresh. Pass only when (1) the remaining work contains independent units that can run in parallel and (2) the task is large enough that parallel execution will materially improve intelligence, productivity, or elapsed throughput after coordination and synthesis. Task length, context exhaustion, sequential phases, or one helper are not enough; keep hands-on work in base mode and yield again as needed. Promote when coordinating and integrating children becomes your primary job. Already an orchestrator? This is not an error: your mode stays orchestrator and a missing roadmap is seeded.' },
-            { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: 'Respecialize as you refresh. The <kinds> list below names every top-level available kind and when to choose it; a sub-kind (e.g. plan/reviewers/security) is valid too by exact path but not listed here. Defaults to your current kind. With --promote it sets the orchestrator kind you become; without --promote it changes the kind while preserving your current mode.' },
-            { kind: 'flag', name: 'model', type: 'enum', choices: ['ultra', 'strong'], required: false, constraint: 'Change the model your fresh revive runs on, by capability tier: `ultra` (frontier — reserve for high-taste judgment or enormous work: speccing, planning something large, e2e-testing something hard to test) or `strong` (opus — regular dev work). Omit to keep your current model. A node steering work is never weaker than opus, so these are the only two choices; the change is durable across future revives.' },
-            // Deliberate fail-first contract (#395): builtin orchestration guidance shows bare
-            // `crtr node yield`; that invocation fails fast and surfaces yield's full help just in
-            // time, at the point of use. Keep the note required rather than pre-documenting stdin
-            // in kernel guidance.
-            { kind: 'stdin', name: 'message', required: true, constraint: 'A note to your future self — what to do the moment you wake fresh. Surfaced as <yield-message> in the next revive. Pass as a positional or pipe via heredoc.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The yielding node.' },
-            { name: 'promoted', type: 'boolean', required: true, constraint: 'True iff you passed --promote.' },
-            { name: 'model', type: 'string', required: false, constraint: 'The model tier your fresh revive will run on, present only when you changed it with --model.' },
-            { name: 'will_refresh', type: 'boolean', required: true, constraint: 'Always true: end your turn and you will revive fresh.' },
-        ],
-        dynamicState: () => kindsStateBlock(),
-        outputKind: 'object',
-        effects: ['Sets intent=refresh; the stophook shuts the process down on next stop and the daemon revives it fresh.', '--kind and/or --model durably reshape the node (kind respecialization, model-tier pin) before the refresh-revive; --promote additionally flips mode→orchestrator and seeds a roadmap scaffold — mode is otherwise left exactly as it was.'],
-    },
-    run: async (input) => {
-        const id = process.env['CRTR_NODE_ID'];
-        if (id === undefined || id === '')
-            throw new InputError({ error: 'no_node', message: 'no node to yield (CRTR_NODE_ID unset)', next: 'Run from inside a node.' });
-        const kind = input['kind'];
-        if (kind !== undefined)
-            assertKind(kind);
-        const model = input['model'];
-        const doPromote = input['promote'] === true;
-        const message = typeof input['message'] === 'string' ? input['message'].trim() : '';
-        if (message === '') {
-            throw new InputError({ error: 'empty_message', message: 'a yield message is required (stdin or positional)', next: 'Pass a note to your future self as an argument or pipe it on stdin.' });
-        }
-        // The server writes the yield note + sets intent=refresh (handleYield);
-        // `promoted`/`will_refresh` are derived client-side (a yield always refreshes;
-        // promoted iff --promote was passed).
-        const detail = await cliClient()
-            .yieldNode(id, { note: message, ...(kind !== undefined ? { kind } : {}), ...(model !== undefined ? { model } : {}), ...(doPromote ? { promote: true } : {}) })
-            .catch((err) => rethrowAsCliError(err));
-        return { node_id: detail.node_id, promoted: doPromote, ...(model !== undefined && detail.model_override != null ? { model: detail.model_override } : {}), will_refresh: true };
-    },
-});
-// ---------------------------------------------------------------------------
-// node wait — declare one controller message as a durable stop dependency
-// ---------------------------------------------------------------------------
-const nodeWait = defineLeaf({
-    name: 'controller',
-    description: 'wait durably for a named controller message',
-    whenToUse: 'you are a terminal node blocked on one specific live parent or controller and have no managed-child subscription whose report will wake you',
-    help: {
-        name: 'node wait controller',
-        summary: 'declare that your next stop may dorm only until one live controller delivers an inbox message',
-        params: [
-            { kind: 'positional', name: 'controller', type: 'string', required: true, constraint: 'Live node id expected to send the message. It may be your parent or another named controller, but cannot be yourself.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The terminal node that declared the wait.' },
-            { name: 'controller', type: 'string', required: true, constraint: 'The named live sender whose next inbox delivery clears this wait.' },
-        ],
-        outputKind: 'object',
-        effects: ['Durably records the controller on this node. The stop guard permits dormancy only while that controller remains active or idle; its next inbox delivery clears the record before the delivery wakes this node.'],
-    },
-    run: async (input) => {
-        const nodeId = process.env['CRTR_NODE_ID'];
-        if (nodeId === undefined || nodeId === '')
-            throw new InputError({ error: 'no_node', message: 'no node to wait (CRTR_NODE_ID unset)', next: 'Run from inside the terminal node that is blocked.' });
-        const node = await getNodeOrNull(nodeId);
-        if (node === null)
-            throw new InputError({ error: 'not_found', message: `no node: ${nodeId}`, next: 'Run from a live canvas node.' });
-        if (node.lifecycle !== 'terminal')
-            throw new InputError({ error: 'resident_node', message: `node ${nodeId} is resident and may already dorm on its inbox`, next: 'Use this only from a terminal node that needs the stop guard to recognize a controller dependency.' });
-        const controller = String(input['controller']).trim();
-        if (controller === nodeId)
-            throw new InputError({ error: 'self_controller', message: 'a node cannot wait for its own message', field: 'controller', next: 'Name the parent or external controller expected to send the message.' });
-        // The server validates the controller exists + is live and records the wait
-        // (handleWait); a 404/422 surfaces as the clean CLI error.
-        await cliClient()
-            .waitNode(nodeId, { controller })
-            .catch((err) => rethrowAsCliError(err));
-        return { node_id: nodeId, controller };
-    },
-    render: (r) => `Waiting for controller ${r['controller']}. End your turn to dorm; its next message wakes you and clears this wait.`,
-});
-const nodeWaitBranch = defineBranch({
-    name: 'wait',
-    description: 'declare a durable controller or deadline wait',
-    whenToUse: 'a terminal node must dorm for one named controller, or race its inbox against a self-scheduled deadline',
-    help: { name: 'node wait', summary: 'declare durable wait state; choose the event that settles it' },
-    children: [nodeWait, nodeWaitDeadline],
-});
-// ── /pyramid slash command ──────────────────────────────────────────────────────────────────────────────
-// Rides on the `node` subtree, not because pyramid is a `node` verb, but because
-// (1) the workflow IS node orchestration — it fans out explore agents — and
-// (2) provisionExports lazy-loads only the invoked subtree (build-root.ts), so a
-// slash spec only gets (re)written to the host's command dirs when its host
-// subtree runs; `node` is the most-invoked subtree, so `/pyramid` provisions
-// reliably. The body is a self-contained agent workflow prompt (pi prompt
-// template / Claude Code command), exported one-way by host-exports.
-const pyramidSlash = {
-    name: 'pyramid',
-    description: 'Explain a topic as a live-building Minto pyramid diagram, backed by parallel explore agents.',
-    argumentHint: '<topic to explain>',
-    body: [
-        '# Pyramid explanation',
-        '',
-        'Explain **$ARGUMENTS** as a *pyramid*: lead with the answer, support it with a few key pillars, ground each pillar in evidence. You build this as a LIVE termrender diagram that fills in as parallel research lands — the user watches the skeleton grow into a complete picture.',
-        '',
-        '## The pyramid (Minto principle)',
-        '- **Apex** — ONE crisp sentence: the single governing answer/claim, the thing worth remembering.',
-        '- **Pillars** — 2–4 MECE supporting arguments that together prove the apex.',
-        '- **Base** — concrete evidence under each pillar (mechanisms, `file:line` refs, numbers, sources).',
-        '',
-        'Top-down: the reader gets the conclusion first, then descends for as much support as they want.',
-        '',
-        '## Workflow',
-        '',
-        '1. **Frame it.** Restate the topic in one line and commit to a *working* apex hypothesis (you will sharpen it). Name the 2–4 pillars you expect to need.',
-        '',
-        '2. **Scaffold the live diagram FIRST.** Write the termrender skeleton below to `./pyramid-<slug>.md` (apex = your hypothesis, pillars = titles, every base entry marked `[?]` pending). Then open it live so the user watches it build:',
-        '   ```bash',
-        '   termrender pane open ./pyramid-<slug>.md --watch   # detached tmux side-pane; re-renders on every save',
-        '   ```',
-        '   Not in tmux? Tell the user to run `termrender doc watch ./pyramid-<slug>.md` in another terminal, then continue regardless.',
-        '',
-        '3. **Investigate in parallel — do not block.** Fan out ONE explore agent per pillar/unknown AND dig into what you can answer yourself, concurrently:',
-        '   ```bash',
-        '   crtr node new "Investigate: <focused question for this pillar>. Report findings with sources / file:line refs." --kind explore',
-        '   ```',
-        '   You auto-subscribe; each finish wakes you. Never poll or wait — kick them all off, then start filling in what you already know.',
-        '',
-        '4. **Live-update as findings land.** Every time you learn something — your own digging or an explore report — EDIT the diagram file: flip a `[?]` to `[x]` (or `[!]` for a caveat/risk), add evidence under the right pillar, sharpen or rewrite the apex, drop a pillar that did not hold. Each save re-renders the pane. The diagram visibly grows skeleton → complete.',
-        '',
-        '5. **Land it.** When the apex is one crisp sentence, the pillars are MECE, and the base is concrete, do a final pass for accuracy, then give the user a 3–4 sentence spoken summary that mirrors apex → pillars. Tell them the diagram file path.',
-        '',
-        '## termrender skeleton (write this verbatim, then keep editing it)',
-        '',
-        'Apex panel on top, a divider, then the pillars as a row of boxes below — a literal pyramid: 1 claim over N supports.',
-        '```markdown',
-        ':::panel{title="<TOPIC>" color="cyan"}',
-        '**<one-line apex answer — your governing claim>**',
-        ':::',
-        '',
-        ':::divider{label="why"}',
-        ':::',
-        '',
-        '::::::columns',
-        ':::::col{width="33%"}',
-        '::::panel{title="Pillar 1 — <claim>" color="green"}',
-        ':::tree',
-        'evidence A [x]',
-        'evidence B [?]',
-        ':::',
-        '::::',
-        ':::::',
-        ':::::col{width="33%"}',
-        '::::panel{title="Pillar 2 — <claim>" color="green"}',
-        ':::tree',
-        'evidence C [?]',
-        ':::',
-        '::::',
-        ':::::',
-        ':::::col{width="34%"}',
-        '::::panel{title="Pillar 3 — <claim>" color="green"}',
-        ':::tree',
-        'evidence D [?]',
-        ':::',
-        '::::',
-        ':::::',
-        '::::::',
-        '```',
-        '',
-        '**Nesting rule (termrender will reject the file otherwise): an OUTER directive needs strictly MORE colons than the directive nested inside it.** Hence `::::::columns` (6) wraps `:::::col` (5) wraps `::::panel` (4) wraps `:::tree` (3). Every block closes with a bare run of its OWN colon count on its own line. Run `termrender doc check ./pyramid-<slug>.md` after each edit — if it errors, fix the colon counts before re-saving.',
-        '',
-        'Markers inside a tree: `[x]` → ✔ confirmed, `[!]` → ⚠ caveat/risk; `[?]` is not a marker and stays literal — use it for still-pending. Write structure only — termrender draws every box, border, and guide line; never hand-draw ASCII. Keep the apex to one sentence; push all detail into the base.',
-    ].join('\n'),
-};
 export function registerNode() {
     return defineBranch({
         name: 'node',
@@ -2070,7 +16,7 @@ export function registerNode() {
         rootEntry: {
             concept: 'a unit of the agent runtime — an agent on the canvas with its own context dir and pi vehicle. Spawning nodes is how work gets done here, not an optimization you reach for late',
             desc: 'spawn, inspect, and navigate nodes on the canvas',
-            useWhen: 'delegating a genuinely independent subtask, or walking the subscription graph. Base nodes work hands-on; orchestrators fan out. Give each child a bounded outcome distinct from your whole assignment so delegation moves work toward completion instead of recursively passing it down. Once delegated, do not duplicate the child’s work; its finish wakes you. Use the help surface for the exact node contract before invoking it.'
+            useWhen: 'delegating a genuinely independent subtask, or walking the subscription graph. Base nodes work hands-on; orchestrators fan out. Give each child a bounded outcome distinct from your whole assignment so delegation moves work toward completion instead of recursively passing it down. Once delegated, do not duplicate the child’s work; its finish wakes you. Use the help surface for the exact node contract before invoking it.',
         },
         help: {
             name: 'node',