@oh-my-pi/pi-coding-agent 15.10.10 → 15.10.12

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";
@@ -64,11 +67,17 @@ import {
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
 import { resolveResumableSession, type SessionInfo, SessionManager } from "./session/session-manager";
-import { resolvePromptInput } from "./system-prompt";
+import { discoverTitleSystemPromptFile, 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>;
@@ -76,8 +85,47 @@ type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promis
 type RunRpcMode = (
 	session: AgentSession,
 	setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
+	eventBus?: EventBus,
 ) => 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 +191,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;
@@ -259,6 +371,7 @@ async function runInteractiveMode(
 	eventBus?: EventBus,
 	initialMessage?: string,
 	initialImages?: ImageContent[],
+	titleSystemPrompt?: string,
 ): Promise<void> {
 	const mode = new InteractiveMode(
 		session,
@@ -268,6 +381,7 @@ async function runInteractiveMode(
 		lspServers,
 		mcpManager,
 		eventBus,
+		titleSystemPrompt,
 	);
 
 	// Cold-launch gate: the full setup wizard (every scene + the overlay and
@@ -361,12 +475,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 +491,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 +555,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 +566,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 +580,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,
@@ -619,7 +727,7 @@ async function buildSessionOptions(
 	sessionManager: SessionManager | undefined,
 	modelRegistry: ModelRegistry,
 	activeSettings: Settings,
-): Promise<{ options: CreateAgentSessionOptions }> {
+): Promise<{ options: CreateAgentSessionOptions; titleSystemPrompt?: string }> {
 	const options: CreateAgentSessionOptions = {
 		cwd: parsed.cwd ?? getProjectDir(),
 		autoApprove: parsed.autoApprove ?? false,
@@ -630,6 +738,8 @@ async function buildSessionOptions(
 	const resolvedSystemPrompt = await resolvePromptInput(systemPromptSource, "system prompt");
 	const appendPromptSource = parsed.appendSystemPrompt ?? discoverAppendSystemPromptFile();
 	const resolvedAppendPrompt = await resolvePromptInput(appendPromptSource, "append system prompt");
+	const titleSystemPromptSource = discoverTitleSystemPromptFile();
+	const titleSystemPrompt = await resolvePromptInput(titleSystemPromptSource, "title system prompt");
 
 	if (sessionManager) {
 		options.sessionManager = sessionManager;
@@ -775,7 +885,7 @@ async function buildSessionOptions(
 		options.additionalExtensionPaths = [];
 	}
 
-	return { options };
+	return { options, titleSystemPrompt };
 }
 
 interface RunRootCommandDependencies {
@@ -792,6 +902,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 +914,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) {
@@ -814,6 +925,7 @@ export async function runRootCommand(
 	if (parsedArgs.listModels !== undefined) {
 		const settingsInstance = await logger.time("settings:init:list-models", Settings.init, {
 			cwd: getProjectDir(),
+			configFiles: parsedArgs.config,
 		});
 		await modelRegistry.refresh("online");
 		const cliExtensionPaths = parsedArgs.noExtensions
@@ -877,11 +989,16 @@ export async function runRootCommand(
 	}
 
 	let cwd = getProjectDir();
-	const settingsInstance = deps.settings ?? (await logger.time("settings:init", Settings.init, { cwd }));
+	const settingsInstance =
+		deps.settings ?? (await logger.time("settings:init", Settings.init, { cwd, configFiles: parsedArgs.config }));
 	if (parsedArgs.approvalMode) {
 		// Runtime override (not persisted): every settings.get("tools.approvalMode") downstream
 		// sees this value. The wrapper still honours --auto-approve / --yolo on top of it.
 		settingsInstance.override("tools.approvalMode", parsedArgs.approvalMode);
+	} else if (parsedArgs.autoApprove) {
+		// --auto-approve / --yolo without an explicit --approval-mode: reflect in settings so
+		// setup-time checks (e.g. #wrapToolForAcpPermission) also see the yolo intent.
+		settingsInstance.override("tools.approvalMode", "yolo");
 	}
 	if (parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui") {
 		applyRpcDefaultSettingOverrides(settingsInstance);
@@ -991,10 +1108,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;
@@ -1025,7 +1144,7 @@ export async function runRootCommand(
 		clearPluginRootsCache: clearPluginRootsAndCaches,
 	});
 
-	const { options: sessionOptions } = await logger.time(
+	const { options: sessionOptions, titleSystemPrompt } = await logger.time(
 		"buildSessionOptions",
 		buildSessionOptions,
 		parsedArgs,
@@ -1086,6 +1205,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 +1239,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,7 +1308,8 @@ 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;
-			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined);
+			stopStartupWatchdog();
+			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined, eventBus);
 		} else if (isInteractive) {
 			const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
 			const changelogMarkdown = await logger.time("main:getChangelogForDisplay", getChangelogForDisplay, parsedArgs);
@@ -1175,6 +1332,7 @@ export async function runRootCommand(
 				}
 			}
 
+			stopStartupWatchdog();
 			logger.endTiming();
 			await runInteractiveMode(
 				session,
@@ -1191,9 +1349,11 @@ export async function runRootCommand(
 				eventBus,
 				initialMessage,
 				initialImages,
+				titleSystemPrompt,
 			);
 		} 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";
@@ -275,6 +276,7 @@ async function runPhase1(options: {
 				apiKey: modelRegistry.resolver(phase1Model.provider, {
 					sessionId: session.sessionId,
 					baseUrl: phase1Model.baseUrl,
+					modelId: phase1Model.id,
 				}),
 				modelMaxTokens: computeModelTokenBudget(phase1Model, config),
 				config,
@@ -435,6 +437,7 @@ async function runPhase2(options: {
 				apiKey: modelRegistry.resolver(phase2Model.provider, {
 					sessionId: session.sessionId,
 					baseUrl: phase2Model.baseUrl,
+					modelId: phase2Model.id,
 				}),
 				metadata: session.agent?.metadataForProvider(phase2Model.provider),
 			});

package/src/memory-backend/index.ts

@@ -14,4 +14,5 @@ export type {
 export * from "./local-backend";
 export * from "./off-backend";
 export * from "./resolve";
+export * from "./runtime";
 export * from "./types";

package/src/memory-backend/local-backend.ts

@@ -27,4 +27,13 @@ export const localBackend: MemoryBackend = {
 	async enqueue(agentDir, cwd) {
 		enqueueMemoryConsolidation(agentDir, cwd);
 	},
+	async status() {
+		return {
+			backend: "local" as const,
+			active: true,
+			writable: false,
+			searchable: false,
+			message: "Local rollout-summary memory is active; structured search/save is not available.",
+		};
+	},
 };

package/src/memory-backend/off-backend.ts

@@ -13,4 +13,13 @@ export const offBackend: MemoryBackend = {
 	},
 	async clear() {},
 	async enqueue() {},
+	async status() {
+		return {
+			backend: "off" as const,
+			active: false,
+			writable: false,
+			searchable: false,
+			message: "Memory backend is off.",
+		};
+	},
 };

package/src/memory-backend/runtime.ts

@@ -0,0 +1,66 @@
+import type { AgentSession } from "../session/agent-session";
+import { resolveMemoryBackend } from "./resolve";
+import type {
+	MemoryBackendId,
+	MemoryBackendOperationContext,
+	MemoryBackendSaveInput,
+	MemoryBackendSearchOptions,
+	MemoryRuntimeContext,
+} from "./types";
+export function createMemoryRuntimeContext(context: MemoryBackendOperationContext): MemoryRuntimeContext {
+	const settings = context.session?.settings;
+	return {
+		async status() {
+			if (!settings) {
+				return {
+					backend: "off" as const,
+					active: false,
+					writable: false,
+					searchable: false,
+					message: "No active agent session.",
+				};
+			}
+			const backend = await resolveMemoryBackend(settings);
+			return backend.status
+				? await backend.status(context)
+				: {
+						backend: backend.id,
+						active: backend.id !== "off",
+						writable: false,
+						searchable: false,
+						message: "This memory backend does not expose structured status.",
+					};
+		},
+		async search(query: string, options?: MemoryBackendSearchOptions) {
+			if (!settings) return unavailableSearch("off", query, "No active agent session.");
+			const backend = await resolveMemoryBackend(settings);
+			return backend.search
+				? await backend.search(context, query, options)
+				: unavailableSearch(backend.id, query, `Memory search is not available for the ${backend.id} backend.`);
+		},
+		async save(input: string | MemoryBackendSaveInput) {
+			if (!settings) return unavailableSave("off", "No active agent session.");
+			const backend = await resolveMemoryBackend(settings);
+			const normalized = typeof input === "string" ? { content: input } : input;
+			return backend.save
+				? await backend.save(context, normalized)
+				: unavailableSave(backend.id, `Memory save is not available for the ${backend.id} backend.`);
+		},
+	};
+}
+
+export function createSessionMemoryRuntimeContext(
+	session: AgentSession,
+	agentDir: string,
+	cwd: string,
+): MemoryRuntimeContext {
+	return createMemoryRuntimeContext({ agentDir, cwd, session });
+}
+
+function unavailableSearch(backend: MemoryBackendId, query: string, message: string) {
+	return { backend, query, count: 0, items: [], message };
+}
+
+function unavailableSave(backend: MemoryBackendId, message: string) {
+	return { backend, stored: 0, message };
+}