@oh-my-pi/pi-coding-agent 13.10.1 → 13.11.1

package/src/slash-commands/builtin-registry.ts

@@ -214,8 +214,16 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 	{
 		name: "copy",
 		description: "Copy last agent message to clipboard",
-		handle: async (_command, runtime) => {
-			await runtime.ctx.handleCopyCommand();
+		subcommands: [
+			{ name: "last", description: "Copy full last agent message" },
+			{ name: "code", description: "Copy last code block" },
+			{ name: "all", description: "Copy all code blocks from last message" },
+			{ name: "cmd", description: "Copy last bash/python command" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const sub = command.args.trim().toLowerCase() || undefined;
+			await runtime.ctx.handleCopyCommand(sub);
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/task/executor.ts

@@ -5,7 +5,6 @@
  */
 import path from "node:path";
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model, ToolChoice } from "@oh-my-pi/pi-ai";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import Ajv, { type ValidateFunction } from "ajv";
@@ -28,6 +27,7 @@ import { type ContextFileEntry, truncateTail } from "../tools";
 import { jtdToJsonSchema } from "../tools/jtd-to-json-schema";
 import { ToolAbortError } from "../tools/tool-errors";
 import type { EventBus } from "../utils/event-bus";
+import { buildNamedToolChoice } from "../utils/tool-choice";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,
@@ -117,28 +117,13 @@ function getReportFindingKey(value: unknown): string | null {
 	return `${filePath}:${lineStart}:${lineEnd}:${priority ?? ""}:${title}`;
 }
 
-function buildSubmitResultToolChoice(model?: Model<Api>): ToolChoice | undefined {
-	if (!model) return undefined;
-	if (
-		model.api === "openai-codex-responses" ||
-		model.api === "openai-responses" ||
-		model.api === "openai-completions" ||
-		model.api === "azure-openai-responses"
-	) {
-		return { type: "function", name: "submit_result" };
-	}
-	if (model.api === "anthropic-messages" || model.api === "bedrock-converse-stream") {
-		return { type: "tool", name: "submit_result" };
-	}
-	return undefined;
-}
-
 /** Options for subagent execution */
 export interface ExecutorOptions {
 	cwd: string;
 	worktree?: string;
 	agent: AgentDefinition;
 	task: string;
+	assignment?: string;
 	description?: string;
 	index: number;
 	id: string;
@@ -458,6 +443,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		cwd,
 		agent,
 		task,
+		assignment,
 		index,
 		id,
 		worktree,
@@ -478,6 +464,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		agentSource: agent.source,
 		status: "running",
 		task,
+		assignment,
 		description: options.description,
 		lastIntent: undefined,
 		recentTools: [],
@@ -496,6 +483,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			agent: agent.name,
 			agentSource: agent.source,
 			task,
+			assignment,
 			description: options.description,
 			exitCode: 1,
 			output: "",
@@ -638,6 +626,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				agent: agent.name,
 				agentSource: agent.source,
 				task,
+				assignment,
 				progress: { ...progress },
 			});
 		}
@@ -727,6 +716,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				agent: agent.name,
 				agentSource: agent.source,
 				task,
+				assignment,
 				event,
 			});
 		}
@@ -1091,7 +1081,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			await session.prompt(task);
 			await session.waitForIdle();
 
-			const reminderToolChoice = buildSubmitResultToolChoice(session.model);
+			const reminderToolChoice = buildNamedToolChoice("submit_result", session.model);
 
 			let retryCount = 0;
 			while (!submitResultCalled && retryCount < MAX_SUBMIT_RESULT_RETRIES && !abortSignal.aborted) {
@@ -1247,12 +1237,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		agent: agent.name,
 		agentSource: agent.source,
 		task,
+		assignment,
 		description: options.description,
 		lastIntent: progress.lastIntent,
 		exitCode,
 		output: truncatedOutput,
 		stderr,
-		truncated,
+		truncated: Boolean(truncated),
 		durationMs: Date.now() - startTime,
 		tokens: progress.tokens,
 		modelOverride,

package/src/task/index.ts

@@ -224,6 +224,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 				agentSource: fallbackAgentSource,
 				status: "pending",
 				task: renderedTask.task,
+				assignment: renderedTask.assignment,
 				description: renderedTask.description,
 				recentTools: [],
 				recentOutput: [],
@@ -732,6 +733,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 					agentSource: agent.source,
 					status: "pending",
 					task: t.task,
+					assignment: t.assignment,
 					recentTools: [],
 					recentOutput: [],
 					toolCount: 0,
@@ -749,6 +751,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						cwd: this.session.cwd,
 						agent,
 						task: task.task,
+						assignment: task.assignment,
 						description: task.description,
 						index,
 						id: task.id,
@@ -801,6 +804,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						worktree: isolationDir,
 						agent,
 						task: task.task,
+						assignment: task.assignment,
 						description: task.description,
 						index,
 						id: task.id,
@@ -834,11 +838,10 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 							const commitMsg =
 								commitStyle === "ai" && this.session.modelRegistry
 									? async (diff: string) => {
-											const smolModel = this.session.settings.getModelRole("smol");
 											return generateCommitMessage(
 												diff,
 												this.session.modelRegistry!,
-												smolModel,
+												this.session.settings,
 												this.session.getSessionId?.() ?? undefined,
 											);
 										}
@@ -887,6 +890,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						agent: agent.name,
 						agentSource: agent.source,
 						task: task.task,
+						assignment: task.assignment,
 						description: task.description,
 						exitCode: 1,
 						output: "",
@@ -930,6 +934,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 					agent: agentName,
 					agentSource: agent.source,
 					task: task.task,
+					assignment: task.assignment,
 					description: task.description,
 					exitCode: 1,
 					output: "",
@@ -1081,11 +1086,10 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						const commitMsg =
 							commitStyle === "ai" && this.session.modelRegistry
 								? async (diff: string) => {
-										const smolModel = this.session.settings.getModelRole("smol");
 										return generateCommitMessage(
 											diff,
 											this.session.modelRegistry!,
-											smolModel,
+											this.session.settings,
 											this.session.getSessionId?.() ?? undefined,
 										);
 									}

package/src/task/render.ts

@@ -374,16 +374,11 @@ function renderTaskSection(
 	maxExpanded = 20,
 ): string[] {
 	const lines: string[] = [];
-	const trimmed = task.trimEnd();
+	const trimmed = task.trim();
 	if (!expanded || !trimmed) return lines;
 
-	// Strip the shared <context>...</context> block — it's the same
-	// across all tasks and just adds noise when expanded.
-	const stripped = trimmed.replace(/<context>[\s\S]*?<\/context>\s*/, "").trimStart();
-	if (!stripped) return lines;
-
 	lines.push(`${continuePrefix}${theme.fg("dim", "Task")}`);
-	const taskLines = stripped.split("\n");
+	const taskLines = trimmed.split("\n");
 	for (const line of taskLines.slice(0, maxExpanded)) {
 		lines.push(`${continuePrefix}  ${theme.fg("dim", truncateToWidth(replaceTabs(line), 70))}`);
 	}
@@ -526,7 +521,7 @@ function renderAgentProgress(
 
 	if (progress.status === "running") {
 		if (!description) {
-			const taskPreview = truncateToWidth(progress.task, 40);
+			const taskPreview = truncateToWidth(progress.assignment ?? progress.task, 40);
 			statusLine += ` ${theme.fg("muted", taskPreview)}`;
 		}
 		if (progress.toolCount > 0) {
@@ -546,7 +541,7 @@ function renderAgentProgress(
 
 	lines.push(statusLine);
 
-	lines.push(...renderTaskSection(progress.task, continuePrefix, expanded, theme));
+	lines.push(...renderTaskSection(progress.assignment ?? progress.task, continuePrefix, expanded, theme));
 
 	// Current tool (if running) or most recent completed tool
 	if (progress.status === "running") {
@@ -781,7 +776,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 
 	lines.push(statusLine);
 
-	lines.push(...renderTaskSection(result.task, continuePrefix, expanded, theme));
+	lines.push(...renderTaskSection(result.assignment ?? result.task, continuePrefix, expanded, theme));
 
 	if (aborted && result.abortReason) {
 		lines.push(

package/src/task/template.ts

@@ -5,6 +5,8 @@ import type { TaskItem } from "./types";
 interface RenderResult {
 	/** Full task text sent to the subagent */
 	task: string;
+	/** Raw per-task assignment text, without prompt template boilerplate */
+	assignment: string;
 	id: string;
 	description: string;
 }
@@ -20,10 +22,11 @@ export function renderTemplate(context: string | undefined, task: TaskItem): Ren
 	context = context?.trim();
 
 	if (!context || !assignment) {
-		return { task: assignment || context!, id, description };
+		return { task: assignment || context!, assignment: assignment || context!, id, description };
 	}
 	return {
 		task: renderPromptTemplate(subagentUserPromptTemplate, { context, assignment }),
+		assignment,
 		id,
 		description,
 	};

package/src/task/types.ts

@@ -136,6 +136,7 @@ export interface AgentProgress {
 	agentSource: AgentSource;
 	status: "pending" | "running" | "completed" | "failed" | "aborted";
 	task: string;
+	assignment?: string;
 	description?: string;
 	lastIntent?: string;
 	currentTool?: string;
@@ -158,6 +159,7 @@ export interface SingleResult {
 	agent: string;
 	agentSource: AgentSource;
 	task: string;
+	assignment?: string;
 	description?: string;
 	lastIntent?: string;
 	exitCode: number;

package/src/tools/ast-edit.ts

@@ -14,7 +14,13 @@ import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, t
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
-import { combineSearchGlobs, hasGlobPathChars, parseSearchPath, resolveToCwd } from "./path-utils";
+import {
+	combineSearchGlobs,
+	hasGlobPathChars,
+	parseSearchPath,
+	resolveMultiSearchPath,
+	resolveToCwd,
+} from "./path-utils";
 import {
 	dedupeParseErrors,
 	formatCount,
@@ -98,7 +104,12 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			}
 			const maxFiles = parseInt(process.env.PI_MAX_AST_FILES ?? "", 10) || 1000;
 
+			const formatScopePath = (targetPath: string): string => {
+				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
+				return relative.length === 0 ? "." : relative;
+			};
 			let searchPath: string | undefined;
+			let scopePath: string | undefined;
 			let globFilter = params.glob?.trim() || undefined;
 			const rawPath = params.path?.trim();
 			if (rawPath) {
@@ -112,21 +123,29 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 						throw new ToolError(`Cannot rewrite internal URL without backing file: ${rawPath}`);
 					}
 					searchPath = resource.sourcePath;
+					scopePath = formatScopePath(searchPath);
 				} else {
-					const parsedPath = parseSearchPath(rawPath);
-					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-					globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+					const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
+					if (multiSearchPath) {
+						searchPath = multiSearchPath.basePath;
+						globFilter = multiSearchPath.glob;
+						scopePath = multiSearchPath.scopePath;
+					} else {
+						const parsedPath = parseSearchPath(rawPath);
+						searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
+						globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+						scopePath = formatScopePath(searchPath);
+					}
 				}
 			}
-
 			const resolvedSearchPath = searchPath ?? resolveToCwd(".", this.session.cwd);
-			const scopePath = path.relative(this.session.cwd, resolvedSearchPath).replace(/\\/g, "/") || ".";
+			scopePath = scopePath ?? formatScopePath(resolvedSearchPath);
 			let isDirectory: boolean;
 			try {
 				const stat = await Bun.file(resolvedSearchPath).stat();
 				isDirectory = stat.isDirectory();
 			} catch {
-				throw new ToolError(`Path not found: ${resolvedSearchPath}`);
+				throw new ToolError(`Path not found: ${scopePath}`);
 			}
 
 			const result = await astEdit({

package/src/tools/ast-grep.ts

@@ -14,7 +14,13 @@ import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, t
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
-import { combineSearchGlobs, hasGlobPathChars, parseSearchPath, resolveToCwd } from "./path-utils";
+import {
+	combineSearchGlobs,
+	hasGlobPathChars,
+	parseSearchPath,
+	resolveMultiSearchPath,
+	resolveToCwd,
+} from "./path-utils";
 import {
 	dedupeParseErrors,
 	formatCount,
@@ -86,7 +92,12 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				throw new ToolError("Context must be a non-negative number");
 			}
 
+			const formatScopePath = (targetPath: string): string => {
+				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
+				return relative.length === 0 ? "." : relative;
+			};
 			let searchPath: string | undefined;
+			let scopePath: string | undefined;
 			let globFilter = params.glob?.trim() || undefined;
 			const rawPath = params.path?.trim();
 			if (rawPath) {
@@ -100,24 +111,30 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 						throw new ToolError(`Cannot search internal URL without backing file: ${rawPath}`);
 					}
 					searchPath = resource.sourcePath;
+					scopePath = formatScopePath(searchPath);
 				} else {
-					const parsedPath = parseSearchPath(rawPath);
-					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-					globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+					const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
+					if (multiSearchPath) {
+						searchPath = multiSearchPath.basePath;
+						globFilter = multiSearchPath.glob;
+						scopePath = multiSearchPath.scopePath;
+					} else {
+						const parsedPath = parseSearchPath(rawPath);
+						searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
+						globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+						scopePath = formatScopePath(searchPath);
+					}
 				}
 			}
 
 			const resolvedSearchPath = searchPath ?? resolveToCwd(".", this.session.cwd);
-			const scopePath = (() => {
-				const relative = path.relative(this.session.cwd, resolvedSearchPath).replace(/\\/g, "/");
-				return relative.length === 0 ? "." : relative;
-			})();
+			scopePath = scopePath ?? formatScopePath(resolvedSearchPath);
 			let isDirectory: boolean;
 			try {
 				const stat = await Bun.file(resolvedSearchPath).stat();
 				isDirectory = stat.isDirectory();
 			} catch {
-				throw new ToolError(`Path not found: ${resolvedSearchPath}`);
+				throw new ToolError(`Path not found: ${scopePath}`);
 			}
 
 			const result = await astGrep({

package/src/tools/exit-plan-mode.ts

@@ -77,6 +77,12 @@ export class ExitPlanModeTool implements AgentTool<typeof exitPlanModeSchema, Ex
 			}
 		}
 
+		if (!planExists) {
+			throw new ToolError(
+				`Plan file not found at ${state.planFilePath}. Write the finalized plan to ${state.planFilePath} before calling exit_plan_mode.`,
+			);
+		}
+
 		return {
 			content: [{ type: "text", text: "Plan ready for approval." }],
 			details: {

package/src/tools/fetch.ts

@@ -7,6 +7,7 @@ import { ptree, truncate } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { parseHTML } from "linkedom";
 import { renderPromptTemplate } from "../config/prompt-templates";
+import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
 import fetchDescription from "../prompts/tools/fetch.md" with { type: "text" };
@@ -15,6 +16,7 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { ensureTool } from "../utils/tools-manager";
+import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
 import { finalizeOutput, loadPage, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
@@ -465,12 +467,13 @@ function parseFeedToMarkdown(content: string, maxItems = 10): string {
 }
 
 /**
- * Render HTML to markdown using jina, trafilatura, lynx (in order of preference)
+ * Render HTML to markdown using Parallel, jina, trafilatura, lynx (in order of preference)
  */
 async function renderHtmlToText(
 	url: string,
 	html: string,
 	timeout: number,
+	settings: Settings,
 	userSignal?: AbortSignal,
 ): Promise<{ content: string; ok: boolean; method: string }> {
 	const signal = ptree.combineSignals(userSignal, timeout * 1000);
@@ -482,6 +485,28 @@ async function renderHtmlToText(
 		signal,
 	};
 
+	// Try Parallel extract first when credentials are configured
+	if (settings.get("providers.parallelFetch") && (await findParallelApiKey())) {
+		try {
+			const parallelResult = await extractWithParallel([url], {
+				objective: "Extract the main content",
+				excerpts: true,
+				fullContent: false,
+				signal,
+			});
+			const firstDocument = parallelResult.results[0];
+			if (firstDocument) {
+				const content = getParallelExtractContent(firstDocument);
+				if (content.trim().length > 100 && !isLowQualityOutput(content)) {
+					return { content, ok: true, method: "parallel" };
+				}
+			}
+		} catch {
+			// Parallel extract failed, continue to next method
+			signal?.throwIfAborted();
+		}
+	}
+
 	// Try jina first (reader API)
 	try {
 		const jinaUrl = `https://r.jina.ai/${url}`;
@@ -608,7 +633,13 @@ async function handleSpecialUrls(
 /**
  * Main render function implementing the full pipeline
  */
-async function renderUrl(url: string, timeout: number, raw: boolean, signal?: AbortSignal): Promise<FetchRenderResult> {
+async function renderUrl(
+	url: string,
+	timeout: number,
+	raw: boolean,
+	settings: Settings,
+	signal?: AbortSignal,
+): Promise<FetchRenderResult> {
 	const notes: string[] = [];
 	const fetchedAt = new Date().toISOString();
 	if (signal?.aborted) {
@@ -714,7 +745,7 @@ async function renderUrl(url: string, timeout: number, raw: boolean, signal?: Ab
 				}
 
 				const resized = await resizeImage(
-					{ type: "image", data: binary.buffer.toBase64(), mimeType: imageMimeType },
+					{ type: "image", data: Buffer.from(binary.buffer).toBase64(), mimeType: imageMimeType },
 					{ maxBytes: MAX_INLINE_IMAGE_OUTPUT_BYTES },
 				);
 				const isDecodedImage =
@@ -952,7 +983,7 @@ async function renderUrl(url: string, timeout: number, raw: boolean, signal?: Ab
 		}
 
 		// 5E: Render HTML with lynx or html2text
-		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, signal);
+		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal);
 		if (!htmlResult.ok) {
 			notes.push("html rendering failed (lynx/html2text unavailable)");
 			const output = finalizeOutput(rawContent);
@@ -1092,7 +1123,7 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 			throw new ToolAbortError();
 		}
 
-		const result = await renderUrl(url, effectiveTimeout, raw, signal);
+		const result = await renderUrl(url, effectiveTimeout, raw, this.session.settings, signal);
 		const truncation = truncateHead(result.content, {
 			maxBytes: DEFAULT_MAX_BYTES,
 			maxLines: FETCH_DEFAULT_MAX_LINES,
@@ -1128,7 +1159,7 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 			finalUrl: result.finalUrl,
 			contentType: result.contentType,
 			method: result.method,
-			truncated: result.truncated || needsArtifact,
+			truncated: Boolean(result.truncated || needsArtifact),
 			notes: result.notes,
 		};
 

package/src/tools/find.ts

@@ -24,7 +24,7 @@ import {
 import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
-import { resolveToCwd } from "./path-utils";
+import { parseFindPattern, resolveMultiFindPattern, resolveToCwd } from "./path-utils";
 import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -40,56 +40,6 @@ export type FindToolInput = Static<typeof findSchema>;
 const DEFAULT_LIMIT = 1000;
 const GLOB_TIMEOUT_MS = 5000;
 
-/**
- * Parse a pattern to extract the base directory path and glob pattern.
- * Examples:
- *   "src/app/**\/*.tsx" → { basePath: "src/app", globPattern: "**\/*.tsx" }
- *   "src/app/*.tsx" → { basePath: "src/app", globPattern: "*.tsx" }
- *   "*.ts" → { basePath: ".", globPattern: "**\/*.ts" }
- *   "**\/*.json" → { basePath: ".", globPattern: "**\/*.json" }
- *   "/abs/path/**\/*.ts" → { basePath: "/abs/path", globPattern: "**\/*.ts" }
- */
-function parsePatternPath(pattern: string): { basePath: string; globPattern: string } {
-	// Find the first segment containing glob characters
-	const segments = pattern.split("/");
-	const globChars = ["*", "?", "[", "{"];
-
-	let firstGlobIndex = -1;
-	for (let i = 0; i < segments.length; i++) {
-		if (globChars.some(c => segments[i].includes(c))) {
-			firstGlobIndex = i;
-			break;
-		}
-	}
-
-	// No glob characters found - treat as literal path with implicit **/*
-	if (firstGlobIndex === -1) {
-		// Pattern is a directory path like "src/app" - search recursively in it
-		return { basePath: pattern, globPattern: "**/*" };
-	}
-
-	// Glob starts at first segment - no base path
-	if (firstGlobIndex === 0) {
-		// Simple pattern like "*.ts" needs **/ prefix for recursive search
-		const needsRecursive = !pattern.startsWith("**/");
-		return {
-			basePath: ".",
-			globPattern: needsRecursive ? `**/${pattern}` : pattern,
-		};
-	}
-
-	// Split at the glob boundary
-	const basePath = segments.slice(0, firstGlobIndex).join("/");
-	const globPattern = segments.slice(firstGlobIndex).join("/");
-
-	return { basePath, globPattern };
-}
-
-function hasGlobChars(pattern: string): boolean {
-	const globChars = ["*", "?", "[", "{"];
-	return globChars.some(char => pattern.includes(char));
-}
-
 export interface FindToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
@@ -149,27 +99,26 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		const { pattern, limit, hidden } = params;
 
 		return untilAborted(signal, async () => {
-			// Parse pattern to extract base directory and glob pattern
-			// e.g., "src/app/**/*.tsx" → basePath: "src/app", globPattern: "**/*.tsx"
-			// e.g., "*.ts" → basePath: ".", globPattern: "**/*.ts"
+			const formatScopePath = (targetPath: string): string => {
+				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
+				return relative.length === 0 ? "." : relative;
+			};
 			const normalizedPattern = pattern.trim().replace(/\\/g, "/");
 			if (!normalizedPattern) {
 				throw new ToolError("Pattern must not be empty");
 			}
 
-			const hasGlob = hasGlobChars(normalizedPattern);
-			const { basePath, globPattern } = parsePatternPath(normalizedPattern);
-			const searchPath = resolveToCwd(basePath, this.session.cwd);
+			const multiPattern = await resolveMultiFindPattern(normalizedPattern, this.session.cwd);
+			const parsedPattern = multiPattern ? null : parseFindPattern(normalizedPattern);
+			const hasGlob = multiPattern ? true : (parsedPattern?.hasGlob ?? false);
+			const globPattern = multiPattern?.globPattern ?? parsedPattern?.globPattern ?? "**/*";
+			const searchPath = resolveToCwd(multiPattern?.basePath ?? parsedPattern?.basePath ?? ".", this.session.cwd);
+			const scopePath = multiPattern?.scopePath ?? formatScopePath(searchPath);
 
 			if (searchPath === "/") {
 				throw new ToolError("Searching from root directory '/' is not allowed");
 			}
 
-			const scopePath = (() => {
-				const relative = path.relative(this.session.cwd, searchPath).replace(/\\/g, "/");
-				return relative.length === 0 ? "." : relative;
-			})();
-
 			const rawLimit = limit ?? DEFAULT_LIMIT;
 			const effectiveLimit = Number.isFinite(rawLimit) ? Math.floor(rawLimit) : Number.NaN;
 			if (!Number.isFinite(effectiveLimit) || effectiveLimit <= 0) {
@@ -180,7 +129,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			// If custom operations provided with glob, use that instead of fd
 			if (this.#customOps?.glob) {
 				if (!(await this.#customOps.exists(searchPath))) {
-					throw new ToolError(`Path not found: ${searchPath}`);
+					throw new ToolError(`Path not found: ${scopePath}`);
 				}
 
 				if (!hasGlob && this.#customOps.stat) {
@@ -245,7 +194,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				searchStat = await fs.promises.stat(searchPath);
 			} catch (err) {
 				if (isEnoent(err)) {
-					throw new ToolError(`Path not found: ${searchPath}`);
+					throw new ToolError(`Path not found: ${scopePath}`);
 				}
 				throw err;
 			}