@oh-my-pi/pi-coding-agent 8.0.20 → 8.1.0

package/src/index.ts

@@ -3,7 +3,7 @@
 // TypeBox helper for string enums (convenience for custom tools)
 // Re-export from pi-ai which uses the correct enum-based schema format
 export { StringEnum } from "@oh-my-pi/pi-ai";
-export type { FileDiagnosticsResult } from "@oh-my-pi/pi-coding-agent/lsp/index";
+export type { FileDiagnosticsResult } from "@oh-my-pi/pi-coding-agent/lsp";
 // UI components for extensions
 export {
 	ArminComponent,
@@ -37,7 +37,7 @@ export {
 	UserMessageComponent,
 	UserMessageSelectorComponent,
 	type VisualTruncateResult,
-} from "@oh-my-pi/pi-coding-agent/modes/components/index";
+} from "@oh-my-pi/pi-coding-agent/modes/components";
 // Theme utilities for custom tools
 export {
 	getLanguageFromPath,
@@ -88,9 +88,9 @@ export type {
 	ExecResult,
 	LoadedCustomTool,
 	RenderResultOptions,
-} from "./extensibility/custom-tools/index";
+} from "./extensibility/custom-tools";
 // Custom tools
-export { CustomToolLoader, discoverAndLoadCustomTools, loadCustomTools } from "./extensibility/custom-tools/index";
+export { CustomToolLoader, discoverAndLoadCustomTools, loadCustomTools } from "./extensibility/custom-tools";
 export type {
 	AppAction,
 	Extension,
@@ -122,7 +122,7 @@ export type {
 	UserBashEventResult,
 	UserPythonEvent,
 	UserPythonEventResult,
-} from "./extensibility/extensions/index";
+} from "./extensibility/extensions";
 // Extension types and utilities
 export {
 	discoverAndLoadExtensions,
@@ -135,9 +135,9 @@ export {
 	isLsToolResult,
 	isReadToolResult,
 	isWriteToolResult,
-} from "./extensibility/extensions/index";
+} from "./extensibility/extensions";
 // Hook system types (legacy re-export)
-export type * from "./extensibility/hooks/index";
+export type * from "./extensibility/hooks";
 // Skills
 export {
 	type LoadSkillsFromDirOptions,
@@ -162,7 +162,7 @@ export {
 	type RpcEventListener,
 	runPrintMode,
 	runRpcMode,
-} from "./modes/index";
+} from "./modes";
 // SDK for programmatic usage
 export {
 	// Factory
@@ -228,7 +228,7 @@ export {
 	prepareBranchEntries,
 	serializeConversation,
 	shouldCompact,
-} from "./session/compaction/index";
+} from "./session/compaction";
 export { convertToLlm } from "./session/messages";
 export {
 	type BranchSummaryEntry,
@@ -275,5 +275,5 @@ export {
 	truncateLine,
 	truncateTail,
 	type WriteToolDetails,
-} from "./tools/index";
+} from "./tools";
 export { getShellConfig } from "./utils/shell";

package/src/ipy/executor.ts

