pi-legion 3.0.3 → 3.1.0

package/CHANGELOG.md

@@ -11,6 +11,54 @@ summary so you can see **2.x vs 0.16** without leaving the tree.
 
 ## [Unreleased]
 
+## [3.1.0] — 2026-10-19
+
+### Added
+
+- **The arbitrated launch backend is now visible (#209).** In-process has been
+  the default since #197, but the backend a launch actually resolved to only
+  ever appeared as a substring of one result line, so a user could not tell
+  `inprocess` from `rpc`. Three surfaces now name it, always from
+  `Handle.spawnMode` (the arbitration result) and never re-derived:
+  - `subagent` and `vexillatio` results carry `details.spawns[]` /
+    `handles[].spawnMode`, and a shared `renderResult`
+    (`src/extension/spawn-render.ts`) prepends `spawn: scout-0=inprocess` to the
+    tool card. The line lives in `details`, not `content`, so it stays out of
+    the LLM context.
+  - The `/legion` node modal footer appends `spawn <mode>` through
+    `TrackedJobInput` → `TreeNodeSnapshot` → `LiveOverlayNode` → `metaPlain()`.
+    No `legion.db` column and no schema-version bump; the value is threaded from
+    the live job.
+  - An unknown or legacy mode is **omitted**, never guessed as `rpc`.
+
+  `pi` does not render a tool result's `details` on its own — `renderResult` is
+  its only consumer — so the field alone would have been invisible. The
+  renderer is hardened accordingly: a hostile `details` (throwing getter) is
+  treated as a missing fact instead of throwing into the host's silent
+  fallback, and `\r` / binary control bytes are normalized before the collapsed
+  line cap is counted, matching the host fallback's own sanitization.
+
+### Changed
+
+- **Parent-facing guidance no longer calls every child an "RPC child".** The
+  playbook, the collect/retire notices and the async tail now say "child" and
+  describe in-process as the default, naming the rpc backend only where it is
+  genuinely meant. The internal settle reasons, the auto-doctor classifier
+  regex and the frozen interrupted head line are unchanged. The
+  `--no-extensions` guidance is backend-neutral again: in-process children do
+  not inherit host extensions either.
+
+- **The railway lane only shows "last activity" once it is worth a word (#231).**
+  A lane used to end with `· 1s ago` on every running agent — the tallest,
+  least informative field in the label, and it crowded out the role/clocks
+  that actually distinguish lanes. Ages under a minute are now dropped
+  entirely; from 60s up the field reads `1m ago` / `2h ago` / `3d ago` as
+  before, and a missing timestamp still shows `—`. `formatActivityAgo`
+  returns `""` for the dropped case, so the field simply disappears from the
+  detail candidates instead of leaving a dangling separator.
+
+  Contract: `docs/spawn-mode-visibility-v1.md` (D1–D8, with the round-1 errata).
+
 ## [3.0.3] — 2026-10-19
 
 ### Changed

package/README.md

@@ -244,7 +244,10 @@ commands without an LLM. Passing verification advances the squad to `done`.
    header shows the live count and tok/s (trailing 60s average). The lane
    label reads `role · <time since the last task started> / <lifetime> · <age
    of last activity>`; the leading clock keeps ticking through the quiet gap
-   after a turn settles and freezes only when the agent itself ends. The lane
+   after a turn settles and freezes only when the agent itself ends. The
+   last-activity age only appears once it is at least a minute old — a lane
+   that just saw activity is already visibly live, so `1s ago` on every
+   running agent was noise; a missing timestamp still shows `—`. The lane
    column is measured from what the labels need and the time axis takes the
    rest (down to a floor), so a row always fills the line. Hidden when no
    subagent is live. Set `PI_LEGION_STRIP=tree` for the classic roster.

package/docs/spawn-mode-visibility-v1.md

@@ -0,0 +1,206 @@
+# Spawn-mode visibility + RPC copy cleanup — frozen contract v1
+
+Status: frozen for implementation. Owner decisions are D1–D7; do not re-litigate.
+
+## Why
+
+`DEFAULT_SPAWN_MODE = "inprocess"` (`src/supervisor/spawn-mode.ts:18`) has shipped,
+but the parent-facing guidance still says every child is an "RPC child", and the
+actual backend (`handle.spawnMode`) is only visible as a substring of a result
+text line. Users cannot tell inprocess from rpc from the UI.
+
+Facts established by recon (do not re-verify):
+
+- pi never renders tool-result `details` on its own. The only consumer is
+  `renderResult` (`tool-execution.js:243`); with no renderer the host falls back
+  to `content` text only. Adding a `details` field alone is invisible.
+- `subagent` / `vexillatio` register **no** renderer (`index.ts:708`, `index.ts:973`).
+- `Handle.spawnMode: SpawnMode` is non-optional and is the arbitrated backend
+  (`src/shared/types.ts:482-503`, produced at `src/runs/orchestrator.ts:809-818`).
+- `LaunchSession.handles` is `string[]` (`index.ts:1831`) — the mode is dropped there.
+- The `/legion` node modal footer is `metaPlain()` (`src/tui/live-overlay.ts:737-756`)
+  rendering `role · model · turn N (Xs) · elapsed · status`.
+- `legion.nodes` has **no** spawn_mode column (`src/legion/db.ts:47-67`).
+
+## D1 — Wording (backend-neutral) for parent guidance
+
+Children are **in-process by default**; a separate `pi` process is used only when
+the launch needs a worktree (centurion) or the role pins `spawnMode: rpc`.
+
+Replace "RPC child / headless RPC children / started via RPC / RPC launch" with
+backend-neutral phrasing in these exact places:
+
+| File:line | Current |
+| --- | --- |
+| `src/extension/playbook.ts:12` | `Child processes are headless RPC children; no pane or tab is created.` |
+| `src/extension/playbook.ts:13` | `when each RPC child finishes` |
+| `src/extension/playbook.ts:15` | `A collect timeout with a live RPC child` |
+| `src/extension/playbook.ts:25` | `children use --no-extensions` (keep only if still true for the rpc path; phrase as `rpc children use --no-extensions`) |
+| `index.ts:1669` | `playbook: … → RPC launch → watch` |
+| `index.ts:1966` | `playbook: … started via RPC` |
+| `index.ts:1801` | `when each RPC child finishes` |
+| `index.ts:1616` | `(live RPC child steered)` |
+| `index.ts:1574` | `RPC process stopped; session kept for resume:` |
+| `src/extension/recycle.ts:10` | `the RPC child is already stopped` |
+| `src/extension/notify.ts:200` | `RPC child retired.` |
+| `src/extension/notify.ts:237` | `(RPC child is not alive)` |
+| `src/extension/notify.ts:315` | `(RPC child retired)` |
+
+Use `child` as the noun. Suggested replacement vocabulary (one word list, keep it
+consistent): `child`, `in-process child`, `rpc child` (lowercase, only when the
+rpc backend is meant), `session`, `watch`.
+
+## D2 — Out of scope for D1 (do NOT touch)
+
+These are either internal identifiers or the genuine rpc backend; changing them
+breaks failure classification or contracts:
+
+- `src/supervisor/rpc-supervisor.ts` reasons (`Pi RPC process exited …`, etc.)
+- `src/extension/auto-doctor.ts:50` regex (matches `Pi RPC process exited`)
+- `src/runs/orchestrator.ts:146` `TRANSIENT_CONNECTION_REASON` value
+- `src/runs/orchestrator.ts:579/782`, `src/runs/hygiene.ts`, `--no-extensions`
+  plumbing, `rpc-child-*` temp dir prefixes, `subagents.rpc.*` keys
+- the frozen head line `interrupted (parent turn ended; children still running)`
+- `docs/contracts/**`
+
+## D3 — `details` carries the mode (machine facts)
+
+Additive only; never replace an existing field, never emit `isError`.
+
+`subagent` launch-family success + interrupted results gain:
+
+```ts
+spawns?: Array<{ name: string; agent: string; spawnMode: "rpc" | "inprocess" }>
+```
+
+- Emitted only when at least one handle resolved (omitted otherwise, matching the
+  existing `stillRunning?` "present only when non-empty" convention).
+- Values come from `handle.spawnMode` (`Handle`, never re-derived, never guessed).
+- Sites: `index.ts:1754` (interrupted) and `index.ts:1807` (normal).
+  The interrupted path runs after `handles` is cleared, so keep the resolved
+  entries in a parallel field on `LaunchSession` (precedent: `timeoutByName`).
+
+`vexillatio` gains `spawnMode` on each handle object:
+
+```ts
+handles: Array<{ name: string; agent: string; sessionFile: string; spawnMode?: SpawnMode }>
+```
+
+`spawnMode` is optional so `ChildRecord.spawnMode?: SpawnMode` legacy runs
+(`src/shared/types.ts:365-373`) render as absent, never as `"rpc"`.
+`docs/vexillatio-contract.md:57` freezes top-level details keys only, so this is
+allowed; do not change that doc.
+
+## D4 — TUI renderer for both tools (this is what makes D3 visible)
+
+New file `src/extension/spawn-render.ts`:
+
+```ts
+export function spawnModeSummary(details: unknown): string | undefined
+export function renderSpawnResult(
+  result: AgentToolResult<unknown>,
+  opts: { expanded: boolean; isPartial: boolean },
+  theme: Theme,
+): Component
+```
+
+Behaviour:
+
+1. `spawnModeSummary` reads `details.spawns` and/or `details.handles[].spawnMode`
+   defensively (unknown → undefined). Output: `spawn: scout-0=inprocess`
+   or `spawn: worker-0=rpc, scout-1=inprocess`. Entries with an unknown mode are
+   skipped; if none survive, return `undefined`.
+2. `renderSpawnResult` builds the text from `content` text blocks only
+   (`stripTerminalSequences`), prepends the summary line when defined, then
+   collapsed → first 10 lines + `... (N more lines, ctrl+o to expand)`,
+   expanded → all lines. Returns `new Text(text, 0, 0)`.
+3. It must never throw: wrap the details access in optional chaining; a throw is
+   silently swallowed by the host and would blank the card.
+
+Attach `renderResult: (result, opts, theme) => renderSpawnResult(result, opts, theme)`
+to both `subagent` (`index.ts:973`) and `vexillatio` (`index.ts:708`).
+No `renderCall`, no `renderShell: "self"`.
+
+Rationale: `content` is model-facing, `details` is TUI-facing (`docs/design.md:258`).
+The summary line goes through `details` so it does not enter the LLM context.
+
+## D5 — `/legion` node modal footer shows the same value
+
+Thread the arbitrated mode to the overlay without a DB migration:
+
+1. `TrackedJobInput` (`src/extension/runtime.ts:68`) gains `spawnMode?: SpawnMode`.
+2. Launch sites pass `handle.spawnMode` (`index.ts` ~1914 and the follow sites
+   ~2709-2790 that already carry the handle/record).
+3. `TreeNodeSnapshot` (`src/tui/tree-view.ts:22`) gains `spawnMode?: SpawnMode`;
+   `snapshotNodes()` (`src/extension/runtime.ts:608`) merges the job's value onto
+   the node snapshot (`job.spawnMode`, matched by nodeId/name, no guessing).
+4. `liveNode()` (`src/extension/legion-commands.ts:298`) maps it through
+   `LiveOverlayNode` (`src/tui/live-overlay.ts:25`).
+5. `metaPlain()` appends `spawn <mode>` **only when known**; legacy/unknown →
+   omit the segment entirely (never print `rpc` as a default).
+
+Do **not** add a `legion.db` column and do **not** bump `LEGION_DB_USER_VERSION`.
+
+## D6 — Tests (must be updated/added by the same change)
+
+Update (currently lock the old wording):
+
+- `test/unit/playbook.test.ts:17` `/headless RPC children/`, `:76` `/RPC child is a progress signal/`
+- `test/unit/notify.test.ts:52,163,169,398,410-411`
+- `test/unit/recycle.test.ts:11`
+- `test/unit/runtime.test.ts:1252`
+
+Add:
+
+- `spawnModeSummary` returns `undefined` for `{}`/unknown/legacy, and the
+  documented string for both launch-family and vexillatio details shapes.
+- `renderSpawnResult` collapsed keeps the summary line and caps at 10 lines +
+  hint; expanded prints everything.
+- launch details expose `spawns` with the arbitrated value (extend an existing
+  harness that already inspects `details`, e.g. `test/unit/teams.test.ts:1320`).
+- `metaPlain` includes `spawn rpc` / `spawn inprocess` when set and omits it when
+  unknown (`test/unit/legion-live-overlay.test.ts`).
+
+## Errata (review round 1, accepted)
+
+- **D3/D6 (line numbers)**: the D1 table merged two `index.ts` copy sites into
+  `playbook.ts` rows. The real sites are `playbook.ts:12/14/15` plus
+  `index.ts:1669/1801/1966/1616/1574`. Behaviour unchanged.
+- **D1 (`--no-extensions`)**: the suggested wording `rpc children use
+  --no-extensions` was wrong — in-process children run with
+  `noExtensions = !childInheritsExtensions(...)` too
+  (`src/supervisor/inprocess-supervisor.ts:145`). The sentence must stay
+  backend-neutral; do not name `rpc` there.
+- **D4 (never-throw)**: shape checks are not enough. A `details` object with a
+  throwing getter still throws, and the host silently swallows it
+  (`tool-execution.js:150-160`). `spawnModeSummary` and `renderSpawnResult` must
+  both be wrapped in `try/catch`. Covered by a getter/Proxy test.
+- **D4 (line cap)**: the collapsed cap must count rendered lines, so `\r` and
+  binary control bytes are stripped **before** splitting — parity with the host
+  fallback (`render-utils.js:40`: `sanitizeBinaryOutput` + `.replace(/\r/g,"")`).
+  Without it a `\r` progress stream renders 21 lines and never shows the hint.
+- **D4 (dedupe)**: one `name=mode` entry per child, first occurrence wins.
+- **D5 (`treeNodes()`)**: `snapshotNodes()` alone is not enough. `treeNodes()`
+  synthesizes a `TreeNodeSnapshot` for a job with identity but no DB row
+  (`runtime.ts:1311-1331`), and that literal dropped `spawnMode`, so the modal
+  footer lost the segment in the plain-session / pre-DB-row window. Merge in
+  `treeNodes()` (shared helper), not only in `snapshotNodes()`.
+- **D5 (width)**: `spawn <mode>` appended last is truncated to `spawn inpr...`
+  at the default 80-column layout (`resolveModalLayout(24,80)` → `innerWidth=78`).
+  Put the segment before `model` so the role+status survive, and test with a
+  realistic model id.
+
+## D8 — Commit ownership
+
+Implementation lands as a single commit **created by the parent agent**.
+Sub-agents must not `git commit`, `git push`, or merge. Round 1 violated this
+(`80890ba` was authored by the worker); it is amended by the parent in round 2.
+
+## D7 — Acceptance
+
+- `npm run typecheck`
+- `npm test`
+- `npm run test:integration`
+- No new `RPC child` occurrences in parent-visible strings: the D1 table is empty
+  afterwards, and `rg -n 'RPC child|headless RPC|via RPC' src index.ts` returns
+  only the files listed in D2.

package/index.ts

@@ -83,6 +83,7 @@ import {
 	SUBAGENT_NOTIFY_TYPE,
 } from "./src/extension/notify.ts";
 import { renderSubagentNotice } from "./src/extension/notice-renderer.ts";
+import { renderSpawnResult } from "./src/extension/spawn-render.ts";
 import { PARENT_PLAYBOOK, TOOL_DESCRIPTION } from "./src/extension/playbook.ts";
 import { configureSessionErrors, recordSessionError } from "./src/extension/session-errors.ts";
 import { getAgentDir } from "./src/agents/paths.ts";
@@ -710,6 +711,9 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 			label: "Vexillatio",
 			description: "Launch only read-only utility agents and return their collected output.",
 			parameters: VexillatioParams,
+			// D4: pi never renders `details` on its own, so without this the
+			// arbitrated spawnMode in `details.handles[].spawnMode` is invisible.
+			renderResult: (result, opts, theme) => renderSpawnResult(result, opts, theme),
 			async execute(_id, params, signal, _onUpdate, ctx: ExtensionContext): Promise<AgentToolResult<unknown>> {
 				if (signal?.aborted) {
 					return ok("interrupted (parent turn ended; children still running)");
@@ -975,6 +979,9 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 		description: TOOL_DESCRIPTION,
 		parameters: SubagentParams,
 
+		// D4: the same renderer as `vexillatio` — it reads both detail shapes.
+		renderResult: (result, opts, theme) => renderSpawnResult(result, opts, theme),
+
 		// The parameter list is fixed by Pi's `ExtensionAPI.registerTool`
 		// contract — an options object is not ours to choose.
 		// pi-lens-ignore: long-parameter-list
@@ -1121,7 +1128,18 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 				onUpdate,
 			});
 			if (signal?.aborted) {
-				return ok("interrupted (parent turn ended; children still running)");
+				// The frozen head line still leads, but the machine facts must
+				// survive: `launchFamily` already returns its own interrupted result
+				// (frozen head + `runId` + `spawns`) when it observes the abort; this
+				// outer net only catches an abort seen after that check. Replacing the
+				// whole result with a bare `ok()` used to drop `details.spawns` — the
+				// only record of the arbitrated backend once `handles` is cleared (#209/D3).
+				const details = result.details;
+				const carried =
+					details !== null && typeof details === "object" && !Array.isArray(details)
+						? (details as Record<string, unknown>)
+						: undefined;
+				return ok("interrupted (parent turn ended; children still running)", carried);
 			}
 			return result;
 		},
@@ -1554,7 +1572,7 @@ async function collectChild(
 	}
 }
 
