@oh-my-pi/pi-coding-agent 9.4.0 → 9.6.0

package/src/discovery/helpers.ts

@@ -8,6 +8,7 @@ import { readDirEntries, readFile } from "../capability/fs";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 import { parseFrontmatter } from "../utils/frontmatter";
+import { addIgnoreRules, createIgnoreMatcher, type IgnoreMatcher, shouldIgnore } from "../utils/ignore-files";
 
 const VALID_THINKING_LEVELS: readonly string[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
@@ -236,6 +237,10 @@ export async function loadSkillsFromDir(
 	const warnings: string[] = [];
 	const { dir, level, providerId, requireDescription = false } = options;
 
+	// Initialize ignore matcher and read ignore rules from root
+	const ig = createIgnoreMatcher();
+	await addIgnoreRules(ig, dir, dir, readFile);
+
 	const entries = await readDirEntries(dir);
 	const skillDirs = entries.filter(
 		entry => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules",
@@ -243,7 +248,14 @@ export async function loadSkillsFromDir(
 
 	const results = await Promise.all(
 		skillDirs.map(async entry => {
-			const skillFile = path.join(dir, entry.name, "SKILL.md");
+			const entryPath = path.join(dir, entry.name);
+
+			// Check if this directory should be ignored
+			if (shouldIgnore(ig, dir, entryPath, true)) {
+				return { item: null as Skill | null, warning: null as string | null };
+			}
+
+			const skillFile = path.join(entryPath, "SKILL.md");
 			const content = await readFile(skillFile);
 			if (!content) {
 				return { item: null as Skill | null, warning: null as string | null };
@@ -311,6 +323,7 @@ export function expandEnvVarsDeep<T>(obj: T, extraEnv?: Record<string, string>):
 
 /**
  * Load files from a directory matching a pattern.
+ * Respects .gitignore, .ignore, and .fdignore files.
  */
 export async function loadFilesFromDir<T>(
 	_ctx: LoadContext,
@@ -324,24 +337,47 @@ export async function loadFilesFromDir<T>(
 		transform: (name: string, content: string, path: string, source: SourceMeta) => T | null;
 		/** Whether to recurse into subdirectories */
 		recursive?: boolean;
+		/** Root directory for ignore file handling (defaults to dir) */
+		rootDir?: string;
+		/** Ignore matcher (used internally for recursion) */
+		ignoreMatcher?: IgnoreMatcher;
 	},
 ): Promise<LoadResult<T>> {
+	const rootDir = options.rootDir ?? dir;
+	const ig = options.ignoreMatcher ?? createIgnoreMatcher();
+
+	// Read ignore rules from this directory
+	await addIgnoreRules(ig, dir, rootDir, readFile);
+
 	const entries = await readDirEntries(dir);
 
 	const visibleEntries = entries.filter(entry => !entry.name.startsWith("."));
 
-	const directories = options.recursive ? visibleEntries.filter(entry => entry.isDirectory()) : [];
+	const directories = options.recursive
+		? visibleEntries.filter(entry => {
+				if (!entry.isDirectory()) return false;
+				const entryPath = path.join(dir, entry.name);
+				return !shouldIgnore(ig, rootDir, entryPath, true);
+			})
+		: [];
 
-	const files = visibleEntries
-		.filter(entry => entry.isFile())
-		.filter(entry => {
-			if (!options.extensions) return true;
-			return options.extensions.some(ext => entry.name.endsWith(`.${ext}`));
-		});
+	const files = visibleEntries.filter(entry => {
+		if (!entry.isFile()) return false;
+		const entryPath = path.join(dir, entry.name);
+		if (shouldIgnore(ig, rootDir, entryPath, false)) return false;
+		if (!options.extensions) return true;
+		return options.extensions.some(ext => entry.name.endsWith(`.${ext}`));
+	});
 
 	const [subResults, fileResults] = await Promise.all([
 		Promise.all(
-			directories.map(entry => loadFilesFromDir(_ctx, path.join(dir, entry.name), provider, level, options)),
+			directories.map(entry =>
+				loadFilesFromDir(_ctx, path.join(dir, entry.name), provider, level, {
+					...options,
+					rootDir,
+					ignoreMatcher: ig,
+				}),
+			),
 		),
 		Promise.all(
 			files.map(async entry => {
@@ -435,24 +471,32 @@ function isExtensionModuleFile(name: string): boolean {
  * 3. Subdirectory with package.json: `extensions/<ext>/package.json` with "omp"/"pi" field → load declared paths
  *
  * No recursion beyond one level. Complex packages must use package.json manifest.
+ * Respects .gitignore, .ignore, and .fdignore files.
  */
 export async function discoverExtensionModulePaths(ctx: LoadContext, dir: string): Promise<string[]> {
 	const discovered: string[] = [];
 	const entries = await readDirEntries(dir);
 
+	// Initialize ignore matcher and read ignore rules from root
+	const ig = createIgnoreMatcher();
+	await addIgnoreRules(ig, dir, dir, readFile);
+
 	for (const entry of entries) {
 		if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
 
 		const entryPath = path.join(dir, entry.name);
 
 		// 1. Direct files: *.ts or *.js
-		if (entry.isFile() && isExtensionModuleFile(entry.name)) {
+		if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionModuleFile(entry.name)) {
+			if (shouldIgnore(ig, dir, entryPath, false)) continue;
 			discovered.push(entryPath);
 			continue;
 		}
 
 		// 2 & 3. Subdirectories
-		if (entry.isDirectory()) {
+		if (entry.isDirectory() || entry.isSymbolicLink()) {
+			if (shouldIgnore(ig, dir, entryPath, true)) continue;
+
 			const subEntries = await readDirEntries(entryPath);
 			const subFileNames = new Set(subEntries.filter(e => e.isFile()).map(e => e.name));
 

package/src/exa/index.ts

@@ -8,7 +8,7 @@
  * - 2 researcher tools (start, poll)
  * - 14 websets tools (CRUD, items, search, enrichment, monitor)
  */
-import type { ExaSettings } from "../config/settings-manager";
+import type { ExaSettings } from "../config/settings";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import { companyTool } from "./company";
 import { linkedinTool } from "./linkedin";

package/src/exec/bash-executor.ts

@@ -4,7 +4,7 @@
  * Provides unified bash execution for AgentSession.executeBash() and direct calls.
  */
 import { Exception, ptree } from "@oh-my-pi/pi-utils";
-import { SettingsManager } from "../config/settings-manager";
+import { Settings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
 import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
 import { executeShellCommand } from "./shell-session";
@@ -34,10 +34,11 @@ export interface BashResult {
 }
 
 export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
-	const { shell, args, env, prefix } = await SettingsManager.getGlobalShellConfig();
+	const settings = await Settings.init();
+	const { shell, args, env, prefix } = settings.getShellConfig();
 	const snapshotPath = await getOrCreateSnapshot(shell, env);
 
-	if (shouldUsePersistentShell(shell)) {
+	if (shouldUsePersistentShell(settings.get("bash.persistentShell"))) {
 		return await executeShellCommand({ shell, env, prefix, snapshotPath }, command, {
 			cwd: options?.cwd,
 			timeout: options?.timeout,
@@ -52,19 +53,18 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	return await executeBashOnce(command, options, { shell, args, env, prefix, snapshotPath });
 }
 
-function shouldUsePersistentShell(shell: string): boolean {
+/**
+ * Determine whether to use persistent shell sessions.
+ * Priority: OMP_SHELL_PERSIST env var > settings > default (false)
+ */
+function shouldUsePersistentShell(settingValue: boolean): boolean {
+	// Env var takes precedence (for debugging/override)
 	const flag = parseEnvFlag(process.env.OMP_SHELL_PERSIST);
 	if (flag !== undefined) return flag;
+	// Windows never uses persistent shell (too unreliable)
 	if (process.platform === "win32") return false;
-	const normalized = shell.toLowerCase();
-	return (
-		normalized.includes("bash") ||
-		normalized.includes("zsh") ||
-		normalized.includes("fish") ||
-		normalized.endsWith("/sh") ||
-		normalized.endsWith("\\\\sh") ||
-		normalized.endsWith("sh")
-	);
+	// Use setting value (defaults to false)
+	return settingValue;
 }
 
 function parseEnvFlag(value: string | undefined): boolean | undefined {

package/src/exec/shell-session.ts

@@ -194,6 +194,7 @@ class ShellSession {
 	#buffer = "";
 	#queue: Promise<void> = Promise.resolve();
 	#chunkQueue: Promise<void> = Promise.resolve();
+	#streamsDone: Promise<unknown> = Promise.resolve();
 	#current: RunningCommand | null = null;
 	#startPromise: Promise<void> | null = null;
 	#closed = false;
@@ -313,8 +314,7 @@ class ShellSession {
 			}
 		};
 
-		void readStream(child.stdout);
-		void readStream(child.stderr);
+		this.#streamsDone = Promise.allSettled([readStream(child.stdout), readStream(child.stderr)]);
 	}
 
 	async #enqueueChunk(text: string): Promise<void> {
@@ -477,6 +477,11 @@ class ShellSession {
 		if (completed) return;
 
 		await this.#terminateSession();
+
+		// Drain streams and chunk queue - marker might have arrived but not yet processed
+		await this.#streamsDone;
+		await this.#chunkQueue;
+
 		if (running.completed) return;
 		running.completed = true;
 		running.abortListener?.();
@@ -522,14 +527,21 @@ class ShellSession {
 		this.#child = null;
 		this.#stdinWriter = null;
 		this.#startPromise = null;
-		this.#buffer = "";
 
 		if (!running || running.completed) return;
+
+		// Wait for any pending chunks to be processed - marker might be in the queue
+		await this.#streamsDone;
+		await this.#chunkQueue;
+
+		if (running.completed) return;
+
 		running.cancelled = true;
 		running.abortReason = "signal";
 		running.completed = true;
 		running.abortListener?.();
 		this.#current = null;
+		this.#buffer = "";
 		const summary = await running.sink.dump(running.abortNotice ?? "Shell session terminated");
 		running.resolve({
 			exitCode: undefined,

package/src/export/ttsr.ts

@@ -7,7 +7,7 @@
  */
 import { logger } from "@oh-my-pi/pi-utils";
 import type { Rule } from "../capability/rule";
-import type { TtsrSettings } from "../config/settings-manager";
+import type { TtsrSettings } from "../config/settings";
 
 interface TtsrEntry {
 	rule: Rule;

package/src/extensibility/skills.ts

@@ -3,10 +3,11 @@ import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import { skillCapability } from "../capability/skill";
 import type { SourceMeta } from "../capability/types";
-import type { SkillsSettings } from "../config/settings-manager";
+import type { SkillsSettings } from "../config/settings";
 import type { Skill as CapabilitySkill, SkillFrontmatter as ImportedSkillFrontmatter } from "../discovery";
 import { loadCapability } from "../discovery";
 import { parseFrontmatter } from "../utils/frontmatter";
+import { addIgnoreRules, createIgnoreMatcher, type IgnoreMatcher, shouldIgnore } from "../utils/ignore-files";
 
 // Re-export SkillFrontmatter for backward compatibility
 export type { ImportedSkillFrontmatter as SkillFrontmatter };
@@ -38,14 +39,24 @@ export interface LoadSkillsFromDirOptions {
 	source: string;
 }
 
+async function readFileContent(filePath: string): Promise<string | null> {
+	try {
+		return await fs.readFile(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
 /**
  * Load skills from a directory recursively.
  * Skills are directories containing a SKILL.md file with frontmatter including a description.
+ * Respects .gitignore, .ignore, and .fdignore files.
  */
 export async function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Promise<LoadSkillsResult> {
 	const skills: Skill[] = [];
 	const warnings: SkillWarning[] = [];
 	const seenPaths = new Set<string>();
+	const rootDir = options.dir;
 
 	async function addSkill(skillFile: string, skillDir: string, dirName: string): Promise<void> {
 		if (seenPaths.has(skillFile)) return;
@@ -70,8 +81,11 @@ export async function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Prom
 		}
 	}
 
-	async function scanDir(dir: string): Promise<void> {
+	async function scanDir(dir: string, ig: IgnoreMatcher): Promise<void> {
 		try {
+			// Add ignore rules from this directory
+			await addIgnoreRules(ig, dir, rootDir, readFileContent);
+
 			// First check if this directory itself is a skill
 			const selfSkillFile = path.join(dir, "SKILL.md");
 			try {
@@ -92,8 +106,13 @@ export async function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Prom
 				if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
 
 				const fullPath = path.join(dir, entry.name);
-				if (entry.isDirectory()) {
-					await scanDir(fullPath);
+				const isDir = entry.isDirectory();
+
+				// Check if this entry should be ignored
+				if (shouldIgnore(ig, rootDir, fullPath, isDir)) continue;
+
+				if (isDir) {
+					await scanDir(fullPath, ig);
 				}
 			}
 		} catch (err) {
@@ -101,7 +120,8 @@ export async function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Prom
 		}
 	}
 
-	await scanDir(options.dir);
+	const ig = createIgnoreMatcher();
+	await scanDir(options.dir, ig);
 
 	return { skills, warnings };
 }
@@ -109,11 +129,13 @@ export async function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Prom
 /**
  * Scan a directory for SKILL.md files recursively.
  * Used internally by loadSkills for custom directories.
+ * Respects .gitignore, .ignore, and .fdignore files.
  */
 async function scanDirectoryForSkills(dir: string): Promise<LoadSkillsResult> {
 	const skills: Skill[] = [];
 	const warnings: SkillWarning[] = [];
 	const seenPaths = new Set<string>();
+	const rootDir = dir;
 
 	async function addSkill(skillFile: string, skillDir: string, dirName: string): Promise<void> {
 		if (seenPaths.has(skillFile)) return;
@@ -138,8 +160,11 @@ async function scanDirectoryForSkills(dir: string): Promise<LoadSkillsResult> {
 		}
 	}
 
-	async function scanDir(currentDir: string): Promise<void> {
+	async function scanDir(currentDir: string, ig: IgnoreMatcher): Promise<void> {
 		try {
+			// Add ignore rules from this directory
+			await addIgnoreRules(ig, currentDir, rootDir, readFileContent);
+
 			// First check if this directory itself is a skill
 			const selfSkillFile = path.join(currentDir, "SKILL.md");
 			try {
@@ -160,8 +185,13 @@ async function scanDirectoryForSkills(dir: string): Promise<LoadSkillsResult> {
 				if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
 
 				const fullPath = path.join(currentDir, entry.name);
-				if (entry.isDirectory()) {
-					await scanDir(fullPath);
+				const isDir = entry.isDirectory();
+
+				// Check if this entry should be ignored
+				if (shouldIgnore(ig, rootDir, fullPath, isDir)) continue;
+
+				if (isDir) {
+					await scanDir(fullPath, ig);
 				}
 			}
 		} catch (err) {
@@ -169,7 +199,8 @@ async function scanDirectoryForSkills(dir: string): Promise<LoadSkillsResult> {
 		}
 	}
 
-	await scanDir(dir);
+	const ig = createIgnoreMatcher();
+	await scanDir(dir, ig);
 
 	return { skills, warnings };
 }

package/src/index.ts

@@ -12,15 +12,8 @@ export { formatKeyHint, formatKeyHints } from "./config/keybindings";
 export { ModelRegistry } from "./config/model-registry";
 // Prompt templates
 export type { PromptTemplate } from "./config/prompt-templates";
-export {
-	type CompactionSettings,
-	type ImageSettings,
-	type LspSettings,
-	type RetrySettings,
-	type Settings,
-	SettingsManager,
-	type SkillsSettings,
-} from "./config/settings-manager";
+export type { CompactionSettings, RetrySettings, SkillsSettings } from "./config/settings";
+export { Settings, settings } from "./config/settings";
 // Custom commands
 export type {
 	CustomCommand,
@@ -188,7 +181,6 @@ export {
 	FindTool,
 	GrepTool,
 	LsTool,
-	loadSettings,
 	loadSshTool,
 	PythonTool,
 	ReadTool,

package/src/ipy/gateway-coordinator.ts

@@ -4,9 +4,10 @@ import * as path from "node:path";
 import { isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
 import { getAgentDir } from "../config";
-import { SettingsManager } from "../config/settings-manager";
+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";
 const GATEWAY_INFO_FILE = "gateway.json";
@@ -18,96 +19,6 @@ const GATEWAY_LOCK_STALE_MS = GATEWAY_STARTUP_TIMEOUT_MS * 2;
 const GATEWAY_LOCK_HEARTBEAT_MS = 5000;
 const HEALTH_CHECK_TIMEOUT_MS = 3000;
 
-const DEFAULT_ENV_ALLOWLIST = new Set([
-	"PATH",
-	"HOME",
-	"USER",
-	"LOGNAME",
-	"SHELL",
-	"LANG",
-	"LC_ALL",
-	"LC_CTYPE",
-	"LC_MESSAGES",
-	"TERM",
-	"TERM_PROGRAM",
-	"TERM_PROGRAM_VERSION",
-	"TMPDIR",
-	"TEMP",
-	"TMP",
-	"XDG_CACHE_HOME",
-	"XDG_CONFIG_HOME",
-	"XDG_DATA_HOME",
-	"XDG_RUNTIME_DIR",
-	"SSH_AUTH_SOCK",
-	"SSH_AGENT_PID",
-	"CONDA_PREFIX",
-	"CONDA_DEFAULT_ENV",
-	"VIRTUAL_ENV",
-	"PYTHONPATH",
-	"SYSTEMROOT",
-	"COMSPEC",
-	"WINDIR",
-	"USERPROFILE",
-	"LOCALAPPDATA",
-	"APPDATA",
-	"PROGRAMDATA",
-	"PATHEXT",
-	"USERNAME",
-	"HOMEDRIVE",
-	"HOMEPATH",
-]);
-
-const WINDOWS_ENV_ALLOWLIST = new Set([
-	"APPDATA",
-	"COMPUTERNAME",
-	"COMSPEC",
-	"HOMEDRIVE",
-	"HOMEPATH",
-	"LOCALAPPDATA",
-	"NUMBER_OF_PROCESSORS",
-	"OS",
-	"PATH",
-	"PATHEXT",
-	"PROCESSOR_ARCHITECTURE",
-	"PROCESSOR_IDENTIFIER",
-	"PROGRAMDATA",
-	"PROGRAMFILES",
-	"PROGRAMFILES(X86)",
-	"PROGRAMW6432",
-	"SESSIONNAME",
-	"SYSTEMDRIVE",
-	"SYSTEMROOT",
-	"TEMP",
-	"TMP",
-	"USERDOMAIN",
-	"USERDOMAIN_ROAMINGPROFILE",
-	"USERPROFILE",
-	"USERNAME",
-	"WINDIR",
-]);
-
-const DEFAULT_ENV_ALLOW_PREFIXES = ["LC_", "XDG_", "OMP_"];
-
-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),
-);
-const NORMALIZED_ALLOW_PREFIXES = CASE_INSENSITIVE_ENV
-	? DEFAULT_ENV_ALLOW_PREFIXES.map(prefix => prefix.toUpperCase())
-	: DEFAULT_ENV_ALLOW_PREFIXES;
-
-function normalizeEnvKey(key: string): string {
-	return CASE_INSENSITIVE_ENV ? key.toUpperCase() : key;
-}
-
-function resolvePathKey(env: Record<string, string | undefined>): string {
-	if (!CASE_INSENSITIVE_ENV) return "PATH";
-	const match = Object.keys(env).find(candidate => candidate.toLowerCase() === "path");
-	return match ?? "PATH";
-}
-
 export interface GatewayInfo {
 	url: string;
 	pid: number;
@@ -130,56 +41,6 @@ let localGatewayProcess: Subprocess | null = null;
 let localGatewayUrl: string | null = null;
 let isCoordinatorInitialized = false;
 
-function filterEnv(env: Record<string, string | undefined>): Record<string, string | undefined> {
-	const filtered: Record<string, string | undefined> = {};
-	for (const [key, value] of Object.entries(env)) {
-		if (value === undefined) continue;
-		const normalizedKey = normalizeEnvKey(key);
-		const canonicalKey = NORMALIZED_ALLOWLIST.get(normalizedKey);
-		if (canonicalKey !== undefined) {
-			filtered[canonicalKey] = value;
-			continue;
-		}
-		if (NORMALIZED_ALLOW_PREFIXES.some(prefix => normalizedKey.startsWith(prefix))) {
-			filtered[key] = value;
-		}
-	}
-	return filtered;
-}
-
-function resolveVenvPath(cwd: string): string | null {
-	if (process.env.VIRTUAL_ENV) return process.env.VIRTUAL_ENV;
-	const candidates = [path.join(cwd, ".venv"), path.join(cwd, "venv")];
-	for (const candidate of candidates) {
-		if (fs.existsSync(candidate)) {
-			return candidate;
-		}
-	}
-	return null;
-}
-
-function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string | undefined>) {
-	const env = { ...baseEnv };
-	const venvPath = env.VIRTUAL_ENV ?? resolveVenvPath(cwd);
-	if (venvPath) {
-		env.VIRTUAL_ENV = venvPath;
-		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 (fs.existsSync(pythonCandidate)) {
-			const pathKey = resolvePathKey(env);
-			const currentPath = env[pathKey];
-			env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
-			return { pythonPath: pythonCandidate, env, venvPath };
-		}
-	}
-
-	const pythonPath = Bun.which("python") ?? Bun.which("python3");
-	if (!pythonPath) {
-		throw new Error("Python executable not found on PATH");
-	}
-	return { pythonPath, env, venvPath: null };
-}
-
 async function allocatePort(): Promise<number> {
 	const { promise, resolve, reject } = Promise.withResolvers<number>();
 	const server = createServer();
@@ -368,7 +229,8 @@ async function isGatewayAlive(info: GatewayInfo): Promise<boolean> {
 async function startGatewayProcess(
 	cwd: string,
 ): Promise<{ url: string; pid: number; pythonPath: string; venvPath: string | null }> {
-	const { shell, env } = await SettingsManager.getGlobalShellConfig();
+	const settings = await Settings.init();
+	const { shell, env } = settings.getShellConfig();
 	const filteredEnv = filterEnv(env);
 	const runtime = await resolvePythonRuntime(cwd, filteredEnv);
 	const snapshotPath = await getOrCreateSnapshot(shell, env).catch((err: unknown) => {
@@ -389,7 +251,7 @@ async function startGatewayProcess(
 
 	const gatewayProcess = Bun.spawn(
 		[
-			runtime.pythonPath,
+			runtime.pythonwPath,
 			"-m",
 			"kernel_gateway",
 			"--KernelGatewayApp.ip=127.0.0.1",