@oh-my-pi/pi-coding-agent 8.1.0 → 8.2.0

package/src/ipy/executor.ts

@@ -1,4 +1,7 @@
-import { shutdownSharedGateway } from "@oh-my-pi/pi-coding-agent/ipy/gateway-coordinator";
+import { logger } from "@oh-my-pi/pi-utils";
+import { OutputSink } from "../session/streaming-output";
+import { time } from "../utils/timings";
+import { shutdownSharedGateway } from "./gateway-coordinator";
 import {
 	checkPythonKernelAvailability,
 	type KernelDisplayOutput,
@@ -6,9 +9,7 @@ import {
 	type KernelExecuteResult,
 	type PreludeHelper,
 	PythonKernel,
-} from "@oh-my-pi/pi-coding-agent/ipy/kernel";
-import { OutputSink } from "@oh-my-pi/pi-coding-agent/session/streaming-output";
-import { logger } from "@oh-my-pi/pi-utils";
+} from "./kernel";
 
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 const MAX_KERNEL_SESSIONS = 4;
@@ -112,7 +113,7 @@ async function cleanupIdleSessions(): Promise<void> {
 
 	if (toDispose.length > 0) {
 		logger.debug("Cleaning up idle kernel sessions", { count: toDispose.length });
-		await Promise.allSettled(toDispose.map((session) => disposeKernelSession(session)));
+		await Promise.allSettled(toDispose.map(session => disposeKernelSession(session)));
 	}
 
 	if (kernelSessions.size === 0) {
@@ -136,7 +137,7 @@ async function evictOldestSession(): Promise<void> {
 export async function disposeAllKernelSessions(): Promise<void> {
 	stopCleanupTimer();
 	const sessions = Array.from(kernelSessions.values());
-	await Promise.allSettled(sessions.map((session) => disposeKernelSession(session)));
+	await Promise.allSettled(sessions.map(session => disposeKernelSession(session)));
 }
 
 async function ensureKernelAvailable(cwd: string): Promise<void> {
@@ -154,6 +155,7 @@ export async function warmPythonEnvironment(
 ): Promise<{ ok: boolean; reason?: string; docs: PreludeHelper[] }> {
 	try {
 		await ensureKernelAvailable(cwd);
+		time("warmPython:ensureKernelAvailable");
 	} catch (err: unknown) {
 		const reason = err instanceof Error ? err.message : String(err);
 		cachedPreludeDocs = [];
@@ -167,10 +169,11 @@ export async function warmPythonEnvironment(
 		const docs = await withKernelSession(
 			resolvedSessionId,
 			cwd,
-			async (kernel) => kernel.introspectPrelude(),
+			async kernel => kernel.introspectPrelude(),
 			useSharedGateway,
 			sessionFile,
 		);
+		time("warmPython:withKernelSession");
 		cachedPreludeDocs = docs;
 		return { ok: true, docs };
 	} catch (err: unknown) {
@@ -230,6 +233,7 @@ async function createKernelSession(
 	let kernel: PythonKernel;
 	try {
 		kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
+		time("createKernelSession:PythonKernel.start");
 	} catch (err) {
 		if (!isRetry && isResourceExhaustionError(err)) {
 			await recoverFromResourceExhaustion();
@@ -362,8 +366,8 @@ async function executeWithKernel(
 		const result = await kernel.execute(code, {
 			signal: options?.signal,
 			timeoutMs: options?.timeoutMs,
-			onChunk: (text) => sink.push(text),
-			onDisplay: (output) => void displayOutputs.push(output),
+			onChunk: text => sink.push(text),
+			onDisplay: output => void displayOutputs.push(output),
 		});
 
 		if (result.cancelled) {
@@ -447,7 +451,7 @@ export async function executePython(code: string, options?: PythonExecutorOption
 	return await withKernelSession(
 		sessionId,
 		cwd,
-		async (kernel) => executeWithKernel(kernel, code, options),
+		async kernel => executeWithKernel(kernel, code, options),
 		useSharedGateway,
 		sessionFile,
 		artifactsDir,

package/src/ipy/gateway-coordinator.ts

@@ -1,22 +1,12 @@
-import {
-	closeSync,
-	existsSync,
-	mkdirSync,
-	openSync,
-	readFileSync,
-	renameSync,
-	statSync,
-	unlinkSync,
-	utimesSync,
-	writeFileSync,
-} from "node:fs";
+import * as fs from "node:fs";
 import { createServer } from "node:net";
-import { delimiter, join } from "node:path";
-import { getAgentDir } from "@oh-my-pi/pi-coding-agent/config";
-import { getShellConfig, killProcessTree } from "@oh-my-pi/pi-coding-agent/utils/shell";
-import { getOrCreateSnapshot } from "@oh-my-pi/pi-coding-agent/utils/shell-snapshot";
-import { logger } from "@oh-my-pi/pi-utils";
+import * as path from "node:path";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
+import { getAgentDir } from "../config";
+import { getShellConfig, killProcessTree } from "../utils/shell";
+import { getOrCreateSnapshot } from "../utils/shell-snapshot";
+import { time } from "../utils/timings";
 
 const GATEWAY_DIR_NAME = "python-gateway";
 const GATEWAY_INFO_FILE = "gateway.json";
@@ -114,13 +104,13 @@ const CASE_INSENSITIVE_ENV = process.platform === "win32";
 const ACTIVE_ENV_ALLOWLIST = CASE_INSENSITIVE_ENV ? WINDOWS_ENV_ALLOWLIST : DEFAULT_ENV_ALLOWLIST;
 
 const NORMALIZED_ALLOWLIST = new Map(
-	Array.from(ACTIVE_ENV_ALLOWLIST, (key) => [CASE_INSENSITIVE_ENV ? key.toUpperCase() : key, key] as const),
+	Array.from(ACTIVE_ENV_ALLOWLIST, key => [CASE_INSENSITIVE_ENV ? key.toUpperCase() : key, key] as const),
 );
 const NORMALIZED_DENYLIST = new Set(
-	Array.from(DEFAULT_ENV_DENYLIST, (key) => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
+	Array.from(DEFAULT_ENV_DENYLIST, key => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
 );
 const NORMALIZED_ALLOW_PREFIXES = CASE_INSENSITIVE_ENV
-	? DEFAULT_ENV_ALLOW_PREFIXES.map((prefix) => prefix.toUpperCase())
+	? DEFAULT_ENV_ALLOW_PREFIXES.map(prefix => prefix.toUpperCase())
 	: DEFAULT_ENV_ALLOW_PREFIXES;
 
 function normalizeEnvKey(key: string): string {
@@ -129,7 +119,7 @@ function normalizeEnvKey(key: string): string {
 
 function resolvePathKey(env: Record<string, string | undefined>): string {
 	if (!CASE_INSENSITIVE_ENV) return "PATH";
-	const match = Object.keys(env).find((candidate) => candidate.toLowerCase() === "path");
+	const match = Object.keys(env).find(candidate => candidate.toLowerCase() === "path");
 	return match ?? "PATH";
 }
 
@@ -166,7 +156,7 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 			filtered[canonicalKey] = value;
 			continue;
 		}
-		if (NORMALIZED_ALLOW_PREFIXES.some((prefix) => normalizedKey.startsWith(prefix))) {
+		if (NORMALIZED_ALLOW_PREFIXES.some(prefix => normalizedKey.startsWith(prefix))) {
 			filtered[key] = value;
 		}
 	}
@@ -175,7 +165,7 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 
 async function resolveVenvPath(cwd: string): Promise<string | null> {
 	if (process.env.VIRTUAL_ENV) return process.env.VIRTUAL_ENV;
-	const candidates = [join(cwd, ".venv"), join(cwd, "venv")];
+	const candidates = [path.join(cwd, ".venv"), path.join(cwd, "venv")];
 	for (const candidate of candidates) {
 		if (await Bun.file(candidate).exists()) {
 			return candidate;
@@ -189,12 +179,12 @@ async function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string
 	const venvPath = env.VIRTUAL_ENV ?? (await resolveVenvPath(cwd));
 	if (venvPath) {
 		env.VIRTUAL_ENV = venvPath;
-		const binDir = process.platform === "win32" ? join(venvPath, "Scripts") : join(venvPath, "bin");
-		const pythonCandidate = join(binDir, process.platform === "win32" ? "python.exe" : "python");
+		const binDir = process.platform === "win32" ? path.join(venvPath, "Scripts") : path.join(venvPath, "bin");
+		const pythonCandidate = path.join(binDir, process.platform === "win32" ? "python.exe" : "python");
 		if (await Bun.file(pythonCandidate).exists()) {
 			const pathKey = resolvePathKey(env);
 			const currentPath = env[pathKey];
-			env[pathKey] = currentPath ? `${binDir}${delimiter}${currentPath}` : binDir;
+			env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
 			return { pythonPath: pythonCandidate, env, venvPath };
 		}
 	}
@@ -232,33 +222,29 @@ async function allocatePort(): Promise<number> {
 }
 
 function getGatewayDir(): string {
-	return join(getAgentDir(), GATEWAY_DIR_NAME);
+	return path.join(getAgentDir(), GATEWAY_DIR_NAME);
 }
 
 function getGatewayInfoPath(): string {
-	return join(getGatewayDir(), GATEWAY_INFO_FILE);
+	return path.join(getGatewayDir(), GATEWAY_INFO_FILE);
 }
 
 function getGatewayLockPath(): string {
-	return join(getGatewayDir(), GATEWAY_LOCK_FILE);
+	return path.join(getGatewayDir(), GATEWAY_LOCK_FILE);
 }
 
-function writeLockInfo(lockPath: string, fd: number): void {
+async function writeLockInfo(lockPath: string): Promise<void> {
 	const payload: GatewayLockInfo = { pid: process.pid, startedAt: Date.now() };
 	try {
-		writeFileSync(fd, JSON.stringify(payload));
+		await Bun.write(lockPath, JSON.stringify(payload));
 	} catch {
-		try {
-			writeFileSync(lockPath, JSON.stringify(payload));
-		} catch {
-			// Ignore lock write failures
-		}
+		// Ignore lock write failures
 	}
 }
 
-function readLockInfo(lockPath: string): GatewayLockInfo | null {
+async function readLockInfo(lockPath: string): Promise<GatewayLockInfo | null> {
 	try {
-		const raw = readFileSync(lockPath, "utf-8");
+		const raw = await Bun.file(lockPath).text();
 		const parsed = JSON.parse(raw) as Partial<GatewayLockInfo>;
 		if (typeof parsed.pid === "number" && Number.isFinite(parsed.pid)) {
 			return { pid: parsed.pid, startedAt: typeof parsed.startedAt === "number" ? parsed.startedAt : 0 };
@@ -269,36 +255,41 @@ function readLockInfo(lockPath: string): GatewayLockInfo | null {
 	return null;
 }
 
-function ensureGatewayDir(): void {
+async function ensureGatewayDir(): Promise<void> {
 	const dir = getGatewayDir();
-	if (!existsSync(dir)) {
-		mkdirSync(dir, { recursive: true });
-	}
+	await fs.promises.mkdir(dir, { recursive: true });
 }
 
 async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
-	ensureGatewayDir();
+	await ensureGatewayDir();
 	const lockPath = getGatewayLockPath();
 	const start = Date.now();
 	while (true) {
+		let fd: fs.promises.FileHandle | undefined;
 		try {
-			const fd = openSync(lockPath, "wx");
-			const heartbeat = setInterval(() => {
-				try {
-					const now = new Date();
-					utimesSync(lockPath, now, now);
-				} catch {
-					// Ignore heartbeat errors
+			fd = await fs.promises.open(lockPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL);
+			let heartbeatRunning = true;
+			const heartbeat = (async () => {
+				while (heartbeatRunning) {
+					await Bun.sleep(GATEWAY_LOCK_HEARTBEAT_MS);
+					if (!heartbeatRunning) break;
+					try {
+						const now = new Date();
+						await fs.promises.utimes(lockPath, now, now);
+					} catch {
+						// Ignore heartbeat errors
+					}
 				}
-			}, GATEWAY_LOCK_HEARTBEAT_MS);
+			})();
 			try {
-				writeLockInfo(lockPath, fd);
+				await writeLockInfo(lockPath);
 				return await handler();
 			} finally {
-				clearInterval(heartbeat);
+				heartbeatRunning = false;
+				void heartbeat.catch(() => {}); // Don't await - let it die naturally
 				try {
-					closeSync(fd);
-					unlinkSync(lockPath);
+					await fd.close();
+					await fs.promises.unlink(lockPath);
 				} catch {
 					// Ignore lock cleanup errors
 				}
@@ -308,15 +299,15 @@ async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
 			if (error.code === "EEXIST") {
 				let removedStale = false;
 				try {
-					const stat = statSync(lockPath);
-					const lockInfo = readLockInfo(lockPath);
+					const lockStat = await fs.promises.stat(lockPath);
+					const lockInfo = await readLockInfo(lockPath);
 					const lockPid = lockInfo?.pid;
-					const lockAgeMs = lockInfo?.startedAt ? Date.now() - lockInfo.startedAt : Date.now() - stat.mtimeMs;
+					const lockAgeMs = lockInfo?.startedAt ? Date.now() - lockInfo.startedAt : Date.now() - lockStat.mtimeMs;
 					const staleByTime = lockAgeMs > GATEWAY_LOCK_STALE_MS;
 					const staleByPid = lockPid !== undefined && !isPidRunning(lockPid);
 					const staleByMissingPid = lockPid === undefined && staleByTime;
 					if (staleByPid || staleByMissingPid) {
-						unlinkSync(lockPath);
+						await fs.promises.unlink(lockPath);
 						removedStale = true;
 						logger.warn("Removed stale shared gateway lock", { path: lockPath, pid: lockPid });
 					}
@@ -336,14 +327,12 @@ async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
 	}
 }
 
-function readGatewayInfo(): GatewayInfo | null {
+async function readGatewayInfo(): Promise<GatewayInfo | null> {
 	const infoPath = getGatewayInfoPath();
-	if (!existsSync(infoPath)) return null;
-
 	try {
-		const content = readFileSync(infoPath, "utf-8");
+		const content = await Bun.file(infoPath).text();
 		const parsed = JSON.parse(content) as Partial<GatewayInfo>;
-		if (!parsed || typeof parsed !== "object") return null;
+
 		if (typeof parsed.url !== "string" || typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number") {
 			return null;
 		}
@@ -354,26 +343,25 @@ function readGatewayInfo(): GatewayInfo | null {
 			pythonPath: typeof parsed.pythonPath === "string" ? parsed.pythonPath : undefined,
 			venvPath: typeof parsed.venvPath === "string" || parsed.venvPath === null ? parsed.venvPath : undefined,
 		};
-	} catch {
+	} catch (err) {
+		if (isEnoent(err)) return null;
 		return null;
 	}
 }
 
-function writeGatewayInfo(info: GatewayInfo): void {
+async function writeGatewayInfo(info: GatewayInfo): Promise<void> {
 	const infoPath = getGatewayInfoPath();
 	const tempPath = `${infoPath}.tmp`;
-	writeFileSync(tempPath, JSON.stringify(info, null, 2));
-	renameSync(tempPath, infoPath);
+	await Bun.write(tempPath, JSON.stringify(info, null, 2));
+	await fs.promises.rename(tempPath, infoPath);
 }
 
-function clearGatewayInfo(): void {
+async function clearGatewayInfo(): Promise<void> {
 	const infoPath = getGatewayInfoPath();
-	if (existsSync(infoPath)) {
-		try {
-			unlinkSync(infoPath);
-		} catch {
-			// Ignore errors on cleanup
-		}
+	try {
+		await fs.promises.unlink(infoPath);
+	} catch {
+		// Ignore errors on cleanup (file may not exist)
 	}
 }
 
@@ -388,12 +376,9 @@ function isPidRunning(pid: number): boolean {
 
 async function isGatewayHealthy(url: string): Promise<boolean> {
 	try {
-		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT_MS);
 		const response = await fetch(`${url}/api/kernelspecs`, {
-			signal: controller.signal,
+			signal: AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS),
 		});
-		clearTimeout(timeout);
 		return response.ok;
 	} catch {
 		return false;
@@ -497,9 +482,12 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 
 	try {
 		return await withGatewayLock(async () => {
-			const existingInfo = readGatewayInfo();
+			time("acquireSharedGateway:lockAcquired");
+			const existingInfo = await readGatewayInfo();
+			time("acquireSharedGateway:readInfo");
 			if (existingInfo) {
 				if (await isGatewayAlive(existingInfo)) {
+					time("acquireSharedGateway:isAlive");
 					localGatewayUrl = existingInfo.url;
 					isCoordinatorInitialized = true;
 					logger.debug("Reusing global Python gateway", { url: existingInfo.url });
@@ -510,10 +498,11 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 				if (isPidRunning(existingInfo.pid)) {
 					await killGateway(existingInfo.pid, "stale");
 				}
-				clearGatewayInfo();
+				await clearGatewayInfo();
 			}
 
 			const { url, pid, pythonPath, venvPath } = await startGatewayProcess(cwd);
+			time("acquireSharedGateway:startGateway");
 			const info: GatewayInfo = {
 				url,
 				pid,
@@ -521,7 +510,7 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 				pythonPath,
 				venvPath,
 			};
-			writeGatewayInfo(info);
+			await writeGatewayInfo(info);
 			isCoordinatorInitialized = true;
 			logger.debug("Started global Python gateway", { url, pid });
 			return { url, isShared: true };
@@ -538,13 +527,13 @@ export async function releaseSharedGateway(): Promise<void> {
 	if (!isCoordinatorInitialized) return;
 }
 
-export function getSharedGatewayUrl(): string | null {
+export async function getSharedGatewayUrl(): Promise<string | null> {
 	if (localGatewayUrl) return localGatewayUrl;
-	return readGatewayInfo()?.url ?? null;
+	return (await readGatewayInfo())?.url ?? null;
 }
 
-export function isSharedGatewayActive(): boolean {
-	return getGatewayStatus().active;
+export async function isSharedGatewayActive(): Promise<boolean> {
+	return (await getGatewayStatus()).active;
 }
 
 export interface GatewayStatus {
@@ -556,8 +545,8 @@ export interface GatewayStatus {
 	venvPath: string | null;
 }
 
-export function getGatewayStatus(): GatewayStatus {
-	const info = readGatewayInfo();
+export async function getGatewayStatus(): Promise<GatewayStatus> {
+	const info = await readGatewayInfo();
 	if (!info) {
 		return {
 			active: false,
@@ -582,12 +571,12 @@ export function getGatewayStatus(): GatewayStatus {
 export async function shutdownSharedGateway(): Promise<void> {
 	try {
 		await withGatewayLock(async () => {
-			const info = readGatewayInfo();
+			const info = await readGatewayInfo();
 			if (!info) return;
 			if (isPidRunning(info.pid)) {
 				await killGateway(info.pid, "shutdown");
 			}
-			clearGatewayInfo();
+			await clearGatewayInfo();
 		});
 	} catch (err) {
 		logger.warn("Failed to shutdown shared gateway", {

package/src/ipy/kernel.ts

@@ -1,11 +1,12 @@
 import { createServer } from "node:net";
-import { delimiter, join } from "node:path";
-import { getShellConfig, killProcessTree } from "@oh-my-pi/pi-coding-agent/utils/shell";
-import { getOrCreateSnapshot } from "@oh-my-pi/pi-coding-agent/utils/shell-snapshot";
-import { htmlToBasicMarkdown } from "@oh-my-pi/pi-coding-agent/web/scrapers/types";
+import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import { $, type Subprocess } from "bun";
 import { nanoid } from "nanoid";
+import { getShellConfig, killProcessTree } from "../utils/shell";
+import { getOrCreateSnapshot } from "../utils/shell-snapshot";
+import { time } from "../utils/timings";
+import { htmlToBasicMarkdown } from "../web/scrapers/types";
 import { acquireSharedGateway, releaseSharedGateway } from "./gateway-coordinator";
 import { loadPythonModules } from "./modules";
 import { PYTHON_PRELUDE } from "./prelude";
@@ -131,13 +132,13 @@ const BASE_ENV_ALLOWLIST = CASE_INSENSITIVE_ENV
 	? new Set([...DEFAULT_ENV_ALLOWLIST, ...WINDOWS_ENV_ALLOWLIST])
 	: DEFAULT_ENV_ALLOWLIST;
 const NORMALIZED_ALLOWLIST = new Set(
-	Array.from(BASE_ENV_ALLOWLIST, (key) => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
+	Array.from(BASE_ENV_ALLOWLIST, key => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
 );
 const NORMALIZED_DENYLIST = new Set(
-	Array.from(DEFAULT_ENV_DENYLIST, (key) => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
+	Array.from(DEFAULT_ENV_DENYLIST, key => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
 );
 const NORMALIZED_ALLOW_PREFIXES = CASE_INSENSITIVE_ENV
-	? DEFAULT_ENV_ALLOW_PREFIXES.map((prefix) => prefix.toUpperCase())
+	? DEFAULT_ENV_ALLOW_PREFIXES.map(prefix => prefix.toUpperCase())
 	: DEFAULT_ENV_ALLOW_PREFIXES;
 
 function normalizeEnvKey(key: string): string {
@@ -146,7 +147,7 @@ function normalizeEnvKey(key: string): string {
 
 function resolvePathKey(env: Record<string, string | undefined>): string {
 	if (!CASE_INSENSITIVE_ENV) return "PATH";
-	const match = Object.keys(env).find((candidate) => candidate.toLowerCase() === "path");
+	const match = Object.keys(env).find(candidate => candidate.toLowerCase() === "path");
 	return match ?? "PATH";
 }
 
@@ -230,7 +231,7 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 			filtered[destKey] = value;
 			continue;
 		}
-		if (NORMALIZED_ALLOW_PREFIXES.some((prefix) => normalizedKey.startsWith(prefix))) {
+		if (NORMALIZED_ALLOW_PREFIXES.some(prefix => normalizedKey.startsWith(prefix))) {
 			filtered[key] = value;
 		}
 	}
@@ -239,7 +240,7 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 
 async function resolveVenvPath(cwd: string): Promise<string | null> {
 	if (process.env.VIRTUAL_ENV) return process.env.VIRTUAL_ENV;
-	const candidates = [join(cwd, ".venv"), join(cwd, "venv")];
+	const candidates = [path.join(cwd, ".venv"), path.join(cwd, "venv")];
 	for (const candidate of candidates) {
 		if (await Bun.file(candidate).exists()) {
 			return candidate;
@@ -253,12 +254,12 @@ async function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string
 	const venvPath = env.VIRTUAL_ENV ?? (await resolveVenvPath(cwd));
 	if (venvPath) {
 		env.VIRTUAL_ENV = venvPath;
-		const binDir = process.platform === "win32" ? join(venvPath, "Scripts") : join(venvPath, "bin");
-		const pythonCandidate = join(binDir, process.platform === "win32" ? "python.exe" : "python");
+		const binDir = process.platform === "win32" ? path.join(venvPath, "Scripts") : path.join(venvPath, "bin");
+		const pythonCandidate = path.join(binDir, process.platform === "win32" ? "python.exe" : "python");
 		if (await Bun.file(pythonCandidate).exists()) {
 			const pathKey = resolvePathKey(env);
 			const currentPath = env[pathKey];
-			env[pathKey] = currentPath ? `${binDir}${delimiter}${currentPath}` : binDir;
+			env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
 			return { pythonPath: pythonCandidate, env };
 		}
 	}
@@ -309,13 +310,11 @@ async function checkExternalGatewayAvailability(config: ExternalGatewayConfig):
 		}
 
 		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), 5000);
 
 		const response = await fetch(`${config.url}/api/kernelspecs`, {
 			headers,
-			signal: controller.signal,
+			signal: AbortSignal.any([controller.signal, AbortSignal.timeout(5000)]),
 		});
-		clearTimeout(timeout);
 
 		if (response.ok) {
 			return { ok: true };
@@ -505,6 +504,7 @@ export class PythonKernel {
 
 	static async start(options: KernelStartOptions): Promise<PythonKernel> {
 		const availability = await checkPythonKernelAvailability(options.cwd);
+		time("PythonKernel.start:availabilityCheck");
 		if (!availability.ok) {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
 		}
@@ -518,8 +518,11 @@ export class PythonKernel {
 		if (options.useSharedGateway !== false) {
 			try {
 				const sharedResult = await acquireSharedGateway(options.cwd);
+				time("PythonKernel.start:acquireSharedGateway");
 				if (sharedResult) {
-					return PythonKernel.startWithSharedGateway(sharedResult.url, options.cwd, options.env);
+					const kernel = await PythonKernel.startWithSharedGateway(sharedResult.url, options.cwd, options.env);
+					time("PythonKernel.start:startWithSharedGateway");
+					return kernel;
 				}
 			} catch (err) {
 				logger.warn("Failed to acquire shared gateway, falling back to local", {
@@ -582,6 +585,7 @@ export class PythonKernel {
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ name: "python3" }),
 		});
+		time("startWithSharedGateway:createKernel");
 
 		if (!createResponse.ok) {
 			await releaseSharedGateway();
@@ -595,13 +599,17 @@ export class PythonKernel {
 
 		try {
 			await kernel.connectWebSocket();
+			time("startWithSharedGateway:connectWS");
 			await kernel.initializeKernelEnvironment(cwd, env);
+			time("startWithSharedGateway:initEnv");
 			kernel.startHeartbeat();
 			const preludeResult = await kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false });
+			time("startWithSharedGateway:prelude");
 			if (preludeResult.cancelled || preludeResult.status === "error") {
 				throw new Error("Failed to initialize Python kernel prelude");
 			}
 			await loadPythonModules(kernel, { cwd });
+			time("startWithSharedGateway:loadModules");
 			return kernel;
 		} catch (err: unknown) {
 			await kernel.shutdown();
@@ -627,7 +635,7 @@ export class PythonKernel {
 			OMP_SHELL_SNAPSHOT: snapshotPath ?? undefined,
 		};
 
-		const pythonPathParts = [options.cwd, kernelEnv.PYTHONPATH].filter(Boolean).join(delimiter);
+		const pythonPathParts = [options.cwd, kernelEnv.PYTHONPATH].filter(Boolean).join(path.delimiter);
 		if (pythonPathParts) {
 			kernelEnv.PYTHONPATH = pythonPathParts;
 		}
@@ -754,7 +762,7 @@ export class PythonKernel {
 			resolve();
 		};
 
-		ws.onerror = (event) => {
+		ws.onerror = event => {
 			const error = new Error(`WebSocket error: ${event}`);
 			if (!settled) {
 				settled = true;
@@ -779,7 +787,7 @@ export class PythonKernel {
 			this.abortPendingExecutions("WebSocket closed");
 		};
 
-		ws.onmessage = (event) => {
+		ws.onmessage = event => {
 			let msg: JupyterMessage | null = null;
 			if (event.data instanceof ArrayBuffer) {
 				msg = deserializeWebSocketMessage(event.data);
@@ -950,7 +958,7 @@ export class PythonKernel {
 			return promise;
 		}
 
-		this.#messageHandlers.set(msgId, async (response) => {
+		this.#messageHandlers.set(msgId, async response => {
 			switch (response.header.msg_type) {
 				case "execute_reply": {
 					replyReceived = true;
@@ -1045,7 +1053,7 @@ export class PythonKernel {
 		const result = await this.execute(PRELUDE_INTROSPECTION_SNIPPET, {
 			silent: false,
 			storeHistory: false,
-			onChunk: (text) => {
+			onChunk: text => {
 				output += text;
 			},
 		});
@@ -1064,14 +1072,11 @@ export class PythonKernel {
 
 	async interrupt(): Promise<void> {
 		try {
-			const controller = new AbortController();
-			const timeout = setTimeout(() => controller.abort(), 2000);
 			await fetch(`${this.gatewayUrl}/api/kernels/${this.kernelId}/interrupt`, {
 				method: "POST",
 				headers: this.#authHeaders(),
-				signal: controller.signal,
+				signal: AbortSignal.timeout(2000),
 			});
-			clearTimeout(timeout);
 		} catch (err: unknown) {
 			logger.warn("Failed to interrupt kernel via API", { error: err instanceof Error ? err.message : String(err) });
 		}
@@ -1138,13 +1143,10 @@ export class PythonKernel {
 	async ping(timeoutMs: number = HEARTBEAT_TIMEOUT_MS): Promise<boolean> {
 		if (!this.isAlive()) return false;
 		try {
-			const controller = new AbortController();
-			const timeout = setTimeout(() => controller.abort(), timeoutMs);
 			const response = await fetch(`${this.gatewayUrl}/api/kernels/${this.kernelId}`, {
-				signal: controller.signal,
+				signal: AbortSignal.timeout(timeoutMs),
 				headers: this.#authHeaders(),
 			});
-			clearTimeout(timeout);
 			if (response.ok) {
 				this.#heartbeatFailures = 0;
 				return true;