@oh-my-pi/pi-coding-agent 8.12.8 → 8.12.10

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "8.12.8",
+	"version": "8.12.10",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -79,22 +79,20 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "8.12.8",
-		"@oh-my-pi/pi-agent-core": "8.12.8",
-		"@oh-my-pi/pi-ai": "8.12.8",
-		"@oh-my-pi/pi-natives": "8.12.8",
-		"@oh-my-pi/pi-tui": "8.12.8",
-		"@oh-my-pi/pi-utils": "8.12.8",
+		"@oh-my-pi/omp-stats": "8.12.10",
+		"@oh-my-pi/pi-agent-core": "8.12.10",
+		"@oh-my-pi/pi-ai": "8.12.10",
+		"@oh-my-pi/pi-natives": "8.12.10",
+		"@oh-my-pi/pi-tui": "8.12.10",
+		"@oh-my-pi/pi-utils": "8.12.10",
 		"@openai/agents": "^0.4.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
 		"chalk": "^5.6.2",
-		"cli-highlight": "^2.1.11",
 		"diff": "^8.0.3",
 		"file-type": "^21.3.0",
 		"glob": "^13.0.0",
 		"handlebars": "^4.7.8",
-		"highlight.js": "^11.11.1",
 		"marked": "^17.0.1",
 		"nanoid": "^5.1.6",
 		"node-html-parser": "^7.0.2",

package/src/config/settings-manager.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { type Settings as SettingsItem, settingsCapability } from "../capability/settings";
 import { getAgentDbPath, getAgentDir } from "../config";
