@oh-my-pi/pi-coding-agent 17.0.0 → 17.0.2

package/src/extensibility/hooks/loader.ts

@@ -12,7 +12,7 @@ import { loadCapability } from "../../discovery";
 import * as PiCodingAgent from "../../index";
 import type { CustomMessagePayload } from "../../session/messages";
 import * as typebox from "../typebox";
-import { resolvePath, withExitGuard } from "../utils";
+import { resolvePath, withHostGuard } from "../utils";
 import { execCommand } from "./runner";
 import type { ExecOptions, HookAPI, HookFactory, HookMessageRenderer, RegisteredCommand } from "./types";
 
@@ -149,7 +149,7 @@ async function loadHook(hookPath: string, cwd: string): Promise<{ hook: LoadedHo
 
 	try {
 		// Import the module using native Bun import
-		const module = await withExitGuard(() => import(resolvedPath));
+		const module = await withHostGuard(() => import(resolvedPath));
 		const factory = module.default as HookFactory;
 
 		if (typeof factory !== "function") {
@@ -164,7 +164,7 @@ async function loadHook(hookPath: string, cwd: string): Promise<{ hook: LoadedHo
 		);
 
 		// Call factory to register handlers
-		await withExitGuard(async () => factory(api));
+		await withHostGuard(async () => factory(api));
 
 		return {
 			hook: {

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -44,9 +44,10 @@ import { ReadTool } from "../tools/read";
 import { formatBytes } from "../tools/render-utils";
 import { WriteTool } from "../tools/write";
 import { EventBus } from "../utils/event-bus";
-import { loadExtensionFromFactory, loadExtensions } from "./extensions";
+import { discoverExtensionPaths, loadExtensionFromFactory, loadExtensions } from "./extensions";
 import { ExtensionRuntime } from "./extensions/loader";
 import type { ExtensionFactory, ToolDefinition } from "./extensions/types";
+import { getEnabledPlugins, resolvePluginExtensionPaths, type ScopedInstalledPlugin } from "./plugins/loader";
 import type { Skill } from "./skills";
 import { loadSkillsFromDir } from "./skills";
 import { Type } from "./typebox";
@@ -655,6 +656,100 @@ export const SettingsManager = {
 	},
 } as const;
 
+/** Scope used by the legacy package manager for discovered resources. */
+export type SourceScope = "user" | "project" | "temporary";
+
+/** Discovery metadata exposed alongside a legacy package resource path. */
+export interface PathMetadata {
+	source: string;
+	scope: SourceScope;
+	origin: "package" | "top-level";
+	baseDir?: string;
+}
+
+/** One extension, skill, prompt, or theme resolved by the legacy package manager. */
+export interface ResolvedResource {
+	path: string;
+	enabled: boolean;
+	metadata: PathMetadata;
+}
+
+/** Resource groups returned by {@link DefaultPackageManager.resolve}. */
+export interface ResolvedPaths {
+	extensions: ResolvedResource[];
+	skills: ResolvedResource[];
+	prompts: ResolvedResource[];
+	themes: ResolvedResource[];
+}
+
+/** Action a legacy caller requests when a configured package is unavailable. */
+export type MissingSourceAction = "install" | "skip" | "error";
+
+/** Construction inputs accepted by the legacy package manager. */
+export interface DefaultPackageManagerOptions {
+	cwd: string;
+	agentDir: string;
+	settingsManager: Settings | Promise<Settings>;
+}
+
+/**
+ * Enumerates the extensions OMP would load through the historical package
+ * manager surface used by legacy extensions.
+ */
+export class DefaultPackageManager {
+	#cwd: string;
+	#agentDir: string;
+	#settingsManager: Settings | Promise<Settings>;
+
+	constructor(options: DefaultPackageManagerOptions) {
+		this.#cwd = options.cwd;
+		this.#agentDir = options.agentDir;
+		this.#settingsManager = options.settingsManager;
+	}
+
+	/** Resolve enabled extension paths with their OMP plugin provenance. */
+	async resolve(_onMissing?: (source: string) => Promise<MissingSourceAction>): Promise<ResolvedPaths> {
+		const settings = await this.#settingsManager;
+		const configuredPaths = settings.get("extensions") ?? [];
+		const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
+		const [extensionPaths, plugins] = await Promise.all([
+			discoverExtensionPaths(configuredPaths, this.#cwd, disabledExtensionIds),
+			getEnabledPlugins(this.#cwd),
+		]);
+		const pluginByExtensionPath = new Map<string, ScopedInstalledPlugin>();
+		for (const plugin of plugins) {
+			for (const extensionPath of resolvePluginExtensionPaths(plugin)) {
+				pluginByExtensionPath.set(path.resolve(extensionPath), plugin);
+			}
+		}
+
+		const extensions = extensionPaths.map(extensionPath => {
+			const resolvedPath = path.resolve(extensionPath);
+			const plugin = pluginByExtensionPath.get(resolvedPath);
+			const agentDirRelative = path.relative(path.resolve(this.#agentDir), resolvedPath);
+			const metadata: PathMetadata = plugin
+				? {
+						source: `npm:${plugin.name}`,
+						scope: plugin.scope,
+						origin: "package",
+						baseDir: plugin.path,
+					}
+				: {
+						source: "auto",
+						scope:
+							agentDirRelative === "" ||
+							(!agentDirRelative.startsWith("..") && !path.isAbsolute(agentDirRelative))
+								? "user"
+								: "project",
+						origin: "top-level",
+					};
+			return { path: resolvedPath, enabled: true, metadata };
+		});
+
+		return { extensions, skills: [], prompts: [], themes: [] };
+	}
+}
+
 /**
  * Resource-loader compatibility layer for legacy pi extensions.
  *

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -1,6 +1,6 @@
 /// <reference path="./legacy-pi-virtual-modules.d.ts" />
 import * as fs from "node:fs";
-import { isBuiltin } from "node:module";
+import { createRequire, isBuiltin } from "node:module";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isCompiledBinary, stripWindowsExtendedLengthPathPrefix } from "@oh-my-pi/pi-utils";
@@ -1111,6 +1111,74 @@ const EXTENSION_GRAPH_SPECIFIER_REGEX = /((?:from\s+|import\s+|import\s*\(\s*)["
 // reloads install supplemental hooks only for modules added to the graph since
 // the previous load.
 const extensionGraphHookModules = new Map<string, Set<string>>();
+const commonJsModuleSources = new Map<string, string>();
+const commonJsFallbackModulePaths = new Map<string, string>();
+const COMMONJS_REQUIRE_GLOBAL = "__ompLegacyPiRequireGraphModule";
+const commonJsModuleDefinitions = new Map<string, { source: string; filename: string; dirname: string }>();
+const commonJsModuleCache = new Map<
+	string,
+	{
+		exports: unknown;
+		filename: string;
+		id: string;
+		path: string;
+		require: NodeJS.Require;
+		loaded: boolean;
+	}
+>();
+const commonJsTypeScriptTranspiler = new Bun.Transpiler({ loader: "ts" });
+
+function evaluateGraphCommonJs(modulePath: string): unknown {
+	const cached = commonJsModuleCache.get(modulePath);
+	if (cached) {
+		return cached.exports;
+	}
+	const definition = commonJsModuleDefinitions.get(modulePath);
+	if (!definition) {
+		throw new Error(`Missing graph-owned CommonJS definition: ${modulePath}`);
+	}
+
+	const nativeRequire = createRequire(definition.filename);
+	const module = {
+		exports: {},
+		filename: definition.filename,
+		id: definition.filename,
+		path: definition.dirname,
+		require: nativeRequire,
+		loaded: false,
+	};
+	commonJsModuleCache.set(modulePath, module);
+	const graphRequire: NodeJS.Require = Object.assign(
+		(specifier: string) => {
+			const resolved = nativeRequire.resolve(specifier);
+			let graphPath = resolved;
+			try {
+				graphPath = fs.realpathSync(resolved);
+			} catch {
+				// Builtins and virtual modules have no filesystem realpath.
+			}
+			return commonJsModuleDefinitions.has(graphPath) ? evaluateGraphCommonJs(graphPath) : nativeRequire(specifier);
+		},
+		{
+			resolve: nativeRequire.resolve,
+			cache: nativeRequire.cache,
+			extensions: nativeRequire.extensions,
+			main: nativeRequire.main,
+		},
+	);
+	module.require = graphRequire;
+	const execute = new Function("exports", "require", "module", "__filename", "__dirname", definition.source);
+	try {
+		execute.call(module.exports, module.exports, graphRequire, module, definition.filename, definition.dirname);
+		module.loaded = true;
+		return module.exports;
+	} catch (error) {
+		commonJsModuleCache.delete(modulePath);
+		throw error;
+	}
+}
+
+Reflect.set(globalThis, COMMONJS_REQUIRE_GLOBAL, evaluateGraphCommonJs);
 
 let legacyPiLoadTag = 0;
 
@@ -1144,9 +1212,9 @@ async function realpathOrSelfUncached(p: string): Promise<string> {
  * Extension-local bare dependency entries are also included so their relative
  * children receive the reload mtime tag; bare imports inside those dependencies
  * remain native Bun resolutions to avoid taking over full third-party graphs.
- * CommonJS modules reached through `require()` stay on Bun's native loader.
- * The only exception is a module whose bare requires resolve to native addons:
- * those require a synchronous hook that pins the addon to an absolute path.
+ * CommonJS modules reached through `require()` stay on Bun's native loader
+ * unless they resolve native addons. CommonJS reached through ESM imports stays
+ * graph-owned so the load hook can expose its exports through an ESM default.
  */
 async function collectExtensionModules(entryRealPath: string): Promise<Map<string, string>> {
 	const modules = new Map<string, string>();
@@ -1253,21 +1321,106 @@ async function collectExtensionModules(entryRealPath: string): Promise<Map<strin
 	return modules;
 }
 
+/**
+ * Discovers CommonJS export names Bun normally exposes to ESM importers. The
+ * bridge must declare them statically because its default export is synthetic.
+ */
+function collectCommonJsNamedExports(source: string): string[] {
+	const names = new Set<string>();
+	const assignmentPattern = /(?:^|[;\n])\s*(?:exports|module\.exports)\.([A-Za-z_$][\w$]*)\s*=/gm;
+	for (const match of source.matchAll(assignmentPattern)) {
+		const name = match[1];
+		if (name && name !== "default") {
+			names.add(name);
+		}
+	}
+	const objectPattern = /module\.exports\s*=\s*\{([\s\S]*?)\}/g;
+	for (const objectMatch of source.matchAll(objectPattern)) {
+		const propertyPattern = /(?:^|,)\s*(?:([A-Za-z_$][\w$]*)\s*(?=[:,]|$)|["']([A-Za-z_$][\w$]*)["']\s*:)/g;
+		for (const propertyMatch of objectMatch[1]?.matchAll(propertyPattern) ?? []) {
+			const name = propertyMatch[1] ?? propertyMatch[2];
+			if (name && name !== "default") {
+				names.add(name);
+			}
+		}
+	}
+	return [...names];
+}
+
+/**
+ * The shared evaluator gives ESM imports and sibling `require()` calls the
+ * same `module.exports` value and cycle-aware cache.
+ */
+function synthesizeCommonJsDefaultModule(modulePath: string, source: string, targetPath = modulePath): string {
+	let commonJsSource = source;
+	if (commonJsSource.startsWith("#!")) {
+		const firstLineEnd = commonJsSource.indexOf("\n");
+		commonJsSource = firstLineEnd === -1 ? "" : commonJsSource.slice(firstLineEnd + 1);
+	}
+
+	const executableSource = targetPath.endsWith(".cts")
+		? commonJsTypeScriptTranspiler.transformSync(commonJsSource)
+		: commonJsSource;
+	commonJsModuleDefinitions.set(modulePath, {
+		source: executableSource,
+		filename: targetPath,
+		dirname: path.dirname(targetPath),
+	});
+	commonJsModuleCache.delete(modulePath);
+	const exportsBinding = "__ompLegacyPiCommonJsExports";
+	const namedExports = collectCommonJsNamedExports(executableSource)
+		.map(
+			(name, index) =>
+				`const __ompLegacyPiCommonJsExport${index} = ${exportsBinding}[${JSON.stringify(name)}]; export { __ompLegacyPiCommonJsExport${index} as ${name} };`,
+		)
+		.join("\n");
+	return `const ${exportsBinding} = globalThis[${JSON.stringify(COMMONJS_REQUIRE_GLOBAL)}](${JSON.stringify(modulePath)});\nexport default ${exportsBinding};\n${namedExports}\n`;
+}
+
+/**
+ * Linkedom's canvas bridge uses its bundled fallback because OMP does not ship
+ * native canvas.
+ */
+async function prepareCommonJsDefaultModule(modulePath: string, source: string): Promise<string> {
+	const packageRoot = await findPackageRoot(modulePath);
+	if (!packageRoot) {
+		return synthesizeCommonJsDefaultModule(modulePath, source);
+	}
+	const manifest = await readPackageManifest(packageRoot);
+	const packageRelativePath = path.relative(packageRoot, modulePath).split(path.sep).join("/");
+	if (manifest?.name !== "linkedom" || packageRelativePath !== "commonjs/canvas.cjs") {
+		return synthesizeCommonJsDefaultModule(modulePath, source);
+	}
+
+	const targetPath = path.join(packageRoot, "commonjs", "canvas-shim.cjs");
+	commonJsFallbackModulePaths.set(modulePath, targetPath);
+	return synthesizeCommonJsDefaultModule(modulePath, await Bun.file(targetPath).text(), targetPath);
+}
+
 /**
  * Install exact-path load hooks for the current extension graph. ESM/TS source
- * retains the async rewrite path. Native-addon CJS loaders use a synchronous
- * hook with source pre-rewritten during graph collection; Bun rejects a CJS
- * `require()` whose onLoad callback returns a promise.
+ * retains the async rewrite path. CommonJS wrappers and native-addon loaders
+ * stay synchronous because Bun rejects `require()` targets backed by async
+ * `onLoad` callbacks.
  */
-function installExtensionGraphHook(
+async function installExtensionGraphHook(
 	entryRealPath: string,
 	modules: Map<string, string>,
-): { asyncModules: Map<string, string>; syncCommonJsModules: Map<string, string> } {
+	commonJsPaths: Set<string>,
+): Promise<{ asyncModules: Map<string, string>; syncSourceModules: Map<string, string> }> {
 	const asyncModules = new Map<string, string>();
-	const syncCommonJsModules = new Map<string, string>();
+	const syncSourceModules = new Map<string, string>();
 	for (const [modulePath, source] of modules) {
-		const destination = nativeAddonLoaderModulePaths.has(modulePath) ? syncCommonJsModules : asyncModules;
-		destination.set(modulePath, source);
+		const extension = path.extname(modulePath);
+		if (extension === ".cjs" || extension === ".cts") {
+			if (!commonJsPaths.has(modulePath)) {
+				throw new Error(`Missing CommonJS compatibility source: ${modulePath}`);
+			}
+		} else if (nativeAddonLoaderModulePaths.has(modulePath)) {
+			syncSourceModules.set(modulePath, source);
+		} else {
+			asyncModules.set(modulePath, source);
+		}
 	}
 
 	if (asyncModules.size > 0) {
@@ -1299,17 +1452,42 @@ function installExtensionGraphHook(
 		});
 	}
 
-	if (syncCommonJsModules.size > 0) {
-		const alternation = [...syncCommonJsModules.keys()].map(escapeRegExp).join("|");
+	if (commonJsPaths.size > 0) {
+		const alternation = [...commonJsPaths].map(escapeRegExp).join("|");
+		const filter = new RegExp(`^(?:${alternation})(?:\\?mtime=\\d+)?$`);
+		const hookId = Bun.hash(`${entryRealPath}\0commonjs\0${[...commonJsPaths].join("\0")}`).toString(36);
+		Bun.plugin({
+			name: `omp:legacy-pi-ext:${hookId}`,
+			setup(build) {
+				build.onLoad({ filter, namespace: "file" }, args => {
+					const queryIndex = args.path.indexOf("?mtime=");
+					const sourcePath = queryIndex >= 0 ? args.path.slice(0, queryIndex) : args.path;
+					const source =
+						commonJsModuleSources.get(sourcePath) ??
+						synthesizeCommonJsDefaultModule(
+							sourcePath,
+							fs.readFileSync(commonJsFallbackModulePaths.get(sourcePath) ?? sourcePath, "utf8"),
+							commonJsFallbackModulePaths.get(sourcePath) ?? sourcePath,
+						);
+					return { contents: source, loader: getLoader(sourcePath) };
+				});
+			},
+		});
+	}
+
+	if (syncSourceModules.size > 0) {
+		const alternation = [...syncSourceModules.keys()].map(escapeRegExp).join("|");
 		const filter = new RegExp(`^(?:${alternation})(?:\\?mtime=\\d+)?$`);
-		const hookId = Bun.hash(`${entryRealPath}\0sync-cjs\0${[...syncCommonJsModules.keys()].join("\0")}`).toString(36);
+		const hookId = Bun.hash(`${entryRealPath}\0sync-source\0${[...syncSourceModules.keys()].join("\0")}`).toString(
+			36,
+		);
 		Bun.plugin({
 			name: `omp:legacy-pi-ext:${hookId}`,
 			setup(build) {
 				build.onLoad({ filter, namespace: "file" }, args => {
 					const queryIndex = args.path.indexOf("?mtime=");
 					const sourcePath = queryIndex >= 0 ? args.path.slice(0, queryIndex) : args.path;
-					const source = syncCommonJsModules.get(sourcePath);
+					const source = syncSourceModules.get(sourcePath);
 					if (source === undefined) {
 						throw new Error(`Missing pre-rewritten CommonJS extension source: ${sourcePath}`);
 					}
@@ -1318,7 +1496,7 @@ function installExtensionGraphHook(
 			},
 		});
 	}
-	return { asyncModules, syncCommonJsModules };
+	return { asyncModules, syncSourceModules };
 }
 
 /**
@@ -1331,6 +1509,14 @@ function installExtensionGraphHook(
  */
 async function ensureExtensionGraphHook(entryRealPath: string): Promise<{ clear(): void } | undefined> {
 	const currentModules = await collectExtensionModules(entryRealPath);
+	const commonJsPaths = new Set<string>();
+	for (const [modulePath, source] of currentModules) {
+		const extension = path.extname(modulePath);
+		if (extension === ".cjs" || extension === ".cts") {
+			commonJsModuleSources.set(modulePath, await prepareCommonJsDefaultModule(modulePath, source));
+			commonJsPaths.add(modulePath);
+		}
+	}
 	let hookedModules = extensionGraphHookModules.get(entryRealPath);
 	if (!hookedModules) {
 		hookedModules = new Set<string>();
@@ -1338,23 +1524,40 @@ async function ensureExtensionGraphHook(entryRealPath: string): Promise<{ clear(
 	}
 
 	const pendingModules = new Map<string, string>();
+	const pendingCommonJsPaths = new Set<string>();
 	for (const [modulePath, source] of currentModules) {
 		if (!hookedModules.has(modulePath)) {
 			pendingModules.set(modulePath, source);
+			if (commonJsPaths.has(modulePath)) {
+				pendingCommonJsPaths.add(modulePath);
+			}
 		}
 	}
-	if (pendingModules.size === 0) {
+	if (pendingModules.size === 0 && commonJsPaths.size === 0) {
 		return undefined;
 	}
 
-	const { asyncModules, syncCommonJsModules } = installExtensionGraphHook(entryRealPath, pendingModules);
-	for (const modulePath of pendingModules.keys()) {
-		hookedModules.add(modulePath);
+	let asyncModules = new Map<string, string>();
+	let syncSourceModules = new Map<string, string>();
+	if (pendingModules.size > 0) {
+		({ asyncModules, syncSourceModules } = await installExtensionGraphHook(
+			entryRealPath,
+			pendingModules,
+			pendingCommonJsPaths,
+		));
+		for (const modulePath of pendingModules.keys()) {
+			hookedModules.add(modulePath);
+		}
 	}
 	return {
 		clear() {
 			asyncModules.clear();
-			syncCommonJsModules.clear();
+			syncSourceModules.clear();
+			for (const modulePath of commonJsPaths) {
+				commonJsModuleSources.delete(modulePath);
+				commonJsModuleDefinitions.delete(modulePath);
+				commonJsModuleCache.delete(modulePath);
+			}
 		},
 	};
 }

package/src/extensibility/plugins/manager.ts

@@ -11,7 +11,7 @@ import {
 	isEnoent,
 	logger,
 } from "@oh-my-pi/pi-utils";
-import { withExitGuard } from "../utils";
+import { withHostGuard } from "../utils";
 import { refreshBunGitCache } from "./bun-git-cache";
 import { type GitSource, parseGitUrl } from "./git-url";
 import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "./legacy-pi-compat";
@@ -375,7 +375,7 @@ export class PluginManager {
 			installLegacyPiSpecifierShim();
 			for (const extensionPath of loadable) {
 				try {
-					const module = await withExitGuard(() => loadLegacyPiModule(extensionPath));
+					const module = await withHostGuard(() => loadLegacyPiModule(extensionPath));
 					if (!hasExtensionFactoryExport(module)) {
 						errors.push(`${extensionPath}: extension does not export a valid factory function`);
 					}

package/src/extensibility/shared-events.ts

@@ -191,6 +191,12 @@ export interface AgentStartEvent {
 export interface AgentEndEvent {
 	type: "agent_end";
 	messages: AgentMessage[];
+	/**
+	 * When true, the session has already scheduled an automatic continuation
+	 * (auto-retry, empty/unexpected-stop retry, etc.). Subscribers must not
+	 * treat this as a user-visible terminal settle.
+	 */
+	willContinue?: boolean;
 }
 
 /** Fired at the start of each turn */

package/src/extensibility/utils.ts

@@ -44,7 +44,7 @@ export function createNoOpUIContext(): HookUIContext {
 }
 
 /**
- * Raised by {@link withExitGuard} when a guarded callback synchronously
+ * Raised by {@link withHostGuard} when a guarded callback synchronously
  * attempts to terminate the host process. Callers catch this like any other
  * load-time failure so the extension/hook is skipped with a logged error
  * instead of taking the CLI down with it.
@@ -66,22 +66,46 @@ export class ExtensionExitError extends Error {
 
 type ExitAliasName = "process.exit" | "process.reallyExit";
 
-let exitGuardDepth = 0;
-let exitGuardOriginalProcessExit: typeof process.exit | null = null;
-let exitGuardOriginalReallyExit: typeof process.reallyExit | null = null;
+/**
+ * stdin events a loaded module must not be allowed to leave hijacked. A
+ * top-level `new StdioServerTransport()` (or a bare `process.stdin.resume()`)
+ * inside a `~/.claude/tools` MCP server attaches a `data` consumer and puts the
+ * shared stdin into flowing mode; Bun delivers one `data` event to that
+ * consumer and the TUI's own listener (attached later in `terminal.start()`)
+ * then never re-arms — every keypress after the first is swallowed (#5618).
+ */
+const HOST_GUARD_STDIN_EVENTS = ["data", "readable", "end", "close", "error"] as const;
+type StdinGuardEvent = (typeof HOST_GUARD_STDIN_EVENTS)[number];
+type StdinGuardListener = (...args: unknown[]) => void;
+
+let hostGuardDepth = 0;
+let hostGuardOriginalProcessExit: typeof process.exit | null = null;
+let hostGuardOriginalReallyExit: typeof process.reallyExit | null = null;
+let hostGuardStdinListeners: Record<StdinGuardEvent, StdinGuardListener[]> | null = null;
+let hostGuardStdinWasPaused = false;
+let hostGuardStdinWasRaw = false;
 
 /**
- * Run `fn` with hard-exit APIs patched so any synchronous attempt to terminate
- * the host raises {@link ExtensionExitError} instead. Restored in `finally`.
+ * Run `fn` with host-owned process state fenced off from third-party module
+ * evaluation, restored in `finally`. Guards the dynamic-import and
+ * factory-invocation sites that load extension / hook / tool / plugin modules
+ * from user directories (including Claude Code's `~/.claude/tools`, which OMP
+ * slurps wholesale). Two hazards are neutralized:
  *
- * Guards the dynamic-import and factory-invocation sites that load third-party
- * extension / hook modules — a `process.exit(0)` or `process.reallyExit(0)` in
- * a stranger's script (e.g. a Codex hook script that happens to live next to
- * OMP-shaped modules) would otherwise kill OMP during startup with no error
- * surface, since `try/catch` cannot intercept a synchronous exit.
+ * - **Hard exit.** `process.exit(0)` / `process.reallyExit(0)` in a stranger's
+ *   script (e.g. a CLI-shaped module with `main()` at the bottom) would kill
+ *   OMP during startup with no error surface, since `try/catch` cannot
+ *   intercept a synchronous exit. Both are patched to throw
+ *   {@link ExtensionExitError} instead.
+ * - **stdin hijack.** A module that attaches a stdin consumer at evaluation
+ *   time (an MCP `StdioServerTransport`, or a bare `resume()`) steals Bun's
+ *   single stdin reader, so the TUI goes permanently deaf after one keypress
+ *   (#5618). Any `data`/`readable`/`end`/`close`/`error` listener the module
+ *   adds is removed, and the stream's paused and raw-mode state is restored to
+ *   the pre-load snapshot.
  *
  * Nested and concurrent guard windows are safe: only the outermost guard
- * restores the real hard-exit APIs.
+ * snapshots and restores host state.
  */
 function guardedExit(alias: ExitAliasName): (code?: number | string) => never {
 	return (code?: number | string): never => {
@@ -89,29 +113,71 @@ function guardedExit(alias: ExitAliasName): (code?: number | string) => never {
 	};
 }
 
-export async function withExitGuard<T>(fn: () => Promise<T>): Promise<T> {
-	if (exitGuardDepth === 0) {
-		exitGuardOriginalProcessExit = process.exit;
+export async function withHostGuard<T>(fn: () => Promise<T>): Promise<T> {
+	if (hostGuardDepth === 0) {
+		hostGuardOriginalProcessExit = process.exit;
 		process.exit = guardedExit("process.exit") as typeof process.exit;
 
 		if (typeof process.reallyExit === "function") {
-			exitGuardOriginalReallyExit = process.reallyExit;
+			hostGuardOriginalReallyExit = process.reallyExit;
 			process.reallyExit = guardedExit("process.reallyExit") as typeof process.reallyExit;
 		}
+
+		const stdin = process.stdin;
+		hostGuardStdinWasPaused = stdin.isPaused();
+		hostGuardStdinWasRaw = stdin.isRaw ?? false;
+		const snapshot = {} as Record<StdinGuardEvent, StdinGuardListener[]>;
+		for (const event of HOST_GUARD_STDIN_EVENTS) {
+			snapshot[event] = stdin.rawListeners(event) as StdinGuardListener[];
+		}
+		hostGuardStdinListeners = snapshot;
 	}
-	exitGuardDepth++;
+	hostGuardDepth++;
 	try {
 		return await fn();
 	} finally {
-		exitGuardDepth--;
-		if (exitGuardDepth === 0) {
-			if (exitGuardOriginalProcessExit) {
-				process.exit = exitGuardOriginalProcessExit;
-				exitGuardOriginalProcessExit = null;
+		hostGuardDepth--;
+		if (hostGuardDepth === 0) {
+			if (hostGuardOriginalProcessExit) {
+				process.exit = hostGuardOriginalProcessExit;
+				hostGuardOriginalProcessExit = null;
+			}
+			if (hostGuardOriginalReallyExit) {
+				process.reallyExit = hostGuardOriginalReallyExit;
+				hostGuardOriginalReallyExit = null;
 			}
-			if (exitGuardOriginalReallyExit) {
-				process.reallyExit = exitGuardOriginalReallyExit;
-				exitGuardOriginalReallyExit = null;
+			if (hostGuardStdinListeners) {
+				const stdin = process.stdin;
+				for (const event of HOST_GUARD_STDIN_EVENTS) {
+					const before = hostGuardStdinListeners[event];
+					// Reconcile the stream back to the pre-load snapshot: drop any
+					// listener the module added, and reinstate any snapshot listener
+					// it removed (e.g. a factory calling `removeAllListeners("data")`
+					// would otherwise permanently strip ProcessTerminal's input
+					// handler, leaving the parent TUI deaf). removeAllListeners then
+					// re-adding in snapshot order restores both membership and order.
+					const current = stdin.rawListeners(event) as StdinGuardListener[];
+					const differs =
+						current.length !== before.length || current.some((listener, index) => listener !== before[index]);
+					if (!differs) continue;
+					stdin.removeAllListeners(event);
+					for (const listener of before) {
+						stdin.on(event, listener);
+					}
+				}
+				if (
+					stdin.isTTY &&
+					typeof stdin.setRawMode === "function" &&
+					(stdin.isRaw ?? false) !== hostGuardStdinWasRaw
+				) {
+					stdin.setRawMode(hostGuardStdinWasRaw);
+				}
+				if (hostGuardStdinWasPaused && !stdin.isPaused()) {
+					stdin.pause();
+				} else if (!hostGuardStdinWasPaused && stdin.isPaused()) {
+					stdin.resume();
+				}
+				hostGuardStdinListeners = null;
 			}
 		}
 	}