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

package/src/core/tools/output.ts

@@ -36,6 +36,11 @@ const outputSchema = Type.Object({
 			description: "Output format: raw (default), json (structured), stripped (no ANSI)",
 		}),
 	),
+	query: Type.Optional(
+		Type.String({
+			description: "jq-like query for JSON outputs (e.g., .result.items[0].name). Requires JSON output.",
+		}),
+	),
 	offset: Type.Optional(
 		Type.Number({
 			description: "Line number to start reading from (1-indexed)",
@@ -70,6 +75,7 @@ interface OutputEntry {
 	provenance?: OutputProvenance;
 	previewLines?: string[];
 	range?: OutputRange;
+	query?: string;
 }
 
 export interface OutputToolDetails {
@@ -83,6 +89,77 @@ function stripAnsi(text: string): string {
 	return text.replace(/\x1b\[[0-9;]*m/g, "");
 }
 
+function parseQuery(query: string): Array<string | number> {
+	let input = query.trim();
+	if (!input) return [];
+	if (input.startsWith(".")) input = input.slice(1);
+	if (!input) return [];
+
+	const tokens: Array<string | number> = [];
+	let i = 0;
+
+	const isIdentChar = (ch: string) => /[A-Za-z0-9_-]/.test(ch);
+
+	while (i < input.length) {
+		const ch = input[i];
+		if (ch === ".") {
+			i++;
+			continue;
+		}
+		if (ch === "[") {
+			const closeIndex = input.indexOf("]", i + 1);
+			if (closeIndex === -1) {
+				throw new Error(`Invalid query: missing ] in ${query}`);
+			}
+			const raw = input.slice(i + 1, closeIndex).trim();
+			if (!raw) {
+				throw new Error(`Invalid query: empty [] in ${query}`);
+			}
+			const quote = raw[0];
+			if ((quote === '"' || quote === "'") && raw.endsWith(quote)) {
+				let inner = raw.slice(1, -1);
+				inner = inner.replace(/\\(["'\\])/g, "$1");
+				tokens.push(inner);
+			} else if (/^\d+$/.test(raw)) {
+				tokens.push(Number(raw));
+			} else {
+				tokens.push(raw);
+			}
+			i = closeIndex + 1;
+			continue;
+		}
+
+		const start = i;
+		while (i < input.length && isIdentChar(input[i])) {
+			i++;
+		}
+		if (start === i) {
+			throw new Error(`Invalid query: unexpected token '${input[i]}' in ${query}`);
+		}
+		const ident = input.slice(start, i);
+		tokens.push(ident);
+	}
+
+	return tokens;
+}
+
+function applyQuery(data: unknown, query: string): unknown {
+	const tokens = parseQuery(query);
+	let current: unknown = data;
+	for (const token of tokens) {
+		if (current === null || current === undefined) return undefined;
+		if (typeof token === "number") {
+			if (!Array.isArray(current)) return undefined;
+			current = current[token];
+			continue;
+		}
+		if (typeof current !== "object") return undefined;
+		const record = current as Record<string, unknown>;
+		current = record[token];
+	}
+	return current;
+}
+
 /** List available output IDs in artifacts directory */
 function listAvailableOutputs(artifactsDir: string): string[] {
 	try {
@@ -128,7 +205,13 @@ export function createOutputTool(session: ToolSession): AgentTool<typeof outputS
 		parameters: outputSchema,
 		execute: async (
 			_toolCallId: string,
-			params: { ids: string[]; format?: "raw" | "json" | "stripped"; offset?: number; limit?: number },
+			params: {
+				ids: string[];
+				format?: "raw" | "json" | "stripped";
+				query?: string;
+				offset?: number;
+				limit?: number;
+			},
 		): Promise<{ content: TextContent[]; details: OutputToolDetails }> => {
 			const sessionFile = session.getSessionFile();
 
@@ -150,7 +233,15 @@ export function createOutputTool(session: ToolSession): AgentTool<typeof outputS
 			const outputs: OutputEntry[] = [];
 			const notFound: string[] = [];
 			const outputContentById = new Map<string, string>();
-			const format = params.format ?? "raw";
+			const query = params.query?.trim();
+			const wantsQuery = query !== undefined && query.length > 0;
+			const format = params.format ?? (wantsQuery ? "json" : "raw");
+
+			if (wantsQuery && (params.offset !== undefined || params.limit !== undefined)) {
+				throw new Error("query cannot be combined with offset/limit");
+			}
+
+			const queryResults: Array<{ id: string; value: unknown }> = [];
 
 			for (const id of params.ids) {
 				const outputPath = path.join(artifactsDir, `${id}.out.md`);
@@ -168,7 +259,22 @@ export function createOutputTool(session: ToolSession): AgentTool<typeof outputS
 				let selectedContent = rawContent;
 				let range: OutputRange | undefined;
 
-				if (params.offset !== undefined || params.limit !== undefined) {
+				if (wantsQuery && query) {
+					let jsonValue: unknown;
+					try {
+						jsonValue = JSON.parse(rawContent);
+					} catch (err) {
+						const message = err instanceof Error ? err.message : String(err);
+						throw new Error(`Output ${id} is not valid JSON: ${message}`);
+					}
+					const value = applyQuery(jsonValue, query);
+					queryResults.push({ id, value });
+					try {
+						selectedContent = JSON.stringify(value, null, 2) ?? "null";
+					} catch {
+						selectedContent = String(value);
+					}
+				} else if (params.offset !== undefined || params.limit !== undefined) {
 					const startLine = Math.max(1, params.offset ?? 1);
 					if (startLine > totalLines) {
 						throw new Error(
@@ -186,11 +292,12 @@ export function createOutputTool(session: ToolSession): AgentTool<typeof outputS
 				outputs.push({
 					id,
 					path: outputPath,
-					lineCount: totalLines,
-					charCount: totalChars,
+					lineCount: wantsQuery ? selectedContent.split("\n").length : totalLines,
+					charCount: wantsQuery ? selectedContent.length : totalChars,
 					provenance: parseOutputProvenance(id),
 					previewLines: extractPreviewLines(selectedContent, 4),
 					range,
+					query: query,
 				});
 			}
 
@@ -212,15 +319,17 @@ export function createOutputTool(session: ToolSession): AgentTool<typeof outputS
 			let contentText: string;
 
 			if (format === "json") {
-				const jsonData = outputs.map((o) => ({
-					id: o.id,
-					lineCount: o.lineCount,
-					charCount: o.charCount,
-					provenance: o.provenance,
-					previewLines: o.previewLines,
-					range: o.range,
-					content: outputContentById.get(o.id) ?? "",
-				}));
+				const jsonData = wantsQuery
+					? queryResults
+					: outputs.map((o) => ({
+							id: o.id,
+							lineCount: o.lineCount,
+							charCount: o.charCount,
+							provenance: o.provenance,
+							previewLines: o.previewLines,
+							range: o.range,
+							content: outputContentById.get(o.id) ?? "",
+						}));
 				contentText = JSON.stringify(jsonData, null, 2);
 			} else {
 				// raw or stripped
@@ -257,6 +366,7 @@ export function createOutputTool(session: ToolSession): AgentTool<typeof outputS
 interface OutputRenderArgs {
 	ids: string[];
 	format?: "raw" | "json" | "stripped";
+	query?: string;
 	offset?: number;
 	limit?: number;
 }
@@ -285,6 +395,7 @@ export const outputToolRenderer = {
 
 		const meta: string[] = [];
 		if (args.format && args.format !== "raw") meta.push(`format:${args.format}`);
+		if (args.query) meta.push(`query:${args.query}`);
 		if (args.offset !== undefined) meta.push(`offset:${args.offset}`);
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
 		text += formatMeta(meta, uiTheme);

package/src/core/tools/read.ts

@@ -311,10 +311,10 @@ async function findReadPathSuggestions(
 	return { suggestions, scopeLabel, truncated };
 }
 
-function convertWithMarkitdown(filePath: string): { content: string; ok: boolean; error?: string } {
-	const cmd = Bun.which("markitdown");
+async function convertWithMarkitdown(filePath: string): Promise<{ content: string; ok: boolean; error?: string }> {
+	const cmd = await ensureTool("markitdown", true);
 	if (!cmd) {
-		return { content: "", ok: false, error: "markitdown not found" };
+		return { content: "", ok: false, error: "markitdown not found (uv/pip unavailable)" };
 	}
 
 	const result = Bun.spawnSync([cmd, filePath], {
@@ -449,7 +449,7 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 					}
 				} else if (CONVERTIBLE_EXTENSIONS.has(ext)) {
 					// Convert document via markitdown
-					const result = convertWithMarkitdown(absolutePath);
+					const result = await convertWithMarkitdown(absolutePath);
 					if (result.ok) {
 						// Apply truncation to converted content
 						const truncation = truncateHead(result.content);

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

@@ -38,14 +38,12 @@ export function ensureArtifactsDir(dir: string): void {
  */
 export function getArtifactPaths(
 	dir: string,
-	agentName: string,
-	index: number,
+	taskId: string,
 ): { inputPath: string; outputPath: string; jsonlPath: string } {
-	const base = `${agentName}_${index}`;
 	return {
-		inputPath: path.join(dir, `${base}.in.md`),
-		outputPath: path.join(dir, `${base}.out.md`),
-		jsonlPath: path.join(dir, `${base}.jsonl`),
+		inputPath: path.join(dir, `${taskId}.in.md`),
+		outputPath: path.join(dir, `${taskId}.out.md`),
+		jsonlPath: path.join(dir, `${taskId}.jsonl`),
 	};
 }
 
@@ -54,15 +52,14 @@ export function getArtifactPaths(
  */
 export async function writeArtifacts(
 	dir: string,
-	agentName: string,
-	index: number,
+	taskId: string,
 	input: string,
 	output: string,
 	jsonlEvents?: string[],
 ): Promise<{ inputPath: string; outputPath: string; jsonlPath?: string }> {
 	ensureArtifactsDir(dir);
 
-	const paths = getArtifactPaths(dir, agentName, index);
+	const paths = getArtifactPaths(dir, taskId);
 
 	// Write input
 	await fs.promises.writeFile(paths.inputPath, input, "utf-8");

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

@@ -28,8 +28,10 @@ export interface ExecutorOptions {
 	task: string;
 	description?: string;
 	index: number;
+	taskId: string;
 	context?: string;
 	modelOverride?: string;
+	outputSchema?: unknown;
 	signal?: AbortSignal;
 	onProgress?: (progress: AgentProgress) => void;
 	sessionFile?: string | null;
@@ -130,12 +132,13 @@ function getUsageTokens(usage: unknown): number {
  * Run a single agent in a worker.
  */
 export async function runSubprocess(options: ExecutorOptions): Promise<SingleResult> {
-	const { cwd, agent, task, index, context, modelOverride, signal, onProgress } = options;
+	const { cwd, agent, task, index, taskId, context, modelOverride, outputSchema, signal, onProgress } = options;
 	const startTime = Date.now();
 
 	// Initialize progress
 	const progress: AgentProgress = {
 		index,
+		taskId,
 		agent: agent.name,
 		agentSource: agent.source,
 		status: "running",
@@ -153,6 +156,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	if (signal?.aborted) {
 		return {
 			index,
+			taskId,
 			agent: agent.name,
 			agentSource: agent.source,
 			task,
@@ -177,7 +181,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	if (options.artifactsDir) {
 		ensureArtifactsDir(options.artifactsDir);
-		artifactPaths = getArtifactPaths(options.artifactsDir, agent.name, index);
+		artifactPaths = getArtifactPaths(options.artifactsDir, taskId);
 		subtaskSessionFile = artifactPaths.jsonlPath;
 
 		// Write input file immediately (real-time visibility)
@@ -203,13 +207,39 @@ 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 = "";
 	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 abortTerminateTimer: ReturnType<typeof setTimeout> | undefined;
+	let pendingTerminationTimer: ReturnType<typeof setTimeout> | undefined;
+	let finalize: ((message: Extract<SubagentWorkerResponse, { type: "done" }>) => void) | null = null;
 
 	// Accumulate usage incrementally from message_end events (no memory for streaming events)
 	const accumulatedUsage = {
@@ -222,22 +252,55 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	};
 	let hasUsage = false;
 
-	let abortSent = false;
-	const requestAbort = () => {
-		if (abortSent) return;
+	const clearTimers = (): void => {
+		if (abortTerminateTimer) clearTimeout(abortTerminateTimer);
+		abortTerminateTimer = undefined;
+		if (pendingTerminationTimer) clearTimeout(pendingTerminationTimer);
+		pendingTerminationTimer = undefined;
+	};
+
+	const requestAbort = (reason: AbortReason) => {
+		if (abortSent) {
+			if (reason === "signal" && abortReason !== "signal") {
+				abortReason = "signal";
+			}
+			return;
+		}
+		if (resolved) return;
 		abortSent = true;
+		abortReason = reason;
+		if (pendingTerminationTimer) clearTimeout(pendingTerminationTimer);
+		pendingTerminationTimer = undefined;
 		const abortMessage: SubagentWorkerRequest = { type: "abort" };
-		worker.postMessage(abortMessage);
-		setTimeout(() => {
+		try {
+			worker.postMessage(abortMessage);
+		} catch {
+			// Worker already terminated, nothing to do
+		}
+		if (abortTerminateTimer) clearTimeout(abortTerminateTimer);
+		abortTerminateTimer = setTimeout(() => {
 			if (!resolved) {
-				worker.terminate();
+				try {
+					worker.terminate();
+				} catch {
+					// Ignore termination errors
+				}
+				if (finalize && !resolved) {
+					finalize({
+						type: "done",
+						exitCode: 1,
+						durationMs: Date.now() - startTime,
+						error: reason === "signal" ? "Aborted" : "Worker terminated after tool completion",
+						aborted: reason === "signal",
+					});
+				}
 			}
 		}, 2000);
 	};
 
 	// Handle abort signal
 	const onAbort = () => {
-		if (!resolved) requestAbort();
+		if (!resolved) requestAbort("signal");
 	};
 	if (signal) {
 		signal.addEventListener("abort", onAbort, { once: true });
@@ -345,9 +408,10 @@ 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 (pendingTerminationTimer) clearTimeout(pendingTerminationTimer);
+						pendingTerminationTimer = setTimeout(() => {
 							if (!resolved) {
-								requestAbort();
+								requestAbort("terminate");
 							}
 						}, 2000);
 					}
@@ -417,7 +481,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				}
 				// If pending termination, now we have tokens - terminate
 				if (pendingTermination && !resolved) {
-					requestAbort();
+					requestAbort("terminate");
 				}
 				break;
 			}
@@ -451,6 +515,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			systemPrompt: agent.systemPrompt,
 			model: resolvedModel,
 			toolNames,
+			outputSchema,
 			sessionFile,
 			spawnsEnv,
 		},
@@ -464,46 +529,145 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	const done = await new Promise<Extract<SubagentWorkerResponse, { type: "done" }>>((resolve) => {
+		const cleanup = () => {
+			worker.removeEventListener("message", onMessage);
+			worker.removeEventListener("error", onError);
+			worker.removeEventListener("close", onClose);
+			worker.removeEventListener("messageerror", onMessageError);
+			clearTimers();
+		};
+		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,
 			});
 		};
+		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);
 		worker.addEventListener("error", onError);
-		worker.postMessage(startMessage);
+		worker.addEventListener("close", onClose);
+		worker.addEventListener("messageerror", onMessageError);
+		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);
 	}
-	worker.terminate();
+	try {
+		worker.terminate();
+	} catch {
+		// Ignore termination errors
+	}
 
-	const exitCode = done.exitCode;
+	let exitCode = done.exitCode;
 	if (done.error) {
 		stderr = done.error;
 	}
 
 	// Use final output if available, otherwise accumulated output
-	const rawOutput = finalOutput || output;
+	let rawOutput = finalOutput || output;
+	let abortedViaComplete = false;
+	const completeItems = progress.extractedToolData?.complete as
+		| Array<{ data?: unknown; status?: "success" | "aborted"; error?: string }>
+		| undefined;
+	const hasComplete = Array.isArray(completeItems) && completeItems.length > 0;
+	if (hasComplete) {
+		const lastComplete = completeItems[completeItems.length - 1];
+		if (lastComplete?.status === "aborted") {
+			// Agent explicitly aborted via complete tool - clean exit with error info
+			abortedViaComplete = true;
+			exitCode = 0;
+			stderr = lastComplete.error || "Subagent aborted task";
+			try {
+				rawOutput = JSON.stringify({ aborted: true, error: lastComplete.error }, null, 2);
+			} catch {
+				rawOutput = `{"aborted":true,"error":"${lastComplete.error || "Unknown error"}"}`;
+			}
+		} else {
+			// Normal successful completion
+			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) {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				rawOutput = `{"error":"Failed to serialize complete data: ${errorMessage}"}`;
+			}
+			exitCode = 0;
+			stderr = "";
+		}
+	} else {
+		const warning = "SYSTEM WARNING: Subagent exited without calling complete tool after 3 reminders.";
+		rawOutput = rawOutput ? `${warning}\n\n${rawOutput}` : warning;
+	}
 	const { text: truncatedOutput, truncated } = truncateOutput(rawOutput);
 
 	// Write output artifact (input and jsonl already written in real-time)
@@ -522,12 +686,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	// Update final progress
-	const wasAborted = done.aborted || signal?.aborted || false;
+	const wasAborted = abortedViaComplete || (!hasComplete && (done.aborted || signal?.aborted || false));
 	progress.status = wasAborted ? "aborted" : exitCode === 0 ? "completed" : "failed";
 	emitProgress();
 
 	return {
 		index,
+		taskId,
 		agent: agent.name,
 		agentSource: agent.source,
 		task,