@oh-my-pi/pi-coding-agent 15.10.9 → 15.10.11

package/src/main.ts

@@ -11,6 +11,7 @@ import { EventLoopKeepalive } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import {
 	$env,
+	getLogPath,
 	getProjectDir,
 	logger,
 	normalizePathForComparison,
@@ -28,7 +29,7 @@ import { runListModelsCommand } from "./cli/list-models";
 import { selectSession } from "./cli/session-picker";
 import { applyStartupCwd } from "./cli/startup-cwd";
 import { findConfigFile } from "./config";
-import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
+import { ModelRegistry } from "./config/model-registry";
 import {
 	getModelMatchPreferences,
 	resolveCliModel,
@@ -36,6 +37,7 @@ import {
 	resolveModelScope,
 	type ScopedModel,
 } from "./config/model-resolver";
+import { ModelsConfigFile } from "./config/models-config";
 import { getDefault, type SettingPath, Settings, settings } from "./config/settings";
 import { initializeWithSettings } from "./discovery";
 import {
@@ -49,6 +51,7 @@ import { ExtensionRunner } from "./extensibility/extensions/runner";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
 import { scheduleMarketplaceAutoUpdate } from "./extensibility/plugins/marketplace-auto-update";
 import type { MCPManager } from "./mcp";
+import { WelcomeComponent } from "./modes/components/welcome";
 import { InteractiveMode } from "./modes/interactive-mode";
 import type { PrintModeOptions } from "./modes/print-mode";
 import { CURRENT_SETUP_VERSION } from "./modes/setup-version";
@@ -67,8 +70,14 @@ import { resolveResumableSession, type SessionInfo, SessionManager } from "./ses
 import { resolvePromptInput } from "./system-prompt";
 import { initTelemetryExport, isTelemetryExportEnabled } from "./telemetry-export";
 import { AUTO_THINKING } from "./thinking";
-import type { LspStartupServerInfo } from "./tools";
-import { getChangelogPath, getNewEntries, parseChangelog } from "./utils/changelog";
+import { discoverStartupLspServers, type LspStartupServerInfo } from "./tools";
+import {
+	getChangelogPath,
+	getNewEntries,
+	parseChangelog,
+	readLastChangelogVersion,
+	writeLastChangelogVersion,
+} from "./utils/changelog";
 import { EventBus } from "./utils/event-bus";
 
 type RunAcpMode = (createSession: AcpSessionFactory) => Promise<never>;
@@ -78,6 +87,44 @@ type RunRpcMode = (
 	setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
 ) => Promise<never>;
 
+function maybeShowStartupSplash(options: {
+	isInteractive: boolean;
+	resuming: boolean;
+	quiet: boolean;
+	version: string;
+	setupPending: boolean;
+	modelName?: string;
+	providerName?: string;
+	lspServers?: LspStartupServerInfo[];
+}): void {
+	if (!options.isInteractive) return;
+	if (options.resuming || options.quiet) return;
+	if ($env.PI_TIMING) return;
+	if (!process.stdin.isTTY || !process.stdout.isTTY) return;
+	// First-run launches go straight into the setup wizard, which paints its own
+	// splash — keep the minimal two-line notice there.
+	if (options.setupPending) {
+		process.stdout.write(`${chalk.dim(`omp ${options.version}`)}\n${chalk.dim("Initializing session…")}\n`);
+		return;
+	}
+	// Render the same welcome box the TUI paints first: recent sessions as a
+	// loading placeholder (the fixed slot count keeps the box height stable) and
+	// the logo held on the intro animation's first frame so the in-TUI intro
+	// continues from the frame shown here. Clearing the screen first puts the
+	// box at the same origin the TUI's first full paint (clearScrollback) uses,
+	// so the live welcome replaces this frame in place without shifting.
+	const welcome = new WelcomeComponent(
+		options.version,
+		options.modelName ?? "",
+		options.providerName ?? "",
+		null,
+		options.lspServers ?? [],
+	);
+	welcome.holdIntroFirstFrame();
+	const lines = welcome.render(process.stdout.columns || 80);
+	process.stdout.write(`\x1b[2J\x1b[H\x1b[3J\n${lines.join("\n")}\n`);
+}
+
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
 	if (!settings.get("startup.checkUpdate")) {
 		return;
@@ -143,15 +190,79 @@ function applyAcpDefaultSettingOverrides(targetSettings: Settings = settings): v
 
 async function readPipedInput(): Promise<string | undefined> {
 	if (process.stdin.isTTY !== false) return undefined;
+	// stdin is a pipe: a producer that never writes nor closes would block
+	// startup forever with zero output. Say what we're blocked on after 1s.
+	const notice = setTimeout(() => {
+		process.stderr.write(`${chalk.dim("Reading prompt from piped stdin (waiting for EOF; ctrl+c to abort)…")}\n`);
+	}, 1000);
+	notice.unref?.();
 	try {
 		const text = await Bun.stdin.text();
 		if (text.trim().length === 0) return undefined;
 		return text;
 	} catch {
 		return undefined;
+	} finally {
+		clearTimeout(notice);
 	}
 }
 
+// ---------------------------------------------------------------------------
+// Startup watchdog
+// ---------------------------------------------------------------------------
+// Speculative-hang reporter: until startup hands off to a mode runner, print a
+// stderr line every 10s naming the deepest in-flight startup phase. Turns
+// zero-output indefinite hangs (stuck discovery read, network wait, stdin
+// pipe) into self-diagnosing reports instead of "it just hangs" (see the
+// PI_DEBUG_STARTUP markers for the synchronous-hang counterpart).
+
+const STARTUP_WATCHDOG_INTERVAL_MS = 10_000;
+let startupWatchdogTimer: NodeJS.Timeout | undefined;
+let startupWatchdogActive = false;
+let startupWatchdogStartedAt = 0;
+
+function armStartupWatchdog(): void {
+	if (startupWatchdogTimer) return;
+	startupWatchdogTimer = setInterval(() => {
+		const elapsed = Math.round((Date.now() - startupWatchdogStartedAt) / 1000);
+		const phase = logger.openSpanPath().join(" > ") || "module load / pre-phase work";
+		process.stderr.write(
+			`${chalk.yellow(`Still starting after ${elapsed}s`)}${chalk.dim(` — phase: ${phase}`)}\n` +
+				`${chalk.dim(`  logs: ${getLogPath()} · re-run with PI_DEBUG_STARTUP=1 for streaming phase markers`)}\n`,
+		);
+	}, STARTUP_WATCHDOG_INTERVAL_MS);
+	startupWatchdogTimer.unref?.();
+}
+
+function disarmStartupWatchdog(): void {
+	if (!startupWatchdogTimer) return;
+	clearInterval(startupWatchdogTimer);
+	startupWatchdogTimer = undefined;
+}
+
+/** Begin watching startup (idempotent). */
+function startStartupWatchdog(): void {
+	startupWatchdogActive = true;
+	startupWatchdogStartedAt = Date.now();
+	armStartupWatchdog();
+}
+
+/** Permanently stop watching: a mode runner now owns the terminal. */
+function stopStartupWatchdog(): void {
+	startupWatchdogActive = false;
+	disarmStartupWatchdog();
+}
+
+/** Pause while an interactive prompt legitimately waits on the user. */
+function pauseStartupWatchdog(): void {
+	disarmStartupWatchdog();
+}
+
+/** Resume after an interactive prompt, if startup is still being watched. */
+function resumeStartupWatchdog(): void {
+	if (startupWatchdogActive) armStartupWatchdog();
+}
+
 export interface InteractiveModeNotify {
 	kind: "warn" | "error" | "info";
 	message: string;
@@ -361,12 +472,14 @@ async function promptForkSession(session: SessionInfo): Promise<SessionPromptRes
 		return "unavailable";
 	}
 	const message = `Session found in different project: ${session.cwd}. Fork into current directory? [y/N] `;
+	pauseStartupWatchdog();
 	const rl = createInterface({ input: process.stdin, output: process.stdout });
 	try {
 		const answer = (await rl.question(message)).trim().toLowerCase();
 		return answer === "y" || answer === "yes" ? "accepted" : "declined";
 	} finally {
 		rl.close();
+		resumeStartupWatchdog();
 	}
 }
 
@@ -375,12 +488,14 @@ async function promptMoveSession(session: SessionInfo): Promise<SessionPromptRes
 		return "unavailable";
 	}
 	const message = `Session's directory no longer exists (${session.cwd}). Move (re-root) it into the current directory? [Y/n] `;
+	pauseStartupWatchdog();
 	const rl = createInterface({ input: process.stdin, output: process.stdout });
 	try {
 		const answer = (await rl.question(message)).trim().toLowerCase();
 		return answer === "" || answer === "y" || answer === "yes" ? "accepted" : "declined";
 	} finally {
 		rl.close();
+		resumeStartupWatchdog();
 	}
 }
 
@@ -437,7 +552,7 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 		return undefined;
 	}
 
