@oh-my-pi/pi-coding-agent 3.30.0 → 3.31.0

package/src/core/tools/task/index.ts

@@ -21,7 +21,6 @@ import { formatDuration } from "../render-utils";
 import { cleanupTempDir, createTempArtifactsDir, getArtifactsDir } from "./artifacts";
 import { discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
-import { generateTaskName } from "./name-generator";
 import { mapWithConcurrencyLimit } from "./parallel";
 import { renderCall, renderResult } from "./render";
 import {
@@ -135,17 +134,34 @@ export async function createTaskTool(
 		execute: async (_toolCallId, params, signal, onUpdate) => {
 			const startTime = Date.now();
 			const { agents, projectAgentsDir } = await discoverAgents(session.cwd);
-			const context = params.context;
-			const outputSchema = params.output_schema;
+			const { agent: agentName, context, model, output: outputSchema } = params;
+
+			// Validate agent exists
+			const agent = getAgent(agents, agentName);
+			if (!agent) {
+				const available = agents.map((a) => a.name).join(", ") || "none";
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Unknown agent "${agentName}". Available: ${available}`,
+						},
+					],
+					details: {
+						projectAgentsDir,
+						results: [],
+						totalDurationMs: 0,
+					},
+				};
+			}
 
 			// Handle empty or missing tasks
 			if (!params.tasks || params.tasks.length === 0) {
-				const available = agents.map((a) => a.name).join(", ") || "none";
 				return {
 					content: [
 						{
 							type: "text",
-							text: `No tasks provided. Use: { tasks: [{agent, task}, ...] }\nAvailable agents: ${available}`,
+							text: `No tasks provided. Use: { agent, context, tasks: [{id, task, description}, ...] }`,
 						},
 					],
 					details: {
@@ -173,6 +189,56 @@ export async function createTaskTool(
 				};
 			}
 
+			const tasks = params.tasks;
+			const missingTaskIndexes: number[] = [];
+			const idIndexes = new Map<string, number[]>();
+
+			for (let i = 0; i < tasks.length; i++) {
+				const id = tasks[i]?.id;
+				if (typeof id !== "string" || id.trim() === "") {
+					missingTaskIndexes.push(i);
+					continue;
+				}
+				const normalizedId = id.toLowerCase();
+				const indexes = idIndexes.get(normalizedId);
+				if (indexes) {
+					indexes.push(i);
+				} else {
+					idIndexes.set(normalizedId, [i]);
+				}
+			}
+
+			const duplicateIds: Array<{ id: string; indexes: number[] }> = [];
+			for (const [normalizedId, indexes] of idIndexes.entries()) {
+				if (indexes.length > 1) {
+					duplicateIds.push({
+						id: tasks[indexes[0]]?.id ?? normalizedId,
+						indexes,
+					});
+				}
+			}
+
+			if (missingTaskIndexes.length > 0 || duplicateIds.length > 0) {
+				const problems: string[] = [];
+				if (missingTaskIndexes.length > 0) {
+					problems.push(`Missing task ids at indexes: ${missingTaskIndexes.join(", ")}`);
+				}
+				if (duplicateIds.length > 0) {
+					const details = duplicateIds
+						.map((entry) => `${entry.id} (indexes ${entry.indexes.join(", ")})`)
+						.join("; ");
+					problems.push(`Duplicate task ids detected (case-insensitive): ${details}`);
+				}
+				return {
+					content: [{ type: "text", text: `Invalid tasks: ${problems.join(". ")}` }],
+					details: {
+						projectAgentsDir,
+						results: [],
+						totalDurationMs: 0,
+					},
+				};
+			}
+
 			// Derive artifacts directory
 			const sessionFile = session.getSessionFile();
 			const artifactsDir = sessionFile ? getArtifactsDir(sessionFile) : null;
@@ -197,88 +263,59 @@ export async function createTaskTool(
 			};
 
 			try {
-				let tasks = params.tasks;
-				let skippedSelfRecursion = 0;
-
-				// Filter out blocked agent (self-recursion prevention)
-				if (blockedAgent) {
-					const blockedTasks = tasks.filter((t) => t.agent === blockedAgent);
-					tasks = tasks.filter((t) => t.agent !== blockedAgent);
-					skippedSelfRecursion = blockedTasks.length;
-
-					if (skippedSelfRecursion > 0 && tasks.length === 0) {
-						return {
-							content: [
-								{
-									type: "text",
-									text: `Cannot spawn ${blockedAgent} agent from within itself (recursion prevention). Use a different agent type.`,
-								},
-							],
-							details: {
-								projectAgentsDir,
-								results: [],
-								totalDurationMs: Date.now() - startTime,
+				// Check self-recursion prevention
+				if (blockedAgent && agentName === blockedAgent) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: `Cannot spawn ${blockedAgent} agent from within itself (recursion prevention). Use a different agent type.`,
 							},
-						};
-					}
-				}
-
-				// Validate all agents exist
-				for (const task of tasks) {
-					if (!getAgent(agents, task.agent)) {
-						const available = agents.map((a) => a.name).join(", ");
-						return {
-							content: [{ type: "text", text: `Unknown agent: ${task.agent}. Available: ${available}` }],
-							details: {
-								projectAgentsDir,
-								results: [],
-								totalDurationMs: Date.now() - startTime,
-							},
-						};
-					}
+						],
+						details: {
+							projectAgentsDir,
+							results: [],
+							totalDurationMs: Date.now() - startTime,
+						},
+					};
 				}
 
 				// Check spawn restrictions from parent
 				const parentSpawns = session.getSessionSpawns() ?? "*";
 				const allowedSpawns = parentSpawns.split(",").map((s) => s.trim());
-				const isSpawnAllowed = (agentName: string): boolean => {
+				const isSpawnAllowed = (): boolean => {
 					if (parentSpawns === "") return false; // Empty = deny all
 					if (parentSpawns === "*") return true; // Wildcard = allow all
 					return allowedSpawns.includes(agentName);
 				};
 
-				for (const task of tasks) {
-					if (!isSpawnAllowed(task.agent)) {
-						const allowed = parentSpawns === "" ? "none (spawns disabled for this agent)" : parentSpawns;
-						return {
-							content: [{ type: "text", text: `Cannot spawn '${task.agent}'. Allowed: ${allowed}` }],
-							details: {
-								projectAgentsDir,
-								results: [],
-								totalDurationMs: Date.now() - startTime,
-							},
-						};
-					}
+				if (!isSpawnAllowed()) {
+					const allowed = parentSpawns === "" ? "none (spawns disabled for this agent)" : parentSpawns;
+					return {
+						content: [{ type: "text", text: `Cannot spawn '${agentName}'. Allowed: ${allowed}` }],
+						details: {
+							projectAgentsDir,
+							results: [],
+							totalDurationMs: Date.now() - startTime,
+						},
+					};
 				}
 
-				// Build full prompts with context prepended and generate task IDs
+				// Build full prompts with context prepended
 				const tasksWithContext = tasks.map((t) => ({
-					agent: t.agent,
 					task: context ? `${context}\n\n${t.task}` : t.task,
-					model: t.model,
 					description: t.description,
-					taskId: generateTaskName(),
+					taskId: t.id,
 				}));
 
 				// Initialize progress for all tasks
 				for (let i = 0; i < tasksWithContext.length; i++) {
 					const t = tasksWithContext[i];
-					const agentCfg = getAgent(agents, t.agent);
 					progressMap.set(i, {
 						index: i,
 						taskId: t.taskId,
-						agent: t.agent,
-						agentSource: agentCfg?.source ?? "user",
+						agent: agentName,
+						agentSource: agent.source,
 						status: "pending",
 						task: t.task,
 						recentTools: [],
@@ -286,36 +323,40 @@ export async function createTaskTool(
 						toolCount: 0,
 						tokens: 0,
 						durationMs: 0,
-						modelOverride: t.model,
+						modelOverride: model,
 						description: t.description,
 					});
 				}
 				emitProgress();
 
 				// Execute in parallel with concurrency limit
-				const results = await mapWithConcurrencyLimit(tasksWithContext, MAX_CONCURRENCY, async (task, index) => {
-					const agent = getAgent(agents, task.agent)!;
-					return runSubprocess({
-						cwd: session.cwd,
-						agent,
-						task: task.task,
-						description: task.description,
-						index,
-						taskId: task.taskId,
-						context: undefined, // Already prepended above
-						modelOverride: task.model,
-						outputSchema,
-						sessionFile,
-						persistArtifacts: !!artifactsDir,
-						artifactsDir: effectiveArtifactsDir,
-						signal,
-						eventBus: undefined,
-						onProgress: (progress) => {
-							progressMap.set(index, structuredClone(progress));
-							emitProgress();
-						},
-					});
-				});
+				const results = await mapWithConcurrencyLimit(
+					tasksWithContext,
+					MAX_CONCURRENCY,
+					async (task, index) => {
+						return runSubprocess({
+							cwd: session.cwd,
+							agent,
+							task: task.task,
+							description: task.description,
+							index,
+							taskId: task.taskId,
+							context: undefined, // Already prepended above
+							modelOverride: model,
+							outputSchema,
+							sessionFile,
+							persistArtifacts: !!artifactsDir,
+							artifactsDir: effectiveArtifactsDir,
+							signal,
+							eventBus: undefined,
+							onProgress: (progress) => {
+								progressMap.set(index, structuredClone(progress));
+								emitProgress();
+							},
+						});
+					},
+					signal,
+				);
 
 				// Aggregate usage from executor results (already accumulated incrementally)
 				const aggregatedUsage = createUsageTotals();
@@ -349,14 +390,10 @@ export async function createTaskTool(
 					return `[${r.agent}] ${status}${meta} ${r.taskId}\n${preview}`;
 				});
 
-				const skippedNote =
-					skippedSelfRecursion > 0
-						? ` (${skippedSelfRecursion} ${blockedAgent} task${skippedSelfRecursion > 1 ? "s" : ""} skipped - self-recursion blocked)`
-						: "";
 				const outputIds = results.map((r) => r.taskId);
 				const outputHint =
 					outputIds.length > 0 ? `\n\nUse output tool for full logs: output ids ${outputIds.join(", ")}` : "";
-				const summary = `${successCount}/${results.length} succeeded${skippedNote} [${formatDuration(
+				const summary = `${successCount}/${results.length} succeeded [${formatDuration(
 					totalDuration,
 				)}]\n\n${summaries.join("\n\n---\n\n")}${outputHint}`;
 

package/src/core/tools/task/parallel.ts

@@ -7,24 +7,45 @@ import { MAX_CONCURRENCY } from "./types";
 /**
  * Execute items with a concurrency limit using a worker pool pattern.
  * Results are returned in the same order as input items.
+ * Fails fast on first error - does not wait for other workers to complete.
  *
  * @param items - Items to process
  * @param concurrency - Maximum concurrent operations
  * @param fn - Async function to execute for each item
+ * @param signal - Optional abort signal to stop scheduling work
  */
 export async function mapWithConcurrencyLimit<T, R>(
 	items: T[],
 	concurrency: number,
 	fn: (item: T, index: number) => Promise<R>,
+	signal?: AbortSignal,
 ): Promise<R[]> {
 	const limit = Math.max(1, Math.min(concurrency, items.length, MAX_CONCURRENCY));
 	const results: R[] = new Array(items.length);
 	let nextIndex = 0;
 
+	// Create internal abort controller to cancel workers on any rejection
+	const abortController = new AbortController();
+	const workerSignal = signal ? AbortSignal.any([signal, abortController.signal]) : abortController.signal;
+
+	// Promise that rejects on first error - used to fail fast
+	let rejectFirst: (error: unknown) => void;
+	const firstErrorPromise = new Promise<never>((_, reject) => {
+		rejectFirst = reject;
+	});
+
 	const worker = async (): Promise<void> => {
-		while (nextIndex < items.length) {
+		while (true) {
+			workerSignal.throwIfAborted();
 			const index = nextIndex++;
-			results[index] = await fn(items[index], index);
+			if (index >= items.length) return;
+			try {
+				results[index] = await fn(items[index], index);
+			} catch (error) {
+				abortController.abort();
+				rejectFirst(error);
+				throw error;
+			}
 		}
 	};
 
@@ -32,7 +53,13 @@ export async function mapWithConcurrencyLimit<T, R>(
 	const workers = Array(limit)
 		.fill(null)
 		.map(() => worker());
+	await Promise.race([Promise.all(workers), firstErrorPromise]);
+
+	// Check external abort
+	if (signal?.aborted) {
+		const reason = signal.reason instanceof Error ? signal.reason : new Error("Aborted");
+		throw reason;
+	}
 
-	await Promise.all(workers);
 	return results;
 }

package/src/core/tools/task/render.ts

@@ -58,12 +58,20 @@ function formatFindingSummary(findings: ReportFindingDetails[], theme: Theme): s
 		counts.set(finding.priority, (counts.get(finding.priority) ?? 0) + 1);
 	}
 
+	const priorityMeta: Record<number, { icon: string; color: "error" | "warning" | "muted" | "accent" }> = {
+		0: { icon: theme.styledSymbol("status.error", "error"), color: "error" },
+		1: { icon: theme.styledSymbol("status.warning", "warning"), color: "warning" },
+		2: { icon: theme.styledSymbol("status.warning", "muted"), color: "muted" },
+		3: { icon: theme.styledSymbol("status.info", "accent"), color: "accent" },
+	};
+
 	const parts: string[] = [];
 	for (const priority of [0, 1, 2, 3]) {
 		const label = PRIORITY_LABELS[priority] ?? "P?";
-		const color = priority === 0 ? "error" : priority === 1 ? "warning" : "muted";
+		const meta = priorityMeta[priority] ?? { icon: "", color: "muted" as const };
 		const count = counts.get(priority) ?? 0;
-		parts.push(theme.fg(color, `${label}:${count}`));
+		const text = theme.fg(meta.color, `${label}:${count}`);
+		parts.push(meta.icon ? `${meta.icon} ${text}` : text);
 	}
 
 	return `${theme.fg("dim", "Findings:")} ${parts.join(theme.sep.dot)}`;
@@ -123,13 +131,19 @@ function renderJsonTreeLines(
 			pushLine(`${prefix}${iconArray} ${header}`);
 			if (val.length === 0) {
 				pushLine(
-					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg("dim", "[]")}`,
+					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg(
+						"dim",
+						"[]",
+					)}`,
 				);
 				return;
 			}
 			if (depth >= maxDepth) {
 				pushLine(
-					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg("dim", theme.format.ellipsis)}`,
+					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg(
+						"dim",
+						theme.format.ellipsis,
+					)}`,
 				);
 				return;
 			}
@@ -150,13 +164,19 @@ function renderJsonTreeLines(
 			const entries = Object.entries(val as Record<string, unknown>);
 			if (entries.length === 0) {
 				pushLine(
-					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg("dim", "{}")}`,
+					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg(
+						"dim",
+						"{}",
+					)}`,
 				);
 				return;
 			}
 			if (depth >= maxDepth) {
 				pushLine(
-					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg("dim", theme.format.ellipsis)}`,
+					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg(
+						"dim",
+						theme.format.ellipsis,
+					)}`,
 				);
 				return;
 			}
@@ -233,19 +253,25 @@ function renderOutputSection(
  */
 export function renderCall(args: TaskParams, theme: Theme): Component {
 	const label = theme.fg("toolTitle", theme.bold("Task"));
+	const agentTag = theme.italic(
+		theme.fg("dim", `${theme.format.bracketLeft}${args.agent}${theme.format.bracketRight}`),
+	);
 
 	if (args.tasks.length === 1) {
-		// Single task - show agent and task preview
+		// Single task - show description preview
 		const task = args.tasks[0];
-		const summary = task.description?.trim() || task.task;
-		const taskPreview = truncate(summary, 60, theme.format.ellipsis);
-		return new Text(`${label} ${theme.fg("accent", task.agent)}: ${theme.fg("muted", taskPreview)}`, 0, 0);
+		const summary = task.description.trim() || task.task;
+		const taskPreview = truncate(summary, 50, theme.format.ellipsis);
+		return new Text(`${label} ${agentTag} ${theme.fg("muted", taskPreview)}`, 0, 0);
 	}
 
-	// Multiple tasks - show count and descriptions (or agent names as fallback)
-	const agents = args.tasks.map((t) => t.description?.trim() || t.agent).join(", ");
+	// Multiple tasks - show count and descriptions
+	const descriptions = args.tasks.map((t) => t.description.trim()).join(", ");
 	return new Text(
-		`${label} ${theme.fg("muted", `${args.tasks.length} agents: ${truncate(agents, 50, theme.format.ellipsis)}`)}`,
+		`${label} ${agentTag} ${args.tasks.length} agents: ${theme.fg(
+			"muted",
+			truncate(descriptions, 50, theme.format.ellipsis),
+		)}`,
 		0,
 		0,
 	);
@@ -275,23 +301,14 @@ function renderAgentProgress(
 				? "error"
 				: "accent";
 
-	// Main status line - use taskId for Output tool
-	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", progress.taskId)}`;
+	// Main status line: taskId: description [status] · stats · ⟨agent⟩
 	const description = progress.description?.trim();
-	if (description) {
-		statusLine += ` ${theme.fg("muted", truncate(description, 40, theme.format.ellipsis))}`;
-	}
+	const titlePart = description ? `${theme.bold(progress.taskId)}: ${description}` : progress.taskId;
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)}`;
 
 	// Only show badge for non-running states (spinner already indicates running)
-	if (progress.status !== "running") {
-		const statusLabel =
-			progress.status === "completed"
-				? "done"
-				: progress.status === "failed"
-					? "failed"
-					: progress.status === "aborted"
-						? "aborted"
-						: "pending";
+	if (progress.status === "failed" || progress.status === "aborted") {
+		const statusLabel = progress.status === "failed" ? "failed" : "aborted";
 		statusLine += ` ${formatBadge(statusLabel, iconColor, theme)}`;
 	}
 
@@ -338,6 +355,21 @@ function renderAgentProgress(
 
 	// Render extracted tool data inline (e.g., review findings)
 	if (progress.extractedToolData) {
+		// For completed tasks, check for review verdict from complete tool
+		if (progress.status === "completed") {
+			const completeData = progress.extractedToolData.complete as Array<{ data: unknown }> | undefined;
+			const reportFindingData = progress.extractedToolData.report_finding as ReportFindingDetails[] | undefined;
+			const reviewData = completeData
+				?.map((c) => c.data as SubmitReviewDetails)
+				.filter((d) => d && typeof d === "object" && "overall_correctness" in d);
+			if (reviewData && reviewData.length > 0) {
+				const summary = reviewData[reviewData.length - 1];
+				const findings = reportFindingData ?? [];
+				lines.push(...renderReviewResult(summary, findings, continuePrefix, expanded, theme));
+				return lines; // Review result handles its own rendering
+			}
+		}
+
 		for (const [toolName, dataArray] of Object.entries(progress.extractedToolData)) {
 			const handler = subprocessToolRegistry.getHandler(toolName);
 			if (handler?.renderInline) {
@@ -381,7 +413,10 @@ function renderReviewResult(
 	const verdictColor = summary.overall_correctness === "correct" ? "success" : "error";
 	const verdictIcon = summary.overall_correctness === "correct" ? theme.status.success : theme.status.error;
 	lines.push(
-		`${continuePrefix}${theme.fg(verdictColor, verdictIcon)} Patch is ${theme.fg(verdictColor, summary.overall_correctness)} ${theme.fg("dim", `(${(summary.confidence * 100).toFixed(0)}% confidence)`)}`,
+		`${continuePrefix} Patch is ${theme.fg(verdictColor, summary.overall_correctness)} ${theme.fg(
+			verdictColor,
+			verdictIcon,
+		)} ${theme.fg("dim", `(${(summary.confidence * 100).toFixed(0)}% confidence)`)}`,
 	);
 
 	// Explanation preview (first ~80 chars when collapsed, full when expanded)
@@ -395,7 +430,7 @@ function renderReviewResult(
 		} else {
 			// Preview: first sentence or ~100 chars
 			const preview = truncate(`${summary.explanation.split(/[.!?]/)[0]}.`, 100, theme.format.ellipsis);
-			lines.push(`${continuePrefix}${theme.fg("dim", `Summary: ${preview}`)}`);
+			lines.push(`${continuePrefix}${theme.fg("dim", preview)}`);
 		}
 	}
 
@@ -411,7 +446,7 @@ function renderReviewResult(
 }
 
 /**
- * Render review findings list (used with and without submit_review).
+ * Render review findings list.
  */
 function renderFindings(
 	findings: ReportFindingDetails[],
@@ -472,12 +507,14 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	const iconColor = success ? "success" : "error";
 	const statusText = aborted ? "aborted" : success ? "done" : "failed";
 
-	// Main status line - use taskId for Output tool
-	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", result.taskId)} ${formatBadge(statusText, iconColor, theme)}`;
+	// Main status line: taskId: description [status] · stats · ⟨agent⟩
 	const description = result.description?.trim();
-	if (description) {
-		statusLine += ` ${theme.fg("muted", truncate(description, 40, theme.format.ellipsis))}`;
-	}
+	const titlePart = description ? `${theme.bold(result.taskId)}: ${description}` : result.taskId;
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)} ${formatBadge(
+		statusText,
+		iconColor,
+		theme,
+	)}`;
 	if (result.tokens > 0) {
 		statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatTokens(result.tokens)} tokens`)}`;
 	}
@@ -489,10 +526,16 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 
 	lines.push(statusLine);
 
-	// Check for review result (submit_review + report_finding)
-	const submitReviewData = result.extractedToolData?.submit_review as SubmitReviewDetails[] | undefined;
+	// Check for review result (complete with review schema + report_finding)
+	const completeData = result.extractedToolData?.complete as Array<{ data: unknown }> | undefined;
 	const reportFindingData = result.extractedToolData?.report_finding as ReportFindingDetails[] | undefined;
 
+	// Extract review verdict from complete tool's data field if it matches SubmitReviewDetails
+	const reviewData = completeData
+		?.map((c) => c.data as SubmitReviewDetails)
+		.filter((d) => d && typeof d === "object" && "overall_correctness" in d);
+	const submitReviewData = reviewData && reviewData.length > 0 ? reviewData : undefined;
+
 	if (submitReviewData && submitReviewData.length > 0) {
 		// Use combined review renderer
 		const summary = submitReviewData[submitReviewData.length - 1];
@@ -502,7 +545,10 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	}
 	if (reportFindingData && reportFindingData.length > 0) {
 		lines.push(
-			`${continuePrefix}${theme.fg("warning", theme.status.warning)} ${theme.fg("dim", "Review summary missing (submit_review not called)")}`,
+			`${continuePrefix}${theme.fg("warning", theme.status.warning)} ${theme.fg(
+				"dim",
+				"Review summary missing (complete not called)",
+			)}`,
 		);
 		lines.push(`${continuePrefix}${formatFindingSummary(reportFindingData, theme)}`);
 		lines.push(`${continuePrefix}`); // Spacing
@@ -515,7 +561,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	if (result.extractedToolData) {
 		for (const [toolName, dataArray] of Object.entries(result.extractedToolData)) {
 			// Skip review tools - handled above
-			if (toolName === "submit_review" || toolName === "report_finding") continue;
+			if (toolName === "complete" || toolName === "report_finding") continue;
 
 			const handler = subprocessToolRegistry.getHandler(toolName);
 			if (handler?.renderFinal && (dataArray as unknown[]).length > 0) {

package/src/core/tools/task/types.ts

@@ -41,20 +41,29 @@ export const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
 
 /** Single task item for parallel execution */
 export const taskItemSchema = Type.Object({
-	agent: Type.String({ description: "Agent name" }),
+	id: Type.String({
+		description: "Short task identifier for display (max 32 chars, CamelCase, e.g. 'SessionStore', 'WebFetchFix')",
+		maxLength: 32,
+		pattern: "^[A-Za-z][A-Za-z0-9]*$",
+	}),
 	task: Type.String({ description: "Task description for the agent" }),
-	description: Type.Optional(Type.String({ description: "Short description for UI display" })),
-	model: Type.Optional(Type.String({ description: "Model override for this task" })),
+	description: Type.String({ description: "Short description for UI display" }),
 });
 
 export type TaskItem = Static<typeof taskItemSchema>;
 
 /** Task tool parameters */
 export const taskSchema = Type.Object({
-	context: Type.Optional(Type.String({ description: "Shared context prepended to all task prompts" })),
-	output_schema: Type.Optional(
+	agent: Type.String({ description: "Agent type to use for all tasks" }),
+	context: Type.String({ description: "Shared context prepended to all task prompts" }),
+	model: Type.Optional(
+		Type.String({
+			description: "Model override for all tasks (fuzzy matching, e.g. 'sonnet', 'opus')",
+		}),
+	),
+	output: Type.Optional(
 		Type.Any({
-			description: "JSON schema for structured subagent output (used by the complete tool)",
+			description: "JTD schema for structured subagent output (used by the complete tool)",
 		}),
 	),
 	tasks: Type.Array(taskItemSchema, {