@crouton-kit/crouter 0.3.45 → 0.3.46

package/dist/core/preview-registry.js

@@ -76,9 +76,10 @@ const LEAF_ICON_CP = {
     'canvas attention list': 0xf03a,
     'canvas attention map': 0xf279,
     'canvas revive': 0xf021,
+    'node lifecycle revive': 0xf021,
     'canvas history search': 0xf002,
     'canvas history read': 0xf02d,
-    'canvas history show': 0xf1da,
+    'node inspect artifacts': 0xf1da,
     'sys daemon start': 0xf04b,
     'sys daemon status': 0xf111,
     'sys daemon stop': 0xf04d,
@@ -558,10 +559,10 @@ function summarizeCanvasAttentionMap(text) {
 }
 /** Find the first argv token after `skipWords` that isn't a boolean flag
  *  (`--foo`) — recovers a leaf's own positional id when its render() output
- *  carries no id of its own (see summarizeCanvasRevive below). Safe here
- *  specifically because every `canvas revive` flag is a boolean with no
- *  separate value token, so a naive forward scan can't mistake a flag's
- *  value for the positional. */
+ *  carries no id of its own (see summarizeNodeLifecycleRevive below). Safe
+ *  here specifically because every `node lifecycle revive` flag is a boolean
+ *  with no separate value token, so a naive forward scan can't mistake a
+ *  flag's value for the positional. */
 function firstPositionalAfter(tokens, skipWords) {
     for (let i = skipWords; i < tokens.length; i++) {
         if (!tokens[i].startsWith('--'))
@@ -569,31 +570,24 @@ function firstPositionalAfter(tokens, skipWords) {
     }
     return undefined;
 }
-/** `crtr canvas revive` (src/commands/revive.ts) has no custom `render`, so
- *  its object output falls through to generic renderResult. Four shapes
- *  depending on flags:
- *  - `--all` (preview or executed) carries a `- mode: preview|revived`
- *    bullet — skipped (null): `candidates`/`revived`/`failed` are
- *    prose-or-bullet depending on whether they contain a newline (multi- vs
- *    single-id), which core/render.ts's `isProse` makes genuinely ambiguous
- *    to parse strictly, and this is a rare admin path.
- *  - `--now` kick: the only shape with `- kicked: true` (revive.ts:192).
- *  - plain single-node revive: the only shape with `- resumed: true|false`.
- *    `window` (revive.ts:83) is documented "Always null", so it's never
- *    bulleted — and there is no node id anywhere in the output, so it's
- *    recovered from argv (the leaf's own positional) via
+/** `crtr node lifecycle revive` (src/commands/node-lifecycle-revive.ts) has no
+ *  custom `render`, so its object output falls through to generic
+ *  renderResult. Two shapes depending on flags:
+ *  - `--now` kick: the only shape with `- kicked: true`.
+ *  - plain single-node revive (default or `--fresh`): the only shape with
+ *    `- resumed: true|false`. `window` is documented "Always null", so it's
+ *    never bulleted — and there is no node id anywhere in the output, so
+ *    it's recovered from argv (the leaf's own positional) via
  *    firstPositionalAfter.
  *  Returns null on any other/unrecognized shape. */
-function summarizeCanvasRevive(text, tokens) {
-    if (/^- mode:\s*\S+\s*$/m.test(text))
-        return null;
+function summarizeNodeLifecycleRevive(text, tokens) {
     if (/^- kicked:\s*true\s*$/m.test(text)) {
         return [{ text: 'kicked — daemon resumes in ~20s', tone: 'warning' }];
     }
     const resumedMatch = /^- resumed:\s*(true|false)\s*$/m.exec(text);
     if (resumedMatch === null)
         return null;
-    const id = firstPositionalAfter(tokens, 2); // 'canvas','revive' = 2 words
+    const id = firstPositionalAfter(tokens, 3); // 'node','lifecycle','revive' = 3 words
     const lines = [{ text: id !== undefined ? `revived ${id}` : 'revived', tone: 'success' }];
     const readyMatch = /^- ready:\s*(true|false)\s*$/m.exec(text);
     if (readyMatch !== null && readyMatch[1] === 'false') {
@@ -601,6 +595,13 @@ function summarizeCanvasRevive(text, tokens) {
     }
     return lines;
 }
+// `crtr canvas revive --all` (src/commands/revive.ts) has no custom `render`,
+// so its object output falls through to generic renderResult; both the
+// preview and executed shapes carry a `- mode: preview|revived` bullet, which
+// core/render.ts's `isProse` makes genuinely ambiguous to parse strictly
+// (`candidates`/`revived`/`failed` are prose-or-bullet depending on whether
+// they contain a newline). Rare admin path — no summarizer registered; the
+// generic truncated render is fine.
 /** `crtr canvas history search` (renderSearch, src/commands/canvas-history/
  *  search.ts:246) has three shapes: `0 hits.`; `--full` (### heading blocks
  *  per hit, not tabular — skipped, returns null); or the normal `N of M
@@ -685,7 +686,7 @@ function summarizeCanvasHistoryRead(text) {
     }
     return lines;
 }
-/** `crtr canvas history show` (src/commands/canvas-history/show.ts:66):
+/** `crtr node inspect artifacts` (src/commands/node-inspect-artifacts.ts):
  *  `node: <name (id)>\n\n0 artifacts. | N artifacts:\n\n<table
  *  cols=ref,source,ts,detail>\n\n<follow_up>`. `source` values are
  *  colon-prefixed types (`report:final`, `report:update`, `doc`,
@@ -695,7 +696,7 @@ function summarizeCanvasHistoryRead(text) {
  *  match — or when the parsed row count doesn't match the leading `N
  *  artifacts:` count (this render has no pagination, so the two must
  *  agree exactly). */
-function summarizeCanvasHistoryShow(text) {
+function summarizeNodeInspectArtifacts(text) {
     const nodeMatch = /^node: (.+)$/m.exec(text);
     if (nodeMatch === null)
         return null;
@@ -1897,10 +1898,10 @@ const SUMMARIZERS = [
     { path: 'canvas attention count', run: summarizeCanvasAttentionCount },
     { path: 'canvas attention list', run: summarizeCanvasAttentionList },
     { path: 'canvas attention map', run: summarizeCanvasAttentionMap },
-    { path: 'canvas revive', run: summarizeCanvasRevive },
+    { path: 'node lifecycle revive', run: summarizeNodeLifecycleRevive },
     { path: 'canvas history search', run: summarizeCanvasHistorySearch },
     { path: 'canvas history read', run: summarizeCanvasHistoryRead },
-    { path: 'canvas history show', run: summarizeCanvasHistoryShow },
+    { path: 'node inspect artifacts', run: summarizeNodeInspectArtifacts },
     { path: 'sys daemon start', run: summarizeSysDaemonStart },
     { path: 'sys daemon status', run: summarizeSysDaemonStatus },
     { path: 'sys daemon stop', run: summarizeSysDaemonStop },

package/dist/core/profiles/select.d.ts

@@ -4,10 +4,18 @@
  *     its manifest does not already cover `cwd` and the session is interactive,
  *     offer to add `cwd` to its purview (default yes). Bump `last_used_at`,
  *     return the id.
- *  2. Else, among profiles whose project list COVERS `cwd`, pick the
- *     most-recently-used (nulls oldest), bump its `last_used_at`, return it.
- *  3. Else — nothing covers cwd. Interactive session: prompt synchronously to
- *     create a profile here or proceed as root, BEFORE pi boots. Non-
+ *  2. Else, if EXACTLY ONE profile's project dir IS `cwd` (you're at a project
+ *     root, unambiguously one owner), auto-pick it with no prompt — the
+ *     strongest signal. If SEVERAL profiles claim `cwd` exactly, it's genuinely
+ *     ambiguous: interactive → menu among them + create; headless → MRU.
+ *  3. Else, among profiles whose project list otherwise COVERS `cwd` (cwd sits
+ *     in a subdir of, or a workspace above, one of their project dirs):
+ *       - Interactive: prompt with a MENU of those covering profiles + "create
+ *         a new profile here", BEFORE pi boots (no root option — the directory
+ *         is covered). Default is the MRU covering profile.
+ *       - Non-interactive: auto-pick the MRU covering profile, no prompt.
+ *  4. Else — nothing covers cwd walking all the way up. Interactive: prompt to
+ *     create a profile here or proceed as root (root lives ONLY here). Non-
  *     interactive (no TTY): default to root (null) and print the recovery
  *     instruction to STDERR — never stdout, which the caller may be piping. */
 export declare function selectProfileForCwd(cwd: string, explicitProfile?: string | null): Promise<string | null>;

package/dist/core/profiles/select.js

@@ -1,11 +1,15 @@
 // Startup profile selection — the CTO-decided order applied at the front door
-// and at any non-inherited `crtr node new`: explicit `--profile` > MRU profile
-// covering cwd > synchronous create-or-root decision. This is the ONLY place
-// that decision runs; front-door.ts/spawn.ts call it, never re-derive it.
+// and at any non-inherited `crtr node new`: explicit `--profile` > a profile
+// whose project dir IS cwd exactly (auto) > an interactive menu of profiles
+// covering cwd from a parent/workspace dir + create (MRU auto when headless) >
+// synchronous create-or-root decision when nothing covers. This is the ONLY
+// place that decision runs; front-door.ts/spawn.ts call it, never re-derive it.
 import { existsSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { basename, resolve as resolvePath, sep } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { listProfiles, loadProfileManifest, updateProfileLastUsed, createProfile, addProfileProject, } from './manifest.js';
+import { stdoutColor } from '../output.js';
 /** Resolve cwd to an absolute, realpath'd form so it compares against the
  *  realpath'd project dirs `createProfile`/`addProfileProject` already store
  *  (manifest.ts resolves every project dir through `realpathSync`). Falls back
@@ -52,6 +56,74 @@ function pickMostRecent(entries) {
 function isInteractive() {
     return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
 }
+// ---------------------------------------------------------------------------
+// Pre-boot prompt presentation. These prompts print to the raw controlling
+// terminal BEFORE pi takes it over (not the attach viewer), so styling is
+// plain ANSI via the house `stdoutColor` helper (NO_COLOR / non-TTY aware) and
+// portable glyphs only — no Nerd Font (the pre-boot terminal may lack it).
+// One shared visual language across all four gates: a bold title + optional
+// dim subtitle, then accent-keyed option rows. We deliberately do NOT echo the
+// user's own cwd back at them (they know where they are) — the only paths
+// worth showing are OTHER dirs: which project root a covering profile owns.
+// ---------------------------------------------------------------------------
+const dim = stdoutColor.dim;
+const bold = stdoutColor.bold;
+const accent = stdoutColor.cyan;
+/** Selectable key ([1], [c], [r]) — the one thing the eye hunts for. */
+function key(k) {
+    return accent(bold(k));
+}
+/** Collapse the home prefix to `~` so project paths read short. */
+function tildify(p) {
+    const home = homedir();
+    if (p === home)
+        return '~';
+    if (p.startsWith(home + sep))
+        return '~' + p.slice(home.length);
+    return p;
+}
+/** Coarse "last used" for disambiguating profiles that otherwise look alike
+ *  (notably several profiles claiming the SAME dir). null → never used. */
+function relativeUsed(iso) {
+    if (iso === null)
+        return 'never used';
+    const then = Date.parse(iso);
+    if (Number.isNaN(then))
+        return 'used recently';
+    const secs = Math.max(0, Math.floor((Date.now() - then) / 1000));
+    if (secs < 60)
+        return 'used just now';
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return `used ${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `used ${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `used ${days}d ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `used ${months}mo ago`;
+    return `used ${Math.floor(months / 12)}y ago`;
+}
+/** Blank-line-padded bold title with an optional dim subtitle beneath it. No
+ *  cwd echo — the user already knows their own directory. */
+function writeHeader(title, subtitle) {
+    const sub = subtitle !== undefined ? `  ${dim(subtitle)}\n` : '';
+    process.stdout.write(`\n  ${bold(title)}\n${sub}\n`);
+}
+/** One option row: `    <key>  <label>  <dim detail>  · default`. `label` is
+ *  passed pre-styled; `detail` is dimmed here; the default row gets a marker. */
+function optionRow(k, label, detail, isDefault) {
+    const det = detail !== '' ? '  ' + dim(detail) : '';
+    const def = isDefault ? '  ' + accent('\u00b7 default') : '';
+    return `    ${key(k)}  ${label}${det}${def}\n`;
+}
+/** The trailing readline prompt: `  › <dim hint> `. */
+function caret(hint) {
+    return `  ${accent('\u203a')} ${dim(hint)} `;
+}
 function recoveryMessage(cwd) {
     return (`crtr: no profile covers ${cwd}, and this session is non-interactive — starting without a profile (root).\n` +
         `Run \`crtr profile new --name <name> --project ${cwd}\` to create one, or pass --profile <id-or-name> next time.\n`);
@@ -75,8 +147,10 @@ function recoveryMessage(cwd) {
 async function promptAddDirToProfile(entry, cwd) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     try {
-        process.stdout.write(`\nProfile "${entry.manifest.name}" does not cover this directory:\n  ${cwd}\n\n`);
-        const choice = (await rl.question('Add it to the profile? [Y/n]: ')).trim().toLowerCase();
+        writeHeader(`Profile "${entry.manifest.name}" doesn't cover this directory`);
+        const choice = (await rl.question(caret('add it to the profile? [Y/n]')))
+            .trim()
+            .toLowerCase();
         if (choice === 'n' || choice === 'no')
             return;
         addProfileProject(entry.profileId, cwd);
@@ -85,19 +159,77 @@ async function promptAddDirToProfile(entry, cwd) {
         rl.close();
     }
 }
+/** Ask for a name (defaulting to cwd's basename) and create a profile pointing
+ *  at cwd on the SAME open readline — shared by both interactive create paths
+ *  so the name prompt reads identically whether reached via the covering menu
+ *  or the no-coverage fallback. */
+async function createProfileHere(rl, cwd) {
+    const defaultName = basename(cwd) || 'profile';
+    const nameInput = (await rl.question(caret(`name the new profile [${defaultName}]`))).trim();
+    const name = nameInput !== '' ? nameInput : defaultName;
+    const profileId = createProfile(name, [cwd]).profileId;
+    process.stdout.write(`  ${accent('\u2713')} ${dim(`created profile "${name}"`)}\n`);
+    return profileId;
+}
 async function promptCreateOrRoot(cwd) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     try {
-        process.stdout.write(`\nNo profile covers this directory:\n  ${cwd}\n\n`);
-        const choice = (await rl.question('Create a profile here, or run as root? [c]reate / [r]oot: '))
-            .trim()
-            .toLowerCase();
+        writeHeader('No profile covers this directory');
+        process.stdout.write(optionRow('c', 'create a profile here', '', false));
+        process.stdout.write(optionRow('r', dim('run without a profile (root)'), '', true));
+        process.stdout.write('\n');
+        const choice = (await rl.question(caret('[c/r]'))).trim().toLowerCase();
         if (choice !== 'c' && choice !== 'create')
             return null;
-        const defaultName = basename(cwd) || 'profile';
-        const nameInput = (await rl.question(`Profile name [${defaultName}]: `)).trim();
-        const name = nameInput !== '' ? nameInput : defaultName;
-        return createProfile(name, [cwd]).profileId;
+        return await createProfileHere(rl, cwd);
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Choose among a set of candidate profiles for `cwd`, or create a new one.
+ *  Reached in two ambiguous cases: MULTIPLE profiles claim `cwd` as their exact
+ *  project dir (`exact` true), or `cwd` merely sits within one or more profiles'
+ *  project dirs from a parent/workspace dir (`exact` false). Present them
+ *  most-recently-used first (choice 1 / the bare-Enter default) plus "create a
+ *  new profile here", and block until answered. Root is deliberately NOT offered
+ *  here: a claimed/covered directory always has at least a covering profile as a
+ *  sane identity, so `[r]oot` belongs only to the no-coverage prompt
+ *  (`promptCreateOrRoot`). Same raw-readline / boot-gating rationale. */
+async function promptPickProfileOrCreate(candidates, cwd, exact) {
+    // MRU-first so the most-recently-used candidate is choice 1 / the bare-Enter
+    // default — the same profile the non-interactive path auto-picks.
+    const ordered = [...candidates].sort((a, b) => isMoreRecent(a.manifest.last_used_at, b.manifest.last_used_at) ? -1 : 1);
+    // Pad names to a shared column so the dim detail lines up down the menu.
+    const nameWidth = Math.max(...ordered.map((e) => e.manifest.name.length));
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        writeHeader(exact ? 'Choose a profile' : 'Select a profile', exact
+            ? 'Several profiles claim this directory as their project'
+            : 'This directory falls under existing profile(s)');
+        ordered.forEach((entry, i) => {
+            // For exact ties the covered path is identical, so surface last-used to
+            // tell them apart; for parent/workspace coverage, WHICH dir covers cwd
+            // is the useful differentiator.
+            const detail = exact
+                ? relativeUsed(entry.manifest.last_used_at)
+                : `covers ${tildify(entry.manifest.projects.find((p) => projectCovers(cwd, p)) ?? entry.manifest.projects[0])}`;
+            const label = bold(entry.manifest.name.padEnd(nameWidth));
+            process.stdout.write(optionRow(String(i + 1), label, detail, i === 0));
+        });
+        process.stdout.write(optionRow('c', dim('create a new profile here'), '', false));
+        process.stdout.write('\n');
+        const answer = (await rl.question(caret('[1]'))).trim().toLowerCase();
+        if (answer === 'c' || answer === 'create')
+            return await createProfileHere(rl, cwd);
+        if (answer === '')
+            return ordered[0].profileId;
+        const n = Number.parseInt(answer, 10);
+        if (Number.isInteger(n) && n >= 1 && n <= ordered.length)
+            return ordered[n - 1].profileId;
+        // Unrecognized input → the safe default (the MRU candidate); never loop,
+        // since this prompt is gating pi's boot on the shared TTY.
+        return ordered[0].profileId;
     }
     finally {
         rl.close();
@@ -109,10 +241,18 @@ async function promptCreateOrRoot(cwd) {
  *     its manifest does not already cover `cwd` and the session is interactive,
  *     offer to add `cwd` to its purview (default yes). Bump `last_used_at`,
  *     return the id.
- *  2. Else, among profiles whose project list COVERS `cwd`, pick the
- *     most-recently-used (nulls oldest), bump its `last_used_at`, return it.
- *  3. Else — nothing covers cwd. Interactive session: prompt synchronously to
- *     create a profile here or proceed as root, BEFORE pi boots. Non-
+ *  2. Else, if EXACTLY ONE profile's project dir IS `cwd` (you're at a project
+ *     root, unambiguously one owner), auto-pick it with no prompt — the
+ *     strongest signal. If SEVERAL profiles claim `cwd` exactly, it's genuinely
+ *     ambiguous: interactive → menu among them + create; headless → MRU.
+ *  3. Else, among profiles whose project list otherwise COVERS `cwd` (cwd sits
+ *     in a subdir of, or a workspace above, one of their project dirs):
+ *       - Interactive: prompt with a MENU of those covering profiles + "create
+ *         a new profile here", BEFORE pi boots (no root option — the directory
+ *         is covered). Default is the MRU covering profile.
+ *       - Non-interactive: auto-pick the MRU covering profile, no prompt.
+ *  4. Else — nothing covers cwd walking all the way up. Interactive: prompt to
+ *     create a profile here or proceed as root (root lives ONLY here). Non-
  *     interactive (no TTY): default to root (null) and print the recovery
  *     instruction to STDERR — never stdout, which the caller may be piping. */
 export async function selectProfileForCwd(cwd, explicitProfile) {
@@ -128,14 +268,34 @@ export async function selectProfileForCwd(cwd, explicitProfile) {
         return entry.profileId;
     }
     const covering = listProfiles().filter((p) => profileCoversCwd(p, resolvedCwd));
-    if (covering.length > 0) {
-        const winner = pickMostRecent(covering);
-        updateProfileLastUsed(winner.profileId);
-        return winner.profileId;
+    const exact = covering.filter((p) => p.manifest.projects.some((proj) => proj === resolvedCwd));
+    // Exactly one profile's project dir IS cwd — unambiguous project root, use it
+    // silently, never a prompt. (Several exact claims fall through to the menu.)
+    if (exact.length === 1) {
+        updateProfileLastUsed(exact[0].profileId);
+        return exact[0].profileId;
     }
+    // Non-interactive: cannot prompt. Prefer an exact claimant, else any covering
+    // profile (both MRU), else root.
     if (!isInteractive()) {
+        const pool = exact.length > 0 ? exact : covering;
+        if (pool.length > 0) {
+            const winner = pickMostRecent(pool);
+            updateProfileLastUsed(winner.profileId);
+            return winner.profileId;
+        }
         process.stderr.write(recoveryMessage(resolvedCwd));
         return null;
     }
-    return await promptCreateOrRoot(resolvedCwd);
+    // Interactive. Several exact claimants → choose among them. Else covered from
+    // a parent/workspace dir → menu of covering profiles. Else nothing covers →
+    // the create-or-root prompt (root is only ever offered there).
+    const chosen = exact.length > 1
+        ? await promptPickProfileOrCreate(exact, resolvedCwd, true)
+        : covering.length > 0
+            ? await promptPickProfileOrCreate(covering, resolvedCwd, false)
+            : await promptCreateOrRoot(resolvedCwd);
+    if (chosen !== null)
+        updateProfileLastUsed(chosen);
+    return chosen;
 }

package/dist/core/runtime/bearings.js

@@ -448,7 +448,7 @@ export function buildContextBearings(nodeId) {
         bearings.push('', profileSection);
     const wt = node?.managed_worktree;
     if (wt?.state === 'open') {
-        bearings.push('', '## Your managed worktree', `Branch: \`${wt.branch}\`\nWorktree: \`${wt.path}\`\nBase: \`${wt.base_ref}\` @ \`${wt.base_sha}\`\nCommit work here. Land it with \`crtr worktree close\` before finishing; \`crtr push final\` is blocked until this worktree is closed.`);
+        bearings.push('', '## Your managed worktree', `Branch: \`${wt.branch}\`\nWorktree: \`${wt.path}\`\nBase: \`${wt.base_ref}\` @ \`${wt.base_sha}\`\nCommit work here. Land it with \`crtr node worktree close\` before finishing; \`crtr push final\` is blocked until this worktree is closed.`);
     }
     // Orchestrator-only: the across-cycles framing (a terminal has no future cycle).
     if (node?.mode === 'orchestrator')

package/dist/core/runtime/close.js

@@ -4,7 +4,7 @@
 // EXCLUSIVELY owns, walking DOWN the subscribes_to spine (subscriptionsOf = a
 // node's reports/children). Nothing is deleted: pi_session_id, the canvas
 // edges, and all on-disk state persist, so any closed node can later be revived
-// (`crtr canvas revive` / focus → `pi --session <id>`). A close is a pause, not a reap.
+// (`crtr node lifecycle revive` / focus → `pi --session <id>`). A close is a pause, not a reap.
 //
 // Per node, in this order — the order matters twice:
 //

package/dist/core/runtime/kickoff.js

@@ -1,5 +1,5 @@
 // The revive kickoff — the message auto-injected as a node's first turn when it
-// comes back FRESH (a refresh-yield, or `canvas revive --fresh`). The node's
+// comes back FRESH (a refresh-yield, or `node lifecycle revive --fresh`). The node's
 // in-memory context is gone, so this message IS its bearings: everything is
 // read from disk and framed so the node can rebuild and continue without a
 // round-trip. Resuming a saved conversation needs none of this (the
@@ -140,7 +140,7 @@ function reportKind(filename) {
 /** Condensed report-history index for each ACTIVE subscription of `nodeId` —
  *  independent of publisher liveness, so a finished worker's history still
  *  surfaces for catch-up. Each source carries only its count and newest report
- *  ref; older refs stay one command away via `canvas history show`. */
+ *  ref; older refs stay one command away via `node inspect artifacts`. */
 function reportHistorySources(nodeId) {
     const out = [];
     for (const sub of subscriptionsOf(nodeId).filter((s) => s.active)) {
@@ -201,7 +201,7 @@ function feedBlock(nodeId, unreadDigest) {
         lines.push('', `Report history on disk (collapsed): ${total} report${total === 1 ? '' : 's'} across ${history.length} subscribed node${history.length === 1 ? '' : 's'}. This is a catch-up index for reports your cursor already passed; read only what matters.`, ...visible.map((h) => {
             const ref = `${h.nodeId}:reports/${h.latest}`;
             return `  - ${h.name} (${h.nodeId}): ${h.count} report${h.count === 1 ? '' : 's'}; latest ${reportKind(h.latest)}: ${ref}`;
-        }), ...(hidden > 0 ? [`  - … ${hidden} more subscribed node${hidden === 1 ? '' : 's'} with reports hidden`] : []), 'Expand: `crtr canvas history read <ref>` for one listed report; `crtr canvas history show <node-id> --type report` for that node\'s full report list; `crtr canvas history show <node-id> --type inbox` for cursor-independent inbox history including full message bodies.');
+        }), ...(hidden > 0 ? [`  - … ${hidden} more subscribed node${hidden === 1 ? '' : 's'} with reports hidden`] : []), 'Expand: `crtr canvas history read <ref>` for one listed report; `crtr node inspect artifacts <node-id> --type report` for that node\'s full report list; `crtr node inspect artifacts <node-id> --type inbox` for cursor-independent inbox history including full message bodies.');
     }
     return `<feed>\n${lines.join('\n')}\n</feed>`;
 }

package/dist/core/runtime/revive.js

@@ -1,6 +1,6 @@
 // The revive primitive — restores a node to active status by relaunching its
 // broker engine. Used by both the supervisor daemon (on crash/refresh
-// detection) and the explicit `crtr canvas revive` command.
+// detection) and the explicit `crtr node lifecycle revive` command (or `crtr canvas revive --all`).
 //
 // A revive replays the node's persisted LaunchSpec + cwd (the canonical recipe)
 // and launches the headless broker host (the only host after the
@@ -87,7 +87,7 @@ export function reviveNode(nodeId, opts) {
     // right below into believing a dead broker is still alive. Idempotent and
     // cheap once reconciled (a single small file read) except the one time it
     // actually matters, so it's safe to call on every revive regardless of
-    // entry point (daemon tick, or a direct/manual `canvas revive`).
+    // entry point (daemon tick, or a direct/manual `node lifecycle revive`).
     reconcileBootLiveness();
     // Double-revive guard: the broker's isAlive IS isPidAlive(pi_pid), so a node
     // whose broker pid is still running was already revived by another path —

package/dist/core/view/stream-local.js

@@ -31,7 +31,7 @@ function makeNoBrokerError(target) {
         display: {
             headline: `node ${target} has no running broker`,
             explanation: 'The stream transport connects only to an already-running broker.',
-            nextStep: `Run crtr node focus ${target} or crtr canvas revive ${target}, then reconnect.`,
+            nextStep: `Run crtr node focus ${target} or crtr node lifecycle revive ${target}, then reconnect.`,
             level: 'error',
             blocking: false,
         },

package/dist/core/worktree.js

@@ -86,22 +86,22 @@ export function closeManagedWorktree(nodeId) {
         throw new WorktreeError('worktree_missing', `managed worktree path is missing: ${wt.path}`, 'Ask the human with `crtr human ask` before changing node state; the checkout disappeared outside crouter.');
     }
     if (isRebaseInProgress(wt.path)) {
-        throw new WorktreeError('rebase_in_progress', 'this managed worktree is mid-rebase', `Resolve conflicts in ${wt.path}, run \`git rebase --continue\` there, then rerun \`crtr worktree close\`.`);
+        throw new WorktreeError('rebase_in_progress', 'this managed worktree is mid-rebase', `Resolve conflicts in ${wt.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`.`);
     }
     const dirty = statusPorcelain(wt.path);
     if (dirty !== '') {
-        throw new WorktreeError('dirty_worktree', 'managed worktree has uncommitted changes', `Commit the work in ${wt.path} (or ask the human with \`crtr human ask\` if you do not know whether to keep it), then rerun \`crtr worktree close\`.`);
+        throw new WorktreeError('dirty_worktree', 'managed worktree has uncommitted changes', `Commit the work in ${wt.path} (or ask the human with \`crtr human ask\` if you do not know whether to keep it), then rerun \`crtr node worktree close\`.`);
     }
     const branch = currentBranch(wt.path);
     if (branch !== wt.branch) {
         const found = branch === 'HEAD' ? 'detached HEAD' : branch;
-        throw new WorktreeError('wrong_branch', `managed worktree is not on its recorded branch (expected ${wt.branch}, found ${found})`, `Check out ${wt.branch} in ${wt.path} before closing, or ask the human with \`crtr human ask\` if you are unsure why it changed, then rerun \`crtr worktree close\`.`);
+        throw new WorktreeError('wrong_branch', `managed worktree is not on its recorded branch (expected ${wt.branch}, found ${found})`, `Check out ${wt.branch} in ${wt.path} before closing, or ask the human with \`crtr human ask\` if you are unsure why it changed, then rerun \`crtr node worktree close\`.`);
     }
     runGit(wt.path, ['fetch', 'origin', 'main'], 'fetch_failed', 'Network/remote state blocked landing. Ask the human with `crtr human ask` if this is not a transient git/network issue.');
     const rebase = gitSync(['rebase', 'origin/main'], wt.path);
     if (rebase.status !== 0) {
         const detail = (rebase.stderr.trim() || rebase.stdout.trim()).trim();
-        throw new WorktreeError('rebase_failed', 'rebase onto origin/main did not complete', `Resolve conflicts in ${wt.path}, run \`git rebase --continue\` there, then rerun \`crtr worktree close\`. If the blocker is not mechanical, ask the human with \`crtr human ask\`.`, detail);
+        throw new WorktreeError('rebase_failed', 'rebase onto origin/main did not complete', `Resolve conflicts in ${wt.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`. If the blocker is not mechanical, ask the human with \`crtr human ask\`.`, detail);
     }
     const push = gitSync(['push', 'origin', 'HEAD:main'], wt.path);
     if (push.status !== 0) {

package/dist/daemon/crtrd.js

@@ -43,7 +43,7 @@
 // out-of-band launch.
 // dead-pid crash path grace-revives RESUME on the saved session (or, for a
 // crash mid-cycle, retries AS a cycle — see cycle_pending above) — the manual
-// recovery (kill broker + canvas revive) that fixes these by hand.
+// recovery (kill broker + node lifecycle revive) that fixes these by hand.
 //
 // Single-instance guarantee
 //   A PID file prevents double-runs. On start, if the file exists and the
@@ -235,7 +235,7 @@ function handleYieldStall(row, pid, now) {
 //   • no descendants (the broker pid stands alone — e.g. the engine itself
 //     stalled after a model_change, with nothing to kill) → the daemon
 //     performs the ONLY remaining remediation itself: SIGTERM the broker, the
-//     same on-demand kick `canvas revive --now` does, so its own dead-pid
+//     same on-demand kick `node lifecycle revive --now` does, so its own dead-pid
 //     crash-grace path (REVIVE_GRACE_MS) resumes it on the saved session with
 //     no lost context.
 //
@@ -451,7 +451,7 @@ function handleWedgeDetection(id, pid, now) {
     else {
         // No descendant to kill — the engine itself stalled (e.g. mid model_change)
         // with nothing a human could kill. The daemon performs the same kick
-        // `canvas revive --now` does on demand: SIGTERM the broker, then its own
+        // `node lifecycle revive --now` does on demand: SIGTERM the broker, then its own
         // dead-pid crash-grace path (REVIVE_GRACE_MS) resumes it on the saved
         // session (issue #119).
         label =

package/dist/web/transport-stream.js

@@ -23,7 +23,7 @@ function makeNoBrokerError(target) {
         display: {
             headline: `node ${target} is asleep or has no running broker`,
             explanation: 'This browser stream connects only to an already-running local broker.',
-            nextStep: `Run crtr node focus ${target} or crtr canvas revive ${target}, then reconnect.`,
+            nextStep: `Run crtr node focus ${target} or crtr node lifecycle revive ${target}, then reconnect.`,
             level: 'error',
             blocking: false,
         },