@selesai/code 0.5.19 → 0.5.21

package/dist/extensions/pi-subagents/test/integration/parallel-execution.test.ts

@@ -10,7 +10,9 @@
 
 import { describe, it, before, after, beforeEach, afterEach } from "node:test";
 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 type { MockPi } from "../support/helpers.ts";
 import {
@@ -112,11 +114,15 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		removeTempDir(tempDir);
 	});
 
-	function makeExecutor(agents = [makeAgent("echo")]) {
+	function makeExecutor(
+		agents = [makeAgent("echo")],
+		state = { baseCwd: tempDir, currentSessionId: null, asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null },
+		config: Record<string, unknown> = {},
+	) {
 		return createSubagentExecutor({
 			pi: { events: createEventBus(), getSessionName: () => undefined },
-			state: { baseCwd: tempDir, currentSessionId: null, asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null },
-			config: {},
+			state,
+			config,
 			asyncByDefault: false,
 			tempArtifactsDir: tempDir,
 			getSubagentSessionRoot: () => tempDir,
@@ -125,6 +131,12 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		});
 	}
 
+	function git(args: string[]): string {
+		const result = spawnSync("git", args, { cwd: tempDir, encoding: "utf-8" });
+		assert.equal(result.status, 0, result.stderr || result.stdout);
+		return result.stdout.trim();
+	}
+
 	function readLastCallArgs(): string[] {
 		const callFile = fs.readdirSync(mockPi.dir).find((name) => name.startsWith("call-"));
 		assert.ok(callFile, "expected a recorded mock pi call");
@@ -171,6 +183,124 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		assert.equal(ok, 2);
 	});
 
+	it("tracks every concurrently running foreground child", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		for (let index = 0; index < 3; index++) mockPi.onCall({ output: `Review ${index} complete`, delay: 250 });
+		const agents = [makeAgent("reviewer")];
+		const state = {
+			baseCwd: tempDir,
+			currentSessionId: null,
+			asyncJobs: new Map(),
+			foregroundControls: new Map(),
+			lastForegroundControlId: null,
+		};
+		const executor = makeExecutor(agents, state);
+		const executionPromise = executor.execute(
+			"parallel-foreground-fleet",
+			{
+				tasks: [
+					{ agent: "reviewer", task: "Review correctness" },
+					{ agent: "reviewer", task: "Review quality" },
+					{ agent: "reviewer", task: "Review tests" },
+				],
+			},
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		for (let attempt = 0; attempt < 40; attempt++) {
+			const active = [...state.foregroundControls.values()][0]?.activeChildren;
+			if (active?.size === 3) break;
+			await new Promise((resolve) => setTimeout(resolve, 10));
+		}
+		const control = [...state.foregroundControls.values()][0];
+		assert.ok(control);
+		assert.deepEqual([...control.activeChildren.values()].map((child) => child.description), [
+			"Review correctness",
+			"Review quality",
+			"Review tests",
+		]);
+		assert.equal(control.activeChildren.size, 3);
+
+		const result = await executionPromise;
+		assert.equal(result.isError, undefined);
+		assert.equal(state.foregroundControls.size, 0);
+	});
+
+	it("publishes a durable handoff before cleaning foreground parallel worktrees", { skip: !createSubagentExecutor || process.platform === "win32" ? "executor unavailable or worktree paths differ on Windows" : undefined }, async () => {
+		git(["init"]);
+		git(["config", "user.email", "test@example.com"]);
+		git(["config", "user.name", "Test User"]);
+		fs.writeFileSync(path.join(tempDir, "tracked.txt"), "base\n", "utf-8");
+		git(["add", "tracked.txt"]);
+		git(["commit", "-m", "initial"]);
+		mockPi.onCall({ output: "Worktree task complete" });
+		const executor = makeExecutor();
+		const result = await executor.execute(
+			"foreground-worktree-handoff",
+			{ tasks: [{ agent: "echo", task: "Work in isolation" }], worktree: true },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.parallelHandoff?.version, 1);
+		assert.equal(result.details?.parallelHandoff?.cleanupState, "complete");
+		assert.match(result.content[0]?.text ?? "", /Parallel handoff:/);
+		const handoffPath = result.details!.parallelHandoff!.path;
+		const handoff = JSON.parse(fs.readFileSync(handoffPath, "utf-8")) as {
+			groups: Array<{ children: Array<{ agent: string; summary: string; patch: { path: string } }>; cleanup: { state: string; tasks: Array<{ path: string; worktreeRemoved: boolean; branchRemoved: boolean }> } }>;
+		};
+		assert.equal(handoff.groups[0]!.children[0]!.agent, "echo");
+		assert.equal(handoff.groups[0]!.children[0]!.summary, "Worktree task complete");
+		assert.equal(fs.existsSync(handoff.groups[0]!.children[0]!.patch.path), true);
+		assert.ok(result.details?.runId);
+		assert.ok(handoff.groups[0]!.children[0]!.patch.path.includes(`${path.sep}worktree-diffs${path.sep}${result.details.runId}${path.sep}`));
+		assert.equal(handoff.groups[0]!.cleanup.state, "complete");
+		assert.equal(handoff.groups[0]!.cleanup.tasks[0]!.worktreeRemoved, true);
+		assert.equal(handoff.groups[0]!.cleanup.tasks[0]!.branchRemoved, true);
+		assert.equal(fs.existsSync(handoff.groups[0]!.cleanup.tasks[0]!.path), false);
+	});
+
+	it("keeps worktree parallel runs successful when handoff manifest writing fails", { skip: !createSubagentExecutor || process.platform === "win32" ? "executor unavailable or worktree paths differ on Windows" : undefined }, async () => {
+		git(["init"]);
+		git(["config", "user.email", "test@example.com"]);
+		git(["config", "user.name", "Test User"]);
+		fs.writeFileSync(path.join(tempDir, "tracked.txt"), "base\n", "utf-8");
+		git(["add", "tracked.txt"]);
+		git(["commit", "-m", "initial"]);
+		const sessionDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-session-"));
+		try {
+			const artifactsDir = path.join(sessionDir, "subagent-artifacts");
+			fs.mkdirSync(artifactsDir, { recursive: true });
+			fs.writeFileSync(path.join(artifactsDir, "handoffs"), "not a directory", "utf-8");
+			mockPi.onCall({ output: "Worktree task complete" });
+			const executor = makeExecutor([makeAgent("echo")], undefined, { artifactDir: "session" });
+			const ctx = {
+				...makeMinimalCtx(tempDir),
+				sessionManager: {
+					getSessionId: () => "session-123",
+					getSessionFile: () => path.join(sessionDir, "session.jsonl"),
+				},
+			};
+			const result = await executor.execute(
+				"foreground-worktree-handoff-collision",
+				{ tasks: [{ agent: "echo", task: "Work in isolation" }], worktree: true },
+				new AbortController().signal,
+				undefined,
+				ctx,
+			);
+
+			assert.equal(result.isError, undefined);
+			assert.equal(result.details?.parallelHandoff, undefined);
+			assert.match(result.content[0]?.text ?? "", /Parallel handoff unavailable:/);
+			assert.doesNotMatch(git(["worktree", "list", "--porcelain"]), /pi-parallel-/);
+		} finally {
+			fs.rmSync(sessionDir, { recursive: true, force: true });
+		}
+	});
+
 	it("treats parallel action aliases with tasks as top-level parallel execution", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		for (const action of ["parallel", "PARALLEL", "tasks"]) {
 			mockPi.reset();
@@ -191,6 +321,42 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		}
 	});
 
+	it("does not apply agent acceptance defaults to top-level parallel tasks", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		mockPi.onCall({ output: "parallel response without explicit acceptance" });
+		const executor = makeExecutor([
+			makeAgent("echo", { defaultAcceptance: { level: "none", reason: "single launches only" } }),
+		]);
+
+		const result = await executor.execute(
+			"parallel-agent-acceptance-default",
+			{ tasks: [{ agent: "echo", task: "Return a concise answer" }] },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.results?.[0]?.acceptance?.explicit, false);
+		assert.equal(result.details?.results?.[0]?.acceptance?.effectiveAcceptance.level, "attested");
+	});
+
+	it("applies agent acceptance roles to inferred parallel acceptance", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		mockPi.onCall({ output: "exploration complete" });
+		const executor = makeExecutor([
+			makeAgent("worker", { acceptanceRole: "read-only" }),
+		]);
+
+		const result = await executor.execute(
+			"parallel-agent-acceptance-role",
+			{ tasks: [{ agent: "worker", task: "Explore the authentication flow" }] },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.details?.results?.[0]?.acceptance?.effectiveAcceptance.level, "attested");
+	});
+
 	it("top-level parallel output saves use per-task output paths", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		mockPi.onCall({ output: "Saved report" });
 		const executor = makeExecutor();
@@ -211,6 +377,32 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		assert.equal(result.details?.results?.[0]?.savedOutputPath, outputPath);
 	});
 
+	it("top-level parallel tasks support outputSchema", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		mockPi.onCall({ matchArgIncludes: "First structured", output: "first", structuredOutput: { ok: true, item: "first" } });
+		mockPi.onCall({ matchArgIncludes: "Second structured", output: "second", structuredOutput: { ok: true, item: "second" } });
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"parallel-schema",
+			{
+				tasks: [
+					{ agent: "echo", task: "First structured", outputSchema: { type: "object", required: ["ok", "item"], properties: { ok: { type: "boolean" }, item: { type: "string" } } } },
+					{ agent: "echo", task: "Second structured", outputSchema: { type: "object", required: ["ok", "item"], properties: { ok: { type: "boolean" }, item: { type: "string" } } } },
+				],
+				acceptance: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.deepEqual(result.details?.results?.map((item: { structuredOutput?: unknown }) => item.structuredOutput), [
+			{ ok: true, item: "first" },
+			{ ok: true, item: "second" },
+		]);
+	});
+
 	it("top-level parallel preserves completed siblings and marks timed-out children", { skip: !createSubagentExecutor ? "executor not importable" : process.platform === "win32" ? "timeout signal delivery intermittent on Windows CI" : undefined }, async () => {
 		mockPi.onCall({ matchArgIncludes: "Slow review", delay: 10000 });
 		mockPi.onCall({ matchArgIncludes: "Fast review", output: "fast done" });
@@ -306,6 +498,38 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		assert.equal(mockPi.callCount(), 0);
 	});
 
+	for (const outputOverride of [undefined, true] as const) {
+		it(`isolates foreground inherited output (${outputOverride === true ? "output:true" : "omitted output"})`, { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+			mockPi.onCall({ matchArgIncludes: "Write A", output: "first foreground report" });
+			mockPi.onCall({ matchArgIncludes: "Write B", output: "second foreground report" });
+			const executor = makeExecutor([makeAgent("echo", { output: "context.md" })]);
+			const tasks = [
+				{ agent: "echo", task: "Write A", ...(outputOverride !== undefined ? { output: outputOverride } : {}) },
+				{ agent: "echo", task: "Write B", ...(outputOverride !== undefined ? { output: outputOverride } : {}) },
+			];
+
+			const result = await executor.execute(
+				`parallel-inherited-output-${outputOverride === true ? "true" : "omitted"}`,
+				{ tasks },
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(tempDir),
+			);
+
+			const runId = result.details?.runId;
+			assert.ok(runId, "expected run id in details");
+			const outputDir = path.join(tempDir, ".pi-subagents", "artifacts", "outputs", runId);
+			const firstOutputPath = path.join(outputDir, "parallel-0", "0-echo", "context.md");
+			const secondOutputPath = path.join(outputDir, "parallel-0", "1-echo", "context.md");
+			assert.equal(result.isError, undefined);
+			assert.equal(mockPi.callCount(), 2);
+			assert.equal(fs.readFileSync(firstOutputPath, "utf-8"), "first foreground report");
+			assert.equal(fs.readFileSync(secondOutputPath, "utf-8"), "second foreground report");
+			assert.equal(result.details?.results?.[0]?.savedOutputPath, firstOutputPath);
+			assert.equal(result.details?.results?.[1]?.savedOutputPath, secondOutputPath);
+		});
+	}
+
 	it("treats string false as disabled output in top-level parallel runs", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		mockPi.onCall({ output: "Review done" });
 		const executor = makeExecutor();

package/dist/extensions/pi-subagents/test/integration/render-fork-badge.test.ts

@@ -1,12 +1,14 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
+import { keyText } from "@selesai/code";
 
 type RenderSubagentResult = (
 	result: {
 		content: Array<{ type: "text"; text: string }>;
+		isError?: boolean;
 		details?: {
 			mode: "single" | "parallel" | "chain" | "management";
-			context?: "fresh" | "fork";
+			context?: "fresh" | "fork" | "mixed";
 			results: unknown[];
 		};
 	},
@@ -26,9 +28,25 @@ const theme = {
 	fg: (_name: string, text: string) => text,
 	bold: (text: string) => text,
 };
+const expandKey = keyText("app.tools.expand");
+const expandHint = `Press ${expandKey} for full output`;
 
 const emptyUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 
+function nestedChild(id: string, state: "running" | "complete" | "failed" = "running") {
+	return {
+		id,
+		parentRunId: "root",
+		parentStepIndex: 0,
+		depth: 1,
+		path: [{ runId: "root", stepIndex: 0, agent: "owner" }],
+		state,
+		agent: id,
+		lastUpdate: 1_700_000_002_000,
+		...(state === "running" ? { currentTool: "bash" } : {}),
+	};
+}
+
 function firstGrapheme(text: string): string {
 	return Array.from(text.trimStart())[0] ?? "";
 }
@@ -50,6 +68,148 @@ function withTerminalWidth<T>(columns: number, fn: () => T): T {
 }
 
 describe("renderSubagentResult fork indicator", () => {
+	it("renders result-owned nested children for foreground single, parallel, and chain runs", () => {
+		const cases = [
+			{
+				mode: "single" as const,
+				results: [{ agent: "single", task: "run", exitCode: 0, messages: [], usage: emptyUsage, children: [nestedChild("single-child")] }],
+			},
+			{
+				mode: "parallel" as const,
+				totalSteps: 2,
+				results: [
+					{ agent: "parallel-a", task: "run", exitCode: 0, messages: [], usage: emptyUsage, progress: { status: "running", index: 0, agent: "parallel-a", toolCount: 0, tokens: 0, durationMs: 0 }, children: [nestedChild("parallel-child-a")] },
+					{ agent: "parallel-b", task: "run", exitCode: 0, messages: [], usage: emptyUsage, progress: { status: "running", index: 1, agent: "parallel-b", toolCount: 0, tokens: 0, durationMs: 0 }, children: [nestedChild("parallel-child-b")] },
+				],
+			},
+			{
+				mode: "chain" as const,
+				chainAgents: ["chain-a", "chain-b"],
+				results: [
+					{ agent: "chain-a", task: "run", exitCode: 0, messages: [], usage: emptyUsage, progress: { status: "running", index: 0, agent: "chain-a", toolCount: 0, tokens: 0, durationMs: 0 }, children: [nestedChild("chain-child-a")] },
+					{ agent: "chain-b", task: "run", exitCode: 0, messages: [], usage: emptyUsage, progress: { status: "running", index: 1, agent: "chain-b", toolCount: 0, tokens: 0, durationMs: 0 }, children: [nestedChild("chain-child-b")] },
+				],
+			},
+		];
+
+		for (const details of cases) {
+			const widget = renderSubagentResult!({ content: [{ type: "text", text: "running" }], details }, { expanded: true }, theme);
+			const text = widget.render(160).join("\n");
+			for (const result of details.results) {
+				assert.match(text, new RegExp(`${result.children[0].id} · running`));
+			}
+		}
+	});
+
+	it("renders result-owned nested children for terminal foreground results", () => {
+		const widget = renderSubagentResult!({
+			content: [{ type: "text", text: "failed" }],
+			details: {
+				mode: "parallel",
+				totalSteps: 1,
+				results: [{
+					agent: "owner",
+					task: "run",
+					exitCode: 1,
+					error: "failed",
+					messages: [],
+					usage: emptyUsage,
+					children: [nestedChild("terminal-child", "failed")],
+				}],
+			},
+		}, { expanded: true }, theme);
+
+		assert.match(widget.render(160).join("\n"), /terminal-child · failed/);
+
+		const compact = renderSubagentResult!({
+			content: [{ type: "text", text: "done" }],
+			details: {
+				mode: "single",
+				results: [{
+					agent: "owner",
+					task: "run",
+					exitCode: 0,
+					messages: [],
+					usage: emptyUsage,
+					children: [nestedChild("compact-terminal-child", "complete")],
+				}],
+			},
+		}, { expanded: false }, theme).render(160).join("\n");
+		assert.match(compact, /↳ \[\d{2}:\d{2}:\d{2}\] \+1 nested run \(1 complete\)/);
+		assert.doesNotMatch(compact, /compact-terminal-child · complete/);
+	});
+	it("collapses multiline structured management output to a first-line summary", () => {
+		const output = `\n${"Managed agents: ".padEnd(220, "x")}\n- reviewer\n- writer`;
+		const widget = renderSubagentResult!({
+			content: [{ type: "text", text: output }],
+			details: { mode: "management", context: "fork", results: [] },
+		}, { expanded: false }, theme);
+
+		const lines = widget.render(120).map((line) => line.trimEnd());
+		assert.match(lines[0]!, /^\[fork\] Managed agents:/);
+		assert.match(lines[0]!, /…$/);
+		const hintLineIndex = lines.findIndex((line) => line.includes(expandHint) || (expandKey === "" && line.includes("Press ") && line.includes(" for full output")));
+		assert.ok(hintLineIndex > 0);
+		assert.doesNotMatch(lines[0]!, /reviewer/);
+	});
+
+	it("keeps multiline structured zero-result errors visible", () => {
+		const widget = renderSubagentResult!({
+			content: [{ type: "text", text: "Error: management failed\nfirst diagnostic\nsecond diagnostic" }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		}, { expanded: false }, theme);
+
+		const text = widget.render(120).join("\n");
+		assert.match(text, /Error: management failed/);
+		assert.match(text, /first diagnostic/);
+		assert.match(text, /second diagnostic/);
+		assert.ok(!text.includes(expandHint));
+	});
+
+	it("keeps full multiline structured output when expanded", () => {
+		const output = "Managed agents:\n- reviewer\n- writer";
+		const widget = renderSubagentResult!({
+			content: [{ type: "text", text: output }],
+			details: { mode: "management", results: [] },
+		}, { expanded: true }, theme);
+
+		const text = widget.render(120).join("\n");
+		assert.match(text, /Managed agents:/);
+		assert.match(text, /- reviewer/);
+		assert.match(text, /- writer/);
+		assert.ok(!text.includes(expandHint));
+	});
+
+	it("collapses multiline structured single output using the same contract", () => {
+		const widget = renderSubagentResult!({
+			content: [{ type: "text", text: "Run status:\nState: running\nTranscript: available" }],
+			details: { mode: "single", results: [] },
+		}, { expanded: false }, theme);
+
+		const text = widget.render(120).join("\n");
+		assert.match(text, /^Run status:/);
+		assert.match(text, /3 lines/);
+		assert.ok(text.includes(expandHint) || (expandKey === "" && text.includes("Press ") && text.includes(" for full output")));
+		assert.doesNotMatch(text, /State: running/);
+	});
+
+	it("preserves unstructured multiline and structured single-line output", () => {
+		const unstructured = renderSubagentResult!({
+			content: [{ type: "text", text: "Error:\nfirst detail\nsecond detail" }],
+		}, { expanded: false }, theme).render(120).join("\n");
+		assert.match(unstructured, /first detail/);
+		assert.match(unstructured, /second detail/);
+		assert.ok(!unstructured.includes(expandHint));
+
+		const singleLine = renderSubagentResult!({
+			content: [{ type: "text", text: "No active async run transcript is available." }],
+			details: { mode: "single", results: [] },
+		}, { expanded: false }, theme).render(120).map((line) => line.trimEnd()).join("\n");
+		assert.equal(singleLine, "No active async run transcript is available.");
+		assert.ok(!singleLine.includes(expandHint));
+	});
+
 	it("shows [fork] when details are empty but context is fork", () => {
 		const widget = renderSubagentResult!({
 			content: [{ type: "text", text: "Async: reviewer [abc123]" }],
@@ -60,24 +220,92 @@ describe("renderSubagentResult fork indicator", () => {
 		assert.match(text, /\[fork\]/);
 	});
 
-	it("shows [fork] on single-result header", () => {
+	it("shows nested foreground children with timestamps on running single results", () => {
 		const widget = renderSubagentResult!({
-			content: [{ type: "text", text: "done" }],
+			content: [{ type: "text", text: "running" }],
 			details: {
 				mode: "single",
-				context: "fork",
 				results: [{
-					agent: "reviewer",
-					task: "review",
+					agent: "execute",
+					task: "run plan",
 					exitCode: 0,
 					messages: [],
 					usage: emptyUsage,
+					progress: { status: "running", index: 0, agent: "execute", toolCount: 1, tokens: 10, durationMs: 1_000, lastActivityAt: 1_700_000_001_000 },
+					children: [{
+						id: "impl-1",
+						parentRunId: "root",
+						parentStepIndex: 0,
+						depth: 1,
+						path: [{ runId: "root", stepIndex: 0, agent: "execute" }],
+						state: "running",
+						agent: "implement",
+						lastUpdate: 1_700_000_002_000,
+						currentTool: "bash",
+					}],
 				}],
 			},
 		}, { expanded: false }, theme);
 
 		const text = widget.render(120).join("\n");
-		assert.match(text, /\[fork\]/);
+		assert.match(text, /↳ \[\d{2}:\d{2}:\d{2}\] \+1 nested run \(1 running\)/);
+	});
+
+	it("shows [fresh] and [fork] on single-result headers", () => {
+		for (const context of ["fresh", "fork"] as const) {
+			const widget = renderSubagentResult!({
+				content: [{ type: "text", text: "done" }],
+				details: {
+					mode: "single",
+					context,
+					results: [{
+						agent: "reviewer",
+						task: "review",
+						context,
+						exitCode: 0,
+						messages: [],
+						usage: emptyUsage,
+					}],
+				},
+			}, { expanded: false }, theme);
+
+			const text = widget.render(120).join("\n");
+			assert.match(text, new RegExp(`\\[${context}\\]`));
+		}
+	});
+
+	it("shows [mixed] on mixed runs and per-child context badges", () => {
+		const compact = renderSubagentResult!({
+			content: [{ type: "text", text: "done" }],
+			details: {
+				mode: "parallel",
+				context: "mixed",
+				results: [
+					{ agent: "scout", task: "scan", context: "fresh", exitCode: 0, messages: [], usage: emptyUsage },
+					{ agent: "worker", task: "fix", context: "fork", exitCode: 0, messages: [], usage: emptyUsage },
+				],
+			},
+		}, { expanded: false }, theme).render(160).join("\n");
+
+		assert.match(compact, /parallel \[mixed\]/);
+		assert.match(compact, /scout \[fresh\]/);
+		assert.match(compact, /worker \[fork\]/);
+
+		const expanded = renderSubagentResult!({
+			content: [{ type: "text", text: "done" }],
+			details: {
+				mode: "parallel",
+				context: "mixed",
+				results: [
+					{ agent: "scout", task: "scan", context: "fresh", exitCode: 0, messages: [], usage: emptyUsage },
+					{ agent: "worker", task: "fix", context: "fork", exitCode: 0, messages: [], usage: emptyUsage },
+				],
+			},
+		}, { expanded: true }, theme).render(160).join("\n");
+
+		assert.match(expanded, /parallel \[mixed\]/);
+		assert.match(expanded, /scout \[fresh\]/);
+		assert.match(expanded, /worker \[fork\]/);
 	});
 
 	it("uses compacted tool-call summaries when messages were stripped", () => {

package/dist/extensions/pi-subagents/test/integration/render-widget.test.ts

@@ -333,6 +333,33 @@ describe("subagent async widget rendering", () => {
 		assert.match(text, /Agent 3\/3: reviewer · complete · 1\.5k token/);
 	});
 
+	it("shows async job and step context badges", () => {
+		const now = Date.now();
+		const text = buildWidgetLines([
+			{
+				asyncId: "run-1",
+				asyncDir: "/tmp/1",
+				status: "running",
+				mode: "parallel",
+				context: "mixed",
+				agents: ["scout", "worker"],
+				activeParallelGroup: true,
+				runningSteps: 2,
+				completedSteps: 0,
+				stepsTotal: 2,
+				updatedAt: now,
+				steps: [
+					{ agent: "scout", context: "fresh", status: "running", lastActivityAt: now },
+					{ agent: "worker", context: "fork", status: "running", currentTool: "bash", currentToolStartedAt: now - 1000 },
+				],
+			},
+		], theme, 160).join("\n");
+
+		assert.match(text, /parallel \[mixed\]/);
+		assert.match(text, /Agent 1\/2: scout \[fresh\] · running/);
+		assert.match(text, /Agent 2\/2: worker \[fork\] · running/);
+	});
+
 	it("shows model and thinking for active async widget rows", () => {
 		const lines = buildWidgetLines([
 			{