@oh-my-pi/pi-coding-agent 14.0.5 → 14.1.1

package/src/task/index.ts

@@ -530,8 +530,8 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 		});
 		const thinkingLevelOverride = effectiveAgent.thinkingLevel;
 
-		// Output schema priority: agent frontmatter > params > inherited from parent session
-		const effectiveOutputSchema = effectiveAgent.output ?? outputSchema ?? this.session.outputSchema;
+		// Output schema priority: caller params > agent frontmatter > inherited from parent session
+		const effectiveOutputSchema = outputSchema ?? effectiveAgent.output ?? this.session.outputSchema;
 
 		// Handle empty or missing tasks
 		if (!params.tasks || params.tasks.length === 0) {
@@ -787,7 +787,6 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						},
 						authStorage: this.session.authStorage,
 						modelRegistry: this.session.modelRegistry,
-						searchDb: this.session.searchDb,
 						settings: this.session.settings,
 						mcpManager: this.session.mcpManager,
 						contextFiles,
@@ -841,7 +840,6 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						},
 						authStorage: this.session.authStorage,
 						modelRegistry: this.session.modelRegistry,
-						searchDb: this.session.searchDb,
 						settings: this.session.settings,
 						mcpManager: this.session.mcpManager,
 						contextFiles,
@@ -1116,8 +1114,8 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 			}
 
 			// Build final output - match plugin format
-			const successCount = results.filter(r => r.exitCode === 0 && !r.error).length;
 			const cancelledCount = results.filter(r => r.aborted).length;
+			const successCount = results.filter(r => r.exitCode === 0 && !r.error && !r.aborted).length;
 			const totalDuration = Date.now() - startTime;
 
 			const summaries = results.map(r => {

package/src/task/types.ts

@@ -82,9 +82,9 @@ const createTaskSchema = (options: { isolationEnabled: boolean }) => {
 			}),
 		),
 		schema: Type.Optional(
-			Type.Record(Type.String(), Type.Unknown(), {
+			Type.String({
 				description:
-					"JTD schema defining expected response structure. Use typed properties. Output format belongs here — never in context or assignment.",
+					"JSON-encoded JTD schema defining expected response structure. Output format belongs here — never in context or assignment.",
 			}),
 		),
 		tasks: Type.Array(taskItemSchema, {

package/src/tools/bash.ts

@@ -28,6 +28,7 @@ import { clampTimeout } from "./tool-timeouts";
 export const BASH_DEFAULT_PREVIEW_LINES = 10;
 
 const BASH_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const DEFAULT_AUTO_BACKGROUND_THRESHOLD_MS = 60_000;
 
 const bashSchemaBase = Type.Object({
 	command: Type.String({ description: "Command to execute" }),
@@ -72,6 +73,7 @@ export interface BashToolInput {
 
 export interface BashToolDetails {
 	meta?: OutputMeta;
+	timeoutSeconds?: number;
 	async?: {
 		state: "running" | "completed" | "failed";
 		jobId: string;
@@ -81,6 +83,24 @@ export interface BashToolDetails {
 
 export interface BashToolOptions {}
 
+type ManagedBashJobCompletion =
+	| {
+			kind: "completed";
+			result: AgentToolResult<BashToolDetails>;
+	  }
+	| {
+			kind: "failed";
+			error: unknown;
+	  };
+
+interface ManagedBashJobHandle {
+	jobId: string;
+	label: string;
+	completion: Promise<ManagedBashJobCompletion>;
+	getLatestText: () => string;
+	setBackgrounded: (backgrounded: boolean) => void;
+}
+
 function normalizeResultOutput(result: BashResult | BashInteractiveResult): string {
 	return result.output || "";
 }
@@ -212,12 +232,23 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	readonly concurrency = "exclusive";
 	readonly strict = true;
 	readonly #asyncEnabled: boolean;
+	readonly #autoBackgroundEnabled: boolean;
+	readonly #autoBackgroundThresholdMs: number;
 
 	constructor(private readonly session: ToolSession) {
 		this.#asyncEnabled = this.session.settings.get("async.enabled");
+		this.#autoBackgroundEnabled = this.session.settings.get("bash.autoBackground.enabled");
+		this.#autoBackgroundThresholdMs = Math.max(
+			0,
+			Math.floor(
+				this.session.settings.get("bash.autoBackground.thresholdMs") ?? DEFAULT_AUTO_BACKGROUND_THRESHOLD_MS,
+			),
+		);
 		this.parameters = this.#asyncEnabled ? bashSchemaWithAsync : bashSchemaBase;
 		this.description = prompt.render(bashDescription, {
 			asyncEnabled: this.#asyncEnabled,
+			autoBackgroundEnabled: this.#autoBackgroundEnabled,
+			autoBackgroundThresholdSeconds: Math.max(0, Math.floor(this.#autoBackgroundThresholdMs / 1000)),
 			hasAstGrep: this.session.settings.get("astGrep.enabled"),
 			hasAstEdit: this.session.settings.get("astEdit.enabled"),
 			hasGrep: this.session.settings.get("grep.enabled"),
@@ -253,6 +284,165 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		return outputText;
 	}
 
+	#buildCompletedResult(
+		result: BashResult | BashInteractiveResult,
+		timeoutSec: number,
+		headLines?: number,
+		tailLines?: number,
+	): AgentToolResult<BashToolDetails> {
+		const outputText = this.#formatResultOutput(result, headLines, tailLines);
+		const details: BashToolDetails = { timeoutSeconds: timeoutSec };
+		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
+		this.#buildResultText(result, timeoutSec, outputText);
+		return resultBuilder.done();
+	}
+
+	#buildBackgroundStartResult(
+		jobId: string,
+		label: string,
+		previewText: string,
+		timeoutSec: number,
+	): AgentToolResult<BashToolDetails> {
+		const details: BashToolDetails = {
+			timeoutSeconds: timeoutSec,
+			async: { state: "running", jobId, type: "bash" },
+		};
+		const lines: string[] = [];
+		const trimmedPreview = previewText.trimEnd();
+		if (trimmedPreview.length > 0) {
+			lines.push(trimmedPreview, "");
+		}
+		lines.push(`Background job ${jobId} started: ${label}`);
+		lines.push("Result will be delivered automatically when complete.");
+		lines.push(`Use \`poll\`, \`read jobs://${jobId}\`, or \`cancel_job\` if needed.`);
+		return {
+			content: [{ type: "text", text: lines.join("\n") }],
+			details,
+		};
+	}
+
+	#extractTextResult(result: AgentToolResult<BashToolDetails>): string {
+		return result.content.find(block => block.type === "text")?.text ?? "";
+	}
+
+	#startManagedBashJob(options: {
+		command: string;
+		commandCwd: string;
+		timeoutMs: number;
+		timeoutSec: number;
+		headLines?: number;
+		tailLines?: number;
+		resolvedEnv?: Record<string, string>;
+		onUpdate?: AgentToolUpdateCallback<BashToolDetails>;
+		startBackgrounded: boolean;
+	}): ManagedBashJobHandle {
+		const manager = this.session.asyncJobManager;
+		if (!manager) {
+			throw new ToolError("Background job manager unavailable for this session.");
+		}
+
+		const label = options.command.length > 120 ? `${options.command.slice(0, 117)}...` : options.command;
+		let latestText = "";
+		let backgrounded = options.startBackgrounded;
+		const completion = Promise.withResolvers<ManagedBashJobCompletion>();
+
+		const jobId = manager.register(
+			"bash",
+			label,
+			async ({ jobId, signal: runSignal, reportProgress }) => {
+				const { path: artifactPath, id: artifactId } = (await this.session.allocateOutputArtifact?.("bash")) ?? {};
+				const tailBuffer = new TailBuffer(DEFAULT_MAX_BYTES);
+				try {
+					const result = await executeBash(options.command, {
+						cwd: options.commandCwd,
+						sessionKey: `${this.session.getSessionId?.() ?? ""}:async:${jobId}`,
+						timeout: options.timeoutMs,
+						signal: runSignal,
+						env: options.resolvedEnv,
+						artifactPath,
+						artifactId,
+						onChunk: chunk => {
+							tailBuffer.append(chunk);
+							latestText = tailBuffer.text();
+							void reportProgress(latestText, { async: { state: "running", jobId, type: "bash" } });
+						},
+					});
+					const finalResult = this.#buildCompletedResult(
+						result,
+						options.timeoutSec,
+						options.headLines,
+						options.tailLines,
+					);
+					const finalText = this.#extractTextResult(finalResult);
+					latestText = finalText;
+					completion.resolve({ kind: "completed", result: finalResult });
+					await reportProgress(finalText, { async: { state: "completed", jobId, type: "bash" } });
+					return finalText;
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					latestText = message;
+					completion.resolve({ kind: "failed", error });
+					await reportProgress(message, { async: { state: "failed", jobId, type: "bash" } });
+					throw error;
+				}
+			},
+			{
+				onProgress: async (text, details) => {
+					latestText = text;
+					await options.onUpdate?.({
+						content: [{ type: "text", text }],
+						details: backgrounded ? ((details ?? {}) as BashToolDetails) : {},
+					});
+				},
+			},
+		);
+
+		return {
+			jobId,
+			label,
+			completion: completion.promise,
+			getLatestText: () => latestText,
+			setBackgrounded: (nextBackgrounded: boolean) => {
+				backgrounded = nextBackgrounded;
+			},
+		};
+	}
+
+	async #waitForManagedBashJob(
+		job: ManagedBashJobHandle,
+		thresholdMs: number,
+		signal?: AbortSignal,
+	): Promise<ManagedBashJobCompletion | { kind: "running" } | { kind: "aborted" }> {
+		if (signal?.aborted) {
+			return { kind: "aborted" };
+		}
+
+		const waiters: Array<Promise<ManagedBashJobCompletion | { kind: "running" } | { kind: "aborted" }>> = [
+			job.completion,
+			Bun.sleep(thresholdMs).then(() => ({ kind: "running" as const })),
+		];
+
+		if (!signal) {
+			return await Promise.race(waiters);
+		}
+
+		const { promise: abortedPromise, resolve: resolveAborted } = Promise.withResolvers<{ kind: "aborted" }>();
+		const onAbort = () => resolveAborted({ kind: "aborted" });
+		signal.addEventListener("abort", onAbort, { once: true });
+		waiters.push(abortedPromise);
+		try {
+			return await Promise.race(waiters);
+		} finally {
+			signal.removeEventListener("abort", onAbort);
+		}
+	}
+
+	#resolveAutoBackgroundWaitMs(timeoutMs: number): number {
+		if (this.#autoBackgroundThresholdMs <= 0) return 0;
+		const timeoutBufferMs = 1_000;
+		return Math.max(0, Math.min(this.#autoBackgroundThresholdMs, timeoutMs - timeoutBufferMs));
+	}
+
 	async execute(
 		_toolCallId: string,
 		{
@@ -345,52 +535,56 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		const timeoutMs = timeoutSec * 1000;
 
 		if (asyncRequested) {
-			const manager = this.session.asyncJobManager;
-			if (!manager) {
+			if (!this.session.asyncJobManager) {
 				throw new ToolError("Async job manager unavailable for this session.");
 			}
-			const label = command.length > 120 ? `${command.slice(0, 117)}...` : command;
-			const tailBuffer = new TailBuffer(DEFAULT_MAX_BYTES);
-			const jobId = manager.register(
-				"bash",
-				label,
-				async ({ jobId, signal: runSignal, reportProgress }) => {
-					const { path: artifactPath, id: artifactId } =
-						(await this.session.allocateOutputArtifact?.("bash")) ?? {};
-					try {
-						const result = await executeBash(command, {
-							cwd: commandCwd,
-							sessionKey: `${this.session.getSessionId?.() ?? ""}:async:${jobId}`,
-							timeout: timeoutMs,
-							signal: runSignal,
-							env: resolvedEnv,
-							artifactPath,
-							artifactId,
-							onChunk: chunk => {
-								tailBuffer.append(chunk);
-								void reportProgress(tailBuffer.text(), { async: { state: "running", jobId, type: "bash" } });
-							},
-						});
-						const outputText = this.#formatResultOutput(result, headLines, tailLines);
-						const finalText = this.#buildResultText(result, timeoutSec, outputText);
-						await reportProgress(finalText, { async: { state: "completed", jobId, type: "bash" } });
-						return finalText;
-					} catch (error) {
-						const message = error instanceof Error ? error.message : String(error);
-						await reportProgress(message, { async: { state: "failed", jobId, type: "bash" } });
-						throw error;
-					}
-				},
-				{
-					onProgress: (text, details) => {
-						onUpdate?.({ content: [{ type: "text", text }], details: details ?? {} });
-					},
-				},
-			);
-			return {
-				content: [{ type: "text", text: `Background job ${jobId} started: ${label}` }],
-				details: { async: { state: "running", jobId, type: "bash" } },
-			};
+			const job = this.#startManagedBashJob({
+				command,
+				commandCwd,
+				timeoutMs,
+				timeoutSec,
+				headLines,
+				tailLines,
+				resolvedEnv,
+				onUpdate,
+				startBackgrounded: true,
+			});
+			return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec);
+		}
+
+		if (this.#autoBackgroundEnabled && !pty && this.session.asyncJobManager) {
+			const autoBackgroundWaitMs = this.#resolveAutoBackgroundWaitMs(timeoutMs);
+			const startBackgrounded = autoBackgroundWaitMs === 0;
+			const job = this.#startManagedBashJob({
+				command,
+				commandCwd,
+				timeoutMs,
+				timeoutSec,
+				headLines,
+				tailLines,
+				resolvedEnv,
+				onUpdate,
+				startBackgrounded,
+			});
+			if (startBackgrounded) {
+				return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec);
+			}
+			const waitResult = await this.#waitForManagedBashJob(job, autoBackgroundWaitMs, signal);
+			if (waitResult.kind === "completed") {
+				this.session.asyncJobManager.acknowledgeDeliveries([job.jobId]);
+				return waitResult.result;
+			}
+			if (waitResult.kind === "failed") {
+				this.session.asyncJobManager.acknowledgeDeliveries([job.jobId]);
+				throw waitResult.error;
+			}
+			if (waitResult.kind === "aborted") {
+				this.session.asyncJobManager.cancel(job.jobId);
+				this.session.asyncJobManager.acknowledgeDeliveries([job.jobId]);
+				throw new ToolAbortError(job.getLatestText() || "Command aborted");
+			}
+			job.setBackgrounded(true);
+			return this.#buildBackgroundStartResult(job.jobId, job.label, job.getLatestText(), timeoutSec);
 		}
 
 		// Track output for streaming updates (tail only)
@@ -437,18 +631,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		if (isInteractiveResult(result) && result.timedOut) {
 			throw new ToolError(normalizeResultOutput(result) || `Command timed out after ${timeoutSec} seconds`);
 		}
-
-		const outputText = this.#formatResultOutput(result, headLines, tailLines);
-		const details: BashToolDetails = {};
-		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
-		if (result.exitCode === undefined) {
-			throw new ToolError(`${outputText}\n\nCommand failed: missing exit status`);
-		}
-		if (result.exitCode !== 0 && result.exitCode !== undefined) {
-			throw new ToolError(`${outputText}\n\nCommand exited with code ${result.exitCode}`);
-		}
-
-		return resultBuilder.done();
+		return this.#buildCompletedResult(result, timeoutSec, headLines, tailLines);
 	}
 }
 
@@ -524,7 +707,7 @@ export const bashToolRenderer = {
 				const showingFullOutput = expanded && renderContext?.isFullOutput === true;
 
 				// Build truncation warning
-				const timeoutSeconds = renderContext?.timeout;
+				const timeoutSeconds = details?.timeoutSeconds ?? renderContext?.timeout;
 				const timeoutLine =
 					typeof timeoutSeconds === "number"
 						? uiTheme.fg(

package/src/tools/cancel-job.ts

@@ -1,6 +1,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
+import { isBackgroundJobSupportEnabled } from "../async";
 import cancelJobDescription from "../prompts/tools/cancel-job.md" with { type: "text" };
 import type { ToolSession } from "./index";
 
@@ -27,7 +28,7 @@ export class CancelJobTool implements AgentTool<typeof cancelJobSchema, CancelJo
 	}
 
 	static createIf(session: ToolSession): CancelJobTool | null {
-		if (!session.settings.get("async.enabled")) return null;
+		if (!isBackgroundJobSupportEnabled(session.settings)) return null;
 		return new CancelJobTool(session);
 	}
 

package/src/tools/find.ts

@@ -244,17 +244,20 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 							maxResults: effectiveLimit,
 							sortByMtime: true,
 							gitignore: useGitignore,
+							signal: combinedSignal,
 						},
 						onMatch,
-						this.session.searchDb,
 					),
 				);
 
 			try {
 				let result = await doGlob(true);
-				if (result.matches.length === 0) {
+				if (result.matches.length === 0 && !timeoutSignal.aborted) {
 					result = await doGlob(false);
 				}
+				// Sort by mtime descending (most recent first) in JS instead of native.
+				// This allows native glob to early-terminate at maxResults.
+				result.matches.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
 				matches = result.matches;
 			} catch (error) {
 				if (error instanceof Error && error.name === "AbortError") {

package/src/tools/grep.ts

@@ -7,7 +7,7 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { computeLineHash } from "../edit/line-hash";
-import { formatChunkedGrepLine } from "../edit/modes/chunk";
+import { type ChunkedGrepMatch, describeChunkedGrepMatch } from "../edit/modes/chunk";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
 import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
@@ -162,7 +162,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				const stat = await Bun.file(searchPath).stat();
 				isDirectory = stat.isDirectory();
 			} catch {
-				throw new ToolError(`Path not found: ${scopePath}`);
+				const hint = scopePath.includes(",") ? ` (comma-separated paths must each exist relative to cwd)` : "";
+				throw new ToolError(`Path not found: ${scopePath}${hint}`);
 			}
 
 			const effectiveOutputMode = GrepOutputMode.Content;
@@ -191,7 +192,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						mode: effectiveOutputMode,
 					},
 					undefined,
-					this.session.searchDb,
 				);
 			} catch (err) {
 				if (err instanceof Error && err.message.startsWith("regex parse error")) {
@@ -274,13 +274,11 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				matchesByFile.get(relativePath)!.push(match);
 			}
 			if (chunkMode) {
-				const annotatedLines = await Promise.all(
+				const annotatedMatches = await Promise.all(
 					selectedMatches.map(match => {
 						const relativePath = match.path.startsWith("/") ? match.path.slice(1) : match.path;
 						const absoluteFilePath = isDirectory ? path.join(searchPath, relativePath) : searchPath;
-						const displayPath = formatPath(match.path);
-						fileMatchCounts.set(displayPath, (fileMatchCounts.get(displayPath) ?? 0) + 1);
-						return formatChunkedGrepLine({
+						return describeChunkedGrepMatch({
 							filePath: absoluteFilePath,
 							lineNumber: match.lineNumber,
 							line: match.line,
@@ -289,7 +287,78 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						});
 					}),
 				);
-				const rawOutput = annotatedLines.join("\n");
+				const chunkMatchesByFile = new Map<string, ChunkedGrepMatch[]>();
+				for (const match of annotatedMatches) {
+					recordFile(match.displayPath);
+					if (!chunkMatchesByFile.has(match.displayPath)) {
+						chunkMatchesByFile.set(match.displayPath, []);
+					}
+					chunkMatchesByFile.get(match.displayPath)!.push(match);
+				}
+				const renderChunkedMatchesForFile = (relativePath: string) => {
+					const fileMatches = chunkMatchesByFile.get(relativePath) ?? [];
+					if (fileMatches.length === 0) {
+						return;
+					}
+					const lineWidth = fileMatches[0]?.fileLineCount.toString().length ?? 1;
+					const matchesByChunk = new Map<string, ChunkedGrepMatch[]>();
+					for (const match of fileMatches) {
+						const chunkKey = match.chunkPath ?? "";
+						if (!matchesByChunk.has(chunkKey)) {
+							matchesByChunk.set(chunkKey, []);
+						}
+						matchesByChunk.get(chunkKey)!.push(match);
+					}
+					for (const [chunkPath, chunkMatches] of matchesByChunk) {
+						if (chunkPath) {
+							const chunkChecksum = chunkMatches[0]?.chunkChecksum;
+							const dashes = "-".repeat(chunkPath.split(".").length - 1);
+							const anchor = chunkChecksum
+								? `${dashes}@${chunkPath}#${chunkChecksum}`
+								: `${dashes}@${chunkPath}`;
+							outputLines.push(anchor);
+						}
+						for (const match of chunkMatches) {
+							outputLines.push(`    ${match.lineNumber.toString().padStart(lineWidth, " ")} |${match.line}`);
+							fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
+						}
+					}
+				};
+				if (isDirectory) {
+					const filesByDirectory = new Map<string, string[]>();
+					for (const relativePath of fileList) {
+						const directory = path.dirname(relativePath).replace(/\\/g, "/");
+						if (!filesByDirectory.has(directory)) {
+							filesByDirectory.set(directory, []);
+						}
+						filesByDirectory.get(directory)!.push(relativePath);
+					}
+					for (const [directory, directoryFiles] of filesByDirectory) {
+						if (directory === ".") {
+							for (const relativePath of directoryFiles) {
+								if (outputLines.length > 0) {
+									outputLines.push("");
+								}
+								outputLines.push(`# ${path.basename(relativePath)}`);
+								renderChunkedMatchesForFile(relativePath);
+							}
+							continue;
+						}
+						if (outputLines.length > 0) {
+							outputLines.push("");
+						}
+						outputLines.push(`# ${directory}`);
+						for (const relativePath of directoryFiles) {
+							outputLines.push(`## └─ ${path.basename(relativePath)}`);
+							renderChunkedMatchesForFile(relativePath);
+						}
+					}
+				} else {
+					for (const relativePath of fileList) {
+						renderChunkedMatchesForFile(relativePath);
+					}
+				}
+				const rawOutput = outputLines.join("\n");
 				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 				const truncated = Boolean(matchLimitReached || result.limitReached || truncation.truncated);
 				const details: GrepToolDetails = {