@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.1

package/src/tools/search.ts

@@ -8,32 +8,25 @@ import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { getFileReadCache } from "../edit/file-read-cache";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { InternalUrlRouter } from "../internal-urls";
 import type { Theme } from "../modes/theme/theme";
 import searchDescription from "../prompts/tools/search.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead } from "../session/streaming-output";
-import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
+import { Ellipsis, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { formatGroupedFiles } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
+import { resolveToolSearchScope } from "./path-utils";
 import {
-	formatPathRelativeToCwd,
-	hasGlobPathChars,
-	normalizePathLikeInput,
-	parseSearchPath,
-	partitionExistingPaths,
-	resolveExplicitSearchPaths,
-	resolveToCwd,
-} from "./path-utils";
-import {
+	createCachedComponent,
 	formatCodeFrameLine,
 	formatCount,
 	formatEmptyMessage,
 	formatErrorMessage,
 	PREVIEW_LIMITS,
+	splitGroupsByBlankLine,
 } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -47,17 +40,36 @@ const searchSchema = Type.Object({
 	}),
 	i: Type.Optional(Type.Boolean({ description: "case-insensitive search", default: false })),
 	gitignore: Type.Optional(Type.Boolean({ description: "respect gitignore", default: true })),
-	skip: Type.Optional(Type.Number({ description: "matches to skip", default: 0 })),
+	skip: Type.Optional(
+		Type.Number({
+			description:
+				"files to skip before collecting results — use to paginate when the prior call hit the file limit",
+			default: 0,
+		}),
+	),
 });
 
 export type SearchToolInput = Static<typeof searchSchema>;
 
