@oh-my-pi/pi-coding-agent 14.0.4 → 14.0.5

package/src/modes/theme/mermaid-cache.ts

@@ -1,7 +1,6 @@
 import { extractMermaidBlocks, logger, renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils";
 
-const cache = new Map<bigint, string>();
-const failed = new Set<bigint>();
+const cache = new Map<bigint | number, string | null>();
 
 let onRenderNeeded: (() => void) | null = null;
 
@@ -16,7 +15,7 @@ export function setMermaidRenderCallback(callback: (() => void) | null): void {
  * Get a pre-rendered mermaid ASCII diagram by hash.
  * Returns null if not cached or rendering failed.
  */
-export function getMermaidAscii(hash: bigint): string | null {
+export function getMermaidAscii(hash: bigint | number): string | null {
 	return cache.get(hash) ?? null;
 }
 
@@ -31,14 +30,14 @@ export function prerenderMermaid(markdown: string): void {
 	let hasNew = false;
 
 	for (const { source, hash } of blocks) {
-		if (cache.has(hash) || failed.has(hash)) continue;
+		if (cache.has(hash)) continue;
 
 		const ascii = renderMermaidAsciiSafe(source);
 		if (ascii) {
 			cache.set(hash, ascii);
 			hasNew = true;
 		} else {
-			failed.add(hash);
+			cache.set(hash, null);
 		}
 	}
 
@@ -58,7 +57,7 @@ export function prerenderMermaid(markdown: string): void {
  */
 export function hasPendingMermaid(markdown: string): boolean {
 	const blocks = extractMermaidBlocks(markdown);
-	return blocks.some(({ hash }) => !cache.has(hash) && !failed.has(hash));
+	return blocks.some(({ hash }) => !cache.has(hash));
 }
 
 /**
@@ -66,5 +65,4 @@ export function hasPendingMermaid(markdown: string): boolean {
  */
 export function clearMermaidCache(): void {
 	cache.clear();
-	failed.clear();
 }

package/src/priority.json

@@ -25,5 +25,13 @@
 		"opus-4.1",
 		"opus-4-1",
 		"pro"
+	],
+	"designer": [
+		"google-gemini-cli/gemini-3.1-pro",
+		"google-gemini-cli/gemini-3-pro",
+		"gemini-3.1-pro",
+		"gemini-3-1-pro",
+		"gemini-3-pro",
+		"gemini-3"
 	]
 }

package/src/prompts/agents/designer.md

@@ -1,8 +1,7 @@
 ---
 name: designer
 description: UI/UX specialist for design implementation, review, visual refinement
-spawns: explore
-model: google-gemini-cli/gemini-3.1-pro, google-gemini-cli/gemini-3-pro, gemini-3.1-pro, gemini-3-1-pro, gemini-3-pro, gemini-3, pi/default
+model: pi/designer
 ---
 
 You are an expert UI/UX designer implementing and reviewing UI designs.

package/src/prompts/tools/chunk-edit.md

@@ -3,67 +3,66 @@ Edits files via syntax-aware chunks. Run `read(path="file.ts")` first. The edit
 <rules>
 - **MUST** `read` first. Never invent chunk paths or CRCs. Copy them from the latest `read` output or edit response.
 - `sel` format:
-  - insertions: `chunk` or `chunk@region`
-  - replacements: `chunk#CRC` or `chunk#CRC@region`
-- Without a `@region` it defaults to the entire chunk including leading trivia. Valid regions: `head`, `body`, `tail`, `decl`.
+  - insertions: `chunk`, `chunk~`, or `chunk^`
+  - replacements: `chunk#CRC`, `chunk#CRC~`, or `chunk#CRC^`
+- Without a suffix it defaults to the entire chunk including leading trivia. `~` targets the body, `^` targets the head.
 - If the exact chunk path is unclear, run `read(path="file", sel="?")` and copy a selector from that listing.
 {{#if chunkAutoIndent}}
-- Use `\t` for indentation in `content`. Write content at indent-level 0 — the tool re-indents it to match the chunk's position in the file. For example, to replace `@body` of a method, write the body starting at column 0:
+- Use `\t` for indentation in `content`. Write content at indent-level 0 — the tool re-indents it to match the chunk's position in the file. For example, to replace `~` of a method, write the body starting at column 0:
   ```
   content: "if (x) {\n\treturn true;\n}"
   ```
   The tool adds the correct base indent automatically. Never manually pad with the chunk's own indentation.
 {{else}}
 - Match the file's literal tabs/spaces in `content`. Do not convert indentation to canonical `\t`.
-- Write content at indent-level 0 relative to the target region. For example, to replace `@body` of a method, write:
+- Write content at indent-level 0 relative to the target region. For example, to replace `~` of a method, write:
   ```
   content: "if (x) {\n  return true;\n}"
   ```
   The tool adds the correct base indent automatically, then preserves the tabs/spaces you used inside the snippet. Never manually pad with the chunk's own indentation.
 {{/if}}
-- `@region` only works on container chunks (classes, functions, impl blocks, sections). Do **not** use `@head`/`@body`/`@tail` on leaf chunks (enum variants, fields, single statements) — use the whole chunk instead.
+- Region suffixes only apply to container chunks (classes, functions, impl blocks, sections). On leaf chunks (enum variants, fields, single statements, and compound statements like `if`/`for`/`while`/`match`/`try`), `~` and `^` silently fall back to whole-chunk replacement — prefer the unsuffixed form and always supply the complete replacement (condition + body, not just the body) to avoid dropping structural parts.
 - `replace` requires the current CRC. Insertions do not.
-- **CRCs change after every edit.** Always use the selectors/CRCs from the most recent `read` or edit response. Never reuse a CRC from a previous edit.
+- **CRCs change after every edit.** The edit response always carries the new CRCs — use those for the next call or run `read(path="file", sel="?")` to refresh. Never reuse a CRC from before the latest edit.
 </rules>
 
 <critical>
 You **MUST** use the narrowest region that covers your change. Replacing without a region replaces the **entire chunk including leading comments, decorators, and attributes** — omitting them from `content` deletes them.
 
-**`replace` is total, not surgical.** The `content` you supply becomes the *complete* new content for the targeted region. Everything in the original region that you omit from `content` is deleted. Before replacing `@body` on any chunk, verify the chunk does not contain children you intend to keep. If a chunk spans hundreds of lines and your change touches only a few, target a specific child chunk — not the parent.
+**`replace` is total, not surgical.** The `content` you supply becomes the *complete* new content for the targeted region. Everything in the original region that you omit from `content` is deleted. Before replacing `~` on any chunk, verify the chunk does not contain children you intend to keep. If a chunk spans hundreds of lines and your change touches only a few, target a specific child chunk — not the parent.
 
-**Group chunks (`stmts_*`, `imports_*`, `decls_*`) are containers.** They hold many sibling items (test functions, import statements, declarations). Replacing `@body` on a group chunk replaces **all** of its children. To edit one item inside a group, target that item's own chunk path. If no child chunk exists, use the specific child's chunk selector from `read` output — do not replace the parent group.
+**Group chunks (`stmts_*`, `imports_*`, `decls_*`) are containers.** They hold many sibling items (test functions, import statements, declarations). Replacing `~` on a group chunk replaces **all** of its children. To edit one item inside a group, target that item's own chunk path. If no child chunk exists, use the specific child's chunk selector from `read` output — do not replace the parent group.
 </critical>
 
 <regions>
+Given a chunk like:
 ```
-  @head ··· ┊ /// doc comment
-          · ┊ #[attr]
-  @decl ··· ┊ fn foo(x: i32) {
-   @body ·· ┊     body();
-   @tail ·· ┊ }
+/// doc comment      <-- leading trivia
+#[attr]              <-- leading trivia
+fn foo(x: i32) {     <-- signature + opening delimiter
+    body();          <-- body
+}                    <-- closing delimiter
 ```
-- `@body` — the interior only. **Use for most edits.**
-- `@head` — leading trivia + signature + opening delimiter.
-- `@tail` — the closing delimiter.
-- `@decl` — everything except leading trivia (signature + body + closing delimiter).
-- *(no region)* — the entire chunk including leading trivia. Same as `@head` + `@body` + `@tail`.
 
-For leaf chunks (fields, variants, single-line items), `@body` falls back to the full chunk.
+Append `~` to target the body, `^` to target the head (trivia + signature), or nothing for the whole chunk:
+- `fn_foo#CRC~` — body only. **Use for most edits.** On leaf chunks, falls back to whole chunk.
+- `fn_foo#CRC^` — head (decorators, attributes, doc comments, signature, opening delimiter).
+- `fn_foo#CRC` — entire chunk including leading trivia.
+- `chunk~` + `append`/`prepend` inserts *inside* the container. `chunk` + `append`/`prepend` inserts *outside*.
 
-`append`/`prepend` without a `@region` inserts _outside_ the chunk. To add children _inside_ a class, struct, enum, or function body, use `@body`:
-- `class_Foo@body` + `append` → adds inside the class before `}`
-- `class_Foo@body` + `prepend` → adds inside the class after `{`
-- `class_Foo` + `append` → adds after the entire class (after `}`)
+**Note on leading trivia:** whether a decorator/doc comment belongs to `^` depends on the parser. In Rust and Python, attributes and decorators are attached to the function chunk, so `^` covers them. In TypeScript/JavaScript, a `@decorator` + `/** jsdoc */` block immediately above a method often surfaces as a **separate sibling chunk** (shown as `chunk#CRC` in the `?` listing) rather than as part of the function's `^`. If you need to rewrite a decorator, check the `?` listing for a sibling `chunk#CRC` directly above your target.
+
+**Note on non-code formats:** for prose and data formats (markdown, YAML, JSON, fenced code blocks, frontmatter), `^` and `~` fall back to the whole chunk. Always replace the entire chunk and include any delimiter syntax (fence backticks, `---` frontmatter markers, list markers) in your `content` — omitting them deletes them. For markdown sections (`sect_*`), always use unsuffixed whole-chunk replace — `^` and `~` on section containers also fall back to whole-chunk replace. When editing fenced code blocks in markdown, use the exact whitespace from the file (read with `raw` first) — the tool preserves literal indentation inside fenced blocks, but any content you supply is written verbatim. To insert content after a markdown section heading, use `after` on the heading chunk (`sect_*.chunk` or `sect_*.chunk_1`) — not `before`/`prepend` on the section itself, which lands physically before the heading and gets absorbed by the preceding section on reparse.
 </regions>
 
 <ops>
 |op|sel|effect|
 |---|---|---|
-|`replace`|`chunk#CRC(@region)?`|rewrite the addressed region|
-|`before`|`chunk(@region)?`|insert before the region span|
-|`after`|`chunk(@region)?`|insert after the region span|
-|`prepend`|`chunk(@region)?`|insert at the start inside the region|
-|`append`|`chunk(@region)?`|insert at the end inside the region|
+|`replace`|`chunk#CRC`, `chunk#CRC~`, or `chunk#CRC^`|rewrite the addressed region|
+|`before`|`chunk`, `chunk~`, or `chunk^`|insert before the region span|
+|`after`|`chunk`, `chunk~`, or `chunk^`|insert after the region span|
+|`prepend`|`chunk`, `chunk~`, or `chunk^`|insert at the start inside the region|
+|`append`|`chunk`, `chunk~`, or `chunk^`|insert at the end inside the region|
 </ops>
 
 <examples>
@@ -137,9 +136,9 @@ function makeCounter(start: number): Counter {
 }
 ```
 
-**Replace a method body** (`@body`):
+**Replace a method body** (`~`):
 ```
-{ "sel": "class_Counter.fn_increment#NQWY@body", "op": "replace", "content": "this.value += 1;\nconsole.log('incremented to', this.value);\n" }
+{ "sel": "class_Counter.fn_increment#NQWY~", "op": "replace", "content": "this.value += 1;\nconsole.log('incremented to', this.value);\n" }
 ```
 Result — only the body changes, signature and braces are kept:
 ```
@@ -149,9 +148,9 @@ Result — only the body changes, signature and braces are kept:
   }
 ```
 
-**Replace a function header** (`@head` — signature and doc comment):
+**Replace a function header** (`^` — signature and doc comment):
 ```
-{ "sel": "fn_createCounter#PQQY@head", "op": "replace", "content": "/** Creates a counter with the given start value. */\nfunction createCounter(initial: number, label?: string): Counter {\n" }
+{ "sel": "fn_createCounter#PQQY^", "op": "replace", "content": "/** Creates a counter with the given start value. */\nfunction createCounter(initial: number, label?: string): Counter {\n" }
 ```
 Result — adds a doc comment and updates the signature, body untouched:
 ```
@@ -197,9 +196,9 @@ function isActive(s: Status): boolean {
 function createCounter(initial: number): Counter {
 ```
 
-**Prepend inside a container** (`@body` + `prepend`):
+**Prepend inside a container** (`~` + `prepend`):
 ```
-{ "sel": "class_Counter@body", "op": "prepend", "content": "label: string = 'default';\n\n" }
+{ "sel": "class_Counter~", "op": "prepend", "content": "label: string = 'default';\n\n" }
 ```
 Result — a new field is added at the top of the class body, before existing members:
 ```
@@ -209,12 +208,12 @@ class Counter {
   value: number = 0;
 ```
 
-**Append inside a container** (`@body` + `append`):
+**Append inside a container** (`~` + `append`):
 ~~~json
 {{#if chunkAutoIndent}}
-{ "sel": "class_Counter@body", "op": "append", "content": "\nreset(): void {\n\tthis.value = 0;\n}\n" }
+{ "sel": "class_Counter~", "op": "append", "content": "\nreset(): void {\n\tthis.value = 0;\n}\n" }
 {{else}}
-{ "sel": "class_Counter@body", "op": "append", "content": "\nreset(): void {\n  this.value = 0;\n}\n" }
+{ "sel": "class_Counter~", "op": "append", "content": "\nreset(): void {\n  this.value = 0;\n}\n" }
 {{/if}}
 ~~~
 Result — a new method is added at the end of the class body, before the closing `}`:
@@ -241,8 +240,8 @@ Result — the method is removed from the class.
   - Match the file's real indentation characters in your snippet. The tool preserves your literal tabs/spaces after adding the target region's base indent.
 {{/if}}
   - Do NOT include the chunk's base indentation — only indent relative to the region's opening level.
-  - For `@body` of a function: write at column 0, e.g. `"return x;\n"`. The tool adds the correct base indent.
-  - For `@head`: write at the chunk's own depth. A class member's head uses `"/** doc */\nstart(): void {"`.
+  - For `~` of a function: write at column 0, and use `\t` for *relative* nesting. Flat body: `"return x;\n"`. Nested body: `"if (cond) {\n\treturn x;\n}\n"` — the `if` is at column 0, the `return` is one tab in, and the tool adds the method's base indent to both.
+  - For `^`: write at the chunk's own depth. A class member's head uses `"/** doc */\nstart(): void {"`.
 {{#if chunkAutoIndent}}
   - For a top-level item: start at zero indent. Write `"function foo() {\n\treturn 1;\n}\n"`.
 {{else}}

package/src/prompts/tools/read-chunk.md

@@ -2,13 +2,15 @@ Reads files using syntax-aware chunks.
 
 <instruction>
 - `path` — file path or URL; may include `:selector` suffix
-- `sel` — optional selector: `class_Foo`, `class_Foo.fn_bar#ABCD@body`, `?`, `L50`, `L50-L120`, or `raw`
+- `sel` — optional selector: `class_Foo`, `class_Foo.fn_bar#ABCD~`, `?`, `L50`, `L50-L120`, or `raw`
 - `timeout` — seconds, for URLs only
 
 Each opening anchor `[< full.chunk.path#CCCC ]` in the default output identifies a chunk. Use `full.chunk.path#CCCC` as-is to read truncated chunks.
 If you need a canonical target list, run `read(path="file", sel="?")`. That listing shows chunk paths with CRCs.
 Line numbers in the gutter are absolute file line numbers.
 
+`L20` (single line, no explicit end) is shorthand for `L20` to end-of-file. Use `L20-L20` for a one-line window.
+
 {{#if chunkAutoIndent}}
 Chunk reads normalize leading indentation so copied content round-trips cleanly into chunk edits.
 {{else}}
@@ -20,4 +22,5 @@ Chunk trees: JS, TS, TSX, Python, Rust, Go. Others use blank-line fallback.
 
 <critical>
 - **MUST** `read` before editing — never invent chunk names or CRCs.
+    - Chunk names are truncated (e.g., `handleRequest` becomes `fn_handleRequ`). Always copy chunk paths from `read` or `?` output — never construct them from source identifiers.
 </critical>

package/src/session/agent-session.ts

@@ -997,6 +997,16 @@ export class AgentSession {
 			this.#lastAssistantMessage = undefined;
 			if (!msg) return;
 
+			// Invalidate GitHub Copilot credentials on auth failure so stale tokens
+			// aren't reused on the next request
+			if (
+				msg.stopReason === "error" &&
+				msg.provider === "github-copilot" &&
+				msg.errorMessage?.includes("GitHub Copilot authentication failed")
+			) {
+				await this.#modelRegistry.authStorage.remove("github-copilot");
+			}
+
 			if (this.#skipPostTurnMaintenanceAssistantTimestamp === msg.timestamp) {
 				this.#skipPostTurnMaintenanceAssistantTimestamp = undefined;
 				return;

package/src/session/compaction/compaction.ts

@@ -761,7 +761,7 @@ function buildOpenAiNativeHistory(
 					if (!msgId) {
 						msgId = `msg_${msgIndex}`;
 					} else if (msgId.length > 64) {
-						msgId = `msg_${Bun.hash.xxHash64(msgId).toString(36)}`;
+						msgId = `msg_${Bun.hash(msgId).toString(36)}`;
 					}
 					input.push({
 						type: "message",

package/src/tools/browser.ts

@@ -501,6 +501,83 @@ export interface ReadableResult {
 	markdown?: string;
 }
 
+type ReadableFormat = "text" | "markdown";
+
+/** Trim to non-empty string or undefined. */
+function normalize(text: string | null | undefined): string | undefined {
+	const trimmed = text?.trim();
+	return trimmed || undefined;
+}
+
+/**
+ * Extract readable content from raw HTML.
+ * Tries Readability (article-isolation scoring) first, then falls back to a
+ * CSS selector chain over the same pre-parsed DOM. Returns null if neither
+ * path yields usable content.
+ */
+export function extractReadableFromHtml(html: string, url: string, format: ReadableFormat): ReadableResult | null {
+	const { document } = parseHTML(html);
+
+	// --- Primary: Readability article extraction ---
+	const article = new Readability(document).parse();
+	if (article) {
+		const result = toReadableResult(url, format, article.textContent, article.content, {
+			title: article.title,
+			byline: article.byline,
+			excerpt: article.excerpt,
+			length: article.length,
+		});
+		if (result) return result;
+	}
+
+	// --- Fallback: CSS selector chain ---
+	const candidates = [
+		document.querySelector("[data-pagefind-body]"),
+		document.querySelector("main article"),
+		document.querySelector("article"),
+		document.querySelector("main"),
+		document.querySelector("[role='main']"),
+		document.body,
+	];
+	for (const el of candidates) {
+		if (!el) continue;
+		const innerHTML = el.innerHTML?.trim();
+		const textContent = el.textContent?.trim();
+		if (!innerHTML || !textContent) continue;
+		const result = toReadableResult(url, format, textContent, innerHTML, {
+			title: document.title,
+			excerpt: textContent.slice(0, 240),
+			length: textContent.length,
+		});
+		if (result) return result;
+	}
+
+	return null;
+}
+
+/** Shared builder for both extraction paths. */
+function toReadableResult(
+	url: string,
+	format: ReadableFormat,
+	textContent: string | null | undefined,
+	htmlContent: string | null | undefined,
+	meta: { title?: string | null; byline?: string | null; excerpt?: string | null; length?: number | null },
+): ReadableResult | null {
+	const text = normalize(textContent);
+	const markdown = format === "markdown" ? (normalize(htmlToBasicMarkdown(htmlContent ?? "")) ?? text) : undefined;
+	const normalizedText = format === "text" ? text : undefined;
+	if (!normalizedText && !markdown) return null;
+	return {
+		url,
+		title: normalize(meta.title),
+		byline: normalize(meta.byline),
+		excerpt: normalize(meta.excerpt),
+		contentLength: meta.length ?? text?.length ?? markdown?.length ?? 0,
+		text: normalizedText,
+		markdown,
+	};
+}
+
 function ensureParam<T>(value: T | undefined, name: string, action: string): T {
 	if (value === undefined || value === null || value === "") {
 		throw new ToolError(`Missing required parameter '${name}' for action '${action}'.`);
@@ -1365,26 +1442,13 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 					const format = params.format ?? "markdown";
 					const html = (await untilAborted(signal, () => page.content())) as string;
 					const url = page.url();
-					const { document } = parseHTML(html);
-					const reader = new Readability(document);
-					const article = reader.parse();
-					if (!article) {
+					const readable = extractReadableFromHtml(html, url, format);
+					if (!readable) {
 						throw new ToolError("Readable content not found");
 					}
-					const markdown = format === "markdown" ? htmlToBasicMarkdown(article.content ?? "") : undefined;
-					const text = format === "text" ? (article.textContent ?? "") : undefined;
-					const readable: ReadableResult = {
-						url,
-						title: article.title ?? undefined,
-						byline: article.byline ?? undefined,
-						excerpt: article.excerpt ?? undefined,
-						contentLength: article.length ?? article.textContent?.length ?? 0,
-						text,
-						markdown,
-					};
 					details.url = url;
 					details.readable = readable;
-					details.result = format === "markdown" ? (markdown ?? "") : (text ?? "");
+					details.result = format === "markdown" ? (readable.markdown ?? "") : (readable.text ?? "");
 					return toolResult(details)
 						.text(JSON.stringify(readable, null, 2))
 						.done();
@@ -1407,13 +1471,12 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 						buffer = (await untilAborted(signal, () => page.screenshot({ type: "png", fullPage }))) as Buffer;
 					}
 
-					// Compress for API content (same as pasted images)
-					// NOTE: screenshots can be deceptively large (especially PNG) even at modest resolutions,
-					// and tool results are immediately embedded in the next LLM request.
-					// Use a tighter budget than the global per-image limit to avoid 413 request_too_large.
+					// Compress aggressively for API content — screenshots are the most
+					// frequent image source and land directly in the next LLM request.
+					// 1024px is plenty for OCR/UI inspection; 150KB keeps payloads lean.
 					const resized = await resizeImage(
 						{ type: "image", data: buffer.toBase64(), mimeType: "image/png" },
-						{ maxBytes: 0.75 * 1024 * 1024 },
+						{ maxWidth: 1024, maxHeight: 1024, maxBytes: 150 * 1024, jpegQuality: 70 },
 					);
 					// Resolve destination: user-defined path > screenshotDir (auto-named) > temp file.
 					const screenshotDir = (() => {

package/src/tools/fetch.ts

@@ -84,7 +84,7 @@ const IMAGE_MIME_BY_EXTENSION = new Map<string, string>([
 ]);
 const SUPPORTED_INLINE_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 const MAX_INLINE_IMAGE_SOURCE_BYTES = 20 * 1024 * 1024;
-const MAX_INLINE_IMAGE_OUTPUT_BYTES = 0.75 * 1024 * 1024;
+const MAX_INLINE_IMAGE_OUTPUT_BYTES = 300 * 1024;
 
 // =============================================================================
 // Utilities

package/src/tools/find.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { FileType, type GlobMatch, glob } from "@oh-my-pi/pi-natives";
+import * as natives from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
@@ -124,46 +124,15 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				throw new ToolError("Limit must be a positive number");
 			}
 			const includeHidden = hidden ?? true;
-
-			// 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: ${scopePath}`);
-				}
-
-				if (!hasGlob && this.#customOps.stat) {
-					const stat = await this.#customOps.stat(searchPath);
-					if (stat.isFile()) {
-						const files = [scopePath];
-						const details: FindToolDetails = {
-							scopePath,
-							fileCount: 1,
-							files,
-							truncated: false,
-						};
-						return toolResult(details).text(files.join("\n")).done();
-					}
-				}
-
-				const results = await this.#customOps.glob(globPattern, searchPath, {
-					ignore: ["**/node_modules/**", "**/.git/**"],
-					limit: effectiveLimit,
-				});
-
-				if (results.length === 0) {
+			const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
+			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+			const buildResult = (files: string[]): AgentToolResult<FindToolDetails> => {
+				if (files.length === 0) {
 					const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
 					return toolResult(details).text("No files found matching pattern").done();
 				}
 
-				// Relativize paths
-				const relativized = results.map(p => {
-					if (p.startsWith(searchPath)) {
-						return p.slice(searchPath.length + 1);
-					}
-					return path.relative(searchPath, p);
-				});
-
-				const listLimit = applyListLimit(relativized, { limit: effectiveLimit });
+				const listLimit = applyListLimit(files, { limit: effectiveLimit });
 				const limited = listLimit.items;
 				const limitMeta = listLimit.meta;
 				const rawOutput = limited.join("\n");
@@ -186,6 +155,32 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				}
 
 				return resultBuilder.done();
+			};
+
+			if (this.#customOps?.glob) {
+				if (!(await this.#customOps.exists(searchPath))) {
+					throw new ToolError(`Path not found: ${scopePath}`);
+				}
+
+				if (!hasGlob && this.#customOps.stat) {
+					const stat = await this.#customOps.stat(searchPath);
+					if (stat.isFile()) {
+						return buildResult([scopePath]);
+					}
+				}
+
+				const results = await this.#customOps.glob(globPattern, searchPath, {
+					ignore: ["**/node_modules/**", "**/.git/**"],
+					limit: effectiveLimit,
+				});
+				const relativized = results.map(p => {
+					if (p.startsWith(searchPath)) {
+						return p.slice(searchPath.length + 1);
+					}
+					return path.relative(searchPath, p);
+				});
+
+				return buildResult(relativized);
 			}
 
 			let searchStat: fs.Stats;
@@ -199,20 +194,13 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			}
 
 			if (!hasGlob && searchStat.isFile()) {
-				const files = [scopePath];
-				const details: FindToolDetails = {
-					scopePath,
-					fileCount: 1,
-					files,
-					truncated: false,
-				};
-				return toolResult(details).text(files.join("\n")).done();
+				return buildResult([scopePath]);
 			}
 			if (!searchStat.isDirectory()) {
 				throw new ToolError(`Path is not a directory: ${searchPath}`);
 			}
 
-			let matches: GlobMatch[];
+			let matches: natives.GlobMatch[];
 			const onUpdateMatches: string[] = [];
 			const updateIntervalMs = 200;
 			let lastUpdate = 0;
@@ -233,27 +221,25 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				});
 			};
 			const onMatch = onUpdate
-				? (err: Error | null, match: GlobMatch | null) => {
+				? (err: Error | null, match: natives.GlobMatch | null) => {
 						if (err || signal?.aborted || !match) return;
 						let relativePath = match.path;
 						if (!relativePath) return;
-						if (match.fileType === FileType.Dir && !relativePath.endsWith("/")) {
+						if (match.fileType === natives.FileType.Dir && !relativePath.endsWith("/")) {
 							relativePath += "/";
 						}
 						onUpdateMatches.push(relativePath);
 						emitUpdate();
 					}
 				: undefined;
-			const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
-			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 
 			const doGlob = async (useGitignore: boolean) =>
 				untilAborted(combinedSignal, () =>
-					glob(
+					natives.glob(
 						{
 							pattern: globPattern,
 							path: searchPath,
-							fileType: FileType.File,
+							fileType: natives.FileType.File,
 							hidden: includeHidden,
 							maxResults: effectiveLimit,
 							sortByMtime: true,
@@ -266,7 +252,6 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 			try {
 				let result = await doGlob(true);
-				// If gitignore filtering yielded nothing, retry without it
 				if (result.matches.length === 0) {
 					result = await doGlob(false);
 				}
@@ -282,12 +267,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				throw error;
 			}
 
-			if (matches.length === 0) {
-				const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
-				return toolResult(details).text("No files found matching pattern").done();
-			}
 			const relativized: string[] = [];
-
 			for (const match of matches) {
 				throwIfAborted(signal);
 				const line = match.path;
@@ -297,9 +277,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 				const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
 				let relativePath = line;
-
-				const isDirectory = match.fileType === FileType.Dir;
-
+				const isDirectory = match.fileType === natives.FileType.Dir;
 				if ((isDirectory || hadTrailingSlash) && !relativePath.endsWith("/")) {
 					relativePath += "/";
 				}
@@ -307,39 +285,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				relativized.push(relativePath);
 			}
 
-			if (relativized.length === 0) {
-				const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
-				return toolResult(details).text("No files found matching pattern").done();
-			}
-
-			// Results are already sorted by mtime from native (sortByMtime: true)
-
-			const listLimit = applyListLimit(relativized, { limit: effectiveLimit });
-			const limited = listLimit.items;
-			const limitMeta = listLimit.meta;
-
-			// Apply byte truncation (no line limit since we already have result limit)
-			const rawOutput = limited.join("\n");
-			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-
-			const resultOutput = truncation.content;
-			const details: FindToolDetails = {
-				scopePath,
-				fileCount: limited.length,
-				files: limited,
-				truncated: Boolean(limitMeta.resultLimit || truncation.truncated),
-				resultLimitReached: limitMeta.resultLimit?.reached,
-				truncation: truncation.truncated ? truncation : undefined,
-			};
-
-			const resultBuilder = toolResult(details)
-				.text(resultOutput)
-				.limits({ resultLimit: limitMeta.resultLimit?.reached });
-			if (truncation.truncated) {
-				resultBuilder.truncation(truncation, { direction: "head" });
-			}
-
-			return resultBuilder.done();
+			return buildResult(relativized);
 		});
 	}
 }

package/src/tools/gemini-image.ts

@@ -728,6 +728,7 @@ export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageTo
 					headers: {
 						"Content-Type": "application/json",
 						Authorization: `Bearer ${apiKey.apiKey}`,
+						"X-Title": "Oh-My-Pi",
 					},
 					body: JSON.stringify(requestBody),
 					signal: requestSignal,