@selesai/code 0.13.13 → 0.13.14

package/dist/extensions/pi-subagents/test/unit/fleet.test.ts

@@ -0,0 +1,1786 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { visibleWidth, type MarkdownTheme } from "@earendil-works/pi-tui";
+import { EXTERNAL_RUN_REGISTRY_KEY, EXTERNAL_RUN_REGISTRY_VERSION, registerExternalRun } from "../../src/api/external-runs.ts";
+import { collectFleetSnapshot, openSubagentFleet, SubagentFleetComponent } from "../../src/tui/fleet.ts";
+import { persistForegroundRunHistory, restoreForegroundRunHistory } from "../../src/runs/foreground/foreground-history.ts";
+import { FLEET_STATUS_WIDGET_KEY } from "../../src/tui/fleet-status.ts";
+import { registerLivePromptAudit, rewritePromptWithGuidance } from "../../src/runs/foreground/prompt-audit.ts";
+import { getArtifactPaths, getArtifactsDir, getProjectArtifactsDir } from "../../src/shared/artifacts.ts";
+import type { HerdrClient } from "../../src/inspectors/herdr/client.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+import { fauxAssistantMessage } from "@earendil-works/pi-ai/providers/faux";
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+
+function clearExternalRuns(): void {
+	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)];
+}
+
+function stateForTest(): SubagentState {
+	return {
+		baseCwd: process.cwd(),
+		currentSessionId: "session-current",
+		asyncJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+function writeAsyncRun(root: string, input: {
+	id: string;
+	sessionId?: string;
+	state?: "running" | "complete" | "failed";
+	mode?: "single" | "parallel" | "workflow";
+	lastUpdate?: number;
+	agents?: string[];
+	contexts?: Array<"fresh" | "fork">;
+	models?: string[];
+	thinking?: string[];
+	output?: string;
+	transcript?: Array<Record<string, unknown>>;
+}): string {
+	const asyncDir = path.join(root, input.id);
+	fs.mkdirSync(asyncDir, { recursive: true });
+	const agents = input.agents ?? ["worker"];
+	if (input.output !== undefined) fs.writeFileSync(path.join(asyncDir, "output-0.log"), input.output, "utf-8");
+	const transcriptPath = input.transcript ? path.join(asyncDir, "transcript-0.jsonl") : undefined;
+	if (transcriptPath && input.transcript) fs.writeFileSync(transcriptPath, `${input.transcript.map((record) => JSON.stringify(record)).join("\n")}\n`, "utf-8");
+	const state = input.state ?? "running";
+	fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+		runId: input.id,
+		sessionId: input.sessionId ?? "session-current",
+		mode: input.mode ?? (agents.length > 1 ? "parallel" : "single"),
+		state,
+		startedAt: 100,
+		lastUpdate: input.lastUpdate ?? 200,
+		currentStep: 0,
+		steps: agents.map((agent, index) => ({
+			agent,
+			...(input.contexts?.[index] ? { context: input.contexts[index] } : {}),
+			...(input.models?.[index] ? { model: input.models[index] } : {}),
+			...(input.thinking?.[index] ? { thinking: input.thinking[index] } : {}),
+			status: input.state === "complete" ? "complete" : input.state === "failed" ? "failed" : index === 0 ? "running" : "pending",
+			startedAt: 100,
+			...(index === 0 ? { sessionFile: path.join(asyncDir, `${agent}.jsonl`), ...(transcriptPath ? { transcriptPath } : {}) } : {}),
+		})),
+		...(input.output !== undefined ? { outputFile: "output-0.log" } : {}),
+	}, null, 2));
+	updateActiveRunIndex(asyncDir, state);
+	return asyncDir;
+}
+
+const theme = {
+	fg: (_name: string, text: string) => text,
+	bold: (text: string) => text,
+};
+
+const markdownTheme: MarkdownTheme = {
+	heading: (text) => text,
+	link: (text) => text,
+	linkUrl: (text) => text,
+	code: (text) => text,
+	codeBlock: (text) => text,
+	codeBlockBorder: (text) => text,
+	quote: (text) => text,
+	quoteBorder: (text) => text,
+	hr: (text) => text,
+	listBullet: (text) => text,
+	bold: (text) => text,
+	italic: (text) => text,
+	strikethrough: (text) => text,
+	underline: (text) => text,
+};
+
+describe("native subagent fleet", () => {
+	it("rewrites an authored prompt from guidance without persistence", async () => {
+		const calls: unknown[] = [];
+		const streamFn = (_model: never, context: unknown) => {
+			calls.push(context);
+			const stream = createAssistantMessageEventStream();
+			queueMicrotask(() => stream.push({ type: "done", reason: "stop", message: fauxAssistantMessage("Rewritten task", { stopReason: "stop" }) }));
+			return stream;
+		};
+		const model = { provider: "faux", id: "rewrite", api: "faux", input: ["text"], reasoning: false, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1000, maxTokens: 100 };
+		const ctx = {
+			model,
+			signal: undefined,
+			modelRegistry: {
+				async getApiKeyAndHeaders() { return { ok: true as const, apiKey: "test" }; },
+				getRegisteredProviderConfig() { return { api: "faux", streamSimple: streamFn }; },
+			},
+		} as never;
+		const rewritten = await rewritePromptWithGuidance({
+			ctx,
+			authoredTask: "Original task",
+			runtimeAdditions: "Runtime context",
+			finalEffectivePrompt: "Runtime context\n\nOriginal task",
+			guidance: "Make it narrower",
+		});
+		assert.equal(rewritten, "Rewritten task");
+		assert.match(JSON.stringify(calls), /Original task/);
+		assert.match(JSON.stringify(calls), /Make it narrower/);
+	});
+
+	it("collects current-session foreground and flattened async children", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-collect-"));
+		try {
+			writeAsyncRun(root, { id: "async-current", agents: ["worker", "reviewer"], output: "CURRENT OUTPUT" });
+			writeAsyncRun(root, { id: "async-other", sessionId: "session-other", output: "OTHER OUTPUT" });
+			const state = stateForTest();
+			state.foregroundControls.set("foreground-live", {
+				runId: "foreground-live",
+				mode: "chain",
+				startedAt: 10,
+				updatedAt: 30,
+				currentAgent: "scout",
+				currentIndex: 1,
+			});
+			state.foregroundRuns!.set("foreground-recent", {
+				runId: "foreground-recent",
+				mode: "single",
+				cwd: root,
+				sessionId: "session-current",
+				updatedAt: 20,
+				children: [{ agent: "planner", index: 0, status: "completed", finalOutput: "PLAN COMPLETE" }],
+			});
+			state.foregroundRuns!.set("foreground-other", {
+				runId: "foreground-other",
+				mode: "single",
+				cwd: root,
+				sessionId: "session-other",
+				updatedAt: 20,
+				children: [{ agent: "outsider", index: 0, status: "completed" }],
+			});
+
+			const snapshot = collectFleetSnapshot(state, { asyncDirRoot: root, resultsDir: path.join(root, "results") });
+			assert.deepEqual(snapshot.items.map((item) => item.key), [
+				"foreground-active:foreground-live:1",
+				"async:async-current:0",
+				"async:async-current:1",
+				"foreground-recent:foreground-recent:0",
+			]);
+			assert.equal(snapshot.error, undefined);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("shows cached external jobs as display-only without reading paths or invoking controls", async () => {
+		clearExternalRuns();
+		registerExternalRun({
+			id: "external-review",
+			sessionId: "session-current",
+			source: "interactive-shell",
+			label: "Dependency review",
+			state: "completed",
+			startedAt: 100,
+			updatedAt: 200,
+			currentAction: "Inspecting package metadata",
+			preview: "No dependency blockers found.",
+			reportPath: "/outside/trusted/roots/report.md",
+			transcriptPath: "/outside/trusted/roots/transcript.jsonl",
+		});
+		const state = stateForTest();
+		const snapshot = collectFleetSnapshot(state);
+		assert.equal(snapshot.error, undefined);
+		assert.deepEqual(snapshot.items.map((item) => ({ key: item.key, kind: item.kind, agent: item.agent })), [{
+			key: "external:external-review",
+			kind: "external",
+			agent: "Dependency review",
+		}]);
+		let steerCalls = 0;
+		let stopCalls = 0;
+		let inspectCalls = 0;
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 32, columns: 120 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{
+				refreshMs: 60_000,
+				markdownTheme,
+				actions: {
+					async steer() { steerCalls++; return { text: "unexpected" }; },
+					stop() { stopCalls++; return { text: "unexpected" }; },
+					async inspect() { inspectCalls++; return { text: "unexpected" }; },
+				},
+			},
+		);
+		try {
+			const initial = component.render(120).join("\n");
+			assert.match(initial, /Fleet inspector.*external display-only/);
+			assert.match(initial, /Source: external · display-only/);
+			assert.match(initial, /Owner: interactive-shell/);
+			assert.match(initial, /Inspecting package metadata/);
+			assert.match(initial, /Elapsed: 100ms/);
+			assert.match(initial, /No dependency blockers found/);
+			assert.match(initial, /Report path: \/outside\/trusted\/roots\/report\.md/);
+			assert.match(initial, /Transcript path: \/outside\/trusted\/roots\/transcript\.jsonl/);
+			assert.doesNotMatch(initial, /Herdr ·|steer ·|stop ·/);
+			component.handleInput("H");
+			assert.match(component.render(120).join("\n"), /display-only and have no Herdr controls/);
+			component.handleInput("s");
+			assert.match(component.render(120).join("\n"), /display-only and remain controlled/);
+			component.handleInput("D");
+			assert.match(component.render(120).join("\n"), /display-only and remain controlled/);
+			await new Promise((resolve) => setImmediate(resolve));
+			assert.deepEqual({ steerCalls, stopCalls, inspectCalls }, { steerCalls: 0, stopCalls: 0, inspectCalls: 0 });
+		} finally {
+			component.dispose();
+			clearExternalRuns();
+		}
+	});
+
+	it("keeps running external elapsed time live when endedAt is present", () => {
+		clearExternalRuns();
+		try {
+			const startedAt = Date.now() - 5_000;
+			registerExternalRun({
+				id: "external-running",
+				sessionId: "session-current",
+				source: "interactive-shell",
+				label: "Running external job",
+				state: "running",
+				startedAt,
+				updatedAt: startedAt + 100,
+				endedAt: startedAt + 100,
+			});
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 32, columns: 120 }, requestRender() {} } as never,
+				theme as never,
+				stateForTest(),
+				() => {},
+				{ refreshMs: 60_000, markdownTheme },
+			);
+			try {
+				const rendered = component.render(120).join("\n");
+				assert.match(rendered, /Elapsed: 5\.0s/);
+				assert.doesNotMatch(rendered, /Elapsed: 100ms/);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			clearExternalRuns();
+		}
+	});
+
+	it("ignores malformed cached external jobs while rendering Fleet", () => {
+		clearExternalRuns();
+		const warnings: string[] = [];
+		const originalWarn = console.warn;
+		console.warn = (message?: unknown) => warnings.push(String(message));
+		(globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)] = {
+			version: EXTERNAL_RUN_REGISTRY_VERSION,
+			runs: new Map<string, unknown>([[
+				"session-current\0bad",
+				{ id: "bad", sessionId: "session-current", source: "tool", label: "Bad external", state: "running", startedAt: Number.NaN },
+			]]),
+		};
+		const state = stateForTest();
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ refreshMs: 60_000, markdownTheme },
+		);
+		try {
+			const snapshot = collectFleetSnapshot(state);
+			assert.equal(snapshot.error, undefined);
+			assert.deepEqual(snapshot.items, []);
+			assert.match(warnings[0]!, /Removed Malformed cached external run/);
+			assert.match(component.render(100).join("\n"), /No current-session Fleet jobs/);
+		} finally {
+			console.warn = originalWarn;
+			component.dispose();
+			clearExternalRuns();
+		}
+	});
+
+	it("does not crash Fleet render when live prompt audit stores a non-string authored task", () => {
+		const state = stateForTest();
+		const control = {
+			runId: "bad-prompt-run",
+			sessionId: "session-current",
+			mode: "single" as const,
+			startedAt: 10,
+			updatedAt: 20,
+			activeChildren: new Map([[0, { index: 0, agent: "worker", startedAt: 10, updatedAt: 20 }]]),
+		};
+		state.foregroundControls.set(control.runId, control);
+		registerLivePromptAudit(control, 0, { nested: "task payload" } as unknown as string, "effective prompt");
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ refreshMs: 60_000, markdownTheme },
+		);
+		try {
+			assert.doesNotThrow(() => component.render(100));
+			const rendered = component.render(100).join("\n");
+			assert.doesNotMatch(rendered, /nested|task payload/);
+			component.handleInput("p");
+			assert.doesNotThrow(() => component.render(100));
+			assert.match(component.render(100).join("\n"), /Selected prompt unavailable/);
+		} finally {
+			component.dispose();
+		}
+	});
+
+	it("shows live prompt summaries and opens Prompt Audit with the authored prompt visible", async () => {
+		const sentinel = "PROMPT_AUDIT_SENTINEL_1021";
+		const secondSentinel = "PROMPT_AUDIT_SECOND_CHILD";
+		const state = stateForTest();
+		const control = {
+			runId: "prompt-run",
+			sessionId: "session-current",
+			mode: "parallel" as const,
+			startedAt: 10,
+			updatedAt: 20,
+			activeChildren: new Map([
+				[0, { index: 0, agent: "worker", startedAt: 10, updatedAt: 20 }],
+				[1, { index: 1, agent: "reviewer", startedAt: 11, updatedAt: 21 }],
+			]),
+		};
+		state.foregroundControls.set(control.runId, control);
+		registerLivePromptAudit(control, 0, sentinel, `[Read from: context.md]\n\n${sentinel}\n\n---\nRuntime acceptance`, { rerun: { params: { agent: "worker", task: sentinel } } });
+		registerLivePromptAudit(control, 1, secondSentinel, secondSentinel);
+		assert.doesNotMatch(JSON.stringify(control), new RegExp(sentinel), "live prompts must not enter serializable Fleet state");
+		const clipboardWrites: string[] = [];
+		const redoCalls: Array<{ runId: string; index: number; guidance: string }> = [];
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{
+				refreshMs: 60_000,
+				markdownTheme,
+				copyText: (text) => { clipboardWrites.push(text); },
+				actions: {
+					async steer() { return { text: "unused" }; },
+					stop() { return { text: "unused" }; },
+					async redoPrompt(input) {
+						redoCalls.push(input);
+						return { text: "Prompt redo started redo-run." };
+					},
+				},
+			},
+		);
+		try {
+			const initialRender = component.render(100).join("\n");
+			assert.match(initialRender, new RegExp(`Task: ${sentinel}`));
+			assert.match(initialRender, /Prompt audit: 2 live · 3 views · p opens/);
+			component.handleInput("p");
+			assert.doesNotMatch(component.render(100).join("\n"), /Prompt text hidden|Enter reveal|r hide/);
+			assert.match(component.render(100).join("\n"), new RegExp(sentinel));
+			component.handleInput("2");
+			assert.match(component.render(100).join("\n"), /Read from: context\.md/);
+			component.handleInput("3");
+			assert.match(component.render(100).join("\n"), /Runtime acceptance/);
+			component.handleInput("c");
+			await new Promise((resolve) => setImmediate(resolve));
+			assert.deepEqual(clipboardWrites, [`[Read from: context.md]\n\n${sentinel}\n\n---\nRuntime acceptance`]);
+			assert.match(component.render(100).join("\n"), /Copied visible prompt view/);
+			component.handleInput("g");
+			for (const char of "make narrower") component.handleInput(char);
+			component.handleInput("\r");
+			await new Promise((resolve) => setImmediate(resolve));
+			assert.deepEqual(redoCalls, [{ runId: "prompt-run", index: 0, guidance: "make narrower", control }]);
+			assert.match(component.render(100).join("\n"), /Prompt redo started redo-run/);
+			component.handleInput("j");
+			assert.match(component.render(100).join("\n"), /Selected: 2\/2/);
+			assert.match(component.render(100).join("\n"), /Agent: reviewer/);
+			assert.match(component.render(100).join("\n"), new RegExp(secondSentinel));
+			component.handleInput("k");
+			component.handleInput("1");
+			assert.match(component.render(100).join("\n"), /Selected: 1\/2/);
+			assert.match(component.render(100).join("\n"), /Agent: worker/);
+			assert.match(component.render(100).join("\n"), new RegExp(sentinel));
+			component.handleInput("\x1b");
+			assert.match(component.render(100).join("\n"), /Prompt audit: 2 live · 3 views · p opens/);
+		} finally {
+			component.dispose();
+		}
+	});
+
+	it("rejects Prompt Audit for a child owned by another session", () => {
+		const state = stateForTest();
+		const control = {
+			runId: "other-run",
+			sessionId: "session-other",
+			mode: "single" as const,
+			startedAt: 10,
+			updatedAt: 20,
+			activeChildren: new Map([[0, { index: 0, agent: "worker", startedAt: 10, updatedAt: 20 }]]),
+		};
+		state.foregroundControls.set(control.runId, control);
+		registerLivePromptAudit(control, 0, "SECRET", "SECRET");
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ refreshMs: 60_000, markdownTheme },
+		);
+		try {
+			component.handleInput("p");
+			const rendered = component.render(100).join("\n");
+			assert.match(rendered, /Prompt Audit is available only/);
+			assert.doesNotMatch(rendered, /SECRET/);
+		} finally {
+			component.dispose();
+		}
+	});
+
+	it("keeps tracked active workflows ahead of older failed terminal history", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-history-"));
+		try {
+			writeAsyncRun(root, { id: "older-failed", state: "failed", lastUpdate: 100 });
+			writeAsyncRun(root, { id: "newer-complete", state: "complete", lastUpdate: 300 });
+			const state = stateForTest();
+			state.fleetJobs = new Map([["active-workflow", {
+				asyncId: "active-workflow",
+				asyncDir: path.join(root, "active-workflow"),
+				sessionId: "session-current",
+				status: "running",
+				mode: "workflow",
+				agents: ["worker"],
+				startedAt: 100,
+				updatedAt: 200,
+			}]]);
+
+			const snapshot = collectFleetSnapshot(state, { asyncDirRoot: root, resultsDir: path.join(root, "results") });
+			assert.deepEqual(snapshot.items.map((item) => item.runId), ["active-workflow", "newer-complete", "older-failed"]);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("bounds Fleet history status-file reads", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-bounded-history-"));
+		try {
+			for (let index = 0; index < 100; index++) {
+				const asyncDir = writeAsyncRun(root, { id: `recent-${index}`, state: "complete", lastUpdate: index });
+				fs.utimesSync(path.join(asyncDir, "status.json"), 1_000 + index, 1_000 + index);
+			}
+			const oldDir = writeAsyncRun(root, { id: "old-invalid", state: "failed", lastUpdate: 0 });
+			fs.writeFileSync(path.join(oldDir, "status.json"), "{not-json", "utf8");
+			fs.utimesSync(path.join(oldDir, "status.json"), 1, 1);
+
+			const snapshot = collectFleetSnapshot(stateForTest(), { asyncDirRoot: root, resultsDir: path.join(root, "results") });
+			assert.equal(snapshot.error, undefined);
+			assert.equal(snapshot.items.length, 20);
+			assert.ok(!snapshot.items.some((item) => item.runId === "old-invalid"));
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("shows async model and thinking metadata in the structured header", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-model-thinking-"));
+		try {
+			writeAsyncRun(root, {
+				id: "model-thinking",
+				state: "running",
+				models: ["openai-codex/gpt-5.5"],
+				thinking: ["high"],
+			});
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 32, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				stateForTest(),
+				() => {},
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000, markdownTheme },
+			);
+			try {
+				assert.ok(component.render(100).some((line) => line.includes("gpt-5.5 · thinking high")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("shows a scripted workflow as one fleet parent instead of unrelated children", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-workflow-parent-"));
+		try {
+			const state = stateForTest();
+			const asyncDir = path.join(root, "workflow-1");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId: "workflow-1",
+				sessionId: "session-current",
+				mode: "workflow",
+				state: "running",
+				startedAt: 10,
+				lastUpdate: 20,
+				steps: [
+					{ agent: "scan", workflowKey: "scan", phase: "Plan", label: "Find seams", status: "completed", index: 0 },
+					{ agent: "review", workflowKey: "review", phase: "Review", status: "running", index: 1, currentTool: "grep" },
+				],
+			}, null, 2));
+			state.fleetJobs = new Map([["workflow-1", {
+				asyncId: "workflow-1",
+				asyncDir,
+				sessionId: "session-current",
+				status: "running",
+				mode: "workflow",
+				agents: ["scan", "review"],
+				steps: [
+					{ agent: "scan", workflowKey: "scan", status: "completed", index: 0 },
+					{ agent: "review", workflowKey: "review", status: "running", index: 1 },
+				],
+				workflow: { trace: [], emits: ["reviewing"], console: [] },
+				startedAt: 10,
+				updatedAt: 20,
+			}]]);
+
+			const snapshot = collectFleetSnapshot(state);
+			assert.deepEqual(snapshot.items.map((item) => item.key), ["async:workflow-1"]);
+			assert.equal(snapshot.items[0]?.agent, "workflow");
+
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{ initialKey: "async:workflow-1", refreshMs: 60_000 },
+			);
+			try {
+				const lines = component.render(120).join("\n");
+				assert.match(lines, /Workflow progress:/);
+				assert.match(lines, /Plan: scan · Find seams \(scan\) — completed/);
+				assert.match(lines, /Review: review \(review\) — running · tool grep/);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("shows selectable workflow children only when multiple are live", async () => {
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-1", {
+			asyncId: "workflow-1",
+			asyncDir: "/tmp/workflow-1",
+			sessionId: "session-current",
+			status: "running",
+			mode: "workflow",
+			startedAt: 10,
+			updatedAt: 20,
+		});
+		state.asyncJobs.set("unrelated", {
+			asyncId: "unrelated",
+			asyncDir: "/tmp/unrelated",
+			sessionId: "session-current",
+			status: "running",
+			mode: "single",
+			startedAt: 5,
+			updatedAt: 30,
+		});
+		state.foregroundControls.set("child-1", {
+			runId: "child-1",
+			parentWorkflowRunId: "workflow-1",
+			workflowKey: "review",
+			workflowSteeringDir: "/tmp/workflow-1/control/workflow-foreground/child-1",
+			sessionId: "session-current",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			activeChildren: new Map([[0, { index: 0, agent: "reviewer", startedAt: 10, updatedAt: 20 }]]),
+		});
+		assert.deepEqual(collectFleetSnapshot(state).items.map((item) => item.key), ["async:unrelated", "async:workflow-1"]);
+		state.foregroundControls.get("child-1")!.activeChildren!.set(1, { index: 1, agent: "writer", startedAt: 11, updatedAt: 21 });
+		assert.deepEqual(collectFleetSnapshot(state).items.map((item) => item.key), [
+			"foreground-active:child-1:0",
+			"foreground-active:child-1:1",
+			"async:unrelated",
+			"async:workflow-1",
+		]);
+		state.foregroundControls.get("child-1")!.activeChildren!.delete(1);
+		state.foregroundControls.set("child-2", {
+			runId: "child-2",
+			parentWorkflowRunId: "workflow-1",
+			workflowKey: "verify",
+			workflowSteeringDir: "/tmp/workflow-1/control/workflow-foreground/child-2",
+			sessionId: "session-current",
+			mode: "single",
+			startedAt: 11,
+			updatedAt: 21,
+			activeChildren: new Map([[0, { index: 0, agent: "verifier", startedAt: 11, updatedAt: 21 }]]),
+		});
+		const snapshot = collectFleetSnapshot(state);
+		assert.deepEqual(snapshot.items.map((item) => item.key), [
+			"foreground-active:child-2:0",
+			"foreground-active:child-1:0",
+			"async:unrelated",
+			"async:workflow-1",
+		]);
+		const steerCalls: Array<{ runId: string; asyncDir: string; index?: number; message: string; mode: string }> = [];
+		const inspectCalls: Array<{ runId: string; asyncDir: string; index?: number }> = [];
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{
+				initialKey: "foreground-active:child-1:0",
+				refreshMs: 60_000,
+				actions: {
+					async steer(input) { steerCalls.push(input); return { text: "Steering queued." }; },
+					stop() { return { text: "unused" }; },
+					async inspect(input) { inspectCalls.push(input); return { text: "Inspector opened." }; },
+				},
+			},
+		);
+		try {
+			assert.ok(component.render(100).some((line) => line.includes("workflow")));
+			component.handleInput("s");
+			for (const char of "check the failure") component.handleInput(char);
+			component.handleInput("\r");
+			await new Promise((resolve) => setImmediate(resolve));
+			assert.deepEqual(steerCalls, [{ runId: "child-1", asyncDir: "/tmp/workflow-1", index: 0, message: "check the failure", mode: "steer" }]);
+			component.handleInput("H");
+			await new Promise((resolve) => setImmediate(resolve));
+			assert.deepEqual(inspectCalls, [{ runId: "workflow-1", asyncDir: "/tmp/workflow-1" }]);
+		} finally {
+			component.dispose();
+		}
+	});
+
+	it("keeps every active async run ahead of the bounded recent-completion window", () => {
+		const state = stateForTest();
+		for (let index = 0; index < 22; index++) {
+			state.fleetJobs ??= new Map();
+			state.fleetJobs.set(`terminal-${index}`, {
+				asyncId: `terminal-${index}`,
+				asyncDir: path.join(os.tmpdir(), `missing-terminal-${index}`),
+				sessionId: "session-current",
+				status: "complete",
+				mode: "single",
+				agents: ["worker"],
+				startedAt: index,
+				updatedAt: index,
+			});
+		}
+		state.fleetJobs!.set("active-old", {
+			asyncId: "active-old",
+			asyncDir: path.join(os.tmpdir(), "missing-active-old"),
+			sessionId: "session-current",
+			status: "running",
+			mode: "single",
+			agents: ["scout"],
+			startedAt: 0,
+			updatedAt: 0,
+		});
+
+		const snapshot = collectFleetSnapshot(state);
+		assert.equal(snapshot.items.length, 21);
+		assert.equal(snapshot.items[0]?.runId, "active-old");
+		assert.equal(snapshot.items.find((item) => item.runId === "terminal-21")?.state, "complete");
+		assert.ok(!snapshot.items.some((item) => item.runId === "terminal-0"));
+	});
+
+	it("accepts default Fleet navigation from Kitty CSI-u input", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-kitty-default-"));
+		try {
+			writeAsyncRun(root, { id: "newer", lastUpdate: 300 });
+			writeAsyncRun(root, { id: "older", lastUpdate: 200 });
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				stateForTest(),
+				() => {},
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000 },
+			);
+			try {
+				const selectedLine = () => component.render(100).find((line) => line.includes("›")) ?? "";
+				assert.match(selectedLine(), /newer/);
+				component.handleInput("\x1b[106;1u");
+				assert.match(selectedLine(), /older/);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("uses custom Fleet keybindings without applying them inside modal text input", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-custom-keys-"));
+		try {
+			writeAsyncRun(root, { id: "newer", lastUpdate: 300 });
+			writeAsyncRun(root, { id: "older", lastUpdate: 200 });
+			const state = stateForTest();
+			let closed = false;
+			let inspectCalls = 0;
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => { closed = true; },
+				{
+					asyncDirRoot: root,
+					resultsDir: path.join(root, "results"),
+					refreshMs: 60_000,
+					fleetKeybindings: {
+						selectDown: ["return"],
+						selectUp: ["p"],
+						steer: ["m"],
+						close: ["z"],
+					},
+					actions: {
+						async steer() { return { text: "unused" }; },
+						stop() { return { text: "unused" }; },
+						async inspect() { inspectCalls++; return { text: "unexpected" }; },
+					},
+				},
+			);
+			try {
+				const selectedLine = () => component.render(100).find((line) => line.includes("›")) ?? "";
+				assert.match(selectedLine(), /newer/);
+				component.handleInput("j");
+				assert.match(selectedLine(), /newer/, "default j should not move when selectDown is overridden");
+				component.handleInput("\r");
+				assert.match(selectedLine(), /older/, "custom Enter binding should move instead of opening Herdr");
+				assert.equal(inspectCalls, 0);
+				component.handleInput("p");
+				assert.match(selectedLine(), /newer/);
+				component.handleInput("m");
+				component.handleInput("m");
+				assert.ok(component.render(100).some((line) => line.includes("Steer message (steer): m")));
+				component.handleInput("\x1b");
+				component.handleInput("z");
+				assert.equal(closed, true);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("restores current-session completed foreground history from the compact index", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-foreground-history-"));
+		try {
+			const resultsDir = path.join(root, "results");
+			const cwd = path.join(root, "project");
+			const artifactsRoot = getProjectArtifactsDir(cwd);
+			fs.mkdirSync(artifactsRoot, { recursive: true });
+			const outputPath = path.join(artifactsRoot, "outputs", "restored", "output.md");
+			fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+			fs.writeFileSync(outputPath, "restored foreground output", "utf-8");
+
+			const state = stateForTest();
+			state.artifactDirPreference = "project";
+			state.foregroundRuns!.set("restored", {
+				runId: "restored",
+				mode: "single",
+				cwd,
+				sessionId: "session-current",
+				updatedAt: 200,
+				children: [{ agent: "worker", index: 0, status: "completed", finalOutput: "do not persist this when an artifact exists", savedOutputPath: outputPath, resumeContract: { outputSchema: { type: "object" }, agentContract: { version: 1 }, acceptance: false, output: false, outputMode: "inline" }, extensionBindings: { "shepherd.dispatch/1": { role: "coder" } } }],
+			});
+			state.foregroundRuns!.set("other-session", {
+				runId: "other-session",
+				mode: "single",
+				cwd,
+				sessionId: "session-other",
+				updatedAt: 300,
+				children: [{ agent: "outsider", index: 0, status: "completed", savedOutputPath: outputPath }],
+			});
+			persistForegroundRunHistory(state, { resultsDir });
+			const historyFile = path.join(resultsDir, "foreground-history.json");
+			if (process.platform !== "win32") assert.equal(fs.statSync(historyFile).mode & 0o777, 0o600);
+
+			const restored = stateForTest();
+			restored.baseCwd = cwd;
+			restored.artifactDirPreference = "project";
+			assert.equal(restoreForegroundRunHistory(restored, { resultsDir }), 1);
+			assert.deepEqual(restored.foregroundRuns?.get("restored")?.children[0]?.resumeContract, { outputSchema: { type: "object" }, agentContract: { version: 1 }, acceptance: false, output: false, outputMode: "inline" });
+			assert.deepEqual(restored.foregroundRuns?.get("restored")?.children[0]?.extensionBindings, { "shepherd.dispatch/1": { role: "coder" } });
+			const snapshot = collectFleetSnapshot(restored);
+			assert.deepEqual(snapshot.items.map((item) => item.key), ["foreground-recent:restored:0"]);
+
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				restored,
+				() => {},
+				{ refreshMs: 60_000 },
+			);
+			try {
+				const lines = component.render(100);
+				assert.ok(lines.some((line) => line.includes("restored foreground output")));
+				assert.ok(!lines.some((line) => line.includes("do not persist")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not restore nonterminal foreground history rows", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-foreground-terminal-"));
+		try {
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(resultsDir, { recursive: true });
+			fs.writeFileSync(path.join(resultsDir, "foreground-history.json"), JSON.stringify({
+				version: 1,
+				runs: [
+					{
+						runId: "stale-running",
+						mode: "single",
+						cwd: root,
+						sessionId: "session-current",
+						updatedAt: 300,
+						children: [{ agent: "worker", index: 0, status: "running", currentTool: "bash" }],
+					},
+					{
+						runId: "terminal",
+						mode: "single",
+						cwd: root,
+						sessionId: "session-current",
+						updatedAt: 200,
+						children: [{ agent: "reviewer", index: 0, status: "completed", finalOutput: "done" }],
+					},
+				],
+			}, null, 2), "utf-8");
+
+			const restored = stateForTest();
+			restored.baseCwd = root;
+			assert.equal(restoreForegroundRunHistory(restored, { resultsDir }), 1);
+			assert.deepEqual([...restored.foregroundRuns!.keys()], ["terminal"]);
+			assert.deepEqual(collectFleetSnapshot(restored).items.map((item) => item.key), ["foreground-recent:terminal:0"]);
+
+			const state = stateForTest();
+			state.foregroundRuns!.set("stale-running", {
+				runId: "stale-running",
+				mode: "single",
+				cwd: root,
+				sessionId: "session-current",
+				updatedAt: 400,
+				children: [{ agent: "worker", index: 0, status: "running" as never }],
+			});
+			persistForegroundRunHistory(state, { resultsDir });
+			const persisted = JSON.parse(fs.readFileSync(path.join(resultsDir, "foreground-history.json"), "utf-8")) as { runs: Array<{ runId: string }> };
+			assert.deepEqual(persisted.runs.map((run) => run.runId), ["terminal"]);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not restore or persist oversized foreground resume contracts", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-foreground-contract-bound-"));
+		try {
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(resultsDir, { recursive: true });
+			const oversizedContract = { outputSchema: { type: "object", description: "x".repeat(65 * 1024) } };
+			fs.writeFileSync(path.join(resultsDir, "foreground-history.json"), JSON.stringify({
+				version: 1,
+				runs: [{
+					runId: "oversized",
+					mode: "single",
+					cwd: root,
+					sessionId: "session-current",
+					updatedAt: 200,
+					children: [{ agent: "worker", index: 0, status: "completed", resumeContract: oversizedContract }],
+				}],
+			}), "utf-8");
+
+			const restored = stateForTest();
+			assert.equal(restoreForegroundRunHistory(restored, { resultsDir }), 0);
+			assert.equal(restored.foregroundRuns?.has("oversized"), false);
+
+			const state = stateForTest();
+			state.foregroundRuns!.set("oversized", {
+				runId: "oversized",
+				mode: "single",
+				cwd: root,
+				sessionId: "session-current",
+				updatedAt: 200,
+				children: [{ agent: "worker", index: 0, status: "completed", resumeContract: oversizedContract }],
+			});
+			persistForegroundRunHistory(state, { resultsDir });
+			const persisted = JSON.parse(fs.readFileSync(path.join(resultsDir, "foreground-history.json"), "utf-8")) as { runs: Array<{ runId: string }> };
+			assert.deepEqual(persisted.runs, []);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps restored foreground rows when output artifacts are unavailable and bounds history", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-foreground-missing-"));
+		try {
+			const resultsDir = path.join(root, "results");
+			const cwd = path.join(root, "project");
+			const artifactsRoot = getProjectArtifactsDir(cwd);
+			const state = stateForTest();
+			state.artifactDirPreference = "project";
+			for (let index = 0; index < 3; index++) {
+				const outputPath = path.join(artifactsRoot, "outputs", `run-${index}`, "output.md");
+				fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+				fs.writeFileSync(outputPath, `output ${index}`, "utf-8");
+				state.foregroundRuns!.set(`run-${index}`, {
+					runId: `run-${index}`,
+					mode: "single",
+					cwd,
+					sessionId: "session-current",
+					updatedAt: index,
+					children: [{ agent: "worker", index: 0, status: "completed", savedOutputPath: outputPath }],
+				});
+			}
+			persistForegroundRunHistory(state, { resultsDir, limit: 2 });
+			fs.rmSync(path.join(artifactsRoot, "outputs", "run-2", "output.md"), { force: true });
+
+			const restored = stateForTest();
+			restored.baseCwd = cwd;
+			restored.artifactDirPreference = "project";
+			assert.equal(restoreForegroundRunHistory(restored, { resultsDir, limit: 2 }), 2);
+			assert.deepEqual([...restored.foregroundRuns!.keys()], ["run-2", "run-1"]);
+
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				restored,
+				() => {},
+				{ initialKey: "foreground-recent:run-2:0", refreshMs: 60_000 },
+			);
+			try {
+				assert.ok(component.render(100).some((line) => line.includes("output artifact unavailable")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("uses the full 85% terminal-height budget for the inspector", () => {
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 60, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			stateForTest(),
+			() => {},
+			{ refreshMs: 60_000 },
+		);
+		try {
+			assert.equal(component.render(100).length, 51);
+		} finally {
+			component.dispose();
+		}
+	});
+
+	it("renders selectable transcript detail and completed artifact paths within terminal width", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-render-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-finished", state: "complete", contexts: ["fork"], output: "FINAL ASYNC OUTPUT" });
+			const state = stateForTest();
+			let closed = false;
+			let renderRequests = 0;
+			const tui = { terminal: { rows: 32, columns: 100 }, requestRender: () => { renderRequests++; } };
+			const component = new SubagentFleetComponent(
+				tui as never,
+				theme as never,
+				state,
+				() => { closed = true; },
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000 },
+			);
+			try {
+				const lines = component.render(100);
+				assert.ok(lines.some((line) => line.includes("FINAL ASYNC OUTPUT")));
+				assert.ok(lines.some((line) => line.includes("output-0.log")));
+				assert.ok(lines.some((line) => line.includes("worker") && line.includes("[fork]")));
+				assert.ok(lines.some((line) => line.includes("worker.jsonl")));
+				for (const line of lines) assert.ok(visibleWidth(line) <= 100, `line exceeded width: ${line}`);
+				tui.terminal.rows = 10;
+				assert.ok(component.render(100).length <= 8, "short-terminal render should fit the overlay's 85% height cap");
+				component.handleInput("\x1b[6~");
+				component.handleInput("r");
+				assert.ok(renderRequests >= 2);
+				component.handleInput("\x1b");
+				assert.equal(closed, true);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("passes current-session trusted roots to async session transcript fallback", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-session-fallback-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-session-fallback" });
+			const sessionFile = path.join(asyncDir, "worker.jsonl");
+			fs.writeFileSync(sessionFile, `${JSON.stringify({ role: "assistant", content: "TRUSTED SESSION FALLBACK" })}\n`, "utf-8");
+			const state = stateForTest();
+			state.trustedSessionRoots = [asyncDir];
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 32, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000 },
+			);
+			try {
+				const rendered = component.render(100).join("\n");
+				assert.match(rendered, /TRUSTED SESSION FALLBACK/);
+				assert.doesNotMatch(rendered, /without a trusted root|Session read failed/);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("previews an exact runtime-recorded workflow session under the Pi sessions base", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-recorded-session-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-recorded-session" });
+			const sessionsBase = path.join(root, "sessions");
+			const projectDir = path.join(sessionsBase, "project");
+			fs.mkdirSync(projectDir, { recursive: true });
+			const sessionFile = path.join(projectDir, "workflow-child.jsonl");
+			fs.writeFileSync(sessionFile, `${JSON.stringify({ role: "assistant", content: "RECORDED WORKFLOW SESSION" })}\n`, "utf-8");
+			const statusPath = path.join(asyncDir, "status.json");
+			const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as { sessionFile?: string; steps?: Array<{ sessionFile?: string; transcriptPath?: string }> };
+			status.sessionFile = sessionFile;
+			status.steps![0]!.sessionFile = sessionFile;
+			delete status.steps![0]!.transcriptPath;
+			fs.writeFileSync(statusPath, JSON.stringify(status, null, 2), "utf-8");
+
+			const state = stateForTest();
+			state.trustedSessionRoots = [];
+			state.trustedSessionFileRoot = sessionsBase;
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 32, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000 },
+			);
+			try {
+				const rendered = component.render(100).join("\n");
+				assert.match(rendered, /RECORDED WORKFLOW SESSION/);
+				assert.doesNotMatch(rendered, /without a trusted root|Session read failed/);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("renders structured tool activity and assistant Markdown when a child transcript is available", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-structured-"));
+		try {
+			const longResponse = `## Finding\n\n${Array.from({ length: 40 }, (_, index) => `detail ${index}`).join("\n")}\n\n\`\`\`ts\nconst fleet = true;\n\`\`\``;
+			writeAsyncRun(root, {
+				id: "async-structured",
+				state: "complete",
+				output: "RAW FALLBACK SHOULD NOT RENDER",
+				transcript: [
+					{ recordType: "message", sourceEventType: "initial_prompt", role: "user", text: "injected task" },
+					{ recordType: "tool_start", toolName: "read", argsPreview: "src/tui/fleet.ts" },
+					{ recordType: "tool_end", toolName: "read" },
+					{ recordType: "message", role: "toolResult", text: "very large tool payload", message: { toolName: "read", isError: false } },
+					{ recordType: "message", role: "assistant", model: "test-model", text: longResponse },
+				],
+			});
+			const state = stateForTest();
+			state.baseCwd = root;
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 32, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000, markdownTheme },
+			);
+			try {
+				let lines = component.render(100);
+				assert.ok(lines.some((line) => line.includes("Conversation") && line.includes("assistant response")));
+				assert.ok(lines.some((line) => line.includes("const fleet = true;")));
+				assert.ok(!lines.some((line) => line.includes("very large tool payload")));
+				assert.ok(!lines.some((line) => line.includes("RAW FALLBACK SHOULD NOT RENDER")));
+				const bottomLines = lines;
+				const realDateNow = Date.now;
+				const laterNow = realDateNow() + 2_000;
+				Date.now = () => laterNow;
+				try {
+					component.handleInput("K");
+					lines = component.render(100);
+					assert.notDeepEqual(lines, bottomLines, "Shift+K should scroll the conversation up by one line");
+					component.handleInput("J");
+					lines = component.render(100);
+					assert.deepEqual(lines, bottomLines, "Shift+J should scroll the conversation back down by one line");
+				} finally {
+					Date.now = realDateNow;
+				}
+				for (let page = 0; page < 4; page++) component.handleInput("\x1b[5~");
+				lines = component.render(100);
+				assert.ok(lines.some((line) => line.includes("Conversation") && line.includes("assistant response")), "the conversation header should remain pinned while scrolling");
+				assert.ok(lines.some((line) => line.includes("✓ read") && line.includes("src/tui/fleet.ts")), "page up should reveal compact tool activity");
+				assert.ok(lines.some((line) => line.includes("Assistant") && line.includes("test-model")), "page up should reveal the rendered assistant message header");
+				for (const renderWidth of [60, 80, 100]) {
+					for (const line of component.render(renderWidth)) {
+						assert.ok(visibleWidth(line) <= renderWidth, `line exceeded ${renderWidth} columns: ${line}`);
+					}
+				}
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("uses parent-tracked async state and cwd without rescanning status", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-async-cwd-"));
+		try {
+			const asyncDir = path.join(root, "async-custom-cwd");
+			const customCwd = path.join(root, "custom-cwd");
+			const artifactsRoot = getProjectArtifactsDir(customCwd);
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.mkdirSync(artifactsRoot, { recursive: true });
+			const transcriptPath = path.join(artifactsRoot, "async-custom-cwd_worker_transcript.jsonl");
+			fs.writeFileSync(transcriptPath, `${JSON.stringify({ recordType: "message", role: "assistant", text: "Custom cwd async result" })}\n`, "utf-8");
+			fs.writeFileSync(path.join(asyncDir, "status.json"), "{in-flight status", "utf-8");
+			const state = stateForTest();
+			state.baseCwd = path.join(root, "parent-cwd");
+			state.artifactDirPreference = "project";
+			state.asyncJobs.set("async-custom-cwd", {
+				asyncId: "async-custom-cwd",
+				asyncDir,
+				cwd: customCwd,
+				sessionId: "session-current",
+				status: "running",
+				mode: "single",
+				startedAt: 100,
+				updatedAt: 200,
+				steps: [{ agent: "worker", index: 0, status: "running", transcriptPath }],
+			});
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{ refreshMs: 60_000, markdownTheme },
+			);
+			try {
+				assert.ok(component.render(100).some((line) => line.includes("Custom cwd async result")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("toggles bounded tool output expansion with x and Ctrl+O", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-tool-toggle-"));
+		try {
+			writeAsyncRun(root, {
+				id: "async-tools",
+				state: "complete",
+				transcript: [
+					{ recordType: "tool_start", toolCallId: "read-1", toolName: "read", argsPreview: "src/a.ts", argsPayload: JSON.stringify({ path: "src/a.ts" }), ts: 1 },
+					{ recordType: "tool_end", toolCallId: "read-1", toolName: "read", ts: 2 },
+					{ recordType: "message", role: "toolResult", toolCallId: "read-1", toolName: "read", text: "alpha\nbeta\ngamma", isError: false, ts: 3 },
+				],
+			});
+			const state = stateForTest();
+			state.baseCwd = root;
+			let renderRequests = 0;
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 32, columns: 100 }, requestRender() { renderRequests++; } } as never,
+				theme as never,
+				state,
+				() => {},
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000, markdownTheme },
+			);
+			try {
+				let lines = component.render(100);
+				assert.ok(lines.some((line) => line.includes("alpha beta gamma") && line.includes("x to expand")));
+				component.handleInput("x");
+				lines = component.render(100);
+				assert.ok(lines.some((line) => line.includes("alpha") && !line.includes("beta")));
+				assert.ok(lines.some((line) => line.includes("x to collapse")));
+				component.handleInput("\x0f");
+				lines = component.render(100);
+				assert.ok(lines.some((line) => line.includes("alpha beta gamma") && line.includes("x to expand")));
+				fs.appendFileSync(
+					path.join(root, "async-tools", "transcript-0.jsonl"),
+					`${JSON.stringify({ recordType: "message", role: "assistant", text: "Cache refreshed after append", ts: 4 })}\n`,
+					"utf-8",
+				);
+				lines = component.render(100);
+				assert.ok(lines.some((line) => line.includes("Cache refreshed after append")));
+				assert.equal(renderRequests, 2);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("renders the selected foreground parallel child's structured transcript", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-foreground-"));
+		try {
+			const state = stateForTest();
+			state.baseCwd = path.join(root, "parent-cwd");
+			state.artifactDirPreference = "project";
+			const effectiveCwd = path.join(root, "effective-cwd");
+			const now = Date.now();
+			state.foregroundControls.set("foreground-live", {
+				runId: "foreground-live",
+				mode: "parallel",
+				startedAt: now - 1_000,
+				updatedAt: now,
+				cwd: effectiveCwd,
+				currentAgent: "reviewer",
+				currentIndex: 1,
+				description: "Review the active task",
+				activeChildren: new Map([
+					[0, { index: 0, agent: "worker", description: "Implement the active task", startedAt: now - 900, updatedAt: now - 100, tokens: 120, model: "provider/live-model", thinking: "high" }],
+					[1, { index: 1, agent: "reviewer", description: "Review the active task", startedAt: now - 800, updatedAt: now, tokens: 240 }],
+				]),
+			});
+			const artifactsRoot = getProjectArtifactsDir(effectiveCwd);
+			fs.mkdirSync(artifactsRoot, { recursive: true });
+			const transcriptPath = getArtifactPaths(artifactsRoot, "foreground-live", "worker", 0).transcriptPath;
+			fs.writeFileSync(transcriptPath, `${JSON.stringify({ recordType: "message", role: "assistant", model: "test-model", text: "**Worker live result**" })}\n`, "utf-8");
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 90 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{ initialKey: "foreground-active:foreground-live:0", refreshMs: 60_000, markdownTheme },
+			);
+			try {
+				const lines = component.render(90);
+				assert.ok(lines.some((line) => line.includes("worker")));
+				assert.ok(lines.some((line) => line.includes("reviewer")));
+				assert.ok(lines.some((line) => line.includes("foreground · live")));
+				assert.ok(lines.some((line) => line.includes("live-model · thinking high")));
+				assert.ok(lines.every((line) => !line.includes("Implement the active task") && !line.includes("Review the active task")));
+				assert.ok(lines.some((line) => line.includes("Conversation") && line.includes("assistant response")));
+				assert.ok(lines.some((line) => line.includes("Worker live result")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("renders configured session and temp transcripts for active foreground, completed foreground, and async children", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-artifact-roots-"));
+		const createdTranscriptPaths: string[] = [];
+		try {
+			for (const preference of ["session", "temp"] as const) {
+				const baseCwd = path.join(root, `${preference}-cwd`);
+				const sessionFile = path.join(root, `${preference}-session`, "session.jsonl");
+				const artifactsRoot = getArtifactsDir(sessionFile, baseCwd, preference);
+				const prefix = `${path.basename(root)}-${preference}`;
+				fs.mkdirSync(artifactsRoot, { recursive: true });
+				const transcript = (runId: string, agent: string, index: number, text: string) => {
+					const transcriptPath = getArtifactPaths(artifactsRoot, runId, agent, index).transcriptPath;
+					fs.writeFileSync(transcriptPath, `${JSON.stringify({ recordType: "message", role: "assistant", text })}\n`, "utf-8");
+					createdTranscriptPaths.push(transcriptPath);
+					return transcriptPath;
+				};
+
+				const activeId = `${prefix}-active`;
+				const recentId = `${prefix}-recent`;
+				const asyncId = `${prefix}-async`;
+				transcript(activeId, "worker", 0, `${preference} active foreground transcript`);
+				const recentTranscript = transcript(recentId, "reviewer", 0, `${preference} completed foreground transcript`);
+				const asyncTranscript = transcript(asyncId, "scout", 0, `${preference} async transcript`);
+
+				const state = stateForTest();
+				state.baseCwd = baseCwd;
+				state.artifactDirPreference = preference;
+				state.parentSessionFile = sessionFile;
+				state.foregroundControls.set(activeId, {
+					runId: activeId,
+					mode: "single",
+					cwd: baseCwd,
+					startedAt: 100,
+					updatedAt: 300,
+					currentAgent: "worker",
+					currentIndex: 0,
+				});
+				state.foregroundRuns!.set(recentId, {
+					runId: recentId,
+					mode: "single",
+					cwd: baseCwd,
+					sessionId: "session-current",
+					updatedAt: 200,
+					children: [{ agent: "reviewer", index: 0, status: "completed", transcriptPath: recentTranscript, model: "provider/recent-model", thinking: "xhigh" }],
+				});
+				state.asyncJobs.set(asyncId, {
+					asyncId,
+					asyncDir: path.join(root, `${preference}-async-run`),
+					cwd: baseCwd,
+					sessionId: "session-current",
+					status: "complete",
+					mode: "single",
+					startedAt: 100,
+					updatedAt: 250,
+					steps: [{ agent: "scout", index: 0, status: "complete", transcriptPath: asyncTranscript }],
+				});
+
+				for (const [initialKey, expected] of [
+					[`foreground-active:${activeId}:0`, `${preference} active foreground transcript`],
+					[`foreground-recent:${recentId}:0`, `${preference} completed foreground transcript`],
+					[`async:${asyncId}:0`, `${preference} async transcript`],
+				] as const) {
+					const component = new SubagentFleetComponent(
+						{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+						theme as never,
+						state,
+						() => {},
+						{ initialKey, refreshMs: 60_000, markdownTheme },
+					);
+					try {
+						const lines = component.render(100);
+						assert.ok(lines.some((line) => line.includes(expected)), `missing ${expected}`);
+						if (initialKey.startsWith("foreground-recent:")) {
+							assert.ok(lines.some((line) => line.includes("recent-model · thinking xhigh")));
+						}
+					} finally {
+						component.dispose();
+					}
+				}
+			}
+		} finally {
+			for (const transcriptPath of createdTranscriptPaths) fs.rmSync(transcriptPath, { force: true });
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("shows disk-only current-session async runs when the overlay opens", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-overlay-reconcile-"));
+		try {
+			writeAsyncRun(root, { id: "disk-only", agents: ["worker"] });
+			const state = stateForTest();
+			let rendered = "";
+			const ctx = {
+				hasUI: true,
+				ui: {
+					setWidget() {},
+					async custom(factory: (tui: unknown, theme: unknown, keybindings: unknown, done: (result: undefined) => void) => SubagentFleetComponent) {
+						const component = factory({ terminal: { rows: 32 }, requestRender() {} }, theme, undefined, () => {});
+						try {
+							rendered = component.render(100).join("\n");
+						} finally {
+							component.dispose();
+						}
+					},
+				},
+			};
+
+			await openSubagentFleet(ctx as never, state, { asyncDirRoot: root, resultsDir: path.join(root, "results") });
+			assert.match(rendered, /worker/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("focuses the Herdr pane the operator opens with the inspect key", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-inspect-focus-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "run-focus", agents: ["worker"] });
+			const state = stateForTest();
+			state.asyncJobs.set("run-focus", {
+				asyncId: "run-focus",
+				asyncDir,
+				status: "running",
+				mode: "single",
+				agents: ["worker"],
+				startedAt: 100,
+				updatedAt: 200,
+			});
+			const calls: string[][] = [];
+			const herdrClient: HerdrClient = {
+				run: async <T>(args: string[]) => {
+					calls.push(args);
+					if (args[0] === "--version") return { ok: true, data: "herdr 0.7.5" as T };
+					if (args[0] === "pane" && args[1] === "split") return { ok: true, data: { pane: { pane_id: "w1:p9" } } as T };
+					return { ok: true, data: {} as T };
+				},
+			};
+			const ctx = {
+				hasUI: true,
+				ui: {
+					setWidget() {},
+					async custom(factory: (tui: unknown, theme: unknown, keybindings: unknown, done: (result: undefined) => void) => SubagentFleetComponent) {
+						const component = factory({ terminal: { rows: 32, columns: 100 }, requestRender() {} }, theme, undefined, () => {});
+						try {
+							component.render(100);
+							component.handleInput("H");
+							for (let attempt = 0; attempt < 500 && !calls.some((args) => args[0] === "pane" && args[1] === "split"); attempt++) {
+								await new Promise((resolve) => setImmediate(resolve));
+							}
+						} finally {
+							component.dispose();
+						}
+					},
+				},
+			};
+
+			await openSubagentFleet(ctx as never, state, { asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000, herdrClient });
+			const split = calls.find((args) => args[0] === "pane" && args[1] === "split");
+			assert.ok(split, `no pane split call: ${JSON.stringify(calls)}`);
+			assert.deepEqual(split.slice(-1), ["--focus"]);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("suppresses the status widget for the full inspector lifecycle", async () => {
+		const state = stateForTest();
+		let hidden = 0;
+		let observedOpen = false;
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(key: string, content: unknown) {
+					assert.equal(key, FLEET_STATUS_WIDGET_KEY);
+					assert.equal(content, undefined);
+					hidden++;
+				},
+				async custom() {
+					observedOpen = state.fleetInspectorOpen === true;
+					throw new Error("overlay closed");
+				},
+			},
+		};
+
+		await assert.rejects(openSubagentFleet(ctx as never, state), /overlay closed/);
+		assert.equal(hidden, 1);
+		assert.equal(observedOpen, true);
+		assert.equal(state.fleetInspectorOpen, false);
+	});
+
+	it("focuses the selected child and renders raw foreground model details", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			currentAgent: "worker",
+			currentIndex: 0,
+			model: "provider/raw-model",
+			thinking: "medium",
+		});
+		state.foregroundControls.set("run-reviewer", {
+			runId: "run-reviewer",
+			mode: "single",
+			startedAt: 11,
+			updatedAt: 21,
+			currentAgent: "reviewer",
+			currentIndex: 0,
+		});
+		state.foregroundRuns!.set("run-recent", {
+			runId: "run-recent",
+			mode: "single",
+			cwd: process.cwd(),
+			sessionId: "session-current",
+			updatedAt: 19,
+			children: [{ agent: "reviewer", index: 0, status: "completed", model: "provider/recent-raw-model", thinking: "xhigh" }],
+		});
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 90 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ initialKey: "foreground-active:run-worker:0", refreshMs: 60_000 },
+		);
+		try {
+			const lines = component.render(90);
+			const selectedLine = lines.find((line) => line.includes("›"));
+			assert.ok(selectedLine?.includes("run-work"), `unexpected selected row: ${selectedLine}`);
+			assert.ok(lines.some((line) => line.includes("Model: raw-model · thinking medium")));
+		} finally {
+			component.dispose();
+		}
+
+		const recentComponent = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 90 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ initialKey: "foreground-recent:run-recent:0", refreshMs: 60_000 },
+		);
+		try {
+			assert.ok(recentComponent.render(90).some((line) => line.includes("Model: recent-raw-model · thinking xhigh")));
+		} finally {
+			recentComponent.dispose();
+		}
+	});
+
+	it("steers the selected async child with an inline message", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-steer-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-steer", agents: ["worker", "reviewer"] });
+			const state = stateForTest();
+			const calls: Array<{ runId: string; asyncDir: string; index?: number; message: string; mode: string }> = [];
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{
+					asyncDirRoot: root,
+					resultsDir: path.join(root, "results"),
+					initialKey: "async:async-steer:0",
+					refreshMs: 60_000,
+					actions: {
+						async steer(input) {
+							calls.push(input);
+							return { text: "Steering queued." };
+						},
+						stop() {
+							return { text: "unused" };
+						},
+					},
+				},
+			);
+			try {
+				component.handleInput("s");
+				assert.ok(component.render(100).some((line) => line.includes("Steer message (steer):")));
+				component.handleInput("\t");
+				assert.ok(component.render(100).some((line) => line.includes("Steer message (follow_up):")));
+				for (const char of "please continue") component.handleInput(char);
+				component.handleInput("\r");
+				await new Promise((resolve) => setImmediate(resolve));
+				assert.deepEqual(calls, [{ runId: "async-steer", asyncDir, index: 0, message: "please continue", mode: "follow_up" }]);
+				assert.ok(component.render(100).some((line) => line.includes("Steering queued.")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("opens the selected async child in a Herdr inspector", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-herdr-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-herdr" });
+			const calls: Array<{ runId: string; asyncDir: string; index?: number }> = [];
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				stateForTest(),
+				() => {},
+				{
+					asyncDirRoot: root,
+					resultsDir: path.join(root, "results"),
+					refreshMs: 60_000,
+					actions: {
+						async steer() { return { text: "unused" }; },
+						stop() { return { text: "unused" }; },
+						async inspect(input) { calls.push(input); return { text: "Inspector opened." }; },
+					},
+				},
+			);
+			try {
+				component.handleInput("\r");
+				await new Promise((resolve) => setImmediate(resolve));
+				assert.deepEqual(calls, [{ runId: "async-herdr", asyncDir, index: 0 }]);
+				component.handleInput("H");
+				await new Promise((resolve) => setImmediate(resolve));
+				assert.deepEqual(calls, [
+					{ runId: "async-herdr", asyncDir, index: 0 },
+					{ runId: "async-herdr", asyncDir, index: 0 },
+				]);
+				assert.ok(component.render(100).some((line) => line.includes("Inspector opened.")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("confirms stop for the selected async child before calling the action", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-stop-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-stop" });
+			const state = stateForTest();
+			const calls: Array<{ runId: string; asyncDir: string; index?: number }> = [];
+			let inspectCalls = 0;
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{
+					asyncDirRoot: root,
+					resultsDir: path.join(root, "results"),
+					refreshMs: 60_000,
+					fleetKeybindings: { stop: ["return"] },
+					actions: {
+						async steer() {
+							return { text: "unused" };
+						},
+						stop(input) {
+							calls.push(input);
+							return { text: "Stop requested." };
+						},
+						async inspect() { inspectCalls++; return { text: "unexpected" }; },
+					},
+				},
+			);
+			try {
+				component.handleInput("\r");
+				assert.ok(component.render(100).some((line) => line.includes("Confirm stop for async run async-stop")));
+				assert.equal(inspectCalls, 0);
+				component.handleInput("n");
+				assert.deepEqual(calls, []);
+				component.handleInput("\r");
+				component.handleInput("y");
+				await new Promise((resolve) => setImmediate(resolve));
+				assert.deepEqual(calls, [{ runId: "async-stop", asyncDir, index: 0 }]);
+				assert.ok(component.render(100).some((line) => line.includes("Stop requested.")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("explains unavailable controls for completed async children", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-unavailable-"));
+		try {
+			writeAsyncRun(root, { id: "async-complete", state: "complete" });
+			const state = stateForTest();
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{
+					asyncDirRoot: root,
+					resultsDir: path.join(root, "results"),
+					refreshMs: 60_000,
+					actions: {
+						async steer() {
+							return { text: "unused" };
+						},
+						stop() {
+							return { text: "unused" };
+						},
+					},
+				},
+			);
+			try {
+				component.handleInput("s");
+				assert.ok(component.render(100).some((line) => line.includes("Selected child is complete")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("periodically redraws only while the overlay remains open", (t) => {
+		t.mock.timers.enable({ apis: ["setTimeout"] });
+		const state = stateForTest();
+		let renderRequests = 0;
+		let closed = false;
+		const tui = { terminal: { rows: 28, columns: 90 }, requestRender: () => { renderRequests++; } };
+		const component = new SubagentFleetComponent(
+			tui as never,
+			theme as never,
+			state,
+			() => { closed = true; },
+			{ refreshMs: 10 },
+		);
+		t.mock.timers.tick(249);
+		assert.equal(renderRequests, 0, "refresh cadence is bounded away from a hot loop");
+		t.mock.timers.tick(1);
+		assert.equal(renderRequests, 1);
+		component.handleInput("\x1b");
+		assert.equal(closed, true);
+		t.mock.timers.tick(1_000);
+		assert.equal(renderRequests, 1, "closing cancels periodic redraws");
+
+		const disposed = new SubagentFleetComponent(
+			tui as never,
+			theme as never,
+			state,
+			() => {},
+			{ refreshMs: 250 },
+		);
+		disposed.dispose();
+		t.mock.timers.tick(1_000);
+		assert.equal(renderRequests, 1, "disposing cancels periodic redraws");
+	});
+
+	it("refreshes the roster while the overlay remains open", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-refresh-"));
+		try {
+			const state = stateForTest();
+			let renderRequests = 0;
+			const tui = { terminal: { rows: 28, columns: 90 }, requestRender: () => { renderRequests++; } };
+			const component = new SubagentFleetComponent(
+				tui as never,
+				theme as never,
+				state,
+				() => {},
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 250 },
+			);
+			let invalidations = 0;
+			const originalInvalidate = component.invalidate.bind(component);
+			component.invalidate = () => {
+				invalidations++;
+				originalInvalidate();
+			};
+			try {
+				assert.ok(component.render(90).some((line) => line.includes("No tracked children")));
+				const initialOutput = Array.from({ length: 40 }, (_, index) => `output line ${index}`).join("\n");
+				const asyncDir = writeAsyncRun(root, { id: "appeared-live", output: initialOutput });
+				await new Promise((resolve) => setTimeout(resolve, 275));
+				let lines = component.render(90);
+				assert.ok(lines.some((line) => line.includes("appeared")));
+				assert.ok(lines.some((line) => line.includes("output line 39")));
+				fs.appendFileSync(path.join(asyncDir, "output-0.log"), "\nLATEST LIVE OUTPUT", "utf-8");
+				await new Promise((resolve) => setTimeout(resolve, 35));
+				lines = component.render(90);
+				assert.ok(lines.some((line) => line.includes("LATEST LIVE OUTPUT")), "live transcript should keep following new output");
+				assert.ok(renderRequests > 0);
+				assert.ok(invalidations > 0, "live refresh must invalidate cached TUI frames before rendering");
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});