@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-subagents/test/unit/external-cli-runner.test.ts

@@ -1,10 +1,14 @@
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import { buildExternalCliPrompt, runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
+import { clearExternalCliPreflightCacheForTests } from "../../src/runs/shared/external-cli-preflight.ts";
+import { resolveExternalCliRunnerStatus } from "../../src/runs/shared/external-cli-contract.ts";
 import { SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV } from "../../src/runs/shared/extension-bindings.ts";
+import { writeNodeCommand } from "../support/node-command.ts";
 
 const tempDirs: string[] = [];
 function tempDir(): string {
@@ -13,6 +17,7 @@ function tempDir(): string {
 	return dir;
 }
 afterEach(() => {
+	clearExternalCliPreflightCacheForTests();
 	for (const dir of tempDirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
 });
 
@@ -54,6 +59,18 @@ describe("external CLI runner", () => {
 		assert.equal(fs.readFileSync(result.externalProcess.stdoutPath, "utf-8"), result.output);
 	});
 
+	it("keeps supervisor-shaped stdout inert when supervisor support is unsupported", async () => {
+		const dir = tempDir();
+		const spoofed = JSON.stringify({ type: "contact_supervisor", reason: "need_decision", message: "Approve this" });
+		const result = await runExternalCli({ command: process.execPath, args: ["-e", `process.stdout.write(${JSON.stringify(spoofed)})`], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 0 });
+		const runner = resolveExternalCliRunnerStatus({ command: process.execPath });
+
+		assert.equal(result.exitCode, 0);
+		assert.equal(result.output, spoofed);
+		assert.equal(runner.capabilities.supervisor, "unsupported");
+		assert.match(runner.unsupportedReasons.supervisor, /no trusted supervisor event transport/);
+	});
+
 	it("flushes both full logs before returning while retaining a bounded stdout tail", async () => {
 		const dir = tempDir();
 		const stdout = "x".repeat(2 * 1024 * 1024) + "STDOUT_TAIL";
@@ -68,6 +85,186 @@ describe("external CLI runner", () => {
 		assert.equal(fs.readFileSync(result.externalProcess.stderrPath, "utf-8"), stderr);
 	});
 
+	it("parses the complete bounded stream separately from bounded raw logs and display tails", async () => {
+		const dir = tempDir();
+		let terminal = "";
+		const result = await runExternalCli({
+			command: process.execPath,
+			args: ["-e", "process.stdout.write('x'.repeat(100000)+'\\nFINAL:trusted result\\n')"],
+			cwd: dir,
+			prompt: "x",
+			asyncDir: dir,
+			stepIndex: 8,
+			limits: { stdoutLogBytes: 32 },
+			parser: {
+				parseLine(line) { if (line.startsWith("FINAL:")) terminal = line.slice(6); return undefined; },
+				finish() { return terminal ? { state: "completed", output: terminal } : undefined; },
+			},
+		});
+		assert.equal(result.exitCode, 0);
+		assert.equal(result.output, "trusted result");
+		assert.equal(fs.statSync(result.externalProcess.stdoutPath).size, 32);
+		assert.equal(result.externalProcess.stdoutTruncated, true);
+		assert.equal(result.externalProcess.stdoutBytes, 100022);
+	});
+
+	it("allows parser and log limits to narrow but not widen code-owned bounds", () => {
+		const dir = tempDir();
+		assert.throws(() => runExternalCli({
+			command: process.execPath,
+			cwd: dir,
+			prompt: "x",
+			asyncDir: dir,
+			stepIndex: 20,
+			limits: { stdoutLogBytes: 9 * 1024 * 1024 },
+		}), /stdoutLogBytes may only narrow/);
+	});
+
+	it("fails closed on malformed, oversized, or missing parser terminal state", async () => {
+		const dir = tempDir();
+		const malformed = await runExternalCli({
+			command: process.execPath, args: ["-e", "process.stdout.write('bad\\n')"], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 9,
+			parser: { parseLine() { throw new Error("malformed event"); }, finish() { return undefined; } },
+		});
+		assert.equal(malformed.exitCode, 1);
+		assert.match(malformed.error ?? "", /malformed event/);
+
+		const oversized = await runExternalCli({
+			command: process.execPath, args: ["-e", "process.stdout.write('x'.repeat(128))"], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 10,
+			limits: { parserLineBytes: 64 },
+			parser: { parseLine() { return undefined; }, finish() { return { state: "completed" }; } },
+		});
+		assert.equal(oversized.exitCode, 1);
+		assert.match(oversized.error ?? "", /line exceeded/);
+
+		let settleTimer: NodeJS.Timeout | undefined;
+		try {
+			const unterminated = await Promise.race([
+				runExternalCli({
+					command: process.execPath,
+					args: ["-e", "process.stdout.write('x'.repeat(128));setInterval(()=>{},1000)"],
+					cwd: dir,
+					prompt: "x",
+					asyncDir: dir,
+					stepIndex: 16,
+					limits: { parserLineBytes: 64 },
+					parser: { parseLine() { return undefined; }, finish() { return { state: "completed" }; } },
+				}),
+				new Promise<never>((_, reject) => { settleTimer = setTimeout(() => reject(new Error("unterminated oversized line did not fail promptly")), 1_000); }),
+			]);
+			assert.equal(unterminated.exitCode, 1);
+			assert.match(unterminated.error ?? "", /line exceeded/);
+		} finally {
+			if (settleTimer) clearTimeout(settleTimer);
+		}
+
+		const missing = await runExternalCli({
+			command: process.execPath, args: ["-e", "process.stdout.write('event\\n')"], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 11,
+			parser: { parseLine() { return undefined; }, finish() { return undefined; } },
+		});
+		assert.equal(missing.exitCode, 1);
+		assert.match(missing.error ?? "", /did not produce a terminal state/);
+	});
+
+	it("coalesces parser progress and flushes the terminal update", async () => {
+		const dir = tempDir();
+		const updates: number[] = [];
+		let count = 0;
+		const result = await runExternalCli({
+			command: process.execPath, args: ["-e", "process.stdout.write(Array.from({length:20},(_,i)=>String(i)).join('\\n')+'\\n')"], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 12,
+			parser: {
+				parseLine() { count++; return { phase: "streaming", eventCount: count }; },
+				finish() { return { state: "completed", output: "done" }; },
+			},
+			onParserProgress: (progress) => updates.push(progress.eventCount),
+		});
+		assert.equal(result.exitCode, 0);
+		assert.deepEqual(updates, [20]);
+	});
+
+	it("passes only adapter-allowed environment keys", async () => {
+		const dir = tempDir();
+		const previousSecret = process.env.UNRELATED_SECRET;
+		const previousBinding = process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV];
+		process.env.UNRELATED_SECRET = "hidden";
+		process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV] = "hidden-binding";
+		try {
+			const result = await runExternalCli({
+				command: process.execPath,
+				args: ["-e", `process.stdout.write(JSON.stringify({allowed:process.env.ALLOWED_VALUE,secret:process.env.UNRELATED_SECRET,binding:process.env.${SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV}}))`],
+				cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 13,
+				environment: { allowlist: ["ALLOWED_VALUE", SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV], values: { ALLOWED_VALUE: "yes", [SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV]: "still-hidden" } },
+			});
+			assert.deepEqual(JSON.parse(result.output), { allowed: "yes" });
+		} finally {
+			if (previousSecret === undefined) delete process.env.UNRELATED_SECRET; else process.env.UNRELATED_SECRET = previousSecret;
+			if (previousBinding === undefined) delete process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV]; else process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV] = previousBinding;
+		}
+	});
+
+	it("caches launch preflight and invalidates it after a launch failure", async () => {
+		const dir = tempDir();
+		const countPath = path.join(dir, "count.log");
+		const failPath = path.join(dir, "fail-once");
+		const scriptPath = path.join(dir, "preflight-cli.cjs");
+		fs.writeFileSync(scriptPath, `
+const fs=require('fs'); fs.appendFileSync(${JSON.stringify(countPath)}, 'x');
+if(process.argv[2]==='--version'){console.log('v1');process.exit(0)}
+if(process.argv[2]==='--help'){console.log('safe-help');process.exit(0)}
+if(fs.existsSync(${JSON.stringify(failPath)})){fs.rmSync(${JSON.stringify(failPath)});console.error('launch failed');process.exit(2)}
+process.stdout.write('ok');`);
+		const preflight = { id: "test-one-shot", versionArgs: [scriptPath, "--version"], helpArgs: [scriptPath, "--help"], validate: (value: { version: string; help: string }) => { assert.equal(value.version, "v1"); assert.match(value.help, /safe-help/); } };
+		const run = (stepIndex: number) => runExternalCli({ command: process.execPath, args: [scriptPath], cwd: dir, prompt: "x", asyncDir: dir, stepIndex, preflight });
+		assert.equal((await run(14)).preflight?.cacheHit, false);
+		assert.equal((await run(15)).preflight?.cacheHit, true);
+		assert.equal(fs.readFileSync(countPath, "utf-8").length, 4);
+		fs.writeFileSync(failPath, "1");
+		assert.equal((await run(16)).exitCode, 2);
+		assert.equal((await run(17)).preflight?.cacheHit, false);
+		assert.equal(fs.readFileSync(countPath, "utf-8").length, 8);
+	});
+
+	it("bounds launch preflight probes", async () => {
+		const dir = tempDir();
+		const scriptPath = path.join(dir, "hanging-preflight-cli.cjs");
+		fs.writeFileSync(scriptPath, `
+if(process.argv[2]==='--version') setInterval(()=>{}, 1000);
+if(process.argv[2]==='--help'){console.log('safe-help');process.exit(0)}
+process.stdout.write('ok');`);
+
+		const timedOut = await runExternalCli({
+			command: process.execPath,
+			args: [scriptPath],
+			cwd: dir,
+			prompt: "x",
+			asyncDir: dir,
+			stepIndex: 21,
+			preflight: { id: "hanging", versionArgs: [scriptPath, "--version"], helpArgs: [scriptPath, "--help"], probeTimeoutMs: 25 },
+		});
+		assert.equal(timedOut.exitCode, 1);
+		assert.match(timedOut.error ?? "", /version preflight failed|ETIMEDOUT|timed out/i);
+
+		const widened = await runExternalCli({
+			command: process.execPath,
+			args: [scriptPath],
+			cwd: dir,
+			prompt: "x",
+			asyncDir: dir,
+			stepIndex: 22,
+			preflight: { id: "wide-timeout", versionArgs: [scriptPath, "--version"], helpArgs: [scriptPath, "--help"], probeTimeoutMs: 6_000 },
+		});
+		assert.equal(widened.exitCode, 1);
+		assert.match(widened.error ?? "", /probeTimeoutMs may only narrow/);
+	});
+
+	it("does not probe an external binary while resolving status metadata", () => {
+		const dir = tempDir();
+		const marker = path.join(dir, "probed");
+		const command = writeNodeCommand(dir, "cold-cli", `require('fs').writeFileSync(${JSON.stringify(marker)}, 'yes')`);
+		resolveExternalCliRunnerStatus({ command });
+		assert.equal(fs.existsSync(marker), false);
+	});
+
 	it("rejects when a log stream cannot be written", async () => {
 		const dir = tempDir();
 		fs.mkdirSync(path.join(dir, "external-2.stdout.log"));
@@ -90,6 +287,13 @@ describe("external CLI runner", () => {
 		const result = await runExternalCli({ command: path.join(dir, "does-not-exist"), cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 2 });
 		assert.equal(result.exitCode, 1);
 		assert.match(result.error ?? "", /ENOENT|not found/i);
+		const preflighted = await runExternalCli({
+			command: "missing-preflight-cli", cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 19,
+			preflight: { id: "missing", versionArgs: ["--version"], helpArgs: ["--help"] },
+			environment: { allowlist: ["PATH"] },
+		});
+		assert.equal(preflighted.exitCode, 1);
+		assert.match(preflighted.error ?? "", /binary 'missing-preflight-cli' was not found on PATH/);
 	});
 
 	it("terminates on timeout", async () => {
@@ -113,4 +317,23 @@ describe("external CLI runner", () => {
 		assert.equal(result.stopped, true);
 		assert.equal(result.error, "stopped for test");
 	});
+
+	it("terminates descendants in the owned process group on stop", { skip: process.platform === "win32" ? "POSIX process-group assertion" : undefined }, async () => {
+		const dir = tempDir();
+		const descendantPath = path.join(dir, "descendant.pid");
+		let stop: (() => void) | undefined;
+		const script = `const {spawn}=require('child_process');const fs=require('fs');const c=spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{stdio:'ignore'});fs.writeFileSync(${JSON.stringify(descendantPath)},String(c.pid));setInterval(()=>{},1000)`;
+		const pending = runExternalCli({ command: process.execPath, args: ["-e", script], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 18, registerStop: (handler) => { stop = handler; } });
+		const deadline = Date.now() + 2_000;
+		while (!fs.existsSync(descendantPath)) {
+			if (Date.now() > deadline) throw new Error("descendant did not start");
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+		const descendantPid = Number(fs.readFileSync(descendantPath, "utf-8"));
+		stop?.();
+		const result = await pending;
+		assert.equal(result.stopped, true);
+		const status = spawnSync("ps", ["-p", String(descendantPid), "-o", "stat="], { encoding: "utf-8" }).stdout.trim();
+		assert.ok(!status || status.startsWith("Z"), `descendant ${descendantPid} remained active (${status})`);
+	});
 });

package/dist/extensions/pi-subagents/test/unit/fast-mode-extension.test.ts

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { rewriteFastModeProviderRequest } from "../../src/runs/shared/fast-mode-extension.ts";
+
+describe("fast mode provider request", () => {
+	it("returns the rewritten provider payload without a wrapper", () => {
+		const payload = {
+			model: "gpt-5.6-luna",
+			input: [{ role: "user", content: "test" }],
+		};
+
+		assert.deepEqual(
+			rewriteFastModeProviderRequest({ type: "before_provider_request", payload }),
+			{
+				...payload,
+				service_tier: "priority",
+			},
+		);
+	});
+
+	it("preserves a non-object provider payload", () => {
+		assert.equal(
+			rewriteFastModeProviderRequest({ type: "before_provider_request", payload: "request" }),
+			"request",
+		);
+	});
+});

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

@@ -50,6 +50,7 @@ describe("below-editor subagent FleetView", () => {
 		assert.equal(formatFleetTokens(999), "↓ 999 tokens");
 		assert.equal(formatFleetTokens(13_100), "↓ 13.1k tokens");
 		assert.equal(formatFleetTokens(1_250_000), "↓ 1.3M tokens");
+		assert.equal(formatFleetTokens(484_000, 129_000), "↓ 129.0k window · 484.0k spent");
 	});
 
 	it("renders cached external jobs with an external marker and elapsed time", () => {
@@ -230,7 +231,7 @@ describe("below-editor subagent FleetView", () => {
 			mode: "single",
 			startedAt: 10,
 			updatedAt: 20,
-			totalTokens: { input: 40, output: 2, total: 42 },
+			totalTokens: { input: 40, output: 2, total: 42, window: 30, windowPeak: 35 },
 		});
 		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[] }) | undefined;
 		const ctx = {
@@ -250,7 +251,7 @@ describe("below-editor subagent FleetView", () => {
 			const lines = widgetFactory!({ requestRender() {} }, theme).render(50);
 			assert.equal(lines.length, 1);
 			assert.ok(lines[0]!.includes("1 active agent"));
-			assert.ok(lines[0]!.includes("↓ 42 tokens"));
+			assert.ok(lines[0]!.includes("↓ 30 window · 42 spent"));
 			assert.ok(visibleWidth(lines[0]!) <= 50);
 		} finally {
 			fleet.dispose();
@@ -699,6 +700,15 @@ describe("below-editor subagent FleetView", () => {
 			mode: "parallel",
 			startedAt: 10,
 			updatedAt: 30,
+			nestedChildren: [0, 1, 2].map((index) => ({
+				id: `nested-${index}`,
+				parentRunId: "parallel",
+				parentStepIndex: index,
+				depth: 1,
+				path: [{ runId: "parallel", stepIndex: index }],
+				state: "running" as const,
+				agent: `nested-${index}`,
+			})),
 			activeChildren: new Map([
 				[0, { index: 0, agent: "reviewer", description: "Review correctness", startedAt: 11, updatedAt: 21, tokens: 100 }],
 				[1, { index: 1, agent: "reviewer", description: "Review quality", startedAt: 12, updatedAt: 22, tokens: 200 }],
@@ -713,6 +723,7 @@ describe("below-editor subagent FleetView", () => {
 			"foreground-active:parallel:2",
 		]);
 		assert.deepEqual(entries.map((entry) => entry.description), ["Review correctness", "Review quality", "Review tests"]);
+		assert.deepEqual(entries.map((entry) => entry.nestedChildren?.map((child) => child.id)), [["nested-0"], ["nested-1"], ["nested-2"]]);
 		assert.deepEqual(collectFleetSnapshot(state).items.map((item) => item.key), entries.map((entry) => entry.key));
 	});
 
@@ -833,6 +844,128 @@ describe("below-editor subagent FleetView", () => {
 		}
 	});
 
+	it("attaches active async workflow children and removes matching shell rows", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-1", {
+			asyncId: "workflow-1",
+			asyncDir: "/tmp/workflow-1",
+			status: "running",
+			mode: "workflow",
+			startedAt: 10,
+			updatedAt: 20,
+			steps: [
+				{ agent: "reviewer", workflowKey: "review", runId: "child-review", status: "running" },
+				{ agent: "worker", workflowKey: "worker", runId: "child-worker", status: "running" },
+			],
+		});
+		state.asyncJobs.set("child-review", {
+			asyncId: "child-review",
+			asyncDir: "/tmp/child-review",
+			status: "running",
+			mode: "single",
+			parentWorkflowRunId: "workflow-1",
+			workflowKey: "review",
+			startedAt: 11,
+			updatedAt: 20,
+			steps: [{ agent: "reviewer", status: "running" }],
+		});
+
+		const entries = collectFleetStatusEntries(state);
+		const workflow = entries.find((entry) => entry.key === "async:workflow-1");
+		const child = entries.find((entry) => entry.key === "async:child-review:0");
+		assert.equal(child?.parentKey, "async:workflow-1");
+		assert.deepEqual(workflow?.workflowRows?.map((row) => row.name), ["worker (worker)"]);
+	});
+
+	it("preserves sibling shell rows when a materialized child has nested step identities", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-1", {
+			asyncId: "workflow-1",
+			asyncDir: "/tmp/workflow-1",
+			status: "running",
+			mode: "workflow",
+			startedAt: 10,
+			updatedAt: 20,
+			steps: [
+				{ agent: "reviewer", workflowKey: "a", status: "running" },
+				{ agent: "worker", workflowKey: "b", status: "running" },
+			],
+		});
+		state.asyncJobs.set("child-a", {
+			asyncId: "child-a",
+			asyncDir: "/tmp/child-a",
+			status: "running",
+			mode: "single",
+			parentWorkflowRunId: "workflow-1",
+			workflowKey: "a",
+			startedAt: 11,
+			updatedAt: 20,
+			steps: [{ agent: "nested", workflowKey: "b", status: "running" }],
+		});
+
+		const entries = collectFleetStatusEntries(state);
+		const workflow = entries.find((entry) => entry.key === "async:workflow-1");
+		const child = entries.find((entry) => entry.key === "async:child-a:0");
+		assert.equal(child?.parentKey, "async:workflow-1");
+		assert.deepEqual(workflow?.workflowRows?.map((row) => row.name), ["b (worker)"]);
+	});
+
+	it("keeps async workflow children top-level when the parent is missing or terminal", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("missing-child", {
+			asyncId: "missing-child",
+			asyncDir: "/tmp/missing-child",
+			status: "running",
+			mode: "single",
+			parentWorkflowRunId: "missing-parent",
+			workflowKey: "missing",
+			startedAt: 10,
+			updatedAt: 20,
+			steps: [{ agent: "reviewer", status: "running" }],
+		});
+		state.asyncJobs.set("terminal-child", {
+			asyncId: "terminal-child",
+			asyncDir: "/tmp/terminal-child",
+			status: "running",
+			mode: "single",
+			parentWorkflowRunId: "terminal-parent",
+			workflowKey: "terminal",
+			startedAt: 11,
+			updatedAt: 20,
+			steps: [{ agent: "worker", status: "running" }],
+		});
+		state.asyncJobs.set("terminal-parent", {
+			asyncId: "terminal-parent",
+			asyncDir: "/tmp/terminal-parent",
+			status: "complete",
+			mode: "workflow",
+			startedAt: 12,
+			updatedAt: 20,
+		});
+
+		const entries = collectFleetStatusEntries(state);
+		assert.deepEqual(entries.map((entry) => [entry.key, entry.parentKey]), [
+			["async:missing-child:0", undefined],
+			["async:terminal-child:0", undefined],
+		]);
+	});
+
+	it("keeps workflow shell rows when no materialized child is present", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-1", {
+			asyncId: "workflow-1",
+			asyncDir: "/tmp/workflow-1",
+			status: "running",
+			mode: "workflow",
+			startedAt: 10,
+			updatedAt: 20,
+			steps: [{ agent: "reviewer", workflowKey: "review", runId: "child-review", status: "running" }],
+		});
+
+		const workflow = collectFleetStatusEntries(state).find((entry) => entry.key === "async:workflow-1");
+		assert.deepEqual(workflow?.workflowRows?.map((row) => row.name), ["review (reviewer)"]);
+	});
+
 	it("renders bounded workflow progress rows under the workflow parent", () => {
 		const state = stateForTest();
 		const workflowJob = {
@@ -882,6 +1015,79 @@ describe("below-editor subagent FleetView", () => {
 		}
 	});
 
+	it("renders host CI and gate rows as typed workflow monitors", () => {
+		const state = stateForTest();
+		const workflowJob = {
+			asyncId: "workflow-host",
+			asyncDir: "/tmp/workflow-host",
+			sessionId: "session-current",
+			status: "running" as const,
+			mode: "workflow" as const,
+			startedAt: 10,
+			updatedAt: 20,
+			hostSteps: [
+				{
+					version: 1 as const,
+					kind: "host-step" as const,
+					monitorKind: "ci" as const,
+					id: "ci-check",
+					label: "CI checks",
+					provider: "github-ci",
+					state: "running" as const,
+					target: "PR #1614",
+					updatedAt: 20,
+				},
+				{
+					version: 1 as const,
+					kind: "host-step" as const,
+					monitorKind: "gate" as const,
+					id: "gate-check",
+					label: "Review gate",
+					provider: "greptile",
+					state: "done" as const,
+					verdict: "inconclusive" as const,
+					reasonCode: "stale-head",
+					freshness: { expectedRef: "old", observedRef: "new", stale: true },
+					reportPath: "/tmp/reports/gate.json",
+					updatedAt: 20,
+				},
+			],
+		};
+		state.asyncJobs.set(workflowJob.asyncId, workflowJob);
+		state.fleetJobs!.set(workflowJob.asyncId, workflowJob);
+
+		const workflow = collectFleetStatusEntries(state).find((entry) => entry.key === "async:workflow-host");
+		assert.deepEqual(workflow?.workflowRows?.map((row) => ({ kind: row.kind, state: row.state })), [
+			{ kind: "ci", state: "running" },
+			{ kind: "gate", state: "done" },
+		]);
+
+		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[] }) | undefined;
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(_key: string, content: typeof widgetFactory | undefined) { if (content) widgetFactory = content; },
+				onTerminalInput() { return () => {}; },
+				getEditorText() { return ""; },
+				requestRender() {},
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000, maxAgentRows: 8 });
+		try {
+			fleet.setContext(ctx);
+			const component = widgetFactory!({ requestRender() {}, focusedComponent: Object.create(Editor.prototype) as Editor }, theme);
+			assert.deepEqual(fleet.handleKey("\x1b[B"), { consume: true });
+			const lines = component.render(160).join("\n");
+			assert.match(lines, /ci: CI checks · running · .*provider:github-ci.*PR #1614/);
+			assert.match(lines, /gate: Review gate · inconclusive · .*provider:greptile.*stale.*out:gate.json/);
+			assert.doesNotMatch(lines, /agent: CI checks/);
+		} finally {
+			fleet.dispose();
+		}
+	});
+
 	it("renders recursive nested runs and steps within the existing row budget", () => {
 		const state = stateForTest();
 		state.asyncJobs.set("supervisor", {

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

@@ -363,7 +363,8 @@ describe("Fleet inspector structured transcript", () => {
 			assert.deepEqual(directLink.events, []);
 			assert.match(directLink.warning ?? "", /refused a symlink/);
 
-			const parentLink = readFleetTranscript(path.join(trustedRoot, "directory-link", path.basename(outsideTranscript)), { trustedRoots: [trustedRoot] });
+			const linkedPath = path.join(trustedRoot, "directory-link", path.basename(outsideTranscript));
+			const parentLink = readFleetTranscript(linkedPath, { trustedRoots: [trustedRoot], trustedFiles: [linkedPath], trustedFileRoot: trustedRoot });
 			assert.deepEqual(parentLink.events, []);
 			assert.match(parentLink.warning ?? "", /resolves outside trusted roots/);
 		} finally {
@@ -386,6 +387,33 @@ describe("Fleet inspector structured transcript", () => {
 		}
 	});
 
+	it("trusts only the recorded session file inside the Pi sessions base", () => {
+		const sessionsBase = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-recorded-session-"));
+		const outsideBase = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-recorded-outside-"));
+		try {
+			const projectDir = path.join(sessionsBase, "project");
+			fs.mkdirSync(projectDir);
+			const recorded = writeTranscript(projectDir, [{ recordType: "message", role: "assistant", text: "recorded child" }]);
+			const sibling = path.join(projectDir, "sibling.jsonl");
+			fs.copyFileSync(recorded, sibling);
+
+			const trusted = readFleetTranscript(recorded, { trustedRoots: [], trustedFiles: [recorded], trustedFileRoot: sessionsBase });
+			assert.equal(trusted.events.find((event) => event.kind === "assistant")?.text, "recorded child");
+
+			const refused = readFleetTranscript(sibling, { trustedRoots: [], trustedFiles: [recorded], trustedFileRoot: sessionsBase });
+			assert.deepEqual(refused.events, []);
+			assert.match(refused.warning ?? "", /outside trusted roots/);
+
+			const outside = writeTranscript(outsideBase, [{ recordType: "message", role: "assistant", text: "outside" }]);
+			const outsideRefused = readFleetTranscript(outside, { trustedRoots: [], trustedFiles: [outside], trustedFileRoot: sessionsBase });
+			assert.deepEqual(outsideRefused.events, []);
+			assert.match(outsideRefused.warning ?? "", /outside trusted roots/);
+		} finally {
+			fs.rmSync(sessionsBase, { recursive: true, force: true });
+			fs.rmSync(outsideBase, { recursive: true, force: true });
+		}
+	});
+
 	it("sanitizes read-boundary warnings before other Fleet views consume them", () => {
 		const trustedRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-warning-trusted-"));
 		const outsideRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-warning-outside-"));