@oh-my-pi/pi-coding-agent 14.2.1 → 14.3.0

package/src/internal-urls/pi-protocol.ts

@@ -45,7 +45,6 @@ export class PiProtocolHandler implements ProtocolHandler {
 			content,
 			contentType: "text/markdown",
 			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: "pi://",
 		};
 	}
 
@@ -78,7 +77,6 @@ export class PiProtocolHandler implements ProtocolHandler {
 			content,
 			contentType: "text/markdown",
 			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: `pi://${normalized}`,
 		};
 	}
 }

package/src/lsp/client.ts

@@ -484,7 +484,14 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 
 			// Reject any pending requests — the server is gone, they will never complete.
 			if (client.pendingRequests.size > 0) {
-				const stderr = proc.peekStderr().trim();
+				// Strip informational log lines (e.g. marksman's [INF]/[DBG] prefix)
+				// — they are startup noise, not actionable errors.
+				const rawStderr = proc.peekStderr().trim();
+				const stderr = rawStderr
+					.split("\n")
+					.filter(line => !/^\[\d{2}:\d{2}:\d{2} (?:INF|DBG|VRB)\]/.test(line))
+					.join("\n")
+					.trim();
 				const code = proc.exitCode;
 				const err = new Error(
 					stderr ? `LSP server exited (code ${code}): ${stderr}` : `LSP server exited unexpectedly (code ${code})`,

package/src/lsp/defaults.json

@@ -857,7 +857,8 @@
 		"rootMarkers": [
 			".marksman.toml",
 			".git"
-		]
+		],
+		"warmupTimeoutMs": 15000
 	},
 	"texlab": {
 		"command": "texlab",

package/src/modes/acp/acp-agent.ts

@@ -39,11 +39,14 @@ import {
 } from "@agentclientprotocol/sdk";
 import type { Model } from "@oh-my-pi/pi-ai";
 import { logger, VERSION } from "@oh-my-pi/pi-utils";
+import { disableProvider, enableProvider } from "../../capability";
+import { Settings } from "../../config/settings";
 import type { ExtensionUIContext } from "../../extensibility/extensions";
 import { runExtensionCompact } from "../../extensibility/extensions/compact-handler";
 import { loadSlashCommands } from "../../extensibility/slash-commands";
 import { MCPManager } from "../../mcp/manager";
 import type { MCPServerConfig } from "../../mcp/types";
+import { loadAllExtensions } from "../../modes/components/extensions/state-manager";
 import { theme } from "../../modes/theme/theme";
 import type { AgentSession, AgentSessionEvent } from "../../session/agent-session";
 import {
@@ -379,8 +382,79 @@ export class AcpAgent implements Agent {
 		}
 	}
 
-	async extMethod(_method: string, _params: { [key: string]: unknown }): Promise<{ [key: string]: unknown }> {
-		throw new Error("ACP extension methods are not implemented");
+	async extMethod(method: string, params: { [key: string]: unknown }): Promise<{ [key: string]: unknown }> {
+		switch (method) {
+			case "omp/sessions/listAll": {
+				const limit = typeof params.limit === "number" ? Math.max(1, Math.min(5000, params.limit as number)) : 1000;
+				const sessions = await SessionManager.listAll();
+				const sorted = sessions.sort((l, r) => r.modified.getTime() - l.modified.getTime()).slice(0, limit);
+				return {
+					sessions: sorted.map(s => this.#toSessionInfo(s)),
+					total: sessions.length,
+				};
+			}
+			case "omp/projects/list": {
+				const sessions = await SessionManager.listAll();
+				const buckets = new Map<
+					string,
+					{ cwd: string; sessionCount: number; lastActivityAt: number; lastTitle: string }
+				>();
+				for (const s of sessions) {
+					if (!s.cwd) continue;
+					const ts = s.modified.getTime();
+					const existing = buckets.get(s.cwd);
+					if (existing) {
+						existing.sessionCount += 1;
+						if (ts > existing.lastActivityAt) {
+							existing.lastActivityAt = ts;
+							existing.lastTitle = s.title ?? "";
+						}
+					} else {
+						buckets.set(s.cwd, {
+							cwd: s.cwd,
+							sessionCount: 1,
+							lastActivityAt: ts,
+							lastTitle: s.title ?? "",
+						});
+					}
+				}
+				const projects = Array.from(buckets.values()).sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+				return { projects, totalSessions: sessions.length };
+			}
+			case "omp/chats/byCwd": {
+				const cwd = typeof params.cwd === "string" ? (params.cwd as string) : undefined;
+				if (!cwd) throw new Error("cwd required");
+				const limit = typeof params.limit === "number" ? Math.max(1, Math.min(500, params.limit as number)) : 100;
+				const sessions = await SessionManager.list(cwd);
+				const sorted = sessions.sort((l, r) => r.modified.getTime() - l.modified.getTime()).slice(0, limit);
+				return { sessions: sorted.map(s => this.#toSessionInfo(s)) };
+			}
+			case "omp/usage": {
+				const [firstRecord] = this.#sessions.values();
+				const target = firstRecord?.session ?? this.#initialSession;
+				const reports = await target.fetchUsageReports();
+				return { reports: reports ?? [] };
+			}
+			case "omp/extensions": {
+				const cwd = typeof params.cwd === "string" ? (params.cwd as string) : undefined;
+				const sm = await Settings.init();
+				const disabledIds = (sm.get("disabledExtensions") as string[] | undefined) ?? [];
+				const extensions = await loadAllExtensions(cwd, disabledIds);
+				return { extensions: extensions as unknown as Array<{ [key: string]: unknown }> };
+			}
+			case "omp/extensions/toggle": {
+				const providerId = params.providerId;
+				if (typeof providerId !== "string") throw new Error("providerId required");
+				if (params.enabled === false) {
+					disableProvider(providerId);
+					return { enabled: false };
+				}
+				enableProvider(providerId);
+				return { enabled: true };
+			}
+			default:
+				throw new Error(`Unknown ACP ext method: ${method}`);
+		}
 	}
 
 	async extNotification(_method: string, _params: { [key: string]: unknown }): Promise<void> {}

package/src/modes/components/assistant-message.ts

@@ -1,8 +1,7 @@
 import type { AssistantMessage, ImageContent, Usage } from "@oh-my-pi/pi-ai";
 import { Container, Image, ImageProtocol, Markdown, Spacer, TERMINAL, Text } from "@oh-my-pi/pi-tui";
-import { formatNumber, logger } from "@oh-my-pi/pi-utils";
+import { formatNumber } from "@oh-my-pi/pi-utils";
 import { settings } from "../../config/settings";
-import { hasPendingMermaid, prerenderMermaid } from "../../modes/theme/mermaid-cache";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { resolveImageOptions } from "../../tools/render-utils";
 
@@ -12,7 +11,6 @@ import { resolveImageOptions } from "../../tools/render-utils";
 export class AssistantMessageComponent extends Container {
 	#contentContainer: Container;
 	#lastMessage?: AssistantMessage;
-	#prerenderInFlight = false;
 	#toolImagesByCallId = new Map<string, ImageContent[]>();
 	#usageInfo?: Usage;
 
@@ -85,34 +83,6 @@ export class AssistantMessageComponent extends Container {
 			this.#contentContainer.addChild(new Text(theme.fg("toolOutput", `[Image: ${image.mimeType}]`), 1, 0));
 		}
 	}
-	#triggerMermaidPrerender(message: AssistantMessage): void {
-		if (!TERMINAL.imageProtocol || this.#prerenderInFlight) return;
-
-		// Check if any text content has pending mermaid blocks
-		const hasPending = message.content.some(c => c.type === "text" && c.text.trim() && hasPendingMermaid(c.text));
-		if (!hasPending) return;
-
-		this.#prerenderInFlight = true;
-
-		// Fire off background prerender
-		void (async () => {
-			try {
-				for (const content of message.content) {
-					if (content.type === "text" && content.text.trim() && hasPendingMermaid(content.text)) {
-						prerenderMermaid(content.text);
-					}
-				}
-			} catch (error) {
-				logger.warn("Background mermaid prerender failed", {
-					error: error instanceof Error ? error.message : String(error),
-				});
-			} finally {
-				this.#prerenderInFlight = false;
-				// Invalidate to re-render with cached images
-				this.invalidate();
-			}
-		})();
-	}
 
 	updateContent(message: AssistantMessage): void {
 		this.#lastMessage = message;
@@ -120,9 +90,6 @@ export class AssistantMessageComponent extends Container {
 		// Clear content container
 		this.#contentContainer.clear();
 
-		// Trigger background mermaid pre-rendering if needed
-		this.#triggerMermaidPrerender(message);
-
 		const hasVisibleContent = message.content.some(
 			c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()),
 		);

package/src/modes/components/hook-editor.ts

@@ -136,7 +136,7 @@ export class HookEditorComponent extends Container {
 		const editorCmd = getEditorCommand();
 		if (!editorCmd) return;
 
-		const currentText = this.#editor.getText();
+		const currentText = this.#editor.getExpandedText();
 		try {
 			this.#tui.stop();
 			const result = await openInEditor(editorCmd, currentText);

package/src/modes/components/tool-execution.ts

@@ -14,14 +14,7 @@ import {
 	type TUI,
 } from "@oh-my-pi/pi-tui";
 import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
-import {
-	computeEditDiff,
-	computeHashlineDiff,
-	computePatchDiff,
-	type DiffError,
-	type DiffResult,
-	expandApplyPatchToEntries,
-} from "../../edit";
+import { EDIT_MODE_STRATEGIES, type EditMode, type PerFileDiffPreview } from "../../edit";
 import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
 import { BASH_DEFAULT_PREVIEW_LINES } from "../../tools/bash";
@@ -65,6 +58,12 @@ function isEditLikeToolName(toolName: string): boolean {
 	return toolName === "edit" || toolName === "apply_patch";
 }
 
+function resolveEditModeForTool(toolName: string, tool: AgentTool | undefined): EditMode | undefined {
+	if (toolName === "apply_patch") return "apply_patch";
+	if (toolName !== "edit") return undefined;
+	return (tool as { mode?: EditMode } | undefined)?.mode;
+}
+
 export interface ToolExecutionOptions {
 	showImages?: boolean; // default: true (only used if terminal supports images)
 	editFuzzyThreshold?: number;
@@ -111,9 +110,12 @@ export class ToolExecutionComponent extends Container {
 		isError?: boolean;
 		details?: any;
 	};
-	// Cached edit diff preview (computed when args arrive, before tool executes)
-	#editDiffPreview?: DiffResult | DiffError;
-	#editDiffArgsKey?: string; // Track which args the preview is for
+	// Edit preview state (single-file for legacy modes, multi-file for chunk)
+	#editMode?: EditMode;
+	#editDiffPreview?: PerFileDiffPreview[];
+	#editDiffScheduleTimer?: NodeJS.Timeout;
+	#editDiffAbort?: AbortController;
+	#editDiffLastArgsKey?: string;
 	// Cached converted images for Kitty protocol (which requires PNG), keyed by index
 	#convertedImages: Map<number, { data: string; mimeType: string }> = new Map();
 	// Spinner animation for partial task results
@@ -166,116 +168,98 @@ export class ToolExecutionComponent extends Container {
 			this.addChild(this.#contentText);
 		}
 
+		this.#editMode = resolveEditModeForTool(toolName, tool);
+
 		this.#updateDisplay();
+		this.#schedulePreviewDiff(0);
 	}
 
 	updateArgs(args: any, _toolCallId?: string): void {
 		this.#args = cloneToolArgs(args);
 		this.#updateSpinnerAnimation();
+		this.#schedulePreviewDiff();
 		this.#updateDisplay();
 	}
 
 	/**
 	 * Signal that args are complete (tool is about to execute).
-	 * This triggers diff computation for edit-like tools.
+	 * This triggers an immediate final diff computation for edit-like tools.
 	 */
 	setArgsComplete(_toolCallId?: string): void {
 		this.#argsComplete = true;
 		this.#updateSpinnerAnimation();
-		this.#maybeComputeEditDiff();
+		this.#schedulePreviewDiff(0);
 	}
 
 	/**
-	 * Compute edit diff preview when we have complete args.
-	 * This runs async and updates display when done.
+	 * Schedule a debounced compute of the streaming edit-diff preview.
+	 * `delayMs === 0` runs immediately (used on construction and on
+	 * `setArgsComplete`). All other calls coalesce to a trailing-edge timer.
 	 */
-	#maybeComputeEditDiff(): void {
-		if (!isEditLikeToolName(this.#toolName)) return;
-
-		const edits = this.#args?.edits;
-		if (!Array.isArray(edits) || edits.length === 0) {
-			if (this.#toolName !== "apply_patch" || typeof this.#args?.input !== "string") {
-				return;
-			}
-
-			const input = this.#args.input;
-			const argsKey = JSON.stringify({ input });
-			if (this.#editDiffArgsKey === argsKey) return;
-			this.#editDiffArgsKey = argsKey;
-
-			try {
-				const first = expandApplyPatchToEntries({ input })[0];
-				if (!first?.path) return;
-				computePatchDiff({ ...first, op: first.op ?? "update" }, this.#cwd, {
-					fuzzyThreshold: this.#editFuzzyThreshold,
-					allowFuzzy: this.#editAllowFuzzy,
-				}).then(result => {
-					if (this.#editDiffArgsKey === argsKey) {
-						this.#editDiffPreview = result;
-						this.#updateDisplay();
-						this.#ui.requestRender();
-					}
-				});
-			} catch (err) {
-				this.#editDiffPreview = { error: err instanceof Error ? err.message : String(err) };
-				this.#updateDisplay();
-				this.#ui.requestRender();
-			}
+	#schedulePreviewDiff(delayMs = 80): void {
+		if (!this.#editMode) return;
+		if (this.#editDiffScheduleTimer) {
+			clearTimeout(this.#editDiffScheduleTimer);
+			this.#editDiffScheduleTimer = undefined;
+		}
+		if (delayMs === 0) {
+			void this.#runPreviewDiff();
 			return;
 		}
+		this.#editDiffScheduleTimer = setTimeout(() => {
+			this.#editDiffScheduleTimer = undefined;
+			void this.#runPreviewDiff();
+		}, delayMs);
+	}
 
-		const first = edits[0];
-		if (!first || typeof first !== "object") return;
-
-		// Detect mode from first edit entry shape and compute preview for first file
-		if ("old_text" in first && "new_text" in first) {
-			// Replace mode
-			const { path, old_text: oldText, new_text: newText, all } = first;
-			if (!path || oldText === undefined || newText === undefined) return;
-
-			const argsKey = JSON.stringify({ path, oldText, newText, all });
-			if (this.#editDiffArgsKey === argsKey) return;
-			this.#editDiffArgsKey = argsKey;
+	async #runPreviewDiff(): Promise<void> {
+		const editMode = this.#editMode;
+		if (!editMode) return;
+		const strategy = EDIT_MODE_STRATEGIES[editMode];
+		if (!strategy) return;
+
+		const args = this.#args;
+		if (args == null || typeof args !== "object") return;
+
+		const partialJson = (args as { __partialJson?: string }).__partialJson;
+		let effectiveArgs: unknown;
+		try {
+			effectiveArgs = strategy.extractCompleteEdits(args, partialJson);
+		} catch {
+			effectiveArgs = args;
+		}
 
-			computeEditDiff(path, oldText, newText, this.#cwd, true, all, this.#editFuzzyThreshold).then(result =>
-				this.#applyEditDiffResult(argsKey, result),
-			);
-		} else if ("path" in first && ("diff" in first || ("op" in first && !("content" in first)))) {
-			// Patch mode (has diff or op without content — chunk edits always have content)
-			const { path, op, rename, diff } = first;
-			if (!path) return;
+		// Coalesce duplicate computes for identical args.
+		let argsKey: string;
+		try {
+			argsKey = JSON.stringify(effectiveArgs);
+		} catch {
+			argsKey = String(Date.now());
+		}
+		if (argsKey === this.#editDiffLastArgsKey) return;
+		this.#editDiffLastArgsKey = argsKey;
 
-			const argsKey = JSON.stringify({ path, op, rename, diff });
-			if (this.#editDiffArgsKey === argsKey) return;
-			this.#editDiffArgsKey = argsKey;
+		this.#editDiffAbort?.abort();
+		const controller = new AbortController();
+		this.#editDiffAbort = controller;
 
-			computePatchDiff({ path, op, rename, diff }, this.#cwd, {
+		try {
+			const previews = await strategy.computeDiffPreview(effectiveArgs, {
+				cwd: this.#cwd,
+				signal: controller.signal,
 				fuzzyThreshold: this.#editFuzzyThreshold,
 				allowFuzzy: this.#editAllowFuzzy,
-			}).then(result => this.#applyEditDiffResult(argsKey, result));
-		} else if ("loc" in first && "path" in first) {
-			// Hashline mode — group edits by path, preview first file
-			const path = first.path;
-			if (!path) return;
-			const fileEdits = edits.filter((e: any) => e.path === path);
-			const move = this.#args?.move;
-
-			const argsKey = JSON.stringify({ path, edits: fileEdits, move });
-			if (this.#editDiffArgsKey === argsKey) return;
-			this.#editDiffArgsKey = argsKey;
-
-			computeHashlineDiff({ path, edits: fileEdits, move }, this.#cwd).then(result =>
-				this.#applyEditDiffResult(argsKey, result),
-			);
+			});
+			if (controller.signal.aborted) return;
+			if (previews) {
+				this.#editDiffPreview = previews;
+				this.#updateDisplay();
+				this.#ui.requestRender();
+			}
+		} catch (err) {
+			if (controller.signal.aborted) return;
+			logger.warn("Edit preview diff failed", { tool: this.#toolName, error: String(err) });
 		}
-		// Chunk mode edits don't have a pre-execution diff preview
-	}
-
-	#applyEditDiffResult(argsKey: string, result: DiffResult | DiffError): void {
-		if (this.#editDiffArgsKey !== argsKey) return;
-		this.#editDiffPreview = result;
-		this.#updateDisplay();
-		this.#ui.requestRender();
 	}
 
 	updateResult(
@@ -378,6 +362,12 @@ export class ToolExecutionComponent extends Container {
 			this.#spinnerInterval = undefined;
 			this.#spinnerFrame = undefined;
 		}
+		if (this.#editDiffScheduleTimer) {
+			clearTimeout(this.#editDiffScheduleTimer);
+			this.#editDiffScheduleTimer = undefined;
+		}
+		this.#editDiffAbort?.abort();
+		this.#editDiffAbort = undefined;
 	}
 
 	setExpanded(expanded: boolean): void {
@@ -549,6 +539,9 @@ export class ToolExecutionComponent extends Container {
 				this.#contentBox.setBgFn(renderer.inline ? undefined : bgFn);
 				this.#contentBox.clear();
 
+				const renderContext = this.#buildRenderContext();
+				this.#renderState.renderContext = renderContext;
+
 				const shouldRenderCall = !this.#result || !renderer.mergeCallAndResult;
 				if (shouldRenderCall) {
 					// Render call component
@@ -567,10 +560,6 @@ export class ToolExecutionComponent extends Container {
 				// Render result component if we have a result
 				if (this.#result) {
 					try {
-						// Build render context for tools that need extra state
-						const renderContext = this.#buildRenderContext();
-						this.#renderState.renderContext = renderContext;
-
 						const resultComponent = renderer.renderResult(
 							{
 								content: this.#result.content as any,
@@ -646,10 +635,20 @@ export class ToolExecutionComponent extends Container {
 		if (!isEditLikeToolName(this.#toolName)) {
 			return this.#args;
 		}
-		if (!this.#editDiffPreview || !("diff" in this.#editDiffPreview) || !this.#editDiffPreview.diff) {
+		const previews = this.#editDiffPreview;
+		if (!previews || previews.length === 0) {
 			return this.#args;
 		}
-		return { ...(this.#args as Record<string, unknown>), previewDiff: this.#editDiffPreview.diff };
+		// Single-file previews feed the existing `previewDiff` channel consumed
+		// by `formatStreamingDiff` in the renderer. Multi-file previews are
+		// piped via `renderContext.perFileDiffPreview`, so the args we hand to
+		// `renderCall` only need the first file's diff to preserve prior
+		// single-file behavior.
+		const first = previews[0];
+		if (!first?.diff) {
+			return this.#args;
+		}
+		return { ...(this.#args as Record<string, unknown>), previewDiff: first.diff };
 	}
 
 	/**
@@ -680,8 +679,19 @@ export class ToolExecutionComponent extends Container {
 			context.previewLines = PYTHON_DEFAULT_PREVIEW_LINES;
 			context.timeout = normalizeTimeoutSeconds(this.#args?.timeout, 600);
 		} else if (isEditLikeToolName(this.#toolName)) {
-			// Edit needs diff preview and renderDiff function
-			context.editDiffPreview = this.#editDiffPreview;
+			context.editMode = this.#editMode;
+			const previews = this.#editDiffPreview;
+			if (previews && previews.length > 0) {
+				const first = previews[0];
+				if (first?.diff || first?.error) {
+					context.editDiffPreview = first.error
+						? { error: first.error }
+						: { diff: first.diff ?? "", firstChangedLine: first.firstChangedLine };
+				}
+				if (previews.length > 1) {
+					context.perFileDiffPreview = previews;
+				}
+			}
 			context.renderDiff = renderDiff;
 		}
 

package/src/modes/controllers/input-controller.ts

@@ -715,7 +715,7 @@ export class InputController {
 			return;
 		}
 
-		const currentText = this.ctx.editor.getText();
+		const currentText = this.ctx.editor.getExpandedText?.() ?? this.ctx.editor.getText();
 
 		let ttyHandle: fs.FileHandle | null = null;
 		try {

package/src/modes/interactive-mode.ts

@@ -63,7 +63,6 @@ import { SelectorController } from "./controllers/selector-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
-import { setMermaidRenderCallback } from "./theme/mermaid-cache";
 import type { Theme } from "./theme/theme";
 import {
 	getEditorTheme,
@@ -220,7 +219,6 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		this.ui = new TUI(new ProcessTerminal(), settings.get("showHardwareCursor"));
 		this.ui.setClearOnShrink(settings.get("clearOnShrink"));
-		setMermaidRenderCallback(() => this.ui.requestRender());
 		this.chatContainer = new Container();
 		this.pendingMessagesContainer = new Container();
 		this.statusContainer = new Container();

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

@@ -1,63 +1,24 @@
-import { extractMermaidBlocks, logger, renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils";
+import { renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils";
 
-const cache = new Map<bigint | number, string | null>();
+const cache = new Map<string, string | null>();
 
-let onRenderNeeded: (() => void) | null = null;
-
-/**
- * Set callback to trigger TUI re-render when mermaid ASCII renders become available.
- */
-export function setMermaidRenderCallback(callback: (() => void) | null): void {
-	onRenderNeeded = callback;
-}
-
-/**
- * Get a pre-rendered mermaid ASCII diagram by hash.
- * Returns null if not cached or rendering failed.
- */
-export function getMermaidAscii(hash: bigint | number): string | null {
-	return cache.get(hash) ?? null;
+function normalizeMermaidSource(source: string): string {
+	return source.replace(/\r\n?/g, "\n").trim();
 }
 
 /**
- * Render all mermaid blocks in markdown text.
- * Caches results and calls render callback when new diagrams are available.
+ * Resolve mermaid ASCII from fenced block source text.
+ * Returns null when rendering fails, while memoizing failures to avoid repeated work.
  */
-export function prerenderMermaid(markdown: string): void {
-	const blocks = extractMermaidBlocks(markdown);
-	if (blocks.length === 0) return;
-
-	let hasNew = false;
-
-	for (const { source, hash } of blocks) {
-		if (cache.has(hash)) continue;
-
-		const ascii = renderMermaidAsciiSafe(source);
-		if (ascii) {
-			cache.set(hash, ascii);
-			hasNew = true;
-		} else {
-			cache.set(hash, null);
-		}
+export function resolveMermaidAscii(source: string): string | null {
+	const normalizedSource = normalizeMermaidSource(source);
+	if (cache.has(normalizedSource)) {
+		return cache.get(normalizedSource) ?? null;
 	}
 
-	if (hasNew && onRenderNeeded) {
-		try {
-			onRenderNeeded();
-		} catch (error) {
-			logger.warn("Mermaid render callback failed", {
-				error: error instanceof Error ? error.message : String(error),
-			});
-		}
-	}
-}
-
-/**
- * Check if markdown contains mermaid blocks that aren't cached yet.
- */
-export function hasPendingMermaid(markdown: string): boolean {
-	const blocks = extractMermaidBlocks(markdown);
-	return blocks.some(({ hash }) => !cache.has(hash));
+	const ascii = normalizedSource ? renderMermaidAsciiSafe(normalizedSource) : null;
+	cache.set(normalizedSource, ascii);
+	return ascii;
 }
 
 /**

package/src/modes/theme/theme.ts

@@ -18,7 +18,7 @@ import chalk from "chalk";
 import darkThemeJson from "./dark.json" with { type: "json" };
 import { defaultThemes } from "./defaults";
 import lightThemeJson from "./light.json" with { type: "json" };
-import { getMermaidAscii } from "./mermaid-cache";
+import { resolveMermaidAscii } from "./mermaid-cache";
 
 export { getLanguageFromPath } from "../../utils/lang-from-path";
 
@@ -2339,7 +2339,7 @@ export function getMarkdownTheme(): MarkdownTheme {
 		underline: (text: string) => theme.underline(text),
 		strikethrough: (text: string) => chalk.strikethrough(text),
 		symbols: getSymbolTheme(),
-		getMermaidAscii,
+		resolveMermaidAscii,
 		highlightCode: (code: string, lang?: string): string[] => {
 			const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
 			try {

package/src/prompts/system/system-prompt.md

@@ -187,7 +187,7 @@ You **MUST NOT** use Python or Bash when a specialized tool exists.
 {{/ifAny}}
 
 {{#ifAny (includes tools "read") (includes tools "write") (includes tools "grep") (includes tools "find") (includes tools "edit")}}
-{{#has tools "read"}}- Use `read`, not `cat` or `open`.{{/has}}
+{{#has tools "read"}}- Use `read`, not `cat`.{{/has}}
 {{#has tools "write"}}- Use `write`, not shell redirection.{{/has}}
 {{#has tools "grep"}}- Use `grep`, not shell regex search.{{/has}}
 {{#has tools "find"}}- Use `find`, not shell file globbing.{{/has}}

package/src/prompts/tools/browser.md

@@ -1,6 +1,7 @@
 Navigates, clicks, types, scrolls, drags, queries DOM content, and captures screenshots.
 
 <instruction>
+- For fetching static web content (articles, docs, issues/PRs, JSON, PDFs, feeds), prefer the `read` tool with a URL — it returns clean reader-mode text without spinning up a browser. Use this tool only when you need JS execution, authentication, or interactive actions.
 - `"open"` starts a headless session (or implicitly on first action); `"goto"` navigates to `url`; `"close"` releases the browser
 - `"observe"` captures a numbered accessibility snapshot — prefer `click_id`/`type_id`/`fill_id` using returned `element_id` values; flags: `include_all`, `viewport_only`
 - `"click"`, `"type"`, `"fill"`, `"press"`, `"scroll"`, `"drag"` for selector-based interactions — prefer ARIA/text selectors (`p-aria/[name="Sign in"]`, `p-text/Continue`) over brittle CSS