@oh-my-pi/pi-coding-agent 15.10.8 → 15.10.9

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [15.10.9] - 2026-06-09
+
+### Fixed
+
+- Fixed streaming thinking (and other styled assistant content) vanishing from native scrollback once it scrolled past the viewport top during a foreground turn. The transcript's append-only commit detector compared raw row bytes, so a styled paragraph wrapping onto a new row (the span-closing SGR and width padding move while the visible cells stay identical) or a streamed token pushing the last word down a line flagged the block as permanently volatile — the commit boundary froze and every later row that crossed the viewport top was committed nowhere. Rows are now compared by visible content, a wrap-shrink of the in-flight bottom line counts as append-only, and a genuine one-off interior rewrite only suspends commits until the block re-earns append-only (30 clean frames), after which the pinned emitter backfills the stalled gap contiguously. Periodically rewriting blocks (spinners, collapsing tool previews) never re-earn and stay deferred.
+
+- Fixed bracketed pastes containing multiple image file paths so each image is attached in order instead of treating the whole paste as one unreadable path.
+
+- Fixed MCP OAuth fallback prompts so the "Click here to authorize" label emits an auth-safe terminal hyperlink even when hyperlink auto-detection is unavailable, keeping non-browser MCP setup usable ([#2196](https://github.com/can1357/oh-my-pi/issues/2196)).
+- Fixed `task`-spawned subagents repeating filesystem scans the parent had already completed. `ExecutorOptions` and the `createAgentSession()` call inside `runSubprocess()` did not forward `rules`, the discovered extension paths, or the discovered `.omp/tools/` paths, so each subagent re-ran `loadCapability<Rule>()`, `discoverAndLoadExtensions()`, and the full `.omp/tools/` walk. The toolsession now caches `session.rules`, `session.extensionPaths`, and `session.customToolPaths`; `runSubprocess()` threads them through; and `createAgentSession()` accepts new `preloadedExtensionPaths` and `preloadedCustomToolPaths` options backed by new exported `discoverExtensionPaths()` and `discoverCustomToolPaths()` helpers. Crucially, only path lists are forwarded — never loaded instances. Each session rebuilds its own `Extension` and `LoadedCustomTool` objects so the per-session `ExtensionAPI`/`CustomToolAPI` (cwd, eventBus, runtime, exec, pushPendingAction, UI) targets the right session; forwarding loaded instances would have routed extension handlers and custom-tool execution back through the parent. The CLI's `preloadedExtensions` short-circuit is preserved for same-process reuse and now shallow-clones the caller's `extensions` array so inline-extension augmentation (autoresearch + custom-tools wrapper) cannot bleed back into it ([#2190](https://github.com/can1357/oh-my-pi/issues/2190)).
+- Fixed SSH tool cancellation hanging behind OpenSSH ControlMaster streams that stayed open after an Esc/user interrupt ([#2180](https://github.com/can1357/oh-my-pi/issues/2180)).
+- Fixed Windows stdio MCP servers launched through PATH shims such as `codegraph.cmd` so bare commands like `codegraph` resolve via `PATHEXT` before spawn ([#2174](https://github.com/can1357/oh-my-pi/issues/2174)).
+- Fixed compiled-binary extensions failing to load `@oh-my-pi/pi-*` packages when `bun --compile` quietly dropped one of the extra entrypoints (observed on macOS arm64 release builds): the legacy-pi compat shim's package-root override branch returned the bunfs path without checking the target was present, so the rewrite emitted a `file://` URL to a missing module and the #1216 fallback (scoped to the throwing `getResolvedSpecifier` path) never ran. Override targets are now validated against the on-disk filesystem at module init, missing entries are dropped, and resolution falls through to canonical lookup so Bun resolves the import from the extension's own `node_modules` ([#2168](https://github.com/can1357/oh-my-pi/issues/2168)).
+
 ## [15.10.8] - 2026-06-09
 
 ### Added
@@ -9796,4 +9810,4 @@ Initial public release.
 - Git branch display in footer
 - Message queueing during streaming responses
 - OAuth integration for Gmail and Google Calendar access
-- HTML export with syntax highlighting and collapsible sections
+- HTML export with syntax highlighting and collapsible sections

package/dist/types/extensibility/custom-tools/loader.d.ts

@@ -1,8 +1,10 @@
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import type { HookUIContext } from "../../extensibility/hooks/types";
 import type { LoadedCustomTool, ToolLoadError } from "./types";
-/** Tool path with optional source metadata */
-interface ToolPathWithSource {
+/** Tool path with optional source metadata, suitable for forwarding from a
+ * parent session to a subagent so the subagent can re-bind tools to its own
+ * `CustomToolAPI` without redoing the filesystem scan. */
+export interface ToolPathWithSource {
     path: string;
     source?: {
         provider: string;
@@ -46,12 +48,30 @@ export declare function loadCustomTools(pathsWithSources: ToolPathWithSource[],
     errors: ToolLoadError[];
     setUIContext: (uiContext: HookUIContext, hasUI: boolean) => void;
 }>;
+/**
+ * Collect the absolute tool-source paths to load, without importing or
+ * binding factories. Hot path on session startup — the scan walks
+ * `.omp/tools/`, `.claude/tools/`, the plugin tree, and any configured paths.
+ *
+ * Subagents reuse the parent's collected paths via the SDK's
+ * `preloadedCustomToolPaths` option, then call `loadCustomTools` themselves
+ * so each session re-binds factories with its own session-scoped
+ * `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
+ *
+ * @param configuredPaths - Explicit paths from settings.json and CLI --tool flags
+ * @param cwd - Current working directory
+ */
+export declare function discoverCustomToolPaths(configuredPaths: string[], cwd: string): Promise<ToolPathWithSource[]>;
 /**
  * Discover and load tools from standard locations via capability system:
  * 1. User and project tools discovered by capability providers
  * 2. Installed plugins (~/.omp/plugins/node_modules/*)
  * 3. Explicitly configured paths from settings or CLI
  *
+ * Composed of {@link discoverCustomToolPaths} (FS scan) + {@link loadCustomTools}
+ * (per-session binding). Subagents skip the first step and just call
+ * `loadCustomTools` against the parent's collected paths.
+ *
  * @param configuredPaths - Explicit paths from settings.json and CLI --tool flags
  * @param cwd - Current working directory
  * @param builtInToolNames - Names of built-in tools to check for conflicts
@@ -66,4 +86,3 @@ export declare function discoverAndLoadCustomTools(configuredPaths: string[], cw
     errors: ToolLoadError[];
     setUIContext: (uiContext: HookUIContext, hasUI: boolean) => void;
 }>;
-export {};

package/dist/types/extensibility/extensions/index.d.ts

@@ -2,7 +2,7 @@
  * Extension system for lifecycle events and custom tools.
  */
 export type { SlashCommandInfo, SlashCommandLocation, SlashCommandSource } from "../slash-commands";
-export { discoverAndLoadExtensions, ExtensionRuntimeNotInitializedError, loadExtensionFromFactory, loadExtensions, } from "./loader";
+export { discoverAndLoadExtensions, discoverExtensionPaths, ExtensionRuntimeNotInitializedError, loadExtensionFromFactory, loadExtensions, } from "./loader";
 export * from "./runner";
 export * from "./types";
 export * from "./wrapper";

package/dist/types/extensibility/extensions/loader.d.ts

@@ -38,6 +38,22 @@ export declare function loadExtensionFromFactory(factory: ExtensionFactory, cwd:
  */
 export declare function loadExtensions(paths: string[], cwd: string, eventBus?: EventBus): Promise<LoadExtensionsResult>;
 /**
- * Discover and load extensions from standard locations.
+ * Discover absolute paths of extensions to load, without importing or
+ * binding factories. Hot path on session startup — the scan walks native
+ * `.omp`/`.pi` extension capabilities, the installed-plugin tree, and any
+ * configured paths.
+ *
+ * Subagents reuse the parent's collected paths via the SDK's
+ * `preloadedExtensionPaths` option, then call {@link loadExtensions} themselves
+ * so each session rebuilds Extension instances bound to its OWN
+ * `ExtensionAPI` (cwd, eventBus, runtime). Forwarding the parent's
+ * `LoadExtensionsResult` directly would reuse handlers/tools/commands that
+ * closed over the parent's `cwd` and event bus.
+ */
+export declare function discoverExtensionPaths(configuredPaths: string[], cwd: string, disabledExtensionIds?: string[]): Promise<string[]>;
+/**
+ * Discover and load extensions from standard locations. Composed of
+ * {@link discoverExtensionPaths} (FS scan) + {@link loadExtensions}
+ * (per-session binding).
  */
 export declare function discoverAndLoadExtensions(configuredPaths: string[], cwd: string, eventBus?: EventBus, disabledExtensionIds?: string[]): Promise<LoadExtensionsResult>;

package/dist/types/extensibility/plugins/legacy-pi-compat.d.ts

@@ -13,6 +13,14 @@ import * as path from "node:path";
  * Exported for tests; production callers use `BUNFS_PACKAGE_ROOT` below.
  */
 export declare function __computeBunfsPackageRoot(metaDir: string, pathImpl?: typeof path): string;
+/**
+ * Drop overrides whose targets are missing on disk so they can fall through to
+ * the canonical-resolution path. Exported for the test seam in #2168.
+ *
+ * `pathExistsSync` defaults to `fs.existsSync`; the tests inject a stub to
+ * simulate the missing-entrypoint failure mode without touching the real FS.
+ */
+export declare function __validateLegacyPiPackageRootOverrides(candidates: Record<string, string>, pathExistsSync?: (p: string) => boolean): Record<string, string>;
 /**
  * Load a legacy Pi extension module from its real on-disk location.
  *

package/dist/types/mcp/transports/stdio.d.ts

@@ -5,6 +5,18 @@
  * Messages are newline-delimited JSON.
  */
 import type { MCPRequestOptions, MCPStdioServerConfig, MCPTransport } from "../../mcp/types";
+/** Subprocess argv for launching an MCP stdio server. */
+export interface StdioSpawnCommand {
+    cmd: string[];
+}
+/** Inputs used to resolve platform-specific stdio spawn behavior. */
+export interface ResolveStdioSpawnOptions {
+    cwd: string;
+    env: Record<string, string | undefined>;
+    platform?: NodeJS.Platform;
+}
+/** Resolve the subprocess argv used to launch an MCP stdio server. */
+export declare function resolveStdioSpawnCommand(config: MCPStdioServerConfig, options: ResolveStdioSpawnOptions): Promise<StdioSpawnCommand>;
 /** Minimal write surface of `Subprocess.stdin` we need for framed sends. */
 interface FrameSink {
     write(chunk: string): unknown;

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,6 +1,7 @@
 import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
+export declare function extractBracketedImagePastePaths(data: string): string[] | undefined;
 export declare function extractBracketedImagePastePath(data: string): string | undefined;
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
@@ -33,8 +34,8 @@ export declare class CustomEditor extends Editor {
     onCopyPrompt?: () => void;
     /** Called when the configured image-paste shortcut is pressed. */
     onPasteImage?: () => Promise<boolean>;
-    /** Called when a bracketed paste contains exactly one image-file path. */
-    onPasteImagePath?: (path: string) => void;
+    /** Called when a bracketed paste contains one or more image-file paths. */
+    onPasteImagePath?: (path: string) => void | Promise<void>;
     /** Called when the configured raw text-paste shortcut is pressed. */
     onPasteTextRaw?: () => void;
     /** Called when the configured dequeue shortcut is pressed. */

package/dist/types/sdk.d.ts

@@ -6,6 +6,7 @@ import { type PromptTemplate } from "./config/prompt-templates";
 import { Settings, type SkillsSettings } from "./config/settings";
 import "./discovery";
 import { type CustomCommandsLoadResult } from "./extensibility/custom-commands";
+import { type ToolPathWithSource } from "./extensibility/custom-tools";
 import type { CustomTool } from "./extensibility/custom-tools/types";
 import { type ExtensionFactory, type ExtensionUIContext, type LoadExtensionsResult, type ToolDefinition } from "./extensibility/extensions";
 import { type Skill, type SkillWarning } from "./extensibility/skills";
@@ -62,10 +63,41 @@ export interface CreateAgentSessionOptions {
     /** Disable extension discovery (explicit paths still load). */
     disableExtensionDiscovery?: boolean;
     /**
-     * Pre-loaded extensions (skips file discovery).
-     * @internal Used by CLI when extensions are loaded early to parse custom flags.
+     * Pre-loaded extensions (skips file discovery and the per-session factory
+     * call). Used by the CLI when extensions are loaded early to parse custom
+     * flags — the same process owns the returned instances, so reusing them is
+     * safe.
+     *
+     * NEVER pass this across session boundaries (e.g. parent → subagent).
+     * `Extension` instances close over a parent-bound `ExtensionAPI` (cwd,
+     * eventBus, runtime), and reusing them would route tools/handlers/commands
+     * back through the parent. For subagents, forward
+     * {@link preloadedExtensionPaths} instead.
+     *
+     * @internal
      */
     preloadedExtensions?: LoadExtensionsResult;
+    /**
+     * Pre-discovered extension source paths. When provided, the filesystem-scan
+     * inside `discoverExtensionPaths()` is skipped — the session still calls
+     * `loadExtensions()` itself so each `Extension` is bound to THIS session's
+     * `ExtensionAPI` (cwd, eventBus, runtime).
+     *
+     * This is the safe pass-through for parent → subagent forwarding.
+     */
+    preloadedExtensionPaths?: string[];
+    /**
+     * Pre-discovered custom-tool source paths from `.omp/tools/`, `.claude/tools/`,
+     * plugins, etc. When provided, the filesystem-scan inside
+     * `discoverCustomToolPaths()` is skipped — subagents inherit the parent's
+     * scan result and call `loadCustomTools()` themselves so each session binds
+     * tools to its OWN `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
+     *
+     * Forwarding the loaded `LoadedCustomTool[]` instances directly would reuse
+     * the parent's session-bound API and route tool execution back through the
+     * parent — wrong for isolated tasks and for pending-action routing.
+     */
+    preloadedCustomToolPaths?: ToolPathWithSource[];
     /** Shared event bus for tool/extension communication. Default: creates new bus. */
     eventBus?: EventBus;
     /** Skills. Default: discovered from multiple locations */
@@ -178,6 +210,14 @@ export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStor
  * Discover extensions from cwd.
  */
 export declare function discoverExtensions(cwd?: string): Promise<LoadExtensionsResult>;
+/**
+ * Path-only counterpart of {@link loadSessionExtensions}: the FS-heavy scan
+ * without the per-session module load. Subagents reuse the parent's path list
+ * (cached on {@link ToolSession.extensionPaths}) and rebuild Extension
+ * instances themselves so each session's `ExtensionAPI` (cwd, eventBus,
+ * runtime) is its own.
+ */
+export declare function discoverSessionExtensionPaths(options: Pick<CreateAgentSessionOptions, "disableExtensionDiscovery" | "additionalExtensionPaths">, cwd: string, settings: Settings): Promise<string[]>;
 /**
  * Load the discovered/configured extensions for a session — everything {@link
  * createAgentSession} would load except the inline factory extensions it appends

package/dist/types/task/executor.d.ts

@@ -4,10 +4,12 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import type { AgentTelemetryConfig, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Rule } from "../capability/rule";
 import { ModelRegistry } from "../config/model-registry";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
 import { type SettingPath } from "../config/settings-schema";
+import type { ToolPathWithSource } from "../extensibility/custom-tools";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import { type Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
@@ -70,6 +72,20 @@ export interface ExecutorOptions {
     skills?: Skill[];
     promptTemplates?: PromptTemplate[];
     workspaceTree?: WorkspaceTree;
+    /** Parent-discovered rules, forwarded to skip rule discovery in the subagent. */
+    rules?: Rule[];
+    /**
+     * Parent's discovered extension source paths. Forwarded to skip the
+     * extension FS scan in the subagent; the subagent then re-binds each
+     * extension against its own `ExtensionAPI` (cwd, eventBus, runtime).
+     */
+    preloadedExtensionPaths?: string[];
+    /**
+     * Parent's discovered custom-tool source paths. Forwarded to skip the
+     * `.omp/tools/` FS scan in the subagent; the subagent then re-binds each
+     * tool against its own `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
+     */
+    preloadedCustomToolPaths?: ToolPathWithSource[];
     mcpManager?: MCPManager;
     authStorage?: AuthStorage;
     modelRegistry?: ModelRegistry;

package/dist/types/tools/index.d.ts

@@ -2,8 +2,10 @@ import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { FetchImpl, ToolChoice } from "@oh-my-pi/pi-ai";
 import type { AsyncJobManager } from "../async/job-manager";
+import type { Rule } from "../capability/rule";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
+import type { ToolPathWithSource } from "../extensibility/custom-tools";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
 import type { HindsightSessionState } from "../hindsight/state";
@@ -107,6 +109,21 @@ export interface ToolSession {
     skills?: Skill[];
     /** Pre-loaded prompt templates */
     promptTemplates?: PromptTemplate[];
+    /** Pre-loaded rules (forwarded to subagents to skip re-discovery). */
+    rules?: Rule[];
+    /**
+     * Pre-discovered extension source paths. Forwarded to subagents so they
+     * skip the FS scan but still re-bind extensions to their own session-scoped
+     * `ExtensionAPI` (cwd, eventBus, runtime). Inline extension factories
+     * (`<inline-N>`) are NOT included — those are session-local.
+     */
+    extensionPaths?: string[];
+    /**
+     * Pre-discovered custom-tool source paths from `.omp/tools/`, `.claude/tools/`,
+     * plugins, etc. Forwarded to subagents so they skip the FS scan but still
+     * re-bind tools to their own session-scoped `CustomToolAPI`.
+     */
+    customToolPaths?: ToolPathWithSource[];
     /** Whether LSP integrations are enabled */
     enableLsp?: boolean;
     /** Whether an edit-capable tool is available in this session (controls hashline output) */

package/dist/types/tui/hyperlink.d.ts

@@ -19,6 +19,14 @@ export declare function uriHyperlink(uri: string, displayText: string): string;
  * `www.example.com` inputs are linked as `https://www.example.com`.
  */
 export declare function urlHyperlink(url: string, displayText: string): string;
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at an HTTP(S) URL,
+ * bypassing terminal capability auto-detection. Used for auth prompts where
+ * an inert "click" label blocks login on terminals whose capabilities are
+ * not advertised. Still returns plain text when the user has explicitly
+ * opted out via `tui.hyperlinks=off`.
+ */
+export declare function urlHyperlinkAlways(url: string, displayText: string): string;
 /**
  * Wrap `displayText` in an OSC 8 hyperlink pointing at a filesystem path.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.10.8",
+	"version": "15.10.9",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,14 +47,14 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.10.8",
-		"@oh-my-pi/omp-stats": "15.10.8",
-		"@oh-my-pi/pi-agent-core": "15.10.8",
-		"@oh-my-pi/pi-ai": "15.10.8",
-		"@oh-my-pi/pi-mnemopi": "15.10.8",
-		"@oh-my-pi/pi-natives": "15.10.8",
-		"@oh-my-pi/pi-tui": "15.10.8",
-		"@oh-my-pi/pi-utils": "15.10.8",
+		"@oh-my-pi/hashline": "15.10.9",
+		"@oh-my-pi/omp-stats": "15.10.9",
+		"@oh-my-pi/pi-agent-core": "15.10.9",
+		"@oh-my-pi/pi-ai": "15.10.9",
+		"@oh-my-pi/pi-mnemopi": "15.10.9",
+		"@oh-my-pi/pi-natives": "15.10.9",
+		"@oh-my-pi/pi-tui": "15.10.9",
+		"@oh-my-pi/pi-utils": "15.10.9",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/extensibility/custom-tools/loader.ts

@@ -66,8 +66,10 @@ async function loadTool(
 	}
 }
 
-/** Tool path with optional source metadata */
-interface ToolPathWithSource {
+/** Tool path with optional source metadata, suitable for forwarding from a
+ * parent session to a subagent so the subagent can re-bind tools to its own
+ * `CustomToolAPI` without redoing the filesystem scan. */
+export interface ToolPathWithSource {
 	path: string;
 	source?: { provider: string; providerName: string; level: "user" | "project" };
 }
@@ -189,26 +191,19 @@ export async function loadCustomTools(
 }
 
 /**
- * Discover and load tools from standard locations via capability system:
- * 1. User and project tools discovered by capability providers
- * 2. Installed plugins (~/.omp/plugins/node_modules/*)
- * 3. Explicitly configured paths from settings or CLI
+ * Collect the absolute tool-source paths to load, without importing or
+ * binding factories. Hot path on session startup — the scan walks
+ * `.omp/tools/`, `.claude/tools/`, the plugin tree, and any configured paths.
+ *
+ * Subagents reuse the parent's collected paths via the SDK's
+ * `preloadedCustomToolPaths` option, then call `loadCustomTools` themselves
+ * so each session re-binds factories with its own session-scoped
+ * `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
  *
  * @param configuredPaths - Explicit paths from settings.json and CLI --tool flags
  * @param cwd - Current working directory
- * @param builtInToolNames - Names of built-in tools to check for conflicts
  */
-export async function discoverAndLoadCustomTools(
-	configuredPaths: string[],
-	cwd: string,
-	builtInToolNames: string[],
-	pushPendingAction?: (action: {
-		label: string;
-		sourceToolName: string;
-		apply(reason: string): Promise<AgentToolResult<unknown>>;
-		reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
-	}) => void,
-) {
+export async function discoverCustomToolPaths(configuredPaths: string[], cwd: string): Promise<ToolPathWithSource[]> {
 	const allPathsWithSources: ToolPathWithSource[] = [];
 	const seen = new Set<string>();
 
@@ -241,5 +236,34 @@ export async function discoverAndLoadCustomTools(
 		addPath(resolvePath(configPath, cwd), { provider: "config", providerName: "Config", level: "project" });
 	}
 
-	return loadCustomTools(allPathsWithSources, cwd, builtInToolNames, pushPendingAction);
+	return allPathsWithSources;
+}
+
+/**
+ * Discover and load tools from standard locations via capability system:
+ * 1. User and project tools discovered by capability providers
+ * 2. Installed plugins (~/.omp/plugins/node_modules/*)
+ * 3. Explicitly configured paths from settings or CLI
+ *
+ * Composed of {@link discoverCustomToolPaths} (FS scan) + {@link loadCustomTools}
+ * (per-session binding). Subagents skip the first step and just call
+ * `loadCustomTools` against the parent's collected paths.
+ *
+ * @param configuredPaths - Explicit paths from settings.json and CLI --tool flags
+ * @param cwd - Current working directory
+ * @param builtInToolNames - Names of built-in tools to check for conflicts
+ */
+export async function discoverAndLoadCustomTools(
+	configuredPaths: string[],
+	cwd: string,
+	builtInToolNames: string[],
+	pushPendingAction?: (action: {
+		label: string;
+		sourceToolName: string;
+		apply(reason: string): Promise<AgentToolResult<unknown>>;
+		reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+	}) => void,
+) {
+	const pathsWithSources = await discoverCustomToolPaths(configuredPaths, cwd);
+	return loadCustomTools(pathsWithSources, cwd, builtInToolNames, pushPendingAction);
 }

package/src/extensibility/extensions/index.ts

@@ -5,6 +5,7 @@
 export type { SlashCommandInfo, SlashCommandLocation, SlashCommandSource } from "../slash-commands";
 export {
 	discoverAndLoadExtensions,
+	discoverExtensionPaths,
 	ExtensionRuntimeNotInitializedError,
 	loadExtensionFromFactory,
 	loadExtensions,

package/src/extensibility/extensions/loader.ts

@@ -475,16 +475,24 @@ async function discoverExtensionsInDir(dir: string): Promise<string[]> {
 
 	return discovered;
 }
-
 /**
- * Discover and load extensions from standard locations.
+ * Discover absolute paths of extensions to load, without importing or
+ * binding factories. Hot path on session startup — the scan walks native
+ * `.omp`/`.pi` extension capabilities, the installed-plugin tree, and any
+ * configured paths.
+ *
+ * Subagents reuse the parent's collected paths via the SDK's
+ * `preloadedExtensionPaths` option, then call {@link loadExtensions} themselves
+ * so each session rebuilds Extension instances bound to its OWN
+ * `ExtensionAPI` (cwd, eventBus, runtime). Forwarding the parent's
+ * `LoadExtensionsResult` directly would reuse handlers/tools/commands that
+ * closed over the parent's `cwd` and event bus.
  */
-export async function discoverAndLoadExtensions(
+export async function discoverExtensionPaths(
 	configuredPaths: string[],
 	cwd: string,
-	eventBus?: EventBus,
 	disabledExtensionIds: string[] = [],
-): Promise<LoadExtensionsResult> {
+): Promise<string[]> {
 	const allPaths: string[] = [];
 	const seen = new Set<string>();
 	const disabled = new Set(disabledExtensionIds);
@@ -545,5 +553,20 @@ export async function discoverAndLoadExtensions(
 		addPath(resolved);
 	}
 
-	return loadExtensions(allPaths, cwd, eventBus);
+	return allPaths;
+}
+
+/**
+ * Discover and load extensions from standard locations. Composed of
+ * {@link discoverExtensionPaths} (FS scan) + {@link loadExtensions}
+ * (per-session binding).
+ */
+export async function discoverAndLoadExtensions(
+	configuredPaths: string[],
+	cwd: string,
+	eventBus?: EventBus,
+	disabledExtensionIds: string[] = [],
+): Promise<LoadExtensionsResult> {
+	const paths = await discoverExtensionPaths(configuredPaths, cwd, disabledExtensionIds);
+	return loadExtensions(paths, cwd, eventBus);
 }

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

@@ -1,4 +1,4 @@
-import * as fs from "node:fs/promises";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isCompiledBinary } from "@oh-my-pi/pi-utils";
@@ -142,7 +142,31 @@ const LEGACY_PI_CODING_AGENT_SHIM_PATH = BUNFS_PACKAGE_ROOT
 // `Bun.resolveSync`, and hardcoding a relative source-tree path would break
 // installs where the bundled packages live at `node_modules/@oh-my-pi/pi-*`
 // rather than `packages/*`.
-const LEGACY_PI_PACKAGE_ROOT_OVERRIDES: Record<string, string> = {
+//
+// Every override target is validated against the on-disk filesystem at module
+// init: any entry whose file is missing (e.g. a compiled binary where Bun's
+// `--compile` quietly dropped an additional entrypoint — issue #2168) is left
+// out so `resolveCanonicalPiSpecifier` falls through to `getResolvedSpecifier`,
+// which throws under bunfs and triggers the catch in `rewriteLegacyPiImports`.
+// That catch leaves the specifier untouched so Bun resolves the canonical
+// `@oh-my-pi/pi-*` import from the extension's own `node_modules` instead of
+// emitting a bunfs `file://` URL to a module that isn't actually present.
+
+/**
+ * Drop overrides whose targets are missing on disk so they can fall through to
+ * the canonical-resolution path. Exported for the test seam in #2168.
+ *
+ * `pathExistsSync` defaults to `fs.existsSync`; the tests inject a stub to
+ * simulate the missing-entrypoint failure mode without touching the real FS.
+ */
+export function __validateLegacyPiPackageRootOverrides(
+	candidates: Record<string, string>,
+	pathExistsSync: (p: string) => boolean = fs.existsSync,
+): Record<string, string> {
+	return Object.fromEntries(Object.entries(candidates).filter(([, candidate]) => pathExistsSync(candidate)));
+}
+
+const LEGACY_PI_PACKAGE_ROOT_OVERRIDES = __validateLegacyPiPackageRootOverrides({
 	[`${CANONICAL_PI_SCOPE}/pi-ai`]: LEGACY_PI_AI_SHIM_PATH,
 	[`${CANONICAL_PI_SCOPE}/pi-coding-agent`]: LEGACY_PI_CODING_AGENT_SHIM_PATH,
 	...(BUNFS_PACKAGE_ROOT
@@ -153,7 +177,7 @@ const LEGACY_PI_PACKAGE_ROOT_OVERRIDES: Record<string, string> = {
 				[`${CANONICAL_PI_SCOPE}/pi-utils`]: bunfsPath("utils", "src", "index.js"),
 			}
 		: {}),
-};
+});
 
 let isLegacyPiSpecifierShimInstalled = false;
 
@@ -253,7 +277,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 async function pathExists(p: string): Promise<boolean> {
 	try {
-		await fs.stat(p);
+		await fs.promises.stat(p);
 		return true;
 	} catch {
 		return false;
@@ -267,7 +291,7 @@ function hasSourceModuleExtension(p: string): boolean {
 
 async function resolveSourceModuleFile(basePath: string): Promise<string | null> {
 	try {
-		const stats = await fs.stat(basePath);
+		const stats = await fs.promises.stat(basePath);
 		if (stats.isFile()) {
 			// Non-source files (JSON, WASM, text assets, etc.) bypass the on-load
 			// rewrite hook so Bun's native loaders handle them; our hook would
@@ -475,7 +499,7 @@ const hookedExtensionEntries = new Set<string>();
 /** Resolve symlinks in a path, falling back to the input if realpath fails. */
 async function realpathOrSelf(p: string): Promise<string> {
 	try {
-		return await fs.realpath(p);
+		return await fs.promises.realpath(p);
 	} catch {
 		return p;
 	}