@@ -461,6 +461,8 @@ export class SettingsManager {
 	private settings!: Settings;
 	private persist: boolean;
 
+	static #lastInstance: SettingsManager | null = null;
+
 	/**
 	 * Private constructor - use static factory methods instead.
 	 * @param storage - SQLite storage instance for auth/cache, or null for in-memory mode
@@ -477,6 +479,7 @@ export class SettingsManager {
 		initialSettings: Settings,
 		persist: boolean,
 		projectSettings: Settings,
+		private agentDir: string | null,
 	) {
 		this.storage = storage;
 		this.configPath = configPath;
@@ -517,6 +520,9 @@ export class SettingsManager {
 	 * @returns Configured SettingsManager with merged global and user settings
 	 */
 	static async create(cwd: string = process.cwd(), agentDir: string = getAgentDir()): Promise<SettingsManager> {
+		cwd = path.normalize(cwd);
+		agentDir = path.normalize(agentDir);
+
 		const configPath = path.join(agentDir, "config.yml");
 		const storage = await AgentStorage.open(getAgentDbPath(agentDir));
 
@@ -541,7 +547,9 @@ export class SettingsManager {
 		// Load project settings before construction (constructor is sync)
 		const projectSettings = await SettingsManager.loadProjectSettingsStatic(cwd);
 
-		return new SettingsManager(storage, configPath, cwd, globalSettings, true, projectSettings);
+		const instance = new SettingsManager(storage, configPath, cwd, globalSettings, true, projectSettings, agentDir);
+		SettingsManager.#lastInstance = instance;
+		return instance;
 	}
 
 	/**
@@ -550,7 +558,7 @@ export class SettingsManager {
 	 * @returns SettingsManager that won't persist changes to disk
 	 */
 	static inMemory(settings: Partial<Settings> = {}): SettingsManager {
-		return new SettingsManager(null, null, null, settings, false, {});
+		return new SettingsManager(null, null, null, settings, false, {}, null);
 	}
 
 	/**
@@ -1784,4 +1792,54 @@ export class SettingsManager {
 			await this.save();
 		}
 	}
+
+	_compareUniqueCtorKeys(cwd: string, agentDir: string): boolean {
+		if (this.cwd !== cwd) {
+			cwd = path.normalize(cwd);
+			if (this.cwd !== cwd) {
+				return false;
+			}
+		}
+		if (this.agentDir !== agentDir) {
+			agentDir = path.normalize(agentDir);
+			if (this.agentDir !== agentDir) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Acquire the last created SettingsManager instance.
+	 * If no instance exists, create a new one.
+	 * @returns The SettingsManager instance
+	 */
+	static acquire(
+		cwd: string = process.cwd(),
+		agentDir: string = getAgentDir(),
+	): SettingsManager | Promise<SettingsManager> {
+		const prev = SettingsManager.#lastInstance;
+		if (prev?._compareUniqueCtorKeys(cwd, agentDir)) {
+			return prev;
+		}
+		return SettingsManager.create(cwd, agentDir);
+	}
+
+	/**
+	 * Gets the shell configuration
+	 * @returns The shell configuration
+	 */
+	async getShellConfig() {
+		const shell = this.getShellPath();
+		return procmgr.getShellConfig(shell);
+	}
+
+	/**
+	 * Gets the shell configuration from the last created SettingsManager instance.
+	 * @returns The shell configuration
+	 */
+	static async getGlobalShellConfig() {
+		const settings = await SettingsManager.acquire();
+		return settings.getShellConfig();
+	}
 }

package/src/exec/bash-executor.ts

@@ -4,8 +4,8 @@
  * 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 { OutputSink } from "../session/streaming-output";
-import { getShellConfig } from "../utils/shell";
 import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
 
 export interface BashExecutorOptions {
@@ -33,7 +33,7 @@ export interface BashResult {
 }
 
 export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
-	const { shell, args, env, prefix } = await getShellConfig();
+	const { shell, args, env, prefix } = await SettingsManager.getGlobalShellConfig();
 
 	// Merge additional env vars if provided
 	const finalEnv = options?.env ? { ...env, ...options.env } : env;

package/src/extensibility/plugins/installer.ts

@@ -45,7 +45,7 @@ export async function installPlugin(packageName: string): Promise<InstalledPlugi
 	}
 
 	// Run npm install in plugins directory
-	const proc = Bun.spawn(["npm", "install", packageName], {
+	const proc = Bun.spawn(["bun", "install", packageName], {
 		cwd: PLUGINS_DIR,
 		stdin: "ignore",
 		stdout: "pipe",
@@ -86,7 +86,7 @@ export async function uninstallPlugin(name: string): Promise<void> {
 
 	await ensurePluginsDir();
 
-	const proc = Bun.spawn(["npm", "uninstall", name], {
+	const proc = Bun.spawn(["bun", "uninstall", name], {
 		cwd: PLUGINS_DIR,
 		stdin: "ignore",
 		stdout: "pipe",

package/src/extensibility/plugins/manager.ts

@@ -154,7 +154,7 @@ export class PluginManager {
 		}
 
 		// Run npm install
-		const proc = Bun.spawn(["npm", "install", spec.packageName], {
+		const proc = Bun.spawn(["bun", "install", spec.packageName], {
 			cwd: getPluginsDir(),
 			stdin: "ignore",
 			stdout: "pipe",
@@ -234,7 +234,7 @@ export class PluginManager {
 		validatePackageName(name);
 		await this.ensurePackageJson();
 
-		const proc = Bun.spawn(["npm", "uninstall", name], {
+		const proc = Bun.spawn(["bun", "uninstall", name], {
 			cwd: getPluginsDir(),
 			stdin: "ignore",
 			stdout: "pipe",
@@ -616,7 +616,7 @@ export class PluginManager {
 
 	private async fixMissingPlugin(): Promise<boolean> {
 		try {
-			const proc = Bun.spawn(["npm", "install"], {
+			const proc = Bun.spawn(["bun", "install"], {
 				cwd: getPluginsDir(),
 				stdin: "ignore",
 				stdout: "pipe",

package/src/index.ts

@@ -276,4 +276,3 @@ export {
 	truncateTail,
 	type WriteToolDetails,
 } from "./tools";
-export { getShellConfig } from "./utils/shell";

package/src/ipy/gateway-coordinator.ts

@@ -1,10 +1,10 @@
 import * as fs from "node:fs";
 import { createServer } from "node:net";
 import * as path from "node:path";
-import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
 import { getAgentDir } from "../config";
-import { getShellConfig, killProcessTree } from "../utils/shell";
+import { SettingsManager } from "../config/settings-manager";
 import { getOrCreateSnapshot } from "../utils/shell-snapshot";
 import { time } from "../utils/timings";
 
@@ -304,7 +304,7 @@ async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
 					const lockPid = lockInfo?.pid;
 					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 staleByPid = lockPid !== undefined && !procmgr.isPidRunning(lockPid);
 					const staleByMissingPid = lockPid === undefined && staleByTime;
 					if (staleByPid || staleByMissingPid) {
 						await fs.promises.unlink(lockPath);
@@ -365,15 +365,6 @@ async function clearGatewayInfo(): Promise<void> {
 	}
 }
 
-function isPidRunning(pid: number): boolean {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
 async function isGatewayHealthy(url: string): Promise<boolean> {
 	try {
 		const response = await fetch(`${url}/api/kernelspecs`, {
@@ -386,14 +377,14 @@ async function isGatewayHealthy(url: string): Promise<boolean> {
 }
 
 async function isGatewayAlive(info: GatewayInfo): Promise<boolean> {
-	if (!isPidRunning(info.pid)) return false;
+	if (!procmgr.isPidRunning(info.pid)) return false;
 	return await isGatewayHealthy(info.url);
 }
 
 async function startGatewayProcess(
 	cwd: string,
 ): Promise<{ url: string; pid: number; pythonPath: string; venvPath: string | null }> {
-	const { shell, env } = await getShellConfig();
+	const { shell, env } = await SettingsManager.getGlobalShellConfig();
 	const filteredEnv = filterEnv(env);
 	const runtime = await resolvePythonRuntime(cwd, filteredEnv);
 	const snapshotPath = await getOrCreateSnapshot(shell, env).catch((err: unknown) => {
@@ -428,17 +419,16 @@ async function startGatewayProcess(
 			stdin: "ignore",
 			stdout: "pipe",
 			stderr: "pipe",
+			detached: true,
 			env: kernelEnv,
 		},
 	);
 
 	let exited = false;
 	gatewayProcess.exited
+		.catch(() => {})
 		.then(() => {
 			exited = true;
-		})
-		.catch(() => {
-			exited = true;
 		});
 
 	const startTime = Date.now();
@@ -459,13 +449,13 @@ async function startGatewayProcess(
 		await Bun.sleep(100);
 	}
 
-	await killProcessTree(gatewayProcess.pid);
+	await procmgr.terminate({ target: gatewayProcess, group: true });
 	throw new Error("Gateway startup timeout");
 }
 
 async function killGateway(pid: number, context: string): Promise<void> {
 	try {
-		await killProcessTree(pid);
+		await procmgr.terminate({ target: pid, group: true });
 	} catch (err) {
 		logger.warn("Failed to kill shared gateway process", {
 			error: err instanceof Error ? err.message : String(err),
@@ -495,7 +485,7 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 				}
 
 				logger.debug("Cleaning up stale gateway info", { pid: existingInfo.pid });
-				if (isPidRunning(existingInfo.pid)) {
+				if (procmgr.isPidRunning(existingInfo.pid)) {
 					await killGateway(existingInfo.pid, "stale");
 				}
 				await clearGatewayInfo();
@@ -557,7 +547,7 @@ export async function getGatewayStatus(): Promise<GatewayStatus> {
 			venvPath: null,
 		};
 	}
-	const active = isPidRunning(info.pid);
+	const active = procmgr.isPidRunning(info.pid);
 	return {
 		active,
 		url: info.url,
@@ -573,7 +563,7 @@ export async function shutdownSharedGateway(): Promise<void> {
 		await withGatewayLock(async () => {
 			const info = await readGatewayInfo();
 			if (!info) return;
-			if (isPidRunning(info.pid)) {
+			if (procmgr.isPidRunning(info.pid)) {
 				await killGateway(info.pid, "shutdown");
 			}
 			await clearGatewayInfo();

package/src/ipy/kernel.ts

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { logger, ptree } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
-import { getShellConfig } from "../utils/shell";
+import { SettingsManager } from "../config/settings-manager";
 import { getOrCreateSnapshot } from "../utils/shell-snapshot";
 import { time } from "../utils/timings";
 import { htmlToBasicMarkdown } from "../web/scrapers/types";
@@ -279,7 +279,7 @@ export async function checkPythonKernelAvailability(cwd: string): Promise<Python
 	}
 
 	try {
-		const { env } = await getShellConfig();
+		const { env } = await SettingsManager.getGlobalShellConfig();
 		const baseEnv = filterEnv(env);
 		const runtime = await resolvePythonRuntime(cwd, baseEnv);
 		const checkScript =
@@ -611,7 +611,7 @@ export class PythonKernel {
 	}
 
 	private static async startWithLocalGateway(options: KernelStartOptions): Promise<PythonKernel> {
-		const { shell, env } = await getShellConfig();
+		const { shell, env } = await SettingsManager.getGlobalShellConfig();
 		const filteredEnv = filterEnv(env);
 		const runtime = await resolvePythonRuntime(options.cwd, filteredEnv);
 		const snapshotPath = await getOrCreateSnapshot(shell, env).catch((err: unknown) => {

package/src/lsp/client.ts

@@ -1,4 +1,4 @@
-import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger, ptree } from "@oh-my-pi/pi-utils";
 import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
@@ -206,7 +206,7 @@ function concatBuffers(a: Uint8Array, b: Uint8Array): Uint8Array {
 }
 
 async function writeMessage(
-	sink: import("bun").FileSink,
+	sink: Bun.FileSink,
 	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
 ): Promise<void> {
 	const content = JSON.stringify(message);
@@ -230,7 +230,7 @@ async function startMessageReader(client: LspClient): Promise<void> {
 	if (client.isReading) return;
 	client.isReading = true;
 
-	const reader = (client.process.stdout as ReadableStream<Uint8Array>).getReader();
+	const reader = (client.proc.stdout as ReadableStream<Uint8Array>).getReader();
 
 	try {
 		while (true) {
@@ -364,7 +364,7 @@ async function sendResponse(
 	};
 
 	try {
-		await writeMessage(client.process.stdin as import("bun").FileSink, response);
+		await writeMessage(client.proc.stdin, response);
 	} catch (err) {
 		logger.error("LSP failed to respond.", { method, error: String(err) });
 	}
@@ -409,18 +409,17 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			? await getLspmuxCommand(baseCommand, baseArgs)
 			: { command: baseCommand, args: baseArgs };
 
-		const proc = Bun.spawn([command, ...args], {
+		const proc = ptree.spawn([command, ...args], {
 			cwd,
+			detached: true,
 			stdin: "pipe",
-			stdout: "pipe",
-			stderr: "pipe",
 			env: env ? { ...process.env, ...env } : undefined,
 		});
 
 		const client: LspClient = {
 			name: key,
 			cwd,
-			process: proc,
+			proc,
 			config,
 			requestId: 0,
 			diagnostics: new Map(),
@@ -686,7 +685,7 @@ export function shutdownClient(key: string): void {
 	sendRequest(client, "shutdown", null).catch(() => {});
 
 	// Kill process
-	client.process.kill();
+	client.proc.kill();
 	clients.delete(key);
 }
 
@@ -773,7 +772,7 @@ export async function sendRequest(
 	});
 
 	// Write request
-	writeMessage(client.process.stdin as import("bun").FileSink, request).catch(err => {
+	writeMessage(client.proc.stdin, request).catch(err => {
 		if (timeout) clearTimeout(timeout);
 		client.pendingRequests.delete(id);
 		cleanup();
@@ -793,26 +792,33 @@ export async function sendNotification(client: LspClient, method: string, params
 	};
 
 	client.lastActivity = Date.now();
-	await writeMessage(client.process.stdin as import("bun").FileSink, notification);
+	await writeMessage(client.proc.stdin, notification);
 }
 
 /**
  * Shutdown all LSP clients.
  */
 export function shutdownAll(): void {
-	for (const client of Array.from(clients.values())) {
-		// Reject all pending requests
-		for (const pending of Array.from(client.pendingRequests.values())) {
-			pending.reject(new Error("LSP client shutdown"));
-		}
-		client.pendingRequests.clear();
+	const clientsToShutdown = Array.from(clients.values());
+	clients.clear();
 
-		// Send shutdown request (best effort, don't wait)
-		sendRequest(client, "shutdown", null).catch(() => {});
+	const err = new Error("LSP client shutdown");
+	for (const client of clientsToShutdown) {
+		/// Reject all pending requests
+		const reqs = Array.from(client.pendingRequests.values());
+		client.pendingRequests.clear();
+		for (const pending of reqs) {
+			pending.reject(err);
+		}
 
-		client.process.kill();
+		void (async () => {
+			// Send shutdown request (best effort, don't wait)
+			const timeout = Bun.sleep(5_000);
+			const result = sendRequest(client, "shutdown", null).catch(() => {});
+			await Promise.race([result, timeout]);
+			client.proc.kill();
+		})().catch(() => {});
 	}
-	clients.clear();
 }
 
 /** Status of an LSP server */

package/src/lsp/render.ts

@@ -8,8 +8,8 @@
  * - Collapsible/expandable views
  */
 import type { RenderResultOptions } from "@oh-my-pi/pi-agent-core";
+import { type HighlightColors, highlightCode as nativeHighlightCode, supportsLanguage } from "@oh-my-pi/pi-natives";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
-import { highlight, supportsLanguage } from "cli-highlight";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
 import {
 	formatExpandHint,
@@ -291,29 +291,23 @@ function renderHover(
 }
 
 /**
- * Syntax highlight code using highlight.ts.
+ * Syntax highlight code using native WASM highlighter.
  */
 function highlightCode(codeText: string, language: string, theme: Theme): string[] {
 	const validLang = language && supportsLanguage(language) ? language : undefined;
 	try {
-		const cliTheme = {
-			keyword: (s: string) => theme.fg("syntaxKeyword", s),
-			built_in: (s: string) => theme.fg("syntaxType", s),
-			literal: (s: string) => theme.fg("syntaxNumber", s),
-			number: (s: string) => theme.fg("syntaxNumber", s),
-			string: (s: string) => theme.fg("syntaxString", s),
-			comment: (s: string) => theme.fg("syntaxComment", s),
-			function: (s: string) => theme.fg("syntaxFunction", s),
-			title: (s: string) => theme.fg("syntaxFunction", s),
-			class: (s: string) => theme.fg("syntaxType", s),
-			type: (s: string) => theme.fg("syntaxType", s),
-			attr: (s: string) => theme.fg("syntaxVariable", s),
-			variable: (s: string) => theme.fg("syntaxVariable", s),
-			params: (s: string) => theme.fg("syntaxVariable", s),
-			operator: (s: string) => theme.fg("syntaxOperator", s),
-			punctuation: (s: string) => theme.fg("syntaxPunctuation", s),
+		const colors: HighlightColors = {
+			comment: theme.getFgAnsi("syntaxComment"),
+			keyword: theme.getFgAnsi("syntaxKeyword"),
+			function: theme.getFgAnsi("syntaxFunction"),
+			variable: theme.getFgAnsi("syntaxVariable"),
+			string: theme.getFgAnsi("syntaxString"),
+			number: theme.getFgAnsi("syntaxNumber"),
+			type: theme.getFgAnsi("syntaxType"),
+			operator: theme.getFgAnsi("syntaxOperator"),
+			punctuation: theme.getFgAnsi("syntaxPunctuation"),
 		};
-		return highlight(codeText, { language: validLang, ignoreIllegals: true, theme: cliTheme }).split("\n");
+		return nativeHighlightCode(codeText, validLang, colors).split("\n");
 	} catch {
 		return codeText.split("\n");
 	}

package/src/lsp/types.ts

@@ -1,6 +1,6 @@
 import { StringEnum } from "@oh-my-pi/pi-ai";
+import type { ptree } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import type { Subprocess } from "bun";
 
 // =============================================================================
 // Tool Schema
@@ -400,7 +400,7 @@ export interface LspClient {
 	name: string;
 	cwd: string;
 	config: ServerConfig;
-	process: Subprocess;
+	proc: ptree.ChildProcess<"pipe">;
 	requestId: number;
 	diagnostics: Map<string, Diagnostic[]>;
 	diagnosticsVersion: number;

package/src/modes/rpc/rpc-client.ts

@@ -524,7 +524,7 @@ export class RpcClient {
 
 		// Write to stdin after registering the handler
 		const stdin = this.process!.stdin as import("bun").FileSink;
-		stdin.write(new TextEncoder().encode(`${JSON.stringify(fullCommand)}\n`));
+		stdin.write(`${JSON.stringify(fullCommand)}\n`);
 		// flush() returns number | Promise<number> - handle both cases
 		const flushResult = stdin.flush();
 		if (flushResult instanceof Promise) {

package/src/modes/theme/theme.ts

@@ -1,11 +1,15 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import {
+	type HighlightColors as NativeHighlightColors,
+	highlightCode as nativeHighlightCode,
+	supportsLanguage as nativeSupportsLanguage,
+} from "@oh-my-pi/pi-natives";
 import type { EditorTheme, MarkdownTheme, SelectListTheme, SymbolTheme } from "@oh-my-pi/pi-tui";
 import { adjustHsv, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
 import chalk from "chalk";
-import { highlight, supportsLanguage } from "cli-highlight";
 import { getCustomThemesDir } from "../../config";
 // Embed theme JSON files at build time
 import darkThemeJson from "./dark.json" with { type: "json" };
@@ -2029,37 +2033,25 @@ export async function getThemeExportColors(themeName?: string): Promise<{
 // TUI Helpers
 // ============================================================================
 
-type CliHighlightTheme = Record<string, (s: string) => string>;
-
-let cachedHighlightThemeFor: Theme | undefined;
-let cachedCliHighlightTheme: CliHighlightTheme | undefined;
-
-function buildCliHighlightTheme(t: Theme): CliHighlightTheme {
-	return {
-		keyword: (s: string) => t.fg("syntaxKeyword", s),
-		built_in: (s: string) => t.fg("syntaxType", s),
-		literal: (s: string) => t.fg("syntaxNumber", s),
-		number: (s: string) => t.fg("syntaxNumber", s),
-		string: (s: string) => t.fg("syntaxString", s),
-		comment: (s: string) => t.fg("syntaxComment", s),
-		function: (s: string) => t.fg("syntaxFunction", s),
-		title: (s: string) => t.fg("syntaxFunction", s),
-		class: (s: string) => t.fg("syntaxType", s),
-		type: (s: string) => t.fg("syntaxType", s),
-		attr: (s: string) => t.fg("syntaxVariable", s),
-		variable: (s: string) => t.fg("syntaxVariable", s),
-		params: (s: string) => t.fg("syntaxVariable", s),
-		operator: (s: string) => t.fg("syntaxOperator", s),
-		punctuation: (s: string) => t.fg("syntaxPunctuation", s),
-	};
-}
-
-function getCliHighlightTheme(t: Theme): CliHighlightTheme {
-	if (cachedHighlightThemeFor !== t || !cachedCliHighlightTheme) {
-		cachedHighlightThemeFor = t;
-		cachedCliHighlightTheme = buildCliHighlightTheme(t);
+let cachedHighlightColorsFor: Theme | undefined;
+let cachedHighlightColors: NativeHighlightColors | undefined;
+
+function getHighlightColors(t: Theme): NativeHighlightColors {
+	if (cachedHighlightColorsFor !== t || !cachedHighlightColors) {
+		cachedHighlightColorsFor = t;
+		cachedHighlightColors = {
+			comment: t.getFgAnsi("syntaxComment"),
+			keyword: t.getFgAnsi("syntaxKeyword"),
+			function: t.getFgAnsi("syntaxFunction"),
+			variable: t.getFgAnsi("syntaxVariable"),
+			string: t.getFgAnsi("syntaxString"),
+			number: t.getFgAnsi("syntaxNumber"),
+			type: t.getFgAnsi("syntaxType"),
+			operator: t.getFgAnsi("syntaxOperator"),
+			punctuation: t.getFgAnsi("syntaxPunctuation"),
+		};
 	}
-	return cachedCliHighlightTheme;
+	return cachedHighlightColors;
 }
 
 /**
@@ -2067,15 +2059,9 @@ function getCliHighlightTheme(t: Theme): CliHighlightTheme {
  * Returns array of highlighted lines.
  */
 export function highlightCode(code: string, lang?: string): string[] {
-	// Validate language before highlighting to avoid stderr spam from cli-highlight
-	const validLang = lang && supportsLanguage(lang) ? lang : undefined;
-	const opts = {
-		language: validLang,
-		ignoreIllegals: true,
-		theme: getCliHighlightTheme(theme),
-	};
+	const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
 	try {
-		return highlight(code, opts).split("\n");
+		return nativeHighlightCode(code, validLang, getHighlightColors(theme)).split("\n");
 	} catch {
 		return code.split("\n");
 	}
@@ -2212,15 +2198,9 @@ export function getMarkdownTheme(): MarkdownTheme {
 		symbols: getSymbolTheme(),
 		getMermaidImage,
 		highlightCode: (code: string, lang?: string): string[] => {
-			// Validate language before highlighting to avoid stderr spam from cli-highlight
-			const validLang = lang && supportsLanguage(lang) ? lang : undefined;
-			const opts = {
-				language: validLang,
-				ignoreIllegals: true,
-				theme: getCliHighlightTheme(theme),
-			};
+			const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
 			try {
-				return highlight(code, opts).split("\n");
+				return nativeHighlightCode(code, validLang, getHighlightColors(theme)).split("\n");
 			} catch {
 				return code.split("\n").map(line => theme.fg("mdCodeBlock", line));
 			}

package/src/tools/read.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
@@ -43,77 +44,183 @@ function isRemoteMountPath(absolutePath: string): boolean {
 	return absolutePath.startsWith(REMOTE_MOUNT_PREFIX);
 }
 
-/**
- * Stream lines from a file, collecting only the requested range.
- * Avoids loading the entire file into memory for large files.
- *
- * @param filePath - Path to the file
- * @param startLine - 0-indexed start line
- * @param maxLinesToCollect - Maximum lines to collect (from startLine)
- * @param maxBytes - Maximum bytes to collect
- * @returns Collected lines, total line count, and truncation info
- */
+const READ_CHUNK_SIZE = 64 * 1024;
+
 async function streamLinesFromFile(
 	filePath: string,
 	startLine: number,
 	maxLinesToCollect: number,
 	maxBytes: number,
+	selectedLineLimit: number | null,
+	signal?: AbortSignal,
 ): Promise<{
 	lines: string[];
 	totalFileLines: number;
 	collectedBytes: number;
 	stoppedByByteLimit: boolean;
+	firstLinePreview?: { text: string; bytes: number };
+	firstLineByteLength?: number;
+	selectedBytesTotal: number;
 }> {
-	const stream = Bun.file(filePath).stream();
-	const decoder = new TextDecoder();
-
+	const bufferChunk = Buffer.allocUnsafe(READ_CHUNK_SIZE);
 	const collectedLines: string[] = [];
 	let lineIndex = 0;
 	let collectedBytes = 0;
 	let stoppedByByteLimit = false;
-	let buffer = "";
 	let doneCollecting = false;
+	let fileHandle: fs.FileHandle | null = null;
+	let currentLineLength = 0;
+	let currentLineChunks: Buffer[] = [];
+	let sawAnyByte = false;
+	let endedWithNewline = false;
+	let firstLinePreviewBytes = 0;
+	const firstLinePreviewChunks: Buffer[] = [];
+	let firstLineByteLength: number | undefined;
+	let selectedBytesTotal = 0;
+	let selectedLinesSeen = 0;
+	let captureLine = false;
+	let discardLineChunks = false;
+	let lineCaptureLimit = 0;
+
+	const setupLineState = () => {
+		captureLine = !doneCollecting && lineIndex >= startLine;
+		discardLineChunks = !captureLine;
+		if (captureLine) {
+			const separatorBytes = collectedLines.length > 0 ? 1 : 0;
+			lineCaptureLimit = maxBytes - collectedBytes - separatorBytes;
+			if (lineCaptureLimit <= 0) {
+				discardLineChunks = true;
+			}
+		} else {
+			lineCaptureLimit = 0;
+		}
+	};
+
+	const decodeLine = (): string => {
+		if (currentLineLength === 0) return "";
+		if (currentLineChunks.length === 1 && currentLineChunks[0]?.length === currentLineLength) {
+			return currentLineChunks[0].toString("utf-8");
+		}
+		return Buffer.concat(currentLineChunks, currentLineLength).toString("utf-8");
+	};
 
-	for await (const chunk of stream) {
-		buffer += decoder.decode(chunk, { stream: true });
+	const maybeCapturePreview = (segment: Uint8Array) => {
+		if (doneCollecting || lineIndex < startLine || collectedLines.length !== 0) return;
+		if (firstLinePreviewBytes >= maxBytes || segment.length === 0) return;
+		const remaining = maxBytes - firstLinePreviewBytes;
+		const slice = segment.length > remaining ? segment.subarray(0, remaining) : segment;
+		if (slice.length === 0) return;
+		firstLinePreviewChunks.push(Buffer.from(slice));
+		firstLinePreviewBytes += slice.length;
+	};
 
-		for (let newlinePos = buffer.indexOf("\n"); newlinePos !== -1; newlinePos = buffer.indexOf("\n")) {
-			const line = buffer.slice(0, newlinePos);
-			buffer = buffer.slice(newlinePos + 1);
+	const appendSegment = (segment: Uint8Array) => {
+		currentLineLength += segment.length;
+		maybeCapturePreview(segment);
+		if (!captureLine || discardLineChunks || segment.length === 0) return;
+		if (currentLineLength <= lineCaptureLimit) {
+			currentLineChunks.push(Buffer.from(segment));
+		} else {
+			discardLineChunks = true;
+		}
+	};
 
-			if (!doneCollecting && lineIndex >= startLine) {
-				const lineBytes = Buffer.byteLength(line, "utf-8") + (collectedLines.length > 0 ? 1 : 0);
+	const finalizeLine = () => {
+		if (lineIndex >= startLine && (selectedLineLimit === null || selectedLinesSeen < selectedLineLimit)) {
+			selectedBytesTotal += currentLineLength + (selectedLinesSeen > 0 ? 1 : 0);
+			selectedLinesSeen++;
+		}
 
-				if (collectedBytes + lineBytes > maxBytes && collectedLines.length > 0) {
+		if (!doneCollecting && lineIndex >= startLine) {
+			const separatorBytes = collectedLines.length > 0 ? 1 : 0;
+			if (collectedLines.length >= maxLinesToCollect) {
+				doneCollecting = true;
+			} else if (collectedLines.length === 0 && currentLineLength > maxBytes) {
+				stoppedByByteLimit = true;
+				doneCollecting = true;
+				if (firstLineByteLength === undefined) {
+					firstLineByteLength = currentLineLength;
+				}
+			} else if (collectedLines.length > 0 && collectedBytes + separatorBytes + currentLineLength > maxBytes) {
+				stoppedByByteLimit = true;
+				doneCollecting = true;
+			} else {
+				const lineText = decodeLine();
+				collectedLines.push(lineText);
+				collectedBytes += separatorBytes + currentLineLength;
+				if (firstLineByteLength === undefined) {
+					firstLineByteLength = currentLineLength;
+				}
+				if (collectedBytes > maxBytes) {
 					stoppedByByteLimit = true;
 					doneCollecting = true;
-				} else if (collectedLines.length < maxLinesToCollect) {
-					collectedLines.push(line);
-					collectedBytes += lineBytes;
-					if (collectedLines.length >= maxLinesToCollect) {
-						doneCollecting = true;
-					}
-				} else {
+				} else if (collectedLines.length >= maxLinesToCollect) {
 					doneCollecting = true;
 				}
 			}
+		} else if (lineIndex >= startLine && firstLineByteLength === undefined) {
+			firstLineByteLength = currentLineLength;
+		}
+
+		lineIndex++;
+		currentLineLength = 0;
+		currentLineChunks = [];
+		setupLineState();
+	};
+
+	setupLineState();
+
+	try {
+		fileHandle = await fs.open(filePath, "r");
+
+		while (true) {
+			throwIfAborted(signal);
+			const { bytesRead } = await fileHandle.read(bufferChunk, 0, bufferChunk.length, null);
+			if (bytesRead === 0) break;
+
+			sawAnyByte = true;
+			const chunk = bufferChunk.subarray(0, bytesRead);
+			endedWithNewline = chunk[bytesRead - 1] === 0x0a;
+
+			let start = 0;
+			for (let i = 0; i < chunk.length; i++) {
+				if (chunk[i] === 0x0a) {
+					const segment = chunk.subarray(start, i);
+					if (segment.length > 0) {
+						appendSegment(segment);
+					}
+					finalizeLine();
+					start = i + 1;
+				}
+			}
 
-			lineIndex++;
+			if (start < chunk.length) {
+				appendSegment(chunk.subarray(start));
+			}
+		}
+	} finally {
+		if (fileHandle) {
+			await fileHandle.close();
 		}
 	}
 
-	// Handle remaining buffer (last line without trailing newline)
-	if (buffer.length > 0) {
-		if (!doneCollecting && lineIndex >= startLine && collectedLines.length < maxLinesToCollect) {
-			const lineBytes = Buffer.byteLength(buffer, "utf-8") + (collectedLines.length > 0 ? 1 : 0);
-			if (collectedBytes + lineBytes <= maxBytes || collectedLines.length === 0) {
-				collectedLines.push(buffer);
-				collectedBytes += lineBytes;
-			} else {
-				stoppedByByteLimit = true;
-			}
+	if (endedWithNewline || currentLineLength > 0 || !sawAnyByte) {
+		finalizeLine();
+	}
+
+	let firstLinePreview: { text: string; bytes: number } | undefined;
+	if (firstLinePreviewBytes > 0) {
+		const buf = Buffer.concat(firstLinePreviewChunks, firstLinePreviewBytes);
+		let end = Math.min(buf.length, maxBytes);
+		while (end > 0 && (buf[end] & 0xc0) === 0x80) {
+			end--;
+		}
+		if (end > 0) {
+			const text = buf.slice(0, end).toString("utf-8");
+			firstLinePreview = { text, bytes: Buffer.byteLength(text, "utf-8") };
+		} else {
+			firstLinePreview = { text: "", bytes: 0 };
 		}
-		lineIndex++;
 	}
 
 	return {
@@ -121,6 +228,9 @@ async function streamLinesFromFile(
 		totalFileLines: lineIndex,
 		collectedBytes,
 		stoppedByByteLimit,
+		firstLinePreview,
+		firstLineByteLength,
+		selectedBytesTotal,
 	};
 }
 
@@ -599,13 +709,25 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const startLine = offset ? Math.max(0, offset - 1) : 0;
 			const startLineDisplay = startLine + 1; // For display (1-indexed)
 
-			// Calculate how many lines to collect: user limit or default truncation limit
-			const maxLinesToCollect = limit !== undefined ? limit : DEFAULT_MAX_LINES;
-
-			// Stream the file, collecting only the needed lines
-			const streamResult = await streamLinesFromFile(absolutePath, startLine, maxLinesToCollect, DEFAULT_MAX_BYTES);
+			const maxLinesToCollect = limit !== undefined ? Math.min(limit, DEFAULT_MAX_LINES) : DEFAULT_MAX_LINES;
+			const selectedLineLimit = limit ?? null;
+			const streamResult = await streamLinesFromFile(
+				absolutePath,
+				startLine,
+				maxLinesToCollect,
+				DEFAULT_MAX_BYTES,
+				selectedLineLimit,
+				signal,
+			);
 
-			const { lines: collectedLines, totalFileLines, collectedBytes, stoppedByByteLimit } = streamResult;
+			const {
+				lines: collectedLines,
+				totalFileLines,
+				collectedBytes,
+				stoppedByByteLimit,
+				firstLinePreview,
+				firstLineByteLength,
+			} = streamResult;
 
 			// Check if offset is out of bounds - return graceful message instead of throwing
 			if (startLine >= totalFileLines) {
@@ -618,14 +740,13 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					.done();
 			}
 
-			// Build the selected content from collected lines
 			const selectedContent = collectedLines.join("\n");
 			const userLimitedLines = limit !== undefined ? collectedLines.length : undefined;
 
-			// Build truncation result from streaming data
 			const totalSelectedLines = totalFileLines - startLine;
-			const totalSelectedBytes = collectedBytes; // We don't know exact total bytes without reading all
+			const totalSelectedBytes = collectedBytes;
 			const wasTruncated = collectedLines.length < totalSelectedLines || stoppedByByteLimit;
+			const firstLineExceedsLimit = firstLineByteLength !== undefined && firstLineByteLength > DEFAULT_MAX_BYTES;
 
 			const truncation: TruncationResult = {
 				content: selectedContent,
@@ -636,7 +757,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				outputLines: collectedLines.length,
 				outputBytes: collectedBytes,
 				lastLinePartial: false,
-				firstLineExceedsLimit: collectedLines.length === 0 && totalFileLines > startLine,
+				firstLineExceedsLimit,
 				maxLines: DEFAULT_MAX_LINES,
 				maxBytes: DEFAULT_MAX_BYTES,
 			};
@@ -658,9 +779,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			let outputText: string;
 
 			if (truncation.firstLineExceedsLimit) {
-				const firstLine = collectedLines[0] ?? "";
-				const firstLineBytes = Buffer.byteLength(firstLine, "utf-8");
-				const snippet = truncateStringToBytesFromStart(firstLine, DEFAULT_MAX_BYTES);
+				const firstLineBytes = firstLineByteLength ?? 0;
+				const snippet = firstLinePreview ?? { text: "", bytes: 0 };
 
 				outputText = shouldAddLineNumbers ? prependLineNumbers(snippet.text, startLineDisplay) : snippet.text;
 				if (snippet.text.length === 0) {

package/src/utils/shell.ts

@@ -1,302 +0,0 @@
-import * as fs from "node:fs";
-import { $ } from "bun";
-import { SettingsManager } from "../config/settings-manager";
-
-export interface ShellConfig {
-	shell: string;
-	args: string[];
-	env: Record<string, string | undefined>;
-	prefix: string | undefined;
-}
-
-let cachedShellConfig: ShellConfig | null = null;
-
-/**
- * Check if a shell binary is executable.
- */
-async function isExecutable(path: string): Promise<boolean> {
-	try {
-		await fs.promises.access(path, fs.constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Build the spawn environment (cached).
- */
-function buildSpawnEnv(shell: string): Record<string, string | undefined> {
-	const noCI = process.env.OMP_BASH_NO_CI || process.env.CLAUDE_BASH_NO_CI;
-	return {
-		...process.env,
-		SHELL: shell,
-		GIT_EDITOR: "true",
-		GPG_TTY: "not a tty",
-		OMPCODE: "1",
-		CLAUDECODE: "1",
-		...(noCI ? {} : { CI: "true" }),
-	};
-}
-
-/**
- * Get shell args, optionally including login shell flag.
- * Supports OMP_BASH_NO_LOGIN and CLAUDE_BASH_NO_LOGIN to skip -l.
- */
-function getShellArgs(): string[] {
-	const noLogin = process.env.OMP_BASH_NO_LOGIN || process.env.CLAUDE_BASH_NO_LOGIN;
-	return noLogin ? ["-c"] : ["-l", "-c"];
-}
-
-/**
- * Get shell prefix for wrapping commands (profilers, strace, etc.).
- */
-function getShellPrefix(): string | undefined {
-	return process.env.OMP_SHELL_PREFIX || process.env.CLAUDE_CODE_SHELL_PREFIX;
-}
-
-/**
- * Find bash executable on PATH (Windows)
- */
-function findBashOnPath(): string | null {
-	try {
-		return Bun.which("bash.exe");
-	} catch {
-		// Ignore errors
-	}
-	return null;
-}
-
-/**
- * Build full shell config from a shell path.
- */
-function buildConfig(shell: string): ShellConfig {
-	return {
-		shell,
-		args: getShellArgs(),
-		env: buildSpawnEnv(shell),
-		prefix: getShellPrefix(),
-	};
-}
-
-/**
- * Get shell configuration based on platform.
- * Resolution order:
- * 1. User-specified shellPath in settings.json
- * 2. On Windows: Git Bash in known locations, then bash on PATH
- * 3. On Unix: $SHELL if bash/zsh, then fallback paths
- * 4. Fallback: sh
- */
-export async function getShellConfig(): Promise<ShellConfig> {
-	if (cachedShellConfig) {
-		return cachedShellConfig;
-	}
-
-	const settings = await SettingsManager.create();
-	const customShellPath = settings.getShellPath();
-
-	// 1. Check user-specified shell path
-	if (customShellPath) {
-		if (await Bun.file(customShellPath).exists()) {
-			cachedShellConfig = buildConfig(customShellPath);
-			return cachedShellConfig;
-		}
-		throw new Error(
-			`Custom shell path not found: ${customShellPath}\nPlease update shellPath in ~/.omp/agent/settings.json`,
-		);
-	}
-
-	if (process.platform === "win32") {
-		// 2. Try Git Bash in known locations
-		const paths: string[] = [];
-		const programFiles = process.env.ProgramFiles;
-		if (programFiles) {
-			paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
-		}
-		const programFilesX86 = process.env["ProgramFiles(x86)"];
-		if (programFilesX86) {
-			paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
-		}
-
-		for (const path of paths) {
-			if (await Bun.file(path).exists()) {
-				cachedShellConfig = buildConfig(path);
-				return cachedShellConfig;
-			}
-		}
-
-		// 3. Fallback: search bash.exe on PATH (Cygwin, MSYS2, WSL, etc.)
-		const bashOnPath = findBashOnPath();
-		if (bashOnPath) {
-			cachedShellConfig = buildConfig(bashOnPath);
-			return cachedShellConfig;
-		}
-
-		throw new Error(
-			`No bash shell found. Options:\n` +
-				`  1. Install Git for Windows: https://git-scm.com/download/win\n` +
-				`  2. Add your bash to PATH (Cygwin, MSYS2, etc.)\n` +
-				`  3. Set shellPath in ~/.omp/agent/settings.json\n\n` +
-				`Searched Git Bash in:\n${paths.map(p => `  ${p}`).join("\n")}`,
-		);
-	}
-
-	// Unix: prefer user's shell from $SHELL if it's bash/zsh and executable
-	const userShell = process.env.SHELL;
-	const isValidShell = userShell && (userShell.includes("bash") || userShell.includes("zsh"));
-	if (isValidShell && (await isExecutable(userShell))) {
-		cachedShellConfig = buildConfig(userShell);
-		return cachedShellConfig;
-	}
-
-	// Fallback paths (Claude's approach: check known locations)
-	const fallbackPaths = ["/bin", "/usr/bin", "/usr/local/bin", "/opt/homebrew/bin"];
-	const preferZsh = !userShell?.includes("bash");
-	const shellOrder = preferZsh ? ["zsh", "bash"] : ["bash", "zsh"];
-
-	for (const shellName of shellOrder) {
-		for (const dir of fallbackPaths) {
-			const shellPath = `${dir}/${shellName}`;
-			if (await isExecutable(shellPath)) {
-				cachedShellConfig = buildConfig(shellPath);
-				return cachedShellConfig;
-			}
-		}
-	}
-
-	// Last resort: use Bun.which
-	const bashPath = Bun.which("bash");
-	if (bashPath) {
-		cachedShellConfig = buildConfig(bashPath);
-		return cachedShellConfig;
-	}
-
-	const shPath = Bun.which("sh");
-	cachedShellConfig = buildConfig(shPath || "sh");
-	return cachedShellConfig;
-}
-
-let pgrepAvailable: string | null | undefined;
-
-/**
- * Check if pgrep is available on this system (cached).
- */
-function hasPgrep(): string | null {
-	if (pgrepAvailable === undefined) {
-		try {
-			pgrepAvailable = Bun.which("pgrep") ?? null;
-		} catch {
-			pgrepAvailable = null;
-		}
-	}
-	return pgrepAvailable;
-}
-
-/**
- * Get direct children of a PID using pgrep.
- */
-async function getChildrenViaPgrep(pid: number): Promise<number[]> {
-	const result = await $`pgrep -P ${pid}`.quiet().nothrow();
-	if (result.exitCode !== 0) return [];
-	const output = result.stdout.toString().trim();
-	if (!output) return [];
-
-	const children: number[] = [];
-	for (const line of output.split("\n")) {
-		const childPid = parseInt(line, 10);
-		if (!Number.isNaN(childPid)) children.push(childPid);
-	}
-	return children;
-}
-
-/**
- * Get direct children of a PID using /proc (Linux only).
- */
-async function getChildrenViaProc(pid: number): Promise<number[]> {
-	try {
-		const script = `for p in /proc/[0-9]*/stat; do cat "$p" 2>/dev/null; done | awk -v ppid=${pid} '$4 == ppid { print $1 }'`;
-		const result = await $`sh -c ${script}`.quiet().nothrow();
-		if (result.exitCode !== 0) return [];
-		const output = result.stdout.toString().trim();
-		if (!output) return [];
-
-		const children: number[] = [];
-		for (const line of output.split("\n")) {
-			const childPid = parseInt(line, 10);
-			if (!Number.isNaN(childPid)) children.push(childPid);
-		}
-		return children;
-	} catch {
-		return [];
-	}
-}
-
-/**
- * Collect all descendant PIDs breadth-first.
- * Returns deepest descendants first (reverse BFS order) for proper kill ordering.
- */
-async function getDescendantPids(pid: number): Promise<number[]> {
-	const getChildren = hasPgrep() ? getChildrenViaPgrep : getChildrenViaProc;
-	const descendants: number[] = [];
-	const queue = [pid];
-
-	while (queue.length > 0) {
-		const current = queue.shift()!;
-		const children = await getChildren(current);
-		for (const child of children) {
-			descendants.push(child);
-			queue.push(child);
-		}
-	}
-
-	// Reverse so deepest children are killed first
-	return descendants.reverse();
-}
-
-function tryKill(pid: number, signal: NodeJS.Signals): boolean {
-	try {
-		process.kill(pid, signal);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Kill a process and all its descendants.
- * @param gracePeriodMs - Time to wait after SIGTERM before SIGKILL (0 = immediate SIGKILL)
- */
-export async function killProcessTree(pid: number, gracePeriodMs = 0): Promise<void> {
-	if (process.platform === "win32") {
-		await $`taskkill /F /T /PID ${pid}`.quiet().nothrow();
-		return;
-	}
-
-	const signal = gracePeriodMs > 0 ? "SIGTERM" : "SIGKILL";
-
-	// Fast path: process group kill (works if pid is group leader)
-	try {
-		process.kill(-pid, signal);
-		if (gracePeriodMs > 0) {
-			await Bun.sleep(gracePeriodMs);
-			try {
-				process.kill(-pid, "SIGKILL");
-			} catch {
-				// Already dead
-			}
-		}
-		return;
-	} catch {
-		// Not a process group leader, fall through
-	}
-
-	// Collect descendants BEFORE killing to minimize race window
-	const allPids = [...(await getDescendantPids(pid)), pid];
-
-	if (gracePeriodMs > 0) {
-		for (const p of allPids) tryKill(p, "SIGTERM");
-		await Bun.sleep(gracePeriodMs);
-	}
-
-	for (const p of allPids) tryKill(p, "SIGKILL");
-}