@@ -1,3 +1,4 @@
+import { shutdownSharedGateway } from "@oh-my-pi/pi-coding-agent/ipy/gateway-coordinator";
 import {
 	checkPythonKernelAvailability,
 	type KernelDisplayOutput,
@@ -8,6 +9,11 @@ import {
 } from "@oh-my-pi/pi-coding-agent/ipy/kernel";
 import { OutputSink } from "@oh-my-pi/pi-coding-agent/session/streaming-output";
 import { logger } from "@oh-my-pi/pi-utils";
+
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_KERNEL_SESSIONS = 4;
+const CLEANUP_INTERVAL_MS = 30 * 1000; // 30 seconds
+
 export type PythonKernelMode = "session" | "per-call";
 
 export interface PythonExecutorOptions {
@@ -77,8 +83,58 @@ interface KernelSession {
 
 const kernelSessions = new Map<string, KernelSession>();
 let cachedPreludeDocs: PreludeHelper[] | null = null;
+let cleanupTimer: NodeJS.Timeout | null = null;
+
+function startCleanupTimer(): void {
+	if (cleanupTimer) return;
+	cleanupTimer = setInterval(() => {
+		void cleanupIdleSessions();
+	}, CLEANUP_INTERVAL_MS);
+	cleanupTimer.unref();
+}
+
+function stopCleanupTimer(): void {
+	if (cleanupTimer) {
+		clearInterval(cleanupTimer);
+		cleanupTimer = null;
+	}
+}
+
+async function cleanupIdleSessions(): Promise<void> {
+	const now = Date.now();
+	const toDispose: KernelSession[] = [];
+
+	for (const session of kernelSessions.values()) {
+		if (session.dead || now - session.lastUsedAt > IDLE_TIMEOUT_MS) {
+			toDispose.push(session);
+		}
+	}
+
+	if (toDispose.length > 0) {
+		logger.debug("Cleaning up idle kernel sessions", { count: toDispose.length });
+		await Promise.allSettled(toDispose.map((session) => disposeKernelSession(session)));
+	}
+
+	if (kernelSessions.size === 0) {
+		stopCleanupTimer();
+	}
+}
+
+async function evictOldestSession(): Promise<void> {
+	let oldest: KernelSession | null = null;
+	for (const session of kernelSessions.values()) {
+		if (!oldest || session.lastUsedAt < oldest.lastUsedAt) {
+			oldest = session;
+		}
+	}
+	if (oldest) {
+		logger.debug("Evicting oldest kernel session", { id: oldest.id });
+		await disposeKernelSession(oldest);
+	}
+}
 
 export async function disposeAllKernelSessions(): Promise<void> {
+	stopCleanupTimer();
 	const sessions = Array.from(kernelSessions.values());
 	await Promise.allSettled(sessions.map((session) => disposeKernelSession(session)));
 }
@@ -132,12 +188,36 @@ export function resetPreludeDocsCache(): void {
 	cachedPreludeDocs = null;
 }
 
+function isResourceExhaustionError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return (
+		message.includes("Too many open files") ||
+		message.includes("EMFILE") ||
+		message.includes("ENFILE") ||
+		message.includes("resource temporarily unavailable")
+	);
+}
+
+async function recoverFromResourceExhaustion(): Promise<void> {
+	logger.warn("Resource exhaustion detected, recovering by restarting shared gateway");
+	stopCleanupTimer();
+	const sessions = Array.from(kernelSessions.values());
+	for (const session of sessions) {
+		if (session.heartbeatTimer) {
+			clearInterval(session.heartbeatTimer);
+		}
+		kernelSessions.delete(session.id);
+	}
+	await shutdownSharedGateway();
+}
+
 async function createKernelSession(
 	sessionId: string,
 	cwd: string,
 	useSharedGateway?: boolean,
 	sessionFile?: string,
 	artifactsDir?: string,
+	isRetry?: boolean,
 ): Promise<KernelSession> {
 	const env: Record<string, string> | undefined =
 		sessionFile || artifactsDir
@@ -146,7 +226,18 @@ async function createKernelSession(
 					...(artifactsDir ? { ARTIFACTS: artifactsDir } : {}),
 				}
 			: undefined;
-	const kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
+
+	let kernel: PythonKernel;
+	try {
+		kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
+	} catch (err) {
+		if (!isRetry && isResourceExhaustionError(err)) {
+			await recoverFromResourceExhaustion();
+			return createKernelSession(sessionId, cwd, useSharedGateway, sessionFile, artifactsDir, true);
+		}
+		throw err;
+	}
+
 	const session: KernelSession = {
 		id: sessionId,
 		kernel,
@@ -218,8 +309,13 @@ async function withKernelSession<T>(
 ): Promise<T> {
 	let session = kernelSessions.get(sessionId);
 	if (!session) {
+		// Evict oldest session if at capacity
+		if (kernelSessions.size >= MAX_KERNEL_SESSIONS) {
+			await evictOldestSession();
+		}
 		session = await createKernelSession(sessionId, cwd, useSharedGateway, sessionFile, artifactsDir);
 		kernelSessions.set(sessionId, session);
+		startCleanupTimer();
 	}
 
 	const run = async (): Promise<T> => {

package/src/lsp/index.ts

@@ -5,7 +5,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
 import { type Theme, theme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
 import lspDescription from "@oh-my-pi/pi-coding-agent/prompts/tools/lsp.md" with { type: "text" };
-import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools/index";
+import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
 import { resolveToCwd } from "@oh-my-pi/pi-coding-agent/tools/path-utils";
 import { throwIfAborted } from "@oh-my-pi/pi-coding-agent/tools/tool-errors";
 import { logger, once, untilAborted } from "@oh-my-pi/pi-utils";

package/src/lsp/render.ts

@@ -16,7 +16,8 @@ import {
 	TRUNCATE_LENGTHS,
 	truncate,
 } from "@oh-my-pi/pi-coding-agent/tools/render-utils";
-import { Text } from "@oh-my-pi/pi-tui";
+import { renderOutputBlock, renderStatusLine } from "@oh-my-pi/pi-coding-agent/tui";
+import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
 import type { LspParams, LspToolDetails } from "./types";
 
@@ -30,16 +31,13 @@ import type { LspParams, LspToolDetails } from "./types";
  */
 export function renderCall(args: unknown, theme: Theme): Text {
 	const p = args as LspParams & { file?: string; files?: string[] };
-
-	let text = theme.fg("toolTitle", theme.bold("LSP"));
-	text += ` ${theme.fg("accent", p.action || "?")}`;
-
+	const meta: string[] = [];
 	if (p.file) {
-		text += ` ${theme.fg("muted", p.file)}`;
+		meta.push(p.file);
 	} else if (p.files?.length) {
-		text += ` ${theme.fg("muted", `${p.files.length} file(s)`)}`;
+		meta.push(`${p.files.length} file(s)`);
 	}
-
+	const text = renderStatusLine({ icon: "pending", title: "LSP", description: p.action || "?", meta }, theme);
 	return new Text(text, 0, 0);
 }
 
@@ -55,40 +53,74 @@ export function renderResult(
 	result: AgentToolResult<LspToolDetails>,
 	options: RenderResultOptions,
 	theme: Theme,
-): Text {
+	args?: LspParams & { file?: string; files?: string[] },
+): Component {
 	const content = result.content?.[0];
 	if (!content || content.type !== "text" || !("text" in content) || !content.text) {
-		return new Text(theme.fg("error", "No result"), 0, 0);
+		const header = renderStatusLine({ icon: "warning", title: "LSP", description: "No result" }, theme);
+		return new Text([header, theme.fg("dim", "No result")].join("\n"), 0, 0);
 	}
 
 	const text = content.text;
-	const lines = text.split("\n").filter((l) => l.trim());
+	const lines = text.split("\n");
 	const expanded = options.expanded;
 
-	// Detect result type and render accordingly
+	let label = "Result";
+	let state: "success" | "warning" | "error" = "success";
+	let bodyLines: string[] = [];
+
 	const codeBlockMatch = text.match(/```(\w*)\n([\s\S]*?)```/);
 	if (codeBlockMatch) {
-		return renderHover(codeBlockMatch, text, lines, expanded, theme);
-	}
-
-	const errorMatch = text.match(/(\d+)\s+error\(s\)/);
-	const warningMatch = text.match(/(\d+)\s+warning\(s\)/);
-	if (errorMatch || warningMatch || text.includes(theme.status.error)) {
-		return renderDiagnostics(errorMatch, warningMatch, lines, expanded, theme);
-	}
-
-	const refMatch = text.match(/(\d+)\s+reference\(s\)/);
-	if (refMatch) {
-		return renderReferences(refMatch, lines, expanded, theme);
+		label = "Hover";
+		bodyLines = renderHover(codeBlockMatch, text, lines, expanded, theme);
+	} else {
+		const errorMatch = text.match(/(\d+)\s+error\(s\)/);
+		const warningMatch = text.match(/(\d+)\s+warning\(s\)/);
+		if (errorMatch || warningMatch || text.includes(theme.status.error)) {
+			label = "Diagnostics";
+			const errorCount = errorMatch ? Number.parseInt(errorMatch[1], 10) : 0;
+			const warnCount = warningMatch ? Number.parseInt(warningMatch[1], 10) : 0;
+			state = errorCount > 0 ? "error" : warnCount > 0 ? "warning" : "success";
+			bodyLines = renderDiagnostics(errorMatch, warningMatch, lines, expanded, theme);
+		} else {
+			const refMatch = text.match(/(\d+)\s+reference\(s\)/);
+			if (refMatch) {
+				label = "References";
+				bodyLines = renderReferences(refMatch, lines, expanded, theme);
+			} else {
+				const symbolsMatch = text.match(/Symbols in (.+):/);
+				if (symbolsMatch) {
+					label = "Symbols";
+					bodyLines = renderSymbols(symbolsMatch, lines, expanded, theme);
+				} else {
+					label = "Response";
+					bodyLines = renderGeneric(text, lines, expanded, theme);
+				}
+			}
+		}
 	}
 
-	const symbolsMatch = text.match(/Symbols in (.+):/);
-	if (symbolsMatch) {
-		return renderSymbols(symbolsMatch, lines, expanded, theme);
+	const meta: string[] = [];
+	if (args?.action) meta.push(args.action);
+	if (args?.file) {
+		meta.push(args.file);
+	} else if (args?.files?.length) {
+		meta.push(`${args.files.length} file(s)`);
 	}
-
-	// Default fallback rendering
-	return renderGeneric(text, lines, expanded, theme);
+	const header = renderStatusLine({ icon: state, title: "LSP", description: label, meta }, theme);
+	return {
+		render: (width: number) =>
+			renderOutputBlock(
+				{
+					header,
+					state,
+					sections: [{ label: theme.fg("toolTitle", label), lines: bodyLines }],
+					width,
+				},
+				theme,
+			),
+		invalidate: () => {},
+	};
 }
 
 // =============================================================================
@@ -104,9 +136,11 @@ function renderHover(
 	_lines: string[],
 	expanded: boolean,
 	theme: Theme,
-): Text {
+): string[] {
 	const lang = codeBlockMatch[1] || "";
 	const code = codeBlockMatch[2].trim();
+	const codeStart = codeBlockMatch.index ?? 0;
+	const beforeCode = fullText.slice(0, codeStart).trimEnd();
 	const afterCode = fullText.slice(fullText.indexOf("```", 3) + 3).trim();
 
 	const codeLines = highlightCode(code, lang, theme);
@@ -119,6 +153,11 @@ function renderHover(
 		const top = `${theme.boxSharp.topLeft}${h.repeat(3)}`;
 		const bottom = `${theme.boxSharp.bottomLeft}${h.repeat(3)}`;
 		let output = `${icon}${langLabel}`;
+		if (beforeCode) {
+			for (const line of beforeCode.split("\n")) {
+				output += `\n ${theme.fg("muted", line)}`;
+			}
+		}
 		output += `\n ${theme.fg("mdCodeBlockBorder", top)}`;
 		for (const line of codeLines) {
 			output += `\n ${theme.fg("mdCodeBlockBorder", v)} ${line}`;
@@ -127,15 +166,19 @@ function renderHover(
 		if (afterCode) {
 			output += `\n ${theme.fg("muted", afterCode)}`;
 		}
-		return new Text(output, 0, 0);
+		return output.split("\n");
 	}
 
 	// Collapsed view
 	const firstCodeLine = codeLines[0] || "";
-	const hasMore = codeLines.length > 1 || Boolean(afterCode);
+	const hasMore = codeLines.length > 1 || Boolean(afterCode) || Boolean(beforeCode);
 	const expandHint = formatExpandHint(theme, expanded, hasMore);
 
 	let output = `${icon}${langLabel}${expandHint}`;
+	if (beforeCode) {
+		const preview = truncate(beforeCode, TRUNCATE_LENGTHS.TITLE, theme.format.ellipsis);
+		output += `\n ${theme.fg("dim", theme.tree.branch)} ${theme.fg("muted", preview)}`;
+	}
 	const h = theme.boxSharp.horizontal;
 	const v = theme.boxSharp.vertical;
 	const bottom = `${theme.boxSharp.bottomLeft}${h.repeat(3)}`;
@@ -155,7 +198,7 @@ function renderHover(
 		output += `\n ${theme.fg("mdCodeBlockBorder", bottom)}`;
 	}
 
-	return new Text(output, 0, 0);
+	return output.split("\n");
 }
 
 /**
@@ -206,7 +249,7 @@ function renderDiagnostics(
 	lines: string[],
 	expanded: boolean,
 	theme: Theme,
-): Text {
+): string[] {
 	const errorCount = errorMatch ? Number.parseInt(errorMatch[1], 10) : 0;
 	const warnCount = warningMatch ? Number.parseInt(warningMatch[1], 10) : 0;
 
@@ -253,7 +296,7 @@ function renderDiagnostics(
 				)}`;
 			}
 		}
-		return new Text(output, 0, 0);
+		return output.split("\n");
 	}
 
 	// Collapsed view
@@ -285,7 +328,7 @@ function renderDiagnostics(
 		)}`;
 	}
 
-	return new Text(output, 0, 0);
+	return output.split("\n");
 }
 
 // =============================================================================
@@ -295,7 +338,7 @@ function renderDiagnostics(
 /**
  * Render references grouped by file.
  */
-function renderReferences(refMatch: RegExpMatchArray, lines: string[], expanded: boolean, theme: Theme): Text {
+function renderReferences(refMatch: RegExpMatchArray, lines: string[], expanded: boolean, theme: Theme): string[] {
 	const refCount = Number.parseInt(refMatch[1], 10);
 	const icon =
 		refCount > 0 ? theme.styledSymbol("status.success", "success") : theme.styledSymbol("status.warning", "warning");
@@ -369,10 +412,10 @@ function renderReferences(refMatch: RegExpMatchArray, lines: string[], expanded:
 	};
 
 	if (expanded) {
-		return new Text(renderGrouped(files.length, 3, false), 0, 0);
+		return renderGrouped(files.length, 3, false).split("\n");
 	}
 
-	return new Text(renderGrouped(3, 1, true), 0, 0);
+	return renderGrouped(3, 1, true).split("\n");
 }
 
 // =============================================================================
@@ -382,7 +425,7 @@ function renderReferences(refMatch: RegExpMatchArray, lines: string[], expanded:
 /**
  * Render document symbols in a hierarchical tree.
  */
-function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded: boolean, theme: Theme): Text {
+function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded: boolean, theme: Theme): string[] {
 	const fileName = symbolsMatch[1];
 	const icon = theme.styledSymbol("status.info", "accent");
 
@@ -450,7 +493,7 @@ function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded
 			output += `\n${prefix}${theme.fg("dim", branch)} ${theme.fg("accent", sym.icon)} ${theme.fg("accent", sym.name)}`;
 			output += `\n${prefix}${theme.fg("dim", detailPrefix)}${theme.fg("muted", `line ${sym.line}`)}`;
 		}
-		return new Text(output, 0, 0);
+		return output.split("\n");
 	}
 
 	// Collapsed: show first 3 top-level symbols
@@ -474,7 +517,7 @@ function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded
 		)}`;
 	}
 
-	return new Text(output, 0, 0);
+	return output.split("\n");
 }
 
 // =============================================================================
@@ -484,7 +527,7 @@ function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded
 /**
  * Generic fallback rendering for unknown result types.
  */
-function renderGeneric(text: string, lines: string[], expanded: boolean, theme: Theme): Text {
+function renderGeneric(text: string, lines: string[], expanded: boolean, theme: Theme): string[] {
 	const hasError = text.includes("Error:") || text.includes(theme.status.error);
 	const hasSuccess = text.includes(theme.status.success) || text.includes("Applied");
 
@@ -502,7 +545,7 @@ function renderGeneric(text: string, lines: string[], expanded: boolean, theme:
 			const branch = isLast ? theme.tree.last : theme.tree.branch;
 			output += `\n ${theme.fg("dim", branch)} ${lines[i]}`;
 		}
-		return new Text(output, 0, 0);
+		return output.split("\n");
 	}
 
 	const firstLine = lines[0] || "No output";
@@ -530,7 +573,7 @@ function renderGeneric(text: string, lines: string[], expanded: boolean, theme:
 		}
 	}
 
-	return new Text(output, 0, 0);
+	return output.split("\n");
 }
 
 // =============================================================================
@@ -574,4 +617,5 @@ function severityToColor(severity: string): "error" | "warning" | "accent" | "di
 export const lspToolRenderer = {
 	renderCall,
 	renderResult,
+	mergeCallAndResult: true,
 };

package/src/main.ts

@@ -21,15 +21,17 @@ import { selectSession } from "./cli/session-picker";
 import { parseSetupArgs, printSetupHelp, runSetupCommand } from "./cli/setup-cli";
 import { parseStatsArgs, printStatsHelp, runStatsCommand } from "./cli/stats-cli";
 import { parseUpdateArgs, printUpdateHelp, runUpdateCommand } from "./cli/update-cli";
+import { runCommitCommand } from "./commit";
+import { parseCommitArgs, printCommitHelp } from "./commit/cli";
 import { findConfigFile, getModelsPath, VERSION } from "./config";
 import type { ModelRegistry } from "./config/model-registry";
 import { parseModelPattern, parseModelString, resolveModelScope, type ScopedModel } from "./config/model-resolver";
 import { SettingsManager } from "./config/settings-manager";
 import { initializeWithSettings } from "./discovery";
-import { exportFromFile } from "./export/html/index";
+import { exportFromFile } from "./export/html";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
 import { runMigrations, showDeprecationWarnings } from "./migrations";
-import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index";
+import { InteractiveMode, runPrintMode, runRpcMode } from "./modes";
 import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage, discoverModels } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
 import { type SessionInfo, SessionManager } from "./session/session-manager";
@@ -85,7 +87,7 @@ async function runInteractiveMode(
 	initialMessages: string[],
 	setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
 	lspServers: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }> | undefined,
-	mcpManager: import("./mcp/index").MCPManager | undefined,
+	mcpManager: import("./mcp").MCPManager | undefined,
 	initialMessage?: string,
 	initialImages?: ImageContent[],
 ): Promise<void> {
@@ -532,6 +534,17 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	// Handle commit subcommand
+	const commitCmd = parseCommitArgs(args);
+	if (commitCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printCommitHelp();
+			return;
+		}
+		await runCommitCommand(commitCmd);
+		process.exit(0);
+	}
+
 	const parsed = parseArgs(args);
 	time("parseArgs");
 	await maybeAutoChdir(parsed);

package/src/mcp/loader.ts

@@ -36,10 +36,10 @@ export interface MCPToolsLoadOptions {
 	cacheStorage?: AgentStorage | null;
 }
 
-function resolveToolCache(storage: AgentStorage | null | undefined): MCPToolCache | null {
+async function resolveToolCache(storage: AgentStorage | null | undefined): Promise<MCPToolCache | null> {
 	if (storage === null) return null;
 	try {
-		const resolved = storage ?? AgentStorage.open();
+		const resolved = storage ?? (await AgentStorage.open());
 		return new MCPToolCache(resolved);
 	} catch (error) {
 		logger.warn("MCP tool cache unavailable", { error: String(error) });
@@ -55,7 +55,7 @@ function resolveToolCache(storage: AgentStorage | null | undefined): MCPToolCach
  * @returns MCP tools in LoadedCustomTool format for integration
  */
 export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoadOptions): Promise<MCPToolsLoadResult> {
-	const toolCache = resolveToolCache(options?.cacheStorage);
+	const toolCache = await resolveToolCache(options?.cacheStorage);
 	const manager = new MCPManager(cwd, toolCache);
 
 	let result: MCPLoadResult;

package/src/migrations.ts

@@ -15,11 +15,11 @@ import { getAgentDbPath, getAgentDir, getBinDir } from "./config";
  *
  * @returns Array of provider names that were migrated
  */
-export function migrateAuthToAgentDb(): string[] {
+export async function migrateAuthToAgentDb(): Promise<string[]> {
 	const agentDir = getAgentDir();
 	const oauthPath = join(agentDir, "oauth.json");
 	const settingsPath = join(agentDir, "settings.json");
-	const storage = AgentStorage.open(getAgentDbPath(agentDir));
+	const storage = await AgentStorage.open(getAgentDbPath(agentDir));
 
 	const migrated: Record<string, AuthCredential[]> = {};
 	const providers: string[] = [];
@@ -179,7 +179,7 @@ export async function runMigrations(_cwd: string): Promise<{
 	deprecationWarnings: string[];
 }> {
 	// Then: run data migrations
-	const migratedAuthProviders = migrateAuthToAgentDb();
+	const migratedAuthProviders = await migrateAuthToAgentDb();
 	migrateSessionsFromAgentRoot();
 	migrateToolsToBin();
 

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

@@ -1,6 +1,7 @@
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import { hasPendingMermaid, prerenderMermaid } from "@oh-my-pi/pi-coding-agent/modes/theme/mermaid-cache";
 import { getMarkdownTheme, theme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
-import { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
+import { Container, getCapabilities, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 
 /**
  * Component that renders a complete assistant message
@@ -9,6 +10,7 @@ export class AssistantMessageComponent extends Container {
 	private contentContainer: Container;
 	private hideThinkingBlock: boolean;
 	private lastMessage?: AssistantMessage;
+	private prerenderInFlight = false;
 
 	constructor(message?: AssistantMessage, hideThinkingBlock = false) {
 		super();
@@ -35,12 +37,38 @@ export class AssistantMessageComponent extends Container {
 		this.hideThinkingBlock = hide;
 	}
 
+	private triggerMermaidPrerender(message: AssistantMessage): void {
+		const caps = getCapabilities();
+		if (!caps.images || 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
+		(async () => {
+			for (const content of message.content) {
+				if (content.type === "text" && content.text.trim() && hasPendingMermaid(content.text)) {
+					await prerenderMermaid(content.text);
+				}
+			}
+			this.prerenderInFlight = false;
+			// Invalidate to re-render with cached images
+			this.invalidate();
+		})();
+	}
+
 	updateContent(message: AssistantMessage): void {
 		this.lastMessage = message;
 
 		// 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()),
 		);