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

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [12.18.0] - 2026-02-21
+
+### Added
+
+- Added `overlay` option to custom UI hooks to display components as bottom-centered overlays instead of replacing the editor
+- Added automatic chat transcript rebuild when returning from custom or debug UI to prevent message duplication
+
+### Changed
+
+- Changed custom UI hook cleanup to conditionally restore editor state only when not using overlay mode
+- Extracted environment variable configuration for non-interactive bash execution into reusable `NO_PAGER_ENV` constant
+- Replaced custom timing instrumentation with logger.timeAsync() and logger.time() from pi-utils for consistent startup profiling
+- Removed PI_DEBUG_STARTUP environment variable in favor of logger.debug() for conditional debug output
+- Consolidated timing calls throughout initialization pipeline to use unified logger-based timing system
+
+### Removed
+
+- Deleted utils/timings.ts module - timing functionality now provided by pi-utils logger
+
+### Fixed
+
+- Fixed potential race condition in bash interactive component where output could be appended after the component was closed
+
 ## [12.17.2] - 2026-02-21
 ### Changed
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "12.17.2",
+	"version": "12.18.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Bölük",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "12.17.2",
-		"@oh-my-pi/pi-agent-core": "12.17.2",
-		"@oh-my-pi/pi-ai": "12.17.2",
-		"@oh-my-pi/pi-natives": "12.17.2",
-		"@oh-my-pi/pi-tui": "12.17.2",
-		"@oh-my-pi/pi-utils": "12.17.2",
+		"@oh-my-pi/omp-stats": "12.18.0",
+		"@oh-my-pi/pi-agent-core": "12.18.0",
+		"@oh-my-pi/pi-ai": "12.18.0",
+		"@oh-my-pi/pi-natives": "12.18.0",
+		"@oh-my-pi/pi-tui": "12.18.0",
+		"@oh-my-pi/pi-utils": "12.18.0",
 		"@sinclair/typebox": "^0.34.48",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.18.0",

package/src/capability/index.ts

@@ -8,12 +8,9 @@
  */
 import * as os from "node:os";
 import * as path from "node:path";
-import { $env } from "@oh-my-pi/pi-utils";
+import { logger } from "@oh-my-pi/pi-utils";
 import { getProjectDir } from "@oh-my-pi/pi-utils/dirs";
 
