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

package/src/tools/browser/launch.ts

@@ -3,7 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { $which, getPuppeteerDir, logger } from "@oh-my-pi/pi-utils";
 import * as browsers from "@puppeteer/browsers";
-import type { Browser, CDPSession, Page, default as Puppeteer } from "puppeteer-core";
+import type { Browser, CDPSession, Page, default as Puppeteer, Target } from "puppeteer-core";
 import { PUPPETEER_REVISIONS } from "puppeteer-core/internal/revisions.js";
 import stealthTamperingScript from "../puppeteer/00_stealth_tampering.txt" with { type: "text" };
 import stealthActivityScript from "../puppeteer/01_stealth_activity.txt" with { type: "text" };
@@ -30,13 +30,15 @@ export const DEFAULT_VIEWPORT = { width: 1365, height: 768, deviceScaleFactor: 1
  * connection dropped, etc.).
  */
 export const BROWSER_PROTOCOL_TIMEOUT_MS = 60_000;
-export const STEALTH_IGNORE_DEFAULT_ARGS = [
+const STEALTH_IGNORE_DEFAULT_ARGS = [
 	"--disable-extensions",
 	"--disable-default-apps",
 	"--disable-component-extensions-with-background-pages",
 ];
-export const STEALTH_ACCEPT_LANGUAGE = "en-US,en";
+const STEALTH_ACCEPT_LANGUAGE = "en-US,en";
 
+const USER_AGENT_TARGET_TIMEOUT_MS = 5_000;
+const USER_AGENT_TARGET_TYPES = new Set(["page", "webview", "background_page"]);
 const PUPPETEER_SOURCE_URL_SUFFIX = "//# sourceURL=__puppeteer_evaluation_script__";
 
 /**
@@ -82,7 +84,7 @@ export async function loadPuppeteerInWorker(safeDir: string): Promise<typeof Pup
  * The browser is cached under ~/.omp/puppeteer (getPuppeteerDir).
  */
 let chromiumExecutablePromise: Promise<string | undefined> | undefined;
-export async function ensureChromiumExecutable(): Promise<string | undefined> {
+async function ensureChromiumExecutable(): Promise<string | undefined> {
 	const sysChrome = resolveSystemChromium();
 	if (sysChrome) return sysChrome;
 	const envPath = process.env.PUPPETEER_EXECUTABLE_PATH;
@@ -138,7 +140,7 @@ export async function ensureChromiumExecutable(): Promise<string | undefined> {
 	return chromiumExecutablePromise;
 }
 
-let _resolvedChromium: string | null | undefined; // undefined = unchecked; null = not found
+let resolvedChromium: string | null | undefined; // undefined = unchecked; null = not found
 
 function isExecutableFile(p: string): boolean {
 	try {
@@ -209,19 +211,19 @@ function systemChromiumCandidates(): string[] {
 	return candidates;
 }
 
-export function resolveSystemChromium(): string | undefined {
-	if (_resolvedChromium !== undefined) return _resolvedChromium ?? undefined;
+function resolveSystemChromium(): string | undefined {
+	if (resolvedChromium !== undefined) return resolvedChromium ?? undefined;
 	const seen = new Set<string>();
 	for (const candidate of systemChromiumCandidates()) {
 		if (!candidate || seen.has(candidate)) continue;
 		seen.add(candidate);
 		if (isExecutableFile(candidate)) {
-			_resolvedChromium = candidate;
+			resolvedChromium = candidate;
 			logger.debug("Using system Chrome/Chromium", { path: candidate });
 			return candidate;
 		}
 	}
-	_resolvedChromium = null;
+	resolvedChromium = null;
 	return undefined;
 }
 
@@ -463,6 +465,7 @@ export interface UserAgentSession {
 async function configureUserAgentTargets(
 	browser: Browser,
 	state: { browserSession: CDPSession | null; override: UserAgentOverride },
+	targetTimeoutMs = USER_AGENT_TARGET_TIMEOUT_MS,
 ): Promise<void> {
 	if (!state.browserSession) {
 		state.browserSession = await browser.target().createCDPSession();
@@ -471,23 +474,72 @@ async function configureUserAgentTargets(
 			waitForDebuggerOnStart: false,
 			flatten: true,
 		});
-		state.browserSession.on("Target.attachedToTarget", async (event: { sessionId: string }) => {
-			const connection = state.browserSession?.connection();
-			const session = connection?.session(event.sessionId);
-			if (!session) return;
-			await sendUserAgentOverride(wrapSession(session), state.override);
-		});
+		state.browserSession.on(
+			"Target.attachedToTarget",
+			async (event: { sessionId: string; targetInfo?: { type?: string } }) => {
+				if (!targetInfoSupportsUserAgentOverride(event.targetInfo)) return;
+				const connection = state.browserSession?.connection();
+				const session = connection?.session(event.sessionId);
+				if (!session) return;
+				await withSoftTimeout(
+					sendUserAgentOverride(wrapSession(session), state.override),
+					targetTimeoutMs,
+					"new target user-agent override",
+				);
+			},
+		);
 	}
 
-	const targets = browser.targets();
+	const targets = browser.targets().filter(targetSupportsUserAgentOverride);
 	await Promise.all(
 		targets.map(async target => {
-			const session = await target.createCDPSession();
-			await sendUserAgentOverride(wrapSession(session), state.override);
+			await withSoftTimeout(
+				applyTargetUserAgentOverride(target, state.override),
+				targetTimeoutMs,
+				"target user-agent override",
+			);
 		}),
 	);
 }
 
+function targetSupportsUserAgentOverride(target: Target): boolean {
+	return targetInfoSupportsUserAgentOverride({ type: target.type() });
+}
+
+function targetInfoSupportsUserAgentOverride(targetInfo: { type?: string } | undefined): boolean {
+	return Boolean(targetInfo?.type && USER_AGENT_TARGET_TYPES.has(targetInfo.type));
+}
+
+async function applyTargetUserAgentOverride(target: Target, override: UserAgentOverride): Promise<void> {
+	const session = await target.createCDPSession();
+	try {
+		await sendUserAgentOverride(wrapSession(session), override);
+	} finally {
+		await session.detach().catch(() => undefined);
+	}
+}
+
+async function withSoftTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T | undefined> {
+	let timeout: NodeJS.Timeout | undefined;
+	const timeoutPromise = new Promise<undefined>(resolve => {
+		timeout = setTimeout(() => {
+			logger.debug(`Timed out applying ${label}`);
+			resolve(undefined);
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([
+			promise.catch(error => {
+				logger.debug(`Failed to apply ${label}`, { error: error instanceof Error ? error.message : String(error) });
+				return undefined;
+			}),
+			timeoutPromise,
+		]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+
 async function injectStealthScripts(page: Page): Promise<void> {
 	const scripts = [
 		stealthTamperingScript,
@@ -574,3 +626,14 @@ export async function applyStealthPatches(
 	state.browserSession = targetState.browserSession;
 	await injectStealthScripts(page);
 }
+
+export function targetSupportsUserAgentOverrideForTest(target: Target): boolean {
+	return targetSupportsUserAgentOverride(target);
+}
+export async function configureUserAgentTargetsForTest(
+	browser: Browser,
+	state: { browserSession: CDPSession | null; override: UserAgentOverride },
+	targetTimeoutMs?: number,
+): Promise<void> {
+	await configureUserAgentTargets(browser, state, targetTimeoutMs);
+}

package/src/tools/browser/registry.ts

@@ -26,10 +26,6 @@ export interface BrowserHandle {
 
 const browsers = new Map<string, BrowserHandle>();
 
-export function listBrowsers(): BrowserHandle[] {
-	return [...browsers.values()];
-}
-
 function browserKey(kind: BrowserKind): string {
 	switch (kind.kind) {
 		case "headless":
@@ -166,7 +162,7 @@ export async function releaseBrowser(handle: BrowserHandle, opts: { kill: boolea
 	}
 }
 
-export async function disposeBrowserHandle(handle: BrowserHandle, opts: { kill: boolean }): Promise<void> {
+async function disposeBrowserHandle(handle: BrowserHandle, opts: { kill: boolean }): Promise<void> {
 	if (handle.kind.kind === "headless") {
 		if (handle.browser.connected) {
 			try {

package/src/tools/browser/tab-supervisor.ts

@@ -30,6 +30,7 @@ import type {
 interface WorkerHandle {
 	send(msg: WorkerInbound, transferList?: Transferable[]): void;
 	onMessage(handler: (msg: WorkerOutbound) => void): () => void;
+	onError(handler: (error: Error) => void): () => void;
 	terminate(): Promise<void>;
 	readonly mode: "worker" | "inline";
 }
@@ -89,10 +90,6 @@ export function getTab(name: string): TabSession | undefined {
 	return tabs.get(name);
 }
 
-export function listTabs(): TabSession[] {
-	return [...tabs.values()];
-}
-
 export async function acquireTab(
 	name: string,
 	browser: BrowserHandle,
@@ -124,23 +121,14 @@ export async function acquireTab(
 
 	const initPayload = await buildInitPayload(browser, opts);
 	const worker = await spawnTabWorker();
-	const { promise, resolve, reject } = Promise.withResolvers<ReadyInfo>();
-	const unlisten = worker.onMessage(msg => {
-		if (msg.type === "ready") resolve(msg.info);
-		else if (msg.type === "init-failed") reject(errorFromPayload(msg.error));
-		else if (msg.type === "log") logWorkerMessage(msg);
-	});
 	let info: ReadyInfo;
 	try {
-		worker.send({ type: "init", payload: initPayload });
-		info = await raceWithTimeout(promise, opts.timeoutMs + GRACE_MS, "Timed out initializing browser tab worker");
+		info = await initializeTabWorker(worker, initPayload, opts.timeoutMs + GRACE_MS);
 	} catch (error) {
-		unlisten();
 		await worker.terminate().catch(() => undefined);
 		if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
 		throw error;
 	}
-	unlisten();
 
 	holdBrowser(browser);
 	const tab: TabSession = {
@@ -477,6 +465,17 @@ function wrapBunWorker(worker: Worker): WorkerHandle {
 			worker.addEventListener("message", wrap);
 			return () => worker.removeEventListener("message", wrap);
 		},
+		onError(handler) {
+			const onError = (event: ErrorEvent): void => handler(errorFromWorkerEvent(event));
+			const onMessageError = (event: MessageEvent): void =>
+				handler(new ToolError(`Tab worker message error: ${String(event.data)}`));
+			worker.addEventListener("error", onError);
+			worker.addEventListener("messageerror", onMessageError);
+			return () => {
+				worker.removeEventListener("error", onError);
+				worker.removeEventListener("messageerror", onMessageError);
+			};
+		},
 		async terminate() {
 			worker.terminate();
 		},
@@ -515,6 +514,44 @@ async function spawnInlineWorker(): Promise<WorkerHandle> {
 			hostListeners.add(handler);
 			return () => hostListeners.delete(handler);
 		},
+		onError: () => () => {},
 		async terminate() {},
 	};
 }
+
+async function initializeTabWorker(
+	worker: WorkerHandle,
+	payload: WorkerInitPayload,
+	timeoutMs: number,
+): Promise<ReadyInfo> {
+	const { promise, resolve, reject } = Promise.withResolvers<ReadyInfo>();
+	const unlisten = worker.onMessage(msg => {
+		if (msg.type === "ready") resolve(msg.info);
+		else if (msg.type === "init-failed") reject(errorFromPayload(msg.error));
+		else if (msg.type === "log") logWorkerMessage(msg);
+	});
+	const unlistenError = worker.onError(error => {
+		reject(new ToolError(`Tab worker failed during startup: ${error.message}`));
+	});
+	try {
+		worker.send({ type: "init", payload });
+		return await raceWithTimeout(promise, timeoutMs, "Timed out initializing browser tab worker");
+	} finally {
+		unlisten();
+		unlistenError();
+	}
+}
+
+export function initializeTabWorkerForTest(
+	worker: WorkerHandle,
+	payload: WorkerInitPayload,
+	timeoutMs: number,
+): Promise<ReadyInfo> {
+	return initializeTabWorker(worker, payload, timeoutMs);
+}
+
+function errorFromWorkerEvent(event: ErrorEvent): Error {
+	if (event.error instanceof Error) return event.error;
+	if (event.message) return new Error(event.message);
+	return new Error("Unknown tab worker error");
+}

package/src/tools/conflict-detect.ts

@@ -240,7 +240,7 @@ export function getConflictHistory(session: ToolSession): ConflictHistory {
 	return session.conflictHistory;
 }
 
-/** A side of a conflict block that `read conflict://N/<scope>` can render. */
+/** A side of a conflict block that the `read` tool can render via `conflict://N/<scope>`. */
 export type ConflictScope = "ours" | "theirs" | "base";
 
 const CONFLICT_SCOPES = new Set<ConflictScope>(["ours", "theirs", "base"]);
@@ -250,9 +250,19 @@ export interface ParsedConflictUri {
 	/** `"*"` selects every currently-registered conflict (bulk write only). */
 	id: number | "*";
 	scope?: ConflictScope;
+	/**
+	 * When `raw` was a malformed `<file-prefix>:conflict://…` path, the
+	 * stripped prefix is preserved here so callers can surface a gentle
+	 * "you don't need the file path" note. `undefined` for clean URIs.
+	 */
+	recoveredPrefix?: string;
 }
 
-const CONFLICT_URI_RE = /^conflict:\/\/(.+)$/;
+// Accept an optional `<prefix>:` before the scheme so paths like
+// `path/to/file.ts:conflict://3` (where the agent mixed the `:conflicts`
+// read selector with the `conflict://` scheme) still resolve. The prefix
+// is greedy so the LAST `:conflict://` wins for multi-colon inputs.
+const CONFLICT_URI_RE = /^(?:(.+):)?conflict:\/\/(.+)$/;
 
 /**
  * Parse a `conflict://<N>`, `conflict://<N>/<scope>`, or `conflict://*` URI.
@@ -269,7 +279,8 @@ const CONFLICT_URI_RE = /^conflict:\/\/(.+)$/;
 export function parseConflictUri(raw: string): ParsedConflictUri | null {
 	const match = raw.match(CONFLICT_URI_RE);
 	if (!match) return null;
-	const tail = match[1];
+	const recoveredPrefix = match[1];
+	const tail = match[2];
 	const slashIdx = tail.indexOf("/");
 	const idPart = slashIdx === -1 ? tail : tail.slice(0, slashIdx);
 	const scopePart = slashIdx === -1 ? undefined : tail.slice(slashIdx + 1);
@@ -280,7 +291,7 @@ export function parseConflictUri(raw: string): ParsedConflictUri | null {
 				`Invalid conflict URI '${raw}': wildcard 'conflict://*' does not accept a scope segment. Drop '/${scopePart}' or use a numeric id.`,
 			);
 		}
-		return { id: "*" };
+		return recoveredPrefix !== undefined ? { id: "*", recoveredPrefix } : { id: "*" };
 	}
 
 	if (!/^\d+$/.test(idPart)) {
@@ -303,7 +314,7 @@ export function parseConflictUri(raw: string): ParsedConflictUri | null {
 		scope = scopePart as ConflictScope;
 	}
 
-	return { id, scope };
+	return recoveredPrefix !== undefined ? { id, scope, recoveredPrefix } : { id, scope };
 }
 
 /**
@@ -440,7 +451,7 @@ function markerLine(prefix: string, label: string | undefined): string {
 }
 
 /**
- * Materialise a conflict block for `read conflict://<N>` (and its
+ * Materialise a conflict block for `conflict://<N>` reads (and their
  * `/ours` / `/theirs` / `/base` scopes).
  *
  * Returns:
@@ -534,7 +545,7 @@ export function formatConflictWarning(
 	if (partial) {
 		const hintPath = options.displayPath ?? "<file>";
 		out.push(
-			`⚠ ${entries.length} of ${total} unresolved ${word} visible in this window (run \`read ${hintPath}:conflicts\` for the full list).`,
+			`⚠ ${entries.length} of ${total} unresolved ${word} visible in this window (read \`${hintPath}:conflicts\` for the full list).`,
 		);
 	} else {
 		out.push(`⚠ ${total} unresolved ${word} detected`);
@@ -551,7 +562,7 @@ export function formatConflictWarning(
 	if (theirsLabel) out.push(`- theirs = ${theirsLabel}`);
 	if (anyBase) out.push(`- base = ${baseLabel ?? "(no label)"}`);
 	out.push(
-		'NOTICE: Inspect a block with `read conflict://<N>` (add `/ours` / `/theirs` / `/base` to render a single side). Resolve with `write({ path: "conflict://<N>", content })`, or bulk-resolve every registered conflict with `write({ path: "conflict://*", content })`. Writes replace the whole conflict region (markers + all sides).',
+		'NOTICE: Inspect a block by reading `conflict://<N>` (add `/ours` / `/theirs` / `/base` to render a single side). Resolve with `write({ path: "conflict://<N>", content })`, or bulk-resolve every registered conflict with `write({ path: "conflict://*", content })`. Writes replace the whole conflict region (markers + all sides).',
 	);
 	out.push(
 		'`content` shorthand: a line that is exactly `@ours` / `@theirs` / `@base` / `@both` expands to that recorded section. `@both` is ours-then-theirs with no separator. Lines that are not a token pass through verbatim, so `"// keep both\\n@ours\\n@theirs"` literally writes the comment, then ours, then theirs.',
@@ -592,7 +603,7 @@ export function formatConflictWarning(
 
 /**
  * Render a single-line-per-block index of every conflict in a file.
- * Used by `read <path>:conflicts` to give the agent a cheap overview
+ * Used by the `<path>:conflicts` read selector to give the agent a cheap overview
  * of a heavily-conflicted file without dumping every body.
  */
 export function formatConflictSummary(
@@ -614,7 +625,7 @@ export function formatConflictSummary(
 	if (theirsLabel) lines.push(`- theirs = ${theirsLabel}`);
 	if (anyBase) lines.push(`- base = ${baseLabel ?? "(no label)"}`);
 	lines.push(
-		'NOTICE: Bulk-resolve with `write({ path: "conflict://*", content })`, or address a single block with `write({ path: "conflict://<N>", content })`. Inspect a block with `read conflict://<N>` (add `/ours` / `/theirs` / `/base` for a single side).',
+		'NOTICE: Bulk-resolve with `write({ path: "conflict://*", content })`, or address a single block with `write({ path: "conflict://<N>", content })`. Inspect a block by reading `conflict://<N>` (add `/ours` / `/theirs` / `/base` for a single side).',
 	);
 	lines.push(
 		"`content` shorthand: `@ours` / `@theirs` / `@base` / `@both` lines expand to the recorded sections; `@both` = ours-then-theirs. Non-token lines pass through verbatim.",

package/src/tools/eval.ts

@@ -16,7 +16,7 @@ import evalDescription from "../prompts/tools/eval.md" with { type: "text" };
 import { DEFAULT_MAX_BYTES, OutputSink, type OutputSummary, TailBuffer } from "../session/streaming-output";
 import { getTreeBranch, getTreeContinuePrefix, renderCodeCell } from "../tui";
 import { resolveEvalBackends, type ToolSession } from ".";
-import { formatStyledTruncationWarning } from "./output-meta";
+import { formatStyledTruncationWarning, resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "./output-meta";
 import { formatTitle, replaceTabs, shortenPath, truncateToWidth, wrapBrackets } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -358,6 +358,8 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 				outputSink = new OutputSink({
 					artifactPath,
 					artifactId,
+					headBytes: resolveOutputSinkHeadBytes(session.settings),
+					maxColumns: resolveOutputMaxColumns(session.settings),
 					onChunk: chunk => {
 						appendTail(chunk);
 						pushUpdate();

package/src/tools/fetch.ts

@@ -22,7 +22,7 @@ import { finalizeOutput, loadPage, looksLikeHtml, MAX_OUTPUT_CHARS } from "../we
 import { convertWithMarkit, fetchBinary } from "../web/scrapers/utils";
 import { applyListLimit } from "./list-limit";
 import { formatStyledArtifactReference, type OutputMeta } from "./output-meta";
-import { formatExpandHint, getDomain } from "./render-utils";
+import { formatExpandHint, getDomain, replaceTabs } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
@@ -1362,14 +1362,25 @@ export function renderReadUrlCall(
 
 /** Render URL read result with tree-based layout */
 export function renderReadUrlResult(
-	result: { content: Array<{ type: string; text?: string }>; details?: ReadUrlToolDetails },
+	result: { content: Array<{ type: string; text?: string }>; details?: ReadUrlToolDetails; isError?: boolean },
 	options: RenderResultOptions,
 	uiTheme: Theme = theme,
 ): Component {
 	const details = result.details;
 
-	if (!details) {
-		return new Text(uiTheme.fg("error", "No response data"), 0, 0);
+	if (result.isError || !details) {
+		const rawErrorText = result.content?.find(c => c.type === "text")?.text ?? "";
+		const errorText = (rawErrorText || "No response data").replace(/^Error:\s*/, "");
+		const urlText = details?.finalUrl ?? details?.url ?? "";
+		const description = urlText ? `${getDomain(urlText)}${urlText.replace(/^https?:\/\/[^/]+/, "")}` : undefined;
+		const header = renderStatusLine({ icon: "error", title: "Read", description }, uiTheme);
+		const errorLines = errorText.split("\n").map(line => uiTheme.fg("error", replaceTabs(line)));
+		const outputBlock = new CachedOutputBlock();
+		return {
+			render: (width: number) =>
+				outputBlock.render({ header, state: "error", sections: [{ lines: errorLines }], width }, uiTheme),
+			invalidate: () => outputBlock.invalidate(),
+		};
 	}
 
 	const domain = getDomain(details.finalUrl);

package/src/tools/find.ts

@@ -8,30 +8,30 @@ import { isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import type { Static } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { InternalUrlRouter } from "../internal-urls";
 import type { Theme } from "../modes/theme/theme";
 import findDescription from "../prompts/tools/find.md" with { type: "text" };
 import { type TruncationResult, truncateHead } from "../session/streaming-output";
-import {
-	Ellipsis,
-	Hasher,
-	type RenderCache,
-	renderFileList,
-	renderStatusLine,
-	renderTreeList,
-	truncateToWidth,
-} from "../tui";
+import { Ellipsis, renderFileList, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
 	formatPathRelativeToCwd,
+	hasGlobPathChars,
 	normalizePathLikeInput,
 	parseFindPattern,
 	partitionExistingPaths,
 	resolveExplicitFindPatterns,
 	resolveToCwd,
 } from "./path-utils";
-import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
+import {
+	createCachedComponent,
+	formatCount,
+	formatEmptyMessage,
+	formatErrorMessage,
+	PREVIEW_LIMITS,
+} from "./render-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
@@ -116,7 +116,23 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 		return untilAborted(signal, async () => {
 			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
-			const normalizedPatterns = paths.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
+			const rawPatterns = paths.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
+			const internalRouter = InternalUrlRouter.instance();
+			const normalizedPatterns: string[] = [];
+			for (const rawPattern of rawPatterns) {
+				if (!internalRouter.canHandle(rawPattern)) {
+					normalizedPatterns.push(rawPattern);
+					continue;
+				}
+				if (hasGlobPathChars(rawPattern)) {
+					throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPattern}`);
+				}
+				const resource = await internalRouter.resolve(rawPattern);
+				if (!resource.sourcePath) {
+					throw new ToolError(`Cannot find internal URL without a backing file: ${rawPattern}`);
+				}
+				normalizedPatterns.push(resource.sourcePath);
+			}
 			if (normalizedPatterns.some(pattern => pattern.length === 0)) {
 				throw new ToolError("`paths` must contain non-empty globs or paths");
 			}
@@ -383,30 +399,22 @@ export const findToolRenderer = {
 				},
 				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_LIST_LIMIT,
 							itemType: "file",
 							renderItem: line => uiTheme.fg("accent", line),
 						},
 						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 fileCount = details?.fileCount ?? 0;
@@ -449,28 +457,20 @@ export const findToolRenderer = {
 		}
 		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 fileLines = renderFileList(
 					{
 						files: files.map(entry => ({ path: entry, isDirectory: entry.endsWith("/") })),
-						expanded,
+						expanded: options.expanded,
 						maxCollapsed: COLLAPSED_LIST_LIMIT,
 					},
 					uiTheme,
 				);
-				const result = [header, ...fileLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
-				cached = { key, lines: result };
-				return result;
-			},
-			invalidate() {
-				cached = undefined;
+				return [header, ...fileLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
 			},
-		};
+		);
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/gh-renderer.ts

@@ -27,7 +27,6 @@ type GithubToolRenderArgs = {
 	run?: string;
 	branch?: string;
 	repo?: string;
-	issue?: string;
 	pr?: string | string[];
 	query?: string;
 };
@@ -40,9 +39,6 @@ const FALLBACK_WIDTH = 80;
 
 const OP_TITLES: Record<string, string> = {
 	repo_view: "GitHub Repo",
-	issue_view: "GitHub Issue",
-	pr_view: "GitHub PR",
-	pr_diff: "GitHub PR Diff",
 	pr_checkout: "GitHub PR Checkout",
 	pr_push: "GitHub PR Push",
 	search_issues: "GitHub Search Issues",
@@ -85,14 +81,6 @@ function buildOpMeta(args: GithubToolRenderArgs): string[] {
 	const meta: string[] = [];
 	const op = args.op;
 	switch (op) {
-		case "issue_view": {
-			const id = extractIssueId(args.issue);
-			if (id) meta.push(id);
-			if (args.repo) meta.push(args.repo);
-			break;
-		}
-		case "pr_view":
-		case "pr_diff":
 		case "pr_checkout":
 		case "pr_push": {
 			const id = formatPrIdentifier(args.pr);