-export const DEFAULT_MATCH_LIMIT = 100;
+/** Maximum number of distinct files surfaced in a single response. The
+ * agent paginates further pages via `skip`. */
+export const DEFAULT_FILE_LIMIT = 20;
+/** Per-file match cap for multi-file searches — keeps a single hot file
+ * from crowding out diverse hits. Applied in JS after grep returns. */
+export const MULTI_FILE_PER_FILE_MATCHES = 20;
+/** Per-file match cap for single-file searches — there's no diversity
+ * concern when the scope is one file. */
+export const SINGLE_FILE_MATCHES = 200;
+/** Hard safety ceiling on how many matches we fetch from native grep
+ * before JS-side grouping. Sized to comfortably cover the file window
+ * (DEFAULT_FILE_LIMIT files × MULTI_FILE_PER_FILE_MATCHES matches) plus
+ * pagination headroom so the caller can see total file count. */
+const INTERNAL_TOTAL_CAP = 2000;
 
 export interface SearchToolDetails {
 	truncation?: TruncationResult;
-	matchLimitReached?: number;
-	resultLimitReached?: number;
+	fileLimitReached?: number;
+	perFileLimitReached?: number;
 	linesTruncated?: boolean;
 	meta?: OutputMeta;
 	scopePath?: string;
@@ -122,82 +134,34 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
 			const effectiveMultiline = patternHasNewline;
 
-			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
-			let searchPath: string;
-			let scopePath: string;
-			let exactFilePaths: string[] | undefined;
-			let multiTargets: Array<{ basePath: string; glob?: string }> | undefined;
-			let globFilter: string | undefined;
-			const rawPaths = paths.map(normalizePathLikeInput);
-			if (rawPaths.some(rawPath => rawPath.length === 0)) {
-				throw new ToolError("`paths` must contain non-empty paths or globs");
-			}
-			const internalRouter = InternalUrlRouter.instance();
-			const resolvedPathInputs: string[] = [];
-			// Absolute filesystem paths whose source is immutable (e.g. artifact://,
-			// pi://, skill://). Hashline anchors are suppressed for these on a
-			// per-file basis, leaving editable mixed-in files untouched.
-			const immutableSourcePaths = new Set<string>();
-			for (const rawPath of rawPaths) {
-				if (!internalRouter.canHandle(rawPath)) {
-					resolvedPathInputs.push(rawPath);
-					continue;
-				}
-				if (hasGlobPathChars(rawPath)) {
-					throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
-				}
-				const resource = await internalRouter.resolve(rawPath);
-				if (!resource.sourcePath) {
-					throw new ToolError(`Cannot search internal URL without a backing file: ${rawPath}`);
-				}
-				if (resource.immutable) {
-					immutableSourcePaths.add(path.resolve(resource.sourcePath));
-				}
-				resolvedPathInputs.push(resource.sourcePath);
-			}
+			const scope = await resolveToolSearchScope({
+				rawPaths: paths,
+				cwd: this.session.cwd,
+				internalUrlAction: "search",
+				trackImmutableSources: true,
+				surfaceExactFilePaths: true,
+				multipathStatHint: " (`paths` entries must each exist relative to cwd)",
+			});
+			const {
+				searchPath,
+				scopePath,
+				isDirectory,
+				multiTargets,
+				exactFilePaths,
+				missingPaths,
+				immutableSourcePaths,
+			} = scope;
+			const { globFilter } = scope;
 			const baseDisplayMode = resolveFileDisplayMode(this.session);
 			const immutableDisplayMode = resolveFileDisplayMode(this.session, { immutable: true });
-			// Tolerate missing entries in a multi-path call: skip ones whose base
-			// directory is gone, and only error if every entry is missing. Single
-			// missing path keeps the original ENOENT semantics.
-			let missingPaths: string[] = [];
-			let effectivePaths = resolvedPathInputs;
-			if (resolvedPathInputs.length > 1) {
-				const partition = await partitionExistingPaths(resolvedPathInputs, this.session.cwd, parseSearchPath);
-				if (partition.valid.length === 0) {
-					throw new ToolError(`Path not found: ${partition.missing.join(", ")}`);
-				}
-				effectivePaths = partition.valid;
-				missingPaths = partition.missing;
-			}
-			if (effectivePaths.length === 1) {
-				const parsedPath = parseSearchPath(effectivePaths[0] ?? ".");
-				searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-				globFilter = parsedPath.glob;
-				scopePath = formatScopePath(searchPath);
-			} else {
-				const multiSearchPath = await resolveExplicitSearchPaths(effectivePaths, this.session.cwd, globFilter);
-				if (!multiSearchPath) {
-					throw new ToolError("`paths` must contain at least one path or glob");
-				}
-				searchPath = multiSearchPath.basePath;
-				exactFilePaths = multiSearchPath.exactFilePaths;
-				multiTargets = multiSearchPath.targets;
-				globFilter = exactFilePaths || multiTargets ? undefined : multiSearchPath.glob;
-				scopePath = multiSearchPath.scopePath;
-			}
-			let isDirectory: boolean;
-			try {
-				const stat = await Bun.file(searchPath).stat();
-				isDirectory = stat.isDirectory();
-			} catch {
-				const hint = rawPaths.length > 1 ? " (`paths` entries must each exist relative to cwd)" : "";
-				throw new ToolError(`Path not found: ${scopePath}${hint}`);
-			}
 
 			const effectiveOutputMode = GrepOutputMode.Content;
-			const effectiveLimit = DEFAULT_MATCH_LIMIT;
-			const internalLimit = Math.min(effectiveLimit * 5, 2000);
+			// Multi-scope = more than one file may match. We fetch up to
+			// INTERNAL_TOTAL_CAP matches from native grep, then in JS group by
+			// file, apply a per-file cap (so one hot file doesn't crowd the
+			// window), and round-robin emit from up to DEFAULT_FILE_LIMIT files.
+			const isMultiScope = isDirectory || Boolean(exactFilePaths) || Boolean(multiTargets);
+			const perFileMatchCap = isMultiScope ? MULTI_FILE_PER_FILE_MATCHES : SINGLE_FILE_MATCHES;
 
 			// Run grep
 			let result: GrepResult;
@@ -221,7 +185,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 								hidden: true,
 								gitignore: useGitignore,
 								cache: false,
-								maxCount: exactFilePaths ? undefined : internalLimit,
+								maxCount: INTERNAL_TOTAL_CAP,
 								contextBefore: normalizedContextBefore,
 								contextAfter: normalizedContextAfter,
 								maxColumns: DEFAULT_MAX_COLUMN,
@@ -238,11 +202,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 							matches.push({ ...match, path: rebased });
 						}
 					}
