@oh-my-pi/pi-coding-agent 12.17.0 → 12.18.0

package/src/main.ts

@@ -11,7 +11,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
 import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
-import { $env, postmortem } from "@oh-my-pi/pi-utils";
+import { $env, logger, postmortem } from "@oh-my-pi/pi-utils";
 import { getProjectDir, setProjectDir, VERSION } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
 import type { Args } from "./cli/args";
@@ -32,10 +32,6 @@ import type { AgentSession } from "./session/agent-session";
 import { type SessionInfo, SessionManager } from "./session/session-manager";
 import { resolvePromptInput } from "./system-prompt";
 import { getChangelogPath, getNewEntries, parseChangelog } from "./utils/changelog";
-import { printTimings, time } from "./utils/timings";
-
-/** Conditional startup debug prints (stderr) when PI_DEBUG_STARTUP is set */
-const debugStartup = $env.PI_DEBUG_STARTUP ? (stage: string) => process.stderr.write(`[startup] ${stage}\n`) : () => {};
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
 	try {
@@ -497,28 +493,25 @@ async function buildSessionOptions(
 }
 
 export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<void> {
-	time("start");
-	debugStartup("main:entry");
+	logger.startTiming();
 
 	// Initialize theme early with defaults (CLI commands need symbols)
 	// Will be re-initialized with user preferences later
-	await initTheme();
-	debugStartup("main:initTheme");
+	await logger.timeAsync("initTheme:initial", () => initTheme());
 
 	const parsedArgs = parsed;
-	debugStartup("main:parseArgs");
-	time("parseArgs");
-	await maybeAutoChdir(parsedArgs);
+	await logger.timeAsync("maybeAutoChdir", () => maybeAutoChdir(parsedArgs));
 
 	const notifs: (InteractiveModeNotify | null)[] = [];
 
 	// Create AuthStorage and ModelRegistry upfront
-	const authStorage = await discoverAuthStorage();
-	const modelRegistry = new ModelRegistry(authStorage);
-	const refreshStrategy = parsedArgs.listModels !== undefined ? "online" : "online-if-uncached";
-	await modelRegistry.refresh(refreshStrategy);
-	debugStartup("main:discoverModels");
-	time("discoverModels");
+	const { authStorage, modelRegistry } = await logger.timeAsync("discoverModels", async () => {
+		const authStorage = await discoverAuthStorage();
+		const modelRegistry = new ModelRegistry(authStorage);
+		const refreshStrategy = parsedArgs.listModels !== undefined ? "online" : "online-if-uncached";
+		await modelRegistry.refresh(refreshStrategy);
+		return { authStorage, modelRegistry };
+	});
 
 	if (parsedArgs.version) {
 		writeStdout(VERSION);
@@ -551,26 +544,33 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	}
 
 	const cwd = getProjectDir();
-	await Settings.init({ cwd });
-	debugStartup("main:Settings.init");
-	time("Settings.init");
+	await logger.timeAsync("settings:init", () => Settings.init({ cwd }));
 	if (parsedArgs.noPty) {
 		settings.override("bash.virtualTerminal", "off");
 		Bun.env.PI_NO_PTY = "1";
 	}
-	const pipedInput = await readPipedInput();
-	let { initialMessage, initialImages } = await prepareInitialMessage(parsedArgs, settings.get("images.autoResize"));
-	if (pipedInput) {
-		initialMessage = initialMessage ? `${initialMessage}\n${pipedInput}` : pipedInput;
-	}
-	time("prepareInitialMessage");
+	const {
+		pipedInput,
+		initialMessage: initMsg,
+		initialImages,
+	} = await logger.timeAsync("prepareInitialMessage", async () => {
+		const pipedInput = await readPipedInput();
+		let { initialMessage, initialImages } = await prepareInitialMessage(
+			parsedArgs,
+			settings.get("images.autoResize"),
+		);
+		if (pipedInput) {
+			initialMessage = initialMessage ? `${initialMessage}\n${pipedInput}` : pipedInput;
+		}
+		return { pipedInput, initialMessage, initialImages };
+	});
+	const initialMessage = initMsg;
 	const autoPrint = pipedInput !== undefined && !parsedArgs.print && parsedArgs.mode === undefined;
 	const isInteractive = !parsedArgs.print && !autoPrint && parsedArgs.mode === undefined;
 	const mode = parsedArgs.mode || "text";
 
 	// Initialize discovery system with settings for provider persistence
-	initializeWithSettings(settings);
-	time("initializeWithSettings");
+	logger.time("initializeWithSettings", () => initializeWithSettings(settings));
 
 	// Apply model role overrides from CLI args or env vars (ephemeral, not persisted)
 	const smolModel = parsedArgs.smol ?? $env.PI_SMOL_MODEL;
@@ -584,15 +584,15 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		});
 	}
 
