@oh-my-pi/pi-coding-agent 3.24.0 → 3.25.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/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)
@@ -451,6 +455,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			systemPrompt: agent.systemPrompt,
 			model: resolvedModel,
 			toolNames,
+			outputSchema,
 			sessionFile,
 			spawnsEnv,
 		},
@@ -497,13 +502,46 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 	worker.terminate();
 
-	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
+			const completeData = lastComplete?.data ?? null;
+			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 +560,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,

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

@@ -21,6 +21,7 @@ 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,6 +136,7 @@ export async function createTaskTool(
 			const startTime = Date.now();
 			const { agents, projectAgentsDir } = await discoverAgents(session.cwd);
 			const context = params.context;
+			const outputSchema = params.output_schema;
 
 			// Handle empty or missing tasks
 			if (!params.tasks || params.tasks.length === 0) {
@@ -259,34 +261,37 @@ export async function createTaskTool(
 					}
 				}
 
+				// Build full prompts with context prepended and generate task IDs
+				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(),
+				}));
+
 				// Initialize progress for all tasks
-				for (let i = 0; i < tasks.length; i++) {
-					const agentCfg = getAgent(agents, tasks[i].agent);
+				for (let i = 0; i < tasksWithContext.length; i++) {
+					const t = tasksWithContext[i];
+					const agentCfg = getAgent(agents, t.agent);
 					progressMap.set(i, {
 						index: i,
-						agent: tasks[i].agent,
+						taskId: t.taskId,
+						agent: t.agent,
 						agentSource: agentCfg?.source ?? "user",
 						status: "pending",
-						task: tasks[i].task,
+						task: t.task,
 						recentTools: [],
 						recentOutput: [],
 						toolCount: 0,
 						tokens: 0,
 						durationMs: 0,
-						modelOverride: tasks[i].model,
-						description: tasks[i].description,
+						modelOverride: t.model,
+						description: t.description,
 					});
 				}
 				emitProgress();
 
-				// 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,
-				}));
-
 				// Execute in parallel with concurrency limit
 				const results = await mapWithConcurrencyLimit(tasksWithContext, MAX_CONCURRENCY, async (task, index) => {
 					const agent = getAgent(agents, task.agent)!;
@@ -296,8 +301,10 @@ export async function createTaskTool(
 						task: task.task,
 						description: task.description,
 						index,
+						taskId: task.taskId,
 						context: undefined, // Already prepended above
 						modelOverride: task.model,
+						outputSchema,
 						sessionFile,
 						persistArtifacts: !!artifactsDir,
 						artifactsDir: effectiveArtifactsDir,
@@ -336,19 +343,17 @@ export async function createTaskTool(
 					const status = r.exitCode === 0 ? "completed" : `failed (exit ${r.exitCode})`;
 					const output = r.output.trim() || r.stderr.trim() || "(no output)";
 					const preview = output.split("\n").slice(0, 5).join("\n");
-					// Include output metadata and ID
-					const outputId = `${r.agent}_${r.index}`;
 					const meta = r.outputMeta
 						? ` [${r.outputMeta.lineCount} lines, ${formatBytes(r.outputMeta.charCount)}]`
 						: "";
-					return `[${r.agent}] ${status}${meta} ${outputId}\n${preview}`;
+					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.agent}_${r.index}`);
+				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(