@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/commands/node.js

@@ -2,8 +2,11 @@
 //
 // A node is the unit of the runtime: an agent with its own identity, context
 // dir, and pi vehicle, pinned to a cwd. This subtree spawns terminal workers
-// onto the canvas (`new`), inspects the graph (`inspect list|show`), and walks
-// the spine (`focus`/`msg`). The push/feed half lives under `crtr push`.
+// onto the canvas (`new`), inspects nodes (`inspect`), messages any node and
+// wires the subscribes_to spine (`msg`/`subscribe`/`unsubscribe`), changes
+// lifecycle (`lifecycle`), reconfigures node settings (`config`), and
+// walks/focuses the graph (`focus`/`cycle`). The push/feed half lives under
+// `crtr push`, and pending trigger inspection lives under `triggers`.
 import { defineLeaf, defineBranch } from '../core/command.js';
 import { InputError } from '../core/io.js';
 import { spawnChild } from '../core/runtime/spawn.js';
@@ -11,16 +14,21 @@ import { promote, requestYield } from '../core/runtime/promote.js';
 import { writeYieldMessage, readGoal } from '../core/runtime/kickoff.js';
 import { reviveNode } from '../core/runtime/revive.js';
 import { newNodeId } from '../core/runtime/nodes.js';
-import { readRoadmap } from '../core/runtime/roadmap.js';
+import { readRoadmap, hasRoadmap, seedRoadmap } from '../core/runtime/roadmap.js';
 import { parseWhen, parseCadence, cadenceDisplay } from '../core/wake.js';
+import { nodeSnapshotLeaf } from './node-snapshot.js';
+import { nodeContextLeaf } from './node-context.js';
 import { recycleNode } from '../core/runtime/recycle.js';
-import { detachToBackground, focus as placementFocus, windowAlive, windowOfPane, currentTmux, getPaneOption } from '../core/runtime/placement.js';
-import { buildLaunchSpec } from '../core/runtime/launch.js';
+import { readFaultAsync } from '../core/runtime/fault.js';
+import { activeFaultForDisplay } from '../core/canvas/render.js';
+import { detachToBackground, focus as placementFocus, windowAlive, windowOfPane, currentTmux, getPaneOption, renameWindow } from '../core/runtime/placement.js';
+import { buildLaunchSpec, normalizeModel } from '../core/runtime/launch.js';
 import { closeNode } from '../core/runtime/close.js';
+import { isBrokerLive, setModelLive, persistDormantModel } from '../core/runtime/model-swap.js';
 import { appendInbox } from '../core/feed/inbox.js';
-import { availableKinds, kindWhenToUse, subPersonasFor } from '../core/personas/index.js';
+import { availableKinds, kindWhenToUse } from '../core/personas/index.js';
 import { stateBlock } from '../core/help.js';