-	await initTheme(
-		isInteractive,
-		settings.get("symbolPreset"),
-		settings.get("colorBlindMode"),
-		settings.get("theme.dark"),
-		settings.get("theme.light"),
+	await logger.timeAsync("initTheme:final", () =>
+		initTheme(
+			isInteractive,
+			settings.get("symbolPreset"),
+			settings.get("colorBlindMode"),
+			settings.get("theme.dark"),
+			settings.get("theme.light"),
+		),
 	);
-	debugStartup("main:initTheme2");
-	time("initTheme");
 
 	let scopedModels: ScopedModel[] = [];
 	const modelPatterns = parsedArgs.models ?? settings.get("enabledModels");
@@ -600,25 +600,24 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		usageOrder: settings.getStorage()?.getModelUsageOrder(),
 	};
 	if (modelPatterns && modelPatterns.length > 0) {
-		scopedModels = await resolveModelScope(modelPatterns, modelRegistry, modelMatchPreferences);
-		time("resolveModelScope");
+		scopedModels = await logger.timeAsync("resolveModelScope", () =>
+			resolveModelScope(modelPatterns, modelRegistry, modelMatchPreferences),
+		);
 	}
 
 	// Create session manager based on CLI flags
-	let sessionManager = await createSessionManager(parsedArgs, cwd);
-	debugStartup("main:createSessionManager");
-	time("createSessionManager");
+	let sessionManager = await logger.timeAsync("createSessionManager", () => createSessionManager(parsedArgs, cwd));
 
 	// Handle --resume (no value): show session picker
 	if (parsedArgs.resume === true) {
-		const sessions = await SessionManager.list(cwd, parsedArgs.sessionDir);
-		time("SessionManager.list");
+		const sessions = await logger.timeAsync("SessionManager.list", () =>
+			SessionManager.list(cwd, parsedArgs.sessionDir),
+		);
 		if (sessions.length === 0) {
 			writeStdout(chalk.dim("No sessions found"));
 			return;
 		}
-		const selectedPath = await selectSession(sessions);
-		time("selectSession");
+		const selectedPath = await logger.timeAsync("selectSession", () => selectSession(sessions));
 		if (!selectedPath) {
 			writeStdout(chalk.dim("No session selected"));
 			return;
@@ -626,13 +625,9 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		sessionManager = await SessionManager.open(selectedPath);
 	}
 
-	const { options: sessionOptions, cliThinkingFromModel } = await buildSessionOptions(
-		parsedArgs,
-		scopedModels,
-		sessionManager,
-		modelRegistry,
+	const { options: sessionOptions, cliThinkingFromModel } = await logger.timeAsync("buildSessionOptions", () =>
+		buildSessionOptions(parsedArgs, scopedModels, sessionManager, modelRegistry),
 	);
-	debugStartup("main:buildSessionOptions");
 	sessionOptions.authStorage = authStorage;
 	sessionOptions.modelRegistry = modelRegistry;
 	sessionOptions.hasUI = isInteractive;
@@ -650,11 +645,10 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		}
 	}
 
-	time("buildSessionOptions");
-	const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager } =
-		await createAgentSession(sessionOptions);
-	debugStartup("main:createAgentSession");
-	time("createAgentSession");
+	const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager } = await logger.timeAsync(
+		"createAgentSession",
+		() => createAgentSession(sessionOptions),
+	);
 	if (parsedArgs.apiKey && !sessionOptions.model && session.model) {
 		authStorage.setRuntimeApiKey(session.model.provider, parsedArgs.apiKey);
 	}
@@ -692,8 +686,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 			}
 		}
 	}
-	time("applyExtensionFlags");
-	debugStartup("main:applyExtensionFlags");
 
 	if (!isInteractive && !session.model) {
 		if (modelFallbackMessage) {
@@ -739,8 +731,11 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 			writeStdout(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
 		}
 
-		printTimings();
-		debugStartup("main:runInteractiveMode:start");
+		if ($env.PI_TIMING === "1") {
+			logger.printTimings();
+		}
+
+		logger.endTiming();
 		await runInteractiveMode(
 			session,
 			VERSION,

package/src/mcp/config.ts

@@ -18,6 +18,8 @@ export interface LoadMCPConfigsOptions {
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
 	filterExa?: boolean;
+	/** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+	filterBrowser?: boolean;
 }
 
 /** Result of loading MCP configs */
@@ -91,6 +93,7 @@ function convertToLegacyConfig(server: MCPServer): MCPServerConfig {
 export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOptions): Promise<LoadMCPConfigsResult> {
 	const enableProjectConfig = options?.enableProjectConfig ?? true;
 	const filterExa = options?.filterExa ?? true;
+	const filterBrowser = options?.filterBrowser ?? false;
 
 	// Load MCP servers via capability system
 	const result = await loadCapability<MCPServer>(mcpCapability.id, { cwd });
@@ -103,8 +106,8 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 	// Load user-level disabled servers list
 	const disabledServers = new Set(await readDisabledServers(getMCPConfigPath("user", cwd)));
 	// Convert to legacy format and preserve source metadata
-	const configs: Record<string, MCPServerConfig> = {};
-	const sources: Record<string, SourceMeta> = {};
+	let configs: Record<string, MCPServerConfig> = {};
+	let sources: Record<string, SourceMeta> = {};
 	for (const server of servers) {
 		const config = convertToLegacyConfig(server);
 		if (config.enabled === false || (server._source.level !== "user" && disabledServers.has(server.name))) {
@@ -114,11 +117,19 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 		sources[server.name] = server._source;
 	}
 
-	const exaApiKeys: string[] = [];
+	let exaApiKeys: string[] = [];
 
 	if (filterExa) {
-		const filterResult = filterExaMCPServers(configs, sources);
-		return { configs: filterResult.configs, exaApiKeys: filterResult.exaApiKeys, sources: filterResult.sources };
+		const exaResult = filterExaMCPServers(configs, sources);
+		configs = exaResult.configs;
+		sources = exaResult.sources;
+		exaApiKeys = exaResult.exaApiKeys;
+	}
+
+	if (filterBrowser) {
+		const browserResult = filterBrowserMCPServers(configs, sources);
+		configs = browserResult.configs;
+		sources = browserResult.sources;
 	}
 
 	return { configs, exaApiKeys, sources };
@@ -264,3 +275,89 @@ export function validateServerConfig(name: string, config: MCPServerConfig): str
 
 	return errors;
 }
+
+/** Known browser automation MCP server names (lowercase) */
+const BROWSER_MCP_NAMES = new Set([
+	"puppeteer",
+	"playwright",
+	"browserbase",
+	"browser-tools",
+	"browser-use",
+	"browser",
+]);
+
+/** Patterns matching browser MCP package names in command/args */
+const BROWSER_MCP_PKG_PATTERN =
+	// Official packages
+	// - @modelcontextprotocol/server-puppeteer
+	// - @playwright/mcp
+	// - @browserbasehq/mcp-server-browserbase
+	// - @agentdeskai/browser-tools-mcp
+	// - @agent-infra/mcp-server-browser
+	// Community packages: puppeteer-mcp-server, playwright-mcp, pptr-mcp, etc.
+	/(?:@modelcontextprotocol\/server-puppeteer|@playwright\/mcp|@browserbasehq\/mcp-server-browserbase|@agentdeskai\/browser-tools-mcp|@agent-infra\/mcp-server-browser|puppeteer-mcp|playwright-mcp|pptr-mcp|browser-use-mcp|mcp-browser-use)/i;
+
+/** URL patterns for hosted browser MCP services */
+const BROWSER_MCP_URL_PATTERN = /browserbase\.com|browser-use\.com/i;
+
+/**
+ * Check if a server config is a browser automation MCP server.
+ */
+export function isBrowserMCPServer(name: string, config: MCPServerConfig): boolean {
+	// Check by server name
+	if (BROWSER_MCP_NAMES.has(name.toLowerCase())) {
+		return true;
+	}
+
+	// Check by URL for HTTP/SSE servers
+	if (config.type === "http" || config.type === "sse") {
+		const httpConfig = config as { url?: string };
+		if (httpConfig.url && BROWSER_MCP_URL_PATTERN.test(httpConfig.url)) {
+			return true;
+		}
+	}
+
+	// Check by command/args for stdio servers
+	if (!config.type || config.type === "stdio") {
+		const stdioConfig = config as { command?: string; args?: string[] };
+		if (stdioConfig.command && BROWSER_MCP_PKG_PATTERN.test(stdioConfig.command)) {
+			return true;
+		}
+		if (stdioConfig.args?.some(arg => BROWSER_MCP_PKG_PATTERN.test(arg))) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/** Result of filtering browser MCP servers */
+export interface BrowserFilterResult {
+	/** Configs with browser servers removed */
+	configs: Record<string, MCPServerConfig>;
+	/** Source metadata for remaining servers */
+	sources: Record<string, SourceMeta>;
+}
+
+/**
+ * Filter out browser automation MCP servers.
+ * Since we have a native browser tool, we don't need these MCP servers.
+ */
+export function filterBrowserMCPServers(
+	configs: Record<string, MCPServerConfig>,
+	sources: Record<string, SourceMeta>,
+): BrowserFilterResult {
+	const filtered: Record<string, MCPServerConfig> = {};
+	const filteredSources: Record<string, SourceMeta> = {};
+
+	for (const [name, config] of Object.entries(configs)) {
+		if (!isBrowserMCPServer(name, config)) {
+			filtered[name] = config;
+			if (sources[name]) {
+				filteredSources[name] = sources[name];
+			}
+		}
+	}
+
+	return { configs: filtered, sources: filteredSources };
+}

package/src/mcp/index.ts

@@ -8,10 +8,12 @@
 // Client
 export { callTool, connectToServer, disconnectServer, listTools, serverSupportsTools } from "./client";
 // Config
-export type { ExaFilterResult, LoadMCPConfigsOptions, LoadMCPConfigsResult } from "./config";
+export type { BrowserFilterResult, ExaFilterResult, LoadMCPConfigsOptions, LoadMCPConfigsResult } from "./config";
 export {
 	extractExaApiKey,
+	filterBrowserMCPServers,
 	filterExaMCPServers,
+	isBrowserMCPServer,
 	isExaMCPServer,
 	loadAllMCPConfigs,
 	validateServerConfig,

package/src/mcp/loader.ts

@@ -32,6 +32,8 @@ export interface MCPToolsLoadOptions {
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
 	filterExa?: boolean;
+	/** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+	filterBrowser?: boolean;
 	/** SQLite storage for MCP tool cache (null disables cache) */
 	cacheStorage?: AgentStorage | null;
 	/** Auth storage used to resolve OAuth credentials before initial MCP connect */
@@ -69,6 +71,7 @@ export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoa
 			onConnecting: options?.onConnecting,
 			enableProjectConfig: options?.enableProjectConfig,
 			filterExa: options?.filterExa,
+			filterBrowser: options?.filterBrowser,
 		});
 	} catch (error) {
 		// If discovery fails entirely, return empty result

package/src/mcp/manager.ts

@@ -68,6 +68,8 @@ export interface MCPDiscoverOptions {
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
 	filterExa?: boolean;
+	/** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+	filterBrowser?: boolean;
 	/** Called when starting to connect to servers */
 	onConnecting?: (serverNames: string[]) => void;
 }
@@ -105,6 +107,7 @@ export class MCPManager {
 		const { configs, exaApiKeys, sources } = await loadAllMCPConfigs(this.cwd, {
 			enableProjectConfig: options?.enableProjectConfig,
 			filterExa: options?.filterExa,
+			filterBrowser: options?.filterBrowser,
 		});
 		const result = await this.connectServers(configs, sources, options?.onConnecting);
 		result.exaApiKeys = exaApiKeys;

package/src/modes/controllers/extension-ui-controller.ts

@@ -48,7 +48,7 @@ export class ExtensionUiController {
 			setWorkingMessage: message => this.ctx.setWorkingMessage(message),
 			setWidget: (key, content) => this.setHookWidget(key, content),
 			setTitle: title => setTerminalTitle(title),
-			custom: (factory, _options) => this.showHookCustom(factory),
+			custom: (factory, options) => this.showHookCustom(factory, options),
 			setEditorText: text => this.ctx.editor.setText(text),
 			pasteToEditor: text => {
 				this.ctx.editor.handleInput(`\x1b[200~${text}\x1b[201~`);
@@ -702,25 +702,47 @@ export class ExtensionUiController {
 			keybindings: KeybindingsManager,
 			done: (result: T) => void,
 		) => (Component & { dispose?(): void }) | Promise<Component & { dispose?(): void }>,
+		options?: { overlay?: boolean },
 	): Promise<T> {
 		const savedText = this.ctx.editor.getText();
 		const keybindings = KeybindingsManager.inMemory();
 
 		const { promise, resolve } = Promise.withResolvers<T>();
-		let component: Component & { dispose?(): void };
+		let component: (Component & { dispose?(): void }) | undefined;
+		let overlayHandle: OverlayHandle | undefined;
+		let closed = false;
 
 		const close = (result: T) => {
-			component.dispose?.();
-			this.ctx.editorContainer.clear();
-			this.ctx.editorContainer.addChild(this.ctx.editor);
-			this.ctx.editor.setText(savedText);
+			if (closed) return;
+			closed = true;
+			component?.dispose?.();
+			overlayHandle?.hide();
+			overlayHandle = undefined;
+			if (!options?.overlay) {
+				this.ctx.editorContainer.clear();
+				this.ctx.editorContainer.addChild(this.ctx.editor);
+				this.ctx.editor.setText(savedText);
+			}
 			this.ctx.ui.setFocus(this.ctx.editor);
 			this.ctx.ui.requestRender();
 			resolve(result);
 		};
 
 		Promise.try(() => factory(this.ctx.ui, theme, keybindings, close)).then(c => {
+			if (closed) {
+				c.dispose?.();
+				return;
+			}
 			component = c;
+			if (options?.overlay) {
+				overlayHandle = this.ctx.ui.showOverlay(component, {
+					anchor: "bottom-center",
+					width: "100%",
+					maxHeight: "100%",
+					margin: 0,
+				});
+				return;
+			}
 			this.ctx.editorContainer.clear();
 			this.ctx.editorContainer.addChild(component);
 			this.ctx.ui.setFocus(component);

package/src/modes/interactive-mode.ts

@@ -15,7 +15,7 @@ import {
 	Text,
 	TUI,
 } from "@oh-my-pi/pi-tui";
-import { $env, hsvToRgb, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
+import { hsvToRgb, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
 import { APP_NAME, getProjectDir } from "@oh-my-pi/pi-utils/dirs";
 import chalk from "chalk";
 import { KeybindingsManager } from "../config/keybindings";
@@ -57,9 +57,6 @@ import { getEditorTheme, getMarkdownTheme, onThemeChange, theme } from "./theme/
 import type { CompactionQueuedMessage, InteractiveModeContext, TodoItem } from "./types";
 import { UiHelpers } from "./utils/ui-helpers";
 
-/** Conditional startup debug prints (stderr) when PI_DEBUG_STARTUP is set */
-const debugStartup = $env.PI_DEBUG_STARTUP ? (stage: string) => process.stderr.write(`[startup] ${stage}\n`) : () => {};
-
 const TODO_FILE_NAME = "todos.json";
 const EDITOR_MAX_HEIGHT_MIN = 6;
 const EDITOR_MAX_HEIGHT_MAX = 18;
@@ -258,28 +255,29 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	async init(): Promise<void> {
 		if (this.isInitialized) return;
-		debugStartup("InteractiveMode.init:entry");
 
-		this.keybindings = await KeybindingsManager.create();
-		debugStartup("InteractiveMode.init:keybindings");
+		this.keybindings = await logger.timeAsync("InteractiveMode.init:keybindings", () => KeybindingsManager.create());
 
 		// Register session manager flush for signal handlers (SIGINT, SIGTERM, SIGHUP)
 		this.#cleanupUnsubscribe = postmortem.register("session-manager-flush", () => this.sessionManager.flush());
-		debugStartup("InteractiveMode.init:cleanupRegistered");
 
-		await this.refreshSlashCommandState(getProjectDir());
-		debugStartup("InteractiveMode.init:slashCommands");
+		await logger.timeAsync("InteractiveMode.init:slashCommands", () =>
+			this.refreshSlashCommandState(getProjectDir()),
+		);
 
 		// Get current model info for welcome screen
 		const modelName = this.session.model?.name ?? "Unknown";
 		const providerName = this.session.model?.provider ?? "Unknown";
 
 		// Get recent sessions
-		const recentSessions = (await getRecentSessions(this.sessionManager.getSessionDir())).map(s => ({
-			name: s.name,
-			timeAgo: s.timeAgo,
-		}));
-		debugStartup("InteractiveMode.init:recentSessions");
+		const recentSessions = await logger.timeAsync("InteractiveMode.init:recentSessions", () =>
+			getRecentSessions(this.sessionManager.getSessionDir()).then(sessions =>
+				sessions.map(s => ({
+					name: s.name,
+					timeAgo: s.timeAgo,
+				})),
+			),
+		);
 
 		// Convert LSP servers to welcome format
 		const lspServerInfo =
@@ -293,9 +291,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		if (!startupQuiet) {
 			// Add welcome header
-			debugStartup("InteractiveMode.init:welcomeComponent:start");
 			const welcome = new WelcomeComponent(this.#version, modelName, providerName, recentSessions, lspServerInfo);
-			debugStartup("InteractiveMode.init:welcomeComponent:created");
 
 			// Setup UI layout
 			this.ui.addChild(new Spacer(1));
@@ -1248,8 +1244,9 @@ export class InteractiveMode implements InteractiveModeContext {
 			keybindings: KeybindingsManager,
 			done: (result: T) => void,
 		) => (Component & { dispose?(): void }) | Promise<Component & { dispose?(): void }>,
+		options?: { overlay?: boolean },
 	): Promise<T> {
-		return this.#extensionUiController.showHookCustom(factory);
+		return this.#extensionUiController.showHookCustom(factory, options);
 	}
 
 	showExtensionError(extensionPath: string, error: string): void {

package/src/modes/types.ts

@@ -215,6 +215,7 @@ export interface InteractiveModeContext {
 			keybindings: KeybindingsManager,
 			done: (result: T) => void,
 		) => (Component & { dispose?(): void }) | Promise<Component & { dispose?(): void }>,
+		options?: { overlay?: boolean },
 	): Promise<T>;
 	showExtensionError(extensionPath: string, error: string): void;
 	showToolError(toolName: string, error: string): void;

package/src/modes/utils/ui-helpers.ts

@@ -278,6 +278,13 @@ export class UiHelpers {
 	}
 
 	renderInitialMessages(): void {
+		// This path is used to rebuild the visible chat transcript (e.g. after custom/debug UI).
+		// Clear existing rendered chat first to avoid duplicating the full session in the container.
+		this.ctx.chatContainer.clear();
+		this.ctx.pendingMessagesContainer.clear();
+		this.ctx.pendingBashComponents = [];
+		this.ctx.pendingPythonComponents = [];
+
 		// Get aligned messages and entries from session context
 		const context = this.ctx.sessionManager.buildSessionContext();
 		this.ctx.renderSessionContext(context, {