-/** Retire the RPC child while preserving its outcome and session for resume. */
+/** Retire the child while preserving its outcome and session for resume. */
 async function retireChild(
 	ctx: ChildContext,
 ): Promise<AgentToolResult<unknown>> {
@@ -1571,7 +1589,7 @@ async function retireChild(
 		await persistChild(ctx.store, ctx.found.runId, ctx.orchestrator, ctx.name);
 		return ok(
 			`Retired ${ctx.name} (execution=${child.execution?.status ?? "unknown"}). ` +
-				`RPC process stopped; session kept for resume: ${child.sessionFile}`,
+				`Child stopped; session kept for resume: ${child.sessionFile}`,
 		);
 	} catch (error) {
 		return fail(`retire failed: ${String(error)}`, ErrorCodes.RETIRE_FAILED);
@@ -1613,7 +1631,7 @@ async function reviveChild(
 			await orchestrator.steer(name, params.message);
 			followChild(ctx, { watch: true });
 			return ok(
-				`${action === "resume" ? "Resumed" : "Continued"} ${name} (live RPC child steered).`,
+				`${action === "resume" ? "Resumed" : "Continued"} ${name} (live child steered).`,
 			);
 		}
 
@@ -1666,7 +1684,7 @@ async function launchFamily(input: {
 		content: [
 			{
 				type: "text",
-				text: `playbook: ${plan.steps.map((s) => s.agent).join(", ")} → RPC launch → watch`,
+				text: `playbook: ${plan.steps.map((s) => s.agent).join(", ")} → launch → watch`,
 			},
 		],
 		details: {},
@@ -1742,16 +1760,26 @@ async function launchFamily(input: {
 		results: [],
 		handles: [],
 		timeoutByName: new Map(),
+		// #209/D3: the arbitrated mode survives `handles` being cleared on an
+		// abort (interrupted results run after that), so it is kept per name
+		// here — same precedent as `timeoutByName`.
+		spawnByName: new Map(),
 		...(nameGate.name ? { launchName: nameGate.name } : {}),
 	};
 
+	/** `details.spawns` for the handles this request actually resolved. */
+	const spawnDetails = () => {
+		const spawns = [...session.spawnByName.values()];
+		return spawns.length > 0 ? { spawns } : {};
+	};
+
 	const interruptedResult = async (): Promise<AgentToolResult<unknown> | undefined> => {
 		if (!input.signal?.aborted) return undefined;
 		for (const name of session.handles) await abandonLaunchedChild(session, name);
 		session.handles.length = 0;
 		return {
 			content: [{ type: "text", text: session.results.join("\n") || "interrupted (parent turn ended; children still running)" }],
-			details: { runId: run.runId, handles: [], async: params.async ?? true },
+			details: { runId: run.runId, handles: [], async: params.async ?? true, ...spawnDetails() },
 		};
 	};
 
@@ -1798,13 +1826,13 @@ async function launchFamily(input: {
 
 	if (isAsync && session.handles.length > 0) {
 		session.results.push(
-			"↳ async: a completion message is queued when each RPC child finishes. It wakes this session when idle; otherwise it is delivered after the current turn. Use wait or collect for results. Do not tell children to message the parent.",
+			"↳ async: a completion message is queued when each child finishes. It wakes this session when idle; otherwise it is delivered after the current turn. Use wait or collect for results. Do not tell children to message the parent.",
 		);
 	}
 
 	return {
 		content: [{ type: "text", text: session.results.join("\n") }],
-		details: { runId: run.runId, handles: session.handles, async: isAsync },
+		details: { runId: run.runId, handles: session.handles, async: isAsync, ...spawnDetails() },
 	};
 }
 
@@ -1828,6 +1856,8 @@ interface LaunchSession {
 	results: string[];
 	handles: string[];
 	timeoutByName: Map<string, number>;
+	/** Arbitrated backend per resolved handle; survives an abort clearing `handles`. */
+	spawnByName: Map<string, { name: string; agent: string; spawnMode: SpawnMode }>;
 	/** Explicit child name for this single-step launch; omit to auto-allocate. */
 	launchName?: string;
 }
@@ -1939,6 +1969,13 @@ async function launchStep(
 			await session.store.addChild(session.runId, handle.child);
 		}
 		session.handles.push(handle.name);
+		// Recorded before the abort check below: an interrupted result runs after
+		// `handles` is cleared and still has to name the arbitrated backend.
+		session.spawnByName.set(handle.name, {
+			name: handle.name,
+			agent: effective.name,
+			spawnMode: handle.spawnMode,
+		});
 		if (effective.timeoutMs !== undefined) {
 			session.timeoutByName.set(handle.name, effective.timeoutMs);
 		}
@@ -1963,7 +2000,7 @@ async function launchStep(
 			content: [
 				{
 					type: "text",
-					text: `playbook: ${handle.name} started via RPC`,
+					text: `playbook: ${handle.name} started (supervisor=${handle.spawnMode})`,
 				},
 			],
 			details: {},
@@ -2343,6 +2380,7 @@ async function launchUtilityFamily(input: {
 					name: handle.name,
 					agent: item.agent.name,
 					sessionFile: handle.sessionFile,
+					spawnMode: handle.spawnMode,
 					orchestrator,
 					retire,
 				},
@@ -2358,6 +2396,7 @@ async function launchUtilityFamily(input: {
 		name: string;
 		agent: string;
 		sessionFile: string;
+		spawnMode: SpawnMode;
 		orchestrator: Orchestrator;
 		retire: (opts?: RetireOptions) => Promise<void>;
 	}> = [];
@@ -2373,6 +2412,8 @@ async function launchUtilityFamily(input: {
 			agent: handle.agent,
 			sessionFile: handle.sessionFile,
 			timeoutMs,
+			// Arbitrated at launch; never re-derived here (#209).
+			spawnMode: handle.spawnMode,
 			orchestrator: handle.orchestrator,
 			store,
 			watch,
@@ -2426,7 +2467,7 @@ async function launchUtilityFamily(input: {
 		content: [{ type: "text", text: results.join("\n\n") || "No utility agents were launched." }],
 		details: {
 			runId,
-			handles: handles.map(({ name, agent, sessionFile }) => ({ name, agent, sessionFile })),
+			handles: handles.map(({ name, agent, sessionFile, spawnMode }) => ({ name, agent, sessionFile, spawnMode })),
 			async: false,
 			...(stillRunning.size > 0
 				? { stillRunning: handles.filter(({ name }) => stillRunning.has(name)).map(({ name }) => name) }
@@ -2448,7 +2489,7 @@ async function launchUtilityFamily(input: {
  */
 function interruptedUtilityResult(input: {
 	runId: string;
-	handles: Array<{ name: string; agent: string; sessionFile: string }>;
+	handles: Array<{ name: string; agent: string; sessionFile: string; spawnMode?: SpawnMode }>;
 	stillRunning: Set<string>;
 	results: string[];
 	collected: string[];
@@ -2462,7 +2503,13 @@ function interruptedUtilityResult(input: {
 	// real consumer instead of being a dead signature (#227 review F3).
 	return ok(segments.length > 0 ? `${head}\n\n${segments.join("\n\n")}` : head, {
 		runId: input.runId,
-		handles: input.handles.map(({ name, agent, sessionFile }) => ({ name, agent, sessionFile })),
+		handles: input.handles.map(({ name, agent, sessionFile, spawnMode }) => ({
+			name,
+			agent,
+			sessionFile,
+			// Optional on purpose: a legacy handle must render as absent, never `rpc`.
+			...(spawnMode ? { spawnMode } : {}),
+		})),
 		async: false,
 		interrupted: true,
 		...(stillRunning.length > 0 ? { stillRunning } : {}),
@@ -2614,12 +2661,17 @@ function followJob(
 		watch: boolean;
 		retire?: (opts?: RetireOptions) => Promise<void>;
 		treeIdentity?: { nodeId: string; parentId: string | null; depth: number };
+		/** Arbitrated backend from `Handle.spawnMode`; omitted when unknown (#209). */
+		spawnMode?: SpawnMode;
 	},
 ): void {
 	const child = input.orchestrator
 		.childrenSnapshot()
 		.find((entry) => entry.name === input.name);
 	const existing = runtime.get(input.name);
+	// The caller's Handle owns the arbitration; the persisted ChildRecord records
+	// the same decision. Neither is re-derived here — no handle, no value.
+	const spawnMode = input.spawnMode ?? child?.spawnMode;
 	runtime.track({
 		name: input.name,
 		runId: input.runId,
@@ -2630,6 +2682,7 @@ function followJob(
 		...(child?.model ? { model: child.model } : {}),
 		...(child?.thinking !== undefined ? { thinking: child.thinking } : {}),
 		...(child?.worktreeBranch ? { worktreeBranch: child.worktreeBranch } : {}),
+		...(spawnMode ? { spawnMode } : {}),
 		...(input.treeIdentity ? input.treeIdentity : child?.nodeId ? {
 			nodeId: child.nodeId,
 			parentId: child.nodeId.includes(".") ? child.nodeId.slice(0, child.nodeId.lastIndexOf(".")) : null,
@@ -2706,6 +2759,19 @@ function followChild(ctx: ChildContext, opts: { watch: boolean }): void {
 	});
 }
 
+/**
+ * The arbitrated backend recorded for one handled child of this request.
+ *
+ * Spreads to nothing when unknown, so the caller never has to invent a value.
+ */
+function spawnModeOf(
+	session: LaunchSession,
+	name: string,
+): { spawnMode?: SpawnMode } {
+	const recorded = session.spawnByName.get(name);
+	return recorded ? { spawnMode: recorded.spawnMode } : {};
+}
+
 function followLaunched(
 	session: LaunchSession,
 	name: string,
@@ -2723,6 +2789,8 @@ function followLaunched(
 		orchestrator: session.orchestrator,
 		store: session.store,
 		watch: opts.watch,
+		// Handle-derived, recorded before an abort can clear `handles` (#209).
+		...spawnModeOf(session, name),
 		...(child?.nodeId ? {
 			treeIdentity: {
 				nodeId: child.nodeId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-legion",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "description": "Pi Legion v2: recursive centurion trees on headless Pi RPC; shared SQLite WAL legion.db. Four-stage planning/implementing/reviewing/verifying state machine, parent/child/sibling legion_mail, three-layer /legion UI, upward MR trees, squad resume.",
   "type": "module",
   "license": "MIT",

package/src/extension/legion-commands.ts

@@ -312,6 +312,8 @@ function liveNode(
 		...(node.turns === undefined ? {} : { turns: node.turns }),
 		sessionFile: node.sessionFile,
 		worktreePath: node.worktreePath,
+		// #209/D5: absent for legacy nodes; the footer omits the segment entirely.
+		...(node.spawnMode === undefined ? {} : { spawnMode: node.spawnMode }),
 	};
 }
 

package/src/extension/notify.ts

@@ -197,7 +197,7 @@ export function formatCompletionNotice(input: CompletionInput): CompletionNotice
 		input.sessionFile ? `Session file: ${input.sessionFile}` : undefined,
 		input.recycled === false
 			? undefined
-			: "RPC child retired. Resume from the session file if you need this child again.",
+			: "Child retired. Resume from the session file if you need this child again.",
 	]
 		.filter((line) => line !== undefined)
 		.join("\n");
@@ -234,7 +234,7 @@ export function collectFailureInput(
 	// Live children never reach here: watch() re-arms a connection blip.
 	// A dead child's notice names that, instead of a bare "Connection error."
 	const reason = isTransientConnectionFailure(raw)
-		? `${raw} (RPC child is not alive)`
+		? `${raw} (child is not alive)`
 		: raw;
 	return {
 		name,
@@ -275,8 +275,8 @@ export interface GroupedCompletionInput {
  *   Still running: slow-2 (notifies separately when it finishes)
  *
  * Retirement is per-entry (a wait()-released sibling can race the flush, so a
- * blanket footer could be inaccurate): entries whose RPC child is retired
- * carry an inline "(RPC child retired)" marker.
+ * blanket footer could be inaccurate): entries whose child is retired
+ * carry an inline "(child retired)" marker.
  * Aggregate status: any failed → "failed"; else any stopped → "stopped";
  * else "completed". `display` follows the single-notice rule.
  */
@@ -311,8 +311,8 @@ export function formatGroupedNotice(
 			? ` — acceptance: ${entry.acceptance.status}${entry.acceptance.level ? ` (${entry.acceptance.level})` : ""}`
 			: "";
 		// Retirement is per-entry truth: a wait()-consumed sibling may already
-		// be released while another RPC child is still alive, so no blanket footer.
-		const recycled = entry.recycled === false ? "" : " (RPC child retired)";
+		// be released while another child is still alive, so no blanket footer.
+		const recycled = entry.recycled === false ? "" : " (child retired)";
 		lines.push(`- ${label}: ${entry.status}${reason}${acceptance}${recycled}`);
 		// Prefer the durable full-text artifact over the session file as the
 		// recovery pointer: one `read` beats re-deriving from jsonl/chat store.

package/src/extension/playbook.ts

@@ -1,5 +1,5 @@
 /**
- * Parent-side RPC dispatch guidance shared by tool descriptions and prompts.
+ * Parent-side child dispatch guidance shared by tool descriptions and prompts.
  */
 
 export const PLAYBOOK_NAME = "pi-legion-playbook";
@@ -9,10 +9,10 @@ export const PARENT_PLAYBOOK = [
 	"1. Call the `subagent` tool immediately with the matching role from the roster in this prompt. Do not substitute bash/curl/web fetch for a search or research role.",
 	'   One child:  subagent({ agent: "<role>", task: "...", name?: "scout-a" })  // optional name= registers that handle (not auto scout-N)',
 	"   Parallel:   subagent({ tasks: [{ agent, task }, { agent, task }] })",
-	"2. Prefer tasks[] for independent parallel work. Child processes are headless RPC children; no pane or tab is created.",
+	"2. Prefer tasks[] for independent parallel work. Children are in-process by default; a separate `pi` process is used only when the launch needs a worktree (centurion) or the role pins `spawnMode: rpc`. No pane or tab is created.",
 	"3. Then return control. A completion message wakes this session when idle; if it is still working, the notice waits until the current turn ends. Use `wait` with `name` or `all: true` when you need blocking results, and `collect` to inspect a child's session JSONL. Esc / wait interrupt only ends the parent turn's wait — children keep running and settle still notifies; only an explicit `stop` or session exit retires them. A wait interrupted by Esc returns `interrupted (parent turn ended; children still running)`. In `pi --print` or JSON mode, session shutdown waits for live async children to settle (up to each child's turn timeout) before retiring them. Use same-turn `wait`/`collect` or `async: false` when that print turn must include the child's result.",
-	"4. Later control is only through `subagent({ action, name?, message? })`; `status` with no name (or `all: true`) overviews live children, with `name` for one child; use `stop` to gracefully retire one child or all tracked children (`force: true` for hard retire when soft stop is insufficient). A `wait` timeout does not stop children — the result lists decisions (`extend` / `steer_again` / `stop` / `force_stop`) for the parent to choose. If a child exits oddly (Model not found, missing tools, memory refused, …), call `subagent({ action: \"diagnose\" })` or ask the user to run `/legion doctor` / `/legion doctor models` — children use `--no-extensions`, so provider packages must be passed explicitly. Do not tell a child to message or prompt the parent directly.",
-	"5. A collect timeout with a live RPC child is a progress signal, not a verdict. Check status or session JSONL before deciding to steer or resume.",
+	"4. Later control is only through `subagent({ action, name?, message? })`; `status` with no name (or `all: true`) overviews live children, with `name` for one child; use `stop` to gracefully retire one child or all tracked children (`force: true` for hard retire when soft stop is insufficient). A `wait` timeout does not stop children — the result lists decisions (`extend` / `steer_again` / `stop` / `force_stop`) for the parent to choose. If a child exits oddly (Model not found, missing tools, memory refused, …), call `subagent({ action: \"diagnose\" })` or ask the user to run `/legion doctor` / `/legion doctor models` — children run without host extensions unless the role inherits them, so a provider package the child needs must be passed explicitly. Do not tell a child to message or prompt the parent directly.",
+	"5. A collect timeout with a live child is a progress signal, not a verdict. Check status or session JSONL before deciding to steer or resume.",
 	"6. Isolation belongs to centurion. For N parallel isolated writers, dispatch N centurions (each owns one worktree); members stay `worktree: false` in-process. Passing `worktree: true` on a non-centurion warns once and is forced false.",
 	"7. Launch with `verify: [\"npm run typecheck\", \"npm test\"]` when the project has a mechanical verifier. The extension runs those commands itself in the child worktree at collect time; the child does not need to paste test output.",
 	"Utility agents (`utility: true`, e.g. scout) can be dispatched by ANY role via the separate `vexillatio` tool — read-only helpers, always leaf, no depth budget. The `subagent` tool stays for the command chain (worker/centurion).",

package/src/extension/recycle.ts

@@ -1,4 +1,4 @@
-/** Helpers for collect/retire calls made after an RPC child is auto-retired. */
+/** Helpers for collect/retire calls made after a child is auto-retired. */
 
 import type { TaskState } from "../shared/types.ts";
 
@@ -7,7 +7,7 @@ export function formatAlreadyRecycled(
 	sessionFile: string,
 ): string {
 	return (
-		`Already retired ${name}. This is a no-op — the RPC child is already stopped. ` +
+		`Already retired ${name}. This is a no-op — the child is already stopped. ` +
 		`Session kept for resume: ${sessionFile}`
 	);
 }

package/src/extension/runtime.ts

@@ -34,7 +34,12 @@ import {
 } from "../tui/status.ts";
 import { progressFromSessionFile } from "../shared/progress.ts";
 import { isTransientConnectionFailure } from "../shared/session.ts";
-import { DEFAULTS, type AgentKind, type RetireOptions } from "../shared/types.ts";
+import {
+	DEFAULTS,
+	type AgentKind,
+	type RetireOptions,
+	type SpawnMode,
+} from "../shared/types.ts";
 import type {
 	EventSubscriptionOptions,
 	SupervisorEvent,
@@ -76,6 +81,12 @@ export interface TrackedJobInput {
 	model?: string;
 	thinking?: string | false;
 	worktreeBranch?: string;
+	/**
+	 * Arbitrated backend for this child (`Handle.spawnMode`, #209). Optional:
+	 * a job tracked from a legacy record has no value and must render as
+	 * unknown rather than a guessed `rpc`.
+	 */
+	spawnMode?: SpawnMode;
 	/** Legion tree identity supplied by the host when the M2 ChildRecord is available. */
 	nodeId?: string;
 	parentId?: string | null;
@@ -629,7 +640,30 @@ export function createSessionRuntime(deps: SessionRuntimeDeps): SessionRuntime {
 			for (const nodeId of activity.keys()) if (!tree.has(nodeId)) activity.delete(nodeId);
 			for (const nodeId of eventOverrides.keys()) if (!tree.has(nodeId)) eventOverrides.delete(nodeId);
 		}
-		return [...tree.values()].map((node) => ({ ...node }));
+		const nodes = [...tree.values()].map((node) => ({ ...node }));
+		return mergeSpawnModes(nodes);
+	};
+
+	/**
+	 * #209/D5: the arbitrated backend lives on the tracked job, never in
+	 * legion.db (no column, no migration), so it is merged onto the matching
+	 * snapshot. Unmatched jobs contribute nothing rather than a guess.
+	 *
+	 * Shared by `snapshotNodes()` and `treeNodes()`: the latter synthesizes
+	 * nodes of its own (a job with identity but no DB row yet) and returns that
+	 * array directly, so a merge that only ran in `snapshotNodes()` would drop
+	 * the mode in the pre-DB-row window and in a plain session where
+	 * `getTreeNodes()` yields `[]`.
+	 */
+	const mergeSpawnModes = (
+		nodes: TreeNodeSnapshot[],
+	): TreeNodeSnapshot[] => {
+		for (const job of jobs.values()) {
+			if (job.spawnMode === undefined) continue;
+			const match = storedNodeForJob(job, nodes);
+			if (match) match.spawnMode = job.spawnMode;
+		}
+		return nodes;
 	};
 
 	const storedNodeForJob = (
@@ -969,6 +1003,9 @@ export function createSessionRuntime(deps: SessionRuntimeDeps): SessionRuntime {
 				existing.model = input.model;
 				existing.thinking = input.thinking;
 				existing.worktreeBranch = input.worktreeBranch;
+				// Only a known value overwrites: a re-follow without the handle must
+				// not erase the mode an earlier launch established.
+				if (input.spawnMode !== undefined) existing.spawnMode = input.spawnMode;
 				if (input.nodeId !== undefined || identity.nodeId !== undefined) existing.nodeId = input.nodeId ?? identity.nodeId;
 				if (input.parentId !== undefined || identity.parentId !== undefined) existing.parentId = input.parentId ?? identity.parentId;
 				if (input.depth !== undefined || identity.depth !== undefined) existing.depth = input.depth ?? identity.depth;
@@ -1308,7 +1345,10 @@ export function createSessionRuntime(deps: SessionRuntimeDeps): SessionRuntime {
 				if (index >= 0) result[index] = next;
 				else result.push(next);
 			}
-			return result;
+			// The synthesized nodes above are built from job facts, not from a DB
+			// row, so they carry no `spawnMode` of their own: run the same merge
+			// the snapshot path uses before handing the array out (#209/D5).
+			return mergeSpawnModes(result);
 		},
 
 		statusEntries() {

package/src/extension/spawn-render.ts

@@ -0,0 +1,183 @@
+/**
+ * TUI renderer for the `subagent` / `vexillatio` tool results.
+ *
+ * Pi never renders a tool result's `details` on its own: `renderResult` is the
+ * only consumer, and a tool registered without one falls back to the plain
+ * `content` text. So the arbitrated `spawnMode` (#209) stays invisible until a
+ * renderer names it — that is all this file does.
+ *
+ * The summary line is derived from `details`, never from `content`: `content`
+ * is model-facing, `details` is TUI-facing (`docs/design.md:258`). Keeping the
+ * line out of `content` keeps it out of the LLM context.
+ *
+ * Renderers are called on every repaint, so nothing here may throw: the host
+ * swallows a throwing renderer and falls back to the default block, silently
+ * erasing the very fact this file exists to show. Every `details` read is
+ * therefore optional-chained and shape-checked, AND both entry points are
+ * wrapped in `try/catch`: a shape check is no defence against a getter or a
+ * Proxy trap that throws (host: `tool-execution.js` catch → fallback card).
+ */
+
+import { Text } from "@earendil-works/pi-tui";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+
+/** How many `content` lines a collapsed card keeps before the expand hint. */
+const COLLAPSED_LINES = 10;
+
+const SPAWN_MODES = new Set(["rpc", "inprocess"]);
+
+/**
+ * Binary control bytes that must never reach the terminal renderer.
+ *
+ * Same set as the host fallback (`shell.js:sanitizeBinaryOutput`, used by
+ * `render-utils.js:getTextOutput`): TAB, LF and CR are excluded on purpose —
+ * the carriage return is a line break here, see {@link resultLines}.
+ */
+const BINARY_CONTROL = /[\x00-\x08\x0B\x0C\x0E-\x1F\uFFF9-\uFFFB]/g;
+
+export interface SpawnRenderOptions {
+	expanded: boolean;
+	isPartial: boolean;
+}
+
+function isSpawnMode(value: unknown): value is "rpc" | "inprocess" {
+	return typeof value === "string" && SPAWN_MODES.has(value);
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+/** One `name=mode` entry from a `spawns[]` array (launch-family details). */
+function entryFromSpawn(value: unknown): string | undefined {
+	const spawn = asRecord(value);
+	if (!spawn) return undefined;
+	const name = spawn.name;
+	const mode = spawn.spawnMode;
+	if (typeof name !== "string" || !name) return undefined;
+	// An unknown/absent mode is skipped, never printed as a guess: a legacy
+	// handle must render as "no fact", not as `rpc`.
+	if (!isSpawnMode(mode)) return undefined;
+	return `${name}=${mode}`;
+}
+
+/** One `name=mode` entry from a `handles[]` object (vexillatio details). */
+function entryFromHandle(value: unknown): string | undefined {
+	const handle = asRecord(value);
+	if (!handle) return undefined;
+	return entryFromSpawn(handle);
+}
+
+/**
+ * `spawn: scout-0=inprocess` or `spawn: worker-0=rpc, scout-1=inprocess`.
+ *
+ * Reads both documented detail shapes defensively:
+ * - launch family: `details.spawns[]` (`{ name, agent, spawnMode }`)
+ * - vexillatio:    `details.handles[]` (`{ name, agent, sessionFile, spawnMode? }`)
+ *
+ * One entry per child, first occurrence wins: a result that carries the same
+ * handle in both arrays must not print `w=rpc, w=rpc`.
+ *
+ * Returns `undefined` when nothing survives — no details, wrong shape, or every
+ * entry's mode unknown. Unknown modes are omitted rather than defaulted.
+ *
+ * Never throws: a `details` object with a throwing getter (or a Proxy) would
+ * otherwise take the whole card down, because the host swallows renderer
+ * exceptions and paints its fallback instead.
+ */
+export function spawnModeSummary(details: unknown): string | undefined {
+	try {
+		const record = asRecord(details);
+		if (!record) return undefined;
+		const entries: string[] = [];
+		const seen = new Set<string>();
+		const push = (entry: string | undefined): void => {
+			if (!entry || seen.has(entry)) return;
+			seen.add(entry);
+			entries.push(entry);
+		};
+		const spawns = record.spawns;
+		if (Array.isArray(spawns)) {
+			for (const spawn of spawns) push(entryFromSpawn(spawn));
+		}
+		// `handles` may be a `string[]` (launch-family) or an object array
+		// (vexillatio); string entries simply never match, so both shapes pass.
+		const handles = record.handles;
+		if (Array.isArray(handles)) {
+			for (const handle of handles) push(entryFromHandle(handle));
+		}
+		if (entries.length === 0) return undefined;
+		return `spawn: ${entries.join(", ")}`;
+	} catch {
+		// A hostile/throwing getter is not a rendering failure: no fact, no line.
+		return undefined;
+	}
+}
+
+/**
+ * The model-facing text of a result, normalized the way it will be painted.
+ *
+ * Line counting has to happen on the text that actually renders, so
+ * normalizing runs BEFORE the split: a carriage return is how a progress
+ * stream redraws one line, not 20 rows — but `Text` treats `\r` as a line
+ * break, so leaving it in lets 20 segments paint 20 rows and bypass
+ * {@link COLLAPSED_LINES} with no hint. `\r` therefore becomes `\n` (so all
+ * 20 segments stay readable instead of being concatenated into one blob) and
+ * binary control bytes are dropped, matching the host fallback's intent
+ * (`render-utils.js:40` sanitizes binary output and removes raw `\r`).
+ */
+function resultLines(result: AgentToolResult<unknown> | undefined): string[] {
+	const content = result?.content;
+	if (!Array.isArray(content)) return [];
+	const text = content
+		.flatMap((part) => {
+			if (asRecord(part)?.type !== "text") return [];
+			const value = asRecord(part)?.text;
+			return typeof value === "string" ? [value] : [];
+		})
+		.join("\n");
+	const normalized = stripTerminalSequences(text)
+		.replace(/\r\n/g, "\n")
+		.replace(/\r/g, "\n")
+		.replace(BINARY_CONTROL, "");
+	return normalized.split("\n");
+}
+
+/**
+ * Build the card: the spawn summary line (when known) followed by the result
+ * text, capped at {@link COLLAPSED_LINES} lines until `ctrl+o` expands it.
+ *
+ * Never throws by design; see the file comment.
+ */
+export function renderSpawnResult(
+	result: AgentToolResult<unknown>,
+	opts: SpawnRenderOptions,
+	_theme: Theme,
+) {
+	const lines: string[] = [];
+	// Double insurance: `spawnModeSummary` is already total, but this call site
+	// must not depend on the callee's implementation staying that way (the host
+	// silences a throw and drops the card). The `details` READ is inside the
+	// guard too — a Proxy can throw on the property access itself.
+	let summary: string | undefined;
+	try {
+		summary = spawnModeSummary(result?.details);
+	} catch {
+		summary = undefined;
+	}
+	if (summary) lines.push(summary);
+	lines.push(...resultLines(result));
+	// `opts` is host-supplied; optional-chained so a partial/absent options
+	// object degrades to the collapsed view instead of throwing.
+	if (opts?.expanded || lines.length <= COLLAPSED_LINES) {
+		return new Text(lines.join("\n"), 0, 0);
+	}
+	const hidden = lines.length - COLLAPSED_LINES;
+	const visible = lines.slice(0, COLLAPSED_LINES);
+	visible.push(`... (${hidden} more lines, ctrl+o to expand)`);
+	return new Text(visible.join("\n"), 0, 0);
+}

package/src/tui/live-overlay.ts

@@ -16,6 +16,7 @@ import {
 import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { LegionNode } from "../legion/nodes.ts";
+import type { SpawnMode } from "../shared/types.ts";
 import {
 	createChatItemFactory,
 	type ChatItem,
@@ -30,6 +31,11 @@ export interface LiveOverlayNode extends Pick<LegionNode, "id" | "name" | "role"
 	turns?: number;
 	sessionFile?: string | null;
 	worktreePath?: string | null;
+	/**
+	 * Arbitrated backend for this child (#209). Absent for legacy nodes and for
+	 * the root — the footer omits the segment rather than printing a default.
+	 */
+	spawnMode?: SpawnMode;
 }
 
 /** A normalized tree-bus or RPC event associated with one Legion node. */
@@ -748,6 +754,14 @@ function createSession(
 		const turnLabel = `turn ${turnNumber}${turnElapsed !== undefined ? ` (${turnElapsed})` : ""}`;
 		return [
 			safeText(node.role),
+			// #209/D5: only when the arbitrated backend is known. A legacy or
+			// tree-only node has no value — omit the segment, never print `rpc`.
+			//
+			// Placed before `model` on purpose: the band is clipped by `fitLine`
+			// to the modal inner width (78 cols at the default 24x80), and a real
+			// model id (e.g. `workbuddy/deepseek-v4.1-flash`) used to push the
+			// trailing segment into `spawn inpr...`. role + spawn survive now.
+			...(node.spawnMode ? [`spawn ${node.spawnMode}`] : []),
 			...(node.model ? [safeText(node.model)] : []),
 			turnLabel,
 			elapsed,

package/src/tui/status.ts

@@ -107,13 +107,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);

package/src/tui/tree-view.ts

@@ -11,6 +11,7 @@ import {
 } from "@earendil-works/pi-tui";
 import type { LegionEvent } from "../extension/event-bus.ts";
 import type { LegionNode, NodeStatus } from "../legion/nodes.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";
@@ -30,6 +31,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/railway.ts

@@ -156,8 +156,8 @@ export function formatRate(rate: number): string {
 
 
 /**
- * Wide-lane detail after the name: role, turn/lifetime clocks, and
- * last-activity age.
+ * Wide-lane detail after the name: role, turn/lifetime clocks, and — once it
+ * is at least a minute old — the last-activity age.
  *
  * The leading clock is "time since the last task started": it keeps ticking
  * through the quiet gap after a turn settles (the old behavior froze at that
@@ -170,34 +170,37 @@ export function formatRate(rate: number): string {
  * has a real start time and a real lifetime; show both.
  */
 export function formatRailLaneDetail(node: VizNode, now: number): string {
-	const parts: string[] = [node.role];
-	parts.push(formatAgentElapsed({
-		state: node.status,
-		startedAt: node.startedAt,
-		...(node.endedAt !== undefined ? { finishedAt: node.endedAt } : {}),
-		...(node.currentTurnStartedAt !== undefined ? { currentTurnStartedAt: node.currentTurnStartedAt } : {}),
-	}, now));
-	parts.push(formatActivityAgo(node.lastActivityAt, now));
-	return parts.join(" · ");
+	return laneDetailParts(node, now).join(" · ");
 }
 
-/** Lane detail candidates, richest first (role → clocks → ago). */
-export function laneDetailCandidates(node: VizNode, now: number): string[] {
+/**
+ * Lane detail fields, richest first: role, clocks, then last-activity age —
+ * the age is omitted entirely while it is under a minute, because a lane that
+ * just saw activity is already visibly live and `1s ago` was pure noise.
+ */
+function laneDetailParts(node: VizNode, now: number): string[] {
 	const ago = formatActivityAgo(node.lastActivityAt, now);
-	const clocks = formatAgentElapsed({
-		state: node.status,
-		startedAt: node.startedAt,
-		...(node.endedAt !== undefined ? { finishedAt: node.endedAt } : {}),
-		...(node.currentTurnStartedAt !== undefined ? { currentTurnStartedAt: node.currentTurnStartedAt } : {}),
-	}, now);
 	return [
-		`${node.role} · ${clocks} · ${ago}`,
-		`${clocks} · ${ago}`,
-		clocks,
-		ago,
+		node.role,
+		formatAgentElapsed({
+			state: node.status,
+			startedAt: node.startedAt,
+			...(node.endedAt !== undefined ? { finishedAt: node.endedAt } : {}),
+			...(node.currentTurnStartedAt !== undefined ? { currentTurnStartedAt: node.currentTurnStartedAt } : {}),
+		}, now),
+		...(ago ? [ago] : []),
 	];
 }
 
+/** Lane detail candidates, richest first (role → clocks → ago). */
+export function laneDetailCandidates(node: VizNode, now: number): string[] {
+	const parts = laneDetailParts(node, now);
+	// Drop fields from the left: the role goes first, the clocks are the last
+	// thing to give up. A fresh lane has no age field, so it ends at the clocks
+	// instead of paying for a `1s ago` suffix it never shows.
+	return parts.map((_, start) => parts.slice(start).join(" · "));
+}
+
 /**
  * Width of the lane-name column: as wide as the longest name, clamped to
  * `RAIL_NAME_MAX_COLS` and never below `RAIL_NAME_MIN_COLS`.
@@ -255,7 +258,7 @@ export function railColumnPlan(
 	if (portrait) {
 		const label = Math.max(...shown.map((n) => {
 			const ago = formatActivityAgo(n.lastActivityAt, now);
-			return Array.from(ago === "—" ? n.name : `${n.name} · ${ago}`).length;
+			return Array.from(ago === "" || ago === "—" ? n.name : `${n.name} · ${ago}`).length;
 		}));
 		return { nameW, grade: 0, needed: label + 2 + reserve };
 	}
@@ -423,7 +426,7 @@ export function renderRailway(input: RailInput): RailRender | undefined {
 		const avail = width - (nameX + 2) - overflow.length;
 		if (portrait) {
 			const ago = formatActivityAgo(node.lastActivityAt, now);
-			const label = ago === "—" ? node.name : `${node.name} · ${ago}`;
+			const label = ago === "" || ago === "—" ? node.name : `${node.name} · ${ago}`;
 			canvas.text(nameX + 2, y, ellipsize(label, avail), col, { bold: true });
 		} else {
 			// Paint with the same width the plan measured (clamped to what is