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

package/src/core/tools/review.ts

@@ -1,16 +1,16 @@
 /**
- * Review tools - report_finding and submit_review
+ * Review tools - report_finding for structured code review.
  *
  * Used by the reviewer agent to report findings in a structured way.
- * Both tools are hidden by default - only enabled when explicitly listed in agent's tools.
+ * Hidden by default - only enabled when explicitly listed in agent's tools.
+ * Reviewers finish via `complete` tool with SubmitReviewDetails schema.
  */
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { Container, Spacer, Text } from "@oh-my-pi/pi-tui";
+import { Container, Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
-import type { Theme } from "../../modes/interactive/theme/theme";
-import { theme } from "../../modes/interactive/theme/theme";
+import type { Theme, ThemeColor } from "../../modes/interactive/theme/theme";
 
 const PRIORITY_LABELS: Record<number, string> = {
 	0: "P0",
@@ -19,6 +19,24 @@ const PRIORITY_LABELS: Record<number, string> = {
 	3: "P3",
 };
 
+const PRIORITY_META: Record<number, { symbol: "status.error" | "status.warning" | "status.info"; color: ThemeColor }> =
+	{
+		0: { symbol: "status.error", color: "error" },
+		1: { symbol: "status.warning", color: "warning" },
+		2: { symbol: "status.warning", color: "muted" },
+		3: { symbol: "status.info", color: "accent" },
+	};
+
+function getPriorityDisplay(priority: number, theme: Theme): { label: string; icon: string; color: ThemeColor } {
+	const label = PRIORITY_LABELS[priority] ?? "P?";
+	const meta = PRIORITY_META[priority] ?? { symbol: "status.info", color: "muted" as const };
+	return {
+		label,
+		icon: theme.styledSymbol(meta.symbol, meta.color),
+		color: meta.color,
+	};
+}
+
 // report_finding schema
 const ReportFindingParams = Type.Object({
 	title: Type.String({
@@ -53,7 +71,7 @@ interface ReportFindingDetails {
 export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme> = {
 	name: "report_finding",
 	label: "Report Finding",
-	description: "Report a code review finding. Use this for each issue found. Call submit_review when done.",
+	description: "Report a code review finding. Use this for each issue found. Call complete when done.",
 	parameters: ReportFindingParams,
 	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
 		const { title, body, priority, confidence, file_path, line_start, line_end } = params;
@@ -73,11 +91,10 @@ export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFind
 	},
 
 	renderCall(args, theme): Component {
-		const priority = PRIORITY_LABELS[args.priority as number] ?? "P?";
-		const color = args.priority === 0 ? "error" : args.priority === 1 ? "warning" : "muted";
+		const { label, icon, color } = getPriorityDisplay(args.priority as number, theme);
 		const titleText = String(args.title).replace(/^\[P\d\]\s*/, "");
 		return new Text(
-			`${theme.fg("toolTitle", theme.bold("report_finding "))}${theme.fg(color, `[${priority}]`)} ${theme.fg(
+			`${theme.fg("toolTitle", theme.bold("report_finding "))}${icon} ${theme.fg(color, `[${label}]`)} ${theme.fg(
 				"dim",
 				titleText,
 			)}`,
@@ -93,111 +110,31 @@ export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFind
 			return new Text(text?.type === "text" ? text.text : "", 0, 0);
 		}
 
-		const priority = PRIORITY_LABELS[details.priority] ?? "P?";
-		const color = details.priority === 0 ? "error" : details.priority === 1 ? "warning" : "muted";
+		const { label, icon, color } = getPriorityDisplay(details.priority, theme);
 		const location = `${details.file_path}:${details.line_start}${
 			details.line_end !== details.line_start ? `-${details.line_end}` : ""
 		}`;
 
 		return new Text(
-			`${theme.fg("success", theme.status.success)} ${theme.fg(color, `[${priority}]`)} ${theme.fg("dim", location)}`,
+			`${theme.fg("success", theme.status.success)} ${icon} ${theme.fg(color, `[${label}]`)} ${theme.fg(
+				"dim",
+				location,
+			)}`,
 			0,
 			0,
 		);
 	},
 };
 
-// submit_review schema
-const SubmitReviewParams = Type.Object({
-	overall_correctness: Type.Union([Type.Literal("correct"), Type.Literal("incorrect")], {
-		description: "Whether the patch is correct (no bugs, tests won't break)",
-	}),
-	explanation: Type.String({
-		description: "1-3 sentence explanation justifying the verdict",
-	}),
-	confidence: Type.Number({
-		minimum: 0,
-		maximum: 1,
-		description: "Overall confidence score 0.0-1.0",
-	}),
-});
-
-interface SubmitReviewDetails {
+/** SubmitReviewDetails - used for rendering review results from complete tool */
+export interface SubmitReviewDetails {
 	overall_correctness: "correct" | "incorrect";
 	explanation: string;
 	confidence: number;
 }
 
-export const submitReviewTool: AgentTool<typeof SubmitReviewParams, SubmitReviewDetails, Theme> = {
-	name: "submit_review",
-	label: "Submit Review",
-	description: "Submit the final review verdict. Call this after all findings have been reported.",
-	parameters: SubmitReviewParams,
-
-	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-		const { overall_correctness, explanation, confidence } = params;
-
-		let summary = `## Review Summary\n\n`;
-		summary += `**Verdict:** ${
-			overall_correctness === "correct"
-				? `${theme.status.success} Patch is correct`
-				: `${theme.status.error} Patch is incorrect`
-		}\n`;
-		summary += `**Confidence:** ${(confidence * 100).toFixed(0)}%\n\n`;
-		summary += explanation;
-
-		return {
-			content: [{ type: "text", text: summary }],
-			details: { overall_correctness, explanation, confidence },
-		};
-	},
-
-	renderCall(args, theme): Component {
-		const verdict = args.overall_correctness === "correct" ? "correct" : "incorrect";
-		const color = args.overall_correctness === "correct" ? "success" : "error";
-		return new Text(
-			`${theme.fg("toolTitle", theme.bold("submit_review "))}${theme.fg(color, verdict)} ${theme.fg(
-				"dim",
-				`(${((args.confidence as number) * 100).toFixed(0)}%)`,
-			)}`,
-			0,
-			0,
-		);
-	},
-
-	renderResult(result, { expanded }, theme): Component {
-		const { details } = result;
-		if (!details) {
-			const text = result.content[0];
-			return new Text(text?.type === "text" ? text.text : "", 0, 0);
-		}
-
-		const container = new Container();
-		const verdictColor = details.overall_correctness === "correct" ? "success" : "error";
-		const verdictIcon = details.overall_correctness === "correct" ? theme.status.success : theme.status.error;
-
-		container.addChild(
-			new Text(
-				`${theme.fg(verdictColor, verdictIcon)} Patch is ${theme.fg(
-					verdictColor,
-					details.overall_correctness,
-				)} ${theme.fg("dim", `(${(details.confidence * 100).toFixed(0)}% confidence)`)}`,
-				0,
-				0,
-			),
-		);
-
-		if (expanded) {
-			container.addChild(new Spacer(1));
-			container.addChild(new Text(theme.fg("dim", details.explanation), 0, 0));
-		}
-
-		return container;
-	},
-};
-
 // Re-export types for external use
-export type { ReportFindingDetails, SubmitReviewDetails };
+export type { ReportFindingDetails };
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Subprocess tool handlers - registered for extraction/rendering in task tool
@@ -211,11 +148,10 @@ subprocessToolRegistry.register<ReportFindingDetails>("report_finding", {
 	extractData: (event) => event.result?.details as ReportFindingDetails | undefined,
 
 	renderInline: (data, theme) => {
-		const priority = PRIORITY_LABELS[data.priority] ?? "P?";
-		const color = data.priority === 0 ? "error" : data.priority === 1 ? "warning" : "muted";
+		const { label, icon, color } = getPriorityDisplay(data.priority, theme);
 		const titleText = data.title.replace(/^\[P\d\]\s*/, "");
 		const loc = `${path.basename(data.file_path)}:${data.line_start}`;
-		return new Text(`${theme.fg(color, `[${priority}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0);
+		return new Text(`${icon} ${theme.fg(color, `[${label}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0);
 	},
 
 	renderFinal: (allData, theme, expanded) => {
@@ -224,13 +160,12 @@ subprocessToolRegistry.register<ReportFindingDetails>("report_finding", {
 
 		for (let i = 0; i < displayCount; i++) {
 			const data = allData[i];
-			const priority = PRIORITY_LABELS[data.priority] ?? "P?";
-			const color = data.priority === 0 ? "error" : data.priority === 1 ? "warning" : "muted";
+			const { label, icon, color } = getPriorityDisplay(data.priority, theme);
 			const titleText = data.title.replace(/^\[P\d\]\s*/, "");
 			const loc = `${path.basename(data.file_path)}:${data.line_start}`;
 
 			container.addChild(
-				new Text(`  ${theme.fg(color, `[${priority}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0),
+				new Text(`  ${icon} ${theme.fg(color, `[${label}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0),
 			);
 
 			if (expanded && data.body) {
@@ -251,26 +186,3 @@ subprocessToolRegistry.register<ReportFindingDetails>("report_finding", {
 		return container;
 	},
 });
-
-// Register submit_review handler
-subprocessToolRegistry.register<SubmitReviewDetails>("submit_review", {
-	extractData: (event) => event.result?.details as SubmitReviewDetails | undefined,
-
-	// Terminate subprocess after review is submitted
-	shouldTerminate: () => true,
-
-	renderInline: (data, theme) => {
-		const verdictColor = data.overall_correctness === "correct" ? "success" : "error";
-		const verdictIcon = data.overall_correctness === "correct" ? theme.status.success : theme.status.error;
-		return new Text(
-			`${theme.fg(verdictColor, verdictIcon)} Review: ${theme.fg(verdictColor, data.overall_correctness)} (${(
-				data.confidence * 100
-			).toFixed(0)}%)`,
-			0,
-			0,
-		);
-	},
-
-	// Note: renderFinal is NOT used for submit_review - we use the combined
-	// renderReviewResult in render.ts to show verdict + findings together
-});

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

@@ -8,6 +8,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { nanoid } from "nanoid";
 
 /**
  * Derive artifacts directory from session file path.
@@ -62,14 +63,14 @@ export async function writeArtifacts(
 	const paths = getArtifactPaths(dir, taskId);
 
 	// Write input
-	await fs.promises.writeFile(paths.inputPath, input, "utf-8");
+	await Bun.write(paths.inputPath, input);
 
 	// Write output
-	await fs.promises.writeFile(paths.outputPath, output, "utf-8");
+	await Bun.write(paths.outputPath, output);
 
 	// Write JSONL if events provided
 	if (jsonlEvents && jsonlEvents.length > 0) {
-		await fs.promises.writeFile(paths.jsonlPath, jsonlEvents.join("\n"), "utf-8");
+		await Bun.write(paths.jsonlPath, jsonlEvents.join("\n"));
 		return paths;
 	}
 
@@ -80,7 +81,7 @@ export async function writeArtifacts(
  * Create a temporary artifacts directory.
  */
 export function createTempArtifactsDir(runId?: string): string {
-	const id = runId || `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+	const id = runId || nanoid();
 	const dir = path.join(os.tmpdir(), `omp-task-${id}`);
 	ensureArtifactsDir(dir);
 	return dir;

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

@@ -4,7 +4,6 @@
  * Runs each subagent in a Bun Worker and forwards AgentEvents for progress tracking.
  */
 
-import { writeFileSync } from "node:fs";
 import type { AgentEvent } from "@oh-my-pi/pi-agent-core";
 import type { EventBus } from "../../event-bus";
 import { ensureArtifactsDir, getArtifactPaths } from "./artifacts";
@@ -50,20 +49,26 @@ function truncateOutput(output: string): { text: string; truncated: boolean } {
 
 	let i = 0;
 	let lastNewlineIndex = -1;
-	while (i < output.length && byteBudget > 0) {
-		const ch = output.charCodeAt(i);
-		byteBudget--;
+	while (i < output.length) {
+		const codePoint = output.codePointAt(i);
+		if (codePoint === undefined) break;
+		const codeUnitLength = codePoint > 0xffff ? 2 : 1;
+		const byteLen = codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+		if (byteBudget - byteLen < 0) {
+			truncated = true;
+			break;
+		}
+		byteBudget -= byteLen;
+		i += codeUnitLength;
 
-		if (ch === 10 /* \n */) {
+		if (codePoint === 0x0a) {
 			lineBudget--;
-			lastNewlineIndex = i;
+			lastNewlineIndex = i - 1;
 			if (lineBudget <= 0) {
 				truncated = true;
 				break;
 			}
 		}
-
-		i++;
 	}
 
 	if (i < output.length) {
@@ -186,7 +191,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 		// Write input file immediately (real-time visibility)
 		try {
-			writeFileSync(artifactPaths.inputPath, fullTask, "utf-8");
+			await Bun.write(artifactPaths.inputPath, fullTask);
 		} catch {
 			// Non-fatal, continue without input artifact
 		}
@@ -207,13 +212,40 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	const sessionFile = subtaskSessionFile ?? options.sessionFile ?? null;
 	const spawnsEnv = agent.spawns === undefined ? "" : agent.spawns === "*" ? "*" : agent.spawns.join(",");
 
-	const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
+	let worker: Worker;
+	try {
+		worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
+	} catch (err) {
+		return {
+			index,
+			taskId,
+			agent: agent.name,
+			agentSource: agent.source,
+			task,
+			description: options.description,
+			exitCode: 1,
+			output: "",
+			stderr: `Failed to create worker: ${err instanceof Error ? err.message : String(err)}`,
+			truncated: false,
+			durationMs: Date.now() - startTime,
+			tokens: 0,
+			modelOverride,
+			error: `Failed to create worker: ${err instanceof Error ? err.message : String(err)}`,
+		};
+	}
 
-	let output = "";
+	const outputChunks: string[] = [];
+	const finalOutputChunks: string[] = [];
 	let stderr = "";
-	let finalOutput = "";
 	let resolved = false;
-	let pendingTermination = false; // Set when shouldTerminate fires, wait for message_end
+	type AbortReason = "signal" | "terminate";
+	let abortSent = false;
+	let abortReason: AbortReason | undefined;
+	let terminationScheduled = false;
+	let pendingTerminationController: AbortController | null = null;
+	let finalize: ((message: Extract<SubagentWorkerResponse, { type: "done" }>) => void) | null = null;
+	const listenerController = new AbortController();
+	const listenerSignal = listenerController.signal;
 
 	// Accumulate usage incrementally from message_end events (no memory for streaming events)
 	const accumulatedUsage = {
@@ -226,25 +258,80 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	};
 	let hasUsage = false;
 
-	let abortSent = false;
-	const requestAbort = () => {
-		if (abortSent) return;
+	const scheduleTermination = () => {
+		if (terminationScheduled) return;
+		terminationScheduled = true;
+		const timeoutSignal = AbortSignal.timeout(2000);
+		timeoutSignal.addEventListener(
+			"abort",
+			() => {
+				if (resolved) return;
+				try {
+					worker.terminate();
+				} catch {
+					// Ignore termination errors
+				}
+				if (finalize && !resolved) {
+					finalize({
+						type: "done",
+						exitCode: 1,
+						durationMs: Date.now() - startTime,
+						error: abortReason === "signal" ? "Aborted" : "Worker terminated after tool completion",
+						aborted: abortReason === "signal",
+					});
+				}
+			},
+			{ once: true, signal: listenerSignal },
+		);
+	};
+
+	const requestAbort = (reason: AbortReason) => {
+		if (abortSent) {
+			if (reason === "signal" && abortReason !== "signal") {
+				abortReason = "signal";
+			}
+			return;
+		}
+		if (resolved) return;
 		abortSent = true;
+		abortReason = reason;
 		const abortMessage: SubagentWorkerRequest = { type: "abort" };
-		worker.postMessage(abortMessage);
-		setTimeout(() => {
-			if (!resolved) {
-				worker.terminate();
-			}
-		}, 2000);
+		try {
+			worker.postMessage(abortMessage);
+		} catch {
+			// Worker already terminated, nothing to do
+		}
+		// Cancel pending termination if it exists
+		if (pendingTerminationController) {
+			pendingTerminationController.abort();
+			pendingTerminationController = null;
+		}
+		scheduleTermination();
+	};
+
+	const schedulePendingTermination = () => {
+		if (pendingTerminationController || abortSent || terminationScheduled || resolved) return;
+		const readyController = new AbortController();
+		pendingTerminationController = readyController;
+		const pendingSignal = AbortSignal.any([AbortSignal.timeout(2000), readyController.signal]);
+		pendingSignal.addEventListener(
+			"abort",
+			() => {
+				pendingTerminationController = null;
+				if (!resolved) {
+					requestAbort("terminate");
+				}
+			},
+			{ once: true, signal: listenerSignal },
+		);
 	};
 
 	// Handle abort signal
 	const onAbort = () => {
-		if (!resolved) requestAbort();
+		if (!resolved) requestAbort("signal");
 	};
 	if (signal) {
-		signal.addEventListener("abort", onAbort, { once: true });
+		signal.addEventListener("abort", onAbort, { once: true, signal: listenerSignal });
 	}
 
 	const emitProgress = () => {
@@ -347,13 +434,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						})
 					) {
 						// Don't terminate immediately - wait for message_end to get token counts
-						pendingTermination = true;
-						// Safety timeout in case message_end never arrives
-						setTimeout(() => {
-							if (!resolved) {
-								requestAbort();
-							}
-						}, 2000);
+						schedulePendingTermination();
 					}
 				}
 				break;
@@ -386,7 +467,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					if (messageContent && Array.isArray(messageContent)) {
 						for (const block of messageContent) {
 							if (block.type === "text" && block.text) {
-								output += block.text;
+								outputChunks.push(block.text);
 							}
 						}
 					}
@@ -395,33 +476,29 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				const messageUsage = getMessageUsage(event.message) || (event as AgentEvent & { usage?: unknown }).usage;
 				if (messageUsage && typeof messageUsage === "object") {
 					// Only count assistant messages (not tool results, etc.)
-					if (
-						role === "assistant" &&
-						event.message?.stopReason !== "aborted" &&
-						event.message?.stopReason !== "error"
-					) {
-						const usageRecord = messageUsage as Record<string, number | undefined>;
-						const costRecord = (messageUsage as { cost?: Record<string, number | undefined> }).cost;
+					if (role === "assistant") {
+						const usageRecord = messageUsage as Record<string, unknown>;
+						const costRecord = (messageUsage as { cost?: Record<string, unknown> }).cost;
 						hasUsage = true;
-						accumulatedUsage.input += usageRecord.input ?? 0;
-						accumulatedUsage.output += usageRecord.output ?? 0;
-						accumulatedUsage.cacheRead += usageRecord.cacheRead ?? 0;
-						accumulatedUsage.cacheWrite += usageRecord.cacheWrite ?? 0;
-						accumulatedUsage.totalTokens += usageRecord.totalTokens ?? 0;
+						accumulatedUsage.input += getNumberField(usageRecord, "input") ?? 0;
+						accumulatedUsage.output += getNumberField(usageRecord, "output") ?? 0;
+						accumulatedUsage.cacheRead += getNumberField(usageRecord, "cacheRead") ?? 0;
+						accumulatedUsage.cacheWrite += getNumberField(usageRecord, "cacheWrite") ?? 0;
+						accumulatedUsage.totalTokens += getNumberField(usageRecord, "totalTokens") ?? 0;
 						if (costRecord) {
-							accumulatedUsage.cost.input += costRecord.input ?? 0;
-							accumulatedUsage.cost.output += costRecord.output ?? 0;
-							accumulatedUsage.cost.cacheRead += costRecord.cacheRead ?? 0;
-							accumulatedUsage.cost.cacheWrite += costRecord.cacheWrite ?? 0;
-							accumulatedUsage.cost.total += costRecord.total ?? 0;
+							accumulatedUsage.cost.input += getNumberField(costRecord, "input") ?? 0;
+							accumulatedUsage.cost.output += getNumberField(costRecord, "output") ?? 0;
+							accumulatedUsage.cost.cacheRead += getNumberField(costRecord, "cacheRead") ?? 0;
+							accumulatedUsage.cost.cacheWrite += getNumberField(costRecord, "cacheWrite") ?? 0;
+							accumulatedUsage.cost.total += getNumberField(costRecord, "total") ?? 0;
 						}
 					}
 					// Accumulate tokens for progress display
 					progress.tokens += getUsageTokens(messageUsage);
 				}
 				// If pending termination, now we have tokens - terminate
-				if (pendingTermination && !resolved) {
-					requestAbort();
+				if (pendingTerminationController) {
+					pendingTerminationController.abort();
 				}
 				break;
 			}
@@ -435,7 +512,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						if (messageContent && Array.isArray(messageContent)) {
 							for (const block of messageContent) {
 								if (block.type === "text" && block.text) {
-									finalOutput += block.text;
+									finalOutputChunks.push(block.text);
 								}
 							}
 						}
@@ -469,38 +546,90 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	const done = await new Promise<Extract<SubagentWorkerResponse, { type: "done" }>>((resolve) => {
+		const cleanup = () => {
+			pendingTerminationController = null;
+			listenerController.abort();
+		};
+		finalize = (message) => {
+			if (resolved) return;
+			resolved = true;
+			cleanup();
+			resolve(message);
+		};
 		const onMessage = (event: WorkerMessageEvent<SubagentWorkerResponse>) => {
 			const message = event.data;
 			if (!message || resolved) return;
 			if (message.type === "event") {
-				processEvent(message.event);
+				try {
+					processEvent(message.event);
+				} catch (err) {
+					finalize?.({
+						type: "done",
+						exitCode: 1,
+						durationMs: Date.now() - startTime,
+						error: `Failed to process worker event: ${err instanceof Error ? err.message : String(err)}`,
+					});
+				}
 				return;
 			}
 			if (message.type === "done") {
-				resolved = true;
-				resolve(message);
+				finalize?.(message);
 			}
 		};
 		const onError = (event: WorkerErrorEvent) => {
-			if (resolved) return;
-			resolved = true;
-			resolve({
+			finalize?.({
 				type: "done",
 				exitCode: 1,
 				durationMs: Date.now() - startTime,
 				error: event.message,
 			});
 		};
-		worker.addEventListener("message", onMessage);
-		worker.addEventListener("error", onError);
-		worker.postMessage(startMessage);
+		const onMessageError = () => {
+			finalize?.({
+				type: "done",
+				exitCode: 1,
+				durationMs: Date.now() - startTime,
+				error: "Worker message deserialization failed",
+			});
+		};
+		const onClose = () => {
+			// Worker terminated unexpectedly (crashed or was killed without sending done)
+			const abortMessage =
+				abortSent && abortReason === "signal"
+					? "Worker terminated after abort"
+					: abortSent
+						? "Worker terminated after tool completion"
+						: "Worker terminated unexpectedly";
+			finalize?.({
+				type: "done",
+				exitCode: 1,
+				durationMs: Date.now() - startTime,
+				error: abortMessage,
+				aborted: abortReason === "signal",
+			});
+		};
+		worker.addEventListener("message", onMessage, { signal: listenerSignal });
+		worker.addEventListener("error", onError, { signal: listenerSignal });
+		worker.addEventListener("close", onClose, { signal: listenerSignal });
+		worker.addEventListener("messageerror", onMessageError, { signal: listenerSignal });
+		try {
+			worker.postMessage(startMessage);
+		} catch (err) {
+			finalize({
+				type: "done",
+				exitCode: 1,
+				durationMs: Date.now() - startTime,
+				error: `Failed to start worker: ${err instanceof Error ? err.message : String(err)}`,
+			});
+		}
 	});
 
 	// Cleanup
-	if (signal) {
-		signal.removeEventListener("abort", onAbort);
+	try {
+		worker.terminate();
+	} catch {
+		// Ignore termination errors
 	}
-	worker.terminate();
 
 	let exitCode = done.exitCode;
 	if (done.error) {
@@ -508,7 +637,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	// Use final output if available, otherwise accumulated output
-	let rawOutput = finalOutput || output;
+	let rawOutput = finalOutputChunks.length > 0 ? finalOutputChunks.join("") : outputChunks.join("");
 	let abortedViaComplete = false;
 	const completeItems = progress.extractedToolData?.complete as
 		| Array<{ data?: unknown; status?: "success" | "aborted"; error?: string }>
@@ -528,7 +657,15 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			}
 		} else {
 			// Normal successful completion
-			const completeData = lastComplete?.data ?? null;
+			let completeData = lastComplete?.data ?? null;
+			// Handle double-stringified JSON (subagent returned JSON string instead of object)
+			if (typeof completeData === "string" && (completeData.startsWith("{") || completeData.startsWith("["))) {
+				try {
+					completeData = JSON.parse(completeData);
+				} catch {
+					// Not valid JSON, keep as string
+				}
+			}
 			try {
 				rawOutput = JSON.stringify(completeData, null, 2) ?? "null";
 			} catch (err) {
@@ -549,7 +686,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	let outputMeta: { lineCount: number; charCount: number } | undefined;
 	if (artifactPaths) {
 		try {
-			writeFileSync(artifactPaths.outputPath, rawOutput, "utf-8");
+			await Bun.write(artifactPaths.outputPath, rawOutput);
 			outputMeta = {
 				lineCount: rawOutput.split("\n").length,
 				charCount: rawOutput.length,