@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/tools/report-tool-issue.ts

@@ -0,0 +1,80 @@
+/**
+ * report_tool_issue — automated QA tool for tracking unexpected tool behavior.
+ *
+ * Enabled when PI_AUTO_QA=1 or the dev.autoqa setting is on.
+ * Always injected into every agent (including subagents) regardless of tool selection.
+ * Records grievances to a local SQLite database; never throws.
+ */
+import { Database } from "bun:sqlite";
+import path from "node:path";
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { $env, getAgentDir, logger, VERSION } from "@oh-my-pi/pi-utils";
+import { Type } from "@sinclair/typebox";
+import type { Settings } from "..";
+import type { ToolSession } from "./index";
+
+const ReportToolIssueParams = Type.Object({
+	tool: Type.String({ description: "Name of the tool that behaved unexpectedly" }),
+	report: Type.String({ description: "Description of what was unexpected about the tool's behavior" }),
+});
+
+export function isAutoQaEnabled(settings?: Settings): boolean {
+	return $env.PI_AUTO_QA === "1" || !!settings?.get("dev.autoqa");
+}
+
+export function getAutoQaDbPath(): string {
+	return path.join(getAgentDir(), "autoqa.db");
+}
+
+let cachedDb: Database | null = null;
+
+function openDb(): Database | null {
+	if (cachedDb) return cachedDb;
+	try {
+		const db = new Database(getAutoQaDbPath());
+		db.run(`
+			PRAGMA journal_mode=WAL;
+			PRAGMA synchronous=NORMAL;
+			PRAGMA busy_timeout=5000;
+			CREATE TABLE IF NOT EXISTS grievances (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				model TEXT NOT NULL,
+				version TEXT NOT NULL,
+				tool TEXT NOT NULL,
+				report TEXT NOT NULL
+			);
+		`);
+		cachedDb = db;
+		return db;
+	} catch {
+		return null;
+	}
+}
+
+export function createReportToolIssueTool(session: ToolSession): AgentTool {
+	const getModel = () => session.getActiveModelString?.() ?? "unknown";
+
+	return {
+		name: "report_tool_issue",
+		label: "Report Tool Issue",
+		description: "Report unexpected tool behavior for automated QA tracking.",
+		parameters: ReportToolIssueParams,
+		async execute(_toolCallId, rawParams) {
+			try {
+				const params = rawParams as { tool: string; report: string };
+				const db = openDb();
+				db?.prepare("INSERT INTO grievances (model, version, tool, report) VALUES (?, ?, ?, ?)").run(
+					getModel(),
+					VERSION,
+					params.tool,
+					params.report,
+				);
+			} catch (error) {
+				logger.error("Failed to record tool issue", { error });
+			}
+			return {
+				content: [{ type: "text", text: "Noted, thanks!" }],
+			};
+		},
+	};
+}

package/src/tools/resolve.ts

@@ -1,9 +1,8 @@
 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 { untilAborted } from "@oh-my-pi/pi-utils";