-	const lastVersion = settings.get("lastChangelogVersion");
+	const lastVersion = await readLastChangelogVersion();
 	if (lastVersion === VERSION) {
 		// Steady state: user already saw the current version's changelog. Skip the file read + parse.
 		return undefined;
@@ -448,15 +563,13 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 
 	if (!lastVersion) {
 		if (entries.length > 0) {
-			settings.set("lastChangelogVersion", VERSION);
-			await flushChangelogVersion();
+			await writeLastChangelogVersion(VERSION);
 			return entries.map(e => e.content).join("\n\n");
 		}
 	} else {
 		const newEntries = getNewEntries(entries, lastVersion);
 		if (newEntries.length > 0) {
-			settings.set("lastChangelogVersion", VERSION);
-			await flushChangelogVersion();
+			await writeLastChangelogVersion(VERSION);
 			return newEntries.map(e => e.content).join("\n\n");
 		}
 	}
@@ -464,14 +577,6 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 	return undefined;
 }
 
-async function flushChangelogVersion(): Promise<void> {
-	try {
-		await settings.flush();
-	} catch (error: unknown) {
-		logger.warn("Failed to persist lastChangelogVersion", { error });
-	}
-}
-
 /** Resolves CLI session flags into an existing, forked, in-memory, or cancelled session manager. */
 export async function createSessionManager(
 	parsed: Args,
@@ -792,6 +897,7 @@ export async function runRootCommand(
 	deps: RunRootCommandDependencies = {},
 ): Promise<void> {
 	logger.startTiming();
+	startStartupWatchdog();
 
 	// Initialize theme early with defaults (CLI commands need symbols)
 	// Will be re-initialized with user preferences later
@@ -803,7 +909,7 @@ export async function runRootCommand(
 	const notifs: (InteractiveModeNotify | null)[] = [];
 
 	// Create AuthStorage and ModelRegistry upfront
-	const authStorage = await logger.time("discoverModels", deps.discoverAuthStorage ?? discoverAuthStorage);
+	const authStorage = await logger.time("discoverAuthStorage", deps.discoverAuthStorage ?? discoverAuthStorage);
 	const modelRegistry = new ModelRegistry(authStorage);
 
 	if (parsedArgs.version) {
@@ -991,10 +1097,12 @@ export async function runRootCommand(
 			}
 			startInAllScope = true;
 		}
+		pauseStartupWatchdog();
 		const selected = await logger.time("selectSession", selectSession, folderSessions, {
 			allSessions: preloadedAllSessions,
 			startInAllScope,
 		});
+		resumeStartupWatchdog();
 		if (!selected) {
 			process.stdout.write(`${chalk.dim("No session selected")}\n`);
 			return;
@@ -1086,6 +1194,7 @@ export async function runRootCommand(
 		});
 		// Branch-only protocol runner: keep ACP server code out of normal interactive startup.
 		const runAcpMode = deps.runAcpMode ?? (await import("./modes/acp/acp-mode")).runAcpMode;
+		stopStartupWatchdog();
 		await runAcpMode(createAcpSession);
 	} else {
 		// Resolve extension-registered CLI flags before creating the session so a
@@ -1119,6 +1228,42 @@ export async function runRootCommand(
 			stdinContent: pipedInput,
 		});
 
+		// Resolve the model the session will most likely start with so the splash
+		// box matches the final welcome screen (the raw role selector, e.g.
+		// "anthropic/claude-fable-5:high", is wider than the left column and would
+		// collapse the box into the single-column layout).
+		let splashModel = sessionOptions.model;
+		if (!splashModel) {
+			const remembered = settingsInstance.getModelRole("default");
+			if (remembered) {
+				splashModel = resolveModelRoleValue(remembered, modelRegistry.getAll(), {
+					settings: settingsInstance,
+					matchPreferences: modelMatchPreferences,
+					modelRegistry,
+				}).model;
+			}
+		}
+		// Mirror createAgentSession's startup LSP discovery (sync and cheap: root
+		// markers + binary lookup) so the splash lists the same servers the live
+		// welcome screen will show.
+		const splashLspServers =
+			(sessionOptions.enableLsp ?? true)
+				? discoverStartupLspServers(
+						sessionOptions.cwd ?? cwd,
+						settingsInstance.get("lsp.lazy") ? "available" : "connecting",
+					)
+				: [];
+		maybeShowStartupSplash({
+			isInteractive,
+			resuming: Boolean(parsedArgs.continue || parsedArgs.resume || parsedArgs.fork),
+			quiet: settingsInstance.get("startup.quiet"),
+			version: VERSION,
+			setupPending: deps.forceSetupWizard === true || settingsInstance.get("setupVersion") < CURRENT_SETUP_VERSION,
+			modelName: splashModel?.name,
+			providerName: splashModel?.provider,
+			lspServers: splashLspServers,
+		});
+
 		const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager } = await createSession({
 			...sessionOptions,
 			eventBus,
@@ -1152,6 +1297,7 @@ export async function runRootCommand(
 		if (mode === "rpc" || mode === "rpc-ui") {
 			// Branch-only protocol runner: keep RPC host code out of normal interactive startup.
 			const runRpcMode: RunRpcMode = (await import("./modes/rpc/rpc-mode")).runRpcMode;
+			stopStartupWatchdog();
 			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined);
 		} else if (isInteractive) {
 			const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
@@ -1175,6 +1321,7 @@ export async function runRootCommand(
 				}
 			}
 
+			stopStartupWatchdog();
 			logger.endTiming();
 			await runInteractiveMode(
 				session,
@@ -1194,6 +1341,7 @@ export async function runRootCommand(
 			);
 		} else {
 			// Branch-only single-shot runner: keep print-mode code out of normal interactive startup.
+			stopStartupWatchdog();
 			const runPrintMode: RunPrintMode = (await import("./modes/print-mode")).runPrintMode;
 			await runPrintMode(session, {
 				mode,

package/src/mcp/json-rpc.ts

@@ -6,6 +6,28 @@
  */
 import { logger } from "@oh-my-pi/pi-utils";
 
+/** Hard ceiling on a single MCP HTTP request when the caller provides no signal. */
+const MCP_DEFAULT_TIMEOUT_MS = 60_000;
+
+const SENSITIVE_QUERY_PARAM = /key|token|secret|auth/i;
+
+/**
+ * Redact credential-bearing query params (e.g. `exaApiKey`) so failed
+ * requests never write secrets to the persistent log file.
+ */
+export function redactUrlForLog(url: string): string {
+	try {
+		const parsed = new URL(url);
+		for (const name of parsed.searchParams.keys()) {
+			if (SENSITIVE_QUERY_PARAM.test(name)) parsed.searchParams.set(name, "[redacted]");
+		}
+		return parsed.toString();
+	} catch {
+		// Unparseable URL — drop the query string entirely rather than risk leaking it.
+		return url.split("?")[0];
+	}
+}
+
 /** Parse SSE response format (lines starting with "data: ") */
 export function parseSSE(text: string): unknown {
 	const lines = text.split("\n");
@@ -13,8 +35,12 @@ export function parseSSE(text: string): unknown {
 		if (line.startsWith("data: ")) {
 			const data = line.slice(6).trim();
 			if (data === "[DONE]") continue;
-			const result = JSON.parse(data) as unknown;
-			if (result) return result;
+			try {
+				const result = JSON.parse(data) as unknown;
+				if (result) return result;
+			} catch {
+				// Non-JSON data line (keep-alive/comment) — skip and keep scanning.
+			}
 		}
 	}
 	// Fallback: try parsing entire response as JSON
@@ -71,12 +97,12 @@ export async function callMCP<T = unknown>(
 			Accept: "application/json, text/event-stream",
 		},
 		body: JSON.stringify(body),
-		signal: options?.signal,
+		signal: options?.signal ?? AbortSignal.timeout(MCP_DEFAULT_TIMEOUT_MS),
 	});
 
 	if (!response.ok) {
 		const errorMsg = `MCP request failed: ${response.status} ${response.statusText}`;
-		logger.error(errorMsg, { url, method, params });
+		logger.error(errorMsg, { url: redactUrlForLog(url), method, params });
 		throw new Error(errorMsg);
 	}
 
@@ -84,7 +110,11 @@ export async function callMCP<T = unknown>(
 	const result = parseSSE(text) as JsonRpcResponse<T> | null;
 
 	if (!result) {
-		logger.error("Failed to parse MCP response", { url, method, responseText: text.slice(0, 500) });
+		logger.error("Failed to parse MCP response", {
+			url: redactUrlForLog(url),
+			method,
+			responseText: text.slice(0, 500),
+		});
 		throw new Error("Failed to parse MCP response");
 	}
 

package/src/mcp/transports/stdio.ts

@@ -133,6 +133,12 @@ function resolveComSpec(env: Record<string, string | undefined>): string {
 	return comspec && comspec.length > 0 ? comspec : "cmd.exe";
 }
 
+/** `cmd /s /c` strips one outer quote pair; keep inner argv quotes intact. */
+function buildCmdExeCommand(command: string, args: readonly string[]): string {
+	const quotedCommand = [command, ...args].map(quoteCmdArg).join(" ");
+	return `"${quotedCommand}"`;
+}
+
 /** Resolve the subprocess argv used to launch an MCP stdio server. */
 export async function resolveStdioSpawnCommand(
 	config: MCPStdioServerConfig,
@@ -146,7 +152,7 @@ export async function resolveStdioSpawnCommand(
 	if (!isWindowsBatchCommand(resolvedCommand)) return { cmd: [resolvedCommand, ...args] };
 
 	return {
-		cmd: [resolveComSpec(options.env), "/d", "/s", "/c", [resolvedCommand, ...args].map(quoteCmdArg).join(" ")],
+		cmd: [resolveComSpec(options.env), "/d", "/s", "/c", buildCmdExeCommand(resolvedCommand, args)],
 	};
 }
 

package/src/memories/index.ts

@@ -3,7 +3,8 @@ import type * as fsNode from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import { type ApiKey, clampThinkingLevelForModel, completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
+import { type ApiKey, completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
+import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
 import { getAgentDbPath, getMemoriesDir, logger, parseJsonlLenient, prompt } from "@oh-my-pi/pi-utils";
 
 import type { ModelRegistry } from "../config/model-registry";

package/src/mnemopi/backend.ts

@@ -1,9 +1,9 @@
 import { rm } from "node:fs/promises";
 import * as path from "node:path";
 import { completeSimple } from "@oh-my-pi/pi-ai";
-import { Mnemopi } from "@oh-my-pi/pi-mnemopi";
-import { BankManager } from "@oh-my-pi/pi-mnemopi/core";
-import { type DiagnosticSummary, inspectDatabase } from "@oh-my-pi/pi-mnemopi/diagnose";
+import type { Mnemopi } from "@oh-my-pi/pi-mnemopi";
+import type * as MnemopiDiagnoseNs from "@oh-my-pi/pi-mnemopi/diagnose";
+import type { DiagnosticSummary } from "@oh-my-pi/pi-mnemopi/diagnose";
 import { logger } from "@oh-my-pi/pi-utils";
 
 import type { ModelRegistry } from "../config/model-registry";
@@ -25,10 +25,25 @@ import {
 	getMnemopiScopedBanks,
 	getMnemopiScopedDbPaths,
 	getMnemopiSessionState,
+	loadMnemopi,
+	loadMnemopiCore,
 	MnemopiSessionState,
+	requireMnemopi,
+	requireMnemopiCore,
 	setMnemopiSessionState,
 } from "./state";
 
+// `/diagnose` is the only user of this subpath; load it lazily alongside the
+// loaders in ./state to keep mnemopi off the CLI startup module graph.
+let mnemopiDiagnoseMod: typeof MnemopiDiagnoseNs | undefined;
+
+async function loadMnemopiDiagnose(): Promise<typeof MnemopiDiagnoseNs> {
+	if (!mnemopiDiagnoseMod) {
+		mnemopiDiagnoseMod = await import("@oh-my-pi/pi-mnemopi/diagnose");
+	}
+	return mnemopiDiagnoseMod;
+}
+
 const STATIC_INSTRUCTIONS = [
 	"# Memory",
 	"This agent has local Mnemopi long-term memory.",
@@ -68,6 +83,7 @@ export const mnemopiBackend: MemoryBackend = {
 
 		try {
 			const config = await loadMnemopiConfigWithProviders(settings, agentDir, modelRegistry, sessionId);
+			await Promise.all([loadMnemopi(), loadMnemopiCore()]);
 			const state = new MnemopiSessionState({ sessionId, config, session });
 			const previous = setMnemopiSessionState(session, state);
 			previous?.dispose();
@@ -97,6 +113,7 @@ export const mnemopiBackend: MemoryBackend = {
 		previous?.dispose();
 		const config = previous?.config ?? (session ? loadMnemopiConfig(session.settings, agentDir) : undefined);
 		if (!config) return;
+		await loadMnemopiCore();
 		await removeDbFiles(getMnemopiScopedDbPaths(config));
 	},
 
@@ -110,6 +127,7 @@ export const mnemopiBackend: MemoryBackend = {
 					session.modelRegistry,
 					session.sessionId,
 				);
+				await Promise.all([loadMnemopi(), loadMnemopiCore()]);
 				state = new MnemopiSessionState({ sessionId: session.sessionId, config, session });
 				setMnemopiSessionState(session, state);
 			}
@@ -124,6 +142,7 @@ export const mnemopiBackend: MemoryBackend = {
 	},
 
 	async stats(agentDir, _cwd, session): Promise<string | undefined> {
+		await Promise.all([loadMnemopi(), loadMnemopiCore()]);
 		const { targets, owned } = createStatsTargets(agentDir, session);
 		try {
 			if (targets.length === 0) return undefined;
@@ -137,6 +156,7 @@ export const mnemopiBackend: MemoryBackend = {
 		const state = getMnemopiSessionState(session);
 		const config = state?.config ?? (session ? loadMnemopiConfig(session.settings, agentDir) : undefined);
 		if (!config) return undefined;
+		const [{ inspectDatabase }] = await Promise.all([loadMnemopiDiagnose(), loadMnemopiCore()]);
 		const banks = getMnemopiScopedBanks(config);
 		const dbPaths = getMnemopiScopedDbPaths(config);
 		const summaries = dbPaths.map((dbPath, index) => ({
@@ -179,6 +199,7 @@ function createStatsTargets(
 
 function createStatsMemory(config: MnemopiBackendConfig, bank: string): Mnemopi {
 	const providerOptions = config.providerOptions as Record<string, unknown>;
+	const { Mnemopi } = requireMnemopi();
 	return new Mnemopi({
 		dbPath: resolveBankDbPath(config, bank),
 		bank,
@@ -193,6 +214,7 @@ function createStatsMemory(config: MnemopiBackendConfig, bank: string): Mnemopi
 function resolveBankDbPath(config: MnemopiBackendConfig, bank: string): string {
 	const sharedBank = config.globalBank ?? config.baseBank ?? "default";
 	if (bank === sharedBank) return config.dbPath;
+	const { BankManager } = requireMnemopiCore();
 	return new BankManager(path.dirname(config.dbPath)).getBankDbPath(bank);
 }
 

package/src/mnemopi/state.ts

@@ -1,7 +1,8 @@
 import { dirname } from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import { Mnemopi, type RecallResult } from "@oh-my-pi/pi-mnemopi";
-import { BankManager } from "@oh-my-pi/pi-mnemopi/core";
+import type * as MnemopiNs from "@oh-my-pi/pi-mnemopi";
+import type { Mnemopi, RecallResult } from "@oh-my-pi/pi-mnemopi";
+import type * as MnemopiCoreNs from "@oh-my-pi/pi-mnemopi/core";
 import { logger } from "@oh-my-pi/pi-utils";
 import {
 	composeRecallQuery,
@@ -13,6 +14,39 @@ import { extractMessages } from "../hindsight/transcript";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { MnemopiBackendConfig, MnemopiScoping } from "./config";
 
+// The mnemopi package pulls the embeddings stack; keep it off the CLI startup
+// module graph by loading it lazily at the async boundaries that need it.
+let mnemopiMod: typeof MnemopiNs | undefined;
+let mnemopiCoreMod: typeof MnemopiCoreNs | undefined;
+
+/** Lazily load `@oh-my-pi/pi-mnemopi` (memoized). */
+export async function loadMnemopi(): Promise<typeof MnemopiNs> {
+	if (!mnemopiMod) {
+		mnemopiMod = await import("@oh-my-pi/pi-mnemopi");
+	}
+	return mnemopiMod;
+}
+
+/** Lazily load `@oh-my-pi/pi-mnemopi/core` (memoized). */
+export async function loadMnemopiCore(): Promise<typeof MnemopiCoreNs> {
+	if (!mnemopiCoreMod) {
+		mnemopiCoreMod = await import("@oh-my-pi/pi-mnemopi/core");
+	}
+	return mnemopiCoreMod;
+}
+
+/** Sync access for code below an async boundary that already awaited {@link loadMnemopi}. */
+export function requireMnemopi(): typeof MnemopiNs {
+	if (!mnemopiMod) throw new Error("Mnemopi module not loaded; await loadMnemopi() first.");
+	return mnemopiMod;
+}
+
+/** Sync access for code below an async boundary that already awaited {@link loadMnemopiCore}. */
+export function requireMnemopiCore(): typeof MnemopiCoreNs {
+	if (!mnemopiCoreMod) throw new Error("Mnemopi core module not loaded; await loadMnemopiCore() first.");
+	return mnemopiCoreMod;
+}
+
 const kMnemopiSessionState = Symbol("mnemopi.sessionState");
 
 interface AgentSessionWithMnemopiState extends AgentSession {
@@ -460,6 +494,7 @@ function escapeRegExp(text: string): string {
 }
 function createMemory(config: MnemopiBackendConfig, bank: string): Mnemopi {
 	const providerOptions = config.providerOptions as Record<string, unknown>;
+	const { Mnemopi } = requireMnemopi();
 	return new Mnemopi({
 		dbPath: resolveBankDbPath(config, bank),
 		bank,
@@ -474,6 +509,7 @@ function createMemory(config: MnemopiBackendConfig, bank: string): Mnemopi {
 function resolveBankDbPath(config: MnemopiBackendConfig, bank: string): string {
 	const sharedBank = config.globalBank ?? config.baseBank ?? "default";
 	if (bank === sharedBank) return config.dbPath;
+	const { BankManager } = requireMnemopiCore();
 	return new BankManager(dirname(config.dbPath)).getBankDbPath(bank);
 }
 

package/src/modes/components/agent-dashboard.ts

@@ -194,7 +194,7 @@ class AgentListPane implements Component {
 		private readonly maxVisible: number,
 	) {}
 
-	render(width: number): string[] {
+	render(width: number): readonly string[] {
 		const lines: string[] = [];
 		const searchPrefix = theme.fg("muted", "Search: ");
 		const searchText = this.searchQuery || theme.fg("dim", "type to filter");
@@ -255,7 +255,7 @@ class AgentInspectorPane implements Component {
 		private readonly effectiveResolution: ModelResolution | undefined,
 	) {}
 
-	render(width: number): string[] {
+	render(width: number): readonly string[] {
 		if (!this.agent) {
 			return [theme.fg("muted", "Select an agent"), theme.fg("dim", "to inspect settings")];
 		}
@@ -314,7 +314,7 @@ class TwoColumnBody implements Component {
 		private readonly maxHeight: number,
 	) {}
 
-	render(width: number): string[] {
+	render(width: number): readonly string[] {
 		const leftWidth = Math.floor(width * 0.5);
 		const rightWidth = width - leftWidth - 3;
 		const leftLines = this.leftPane.render(leftWidth);
@@ -507,7 +507,7 @@ export class AgentDashboard extends Container {
 		return Math.max(3, this.#computeBodyHeight() - 3);
 	}
 
-	override render(width: number): string[] {
+	override render(width: number): readonly string[] {
 		// Rebuild when terminal geometry changes so the full-screen overlay
 		// re-fits on resize.
 		if (this.#terminalRows() !== this.#builtRows || this.#uiWidth() !== this.#builtCols) {
@@ -516,10 +516,13 @@ export class AgentDashboard extends Container {
 		const lines = super.render(width);
 		// Pad to the full viewport so every state (list, edit, create) covers the
 		// screen as a true full-screen view instead of letting the transcript peek
-		// through below it.
+		// through below it. Copy before padding — the container's render result is
+		// component-owned and must not be mutated.
 		const rows = this.#terminalRows();
-		while (lines.length < rows) lines.push("");
-		return lines;
+		if (lines.length >= rows) return lines;
+		const padded = lines.slice();
+		while (padded.length < rows) padded.push("");
+		return padded;
 	}
 
 	#clampSelection(): void {