pi-legion 3.0.3 → 4.0.0

package/src/tui/status.ts

@@ -16,6 +16,11 @@ import {
 	visibleWidth,
 } from "@earendil-works/pi-tui";
 import { isThinkingLevel } from "../shared/types.ts";
+import {
+	NON_TERMINAL,
+	TERMINAL_STATES as LIVENESS_TERMINAL_STATES,
+	displayStatusFromState,
+} from "../extension/liveness.ts";
 import { nodesFromEntries, type VizNode } from "./viz/model.ts";
 import { RateSampler } from "./viz/rate.ts";
 import { railwayLines, type RailScroll } from "./viz/railway.ts";
@@ -66,6 +71,25 @@ export interface StatusEntry {
 	nodeId?: string;
 	parentId?: string | null;
 	depth?: number;
+	/**
+	 * Backend the child was actually spawned on (#209). Absent for legacy
+	 * records and for tree-only rows — consumers render `unknown`, never `rpc`.
+	 */
+	spawnMode?: string;
+	/**
+	 * Own OS process of an `rpc` child. Never persisted (pids are host-scoped),
+	 * so a row restored from disk has none. `inprocess` children have none by
+	 * definition — they share this process.
+	 */
+	pid?: number;
+	/** Prompt size of the last assistant message; absolute tokens, not a ratio. */
+	contextTokens?: number;
+	/**
+	 * Resident memory of this child in MB. Only ever set for a child with its own
+	 * process (D2): an `inprocess` child has no separate RSS and must render
+	 * blank rather than a share of the host figure.
+	 */
+	rss?: number;
 }
 
 /** Session-wide totals for the tree header: every launched agent (incl. aged-out), root excluded. */
