@oh-my-pi/pi-coding-agent 8.0.20 → 8.2.0

package/src/task/agents.ts

@@ -3,16 +3,15 @@
  *
  * Agents are embedded at build time via Bun's import with { type: "text" }.
  */
-
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import { parseAgentFields } from "@oh-my-pi/pi-coding-agent/discovery/helpers";
-import exploreMd from "@oh-my-pi/pi-coding-agent/prompts/agents/explore.md" with { type: "text" };
+import { renderPromptTemplate } from "../config/prompt-templates";
+import { parseAgentFields } from "../discovery/helpers";
+import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
 // Embed agent markdown files at build time
-import agentFrontmatterTemplate from "@oh-my-pi/pi-coding-agent/prompts/agents/frontmatter.md" with { type: "text" };
-import planMd from "@oh-my-pi/pi-coding-agent/prompts/agents/plan.md" with { type: "text" };
-import reviewerMd from "@oh-my-pi/pi-coding-agent/prompts/agents/reviewer.md" with { type: "text" };
-import taskMd from "@oh-my-pi/pi-coding-agent/prompts/agents/task.md" with { type: "text" };
-import { parseFrontmatter } from "@oh-my-pi/pi-coding-agent/utils/frontmatter";
+import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
+import planMd from "../prompts/agents/plan.md" with { type: "text" };
+import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
+import taskMd from "../prompts/agents/task.md" with { type: "text" };
+import { parseFrontmatter } from "../utils/frontmatter";
 import type { AgentDefinition, AgentSource } from "./types";
 
 interface AgentFrontmatter {
@@ -69,30 +68,56 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	},
 ];
 
-const EMBEDDED_AGENTS: { name: string; content: string }[] = EMBEDDED_AGENT_DEFS.map((def) => ({
+const EMBEDDED_AGENTS: { name: string; content: string }[] = EMBEDDED_AGENT_DEFS.map(def => ({
 	name: def.fileName,
 	content: buildAgentContent(def),
 }));
 
+export class AgentParsingError extends Error {
+	constructor(
+		error: Error,
+		public readonly source?: unknown,
+	) {
+		super(`Failed to parse agent: ${error.message}`, { cause: error });
+		this.name = "AgentParsingError";
+	}
+
+	toString(): string {
+		const details: string[] = [this.message];
+		if (this.source !== undefined) {
+			details.push(`Source: ${JSON.stringify(this.source)}`);
+		}
+		if (this.cause && typeof this.cause === "object" && "stack" in this.cause && this.cause.stack) {
+			details.push(`Stack:\n${this.cause.stack}`);
+		} else if (this.stack) {
+			details.push(`Stack:\n${this.stack}`);
+		}
+		return details.join("\n\n");
+	}
+}
+
 /**
  * Parse an agent from embedded content.
  */
-function parseAgent(fileName: string, content: string, source: AgentSource): AgentDefinition | null {
+export function parseAgent(
+	filePath: string,
+	content: string,
+	source: AgentSource,
+	level: "fatal" | "warn" | "off" = "fatal",
+): AgentDefinition {
 	const { frontmatter, body } = parseFrontmatter(content, {
-		source: `embedded:${fileName}`,
-		level: "fatal",
+		location: filePath,
+		level,
 	});
 	const fields = parseAgentFields(frontmatter);
-
 	if (!fields) {
-		return null;
+		throw new AgentParsingError(new Error("Invalid agent fields"), filePath);
 	}
-
 	return {
 		...fields,
 		systemPrompt: body,
 		source,
-		filePath: `embedded:${fileName}`,
+		filePath,
 	};
 }
 
@@ -107,25 +132,15 @@ export function loadBundledAgents(): AgentDefinition[] {
 	if (bundledAgentsCache !== null) {
 		return bundledAgentsCache;
 	}
-
-	const agents: AgentDefinition[] = [];
-
-	for (const { name, content } of EMBEDDED_AGENTS) {
-		const agent = parseAgent(name, content, "bundled");
-		if (agent) {
-			agents.push(agent);
-		}
-	}
-
-	bundledAgentsCache = agents;
-	return agents;
+	bundledAgentsCache = EMBEDDED_AGENTS.map(({ name, content }) => parseAgent(`embedded:${name}`, content, "bundled"));
+	return bundledAgentsCache;
 }
 
 /**
  * Get a bundled agent by name.
  */
 export function getBundledAgent(name: string): AgentDefinition | undefined {
-	return loadBundledAgents().find((a) => a.name === name);
+	return loadBundledAgents().find(a => a.name === name);
 }
 
 /**

package/src/task/commands.ts

@@ -3,14 +3,13 @@
  *
  * Commands are embedded at build time via Bun's import with { type: "text" }.
  */
-
 import * as path from "node:path";
-import { type SlashCommand, slashCommandCapability } from "@oh-my-pi/pi-coding-agent/capability/slash-command";
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import { loadCapability } from "@oh-my-pi/pi-coding-agent/discovery";
+import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import { loadCapability } from "../discovery";
 // Embed command markdown files at build time
-import initMd from "@oh-my-pi/pi-coding-agent/prompts/agents/init.md" with { type: "text" };
-import { parseFrontmatter } from "@oh-my-pi/pi-coding-agent/utils/frontmatter";
+import initMd from "../prompts/agents/init.md" with { type: "text" };
+import { parseFrontmatter } from "../utils/frontmatter";
 
 const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
 	{ name: "init.md", content: renderPromptTemplate(initMd) },
@@ -116,7 +115,7 @@ export async function discoverCommands(cwd: string): Promise<WorkflowCommand[]>
  * Get a command by name.
  */
 export function getCommand(commands: WorkflowCommand[], name: string): WorkflowCommand | undefined {
-	return commands.find((c) => c.name === name);
+	return commands.find(c => c.name === name);
 }
 
 /**

package/src/task/discovery.ts

@@ -11,13 +11,11 @@
  *
  * Agent files use markdown with YAML frontmatter.
  */
-
-import * as fs from "node:fs";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { findAllNearestProjectConfigDirs, getConfigDirs } from "@oh-my-pi/pi-coding-agent/config";
-import { parseAgentFields } from "@oh-my-pi/pi-coding-agent/discovery/helpers";
-import { parseFrontmatter } from "@oh-my-pi/pi-coding-agent/utils/frontmatter";
-import { loadBundledAgents } from "./agents";
+import { logger } from "@oh-my-pi/pi-utils";
+import { findAllNearestProjectConfigDirs, getConfigDirs } from "../config";
+import { loadBundledAgents, parseAgent } from "./agents";
 import type { AgentDefinition, AgentSource } from "./types";
 
 /** Result of agent discovery */
@@ -29,55 +27,23 @@ export interface DiscoveryResult {
 /**
  * Load agents from a directory.
  */
-function loadAgentsFromDir(dir: string, source: AgentSource): AgentDefinition[] {
-	const agents: AgentDefinition[] = [];
-
-	if (!fs.existsSync(dir)) {
-		return agents;
-	}
-
-	let entries: fs.Dirent[];
-	try {
-		entries = fs.readdirSync(dir, { withFileTypes: true });
-	} catch {
-		return agents;
-	}
-
-	for (const entry of entries) {
-		if (!entry.name.endsWith(".md")) continue;
-
-		const filePath = path.resolve(dir, entry.name);
-
-		// Handle both regular files and symlinks
-		try {
-			if (!fs.statSync(filePath).isFile()) continue;
-		} catch {
-			continue;
-		}
-
-		let content: string;
-		try {
-			content = fs.readFileSync(filePath, "utf-8");
-		} catch {
-			continue;
-		}
-
-		const { frontmatter, body } = parseFrontmatter(content, { source: filePath });
-		const fields = parseAgentFields(frontmatter);
-
-		if (!fields) {
-			continue;
-		}
-
-		agents.push({
-			...fields,
-			systemPrompt: body,
-			source,
-			filePath,
+async function loadAgentsFromDir(dir: string, source: AgentSource): Promise<AgentDefinition[]> {
+	const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+	const files = entries
+		.filter(entry => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith(".md"))
+		.sort((a, b) => a.name.localeCompare(b.name))
+		.map(file => {
+			const filePath = path.join(dir, file.name);
+			return fs
+				.readFile(filePath, "utf-8")
+				.then(content => parseAgent(filePath, content, source, "warn"))
+				.catch(error => {
+					logger.warn("Failed to read agent file", { filePath, error });
+					return null;
+				});
 		});
-	}
 
-	return agents;
+	return (await Promise.all(files)).filter(Boolean) as AgentDefinition[];
 }
 
 /**
@@ -89,62 +55,59 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentDefinition[]
  */
 export async function discoverAgents(cwd: string): Promise<DiscoveryResult> {
 	const resolvedCwd = path.resolve(cwd);
-	const agentSources = Array.from(new Set(getConfigDirs("", { project: false }).map((entry) => entry.source)));
+	const agentSources = Array.from(new Set(getConfigDirs("", { project: false }).map(entry => entry.source)));
 
 	// Get user directories (priority order: .omp, .pi, .claude, ...)
 	const userDirs = getConfigDirs("agents", { project: false })
-		.filter((entry) => agentSources.includes(entry.source))
-		.map((entry) => ({
+		.filter(entry => agentSources.includes(entry.source))
+		.map(entry => ({
 			...entry,
 			path: path.resolve(entry.path),
 		}));
 
 	// Get project directories by walking up from cwd (priority order)
 	const projectDirs = (await findAllNearestProjectConfigDirs("agents", resolvedCwd))
-		.filter((entry) => agentSources.includes(entry.source))
-		.map((entry) => ({
+		.filter(entry => agentSources.includes(entry.source))
+		.map(entry => ({
 			...entry,
 			path: path.resolve(entry.path),
 		}));
 
 	const orderedSources = agentSources.filter(
-		(source) =>
-			userDirs.some((entry) => entry.source === source) || projectDirs.some((entry) => entry.source === source),
+		source => userDirs.some(entry => entry.source === source) || projectDirs.some(entry => entry.source === source),
 	);
 
 	const orderedDirs: Array<{ dir: string; source: AgentSource }> = [];
 	for (const source of orderedSources) {
-		const project = projectDirs.find((entry) => entry.source === source);
+		const project = projectDirs.find(entry => entry.source === source);
 		if (project) orderedDirs.push({ dir: project.path, source: "project" });
-		const user = userDirs.find((entry) => entry.source === source);
+		const user = userDirs.find(entry => entry.source === source);
 		if (user) orderedDirs.push({ dir: user.path, source: "user" });
 	}
 
-	const agents: AgentDefinition[] = [];
 	const seen = new Set<string>();
-
-	for (const { dir, source } of orderedDirs) {
-		for (const agent of loadAgentsFromDir(dir, source)) {
-			if (seen.has(agent.name)) continue;
-			agents.push(agent);
+	const loadedAgents = (await Promise.all(orderedDirs.map(({ dir, source }) => loadAgentsFromDir(dir, source))))
+		.flat()
+		.filter(agent => {
+			if (seen.has(agent.name)) return false;
 			seen.add(agent.name);
-		}
-	}
+			return true;
+		});
 
-	for (const agent of loadBundledAgents()) {
-		if (seen.has(agent.name)) continue;
-		agents.push(agent);
+	const bundledAgents = loadBundledAgents().filter(agent => {
+		if (seen.has(agent.name)) return false;
 		seen.add(agent.name);
-	}
+		return true;
+	});
 
 	const projectAgentsDir = projectDirs.length > 0 ? projectDirs[0].path : null;
 
-	return { agents, projectAgentsDir };
+	return { agents: [...loadedAgents, ...bundledAgents], projectAgentsDir };
 }
 
 /**
  * Get an agent by name from discovered agents.
  */
 export function getAgent(agents: AgentDefinition[], name: string): AgentDefinition | undefined {
-	return agents.find((a) => a.name === name);
+	return agents.find(a => a.name === name);
 }

package/src/task/executor.ts

@@ -3,20 +3,19 @@
  *
  * Runs each subagent in a Bun Worker and forwards AgentEvents for progress tracking.
  */
-
 import path from "node:path";
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ModelRegistry } from "@oh-my-pi/pi-coding-agent/config/model-registry";
-import { formatModelString, parseModelPattern } from "@oh-my-pi/pi-coding-agent/config/model-resolver";
-import { checkPythonKernelAvailability } from "@oh-my-pi/pi-coding-agent/ipy/kernel";
-import { LspTool } from "@oh-my-pi/pi-coding-agent/lsp/index";
-import type { LspParams } from "@oh-my-pi/pi-coding-agent/lsp/types";
-import { callTool } from "@oh-my-pi/pi-coding-agent/mcp/client";
-import type { MCPManager } from "@oh-my-pi/pi-coding-agent/mcp/manager";
-import type { AuthStorage } from "@oh-my-pi/pi-coding-agent/session/auth-storage";
-import { PythonTool, type PythonToolParams } from "@oh-my-pi/pi-coding-agent/tools/python";
-import type { EventBus } from "@oh-my-pi/pi-coding-agent/utils/event-bus";
 import type { ToolSession } from "..";
+import type { ModelRegistry } from "../config/model-registry";
+import { formatModelString, parseModelPattern } from "../config/model-resolver";
+import { checkPythonKernelAvailability } from "../ipy/kernel";
+import { LspTool } from "../lsp";
+import type { LspParams } from "../lsp/types";
+import { callTool } from "../mcp/client";
+import type { MCPManager } from "../mcp/manager";
+import type { AuthStorage } from "../session/auth-storage";
+import { PythonTool, type PythonToolParams } from "../tools/python";
+import type { EventBus } from "../utils/event-bus";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,
@@ -171,7 +170,7 @@ function getUsageTokens(usage: unknown): number {
  * falling back to empty strings if not.
  */
 function extractMCPToolMetadata(mcpManager: MCPManager): MCPToolMetadata[] {
-	return mcpManager.getTools().map((tool) => {
+	return mcpManager.getTools().map(tool => {
 		// MCPTool and DeferredMCPTool have these properties
 		const mcpTool = tool as { mcpToolName?: string; mcpServerName?: string };
 		return {
@@ -264,7 +263,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	const pythonToolMode = options.settingsManager?.getPythonToolMode?.() ?? "ipy-only";
 	if (toolNames?.includes("exec")) {
-		const expanded = toolNames.filter((name) => name !== "exec");
+		const expanded = toolNames.filter(name => name !== "exec");
 		if (pythonToolMode === "bash-only") {
 			expanded.push("bash");
 		} else if (pythonToolMode === "ipy-only") {
@@ -706,11 +705,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		message: string;
 	}
 
-	const done = await new Promise<Extract<SubagentWorkerResponse, { type: "done" }>>((resolve) => {
+	const done = await new Promise<Extract<SubagentWorkerResponse, { type: "done" }>>(resolve => {
 		const cleanup = () => {
 			listenerController.abort();
 		};
-		finalize = (message) => {
+		finalize = message => {
 			if (resolved) return;
 			resolved = true;
 			cleanup();

package/src/task/index.ts

@@ -12,21 +12,23 @@
  *   - Progress tracking via JSON events
  *   - Session artifacts for debugging
  */
-
-import { mkdir, rm, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import type { Theme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
-import taskDescriptionTemplate from "@oh-my-pi/pi-coding-agent/prompts/tools/task.md" with { type: "text" };
-import { formatDuration } from "@oh-my-pi/pi-coding-agent/tools/render-utils";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
 import type { ToolSession } from "..";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import type { Theme } from "../modes/theme/theme";
+import taskDescriptionTemplate from "../prompts/tools/task.md" with { type: "text" };
+import { formatDuration } from "../tools/render-utils";
+// Import review tools for side effects (registers subagent tool handlers)
+import "../tools/review";
 import { discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
+import { AgentOutputManager } from "./output-manager";
 import { mapWithConcurrencyLimit } from "./parallel";
 import { renderCall, renderResult } from "./render";
 import { renderTemplate } from "./template";
@@ -48,9 +50,6 @@ import {
 	getRepoRoot,
 } from "./worktree";
 
-// Import review tools for side effects (registers subagent tool handlers)
-import "../tools/review";
-
 /** Format byte count for display */
 function formatBytes(bytes: number): string {
 	if (bytes < 1024) return `${bytes}B`;
@@ -101,6 +100,7 @@ function addUsageTotals(target: Usage, usage: Partial<Usage>): void {
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";
+export { AgentOutputManager } from "./output-manager";
 export type { AgentDefinition, AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types";
 export { taskSchema } from "./types";
 
@@ -172,7 +172,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 		// Validate agent exists
 		const agent = getAgent(agents, agentName);
 		if (!agent) {
-			const available = agents.map((a) => a.name).join(", ") || "none";
+			const available = agents.map(a => a.name).join(", ") || "none";
 			return {
 				content: [
 					{
@@ -266,7 +266,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				problems.push(`Missing task ids at indexes: ${missingTaskIndexes.join(", ")}`);
 			}
 			if (duplicateIds.length > 0) {
-				const details = duplicateIds.map((entry) => `${entry.id} (indexes ${entry.indexes.join(", ")})`).join("; ");
+				const details = duplicateIds.map(entry => `${entry.id} (indexes ${entry.indexes.join(", ")})`).join("; ");
 				problems.push(`Duplicate task ids detected (case-insensitive): ${details}`);
 			}
 			return {
@@ -306,9 +306,8 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 		// Derive artifacts directory
 		const sessionFile = this.session.getSessionFile();
 		const artifactsDir = sessionFile ? sessionFile.slice(0, -6) : null;
-		const tempArtifactsDir = artifactsDir ? null : path.join(tmpdir(), `omp-task-${nanoid()}`);
+		const tempArtifactsDir = artifactsDir ? null : path.join(os.tmpdir(), `omp-task-${nanoid()}`);
 		const effectiveArtifactsDir = artifactsDir || tempArtifactsDir!;
-		await mkdir(effectiveArtifactsDir, { recursive: true });
 
 		// Initialize progress tracking
 		const progressMap = new Map<number, AgentProgress>();
@@ -347,7 +346,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 
 			// Check spawn restrictions from parent
 			const parentSpawns = this.session.getSessionSpawns() ?? "*";
-			const allowedSpawns = parentSpawns.split(",").map((s) => s.trim());
+			const allowedSpawns = parentSpawns.split(",").map(s => s.trim());
 			const isSpawnAllowed = (): boolean => {
 				if (parentSpawns === "") return false; // Empty = deny all
 				if (parentSpawns === "*") return true; // Wildcard = allow all
@@ -367,7 +366,14 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			}
 
 			// Build full prompts with context prepended
-			const tasksWithContext = tasks.map((t) => renderTemplate(context, t));
+			// Allocate unique IDs across the session to prevent artifact collisions
+			const outputManager =
+				this.session.agentOutputManager ?? new AgentOutputManager(this.session.getArtifactsDir ?? (() => null));
+			const uniqueIds = await outputManager.allocateBatch(tasks.map(t => t.id));
+			const tasksWithUniqueIds = tasks.map((t, i) => ({ ...t, id: uniqueIds[i] }));
+
+			// Build full prompts with context prepended
+			const tasksWithContext = tasksWithUniqueIds.map(t => renderTemplate(context, t));
 
 			// Initialize progress for all tasks
 			for (let i = 0; i < tasksWithContext.length; i++) {
@@ -410,7 +416,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						enableLsp: false,
 						signal,
 						eventBus: undefined,
-						onProgress: (progress) => {
+						onProgress: progress => {
 							progressMap.set(index, {
 								...structuredClone(progress),
 								args: tasksWithContext[index]?.args,
@@ -450,7 +456,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						enableLsp: false,
 						signal,
 						eventBus: undefined,
-						onProgress: (progress) => {
+						onProgress: progress => {
 							progressMap.set(index, {
 								...structuredClone(progress),
 								args: tasksWithContext[index]?.args,
@@ -556,29 +562,29 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			let patchApplySummary = "";
 			let patchesApplied: boolean | null = null;
 			if (isIsolated) {
-				const patchesInOrder = results.map((result) => result.patchPath).filter(Boolean) as string[];
-				const missingPatch = results.some((result) => !result.patchPath);
+				const patchesInOrder = results.map(result => result.patchPath).filter(Boolean) as string[];
+				const missingPatch = results.some(result => !result.patchPath);
 				if (!repoRoot || missingPatch) {
 					patchesApplied = false;
 				} else {
 					const patchStats = await Promise.all(
-						patchesInOrder.map(async (patchPath) => ({
+						patchesInOrder.map(async patchPath => ({
 							patchPath,
-							size: (await stat(patchPath)).size,
+							size: (await fs.stat(patchPath)).size,
 						})),
 					);
-					const nonEmptyPatches = patchStats.filter((patch) => patch.size > 0).map((patch) => patch.patchPath);
+					const nonEmptyPatches = patchStats.filter(patch => patch.size > 0).map(patch => patch.patchPath);
 					if (nonEmptyPatches.length === 0) {
 						patchesApplied = true;
 					} else {
 						const patchTexts = await Promise.all(
-							nonEmptyPatches.map(async (patchPath) => Bun.file(patchPath).text()),
+							nonEmptyPatches.map(async patchPath => Bun.file(patchPath).text()),
 						);
-						const combinedPatch = patchTexts.map((text) => (text.endsWith("\n") ? text : `${text}\n`)).join("");
+						const combinedPatch = patchTexts.map(text => (text.endsWith("\n") ? text : `${text}\n`)).join("");
 						if (!combinedPatch.trim()) {
 							patchesApplied = true;
 						} else {
-							const combinedPatchPath = path.join(tmpdir(), `omp-task-combined-${nanoid()}.patch`);
+							const combinedPatchPath = path.join(os.tmpdir(), `omp-task-combined-${nanoid()}.patch`);
 							try {
 								await Bun.write(combinedPatchPath, combinedPatch);
 								const checkResult = await $`git apply --check --binary ${combinedPatchPath}`
@@ -595,7 +601,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 									patchesApplied = applyResult.exitCode === 0;
 								}
 							} finally {
-								await rm(combinedPatchPath, { force: true });
+								await fs.rm(combinedPatchPath, { force: true });
 							}
 						}
 					}
@@ -608,18 +614,18 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						"<system-notification>Patches were not applied and must be handled manually.</system-notification>";
 					const patchList =
 						patchPaths.length > 0
-							? `\n\nPatch artifacts:\n${patchPaths.map((patch) => `- ${patch}`).join("\n")}`
+							? `\n\nPatch artifacts:\n${patchPaths.map(patch => `- ${patch}`).join("\n")}`
 							: "";
 					patchApplySummary = `\n\n${notification}${patchList}`;
 				}
 			}
 
 			// Build final output - match plugin format
-			const successCount = results.filter((r) => r.exitCode === 0).length;
-			const cancelledCount = results.filter((r) => r.aborted).length;
+			const successCount = results.filter(r => r.exitCode === 0).length;
+			const cancelledCount = results.filter(r => r.aborted).length;
 			const totalDuration = Date.now() - startTime;
 
-			const summaries = results.map((r) => {
+			const summaries = results.map(r => {
 				const status = r.aborted ? "cancelled" : 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");
@@ -629,10 +635,10 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				return `[${r.agent}] ${status}${meta} ${r.id}\n${preview}`;
 			});
 
-			const outputIds = results.filter((r) => !r.aborted || r.output.trim()).map((r) => r.id);
+			const outputIds = results.filter(r => !r.aborted || r.output.trim()).map(r => r.id);
 			const outputHint =
 				outputIds.length > 0
-					? `\n\nUse read with agent:// for full logs: ${outputIds.map((id) => `agent://${id}`).join(", ")}`
+					? `\n\nUse read with agent:// for full logs: ${outputIds.map(id => `agent://${id}`).join(", ")}`
 					: "";
 			const schemaNote = schemaOverridden
 				? `\n\nNote: Agent '${agentName}' has a fixed output schema; your 'output' parameter was ignored.\nRequired schema: ${JSON.stringify(agent.output)}`
@@ -646,7 +652,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			const shouldCleanupTempArtifacts =
 				tempArtifactsDir && (!isIsolated || patchesApplied === true || patchesApplied === null);
 			if (shouldCleanupTempArtifacts) {
-				await rm(tempArtifactsDir, { recursive: true, force: true });
+				await fs.rm(tempArtifactsDir, { recursive: true, force: true });
 			}
 
 			return {