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

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

@@ -4,20 +4,34 @@ import { type Static, Type } from "@sinclair/typebox";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
 
+function getEnv(name: string, defaultValue: number): number {
+	const value = process.env[name];
+	if (value === undefined) {
+		return defaultValue;
+	}
+	try {
+		const number = Number.parseInt(value, 10);
+		if (!Number.isNaN(number) && number > 0) {
+			return number;
+		}
+	} catch {}
+	return defaultValue;
+}
+
 /** Maximum tasks per call */
-export const MAX_PARALLEL_TASKS = 32;
+export const MAX_PARALLEL_TASKS = getEnv("OMP_TASK_MAX_PARALLEL", 32);
 
 /** Maximum concurrent workers */
-export const MAX_CONCURRENCY = 16;
+export const MAX_CONCURRENCY = getEnv("OMP_TASK_MAX_CONCURRENCY", 16);
 
 /** Maximum output bytes per agent */
-export const MAX_OUTPUT_BYTES = 500_000;
+export const MAX_OUTPUT_BYTES = getEnv("OMP_TASK_MAX_OUTPUT_BYTES", 500_000);
 
 /** Maximum output lines per agent */
-export const MAX_OUTPUT_LINES = 5000;
+export const MAX_OUTPUT_LINES = getEnv("OMP_TASK_MAX_OUTPUT_LINES", 5000);
 
 /** Maximum agents to show in description */
-export const MAX_AGENTS_IN_DESCRIPTION = 10;
+export const MAX_AGENTS_IN_DESCRIPTION = getEnv("OMP_TASK_MAX_AGENTS_IN_DESCRIPTION", 10);
 
 /** EventBus channel for raw subagent events */
 export const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
