@crouton-kit/crouter 0.3.15 → 0.3.17

package/dist/core/canvas/browse/terminal.d.ts

@@ -0,0 +1,23 @@
+export interface Key {
+    upArrow: boolean;
+    downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    return: boolean;
+    escape: boolean;
+    ctrl: boolean;
+    meta: boolean;
+    tab: boolean;
+    shiftTab: boolean;
+    backspace: boolean;
+}
+export declare function parseKeypress(data: Buffer): {
+    input: string;
+    key: Key;
+};
+export declare function setupTerminal(): void;
+export declare function restoreTerminal(): void;
+export declare function getTerminalSize(): {
+    cols: number;
+    rows: number;
+};

package/dist/core/canvas/browse/terminal.js

@@ -0,0 +1,100 @@
+// terminal.ts — raw-mode helpers for the `crtr canvas browse` TUI.
+//
+// Hand-rolled (no deps), mirroring humanloop's src/tui/terminal.ts. Extends its
+// key parsing beyond up/down/return/escape/tab/backspace/ctrl + printable input:
+// adds leftArrow/rightArrow (cursor keys) and shiftTab (`\x1b[Z`) so the browser
+// can drive tree expand/collapse and tab cycling.
+function emptyKey() {
+    return {
+        upArrow: false,
+        downArrow: false,
+        leftArrow: false,
+        rightArrow: false,
+        return: false,
+        escape: false,
+        ctrl: false,
+        meta: false,
+        tab: false,
+        shiftTab: false,
+        backspace: false,
+    };
+}
+export function parseKeypress(data) {
+    const str = data.toString('utf8');
+    const key = emptyKey();
+    if (str === '\x1b[A') {
+        key.upArrow = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[B') {
+        key.downArrow = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[C') {
+        key.rightArrow = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[D') {
+        key.leftArrow = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[Z') {
+        key.shiftTab = true;
+        return { input: '', key };
+    }
+    if (str === '\r' || str === '\n') {
+        key.return = true;
+        return { input: '', key };
+    }
+    // Alt+Backspace: terminals send ESC followed by DEL/BS. Must precede the
+    // bare-ESC check so the two-byte sequence isn't swallowed as plain escape.
+    if (str === '\x1b\x7f' || str === '\x1b\b') {
+        key.meta = true;
+        key.backspace = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b') {
+        key.escape = true;
+        return { input: '', key };
+    }
+    if (str === '\t') {
+        key.tab = true;
+        return { input: '', key };
+    }
+    if (str === '\x7f' || str === '\b') {
+        key.backspace = true;
+        return { input: '', key };
+    }
+    if (str.length === 1 && str.charCodeAt(0) < 32) {
+        key.ctrl = true;
+        const ch = String.fromCharCode(str.charCodeAt(0) + 64).toLowerCase();
+        return { input: ch, key };
+    }
+    // Multi-byte chunks (paste, multi-byte UTF-8, unknown escape sequences) are
+    // returned as-is in `input`; the input-mode handler sanitises them before
+    // appending to its buffer. Top-level handlers ignore strings of length > 1.
+    return { input: str, key };
+}
+export function setupTerminal() {
+    if (!process.stdin.isTTY) {
+        throw new Error('crtr canvas browse requires an interactive terminal (TTY)');
+    }
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdout.write('\x1b[?25l'); // hide cursor
+    process.stdout.write('\x1b[?1049h'); // alt screen
+    process.stdout.write('\x1b[2J\x1b[H'); // clear
+}
+export function restoreTerminal() {
+    process.stdout.write('\x1b[?25h'); // show cursor
+    process.stdout.write('\x1b[?1049l'); // restore screen
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+}
+export function getTerminalSize() {
+    return {
+        cols: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24,
+    };
+}

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

@@ -86,8 +86,14 @@ export interface PruneResult {
  *  `created` is older than `ttlDays`, bounding the otherwise-unbounded growth of
  *  node rows + dirs. The edges→nodes FK (`ON DELETE CASCADE`, migration v4) GCs
  *  each pruned node's edges automatically; the on-disk `nodes/<id>/` dir is
- *  removed too. Live nodes are NEVER touched: active | idle are the daemon's
- *  domain, a DISJOINT status set, so prune and supervision can't interfere.
+ *  removed too.
+ *
+ *  With `includeStale`, ALSO prunes nominally-live (active | idle) nodes past the
+ *  TTL whose process is provably gone — `pi_pid` is NULL or no longer alive. This
+ *  reaps stale roots (a bare `crtr` whose pi died without the row transitioning),
+ *  which the daemon's supervision never reconciled. A genuinely-running node keeps
+ *  a live `pi_pid`, so it is protected, as is the CALLER ($CRTR_NODE_ID). Without
+ *  the flag, active | idle are NEVER touched (the daemon's domain).
  *
  *  The row deletes run in ONE transaction (so the sweep is all-or-nothing); the
  *  dir removals follow after COMMIT — the fs isn't transactional, and by then the
@@ -96,4 +102,5 @@ export interface PruneResult {
 export declare function pruneNodes(opts: {
     ttlDays: number;
     dryRun?: boolean;
+    includeStale?: boolean;
 }): PruneResult;

package/dist/core/canvas/canvas.js

@@ -352,12 +352,29 @@ export function rebuildIndex() {
             recordSpawn(meta.node_id, prov);
     }
 }
+/** Is `pid` a live process? `kill(pid, 0)` sends no signal — it only probes
+ *  existence/permission. ESRCH ⇒ gone; EPERM ⇒ alive but not ours (still alive). */
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
 /** Retention sweep: remove TERMINAL nodes (status dead | done | canceled) whose
  *  `created` is older than `ttlDays`, bounding the otherwise-unbounded growth of
  *  node rows + dirs. The edges→nodes FK (`ON DELETE CASCADE`, migration v4) GCs
  *  each pruned node's edges automatically; the on-disk `nodes/<id>/` dir is
- *  removed too. Live nodes are NEVER touched: active | idle are the daemon's
- *  domain, a DISJOINT status set, so prune and supervision can't interfere.
+ *  removed too.
+ *
+ *  With `includeStale`, ALSO prunes nominally-live (active | idle) nodes past the
+ *  TTL whose process is provably gone — `pi_pid` is NULL or no longer alive. This
+ *  reaps stale roots (a bare `crtr` whose pi died without the row transitioning),
+ *  which the daemon's supervision never reconciled. A genuinely-running node keeps
+ *  a live `pi_pid`, so it is protected, as is the CALLER ($CRTR_NODE_ID). Without
+ *  the flag, active | idle are NEVER touched (the daemon's domain).
  *
  *  The row deletes run in ONE transaction (so the sweep is all-or-nothing); the
  *  dir removals follow after COMMIT — the fs isn't transactional, and by then the
@@ -365,9 +382,11 @@ export function rebuildIndex() {
  *  reports the candidate set and deletes NOTHING. */
 export function pruneNodes(opts) {
     const dryRun = opts.dryRun ?? false;
+    const includeStale = opts.includeStale ?? false;
     const cutoff = new Date(Date.now() - opts.ttlDays * 86_400_000).toISOString();
+    const selfId = process.env['CRTR_NODE_ID'] ?? '';
     const db = openDb();
-    const candidates = db
+    const terminal = db
         .prepare(`SELECT node_id, status, created FROM nodes
          WHERE status IN ('dead', 'done', 'canceled') AND created < ?
          ORDER BY created`)
@@ -376,6 +395,25 @@ export function pruneNodes(opts) {
         status: r['status'],
         created: r['created'],
     }));
+    // Stale non-terminal sweep (opt-in): active | idle past the TTL whose process
+    // is provably gone (pi_pid NULL or not alive). Never the caller itself.
+    const stale = !includeStale ? [] : db
+        .prepare(`SELECT node_id, status, created, pi_pid FROM nodes
+         WHERE status IN ('active', 'idle') AND created < ?
+         ORDER BY created`)
+        .all(cutoff)
+        .filter((r) => {
+        if (r['node_id'] === selfId)
+            return false;
+        const pid = r['pi_pid'];
+        return pid === null || !pidAlive(pid);
+    })
+        .map((r) => ({
+        node_id: r['node_id'],
+        status: r['status'],
+        created: r['created'],
+    }));
+    const candidates = [...terminal, ...stale];
     if (dryRun || candidates.length === 0)
         return { pruned: candidates, dryRun };
     // One transactioned sweep — delete the rows; the FK cascades their edges.

package/dist/core/canvas/db.js

@@ -196,9 +196,8 @@ function addPaneColumn(db) {
  *  viewport (Q7 widens canvas.db from "topology" to "topology + focuses"). Each
  *  row is anchored on the durable tmux `%pane_id`; `session` is a derived cache
  *  reconciled from the pane; `node_id` is UNIQUE so a node occupies at most one
- *  focus (Q5). Additive, forward-only — nothing reads it as authority yet (Step 4
- *  populates it in lockstep with the legacy `focus.ptr` via a transitional
- *  dual-write; the switch to table-as-authority lands in Step 6). */
+ *  focus (Q5). The focuses table is the CANONICAL focus store — there is no
+ *  focus.ptr file and no dual-write bridge; placement writes focus rows directly. */
 function addFocusesTable(db) {
     db.exec(`
 CREATE TABLE IF NOT EXISTS focuses (

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

@@ -15,8 +15,8 @@ export declare function closeFocusRow(focus_id: string): void;
 export declare function getFocusByNode(node_id: string): FocusRow | null;
 /** The focus realized by a given pane (`%id`), or null. */
 export declare function getFocusByPane(pane: string): FocusRow | null;
-/** A focus by its stable id, or null. (Used by the transitional focus.ptr
- *  dual-write bridge to read back its single canonical row; removed in Step 8.) */
+/** A focus by its stable id, or null. Used by placement to read a row back by id
+ *  (handFocusToManager / retargetFocus / registerRootFocus). */
 export declare function getFocusById(focus_id: string): FocusRow | null;
 /** Every focus row, ordered by id. */
 export declare function listFocuses(): FocusRow[];

package/dist/core/canvas/focuses.js

@@ -4,7 +4,8 @@
 // "topology + focuses", so the focus-row SQL lives here beside the node+edge
 // model, never in the runtime layer. A FOCUS is one durable on-screen viewport
 // bound to one node; the table is PLURAL (many focuses across windows/sessions),
-// the generalization of the old single `focus.ptr`.
+// the generalization of the old single focus pointer. It is the CANONICAL focus
+// store — there is no focus.ptr file and no dual-write bridge.
 //
 // placement.ts COMPOSES over these atomic setters/reads (the same way it calls
 // setPresence) — it never runs raw focus SQL itself.
@@ -66,8 +67,8 @@ export function getFocusByPane(pane) {
         .get(pane);
     return r ? focusFrom(r) : null;
 }
-/** A focus by its stable id, or null. (Used by the transitional focus.ptr
- *  dual-write bridge to read back its single canonical row; removed in Step 8.) */
+/** A focus by its stable id, or null. Used by placement to read a row back by id
+ *  (handFocusToManager / retargetFocus / registerRootFocus). */
 export function getFocusById(focus_id) {
     const r = openDb()
         .prepare('SELECT * FROM focuses WHERE focus_id = ?')

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

@@ -23,6 +23,16 @@ export interface DashboardRow {
     mode: string;
     ctx_tokens: number;
     asks: number;
+    /** The dir the node is pinned to (its cwd). Drives the browser's cwd-scope
+     *  filter + the All-dirs basename cue. */
+    cwd: string;
+    /** ISO 8601 birth timestamp — drives the recency sort + the relative-age cue. */
+    created: string;
+    /** The node's spawn prompt (context/initial-prompt.md), trimmed + capped. Only
+     *  populated by dashboardRowsAll (the browser snapshot) — the dashboard leaf
+     *  leaves it undefined to avoid a file read per node. Indexed by super-search
+     *  and shown in the preview panel. */
+    goal?: string;
 }
 /** One row per node visible in the sub-DAG of `rootId` (including root). */
 export declare function dashboardRows(rootId: string): DashboardRow[];

package/dist/core/canvas/render.js

@@ -16,7 +16,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getNode, listNodes, subscriptionsOf, view } from './canvas.js';
 import { fullName } from './labels.js';
-import { jobDir } from './paths.js';
+import { jobDir, contextDir } from './paths.js';
 import { countAsks } from './attention.js';
 // ---------------------------------------------------------------------------
 // Glyphs
@@ -162,6 +162,25 @@ export function renderForest() {
     }
     return parts.join('\n\n');
 }
+/** The spawn prompt, read straight off disk (canvas-home state) and capped so a
+ *  giant initial-prompt.md can't bloat the snapshot. Mirrors how telemetry is
+ *  read here directly rather than via the runtime layer (which would invert the
+ *  canvas→runtime dependency). Never throws. */
+const GOAL_CAP = 4096;
+function readGoalText(nodeId) {
+    try {
+        const p = join(contextDir(nodeId), 'initial-prompt.md');
+        if (!existsSync(p))
+            return undefined;
+        const body = readFileSync(p, 'utf8').trim();
+        if (body === '')
+            return undefined;
+        return body.length > GOAL_CAP ? body.slice(0, GOAL_CAP) : body;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** One row per node visible in the sub-DAG of `rootId` (including root). */
 export function dashboardRows(rootId) {
     const ids = [rootId, ...view(rootId)];
@@ -178,6 +197,8 @@ export function dashboardRows(rootId) {
                 mode: node.mode,
                 ctx_tokens: tel.tokens_in ?? 0,
                 asks: countAsks(id),
+                cwd: node.cwd,
+                created: node.created,
             }];
     });
 }
@@ -196,6 +217,9 @@ export function dashboardRowsAll() {
                 mode: row.mode,
                 ctx_tokens: tel.tokens_in ?? 0,
                 asks: countAsks(row.node_id),
+                cwd: row.cwd,
+                created: row.created,
+                goal: readGoalText(row.node_id),
             }];
     });
 }

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

@@ -168,7 +168,7 @@ export interface Edge {
 /** A FOCUS row as stored in the `focuses` table (canvas.db, migration v6): one
  *  durable on-screen viewport the user looks at, bound to one node. Plural —
  *  many focuses live at once across windows and sessions (the plural
- *  generalization of the old single `focus.ptr`). Anchored on the durable tmux
+ *  generalization of the old single focus pointer). Anchored on the durable tmux
  *  `%pane_id`; `session` is a derived cache reconciled from the pane. `node_id`
  *  is UNIQUE — a node occupies at most one focus (Q5). */
 export interface FocusRow {

package/dist/core/feed/inbox.d.ts

@@ -45,8 +45,5 @@ export declare function writeCursor(nodeId: string, iso: string): void;
  *     [<kind>]                                ← ref-less msg: full body inlined
  *       <body line>
  *     …
- *
- * A header line announces the total count and instructs the receiver to
- * dereference only what matters.
  */
 export declare function coalesce(entries: InboxEntry[]): string;

package/dist/core/feed/inbox.js

@@ -139,14 +139,10 @@ function renderEntry(e) {
  *     [<kind>]                                ← ref-less msg: full body inlined
  *       <body line>
  *     …
- *
- * A header line announces the total count and instructs the receiver to
- * dereference only what matters.
  */
 export function coalesce(entries) {
     if (entries.length === 0)
         return '(inbox empty)';
-    const header = `${entries.length} update${entries.length === 1 ? '' : 's'} since last read — dereference what matters.\n`;
     // Group by `from` (null → 'system').
     const groups = new Map();
     for (const e of entries) {
@@ -160,5 +156,5 @@ export function coalesce(entries) {
         const lines = items.map(renderEntry);
         sections.push(`From ${sender} — ${items.length} update${items.length === 1 ? '' : 's'}:\n${lines.join('\n')}`);
     }
-    return header + sections.join('\n\n');
+    return sections.join('\n\n');
 }

package/dist/core/runtime/busy.d.ts

@@ -0,0 +1,8 @@
+/** Mark a node mid-turn (pi entered a turn). Best-effort. */
+export declare function markBusy(nodeId: string): void;
+/** Clear the mid-turn marker (the turn ended, however it routed). Best-effort. */
+export declare function clearBusy(nodeId: string): void;
+/** Is the node currently inside a turn? AND this with `pidAlive` at the call
+ *  site — a stale marker from a crashed pi is harmless because the dead pid
+ *  fails the AND. */
+export declare function isBusy(nodeId: string): boolean;

package/dist/core/runtime/busy.js

@@ -0,0 +1,46 @@
+// busy.ts — the "is pi actually mid-turn" signal (a marker file, no db column).
+//
+// The disposition of a focus's OUTGOING node on a hot-swap (placement.ts
+// `outgoingDisposition`) must distinguish a terminal worker that is GENUINELY
+// mid-turn (keep it running off-screen, Invariant F2) from one merely PARKED at
+// its prompt with a live pi (a viewer revived for inspection — despawn it back to
+// dormant on focus-away). A live pid is NOT that signal: a parked node has a live
+// pid too. This marker is.
+//
+// `<jobDir>/busy` exists for exactly the span pi is inside a turn: the stophook
+// touches it on `agent_start` and unlinks it at the top of `agent_end` (and
+// defensively on `session_shutdown`). It is always AND-ed with `pidAlive` at the
+// read site, so a stale marker (process crashed mid-turn without firing
+// agent_end) is harmless — the dead pid fails the AND and the node is reaped.
+// No db migration, atomic touch/unlink, best-effort (never throws).
+import { existsSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { jobDir } from '../canvas/index.js';
+function busyPath(nodeId) {
+    return join(jobDir(nodeId), 'busy');
+}
+/** Mark a node mid-turn (pi entered a turn). Best-effort. */
+export function markBusy(nodeId) {
+    try {
+        mkdirSync(jobDir(nodeId), { recursive: true });
+        writeFileSync(busyPath(nodeId), '');
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/** Clear the mid-turn marker (the turn ended, however it routed). Best-effort. */
+export function clearBusy(nodeId) {
+    try {
+        rmSync(busyPath(nodeId), { force: true });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/** Is the node currently inside a turn? AND this with `pidAlive` at the call
+ *  site — a stale marker from a crashed pi is harmless because the dead pid
+ *  fails the AND. */
+export function isBusy(nodeId) {
+    return existsSync(busyPath(nodeId));
+}

package/dist/core/runtime/close.js

@@ -130,8 +130,8 @@ export function closeNode(rootId) {
             transition(id, 'cancel');
             // 2) Tear the node off its placement (pane-keyed): close any focus row it
             //    occupies, kill its PANE (the window closes once its last pane goes, so
-            //    sibling nodes the user co-located in one window survive), null its
-            //    LOCATION, and clear focus.ptr if it was the current focus.
+            //    sibling nodes the user co-located in one window survive), and null its
+            //    LOCATION (closing the focus row is the record — no pointer to clear).
             tearDownNode(id);
             // 3) Leave the resume notice AFTER the watcher is gone, so it survives.
             appendInbox(id, {

package/dist/core/runtime/demote.js

@@ -16,12 +16,10 @@ import { join } from 'node:path';
 import { getNode, setPresence, updateNode, setFocusOccupant, fullName } from '../canvas/index.js';
 import { reportsDir } from '../canvas/paths.js';
 import { pushFinal } from '../feed/feed.js';
-import { spawnNode } from './nodes.js';
+import { spawnNode, nodeSession } from './nodes.js';
 import { buildLaunchSpec, buildPiArgv } from './launch.js';
-import { piCommand, paneLocation, nodeSession } from './tmux.js';
 import { FRONT_DOOR_ENV } from './front-door.js';
-import { getFocus, setFocus } from './presence.js';
-import { focusOf, recycleFocusPane } from './placement.js';
+import { focusOf, recycleFocusPane, piCommand, paneLocation } from './placement.js';
 import { ensureDaemon } from '../../daemon/manage.js';
 /** The agent's most recent surfaced message: the newest reports/*.md body with
  *  its YAML frontmatter stripped. Empty string when the node never reported. */
@@ -104,12 +102,9 @@ export async function demoteNode(nodeId, callerPane) {
     if (f !== null) {
         try {
             setFocusOccupant(f.focus_id, root.node_id);
-            setFocus(root.node_id);
         }
         catch { /* best-effort */ }
     }
-    else if (getFocus() === nodeId)
-        setFocus('');
     const fresh = getNode(root.node_id);
     const inv = buildPiArgv(fresh);
     const env = { ...inv.env, CRTR_ROOT_SESSION: nodeSession(), [FRONT_DOOR_ENV]: '1' };

package/dist/core/runtime/launch.d.ts

@@ -6,12 +6,14 @@ export declare const CANVAS_GOAL_CAPTURE_PATH: string;
 export declare const CANVAS_PASSIVE_CONTEXT_PATH: string;
 export declare const CANVAS_CONTEXT_INTRO_PATH: string;
 export declare const CANVAS_COMMANDS_PATH: string;
+export declare const CANVAS_RESUME_PATH: string;
 /** The canvas extensions every node loads, in order: stophook (routing +
  *  telemetry + session-id capture), inbox-watcher (wake), nav (in-editor
  *  graph chrome), goal-capture (persist the first user message as the goal),
  *  passive-context (drain passive backlog as pre-text on the next message),
  *  context-intro (inject the <crtr-context> bearings block as its own session
- *  message, once per brand-new chat), commands (the /promote slash-command).
+ *  message, once per brand-new chat), commands (the /promote slash-command),
+ *  resume (the /resume-node whole-canvas picker → `crtr node focus`).
  *  All self-gate on CRTR_NODE_ID. goal-capture precedes passive-context so it
  *  reads the raw user text. */
 export declare const CANVAS_EXTENSIONS: string[];

package/dist/core/runtime/launch.js

@@ -33,12 +33,14 @@ export const CANVAS_GOAL_CAPTURE_PATH = resolveExtension('canvas-goal-capture');
 export const CANVAS_PASSIVE_CONTEXT_PATH = resolveExtension('canvas-passive-context');
 export const CANVAS_CONTEXT_INTRO_PATH = resolveExtension('canvas-context-intro');
 export const CANVAS_COMMANDS_PATH = resolveExtension('canvas-commands');
+export const CANVAS_RESUME_PATH = resolveExtension('canvas-resume');
 /** The canvas extensions every node loads, in order: stophook (routing +
  *  telemetry + session-id capture), inbox-watcher (wake), nav (in-editor
  *  graph chrome), goal-capture (persist the first user message as the goal),
  *  passive-context (drain passive backlog as pre-text on the next message),
  *  context-intro (inject the <crtr-context> bearings block as its own session
- *  message, once per brand-new chat), commands (the /promote slash-command).
+ *  message, once per brand-new chat), commands (the /promote slash-command),
+ *  resume (the /resume-node whole-canvas picker → `crtr node focus`).
  *  All self-gate on CRTR_NODE_ID. goal-capture precedes passive-context so it
  *  reads the raw user text. */
 export const CANVAS_EXTENSIONS = [
@@ -49,6 +51,7 @@ export const CANVAS_EXTENSIONS = [
     CANVAS_PASSIVE_CONTEXT_PATH,
     CANVAS_CONTEXT_INTRO_PATH,
     CANVAS_COMMANDS_PATH,
+    CANVAS_RESUME_PATH,
 ];
 /** Bare model aliases resolve to the anthropic provider under pi (avoids the
  *  bedrock default). Anything with a `/` or an unknown name passes through. */

package/dist/core/runtime/lifecycle.d.ts

@@ -2,7 +2,7 @@ import type { NodeMeta } from '../canvas/types.js';
 /** The lifecycle events — the only vocabulary for moving a node's status/intent.
  *  Each maps (in the table below) to a target status and/or intent plus the set
  *  of from-statuses it is legal from. */
-export type LifecycleEvent = 'finalize' | 'reap' | 'cancel' | 'crash' | 'yield' | 'release' | 'revive' | 'boot';
+export type LifecycleEvent = 'finalize' | 'cancel' | 'crash' | 'yield' | 'release' | 'revive' | 'boot';
 /** Enact a lifecycle event on a node: validate the from-status against the
  *  table, then write status+intent in ONE atomic statement (so they can never
  *  disagree). Returns the hydrated node view after the write.

package/dist/core/runtime/lifecycle.js

@@ -17,9 +17,17 @@
 // "flip status to a non-supervised value + clear intent BEFORE killing the
 // window" — the daemon only ever revives active|idle nodes, so a teardown must
 // leave the node done/canceled first to close the revive race. That invariant is
-// now the DEFINITION of the `reap`/`cancel` events: callers flip via transition()
+// now the DEFINITION of the `cancel` event: callers flip via transition()
 // and only THEN kill the window.
 //
+// Unification (A5, human-confirmed 2026-06-06): an externally-reaped node — torn
+// down because the user moved on (close cascade) OR because a root reset/relaunch
+// superseded it — ends `canceled`, NOT `done`. `done` is reserved for a node that
+// finished its OWN work (finalize). The old `reap` event (→ done) was identical to
+// `cancel` in every field and side effect once unified on status, so it was
+// COLLAPSED into `cancel`; reset.ts's reapDescendants + relaunchRoot park-old now
+// route through `cancel`.
+//
 // Layering note: lifecycle.ts is runtime, but it is the canvas write surface's
 // `transition` verb (the only writer of status+intent), so it owns its atomic
 // row UPDATE directly via openDb — the one sanctioned exception to "only
@@ -35,9 +43,9 @@ const LIVE = ['active', 'idle'];
 const TRANSITIONS = {
     // feed.push(final) · queue.cancelJob · markCleanExitDone (clean quit).
     finalize: { status: 'done', intent: 'done', from: LIVE },
-    // reapDescendants · relaunchRoot park-old. Forced teardown → done, intent cleared.
-    reap: { status: 'done', intent: null, from: ANY },
-    // closeNode cascade. Forced teardown → canceled, intent cleared.
+    // closeNode cascade · reapDescendants · relaunchRoot park-old. Forced teardown
+    // of a node that did NOT finish its own work → canceled, intent cleared. (A5:
+    // done is reserved for finalize; every external reap unifies on canceled.)
     cancel: { status: 'canceled', intent: null, from: ANY },
     // daemon superviseTick: window gone with no yield/release intent. Intent KEPT
     // (the dead log line still reports it).

package/dist/core/runtime/naming.d.ts

@@ -1,12 +1,12 @@
 import type { NodeMeta } from '../canvas/index.js';
-/** Coerce arbitrary text into a 3-5 word kebab-case name, or '' if nothing
+/** Coerce arbitrary text into a 3-8 word kebab-case name, or '' if nothing
  *  usable survives. Lowercases, keeps [a-z0-9], collapses everything else to a
- *  single hyphen, and clamps to the first 5 words. */
+ *  single hyphen, and clamps to the first 8 words. */
 export declare function sanitizeSessionName(raw: string): string;
 /** Local fallback: derive a name straight from the prompt (no pi call). Drops
  *  stop-words, takes the first few content words. */
 export declare function slugFromPrompt(prompt: string): string;
-/** Synchronously ask pi for a 2-4 word kebab name for `prompt`. Blocks up to
+/** Synchronously ask pi for a 3-8 word kebab name for `prompt`. Blocks up to
  *  NAME_TIMEOUT_MS; on any failure (non-zero exit, timeout, empty/garbled
  *  output) falls back to a local slug. Returns '' only for an empty prompt. */
 export declare function generateSessionName(prompt: string): string;

package/dist/core/runtime/naming.js

@@ -2,7 +2,7 @@
 // handle for the editor label.
 //
 // A node's editor label is `<kind> (<mode>) <name> <cycle>` (see editorLabel in
-// launch.ts). The `<name>` is a 3-5 word kebab-case "description" derived from
+// launch.ts). The `<name>` is a 3-8 word kebab-case "description" derived from
 // the first prompt by asking pi headlessly (`pi -p`), persisted on the node's
 // meta so it survives revives and shows in every cycle.
 //
@@ -26,7 +26,7 @@ const PROMPT_CAP = 2000;
 const NAME_TIMEOUT_MS = 20_000;
 const NAME_SYSTEM_PROMPT = 'You name coding-agent work sessions. This name is a label used to identify the ' +
     'session at a glance among many other concurrent programming sessions, so it must ' +
-    'describe what the task is about. Reply with ONLY a concise 3-5 word name in ' +
+    'describe what the task is about. Reply with ONLY a concise 3-8 word name in ' +
     'kebab-case: lowercase words joined by single hyphens (e.g. `refactor-auth-token-flow`, ' +
     '`add-csv-export-endpoint`). No punctuation, quotes, prose, or trailing text. ' +
     'Output JUST the name, nothing else.';
@@ -43,9 +43,9 @@ const STOPWORDS = new Set([
     'is', 'are', 'be', 'this', 'that', 'it', 'as', 'at', 'by', 'from', 'into',
     'please', 'can', 'you', 'i', 'we', 'my', 'our', 'me', 'so', 'then',
 ]);
-/** Coerce arbitrary text into a 3-5 word kebab-case name, or '' if nothing
+/** Coerce arbitrary text into a 3-8 word kebab-case name, or '' if nothing
  *  usable survives. Lowercases, keeps [a-z0-9], collapses everything else to a
- *  single hyphen, and clamps to the first 5 words. */
+ *  single hyphen, and clamps to the first 8 words. */
 export function sanitizeSessionName(raw) {
     const firstLine = (raw ?? '').split('\n').map((l) => l.trim()).find((l) => l !== '') ?? '';
     const words = firstLine
@@ -53,7 +53,7 @@ export function sanitizeSessionName(raw) {
         .replace(/[^a-z0-9]+/g, '-')
         .split('-')
         .filter((w) => w !== '');
-    return words.slice(0, 5).join('-');
+    return words.slice(0, 8).join('-');
 }
 /** Local fallback: derive a name straight from the prompt (no pi call). Drops
  *  stop-words, takes the first few content words. */
@@ -97,7 +97,7 @@ function nameArgs(prompt) {
     argv.push(nameUserPrompt(prompt));
     return argv;
 }
-/** Synchronously ask pi for a 2-4 word kebab name for `prompt`. Blocks up to
+/** Synchronously ask pi for a 3-8 word kebab name for `prompt`. Blocks up to
  *  NAME_TIMEOUT_MS; on any failure (non-zero exit, timeout, empty/garbled
  *  output) falls back to a local slug. Returns '' only for an empty prompt. */
 export function generateSessionName(prompt) {

package/dist/core/runtime/nodes.d.ts

@@ -1,6 +1,13 @@
 import { type NodeMeta, type Mode, type Lifecycle, type LaunchSpec } from '../canvas/index.js';
 /** Generate a node id in the same shape as job ids (time-sortable + random). */
 export declare function newNodeId(): string;
+/** The single, shared tmux session that ALL canvas node windows live in.
+ *  Overridable with CRTR_NODE_SESSION (default `crtr`). Every root and every
+ *  child opens a window here rather than cluttering the user's own working
+ *  session — switch to it to browse the whole live graph, ignore it otherwise.
+ *  Pure policy (env only, no tmux call), so it lives in the node layer, not the
+ *  driver; the tmux driver imports it from here for installMenuBinding's use. */
+export declare function nodeSession(): string;
 /** Resolve the tmux session a freshly-born node's window/pane opens into — and
  *  thus its durable REVIVE-HOME (`home_session`). Pure so the birth decision is
  *  unit-testable without a live tmux: