@oh-my-pi/pi-coding-agent 10.6.1 → 11.0.0

package/src/task/executor.ts

@@ -157,6 +157,8 @@ export interface ExecutorOptions {
 	modelOverride?: string | string[];
 	thinkingLevel?: ThinkingLevel;
 	outputSchema?: unknown;
+	/** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */
+	taskDepth?: number;
 	enableLsp?: boolean;
 	signal?: AbortSignal;
 	onProgress?: (progress: AgentProgress) => void;
@@ -428,17 +430,25 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		subtaskSessionFile = path.join(options.artifactsDir, `${id}.jsonl`);
 	}
 
+	const settings = options.settings ?? Settings.isolated();
+	const maxRecursionDepth = settings.get("task.maxRecursionDepth") ?? 2;
+	const parentDepth = options.taskDepth ?? 0;
+	const childDepth = parentDepth + 1;
+	const atMaxDepth = maxRecursionDepth >= 0 && childDepth >= maxRecursionDepth;
+
 	// Add tools if specified
 	let toolNames: string[] | undefined;
 	if (agent.tools && agent.tools.length > 0) {
 		toolNames = agent.tools;
 		// Auto-include task tool if spawns defined but task not in tools
-		if (agent.spawns !== undefined && !toolNames.includes("task")) {
+		if (agent.spawns !== undefined && !toolNames.includes("task") && !atMaxDepth) {
 			toolNames = [...toolNames, "task"];
 		}
 	}
 
-	const settings = options.settings ?? Settings.isolated();
+	if (atMaxDepth && toolNames?.includes("task")) {
+		toolNames = toolNames.filter(name => name !== "task");
+	}
 	const pythonToolMode = settings.get("python.toolMode") ?? "both";
 	if (toolNames?.includes("exec")) {
 		const expanded = toolNames.filter(name => name !== "exec");
@@ -454,7 +464,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	const modelPatterns = normalizeModelPatterns(modelOverride ?? agent.model);
 	const sessionFile = subtaskSessionFile ?? null;
-	const spawnsEnv = agent.spawns === undefined ? "" : agent.spawns === "*" ? "*" : agent.spawns.join(",");
+	const spawnsEnv = atMaxDepth
+		? ""
+		: agent.spawns === undefined
+			? ""
+			: agent.spawns === "*"
+				? "*"
+				: agent.spawns.join(",");
 
 	const lspEnabled = enableLsp ?? true;
 	const skipPythonPreflight = Array.isArray(toolNames) && !toolNames.includes("python");
@@ -877,6 +893,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				sessionManager,
 				hasUI: false,
 				spawns: spawnsEnv,
+				taskDepth: childDepth,
+				parentTaskPrefix: id,
 				enableLsp: lspEnabled,
 				skipPythonPreflight,
 				enableMCP,
@@ -1003,9 +1021,14 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			}
 
 			const lastMessage = session.state.messages[session.state.messages.length - 1];
-			if (lastMessage?.role === "assistant" && lastMessage.stopReason === "aborted") {
-				aborted = abortReason === "signal" || abortReason === undefined;
-				exitCode = 1;
+			if (lastMessage?.role === "assistant") {
+				if (lastMessage.stopReason === "aborted") {
+					aborted = abortReason === "signal" || abortReason === undefined;
+					exitCode = 1;
+				} else if (lastMessage.stopReason === "error") {
+					exitCode = 1;
+					error ??= lastMessage.errorMessage || "Subagent failed";
+				}
 			}
 		} catch (err) {
 			exitCode = 1;
@@ -1093,7 +1116,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			stderr = "";
 		}
 	} else {
-		const allowFallback = !done.aborted && !signal?.aborted;
+		const allowFallback = exitCode === 0 && !done.aborted && !signal?.aborted;
 		const { normalized: normalizedSchema, error: schemaError } = normalizeOutputSchema(outputSchema);
 		const hasOutputSchema = normalizedSchema !== undefined && !schemaError;
 		const fallback = allowFallback ? resolveFallbackCompletion(rawOutput, outputSchema) : null;
@@ -1110,7 +1133,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		} else if (!hasOutputSchema && allowFallback && rawOutput.trim().length > 0) {
 			exitCode = 0;
 			stderr = "";
-		} else {
+		} else if (exitCode === 0) {
 			const warning = "SYSTEM WARNING: Subagent exited without calling submit_result tool after 3 reminders.";
 			rawOutput = rawOutput ? `${warning}\n\n${rawOutput}` : warning;
 		}

package/src/task/index.ts

@@ -17,8 +17,8 @@ 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 { $env, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
-import { nanoid } from "nanoid";
 import type { ToolSession } from "..";
 import { isDefaultModelAlias } from "../config/model-resolver";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -35,15 +35,7 @@ import { AgentOutputManager } from "./output-manager";
 import { mapWithConcurrencyLimit } from "./parallel";
 import { renderCall, renderResult } from "./render";
 import { renderTemplate } from "./template";
-import {
-	type AgentProgress,
-	MAX_CONCURRENCY,
-	MAX_PARALLEL_TASKS,
-	type SingleResult,
-	type TaskParams,
-	type TaskToolDetails,
-	taskSchema,
-} from "./types";
+import { type AgentProgress, type SingleResult, type TaskParams, type TaskToolDetails, taskSchema } from "./types";
 import {
 	applyBaseline,
 	captureBaseline,
@@ -110,13 +102,12 @@ export { taskSchema } from "./types";
 /**
  * Build dynamic tool description listing available agents.
  */
-async function buildDescription(cwd: string): Promise<string> {
+async function buildDescription(cwd: string, maxConcurrency: number): Promise<string> {
 	const { agents } = await discoverAgents(cwd);
 
 	return renderPromptTemplate(taskDescriptionTemplate, {
 		agents,
-		MAX_PARALLEL_TASKS,
-		MAX_CONCURRENCY,
+		MAX_CONCURRENCY: maxConcurrency,
 	});
 }
 
@@ -144,14 +135,15 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 	private constructor(session: ToolSession, description: string) {
 		this.session = session;
 		this.description = description;
-		this.blockedAgent = process.env.OMP_BLOCKED_AGENT;
+		this.blockedAgent = $env.PI_BLOCKED_AGENT;
 	}
 
 	/**
 	 * Create a TaskTool instance with async agent discovery.
 	 */
 	public static async create(session: ToolSession): Promise<TaskTool> {
-		const description = await buildDescription(session.cwd);
+		const maxConcurrency = session.settings.get("task.maxConcurrency");
+		const description = await buildDescription(session.cwd, maxConcurrency);
 		return new TaskTool(session, description);
 	}
 
@@ -165,6 +157,8 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 		const { agents, projectAgentsDir } = await discoverAgents(this.session.cwd);
 		const { agent: agentName, context, schema: outputSchema, isolated } = params;
 		const isIsolated = isolated === true;
+		const maxConcurrency = this.session.settings.get("task.maxConcurrency");
+		const taskDepth = this.session.taskDepth ?? 0;
 
 		// Validate agent exists
 		const agent = getAgent(agents, agentName);
@@ -221,23 +215,6 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			};
 		}
 
-		// Validate task count
-		if (params.tasks.length > MAX_PARALLEL_TASKS) {
-			return {
-				content: [
-					{
-						type: "text",
-						text: `Too many tasks (${params.tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`,
-					},
-				],
-				details: {
-					projectAgentsDir,
-					results: [],
-					totalDurationMs: 0,
-				},
-			};
-		}
-
 		const tasks = params.tasks;
 		const missingTaskIndexes: number[] = [];
 		const idIndexes = new Map<string, number[]>();
@@ -313,7 +290,7 @@ 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(os.tmpdir(), `omp-task-${nanoid()}`);
+		const tempArtifactsDir = artifactsDir ? null : path.join(os.tmpdir(), `omp-task-${Snowflake.next()}`);
 		const effectiveArtifactsDir = artifactsDir || tempArtifactsDir!;
 
 		// Initialize progress tracking
@@ -471,6 +448,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						index,
 						id: task.id,
 						context: undefined, // Already prepended above
+						taskDepth,
 						modelOverride,
 						thinkingLevel: thinkingLevelOverride,
 						outputSchema: effectiveOutputSchema,
@@ -516,6 +494,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						index,
 						id: task.id,
 						context: undefined, // Already prepended above
+						taskDepth,
 						modelOverride,
 						thinkingLevel: thinkingLevelOverride,
 						outputSchema: effectiveOutputSchema,
@@ -577,7 +556,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			// Execute in parallel with concurrency limit
 			const { results: partialResults, aborted } = await mapWithConcurrencyLimit(
 				tasksWithSkills,
-				MAX_CONCURRENCY,
+				maxConcurrency,
 				runTask,
 				signal,
 			);
@@ -658,7 +637,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						if (!combinedPatch.trim()) {
 							patchesApplied = true;
 						} else {
-							const combinedPatchPath = path.join(os.tmpdir(), `omp-task-combined-${nanoid()}.patch`);
+							const combinedPatchPath = path.join(os.tmpdir(), `omp-task-combined-${Snowflake.next()}.patch`);
 							try {
 								await Bun.write(combinedPatchPath, combinedPatch);
 								const checkResult = await $`git apply --check --binary ${combinedPatchPath}`

package/src/task/omp-command.ts

@@ -1,5 +1,7 @@
 import process from "node:process";
 
+import { $env } from "@oh-my-pi/pi-utils";
+
 interface OmpCommand {
 	cmd: string;
 	args: string[];
@@ -10,7 +12,7 @@ const DEFAULT_CMD = process.platform === "win32" ? "omp.cmd" : "omp";
 const DEFAULT_SHELL = process.platform === "win32";
 
 export function resolveOmpCommand(): OmpCommand {
-	const envCmd = process.env.OMP_SUBPROCESS_CMD;
+	const envCmd = $env.PI_SUBPROCESS_CMD;
 	if (envCmd?.trim()) {
 		return { cmd: envCmd, args: [], shell: DEFAULT_SHELL };
 	}

package/src/task/output-manager.ts

@@ -3,24 +3,33 @@
  *
  * Ensures unique output IDs across task tool invocations within a session.
  * Prefixes each ID with a sequential number (e.g., "0-AuthProvider", "1-AuthApi").
+ * If a parent prefix is provided, IDs are nested (e.g., "0-Auth.1-Subtask").
  *
  * This enables reliable agent:// URL resolution and prevents artifact collisions.
  */
 import * as fs from "node:fs/promises";
 
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 /**
  * Manages agent output ID allocation to ensure uniqueness.
  *
  * Each allocated ID gets a numeric prefix based on allocation order.
+ * If configured with a parent prefix, the numeric prefix is appended after
+ * the parent (e.g., "0-Parent.0-Child").
  * On resume, scans existing files to find the next available index.
  */
 export class AgentOutputManager {
 	#nextId = 0;
 	#initialized = false;
 	readonly #getArtifactsDir: () => string | null;
+	readonly #parentPrefix: string | undefined;
 
-	constructor(getArtifactsDir: () => string | null) {
+	constructor(getArtifactsDir: () => string | null, options?: { parentPrefix?: string }) {
 		this.#getArtifactsDir = getArtifactsDir;
+		this.#parentPrefix = options?.parentPrefix;
 	}
 
 	/**
@@ -41,12 +50,15 @@ export class AgentOutputManager {
 			return; // Directory doesn't exist yet
 		}
 
+		const pattern = this.#parentPrefix
+			? new RegExp(`^${escapeRegExp(this.#parentPrefix)}\\.(\\d+)-.*\\.md$`)
+			: /^(\d+)-.*\.md$/;
+
 		let maxId = -1;
 		for (const file of files) {
-			// Agent outputs are named: {index}-{id}.md (e.g., "0-AuthProvider.md")
-			const match = file.match(/^(\d+)-.*\.md$/);
+			const match = file.match(pattern);
 			if (match) {
-				const id = parseInt(match[1], 10);
+				const id = Number.parseInt(match[1], 10);
 				if (id > maxId) maxId = id;
 			}
 		}
@@ -61,7 +73,8 @@ export class AgentOutputManager {
 	 */
 	async allocate(id: string): Promise<string> {
 		await this.#ensureInitialized();
-		return `${this.#nextId++}-${id}`;
+		const prefix = this.#parentPrefix ? `${this.#parentPrefix}.` : "";
+		return `${prefix}${this.#nextId++}-${id}`;
 	}
 
 	/**
@@ -72,7 +85,8 @@ export class AgentOutputManager {
 	 */
 	async allocateBatch(ids: string[]): Promise<string[]> {
 		await this.#ensureInitialized();
-		return ids.map(id => `${this.#nextId++}-${id}`);
+		const prefix = this.#parentPrefix ? `${this.#parentPrefix}.` : "";
+		return ids.map(id => `${prefix}${this.#nextId++}-${id}`);
 	}
 
 	/**

package/src/task/parallel.ts

@@ -1,8 +1,6 @@
 /**
  * Parallel execution with concurrency control.
  */
-import { MAX_CONCURRENCY } from "./types";
-
 /** Result of parallel execution */
 export interface ParallelResult<R> {
 	/** Results array - undefined entries indicate tasks that were skipped due to abort */
@@ -31,7 +29,9 @@ export async function mapWithConcurrencyLimit<T, R>(
 	fn: (item: T, index: number) => Promise<R>,
 	signal?: AbortSignal,
 ): Promise<ParallelResult<R>> {
-	const limit = Math.max(1, Math.min(concurrency, items.length, MAX_CONCURRENCY));
+	const normalizedConcurrency = Number.isFinite(concurrency) ? Math.floor(concurrency) : items.length;
+	const effectiveConcurrency = normalizedConcurrency > 0 ? normalizedConcurrency : items.length;
+	const limit = Math.max(1, Math.min(effectiveConcurrency, items.length));
 	const results: (R | undefined)[] = new Array(items.length);
 	let nextIndex = 0;
 

package/src/task/render.ts

@@ -77,6 +77,18 @@ function formatJsonScalar(value: unknown, _theme: Theme): string {
 	return "";
 }
 
+function formatTaskId(id: string): string {
+	const segments = id.split(".");
+	if (segments.length < 2) return id;
+
+	const parsed = segments.map(segment => segment.match(/^(\d+)-(.+)$/));
+	if (parsed.some(match => !match)) return id;
+
+	const indices = parsed.map(match => match![1]).join(".");
+	const labels = parsed.map(match => match![2]).join(">");
+	return `${indices} ${labels}`;
+}
+
 const MISSING_SUBMIT_RESULT_WARNING_PREFIX = "SYSTEM WARNING: Subagent exited without calling submit_result tool";
 
 function extractMissingSubmitResultWarning(output: string): { warning?: string; rest: string } {
@@ -518,7 +530,8 @@ function renderAgentProgress(
 
 	// Main status line: id: description [status] · stats · ⟨agent⟩
 	const description = progress.description?.trim();
-	const titlePart = description ? `${theme.bold(progress.id)}: ${description}` : progress.id;
+	const displayId = formatTaskId(progress.id);
+	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
 	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)}`;
 
 	// Only show badge for non-running states (spinner already indicates running)
@@ -748,7 +761,8 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 
 	// Main status line: id: description [status] · stats · ⟨agent⟩
 	const description = result.description?.trim();
-	const titlePart = description ? `${theme.bold(result.id)}: ${description}` : result.id;
+	const displayId = formatTaskId(result.id);
+	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
 	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)} ${formatBadge(
 		statusText,
 		iconColor,

package/src/task/types.ts

@@ -1,35 +1,28 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
+import { $env } from "@oh-my-pi/pi-utils";
 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;
+const parseNumber = (value: string | undefined, defaultValue: number): number => {
+	if (value) {
+		try {
+			const number = Number.parseInt(value, 10);
+			if (!Number.isNaN(number) && number > 0) {
+				return number;
+			}
+		} catch {}
 	}
-	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 = getEnv("OMP_TASK_MAX_PARALLEL", 32);
-
-/** Maximum concurrent tasks */
-export const MAX_CONCURRENCY = getEnv("OMP_TASK_MAX_CONCURRENCY", 16);
+};
 
 /** Maximum output bytes per agent */
-export const MAX_OUTPUT_BYTES = getEnv("OMP_TASK_MAX_OUTPUT_BYTES", 500_000);
+export const MAX_OUTPUT_BYTES = parseNumber($env.PI_TASK_MAX_OUTPUT_BYTES, 500_000);
 
 /** Maximum output lines per agent */
-export const MAX_OUTPUT_LINES = getEnv("OMP_TASK_MAX_OUTPUT_LINES", 5000);
+export const MAX_OUTPUT_LINES = parseNumber($env.PI_TASK_MAX_OUTPUT_LINES, 5000);
 
 /** EventBus channel for raw subagent events */
 export const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
@@ -66,7 +59,7 @@ export const taskSchema = Type.Object({
 	schema: Type.Optional(
 		Type.Record(Type.String(), Type.Unknown(), { description: "JTD schema defining expected response structure" }),
 	),
-	tasks: Type.Array(taskItemSchema, { description: "Tasks to run in parallel", maxItems: MAX_PARALLEL_TASKS }),
+	tasks: Type.Array(taskItemSchema, { description: "Tasks to run in parallel" }),
 });
 
 export type TaskParams = Static<typeof taskSchema>;

package/src/task/worktree.ts

@@ -1,7 +1,7 @@
-import { randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import path from "node:path";
+import { Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 
 export interface WorktreeBaseline {
@@ -56,7 +56,7 @@ export async function captureBaseline(repoRoot: string): Promise<WorktreeBaselin
 }
 
 async function writeTempPatchFile(patch: string): Promise<string> {
-	const tempPath = path.join(os.tmpdir(), `omp-task-patch-${randomUUID()}.patch`);
+	const tempPath = path.join(os.tmpdir(), `omp-task-patch-${Snowflake.next()}.patch`);
 	await Bun.write(tempPath, patch);
 	return tempPath;
 }
@@ -119,7 +119,7 @@ async function listUntracked(cwd: string): Promise<string[]> {
 }
 
 export async function captureDeltaPatch(worktreeDir: string, baseline: WorktreeBaseline): Promise<string> {
-	const tempIndex = path.join(os.tmpdir(), `omp-task-index-${randomUUID()}`);
+	const tempIndex = path.join(os.tmpdir(), `omp-task-index-${Snowflake.next()}`);
 	try {
 		await $`git read-tree HEAD`.cwd(worktreeDir).env({
 			GIT_INDEX_FILE: tempIndex,

package/src/tools/ask.ts

@@ -16,14 +16,13 @@
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
+import { TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
 import { renderStatusLine } from "../tui";
-import { detectNotificationProtocol, isNotificationSuppressed, sendNotification } from "../utils/terminal-notify";
 import type { ToolSession } from ".";
 import { ToolUIKit } from "./render-utils";
 
@@ -268,13 +267,9 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 
 	/** Send terminal notification when ask tool is waiting for input */
 	private sendAskNotification(): void {
-		if (isNotificationSuppressed()) return;
-
-		const method = this.session.settings.get("ask.notification");
+		const method = this.session.settings.get("ask.notify");
 		if (method === "off") return;
-
-		const protocol = method === "auto" ? detectNotificationProtocol() : method;
-		sendNotification(protocol, "Waiting for input");
+		TERMINAL.sendNotification("Waiting for input");
 	}
 
 	public async execute(

package/src/tools/fetch.ts

@@ -385,7 +385,7 @@ function parseFeedToMarkdown(content: string, maxItems = 10): string {
 }
 
 /**
- * Render HTML to markdown using native WASM, jina, trafilatura, lynx, or html-to-markdown (in order of preference)
+ * Render HTML to markdown using native, jina, trafilatura, lynx (in order of preference)
  */
 async function renderHtmlToText(
 	url: string,
@@ -438,7 +438,7 @@ async function renderHtmlToText(
 		}
 	}
 
-	// Fall back to native WASM converter (fastest, no network/subprocess)
+	// Fall back to native converter (fastest, no network/subprocess)
 	try {
 		const content = await htmlToMarkdown(html, { cleanContent: true });
 		if (content.trim().length > 100 && !isLowQualityOutput(content)) {

package/src/tools/gemini-image.ts

@@ -1,9 +1,8 @@
 import * as os from "node:os";
 import * as path from "node:path";
-import { getEnv, getEnvApiKey, StringEnum } from "@oh-my-pi/pi-ai";
-import { ptree, untilAborted } from "@oh-my-pi/pi-utils";
+import { getEnvApiKey, StringEnum } from "@oh-my-pi/pi-ai";
+import { $env, ptree, Snowflake, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { nanoid } from "nanoid";
 import type { ModelRegistry } from "../config/model-registry";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { CustomTool } from "../extensibility/custom-tools/types";
@@ -409,7 +408,7 @@ async function findImageApiKey(modelRegistry?: ModelRegistry): Promise<ImageApiK
 	if (preferredImageProvider === "gemini") {
 		const geminiKey = getEnvApiKey("google");
 		if (geminiKey) return { provider: "gemini", apiKey: geminiKey };
-		const googleKey = getEnv("GOOGLE_API_KEY");
+		const googleKey = $env.GOOGLE_API_KEY;
 		if (googleKey) return { provider: "gemini", apiKey: googleKey };
 		// Fall through to auto-detect if preferred provider key not found
 	} else if (preferredImageProvider === "openrouter") {
@@ -430,7 +429,7 @@ async function findImageApiKey(modelRegistry?: ModelRegistry): Promise<ImageApiK
 	const geminiKey = getEnvApiKey("google");
 	if (geminiKey) return { provider: "gemini", apiKey: geminiKey };
 
-	const googleKey = getEnv("GOOGLE_API_KEY");
+	const googleKey = $env.GOOGLE_API_KEY;
 	if (googleKey) return { provider: "gemini", apiKey: googleKey };
 
 	return null;
@@ -487,7 +486,7 @@ function getExtensionForMime(mimeType: string): string {
 
 async function saveImageToTemp(image: InlineImageData): Promise<string> {
 	const ext = getExtensionForMime(image.mimeType);
-	const filename = `omp-image-${nanoid()}.${ext}`;
+	const filename = `omp-image-${Snowflake.next()}.${ext}`;
 	const filepath = path.join(os.tmpdir(), filename);
 	await Bun.write(filepath, Buffer.from(image.data, "base64"));
 	return filepath;

package/src/tools/grep.ts

@@ -1,7 +1,7 @@
 import * as nodePath from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 
-import { grep as wasmGrep } from "@oh-my-pi/pi-natives";
+import { grep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
@@ -124,10 +124,10 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			const effectiveOutputMode = "content";
 			const effectiveLimit = normalizedLimit ?? DEFAULT_MATCH_LIMIT;
 
-			// Run WASM grep
-			let result: Awaited<ReturnType<typeof wasmGrep>>;
+			// Run grep
+			let result: Awaited<ReturnType<typeof grep>>;
 			try {
-				result = await wasmGrep({
+				result = await grep({
 					pattern: normalizedPattern,
 					path: searchPath,
 					glob: glob?.trim() || undefined,
@@ -150,7 +150,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			}
 
 			const formatPath = (filePath: string): string => {
-				// WASM returns paths starting with / (the virtual root)
+				// returns paths starting with / (the virtual root)
 				const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
 				if (isDirectory) {
 					return cleanPath.replace(/\\/g, "/");

package/src/tools/index.ts

@@ -1,5 +1,5 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { logger } from "@oh-my-pi/pi-utils";
+import { $env, logger } from "@oh-my-pi/pi-utils";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
@@ -127,6 +127,8 @@ export interface ToolSession {
 	outputSchema?: unknown;
 	/** Whether to include the submit_result tool by default */
 	requireSubmitResultTool?: boolean;
+	/** Task recursion depth (0 = top-level, 1 = first child, etc.) */
+	taskDepth?: number;
 	/** Get session file */
 	getSessionFile: () => string | null;
 	/** Get session ID */
@@ -192,7 +194,7 @@ export type ToolName = keyof typeof BUILTIN_TOOLS;
 export type PythonToolMode = "ipy-only" | "bash-only" | "both";
 
 /**
- * Parse OMP_PY environment variable to determine Python tool mode.
+ * Parse PI_PY environment variable to determine Python tool mode.
  * Returns null if not set or invalid.
  *
  * Values:
@@ -201,7 +203,7 @@ export type PythonToolMode = "ipy-only" | "bash-only" | "both";
  * - "mix" or "both" → both
  */
 function getPythonModeFromEnv(): PythonToolMode | null {
-	const value = process.env.OMP_PY?.toLowerCase();
+	const value = $env.PI_PY?.toLowerCase();
 	if (!value) return null;
 
 	switch (value) {
@@ -238,7 +240,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		pythonMode !== "bash-only" &&
 		(requestedTools === undefined || requestedTools.includes("python"));
 	const isTestEnv = process.env.BUN_ENV === "test" || process.env.NODE_ENV === "test";
-	const skipPythonWarm = isTestEnv || process.env.OMP_PYTHON_SKIP_CHECK === "1";
+	const skipPythonWarm = isTestEnv || $env.PI_PYTHON_SKIP_CHECK === "1";
 	if (shouldCheckPython) {
 		const availability = await checkPythonKernelAvailability(session.cwd);
 		time("createTools:pythonCheck");
@@ -287,6 +289,11 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "lsp") return session.settings.get("lsp.enabled");
 		if (name === "calc") return session.settings.get("calc.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
+		if (name === "task") {
+			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;
+			const currentDepth = session.taskDepth ?? 0;
+			return maxDepth < 0 || currentDepth < maxDepth;
+		}
 		return true;
 	};
 	if (includeSubmitResult && requestedTools && !requestedTools.includes("submit_result")) {
@@ -317,7 +324,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		}),
 	);
 	time("createTools:afterFactories");
-	if (slowTools.length > 0 && process.env.OMP_TIMING === "1") {
+	if (slowTools.length > 0 && $env.PI_TIMING === "1") {
 		logger.debug("Tool factory timings", { slowTools });
 	}
 	const tools = results.filter(r => r.tool !== null).map(r => r.tool as Tool);

package/src/tools/read.ts

@@ -636,7 +636,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					const base64 = Buffer.from(buffer).toString("base64");
 
 					if (this.autoResizeImages) {
-						// Resize image if needed - catch errors from WASM
+						// Resize image if needed - catch errors from Photon
 						try {
 							const resized = await resizeImage({ type: "image", data: base64, mimeType });
 							const dimensionNote = formatDimensionNote(resized);