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

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

@@ -69,6 +69,118 @@ function formatFindingSummary(findings: ReportFindingDetails[], theme: Theme): s
 	return `${theme.fg("dim", "Findings:")} ${parts.join(theme.sep.dot)}`;
 }
 
+function formatJsonScalar(value: unknown): string {
+	if (value === null) return "null";
+	if (typeof value === "string") return `"${value}"`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return "";
+}
+
+function buildTreePrefix(ancestors: boolean[], theme: Theme): string {
+	return ancestors.map((hasNext) => (hasNext ? `${theme.tree.vertical}  ` : "   ")).join("");
+}
+
+function renderJsonTreeLines(
+	value: unknown,
+	theme: Theme,
+	maxDepth: number,
+	maxLines: number,
+): { lines: string[]; truncated: boolean } {
+	const lines: string[] = [];
+	let truncated = false;
+
+	const iconObject = theme.styledSymbol("icon.folder", "muted");
+	const iconArray = theme.styledSymbol("icon.package", "muted");
+	const iconScalar = theme.styledSymbol("icon.file", "muted");
+
+	const pushLine = (line: string) => {
+		if (lines.length >= maxLines) {
+			truncated = true;
+			return false;
+		}
+		lines.push(line);
+		return true;
+	};
+
+	const renderNode = (val: unknown, key: string | undefined, ancestors: boolean[], isLast: boolean, depth: number) => {
+		if (lines.length >= maxLines) {
+			truncated = true;
+			return;
+		}
+
+		const connector = isLast ? theme.tree.last : theme.tree.branch;
+		const prefix = `${buildTreePrefix(ancestors, theme)}${theme.fg("dim", connector)} `;
+		const scalar = formatJsonScalar(val);
+
+		if (scalar) {
+			const label = key ? theme.fg("muted", key) : theme.fg("muted", "value");
+			pushLine(`${prefix}${iconScalar} ${label}: ${theme.fg("dim", scalar)}`);
+			return;
+		}
+
+		if (Array.isArray(val)) {
+			const header = key ? theme.fg("muted", key) : theme.fg("muted", "array");
+			pushLine(`${prefix}${iconArray} ${header}`);
+			if (val.length === 0) {
+				pushLine(
+					`${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)}`,
+				);
+				return;
+			}
+			const nextAncestors = [...ancestors, !isLast];
+			for (let i = 0; i < val.length; i++) {
+				renderNode(val[i], `[${i}]`, nextAncestors, i === val.length - 1, depth + 1);
+				if (lines.length >= maxLines) {
+					truncated = true;
+					return;
+				}
+			}
+			return;
+		}
+
+		if (val && typeof val === "object") {
+			const header = key ? theme.fg("muted", key) : theme.fg("muted", "object");
+			pushLine(`${prefix}${iconObject} ${header}`);
+			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", "{}")}`,
+				);
+				return;
+			}
+			if (depth >= maxDepth) {
+				pushLine(
+					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.hook)} ${theme.fg("dim", theme.format.ellipsis)}`,
+				);
+				return;
+			}
+			const nextAncestors = [...ancestors, !isLast];
+			for (let i = 0; i < entries.length; i++) {
+				const [childKey, child] = entries[i];
+				renderNode(child, childKey, nextAncestors, i === entries.length - 1, depth + 1);
+				if (lines.length >= maxLines) {
+					truncated = true;
+					return;
+				}
+			}
+			return;
+		}
+
+		const label = key ? theme.fg("muted", key) : theme.fg("muted", "value");
+		pushLine(`${prefix}${iconScalar} ${label}: ${theme.fg("dim", String(val))}`);
+	};
+
+	renderNode(value, undefined, [], true, 0);
+
+	return { lines, truncated };
+}
+
 function renderOutputSection(
 	output: string,
 	continuePrefix: string,
@@ -78,11 +190,30 @@ function renderOutputSection(
 	maxExpanded = 10,
 ): string[] {
 	const lines: string[] = [];
-	const outputLines = output.split("\n").filter((line) => line.trim());
-	if (outputLines.length === 0) return lines;
+	const trimmedOutput = output.trim();
+	if (!trimmedOutput) return lines;
 
 	lines.push(`${continuePrefix}${theme.fg("dim", "Output")}`);
 
+	if (trimmedOutput.startsWith("{") || trimmedOutput.startsWith("[")) {
+		try {
+			const parsed = JSON.parse(trimmedOutput);
+			const tree = renderJsonTreeLines(parsed, theme, expanded ? 6 : 2, expanded ? 24 : 6);
+			if (tree.lines.length > 0) {
+				for (const line of tree.lines) {
+					lines.push(`${continuePrefix}  ${line}`);
+				}
+				if (tree.truncated) {
+					lines.push(`${continuePrefix}  ${theme.fg("dim", theme.format.ellipsis)}`);
+				}
+				return lines;
+			}
+		} catch {
+			// Fall back to raw output
+		}
+	}
+
+	const outputLines = output.split("\n").filter((line) => line.trim());
 	const previewCount = expanded ? maxExpanded : maxCollapsed;
 	for (const line of outputLines.slice(0, previewCount)) {
 		lines.push(`${continuePrefix}  ${theme.fg("dim", truncate(line, 70, theme.format.ellipsis))}`);
@@ -144,9 +275,8 @@ function renderAgentProgress(
 				? "error"
 				: "accent";
 
-	// Main status line - include index for Output tool ID derivation
-	const agentId = `${progress.agent}(${progress.index})`;
-	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", agentId)}`;
+	// Main status line - use taskId for Output tool
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", progress.taskId)}`;
 	const description = progress.description?.trim();
 	if (description) {
 		statusLine += ` ${theme.fg("muted", truncate(description, 40, theme.format.ellipsis))}`;
@@ -342,9 +472,8 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	const iconColor = success ? "success" : "error";
 	const statusText = aborted ? "aborted" : success ? "done" : "failed";
 
-	// Main status line - include index for Output tool ID derivation
-	const agentId = `${result.agent}(${result.index})`;
-	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", agentId)} ${formatBadge(statusText, iconColor, theme)}`;
+	// Main status line - use taskId for Output tool
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", result.taskId)} ${formatBadge(statusText, iconColor, theme)}`;
 	const description = result.description?.trim();
 	if (description) {
 		statusLine += ` ${theme.fg("muted", truncate(description, 40, theme.format.ellipsis))}`;

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";
@@ -38,6 +52,11 @@ 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(
+		Type.Any({
+			description: "JSON schema for structured subagent output (used by the complete tool)",
+		}),
+	),
 	tasks: Type.Array(taskItemSchema, {
 		description: "Tasks to run in parallel",
 		maxItems: MAX_PARALLEL_TASKS,
@@ -85,6 +104,7 @@ export interface AgentDefinition {
 /** Progress tracking for a single agent */
 export interface AgentProgress {
 	index: number;
+	taskId: string;
 	agent: string;
 	agentSource: AgentSource;
 	status: "pending" | "running" | "completed" | "failed" | "aborted";
@@ -106,6 +126,7 @@ export interface AgentProgress {
 /** Result from a single agent execution */
 export interface SingleResult {
 	index: number;
+	taskId: string;
 	agent: string;
 	agentSource: AgentSource;
 	task: string;

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

@@ -6,6 +6,7 @@ export interface SubagentWorkerStartPayload {
 	systemPrompt: string;
 	model?: string;
 	toolNames?: string[];
+	outputSchema?: unknown;
 	sessionFile?: string | null;
 	spawnsEnv?: string;
 }

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

@@ -24,7 +24,11 @@ import type { SubagentWorkerRequest, SubagentWorkerResponse, SubagentWorkerStart
 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> {
@@ -51,7 +55,9 @@ const isAgentEvent = (event: AgentSessionEvent): event is AgentEvent => {
 
 let running = false;
 let abortRequested = false;
+let doneSent = false;
 let activeSession: { abort: () => Promise<void>; dispose: () => Promise<void> } | null = null;
+let unsubscribe: (() => void) | null = null;
 
 /**
  * Resolve model string to Model object with optional thinking level.
@@ -123,6 +129,9 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 
 		// Create agent session (equivalent to CLI's createAgentSession)
 		// Note: hasUI: false disables interactive features
+		const completionInstruction =
+			"When finished, call the complete tool exactly once. Do not end with a plain-text final answer.";
+
 		const { session } = await createAgentSession({
 			cwd: payload.cwd,
 			authStorage,
@@ -130,8 +139,10 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 			model,
 			thinkingLevel,
 			toolNames: payload.toolNames,
+			outputSchema: payload.outputSchema,
+			requireCompleteTool: true,
 			// Append system prompt (equivalent to CLI's --append-system-prompt)
-			systemPrompt: (defaultPrompt) => `${defaultPrompt}\n\n${payload.systemPrompt}`,
+			systemPrompt: (defaultPrompt) => `${defaultPrompt}\n\n${payload.systemPrompt}\n\n${completionInstruction}`,
 			sessionManager,
 			hasUI: false,
 			// Pass spawn restrictions to nested tasks
@@ -140,6 +151,17 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 
 		activeSession = session;
 
+		if (abortRequested) {
+			aborted = true;
+			exitCode = 1;
+			try {
+				await session.abort();
+			} catch {
+				// Ignore abort errors
+			}
+			return;
+		}
+
 		// Initialize extensions (equivalent to CLI's extension initialization)
 		// Note: Does not support --extension CLI flag or extension CLI flags
 		const extensionRunner = session.extensionRunner;
@@ -164,16 +186,43 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 			await extensionRunner.emit({ type: "session_start" });
 		}
 
+		// Track complete tool calls
+		const MAX_COMPLETE_RETRIES = 3;
+		let completeCalled = false;
+
 		// Subscribe to events and forward to parent (equivalent to --mode json output)
-		session.subscribe((event: AgentSessionEvent) => {
+		unsubscribe = session.subscribe((event: AgentSessionEvent) => {
 			if (isAgentEvent(event)) {
 				postMessageSafe({ type: "event", event });
+				// Track when complete tool is called
+				if (event.type === "tool_execution_end" && event.toolName === "complete") {
+					completeCalled = true;
+				}
 			}
 		});
 
 		// Run the prompt (equivalent to --prompt flag)
 		await session.prompt(payload.task);
 
+		// Retry loop if complete was not called
+		let retryCount = 0;
+		while (!completeCalled && retryCount < MAX_COMPLETE_RETRIES && !abortRequested) {
+			retryCount++;
+			const reminder = `<system-reminder>
+CRITICAL: You stopped without calling the complete tool. This is reminder ${retryCount} of ${MAX_COMPLETE_RETRIES}.
+
+You MUST call the complete tool to finish your task. Options:
+1. Call complete with your result data if you have completed the task
+2. Call complete with status="aborted" and an error message if you cannot complete the task
+
+Failure to call complete after ${MAX_COMPLETE_RETRIES} reminders will result in task failure.
+</system-reminder>
+
+Call complete now.`;
+
+			await session.prompt(reminder);
+		}
+
 		// Check if aborted during execution
 		const lastMessage = session.state.messages[session.state.messages.length - 1];
 		if (lastMessage?.role === "assistant" && lastMessage.stopReason === "aborted") {
@@ -190,24 +239,39 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 			if (exitCode === 0) exitCode = 1;
 		}
 
-		// Cleanup session
+		if (unsubscribe) {
+			try {
+				unsubscribe();
+			} catch {
+				// Ignore unsubscribe errors
+			}
+			unsubscribe = null;
+		}
+
+		// Cleanup session with timeout to prevent hanging
 		if (activeSession) {
+			const session = activeSession;
+			activeSession = null;
 			try {
-				await activeSession.dispose();
+				await Promise.race([session.dispose(), new Promise<void>((resolve) => setTimeout(resolve, 5000))]);
 			} catch {
 				// Ignore cleanup errors
 			}
-			activeSession = null;
 		}
 
-		// Send completion message to parent
-		postMessageSafe({
-			type: "done",
-			exitCode,
-			durationMs: Date.now() - startTime,
-			error,
-			aborted,
-		});
+		running = false;
+
+		// Send completion message to parent (only once)
+		if (!doneSent) {
+			doneSent = true;
+			postMessageSafe({
+				type: "done",
+				exitCode,
+				durationMs: Date.now() - startTime,
+				error,
+				aborted,
+			});
+		}
 	}
 }
 
@@ -219,6 +283,64 @@ function handleAbort(): void {
 	}
 }
 
+// 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) => {
+	if (!running || doneSent) return;
+	doneSent = true;
+	abortRequested = true;
+	if (activeSession) {
+		void activeSession.abort();
+	}
+	postMessageSafe({
+		type: "done",
+		exitCode: 1,
+		durationMs: 0,
+		error: `Uncaught error: ${event.message || "Unknown error"}`,
+		aborted: false,
+	});
+});
+
+self.addEventListener("unhandledrejection", (event) => {
+	if (!running || doneSent) return;
+	doneSent = true;
+	abortRequested = true;
+	if (activeSession) {
+		void activeSession.abort();
+	}
+	const reason = event.reason;
+	const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
+	postMessageSafe({
+		type: "done",
+		exitCode: 1,
+		durationMs: 0,
+		error: `Unhandled rejection: ${message}`,
+		aborted: false,
+	});
+});
+
+self.addEventListener("messageerror", () => {
+	if (doneSent) return;
+	doneSent = true;
+	abortRequested = true;
+	if (activeSession) {
+		void activeSession.abort();
+	}
+	postMessageSafe({
+		type: "done",
+		exitCode: 1,
+		durationMs: 0,
+		error: "Failed to deserialize parent message",
+		aborted: false,
+	});
+});
+
 // Message handler - receives start/abort commands from parent
 globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorkerRequest>) => {
 	const message = event.data;