+import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import resolveDescription from "../prompts/tools/resolve.md" with { type: "text" };
@@ -11,7 +10,6 @@ import { Ellipsis, padToWidth, renderStatusLine, truncateToWidth } from "../tui"
 import type { ToolSession } from ".";
 import { replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
-import { toolResult } from "./tool-result";
 
 const resolveSchema = Type.Object({
 	action: Type.Union([Type.Literal("apply"), Type.Literal("discard")]),
@@ -33,6 +31,70 @@ function resolveReasonPreview(reason?: string): string | undefined {
 	return truncateToWidth(trimmed, 72, Ellipsis.Omit);
 }
 
+/**
+ * Queue a resolve-protocol handler on the tool-choice queue. Forces the next
+ * LLM call to invoke the hidden `resolve` tool, wraps the caller's apply/reject
+ * callbacks into an onInvoked closure that matches the resolve schema, and
+ * steers a preview reminder so the model understands why.
+ *
+ * This is the canonical entry point for any tool that wants preview/apply
+ * semantics. No session-level abstraction is needed: callers pass their
+ * apply/reject functions directly.
+ */
+export function queueResolveHandler(
+	session: ToolSession,
+	options: {
+		label: string;
+		sourceToolName: string;
+		apply(reason: string): Promise<AgentToolResult<unknown>>;
+		reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+	},
+): void {
+	const queue = session.getToolChoiceQueue?.();
+	const forced = session.buildToolChoice?.("resolve");
+	if (!queue || !forced || typeof forced === "string") return;
+
+	const detailsFor = (params: ResolveParams): ResolveToolDetails => ({
+		action: params.action,
+		reason: params.reason,
+		sourceToolName: options.sourceToolName,
+		label: options.label,
+	});
+
+	queue.pushOnce(forced, {
+		label: `pending-action:${options.sourceToolName}`,
+		now: true,
+		onRejected: () => "requeue",
+		onInvoked: async (input: unknown) => {
+			const params = input as ResolveParams;
+			if (params.action === "apply") {
+				const result = await options.apply(params.reason);
+				return { ...result, details: detailsFor(params) };
+			}
+			if (params.action === "discard" && options.reject != null) {
+				const result = await options.reject(params.reason);
+				if (result != null) {
+					return { ...result, details: detailsFor(params) };
+				}
+			}
+			return {
+				content: [{ type: "text" as const, text: `Discarded: ${options.label}. Reason: ${params.reason}` }],
+				details: detailsFor(params),
+			};
+		},
+	});
+
+	session.steer?.({
+		customType: "resolve-reminder",
+		content: [
+			"<system-reminder>",
+			"This is a preview. Call the `resolve` tool to apply or discard these changes.",
+			"</system-reminder>",
+		].join("\n"),
+		details: { toolName: options.sourceToolName },
+	});
+}
+
 export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
 	readonly name = "resolve";
 	readonly label = "Resolve";
@@ -42,7 +104,7 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(resolveDescription);
+		this.description = prompt.render(resolveDescription);
 	}
 
 	async execute(
@@ -53,43 +115,12 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<ResolveToolDetails>> {
 		return untilAborted(signal, async () => {
-			const store = this.session.pendingActionStore;
-			if (!store?.hasPending) {
+			const invoker = this.session.peekQueueInvoker?.();
+			if (!invoker) {
 				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
 			}
-
-			const pendingAction = store.pop();
-			if (!pendingAction) {
-				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
-			}
-			const resolveDetails: ResolveToolDetails = {
-				action: params.action,
-				reason: params.reason,
-				sourceToolName: pendingAction.sourceToolName,
-				label: pendingAction.label,
-			};
-
-			if (params.action === "apply") {
-				const applyResult = await pendingAction.apply(params.reason);
-				const appliedText = applyResult.content
-					.filter(part => part.type === "text")
-					.map(part => part.text)
-					.filter(text => text != null && text.length > 0)
-					.join("\n");
-				const baseResult = toolResult()
-					.text(appliedText || `Applied: ${pendingAction.label}.`)
-					.done();
-				return { ...baseResult, details: resolveDetails };
-			}
-
-			if (params.action === "discard" && pendingAction.reject != null) {
-				const discardResult = await pendingAction.reject(params.reason);
-				if (discardResult != null) {
-					return { ...discardResult, details: resolveDetails };
-				}
-			}
-			const discardResult = toolResult().text(`Discarded: ${pendingAction.label}. Reason: ${params.reason}`).done();
-			return { ...discardResult, details: resolveDetails };
+			const result = (await invoker(params)) as AgentToolResult<ResolveToolDetails>;
+			return result;
 		});
 	}
 }

package/src/tools/search-tool-bm25.ts

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
+import { prompt } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import {
 	buildDiscoverableMCPSearchIndex,
@@ -105,7 +105,7 @@ function supportsMCPToolDiscoveryExecution(session: ToolSession): session is MCP
 
 export function renderSearchToolBm25Description(discoverableTools: DiscoverableMCPTool[] = []): string {
 	const summary = summarizeDiscoverableMCPTools(discoverableTools);
-	return renderPromptTemplate(searchToolBm25Description, {
+	return prompt.render(searchToolBm25Description, {
 		discoverableMCPToolCount: summary.toolCount,
 		discoverableMCPServerSummaries: summary.servers.map(formatDiscoverableMCPToolServerSummary),
 		hasDiscoverableMCPServers: summary.servers.length > 0,

package/src/tools/ssh.ts

@@ -1,10 +1,10 @@
 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 { prompt } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { SSHHost } from "../capability/ssh";
 import { sshCapability } from "../capability/ssh";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import { loadCapability } from "../discovery";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
@@ -59,7 +59,7 @@ async function formatHostEntry(host: SSHHost): Promise<string> {
 }
 
 async function formatDescription(hosts: SSHHost[]): Promise<string> {
-	const baseDescription = renderPromptTemplate(sshDescriptionBase);
+	const baseDescription = prompt.render(sshDescriptionBase);
 	if (hosts.length === 0) {
 		return baseDescription;
 	}

package/src/tools/todo-write.ts

@@ -2,9 +2,9 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { prompt } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import chalk from "chalk";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import todoWriteDescription from "../prompts/tools/todo-write.md" with { type: "text" };
@@ -347,7 +347,7 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(todoWriteDescription);
+		this.description = prompt.render(todoWriteDescription);
 	}
 
 	async execute(

package/src/tools/tool-timeouts.ts

@@ -14,6 +14,7 @@ export const TOOL_TIMEOUTS = {
 	ssh: { default: 60, min: 1, max: 3600 },
 	fetch: { default: 20, min: 1, max: 45 },
 	lsp: { default: 20, min: 5, max: 60 },
+	debug: { default: 30, min: 5, max: 300 },
 } as const satisfies Record<string, ToolTimeoutConfig>;
 
 export type ToolWithTimeout = keyof typeof TOOL_TIMEOUTS;

package/src/tools/write.ts

@@ -9,20 +9,19 @@ import type {
 } 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 { isEnoent, untilAborted } from "@oh-my-pi/pi-utils";
+import { isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { unzipSync, zipSync } from "fflate";
-import { renderPromptTemplate } from "../config/prompt-templates";
+import { stripHashlinePrefixes } from "../edit";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
-import { stripHashlinePrefixes } from "../patch";
 import writeDescription from "../prompts/tools/write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { parseArchivePathCandidates } from "./archive-reader";
-import { checkAutoGeneratedFile } from "./auto-generated-guard";
+import { assertEditableFile } from "./auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
 import { type OutputMeta, outputMeta } from "./output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "./plan-mode-guard";
@@ -149,7 +148,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		this.#writethrough = enableLsp
 			? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
 			: writethroughNoop;
-		this.description = renderPromptTemplate(writeDescription);
+		this.description = prompt.render(writeDescription);
 	}
 
 	async #resolveArchiveWritePath(writePath: string): Promise<ResolvedArchiveWritePath | null> {
@@ -298,7 +297,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 
 			// Check if file exists and is auto-generated before overwriting
 			if (await fs.exists(absolutePath)) {
-				await checkAutoGeneratedFile(absolutePath, path);
+				await assertEditableFile(absolutePath, path);
 			}
 
 			const diagnostics = await this.#writethrough(absolutePath, cleanContent, signal, undefined, batchRequest);

package/src/tui/tree-list.ts

@@ -1,8 +1,10 @@
 /**
  * Hierarchical tree list rendering helper.
  */
+
+import { replaceTabs } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
-import { formatMoreItems, replaceTabs } from "../tools/render-utils";
+import { formatMoreItems } from "../tools/render-utils";
 import type { TreeContext } from "./types";
 import { getTreeBranch, getTreeContinuePrefix } from "./utils";
 

package/src/utils/clipboard.ts

@@ -0,0 +1,80 @@
+import { execSync } from "node:child_process";
+import type { ClipboardImage } from "@oh-my-pi/pi-natives";
+import * as native from "@oh-my-pi/pi-natives";
+
+const hasDisplay = process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+
+/**
+ * Copy text to the system clipboard.
+ *
+ * Emits OSC 52 first when running in a real terminal (works over SSH/mosh),
+ * then attempts native clipboard copy as best-effort for local sessions.
+ * On Termux, tries `termux-clipboard-set` before native.
+ *
+ * @param text - UTF-8 text to place on the clipboard.
+ */
+export async function copyToClipboard(text: string): Promise<void> {
+	if (process.stdout.isTTY) {
+		const onError = (err: unknown) => {
+			process.stdout.off("error", onError);
+			// Prevent unhandled 'error' from crashing the process when stdout is a closed pipe.
+			if ((err as NodeJS.ErrnoException | null | undefined)?.code === "EPIPE") {
+				return;
+			}
+		};
+		try {
+			const encoded = Buffer.from(text).toString("base64");
+			const osc52 = `\x1b]52;c;${encoded}\x07`;
+			process.stdout.on("error", onError);
+			process.stdout.write(osc52, err => {
+				process.stdout.off("error", onError);
+				// If stdout is closed (e.g. piped to a process that exits early),
+				// ignore EPIPE and proceed with native clipboard best-effort.
+				if ((err as NodeJS.ErrnoException | null | undefined)?.code === "EPIPE") {
+					return;
+				}
+			});
+		} catch (err) {
+			process.stdout.off("error", onError);
+			if ((err as NodeJS.ErrnoException | null | undefined)?.code !== "EPIPE") {
+				// Ignore all write failures (OSC 52 is best-effort).
+			}
+		}
+	}
+
+	// Also try native tools (best effort for local sessions)
+	try {
+		if (process.env.TERMUX_VERSION) {
+			try {
+				execSync("termux-clipboard-set", { input: text, timeout: 5000 });
+				return;
+			} catch {
+				// Fall through to native
+			}
+		}
+
+		await native.copyToClipboard(text);
+	} catch {
+		// Ignore — clipboard copy is best-effort
+	}
+}
+
+/**
+ * Read an image from the system clipboard.
+ *
+ * Returns null on Termux (no image clipboard support) or when no display
+ * server is available (headless/SSH without forwarding).
+ *
+ * @returns PNG payload or null when no image is available.
+ */
+export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
+	if (process.env.TERMUX_VERSION) {
+		return null;
+	}
+
+	if (!hasDisplay) {
+		return null;
+	}
+
+	return (await native.readImageFromClipboard()) ?? null;
+}

package/src/utils/commit-message-generator.ts

@@ -5,16 +5,15 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
-import { logger } from "@oh-my-pi/pi-utils";
+import { logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveModelRoleValue } from "../config/model-resolver";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
 import commitSystemPrompt from "../prompts/system/commit-message-system.md" with { type: "text" };
 import { toReasoningEffort } from "../thinking";
 
-const COMMIT_SYSTEM_PROMPT = renderPromptTemplate(commitSystemPrompt);
+const COMMIT_SYSTEM_PROMPT = prompt.render(commitSystemPrompt);
 const MAX_DIFF_CHARS = 4000;
 
 /** File patterns that should be excluded from commit message generation diffs. */

package/src/utils/edit-mode.ts

@@ -0,0 +1,49 @@
+import { $env } from "@oh-my-pi/pi-utils";
+
+export type EditMode = "replace" | "patch" | "hashline" | "chunk";
+
+export const DEFAULT_EDIT_MODE: EditMode = "hashline";
+
+const EDIT_MODE_IDS = {
+	chunk: "chunk",
+	hashline: "hashline",
+	patch: "patch",
+	replace: "replace",
+} as const satisfies Record<string, EditMode>;
+
+export const EDIT_MODES = Object.keys(EDIT_MODE_IDS) as EditMode[];
+
+export function normalizeEditMode(mode?: string | null): EditMode | undefined {
+	if (!mode) return undefined;
+	return EDIT_MODE_IDS[mode as keyof typeof EDIT_MODE_IDS];
+}
+
+export interface EditModeSettingsLike {
+	get(key: "edit.mode"): unknown;
+	getEditVariantForModel?(model: string | undefined): EditMode | null;
+}
+
+export interface EditModeSessionLike {
+	settings: EditModeSettingsLike;
+	getActiveModelString?: () => string | undefined;
+}
+
+export function resolveEditMode(session: EditModeSessionLike): EditMode {
+	const activeModel = session.getActiveModelString?.();
+	const modelVariant = session.settings.getEditVariantForModel?.(activeModel);
+	if (modelVariant) return modelVariant;
+
+	const envMode = normalizeEditMode($env.PI_EDIT_VARIANT);
+	if (envMode) return envMode;
+
+	if ($env.PI_STRICT_EDIT_MODE === "1") {
+		if (activeModel?.includes("spark")) return "replace";
+		if (activeModel?.includes("nano")) return "replace";
+		if (activeModel?.includes("mini")) return "replace";
+		if (activeModel?.includes("haiku")) return "replace";
+		if (activeModel?.includes("flash")) return "replace";
+	}
+
+	const settingsMode = normalizeEditMode(String(session.settings.get("edit.mode") ?? ""));
+	return settingsMode ?? DEFAULT_EDIT_MODE;
+}

package/src/utils/external-editor.ts

@@ -17,6 +17,8 @@ export interface OpenInEditorOptions {
 	extension?: string;
 	/** Custom stdio configuration (default: all "inherit"). */
 	stdio?: [number | "inherit", number | "inherit", number | "inherit"];
+	/** Keep the file's trailing newline instead of trimming it from the returned text. */
+	trimTrailingNewline?: boolean;
 }
 
 /**
@@ -40,13 +42,17 @@ export async function openInEditor(
 		const stdio = options?.stdio ?? ["inherit", "inherit", "inherit"];
 
 		const child = spawn(editor, [...editorArgs, tmpFile], { stdio, shell: process.platform === "win32" });
-		const exitCode = await new Promise<number>((resolve, reject) => {
-			child.once("exit", (code, signal) => resolve(code ?? (signal ? -1 : 0)));
-			child.once("error", error => reject(error));
-		});
+		const { promise, reject, resolve } = Promise.withResolvers<number>();
+		child.once("exit", (code, signal) => resolve(code ?? (signal ? -1 : 0)));
+		child.once("error", error => reject(error));
+		const exitCode = await promise;
 
 		if (exitCode === 0) {
-			return (await Bun.file(tmpFile).text()).replace(/\n$/, "");
+			const text = await Bun.file(tmpFile).text();
+			if (options?.trimTrailingNewline === false) {
+				return text;
+			}
+			return text.replace(/\n$/, "");
 		}
 		return null;
 	} finally {

package/src/utils/file-display-mode.ts

@@ -2,9 +2,12 @@
  * Resolve line-display mode for file-like outputs (read, grep, @file mentions).
  */
 
+import { resolveEditMode } from "./edit-mode";
+
 export interface FileDisplayMode {
 	lineNumbers: boolean;
 	hashLines: boolean;
+	chunked: boolean;
 }
 
 /** Session-like object providing settings and tool availability for display mode resolution. */
@@ -24,13 +27,11 @@ export interface FileDisplayModeSession {
 export function resolveFileDisplayMode(session: FileDisplayModeSession): FileDisplayMode {
 	const { settings } = session;
 	const hasEditTool = session.hasEditTool ?? true;
-	const hashLines =
-		hasEditTool &&
-		(settings.get("readHashLines") === true ||
-			settings.get("edit.mode") === "hashline" ||
-			Bun.env.PI_EDIT_VARIANT === "hashline");
+	const hashLines = hasEditTool && resolveEditMode(session) === "hashline" && settings.get("readHashLines") !== false;
+	const chunked = hasEditTool && resolveEditMode(session) === "chunk";
 	return {
 		hashLines,
 		lineNumbers: hashLines || settings.get("readLineNumbers") === true,
+		chunked,
 	};
 }

package/src/utils/file-mentions.ts

@@ -8,8 +8,10 @@
 import * as fs from "node:fs/promises";
 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 { formatHashLines } from "../patch/hashline";
+import { formatAge, formatBytes, readImageMetadata } from "@oh-my-pi/pi-utils";
+import { formatHashLines } from "../edit/line-hash";
 import type { FileMentionMessage } from "../session/messages";
 import {
 	DEFAULT_MAX_BYTES,
@@ -18,10 +20,8 @@ import {
 	truncateHeadBytes,
 } from "../session/streaming-output";
 import { resolveReadPath } from "../tools/path-utils";
-import { formatAge, formatBytes } from "../tools/render-utils";
 import { fuzzyMatch } from "./fuzzy";
 import { formatDimensionNote, resizeImage } from "./image-resize";
-import { detectSupportedImageMimeTypeFromFile } from "./mime";
 
 /** Regex to match @filepath patterns in text */
 const FILE_MENTION_REGEX = /@([^\s@]+)/g;
@@ -304,7 +304,8 @@ export async function generateFileMentionMessages(
 				continue;
 			}
 
-			const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
+			const imageMetadata = await readImageMetadata(absolutePath);
+			const mimeType = imageMetadata?.mimeType;
 			if (mimeType) {
 				if (stat.size > MAX_AUTO_READ_IMAGE_BYTES) {
 					files.push({
@@ -321,7 +322,7 @@ export async function generateFileMentionMessages(
 				}
 
 				const base64Content = buffer.toBase64();
-				let image = { type: "image" as const, mimeType, data: base64Content };
+				let image: ImageContent = { type: "image", mimeType, data: base64Content };
 				let dimensionNote: string | undefined;
 
 				if (autoResizeImages) {
@@ -329,12 +330,12 @@ export async function generateFileMentionMessages(
 						const resized = await resizeImage({ type: "image", data: base64Content, mimeType });
 						dimensionNote = formatDimensionNote(resized);
 						image = {
-							type: "image" as const,
+							type: "image",
 							mimeType: resized.mimeType,
 							data: resized.data,
 						};
 					} catch {
-						image = { type: "image" as const, mimeType, data: base64Content };
+						image = { type: "image", mimeType, data: base64Content };
 					}
 				}