-					const offsetMatches = matches.slice(normalizedSkip);
 					result = {
-						matches: offsetMatches,
-						totalMatches: exactFilePaths ? offsetMatches.length : totalMatches,
-						filesWithMatches: new Set(offsetMatches.map(match => match.path)).size,
+						matches,
+						totalMatches: exactFilePaths ? matches.length : totalMatches,
+						filesWithMatches: new Set(matches.map(match => match.path)).size,
 						filesSearched: exactFilePaths ? exactFilePaths.length : filesSearched,
 						limitReached,
 					};
@@ -257,8 +220,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 							hidden: true,
 							gitignore: useGitignore,
 							cache: false,
-							maxCount: internalLimit,
-							offset: normalizedSkip > 0 ? normalizedSkip : undefined,
+							maxCount: INTERNAL_TOTAL_CAP,
 							contextBefore: normalizedContextBefore,
 							contextAfter: normalizedContextAfter,
 							maxColumns: DEFAULT_MAX_COLUMN,
@@ -277,42 +239,51 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			const formatPath = (filePath: string): string =>
 				formatResultPath(filePath, isDirectory, searchPath, this.session.cwd);
 
-			// Build output
-			const roundRobinSelect = (matches: GrepMatch[], limit: number): GrepMatch[] => {
-				if (matches.length <= limit) return matches;
-				const fileOrder: string[] = [];
-				const byFile = new Map<string, GrepMatch[]>();
-				for (const match of matches) {
-					if (!byFile.has(match.path)) {
-						fileOrder.push(match.path);
-						byFile.set(match.path, []);
-					}
-					byFile.get(match.path)!.push(match);
+			// Group matches by file in encounter order. Detect per-file overflow
+			// BEFORE truncation so the renderer can surface that a hot file was
+			// trimmed for diversity.
+			const fileOrder: string[] = [];
+			const matchesByPath = new Map<string, GrepMatch[]>();
+			for (const match of result.matches) {
+				if (!matchesByPath.has(match.path)) {
+					fileOrder.push(match.path);
+					matchesByPath.set(match.path, []);
 				}
-				const selected: GrepMatch[] = [];
-				const indices = new Map<string, number>(fileOrder.map(file => [file, 0]));
-				while (selected.length < limit) {
-					let anyAdded = false;
-					for (const file of fileOrder) {
-						if (selected.length >= limit) break;
-						const fileMatches = byFile.get(file)!;
-						const idx = indices.get(file)!;
-						if (idx < fileMatches.length) {
-							selected.push(fileMatches[idx]);
-							indices.set(file, idx + 1);
+				matchesByPath.get(match.path)!.push(match);
+			}
+			let perFileLimitReached = false;
+			for (const file of fileOrder) {
+				const list = matchesByPath.get(file)!;
+				if (list.length > perFileMatchCap) {
+					perFileLimitReached = true;
+					list.length = perFileMatchCap;
+				}
+			}
+			const totalFiles = fileOrder.length;
+			// Single-file scopes can't paginate — there is one file by definition.
+			const canPaginate = isMultiScope;
+			const skipFiles = canPaginate ? Math.min(normalizedSkip, totalFiles) : 0;
+			const windowFiles = canPaginate ? fileOrder.slice(skipFiles, skipFiles + DEFAULT_FILE_LIMIT) : fileOrder;
+			const fileLimitReached = canPaginate && totalFiles > skipFiles + DEFAULT_FILE_LIMIT;
+			const selectedMatches: GrepMatch[] = [];
+			if (windowFiles.length > 0) {
+				const lists = windowFiles.map(file => matchesByPath.get(file) ?? []);
+				const cursors = new Array<number>(lists.length).fill(0);
+				let anyAdded = true;
+				while (anyAdded) {
+					anyAdded = false;
+					for (let i = 0; i < lists.length; i++) {
+						if (cursors[i] < lists[i].length) {
+							selectedMatches.push(lists[i][cursors[i]++]);
 							anyAdded = true;
 						}
 					}
-					if (!anyAdded) break;
 				}
-				return selected;
-			};
-			const selectedMatches = isDirectory
-				? roundRobinSelect(result.matches, effectiveLimit)
-				: result.matches.slice(0, effectiveLimit);
-			const matchLimitReached = result.matches.length > effectiveLimit;
-			const nextSkip = normalizedSkip + selectedMatches.length;
-			const limitMessage = `Result limit reached; narrow paths or use skip=${nextSkip}.`;
+			}
+			const nextSkip = skipFiles + windowFiles.length;
+			const limitMessage = fileLimitReached
+				? `Showing files ${skipFiles + 1}-${nextSkip} of ${totalFiles}. Use skip=${nextSkip} for the next page, or narrow paths/pattern.`
+				: "";
 			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileMatchCounts = new Map<string, number>();
 			const missingPathsNote =
@@ -405,7 +376,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					displayLines.push(...rendered.display);
 				}
 			}
-			if (matchLimitReached || result.limitReached) {
+			if (limitMessage) {
 				outputLines.push("", limitMessage);
 			}
 			if (missingPathsNote) {
@@ -414,7 +385,9 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			const rawOutput = outputLines.join("\n");
 			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 			const output = truncation.content;
-			const truncated = Boolean(matchLimitReached || result.limitReached || truncation.truncated || linesTruncated);
+			const truncated = Boolean(
+				fileLimitReached || perFileLimitReached || result.limitReached || truncation.truncated || linesTruncated,
+			);
 			const details: SearchToolDetails = {
 				scopePath,
 				matchCount: selectedMatches.length,
@@ -425,8 +398,8 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					count: fileMatchCounts.get(path) ?? 0,
 				})),
 				truncated,
-				matchLimitReached: matchLimitReached ? effectiveLimit : undefined,
-				resultLimitReached: result.limitReached ? internalLimit : undefined,
+				fileLimitReached: fileLimitReached ? DEFAULT_FILE_LIMIT : undefined,
+				perFileLimitReached: perFileLimitReached ? perFileMatchCap : undefined,
 				displayContent: displayLines.join("\n"),
 				missingPaths: missingPaths.length > 0 ? missingPaths : undefined,
 			};
@@ -499,16 +472,13 @@ export const searchToolRenderer = {
 				{ icon: "success", title: "Search", description, meta: [formatCount("item", lines.length)] },
 				uiTheme,
 			);
-			let cached: RenderCache | undefined;
-			return {
-				render(width: number): string[] {
-					const { expanded } = options;
-					const key = new Hasher().bool(expanded).u32(width).digest();
-					if (cached?.key === key) return cached.lines;
+			return createCachedComponent(
+				() => options.expanded,
+				width => {
 					const listLines = renderTreeList(
 						{
 							items: lines,
-							expanded,
+							expanded: options.expanded,
 							maxCollapsed: COLLAPSED_TEXT_LIMIT,
 							maxCollapsedLines: COLLAPSED_TEXT_LIMIT,
 							itemType: "item",
@@ -516,23 +486,16 @@ export const searchToolRenderer = {
 						},
 						uiTheme,
 					);
-					const result = [header, ...listLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
-					cached = { key, lines: result };
-					return result;
-				},
-				invalidate() {
-					cached = undefined;
+					return [header, ...listLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
 				},
-			};
+			);
 		}
 
 		const matchCount = details?.matchCount ?? 0;
 		const fileCount = details?.fileCount ?? 0;
 		const truncation = details?.meta?.truncation;
 		const limits = details?.meta?.limits;
-		const truncated = Boolean(
-			details?.truncated || truncation || limits?.matchLimit || limits?.resultLimit || limits?.columnTruncated,
-		);
+		const truncated = Boolean(details?.truncated || truncation || limits?.columnTruncated);
 
 		const missingPathsList = details?.missingPaths ?? [];
 		const missingNote =
@@ -561,34 +524,13 @@ export const searchToolRenderer = {
 		);
 
 		const textContent = result.details?.displayContent ?? result.content?.find(c => c.type === "text")?.text ?? "";
-		const rawLines = textContent.split("\n");
-		const hasSeparators = rawLines.some(line => line.trim().length === 0);
-		const matchGroups: string[][] = [];
-		if (hasSeparators) {
-			let current: string[] = [];
-			for (const line of rawLines) {
-				if (line.trim().length === 0) {
-					if (current.length > 0) {
-						matchGroups.push(current);
-						current = [];
-					}
-					continue;
-				}
-				current.push(line);
-			}
-			if (current.length > 0) matchGroups.push(current);
-		} else {
-			const nonEmpty = rawLines.filter(line => line.trim().length > 0);
-			if (nonEmpty.length > 0) {
-				matchGroups.push(nonEmpty);
-			}
-		}
+		const matchGroups = splitGroupsByBlankLine(textContent.split("\n"));
 
-		const renderedMatchLimit = details?.matchLimitReached ?? limits?.matchLimit?.reached;
-		const renderedResultLimit = details?.resultLimitReached ?? limits?.resultLimit?.reached;
+		const renderedFileLimit = details?.fileLimitReached;
+		const renderedPerFileLimit = details?.perFileLimitReached;
 		const truncationReasons: string[] = [];
-		if (renderedMatchLimit) truncationReasons.push(`first ${renderedMatchLimit} matches`);
-		if (renderedResultLimit) truncationReasons.push(`first ${renderedResultLimit} results`);
+		if (renderedFileLimit) truncationReasons.push(`first ${renderedFileLimit} files (skip to paginate)`);
+		if (renderedPerFileLimit) truncationReasons.push(`first ${renderedPerFileLimit} matches per file`);
 		if (truncation) truncationReasons.push(truncation.truncatedBy === "lines" ? "line limit" : "size limit");
 		if (limits?.columnTruncated) truncationReasons.push(`line length ${limits.columnTruncated.maxColumn}`);
 		if (truncation?.artifactId) truncationReasons.push(formatFullOutputReference(truncation.artifactId));
@@ -599,17 +541,14 @@ export const searchToolRenderer = {
 		}
 		if (missingNote) extraLines.push(missingNote);
 
-		let cached: RenderCache | undefined;
-		return {
-			render(width: number): string[] {
-				const { expanded } = options;
-				const key = new Hasher().bool(expanded).u32(width).digest();
-				if (cached?.key === key) return cached.lines;
+		return createCachedComponent(
+			() => options.expanded,
+			width => {
 				const collapsedMatchLineBudget = Math.max(COLLAPSED_TEXT_LIMIT - extraLines.length, 0);
 				const matchLines = renderTreeList(
 					{
 						items: matchGroups,
-						expanded,
+						expanded: options.expanded,
 						maxCollapsed: matchGroups.length,
 						maxCollapsedLines: collapsedMatchLineBudget,
 						itemType: "match",
@@ -622,14 +561,9 @@ export const searchToolRenderer = {
 					},
 					uiTheme,
 				);
-				const result = [header, ...matchLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
-				cached = { key, lines: result };
-				return result;
+				return [header, ...matchLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
 			},
-			invalidate() {
-				cached = undefined;
-			},
-		};
+		);
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/write.ts

@@ -85,6 +85,21 @@ function stripWriteContent(session: ToolSession, content: string): { text: strin
 	return { text: cleaned.join("\n"), stripped: true };
 }
 
+/**
+ * Append a trailing note line to the first text block of a tool result.
+ * Mutates `result` in place (the result object is owned by this call).
+ */
+function appendNoteToResult(result: AgentToolResult<WriteToolDetails>, note: string): void {
+	const firstText = result.content.find(
+		(block): block is { type: "text"; text: string } => block.type === "text" && typeof block.text === "string",
+	);
+	if (firstText) {
+		firstText.text = firstText.text.length > 0 ? `${firstText.text}\n${note}` : note;
+	} else {
+		result.content.push({ type: "text", text: note });
+	}
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
@@ -175,7 +190,6 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	readonly concurrency = "exclusive";
 	readonly loadMode = "discoverable";
 	readonly summary = "Write content to a file (creates or overwrites)";
-	readonly intent = (args: Partial<WriteToolInput>) => (args.path ? `writing ${args.path}` : "writing");
 
 	readonly #writethrough: WritethroughCallback;
 
@@ -489,6 +503,26 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		};
 	}
 
+	/**
+	 * Look up a single conflict entry by id and dispatch to {@link #resolveConflict}.
+	 * Throws a clear `not found` error when the id has been invalidated.
+	 */
+	async #resolveSingleConflictById(
+		id: number,
+		replacementContent: string,
+		stripped: boolean,
+		signal: AbortSignal | undefined,
+		context: AgentToolContext | undefined,
+	): Promise<AgentToolResult<WriteToolDetails>> {
+		const entry = getConflictHistory(this.session).get(id);
+		if (!entry) {
+			throw new ToolError(
+				`Conflict #${id} not found. Conflict ids are registered when \`read\` surfaces a marker block; re-read the file to get a current id.`,
+			);
+		}
+		return this.#resolveConflict(entry, replacementContent, stripped, signal, context);
+	}
+
 	/**
 	 * Bulk-resolve every registered conflict via `conflict://*`.
 	 *
@@ -631,16 +665,17 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 						`Conflict URI scope '/${conflictUri.scope}' is read-only — read \`conflict://${conflictUri.id}/${conflictUri.scope}\` to inspect that side. To write, drop the scope (\`conflict://${conflictUri.id}\`) and put the chosen content (or shorthand like \`@${conflictUri.scope}\`) in \`content\`.`,
 					);
 				}
-				if (conflictUri.id === "*") {
-					return this.#resolveAllConflicts(cleanContent, stripped, signal, context);
-				}
-				const entry = getConflictHistory(this.session).get(conflictUri.id);
-				if (!entry) {
-					throw new ToolError(
-						`Conflict #${conflictUri.id} not found. Conflict ids are registered when \`read\` surfaces a marker block; re-read the file to get a current id.`,
+				const result =
+					conflictUri.id === "*"
+						? await this.#resolveAllConflicts(cleanContent, stripped, signal, context)
+						: await this.#resolveSingleConflictById(conflictUri.id, cleanContent, stripped, signal, context);
+				if (conflictUri.recoveredPrefix !== undefined) {
+					appendNoteToResult(
+						result,
+						`Note: stripped erroneous '${conflictUri.recoveredPrefix}:' prefix from path; conflict URIs are global (use \`conflict://${conflictUri.id}\`, not \`<file>:conflict://${conflictUri.id}\`).`,
 					);
 				}
-				return this.#resolveConflict(entry, cleanContent, stripped, signal, context);
+				return result;
 			}
 			const resolvedArchivePath = await this.#resolveArchiveWritePath(path);
 			if (resolvedArchivePath) {

package/src/utils/file-mentions.ts

@@ -10,6 +10,7 @@ import path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { glob } from "@oh-my-pi/pi-natives";
+import { fuzzyMatch } from "@oh-my-pi/pi-tui";
 import { formatAge, formatBytes, readImageMetadata } from "@oh-my-pi/pi-utils";
 import { formatHashLines } from "../hashline/hash";
 import type { FileMentionMessage } from "../session/messages";
@@ -20,7 +21,6 @@ import {
 	truncateHeadBytes,
 } from "../session/streaming-output";
 import { resolveReadPath } from "../tools/path-utils";
-import { fuzzyMatch } from "./fuzzy";
 import { formatDimensionNote, resizeImage } from "./image-resize";
 
 /** Regex to match @filepath patterns in text */

package/src/utils/image-loading.ts

@@ -2,7 +2,6 @@ import * as fs from "node:fs/promises";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { formatBytes, readImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@oh-my-pi/pi-utils";
 import { resolveReadPath } from "../tools/path-utils";
-import { convertToPng } from "./image-convert";
 import { formatDimensionNote, resizeImage } from "./image-resize";
 
 export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
@@ -42,8 +41,13 @@ export async function ensureSupportedImageInput(image: ImageContent): Promise<Im
 	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) {
 		return image;
 	}
-	const converted = await convertToPng(image.data, image.mimeType);
-	return converted ? { type: "image", data: converted.data, mimeType: converted.mimeType } : null;
+	try {
+		const bytes = Buffer.from(image.data, "base64");
+		const data = await new Bun.Image(bytes).png().toBase64();
+		return { type: "image", data, mimeType: "image/png" };
+	} catch {
+		return null;
+	}
 }
 
 export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {