pi-crew 0.11.0 → 0.11.2

package/src/ui/dashboard-panes/plan-pane.ts

@@ -17,22 +17,45 @@
 import { isPlanApprovalPending } from "../../runtime/plan-approval.ts";
 import { deriveItemProgress } from "../../state/stores/plan-store.ts";
 import type { PlanItemStatus, TeamTaskState } from "../../state/types.ts";
+import { ACTIVE, formatHint, statusIcon } from "../rail.ts";
+
+/**
+ * The ONE plan-approval hint line (keys are case-SENSITIVE per
+ * keybinding-map.ts:75 — `A` approves, `n` denies, `X` shows the revision
+ * diff). `exactKeys` keeps the printed letters truthful; mapping them through
+ * the default `keyToken` would advertise `N`, which is not bound.
+ */
+export const PLAN_APPROVAL_HINT = formatHint(
+	[
+		["A", "approve"],
+		["n", "deny"],
+	],
+	{ exactKeys: true },
+);
+
 import type { RunUiSnapshot } from "../snapshot-types.ts";
+import { PANE_THEME } from "./pane-theme.ts";
 
+/**
+ * Glyph vocabulary — RAIL (`src/ui/rail.ts`) owns it (design system §2.G).
+ * `statusIcon()` covers every state rail names; the four task states it cannot
+ * express — `◷` waiting, `⚠` attention, `⊘` cancelled, `·` skipped: rail
+ * collapses all four into `○` — stay pane-local ON PURPOSE.
+ */
 const ITEM_GLYPH: Record<PlanItemStatus, string> = {
-	pending: "○",
-	active: "▸",
-	done: "✓",
-	dropped: "✗",
+	pending: statusIcon("queued", PANE_THEME),
+	active: ACTIVE,
+	done: statusIcon("completed", PANE_THEME),
+	dropped: statusIcon("failed", PANE_THEME),
 };
 
 const TASK_GLYPH: Record<string, string> = {
-	queued: "○",
-	running: "▸",
+	queued: statusIcon("queued", PANE_THEME),
+	running: ACTIVE,
 	waiting: "◷",
 	needs_attention: "⚠",
-	completed: "✓",
-	failed: "✗",
+	completed: statusIcon("completed", PANE_THEME),
+	failed: statusIcon("failed", PANE_THEME),
 	cancelled: "⊘",
 	skipped: "·",
 };
