@crouton-kit/crouter 0.3.80 → 0.3.82

package/dist/clients/attach/chat-view.js

@@ -201,7 +201,7 @@ export class ChatView {
                     //  renderedPendingTools → pendingTools, where live tool events find them.)
                     if (message.stopReason === 'aborted' || message.stopReason === 'error') {
                         const errorMessage = message.stopReason === 'aborted'
-                            ? 'Operation aborted'
+                            ? 'Interrupted'
                             : (message.errorMessage ?? 'Error');
                         component.updateResult({ content: [{ type: 'text', text: errorMessage }], isError: true });
                     }
@@ -333,8 +333,12 @@ export class ChatView {
                 if (this.streamingComponent) {
                     const stopReason = event.message.stopReason;
                     let errorMessage = event.message.errorMessage;
-                    if (stopReason === 'aborted' && !errorMessage) {
-                        errorMessage = 'Operation aborted';
+                    // An aborted turn is a user interrupt (Esc). The provider tends to
+                    // attach its own generic text ("Request was aborted."), so override it
+                    // outright — don't gate on the absence of an errorMessage — with a
+                    // plain, human label.
+                    if (stopReason === 'aborted') {
+                        errorMessage = 'Interrupted';
                         // Surface the abort on the assistant bubble itself, mirroring pi
                         // (interactive-mode.js:2280 sets streamingMessage.errorMessage before
                         // updateContent) so the rendered message shows the annotation.

package/dist/clients/attach/slash-commands.js

@@ -32,6 +32,7 @@ import { surfaceTmuxStyleArgs } from '../../core/runtime/surface-bg.js';
  *  `/graph` toggles the in-process overlay. Exported so the editor folds these
  *  into the slash autocomplete list. */
 export const CANVAS_SLASH_COMMANDS = [
+    { name: 'clear', description: 'Clear the conversation and free context — a fresh, empty session (like /new)' },
     { name: 'graph', description: 'Toggle the canvas GRAPH view (your local subscription tree)' },
     { name: 'promote', description: 'Promote this node to an orchestrator — /promote, or /promote <kind> to specialize' },
     { name: 'resume-node', description: 'Open the canvas navigator (search/scope/sort/tree) and resume the chosen node' },
@@ -48,7 +49,7 @@ const CANVAS_NAMES = new Set(CANVAS_SLASH_COMMANDS.map((c) => c.name));
  *  local node, `/context` opens local `crtr node inspect context`. `/graph`
  *  (the in-process GRAPH overlay, already remote-safe — see graph-overlay.ts)
  *  and `/view` (a self-contained popup unrelated to `nodeId`) stay available. */
-const REMOTE_UNSAFE_CANVAS_NAMES = new Set(['promote', 'resume-node', 'context', 'rename']);
+const REMOTE_UNSAFE_CANVAS_NAMES = new Set(['promote', 'resume-node', 'context', 'rename', 'clear']);
 /** tmux named colours accepted by `/color` (plus `colourN`/`#rrggbb`, validated
  *  by pattern). Mirrors tmux's colour-name table so a typo is rejected with the
  *  options rather than silently ignored by tmux. */
@@ -279,6 +280,13 @@ function dispatchCanvasCommand(name, arg, ctx) {
         return true;
     }
     switch (name) {
+        case 'clear':
+            // Claude-Code ergonomics: `/clear` == `/new` — drop the conversation and
+            // start an empty session (context freed). The broker's new_session re-
+            // emits a `welcome`, whose applySnapshot resetChat()s the pane, so the
+            // transcript is wiped too. Aliased here so muscle memory works.
+            ctx.send({ type: 'new_session' });
+            return true;
         case 'graph':
             // `/graph` opens the attach viewer's in-process GRAPH overlay, not a tmux
             // popup. Dispatch reaches it through the viewer integration's `onGraph` hook.

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

@@ -54,6 +54,13 @@ export declare function clearPid(nodeId: string): void;
 export declare function listNodes(filter?: {
     status?: NodeStatus | NodeStatus[];
 }): NodeRow[];
+/** Resumable ROOT conversations pinned to `cwd`, most-recently-created first.
+ *  A "root" is the top of a spine (`parent IS NULL`) that is a real
+ *  conversation (not a `kind:'human'` ask) and still resumable (`active`/`idle`,
+ *  never a `done`/`dead`/`canceled` node). This backs the front-door
+ *  `crtr -c`/`-r` resume: cwd is the key (the Claude-Code mental model — "my
+ *  last session HERE"), so it never teleports across projects. */
+export declare function listResumableRoots(cwd: string): NodeRow[];
 /** Record `A subscribes_to B` — A receives B's output. active=true wakes A on
  *  emit; passive accumulates pointers without a wake. Mutable; callable by anyone. */
 export declare function subscribe(subscriber: string, publisher: string, active?: boolean): void;

package/dist/core/canvas/canvas.js

@@ -288,6 +288,21 @@ export function listNodes(filter) {
     }
     return rows.map(rowFrom);
 }
+/** Resumable ROOT conversations pinned to `cwd`, most-recently-created first.
+ *  A "root" is the top of a spine (`parent IS NULL`) that is a real
+ *  conversation (not a `kind:'human'` ask) and still resumable (`active`/`idle`,
+ *  never a `done`/`dead`/`canceled` node). This backs the front-door
+ *  `crtr -c`/`-r` resume: cwd is the key (the Claude-Code mental model — "my
+ *  last session HERE"), so it never teleports across projects. */
+export function listResumableRoots(cwd) {
+    const rows = openDb()
+        .prepare(`SELECT * FROM nodes
+        WHERE parent IS NULL AND kind != 'human'
+          AND status IN ('active','idle') AND cwd = ?
+        ORDER BY created DESC`)
+        .all(cwd);
+    return rows.map(rowFrom);
+}
 // ---------------------------------------------------------------------------
 // Edges
 // ---------------------------------------------------------------------------

package/dist/core/runtime/broker.js

@@ -23,6 +23,7 @@ import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { getAgentDir, initTheme, } from '@earendil-works/pi-coding-agent';
 import { jobDir, nodeDir, sessionListCachePath, viewSocketPath } from '../canvas/paths.js';
+import { missingPackageWarning } from './package-health.js';
 import { SessionListCache } from './session-list-cache.js';
 import { getNode, updateNode } from '../canvas/index.js';
 import { FRONT_DOOR_ENV } from './front-door.js';
@@ -180,6 +181,19 @@ export async function runBroker(nodeId) {
     catch (err) {
         process.stderr.write(`[broker] WARNING: initTheme failed: ${String(err)}\n`);
     }
+    // Diagnose a stale local-path pi package (e.g. a moved crouter repo whose
+    // relative `pi-crtr-extensions` path in settings.json no longer resolves). pi
+    // discards a missing package silently, dropping its whole feature (the Claude
+    // command/marketplace bridge) with no trace; log it loudly so broker.log shows
+    // the cause. Fix: `crtr sys setup`.
+    try {
+        const warn = missingPackageWarning(getAgentDir());
+        if (warn !== null)
+            process.stderr.write(`[broker] WARNING: ${warn}\n`);
+    }
+    catch {
+        /* best-effort */
+    }
     // N3: the node's display name is re-applied inside rebindSession (below) so it
     // survives a session replacement (new_session/switch_session/fork), not only at
     // boot.

package/dist/core/runtime/front-door.js

@@ -3,6 +3,8 @@
 //   crtr                         → boot a root in this terminal (no prompt)
 //   crtr [dir]                   → root pinned to dir
 //   crtr [dir] ["prompt"]        → root with a starter prompt
+//   crtr -c | --continue         → resume the MRU root pinned to cwd (no picker)
+//   crtr -r | --resume           → resume a root pinned to cwd, chosen from a menu
 //   crtr --name NAME ...         → named root
 //   crtr --profile <id-or-name>  → root under an explicit profile (else the
 //                                  startup selector: a per-cwd pinned default,
@@ -18,7 +20,17 @@
 // over the terminal and the process never returns.
 import { existsSync, statSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
-import { bootRoot } from './spawn.js';
+// NOTE: the boot-path deps — ./spawn.js (bootRoot), ./resume.js (resumeRoot),
+// ./package-health.js (missingPackageWarning + piAgentDir) — are DYNAMICALLY
+// imported inside maybeBootRoot, NOT statically here. `cli.ts` calls
+// maybeBootRoot on every invocation, and a static import chain that reaches the
+// pi engine costs ~365ms of cold start that every leaf subcommand (`crtr memory
+// list`, etc.) would pay despite never booting a root. The dynamic imports below
+// are reached only after the early-return guards, i.e. only on a genuine
+// front-door boot. Note we DELIBERATELY do NOT import `@earendil-works/pi-coding-agent`
+// even on the boot path — the one thing we needed from it (getAgentDir) is
+// reimplemented as package-health's `piAgentDir()` so the whole pi engine never
+// loads in the FOREGROUND boot process (the broker loads it in parallel).
 function isDir(p) {
     try {
         return existsSync(p) && statSync(p).isDirectory();
@@ -31,7 +43,7 @@ function isDir(p) {
  *  positional dir/prompt). A leading token in this set still boots a root —
  *  without it, `crtr --name X` would fall through to the dispatcher and error as
  *  an unknown subcommand. */
-const FRONT_DOOR_FLAGS = new Set(['--name', '--kind', '--profile', '--pick-profile']);
+const FRONT_DOOR_FLAGS = new Set(['--name', '--kind', '--profile', '--pick-profile', '--continue', '-c', '--resume', '-r']);
 /** Parse `[dir] [prompt]` positionals + the front-door flags out of the leftover
  *  tokens after the bare `crtr`. */
 function parseRootArgs(tokens) {
@@ -40,6 +52,7 @@ function parseRootArgs(tokens) {
     let kind;
     let profile;
     let pickProfile = false;
+    let resume;
     const positionals = [];
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
@@ -55,6 +68,12 @@ function parseRootArgs(tokens) {
         else if (t === '--pick-profile') {
             pickProfile = true;
         }
+        else if (t === '--continue' || t === '-c') {
+            resume = 'continue';
+        }
+        else if (t === '--resume' || t === '-r') {
+            resume = 'pick';
+        }
         else if (t.startsWith('--')) {
             // ignore unknown flags for the front door
         }
@@ -67,7 +86,7 @@ function parseRootArgs(tokens) {
         cwd = resolvePath(positionals.shift());
     }
     const prompt = positionals.length > 0 ? positionals.join(' ') : undefined;
-    return { cwd, prompt, name, kind, profile, pickProfile };
+    return { cwd, prompt, name, kind, profile, pickProfile, resume };
 }
 /** Env marker set on every pi the front door boots. Its presence means we are
  *  already inside a front-door-booted root, so a nested front-door launch must
@@ -111,8 +130,35 @@ export async function maybeBootRoot(root, argv) {
             return false;
     }
     // Unambiguous front-door launch → boot a resident root inline (exec pi in
-    // this terminal). Does not return.
+    // this terminal). Does not return. Load the heavy boot-path deps lazily now
+    // that we've committed to booting (see the import note at the top of file).
+    const [{ bootRoot }, { resumeRoot }, { missingPackageWarning, piAgentDir }] = await Promise.all([
+        import('./spawn.js'),
+        import('./resume.js'),
+        import('./package-health.js'),
+    ]);
     const args = parseRootArgs(tokens);
+    // Surface any stale/missing local-path pi package BEFORE the viewer takes over
+    // the terminal — pi discards a missing package silently, so this is the only
+    // moment the user sees why (e.g.) their ~/.claude commands vanished.
+    try {
+        const warn = missingPackageWarning(piAgentDir());
+        if (warn !== null)
+            process.stderr.write(`\n${warn}\n\n`);
+    }
+    catch {
+        /* best-effort diagnostic — never block a boot */
+    }
+    // `-c`/`-r`: resume the last root pinned to this cwd (MRU, or via picker) by
+    // taking over THIS terminal as its viewer. Falls through to a fresh boot when
+    // nothing here is resumable, or when the picker was aborted.
+    if (args.resume !== undefined) {
+        const outcome = await resumeRoot(args.cwd, args.resume === 'pick');
+        // 'empty' → nothing to resume here, fall through to a fresh boot.
+        // 'aborted' → the user dismissed the picker; exit without surprise-booting.
+        if (outcome === 'aborted')
+            return true;
+    }
     await bootRoot({ ...args });
     return true;
 }

package/dist/core/runtime/package-health.d.ts

@@ -0,0 +1,28 @@
+export interface MissingPackage {
+    /** The raw `packages[]` entry as stored in settings.json. */
+    source: string;
+    /** Absolute path it resolved to (which does not exist). */
+    resolved: string;
+}
+/**
+ * The pi agent config dir (`~/.pi/agent`, or `$PI_CODING_AGENT_DIR`) — a local
+ * reimplementation of pi's `getAgentDir()`. Reimplemented (not imported) ON
+ * PURPOSE: `getAgentDir` lives in `@earendil-works/pi-coding-agent`, and
+ * importing that package pulls in the ENTIRE ~360ms pi engine module graph. The
+ * front door calls this on every bare-`crtr` boot BEFORE spawning the broker, so
+ * a static/dynamic pi import here adds ~316ms of serialized dead-time in the
+ * foreground before the broker (which loads pi itself) even starts. This mirrors
+ * pi's contract exactly: `$PI_CODING_AGENT_DIR` (tilde-expanded) else
+ * `~/.pi/agent`. Same precedent as `bearings.ts` (keep the pi engine out of the
+ * hot/foreground path). If pi ever rebrands its configDir/env, update here.
+ */
+export declare function piAgentDir(homeDir?: string): string;
+/**
+ * Return every local-path package in `<agentDir>/settings.json` whose resolved
+ * path is missing. Empty when settings is absent/unreadable or all paths exist.
+ * Mirrors pi's own resolution: `resolve(agentDir, expandTilde(source))`.
+ */
+export declare function findMissingPackagePaths(agentDir: string, homeDir?: string): MissingPackage[];
+/** A human-readable, actionable warning for a set of missing packages, or
+ *  `null` when nothing is missing. Names `crtr sys setup` as the fix. */
+export declare function missingPackageWarning(agentDir: string, homeDir?: string): string | null;

package/dist/core/runtime/package-health.js

@@ -0,0 +1,94 @@
+// package-health: detect pi packages configured in `<agentDir>/settings.json`
+// whose LOCAL-PATH source no longer exists on disk.
+//
+// Why this exists: pi installs a local-path package (e.g. crouter's bundled
+// `pi-crtr-extensions`, which surfaces `~/.claude` commands/skills/plugins as
+// slash commands) by storing its path in settings.json RELATIVE to the settings
+// dir. Moving the crouter repo silently invalidates that relative path — and pi
+// DISCARDS a missing package with no error, so the extension just never loads
+// and its whole feature (here: every Claude command/marketplace command) simply
+// vanishes with no diagnostic. This turns that silent failure into a loud,
+// actionable warning. The fix it points at is `crtr sys setup`, which re-resolves
+// package paths to the repo's current location.
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+/** Expand a leading `~` against `homeDir` (pi's own convention). */
+function expandTilde(pathValue, homeDir) {
+    if (pathValue === '~')
+        return homeDir;
+    if (pathValue.startsWith('~/'))
+        return join(homeDir, pathValue.slice(2));
+    return pathValue;
+}
+/**
+ * The pi agent config dir (`~/.pi/agent`, or `$PI_CODING_AGENT_DIR`) — a local
+ * reimplementation of pi's `getAgentDir()`. Reimplemented (not imported) ON
+ * PURPOSE: `getAgentDir` lives in `@earendil-works/pi-coding-agent`, and
+ * importing that package pulls in the ENTIRE ~360ms pi engine module graph. The
+ * front door calls this on every bare-`crtr` boot BEFORE spawning the broker, so
+ * a static/dynamic pi import here adds ~316ms of serialized dead-time in the
+ * foreground before the broker (which loads pi itself) even starts. This mirrors
+ * pi's contract exactly: `$PI_CODING_AGENT_DIR` (tilde-expanded) else
+ * `~/.pi/agent`. Same precedent as `bearings.ts` (keep the pi engine out of the
+ * hot/foreground path). If pi ever rebrands its configDir/env, update here.
+ */
+export function piAgentDir(homeDir = homedir()) {
+    const envDir = process.env['PI_CODING_AGENT_DIR'];
+    if (envDir !== undefined && envDir !== '')
+        return expandTilde(envDir, homeDir);
+    return join(homeDir, '.pi', 'agent');
+}
+/** A `packages[]` entry is a LOCAL PATH (not an npm ref) — the only kind that
+ *  can go stale on a repo move. `npm:...` and bare registry names resolve
+ *  through node/npm, not the filesystem, so they are out of scope here. */
+function isLocalPathSource(source) {
+    if (source.startsWith('npm:'))
+        return false;
+    return source.startsWith('.') || source.startsWith('/') || source.startsWith('~');
+}
+/**
+ * Return every local-path package in `<agentDir>/settings.json` whose resolved
+ * path is missing. Empty when settings is absent/unreadable or all paths exist.
+ * Mirrors pi's own resolution: `resolve(agentDir, expandTilde(source))`.
+ */
+export function findMissingPackagePaths(agentDir, homeDir = homedir()) {
+    let raw;
+    try {
+        raw = readFileSync(join(agentDir, 'settings.json'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    let packages;
+    try {
+        packages = JSON.parse(raw).packages;
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(packages))
+        return [];
+    const missing = [];
+    for (const entry of packages) {
+        if (typeof entry !== 'string' || !isLocalPathSource(entry))
+            continue;
+        const resolved = resolve(agentDir, expandTilde(entry, homeDir));
+        if (!existsSync(resolved))
+            missing.push({ source: entry, resolved });
+    }
+    return missing;
+}
+/** A human-readable, actionable warning for a set of missing packages, or
+ *  `null` when nothing is missing. Names `crtr sys setup` as the fix. */
+export function missingPackageWarning(agentDir, homeDir = homedir()) {
+    const missing = findMissingPackagePaths(agentDir, homeDir);
+    if (missing.length === 0)
+        return null;
+    const lines = missing.map((m) => `  • ${m.source}\n      → ${m.resolved} (missing)`);
+    return (`crtr: ${missing.length} configured pi package path${missing.length === 1 ? '' : 's'} ` +
+        `no longer exist${missing.length === 1 ? 's' : ''} — pi silently skips these, so their ` +
+        `slash commands (e.g. ~/.claude commands & marketplace plugins) will not load.\n` +
+        lines.join('\n') +
+        `\n  Fix: re-run \`crtr sys setup\` (re-resolves package paths to this repo's current location).`);
+}

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

@@ -0,0 +1,6 @@
+/** Resolve a front-door resume: pick a target root (MRU or via picker), then
+ *  take over this terminal to view it. On success it execs the viewer inline and
+ *  never returns. Otherwise reports why it did not: `'empty'` (no resumable root
+ *  here → caller boots a fresh one) or `'aborted'` (the picker was dismissed →
+ *  caller exits without surprise-booting). */
+export declare function resumeRoot(cwd: string, pick: boolean): Promise<'empty' | 'aborted'>;

package/dist/core/runtime/resume.js

@@ -0,0 +1,275 @@
+// Front-door resume — `crtr -c` / `crtr -r`.
+//
+//   crtr -c | --continue   → revive + attach the MRU root pinned to this cwd,
+//                            inline in THIS terminal (no picker). If no root is
+//                            resumable here, boot a fresh one.
+//   crtr -r | --resume     → same, but choose from a keypress menu of the roots
+//                            pinned to this cwd first.
+//
+// A "session" in the Claude-Code sense is a crtr ROOT node: a durable pi
+// conversation pinned to a cwd that never dies, only goes dormant. So resuming
+// is reviving the last root here and making THIS pane its controller-viewer —
+// mirroring the front-door boot tail (register the pane as the viewer focus,
+// then exec `crtr surface attach` inline). cwd is the key so it never teleports
+// across projects; see `listResumableRoots`.
+import { spawn } from 'node:child_process';
+import { emitKeypressEvents } from 'node:readline';
+import { getNode, listResumableRoots } from '../canvas/index.js';
+import { navLabel } from '../canvas/nav-model.js';
+import { isPidAlive } from '../canvas/pid.js';
+import { readGoal } from './kickoff.js';
+import { reviveNode } from './revive.js';
+import { installTmuxBindings } from './tmux-chrome.js';
+import { registerViewerFocus, waitForBrokerViewSocket, viewerSplitEnv, currentTmux, inTmux, } from './placement.js';
+import { getFocusByNode, closeFocusRow } from '../canvas/focuses.js';
+import { ensureDaemon } from '../../daemon/manage.js';
+import { stdoutColor } from '../output.js';
+const dim = stdoutColor.dim;
+const bold = stdoutColor.bold;
+const accent = stdoutColor.cyan;
+/** Resolve a front-door resume: pick a target root (MRU or via picker), then
+ *  take over this terminal to view it. On success it execs the viewer inline and
+ *  never returns. Otherwise reports why it did not: `'empty'` (no resumable root
+ *  here → caller boots a fresh one) or `'aborted'` (the picker was dismissed →
+ *  caller exits without surprise-booting). */
+export async function resumeRoot(cwd, pick) {
+    const roots = listResumableRoots(cwd);
+    if (roots.length === 0)
+        return 'empty';
+    let target;
+    if (pick && roots.length > 1) {
+        target = await pickRoot(roots, cwd);
+        if (target === null)
+            return 'aborted';
+    }
+    else {
+        target = roots[0]; // MRU (also the sole root under `-r` with one candidate)
+    }
+    await attachInline(target.node_id, cwd);
+    return 'aborted'; // unreachable — attachInline execs and exits
+}
+/** Revive the target root's broker if dormant, register THIS pane as its one
+ *  viewer, and exec `crtr surface attach` inline so this terminal becomes the
+ *  controller-viewer. Mirrors the front-door boot tail. Does not return. */
+async function attachInline(nodeId, cwd) {
+    void cwd;
+    if (!inTmux()) {
+        throw new Error('crtr must be resumed from inside a tmux session — start tmux first (e.g. `tmux new -s work`), then run `crtr -c` there.');
+    }
+    const meta = getNode(nodeId);
+    if (meta === null)
+        throw new Error(`resume: unknown node ${nodeId}`);
+    try {
+        ensureDaemon();
+    }
+    catch { /* daemon is best-effort */ }
+    // Revive the broker engine if dormant. reviveNode double-launch-guards, so a
+    // still-alive broker no-ops and returns no launch handle; only a fresh launch
+    // needs the view-socket wait below.
+    const wasAlive = isPidAlive(meta.pi_pid ?? null);
+    const revived = reviveNode(nodeId, { resume: true });
+    try {
+        installTmuxBindings();
+    }
+    catch { /* best-effort */ }
+    // Make THIS pane the node's one viewer. A dormant root's prior focus row
+    // points at a stale/detached pane (the front door keeps the row across a
+    // clean detach), so drop it and claim the current pane — the exact --new-pane
+    // discipline from placement.focus (UNIQUE(node_id): one viewer per node).
+    const here = currentTmux();
+    if (here !== null) {
+        const prior = getFocusByNode(nodeId);
+        if (prior !== null) {
+            try {
+                closeFocusRow(prior.focus_id);
+            }
+            catch { /* best-effort */ }
+        }
+        try {
+            registerViewerFocus(nodeId, here.pane, here.session, here.window);
+        }
+        catch { /* best-effort */ }
+    }
+    // A fresh launch must bind its view socket before we attach; an already-alive
+    // broker already has one.
+    if (!wasAlive) {
+        const ok = await waitForBrokerViewSocket(nodeId, revived.launch?.exited);
+        if (!ok)
+            throw new Error(`the resumed root broker ${nodeId} never bound its view socket — cannot attach.`);
+    }
+    const attachEnv = { ...process.env, ...viewerSplitEnv(), CRTR_ATTACH_WAIT_MS: '30000' };
+    const child = spawn('crtr', ['surface', 'attach', 'to', nodeId], { stdio: 'inherit', env: attachEnv });
+    const code = await new Promise((res) => {
+        child.once('exit', (c) => res(c ?? 0));
+        child.once('error', () => res(1));
+    });
+    process.exit(code);
+}
+// ---------------------------------------------------------------------------
+// `-r` picker — a minimal raw-mode keypress menu (pre-boot, we own the TTY).
+// ---------------------------------------------------------------------------
+const HILITE = accent('\u25b8');
+const cursorUp = (n) => (n > 0 ? `\u001b[${n}A\r` : '');
+const CLEAR_DOWN = '\u001b[0J';
+const ANSI_RE = /\u001b\[[0-9;]*m/g;
+/** Terminal rows a just-written block occupies — counts each '\n' AND the extra
+ *  rows a long line WRAPS into at the current terminal width (ANSI color codes
+ *  stripped so they don't inflate the width). A plain newline count undershoots
+ *  in a narrow pane, so redraws stack instead of clearing. Mirrors the
+ *  profile-menu blockRows. */
+function blockRows(block) {
+    const cols = process.stdout.columns ?? 80;
+    const segs = block.split('\n');
+    const newlines = segs.length - 1; // block ends with '\n' → last seg is ''
+    let extra = 0;
+    for (let i = 0; i < newlines; i++) {
+        const w = segs[i].replace(ANSI_RE, '').length;
+        if (cols > 0 && w > cols)
+            extra += Math.ceil(w / cols) - 1;
+    }
+    return newlines + extra;
+}
+/** Truncate to a visible-column budget, preserving ANSI escapes (they cost no
+ *  width). Appends '…' when it cuts. Keeps a styled row on one terminal line so
+ *  nothing wraps. */
+function fitWidth(s, width) {
+    if (width <= 0)
+        return s;
+    let out = '';
+    let vis = 0;
+    for (let i = 0; i < s.length;) {
+        if (s[i] === '\u001b') {
+            const m = /^\u001b\[[0-9;]*m/.exec(s.slice(i));
+            if (m !== null) {
+                out += m[0];
+                i += m[0].length;
+                continue;
+            }
+        }
+        if (vis >= width - 1 && s.replace(ANSI_RE, '').length > width) {
+            out += '\u2026';
+            break;
+        }
+        out += s[i];
+        vis++;
+        i++;
+    }
+    return out;
+}
+function label(r) {
+    // Liveness is the broker pid, not the row status: a dormant resident root
+    // keeps status='active' while its engine is down.
+    const live = isPidAlive(r.pi_pid ?? null) ? accent('\u25cf live') : dim('\u25cb dormant');
+    // The SAME handle the Alt-G graph shows: navLabel = name → description → kind.
+    // getNode carries `description` (NodeRow from the list query does not).
+    const node = getNode(r.node_id);
+    let name = navLabel(node, r.node_id);
+    // navLabel falls back to the bare kind for a never-named root — useless in a
+    // roster where every root is 'general'. Rescue it with the goal's first line
+    // (the spawning prompt), so unnamed convos are still tellable apart.
+    if (node !== null && name === node.kind) {
+        const goal = firstLine(readGoal(r.node_id));
+        if (goal !== '')
+            name = goal;
+    }
+    return `${name}  ${live}`;
+}
+/** First non-empty line of a goal body, trimmed and length-capped. */
+function firstLine(text) {
+    if (text === null)
+        return '';
+    const line = text.split('\n').map((l) => l.trim()).find((l) => l !== '') ?? '';
+    return line.length > 72 ? line.slice(0, 71) + '\u2026' : line;
+}
+function detail(r, cwd) {
+    const when = ago(r.created);
+    const where = r.cwd === cwd ? '' : `  ${r.cwd}`;
+    // Short id keeps the row on one line; the full id is rarely needed to pick.
+    return `${when}${where}  ${r.node_id.slice(0, 8)}`;
+}
+function ago(iso) {
+    const ms = Date.now() - new Date(iso).getTime();
+    if (!Number.isFinite(ms) || ms < 0)
+        return '';
+    const m = Math.floor(ms / 60000);
+    if (m < 1)
+        return 'just now';
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}
+/** Drive a highlighted keypress menu of resumable roots. ↑/↓ or j/k move,
+ *  digits jump, Enter picks, q/Esc/Ctrl-C abort → null. Restores the TTY on
+ *  every exit path so the inline viewer gets a clean terminal. */
+function pickRoot(roots, cwd) {
+    const title = 'Resume a session here';
+    const subtitle = `${roots.length} roots pinned to ${cwd}`;
+    return new Promise((resolve) => {
+        const out = process.stdout;
+        const input = process.stdin;
+        let sel = 0;
+        let prevLines = 0;
+        const render = () => {
+            const cols = process.stdout.columns ?? 80;
+            let s = `\n  ${bold(title)}\n  ${dim(subtitle)}\n\n`;
+            roots.forEach((r, i) => {
+                const mark = i === sel ? HILITE : ' ';
+                const slot = i < 9 ? key(`${i + 1}`) : '  ';
+                const row = `  ${mark} ${slot}  ${label(r)}  ${dim(detail(r, cwd))}`;
+                s += fitWidth(row, cols) + '\n';
+            });
+            s += `\n  ${dim('↑/↓ move  enter resume  q quit')}\n`;
+            return s;
+        };
+        const draw = () => {
+            const block = render();
+            out.write((prevLines > 0 ? cursorUp(prevLines) + CLEAR_DOWN : '') + block);
+            prevLines = blockRows(block);
+        };
+        emitKeypressEvents(input);
+        const wasRaw = input.isRaw ?? false;
+        if (input.isTTY)
+            input.setRawMode(true);
+        input.resume();
+        const finish = (result) => {
+            input.removeListener('keypress', onKey);
+            if (input.isTTY)
+                input.setRawMode(wasRaw);
+            input.pause();
+            out.write(cursorUp(prevLines) + CLEAR_DOWN);
+            resolve(result);
+        };
+        const onKey = (_str, k) => {
+            const name = k.name ?? '';
+            if (k.ctrl && name === 'c') {
+                finish(null);
+                process.exit(130);
+            }
+            if (name === 'q' || name === 'escape')
+                return finish(null);
+            if (name === 'up' || name === 'k') {
+                sel = (sel - 1 + roots.length) % roots.length;
+                return draw();
+            }
+            if (name === 'down' || name === 'j') {
+                sel = (sel + 1) % roots.length;
+                return draw();
+            }
+            if (name === 'return' || name === 'enter')
+                return finish(roots[sel]);
+            const digit = Number.parseInt(k.sequence ?? '', 10);
+            if (Number.isInteger(digit) && digit >= 1 && digit <= Math.min(9, roots.length)) {
+                sel = digit - 1;
+                return finish(roots[sel]);
+            }
+        };
+        input.on('keypress', onKey);
+        draw();
+    });
+}
+function key(s) {
+    return accent(s);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crouton-kit/crouter",
-  "version": "0.3.80",
+  "version": "0.3.82",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",