@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-subagents/test/unit/render-helpers.test.ts

@@ -111,6 +111,16 @@ test("widget render keys keep compact payloads quiet and expanded payloads fresh
 	const nestedVisibleChange = structuredClone(job);
 	nestedVisibleChange.nestedChildren = [{ id: "nested-1", parentRunId: "workflow-1", depth: 1, path: [{ runId: "workflow-1" }], state: "failed", agent: "nested", error: "failed" }];
 	assert.notEqual(widgetRenderKey(nestedVisibleChange), widgetRenderKey(job));
+
+	const preflightJob: AsyncJobState = {
+		...job,
+		preflight: { version: 1, coverage: "complete", lanes: [{ key: "writer", decision: "Implement change" }] },
+		workflow: { trace: [], emits: [], console: [], preflightWarnings: ["first mismatch"] },
+	};
+	const warningDetailChange = structuredClone(preflightJob);
+	warningDetailChange.workflow!.preflightWarnings = ["different mismatch"];
+	assert.equal(widgetRenderKey(warningDetailChange), widgetRenderKey(preflightJob));
+	assert.notEqual(widgetRenderKey(warningDetailChange, true), widgetRenderKey(preflightJob, true));
 });
 
 test("multiline rendering omits two-column graphemes at one-column width", () => {
@@ -146,6 +156,8 @@ test("running single-subagent cards show the configured detach shortcut", () =>
 		undefined,
 		"ctrl+b",
 	));
+	assert.match(configured, /task: reviewer task/);
+	assert.match(configured, /Ctrl\+Alt\+F Fleet/);
 	assert.match(configured, /Ctrl\+B to run in background/);
 
 	const unconfigured = componentText(renderSubagentResult(toolResult as never, { expanded: false }, theme as any));
@@ -172,6 +184,33 @@ test("running single-subagent cards show the configured detach shortcut", () =>
 	assert.doesNotMatch(pendingBackground, /run in background/);
 });
 