@@ -42,8 +65,8 @@ function taskLine(task: TeamTaskState, indent: string): string {
 	// T3/R5 depth badge: grandchildren (depth 2+) surface explicitly so the
 	// tree shows delegation nesting without another pane.
 	const depth = typeof task.depth === "number" && task.depth > 1 ? ` d${task.depth}` : "";
-	const role = task.displayName ?? task.role;
-	return `${indent}${glyph} ${task.id}${depth} ${role} [${task.status}]`;
+	const role = task.displayName ?? task.role ?? "?";
+	return `${indent}${glyph} ${task.id ?? "?"}${depth} ${role} [${task.status}]`;
 }
 
 export interface PlanPaneOptions {
@@ -63,23 +86,25 @@ export function planRevisionDiff(snapshot: RunUiSnapshot): string[] {
 	if (!previous) {
 		return [`Plan diff: v${current.version} has no prior revision`];
 	}
-	const prevItems = new Map(previous.items.map((i) => [i.id, i]));
+	// Disk-sourced plan records are NOT schema-validated at read time — every
+	// array/field below is guarded (`?? []` / `?? "?"`).
+	const prevItems = new Map((previous.items ?? []).map((i) => [i.id, i]));
 	const lines = [`Plan diff: v${previous.version} → v${current.version}`];
-	for (const item of current.items) {
+	for (const item of current.items ?? []) {
 		const before = prevItems.get(item.id);
 		if (!before) {
-			lines.push(`  + ${item.id} ${item.title} [${item.status}]`);
+			lines.push(`  + ${item.id} ${item.title ?? "?"} [${item.status}]`);
 			continue;
 		}
-		if (before.status !== item.status || before.taskIds.length !== item.taskIds.length) {
-			lines.push(
-				`  ~ ${item.id} ${item.title} [${before.status}→${item.status} · ${before.taskIds.length}→${item.taskIds.length} tasks]`,
-			);
+		const beforeTasks = before.taskIds?.length ?? 0;
+		const currentTasks = item.taskIds?.length ?? 0;
+		if (before.status !== item.status || beforeTasks !== currentTasks) {
+			lines.push(`  ~ ${item.id} ${item.title ?? "?"} [${before.status}→${item.status} · ${beforeTasks}→${currentTasks} tasks]`);
 		}
 		prevItems.delete(item.id);
 	}
 	for (const dropped of prevItems.values()) {
-		lines.push(`  - ${dropped.id} ${dropped.title} (dropped in v${current.version})`);
+		lines.push(`  - ${dropped.id} ${dropped.title ?? "?"} (dropped in v${current.version})`);
 	}
 	return lines;
 }
@@ -97,40 +122,48 @@ export function renderPlanPane(snapshot: RunUiSnapshot, options: PlanPaneOptions
 	if (!current) return ["Plan pane: no plan records"];
 	const progress = deriveItemProgress(current, snapshot.tasks);
 	const tasksById = new Map(snapshot.tasks.map((t) => [t.id, t]));
-	const itemById = new Map(current.items.map((i) => [i.id, i]));
+	// Disk-sourced plan records are NOT schema-validated at read time.
+	const phases = current.phases ?? [];
+	const items = current.items ?? [];
+	const itemById = new Map(items.map((i) => [i.id, i]));
 
 	const pending = isPlanApprovalPending(snapshot.manifest);
-	const header = `Plan pane: ${current.title} @v${current.version} (${current.phases.length} phases · ${current.items.length} items)`;
-	const approval = pending ? ["⚠ plan approval pending — A approve · n deny"] : [];
+	const header = `Plan pane: ${current.title ?? "?"} @v${current.version} (${phases.length} phases · ${items.length} items)`;
+	// Hint join format is the rail one (` · `, close/deny last). NOT routed
+	// through `formatHint` (yet): its `keyToken` upper-cases a bare letter
+	// (`n` → `N`) and the locked pane test
+	// (test/unit/ui/plan-ui-slice.test.ts:159) asserts the lowercase spelling —
+	// see the E3 report / leader decision needed.
+	const approval = pending ? [`⚠ plan approval pending — ${PLAN_APPROVAL_HINT}`] : [];
 
 	const lines: string[] = [header, ...approval];
-	for (const phase of current.phases) {
+	for (const phase of phases) {
 		const glyph = ITEM_GLYPH[phase.status] ?? "?";
-		lines.push(`${glyph} ${phase.title}`);
-		for (const itemId of phase.itemIds) {
+		lines.push(`${glyph} ${phase.title ?? "?"}`);
+		for (const itemId of phase.itemIds ?? []) {
 			const item = itemById.get(itemId);
 			if (!item) continue;
 			const p = progress.get(itemId);
 			const counts = p ? ` ${p.done}/${p.total}${p.failed ? ` ✗${p.failed}` : ""}${p.running ? ` ▸${p.running}` : ""}` : "";
 			const droppedTag = item.status === "dropped" ? " ✗ dropped" : "";
-			lines.push(`  ${ITEM_GLYPH[item.status] ?? "?"} ${item.title}${counts}${droppedTag}`);
-			for (const taskId of item.taskIds) {
+			lines.push(`  ${ITEM_GLYPH[item.status] ?? "?"} ${item.title ?? "?"}${counts}${droppedTag}`);
+			for (const taskId of item.taskIds ?? []) {
 				const task = tasksById.get(taskId);
 				if (task) lines.push(taskLine(task, "    "));
 			}
 		}
 	}
 	// Items not linked to any phase (producer-free-format plans) — still visible.
-	const phased = new Set(current.phases.flatMap((p) => p.itemIds));
-	const orphans = current.items.filter((i) => !phased.has(i.id));
+	const phased = new Set(phases.flatMap((p) => p.itemIds ?? []));
+	const orphans = items.filter((i) => !phased.has(i.id));
 	if (orphans.length) {
 		lines.push("(unphased)");
 		for (const item of orphans) {
 			const p = progress.get(item.id);
 			const droppedTag = item.status === "dropped" ? " ✗ dropped" : "";
-			lines.push(`  ${ITEM_GLYPH[item.status] ?? "?"} ${item.title}${p ? ` ${p.done}/${p.total}` : ""}${droppedTag}`);
+			lines.push(`  ${ITEM_GLYPH[item.status] ?? "?"} ${item.title ?? "?"}${p ? ` ${p.done}/${p.total}` : ""}${droppedTag}`);
 		}
 	}
-	lines.push("X revision diff");
+	lines.push(formatHint([["X", "revision diff"]]));
 	return lines;
 }

package/src/ui/dashboard-panes/progress-pane.ts

@@ -2,6 +2,7 @@ import { computePhaseProgress, formatPhaseProgressLine } from "../../runtime/pha
 import { isPlanApprovalPending } from "../../runtime/plan-approval.ts";
 import { renderDwfPhaseLines } from "../dwf-phase-display.ts";
 import type { RunUiSnapshot } from "../snapshot-types.ts";
+import { PLAN_APPROVAL_HINT } from "./plan-pane.ts";
 
 export function renderProgressPane(snapshot: RunUiSnapshot | undefined): string[] {
 	if (!snapshot) return ["Progress pane: snapshot unavailable"];
@@ -17,7 +18,7 @@ export function renderProgressPane(snapshot: RunUiSnapshot | undefined): string[
 			? runProgress.phases.map((p) => {
 					const done = p.completed + p.failed;
 					const status = p.running > 0 ? "running" : p.queued > 0 ? "queued" : done >= p.total ? "done" : "waiting";
-					return `  Phase ${p.index + 1} ${p.phase}: ${p.percentage}% (${done}/${p.total}) [${status}]`;
+					return `  Phase ${p.index + 1} ${p.phase ?? "?"}: ${p.percentage}% (${done}/${p.total}) [${status}]`;
 				})
 			: [];
 	const phaseHeader = phaseLines.length > 0 ? [formatPhaseProgressLine(runProgress), ...phaseLines] : [];
@@ -27,7 +28,7 @@ export function renderProgressPane(snapshot: RunUiSnapshot | undefined): string[
 	// WP-3 (H4-subset): plan-approval gate banner. Mirrors the health-pane
 	// hint pattern — plain foreground text, no color codes (pane output is
 	// uncolored by design). One line while the run is parked on approval.
-	const planBanner = isPlanApprovalPending(snapshot.manifest) ? ["⚠ plan approval pending — A approve / n deny"] : [];
+	const planBanner = isPlanApprovalPending(snapshot.manifest) ? [`⚠ plan approval pending — ${PLAN_APPROVAL_HINT}`] : [];
 	return [
 		`Progress pane: ${progress.completed}/${progress.total} completed · running=${progress.running} queued=${progress.queued} failed=${progress.failed}`,
 		...planBanner,

package/src/ui/dashboard-panes/schedules-pane.ts

@@ -1,6 +1,9 @@
 import { humanizeSchedule, type ScheduledJob } from "../../runtime/scheduling/scheduler.ts";
 import { formatRelativeTime } from "../../utils/relative-time.ts";
 import { sanitizeLine, truncate } from "../../utils/visual.ts";
+import { formatCount } from "../format-helpers.ts";
+import { ACTIVE, CURSOR, formatHint, statusIcon } from "../rail.ts";
+import { PANE_THEME } from "./pane-theme.ts";
 
 /**
  * Schedules pane (tier A foundation) — pure string[] renderer following
@@ -32,6 +35,16 @@ export interface SchedulesPaneOptions {
 
 export const SCHEDULES_EMPTY_STATE = "No scheduled jobs — create via team tool action='schedule'";
 
+/** Pane-8 actions in the ONE rail hint format (`formatHint`: keys `label`
+ *  pairs joined by ` · `). Order preserved from the pre-migration hint. */
+const ACTION_HINTS: ReadonlyArray<readonly [string, string]> = [
+	["T", "toggle"],
+	["N", "run now"],
+	["V", "details"],
+	["X", "delete"],
+	["R", "refresh"],
+];
+
 /** P2-1 hint line (single source of truth — pane table, empty state, and the
  *  headless /schedules text block all render THIS text). Empty string when
  *  there is nothing to hint (callers render no line). Pure: no clock, no I/O;
@@ -61,7 +74,7 @@ export function renderSchedulesPane(jobs: ScheduledJob[], now: Date, opts: Sched
 	}
 	if (hint) lines.push(hint);
 	if (opts.foreground !== false) {
-		lines.push("Actions: T toggle · N run now · V details · X delete · R refresh");
+		lines.push(`Actions: ${formatHint(ACTION_HINTS)}`);
 	}
 	return lines;
 }
@@ -82,26 +95,32 @@ export function renderSchedulesTextBlock(jobs: ScheduledJob[], now: Date, opts:
 
 function renderJobLines(job: ScheduledJob, now: Date, opts: SchedulesPaneOptions, selected: boolean): string[] {
 	const glyph = job.enabled ? "●" : "○";
-	const name = truncate(sanitizeLine(job.name), opts.nameWidth ?? 28);
+	const name = truncate(sanitizeLine(job.name ?? "?"), opts.nameWidth ?? 28);
 	// The humanized schedule embeds the RAW job.schedule ("cron …"/"once at …")
 	// — same untrusted persisted field the details view sanitizes, so the
 	// main line gets the identical treatment (headless /schedules notify path
 	// applies NO downstream sanitization — security review F-1).
-	const schedule = sanitizeLine(humanizeSchedule({ kind: job.scheduleType, spec: job.schedule }));
+	const schedule = sanitizeLine(humanizeSchedule({ kind: job.scheduleType ?? "once", spec: job.schedule ?? "?" }));
 	const next = job.nextRun ? formatRelativeTime(now, new Date(job.nextRun)) : "—";
-	// Cursor marker (dashboard pane 8): `›` on the selected job, two spaces on
-	// the others — mirroring runLabel's `›`/space marker. Callers that pass NO
-	// selectedIndex (headless text block, foundation tests) get the marker-free
-	// legacy layout byte-for-byte.
-	const marker = opts.selectedIndex === undefined ? "" : selected ? "› " : "  ";
-	const main = `${marker}${glyph} ${name}  ${schedule} · ${next} · ${statusGlyph(job.lastStatus)} · ${job.runCount} runs`;
+	// Cursor marker (dashboard pane 8): the RAIL `CURSOR` glyph on the selected
+	// job, two spaces on the others — mirroring runLabel's marker. Callers that
+	// pass NO selectedIndex (headless text block, foundation tests) get the
+	// marker-free legacy layout byte-for-byte.
+	const marker = opts.selectedIndex === undefined ? "" : selected ? `${CURSOR} ` : "  ";
+	const main = `${marker}${glyph} ${name}  ${schedule} · ${next} · ${statusGlyph(job.lastStatus)} · ${formatCount(job.runCount ?? 0, "run")}`;
 	return [main, renderSubLine(job, now, opts)];
 }
 
+/**
+ * Last-run glyph from the shared RAIL vocabulary. `lastStatus` spells
+ * success/error while `statusSlot`/`statusIcon` key off completed/failed, so
+ * the two are translated instead of forked; "never ran" keeps the pane's own
+ * `·` (rail has no such slot and would render `○`, the disabled/none glyph).
+ */
 function statusGlyph(status: ScheduledJob["lastStatus"]): string {
-	if (status === "success") return "✓";
-	if (status === "error") return "✗";
-	if (status === "running") return "⟳";
+	if (status === "success") return statusIcon("completed", PANE_THEME);
+	if (status === "error") return statusIcon("failed", PANE_THEME);
+	if (status === "running") return statusIcon("running", PANE_THEME);
 	return "·";
 }
 
@@ -110,12 +129,13 @@ function renderSubLine(job: ScheduledJob, now: Date, opts: SchedulesPaneOptions)
 	// the dashboard emit pipeline sanitizes whole lines, but the headless
 	// /schedules text block goes to ui.notify verbatim, and subagentType/id
 	// from a crafted settings entry must not inject line breaks there.
-	const parts = [sanitizeLine(job.subagentType)];
+	// Persisted jobs are NOT schema-validated at read time, hence the `?? "?"`.
+	const parts = [sanitizeLine(job.subagentType ?? "?")];
 	parts.push(job.lastRun ? `last: ${formatRelativeTime(now, new Date(job.lastRun))}` : "last: never");
 	// Duration: rendered only when the job model carries one ("duration if
 	// available" in the approved design). ScheduledJob has no duration field
 	// today, so nothing is invented here — a future field slots in below.
-	if (opts.includeIds) parts.push(`id: ${sanitizeLine(job.id)}`);
+	if (opts.includeIds) parts.push(`id: ${sanitizeLine(job.id ?? "?")}`);
 	return `  ◦ ${parts.join(" · ")}`;
 }
 
@@ -124,14 +144,14 @@ function renderSubLine(job: ScheduledJob, now: Date, opts: SchedulesPaneOptions)
  *  carry free text — fall back to description, then name. */
 function scheduleGoalOf(job: ScheduledJob): string {
 	try {
-		const parsed = JSON.parse(job.prompt) as { goal?: unknown };
+		const parsed = JSON.parse(job.prompt ?? "") as { goal?: unknown };
 		if (parsed && typeof parsed === "object" && typeof parsed.goal === "string" && parsed.goal.length > 0) {
 			return parsed.goal;
 		}
 	} catch {
 		/* prompt is not JSON — fall through */
 	}
-	return job.description || job.name;
+	return job.description || job.name || "?";
 }
 
 /**
@@ -141,14 +161,17 @@ function scheduleGoalOf(job: ScheduledJob): string {
  * dashboard emit pipeline truncates/sanitizes per line.
  */
 export function renderScheduleDetails(job: ScheduledJob, now: Date): string[] {
-	const schedule = humanizeSchedule({ kind: job.scheduleType, spec: job.schedule });
+	// Persisted jobs are NOT schema-validated at read time (design system §2.G:
+	// "guard every optional field") — sanitize AFTER the `?? "?"` fallback so a
+	// missing field renders `?`, never `undefined`.
+	const schedule = humanizeSchedule({ kind: job.scheduleType ?? "once", spec: job.schedule ?? "?" });
 	const next = job.nextRun ? formatRelativeTime(now, new Date(job.nextRun)) : "—";
 	const last = job.lastRun ? formatRelativeTime(now, new Date(job.lastRun)) : "never";
 	return [
-		`▸ ${sanitizeLine(job.name)} — id ${sanitizeLine(job.id)}`,
+		`${ACTIVE} ${sanitizeLine(job.name ?? "?")} — id ${sanitizeLine(job.id ?? "?")}`,
 		`  goal: ${sanitizeLine(scheduleGoalOf(job))}`,
-		`  schedule: ${sanitizeLine(job.schedule)} (${sanitizeLine(job.scheduleType)}) · humanized: ${sanitizeLine(schedule)} · next: ${next}`,
-		`  agent: ${sanitizeLine(job.subagentType)} · runs: ${job.runCount} · last: ${last} · status: ${statusGlyph(job.lastStatus)}`,
-		`  spawned runs: ${job.spawnedRunIds?.length ? job.spawnedRunIds.map(sanitizeLine).join(", ") : "none"}`,
+		`  schedule: ${sanitizeLine(job.schedule ?? "?")} (${sanitizeLine(job.scheduleType ?? "?")}) · humanized: ${sanitizeLine(schedule)} · next: ${next}`,
+		`  agent: ${sanitizeLine(job.subagentType ?? "?")} · runs: ${job.runCount ?? 0} · last: ${last} · status: ${statusGlyph(job.lastStatus)}`,
+		`  spawned runs: ${job.spawnedRunIds?.length ? job.spawnedRunIds.map((runId) => sanitizeLine(String(runId ?? "?"))).join(", ") : "none"}`,
 	];
 }

package/src/ui/dashboard-panes/transcript-pane.ts

@@ -1,3 +1,4 @@
+import { formatHint } from "../rail.ts";
 import type { RunUiSnapshot } from "../snapshot-types.ts";
 
 /**
@@ -21,21 +22,26 @@ function modelAttemptLines(snapshot: RunUiSnapshot): string[] {
 		const attempts = (task.modelAttempts ?? [])
 			.map(
 				(attempt) =>
-					`${attempt.model} ${attempt.success ? "✓" : `✗${attempt.exitCode !== undefined ? `(${attempt.exitCode})` : ""}`}`,
+					`${attempt.model ?? "?"} ${attempt.success ? "✓" : `✗${attempt.exitCode !== undefined ? `(${attempt.exitCode})` : ""}`}`,
 			)
 			.join(" → ");
 		const resolved = task.modelRouting?.resolved ? ` · resolved ${task.modelRouting.resolved}` : "";
-		lines.push(`  ${task.id} (${task.role})${resolved}: ${attempts}`);
+		lines.push(`  ${task.id ?? "?"} (${task.role ?? "?"})${resolved}: ${attempts}`);
 	}
 	return lines;
 }
 
 export function renderTranscriptPane(snapshot: RunUiSnapshot | undefined): string[] {
 	if (!snapshot) return ["Output pane: snapshot unavailable"];
+	const lines = snapshot.recentOutputLines ?? [];
 	return [
-		`Output pane: ${snapshot.recentOutputLines.length} recent lines · press v for transcript viewer · o for raw output`,
+		// Hint format owned by rail.ts (`formatHint`): keys `label` joined by ` · `.
+		`Output pane: ${lines.length} recent lines · press ${formatHint([
+			["v", "for transcript viewer"],
+			["o", "for raw output"],
+		])}`,
 		...modelAttemptLines(snapshot),
-		...snapshot.recentOutputLines.slice(-12).map((line) => `⎿ ${line}`),
-		...(snapshot.recentOutputLines.length ? [] : ["No recent output"]),
+		...lines.slice(-12).map((line) => `⎿ ${line}`),
+		...(lines.length ? [] : ["No recent output"]),
 	];
 }

package/src/ui/dwf-phase-display.ts

@@ -30,11 +30,6 @@ export interface DwfPhaseState {
 	currentPhase: string | null;
 }
 
-export interface RenderDwfPhaseOptions {
-	/** When true, render ASCII fallback markers instead of Unicode glyphs. */
-	ascii?: boolean;
-}
-
 // ---------------------------------------------------------------------------
 // Markers
 // ---------------------------------------------------------------------------
@@ -44,19 +39,9 @@ const MARKER_RUNNING = "▶";
 const MARKER_COMPLETED = "✓";
 const MARKER_PENDING = "⏸";
 
-// ASCII fallbacks for terminals that mis-render the Unicode glyphs above.
-const MARKER_RUNNING_ASCII = "[>]";
-const MARKER_COMPLETED_ASCII = "[v]";
-const MARKER_PENDING_ASCII = "[ ]";
-
 const DWF_PHASE_HEADER = "  ── DWF Phases ──";
 
-function markerFor(status: DwfPhaseStatus, ascii: boolean): string {
-	if (ascii) {
-		if (status === "running") return MARKER_RUNNING_ASCII;
-		if (status === "completed") return MARKER_COMPLETED_ASCII;
-		return MARKER_PENDING_ASCII;
-	}
+function markerFor(status: DwfPhaseStatus): string {
 	if (status === "running") return MARKER_RUNNING;
 	if (status === "completed") return MARKER_COMPLETED;
 	return MARKER_PENDING;
@@ -136,16 +121,14 @@ export function extractDwfPhaseState(events: TeamEvent[]): DwfPhaseState | null
  *
  * - One line per phase: `  ▶ Phase: Scan`, `  ✓ Phase: Scan`, `  ⏸ Phase: Review`.
  * - A grouping header is emitted only when more than one phase is present.
- * - When `options.ascii` is true, ASCII fallback markers are used.
  *
  * Always returns a non-empty array (the caller guarantees a non-null state).
  */
-export function renderDwfPhaseLines(state: DwfPhaseState, options?: RenderDwfPhaseOptions): string[] {
-	const ascii = options?.ascii === true;
+export function renderDwfPhaseLines(state: DwfPhaseState): string[] {
 	const lines: string[] = [];
 	if (state.phases.length > 1) lines.push(DWF_PHASE_HEADER);
 	for (const entry of state.phases) {
-		lines.push(`  ${markerFor(entry.status, ascii)} Phase: ${entry.name}`);
+		lines.push(`  ${markerFor(entry.status)} Phase: ${entry.name}`);
 	}
 	return lines;
 }

package/src/ui/format-helpers.ts

@@ -29,3 +29,25 @@ export function truncLine(text: string, maxWidth: number): string {
 	// respects double-wide CJK + surrogate pairs, adds the '…' ellipsis).
 	return truncateToWidth(text, maxWidth);
 }
+
+/**
+ * `1 tool` / `3 tools` — count label with correct singular/plural.
+ *
+ * Live-run data surfaced `1 tools` in five different surfaces (tool card,
+ * dashboard agent rows, live-run sidebar, live conversation overlay): every
+ * call site hard-coded the plural. One helper, one rule.
+ */
+export function formatCount(count: number, singular: string, plural?: string): string {
+	return `${count} ${count === 1 ? singular : (plural ?? `${singular}s`)}`;
+}
+
+/**
+ * `team` / `team/workflow` — collapse the workflow half when it repeats the
+ * team. Live runs carry both (`fast-fix` + `fast-fix`) and every surface that
+ * printed them naively rendered `fast-fix/fast-fix` (sidebar, dashboard).
+ */
+export function teamWorkflowLabel(team: string | undefined, workflow: string | undefined): string {
+	const t = team && team.length > 0 ? team : "?";
+	const w = workflow && workflow.length > 0 ? workflow : undefined;
+	return !w || w === t ? t : `${t}/${w}`;
+}

package/src/ui/heartbeat-aggregator.ts

@@ -32,6 +32,32 @@ function isActiveTask(task: TeamTaskState): boolean {
 	return task.status === "running";
 }
 
+/**
+ * FINDING 5 (2026-09-23 battery): health ticks must count task statuses from
+ * DISK truth, not the (possibly lagging) snapshot cache. A worker parked on
+ * `ask` transitions running → waiting on disk while the cached snapshot can
+ * still show `running` — in that window the parked worker counted as
+ * active-without-heartbeat and fired a false "dead worker" notification (live:
+ * run team_20260923100114, 01_explore parked on ask, later answered+resumed).
+ *
+ * Overlay FRESH task statuses (and heartbeats) from disk onto the cached
+ * snapshot before summarizing. Returns the ORIGINAL snapshot object when
+ * nothing diverged (cheap identity check — callers use it to decide cache
+ * invalidation), or a shallow copy with the diverging tasks replaced.
+ */
+export function overlayFreshTaskStatuses(snapshot: RunUiSnapshot, freshTasks: TeamTaskState[]): RunUiSnapshot {
+	if (freshTasks.length === 0) return snapshot;
+	const freshById = new Map(freshTasks.map((task) => [task.id, task]));
+	let diverged = false;
+	const tasks = snapshot.tasks.map((task) => {
+		const fresh = freshById.get(task.id);
+		if (!fresh || (fresh.status === task.status && fresh.heartbeat === task.heartbeat)) return task;
+		diverged = true;
+		return { ...task, status: fresh.status, heartbeat: fresh.heartbeat };
+	});
+	return diverged ? { ...snapshot, tasks } : snapshot;
+}
+
 export function summarizeHeartbeats(snapshot: RunUiSnapshot, opts: HeartbeatSummaryOptions = {}): HeartbeatSummary {
 	const staleMs = opts.staleMs ?? 60_000;
 	const deadMs = opts.deadMs ?? 5 * 60_000;
@@ -55,6 +81,14 @@ export function summarizeHeartbeats(snapshot: RunUiSnapshot, opts: HeartbeatSumm
 	const runTerminal = isTerminalRunStatus(snapshot.manifest.status);
 	for (const task of snapshot.tasks) {
 		if (runTerminal || !isActiveTask(task)) continue;
+		// Guest-child tasks (delegate subagents, agent === "delegate") have no
+		// heartbeat channel — they never write task.heartbeat and complete in
+		// seconds; their lifecycle is owned by delegate.requested/admitted/
+		// completed broker events. Counting them here fired a false "N worker(s)
+		// missing heartbeat" ambient for every delegate-using run (live:
+		// team_20260926033657_2b6c6d2610b26d9d, 2026-09-26 battery — same
+		// gc-blindness root shape as the heartbeat-watcher fix).
+		if (task.agent === "delegate") continue;
 		const heartbeat = task.heartbeat;
 		if (!heartbeat) {
 			summary.missing += 1;

package/src/ui/inline-panel/crew-editor.ts

@@ -24,13 +24,23 @@
 import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import { type EditorTheme, matchesKey, type TUI, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-
+import { ACTIVE } from "../rail.ts";
 import type { PanelKeys, PanelTarget } from "./panel-selection.ts";
 import { dispatchPanelKey } from "./panel-selection.ts";
 import { getPanelSelection, getViewedAgent, panelRows, setPanelSelection } from "./panel-store.ts";
 
 export const AGENT_LABEL_MAX = 24;
 
+/**
+ * `name` as it paints in the editor border: whitespace collapsed to one line
+ * (the label is spliced INTO the editor's top border, so a newline would tear
+ * the frame) and the legacy `role->agent` separator normalized to the RAIL
+ * active marker (§4 consistency fix). The mechanism itself is untouched.
+ */
+export function agentBorderLabel(name: string): string {
+	return truncateToWidth(name.replace(/->/g, ACTIVE).replace(/\s+/g, " ").trim(), AGENT_LABEL_MAX);
+}
+
 export interface CrewEditorOptions {
 	/** Open the transcript pane on the given agent. */
 	onOpenPane: (target: PanelTarget) => void;
@@ -192,9 +202,9 @@ export class CrewInlineEditor extends CustomEditor {
 		if (!viewed) return lines;
 		const rows = panelRows();
 		const row = rows.find((r) => r.runId === viewed.runId && r.taskId === viewed.taskId);
-		const name = row?.name ?? viewed.taskId.slice(-AGENT_LABEL_MAX);
+		const name = agentBorderLabel(row?.name ?? viewed.taskId.slice(-AGENT_LABEL_MAX));
 		if (name && lines.length > 0) {
-			const label = ` @${truncateToWidth(name.replace(/\s+/g, " "), AGENT_LABEL_MAX)} `;
+			const label = ` @${name} `;
 			const labelWidth = visibleWidth(label);
 			if (visibleWidth(lines[0]) >= labelWidth + 4) {
 				lines[0] = truncateToWidth(lines[0], width - labelWidth - 2, "") + label + "──";

package/src/ui/inline-panel/index.ts

@@ -66,6 +66,42 @@ function stopPaneTicker(): void {
 	livePane = undefined;
 }
 
+/**
+ * Tear the live view down completely: close the overlay (which also detaches
+ * its pane), stop the repaint ticker, and null every module-level ref.
+ *
+ * Why this must run on a session swap (P1-10): the overlay factory and its
+ * `close`/`steer` callbacks close over the `ctx` they were opened with. If the
+ * overlay survived `session_start`, those closures would keep the OLD
+ * session's `ctx.cwd` and its dead `ctx.ui.custom.done` — view/steer would
+ * quietly target the previous workspace (`openPane`'s try/catch hides the
+ * throw instead of surfacing it). Nothing here touches the run: only the view
+ * and its repaint timer.
+ */
+function teardownLiveView(): void {
+	const overlay = liveOverlay;
+	if (overlay) {
+		// The overlay owns its own teardown (refs + viewed agent + host done()).
+		// A ctx that is already stale can throw out of done(): log, never rethrow.
+		try {
+			overlay.requestClose();
+		} catch (error) {
+			logInternalError("view.teardownOverlay", error);
+		}
+		// Belt and braces: requestClose only unmounts through the host. dispose()
+		// makes render()/handleInput() inert, so even a host that ignored done()
+		// cannot route another keystroke into the old session's ctx.
+		try {
+			overlay.dispose();
+		} catch {
+			/* already disposed by the host */
+		}
+	}
+	liveOverlay = undefined;
+	// Also clears `livePane`, so a ticker that somehow survived has no target.
+	stopPaneTicker();
+}
+
 async function runTeamTool(params: Record<string, unknown>, ctx: ExtensionContext): Promise<PiTeamsToolResult> {
 	// LAZY: team-tool.ts pulls in the entire runtime chain (same boundary as
 	// run-action-dispatcher.ts).
@@ -275,11 +311,13 @@ export function installInlinePanel(pi: ExtensionAPI, ctx: ExtensionContext, uiCo
 		pi.on("session_start", () => {
 			// pi may have replaced or dropped its editor between sessions; the
 			// "installed" flag is reset so the next install re-registers the
-			// factory. The open overlay outlives the session swap (it belongs
-			// to the interactive-mode UI, not the session's ctx) — keep it, but
-			// stop ticking until it is re-targeted.
+			// factory. The open overlay does NOT outlive the swap: its
+			// close/steer callbacks close over the previous session's ctx
+			// (cwd / ui.custom.done), so keeping it would make view and steer
+			// target the OLD workspace behind a try/catch. Close + dispose it
+			// and null the refs instead.
 			editorInstalled = false;
-			stopPaneTicker();
+			teardownLiveView();
 		});
 	}
 }
@@ -291,6 +329,24 @@ export function __resetInlinePanelForTest(): void {
 	stopPaneTicker();
 }
 
+/**
+ * Test seam: the live-view module state. Exposes the raw refs so a test can
+ * assert that a session swap left no `ctx`-holding closure behind, and whether
+ * the repaint ticker is still armed.
+ */
+export function __test__liveViewState(): {
+	liveOverlay: CrewAgentOverlay | undefined;
+	livePane: CrewAgentPane | undefined;
+	ticking: boolean;
+} {
+	return { liveOverlay, livePane, ticking: paneTickTimer !== undefined };
+}
+
+/** Test seam: run the session-swap teardown directly (same code the hook runs). */
+export function __test__teardownLiveView(): void {
+	teardownLiveView();
+}
+
 /** Test seam for openPane (the panel wires it as the dock's Enter action). */
 /** Test seam for closePane. */
 export { closePane as __test__closePane, openPane as __test__openPane };