-import { getNode, updateNode, listNodes, subscribe, unsubscribe, subscriptionsOf, subscribersOf, readContextTokens, view, armWake, listWakes, cancelWake, WakeArmError, } from '../core/canvas/index.js';
+import { getNode, updateNode, listNodes, subscribe, unsubscribe, subscriptionsOf, subscribersOf, readContextTokens, view, armTrigger, listTriggers, cancelTrigger, TriggerArmError, fullName, } from '../core/canvas/index.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
@@ -56,11 +64,8 @@ function assertKind(kind) {
  *  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.
  *
- *  CONTEXT-AWARE: when the CALLER is a live node (CRTR_NODE_ID set) whose kind
- *  has sub-personas available to it, a SECOND `<sub-personas for=K count=M>`
- *  block is appended right after — the specialist sub-personas THAT kind may
- *  spawn (full kind string + whenToUse). Everything but the top-level `<kinds>`
- *  block soft-fails to omission (caller block wrapped in its own try/catch). */
+ *  Keep this block cheap and caller-agnostic: help should not depend on the
+ *  running node's current persona env, which can lag after polymorph. */
 function kindsStateBlock() {
     const kinds = availableKinds();
     const lines = kinds
@@ -69,70 +74,55 @@ function kindsStateBlock() {
         return w ? `${k} — ${w}` : k;
     })
         .join('\n');
-    const block = stateBlock('kinds', { count: kinds.length }, lines);
-    const sub = callerSubPersonasBlock();
-    return sub ? `${block}\n${sub}` : block;
-}
-/** When the caller is a live node whose kind has sub-personas available to it,
- *  render a `<sub-personas for="<kind>" count=M>` block — one
- *  `<full-kind-string> — <whenToUse>` line per sub-persona spawnable BY that
- *  kind (e.g. `plan/reviewers/security`). Returns '' (so the second block is
- *  omitted) when CRTR_NODE_ID is unset, getNode returns null, the caller kind
- *  has no sub-personas, or anything throws — this is help output, never error. */
-function callerSubPersonasBlock() {
-    try {
-        const id = process.env['CRTR_NODE_ID'];
-        if (id === undefined || id === '')
-            return '';
-        const node = getNode(id);
-        if (node === null)
-            return '';
-        const subs = subPersonasFor(node.kind);
-        if (subs.length === 0)
-            return '';
-        const lines = subs.map((s) => (s.whenToUse ? `${s.kind} — ${s.whenToUse}` : s.kind)).join('\n');
-        return stateBlock('sub-personas', { for: node.kind, count: subs.length }, lines);
-    }
-    catch {
-        return '';
-    }
+    return stateBlock('kinds', { count: kinds.length }, lines);
 }
 // ---------------------------------------------------------------------------
 // node new — spawn a terminal worker as a detached headless broker under the root
 // ---------------------------------------------------------------------------
 const nodeNew = defineLeaf({
     name: 'new',
-    description: 'spawn a node — a managed child (default), or an independent root with --root',
-    whenToUse: 'you have a self-contained unit of work — reach for this instead of doing it inline, so the reading and the tokens land in a fresh window and only the conclusion comes back: mapping an unfamiliar part of the codebase, writing a spec, designing an approach, breaking a job into a plan, implementing a change, or running a review. Fan independent units out as concurrent children. Most spawns are managed children whose finish wakes you; reach here too when a unit is itself too big for one window (boot it directly as its own sub-orchestrator rather than hope a base worker promotes itself) or when you are handing off an INDEPENDENT node you will neither manage nor be woken by, e.g. one a human will sit and drive',
+    description: 'spawn a node now — a managed child (default), an independent root with --root, or arm a trigger that births it later',
+    whenToUse: 'you have a self-contained unit of work — reach for this instead of doing it inline, so the reading and the tokens land in a fresh window and only the conclusion comes back: mapping an unfamiliar part of the codebase, writing a spec, designing an approach, breaking a job into a plan, implementing a change, or running a review. Fan independent units out as concurrent children. Most spawns are managed children whose finish wakes you; reach here too when a unit is itself too big for one window (boot it directly as its own sub-orchestrator rather than hope a base worker promotes itself) or when you are handing off an INDEPENDENT node you will neither manage nor be woken by, e.g. one a human will sit and drive. Add `--at`/`--every` to defer or recur the birth instead of spawning now, or `--when` to birth it once an external predicate exits 0',
     tier: 'important',
     help: {
         name: 'node new',
-        summary: 'spawn a terminal worker onto the canvas as a detached broker — returns its node id',
+        summary: 'spawn a terminal worker onto the canvas as a detached broker — returns its node id. With --at/--every/--when, arms a node_birth trigger instead: nothing is spawned now, and the full recipe is stored/re-derived at fire time',
         params: [
             { kind: 'stdin', name: 'prompt', required: true, constraint: 'First user message for the spawned node. Deliver it on stdin from a quoted heredoc (`<<\'EOF\'`) or a file (`< prompt.md`).' },
-            { kind: 'flag', name: 'kind', type: 'string', required: false, default: 'general', constraint: 'Persona kind — match the work to the kind. The <kinds> list below names every installable kind and when to use each; the <sub-personas> block (when present) names the specialist sub-personas available to YOU, each spawnable by its full kind string (e.g. plan/reviewers/security).' },
+            { kind: 'flag', name: 'kind', type: 'string', required: false, default: 'general', constraint: 'Persona kind — match the work to the kind. The <kinds> list below names every installable kind and when to use each. For an exact composed persona list, use `crtr sys prompt-review --list --kind <kind>`.' },
             { kind: 'flag', name: 'mode', type: 'enum', choices: ['base', 'orchestrator'], required: false, default: 'base', constraint: 'Persona mode. base for a worker that finishes in one window; orchestrator to create the child directly as a sub-orchestrator (it boots with the orchestrator persona + a seeded roadmap and fans its scope out) — use it when the unit is too large for one window, e.g. a big review, instead of spawning a base worker and counting on it to promote itself.' },
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Dir the node is pinned to. Defaults to the caller cwd.' },
+            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Dir the node is pinned to. Defaults to the caller cwd, resolved now — for a triggered spawn it must still exist at fire time or the spawn fails loud.' },
             { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Display name (tmux window + resume picker). Defaults to the kind.' },
             { kind: 'flag', name: 'parent', type: 'string', required: false, constraint: 'Parent node id. Defaults to the calling node (CRTR_NODE_ID).' },
             { kind: 'flag', name: 'root', type: 'bool', required: false, constraint: 'Spawn an INDEPENDENT root instead of a managed child: no parent (top-level on the canvas), NO subscription back to you (you are NOT woken by it), resident lifecycle. It records spawned_by=you for provenance and is brought forefront so it can be driven directly. Use for a node you hand off and do not manage (e.g. a sub-orchestrator a human will discuss with).' },
             { kind: 'flag', name: 'fork-from', type: 'string', required: false, constraint: 'FORK the new node from an existing pi conversation instead of starting it fresh: pass a node id (forks from that node\'s session), an absolute session `.jsonl` path, or a partial pi session uuid. pi copies that whole history into a NEW session for the child (the source is untouched), then the prompt is delivered as the next message — i.e. the child wakes up as a continuation of that conversation. Use to branch exploratory work off a node that already built up the context you need, instead of re-deriving it. One-shot at birth: the fork resumes its own session thereafter.' },
-            { kind: 'flag', name: 'model', type: 'enum', choices: ['ultra', 'strong', 'medium', 'light'], required: false, constraint: 'Override the model the node runs on, by capability TIER: ultra (frontier), strong (opus), medium (sonnet), light (haiku). Omit to use the kind\'s persona default (explore=light, every other kind=strong). The override is durable — it survives revives and polymorphs (promote/demote).' },
+            { kind: 'flag', name: 'model', type: 'enum', choices: ['ultra', 'strong', 'medium', 'light'], required: false, constraint: 'Override the model the node runs on, by capability TIER: ultra (frontier), strong (opus), medium (sonnet), light (haiku). Omit to use the kind\'s persona default (advisor=ultra, explore=light, most other builtins=strong). The override is durable — it survives revives and polymorphs (promote/demote).' },
+            { kind: 'flag', name: 'at', type: 'string', required: false, constraint: 'DEFER the birth to a one-shot clock trigger at this future time instead of spawning now — a duration ("5m","1h30m"), a zoned ISO ("2026-06-07T09:00:00Z"), or a bare ISO ("2026-06-07T09:00", host-local or in --tz). Required unless --every is given (the cadence then sets the first fire). Mutually exclusive with --when.' },
+            { kind: 'flag', name: 'every', type: 'string', required: false, constraint: 'SPAWN-CRON: re-birth a fresh node on this cadence — a duration ("6h","30m") or a 5-field cron / @alias ("0 9 * * *","@daily"). Combine with --at to anchor the first fire, then recur normally. Min cadence 60s. With --when, this instead sets the PREDICATE EVALUATION cadence (required), not a repeating birth.' },
+            { kind: 'flag', name: 'when', type: 'string', required: false, constraint: 'Arm a daemon-evaluated bash predicate instead of a clock trigger: exit 0 births the node once, non-zero leaves it armed for the next evaluation. Requires --every (eval cadence) and --timeout (wall-clock bound). Mutually exclusive with --at.' },
+            { kind: 'flag', name: 'timeout', type: 'string', required: false, constraint: 'Wall-clock bound for a --when predicate — a duration or absolute time after which the trigger is consumed and the owner gets one urgent notice with no node born. Required with --when; rejected otherwise.' },
+            { kind: 'flag', name: 'tz', type: 'string', required: false, constraint: 'IANA zone for a calendar --every or a bare-ISO --at (default: host-local). Valid only alongside --at/--every; rejected with --when, and rejected when spawning now (no trigger flags) since neither has anything to parse it against.' },
         ],
         output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The new node id.' },
-            { name: 'name', type: 'string', required: true, constraint: 'Display name.' },
-            { name: 'window', type: 'string', required: false, constraint: 'tmux window id of the viewer opened for an in-tmux --root (a `crtr attach` view onto the node\'s broker); absent for a managed child, which opens no viewer on spawn.' },
-            { name: 'session', type: 'string', required: false, constraint: 'The tmux session a --root\'s viewer opened into (your current session); absent for a managed child and for a --root spawned outside tmux.' },
-            { name: 'status', type: 'string', required: true, constraint: 'Always "active" on spawn.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Decision road sign for the caller: the child runs independently and its finish wakes you on its own, so never wait or poll on it — either pick up other work now or end your turn. If you are an orchestrator already deep in context (>100k), it instead steers you to `crtr node yield` now so your fresh revive absorbs the child\'s result. Read it, then act.' },
+            { name: 'node_id', type: 'string', required: false, constraint: 'The new node id. Present only when spawning now (no trigger flags).' },
+            { name: 'name', type: 'string', required: false, constraint: 'Display name. Present only when spawning now (no trigger flags).' },
+            { name: 'window', type: 'string', required: false, constraint: 'tmux window id of the viewer opened for an in-tmux --root (a surface attach view onto the node\'s broker); absent for a managed child (opens no viewer on spawn) and absent whenever armed.' },
+            { name: 'session', type: 'string', required: false, constraint: 'The tmux session a --root\'s viewer opened into (your current session); absent for a managed child, for a --root spawned outside tmux, and absent whenever armed.' },
+            { name: 'status', type: 'string', required: false, constraint: 'Always "active". Present only when spawning now (no trigger flags).' },
+            { name: 'armed', type: 'boolean', required: true, constraint: 'True when a node_birth trigger was armed for later (--at/--every/--when) instead of spawning now.' },
+            { name: 'id', type: 'string', required: false, constraint: 'The trigger id (inspect/cancel it via `node triggers`), present only when armed=true.' },
+            { name: 'trigger_type', type: 'string', required: false, constraint: '"at", "every", or "when", present only when armed=true.' },
+            { name: 'fires_at', type: 'string', required: false, constraint: 'Absolute UTC birth time, present only for an armed clock trigger.' },
+            { name: 'next_eval_at', type: 'string', required: false, constraint: 'The next predicate-evaluation instant (always "now" at arm time), present only for an armed --when trigger.' },
+            { name: 'timeout_at', type: 'string', required: false, constraint: 'Absolute UTC wall-clock bound, present only for an armed --when trigger.' },
+            { name: 'recur', type: 'string', required: false, constraint: 'Cadence display ("every 6h", cron, or eval cadence for --when), present only when --every was given.' },
+            { name: 'follow_up', type: 'string', required: true, constraint: 'Decision road sign for the caller. Spawned now: the child runs independently and its finish wakes you on its own, so never wait or poll on it — either pick up other work now or end your turn (an orchestrator already deep in context is instead steered to `crtr node yield`). Armed: no node exists yet — inspect/cancel via `crtr node triggers list`/`cancel <id>`, then pick up other work or end your turn.' },
         ],
         dynamicState: () => kindsStateBlock(),
         outputKind: 'object',
         effects: [
-            'Creates a node under ~/.crouter/canvas/nodes/<id>/ and indexes it in canvas.db.',
-            'Default (managed child): parent auto-subscribes (active) and is woken on the child\'s pushes. With --root: no subscription — records a spawned_by edge for provenance only.',
-            'Launches the node\'s engine as a detached broker (the only host). A managed child opens NO viewer — it runs headless and you open one on demand via `crtr node focus` / `crtr attach`. With --root inside tmux, opens one viewer window in your CURRENT session and switches the client to it so the root can be driven directly; outside tmux a --root opens no viewer.',
+            'Spawning now: creates a node under ~/.crouter/canvas/nodes/<id>/ and indexes it in canvas.db. Default (managed child): parent auto-subscribes (active) and is woken on the child\'s pushes. With --root: no subscription — records a spawned_by edge for provenance only. Launches the node\'s engine as a detached broker (the only host); a managed child opens NO viewer, a --root opens one in your current tmux session.',
+            'Armed (--at/--every/--when): inserts one detached `new`/`node_birth` triggers row (node_id NULL, owner=you, parent/cwd resolved now); NO node and NO window exist until fire time. The daemon spawns from the stored recipe at fire time, re-deriving the launch spec live.',
         ],
     },
     run: async (input) => {
@@ -148,19 +138,154 @@ const nodeNew = defineLeaf({
         const root = input['root'] === true;
         const forkFrom = input['forkFrom'];
         const model = input['model'];
-        const res = spawnChild({ kind, mode, cwd, name, prompt, parent, root, forkFrom, model });
+        const at = input['at']?.trim();
+        const every = input['every']?.trim();
+        const whenRaw = input['when'];
+        const hasWhen = whenRaw !== undefined && whenRaw.trim() !== '';
+        const timeout = input['timeout']?.trim();
+        const hasTimeout = timeout !== undefined && timeout !== '';
+        const tz = input['tz'];
+        const hasTz = tz !== undefined && tz.trim() !== '';
+        const hasAt = at !== undefined && at !== '';
+        const hasEvery = every !== undefined && every !== '';
+        const triggered = hasAt || hasEvery || hasWhen;
+        if (hasTz && hasWhen) {
+            throw new InputError({ error: 'tz_not_valid_with_when', message: '--tz has no effect with --when (predicate evaluation parses no calendar timezone)', field: 'tz', next: 'Drop --tz.' });
+        }
+        if (hasTz && !hasAt && !hasEvery) {
+            throw new InputError({ error: 'tz_needs_clock', message: '--tz has no effect without --at or --every to parse it against', field: 'tz', next: 'Drop --tz, or pass --at/--every.' });
+        }
+        if (!triggered) {
+            const res = await spawnChild({ kind, mode, cwd, name, prompt, parent, root, forkFrom, model });
+            return {
+                node_id: res.node.node_id,
+                name: res.node.name,
+                window: res.window ?? undefined,
+                session: res.session ?? undefined,
+                status: res.node.status,
+                armed: false,
+                follow_up: root
+                    ? "Independent root spawned — it is NOT under you. You are not subscribed, so its finish will NOT wake you and it does not hold you alive; it carries spawned_by=you for lineage only. Inside tmux it opened a viewer in your current session (the client switched to it) so it can be driven directly. Hand it off and move on — you will not be notified of its progress."
+                    : childFollowUp(parent ?? process.env['CRTR_NODE_ID']),
+            };
+        }
+        if (hasWhen && hasAt) {
+            throw new InputError({ error: 'bad_when_combo', message: '--when cannot combine with --at', next: 'A trigger is either clock-driven (--at/--every) or predicate-driven (--when).' });
+        }
+        if (hasWhen && !hasEvery) {
+            throw new InputError({ error: 'when_needs_every', message: '--when requires --every (the evaluation cadence)', next: 'Pass --every <cadence> alongside --when.' });
+        }
+        if (hasWhen && !hasTimeout) {
+            throw new InputError({ error: 'when_needs_timeout', message: '--when requires --timeout (the wall-clock bound)', next: 'Pass --timeout <duration> alongside --when.' });
+        }
+        if (hasTimeout && !hasWhen) {
+            throw new InputError({ error: 'timeout_needs_when', message: '--timeout is only valid with --when', next: 'Drop --timeout, or pass --when to make this a predicate trigger.' });
+        }
+        const ownerId = armerId();
+        const recipeParent = parent ?? ownerId;
+        const recipe = {
+            kind,
+            mode,
+            cwd,
+            prompt,
+            parent: recipeParent,
+            ...(name !== undefined ? { name } : {}),
+            ...(root ? { root: true } : {}),
+            ...(forkFrom !== undefined ? { forkFrom } : {}),
+            ...(model !== undefined ? { model } : {}),
+        };
+        const id = `tr-${newNodeId()}`;
+        if (hasWhen) {
+            const now = new Date();
+            const cad = parseCadence(every, parseOpts(now, undefined));
+            if ('error' in cad)
+                throwTimeError(cad.error);
+            const t = parseWhen(timeout, { now });
+            if ('error' in t)
+                throwTimeError(t.error);
+            assertUnderCap(ownerId);
+            armTriggerOrThrow({
+                trigger_id: id,
+                node_id: null,
+                owner_id: ownerId,
+                action: 'new',
+                action_mode: 'node_birth',
+                trigger_type: 'when',
+                when_script: whenRaw.trim(),
+                eval_every: cad.recur,
+                next_eval_at: now.toISOString(),
+                timeout_at: t.fireAt,
+                payload: recipe,
+            });
+            return {
+                armed: true,
+                id,
+                kind,
+                trigger_type: 'when',
+                recur: cadenceDisplay(cad.recur),
+                next_eval_at: now.toISOString(),
+                timeout_at: t.fireAt,
+                follow_up: `Predicate spawn armed — evaluated ${cadenceDisplay(cad.recur)} (first check now), bounded by a wall-clock timeout at ${t.fireAt}. No node exists yet; inspect/cancel via \`crtr node triggers list\` / \`crtr node triggers cancel ${id}\`. Pick up other work or end your turn.`,
+            };
+        }
+        const now = new Date();
+        let recur;
+        let fireAt;
+        if (hasEvery) {
+            const cad = parseCadence(every, parseOpts(now, tz));
+            if ('error' in cad)
+                throwTimeError(cad.error);
+            recur = cad.recur;
+            fireAt = cad.firstFireAt;
+            // BOTH --at and --every (fixed-interval or cron): --at anchors the first
+            // fire; recurrence thereafter advances from wall-clock `now` at settle
+            // time (nextSlotAfter), independent of the anchor, so this holds for
+            // both cadence shapes.
+            if (hasAt) {
+                const w = parseWhen(at, parseOpts(now, tz));
+                if ('error' in w)
+                    throwTimeError(w.error);
+                fireAt = w.fireAt;
+            }
+        }
+        else {
+            const w = parseWhen(at, parseOpts(now, tz));
+            if ('error' in w)
+                throwTimeError(w.error);
+            fireAt = w.fireAt;
+        }
+        assertUnderCap(ownerId);
+        armTriggerOrThrow({
+            trigger_id: id,
+            node_id: null,
+            owner_id: ownerId,
+            action: 'new',
+            action_mode: 'node_birth',
+            trigger_type: recur !== undefined ? 'every' : 'at',
+            fire_at: fireAt,
+            ...(recur !== undefined ? { recur } : {}),
+            payload: recipe,
+        });
+        const eta = etaHint(fireAt, now);
+        const follow_up = recur !== undefined
+            ? `Spawn-cron armed (${cadenceDisplay(recur)}): a fresh ${kind} node is born each fire, first at ${fireAt}${eta}. No node exists yet; the runtime keeps spawning even across your crash/finalize — inspect/cancel via \`crtr node triggers list\` / \`crtr node triggers cancel ${id}\`.`
+            : `Deferred spawn armed: a fresh ${kind} node is born at ${fireAt}${eta}. No node exists yet — inspect/cancel via \`crtr node triggers list\` / \`crtr node triggers cancel ${id}\`. Pick up other work or end your turn.`;
         return {
-            node_id: res.node.node_id,
-            name: res.node.name,
-            window: res.window ?? undefined,
-            session: res.session ?? undefined,
-            status: res.node.status,
-            follow_up: root
-                ? "Independent root spawned — it is NOT under you. You are not subscribed, so its finish will NOT wake you and it does not hold you alive; it carries spawned_by=you for lineage only. Inside tmux it opened a viewer in your current session (the client switched to it) so it can be driven directly. Hand it off and move on — you will not be notified of its progress."
-                : childFollowUp(parent ?? process.env['CRTR_NODE_ID']),
+            armed: true,
+            id,
+            kind,
+            trigger_type: recur !== undefined ? 'every' : 'at',
+            fires_at: fireAt,
+            ...(recur !== undefined ? { recur: cadenceDisplay(recur) } : {}),
+            follow_up,
         };
     },
     render: (r) => {
+        if (r['armed'] === true) {
+            const recur = r['recur'] ? `, recurs ${r['recur']}` : '';
+            const when = r['fires_at'] ? `fires ${r['fires_at']}${recur}` : `next eval ${r['next_eval_at']}, timeout ${r['timeout_at']}`;
+            return `Armed deferred spawn ${r['id']} — a ${r['kind']} node, ${when}.\n\n${r['follow_up']}`;
+        }
         const win = r['window'] ? ` in window ${r['window']}` : '';
         const lines = [`Spawned "${r['name']}" (${r['node_id']}) — ${r['status']}${win}.`];
         if (r['session'])
@@ -170,33 +295,77 @@ const nodeNew = defineLeaf({
     },
 });
 // ---------------------------------------------------------------------------
-// node list — the active canvas (or a status slice)
+// 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, optionally sliced by status: a quick read of what exists and what is still running. 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 which nodes are blocked on a human',
+    whenToUse: 'you want a flat roster of the nodes on the canvas, sliced by any combination of attribute filters (status, kind, mode, lifecycle, cwd, hanging) and graph scope (--under a node, for that node plus its subscription descendants). The filters AND together, so any attribute filter can be paired with any other, and with --under, to narrow by both criteria and subtree at once. 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 which nodes are blocked on a human',
     help: {
         name: 'node inspect list',
-        summary: 'list nodes on the canvas, optionally by status',
+        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: active | idle | done | dead | canceled. Comma-separated for several. 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: '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 installable kind.' },
+            { 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: '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: 'hanging', type: 'bool', required: false, constraint: 'Only nodes PARKED on an active fault (live broker + marker when provider-owned). Use to find stuck/rate-limited nodes awaiting auto-revive.' },
         ],
         output: [
-            { name: 'nodes', type: 'object[]', required: true, constraint: 'Rows: {node_id, name, kind, mode, lifecycle, status, cwd, parent, created}.' },
+            { name: 'nodes', type: 'object[]', required: true, constraint: 'Rows: {node_id, name, kind, mode, lifecycle, status, cwd, parent, created, hanging}. `hanging` is null normally, or {kind, message, since} when the node is PARKED on an active fault (rate-limit/overloaded/connection/other); the canvas-graph views render it with ⚠ + a countdown or state cue.' },
         ],
         outputKind: 'object',
-        effects: ['Read-only: queries canvas.db.'],
+        dynamicState: () => kindsStateBlock(),
+        effects: ['Read-only: queries canvas.db (+ an active-fault marker read).'],
     },
     run: async (input) => {
-        const raw = input['status'];
-        const status = raw !== undefined && raw !== '' ? raw.split(',').map((s) => s.trim()) : undefined;
-        const nodes = listNodes(status !== undefined ? { status } : undefined);
-        return { nodes };
+        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 cwd = input['cwd'];
+        const under = input['under'];
+        const hangingOnly = input['hanging'] === true;
+        // 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 (getNode(under) === 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, ...view(under)]);
+        }
+        const rows = listNodes(status !== undefined ? { status } : undefined).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 (cwd !== undefined && cwd !== '' && row.cwd !== cwd)
+                return false;
+            return true;
+        });
+        // Enrich each row with its active-fault state. Daemon-owned provider faults
+        // are suppressed when the broker pid is gone; manual/client faults stay
+        // visible until cleared.
+        const nodes = await Promise.all(rows.map(async (row) => {
+            const hanging = activeFaultForDisplay(row, await readFaultAsync(row.node_id));
+            return { ...row, hanging };
+        }));
+        return { nodes: nodes.filter((n) => !hangingOnly || n.hanging !== null) };
     },
 });
 // ---------------------------------------------------------------------------