@@ -107,13 +131,22 @@ export function formatElapsed(ms: number): string {
 }
 
 /**
- * Relative age for railway "last activity" (`3s ago` / `2m ago` / `1h ago`).
- * Missing timestamp → `—` (placeholder; see #159).
+ * Age floor for the railway "last activity" field. Below it the field is
+ * dropped entirely instead of reading `1s ago` on every live lane.
+ */
+export const ACTIVITY_AGO_MIN_SECS = 60;
+
+/**
+ * Relative age for railway "last activity" (`2m ago` / `1h ago`).
+ *
+ * Missing timestamp → `—` (placeholder; see #159). Anything fresher than a
+ * minute → `""`, meaning "say nothing": a lane that just printed activity is
+ * already visibly live, so `1s ago` was pure noise on every running agent.
  */
 export function formatActivityAgo(lastActivityAt: number | undefined, now: number): string {
 	if (lastActivityAt === undefined || !Number.isFinite(lastActivityAt)) return "—";
 	const secs = Math.max(0, Math.floor((now - lastActivityAt) / 1000));
-	if (secs < 60) return `${secs}s ago`;
+	if (secs < ACTIVITY_AGO_MIN_SECS) return "";
 	const mins = Math.floor(secs / 60);
 	if (mins < 60) return `${mins}m ago`;
 	const hours = Math.floor(mins / 60);
@@ -140,8 +173,8 @@ function formatTokensCompact(value: number): string {
  * is part of "time since the last task started". It freezes only when the
  * agent ends: a terminal entry clamps at `finishedAt` so the clock does not
  * run on after the agent exits. Undefined when the turn start is unknown, or
- * when the entry is neither active nor terminal (an idle seat has no
- * meaningful running clock).
+ * when the entry is alive but not doing work — an `idle`/`queued`/`awaiting`
+ * seat has no meaningful running clock.
  */
 function currentTurnElapsedMs(
 	entry: Pick<StatusEntry, "state" | "herdrStatus" | "finishedAt" | "currentTurnStartedAt">,
@@ -151,7 +184,11 @@ function currentTurnElapsedMs(
 	const start = entry.currentTurnStartedAt;
 	const status = entry.herdrStatus ?? entry.state;
 	if (TERMINAL_STATES.has(status)) return Math.max(0, (entry.finishedAt ?? now) - start);
-	if (!ACTIVE_STATES.has(status)) return undefined;
+	// Only a *busy* entry has a live turn clock. An `idle` seat (and a `queued`
+	// one, and an `awaiting` centurion waiting on its squad) is visible but not
+	// working, so it keeps no running clock: the doc above says so, and letting
+	// it tick would show time accruing against nothing.
+	if (!BUSY_STATES.has(status)) return undefined;
 	return Math.max(0, now - start);
 }
 
@@ -198,7 +235,7 @@ export function formatAgentElapsed(
 
 export function activeEntries(entries: StatusEntry[]): StatusEntry[] {
 	return entries.filter((entry) =>
-		entry.parentId !== null && entry.depth !== 0 && ACTIVE_STATES.has(entry.herdrStatus ?? entry.state),
+		entry.parentId !== null && entry.depth !== 0 && BUSY_STATES.has(entry.herdrStatus ?? entry.state),
 	);
 }
 
@@ -279,7 +316,8 @@ function formatWorktreeBranch(branch: string): string {
 
 function headlineBits(entry: StatusEntry, now: number): string[] {
 	const bits = [`${entry.name}${roleSuffix(entry)}`];
-	if (entry.kind && entry.kind !== "pi") bits.push(entry.kind);
+	// `entry.kind` is deliberately not rendered: v4 has one kind (`pi`), so the
+	// label would repeat a constant on every row.
 	const model = formatModel(entry);
 	if (model) bits.push(model);
 	bits.push(formatAgentElapsed(entry, now));
@@ -329,18 +367,56 @@ function widgetRow(text: string, nodeId?: string): WidgetRow {
 	return nodeId === undefined ? { text } : { text, nodeId };
 }
 
-const RUNNING_STATES = new Set(["starting", "working", "running"]);
-const ACTIVE_STATES = new Set([...RUNNING_STATES, "blocked"]);
-const TERMINAL_STATES = new Set([
-	"settled",
-	"success",
-	"completed",
-	"failed",
-	"aborted",
-	"retired",
-	"awaiting",
-	"unknown",
-]);
+/**
+ * Terminal / active / busy / running: one derivation from the liveness
+ * authority (contract `docs/contracts/display-liveness-v1.md` D1-a, D5).
+ *
+ * This file used to carry its own three tables, and the terminal one disagreed
+ * with every other surface: it listed `awaiting` and `unknown` as terminal
+ * (so a centurion waiting on its squad vanished from the widget) and omitted
+ * `error`/`truncated`/`done` (so those kept a live clock). `TERMINAL_STATES` is
+ * therefore imported, never re-declared.
+ */
+const TERMINAL_STATES: ReadonlySet<string> = LIVENESS_TERMINAL_STATES;
+
+/**
+ * "This row describes something that is still alive": the liveness module's
+ * in-flight labels plus `awaiting`, which D1-a places on the non-terminal side
+ * ("alive, waiting on downstream"). Drives visibility (`filterLiveTree`,
+ * `isActiveEntry`) and the open-ended clocks.
+ *
+ * This stays a known-label set on purpose. D1-a's "use the complement, not a
+ * whitelist" rule governs `liveness()`'s ledger rule, where the question is
+ * *may we declare this lifecycle over?* — the safe answer for an unrecognised
+ * label is "no". Here the question is the opposite one, *may this row count as
+ * alive?*, and a permissive answer would promote the widget's own synthetic
+ * `waiting` label (and any legacy/foreign label) to activity: rows that must
+ * age out would be resurrected and the `N running` count would inflate.
+ */
+const ACTIVE_STATES: ReadonlySet<string> = new Set([...NON_TERMINAL, "awaiting"]);
+
+/**
+ * "This row is doing work": active and not merely holding a slot. An `idle`
+ * seat is alive and visible (D5) but has no running clock and must not keep the
+ * busy label lit forever; same for a `queued` seat that has not started and an
+ * `awaiting` centurion whose squad is the thing actually running.
+ *
+ * Kept separate from `ACTIVE_STATES` because conflating "should I show this?"
+ * with "is this busy?" is precisely the mistake that made `idle`/`awaiting`
+ * disappear instead of being shown grey.
+ */
+const BUSY_STATES: ReadonlySet<string> = new Set(
+	[...ACTIVE_STATES].filter((state) => displayStatusFromState(state) === "running"),
+);
+
+/**
+ * Working states for the header's `N running` count, derived from the busy set
+ * so it can never list a state the panel considers dead. `blocked` is an
+ * approval gate: busy, but not generating, so it does not count as running.
+ */
+const RUNNING_STATES: ReadonlySet<string> = new Set(
+	[...BUSY_STATES].filter((state) => state !== "blocked"),
+);
 
 function cleanDisplayText(value: string): string {
 	return stripTerminalSequences(value)
@@ -494,6 +570,12 @@ function renderTreeWidgetLines(
 		// A terminal node whose subtree is still running is waiting on
 		// downstream work (e.g. a centurion between turns while its squad
 		// executes) — render it as "waiting" instead of a dead settled state.
+		//
+		// D1-a: a row that is *already* `awaiting` is not rewritten. `awaiting`
+		// means "alive, waiting on downstream", so it is active (ACTIVE_STATES)
+		// and this branch never sees it — which is the point: it must neither
+		// vanish from the panel nor be relabelled as a finished state. It renders
+		// grey, as itself, because `themeLines` dims every non-header row.
 		const effectiveEntry = !isActiveEntry(entry) && activeSubtree
 			? { ...entry, state: "waiting" as const, herdrStatus: "waiting" as const }
 			: entry;
@@ -543,7 +625,7 @@ function formatWidgetRows(entries: StatusEntry[], now: number, totals?: StatusTo
 		return formatEntryLines(entries[0]!, now, { head: "", detail: "" })
 			.map((text) => ({ text }));
 	}
-	const rows: WidgetRow[] = [{ text: "● Async agents · herdr" }];
+	const rows: WidgetRow[] = [{ text: "● Async agents" }];
 	for (const [index, entry] of entries.entries()) {
 		const last = index === entries.length - 1;
 		rows.push(

package/src/tui/tree-view.ts

@@ -10,14 +10,40 @@ import {
 	type TUI,
 } from "@earendil-works/pi-tui";
 import type { LegionEvent } from "../extension/event-bus.ts";
-import type { LegionNode, NodeStatus } from "../legion/nodes.ts";
+import type { LegionNode } from "../legion/nodes.ts";
+import { NODE_STATUSES } from "../legion/nodes.ts";
+import { isTerminalState } from "../extension/liveness.ts";
+import type { SpawnMode } from "../shared/types.ts";
 import { osc8NodeLink } from "./status.ts";
 
 const TREE_HEADER = "Legion tree · j/k move · enter toggle · / search · pgup/pgdn scroll · esc/q close";
 const DEFAULT_TERMINAL_ROWS = 24;
 const MAX_ACTIVITY_TOOLS = 2;
-const ACTIVE_STATUSES = new Set<NodeStatus>(["starting", "running", "blocked"]);
-const TERMINAL_STATUSES = new Set<NodeStatus>(["settled", "failed", "retired"]);
+/**
+ * Active/terminal partition, derived from the liveness authority instead of
+ * hand-written here (contract `docs/contracts/display-liveness-v1.md` D1-a,
+ * D6 exit 4).
+ *
+ * The gain is anti-drift rather than a bug fix: `node.status` is `NodeStatus`,
+ * the six-value ledger set, and for those six the old local pair happened to
+ * agree with `isTerminalState`. But it was a fourth independent copy of the
+ * vocabulary, so the next ledger status would be terminal in the panel and
+ * non-terminal here — exactly the divergence D6 forbids.
+ *
+ * `idle`/`queued` are display states that cannot appear here (D9 keeps them out
+ * of `NODE_STATUSES`). They are unioned into the active side anyway so the two
+ * sets stay a partition of anything a snapshot row might carry: calling a
+ * pending row terminal would fold its subtree and freeze its clock for work
+ * that has not started.
+ */
+const ACTIVE_STATUSES: ReadonlySet<string> = new Set<string>([
+	...NODE_STATUSES.filter((status) => !isTerminalState(status)),
+	"idle",
+	"queued",
+]);
+const TERMINAL_STATUSES: ReadonlySet<string> = new Set<string>(
+	NODE_STATUSES.filter((status) => isTerminalState(status)),
+);
 
 export interface TreeNodeSnapshot extends LegionNode {
 	/** Snapshot from legion.db usage table (≤30s granularity). */
@@ -30,6 +56,13 @@ export interface TreeNodeSnapshot extends LegionNode {
 	lastTools?: readonly string[];
 	/** Unix ms start of the current turn, when known (bus events or snapshots). */
 	turnStartedAt?: number;
+	/**
+	 * Arbitrated backend for this child (#209), merged from the tracked job at
+	 * snapshot time — `legion.db` has no spawn_mode column. Absent for legacy
+	 * records and for nodes never launched in this session; readers must render
+	 * that as unknown, never as `rpc`.
+	 */
+	spawnMode?: SpawnMode;
 }
 
 export interface TreeViewTheme {

package/src/tui/viz/layout.ts

@@ -17,6 +17,13 @@ export interface LegionLayout {
 	/** Subagent wall/gen/other table (#151). */
 	timing: Rect;
 	log: Rect;
+	/**
+	 * Agent status table (role/state/supervisor/ctx/rss/turns). Zero-area in
+	 * portrait: 46×24 already packs four panes into 19 of 21 body rows, so the
+	 * fifth cannot fit (D1). A zero-height rect keeps `frame()` from painting and
+	 * `availablePanes()` (view.ts) keeps Tab off it.
+	 */
+	status: Rect;
 	footer: Rect;
 }
 
@@ -35,6 +42,35 @@ export const TIMING_BAND_MIN = 5;
 export const TIMING_BAND_MAX = 10;
 /** Below this bottom height, stacked prefers a timing strip over side-by-side. */
 export const STACKED_TIMING_SIDE_MIN = 8;
+/** Status band: enough rows for a header plus a few agents, never a tall empty box. */
+export const STATUS_BAND_MIN = 5;
+export const STATUS_BAND_MAX = 12;
+/**
+ * Rows the log keeps when a status band is carved out above it. Below this the
+ * band is dropped entirely rather than shrinking the log to a header-only stub —
+ * the same trade `timing` already makes against `log` in portrait.
+ */
+export const STATUS_LOG_RESERVE = 4;
+
+/**
+ * Height of a status band carved out of `avail` rows while leaving `reserve`
+ * rows for whatever sits below it. Returns 0 when the band cannot reach
+ * STATUS_BAND_MIN — callers then hand the whole area to the neighbouring pane,
+ * and the zero-height rect is what makes Tab skip it.
+ */
+function statusBandHeight(avail: number, reserve: number, share: number): number {
+	const cap = Math.min(STATUS_BAND_MAX, avail - reserve);
+	if (cap < STATUS_BAND_MIN) return 0;
+	return Math.min(cap, Math.max(STATUS_BAND_MIN, Math.round(avail * share)));
+}
+
+/**
+ * A pane that could not be placed (D1). Zero-area, so `frame()` paints nothing
+ * and `availablePanes()` (view.ts) keeps Tab off it.
+ */
+function noRect(): Rect {
+	return { x: 0, y: 0, w: 0, h: 0 };
+}
 
 /** Terminal cells are ~2:1 (tall), so rows*2 >= cols means the window looks taller than wide. */
 export function isTall(cols: number, rows: number): boolean {
@@ -73,6 +109,9 @@ export function computeLayout(cols: number, rows: number, hints: LayoutHints = {
 			Math.max(TIMING_BAND_MIN, Math.round(bodyH * 0.42)),
 			Math.max(TIMING_BAND_MIN, bodyH - 6),
 		);
+		// Right column: timing, then log, then the status band closes it (D1).
+		const statusH = statusBandHeight(bodyH - timingH, STATUS_LOG_RESERVE, 0.25);
+		const logH = Math.max(0, bodyH - timingH - statusH);
 		return {
 			kind,
 			header,
@@ -80,7 +119,8 @@ export function computeLayout(cols: number, rows: number, hints: LayoutHints = {
 			galaxy: { x: 0, y: bodyY, w: leftW, h: galaxyH },
 			chart: { x: 0, y: bodyY + galaxyH, w: leftW, h: chartH },
 			timing: { x: leftW, y: bodyY, w: rightW, h: timingH },
-			log: { x: leftW, y: bodyY + timingH, w: rightW, h: Math.max(0, bodyH - timingH) },
+			log: { x: leftW, y: bodyY + timingH, w: rightW, h: logH },
+			status: statusH > 0 ? { x: leftW, y: bodyY + timingH + logH, w: rightW, h: statusH } : noRect(),
 		};
 	}
 	if (kind === "stacked") {
@@ -91,6 +131,10 @@ export function computeLayout(cols: number, rows: number, hints: LayoutHints = {
 		// Prefer timing|log side-by-side; strip when the bottom band is too short (#151).
 		if (bottomH >= STACKED_TIMING_SIDE_MIN) {
 			const timingW = Math.floor(W * 0.45);
+			const rightW = W - timingW;
+			// Right column of the bottom band: log on top, status closing it (D1).
+			const statusH = statusBandHeight(bottomH, STATUS_LOG_RESERVE, 0.35);
+			const logH = Math.max(0, bottomH - statusH);
 			return {
 				kind,
 				header,
@@ -98,10 +142,14 @@ export function computeLayout(cols: number, rows: number, hints: LayoutHints = {
 				galaxy: { x: 0, y: bodyY, w: galaxyW, h: topH },
 				chart: { x: galaxyW, y: bodyY, w: W - galaxyW, h: topH },
 				timing: { x: 0, y: bottomY, w: timingW, h: bottomH },
-				log: { x: timingW, y: bottomY, w: W - timingW, h: bottomH },
+				log: { x: timingW, y: bottomY, w: rightW, h: logH },
+				status: statusH > 0 ? { x: timingW, y: bottomY + logH, w: rightW, h: statusH } : noRect(),
 			};
 		}
 		const timingH = Math.min(TIMING_BAND_MAX, Math.max(TIMING_BAND_MIN, Math.round(bottomH * 0.4)), Math.max(3, bottomH - 3));
+		const afterTiming = Math.max(0, bottomH - timingH);
+		const statusH = statusBandHeight(afterTiming, STATUS_LOG_RESERVE, 0.35);
+		const logH = Math.max(0, afterTiming - statusH);
 		return {
 			kind,
 			header,
@@ -109,7 +157,8 @@ export function computeLayout(cols: number, rows: number, hints: LayoutHints = {
 			galaxy: { x: 0, y: bodyY, w: galaxyW, h: topH },
 			chart: { x: galaxyW, y: bodyY, w: W - galaxyW, h: topH },
 			timing: { x: 0, y: bottomY, w: W, h: timingH },
-			log: { x: 0, y: bottomY + timingH, w: W, h: Math.max(0, bottomH - timingH) },
+			log: { x: 0, y: bottomY + timingH, w: W, h: logH },
+			status: statusH > 0 ? { x: 0, y: bottomY + timingH + logH, w: W, h: statusH } : noRect(),
 		};
 	}
 	// Portrait: galaxy (aspect-limited), chart (fixed band), timing (compact), log gets the rest.
@@ -151,5 +200,7 @@ export function computeLayout(cols: number, rows: number, hints: LayoutHints = {
 		chart: { x: 0, y: bodyY + galaxyH, w: W, h: chartH },
 		timing: { x: 0, y: bodyY + galaxyH + chartH, w: W, h: Math.max(0, timingH) },
 		log: { x: 0, y: bodyY + galaxyH + chartH + Math.max(0, timingH), w: W, h: Math.max(0, logH) },
+		// D1: portrait has no room for a fifth pane — zero-area, so frame()/Tab skip it.
+		status: noRect(),
 	};
 }

package/src/tui/viz/model.ts

@@ -2,13 +2,25 @@
  * Shared data model for the Legion visualization (railway strip + /legion view).
  *
  * Subagents spawn dynamically and nest, so nothing here assumes a fixed role
- * list. Node statuses collapse to four display states: `blocked` is a
- * transient in-memory approval flag and renders as running.
+ * list. Node statuses collapse to the display states of contract
+ * `docs/contracts/display-liveness-v1.md` D5: `blocked` is a transient
+ * in-memory approval flag and renders as running, while `idle`/`queued` are
+ * first-class display states (a child can hold a concurrency slot without
+ * working) and an unrecognised label is `unknown` rather than the old
+ * `retired` fallback.
  */
 
 import type { StatusEntry } from "../status.ts";
+import { SPAWN_MODES, type SpawnMode } from "../../shared/types.ts";
+import { displayStatusFromState, isTerminalState, type DisplayStatus } from "../../extension/liveness.ts";
 
-export type VizStatus = "running" | "settled" | "failed" | "retired";
+/**
+ * D5's display vocabulary, imported from the single authority rather than
+ * re-declared. The name `VizStatus` stays because every viz consumer imports
+ * it; the values are `liveness.ts`'s `DisplayStatus` so the panel cannot drift
+ * from the list/tree.
+ */
+export type VizStatus = DisplayStatus;
 
 export interface VizNode {
 	id: string;
@@ -37,19 +49,44 @@ export interface VizNode {
 	turns?: number;
 	/** Unix ms of last visible activity for this seat (not run wall-clock start). */
 	lastActivityAt?: number;
+	/**
+	 * Arbitrated backend the child was spawned on (#209). Optional: a row restored
+	 * from disk has none, and consumers must render `unknown` — never guess `rpc`.
+	 */
+	spawnMode?: SpawnMode;
+	/** Own OS process of an `rpc` child; `inprocess` children have none by definition. */
+	pid?: number;
+	/** Prompt size of the last assistant message; absolute tokens, not a ratio. */
+	contextTokens?: number;
+	/**
+	 * Resident memory of this child in MB. Only ever set for a child with its own
+	 * process (D2): an `inprocess` child has no separate RSS, so it renders `—`
+	 * rather than a share of the host figure.
+	 */
+	rss?: number;
 }
 
-/** Same set the footer/busy label treat as active, so live counts agree everywhere. */
-const RUNNING = new Set(["starting", "working", "running", "blocked"]);
-const SETTLED = new Set(["settled", "success", "completed", "done"]);
-const FAILED = new Set(["failed", "aborted", "error", "truncated"]);
+/**
+ * `StatusEntry.spawnMode` is a plain string (it can come off disk or from an old
+ * caller). Only a real mode reaches `VizNode`; anything else stays absent so the
+ * panel prints `unknown` instead of echoing an unvalidated backend name.
+ */
+function asSpawnMode(value: string | undefined): SpawnMode | undefined {
+	return value !== undefined && (SPAWN_MODES as readonly string[]).includes(value) ? (value as SpawnMode) : undefined;
+}
 
+/**
+ * D5: raw lifecycle state → display state, delegated to `liveness.ts`.
+ *
+ * The three local sets that used to live here (`RUNNING`/`SETTLED`/`FAILED`)
+ * plus the `return "retired"` catch-all are gone: a fourth copy of the state
+ * vocabulary is exactly how the strip, the tree and the rail drifted apart. In
+ * particular `idle`/`queued` no longer collapse into `retired`, and anything
+ * unrecognised (including `undefined`) is `unknown` — an undecided child must
+ * not be painted as finished.
+ */
 export function displayStatus(state: string | undefined): VizStatus {
-	const value = (state ?? "").toLowerCase();
-	if (SETTLED.has(value)) return "settled";
-	if (FAILED.has(value)) return "failed";
-	if (RUNNING.has(value)) return "running";
-	return "retired";
+	return displayStatusFromState(state);
 }
 
 /** Build viz nodes from status entries (root row included when present). */
@@ -60,7 +97,19 @@ export function nodesFromEntries(entries: readonly StatusEntry[]): VizNode[] {
 		const id = entry.nodeId ?? entry.name;
 		if (seen.has(id)) continue;
 		seen.add(id);
-		const status = id === "root" ? "running" : displayStatus(entry.herdrStatus ?? entry.state);
+		const raw = entry.herdrStatus ?? entry.state;
+		const status = id === "root" ? "running" : displayStatus(raw);
+		const spawnMode = asSpawnMode(entry.spawnMode);
+		// `endedAt` means "this lane's lifetime is over", and the rail/log/chart
+		// read it as such: the railway drops the lane, `buildLog` emits an end
+		// event, the timing pane freezes the wall clock. Only a *terminal* status
+		// may claim that. `idle`/`queued` are alive (D5: slot held, not started)
+		// and `unknown` is undecided — stamping an end on any of them would erase a
+		// live child from the strip and fake an end event for it.
+		//
+		// The root row is excluded because its display status is pinned to
+		// `running` above: an end stamp would contradict the status it carries.
+		const ended = id !== "root" && isTerminalState(raw);
 		out.push({
 			id,
 			name: entry.name,
@@ -69,7 +118,7 @@ export function nodesFromEntries(entries: readonly StatusEntry[]): VizNode[] {
 			depth: entry.depth ?? (id === "root" ? 0 : 1),
 			status,
 			startedAt: entry.startedAt,
-			...(status !== "running" ? { endedAt: entry.finishedAt ?? entry.startedAt } : {}),
+			...(ended ? { endedAt: entry.finishedAt ?? entry.startedAt } : {}),
 			tokens: Math.max(0, entry.tokensTotal ?? 0),
 			tokensOut: Math.max(0, entry.tokensOut ?? 0),
 			generationMs: Math.max(0, entry.generationMs ?? 0),
@@ -77,6 +126,10 @@ export function nodesFromEntries(entries: readonly StatusEntry[]): VizNode[] {
 			...(entry.currentTurnEndedAt !== undefined ? { currentTurnEndedAt: entry.currentTurnEndedAt } : {}),
 			...(entry.turns !== undefined && entry.turns > 0 ? { turns: entry.turns } : {}),
 			...(entry.lastActivityAt !== undefined ? { lastActivityAt: entry.lastActivityAt } : {}),
+			...(spawnMode ? { spawnMode } : {}),
+			...(entry.pid !== undefined ? { pid: entry.pid } : {}),
+			...(entry.contextTokens !== undefined ? { contextTokens: entry.contextTokens } : {}),
+			...(entry.rss !== undefined ? { rss: entry.rss } : {}),
 		});
 	}
 	// Parents that are missing from the snapshot re-attach to the nearest known ancestor.

package/src/tui/viz/palette.ts

@@ -177,9 +177,20 @@ export function resolveRolePalette(theme: VizTheme, roles: Iterable<string>): Ma
 	return out;
 }
 
+/**
+ * Colour token for a node's status glyph.
+ *
+ * D5: `idle` is *alive but not working* — it holds a concurrency slot, so it
+ * must stay on screen — and an undecided (`unknown`) node is not active
+ * either. Both render `dim`, which is exactly "present, not doing anything".
+ * `queued` keeps its role colour: it has been admitted and is about to run, so
+ * greying it out would read as "nothing to see here" for work that is pending.
+ */
 export function statusToken(role: string, status: VizStatus): string {
 	if (status === "failed") return "error";
 	if (status === "retired") return "dim";
+	if (status === "idle") return "dim";
+	if (status === "unknown") return "dim";
 	return roleColor(role);
 }