-/** 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`) : () => {};
-
 import type { Settings } from "../config/settings";
 import { clearCache as clearFsCache, cacheStats as fsCacheStats, invalidate as invalidateFs } from "./fs";
 import type {
@@ -115,12 +112,12 @@ async function loadImpl<T>(
 	const results = await Promise.all(
 		providers.map(async provider => {
 			try {
-				debugStartup(`capability:${capability.id}:${provider.id}:start`);
-				const result = await provider.load(ctx);
-				debugStartup(`capability:${capability.id}:${provider.id}:done`);
+				const result = await logger.timeAsync(`capability:${capability.id}:${provider.id}`, () =>
+					provider.load(ctx),
+				);
 				return { provider, result };
 			} catch (error) {
-				debugStartup(`capability:${capability.id}:${provider.id}:error`);
+				logger.debug(`capability:${capability.id}:${provider.id}:error`);
 				return { provider, error };
 			}
 		}),

package/src/ipy/executor.ts

@@ -1,8 +1,7 @@
 import * as path from "node:path";
-import { $env, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { getAgentDir, getProjectDir } from "@oh-my-pi/pi-utils/dirs";
 import { OutputSink } from "../session/streaming-output";
-import { time } from "../utils/timings";
 import { shutdownSharedGateway } from "./gateway-coordinator";
 import {
 	checkPythonKernelAvailability,
@@ -15,8 +14,6 @@ import {
 import { discoverPythonModules } from "./modules";
 import { PYTHON_PRELUDE } from "./prelude";
 
-const debugStartup = $env.PI_DEBUG_STARTUP ? (stage: string) => process.stderr.write(`[startup] ${stage}\n`) : () => {};
-
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 const MAX_KERNEL_SESSIONS = 4;
 const CLEANUP_INTERVAL_MS = 30 * 1000; // 30 seconds
@@ -228,10 +225,7 @@ export async function warmPythonEnvironment(
 	const isTestEnv = Bun.env.BUN_ENV === "test" || Bun.env.NODE_ENV === "test";
 	let cacheState: PreludeCacheState | null = null;
 	try {
-		debugStartup("warmPython:ensureKernel:start");
-		await ensureKernelAvailable(cwd);
-		debugStartup("warmPython:ensureKernel:done");
-		time("warmPython:ensureKernelAvailable");
+		await logger.timeAsync("warmPython:ensureKernelAvailable", () => ensureKernelAvailable(cwd));
 	} catch (err: unknown) {
 		const reason = err instanceof Error ? err.message : String(err);
 		cachedPreludeDocs = [];
@@ -255,16 +249,15 @@ export async function warmPythonEnvironment(
 	}
 	const resolvedSessionId = sessionId ?? `session:${cwd}`;
 	try {
-		debugStartup("warmPython:withKernelSession:start");
-		const docs = await withKernelSession(
-			resolvedSessionId,
-			cwd,
-			async kernel => kernel.introspectPrelude(),
-			useSharedGateway,
-			sessionFile,
+		const docs = await logger.timeAsync("warmPython:withKernelSession", () =>
+			withKernelSession(
+				resolvedSessionId,
+				cwd,
+				async kernel => kernel.introspectPrelude(),
+				useSharedGateway,
+				sessionFile,
+			),
 		);
-		debugStartup("warmPython:withKernelSession:done");
-		time("warmPython:withKernelSession");
 		cachedPreludeDocs = docs;
 		if (!isTestEnv && docs.length > 0) {
 			const state = cacheState ?? (await buildPreludeCacheState(cwd));
@@ -321,7 +314,6 @@ async function createKernelSession(
 	artifactsDir?: string,
 	isRetry?: boolean,
 ): Promise<KernelSession> {
-	debugStartup("kernel:createSession:entry");
 	const env: Record<string, string> | undefined =
 		sessionFile || artifactsDir
 			? {
@@ -332,10 +324,9 @@ async function createKernelSession(
 
 	let kernel: PythonKernel;
 	try {
-		debugStartup("kernel:PythonKernel.start:start");
-		kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
-		debugStartup("kernel:PythonKernel.start:done");
-		time("createKernelSession:PythonKernel.start");
+		kernel = await logger.timeAsync("createKernelSession:PythonKernel.start", () =>
+			PythonKernel.start({ cwd, useSharedGateway, env }),
+		);
 	} catch (err) {
 		if (!isRetry && isResourceExhaustionError(err)) {
 			await recoverFromResourceExhaustion();
@@ -412,37 +403,56 @@ async function withKernelSession<T>(
 	sessionFile?: string,
 	artifactsDir?: string,
 ): Promise<T> {
-	debugStartup("kernel:withSession:entry");
 	let session = kernelSessions.get(sessionId);
 	if (!session) {
 		// Evict oldest session if at capacity
 		if (kernelSessions.size >= MAX_KERNEL_SESSIONS) {
 			await evictOldestSession();
 		}
-		session = await createKernelSession(sessionId, cwd, useSharedGateway, sessionFile, artifactsDir);
-		debugStartup("kernel:withSession:created");
+		session = await logger.timeAsync(
+			"kernel:createKernelSession",
+			createKernelSession,
+			sessionId,
+			cwd,
+			useSharedGateway,
+			sessionFile,
+			artifactsDir,
+		);
 		kernelSessions.set(sessionId, session);
 		startCleanupTimer();
 	}
 
 	const run = async (): Promise<T> => {
-		debugStartup("kernel:withSession:run");
 		session!.lastUsedAt = Date.now();
 		if (session!.dead || !session!.kernel.isAlive()) {
-			await restartKernelSession(session!, cwd, useSharedGateway, sessionFile, artifactsDir);
+			await logger.timeAsync(
+				"kernel:restartKernelSession",
+				restartKernelSession,
+				session!,
+				cwd,
+				useSharedGateway,
+				sessionFile,
+				artifactsDir,
+			);
 		}
 		try {
-			debugStartup("kernel:withSession:handler:start");
-			const result = await handler(session!.kernel);
-			debugStartup("kernel:withSession:handler:done");
+			const result = await logger.timeAsync("kernel:withSession:handler", handler, session!.kernel);
 			session!.restartCount = 0;
 			return result;
 		} catch (err) {
 			if (!session!.dead && session!.kernel.isAlive()) {
 				throw err;
 			}
-			await restartKernelSession(session!, cwd, useSharedGateway, sessionFile, artifactsDir);
-			const result = await handler(session!.kernel);
+			await logger.timeAsync(
+				"kernel:restartKernelSession",
+				restartKernelSession,
+				session!,
+				cwd,
+				useSharedGateway,
+				sessionFile,
+				artifactsDir,
+			);
+			const result = await logger.timeAsync("kernel:postRestart:handler", handler, session!.kernel);
 			session!.restartCount = 0;
 			return result;
 		}

package/src/ipy/gateway-coordinator.ts

@@ -6,7 +6,6 @@ import { getAgentDir } from "@oh-my-pi/pi-utils/dirs";
 import type { Subprocess } from "bun";
 import { Settings } from "../config/settings";
 import { getOrCreateSnapshot } from "../utils/shell-snapshot";
-import { time } from "../utils/timings";
 import { filterEnv, resolvePythonRuntime } from "./runtime";
 
 const GATEWAY_DIR_NAME = "python-gateway";
@@ -315,12 +314,9 @@ async function killGateway(pid: number, context: string): Promise<void> {
 export async function acquireSharedGateway(cwd: string): Promise<AcquireResult | null> {
 	try {
 		return await withGatewayLock(async () => {
-			time("acquireSharedGateway:lockAcquired");
-			const existingInfo = await readGatewayInfo();
-			time("acquireSharedGateway:readInfo");
+			const existingInfo = await logger.timeAsync("acquireSharedGateway:readInfo", () => readGatewayInfo());
 			if (existingInfo) {
-				if (await isGatewayAlive(existingInfo)) {
-					time("acquireSharedGateway:isAlive");
+				if (await logger.timeAsync("acquireSharedGateway:isAlive", () => isGatewayAlive(existingInfo))) {
 					localGatewayUrl = existingInfo.url;
 					isCoordinatorInitialized = true;
 					logger.debug("Reusing global Python gateway", { url: existingInfo.url });
@@ -334,8 +330,9 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 				await clearGatewayInfo();
 			}
 
-			const { url, pid, pythonPath, venvPath } = await startGatewayProcess(cwd);
-			time("acquireSharedGateway:startGateway");
+			const { url, pid, pythonPath, venvPath } = await logger.timeAsync("acquireSharedGateway:startGateway", () =>
+				startGatewayProcess(cwd),
+			);
 			const info: GatewayInfo = {
 				url,
 				pid,

package/src/ipy/kernel.ts

@@ -1,7 +1,6 @@
 import { $env, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { Settings } from "../config/settings";
-import { time } from "../utils/timings";
 import { htmlToBasicMarkdown } from "../web/scrapers/types";
 import { acquireSharedGateway, releaseSharedGateway, shutdownSharedGateway } from "./gateway-coordinator";
 import { loadPythonModules } from "./modules";
@@ -13,8 +12,6 @@ const TEXT_DECODER = new TextDecoder();
 const TRACE_IPC = $env.PI_PYTHON_IPC_TRACE === "1";
 const PRELUDE_INTROSPECTION_SNIPPET = "import json\nprint(json.dumps(__omp_prelude_docs__()))";
 
-const debugStartup = $env.PI_DEBUG_STARTUP ? (stage: string) => process.stderr.write(`[startup] ${stage}\n`) : () => {};
-
 class SharedGatewayCreateError extends Error {
 	constructor(
 		readonly status: number,
@@ -334,10 +331,9 @@ export class PythonKernel {
 	}
 
 	static async start(options: KernelStartOptions): Promise<PythonKernel> {
-		debugStartup("PythonKernel.start:entry");
-		const availability = await checkPythonKernelAvailability(options.cwd);
-		debugStartup("PythonKernel.start:availCheck");
-		time("PythonKernel.start:availabilityCheck");
+		const availability = await logger.timeAsync("PythonKernel.start:availabilityCheck", () =>
+			checkPythonKernelAvailability(options.cwd),
+		);
 		if (!availability.ok) {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
 		}
@@ -353,20 +349,18 @@ export class PythonKernel {
 
 		for (let attempt = 0; attempt < 2; attempt += 1) {
 			try {
-				debugStartup("PythonKernel.start:acquireShared:start");
-				const sharedResult = await acquireSharedGateway(options.cwd);
-				debugStartup("PythonKernel.start:acquireShared:done");
-				time("PythonKernel.start:acquireSharedGateway");
+				const sharedResult = await logger.timeAsync("PythonKernel.start:acquireSharedGateway", () =>
+					acquireSharedGateway(options.cwd),
+				);
 				if (!sharedResult) {
 					throw new Error("Shared Python gateway unavailable");
 				}
-				debugStartup("PythonKernel.start:startShared:start");
-				const kernel = await PythonKernel.#startWithSharedGateway(sharedResult.url, options.cwd, options.env);
-				debugStartup("PythonKernel.start:startShared:done");
-				time("PythonKernel.start:startWithSharedGateway");
+				const kernel = await logger.timeAsync("PythonKernel.start:startWithSharedGateway", () =>
+					PythonKernel.#startWithSharedGateway(sharedResult.url, options.cwd, options.env),
+				);
 				return kernel;
 			} catch (err) {
-				debugStartup("PythonKernel.start:sharedFailed");
+				logger.debug("PythonKernel.start:sharedFailed");
 				if (attempt === 0 && err instanceof SharedGatewayCreateError && err.status >= 500) {
 					logger.warn("Shared gateway kernel creation failed, retrying", {
 						status: err.status,
@@ -436,55 +430,42 @@ export class PythonKernel {
 		cwd: string,
 		env?: Record<string, string | undefined>,
 	): Promise<PythonKernel> {
-		debugStartup("sharedGateway:fetch:start");
-		const createResponse = await fetch(`${gatewayUrl}/api/kernels`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ name: "python3" }),
-		});
-		debugStartup("sharedGateway:fetch:done");
-		time("startWithSharedGateway:createKernel");
+		const createResponse = await logger.timeAsync("startWithSharedGateway:createKernel", () =>
+			fetch(`${gatewayUrl}/api/kernels`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ name: "python3" }),
+			}),
+		);
 
 		if (!createResponse.ok) {
-			debugStartup(`sharedGateway:fetch:notOk:${createResponse.status}`);
+			logger.debug(`sharedGateway:fetch:notOk:${createResponse.status}`);
 			await shutdownSharedGateway();
-			debugStartup("sharedGateway:fetch:shutdown");
 			const text = await createResponse.text();
-			debugStartup("sharedGateway:fetch:textRead");
 			throw new SharedGatewayCreateError(
 				createResponse.status,
 				`Failed to create kernel on shared gateway: ${text}`,
 			);
 		}
 
-		debugStartup("sharedGateway:json:start");
-		const kernelInfo = (await createResponse.json()) as { id: string };
-		debugStartup("sharedGateway:json:done");
+		const kernelInfo = await logger.timeAsync(
+			"startWithSharedGateway:parseJson",
+			() => createResponse.json() as Promise<{ id: string }>,
+		);
 		const kernelId = kernelInfo.id;
 
 		const kernel = new PythonKernel(Snowflake.next(), kernelId, gatewayUrl, Snowflake.next(), "omp", true);
-		debugStartup("sharedGateway:kernelCreated");
 
 		try {
-			debugStartup("sharedGateway:connectWS:start");
-			await kernel.#connectWebSocket();
-			debugStartup("sharedGateway:connectWS:done");
-			time("startWithSharedGateway:connectWS");
-			debugStartup("sharedGateway:initEnv:start");
-			await kernel.#initializeKernelEnvironment(cwd, env);
-			debugStartup("sharedGateway:initEnv:done");
-			time("startWithSharedGateway:initEnv");
-			debugStartup("sharedGateway:prelude:start");
-			const preludeResult = await kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false });
-			debugStartup("sharedGateway:prelude:done");
-			time("startWithSharedGateway:prelude");
+			await logger.timeAsync("startWithSharedGateway:connectWS", () => kernel.#connectWebSocket());
+			await logger.timeAsync("startWithSharedGateway:initEnv", () => kernel.#initializeKernelEnvironment(cwd, env));
+			const preludeResult = await logger.timeAsync("startWithSharedGateway:prelude", () =>
+				kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false }),
+			);
 			if (preludeResult.cancelled || preludeResult.status === "error") {
 				throw new Error("Failed to initialize Python kernel prelude");
 			}
-			debugStartup("sharedGateway:loadModules:start");
-			await loadPythonModules(kernel, { cwd });
-			debugStartup("sharedGateway:loadModules:done");
-			time("startWithSharedGateway:loadModules");
+			await logger.timeAsync("startWithSharedGateway:loadModules", () => loadPythonModules(kernel, { cwd }));
 			return kernel;
 		} catch (err: unknown) {
 			await kernel.shutdown();

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,