-// node show — a node + its place in the spine
+// node inspect show — a node + its place in the spine
 // ---------------------------------------------------------------------------
 const nodeShow = defineLeaf({
     name: 'show',
@@ -215,6 +384,11 @@ const nodeShow = defineLeaf({
         ],
         outputKind: 'object',
         effects: ['Read-only: reads the node meta + canvas.db edges.'],
+        // The node meta object inlines the full system prompt + every telemetry
+        // field — a machine-readable dump with no useful human-glance slice to
+        // synthesize (unlike dashboard/list's tabular rows), same rationale as
+        // canvas snapshot / node inspect snapshot.
+        preview: { suppressOutput: true },
     },
     run: async (input) => {
         const id = input['node'];
@@ -226,17 +400,17 @@ const nodeShow = defineLeaf({
     },
 });
 // ---------------------------------------------------------------------------
-// node inspect — read the graph (list + show)
+// node inspect — read the graph (list, show, snapshot, context)
 // ---------------------------------------------------------------------------
 const nodeInspect = defineBranch({
     name: 'inspect',
-    description: 'read the graph (list nodes / show one)',
-    whenToUse: 'reading the graph: enumerate the nodes on the canvas (`list`) or drill into one and its spine neighbors (`show`). Use `canvas dashboard` instead to render the tree SHAPE, or `canvas attention` to find which nodes are blocked on a human',
+    description: 'read the graph (list, show, snapshot, context)',
+    whenToUse: 'reading the graph: enumerate nodes on the canvas (`list`), inspect one and its spine neighbors (`show`), or pull a dormant session snapshot with `node inspect snapshot` / browse on-disk context dirs with `node inspect context` while reading a node. Use `canvas dashboard` instead to render the tree SHAPE, or `canvas attention` to find which nodes are blocked on a human',
     help: {
         name: 'node inspect',
-        summary: 'read the canvas graph — enumerate nodes or inspect one with its spine neighbors',
+        summary: 'read the canvas graph — enumerate nodes, inspect one, or pull snapshot/context views for a node (including dormant session snapshots and on-disk context dirs)',
     },
-    children: [nodeList, nodeShow],
+    children: [nodeList, nodeShow, nodeSnapshotLeaf, nodeContextLeaf],
 });
 // ---------------------------------------------------------------------------
 // node focus — bring a node's viewer forefront (across roots if needed)
@@ -244,10 +418,10 @@ const nodeInspect = defineBranch({
 const nodeFocus = defineLeaf({
     name: 'focus',
     description: 'bring a node\'s viewer forefront',
-    whenToUse: 'you want to bring a specific node into view — open or move its viewer beside your current pane — to watch or steer it directly, reviving its broker first if dormant. Use `node cycle` instead to walk neighbors one viewer at a time rather than jump to a named node, and `node msg` to steer a node without leaving where you are',
+    whenToUse: 'you want to bring a specific node into view — open or move its viewer beside your current pane — to watch or steer it directly, reviving its broker first if dormant. Use `node cycle` instead to walk neighbors one viewer at a time rather than jump to a named node, and `node msg --to` to steer a node without leaving where you are',
     help: {
         name: 'node focus',
-        summary: 'bring a node\'s viewer forefront — open a `crtr attach` view onto the node\'s broker beside your current pane, or navigate to its existing viewer. The engine runs on the broker (the only host); the pane is just a window onto it.',
+        summary: 'bring a node\'s viewer forefront — open a surface attach view onto the node\'s broker beside your current pane, or navigate to its existing viewer. The engine runs on the broker (the only host); the pane is just a window onto 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).' },
@@ -260,7 +434,7 @@ const nodeFocus = defineLeaf({
             { 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: ['Ensures the node\'s broker engine is alive (revives it if dormant) and opens/moves its one viewer pane (a `crtr attach` view) beside the caller, or navigates to it if a live viewer already sits in the caller\'s session.', 'With --new-pane: always splits a fresh viewer beside the caller (two agents on screen) instead of reusing the existing viewer.'],
+        effects: ['Ensures the node\'s broker engine is alive (revives it if dormant) and opens/moves its one viewer pane (a surface attach view) beside the caller, or navigates to it if a live viewer already sits in the caller\'s session.', 'With --new-pane: always splits a fresh viewer beside the caller (two agents on screen) instead of reusing the existing viewer.'],
     },
     run: async (input) => {
         const id = input['node'];
@@ -282,19 +456,19 @@ const nodeFocus = defineLeaf({
         // (revive it if dormant), then open/move its one viewer pane beside the
         // caller (or split a fresh viewer with --new-pane). The reviver is injected
         // so placement need not import revive.ts.
-        const res = placementFocus(id, {
+        const res = await placementFocus(id, {
             pane: input['pane'],
             newPane: input['newPane'] === true,
-            revive: (nid) => { reviveNode(nid, { resume: true }); },
+            revive: (nid) => reviveNode(nid, { resume: true }),
         });
         return { focused: res.focused, session: res.session, revived: res.revived, in_place: res.inPlace };
     },
 });
 // ---------------------------------------------------------------------------
-// node recycle — FINALIZE the agent in your pane + recycle it into a fresh root
+// 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 demote` (±--detach),
+// 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.
 // ---------------------------------------------------------------------------
 /** First live node whose window id is `win` (each node owns one window). The
@@ -308,11 +482,11 @@ function nodeByWindow(win) {
 }
 /** The live node "in front of you" in a tmux pane, HOST-AGNOSTIC. Defaults to
  *  $TMUX_PANE / the caller's current pane when `pane` is omitted — shared by
- *  `node recycle` / `node demote` / `node lifecycle` / `node close` / `node
+ *  `node lifecycle recycle` / `node lifecycle demote` / `node config --lifecycle` / `node lifecycle close` / `node
  *  cycle`, and the `canvas chord` leaf.
  *
  *  Two resolutions, tried in order:
- *    1. VIEWER pane (broker host): a `crtr attach` viewer self-tags its pane with
+ *    1. VIEWER pane (broker host): a `crtr surface attach` viewer self-tags its pane with
  *       the node it views (`@crtr_node`). A broker engine runs DETACHED with
  *       window=null, so the window→node lookup never finds it — the pane tag is
  *       the only handle. Checked FIRST because the tag is pane-precise, whereas a
@@ -337,9 +511,9 @@ export function nodeInPane(pane) {
 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 demote` instead to put it on a finishing track IN PLACE (flip terminal, keep it running) without ending it now, `node 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',
+    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 recycle',
+        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).' },
@@ -390,14 +564,14 @@ const nodeRecycle = defineLeaf({
     },
 });
 // ---------------------------------------------------------------------------
-// node close — close a node + cascade-cancel its exclusive subtree (Alt+C → x)
+// 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 (`canvas revive`). Use `node 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)',
+    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 (`canvas 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 close',
+        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 canvas revive`)',
         params: [
             { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node to close. Defaults to the node occupying --pane (or your current pane).' },
@@ -439,6 +613,160 @@ const nodeClose = defineLeaf({
     },
 });
 // ---------------------------------------------------------------------------
+// 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 installable kind and when to use each.' },
+            { 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 = resolveLifecycleNode(input, pane);
+        const applied = [];
+        const modelSpec = input['model']?.trim();
+        if (modelSpec !== undefined) {
+            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.' });
+            }
+            let resolved;
+            const meta = getNode(nodeId);
+            if (meta === null)
+                throw new InputError({ error: 'not_found', message: `no node: ${nodeId}`, next: 'List nodes with `crtr node inspect list`.' });
+            if (isBrokerLive(meta)) {
+                try {
+                    resolved = await setModelLive(nodeId, modelSpec);
+                }
+                catch (err) {
+                    throw new InputError({ error: 'switch_failed', message: `live model switch failed: ${err instanceof Error ? err.message : String(err)}`, next: 'Check the spec resolves (`provider/id`, tier, alias, or a substring of a registered model).' });
+                }
+            }
+            else {
+                const normalized = normalizeModel(modelSpec);
+                if (!normalized.includes('/')) {
+                    throw new InputError({ error: 'unresolvable_dormant', message: `'${modelSpec}' does not resolve to a concrete model for a dormant node`, field: 'model', next: 'Pass an exact `provider/id` (e.g. openai-codex/gpt-5.5) or a tier/alias — the live registry search is only available while the node\'s broker is up.' });
+                }
+                persistDormantModel(nodeId, normalized);
+                resolved = normalized;
+            }
+            applied.push('model');
+        }
+        let meta = getNode(nodeId);
+        if (meta === null) {
+            throw new InputError({ error: 'not_found', message: `no node: ${nodeId}`, next: 'List nodes with `crtr node inspect list`.' });
+        }
+        const kindSpec = input['kind']?.trim();
+        const lifecycleSpec = input['lifecycle']?.trim();
+        const modeSpec = input['mode']?.trim();
+        if (kindSpec !== undefined || lifecycleSpec !== undefined || modeSpec !== undefined) {
+            if (kindSpec !== undefined)
+                assertKind(kindSpec);
+            let newLifecycle = meta.lifecycle;
+            if (lifecycleSpec !== undefined) {
+                const value = lifecycleSpec.toLowerCase();
+                if (value !== 'terminal' && value !== 'resident') {
+                    throw new InputError({ error: 'bad_lifecycle', message: `invalid lifecycle: ${lifecycleSpec}`, field: 'lifecycle', next: 'Pass `terminal` or `resident`.' });
+                }
+                newLifecycle = value;
+            }
+            let newMode = meta.mode;
+            if (modeSpec !== undefined) {
+                const value = modeSpec.toLowerCase();
+                if (value !== 'base' && value !== 'orchestrator') {
+                    throw new InputError({ error: 'bad_mode', message: `invalid mode: ${modeSpec}`, field: 'mode', next: 'Pass `base` or `orchestrator`.' });
+                }
+                newMode = value;
+            }
+            const newKind = kindSpec ?? meta.kind;
+            if (newMode === 'orchestrator' && !hasRoadmap(nodeId)) {
+                const goal = readGoal(nodeId);
+                seedRoadmap(nodeId, goal !== null && goal.trim() !== '' ? { goal: goal.trim() } : {});
+            }
+            const { launch } = buildLaunchSpec(newKind, newMode, {
+                lifecycle: newLifecycle,
+                hasManager: meta.parent !== null,
+                model: meta.model_override ?? undefined,
+            });
+            meta = updateNode(nodeId, {
+                ...(kindSpec !== undefined ? { kind: newKind } : {}),
+                ...(lifecycleSpec !== undefined ? { lifecycle: newLifecycle } : {}),
+                ...(modeSpec !== undefined ? { mode: newMode } : {}),
+                launch,
+            });
+            if (kindSpec !== undefined)
+                applied.push('kind');
+            if (lifecycleSpec !== undefined)
+                applied.push('lifecycle');
+            if (modeSpec !== undefined)
+                applied.push('mode');
+        }
+        const nameSpec = input['name'];
+        if (nameSpec !== undefined) {
+            meta = updateNode(nodeId, { name: nameSpec });
+            if (meta.window)
+                renameWindow(meta.window, fullName(meta));
+            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 result = { node_id: nodeId, applied };
+        if (getNode(nodeId)?.model_override !== undefined && applied.includes('model'))
+            result.model = getNode(nodeId).model_override;
+        if (applied.includes('lifecycle'))
+            result.lifecycle = getNode(nodeId).lifecycle;
+        if (applied.includes('kind'))
+            result.kind = getNode(nodeId).kind;
+        if (applied.includes('mode'))
+            result.mode = getNode(nodeId).mode;
+        if (applied.includes('name'))
+            result.name = getNode(nodeId).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(', ')}`;
+    },
+});
+// ---------------------------------------------------------------------------
 // node cycle — DFS-walk the canvas one window at a time (Alt+] / Alt+[)
 // ---------------------------------------------------------------------------
 /** Every live node in DFS pre-order across the whole forest. The spawn tree is
@@ -513,9 +841,9 @@ const nodeCycle = defineLeaf({
             return { focused: false, from: fromId };
         // Placement brings the neighbor's viewer forefront beside the caller,
         // relaunching its broker engine first if it was dormant.
-        const res = placementFocus(targetId, {
+        const res = await placementFocus(targetId, {
             pane,
-            revive: (nid) => { reviveNode(nid, { resume: true }); },
+            revive: (nid) => reviveNode(nid, { resume: true }),
         });
         return { focused: res.focused, node_id: targetId, name: target.name, from: fromId };
     },
@@ -524,50 +852,403 @@ const nodeCycle = defineLeaf({
         : 'No other live node to focus.',
 });
 // ---------------------------------------------------------------------------
-// node msg — direct-address any node at a wake tier (wakes a dormant target)
+// node msg — message any node now, or arm a trigger (clock or predicate) that
+// messages/revives it later. See the node-trigger-grammar spec's §Command
+// surface / §node msg.
 // ---------------------------------------------------------------------------
+/** Max pending triggers a single owner may hold. */
+const TRIGGER_CAP = 100;
+/** Resolve the calling node (the armer/owner of a trigger). CRTR_NODE_ID is
+ *  mandatory — a trigger is owned by the node that arms it (owner_id). */
+function armerId() {
+    const id = process.env['CRTR_NODE_ID'];
+    if (id === undefined || id === '') {
+        throw new InputError({ error: 'no_node', message: 'no node to arm a trigger (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 (parseWhen/parseCadence) 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.' });
+}
+/** Run armTrigger, mapping its thrown integrity backstop (TriggerArmError) to a
+ *  rendered error block. The surface validates these cases up front, so a throw
+ *  here is a backstop, not the primary path. */
+function armTriggerOrThrow(spec) {
+    try {
+        return armTrigger(spec);
+    }
+    catch (e) {
+        if (e instanceof TriggerArmError) {
+            const next = {
+                empty_body: 'Provide a real body, or use --fresh for a fresh revive with no message.',
+                deadline_cannot_recur: 'Drop --every — a deadline cannot recur.',
+                bad_action_mode: 'This is a crtr bug — report it.',
+            };
+            throw new InputError({ error: e.code, message: e.message, next: next[e.code] ?? 'Fix the trigger spec and retry.' });
+        }
+        throw e;
+    }
+}
+/** Reject an arm that would push this owner past the pending-triggers cap. */
+function assertUnderCap(ownerId) {
+    const pending = listTriggers({ owner: ownerId }).length;
+    if (pending >= TRIGGER_CAP) {
+        throw new InputError({
+            error: 'cap_exceeded',
+            message: `you hold ${pending} pending triggers (cap ${TRIGGER_CAP}).`,
+            next: 'Reap stale triggers with `crtr node triggers cancel <id>` (see `crtr node triggers list`) before arming more.',
+        });
+    }
+}
+/** A fresh revive resumes a window with no memory beyond disk, so it needs
+ *  durable state to wake INTO. Accept it only when the target has a goal
+ *  (initial-prompt.md) or roadmap (roadmap.md) on disk. */
+function hasRecoverableState(nodeId) {
+    const goal = readGoal(nodeId);
+    if (goal !== null && goal.trim() !== '')
+        return true;
+    const roadmap = readRoadmap(nodeId);
+    return roadmap !== null && roadmap.trim() !== '';
+}
+/** 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 `node msg` target: exactly one of --to/--self. */
+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 };
+    }
+    if (getNode(to) === 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 nodeMsg = defineLeaf({
     name: 'msg',
-    description: 'direct-message any node at a wake tier',
-    whenToUse: 'you want to address a specific node directly — steer it mid-flight, hand it a correction, ping it, or pass it new information — and have it land regardless of subscriptions, reviving a dormant target. You set how urgently it lands, from an immediate interrupt to a note read on its next cycle. Use `node subscribe` instead to wire ongoing push delivery rather than send a one-off, and `push` to report UP your own spine',
+    description: 'message any node now, or arm a trigger that messages/revives it later',
+    whenToUse: 'you want to address a specific node directly — steer it mid-flight, hand it a correction, ping it, pass it new information, or schedule any of that for later — regardless of subscriptions. Default delivers immediately and revives a dormant target; `--at`/`--every` arm a clock trigger instead of acting now; `--fresh` revives with no inbox entry; `--self --until` puts a deadline backstop on your current inbox-wait; `--when` arms a daemon-evaluated predicate for an external condition (CI, a deploy) you cannot otherwise be pushed for. Use `node subscribe` instead to wire ONGOING push delivery rather than a one-off, `push` to report UP your own spine, and `node new` to schedule the BIRTH of a node rather than message an existing one',
     help: {
         name: 'node msg',
-        summary: 'send a direct message to any node\'s inbox at a wake tier — a direct message wakes the node regardless of subscriptions (reviving it if dormant)',
+        summary: 'message a node now, or arm a trigger (clock or predicate) that messages/revives it later. No trigger flag → immediate inbox delivery (or immediate fresh revive with --fresh). --at/--every → clock trigger. --self --until → self-only deadline backstop on the current inbox-wait. --when → daemon-evaluated predicate, fires once on exit 0',
         params: [
-            { kind: 'positional', name: 'node', required: true, constraint: 'Target node id.' },
-            { kind: 'stdin', name: 'body', required: true, constraint: 'Message body. Positional (after the node id is consumed) or stdin.' },
-            { kind: 'flag', name: 'tier', type: 'enum', choices: ['critical', 'urgent', 'normal', 'deferred'], required: false, default: 'normal', constraint: 'How it lands: critical = interrupt + new turn; urgent = steer mid-turn; normal = follow-up; deferred = read on next cycle.' },
+            { kind: 'stdin', name: 'body', required: false, constraint: 'Message body. Positional or stdin. Required for a plain or clock-triggered message and for --until. Forbidden with --fresh. Optional with --when — if omitted, the predicate\'s captured stdout becomes the body when it fires.' },
+            { kind: 'flag', name: 'to', type: 'string', required: false, constraint: 'Target an existing node by id. Exactly one of --to/--self is required.' },
+            { kind: 'flag', name: 'self', type: 'bool', required: false, constraint: 'Target the calling node (CRTR_NODE_ID). Exactly one of --to/--self is required. Required for --until.' },
+            { kind: 'flag', name: 'tier', type: 'enum', choices: ['critical', 'urgent', 'normal', 'deferred'], required: false, constraint: 'Inbox delivery urgency: critical = interrupt + new turn; urgent = steer mid-turn; normal = follow-up; deferred = read on next cycle. Defaults to normal when omitted. Valid for a plain or --when inbox message (immediate or clock-triggered); forbidden with --fresh or --until (--until is always urgent).' },
+            { kind: 'flag', name: 'fresh', type: 'bool', required: false, constraint: 'Fresh-revive the target instead of delivering a message: no inbox entry, just a clean revive (resume:false). Valid alone (revives now) or with --at/--every (arms a clock-triggered fresh revive). Forbidden with a body, --tier, --until, or --when. Rejected if the target has no goal/roadmap on disk (would resume amnesiac).' },
+            { kind: 'flag', name: 'at', type: 'string', required: false, constraint: 'Arm a one-shot clock trigger at this future time instead of acting now — a duration ("5m","1h30m"), a zoned ISO ("2026-06-07T09:00:00Z"), or a bare ISO ("2026-06-07T09:00", host-local or in --tz). Required unless --every is given (the cadence then sets the first fire). Mutually exclusive with --when.' },
+            { kind: 'flag', name: 'every', type: 'string', required: false, constraint: 'Arm a recurring clock trigger on this cadence — a duration ("6h","30m") or a 5-field cron / @alias ("0 9 * * *","@daily"). Combine with --at to anchor the first fire, then recur normally. Min cadence 60s. With --when, this instead sets the PREDICATE EVALUATION cadence (required), not a repeating action.' },
+            { kind: 'flag', name: 'when', type: 'string', required: false, constraint: 'Arm a daemon-evaluated bash predicate instead of a clock trigger: exit 0 fires the message once, non-zero leaves it armed for the next evaluation. Requires --every (eval cadence) and --timeout (wall-clock bound). Mutually exclusive with --at, --fresh, and --until.' },
+            { kind: 'flag', name: 'until', type: 'string', required: false, constraint: 'Self-only: bind a deadline to your current dormancy — you wake on the first inbox message, or at this time if none arrives (whichever fires first cancels the other). One-shot, urgent tier, ≤ 1 per node (a new --until replaces any prior). Mutually exclusive with --at, --every, --when, --fresh, --tier, and --timeout. Requires --self and a body.' },
+            { kind: 'flag', name: 'timeout', type: 'string', required: false, constraint: 'Wall-clock bound for a --when predicate — a duration or absolute time after which the trigger is consumed and the owner gets one urgent notice. Required with --when; rejected otherwise.' },
+            { kind: 'flag', name: 'tz', type: 'string', required: false, constraint: 'IANA zone for a calendar --every, a bare-ISO --at, or a bare-ISO --until (default: host-local). Valid only alongside --at/--every/--until; rejected with --when, and rejected when acting immediately (no trigger flags) since none of those have anything to parse it against.' },
         ],
         output: [
-            { name: 'delivered', type: 'boolean', required: true, constraint: 'True when the message was appended to the target inbox.' },
-            { name: 'node_id', type: 'string', required: true, constraint: 'Target node.' },
-            { name: 'woke', type: 'boolean', required: true, constraint: 'True when a dormant target was revived to receive it.' },
+            { name: 'mode', type: 'string', required: true, constraint: '"inbox_message", "fresh_revive", or "deadline_message" — what this message enacts.' },
+            { name: 'armed', type: 'boolean', required: true, constraint: 'True when a trigger row was armed for later (--at/--every/--when/--until); false when the action happened immediately.' },
+            { 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 immediately (armed=false, mode=inbox_message).' },
+            { name: 'revived', type: 'boolean', required: false, constraint: 'True when a dormant target was revived to receive an immediate delivery, or when an immediate --fresh fired the revive now.' },
+            { name: 'id', type: 'string', required: false, constraint: 'The trigger id (cancel/list it via `node triggers`), present only when armed=true.' },
+            { name: 'trigger_type', type: 'string', required: false, constraint: '"at", "every", "when", or "until", present only when armed=true.' },
+            { name: 'fires_at', type: 'string', required: false, constraint: 'Absolute UTC fire time, present only for an armed clock or deadline trigger.' },
+            { name: 'next_eval_at', type: 'string', required: false, constraint: 'The next predicate-evaluation instant (always "now" at arm time), present only for an armed --when trigger.' },
+            { name: 'timeout_at', type: 'string', required: false, constraint: 'Absolute UTC wall-clock bound, present only for an armed --when trigger.' },
+            { name: 'recur', type: 'string', required: false, constraint: 'Cadence display ("every 6h", cron, or eval cadence for --when), present only when --every was given.' },
+            { name: 'guidance', type: 'string', required: true, constraint: 'What to do now — end your turn to go dormant when armed; delivery confirmation when immediate.' },
         ],
         outputKind: 'object',
-        effects: ['Appends a message entry to the target inbox.jsonl.', 'Revives the target (resume) if it has no live window.'],
+        effects: [
+            'Immediate inbox_message: appends a message entry to the target inbox.jsonl and best-effort revives the target if dormant.',
+            'Immediate fresh_revive: revives the target now with no inbox entry (resume:false).',
+            'Armed (--at/--every/--when/--until): inserts one triggers row; nothing fires/evaluates until the daemon\'s next pass. No pi spawn, no transition — end your turn separately to go dormant.',
+            '--until upserts the node\'s single deadline trigger, replacing any prior.',
+        ],
     },
     run: async (input) => {
-        const id = input['node'];
-        const target = getNode(id);
-        if (target === null)
-            throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
-        const body = (input['body'] ?? '').trim();
-        if (body === '')
-            throw new InputError({ error: 'empty_body', message: 'a message body is required', field: 'body', next: 'Pass the message after the node id or on stdin.' });
-        const tier = (input['tier'] ?? 'normal');
+        const { targetId, isSelf } = 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 at = input['at']?.trim();
+        const every = input['every']?.trim();
+        const whenRaw = input['when'];
+        const hasWhen = whenRaw !== undefined && whenRaw.trim() !== '';
+        const until = input['until']?.trim();
+        const hasUntil = until !== undefined && until !== '';
+        const timeout = input['timeout']?.trim();
+        const hasTimeout = timeout !== undefined && timeout !== '';
+        const tz = input['tz'];
+        const hasAt = at !== undefined && at !== '';
+        const hasEvery = every !== undefined && every !== '';
+        // --- Validation per the approved flag matrix ---
+        if (hasUntil && !isSelf) {
+            throw new InputError({ error: 'until_self_only', message: '--until is self-only', field: 'until', next: 'Use --self, or drop --until.' });
+        }
+        if (hasUntil && (hasAt || hasEvery || hasWhen || fresh || hasTier || hasTimeout)) {
+            throw new InputError({ error: 'bad_until_combo', message: '--until cannot combine with --at, --every, --when, --fresh, --tier, or --timeout', next: 'Drop the conflicting flag(s), or remove --until for a different trigger.' });
+        }
+        if (hasWhen && (hasAt || fresh)) {
+            throw new InputError({ error: 'bad_when_combo', message: '--when cannot combine with --at or --fresh', next: 'A trigger is either clock-driven (--at/--every/--fresh) or predicate-driven (--when).' });
+        }
+        if (hasWhen && !hasEvery) {
+            throw new InputError({ error: 'when_needs_every', message: '--when requires --every (the evaluation cadence)', next: 'Pass --every <cadence> alongside --when.' });
+        }
+        if (hasWhen && !hasTimeout) {
+            throw new InputError({ error: 'when_needs_timeout', message: '--when requires --timeout (the wall-clock bound)', next: 'Pass --timeout <duration> alongside --when.' });
+        }
+        if (hasTimeout && !hasWhen) {
+            throw new InputError({ error: 'timeout_needs_when', message: '--timeout is only valid with --when', next: 'Drop --timeout, or pass --when to make this a predicate trigger.' });
+        }
+        if (fresh && (hasBody || hasTier || hasUntil || hasWhen)) {
+            throw new InputError({ error: 'bad_fresh_combo', message: '--fresh cannot combine with a body, --tier, --until, or --when', next: 'Drop the conflicting flag(s) — --fresh is a fresh revive, not a message.' });
+        }
+        const hasTz = tz !== undefined && tz.trim() !== '';
+        if (hasTz && hasWhen) {
+            throw new InputError({ error: 'tz_not_valid_with_when', message: '--tz has no effect with --when (predicate evaluation parses no calendar timezone)', field: 'tz', next: 'Drop --tz.' });
+        }
+        if (hasTz && !hasAt && !hasEvery && !hasUntil) {
+            throw new InputError({ error: 'tz_needs_trigger', message: '--tz has no effect without --at, --every, or --until to parse it against', field: 'tz', next: 'Drop --tz, or pass --at/--every/--until.' });
+        }
+        const target = isSelf ? 'self' : targetId;
+        // --- Deadline (--until): self-only, one-shot, urgent ---
+        if (hasUntil) {
+            if (!hasBody) {
+                throw new InputError({ error: 'empty_body', message: 'a body is required for --until', field: 'body', next: 'Pass a timeout playbook after the target flags or on stdin.' });
+            }
+            const owner = armerId();
+            const now = new Date();
+            const w = parseWhen(until, parseOpts(now, tz));
+            if ('error' in w)
+                throwTimeError(w.error);
+            assertUnderCap(owner);
+            const payload = { body: body, timeout: true, label: body.split('\n')[0].slice(0, 120) };
+            const id = `tr-${newNodeId()}`;
+            armTriggerOrThrow({
+                trigger_id: id,
+                node_id: targetId,
+                owner_id: owner,
+                action: 'msg',
+                action_mode: 'deadline_message',
+                trigger_type: 'until',
+                fire_at: w.fireAt,
+                payload,
+            });
+            const eta = etaHint(w.fireAt, now);
+            const guidance = `Deadline armed. You wake on the first inbox message, or at ${w.fireAt}${eta} if none arrives. Now delegate / end your turn to go dormant — whichever fires first cancels the other.`;
+            return { mode: 'deadline_message', armed: true, id, target, trigger_type: 'until', fires_at: w.fireAt, guidance };
+        }
+        // --- Predicate (--when) ---
+        if (hasWhen) {
+            const owner = armerId();
+            const now = new Date();
+            const cad = parseCadence(every, parseOpts(now, undefined));
+            if ('error' in cad)
+                throwTimeError(cad.error);
+            const t = parseWhen(timeout, { now });
+            if ('error' in t)
+                throwTimeError(t.error);
+            assertUnderCap(owner);
+            // A supplied body is delivered as-is; omitted body means stdout becomes the
+            // body when the predicate fires (spec's stdout-as-body rule) — armTrigger
+            // accepts a body-less payload only for this trigger_type='when' case.
+            const payload = {
+                ...(hasBody ? { body: body } : {}),
+                label: hasBody ? body.split('\n')[0].slice(0, 120) : `(stdout) ${whenRaw.trim().split('\n')[0].slice(0, 110)}`,
+                ...(hasTier ? { tier: tierRaw } : {}),
+            };
+            const id = `tr-${newNodeId()}`;
+            armTriggerOrThrow({
+                trigger_id: id,
+                node_id: targetId,
+                owner_id: owner,
+                action: 'msg',
+                action_mode: 'inbox_message',
+                trigger_type: 'when',
+                when_script: whenRaw.trim(),
+                eval_every: cad.recur,
+                next_eval_at: now.toISOString(),
+                timeout_at: t.fireAt,
+                payload,
+            });
+            const guidance = `Predicate trigger armed — evaluated ${cadenceDisplay(cad.recur)} (first check now), bounded by a wall-clock timeout at ${t.fireAt}. Fires once the predicate exits 0; non-zero leaves it armed. End your turn to go dormant; do not push final.`;
+            return {
+                mode: 'inbox_message',
+                armed: true,
+                id,
+                target,
+                trigger_type: 'when',
+                next_eval_at: now.toISOString(),
+                timeout_at: t.fireAt,
+                recur: cadenceDisplay(cad.recur),
+                guidance,
+            };
+        }
+        // --- Clock trigger (--at / --every), no --when/--until ---
+        if (hasAt || hasEvery) {
+            if (fresh) {
+                if (!hasRecoverableState(targetId)) {
+                    throw new InputError({
+                        error: 'fresh_no_recoverable_state',
+                        message: `node ${targetId} has no goal/roadmap on disk — a fresh revive would resume amnesiac.`,
+                        next: 'Seed a goal/roadmap first, or drop --fresh so the woken context carries a message.',
+                    });
+                }
+            }
+            else if (!hasBody) {
+                throw new InputError({ error: 'empty_body', message: 'a message body is required (or --fresh for a clock-triggered revive)', field: 'body', next: 'Pass the message after the target flags or on stdin.' });
+            }
+            const owner = armerId();
+            const now = new Date();
+            let recur;
+            let fireAt;
+            if (hasEvery) {
+                const cad = parseCadence(every, parseOpts(now, tz));
+                if ('error' in cad)
+                    throwTimeError(cad.error);
+                recur = cad.recur;
+                fireAt = cad.firstFireAt;
+                // BOTH --at and --every (fixed-interval or cron): --at anchors the first
+                // fire; recurrence thereafter advances from wall-clock `now` at settle
+                // time (nextSlotAfter), independent of the anchor, so this holds for
+                // both cadence shapes.
+                if (hasAt) {
+                    const w = parseWhen(at, parseOpts(now, tz));
+                    if ('error' in w)
+                        throwTimeError(w.error);
+                    fireAt = w.fireAt;
+                }
+            }
+            else {
+                const w = parseWhen(at, parseOpts(now, tz));
+                if ('error' in w)
+                    throwTimeError(w.error);
+                fireAt = w.fireAt;
+            }
+            assertUnderCap(owner);
+            const actionMode = fresh ? 'fresh_revive' : 'inbox_message';
+            const payload = fresh
+                ? null
+                : { body: body, label: body.split('\n')[0].slice(0, 120), ...(hasTier ? { tier: tierRaw } : {}) };
+            const id = `tr-${newNodeId()}`;
+            armTriggerOrThrow({
+                trigger_id: id,
+                node_id: targetId,
+                owner_id: owner,
+                action: 'msg',
+                action_mode: actionMode,
+                trigger_type: recur !== undefined ? 'every' : 'at',
+                fire_at: fireAt,
+                ...(recur !== undefined ? { recur } : {}),
+                payload,
+            });
+            const eta = etaHint(fireAt, now);
+            const guidance = recur !== undefined
+                ? `${fresh ? 'Fresh-revive' : 'Message'} recurrence armed (${cadenceDisplay(recur)}); first fire ${fireAt}${eta}. End your turn to go dormant; do not push final. The runtime keeps firing it even across your crash/finalize — cancel with \`crtr node triggers cancel ${id}\`.`
+                : fresh
+                    ? `Fresh-revive armed. The target wakes in a fresh window at ${fireAt}${eta}, re-reading its roadmap. End your turn now to go dormant; do not push final.`
+                    : `Message armed. It is delivered at ${fireAt}${eta}. End your turn now to go dormant; do not push final.`;
+            return {
+                mode: actionMode,
+                armed: true,
+                id,
+                target,
+                trigger_type: recur !== undefined ? 'every' : 'at',
+                fires_at: fireAt,
+                ...(recur !== undefined ? { recur: cadenceDisplay(recur) } : {}),
+                guidance,
+            };
+        }
+        // --- Immediate (no trigger flag) ---
+        if (fresh) {
+            if (!hasRecoverableState(targetId)) {
+                throw new InputError({
+                    error: 'fresh_no_recoverable_state',
+                    message: `node ${targetId} has no goal/roadmap on disk — a fresh revive would resume amnesiac.`,
+                    next: 'Seed a goal/roadmap first, or drop --fresh so the woken context carries a message.',
+                });
+            }
+            reviveNode(targetId, { resume: false });
+            return {
+                mode: 'fresh_revive',
+                armed: false,
+                target,
+                revived: true,
+                guidance: `Fresh-revived ${isSelf ? 'yourself' : targetId} now — it resumes a clean window re-reading its roadmap/disk.`,
+            };
+        }
+        if (!hasBody) {
+            throw new InputError({ error: 'empty_body', message: 'a message body is required (or --fresh / --when)', field: 'body', next: 'Pass the message after the target flags or on stdin.' });
+        }
+        const targetMeta = getNode(targetId);
+        if (targetMeta === null) {
+            throw new InputError({ error: 'not_found', message: `no node: ${targetId}`, next: 'List nodes with `crtr node inspect list`.' });
+        }
+        const tier = (hasTier ? tierRaw : 'normal');
         const from = process.env['CRTR_NODE_ID'] ?? 'human';
-        appendInbox(id, { from, tier, kind: 'message', label: body.split('\n')[0].slice(0, 120), data: { body } });
+        // A long body clips in the receiver's digest; appendInbox mints a short `id`
+        // for it so the receiver can read the full text back via `feed message <id>`.
+        appendInbox(targetId, { from, tier, kind: 'message', label: body.split('\n')[0].slice(0, 120), data: { body: body } });
         // A direct message wakes any node: if the target has no live window
         // (done/dead/idle-released), revive it so its inbox-watcher delivers this.
         let woke = false;
-        if (!windowAlive(target.tmux_session, target.window)) {
+        if (!windowAlive(targetMeta.tmux_session, targetMeta.window)) {
             try {
-                reviveNode(id, { resume: true });
+                void reviveNode(targetId, { resume: true });
                 woke = true;
             }
-            catch { /* best-effort wake */ }
+            catch {
+                /* best-effort wake */
+            }
         }
-        return { delivered: true, node_id: id, woke };
+        return { mode: 'inbox_message', armed: false, target, delivered: true, revived: woke, guidance: woke ? 'Delivered — the dormant target was revived to receive it.' : 'Delivered.' };
+    },
+    render: (r) => {
+        if (r['armed'] === true) {
+            const recur = r['recur'] ? `, recurs ${r['recur']}` : '';
+            const when = r['fires_at'] ? `fires ${r['fires_at']}${recur}` : `next eval ${r['next_eval_at']}, timeout ${r['timeout_at']}`;
+            return `Armed ${r['mode']} trigger ${r['id']} (${r['trigger_type']}) — ${when}, target ${r['target']}.\n\n${r['guidance']}`;
+        }
+        return `${r['guidance']}`;
     },
 });
 // ---------------------------------------------------------------------------
@@ -657,7 +1338,7 @@ const nodePromote = defineLeaf({
         name: 'node promote',
         summary: 'promote yourself to an orchestrator — do this when your task outgrows one context window (many phases to delegate and persist across refreshes); not for work that fits one window, and not merely because you spawned a child. 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 installable kind and when to use each; the <sub-personas> block (when present) names the specialist sub-personas available to YOU, spawnable by full kind string. 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: 'kind', type: 'string', required: false, constraint: 'Specialize as this kind of orchestrator. The <kinds> list below names every installable kind and when to use each. 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).' },
@@ -691,10 +1372,11 @@ const nodePromote = defineLeaf({
 });
 // ---------------------------------------------------------------------------
 // Shared lifecycle plumbing — the single implementation behind BOTH `node
-// demote` (the friendly terminal-only verb that pairs with `node promote`) and
-// `node lifecycle` (the low-level orthogonal flip, which also does resident).
+// 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/lifecycle command acts on: explicit --node, else
+/** 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. */
 function resolveLifecycleNode(input, pane) {
@@ -714,8 +1396,8 @@ function resolveLifecycleNode(input, pane) {
  *  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 demote` (always terminal) and `node lifecycle`
- *  (the passed value) both call — no duplication. */
+ *  The ONE implementation `node lifecycle demote` (always terminal) and
+ *  `node config --lifecycle` (the passed value) both call — no duplication. */
 function setLifecycle(id, value, opts) {
     const target = getNode(id);
     const { launch } = buildLaunchSpec(target.kind, target.mode, {
@@ -733,18 +1415,18 @@ function setLifecycle(id, value, opts) {
     return { node_id: meta.node_id, lifecycle: meta.lifecycle, detached };
 }
 // ---------------------------------------------------------------------------
-// node 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 lifecycle` is the orthogonal
-// low-level command (it also does resident). See vision F5.
+// 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 recycle` instead to FINISH it now and reboot a fresh root in its pane, and `node lifecycle` for the orthogonal low-level flip (incl. terminal→resident)',
+    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 demote',
+        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).' },
@@ -768,41 +1450,17 @@ const nodeDemote = defineLeaf({
     render: (r) => `Demoted ${r['node_id']} — lifecycle now ${r['lifecycle']} (in place)${r['detached'] === true ? ', viewer closed (broker still running off-screen)' : ''}.`,
 });
 // ---------------------------------------------------------------------------
-// node lifecycle — flip the lifecycle axis (terminal ↔ resident), independent
-// of mode. The persona injector delivers the transition guidance.
+// node lifecycle — recycle, close, or demote a node
 // ---------------------------------------------------------------------------
-const nodeLifecycle = defineLeaf({
+const nodeLifecycle = defineBranch({
     name: 'lifecycle',
-    description: 'switch a node between terminal and resident',
-    whenToUse: 'you want to flip a node\'s LIFECYCLE independent of its mode: make a node RESIDENT so it becomes interactable — it stays dormant, wakes on inbox/human, and is never forced to submit a final; or make a node TERMINAL so it owes a final result up the spine and reaps when done. Orthogonal to `node promote`, which changes MODE (base↔orchestrator), not lifecycle. You can also let go of a still-running agent and send it off-screen to finish in the background. For the human-driver flip-to-terminal pair reach for `node demote` (the friendly terminal-only skin over this)',
+    description: 'lifecycle actions — recycle, close, demote a node',
+    whenToUse: 'you are ending or transitioning a node\'s life: finish the agent in your pane and reboot a fresh root (`recycle`), tear a node + its exclusive subtree down without finishing (`close`), or flip a node onto a finishing track in place (`demote`). 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`.',
     help: {
         name: 'node lifecycle',
-        summary: 'set a node\'s lifecycle axis — terminal (owes a final up the spine, reaps when done) or resident (interactable, stays dormant, woken by inbox/human, never forced to submit). Orthogonal to mode; promotion does not touch it. `--detach` also closes a live agent\'s viewer (broker keeps running off-screen)',
-        params: [
-            { kind: 'positional', name: 'lifecycle', required: true, constraint: 'terminal | resident.' },
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node to change. 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 change, 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 lifecycle, 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 human-driver "I am done foregrounding this" move (Alt+C → D).' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The node.' },
-            { name: 'lifecycle', type: 'string', required: true, constraint: 'Its new lifecycle (terminal | resident).' },
-            { name: 'detached', type: 'boolean', required: false, constraint: 'True when --detach closed the agent\'s viewer pane (broker keeps running).' },
-        ],
-        outputKind: 'object',
-        effects: ['Sets lifecycle on the node meta and rebuilds its launch spec so a future revive boots with the new lifecycle\'s prompt baked in.', '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 value = input['lifecycle']?.trim().toLowerCase();
-        if (value !== 'terminal' && value !== 'resident') {
-            throw new InputError({ error: 'bad_lifecycle', message: `invalid lifecycle: ${value ?? ''}`, field: 'lifecycle', next: 'Pass `terminal` or `resident`.' });
-        }
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        const id = resolveLifecycleNode(input, pane);
-        const res = setLifecycle(id, value, { pane, detach: input['detach'] === true });
-        return { node_id: res.node_id, lifecycle: res.lifecycle, detached: res.detached };
+        summary: 'end or transition a node — recycle the pane, close + cascade-cancel a subtree, or demote to terminal in place',
     },
-    render: (r) => `Set ${r['node_id']} lifecycle → ${r['lifecycle']}${r['detached'] === true ? ', viewer closed (broker still running off-screen)' : ''}.`,
+    children: [nodeRecycle, nodeClose, nodeDemote],
 });
 // ---------------------------------------------------------------------------
 // node yield — refresh: discard context, revive fresh against the roadmap
@@ -846,395 +1504,38 @@ const nodeYield = defineLeaf({
     },
 });
 // ---------------------------------------------------------------------------
-// node wake — scheduled wakeups (arm / list / cancel). The agent-facing skin
-// over the wakeups data-access layer (armWake/listWakes/cancelWake) + the time
-// grammar (parseWhen/parseCadence). The surface ONLY arms a durable row and
-// introspects/cancels — it never spawns pi, drives a transition, or fires a wake
-// (those are the daemon's at fire time). T2's armWake carries only integrity
-// backstops (empty body / recur-on-deadline / unknown kind); the target-
-// resolvability, bare-recoverable-state, and per-owner cap checks live HERE
-// (Min-6), so every armer must route through this surface.
+// node triggers — inspect/cancel pending triggers (clock + predicate) armed by
+// `node msg` or `node new`.
 // ---------------------------------------------------------------------------
-/** Max pending wakes a single owner may hold (AC-N4). */
-const WAKE_CAP = 100;
-/** Default timeout body for a note-less `until`, so the deadline row is never
- *  empty (T2 rejects an empty body) and Maj-8's rendered timeout signal has text. */
-const DEFAULT_DEADLINE_BODY = 'Deadline reached — no report arrived; reassess / chase / escalate.';
-/** Resolve the calling node (the armer/owner). CRTR_NODE_ID is mandatory — a
- *  wake is owned by the node that arms it (owner_id). */
-function armerId() {
-    const id = process.env['CRTR_NODE_ID'];
-    if (id === undefined || id === '') {
-        throw new InputError({ error: 'no_node', message: 'no node to arm a wake (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 T3 typed time-grammar error to the rendered AC-N3/N4 error block. */
-function throwWakeError(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.' });
-}
-/** Run armWake, mapping its thrown integrity backstop (WakeArmError) to a
- *  rendered error block. The surface validates these cases up front, so a throw
- *  here is a backstop, not the primary path. */
-function armOrThrow(spec) {
-    try {
-        return armWake(spec);
-    }
-    catch (e) {
-        if (e instanceof WakeArmError) {
-            const next = {
-                empty_note: 'Provide a real --note, or omit it for a bare wake.',
-                deadline_cannot_recur: 'Drop --every. For a recurring self-alarm use `crtr node wake at --every <cadence>`.',
-                bad_kind: 'This is a crtr bug — report it.',
-            };
-            throw new InputError({ error: e.code, message: e.message, next: next[e.code] ?? 'Fix the wake spec and retry.' });
-        }
-        throw e;
-    }
-}
-/** Reject an arm that would push this owner past the pending-wakes cap (AC-N4),
- *  counted via the {owner} listWakes variant. */
-function assertUnderCap(ownerId) {
-    const pending = listWakes({ owner: ownerId }).length;
-    if (pending >= WAKE_CAP) {
-        throw new InputError({
-            error: 'cap_exceeded',
-            message: `you hold ${pending} pending wakes (cap ${WAKE_CAP}).`,
-            next: 'Reap stale wakes with `crtr node wake cancel <id>` (see `crtr node wake list`) before arming more.',
-        });
-    }
-}
-/** A bare wake resumes a fresh window with no memory beyond disk, so it needs
- *  durable state to wake INTO. Accept it only when the target has a goal
- *  (initial-prompt.md) or roadmap (roadmap.md) on disk — located via the
- *  codebase's own writeGoal/roadmap convention, not a new file (AC-N3). */
-function hasRecoverableState(nodeId) {
-    const goal = readGoal(nodeId);
-    if (goal !== null && goal.trim() !== '')
-        return true;
-    const roadmap = readRoadmap(nodeId);
-    return roadmap !== null && roadmap.trim() !== '';
-}
-/** True when a stored recur is a fixed interval (vs a calendar cron). */
-function isFixedInterval(recur) {
-    try {
-        return typeof JSON.parse(recur).every === 'string';
-    }
-    catch {
-        return false;
-    }
-}
-/** 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)`;
-}
-// node wake at ---------------------------------------------------------------
-const nodeWakeAt = defineLeaf({
-    name: 'at',
-    description: 'arm a self-alarm — wake yourself (or another node) at a future time',
-    whenToUse: 'you have a standing or recurring task on a CLOCK, or nothing to do until a known future time — run a job each morning, loop a health check on a cadence (--every), re-check an EXTERNAL poll (CI, a deploy, a rate-limit window) after a backoff, or hand your future self a timed reminder. Time-driven work ONLY: do NOT arm a timer to watch your own agents — you auto-subscribe to every child you spawn, so its finish already wakes you; setting a wake to "check if it is done yet" just burns a window the subscription would have woken anyway. The bare form is the time-triggered twin of `node yield`: a fresh window re-reading your roadmap, right for standing/recurring work; the noted form instead wakes you into your saved conversation with a pointer this moment needs. Use `node wake until` to put a single DEADLINE backstop on an inbox-wait (still event-first, not polling); `node wake spawn` to defer spawning a NEW node; `node yield` to refresh NOW rather than at a future T',
-    help: {
-        name: 'node wake at',
-        summary: 'arm a self-alarm: wake yourself (default) or another node (--node) at a future time. Bare ⇒ fresh window re-reading roadmap/disk; --note ⇒ saved conversation with the note as new context; --every ⇒ a declarative recurrence the runtime keeps firing even across your crash/finalize',
-        params: [
-            { kind: 'positional', name: 'when', required: false, constraint: 'Fire time — a duration ("5m","1h30m"), a zoned ISO ("2026-06-07T09:00:00Z"), or a bare ISO ("2026-06-07T09:00", host-local). Required UNLESS --every is given (the cadence then sets the first fire).' },
-            { kind: 'flag', name: 'note', type: 'string', required: false, constraint: 'A non-empty note delivered into the woken context. Present ⇒ NOTED wake (resume your saved conversation, note as new context). Absent ⇒ BARE wake (fresh window re-reading roadmap/disk). A bare wake on a node with no goal/roadmap on disk is rejected.' },
-            { kind: 'flag', name: 'every', type: 'string', required: false, constraint: 'Make it a declarative recurrence the runtime fires on schedule even if you crash/finalize (node-anchored revive-cron): a duration ("6h","30m") or a 5-field cron / @alias ("0 9 * * *","@daily"). A fixed-interval --every WITH <when> uses <when> as the first fire; a cron --every ignores <when>. Min cadence 60s.' },
-            { kind: 'flag', name: 'tz', type: 'string', required: false, constraint: 'IANA zone for a calendar --every or a bare-ISO <when> (default: host-local).' },
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Arm the wake for ANOTHER existing node (a parent waking a child / a timed message to it). Default: self (CRTR_NODE_ID).' },
-        ],
-        output: [
-            { name: 'id', type: 'string', required: true, constraint: 'The new wakeup id (cancel/list by it).' },
-            { name: 'kind', type: 'string', required: true, constraint: '"bare" or "noted".' },
-            { name: 'fires_at', type: 'string', required: true, constraint: 'Absolute UTC fire time (the first fire for a recurrence).' },
-            { name: 'recur', type: 'string', required: true, constraint: '"none", or the cadence (every 6h / cron `0 9 * * *` <zone>).' },
-            { name: 'target', type: 'string', required: true, constraint: '"self" or the --node id.' },
-            { name: 'guidance', type: 'string', required: true, constraint: 'What to do now — end your turn to go dormant; do not push final.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Inserts one wakeups row (kind bare/noted); nothing fires before fire_at.',
-            'No pi spawn, no transition — arming is a pure durable side-effect. End your turn separately to go dormant.',
-        ],
-    },
-    run: async (input) => {
-        const ownerId = armerId();
-        const targetId = (input['node'] ?? '').trim() || ownerId;
-        if (getNode(targetId) === null) {
-            throw new InputError({ error: 'not_found', message: `no node: ${targetId}`, field: 'node', next: 'List nodes with `crtr node inspect list`.' });
-        }
-        const when = input['when']?.trim();
-        const every = input['every']?.trim();
-        const tz = input['tz'];
-        const noteRaw = input['note'];
-        const hasNote = noteRaw !== undefined;
-        if ((when === undefined || when === '') && (every === undefined || every === '')) {
-            throw new InputError({ error: 'bad_when', message: 'a <when> time is required (or --every for a recurrence).', next: 'Pass a duration ("5m"), an ISO time, or --every <cadence>.' });
-        }
-        if (hasNote && noteRaw.trim() === '') {
-            throw new InputError({ error: 'empty_note', message: '--note must be non-empty for a noted wake.', received: noteRaw, next: 'Provide a real note ("re-check CI #4821; deploy was pending"), or omit --note for a bare wake.' });
-        }
-        const kind = hasNote ? 'noted' : 'bare';
-        if (kind === 'bare' && !hasRecoverableState(targetId)) {
-            throw new InputError({ error: 'bare_no_recoverable_state', message: `node ${targetId} has no goal/roadmap on disk — a bare wake would resume amnesiac.`, next: 'Pass --note "<why this moment matters>" so the woken context carries a pointer, or arm the bare wake only once the node has a roadmap/goal.' });
-        }
-        const now = new Date();
-        let recur;
-        let fireAt;
-        if (every !== undefined && every !== '') {
-            const cad = parseCadence(every, parseOpts(now, tz));
-            if ('error' in cad)
-                throwWakeError(cad.error);
-            recur = cad.recur;
-            fireAt = cad.firstFireAt;
-            // BOTH <when> and a FIXED-interval --every: <when> overrides the first fire
-            // (Min-12). A cron --every ignores <when> by design.
-            if (when !== undefined && when !== '' && isFixedInterval(cad.recur)) {
-                const w = parseWhen(when, parseOpts(now, tz));
-                if ('error' in w)
-                    throwWakeError(w.error);
-                fireAt = w.fireAt;
-            }
-        }
-        else {
-            const w = parseWhen(when, parseOpts(now, tz));
-            if ('error' in w)
-                throwWakeError(w.error);
-            fireAt = w.fireAt;
-        }
-        assertUnderCap(ownerId);
-        let payload = null;
-        if (kind === 'noted') {
-            const body = noteRaw;
-            payload = { body, label: body.split('\n')[0].slice(0, 120) };
-        }
-        const id = `wk-${newNodeId()}`;
-        armOrThrow({
-            wakeup_id: id,
-            node_id: targetId,
-            owner_id: ownerId,
-            fire_at: fireAt,
-            kind,
-            ...(recur !== undefined ? { recur } : {}),
-            payload,
-        });
-        const target = targetId === ownerId ? 'self' : targetId;
-        const eta = etaHint(fireAt, now);
-        const guidance = recur !== undefined
-            ? `${kind === 'noted' ? 'Noted' : 'Bare'} recurrence armed (${cadenceDisplay(recur)}); first fire ${fireAt}${eta}. End your turn to go dormant; do not push final. The runtime keeps firing it even across your crash/finalize — cancel with \`crtr node wake cancel ${id}\`.`
-            : kind === 'noted'
-                ? `Noted wake armed. You wake into your saved conversation at ${fireAt}${eta} with your note. End your turn now to go dormant; do not push final.`
-                : `Bare self-alarm armed. You wake in a fresh window at ${fireAt}${eta}. End your turn now to go dormant; do not push final. The wake re-reads your roadmap.`;
-        return { id, kind, fires_at: fireAt, recur: cadenceDisplay(recur), target, guidance };
-    },
-    render: (r) => {
-        const recur = r['recur'] !== 'none' ? `, recurs ${r['recur']}` : '';
-        return `Armed ${r['kind']} wake ${r['id']} — fires ${r['fires_at']}${recur}, target ${r['target']}.\n\n${r['guidance']}`;
-    },
-});
-// node wake until ------------------------------------------------------------
-const nodeWakeUntil = defineLeaf({
-    name: 'until',
-    description: 'bind a deadline to your current inbox-wait (self only)',
-    whenToUse: 'rarely — only to put a deadline on an inbox-wait whose event the runtime genuinely cannot guarantee to deliver: you are open to a message AND backstopping an UNPUSHABLE external (a human who may never reply, an outside system with no spine-push). NOT for delegates — a child finishing, crashing, or being closed already wakes you on its own, so a deadline to "chase" a delegate is exactly the belt-and-suspenders the runtime makes redundant. Use `node wake at` instead for an unconditional timed wake unrelated to an inbox event',
-    help: {
-        name: 'node wake until',
-        summary: 'arm a deadline on your current dormancy: you wake on the first inbox message, or at <when> if none arrives — whichever fires first wins, the loser is canceled. Self only; ≤1 deadline per node (a new `until` replaces the prior); cancel-on-wake (any genuine revive drops it)',
-        params: [
-            { kind: 'positional', name: 'when', required: true, constraint: 'Deadline time — a duration ("30m"), a zoned ISO, or a bare ISO (host-local).' },
-            { kind: 'flag', name: 'note', type: 'string', required: false, constraint: 'Your timeout playbook — what to do if you woke because the wait expired (delivered with a timeout marker so you can tell a timeout from a real report). Omit and a default timeout note is supplied.' },
-            { kind: 'flag', name: 'every', type: 'string', required: false, constraint: 'NOT ALLOWED — a deadline cannot recur. Passing it is rejected (deadline_cannot_recur); use `crtr node wake at --every` for a recurring self-alarm.' },
-        ],
-        output: [
-            { name: 'id', type: 'string', required: true, constraint: 'The new deadline wakeup id.' },
-            { name: 'fires_at', type: 'string', required: true, constraint: 'Absolute UTC deadline.' },
-            { name: 'target', type: 'string', required: true, constraint: 'Always "self".' },
-            { name: 'guidance', type: 'string', required: true, constraint: 'What to do now — delegate / end your turn to go dormant.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            "Upserts the node's single deadline wakeups row (replacing any prior).",
-            'No pi spawn, no transition — arm, then end your turn to go dormant. A genuine revive (an inbox event or any other wake) cancels it.',
-        ],
-    },
-    run: async (input) => {
-        const ownerId = armerId();
-        const every = input['every']?.trim();
-        if (every !== undefined && every !== '') {
-            throw new InputError({ error: 'deadline_cannot_recur', message: 'a deadline cannot recur.', next: 'Drop --every. For a recurring self-alarm use `crtr node wake at --every <cadence>`.' });
-        }
-        const when = input['when'].trim();
-        const noteRaw = input['note'];
-        if (noteRaw !== undefined && noteRaw.trim() === '') {
-            throw new InputError({ error: 'empty_note', message: '--note must be non-empty when given.', received: noteRaw, next: 'Provide a real timeout playbook, or omit --note for the default timeout note.' });
-        }
-        const now = new Date();
-        const w = parseWhen(when, { now });
-        if ('error' in w)
-            throwWakeError(w.error);
-        assertUnderCap(ownerId);
-        const body = noteRaw !== undefined && noteRaw.trim() !== '' ? noteRaw : DEFAULT_DEADLINE_BODY;
-        const label = body.split('\n')[0].slice(0, 120);
-        const payload = { body, timeout: true, label };
-        const id = `wk-${newNodeId()}`;
-        armOrThrow({ wakeup_id: id, node_id: ownerId, owner_id: ownerId, fire_at: w.fireAt, kind: 'deadline', payload });
-        const eta = etaHint(w.fireAt, now);
-        const guidance = `Deadline armed. You wake on the first inbox message, or at ${w.fireAt}${eta} if none arrives. Now delegate / end your turn to go dormant — whichever fires first cancels the other.`;
-        return { id, fires_at: w.fireAt, target: 'self', guidance };
-    },
-    render: (r) => `Armed deadline ${r['id']} — fires ${r['fires_at']}, target ${r['target']}.\n\n${r['guidance']}`,
-});
-// node wake spawn -----------------------------------------------------------
-const nodeWakeSpawn = defineLeaf({
-    name: 'spawn',
-    description: 'defer or recur the BIRTH of a new node',
-    whenToUse: 'you want a node spawned LATER or on a repeating cadence rather than right now: a one-shot deferred birth at a future time (--at), or a spawn-cron that re-births a fresh node every interval/cron even across your crash/finalize (--every) — standing work like a nightly review, a periodic health check, a morning digest, or a timed reminder that acts. Use `node new` instead to spawn immediately, and `node wake at` to re-wake an EXISTING node on a timer rather than birth a new one',
-    help: {
-        name: 'node wake spawn',
-        summary: 'defer or recur a node birth — arm a wake that spawns a fresh node at a future time (--at) or on a repeating cadence (--every), instead of `node new` spawning it now. Returns a wakeup id, not a node id; the full spawn recipe is stored on the wake and re-derived live at fire time',
-        params: [
-            { kind: 'stdin', name: 'prompt', required: true, constraint: 'First user message for the node to be born. Deliver it on stdin from a quoted heredoc (`<<\'EOF\'`) or a file (`< prompt.md`).' },
-            { kind: 'flag', name: 'at', type: 'string', required: false, constraint: 'DEFER a one-shot birth at <when> — a duration ("5m"), a zoned ISO, or a bare ISO (host-local, or in --tz). Mutually exclusive with --every; exactly one of --at/--every is required.' },
-            { kind: 'flag', name: 'every', type: 'string', required: false, constraint: 'SPAWN-CRON: re-birth a fresh node on this declarative cadence even after a prior instance reaped itself or crashed — a duration ("6h") or a 5-field cron / @alias ("0 9 * * *","@daily"). Canvas-anchored (survives your crash/finalize), reaped by your deliberate close or `node wake cancel`. Min cadence 60s. Mutually exclusive with --at.' },
-            { kind: 'flag', name: 'tz', type: 'string', required: false, constraint: 'IANA zone for a calendar --every (or a bare-ISO --at); default host-local. Makes "every 9am" mean 9am there, DST-correct.' },
-            { kind: 'flag', name: 'kind', type: 'string', required: false, default: 'general', constraint: 'Persona kind for the node to be born — match the work to the kind (the <kinds> list below names each).' },
-            { kind: 'flag', name: 'mode', type: 'enum', choices: ['base', 'orchestrator'], required: false, default: 'base', constraint: 'Persona mode: base (finishes in one window) or orchestrator (boots with a seeded roadmap and fans its scope out).' },
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Dir the born node is pinned to. Defaults to the caller cwd, resolved NOW — it must still exist at fire time or the spawn fails loud.' },
-            { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Display name for the born node (tmux window + resume picker). Defaults to the kind.' },
-            { kind: 'flag', name: 'parent', type: 'string', required: false, constraint: 'Parent node id for the born node. Defaults to the calling node (CRTR_NODE_ID).' },
-            { kind: 'flag', name: 'root', type: 'bool', required: false, constraint: 'Birth an INDEPENDENT root instead of a managed child: no parent on the spine, NO subscription back to you, resident lifecycle (records spawned_by=you for provenance).' },
-            { kind: 'flag', name: 'fork-from', type: 'string', required: false, constraint: 'Fork the born node from an existing pi conversation instead of starting it fresh: a node id, an absolute session `.jsonl` path, or a partial pi session uuid. pi copies that history into a NEW session, then the prompt is the next message. One-shot at birth.' },
-        ],
-        output: [
-            { name: 'id', type: 'string', required: true, constraint: 'The wakeup id (inspect/cancel by it via `node wake list`/`cancel`).' },
-            { name: 'kind', type: 'string', required: true, constraint: 'The persona kind of the deferred node.' },
-            { name: 'fires_at', type: 'string', required: true, constraint: 'Absolute UTC birth time (the first fire for a cron).' },
-            { name: 'recur', type: 'string', required: true, constraint: '"none" (one-shot --at) or the cadence (every 6h / cron `0 9 * * *` <zone>).' },
-            { name: 'guidance', type: 'string', required: true, constraint: 'What to do now — no node exists yet; pick up other work or end your turn.' },
-        ],
-        dynamicState: () => kindsStateBlock(),
-        outputKind: 'object',
-        effects: [
-            'Inserts one detached `spawn` wakeups row (node_id NULL, owner=you, parent/cwd resolved now); NO node and NO window exist until fire time.',
-            'At fire time the daemon spawns the node from the stored recipe, re-deriving the launch spec live (persona prose is never stale). Best-effort: if the cwd/parent is gone at fire it fails LOUD (an urgent push to you, or a daemon-log line if you are gone).',
-        ],
-    },
-    run: async (input) => {
-        const prompt = input['prompt'] ?? '';
-        if (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.' });
-        }
-        const at = input['at']?.trim();
-        const every = input['every']?.trim();
-        const tz = input['tz'];
-        const hasAt = at !== undefined && at !== '';
-        const hasEvery = every !== undefined && every !== '';
-        if (!hasAt && !hasEvery) {
-            throw new InputError({ error: 'no_schedule', message: 'node wake spawn needs a schedule: --at <when> or --every <cadence>.', next: 'Pass --at for a one-shot deferred spawn, --every for a spawn-cron, or use `crtr node new` to spawn now.' });
-        }
-        if (hasAt && hasEvery) {
-            throw new InputError({ error: 'at_and_every', message: '--at and --every are mutually exclusive.', next: 'Use --at for a one-shot deferred spawn, or --every for a spawn-cron.' });
-        }
-        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 forkFrom = input['forkFrom'];
-        const ownerId = armerId();
-        // The recipe's `parent` is the resolved armer — NON-NULL on EVERY payload,
-        // INCLUDING --root: spawnChild throws at fire time on a null parent (the
-        // daemon has no CRTR_NODE_ID); for a root it internally nulls the spine
-        // parent while keeping `spawner` for provenance, so a non-null value is right.
-        const recipeParent = parent ?? ownerId;
-        const recipe = {
-            kind,
-            mode,
-            cwd,
-            prompt,
-            parent: recipeParent,
-            ...(name !== undefined ? { name } : {}),
-            ...(root ? { root: true } : {}),
-            ...(forkFrom !== undefined ? { forkFrom } : {}),
-        };
-        const now = new Date();
-        let recur;
-        let fireAt;
-        if (hasEvery) {
-            const cad = parseCadence(every, parseOpts(now, tz));
-            if ('error' in cad)
-                throwWakeError(cad.error);
-            recur = cad.recur;
-            fireAt = cad.firstFireAt;
-        }
-        else {
-            const w = parseWhen(at, parseOpts(now, tz));
-            if ('error' in w)
-                throwWakeError(w.error);
-            fireAt = w.fireAt;
-        }
-        assertUnderCap(ownerId);
-        const id = `wk-${newNodeId()}`;
-        armOrThrow({ wakeup_id: id, node_id: null, owner_id: ownerId, fire_at: fireAt, kind: 'spawn', ...(recur !== undefined ? { recur } : {}), payload: recipe });
-        const eta = etaHint(fireAt, now);
-        const guidance = recur !== undefined
-            ? `Spawn-cron armed (${cadenceDisplay(recur)}): a fresh ${kind} node is born each fire, first at ${fireAt}${eta}. No node exists yet; the runtime keeps spawning even across your crash/finalize — inspect/cancel via \`crtr node wake list\` / \`crtr node wake cancel ${id}\`.`
-            : `Deferred spawn armed: a fresh ${kind} node is born at ${fireAt}${eta}. No node exists yet — inspect/cancel via \`crtr node wake list\` / \`crtr node wake cancel ${id}\`. Pick up other work or end your turn.`;
-        return { id, kind, fires_at: fireAt, recur: cadenceDisplay(recur), guidance };
-    },
-    render: (r) => {
-        const recur = r['recur'] !== 'none' ? `, recurs ${r['recur']}` : '';
-        return `Armed deferred spawn ${r['id']} — a ${r['kind']} node, fires ${r['fires_at']}${recur}.\n\n${r['guidance']}`;
-    },
-});
-// node wake list -------------------------------------------------------------
-const nodeWakeList = defineLeaf({
+const nodeTriggersList = defineLeaf({
     name: 'list',
-    description: 'list pending wakes for a scope (default self)',
-    whenToUse: 'before re-arming or finishing, to see what you already have armed and reap stale ones. Defaults to your own wakes, with scopes for another node, the whole canvas, or a node and its descendants',
+    description: 'list pending triggers for a scope (default self)',
+    whenToUse: 'before re-arming or finishing, to see what you already have armed and reap stale ones. Defaults to your own triggers, with a --node or --canvas scope for anything wider',
     help: {
-        name: 'node wake list',
-        summary: 'list pending wakes (all kinds, incl. deferred spawns) for a scope — id, kind, next fire, cadence, target, owner, note. Fired one-shots are gone; a recurrence shows its NEXT fire, not past slots',
+        name: 'node triggers list',
+        summary: 'list pending triggers (clock and predicate, incl. deferred spawns) for a scope — id, owner, target, action/mode, type, next fire/eval, cadence, timeout, label, predicate diagnostics. Fired one-shots are gone; a recurrence shows its NEXT fire/eval, not past slots',
         params: [
-            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'List the wakes anchored to this node. Mutually exclusive with --canvas/--subtree.' },
-            { kind: 'flag', name: 'canvas', type: 'bool', required: false, constraint: 'List EVERY wake on the canvas. Mutually exclusive with --node/--subtree.' },
-            { kind: 'flag', name: 'subtree', type: 'string', required: false, constraint: 'List the wakes anchored to this node AND its descendants (the subscription sub-DAG). Mutually exclusive with --node/--canvas.' },
+            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'List the triggers owned by this node instead of yourself. Mutually exclusive with --canvas.' },
+            { kind: 'flag', name: 'canvas', type: 'bool', required: false, constraint: 'List EVERY trigger on the canvas. Mutually exclusive with --node.' },
         ],
         output: [
-            { name: 'scope', type: 'string', required: true, constraint: 'The scope listed (self / <id> / canvas / subtree:<id>).' },
-            { name: 'wakes', type: 'object[]', required: true, constraint: 'Rows: {id, kind, next, recur, target, owner, note}.' },
+            { name: 'scope', type: 'string', required: true, constraint: 'The scope listed (self / <id> / canvas).' },
+            {
+                name: 'triggers',
+                type: 'object[]',
+                required: true,
+                constraint: 'Rows: {id, owner, target, action ( "msg"|"new" ), action_mode, trigger_type ( "at"|"every"|"when"|"until" ), next (fire_at or next_eval_at), recur (cadence display), timeout (timeout_at, predicate only), label, eval_state, last_eval_at, last_exit, last_stderr, created}.',
+            },
         ],
         outputKind: 'object',
-        effects: ['Read-only: queries the wakeups table.'],
+        effects: ['Read-only: queries the triggers table.'],
     },
     run: async (input) => {
         const nodeFlag = input['node']?.trim();
         const canvas = input['canvas'] === true;
-        const subtree = input['subtree']?.trim();
-        const chosen = [nodeFlag !== undefined && nodeFlag !== '', canvas, subtree !== undefined && subtree !== ''].filter(Boolean).length;
-        if (chosen > 1) {
-            throw new InputError({ error: 'bad_scope', message: 'choose at most one of --node, --canvas, --subtree.', next: 'Pass a single scope flag, or none for your own wakes.' });
+        const hasNode = nodeFlag !== undefined && nodeFlag !== '';
+        if (hasNode && canvas) {
+            throw new InputError({ error: 'bad_scope', message: 'choose at most one of --node, --canvas.', next: 'Pass a single scope flag, or none for your own triggers.' });
         }
         const viewer = process.env['CRTR_NODE_ID'];
         let scope;
@@ -1243,114 +1544,197 @@ const nodeWakeList = defineLeaf({
             scope = { canvas: true };
             scopeLabel = 'canvas';
         }
-        else if (subtree !== undefined && subtree !== '') {
-            if (getNode(subtree) === null)
-                throw new InputError({ error: 'not_found', message: `no node: ${subtree}`, field: 'subtree', next: 'List nodes with `crtr node inspect list`.' });
-            scope = { subtree: [subtree, ...view(subtree)] };
-            scopeLabel = `subtree:${subtree}`;
-        }
-        else if (nodeFlag !== undefined && nodeFlag !== '') {
-            scope = { node: nodeFlag };
+        else if (hasNode) {
+            if (getNode(nodeFlag) === null)
+                throw new InputError({ error: 'not_found', message: `no node: ${nodeFlag}`, field: 'node', next: 'List nodes with `crtr node inspect list`.' });
+            scope = { owner: nodeFlag };
             scopeLabel = viewer !== undefined && nodeFlag === viewer ? 'self' : nodeFlag;
         }
         else {
-            // Default "self" scope is OWNER-based, not node-anchored: it is "what YOU
-            // armed" (§3.5 whenToUse), so the detached spawn wakes you own via
-            // `node new --at/--every` (node_id NULL, owner_id self) DO surface here
-            // with their `spawn:<kind>@<cwd>` target — §3.5/§3.7 require that. (Use
-            // --node <id> for the node-ANCHORED view of a target's wakes.)
             scope = { owner: armerId() };
             scopeLabel = 'self';
         }
-        const rel = (id) => {
-            if (id === null)
-                return '';
-            return viewer !== undefined && viewer !== '' && id === viewer ? 'self' : id;
-        };
-        const wakes = listWakes(scope).map((w) => {
+        const rel = (id) => (id !== null && viewer !== undefined && viewer !== '' && id === viewer ? 'self' : (id ?? ''));
+        const triggers = listTriggers(scope).map((t) => {
             let target;
-            if (w.node_id !== null) {
-                target = rel(w.node_id);
+            if (t.node_id !== null) {
+                target = rel(t.node_id);
             }
-            else if (w.kind === 'spawn' && w.payload !== null) {
-                const recipe = w.payload;
+            else if (t.action === 'new' && t.payload !== null) {
+                const recipe = t.payload;
                 target = `spawn:${recipe.kind}@${recipe.cwd}`;
             }
             else {
                 target = 'detached';
             }
-            const note = (w.kind === 'noted' || w.kind === 'deadline') && w.payload !== null
-                ? (w.payload.label ?? '')
-                : '';
-            return { id: w.wakeup_id, kind: w.kind, next: w.fire_at, recur: cadenceDisplay(w.recur), target, owner: rel(w.owner_id), note };
+            const label = t.payload !== null && typeof t.payload.label === 'string' ? t.payload.label : '';
+            return {
+                id: t.trigger_id,
+                owner: rel(t.owner_id),
+                target,
+                action: t.action,
+                action_mode: t.action_mode,
+                trigger_type: t.trigger_type,
+                next: t.trigger_type === 'when' ? (t.next_eval_at ?? '') : (t.fire_at ?? ''),
+                recur: cadenceDisplay(t.trigger_type === 'when' ? t.eval_every : t.recur),
+                timeout: t.timeout_at ?? '',
+                label,
+                eval_state: t.eval_state,
+                last_eval_at: t.last_eval_at ?? '',
+                last_exit: t.last_exit,
+                last_stderr: t.last_stderr ?? '',
+                created: t.created,
+            };
         });
-        return { scope: scopeLabel, wakes };
+        return { scope: scopeLabel, triggers };
     },
     render: (r) => {
-        const wakes = r['wakes'];
-        const follow = 'Cancel one with `crtr node wake cancel <id>`. Fired one-shots are gone; a recurrence shows its NEXT fire, not past slots.';
-        if (wakes.length === 0)
-            return `No pending wakes in scope ${r['scope']}.\n\n${follow}`;
-        const cell = (v) => String(v).replace(/\|/g, '\\|').replace(/\n/g, ' ');
-        const head = '| id | kind | next | recur | target | owner | note |\n| --- | --- | --- | --- | --- | --- | --- |';
-        const rows = wakes.map((w) => `| ${cell(w['id'])} | ${cell(w['kind'])} | ${cell(w['next'])} | ${cell(w['recur'])} | ${cell(w['target'])} | ${cell(w['owner'])} | ${cell(w['note'])} |`);
-        return `${wakes.length} pending wake(s) in scope ${r['scope']}.\n\n${head}\n${rows.join('\n')}\n\n${follow}`;
+        const triggers = r['triggers'];
+        const follow = 'Cancel one with `crtr node triggers cancel <id>`. Fired one-shots are gone; a recurrence shows its NEXT fire/eval, not past slots.';
+        if (triggers.length === 0)
+            return `No pending triggers in scope ${r['scope']}.\n\n${follow}`;
+        const cell = (v) => String(v ?? '').replace(/\|/g, '\\|').replace(/\n/g, ' ');
+        const head = '| id | owner | target | action | mode | type | next | recur | timeout | label | eval_state | last_eval_at | last_exit | last_stderr | created |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |';
+        const rows = triggers.map((t) => `| ${cell(t['id'])} | ${cell(t['owner'])} | ${cell(t['target'])} | ${cell(t['action'])} | ${cell(t['action_mode'])} | ${cell(t['trigger_type'])} | ${cell(t['next'])} | ${cell(t['recur'])} | ${cell(t['timeout'])} | ${cell(t['label'])} | ${cell(t['eval_state'])} | ${cell(t['last_eval_at'])} | ${cell(t['last_exit'])} | ${cell(t['last_stderr'])} | ${cell(t['created'])} |`);
+        return `${triggers.length} pending trigger(s) in scope ${r['scope']}.\n\n${head}\n${rows.join('\n')}\n\n${follow}`;
     },
 });
-// node wake cancel -----------------------------------------------------------
-const nodeWakeCancel = defineLeaf({
+const nodeTriggersCancel = defineLeaf({
     name: 'cancel',
-    description: 'cancel a pending wake by id (idempotent)',
-    whenToUse: 'a wait you no longer need — a poll whose goal is met, a deferred spawn you reconsidered, a deadline you are replacing. Idempotent: canceling an already-fired or already-canceled id is a no-op. Closing/reaping a node already reaps its own wakes and the detached ones it armed; reach for this to drop a single wake, or to reap a detached spawn/cron a finished or crashed node left running',
+    description: 'cancel a pending trigger by id (idempotent)',
+    whenToUse: 'a wait you no longer need — a poll whose goal is met, a deferred spawn you reconsidered, a deadline you are replacing. Idempotent: canceling an already-fired or already-canceled id is a no-op. Closing/reaping a node already reaps its own triggers and the detached ones it armed; reach for this to drop a single trigger, or to reap a detached spawn/cron a finished or crashed node left running',
     help: {
-        name: 'node wake cancel',
-        summary: 'cancel a pending wake by id — it never fires and leaves the list. Idempotent (canceling an already-gone id is a no-op, not an error)',
-        params: [
-            { kind: 'positional', name: 'wakeup-id', required: true, constraint: 'The wakeup id to cancel (from `node wake list`).' },
-        ],
+        name: 'node triggers cancel',
+        summary: 'cancel a pending trigger by id — it never fires/evaluates again and leaves the list. Idempotent (canceling an already-gone id is a no-op, not an error)',
+        params: [{ kind: 'positional', name: 'trigger-id', required: true, constraint: 'The trigger id to cancel (from `node triggers list`).' }],
         output: [
-            { name: 'id', type: 'string', required: true, constraint: 'The canceled wakeup id.' },
+            { name: 'id', type: 'string', required: true, constraint: 'The canceled trigger id.' },
             { name: 'was_pending', type: 'boolean', required: true, constraint: 'True when a pending row was removed; false when it was already gone.' },
         ],
         outputKind: 'object',
-        effects: ['Deletes the wakeup row (idempotent — no error if it was already gone).'],
+        effects: ['Deletes the trigger row (idempotent — no error if already gone).'],
     },
     run: async (input) => {
-        const id = input['wakeupId'].trim();
-        const wasPending = listWakes({ canvas: true }).some((w) => w.wakeup_id === id);
-        cancelWake(id);
+        const id = input['triggerId'].trim();
+        const wasPending = listTriggers({ canvas: true }).some((t) => t.trigger_id === id);
+        cancelTrigger(id);
         return { id, was_pending: wasPending };
     },
-    render: (r) => `Canceled wake ${r['id']}${r['was_pending'] === true ? '' : ' (already gone — no-op)'}.`,
+    render: (r) => `Canceled trigger ${r['id']}${r['was_pending'] === true ? '' : ' (already gone — no-op)'}.`,
 });
-// node wake (branch) ---------------------------------------------------------
-const nodeWake = defineBranch({
-    name: 'wake',
-    description: 'arm/list/cancel scheduled wakeups — the second trigger that stirs a dormant node: time',
-    whenToUse: 'you want to schedule work on a CLOCK — a long-horizon or recurring task that fires at a future time or loops on a cadence: a standing job, a recurring cron, a deferred or repeating node birth, or a poll against EXTERNAL state (CI, a deploy, a clock) after a backoff. This is the TIME trigger, NOT a way to watch your own agents — to monitor a child you arm NOTHING: you auto-subscribe on spawn, so its finish, crash, or close wakes you on its own; a deadline to chase a delegate is the belt-and-suspenders the runtime makes redundant. `at` arms a self-alarm (the timed twin of `node yield`), `until` bounds an inbox-wait with a deadline, `spawn` defers or repeats the BIRTH of a new node, `list`/`cancel` inspect and reap',
+const nodeTriggers = defineBranch({
+    name: 'triggers',
+    description: 'inspect/cancel pending triggers (clock + predicate)',
+    whenToUse: 'an agent wants to see/reap its own or the canvas\'s pending triggers — clock or predicate — armed by `node msg` or `node new`',
     help: {
-        name: 'node wake',
-        summary: 'the pending-wakeups namespace — arm a time trigger on the dormant state, then inspect/cancel it',
-        model: 'Time is the second trigger that stirs a dormant node — the first is an inbox message, and a scheduled wake is just a future delivery on that same channel. At the moment you set, the runtime brings you (or, for a deferred birth, a fresh node) back through the ordinary revive path: no new window, nothing the focus model learns. Reach for it to schedule CLOCK-driven work — a standing job, a recurring loop (--every), a deferred birth, or a poll against EXTERNAL state after a backoff. It is NOT how you watch your own agents: you auto-subscribe to every child you spawn, so its finish already wakes you — arm nothing and stay dormant rather than set a timer to "check if it is done" — a child finishing, crashing, or being closed all wake you on their own. (`until` is a narrow exception: a deadline backstop on an inbox-wait the runtime CANNOT guarantee to deliver — an unpushable external, never a delegate, whose outcome already wakes you.) Use this to wait CHEAPLY — end your turn, go dormant (free: no window, no compute), and be woken only when it is worth acting again. `at` arms a self-alarm; `until` bounds an inbox-wait with a deadline; `spawn` defers or repeats the BIRTH of a new node (the full recipe stored on the wake); `list`/`cancel` inspect and reap. Arming is a pure side-effect: it writes a durable row, it does NOT end your turn — end your turn separately to go dormant.',
+        name: 'node triggers',
+        summary: 'the pending-triggers namespace — inspect or cancel a trigger armed by `node msg` or `node new`',
     },
-    children: [nodeWakeAt, nodeWakeUntil, nodeWakeSpawn, nodeWakeList, nodeWakeCancel],
+    children: [nodeTriggersList, nodeTriggersCancel],
 });
+// ── /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',
+        slash: pyramidSlash,
         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 work, or walking the subscription graph. CRITICAL, and your default reflex — spawning a child is the first move on almost any task, not a fallback. Your own context window is the scarce resource: before you read files into it to understand, implement, debug, or change code you do not already know, hand that to a fresh node and get back just the conclusion, matching the node kind to the work. Keep inline only a fact you already know. Fan out independent units as CONCURRENT children — a wake with idle workers is wasted; serialize only true dependencies, and never let two live children edit the same files. Once you delegate a unit, do not also run it yourself: you auto-subscribe on spawn, so its finish wakes you. Spawn + collect mechanics: `crtr node -h`.',
+            useWhen: 'delegating work, or walking the subscription graph. CRITICAL, and your default reflex — spawning a child is the first move on almost any task, not a fallback. Your own context window is the scarce resource: before you read files into it to understand, implement, debug, or change code you do not already know, hand that to a fresh node and get back just the conclusion, matching the node kind to the work. Keep inline only a fact you already know. Fan out independent units as CONCURRENT children — a wake with idle workers is wasted; serialize only true dependencies, and never let two live children edit the same files. Once you delegate a unit, do not also run it yourself: you auto-subscribe on spawn, so its finish wakes you. Use the help surface for the exact node contract before invoking it.'
         },
         help: {
             name: 'node',
             summary: 'spawn and navigate canvas nodes',
             model: 'Every agent is a node in one directed graph (the canvas); `subscribes_to` is the spine — spawn a child and you auto-subscribe (active) to it, so its finish wakes you.\n\n' +
                 'WHEN TO DELEGATE: hand any self-contained unit of work to a child instead of doing it inline — it keeps your own context window (your scarce resource) free for steering. Spawn independent units in PARALLEL; a wake with idle workers is wasted. Serialize only true dependencies, and never let two live children edit the same files.\n\n' +
-                'HOW: `crtr node new "<task>" --kind <kind>` returns a node id immediately and runs the worker as a detached headless broker (no window opens; open a viewer on demand with `crtr node focus`). Match the kind to the work (see `node new -h`). You are woken when a child finishes — the wake message ALREADY IS the coalesced digest (the watcher drains your inbox to wake you), so don\'t re-run `crtr feed read` to "open" it (it would read empty, the cursor already advanced); instead dereference the report paths in that digest that matter, don\'t act on a one-line label. (`crtr feed read` is for proactively polling before a wake, or inspecting a child\'s inbox via `--node`; `--all` re-reads history with full message bodies.) Integrate, then either delegate the next units or finish.\n\n' +
-                'FINISH: a worker ends its own work with `crtr push final "<result>"` (writes the canonical result, marks done, closes the window) — stopping without it is not finishing. For a job too big for one context window, `node promote` to an orchestrator (holds a roadmap, delegates phases); when context fills, `node yield` to refresh against that roadmap.',
+                'HOW: the new leaf returns a node id immediately and runs the worker as a detached headless broker; no viewer opens unless a surface asks for one. Match the kind to the work and read the leaf schema before invoking. You are woken when a child finishes — the wake message ALREADY IS the coalesced digest, so dereference the report paths in that digest that matter instead of acting on a one-line label. Integrate, then either delegate the next units or finish.\n\n' +
+                'FINISH: a worker ends its own work with a final push, which writes the canonical result, marks done, and closes the window; stopping without it is not finishing. For a job too big for one context window, promote to an orchestrator; when context fills, yield to refresh against that roadmap.',
         },
-        children: [nodeNew, nodeInspect, nodeFocus, nodeCycle, nodeRecycle, nodeClose, nodeMsg, nodeSubscribe, nodeUnsubscribe, nodePromote, nodeDemote, nodeLifecycle, nodeYield, nodeWake],
+        children: [nodeNew, nodeMsg, nodeSubscribe, nodeUnsubscribe, nodePromote, nodeYield, nodeFocus, nodeCycle, nodeInspect, nodeLifecycle, nodeConfig, nodeTriggers],
     });
 }