+test("compact multi-result cards prefer bounded workflow labels over raw tasks", () => {
+	const longLabel = `Review auth flow\n${"x".repeat(140)}`;
+	const running = {
+		...result("reviewer", ""),
+		task: "raw task that should not win",
+		progress: { status: "running", index: 0, agent: "reviewer", toolCount: 0, tokens: 0, durationMs: 0 },
+	};
+	const text = componentText(renderSubagentResult({
+		content: [{ type: "text", text: "running" }],
+		details: {
+			mode: "parallel",
+			results: [running],
+			workflowGraph: {
+				runId: "workflow-task-label",
+				mode: "parallel",
+				phases: [],
+				nodes: [{ id: "review", kind: "agent", agent: "reviewer", label: longLabel, status: "running", flatIndex: 0 }],
+			},
+		},
+	}, { expanded: false }, theme as any));
+
+	assert.match(text, /task: Review auth flow x+/);
+	assert.doesNotMatch(text, /raw task that should not win/);
+	assert.match(text, /\.\.\.$/m);
+	assert.match(text, /Ctrl\+Alt\+F Fleet/);
+});
+
 test("compact chain rendering uses workflow graph spans for dynamic fanout results", () => {
 	const component = renderSubagentResult({
 		content: [{ type: "text", text: "done" }],
@@ -331,6 +370,20 @@ test("static sequential and static parallel chain rendering keep existing labels
 	assert.match(parallel, /Step 3: writer/);
 });
 
+test("expanded simple chain summaries prefer result session names", () => {
+	const expanded = componentText(renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "chain",
+			chainAgents: ["chain-label"],
+			totalSteps: 1,
+			results: [{ ...result("worker", "done"), sessionName: "  worker: named task  " }],
+		},
+	}, { expanded: true }, theme as any));
+	assert.match(expanded, /Step 1: worker: named task/);
+	assert.doesNotMatch(expanded, /Step 1: chain-label/);
+});
+
 test("main-window renderer config removes compact result indentation without changing status glyphs", () => {
 	const component = renderSubagentResult({
 		content: [{ type: "text", text: "done" }],

package/dist/extensions/pi-subagents/test/unit/result-delivery-ownership.test.ts

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createResultDeliveryOwnership } from "../../src/runs/background/result-delivery-ownership.ts";
+
+const OWNER = "owner-a";
+
+describe("result delivery ownership", () => {
+	it("claims only the directly proven previous runtime session", () => {
+		const state = { currentSessionId: "old" as string | null, completionOwnerId: OWNER };
+		const ownership = createResultDeliveryOwnership(state);
+		assert.equal(ownership.claimPredecessor(undefined, "old"), false);
+		assert.equal(ownership.claimPredecessor("different", "old"), false);
+		assert.equal(ownership.claimPredecessor("old", "different"), false);
+		assert.equal(ownership.claimPredecessor("old", "old"), true);
+		state.currentSessionId = "new";
+		assert.equal(ownership.owns("old", OWNER), true);
+		assert.equal(ownership.owns("new", OWNER), true);
+		assert.equal(ownership.owns("old", "other-owner"), false);
+		assert.equal(ownership.owns("foreign", OWNER), false);
+	});
+
+	it("keeps predecessor claims bounded", () => {
+		const state = { currentSessionId: "session-0" as string | null, completionOwnerId: OWNER };
+		const ownership = createResultDeliveryOwnership(state);
+		for (let index = 0; index < 9; index += 1) {
+			const previous = `session-${index}`;
+			assert.equal(ownership.claimPredecessor(previous, previous), true);
+			state.currentSessionId = `session-${index + 1}`;
+		}
+		assert.deepEqual(ownership.claimedSessionIds(), ["session-1", "session-2", "session-3", "session-4", "session-5", "session-6", "session-7", "session-8"]);
+		assert.equal(ownership.owns("session-0", OWNER), false);
+		assert.equal(ownership.owns("session-8", OWNER), true);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/result-files.test.ts

@@ -5,7 +5,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { encodeIndexSegment, MAX_INDEX_SEGMENT_BYTES } from "../../src/runs/background/index-segment.ts";
-import { cleanupResultIndexes, removeResultIndex, resultCandidateFilesForSession, resultFilesForSession, resultFilesForToolCall, resultPayloadPathForIndexedRun, resultPayloadPathForSessionRun, writeAsyncResultFile, writePendingAsyncResultFile, writeResultIndexForData } from "../../src/runs/background/result-files.ts";
+import { cleanupResultIndexes, removeResultIndex, resultCandidateFilesForSession, resultFilesForSession, resultFilesForToolCall, resultPayloadPathForIndexedRun, resultPayloadPathForMissionObserverRun, resultPayloadPathForSessionRun, writeAsyncResultFile, writePendingAsyncResultFile, writeResultIndexForData } from "../../src/runs/background/result-files.ts";
 
 const JSON_EXTENSION = ".json";
 const MAX_JSON_FILE_STEM_BYTES = MAX_INDEX_SEGMENT_BYTES - Buffer.byteLength(JSON_EXTENSION, "utf-8");
@@ -175,6 +175,22 @@ describe("result file indexes", () => {
 		}
 	});
 
+	it("treats a missing mission observer index directory as absent without logging", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-observer-enotdir-"));
+		const originalError = console.error;
+		const errors: unknown[][] = [];
+		try {
+			fs.writeFileSync(path.join(resultsDir, "result-index"), "not a directory", "utf-8");
+			console.error = (...args: unknown[]) => { errors.push(args); };
+
+			assert.equal(resultPayloadPathForMissionObserverRun(resultsDir, "mission-run"), undefined);
+			assert.deepEqual(errors, []);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("does not commit a result payload without a session id", () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-no-session-"));
 		try {
@@ -293,7 +309,7 @@ describe("result file indexes", () => {
 	it("round-trips results for Windows session file paths", () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-win-session-"));
 		try {
-			const sessionId = String.raw`C:\Users\theap\.pi\agent\sessions\leaf.jsonl`;
+			const sessionId = String.raw`C:\Users\theap\.selesai\agent\sessions\leaf.jsonl`;
 			const runId = "win-session-run";
 			const resultPath = path.join(resultsDir, `${runId}.json`);
 			writeAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });
@@ -308,10 +324,92 @@ describe("result file indexes", () => {
 		}
 	});
 
+	it("treats an unaddressable legacy session alias as absent and keeps canonical fallback candidates", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-legacy-enametoolong-"));
+		const sessionId = String.raw`C:\Users\theap\.selesai\agent\sessions\leaf.jsonl`;
+		const runId = "legacy-alias-fallback";
+		const resultPath = path.join(resultsDir, `${runId}.json`);
+		const legacyDir = path.join(resultsDir, "result-index", "sessions", encodeURIComponent(sessionId));
+		const originalReadFileSync = fsDefault.readFileSync;
+		const originalReaddirSync = fsDefault.readdirSync;
+		const originalError = console.error;
+		const errors: unknown[][] = [];
+		try {
+			writeAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });
+			const canonicalDir = path.join(resultsDir, "result-index", "sessions", encodeIndexSegment(sessionId));
+			const [canonicalIndexFile] = fs.readdirSync(canonicalDir);
+			assert.ok(canonicalIndexFile);
+			const canonicalPendingPath = pendingPath(resultsDir, sessionId, runId);
+			fs.mkdirSync(path.dirname(canonicalPendingPath), { recursive: true });
+			fs.copyFileSync(resultPath, canonicalPendingPath);
+
+			const nameTooLong = new Error("legacy alias is too long") as NodeJS.ErrnoException;
+			nameTooLong.code = "ENAMETOOLONG";
+			fsDefault.readFileSync = ((filePath: fs.PathOrFileDescriptor, ...args: unknown[]) => {
+				if (String(filePath).startsWith(legacyDir)) throw nameTooLong;
+				return (originalReadFileSync as (...input: unknown[]) => unknown)(filePath, ...args);
+			}) as typeof fsDefault.readFileSync;
+			fsDefault.readdirSync = ((dirPath: fs.PathLike, ...args: unknown[]) => {
+				if (String(dirPath) === legacyDir) throw nameTooLong;
+				return (originalReaddirSync as (...input: unknown[]) => unknown)(dirPath, ...args);
+			}) as typeof fsDefault.readdirSync;
+			console.error = (...args: unknown[]) => { errors.push(args); };
+			syncBuiltinESMExports();
+
+			assert.deepEqual(resultCandidateFilesForSession(resultsDir, sessionId), [`${runId}.json`]);
+			fs.copyFileSync(resultPath, canonicalPendingPath);
+			fs.rmSync(path.join(canonicalDir, canonicalIndexFile));
+			assert.equal(resultPayloadPathForSessionRun(resultsDir, sessionId, runId), canonicalPendingPath);
+			assert.deepEqual(errors, []);
+		} finally {
+			fsDefault.readFileSync = originalReadFileSync;
+			fsDefault.readdirSync = originalReaddirSync;
+			console.error = originalError;
+			t.mock.restoreAll();
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("leaves an unaddressable legacy index untouched during cleanup", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-cleanup-enametoolong-"));
+		const sessionId = String.raw`C:\Users\theap\.selesai\agent\sessions\leaf.jsonl`;
+		const runId = "legacy-cleanup";
+		const originalStatSync = fsDefault.statSync;
+		const originalError = console.error;
+		const errors: unknown[][] = [];
+		try {
+			writeAsyncResultFile(path.join(resultsDir, `${runId}.json`), { id: runId, runId, sessionId, success: true });
+			const canonicalDir = path.join(resultsDir, "result-index", "sessions", encodeIndexSegment(sessionId));
+			const legacyDir = path.join(resultsDir, "result-index", "sessions", encodeURIComponent(sessionId));
+			fs.renameSync(canonicalDir, legacyDir);
+			const [legacyIndexFile] = fs.readdirSync(legacyDir);
+			assert.ok(legacyIndexFile);
+			const legacyIndexPath = path.join(legacyDir, legacyIndexFile);
+			const nameTooLong = new Error("legacy alias is too long") as NodeJS.ErrnoException;
+			nameTooLong.code = "ENAMETOOLONG";
+			t.mock.method(fsDefault, "statSync", ((filePath: fs.PathLike) => {
+				if (String(filePath) === legacyIndexPath) throw nameTooLong;
+				return originalStatSync(filePath);
+			}) as typeof fsDefault.statSync);
+			console.error = (...args: unknown[]) => { errors.push(args); };
+			syncBuiltinESMExports();
+
+			assert.equal(cleanupResultIndexes(resultsDir, Date.now() + 86_400_001, 86_400_000), 0);
+			assert.equal(fs.existsSync(legacyIndexPath), true);
+			assert.deepEqual(errors, []);
+		} finally {
+			console.error = originalError;
+			t.mock.restoreAll();
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("reads a pre-hash URI-encoded session index after the encoding change", () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-legacy-session-"));
 		try {
-			const sessionId = String.raw`C:\Users\theap\.pi\agent\sessions\leaf.jsonl`;
+			const sessionId = String.raw`C:\Users\theap\.selesai\agent\sessions\leaf.jsonl`;
 			const runId = "legacy-session-run";
 			const resultPath = path.join(resultsDir, `${runId}.json`);
 			writeAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });

package/dist/extensions/pi-subagents/test/unit/retained-children.test.ts

@@ -70,6 +70,7 @@ function writeRetainedRun(root: string, index: number, options: WriteRunOptions
 			agent: options.recoveryAgent ?? "worker",
 			cwd: options.recoveryCwd ?? root,
 			systemPromptMode: "replace",
+			inheritGlobalContext: false,
 			inheritProjectContext: false,
 			inheritSkills: false,
 			outputMode: "inline",

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

@@ -203,7 +203,7 @@ describe("subagent extension RPC bridge", () => {
 			asyncJobs: new Map([["async-private-id", {
 				asyncId: "async-private-id", sessionId: "/sessions/parent.jsonl", status: "running", mode: "single",
 				description: ["Review", "\u001b]8;;hostile\u0007", "the diff"].join("\n"),
-				startedAt: 100, steps: [{ agent: "reviewer", label: "opaque label", status: "running", startedAt: 120, model: "anthropic/claude-opus-4-8:high", thinking: "high", tokens: { input: 12, output: 34, total: 46 } }],
+				startedAt: 100, steps: [{ agent: "reviewer", label: "opaque label", status: "running", startedAt: 120, model: "anthropic/claude-opus-4-8:high", thinking: "high", tokens: { input: 12, output: 34, total: 46, window: 40, windowPeak: 44 } }],
 			}]]),
 		} as any;
 		const bridge = registerSubagentRpcBridge({
@@ -217,7 +217,7 @@ describe("subagent extension RPC bridge", () => {
 		assert.equal((fleet as { omitted?: number }).omitted, 0);
 		assert.deepEqual(fleet.entries[0], {
 			key: "fleet-1", agent: "reviewer", role: "opaque label", model: "anthropic/claude-opus-4-8:high", effort: "high",
-			startedAt: 120, tokens: { input: 12, output: 34, total: 46 },
+			startedAt: 120, tokens: { input: 12, output: 34, total: 46, window: 40, windowPeak: 44 },
 		});
 		assert.equal(JSON.stringify(fleet).includes("Review the diff"), false);
 		assert.equal(JSON.stringify(fleet).includes("async-private-id"), false);
@@ -779,7 +779,7 @@ describe("subagent extension RPC bridge", () => {
 				childId: "review",
 				status: "stopping",
 				ts: 150,
-				reason: "user",
+				reason: "rpc",
 				source: "rpc",
 				asyncDir,
 				stepIndex: 1,
@@ -835,6 +835,7 @@ describe("subagent extension RPC bridge", () => {
 			assert.equal(childStatus?.runId, "workflow-stop-child");
 			assert.equal(childStatus?.childId, "slow");
 			assert.equal(childStatus?.status, "stopping");
+			assert.equal(childStatus?.reason, "rpc");
 			assert.equal(childStatus?.source, "rpc");
 			assert.equal(childStatus?.workflowKey, "slow");
 
@@ -931,7 +932,7 @@ describe("subagent extension RPC bridge", () => {
 		}
 	});
 
-	it("rejects stop requests for reload-recovered workflows", async () => {
+	it("stops reload-recovered workflows through the durable control channel", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-rpc-stop-workflow-"));
 		try {
 			const events = new FakeEvents();
@@ -965,10 +966,11 @@ describe("subagent extension RPC bridge", () => {
 
 			const reply = await request(events, "stop-workflow", "stop", { id: "workflow-run" });
 
-			assert.equal(reply.success, false);
-			assert.equal((reply as { error: { code: string; message: string } }).error.code, "invalid_state");
-			assert.match((reply as { error: { message: string } }).error.message, /reload recovery cannot stop it safely/);
-			assert.equal(fs.existsSync(stopRequestPath(asyncDir)), false);
+			assert.equal(reply.success, true);
+			assert.equal((reply as { data: { runId?: string; state?: string; message?: string } }).data.runId, "workflow-run");
+			assert.equal((reply as { data: { state?: string } }).data.state, "stopping");
+			assert.match((reply as { data: { message?: string } }).data.message ?? "", /Stop requested for async run workflow-run/);
+			assert.equal(consumeStopRequestPayload(asyncDir)?.type, "stop");
 			assert.equal(killCalls, 0);
 
 			bridge.dispose();

package/dist/extensions/pi-subagents/test/unit/run-fanout-budget.test.ts

@@ -14,7 +14,9 @@ import {
 	RunFanoutLimitError,
 	validateRunFanoutBudgetDescriptor,
 } from "../../src/runs/shared/run-fanout-budget.ts";
-import { resolveMaxSubagentSpawnsPerRun } from "../../src/shared/types.ts";
+import { resolveMaxSubagentSpawnsPerRun, type AsyncStatus } from "../../src/shared/types.ts";
+import { listAsyncRuns, summarizeAsyncStatus } from "../../src/runs/background/async-status.ts";
+import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
 
 const directories: string[] = [];
 const externalDirectories: string[] = [];
@@ -47,6 +49,74 @@ describe("run fan-out budget", () => {
 		}
 	});
 
+	it("degrades status projection when persisted budget state is removed", () => {
+		const descriptor = budget(2);
+		fs.rmSync(path.join(descriptor.directory, "claims"), { recursive: true, force: true });
+		const asyncDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-fanout-status-"));
+		directories.push(asyncDir);
+		fs.writeFileSync(path.join(asyncDir, "run-fanout-budget.json"), JSON.stringify(descriptor), "utf-8");
+		const fallback = { used: 1, limit: 2, remaining: 1 };
+		const status = {
+			runId: "run-1",
+			mode: "single",
+			state: "running",
+			startedAt: 100,
+			lastUpdate: 200,
+			steps: [{ agent: "worker", status: "running", startedAt: 100 }],
+			runFanoutBudget: fallback,
+		} as AsyncStatus;
+		const summary = summarizeAsyncStatus(asyncDir, status);
+		assert.deepEqual(summary.runFanoutBudget, fallback);
+		assert.ok(summary.nestedWarnings?.some((warning) => warning.includes("Run fan-out status unavailable")));
+	});
+
+	it("keeps nested status projection when persisted budget state is removed", () => {
+		const runId = "run-fanout-nested-status";
+		const asyncRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-fanout-nested-root-"));
+		directories.push(asyncRoot);
+		const asyncDir = path.join(asyncRoot, runId);
+		fs.mkdirSync(asyncDir, { recursive: true });
+		const route = createNestedRoute(runId);
+		directories.push(path.dirname(route.eventSink));
+		const descriptor = budget(2);
+		fs.rmSync(path.join(descriptor.directory, "claims"), { recursive: true, force: true });
+		fs.writeFileSync(path.join(asyncDir, "run-fanout-budget.json"), JSON.stringify(descriptor), "utf-8");
+		const fallback = { used: 1, limit: 2, remaining: 1 };
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+			runId,
+			mode: "single",
+			state: "running",
+			startedAt: 100,
+			lastUpdate: 200,
+			steps: [{ agent: "worker", status: "running" }],
+			runFanoutBudget: fallback,
+		}), "utf-8");
+		writeNestedEvent(route, {
+			type: "subagent.nested.started",
+			ts: 300,
+			parentRunId: runId,
+			parentStepIndex: 0,
+			child: {
+				id: "nested-child",
+				parentRunId: runId,
+				parentStepIndex: 0,
+				depth: 1,
+				path: [{ runId, stepIndex: 0 }],
+				mode: "single",
+				state: "running",
+				agent: "nested-worker",
+				startedAt: 100,
+				lastUpdate: 300,
+			},
+		});
+
+		const summary = listAsyncRuns(asyncRoot, { states: ["running"], repairScan: true })[0];
+		assert.deepEqual(summary?.runFanoutBudget, fallback);
+		assert.equal(summary?.nestedChildren?.[0]?.id, "nested-child");
+		assert.equal(summary?.steps[0]?.children?.[0]?.id, "nested-child");
+		assert.ok(summary?.nestedWarnings?.some((warning) => warning.includes("Run fan-out status unavailable")));
+	});
+
 	it("persists claims and rejects the responsible next path at the exact cap", () => {
 		const descriptor = budget(2);
 		assert.deepEqual(claimRunFanoutBatch(descriptor, ["tasks[0]", "tasks[1]"]), { used: 2, limit: 2, remaining: 0 });

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

@@ -117,6 +117,36 @@ describe("async run status inspection", () => {
 		}
 	});
 
+	it("normalizes old external-cli runner status before rendering adapter details", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-old-external-cli-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "run-old-external-cli");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId: "run-old-external-cli",
+				mode: "single",
+				state: "complete",
+				startedAt: 100,
+				lastUpdate: 200,
+				steps: [{
+					agent: "external",
+					status: "complete",
+					runner: { type: "external-cli", command: "review-cli", args: [], promptDelivery: "stdin", capabilities: { stop: true, steer: false, resume: false, structuredOutput: false, toolEvents: false } },
+				}],
+			}, null, 2), "utf-8");
+
+			const result = inspectSubagentStatus({ id: "run-old-external-cli" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+
+			const text = textContent(result);
+			assert.equal(result.isError, undefined);
+			assert.match(text, /Adapter: external-cli v1 \(one-shot-stdin\)/);
+			assert.match(text, /Unsupported resume: The one-shot stdin adapter has no durable external session identity/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("shows parallel mode and aggregate progress for top-level async parallel runs", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-parallel-"));
 		try {
@@ -141,7 +171,7 @@ describe("async run status inspection", () => {
 				chainStepCount: 1,
 				parallelGroups: [{ start: 0, count: 3, stepIndex: 0 }],
 				steps: [
-					{ agent: "reviewer", status: "running", startedAt: 100, model: "openai-codex/gpt-5.5:high" },
+					{ agent: "reviewer", sessionName: "  reviewer: Inspect the first result  ", status: "running", startedAt: 100, model: "openai-codex/gpt-5.5:high" },
 					{ agent: "reviewer", status: "running", startedAt: 100, model: "anthropic/claude-haiku-4-5", thinking: "low" },
 					{ agent: "reviewer", status: "pending" },
 				],
@@ -159,7 +189,7 @@ describe("async run status inspection", () => {
 			assert.match(text, /Error: top-level async status error/);
 			assert.match(text, /Progress: 2 agents running · 0\/3 done/);
 			assert.match(text, new RegExp(`Output: ${runOutputPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
-			assert.match(text, /Agent 1\/3: reviewer running \(gpt-5\.5 · thinking high\)/);
+			assert.match(text, /Agent 1\/3: reviewer: Inspect the first result running \(gpt-5\.5 · thinking high\)/);
 			assert.match(text, /Agent 2\/3: reviewer running \(claude-haiku-4-5 · thinking low\)/);
 			assert.match(text, /Agent 3\/3: reviewer pending/);
 			assert.doesNotMatch(text, /openai-codex\/gpt-5\.5/);
@@ -186,7 +216,7 @@ describe("async run status inspection", () => {
 				startedAt: 100,
 				lastUpdate: 200,
 				currentStep: 0,
-				steps: [{ agent: "worker", status: "running", startedAt: 100 }],
+				steps: [{ agent: "worker", sessionName: "  worker: Read the transcript  ", status: "running", startedAt: 100 }],
 			}, null, 2), "utf-8");
 
 			const result = inspectSubagentStatus({ id: "run-transcript", view: "transcript", lines: 2 }, {
@@ -199,7 +229,7 @@ describe("async run status inspection", () => {
 			const text = textContent(result);
 			assert.equal(result.isError, undefined);
 			assert.match(text, /Run: run-transcript/);
-			assert.match(text, /Step: 0 \(worker\) \| running/);
+			assert.match(text, /Step: 0 \(worker: Read the transcript\) \| running/);
 			assert.match(text, new RegExp(`Transcript tail from ${outputPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} \\(tail truncated\\):`));
 			assert.doesNotMatch(text, /first line/);
 			assert.match(text, /second line/);
@@ -435,7 +465,7 @@ describe("async run status inspection", () => {
 				chainStepCount: 1,
 				parallelGroups: [{ start: 0, count: 2, stepIndex: 0 }],
 				steps: [
-					{ agent: "worker", status: "running", startedAt: 100 },
+					{ agent: "worker", sessionName: "  worker: Inspect fleet  ", label: "Fleet check", status: "running", startedAt: 100 },
 					{ agent: "reviewer", status: "pending" },
 				],
 			}, null, 2), "utf-8");
@@ -447,6 +477,7 @@ describe("async run status inspection", () => {
 					startedAt: 100,
 					updatedAt: 250,
 					currentAgent: "scout",
+					sessionName: "  foreground: Inspect fleet  ",
 					currentIndex: 0,
 					lastActivityAt: 240,
 				}]]),
@@ -464,8 +495,10 @@ describe("async run status inspection", () => {
 			assert.equal(result.isError, undefined);
 			assert.match(text, /Subagent fleet: 2 tracked/);
 			assert.match(text, /Foreground runs:/);
-			assert.match(text, /fg-run \| running \| scout/);
+			assert.match(text, /fg-run \| running \| foreground: Inspect fleet/);
+			assert.doesNotMatch(text, /fg-run \| running \| scout/);
 			assert.match(text, /Async runs:/);
+			assert.match(text, /0\. worker: Inspect fleet \| running/);
 			assert.match(text, /run-fleet \| running .*\| parallel \| 1 agent running · 0\/2 done/);
 			assert.match(text, /transcript: subagent\(\{ action: "status", id: "run-fleet", view: "transcript" \}\)/);
 			assert.match(text, /transcript: subagent\(\{ action: "status", id: "run-fleet", index: 0, view: "transcript" \}\)/);
@@ -705,6 +738,7 @@ describe("async run status inspection", () => {
 					path: [{ runId: "run-nested-root", stepIndex: 0, agent: "orchestrator" }],
 					state: "running",
 					agent: "reviewer",
+					sessionName: "  reviewer: Read the status  ",
 					currentTool: "read",
 					lastUpdate: 150,
 				},
@@ -720,7 +754,7 @@ describe("async run status inspection", () => {
 			const text = textContent(result);
 			assert.equal(result.isError, undefined);
 			assert.match(text, /Step 1: orchestrator running/);
-			assert.match(text, /↳ reviewer \[nested-status-child\] running \| tool read/);
+			assert.match(text, /↳ reviewer: Read the status \[nested-status-child\] running \| tool read/);
 			assert.match(text, /Status: subagent\(\{ action: "status", id: "nested-status-child" \}\)/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });