@narumitw/pi-subagents 0.28.0 → 0.31.0

package/README.md

@@ -178,6 +178,10 @@ Run multiple agents in parallel with a shared thinking level and one per-task ov
 }
 ```
 
+Omit `aggregator` entirely when parallel worker outputs should return directly. Do not send `null`,
+empty strings, or an empty object for an unused optional field; for compatibility, an aggregator with
+an empty or whitespace-only `agent` or `task` is treated as absent.
+
 Run parallel workers, then aggregate their results:
 
 ```json
@@ -339,6 +343,9 @@ Existing `subagent` requests remain unchanged:
 | Parallel | Input order, with at most four active children. | Collects all task results; partial worker failure is reported in summaries but does not discard successful results. |
 | Parallel + aggregator | Source input order, then aggregator. | The aggregator runs with both successful outputs and failure descriptions; aggregator failure marks the tool result as an error. |
 
+An aggregator whose `agent` or `task` is empty or whitespace-only is treated as absent, so successful
+parallel outputs remain available instead of being replaced by a malformed fan-in failure.
+
 Timeout precedence remains: task/step/aggregator → call → agent setting → `PI_SUBAGENT_TIMEOUT_MS` → 600000 ms. Blocking thinking precedence remains: task/step/aggregator → call → agent setting → child default. Stateful spawn thinking precedence is: `subagent_spawn.thinkingLevel` → agent setting → transport fallback. Project-agent resolution and confirmation behavior is unchanged.
 
 ## 🤖 Built-in agents

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-subagents",
-	"version": "0.28.0",
+	"version": "0.31.0",
 	"description": "Pi extension for delegating work to specialized isolated subagents.",
 	"type": "module",
 	"license": "MIT",
@@ -29,7 +29,7 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"typebox": "^1.3.3"
+		"typebox": "^1.3.8"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-agent-core": "*",
@@ -38,11 +38,11 @@
 		"@earendil-works/pi-tui": "*"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.5.3",
-		"@earendil-works/pi-agent-core": "0.80.10",
-		"@earendil-works/pi-ai": "0.80.10",
-		"@earendil-works/pi-coding-agent": "0.80.10",
-		"@earendil-works/pi-tui": "0.80.10",
+		"@biomejs/biome": "2.5.5",
+		"@earendil-works/pi-agent-core": "0.82.1",
+		"@earendil-works/pi-ai": "0.82.1",
+		"@earendil-works/pi-coding-agent": "0.82.1",
+		"@earendil-works/pi-tui": "0.82.1",
 		"typescript": "7.0.2"
 	},
 	"repository": {

package/src/agents.ts

@@ -6,15 +6,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 
-export const THINKING_LEVELS = [
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max",
-] as const;
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 
 export type SubagentThinkingLevel = (typeof THINKING_LEVELS)[number];
 
@@ -72,7 +64,8 @@ export interface SubagentSettings {
 const BUILT_IN_AGENTS: AgentConfig[] = [
 	{
 		name: "scout",
-		description: "Read-only codebase reconnaissance; returns concise findings with paths and evidence.",
+		description:
+			"Read-only codebase reconnaissance; returns concise findings with paths and evidence.",
 		tools: ["read", "grep", "find", "ls", "bash"],
 		source: "built-in",
 		filePath: "built-in:scout",
@@ -185,7 +178,9 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			description: frontmatter.description,
 			tools: tools && tools.length > 0 ? tools : undefined,
 			model: frontmatter.model,
-			thinkingLevel: isThinkingLevel(frontmatter.thinkingLevel) ? frontmatter.thinkingLevel : undefined,
+			thinkingLevel: isThinkingLevel(frontmatter.thinkingLevel)
+				? frontmatter.thinkingLevel
+				: undefined,
 			systemPrompt: body,
 			source,
 			filePath,
@@ -228,7 +223,8 @@ export function discoverAgents(
 	const projectAgentsDir = findNearestProjectAgentsDir(cwd);
 
 	const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
-	const projectAgents = scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project");
+	const projectAgents =
+		scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project");
 
 	const agentMap = new Map<string, AgentConfig>();
 
@@ -258,7 +254,8 @@ export function discoverAgents(
 			nextAgent.model = override.model === null ? undefined : override.model;
 		}
 		if (hasOwn(override, "thinkingLevel")) {
-			nextAgent.thinkingLevel = override.thinkingLevel === null ? undefined : override.thinkingLevel;
+			nextAgent.thinkingLevel =
+				override.thinkingLevel === null ? undefined : override.thinkingLevel;
 		}
 		if (hasOwn(override, "timeoutMs")) {
 			nextAgent.timeoutMs = override.timeoutMs === null ? undefined : override.timeoutMs;
@@ -269,7 +266,10 @@ export function discoverAgents(
 	return { agents: Array.from(agentMap.values()), projectAgentsDir };
 }
 
-export function formatAgentList(agents: AgentConfig[], maxItems: number): { text: string; remaining: number } {
+export function formatAgentList(
+	agents: AgentConfig[],
+	maxItems: number,
+): { text: string; remaining: number } {
 	if (agents.length === 0) return { text: "none", remaining: 0 };
 	const listed = agents.slice(0, maxItems);
 	const remaining = agents.length - listed.length;

package/src/context.ts

@@ -1,9 +1,5 @@
 import { createHash } from "node:crypto";
-import {
-	DEFAULT_MAX_CONTEXT_BYTES,
-	truncateUtf8,
-	truncateUtf8Tail,
-} from "./limits.js";
+import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8, truncateUtf8Tail } from "./limits.js";
 
 export type ContextMode = "none" | "all" | "summary" | number;
 
@@ -107,19 +103,20 @@ export function buildContextSnapshot(
 	const raw =
 		mode === "summary" && selected.length > 4
 			? [
-					`## Earlier context checkpoint\n${truncateUtf8(
-						selected
-							.slice(0, -4)
-							.map((message) => `${message.role}: ${message.text}`)
-							.join("\n"),
-						Math.floor(maxBytes / 3),
-					).text}`,
-					...selected
-						.slice(-4)
-						.map((message) => `## ${message.role}\n${message.text}`),
+					`## Earlier context checkpoint\n${
+						truncateUtf8(
+							selected
+								.slice(0, -4)
+								.map((message) => `${message.role}: ${message.text}`)
+								.join("\n"),
+							Math.floor(maxBytes / 3),
+						).text
+					}`,
+					...selected.slice(-4).map((message) => `## ${message.role}\n${message.text}`),
 				].join("\n\n")
 			: selected.map((message) => `## ${message.role}\n${message.text}`).join("\n\n");
-	const bounded = mode === "summary" ? truncateUtf8Tail(raw, maxBytes) : truncateUtf8(raw, maxBytes);
+	const bounded =
+		mode === "summary" ? truncateUtf8Tail(raw, maxBytes) : truncateUtf8(raw, maxBytes);
 	return {
 		text: bounded.text,
 		turns: selected.filter((message) => message.role === "user").length,

package/src/execution.ts

@@ -1,13 +1,13 @@
 import type { AgentToolResult, AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
-	discoverAgents,
 	type AgentConfig,
 	type AgentScope,
+	discoverAgents,
 	type SubagentThinkingLevel,
 } from "./agents.js";
 import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8 } from "./limits.js";
-import type { SubagentParams } from "./params.js";
+import { hasUsableAggregator, type SubagentParams } from "./params.js";
 import {
 	buildFanInContext,
 	formatResultFailure,
@@ -105,376 +105,398 @@ export async function executeSubagent(
 	onUpdate: AgentToolUpdateCallback<SubagentDetails> | undefined,
 	ctx: ExtensionContext,
 ): Promise<AgentToolResult<SubagentDetails> & { isError?: boolean }> {
-			assertSubagentDepthAllowed();
-			const agentScope: AgentScope = params.agentScope ?? "user";
-			const config = readSubagentSettings();
-			const discovery = discoverAgents(ctx.cwd, agentScope, config);
-			const agents = discovery.agents;
-			const confirmProjectAgents = params.confirmProjectAgents ?? true;
-			const resolveTimeoutMs = (agentName: string, localTimeoutMs?: number) =>
-				localTimeoutMs ??
-				params.timeoutMs ??
-				agents.find((agent) => agent.name === agentName)?.timeoutMs ??
-				resolveDefaultSubagentTimeoutMs();
-			const resolveThinkingLevel = (agentName: string, localThinkingLevel?: SubagentThinkingLevel) =>
-				resolveSubagentThinkingLevel(agents, agentName, params.thinkingLevel, localThinkingLevel);
-
-			const hasChain = (params.chain?.length ?? 0) > 0;
-			const hasTasks = (params.tasks?.length ?? 0) > 0;
-			const hasSingle = Boolean(params.agent && params.task);
-			const modeCount = Number(hasChain) + Number(hasTasks) + Number(hasSingle);
-
-			const makeDetails =
-				(mode: "single" | "parallel" | "chain") =>
-				(results: SingleResult[], aggregator?: SingleResult): SubagentDetails => ({
-					mode,
-					agentScope,
-					projectAgentsDir: discovery.projectAgentsDir,
-					results,
-					aggregator,
-				});
-
-			if (modeCount !== 1 || (params.aggregator && !hasTasks)) {
-				const available = agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
-				const reason =
-					modeCount !== 1
-						? "Provide exactly one mode."
-						: "Aggregator is only valid with parallel tasks.";
-				return {
-					content: [
-						{
-							type: "text",
-							text: `Invalid parameters. ${reason}\nAvailable agents: ${available}`,
-						},
-					],
-					details: makeDetails("single")([]),
-				};
-			}
+	assertSubagentDepthAllowed();
+	const agentScope: AgentScope = params.agentScope ?? "user";
+	const aggregator = hasUsableAggregator(params.aggregator) ? params.aggregator : undefined;
+	const config = readSubagentSettings();
+	const discovery = discoverAgents(ctx.cwd, agentScope, config);
+	const agents = discovery.agents;
+	const confirmProjectAgents = params.confirmProjectAgents ?? true;
+	const resolveTimeoutMs = (agentName: string, localTimeoutMs?: number) =>
+		localTimeoutMs ??
+		params.timeoutMs ??
+		agents.find((agent) => agent.name === agentName)?.timeoutMs ??
+		resolveDefaultSubagentTimeoutMs();
+	const resolveThinkingLevel = (agentName: string, localThinkingLevel?: SubagentThinkingLevel) =>
+		resolveSubagentThinkingLevel(agents, agentName, params.thinkingLevel, localThinkingLevel);
+
+	const hasChain = (params.chain?.length ?? 0) > 0;
+	const hasTasks = (params.tasks?.length ?? 0) > 0;
+	const hasSingle = Boolean(params.agent && params.task);
+	const modeCount = Number(hasChain) + Number(hasTasks) + Number(hasSingle);
+
+	const makeDetails =
+		(mode: "single" | "parallel" | "chain") =>
+		(results: SingleResult[], aggregator?: SingleResult): SubagentDetails => ({
+			mode,
+			agentScope,
+			projectAgentsDir: discovery.projectAgentsDir,
+			results,
+			aggregator,
+		});
+
+	if (modeCount !== 1 || (aggregator && !hasTasks)) {
+		const available = agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
+		const reason =
+			modeCount !== 1
+				? "Provide exactly one mode."
+				: "Aggregator is only valid with parallel tasks.";
+		return {
+			content: [
+				{
+					type: "text",
+					text: `Invalid parameters. ${reason}\nAvailable agents: ${available}`,
+				},
+			],
+			details: makeDetails("single")([]),
+		};
+	}
 
-			if (agentScope === "project" || agentScope === "both") {
-				const requestedAgentNames = new Set<string>();
-				if (params.chain) for (const step of params.chain) requestedAgentNames.add(step.agent);
-				if (params.tasks) for (const t of params.tasks) requestedAgentNames.add(t.agent);
-				if (params.aggregator) requestedAgentNames.add(params.aggregator.agent);
-				if (params.agent) requestedAgentNames.add(params.agent);
-
-				const projectAgentsRequested = Array.from(requestedAgentNames)
-					.map((name) => agents.find((a) => a.name === name))
-					.filter((a): a is AgentConfig => a?.source === "project");
-
-				if (projectAgentsRequested.length > 0) {
-					if (!ctx.isProjectTrusted()) {
-						throw new Error("Project-local subagent definitions require a trusted project");
-					}
-					if (confirmProjectAgents && ctx.hasUI) {
-						const names = projectAgentsRequested.map((a) => a.name).join(", ");
-						const dir = discovery.projectAgentsDir ?? "(unknown)";
-						const ok = await ctx.ui.confirm(
-							"Run project-local agents?",
-							`Agents: ${names}\nSource: ${dir}\n\nProject agents are repo-controlled. Only continue for trusted repositories.`,
-						);
-						if (!ok) {
-							return {
-								content: [{ type: "text", text: "Canceled: project-local agents not approved." }],
-								details: makeDetails(hasChain ? "chain" : hasTasks ? "parallel" : "single")([]),
-							};
-						}
-					}
-				}
-			}
+	if (agentScope === "project" || agentScope === "both") {
+		const requestedAgentNames = new Set<string>();
+		if (params.chain) for (const step of params.chain) requestedAgentNames.add(step.agent);
+		if (params.tasks) for (const t of params.tasks) requestedAgentNames.add(t.agent);
+		if (aggregator) requestedAgentNames.add(aggregator.agent);
+		if (params.agent) requestedAgentNames.add(params.agent);
 
-			if (params.chain && params.chain.length > 0) {
-				const results: SingleResult[] = [];
-				let previousOutput = "";
-				const status = startSubagentStatus(ctx, toolCallId, chainStatus(0, params.chain.length));
-
-				try {
-					for (let i = 0; i < params.chain.length; i++) {
-						const step = params.chain[i];
-						status.update(chainStatus(i + 1, params.chain.length, step.agent));
-						const taskWithContext = truncateUtf8(
-							step.task.replace(/\{previous\}/g, previousOutput),
-							DEFAULT_MAX_CONTEXT_BYTES,
-						).text;
-
-						// Create update callback that includes all previous results
-						const chainUpdate: OnUpdateCallback | undefined = onUpdate
-							? (partial) => {
-									// Combine completed results with current streaming result
-									const currentResult = partial.details?.results[0];
-									if (currentResult) {
-										const allResults = [...results, currentResult];
-										onUpdate({
-											content: partial.content,
-											details: makeDetails("chain")(allResults),
-										});
-									}
-								}
-							: undefined;
+		const projectAgentsRequested = Array.from(requestedAgentNames)
+			.map((name) => agents.find((a) => a.name === name))
+			.filter((a): a is AgentConfig => a?.source === "project");
 
-						const result = await runSingleAgent(
-							ctx.cwd,
-							agents,
-							step.agent,
-							taskWithContext,
-							step.cwd,
-							i + 1,
-							signal,
-							resolveThinkingLevel(step.agent, step.thinkingLevel),
-							resolveTimeoutMs(step.agent, step.timeoutMs),
-							chainUpdate,
-							makeDetails("chain"),
-						);
-						results.push(result);
-
-						const isError = isResultError(result);
-						if (isError) {
-							const errorMsg = formatResultFailure(result);
-							return {
-								content: [{ type: "text", text: `Chain stopped at step ${i + 1} (${step.agent}): ${errorMsg}` }],
-								details: { ...makeDetails("chain")(results), isError: true },
-								isError: true,
-							};
-						}
-						previousOutput = getResultFinalOutput(result);
-					}
+		if (projectAgentsRequested.length > 0) {
+			if (!ctx.isProjectTrusted()) {
+				throw new Error("Project-local subagent definitions require a trusted project");
+			}
+			if (confirmProjectAgents && ctx.hasUI) {
+				const names = projectAgentsRequested.map((a) => a.name).join(", ");
+				const dir = discovery.projectAgentsDir ?? "(unknown)";
+				const ok = await ctx.ui.confirm(
+					"Run project-local agents?",
+					`Agents: ${names}\nSource: ${dir}\n\nProject agents are repo-controlled. Only continue for trusted repositories.`,
+				);
+				if (!ok) {
 					return {
-						content: [{ type: "text", text: getResultFinalOutput(results[results.length - 1]) || "(no output)" }],
-						details: makeDetails("chain")(results),
+						content: [{ type: "text", text: "Canceled: project-local agents not approved." }],
+						details: makeDetails(hasChain ? "chain" : hasTasks ? "parallel" : "single")([]),
 					};
-				} finally {
-					status.clear();
 				}
 			}
+		}
+	}
 
-			if (params.tasks && params.tasks.length > 0) {
-				if (params.tasks.length > MAX_PARALLEL_TASKS)
+	if (params.chain && params.chain.length > 0) {
+		const results: SingleResult[] = [];
+		let previousOutput = "";
+		const status = startSubagentStatus(ctx, toolCallId, chainStatus(0, params.chain.length));
+
+		try {
+			for (let i = 0; i < params.chain.length; i++) {
+				const step = params.chain[i];
+				status.update(chainStatus(i + 1, params.chain.length, step.agent));
+				const taskWithContext = truncateUtf8(
+					step.task.replace(/\{previous\}/g, previousOutput),
+					DEFAULT_MAX_CONTEXT_BYTES,
+				).text;
+
+				// Create update callback that includes all previous results
+				const chainUpdate: OnUpdateCallback | undefined = onUpdate
+					? (partial) => {
+							// Combine completed results with current streaming result
+							const currentResult = partial.details?.results[0];
+							if (currentResult) {
+								const allResults = [...results, currentResult];
+								onUpdate({
+									content: partial.content,
+									details: makeDetails("chain")(allResults),
+								});
+							}
+						}
+					: undefined;
+
+				const result = await runSingleAgent(
+					ctx.cwd,
+					agents,
+					step.agent,
+					taskWithContext,
+					step.cwd,
+					i + 1,
+					signal,
+					resolveThinkingLevel(step.agent, step.thinkingLevel),
+					resolveTimeoutMs(step.agent, step.timeoutMs),
+					chainUpdate,
+					makeDetails("chain"),
+				);
+				results.push(result);
+
+				const isError = isResultError(result);
+				if (isError) {
+					const errorMsg = formatResultFailure(result);
 					return {
 						content: [
-							{
-								type: "text",
-								text: `Too many parallel tasks (${params.tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`,
-							},
+							{ type: "text", text: `Chain stopped at step ${i + 1} (${step.agent}): ${errorMsg}` },
 						],
-						details: makeDetails("parallel")([]),
+						details: { ...makeDetails("chain")(results), isError: true },
+						isError: true,
 					};
+				}
+				previousOutput = getResultFinalOutput(result);
+			}
+			return {
+				content: [
+					{
+						type: "text",
+						text: getResultFinalOutput(results[results.length - 1]) || "(no output)",
+					},
+				],
+				details: makeDetails("chain")(results),
+			};
+		} finally {
+			status.clear();
+		}
+	}
 
-				const status = startSubagentStatus(ctx, toolCallId, parallelStatus(0, params.tasks.length, params.tasks.length));
-
-				try {
-					// Track all results for streaming updates
-					const allResults: SingleResult[] = new Array(params.tasks.length);
-
-					// Initialize placeholder results
-					for (let i = 0; i < params.tasks.length; i++) {
-						allResults[i] = {
-							agent: params.tasks[i].agent,
-							agentSource: "unknown",
-							task: params.tasks[i].task,
-							exitCode: -1, // -1 = still running
-							messages: [],
-							stderr: "",
-							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-							thinkingLevel: resolveThinkingLevel(params.tasks[i].agent, params.tasks[i].thinkingLevel),
-							finalOutput: "",
-						};
-					}
-
-					let doneCount = 0;
-					let runningCount = params.tasks.length;
-
-					const emitParallelUpdate = () => {
-						status.update(parallelStatus(doneCount, allResults.length, runningCount));
-						if (onUpdate) {
-							const aggregator = params.aggregator;
-							const pendingAggregator: SingleResult | undefined =
-								aggregator && !signal?.aborted && doneCount === allResults.length
-									? {
-											agent: aggregator.agent,
-											agentSource:
-												agents.find((agent) => agent.name === aggregator.agent)?.source ?? "unknown",
-											task: aggregator.task,
-											exitCode: -1,
-											messages: [],
-											stderr: "",
-											usage: {
-												input: 0,
-												output: 0,
-												cacheRead: 0,
-												cacheWrite: 0,
-												cost: 0,
-												contextTokens: 0,
-												turns: 0,
-											},
-											thinkingLevel: resolveThinkingLevel(
-												aggregator.agent,
-												aggregator.thinkingLevel,
-											),
-											timeoutMs: resolveTimeoutMs(aggregator.agent, aggregator.timeoutMs),
-											finalOutput: "",
-										}
-									: undefined;
-							onUpdate({
-								content: [
-									{
-										type: "text",
-										text: `Parallel: ${doneCount}/${allResults.length} done, ${runningCount} running...`,
-									},
-								],
-								details: makeDetails("parallel")([...allResults], pendingAggregator),
-							});
-						}
-					};
+	if (params.tasks && params.tasks.length > 0) {
+		if (params.tasks.length > MAX_PARALLEL_TASKS)
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Too many parallel tasks (${params.tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`,
+					},
+				],
+				details: makeDetails("parallel")([]),
+			};
 
-					const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
-						const result = await runSingleAgent(
-							ctx.cwd,
-							agents,
-							t.agent,
-							t.task,
-							t.cwd,
-							undefined,
-							signal,
-							resolveThinkingLevel(t.agent, t.thinkingLevel),
-							resolveTimeoutMs(t.agent, t.timeoutMs),
-							// Per-task update callback
-							(partial) => {
-								if (partial.details?.results[0]) {
-									allResults[index] = { ...partial.details.results[0], exitCode: -1 };
-									emitParallelUpdate();
-								}
-							},
-							makeDetails("parallel"),
-						);
-						allResults[index] = result;
-						doneCount += 1;
-						runningCount -= 1;
-						emitParallelUpdate();
-						return result;
-					}, signal, (task, index) => {
-						const skipped: SingleResult = {
-							...allResults[index],
-							task: task.task,
-							exitCode: 130,
-							stopReason: "aborted",
-							aborted: true,
-							errorMessage: "Subagent was not started because the parent call was aborted",
-						};
-						allResults[index] = skipped;
-						doneCount += 1;
-						runningCount -= 1;
-						emitParallelUpdate();
-						return skipped;
-					});
+		const status = startSubagentStatus(
+			ctx,
+			toolCallId,
+			parallelStatus(0, params.tasks.length, params.tasks.length),
+		);
+
+		try {
+			// Track all results for streaming updates
+			const allResults: SingleResult[] = new Array(params.tasks.length);
+
+			// Initialize placeholder results
+			for (let i = 0; i < params.tasks.length; i++) {
+				allResults[i] = {
+					agent: params.tasks[i].agent,
+					agentSource: "unknown",
+					task: params.tasks[i].task,
+					exitCode: -1, // -1 = still running
+					messages: [],
+					stderr: "",
+					usage: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						cost: 0,
+						contextTokens: 0,
+						turns: 0,
+					},
+					thinkingLevel: resolveThinkingLevel(params.tasks[i].agent, params.tasks[i].thinkingLevel),
+					finalOutput: "",
+				};
+			}
 
-					let aggregatorResult: SingleResult | undefined;
-					if (params.aggregator && !signal?.aborted) {
-						const aggregator = params.aggregator;
-						status.update(fanInStatus(aggregator.agent));
-						const fanInContext = buildFanInContext(results);
-						const aggregatorTask = truncateUtf8(
-							aggregator.task.includes("{previous}")
-								? aggregator.task.replace(/\{previous\}/g, fanInContext)
-								: `${aggregator.task}\n\nParallel task outputs:\n\n${fanInContext}`,
-							DEFAULT_MAX_CONTEXT_BYTES,
-						).text;
-						aggregatorResult = await runSingleAgent(
-							ctx.cwd,
-							agents,
-							aggregator.agent,
-							aggregatorTask,
-							aggregator.cwd,
-							undefined,
-							signal,
-							resolveThinkingLevel(aggregator.agent, aggregator.thinkingLevel),
-							resolveTimeoutMs(aggregator.agent, aggregator.timeoutMs),
-							(partial) => {
-								status.update(fanInStatus(aggregator.agent));
-								if (onUpdate && partial.details?.results[0]) {
-									onUpdate({
-										content: partial.content,
-										details: makeDetails("parallel")(results, partial.details.results[0]),
-									});
+			let doneCount = 0;
+			let runningCount = params.tasks.length;
+
+			const emitParallelUpdate = () => {
+				status.update(parallelStatus(doneCount, allResults.length, runningCount));
+				if (onUpdate) {
+					const pendingAggregator: SingleResult | undefined =
+						aggregator && !signal?.aborted && doneCount === allResults.length
+							? {
+									agent: aggregator.agent,
+									agentSource:
+										agents.find((agent) => agent.name === aggregator.agent)?.source ?? "unknown",
+									task: aggregator.task,
+									exitCode: -1,
+									messages: [],
+									stderr: "",
+									usage: {
+										input: 0,
+										output: 0,
+										cacheRead: 0,
+										cacheWrite: 0,
+										cost: 0,
+										contextTokens: 0,
+										turns: 0,
+									},
+									thinkingLevel: resolveThinkingLevel(aggregator.agent, aggregator.thinkingLevel),
+									timeoutMs: resolveTimeoutMs(aggregator.agent, aggregator.timeoutMs),
+									finalOutput: "",
 								}
-							},
-							makeDetails("parallel"),
-						);
-					}
-
-					const successCount = results.filter((result) => !isResultError(result)).length;
-					const summaries = results.map((result) => {
-						const failed = isResultError(result);
-						const output = getResultFinalOutput(result);
-						const error = result.errorMessage || result.stderr.trim();
-						const summaryText = failed ? formatResultFailure(result) : output || error;
-						const preview = truncateUtf8(summaryText, 160).text;
-						return `[${result.agent}] ${failed ? "failed" : "completed"}: ${preview || "(no output)"}`;
-					});
-					const aggregatorFailed = aggregatorResult ? isResultError(aggregatorResult) : false;
-					const aggregatorOutput = aggregatorResult ? getResultFinalOutput(aggregatorResult) : "";
-					const aggregatorError = aggregatorResult?.errorMessage || aggregatorResult?.stderr.trim() || "";
-					return {
+							: undefined;
+					onUpdate({
 						content: [
 							{
 								type: "text",
-								text: aggregatorResult
-									? aggregatorFailed
-										? formatResultFailure(aggregatorResult)
-										: aggregatorOutput ||
-											aggregatorError ||
-											`(aggregator ${aggregatorResult.agent} produced no output)`
-									: `Parallel: ${successCount}/${results.length} succeeded\n\n${summaries.join("\n\n")}`,
+								text: `Parallel: ${doneCount}/${allResults.length} done, ${runningCount} running...`,
 							},
 						],
-						details: {
-							...makeDetails("parallel")(results, aggregatorResult),
-							isError: aggregatorFailed,
-						},
-						isError: aggregatorResult ? aggregatorFailed : undefined,
-					};
-				} finally {
-					status.clear();
+						details: makeDetails("parallel")([...allResults], pendingAggregator),
+					});
 				}
-			}
-
-			if (params.agent && params.task) {
-				const status = startSubagentStatus(ctx, toolCallId, singleStatus(params.agent));
+			};
 
-				try {
+			const results = await mapWithConcurrencyLimit(
+				params.tasks,
+				MAX_CONCURRENCY,
+				async (t, index) => {
 					const result = await runSingleAgent(
 						ctx.cwd,
 						agents,
-						params.agent,
-						params.task,
-						params.cwd,
+						t.agent,
+						t.task,
+						t.cwd,
 						undefined,
 						signal,
-						resolveThinkingLevel(params.agent, params.thinkingLevel),
-						resolveTimeoutMs(params.agent, params.timeoutMs),
-						onUpdate,
-						makeDetails("single"),
+						resolveThinkingLevel(t.agent, t.thinkingLevel),
+						resolveTimeoutMs(t.agent, t.timeoutMs),
+						// Per-task update callback
+						(partial) => {
+							if (partial.details?.results[0]) {
+								allResults[index] = { ...partial.details.results[0], exitCode: -1 };
+								emitParallelUpdate();
+							}
+						},
+						makeDetails("parallel"),
 					);
-					const isError = isResultError(result);
-					if (isError) {
-						const errorMsg = formatResultFailure(result);
-						return {
-							content: [{ type: "text", text: `Agent ${result.stopReason || "failed"}: ${errorMsg}` }],
-							details: { ...makeDetails("single")([result]), isError: true },
-							isError: true,
-						};
-					}
-					return {
-						content: [{ type: "text", text: getResultFinalOutput(result) || "(no output)" }],
-						details: makeDetails("single")([result]),
+					allResults[index] = result;
+					doneCount += 1;
+					runningCount -= 1;
+					emitParallelUpdate();
+					return result;
+				},
+				signal,
+				(task, index) => {
+					const skipped: SingleResult = {
+						...allResults[index],
+						task: task.task,
+						exitCode: 130,
+						stopReason: "aborted",
+						aborted: true,
+						errorMessage: "Subagent was not started because the parent call was aborted",
 					};
-				} finally {
-					status.clear();
-				}
+					allResults[index] = skipped;
+					doneCount += 1;
+					runningCount -= 1;
+					emitParallelUpdate();
+					return skipped;
+				},
+			);
+
+			let aggregatorResult: SingleResult | undefined;
+			if (aggregator && !signal?.aborted) {
+				status.update(fanInStatus(aggregator.agent));
+				const fanInContext = buildFanInContext(results);
+				const aggregatorTask = truncateUtf8(
+					aggregator.task.includes("{previous}")
+						? aggregator.task.replace(/\{previous\}/g, fanInContext)
+						: `${aggregator.task}\n\nParallel task outputs:\n\n${fanInContext}`,
+					DEFAULT_MAX_CONTEXT_BYTES,
+				).text;
+				aggregatorResult = await runSingleAgent(
+					ctx.cwd,
+					agents,
+					aggregator.agent,
+					aggregatorTask,
+					aggregator.cwd,
+					undefined,
+					signal,
+					resolveThinkingLevel(aggregator.agent, aggregator.thinkingLevel),
+					resolveTimeoutMs(aggregator.agent, aggregator.timeoutMs),
+					(partial) => {
+						status.update(fanInStatus(aggregator.agent));
+						if (onUpdate && partial.details?.results[0]) {
+							onUpdate({
+								content: partial.content,
+								details: makeDetails("parallel")(results, partial.details.results[0]),
+							});
+						}
+					},
+					makeDetails("parallel"),
+				);
 			}
 
-			const available = agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
+			const successCount = results.filter((result) => !isResultError(result)).length;
+			const summaries = results.map((result) => {
+				const failed = isResultError(result);
+				const output = getResultFinalOutput(result);
+				const error = result.errorMessage || result.stderr.trim();
+				const summaryText = failed ? formatResultFailure(result) : output || error;
+				const preview = truncateUtf8(summaryText, 160).text;
+				return `[${result.agent}] ${failed ? "failed" : "completed"}: ${preview || "(no output)"}`;
+			});
+			const aggregatorFailed = aggregatorResult ? isResultError(aggregatorResult) : false;
+			const aggregatorOutput = aggregatorResult ? getResultFinalOutput(aggregatorResult) : "";
+			const aggregatorError =
+				aggregatorResult?.errorMessage || aggregatorResult?.stderr.trim() || "";
+			return {
+				content: [
+					{
+						type: "text",
+						text: aggregatorResult
+							? aggregatorFailed
+								? formatResultFailure(aggregatorResult)
+								: aggregatorOutput ||
+									aggregatorError ||
+									`(aggregator ${aggregatorResult.agent} produced no output)`
+							: `Parallel: ${successCount}/${results.length} succeeded\n\n${summaries.join("\n\n")}`,
+					},
+				],
+				details: {
+					...makeDetails("parallel")(results, aggregatorResult),
+					isError: aggregatorFailed,
+				},
+				isError: aggregatorResult ? aggregatorFailed : undefined,
+			};
+		} finally {
+			status.clear();
+		}
+	}
+
+	if (params.agent && params.task) {
+		const status = startSubagentStatus(ctx, toolCallId, singleStatus(params.agent));
+
+		try {
+			const result = await runSingleAgent(
+				ctx.cwd,
+				agents,
+				params.agent,
+				params.task,
+				params.cwd,
+				undefined,
+				signal,
+				resolveThinkingLevel(params.agent, params.thinkingLevel),
+				resolveTimeoutMs(params.agent, params.timeoutMs),
+				onUpdate,
+				makeDetails("single"),
+			);
+			const isError = isResultError(result);
+			if (isError) {
+				const errorMsg = formatResultFailure(result);
+				return {
+					content: [{ type: "text", text: `Agent ${result.stopReason || "failed"}: ${errorMsg}` }],
+					details: { ...makeDetails("single")([result]), isError: true },
+					isError: true,
+				};
+			}
 			return {
-				content: [{ type: "text", text: `Invalid parameters. Available agents: ${available}` }],
-				details: makeDetails("single")([]),
+				content: [{ type: "text", text: getResultFinalOutput(result) || "(no output)" }],
+				details: makeDetails("single")([result]),
 			};
+		} finally {
+			status.clear();
+		}
+	}
+
+	const available = agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
+	return {
+		content: [{ type: "text", text: `Invalid parameters. Available agents: ${available}` }],
+		details: makeDetails("single")([]),
+	};
 }

package/src/limits.ts

@@ -31,7 +31,10 @@ export function truncateUtf8(text: string, maxBytes: number): BoundedText {
 			originalBytes,
 		};
 	}
-	const prefix = Buffer.from(text, "utf8").subarray(0, limit - marker.length).toString("utf8").replace(/�+$/g, "");
+	const prefix = Buffer.from(text, "utf8")
+		.subarray(0, limit - marker.length)
+		.toString("utf8")
+		.replace(/�+$/g, "");
 	return { text: `${prefix}${TRUNCATION_MARKER}`, truncated: true, originalBytes };
 }
 
@@ -45,7 +48,10 @@ export function truncateUtf8Tail(text: string, maxBytes: number): BoundedText {
 	const marker = Buffer.from(TAIL_TRUNCATION_MARKER, "utf8");
 	if (marker.length >= limit) {
 		return {
-			text: bytes.subarray(originalBytes - limit).toString("utf8").replace(/^�+/g, ""),
+			text: bytes
+				.subarray(originalBytes - limit)
+				.toString("utf8")
+				.replace(/^�+/g, ""),
 			truncated: true,
 			originalBytes,
 		};

package/src/params.ts

@@ -1,5 +1,5 @@
 import { StringEnum } from "@earendil-works/pi-ai";
-import { Type, type Static } from "typebox";
+import { type Static, Type } from "typebox";
 import { THINKING_LEVELS } from "./agents.js";
 
 const TimeoutMs = Type.Number({
@@ -29,13 +29,25 @@ const ChainItem = Type.Object({
 	thinkingLevel: Type.Optional(ThinkingLevelSchema),
 });
 
-const AggregatorItem = Type.Object({
-	agent: Type.String({ description: "Name of the fan-in agent to invoke after parallel tasks complete" }),
-	task: Type.String({ description: "Fan-in task. Use {previous} to include all parallel outputs." }),
-	cwd: Type.Optional(Type.String({ description: "Working directory for the aggregator process" })),
-	timeoutMs: Type.Optional(TimeoutMs),
-	thinkingLevel: Type.Optional(ThinkingLevelSchema),
-});
+const AggregatorItem = Type.Object(
+	{
+		agent: Type.String({
+			description: "Name of the fan-in agent to invoke after parallel tasks complete",
+		}),
+		task: Type.String({
+			description: "Fan-in task. Use {previous} to include all parallel outputs.",
+		}),
+		cwd: Type.Optional(
+			Type.String({ description: "Working directory for the aggregator process" }),
+		),
+		timeoutMs: Type.Optional(TimeoutMs),
+		thinkingLevel: Type.Optional(ThinkingLevelSchema),
+	},
+	{
+		description:
+			"Optional fan-in step for parallel mode. Omit this key entirely when no aggregation is needed; empty or whitespace-only agent/task values are treated as absent.",
+	},
+);
 
 const AgentScopeSchema = StringEnum(["user", "project", "both"] as const, {
 	description:
@@ -44,18 +56,42 @@ const AgentScopeSchema = StringEnum(["user", "project", "both"] as const, {
 });
 
 export const SubagentParams = Type.Object({
-	agent: Type.Optional(Type.String({ description: "Name of the agent to invoke (for single mode)" })),
+	agent: Type.Optional(
+		Type.String({ description: "Name of the agent to invoke (for single mode)" }),
+	),
 	task: Type.Optional(Type.String({ description: "Task to delegate (for single mode)" })),
-	tasks: Type.Optional(Type.Array(TaskItem, { description: "Array of {agent, task} for parallel execution" })),
-	chain: Type.Optional(Type.Array(ChainItem, { description: "Array of {agent, task} for sequential execution" })),
+	tasks: Type.Optional(
+		Type.Array(TaskItem, { description: "Array of {agent, task} for parallel execution" }),
+	),
+	chain: Type.Optional(
+		Type.Array(ChainItem, { description: "Array of {agent, task} for sequential execution" }),
+	),
 	aggregator: Type.Optional(AggregatorItem),
 	agentScope: Type.Optional(AgentScopeSchema),
 	confirmProjectAgents: Type.Optional(
-		Type.Boolean({ description: "Prompt before running project-local agents. Default: true.", default: true }),
+		Type.Boolean({
+			description: "Prompt before running project-local agents. Default: true.",
+			default: true,
+		}),
+	),
+	cwd: Type.Optional(
+		Type.String({ description: "Working directory for the agent process (single mode)" }),
 	),
-	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process (single mode)" })),
 	timeoutMs: Type.Optional(TimeoutMs),
 	thinkingLevel: Type.Optional(ThinkingLevelSchema),
 });
 
 export type SubagentParams = Static<typeof SubagentParams>;
+
+export function hasUsableAggregator(
+	aggregator: unknown,
+): aggregator is { agent: string; task: string } {
+	if (!aggregator || typeof aggregator !== "object") return false;
+	const candidate = aggregator as { agent?: unknown; task?: unknown };
+	return (
+		typeof candidate.agent === "string" &&
+		candidate.agent.trim().length > 0 &&
+		typeof candidate.task === "string" &&
+		candidate.task.trim().length > 0
+	);
+}

package/src/render.ts

@@ -9,7 +9,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import type { AgentScope, SubagentThinkingLevel } from "./agents.js";
-import type { SubagentParams } from "./params.js";
+import { hasUsableAggregator, type SubagentParams } from "./params.js";
 import {
 	getResultFinalOutput,
 	isResultError,
@@ -19,6 +19,15 @@ import {
 
 const COLLAPSED_ITEM_COUNT = 10;
 
+function previewTask(task: unknown, maxLength = 40): string {
+	if (typeof task !== "string" || task.length === 0) return "...";
+	return task.length > maxLength ? `${task.slice(0, maxLength)}...` : task;
+}
+
+function previewAgent(agent: unknown): string {
+	return typeof agent === "string" && agent.length > 0 ? agent : "...";
+}
+
 export function formatTokens(count: number): string {
 	if (count < 1000) return count.toString();
 	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
@@ -180,16 +189,16 @@ export function renderSubagentCall(args: SubagentParams, theme: Theme) {
 			theme.fg("accent", `chain (${args.chain.length} steps)`) +
 			theme.fg("muted", ` [${scope}]`);
 		for (let i = 0; i < Math.min(args.chain.length, 3); i++) {
-			const step = args.chain[i];
+			const step = args.chain[i] as { agent?: unknown; task?: unknown } | undefined;
 			// Clean up {previous} placeholder for display
-			const cleanTask = step.task.replace(/\{previous\}/g, "").trim();
-			const preview = cleanTask.length > 40 ? `${cleanTask.slice(0, 40)}...` : cleanTask;
+			const cleanTask =
+				typeof step?.task === "string" ? step.task.replace(/\{previous\}/g, "").trim() : undefined;
 			text +=
 				"\n  " +
 				theme.fg("muted", `${i + 1}.`) +
 				" " +
-				theme.fg("accent", step.agent) +
-				theme.fg("dim", ` ${preview}`);
+				theme.fg("accent", previewAgent(step?.agent)) +
+				theme.fg("dim", ` ${previewTask(cleanTask)}`);
 		}
 		if (args.chain.length > 3)
 			text += `\n  ${theme.fg("muted", `... +${args.chain.length - 3} more`)}`;
@@ -200,30 +209,23 @@ export function renderSubagentCall(args: SubagentParams, theme: Theme) {
 			theme.fg("toolTitle", theme.bold("subagent ")) +
 			theme.fg("accent", `parallel (${args.tasks.length} tasks)`) +
 			theme.fg("muted", ` [${scope}]`);
-		for (const t of args.tasks.slice(0, 3)) {
-			const preview = t.task.length > 40 ? `${t.task.slice(0, 40)}...` : t.task;
-			text += `\n  ${theme.fg("accent", t.agent)}${theme.fg("dim", ` ${preview}`)}`;
+		for (const task of args.tasks.slice(0, 3)) {
+			const item = task as { agent?: unknown; task?: unknown } | undefined;
+			text += `\n  ${theme.fg("accent", previewAgent(item?.agent))}${theme.fg("dim", ` ${previewTask(item?.task)}`)}`;
 		}
 		if (args.tasks.length > 3)
 			text += `\n  ${theme.fg("muted", `... +${args.tasks.length - 3} more`)}`;
-		if (args.aggregator) {
-			const preview =
-				args.aggregator.task.length > 40
-					? `${args.aggregator.task.slice(0, 40)}...`
-					: args.aggregator.task;
-			text += `\n  ${theme.fg("muted", "fan-in → ")}${theme.fg("accent", args.aggregator.agent)}${theme.fg(
+		if (hasUsableAggregator(args.aggregator)) {
+			const aggregator = args.aggregator;
+			text += `\n  ${theme.fg("muted", "fan-in → ")}${theme.fg("accent", previewAgent(aggregator.agent))}${theme.fg(
 				"dim",
-				` ${preview}`,
+				` ${previewTask(aggregator.task)}`,
 			)}`;
 		}
 		return new Text(text, 0, 0);
 	}
-	const agentName = args.agent || "...";
-	const preview = args.task
-		? args.task.length > 60
-			? `${args.task.slice(0, 60)}...`
-			: args.task
-		: "...";
+	const agentName = previewAgent(args.agent);
+	const preview = previewTask(args.task, 60);
 	let text =
 		theme.fg("toolTitle", theme.bold("subagent ")) +
 		theme.fg("accent", agentName) +
@@ -438,8 +440,7 @@ export function renderSubagentResult(
 			const collapsed = getCollapsedDisplayItems(r);
 			const finalOutput = getResultFinalOutput(r).trim();
 			text += `\n\n${theme.fg("muted", `─── Step ${r.step}: `)}${theme.fg("accent", r.agent)} ${rIcon}`;
-			if (rFailed && r.errorMessage)
-				text += `\n${theme.fg("error", `Error: ${r.errorMessage}`)}`;
+			if (rFailed && r.errorMessage) text += `\n${theme.fg("error", `Error: ${r.errorMessage}`)}`;
 			if (collapsed.items.length > 0)
 				text += `\n${renderDisplayItems(collapsed.items, 5, collapsed.total)}`;
 			else if (currentIsRunning && r === currentResult)
@@ -603,8 +604,7 @@ export function renderSubagentResult(
 			const collapsed = getCollapsedDisplayItems(r);
 			const finalOutput = getResultFinalOutput(r).trim();
 			text += `\n\n${theme.fg("muted", "─── ")}${theme.fg("accent", r.agent)} ${rIcon}`;
-			if (rFailed && r.errorMessage)
-				text += `\n${theme.fg("error", `Error: ${r.errorMessage}`)}`;
+			if (rFailed && r.errorMessage) text += `\n${theme.fg("error", `Error: ${r.errorMessage}`)}`;
 			if (collapsed.items.length > 0)
 				text += `\n${renderDisplayItems(collapsed.items, 5, collapsed.total)}`;
 			else if (rRunning) text += `\n${theme.fg("muted", "(running...)")}`;

package/src/settings.ts

@@ -261,8 +261,7 @@ export function inspectCompletionDeliverySettings(): CompletionDeliverySettingsS
 		const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
 		const settings = normalizeSubagentSettings(raw);
 		if (!settings) throw new Error(`${SETTINGS_FILE} is not a valid settings object`);
-		const explicit =
-			isPlainObject(raw.stateful) && hasOwn(raw.stateful, "completionDelivery");
+		const explicit = isPlainObject(raw.stateful) && hasOwn(raw.stateful, "completionDelivery");
 		return {
 			path: configPath,
 			value: settings.stateful?.completionDelivery ?? DEFAULT_COMPLETION_DELIVERY,

package/src/stateful-prompt.ts

@@ -1,14 +1,11 @@
 import type { AgentConfig } from "./agents.js";
+import { redactPrivateText } from "./context.js";
 import { resolveDefaultSubagentTimeoutMs } from "./execution.js";
 import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8 } from "./limits.js";
-import { redactPrivateText } from "./context.js";
 import type { ManagedAgent } from "./registry.js";
 
 export function buildStatefulTurnPrompt(
-	record: Pick<
-		ManagedAgent,
-		"context" | "history" | "mailbox" | "currentMailboxMessageIds"
-	>,
+	record: Pick<ManagedAgent, "context" | "history" | "mailbox" | "currentMailboxMessageIds">,
 	task: string,
 	maxBytes = DEFAULT_MAX_CONTEXT_BYTES,
 ): { text: string; truncated: boolean } {

package/src/subagents.ts

@@ -41,6 +41,7 @@ export default function (pi: ExtensionAPI) {
 			"Use the blocking subagent tool only when delegated outputs are required before the main agent's next action and waiting is intentional; the main agent cannot process queued steering until the call returns.",
 			"Use a blocking subagent single, parallel, chain, or fan-in call only when synchronous context or output isolation is worth making the main agent unavailable while it runs.",
 			"If a blocking parallel subagent call is genuinely required, keep tasks independent, stay within the hard max 8, and avoid write-heavy implementation touching the same files or shared state.",
+			"For parallel subagent calls, omit the aggregator key entirely unless a fan-in step is required; do not send null, empty strings, or an empty object for unused optional fields.",
 			'Do not use subagent with project-local agents unless the user explicitly wants project agents or sets agentScope to "project" or "both"; keep confirmation enabled for untrusted repositories.',
 			"When using subagent, write self-contained tasks with file paths, context, expected output, and whether the subagent may edit files.",
 		],

package/src/workspace.ts

@@ -27,10 +27,10 @@ export class WorkspaceManager {
 		if (relativeCwd.startsWith("..") || path.isAbsolute(relativeCwd)) {
 			throw new Error("Subagent cwd is outside the Git repository");
 		}
-		const status = (
-			await execFileAsync("git", ["-C", repositoryRoot, "status", "--porcelain"])
-		).stdout;
-		if (status.trim()) throw new Error("Isolated subagent workspace requires a clean Git repository");
+		const status = (await execFileAsync("git", ["-C", repositoryRoot, "status", "--porcelain"]))
+			.stdout;
+		if (status.trim())
+			throw new Error("Isolated subagent workspace requires a clean Git repository");
 		const rootPath = await fs.promises.mkdtemp(path.join(os.tmpdir(), WORKTREE_PREFIX));
 		let registered = false;
 		try {
@@ -86,8 +86,9 @@ export class WorkspaceManager {
 			workspace.rootPath,
 		]).catch(async () => {
 			await fs.promises.rm(workspace.rootPath, { recursive: true, force: true });
-			await execFileAsync("git", ["-C", workspace.repositoryRoot, "worktree", "prune"])
-				.catch(() => undefined);
+			await execFileAsync("git", ["-C", workspace.repositoryRoot, "worktree", "prune"]).catch(
+				() => undefined,
+			);
 		});
 		await fs.promises.rm(`${workspace.rootPath}.owner`, { force: true });
 	}