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

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 ## [Unreleased]
 
+## [15.10.10] - 2026-06-09
+
+### Added
+
+- Added a read-only `view` op to the `todo` tool that echoes the current list without mutating state, so the agent can recover exact task text instead of guessing it from memory.
+
+### Changed
+
+- Rewrote the bash tool's coreutils guidance (tool prompt and system prompt) around an explicit litmus: pipelines that compute a new fact (`wc -l`, `sort | uniq -c`, `comm`, `diff`) are legitimate bash, while commands that merely move, page, or trim bytes a dedicated tool can fetch remain banned — output trimming destroys data the `artifact://` capture would have saved.
+
+### Fixed
+
+- Fixed the model selector dropping an immediate Enter when cached models were available but the selector's offline refresh was still pending.
+- Fixed dynamic `import(...)` inside functions passed to the browser tool's `tab.evaluate`/`page.evaluate` failing with `__omp_import__ is not defined`. The eval/browser JS runtime rewrites dynamic-import callees to the worker-injected `__omp_import__` helper, but puppeteer serializes evaluate callbacks with `Function.prototype.toString()` and re-runs them inside the page, where the helper does not exist. The rewriter now substitutes a guarded shim that falls back to native dynamic import when the helper is absent, so serialized code works in the page realm while in-worker imports keep resolving against the session cwd.
+- Transcript block freezing is now unconditional instead of gated on ED3-risk terminal detection: every finalized block replays its frozen snapshot once it crosses out of the live region, on all terminals including Windows, because the rewritten renderer's committed scrollback is immutable everywhere. Still-mutating blocks (pending tools, streaming messages, async thinking renderers) anchor the live region and keep repainting until they finalize, which structurally fixes stale/duplicated output from late async expansions ([#1823](https://github.com/can1357/oh-my-pi/issues/1823)).
+- Fixed the edit tool's post-edit diff preview occasionally echoing a context line twice with out-of-order numbering. Block-boundary context injection classified space-prefixed diff rows as old-file-only, so an unchanged line sitting in a net-offset region (old N / new N+k) was missing from the new file's visibility window; `findBlockContextLines` then re-surfaced it under its post-edit number and the row was spliced in after the adjacent change run. New-file boundary lines are now translated back to pre-edit numbers (the compact-preview renumbering contract) and merged into a single old-numbered insertion pass — also fixing closers below a net-offset edit being dropped or renumbered incorrectly.
+- Fixed the Anthropic web-search provider claiming the Claude Code identity on API-key requests: the CC billing header + system instruction were injected whenever the model wasn't Haiku 3.5, regardless of auth mode. Injection is now OAuth-gated like the streaming path, and OAuth search requests patch the billing header's `cch` attestation (via `wrapFetchForCch`) instead of shipping the `cch=00000` placeholder.
+- Fixed long streamed content appearing cut off mid-run: scrolled-off rows were erased from the viewport without ever being appended to terminal history. The transcript's commit boundary (`deriveLiveCommitState`) was all-or-nothing per block — one perpetually rewriting row (a task tool's ticking progress tree, per-agent cost/tool counters, spinner stats) suspended scrollback commits for the entire block, so once the block outgrew the viewport its static head (e.g. a task's prompt/context markdown) was neither committed nor on screen until the tool sealed, and was lost outright if the session ended mid-run. A stable-prefix ratchet now promotes leading rows that stayed visibly identical for a full 30-frame window as commit-safe, so the settled head reaches native scrollback while only the genuinely volatile tail stays deferred; a rewrite above the promoted run retreats the boundary and the engine audit recommits (duplication, never loss).
+- Fixed local tiny-title worker stdout/stderr leaking raw native model output such as `</title>` and cache/status lines into the interactive TUI scrollback ([#2206](https://github.com/can1357/oh-my-pi/issues/2206)).
+- Fixed task-agent discovery advertising Claude Code custom agents from `.claude/agents/*.md` as OMP subagents; direct task-agent discovery now only loads OMP-native `.omp` agent roots, while Claude marketplace plugin agents keep their existing provider path ([#2209](https://github.com/can1357/oh-my-pi/issues/2209)).
+
+### Removed
+
+- Removed the `clearOnShrink` setting and its `PI_CLEAR_ON_SHRINK` environment variable: the rewritten renderer always clears shrunken rows exactly, so the flicker/perf tradeoff the setting controlled no longer exists. Existing config entries are ignored.
+- Removed the prompt-submit native-scrollback reconciliation checkpoint and the eager streaming render mode from the interactive controllers — the renderer's append-only contract made both obsolete.
+
+## [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 +9836,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/config/model-registry.d.ts

@@ -262,6 +262,11 @@ export interface CanonicalModelQueryOptions {
     availableOnly?: boolean;
     candidates?: readonly Model<Api>[];
 }
+/** A canonical record (with query-filtered variants) plus the variant model selected for it. */
+export interface CanonicalModelSelection {
+    record: CanonicalModelRecord;
+    model: Model<Api>;
+}
 /**
  * Model registry - loads and manages models, resolves API keys via AuthStorage.
  */
@@ -306,6 +311,14 @@ export declare class ModelRegistry {
      */
     getAll(): Model<Api>[];
     getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[];
+    /**
+     * One-pass equivalent of `getCanonicalModels` + `resolveCanonicalModel` per
+     * record. The per-query state (candidate-selector set, availability memo,
+     * provider rank, candidate order) is built once, so the whole catalog
+     * resolves in O(records + candidates) instead of O(records × candidates).
+     * This is the path the model selector hydrates from synchronously on open.
+     */
+    getCanonicalModelSelections(options?: CanonicalModelQueryOptions): CanonicalModelSelection[];
     getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
     resolveCanonicalModel(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
     getCanonicalId(model: Model<Api>): string | undefined;

package/dist/types/config/settings-schema.d.ts

@@ -716,15 +716,6 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Show terminal cursor for IME support";
         };
     };
-    readonly clearOnShrink: {
-        readonly type: "boolean";
-        readonly default: false;
-        readonly ui: {
-            readonly tab: "appearance";
-            readonly label: "Clear on Shrink";
-            readonly description: "Clear empty rows when content shrinks (may cause flicker)";
-        };
-    };
     readonly defaultThinkingLevel: {
         readonly type: "enum";
         readonly values: readonly [...import("@oh-my-pi/pi-ai").Effort[], "auto"];

package/dist/types/debug/terminal-info.d.ts

@@ -18,7 +18,6 @@ export interface TerminalStateInfo {
     hyperlinks: boolean;
     deccara: boolean;
     screenToScrollback: boolean;
-    eagerEraseScrollbackRisk: boolean;
     synchronizedOutput: boolean;
     multiplexer: string | null;
     env: {

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/modes/components/transcript-container.d.ts

@@ -1,25 +1,18 @@
 import { Container, type NativeScrollbackLiveRegion } from "@oh-my-pi/pi-tui";
 /**
- * Transcript container that freezes the rendered output of every block except
- * the bottom-most (live) one on terminals where committed native scrollback is
- * immutable.
+ * Transcript container that always renders every block's current content and
+ * reports the live-region seam (`NativeScrollbackLiveRegion`) that gates the
+ * engine's append-only scrollback commits.
  *
- * On ED3-risk terminals with an unobservable viewport (ghostty/kitty/iTerm2/…)
- * the renderer cannot clear saved lines (`\x1b[3J` may yank a reader) or query
- * whether the user has scrolled, so any block that re-lays-out *after* it has
- * scrolled past the viewport leaves a stale duplicate above the live region
- * (a finalized assistant message re-wrapping, a tool preview collapsing to its
- * compact result, a late async tool completion). The renderer's only safe move
- * for such an offscreen edit is to not repaint — which is correct only if the
- * committed region never changes underneath it.
- *
- * This container provides that guarantee: a block's render is snapshotted while
- * it is the live (bottom-most) block, and once a newer block is appended it
- * replays the snapshot instead of recomputing. Mutations after a block leaves
- * live are intentionally deferred until the next checkpoint {@link thaw} (prompt
- * submit → native-scrollback rebuild), where the whole transcript is replayed
- * and any drift reconciles safely. On terminals that can rebuild history this
- * freezing is unnecessary, so it renders every block live for full fidelity.
+ * The engine never rewrites committed history: rows above the seam that have
+ * entered the tape keep whatever bytes they were committed with ("let the
+ * history be"), while the visible window always repaints from each block's
+ * latest render — a late tool result, a post-finalize error pin, or an expand
+ * toggle is always reflected on screen. Blocks that are still mutating (an
+ * unfinalized tool, a streaming assistant message) stay below the seam so
+ * their rows do not enter history while they can still change; a streaming
+ * block whose render grows append-only deepens the seam through its settled
+ * head so a long reply's scrolled-off rows still reach scrollback mid-stream.
  */
 export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion {
     #private;
@@ -27,13 +20,6 @@ export declare class TranscriptContainer extends Container implements NativeScro
     clear(): void;
     getNativeScrollbackLiveRegionStart(): number | undefined;
     getNativeScrollbackCommitSafeEnd(): number | undefined;
-    /**
-     * Retire all frozen snapshots so the next render reflects each block's current
-     * state. Call at reconciliation checkpoints (prompt submit) where the whole
-     * transcript is replayed into native scrollback and any drift a frozen block
-     * accumulated is reconciled.
-     */
-    thaw(): void;
     render(width: number): string[];
 }
 /**

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/discovery.d.ts

@@ -7,8 +7,7 @@ export interface DiscoveryResult {
 /**
  * Discover agents from filesystem and merge with bundled agents.
  *
- * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
- *
+ * Precedence (highest wins): project .omp, user .omp, Claude plugin agents, then bundled
  * @param cwd - Current working directory for project agent discovery
  */
 export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;

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/tiny/title-client.d.ts

@@ -32,7 +32,7 @@ export declare const TINY_WORKER_ARG = "--tiny-worker";
  */
 export declare function tinyWorkerEnvOverlay(env: Record<string, string | undefined>, deviceSetting: string | undefined, dtypeSetting: string | undefined): Record<string, string>;
 interface SpawnedSubprocess {
-    proc: Subprocess<"ignore", "inherit", "inherit">;
+    proc: Subprocess<"ignore", "ignore", "ignore">;
     inbound: Set<(message: TinyTitleWorkerOutbound) => void>;
     errors: Set<(error: Error) => void>;
     /**

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/tools/todo.d.ts

@@ -40,6 +40,7 @@ declare const todoSchema: z.ZodObject<{
             note: "note";
             rm: "rm";
             start: "start";
+            view: "view";
         }>;
         list: z.ZodOptional<z.ZodArray<z.ZodObject<{
             phase: z.ZodString;
@@ -113,6 +114,7 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
                 note: "note";
                 rm: "rm";
                 start: "start";
+                view: "view";
             }>;
             list: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 phase: z.ZodString;

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.10",
 	"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.10",
+		"@oh-my-pi/omp-stats": "15.10.10",
+		"@oh-my-pi/pi-agent-core": "15.10.10",
+		"@oh-my-pi/pi-ai": "15.10.10",
+		"@oh-my-pi/pi-mnemopi": "15.10.10",
+		"@oh-my-pi/pi-natives": "15.10.10",
+		"@oh-my-pi/pi-tui": "15.10.10",
+		"@oh-my-pi/pi-utils": "15.10.10",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/list-models.ts

@@ -64,22 +64,16 @@ export async function listModels(modelRegistry: ModelRegistry, searchPattern?: s
 	}
 
 	const filteredCanonical = modelRegistry
-		.getCanonicalModels({ availableOnly: true, candidates: filteredModels })
-		.map(record => {
-			const selected = modelRegistry.resolveCanonicalModel(record.id, {
-				availableOnly: true,
-				candidates: filteredModels,
-			});
-			if (!selected) return undefined;
-			return {
+		.getCanonicalModelSelections({ availableOnly: true, candidates: filteredModels })
+		.map(
+			({ record, model: selected }): CanonicalRow => ({
 				canonical: record.id,
 				selected: `${selected.provider}/${selected.id}`,
 				variants: String(record.variants.length),
 				context: formatNumber(selected.contextWindow),
 				maxOut: formatNumber(selected.maxTokens),
-			} satisfies CanonicalRow;
-		})
-		.filter((row): row is CanonicalRow => row !== undefined)
+			}),
+		)
 		.sort((left, right) => left.canonical.localeCompare(right.canonical));
 
 	if (filteredModels.length === 0 && filteredCanonical.length === 0) {