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

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,35 +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,
-			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;
 
@@ -830,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,
 		});
@@ -850,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 });
 		}
@@ -889,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 });
 		}
@@ -957,7 +951,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				break;
 			}
 		}
-		time("findAvailableModel");
 		if (model) {
 			if (modelFallbackMessage) {
 				modelFallbackMessage += `. Using ${model.provider}/${model.id}`;
@@ -968,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 });
 		}
@@ -1048,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({
@@ -1115,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[] => {
@@ -1164,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
@@ -1228,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) {
@@ -1264,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),
@@ -1291,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) });
 		}
@@ -1315,7 +1298,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		taskDepth,
 	});
 
-	debugStartup("sdk:return");
 	return {
 		session,
 		extensionsResult,

package/src/system-prompt.ts

@@ -18,9 +18,6 @@ import customSystemPromptTemplate from "./prompts/system/custom-system-prompt.md
 import systemPromptTemplate from "./prompts/system/system-prompt.md" with { type: "text" };
 import type { ToolName } from "./tools";
 
-/** 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`) : () => {};
-
 interface GitContext {
 	isRepo: boolean;
 	currentBranch: string;
@@ -61,6 +58,7 @@ export async function loadGitContext(cwd: string): Promise<GitContext | null> {
 			stdout: "pipe",
 			stderr: "ignore",
 			timeout: timeout,
+			killSignal: "SIGKILL",
 		});
 		return untilAborted(abortSignal, async () => {
 			const exitCode = await proc.exited;
@@ -354,21 +352,15 @@ async function saveGpuCache(info: GpuCache): Promise<void> {
 }
 
 async function getCachedGpu(): Promise<string | undefined> {
-	debugStartup("system-prompt:getEnvironmentInfo:getCachedGpu:start");
-	const cached = await loadGpuCache();
+	const cached = await logger.timeAsync("getCachedGpu:loadGpuCache", loadGpuCache);
 	if (cached) return cached.gpu;
-	debugStartup("system-prompt:getEnvironmentInfo:getGpuModel");
-	const gpu = await getGpuModel();
-	debugStartup("system-prompt:getEnvironmentInfo:saveGpuCache");
-	if (gpu) await saveGpuCache({ gpu });
+	const gpu = await logger.timeAsync("getCachedGpu:getGpuModel", getGpuModel);
+	if (gpu) await logger.timeAsync("getCachedGpu:saveGpuCache", saveGpuCache, { gpu });
 	return gpu ?? undefined;
 }
 async function getEnvironmentInfo(): Promise<Array<{ label: string; value: string }>> {
-	debugStartup("system-prompt:getEnvironmentInfo:getCachedGpu");
-	const gpu = await getCachedGpu();
-	debugStartup("system-prompt:getEnvironmentInfo:getCpuInfo");
+	const gpu = await logger.timeAsync("getEnvironmentInfo:getCachedGpu", getCachedGpu);
 	const cpus = os.cpus();
-	debugStartup("system-prompt:getEnvironmentInfo:buildEntries");
 	const entries: Array<{ label: string; value: string | undefined }> = [
 		{ label: "OS", value: `${os.platform()} ${os.release()}` },
 		{ label: "Distro", value: os.type() },
@@ -380,7 +372,6 @@ async function getEnvironmentInfo(): Promise<Array<{ label: string; value: strin
 		{ label: "DE", value: getDesktopEnvironment() },
 		{ label: "WM", value: getWindowManager() },
 	];
-	debugStartup("system-prompt:getEnvironmentInfo:done");
 	return entries.filter((e): e is { label: string; value: string } => e.value != null && e.value !== "unknown");
 }
 
@@ -511,33 +502,23 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	const preloadedSkills = providedPreloadedSkills;
 
 	const prepPromise = (async () => {
-		const systemPromptCustomizationPromise = (async () => {
-			const customization = await loadSystemPromptFiles({ cwd: resolvedCwd });
-			debugStartup("system-prompt:loadSystemPromptFiles:done");
-			return customization;
-		})();
+		const systemPromptCustomizationPromise = logger.timeAsync("loadSystemPromptFiles", loadSystemPromptFiles, {
+			cwd: resolvedCwd,
+		});
 		const contextFilesPromise = providedContextFiles
 			? Promise.resolve(providedContextFiles)
-			: loadProjectContextFiles({ cwd: resolvedCwd });
-		const agentsMdSearchPromise = buildAgentsMdSearch(resolvedCwd);
+			: logger.timeAsync("loadProjectContextFiles", loadProjectContextFiles, { cwd: resolvedCwd });
+		const agentsMdSearchPromise = logger.timeAsync("buildAgentsMdSearch", buildAgentsMdSearch, resolvedCwd);
 		const skillsPromise: Promise<Skill[]> =
 			providedSkills !== undefined
 				? Promise.resolve(providedSkills)
 				: skillsSettings?.enabled !== false
 					? loadSkills({ ...skillsSettings, cwd: resolvedCwd }).then(result => result.skills)
 					: Promise.resolve([]);
-		const preloadedSkillContentsPromise = (async () => {
-			debugStartup("system-prompt:loadPreloadedSkills:start");
-			const loaded = preloadedSkills ? await loadPreloadedSkillContents(preloadedSkills) : [];
-			debugStartup("system-prompt:loadPreloadedSkills:done");
-			return loaded;
-		})();
-		const gitPromise = (async () => {
-			debugStartup("system-prompt:loadGitContext:start");
-			const loaded = await loadGitContext(resolvedCwd);
-			debugStartup("system-prompt:loadGitContext:done");
-			return loaded;
-		})();
+		const preloadedSkillContentsPromise = preloadedSkills
+			? await logger.timeAsync("loadPreloadedSkills", loadPreloadedSkillContents, preloadedSkills)
+			: [];
+		const gitPromise = logger.timeAsync("loadGitContext", loadGitContext, resolvedCwd);
 
 		const [
 			resolvedCustomPrompt,
@@ -677,9 +658,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		});
 	}
 
-	debugStartup("system-prompt:getEnvironmentInfo:start");
-	const environment = await getEnvironmentInfo();
-	debugStartup("system-prompt:getEnvironmentInfo:done");
+	const environment = await logger.timeAsync("getEnvironmentInfo", getEnvironmentInfo);
 	return renderPromptTemplate(systemPromptTemplate, {
 		tools: toolNamesArray,
 		toolDescriptions,

package/src/tools/bash-interactive.ts

@@ -276,6 +276,50 @@ class BashInteractiveOverlayComponent implements Component {
 	}
 }
 
+const NO_PAGER_ENV = {
+	// Disable pagers so commands don't block on interactive views.
+	PAGER: "cat",
+	GIT_PAGER: "cat",
+	MANPAGER: "cat",
+	SYSTEMD_PAGER: "cat",
+	BAT_PAGER: "cat",
+	DELTA_PAGER: "cat",
+	GH_PAGER: "cat",
+	GLAB_PAGER: "cat",
+	PSQL_PAGER: "cat",
+	MYSQL_PAGER: "cat",
+	AWS_PAGER: "",
+	HOMEBREW_PAGER: "cat",
+	LESS: "FRX",
+	// Disable editor and terminal credential prompts.
+	GIT_EDITOR: "true",
+	VISUAL: "true",
+	EDITOR: "true",
+	GIT_TERMINAL_PROMPT: "0",
+	SSH_ASKPASS: "/usr/bin/false",
+	CI: "1",
+	// Package manager defaults for unattended execution.
+	npm_config_yes: "true",
+	npm_config_update_notifier: "false",
+	npm_config_fund: "false",
+	npm_config_audit: "false",
+	npm_config_progress: "false",
+	PNPM_DISABLE_SELF_UPDATE_CHECK: "true",
+	PNPM_UPDATE_NOTIFIER: "false",
+	YARN_ENABLE_TELEMETRY: "0",
+	YARN_ENABLE_PROGRESS_BARS: "0",
+	// Cross-language/tooling non-interactive defaults.
+	CARGO_TERM_PROGRESS_WHEN: "never",
+	DEBIAN_FRONTEND: "noninteractive",
+	PIP_NO_INPUT: "1",
+	PIP_DISABLE_PIP_VERSION_CHECK: "1",
+	TF_INPUT: "0",
+	TF_IN_AUTOMATION: "1",
+	GH_PROMPT_DISABLED: "1",
+	COMPOSER_NO_INTERACTION: "1",
+	CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
+};
+
 export async function runInteractiveBashPty(
 	ui: NonNullable<AgentToolContext["ui"]>,
 	options: {
@@ -346,54 +390,14 @@ export async function runInteractiveBashPty(
 						timeoutMs: options.timeoutMs,
 						env: {
 							...options.env,
-							// Disable pagers so commands don't block on interactive views.
-							PAGER: "cat",
-							GIT_PAGER: "cat",
-							MANPAGER: "cat",
-							SYSTEMD_PAGER: "cat",
-							BAT_PAGER: "cat",
-							DELTA_PAGER: "cat",
-							GH_PAGER: "cat",
-							GLAB_PAGER: "cat",
-							PSQL_PAGER: "cat",
-							MYSQL_PAGER: "cat",
-							AWS_PAGER: "",
-							HOMEBREW_PAGER: "cat",
-							LESS: "FRX",
-							// Disable editor and terminal credential prompts.
-							GIT_EDITOR: "true",
-							VISUAL: "true",
-							EDITOR: "true",
-							GIT_TERMINAL_PROMPT: "0",
-							SSH_ASKPASS: "/usr/bin/false",
-							CI: "1",
-							// Package manager defaults for unattended execution.
-							npm_config_yes: "true",
-							npm_config_update_notifier: "false",
-							npm_config_fund: "false",
-							npm_config_audit: "false",
-							npm_config_progress: "false",
-							PNPM_DISABLE_SELF_UPDATE_CHECK: "true",
-							PNPM_UPDATE_NOTIFIER: "false",
-							YARN_ENABLE_TELEMETRY: "0",
-							YARN_ENABLE_PROGRESS_BARS: "0",
-							// Cross-language/tooling non-interactive defaults.
-							CARGO_TERM_PROGRESS_WHEN: "never",
-							DEBIAN_FRONTEND: "noninteractive",
-							PIP_NO_INPUT: "1",
-							PIP_DISABLE_PIP_VERSION_CHECK: "1",
-							TF_INPUT: "0",
-							TF_IN_AUTOMATION: "1",
-							GH_PROMPT_DISABLED: "1",
-							COMPOSER_NO_INTERACTION: "1",
-							CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
+							...NO_PAGER_ENV,
 						},
 						signal: options.signal,
 						cols,
 						rows,
 					},
 					(err, chunk) => {
-						if (err || !chunk) return;
+						if (finished || err || !chunk) return;
 						component.appendOutput(chunk);
 						const normalizedChunk = normalizeCaptureChunk(chunk);
 						pendingChunks = pendingChunks.then(() => sink.push(normalizedChunk)).catch(() => {});

package/src/tools/bash.ts

@@ -17,7 +17,7 @@ import { CachedOutputBlock } from "../tui/output-block";
 import type { ToolSession } from ".";
 import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-interactive";
 import { checkBashInterception } from "./bash-interceptor";
-import { applyHeadTail, normalizeBashCommand } from "./bash-normalize";
+import { applyHeadTail } from "./bash-normalize";
 import { expandInternalUrls } from "./bash-skill-urls";
 import type { OutputMeta } from "./output-meta";
 import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
@@ -75,13 +75,11 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
 		ctx?: AgentToolContext,
 	): Promise<AgentToolResult<BashToolDetails>> {
-		// Normalize command: strip head/tail pipes and 2>&1
-		const normalized = normalizeBashCommand(rawCommand);
-		let command = normalized.command;
+		let command = rawCommand;
 
-		// Merge explicit params with extracted ones (explicit takes precedence)
-		const headLines = head ?? normalized.headLines;
-		const tailLines = tail ?? normalized.tailLines;
+		// Only apply explicit head/tail params from tool input.
+		const headLines = head;
+		const tailLines = tail;
 
 		// Check interception if enabled and available tools are known
 		if (this.session.settings.get("bashInterceptor.enabled")) {
@@ -140,6 +138,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 				})
 			: await executeBash(command, {
 					cwd: commandCwd,
+					sessionKey: this.session.getSessionId?.() ?? undefined,
 					timeout: timeoutMs,
 					signal,
 					env: extraEnv,