@crouton-kit/crouter 0.3.18 → 0.3.20

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

@@ -11,7 +11,12 @@
 // Every hue (fg / bg color) is gated on `caps.color`; structural SGR (bold/dim/
 // reverse) is allowed always. See detectColorCaps() for the gate, and the
 // canvas-browse color spec for the rationale + palette.
-import { TABS, matchIndices } from './model.js';
+import { TABS, matchIndices, promptText, previewSnippet } from './model.js';
+// Span/color primitives live in core/tui/draw.ts (one copy, shared with the
+// `crtr view` host). Re-export the color caps so browse's importers + tests keep
+// resolving them from this module.
+import { clip, assemble, detectColorCaps } from '../../tui/draw.js';
+export { detectColorCaps };
 // Fixed chrome heights, shared with app.ts so its viewport math never drifts
 // from what renderFrame actually draws.
 //   header = title + tab bar + status line + separator (+ search input when searching)
@@ -52,16 +57,6 @@ const STATUS_COLOR = {
     dead: FG_RED,
     canceled: FG_GRAY,
 };
-/** Detect color capability. Honors `NO_COLOR` and `TERM=dumb`, and only emits
- *  hue when stdout is a TTY. `color256` additionally requires a 256/truecolor
- *  terminal (for the cursor-row background; otherwise we fall back to reverse). */
-export function detectColorCaps(stream = process.stdout, env = process.env) {
-    const term = env['TERM'] ?? '';
-    const color = stream.isTTY === true && !env['NO_COLOR'] && term !== 'dumb';
-    const colorTerm = env['COLORTERM'] ?? '';
-    const color256 = color && (/256|direct/i.test(term) || /truecolor|24bit/i.test(colorTerm));
-    return { color, color256 };
-}
 function fmtCtx(tokens) {
     if (tokens <= 0)
         return '0k';
@@ -76,12 +71,6 @@ function ctxColorCode(tokens) {
         return FG_YELLOW;
     return undefined;
 }
-/** Truncate to `max` visible cols (plain text, no ANSI). */
-function clip(text, max) {
-    if (max <= 0)
-        return '';
-    return text.length <= max ? text : text.slice(0, Math.max(0, max - 1)) + '…';
-}
 /** Compact relative age, e.g. `45s` `12m` `3h` `5d` `2w` `4mo`. Empty on a bad
  *  timestamp. Drives the per-row recency cue + the preview meta line. */
 function relAge(created, now) {
@@ -110,74 +99,13 @@ function baseDir(cwd) {
     const parts = cwd.replace(/\/+$/, '').split('/');
     return parts[parts.length - 1] || cwd;
 }
-/** Greedy word-wrap to `width` cols, capped at `maxLines` (last line clipped). */
-function wrap(text, width, maxLines) {
-    if (width <= 0 || maxLines <= 0)
-        return [];
-    const words = text.replace(/\s+/g, ' ').trim().split(' ');
-    const out = [];
-    let cur = '';
-    for (const w of words) {
-        const next = cur === '' ? w : `${cur} ${w}`;
-        if (next.length <= width) {
-            cur = next;
-            continue;
-        }
-        if (cur !== '')
-            out.push(cur);
-        cur = w;
-        if (out.length >= maxLines)
-            break;
-    }
-    if (out.length < maxLines && cur !== '')
-        out.push(cur);
-    return out.slice(0, maxLines).map((l) => clip(l, width));
-}
-/** Style one span. Hue is gated on `color`; bold/dim are not. After the span we
- *  return to `lineBase` (not a bare reset) so a row-level background/dim persists
- *  across the span instead of bleeding or being cleared. */
-function styleSpan(text, span, color, lineBase) {
-    if (text === '')
-        return '';
-    let pre = '';
-    if (span.dim)
-        pre += DIM;
-    if (span.bold)
-        pre += BOLD;
-    if (color && span.fg)
-        pre += `${ESC}${span.fg}m`;
-    if (pre === '')
-        return text; // inherits lineBase / default
-    return `${pre}${text}${RESET}${lineBase}`;
-}
-/** Assemble styled spans into one line clipped to `width` visible cols. When
- *  `fill`, pad the remainder with spaces (under `lineBase`) so a cursor-row
- *  background spans the full width. Always RESET-terminated so no color bleeds
- *  into the next line. */
-function assemble(spans, width, color, lineBase, fill) {
-    let used = 0;
-    let body = '';
-    for (const span of spans) {
-        if (used >= width)
-            break;
-        if (span.text === '')
-            continue;
-        let t = span.text;
-        const remaining = width - used;
-        let cut = false;
-        if (t.length > remaining) {
-            t = t.slice(0, Math.max(0, remaining - 1)) + '…';
-            cut = true;
-        }
-        body += styleSpan(t, span, color, lineBase);
-        used += t.length;
-        if (cut)
-            break;
-    }
-    if (fill && used < width)
-        body += ' '.repeat(width - used);
-    return lineBase === '' ? body : `${lineBase}${body}${RESET}`;
-}
+// ── Styled spans ──────────────────────────────────────────────────────────────
+//
+// A row is built from styled spans, then assembled to a width-clipped line. This
+// lets each cell carry its own hue (status glyph, ctx tier, asks, match highlight)
+// while clipping by VISIBLE width — ANSI bytes don't count toward the column
+// budget. `fg` is hue (gated on `color`); `bold`/`dim` are structural (always).
+// Span / styleSpan / assemble now live in core/tui/draw.ts (imported above).
 /** Status tallies across the whole canvas, for the right-aligned header. Memoized
  *  per tree — the snapshot is immutable for a browse session, so counting is done
  *  once, not O(N) on every keystroke (the "massive canvas" target). */
@@ -213,7 +141,7 @@ const EMPTY_HI = new Set();
 function nameSpans(name, query, style) {
     const hi = query === '' ? EMPTY_HI : matchIndices(query, name);
     if (hi.size === 0)
-        return [{ text: name, dim: style.dim, bold: style.bold }];
+        return [{ text: name, style: { dim: style.dim, bold: style.bold } }];
     const out = [];
     let buf = '';
     let bufHi = false;
@@ -221,9 +149,9 @@ function nameSpans(name, query, style) {
         if (buf === '')
             return;
         if (bufHi)
-            out.push({ text: buf, fg: FG_BRIGHT_CYAN, bold: true });
+            out.push({ text: buf, style: { fg: FG_BRIGHT_CYAN, bold: true } });
         else
-            out.push({ text: buf, dim: style.dim, bold: style.bold });
+            out.push({ text: buf, style: { dim: style.dim, bold: style.bold } });
         buf = '';
     };
     for (let i = 0; i < name.length; i++) {
@@ -255,19 +183,19 @@ function rowLine(row, tree, width, isCursor, query, caps, showCwd, now) {
     const nameStyle = { dim: !isCursor && terminal, bold: isCursor };
     const spans = [
         { text: `${indent}${collapse} ` },
-        { text: glyph, fg: STATUS_COLOR[r.status] }, // load-bearing status hue
+        { text: glyph, style: { fg: STATUS_COLOR[r.status] } }, // load-bearing status hue
         { text: ' ' },
         ...nameSpans(r.name, query, nameStyle),
-        { text: ` [${r.kind}/${r.mode}]`, fg: FG_GRAY }, // recedes
-        { text: ' ctx ', dim: true },
-        { text: ctxStr, fg: ctxFg, dim: ctxFg === undefined }, // tiered budget cue
+        { text: ` [${r.kind}/${r.mode}]`, style: { fg: FG_GRAY } }, // recedes
+        { text: ' ctx ', style: { dim: true } },
+        { text: ctxStr, style: { fg: ctxFg, dim: ctxFg === undefined } }, // tiered budget cue
     ];
     if (age !== '')
-        spans.push({ text: ` ${age}`, dim: true }); // recency cue
+        spans.push({ text: ` ${age}`, style: { dim: true } }); // recency cue
     if (showCwd)
-        spans.push({ text: ` ~${baseDir(r.cwd)}`, fg: FG_GRAY }); // project cue (All dirs)
+        spans.push({ text: ` ~${baseDir(r.cwd)}`, style: { fg: FG_GRAY } }); // project cue (All dirs)
     if (r.asks > 0)
-        spans.push({ text: ` ⚑${r.asks}`, fg: FG_BRIGHT_YELLOW, bold: true }); // attention
+        spans.push({ text: ` ⚑${r.asks}`, style: { fg: FG_BRIGHT_YELLOW, bold: true } }); // attention
     // Row base: cursor → subtle bg (256) or reverse fallback (also covers !color);
     // non-matched ancestor → whole-row dim for tree context (keep prior behavior).
     let lineBase = '';
@@ -288,15 +216,44 @@ function statusLine(state) {
     const dim = (s) => `${DIM}${s}${RESET}`;
     const scope = state.cwdScope === null ? 'all dirs' : baseDir(state.cwdScope);
     const segs = [`${dim('scope')} ${scope}`, `${dim('sort')} ${state.sort}`];
+    if (state.residentsOnly)
+        segs.push(`${dim('show')} residents`);
     if (!state.search && state.query !== '')
         segs.push(`${dim('filter')} ${state.query}`);
     return segs.join(dim('  ·  '));
 }
+/** One snippet line → a rendered string with the query-matched columns in bold
+ *  bright-cyan (mirrors the row name highlight). Unmatched text stays default. */
+function snippetLine(ln, width, caps) {
+    if (ln.hi.size === 0)
+        return assemble([{ text: ln.text }], width, caps.color, '', false);
+    const spans = [];
+    let buf = '';
+    let bufHi = false;
+    const flush = () => {
+        if (buf === '')
+            return;
+        spans.push(bufHi ? { text: buf, style: { fg: FG_BRIGHT_CYAN, bold: true } } : { text: buf });
+        buf = '';
+    };
+    for (let i = 0; i < ln.text.length; i++) {
+        const h = ln.hi.has(i);
+        if (h !== bufHi) {
+            flush();
+            bufHi = h;
+        }
+        buf += ln.text[i];
+    }
+    flush();
+    return assemble(spans, width, caps.color, '', false);
+}
 /** The bottom preview panel — exactly PREVIEW_HEIGHT lines: a separator, a meta
- *  line (status · kind/mode · project · age · ctx · asks), then the selected
- *  node's spawn prompt wrapped to PREVIEW_BODY lines. The "which one was this?"
+ *  line (status · kind/mode · project · age · ctx · asks), then the selected node's
+ *  prompt wrapped to PREVIEW_BODY lines. Under a live query the body is WINDOWED to
+ *  the matching prompt (anywhere in the conversation) with the match highlighted;
+ *  with no query it shows the spawn prompt from the start. The "which one was this?"
  *  answer — paired with super-search. Always full height so viewport math holds. */
-function previewPanel(r, width, caps, now) {
+function previewPanel(r, width, caps, now, query) {
     const out = [`${DIM}${'─'.repeat(width)}${RESET}`];
     if (r === undefined) {
         while (out.length < PREVIEW_HEIGHT)
@@ -311,10 +268,21 @@ function previewPanel(r, width, caps, now) {
         metaPieces.push(`⚑${r.asks}`);
     const metaText = clip(metaPieces.filter((p) => p !== '').join('  ·  '), Math.max(0, width - 2));
     out.push(caps.color ? `${glyph} ${DIM}${metaText}${RESET}` : `${glyph} ${metaText}`);
-    const goalText = (r.goal ?? '').trim();
-    const body = goalText === '' ? [`${DIM}(no spawn prompt)${RESET}`] : wrap(goalText, width, PREVIEW_BODY);
-    for (let i = 0; i < PREVIEW_BODY; i++)
-        out.push(body[i] ?? '');
+    // With a query, window+highlight the matching prompt from the WHOLE conversation;
+    // otherwise show the spawn prompt from the start.
+    const sourceText = query !== '' ? promptText(r) : (r.goal ?? '');
+    const snippet = previewSnippet(query, sourceText, width, PREVIEW_BODY);
+    if (snippet.length === 0) {
+        out.push(`${DIM}(no spawn prompt)${RESET}`);
+        for (let i = 1; i < PREVIEW_BODY; i++)
+            out.push('');
+    }
+    else {
+        for (let i = 0; i < PREVIEW_BODY; i++) {
+            const ln = snippet[i];
+            out.push(ln === undefined ? '' : snippetLine(ln, width, caps));
+        }
+    }
     return out;
 }
 /**
@@ -373,13 +341,13 @@ export function renderFrame(state, size, caps = { color: false, color256: false
     if (previewOn) {
         const sel = state.visible[state.cursor];
         const r = sel !== undefined ? state.tree.nodes.get(sel.id)?.row : undefined;
-        for (const l of previewPanel(r, width, caps, now))
+        for (const l of previewPanel(r, width, caps, now, state.query))
             lines.push(l);
     }
     // footer.
     const footer = state.search
         ? '⏎ commit  Esc cancel  ⌫ delete'
-        : '↑↓ move  →/← tree  ⏎ resume  Tab tabs  / search  s sort  c cwd  p preview  q quit';
+        : '↑↓ move  →/← tree  ⏎ resume  Tab tabs  / search  s sort  c cwd  r residents  p preview  q quit';
     lines.push(`${DIM}${clip(footer, width)}${RESET}`);
     // Assemble: home, each line cleared to EOL, then clear below.
     const body = lines.map((l) => `${l}${ESC}K`).join('\r\n');

package/dist/core/canvas/canvas.js

@@ -7,6 +7,7 @@
 import { existsSync, readFileSync, writeFileSync, renameSync, readdirSync, rmSync, } from 'node:fs';
 import { join } from 'node:path';
 import { openDb } from './db.js';
+import { isPidAlive } from './pid.js';
 import { ensureHome, ensureNodeDirs, nodeMetaPath, nodeDir, nodesRoot, } from './paths.js';
 // ---------------------------------------------------------------------------
 // meta.json (durable identity — the source of truth for what PERSISTS)
@@ -19,9 +20,9 @@ import { ensureHome, ensureNodeDirs, nodeMetaPath, nodeDir, nodesRoot, } from '.
 /** The identity keys meta.json persists. Listed explicitly so no runtime field
  *  can ever leak onto disk even when a fully-hydrated NodeMeta is handed in. */
 const IDENTITY_KEYS = [
-    'node_id', 'name', 'description', 'cycles', 'created', 'cwd', 'kind', 'mode',
-    'lifecycle', 'persona_ack', 'parent', 'spawned_by', 'passive_default',
-    'home_session', 'pi_session_id', 'pi_session_file', 'launch',
+    'node_id', 'name', 'description', 'cycles', 'created', 'cwd', 'host_kind', 'kind', 'mode',
+    'lifecycle', 'persona_ack', 'parent', 'spawned_by', 'fork_from', 'passive_default',
+    'home_session', 'pi_session_id', 'pi_session_file', 'model_override', 'launch',
 ];
 /** Project any node object down to its durable-identity subset. */
 function toIdentity(m) {
@@ -60,12 +61,13 @@ function writeMeta(meta) {
  *  state. A fresh insert takes the schema defaults for runtime. */
 function upsertRow(meta) {
     openDb()
-        .prepare(`INSERT INTO nodes (node_id, name, kind, mode, lifecycle, cwd, parent, created)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        .prepare(`INSERT INTO nodes (node_id, name, kind, mode, lifecycle, cwd, host_kind, parent, created)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(node_id) DO UPDATE SET
          name=excluded.name, kind=excluded.kind, mode=excluded.mode,
-         lifecycle=excluded.lifecycle, cwd=excluded.cwd, parent=excluded.parent`)
-        .run(meta.node_id, meta.name, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.parent ?? null, meta.created);
+         lifecycle=excluded.lifecycle, cwd=excluded.cwd, host_kind=excluded.host_kind,
+         parent=excluded.parent`)
+        .run(meta.node_id, meta.name, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.host_kind ?? null, meta.parent ?? null, meta.created);
 }
 /** Seed a node's row at BIRTH: identity columns + runtime columns taken from the
  *  incoming meta (defaults: status='active', the rest null). The only writer
@@ -74,16 +76,17 @@ function upsertRow(meta) {
 function seedRow(meta) {
     openDb()
         .prepare(`INSERT INTO nodes
-         (node_id, name, kind, mode, lifecycle, cwd, parent, created,
+         (node_id, name, kind, mode, lifecycle, cwd, host_kind, parent, created,
           status, intent, pi_pid, "window", tmux_session, pane)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(node_id) DO UPDATE SET
          name=excluded.name, kind=excluded.kind, mode=excluded.mode,
-         lifecycle=excluded.lifecycle, cwd=excluded.cwd, parent=excluded.parent,
+         lifecycle=excluded.lifecycle, cwd=excluded.cwd, host_kind=excluded.host_kind,
+         parent=excluded.parent,
          status=excluded.status, intent=excluded.intent, pi_pid=excluded.pi_pid,
          "window"=excluded."window", tmux_session=excluded.tmux_session,
          pane=excluded.pane`)
-        .run(meta.node_id, meta.name, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.parent ?? null, meta.created, meta.status ?? 'active', meta.intent ?? null, meta.pi_pid ?? null, meta.window ?? null, meta.tmux_session ?? null, meta.pane ?? null);
+        .run(meta.node_id, meta.name, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.host_kind ?? null, meta.parent ?? null, meta.created, meta.status ?? 'active', meta.intent ?? null, meta.pi_pid ?? null, meta.window ?? null, meta.tmux_session ?? null, meta.pane ?? null);
 }
 function rowFrom(r) {
     return {
@@ -94,6 +97,7 @@ function rowFrom(r) {
         lifecycle: r['lifecycle'],
         status: r['status'],
         cwd: r['cwd'],
+        host_kind: r['host_kind'] ?? null,
         parent: r['parent'] ?? null,
         created: r['created'],
         intent: r['intent'] ?? null,
@@ -352,17 +356,6 @@ 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
@@ -406,7 +399,7 @@ export function pruneNodes(opts) {
         if (r['node_id'] === selfId)
             return false;
         const pid = r['pi_pid'];
-        return pid === null || !pidAlive(pid);
+        return !isPidAlive(pid);
     })
         .map((r) => ({
         node_id: r['node_id'],

package/dist/core/canvas/db.js

@@ -208,6 +208,50 @@ CREATE TABLE IF NOT EXISTS focuses (
 );
 `);
 }
+/** v7 — the `wakeups` table: durable store for scheduled wake-ups (the
+ *  scheduled-wakeups feature). One row per armed wake. `node_id` is the TARGET
+ *  and the node-anchored cancel anchor — it carries a `ON DELETE CASCADE` FK to
+ *  `nodes(node_id)` so a pruned/deleted node's node-anchored wakes are reaped in
+ *  the same transaction (mirroring the edges v4 cascade; works because
+ *  `PRAGMA foreign_keys = ON` is set at every open). NULL `node_id` = a
+ *  canvas-detached wake (deferred spawn / spawn-cron) that survives.
+ *
+ *  `owner_id` is the ARMER, set on EVERY row, and is deliberately a PLAIN indexed
+ *  column with NO FK (design D1/D2): an FK on `owner_id` would cascade-drop a
+ *  crashed-then-pruned armer's detached cron, violating Invariant E. A detached
+ *  wake is reaped only by the explicit `cancelWakesFor` DELETE, never by cascade.
+ *
+ *  `fire_at` is an ISO 8601 UTC string for the NEXT occurrence, so the per-tick
+ *  due query is a lexicographic `<=` compare. The partial unique index
+ *  `idx_wakeups_deadline` enforces ≤1 deadline per node. Additive, forward-only. */
+function appendWakeupsTable(db) {
+    db.exec(`
+CREATE TABLE IF NOT EXISTS wakeups (
+  wakeup_id  TEXT PRIMARY KEY,
+  node_id    TEXT,                       -- TARGET + node-anchored cancel anchor; NULL = canvas-detached
+  owner_id   TEXT NOT NULL,              -- ARMER; set on EVERY row. PLAIN column, NO FK (design D1/D2)
+  fire_at    TEXT NOT NULL,              -- ISO 8601 UTC; NEXT occurrence; lexicographic <=
+  kind       TEXT NOT NULL,              -- 'bare' | 'noted' | 'deadline' | 'spawn'
+  recur      TEXT,                       -- NULL = one-shot; else the pinned recur JSON
+  payload    TEXT,                       -- JSON per kind (shared contracts)
+  created    TEXT NOT NULL,
+  FOREIGN KEY (node_id) REFERENCES nodes(node_id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_wakeups_fire  ON wakeups(fire_at);                 -- per-tick due query
+CREATE INDEX IF NOT EXISTS idx_wakeups_node  ON wakeups(node_id);                 -- by-node cancel / list
+CREATE INDEX IF NOT EXISTS idx_wakeups_owner ON wakeups(owner_id);               -- by-owner reap (ruling A)
+CREATE UNIQUE INDEX IF NOT EXISTS idx_wakeups_deadline ON wakeups(node_id) WHERE kind = 'deadline';
+`);
+}
+/** v8 — additive identity column `host_kind`: which HOST launches + supervises a
+ *  node — `'tmux'` (a pane) or `'broker'` (the headless in-process engine). It is
+ *  durable IDENTITY mirrored from meta.json like `cwd` (NOT runtime like `pane`),
+ *  so it survives an index rebuild via the `IDENTITY_KEYS`/`upsertRow` path.
+ *  Defaults NULL ⇒ `'tmux'` (every existing node is tmux-hosted); no data
+ *  backfill. Additive, forward-only. */
+function addHostKindColumn(db) {
+    db.exec(`ALTER TABLE nodes ADD COLUMN host_kind TEXT;`);
+}
 /** The ordered migration list. Index `i` is migration version `i + 1`; the db's
  *  `user_version` tracks how many have been applied. Append only. */
 export const MIGRATIONS = [
@@ -217,6 +261,8 @@ export const MIGRATIONS = [
     /* v4 */ edgesForeignKeyCascade,
     /* v5 */ addPaneColumn,
     /* v6 */ addFocusesTable,
+    /* v7 */ appendWakeupsTable,
+    /* v8 */ addHostKindColumn,
 ];
 /** Bring `db` up to the latest schema version. Reads `user_version`, runs each
  *  pending migration in order, and bumps `user_version` after each so the work

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

@@ -3,5 +3,6 @@ export * from './labels.js';
 export * from './paths.js';
 export * from './canvas.js';
 export * from './focuses.js';
+export * from './wakeups.js';
 export * from './telemetry.js';
 export { openDb, closeDb } from './db.js';

package/dist/core/canvas/index.js

@@ -5,5 +5,6 @@ export * from './labels.js';
 export * from './paths.js';
 export * from './canvas.js';
 export * from './focuses.js';
+export * from './wakeups.js';
 export * from './telemetry.js';
 export { openDb, closeDb } from './db.js';

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

@@ -0,0 +1,4 @@
+/** True if a process with `pid` is currently alive (signal-0 probe). `kill(pid,
+ *  0)` throws ESRCH when the process is gone; EPERM means it exists but isn't
+ *  ours — still alive. A null/undefined pid (legacy / never-booted) reads dead. */
+export declare function isPidAlive(pid: number | null | undefined): boolean;

package/dist/core/canvas/pid.js

@@ -0,0 +1,23 @@
+// src/core/canvas/pid.ts
+//
+// The ONE shared signal-0 liveness probe. It lives at the canvas/ layer — the
+// LOWEST shared layer — so canvas/, runtime/, AND daemon/ can all import it
+// "down" without a reverse-layer violation (runtime/ sits above canvas/, daemon/
+// above runtime/). It is a pure process-existence utility, NOT data-model access,
+// so it is exempt from the "only canvas.ts touches the db" rule. Collapses the
+// four near-identical copies that used to live in canvas.ts, revive.ts,
+// placement.ts, and crtrd.ts into one (Phase 3 review reuse MINOR-1).
+/** True if a process with `pid` is currently alive (signal-0 probe). `kill(pid,
+ *  0)` throws ESRCH when the process is gone; EPERM means it exists but isn't
+ *  ours — still alive. A null/undefined pid (legacy / never-booted) reads dead. */
+export function isPidAlive(pid) {
+    if (pid == null)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { NodeStatus } from './types.js';
+import type { NodeStatus, Lifecycle } from './types.js';
 /**
  * Render the subscription sub-DAG rooted at `rootId` as an ASCII tree.
  * The root is the first line (no connector prefix); children are indented.
@@ -28,11 +28,20 @@ export interface DashboardRow {
     cwd: string;
     /** ISO 8601 birth timestamp — drives the recency sort + the relative-age cue. */
     created: string;
+    /** terminal = one-shot worker (finalizes on push --final); resident = persistent
+     *  agent you come back to. Drives the browser's resident-only lifecycle filter.
+     *  Only populated by dashboardRowsAll (the browser snapshot). */
+    lifecycle?: Lifecycle;
     /** 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. */
+     *  and shown in the preview panel when there is no live query. */
     goal?: string;
+    /** EVERY user prompt across the node's pi session — the whole conversation, not
+     *  just the spawn prompt — joined + capped. Populated by dashboardRowsAll, undefined
+     *  for never-revived nodes (no session file). Powers whole-conversation super-search
+     *  + the windowed match snippet in the preview. */
+    prompts?: 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

@@ -181,6 +181,73 @@ function readGoalText(nodeId) {
         return undefined;
     }
 }
+/** EVERY user prompt across a node's pi session — the whole conversation, not just
+ *  the spawn prompt. Streams the session jsonl off disk, prefiltering to user-role
+ *  lines so the big assistant/toolResult lines are never JSON-parsed, extracts each
+ *  user message's text, joins newline-separated, and caps total + per-message so a
+ *  long session can't bloat the snapshot. Never throws; returns undefined when there
+ *  is no session file yet (a node that was never revived). */
+const CONVO_CAP = 8192;
+const CONVO_MSG_CAP = 2048;
+function readConversationPrompts(sessionFile) {
+    if (sessionFile === undefined || sessionFile === null || sessionFile === '')
+        return undefined;
+    try {
+        if (!existsSync(sessionFile))
+            return undefined;
+        const raw = readFileSync(sessionFile, 'utf8');
+        const parts = [];
+        let total = 0;
+        for (const line of raw.split('\n')) {
+            // Cheap prefilter: skip every line that isn't a user-role message before the
+            // (relatively costly) JSON.parse. Pi writes compact JSON (no spaces), but
+            // tolerate the spaced form too.
+            if (line === '' || (line.indexOf('"role":"user"') === -1 && line.indexOf('"role": "user"') === -1))
+                continue;
+            let rec;
+            try {
+                rec = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (rec.type !== 'message' || rec.message?.role !== 'user')
+                continue;
+            const text = extractUserText(rec.message.content);
+            if (text === '')
+                continue;
+            const capped = text.length > CONVO_MSG_CAP ? text.slice(0, CONVO_MSG_CAP) : text;
+            parts.push(capped);
+            total += capped.length + 1;
+            if (total >= CONVO_CAP)
+                break;
+        }
+        if (parts.length === 0)
+            return undefined;
+        const joined = parts.join('\n');
+        return joined.length > CONVO_CAP ? joined.slice(0, CONVO_CAP) : joined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Concatenate the `text` blocks of one pi user message's content. Content is
+ *  usually an array of `{type,text}` blocks but may be a bare string. */
+function extractUserText(content) {
+    if (typeof content === 'string')
+        return content.trim();
+    if (!Array.isArray(content))
+        return '';
+    const out = [];
+    for (const block of content) {
+        if (block !== null && typeof block === 'object') {
+            const b = block;
+            if (b.type === 'text' && typeof b.text === 'string')
+                out.push(b.text);
+        }
+    }
+    return out.join(' ').trim();
+}
 /** One row per node visible in the sub-DAG of `rootId` (including root). */
 export function dashboardRows(rootId) {
     const ids = [rootId, ...view(rootId)];
@@ -219,7 +286,9 @@ export function dashboardRowsAll() {
                 asks: countAsks(row.node_id),
                 cwd: row.cwd,
                 created: row.created,
+                lifecycle: row.lifecycle,
                 goal: readGoalText(row.node_id),
+                prompts: readConversationPrompts(meta?.pi_session_file),
             }];
     });
 }