@@ -27,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, {

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

@@ -19,12 +19,17 @@ import type { AgentSessionEvent } from "../../agent-session";
 import { parseModelPattern, parseModelString } from "../../model-resolver";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";
 import { SessionManager } from "../../session-manager";
+import { untilAborted } from "../../utils";
 import type { SubagentWorkerRequest, SubagentWorkerResponse, SubagentWorkerStartPayload } from "./worker-protocol";
 
 type PostMessageFn = (message: SubagentWorkerResponse) => void;
 
 const postMessageSafe: PostMessageFn = (message) => {
-	(globalThis as typeof globalThis & { postMessage: PostMessageFn }).postMessage(message);
+	try {
+		(globalThis as typeof globalThis & { postMessage: PostMessageFn }).postMessage(message);
+	} catch {
+		// Parent may have terminated worker, nothing we can do
+	}
 };
 
 interface WorkerMessageEvent<T> {
@@ -49,9 +54,33 @@ const isAgentEvent = (event: AgentSessionEvent): event is AgentEvent => {
 	return agentEventTypes.has(event.type as AgentEvent["type"]);
 };
 
-let running = false;
-let abortRequested = false;
-let activeSession: { abort: () => Promise<void>; dispose: () => Promise<void> } | null = null;
+interface RunState {
+	abortController: AbortController;
+	startTime: number;
+	session: { abort: () => Promise<void>; dispose: () => Promise<void> } | null;
+	unsubscribe: (() => void) | null;
+	sendDoneOnce: (message: Extract<SubagentWorkerResponse, { type: "done" }>) => void;
+}
+
+const createSendDoneOnce = (): RunState["sendDoneOnce"] => {
+	let sent = false;
+	return (message) => {
+		if (sent) return;
+		sent = true;
+		postMessageSafe(message);
+	};
+};
+
+const createRunState = (): RunState => ({
+	abortController: new AbortController(),
+	startTime: Date.now(),
+	session: null,
+	unsubscribe: null,
+	sendDoneOnce: createSendDoneOnce(),
+});
+
+let activeRun: RunState | null = null;
+let pendingAbort = false;
 
 /**
  * Resolve model string to Model object with optional thinking level.
@@ -92,26 +121,35 @@ function resolveModelOverride(
  * - OMP_BLOCKED_AGENT: payload.blockedAgent (prevents same-agent recursion)
  * - OMP_SPAWNS: payload.spawnsEnv (controls nested spawn permissions)
  */
-async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
-	const startTime = Date.now();
+async function runTask(runState: RunState, payload: SubagentWorkerStartPayload): Promise<void> {
+	const { signal } = runState.abortController;
+	const startTime = runState.startTime;
 	let exitCode = 0;
 	let error: string | undefined;
 	let aborted = false;
+	const sessionAbortController = new AbortController();
 
-	try {
-		// Check for pre-start abort
-		if (abortRequested) {
+	// Helper to check abort status - throws if aborted to exit early
+	const checkAbort = (): void => {
+		if (signal.aborted) {
 			aborted = true;
 			exitCode = 1;
-			return;
+			throw new Error("Aborted");
 		}
+	};
+
+	try {
+		// Check for pre-start abort
+		checkAbort();
 
 		// Set working directory (CLI does this implicitly)
 		process.chdir(payload.cwd);
 
 		// Discover auth and models (equivalent to CLI's discoverAuthStorage/discoverModels)
 		const authStorage = await discoverAuthStorage();
+		checkAbort();
 		const modelRegistry = await discoverModels(authStorage);
+		checkAbort();
 
 		// Resolve model override (equivalent to CLI's parseModelPattern with --model)
 		const { model, thinkingLevel } = resolveModelOverride(payload.model, modelRegistry);
@@ -120,6 +158,7 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 		const sessionManager = payload.sessionFile
 			? await SessionManager.open(payload.sessionFile)
 			: SessionManager.inMemory(payload.cwd);
+		checkAbort();
 
 		// Create agent session (equivalent to CLI's createAgentSession)
 		// Note: hasUI: false disables interactive features
@@ -143,7 +182,16 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 			spawns: payload.spawnsEnv,
 		});
 
-		activeSession = session;
+		runState.session = session;
+		checkAbort();
+
+		signal.addEventListener(
+			"abort",
+			() => {
+				void session.abort();
+			},
+			{ once: true, signal: sessionAbortController.signal },
+		);
 
 		// Initialize extensions (equivalent to CLI's extension initialization)
 		// Note: Does not support --extension CLI flag or extension CLI flags
@@ -174,7 +222,7 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 		let completeCalled = false;
 
 		// Subscribe to events and forward to parent (equivalent to --mode json output)
-		session.subscribe((event: AgentSessionEvent) => {
+		runState.unsubscribe = session.subscribe((event: AgentSessionEvent) => {
 			if (isAgentEvent(event)) {
 				postMessageSafe({ type: "event", event });
 				// Track when complete tool is called
@@ -189,7 +237,7 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 
 		// Retry loop if complete was not called
 		let retryCount = 0;
-		while (!completeCalled && retryCount < MAX_COMPLETE_RETRIES && !abortRequested) {
+		while (!completeCalled && retryCount < MAX_COMPLETE_RETRIES && !signal.aborted) {
 			retryCount++;
 			const reminder = `<system-reminder>
 CRITICAL: You stopped without calling the complete tool. This is reminder ${retryCount} of ${MAX_COMPLETE_RETRIES}.
@@ -214,26 +262,45 @@ Call complete now.`;
 		}
 	} catch (err) {
 		exitCode = 1;
-		error = err instanceof Error ? err.stack || err.message : String(err);
+		// Don't record abort as error - it's handled via the aborted flag
+		if (!signal.aborted) {
+			error = err instanceof Error ? err.stack || err.message : String(err);
+		}
 	} finally {
 		// Handle abort requested during execution
-		if (abortRequested) {
+		if (signal.aborted) {
 			aborted = true;
 			if (exitCode === 0) exitCode = 1;
 		}
 
-		// Cleanup session
-		if (activeSession) {
+		sessionAbortController.abort();
+
+		if (runState.unsubscribe) {
+			try {
+				runState.unsubscribe();
+			} catch {
+				// Ignore unsubscribe errors
+			}
+			runState.unsubscribe = null;
+		}
+
+		// Cleanup session with timeout to prevent hanging
+		if (runState.session) {
+			const session = runState.session;
+			runState.session = null;
 			try {
-				await activeSession.dispose();
+				await untilAborted(AbortSignal.timeout(5000), () => session.dispose());
 			} catch {
 				// Ignore cleanup errors
 			}
-			activeSession = null;
 		}
 
-		// Send completion message to parent
-		postMessageSafe({
+		if (activeRun === runState) {
+			activeRun = null;
+		}
+
+		// Send completion message to parent (only once)
+		runState.sendDoneOnce({
 			type: "done",
 			exitCode,
 			durationMs: Date.now() - startTime,
@@ -245,12 +312,65 @@ Call complete now.`;
 
 /** Handle abort request from parent */
 function handleAbort(): void {
-	abortRequested = true;
-	if (activeSession) {
-		void activeSession.abort();
+	const runState = activeRun;
+	if (!runState) {
+		pendingAbort = true;
+		return;
+	}
+	runState.abortController.abort();
+	if (runState.session) {
+		void runState.session.abort();
 	}
 }
 
+const reportFatal = (message: string): void => {
+	const runState = activeRun;
+	if (runState) {
+		runState.abortController.abort();
+		if (runState.session) {
+			void runState.session.abort();
+		}
+		runState.sendDoneOnce({
+			type: "done",
+			exitCode: 1,
+			durationMs: Date.now() - runState.startTime,
+			error: message,
+			aborted: false,
+		});
+		return;
+	}
+
+	postMessageSafe({
+		type: "done",
+		exitCode: 1,
+		durationMs: 0,
+		error: message,
+		aborted: false,
+	});
+};
+
+// Global error handlers to ensure we always send a done message
+// Using self instead of globalThis for proper worker scope typing
+declare const self: {
+	addEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
+	addEventListener(type: "unhandledrejection", listener: (event: { reason: unknown }) => void): void;
+	addEventListener(type: "messageerror", listener: (event: MessageEvent) => void): void;
+};
+
+self.addEventListener("error", (event) => {
+	reportFatal(`Uncaught error: ${event.message || "Unknown error"}`);
+});
+
+self.addEventListener("unhandledrejection", (event) => {
+	const reason = event.reason;
+	const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
+	reportFatal(`Unhandled rejection: ${message}`);
+});
+
+self.addEventListener("messageerror", () => {
+	reportFatal("Failed to deserialize parent message");
+});
+
 // Message handler - receives start/abort commands from parent
 globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorkerRequest>) => {
 	const message = event.data;
@@ -263,8 +383,13 @@ globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorker
 
 	if (message.type === "start") {
 		// Only allow one task per worker
-		if (running) return;
-		running = true;
-		void runTask(message.payload);
+		if (activeRun) return;
+		const runState = createRunState();
+		if (pendingAbort) {
+			pendingAbort = false;
+			runState.abortController.abort();
+		}
+		activeRun = runState;
+		void runTask(runState, message.payload);
 	}
 });