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

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, {

package/src/sdk.ts

@@ -83,10 +83,6 @@ import {
 import { ToolContextStore } from "./tools/context";
 import { getGeminiImageTools } from "./tools/gemini-image";
 import { EventBus } from "./utils/event-bus";
-import { 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`) : () => {};
 
 // Types
 export interface CreateAgentSessionOptions {
@@ -540,7 +536,6 @@ function createCustomToolsExtension(tools: CustomTool[]): ExtensionFactory {
  * ```
  */
 export async function createAgentSession(options: CreateAgentSessionOptions = {}): Promise<CreateAgentSessionResult> {
-	debugStartup("sdk:createAgentSession:entry");
 	const cwd = options.cwd ?? getProjectDir();
 	const agentDir = options.agentDir ?? getDefaultAgentDir();
 	const eventBus = options.eventBus ?? new EventBus();
@@ -549,17 +544,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	registerPythonCleanup();
 
 	// Use provided or create AuthStorage and ModelRegistry
-	const authStorage = options.authStorage ?? (await discoverAuthStorage(agentDir));
-	const modelRegistry = options.modelRegistry ?? new ModelRegistry(authStorage);
-	if (!options.modelRegistry) {
-		await modelRegistry.refresh();
-	}
-	time("discoverModels");
+	const { authStorage, modelRegistry } = await logger.timeAsync("discoverModels", async () => {
+		const authStorage = options.authStorage ?? (await discoverAuthStorage(agentDir));
+		const modelRegistry = options.modelRegistry ?? new ModelRegistry(authStorage);
+		if (!options.modelRegistry) {
+			await modelRegistry.refresh();
+		}
+		return { authStorage, modelRegistry };
+	});
 
-	const settings = options.settings ?? (await Settings.init({ cwd, agentDir }));
-	time("settings");
-	initializeWithSettings(settings);
-	time("initializeWithSettings");
+	const settings = await logger.timeAsync(
+		"settings",
+		async () => options.settings ?? (await Settings.init({ cwd, agentDir })),
+	);
+	logger.time("initializeWithSettings", initializeWithSettings, settings);
 	const skillsSettings = settings.getGroup("skills") as SkillsSettings;
 	const discoveredSkillsPromise =
 		options.skills === undefined ? discoverSkills(cwd, agentDir, skillsSettings) : undefined;
@@ -568,8 +566,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	setPreferredSearchProvider(settings.get("providers.webSearch") ?? "auto");
 	setPreferredImageProvider(settings.get("providers.image") ?? "auto");
 
-	const sessionManager = options.sessionManager ?? SessionManager.create(cwd);
-	time("sessionManager");
+	const sessionManager = options.sessionManager ?? logger.time("sessionManager", SessionManager.create, cwd);
 	const sessionId = sessionManager.getSessionId();
 	const modelApiKeyAvailability = new Map<string, boolean>();
 	const getModelAvailabilityKey = (candidate: Model): string =>
@@ -587,8 +584,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	};
 
 	// Check if session has existing data to restore
-	const existingSession = sessionManager.buildSessionContext();
-	time("loadSession");
+	const existingSession = logger.time("loadSession", () => sessionManager.buildSessionContext());
 	const hasExistingSession = existingSession.messages.length > 0;
 	const hasThinkingEntry = sessionManager.getBranch().some(entry => entry.type === "thinking_level_change");
 
@@ -667,46 +663,52 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		skills = options.skills;
 		skillWarnings = [];
 	} else {
-		const discovered = discoveredSkillsPromise ? await discoveredSkillsPromise : { skills: [], warnings: [] };
-		time("discoverSkills");
+		const discovered = await logger.timeAsync("discoverSkills", async () =>
+			discoveredSkillsPromise ? await discoveredSkillsPromise : { skills: [], warnings: [] },
+		);
 		skills = discovered.skills;
 		skillWarnings = discovered.warnings;
 	}
 
-	debugStartup("sdk:discoverSkills");
-
 	// Discover rules
-	const ttsrSettings = settings.getGroup("ttsr");
-	const ttsrManager = new TtsrManager(ttsrSettings);
-	const rulesResult =
-		options.rules !== undefined
-			? { items: options.rules, warnings: undefined }
-			: await loadCapability<Rule>(ruleCapability.id, { cwd });
-	const registeredTtsrRuleNames = new Set<string>();
-	for (const rule of rulesResult.items) {
-		if (rule.condition && rule.condition.length > 0) {
-			if (ttsrManager.addRule(rule)) {
-				registeredTtsrRuleNames.add(rule.name);
+	const { ttsrManager, rulesResult, registeredTtsrRuleNames } = await logger.timeAsync(
+		"discoverTtsrRules",
+		async () => {
+			const ttsrSettings = settings.getGroup("ttsr");
+			const ttsrManager = new TtsrManager(ttsrSettings);
+			const rulesResult =
+				options.rules !== undefined
+					? { items: options.rules, warnings: undefined }
+					: await loadCapability<Rule>(ruleCapability.id, { cwd });
+			const registeredTtsrRuleNames = new Set<string>();
+			for (const rule of rulesResult.items) {
+				if (rule.condition && rule.condition.length > 0) {
+					if (ttsrManager.addRule(rule)) {
+						registeredTtsrRuleNames.add(rule.name);
+					}
+				}
 			}
-		}
-	}
-	if (existingSession.injectedTtsrRules.length > 0) {
-		ttsrManager.restoreInjected(existingSession.injectedTtsrRules);
-	}
-	time("discoverTtsrRules");
+			if (existingSession.injectedTtsrRules.length > 0) {
+				ttsrManager.restoreInjected(existingSession.injectedTtsrRules);
+			}
+			return { ttsrManager, rulesResult, registeredTtsrRuleNames };
+		},
+	);
 
 	// Filter rules for the rulebook (non-TTSR, non-alwaysApply, with descriptions)
-	const rulebookRules = rulesResult.items.filter((rule: Rule) => {
-		if (registeredTtsrRuleNames.has(rule.name)) return false;
-		if (rule.alwaysApply) return false;
-		if (!rule.description) return false;
-		return true;
-	});
-	time("filterRulebookRules");
+	const rulebookRules = logger.time("filterRulebookRules", () =>
+		rulesResult.items.filter((rule: Rule) => {
+			if (registeredTtsrRuleNames.has(rule.name)) return false;
+			if (rule.alwaysApply) return false;
+			if (!rule.description) return false;
+			return true;
+		}),
+	);
 
-	const contextFiles = options.contextFiles ?? (await discoverContextFiles(cwd, agentDir));
-	debugStartup("sdk:discoverContextFiles");
-	time("discoverContextFiles");
+	const contextFiles = await logger.timeAsync(
+		"discoverContextFiles",
+		async () => options.contextFiles ?? (await discoverContextFiles(cwd, agentDir)),
+	);
 
 	let agent: Agent;
 	let session: AgentSession;
@@ -782,37 +784,30 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		options.parentTaskPrefix ? { parentPrefix: options.parentTaskPrefix } : undefined,
 	);
 
-	debugStartup("sdk:createTools:start");
 	// Create built-in tools (already wrapped with meta notice formatting)
-	const builtinTools = await createTools(toolSession, options.toolNames);
-	debugStartup("sdk:createTools");
-	time("createAllTools");
+	const builtinTools = await logger.timeAsync("createAllTools", () => createTools(toolSession, options.toolNames));
 
-	debugStartup("sdk:discoverMCP:start");
 	// Discover MCP tools from .mcp.json files
 	let mcpManager: MCPManager | undefined;
 	const enableMCP = options.enableMCP ?? true;
 	const customTools: CustomTool[] = [];
 	if (enableMCP) {
-		const mcpResult = await discoverAndLoadMCPTools(cwd, {
-			onConnecting: serverNames => {
-				if (options.hasUI && serverNames.length > 0) {
-					process.stderr.write(
-						chalk.gray(`Connecting to MCP servers: ${serverNames.join(", ")}…
-`),
-					);
-				}
-			},
-			enableProjectConfig: settings.get("mcp.enableProjectConfig") ?? true,
-			// Always filter Exa - we have native integration
-			filterExa: true,
-			// Filter browser MCP servers when builtin browser tool is active
-			filterBrowser: (settings.get("browser.enabled") as boolean) ?? false,
-			cacheStorage: settings.getStorage(),
-			authStorage,
-		});
-		time("discoverAndLoadMCPTools");
-		debugStartup("sdk:discoverAndLoadMCPTools");
+		const mcpResult = await logger.timeAsync("discoverAndLoadMCPTools", () =>
+			discoverAndLoadMCPTools(cwd, {
+				onConnecting: serverNames => {
+					if (options.hasUI && serverNames.length > 0) {
+						process.stderr.write(`${chalk.gray(`Connecting to MCP servers: ${serverNames.join(", ")}…`)}\n`);
+					}
+				},
+				enableProjectConfig: settings.get("mcp.enableProjectConfig") ?? true,
+				// Always filter Exa - we have native integration
+				filterExa: true,
+				// Filter browser MCP servers when builtin browser tool is active
+				filterBrowser: (settings.get("browser.enabled") as boolean) ?? false,
+				cacheStorage: settings.getStorage(),
+				authStorage,
+			}),
+		);
 		mcpManager = mcpResult.manager;
 		toolSession.mcpManager = mcpManager;
 
@@ -832,18 +827,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
-	debugStartup("sdk:geminiImageTools:start");
 	// Add Gemini image tools if GEMINI_API_KEY (or GOOGLE_API_KEY) is available
-	const geminiImageTools = await getGeminiImageTools();
+	const geminiImageTools = await logger.timeAsync("getGeminiImageTools", getGeminiImageTools);
 	if (geminiImageTools.length > 0) {
 		customTools.push(...(geminiImageTools as unknown as CustomTool[]));
 	}
-	time("getGeminiImageTools");
 
 	// Add specialized Exa web search tools if EXA_API_KEY is available
 	const exaSettings = settings.getGroup("exa");
 	if (exaSettings.enabled && exaSettings.enableSearch) {
-		const exaSearchTools = await getSearchTools({
+		const exaSearchTools = await logger.timeAsync("getSearchTools", getSearchTools, {
 			enableLinkedin: exaSettings.enableLinkedin as boolean,
 			enableCompany: exaSettings.enableCompany as boolean,
 		});
@@ -852,34 +845,34 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		if (specializedTools.length > 0) {
 			customTools.push(...specializedTools);
 		}
-		time("getSearchTools");
 	}
 
-	debugStartup("sdk:discoverCustomTools:start");
 	// Discover and load custom tools from .omp/tools/, .claude/tools/, etc.
 	const builtInToolNames = builtinTools.map(t => t.name);
-	const discoveredCustomTools = await discoverAndLoadCustomTools([], cwd, builtInToolNames);
+	const discoveredCustomTools = await logger.timeAsync(
+		"discoverAndLoadCustomTools",
+		discoverAndLoadCustomTools,
+		[],
+		cwd,
+		builtInToolNames,
+	);
 	for (const { path, error } of discoveredCustomTools.errors) {
 		logger.error("Custom tool load failed", { path, error });
 	}
 	if (discoveredCustomTools.tools.length > 0) {
 		customTools.push(...discoveredCustomTools.tools.map(loaded => loaded.tool));
 	}
-	time("discoverAndLoadCustomTools");
-	debugStartup("sdk:discoverCustomTools:done");
 
 	const inlineExtensions: ExtensionFactory[] = options.extensions ? [...options.extensions] : [];
 	if (customTools.length > 0) {
 		inlineExtensions.push(createCustomToolsExtension(customTools));
 	}
 
-	debugStartup("sdk:loadExtensions:start");
 	// Load extensions (discovers from standard locations + configured paths)
 	let extensionsResult: LoadExtensionsResult;
 	if (options.disableExtensionDiscovery) {
 		const configuredPaths = options.additionalExtensionPaths ?? [];
-		extensionsResult = await loadExtensions(configuredPaths, cwd, eventBus);
-		time("loadExtensions");
+		extensionsResult = await logger.timeAsync("loadExtensions", loadExtensions, configuredPaths, cwd, eventBus);
 		for (const { path, error } of extensionsResult.errors) {
 			logger.error("Failed to load extension", { path, error });
 		}
@@ -891,14 +884,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			...(options.additionalExtensionPaths ?? []),
 			...((settings.get("extensions") as string[]) ?? []),
 		];
-		extensionsResult = await discoverAndLoadExtensions(
+		extensionsResult = await logger.timeAsync(
+			"discoverAndLoadExtensions",
+			discoverAndLoadExtensions,
 			configuredPaths,
 			cwd,
 			eventBus,
-			(settings.get("disabledExtensions") as string[]) ?? [],
 		);
-		time("discoverAndLoadExtensions");
-		debugStartup("sdk:discoverAndLoadExtensions");
 		for (const { path, error } of extensionsResult.errors) {
 			logger.error("Failed to load extension", { path, error });
 		}
@@ -959,7 +951,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				break;
 			}
 		}
-		time("findAvailableModel");
 		if (model) {
 			if (modelFallbackMessage) {
 				modelFallbackMessage += `. Using ${model.provider}/${model.id}`;
@@ -970,13 +961,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
-	time("findModel");
 	// Discover custom commands (TypeScript slash commands)
 	const customCommandsResult: CustomCommandsLoadResult = options.disableExtensionDiscovery
 		? { commands: [], errors: [] }
-		: await loadCustomCommandsInternal({ cwd, agentDir });
+		: await logger.timeAsync("discoverCustomCommands", loadCustomCommandsInternal, { cwd, agentDir });
 	if (!options.disableExtensionDiscovery) {
-		time("discoverCustomCommands");
 		for (const { path, error } of customCommandsResult.errors) {
 			logger.error("Failed to load custom command", { path, error });
 		}
@@ -1050,7 +1039,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	if (model?.provider === "cursor") {
 		toolRegistry.delete("edit");
 	}
-	time("combineTools");
 
 	let cursorEventEmitter: ((event: AgentEvent) => void) | undefined;
 	const cursorExecHandlers = new CursorExecHandlers({
@@ -1117,16 +1105,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
-	const systemPrompt = await rebuildSystemPrompt(initialToolNames, toolRegistry);
-	debugStartup("sdk:buildSystemPrompt:done");
-	time("buildSystemPrompt");
+	const systemPrompt = await logger.timeAsync(
+		"buildSystemPrompt",
+		rebuildSystemPrompt,
+		initialToolNames,
+		toolRegistry,
+	);
 
-	const promptTemplates = options.promptTemplates ?? (await discoverPromptTemplates(cwd, agentDir));
-	time("discoverPromptTemplates");
+	const promptTemplates =
+		options.promptTemplates ??
+		(await logger.timeAsync("discoverPromptTemplates", discoverPromptTemplates, cwd, agentDir));
 	toolSession.promptTemplates = promptTemplates;
 
-	const slashCommands = options.slashCommands ?? (await discoverSlashCommands(cwd));
-	time("discoverSlashCommands");
+	const slashCommands =
+		options.slashCommands ?? (await logger.timeAsync("discoverSlashCommands", discoverSlashCommands, cwd));
 
 	// Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)
 	const convertToLlmWithBlockImages = (messages: AgentMessage[]): Message[] => {
@@ -1166,13 +1158,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// Load and create secret obfuscator if secrets are enabled
 	let obfuscator: SecretObfuscator | undefined;
 	if (settings.get("secrets.enabled")) {
-		const fileEntries = await loadSecrets(cwd, agentDir);
+		const fileEntries = await logger.timeAsync("loadSecrets", loadSecrets, cwd, agentDir);
 		const envEntries = collectEnvSecrets();
 		const allEntries = [...envEntries, ...fileEntries];
 		if (allEntries.length > 0) {
 			obfuscator = new SecretObfuscator(allEntries);
 		}
-		time("loadSecrets");
 	}
 
 	// Final convertToLlm: chain block-images filter with secret obfuscation
@@ -1230,8 +1221,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		intentTracing: settings.get("tools.intentTracing") || $env.PI_INTENT_TRACING === "1",
 	});
 	cursorEventEmitter = event => agent.emitExternalEvent(event);
-	debugStartup("sdk:createAgent");
-	time("createAgent");
 
 	// Restore messages if session has existing data
 	if (hasExistingSession) {
@@ -1266,20 +1255,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		forceCopilotAgentInitiator,
 		obfuscator,
 	});
-	debugStartup("sdk:createAgentSession");
-	time("createAgentSession");
 
 	if (model?.api === "openai-codex-responses") {
 		try {
-			debugStartup("sdk:prewarmCodexWebsocket:start");
-			await prewarmOpenAICodexResponses(model, {
+			await logger.timeAsync("prewarmCodexWebsocket", prewarmOpenAICodexResponses, model, {
 				apiKey: await modelRegistry.getApiKey(model, sessionId),
 				sessionId,
 				preferWebsockets: preferOpenAICodexWebsockets,
 				providerSessionState: session.providerSessionState,
 			});
-			debugStartup("sdk:prewarmCodexWebsocket:done");
-			time("prewarmCodexWebsocket");
 		} catch (error) {
 			logger.debug("Codex websocket prewarm failed", {
 				error: error instanceof Error ? error.message : String(error),
@@ -1293,17 +1277,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let lspServers: CreateAgentSessionResult["lspServers"];
 	if (enableLsp && settings.get("lsp.diagnosticsOnWrite")) {
 		try {
-			debugStartup("sdk:warmupLspServers:start");
-			const result = await warmupLspServers(cwd, {
+			const result = await logger.timeAsync("warmupLspServers", warmupLspServers, cwd, {
 				onConnecting: serverNames => {
 					if (options.hasUI && serverNames.length > 0) {
 						process.stderr.write(chalk.gray(`Starting LSP servers: ${serverNames.join(", ")}…\n`));
 					}
 				},
 			});
-			debugStartup("sdk:warmupLspServers:done");
 			lspServers = result.servers;
-			time("warmupLspServers");
 		} catch (error) {
 			logger.warn("LSP server warmup failed", { cwd, error: String(error) });
 		}
@@ -1317,7 +1298,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		taskDepth,
 	});
 
-	debugStartup("sdk:return");
 	return {
 		session,
 		extensionsResult,