@oh-my-pi/pi-coding-agent 16.5.0 → 16.5.2

package/dist/types/advisor/advise-tool.d.ts

@@ -36,6 +36,13 @@ export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[])
  * and `blocker` interrupt; a plain `nit` queues.
  */
 export declare function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean;
+/**
+ * Append a staleness caveat to an advisor note when newer primary turns arrived
+ * after the reviewed transcript window (i.e. `hasFreshBacklog` is true on the
+ * advisor runtime at delivery time). Pure function — no session coupling — so it
+ * can be unit-tested in isolation and called from `AgentSession#routeAdvice`.
+ */
+export declare function annotateForStaleness(note: string, hasFreshBacklog: boolean): string;
 /** How an advisor note is routed to the primary. */
 export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
 /** Half-open turn-count fence for the post-interrupt cooldown. */
@@ -51,6 +58,9 @@ export declare function isAdvisorInterruptImmuneTurnActive(opts: {
  * - An interrupting `concern`/`blocker` is normally steered into the agent: into
  *   the live turn while one is streaming, or (when idle) a triggered turn so the
  *   advice is acted on immediately.
+ * - If the primary tail is already a terminal text answer and there is no queued
+ *   work, late interrupting advice is preserved as a visible card instead of
+ *   waking the primary to restate completion.
  * - After a deliberate user interrupt (`autoResumeSuppressed`) the advisor must
  *   not auto-resume the stopped run. While the agent is idle — or still tearing
  *   the interrupted turn down (`aborting`) — the note is preserved as a visible
@@ -60,13 +70,14 @@ export declare function isAdvisorInterruptImmuneTurnActive(opts: {
  *   run instead strands it (it never reaches the running agent) and the withheld
  *   notes dump as one burst at the next user prompt — the bug this guards.
  * - During the post-interrupt immune-turn window, further `concern`/`blocker`
- *   notes are downgraded to asides; suppression preservation still wins.
+ *   notes are downgraded to asides; preservation still wins.
  */
 export declare function resolveAdvisorDeliveryChannel(opts: {
     severity: AdvisorSeverity | undefined;
     autoResumeSuppressed: boolean;
     streaming: boolean;
     aborting: boolean;
+    terminalAnswerNoQueuedWork?: boolean;
     interruptImmuneTurnActive?: boolean;
 }): AdvisorDeliveryChannel;
 /**

package/dist/types/advisor/runtime.d.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type SecretObfuscator } from "../secrets/obfuscator.js";
 /**
  * Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core
@@ -59,6 +60,24 @@ export interface AdvisorRuntimeHost {
     /** Surface a non-recovering advisor failure to the host UI without adding model-visible context. */
     notifyFailure?(error: unknown): void;
 }
+/** Signals that an advisor response was discarded before it could become model-visible context. */
+export declare class AdvisorOutputQuarantinedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Replaces an advisor assistant turn that requested unavailable tools or generated
+ * output-only destructive directives with a sanitized error before dispatch.
+ *
+ * The agent loop records assistant turns before dispatching tools. Without this
+ * pre-dispatch rewrite, an advisor hallucination can leave unrelated text in the
+ * advisor transcript even though the action itself never executes.
+ */
+export declare function quarantineAdvisorUnsafeOutput(message: AssistantMessage, availableToolNames: ReadonlySet<string>, sourceText?: string): string | undefined;
+/**
+ * Builds the provenance text used to decide whether hazardous advisor output was
+ * generated by the advisor or came from model-visible primary/tool context.
+ */
+export declare function buildAdvisorQuarantineSourceText(currentInput: string, messages: readonly AgentMessage[]): string;
 export declare class AdvisorRuntime {
     #private;
     private readonly agent;
@@ -67,7 +86,28 @@ export declare class AdvisorRuntime {
     disposed: boolean;
     constructor(agent: AdvisorAgent, host: AdvisorRuntimeHost, retryDelayMs?: number);
     get backlog(): number;
-    onTurnEnd(messages?: AgentMessage[]): void;
+    /**
+     * True when `#pending` is non-empty while the drain loop is busy — i.e., newer
+     * primary turns arrived after the current batch's transcript window was fixed
+     * but before the advisor model finished processing it. The delivery path uses
+     * this to annotate advice that was generated without seeing those newer turns.
+     * Can be true during `agent.prompt()`, a `maintainContext` await, or a retry
+     * sleep — any time `#drain` is busy and a concurrent `onTurnEnd` pushed.
+     */
+    get hasFreshBacklog(): boolean;
+    /**
+     * Called after each primary turn ends. Renders the incremental delta and
+     * queues it for the advisor model.
+     *
+     * @param messages - Live primary transcript snapshot (defaults to `snapshotMessages()`).
+     * @param opts.willContinue - When `true` the primary is mid-turn (more tool-call
+     *   steps will follow). The rendered heading is tagged `[in progress]` so the
+     *   advisor knows to withhold critique on partial work. The flag is carried on
+     *   the delta and forwarded to the reprime path so it is never silently dropped.
+     */
+    onTurnEnd(messages?: AgentMessage[], opts?: {
+        willContinue?: boolean;
+    }): void;
     waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<void>;
     dispose(): void;
     /**

package/dist/types/cli/args.d.ts

@@ -79,5 +79,7 @@ export declare function parseArgs(inputArgs: string[], extensionFlags?: Map<stri
  * process (issue #2459).
  */
 export declare function reportUnrecognizedFlags(args: Pick<Args, "unrecognizedFlags">, write?: (text: string) => void): boolean;
+/** Emit a clean CLI usage error without an internal stack trace. */
+export declare function reportCliUsageError(error: unknown, write?: (text: string) => void): boolean;
 export declare function getExtraHelpText(): string;
 export declare function printHelp(): void;

package/dist/types/cli/update-cli.d.ts

@@ -21,11 +21,12 @@ export declare function parseUpdateArgs(args: string[]): {
     check: boolean;
     plugins: boolean;
 } | undefined;
-type UpdateMethod = "brew" | "mise" | "bun" | "binary";
+type UpdateMethod = "brew" | "mise" | "bun" | "npm" | "binary";
 interface UpdateMethodResolutionOptions {
     homebrewPrefix?: string;
     miseBinDirs?: readonly string[];
     miseDataDir?: string;
+    npmBinDir?: string;
 }
 export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined, options?: UpdateMethodResolutionOptions): UpdateMethod;
 interface BunInstallCachePruneResult {
@@ -89,6 +90,8 @@ export declare function replaceBinaryForUpdate(options: BinaryReplacementOptions
  * See #1824.
  */
 export declare function buildBunInstallArgs(expectedVersion: string, nativeTag?: string): string[];
+/** Build the npm argv used to update npm-managed global installs. */
+export declare function buildNpmInstallArgs(expectedVersion: string, nativeTag?: string): string[];
 export declare function buildHomebrewUpdateArgs(force: boolean): string[];
 export declare function buildMiseUpgradeArgs(): string[];
 export declare function buildMiseForceInstallArgs(expectedVersion: string): string[];

package/dist/types/cli/usage-cli.d.ts

@@ -26,6 +26,9 @@ export interface UsageAccountIdentity {
     accountId?: string;
     projectId?: string;
     enterpriseUrl?: string;
+    /** Organization/workspace the credential is scoped to (Anthropic multi-subscription). */
+    orgId?: string;
+    orgName?: string;
 }
 /**
  * Minimal-reveal masks for identity strings (`--redact`).

package/dist/types/cli/usage-error.d.ts

@@ -0,0 +1,4 @@
+/** Command-line input error that should be rendered without a stack trace. */
+export declare class CliUsageError extends Error {
+    constructor(message: string);
+}

package/dist/types/config/api-key-resolver.d.ts

@@ -1,4 +1,4 @@
-import type { Api, ApiKeyResolver, AuthStorage, Model } from "@oh-my-pi/pi-ai";
+import { type Api, type ApiKeyResolver, type AuthStorage, type Model } from "@oh-my-pi/pi-ai";
 /** Model slice accepted by the model-form `resolver(model, sessionId)` overload. */
 export type ApiKeyResolverModel = Pick<Model<Api>, "provider" | "baseUrl" | "id">;
 export interface ApiKeyResolverOptions {
@@ -25,7 +25,7 @@ export interface ApiKeyResolverRegistry {
     /**
      * Build an {@link ApiKeyResolver} implementing the central a/b/c auth-retry
      * policy: initial → resolve; step (b) → force-refresh same account; step (c)
-     * → rotate to a sibling credential, then re-resolve.
+     * → rotate to a sibling and re-resolve, unless quota exhaustion has no sibling.
      *
      * Two call forms: `resolver(provider, options?)` for provider-scoped keys,
      * and `resolver(model, sessionId?)` which derives `baseUrl`/`modelId` from

package/dist/types/config/model-registry.d.ts

@@ -74,7 +74,7 @@ export declare class ModelRegistry {
         fetch?: FetchImpl;
     });
     /**
-     * Reload models from disk (built-in + custom from models.json).
+     * Reload models from disk (built-in + custom config).
      */
     refresh(strategy?: ModelRefreshStrategy): Promise<void>;
     refreshInBackground(strategy?: ModelRefreshStrategy): void;
@@ -94,12 +94,12 @@ export declare class ModelRegistry {
      */
     refreshRuntimeProviders(strategy?: ModelRefreshStrategy): Promise<void>;
     /**
-     * Get any error from loading models.json (undefined if no error).
+     * Get any error from loading custom models config (undefined if no error).
      */
     getError(): ConfigError | undefined;
     /**
      * Get all models (built-in + custom).
-     * If models.json had errors, returns only built-in models.
+     * If custom config had errors, returns only built-in models.
      */
     getAll(): Model<Api>[];
     /**

package/dist/types/config/model-resolver.d.ts

@@ -144,6 +144,7 @@ export declare function resolveModelOverride(modelPatterns: string[], modelRegis
     model?: Model<Api>;
     thinkingLevel?: ConfiguredThinkingLevel;
     explicitThinkingLevel: boolean;
+    warning?: string;
 };
 /**
  * Resolve a list of override patterns to the first matching model, with an
@@ -156,6 +157,11 @@ export declare function resolveModelOverride(modelPatterns: string[], modelRegis
  * `modelRoles.task` pointing at an unqualified id whose only available
  * provider variant has no configured credentials — see #985).
  *
+ * `sessionId` is forwarded to `getApiKey` so that session-sticky OAuth
+ * credentials resolve correctly during the pre-flight auth check. Without it,
+ * providers with multiple OAuth accounts may return `undefined` even though
+ * the credential is usable once the subagent session starts — see #5325.
+ *
  * Keyless-by-design providers (llama.cpp, ollama, lm-studio) advertise the
  * `kNoAuth` sentinel from `getApiKey` to signal that they do not require
  * credentials. Those are treated as authenticated here so an explicitly
@@ -166,11 +172,12 @@ export declare function resolveModelOverride(modelPatterns: string[], modelRegis
  * primary resolution unchanged so the existing error path still surfaces
  * a meaningful failure downstream.
  */
-export declare function resolveModelOverrideWithAuthFallback(modelPatterns: string[], parentActiveModelPattern: string | undefined, modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">, settings?: Settings): Promise<{
+export declare function resolveModelOverrideWithAuthFallback(modelPatterns: string[], parentActiveModelPattern: string | undefined, modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">, settings?: Settings, sessionId?: string): Promise<{
     model?: Model<Api>;
     thinkingLevel?: ConfiguredThinkingLevel;
     explicitThinkingLevel: boolean;
     authFallbackUsed: boolean;
+    warning?: string;
 }>;
 /**
  * Resolve a list of role patterns to the first matching model.

package/dist/types/config/models-config.d.ts

@@ -1,5 +1,5 @@
 /**
- * models.json config file handle and provider configuration validation.
+ * Custom model/provider config file handle and validation.
  */
 import type { Api, ModelSpec } from "@oh-my-pi/pi-ai/types";
 import { ConfigFile } from "./config-file.js";

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

@@ -3699,6 +3699,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the tts tool for on-device (Kokoro) or xAI Grok Voice speech-file synthesis";
         };
     };
+    readonly "generate_image.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly group: "Available Tools";
+            readonly label: "Generate Image";
+            readonly description: "Enable the generate_image tool for text-to-image generation and editing";
+        };
+    };
     readonly "inspect_image.enabled": {
         readonly type: "boolean";
         readonly default: false;

package/dist/types/discovery/substitute-plugin-root.d.ts

@@ -1 +1,23 @@
 export declare function substitutePluginRoot<T>(value: T, rootPath: string): T;
+/**
+ * Rebase relative filesystem values in a discovered plugin stdio config against
+ * the directory of the `.mcp.json` that declared them.
+ *
+ * External plugin configs (bundled ChatGPT/Codex plugins, Claude marketplace
+ * plugins) express `command`/`cwd` relative to their own config file, but MCP
+ * stdio spawning roots relative values at the session cwd — so a plugin shipping
+ * `command: "./bin/server"`, `cwd: "."` launches from the wrong directory and
+ * fails with ENOENT. This resolves those against `configDir` instead:
+ *
+ * - relative `cwd` → resolved against `configDir`;
+ * - path-like `command` (`./`, `../`, or the Windows `.\`/`..\` forms) →
+ *   resolved against `configDir`;
+ * - bare executables (`npx`, `uvx`, …) and absolute paths are left untouched.
+ */
+export declare function resolvePluginStdioPaths(config: {
+    command?: string;
+    cwd?: string;
+}, configDir: string): {
+    command?: string;
+    cwd?: string;
+};

package/dist/types/eval/__tests__/process-entry-import.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/backend.d.ts

@@ -13,10 +13,10 @@ export interface ExecutorBackendExecOptions {
      * driven entirely by `signal`, which the eval tool arms as a watchdog that
      * pauses on bridge timeout-control status events and fires a `TimeoutError`
      * reason only while the Python/JS runtime owns control. Backends use this
-     * value only for timeout-annotation text and as cold-start headroom; they MUST
-     * NOT derive a competing wall-clock timer from it.
+     * value only for timeout-annotation text and as cold-start headroom; undefined
+     * disables the cell timeout. Backends MUST NOT derive a competing wall-clock timer from it.
      */
-    idleTimeoutMs: number;
+    idleTimeoutMs?: number;
     reset: boolean;
     onChunk: (chunk: string) => void;
     /**

package/dist/types/eval/bridge-timeout.d.ts

@@ -20,8 +20,16 @@ export declare const EVAL_TIMEOUT_PAUSE_OP = "timeout-pause";
 export declare const EVAL_TIMEOUT_RESUME_OP = "timeout-resume";
 /** Whether a status event is pure eval-timeout control and should not render. */
 export declare function isEvalTimeoutControlEvent(event: JsStatusEvent): boolean;
+/** Optional behavior for a timeout pause around a host bridge call. */
+export interface BridgeTimeoutPauseOptions {
+    /**
+     * Marks the pause as an `agent()` call whose already-started work must finish
+     * before an external eval abort reaches the kernel.
+     */
+    deferExternalAbort?: boolean;
+}
 /**
  * Run {@link operation} while suspending the eval watchdog through
  * {@link emitStatus}. A no-op wrapper when no status sink is wired.
  */
-export declare function withBridgeTimeoutPause<T>(emitStatus: ((event: JsStatusEvent) => void) | undefined, operation: () => Promise<T>): Promise<T>;
+export declare function withBridgeTimeoutPause<T>(emitStatus: ((event: JsStatusEvent) => void) | undefined, operation: () => Promise<T>, options?: BridgeTimeoutPauseOptions): Promise<T>;

package/dist/types/eval/js/context-manager.d.ts

@@ -13,6 +13,8 @@ export interface VmRunState {
  * {@link WORKER_CLOSE_TIMEOUT_MS}; never call this outside tests.
  */
 export declare function setWorkerCloseTimeoutMsForTests(ms: number): number;
+/** Test-only seam for the legacy Worker lifecycle mocks. */
+export declare function setJsEvalWorkerThreadForTests(enabled: boolean): boolean;
 export declare function executeInVmContext(options: {
     sessionKey: string;
     sessionId: string;
@@ -30,9 +32,9 @@ export declare function executeInVmContext(options: {
 export declare function resetVmContext(sessionKey: string): Promise<void>;
 export declare function disposeAllVmContexts(): Promise<void>;
 /**
- * Smoke probe: spawn the JS eval worker through the worker-host entry and prove
- * it answers the `init` handshake on a real worker thread (not the inline
- * fallback). Catches the silent worker-load and init-message-drop regressions
+ * Smoke probe: spawn the JS evaluator through the worker-host entry and prove
+ * it answers the `init` handshake in a real isolated subprocess (not the inline
+ * fallback). Catches silent process-load and init-message regressions
  * that otherwise strand every cell on the init timeout in a distribution build —
  * the failure mode that motivated `installWorkerInbox`. Wired into
  * `omp --smoke-test` so binary / source / tarball installs all exercise it.

package/dist/types/eval/js/process-entry.d.ts

@@ -0,0 +1,6 @@
+import type { WorkerInbound, WorkerOutbound } from "./worker-protocol.js";
+/** Start the JavaScript evaluator inside a subprocess IPC transport. */
+export declare function startJsEvalProcess(transport: {
+    send(message: WorkerOutbound): void;
+    onMessage(handler: (message: WorkerInbound) => void): () => void;
+}): void;

package/dist/types/eval/js/worker-core.d.ts

@@ -1,6 +1,20 @@
 import type { Transport } from "./worker-protocol.js";
+export type WorkerCoreOptions = {
+    mode: "isolated";
+    /**
+     * Mirror the session cwd onto the real process cwd so cell code using
+     * `process.cwd()`, relative paths, or child processes without an explicit
+     * `cwd` resolves against the project. Only the dedicated subprocess may
+     * pass this: `process.chdir` is unavailable in Worker threads and would
+     * mutate the host's own cwd on the inline fallback.
+     */
+    chdir?: (cwd: string) => void;
+} | {
+    mode: "inline";
+    interceptUnhandledRejections(handler: (reason: unknown) => boolean): () => void;
+};
 export declare class WorkerCore {
     #private;
-    constructor(transport: Transport);
+    constructor(transport: Transport, options: WorkerCoreOptions);
     dispose(): void;
 }

package/dist/types/eval/py/spawn-options.d.ts

@@ -26,6 +26,16 @@ export declare function shouldHideKernelWindow(opts: {
     platform: NodeJS.Platform;
     hostHasInheritableConsole: boolean;
 }): boolean;
+/**
+ * Keep eval kernels outside the host's POSIX terminal session.
+ *
+ * User code can start an interactive shell which calls `tcsetpgrp(3)`. If the
+ * kernel shares OMP's session, that shell can replace OMP as the controlling
+ * terminal's foreground process group and the host is then stopped by SIGTTIN
+ * on its next stdin read. Bun implements `detached: true` with `setsid(2)` on
+ * POSIX, making the kernel a session leader with no controlling terminal.
+ */
+export declare function shouldDetachKernel(platform: NodeJS.Platform): boolean;
 /**
  * TTY-based fallback used when the Win32 console probe is unavailable.
  *

package/dist/types/eval/py/tool-bridge.d.ts

@@ -4,6 +4,7 @@ export interface PyToolBridgeEntry {
     toolSession: ToolSession;
     signal?: AbortSignal;
     emitStatus?: (event: JsStatusEvent) => void;
+    abortRequested?: () => boolean;
 }
 export interface PyToolBridgeInfo {
     url: string;

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

@@ -17,6 +17,7 @@ import type { Settings } from "../../config/settings.js";
 import type { ExecOptions, ExecResult } from "../../exec/exec.js";
 import type { HookUIContext } from "../../extensibility/hooks/types.js";
 import type * as PiCodingAgent from "../../index.js";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js";
 import type { Theme } from "../../modes/theme/theme.js";
 import type { ReadonlySessionManager } from "../../session/session-manager.js";
 import type { TodoItem } from "../../tools/todo.js";
@@ -84,6 +85,8 @@ export interface CustomToolContext {
     settings?: Settings;
     /** Fetch implementation for outbound HTTP; defaults to global fetch when omitted. */
     fetch?: FetchImpl;
+    /** Calling session's `local://` root mapping for tools that bridge out of the OMP process. */
+    localProtocolOptions?: LocalProtocolOptions;
     /** Whether to auto-approve all destructive tool operations (--auto-approve CLI flag) */
     autoApprove?: boolean;
 }

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

@@ -6,6 +6,7 @@ import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMeta
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import type { ModelRegistry } from "../../config/model-registry.js";
 import type { Settings } from "../../config/settings.js";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js";
 import type { MemoryRuntimeContext } from "../../memory-backend/index.js";
 import type { SessionManager } from "../../session/session-manager.js";
 import type { BranchHandler, NavigateTreeHandler, NewSessionHandler } from "../session-handler-types.js";
@@ -65,7 +66,8 @@ export declare class ExtensionRunner {
     private readonly sessionManager;
     private readonly modelRegistry;
     private readonly settings?;
-    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined);
+    private readonly localProtocolOptions?;
+    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined, localProtocolOptions?: LocalProtocolOptions | undefined);
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.

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

@@ -22,6 +22,7 @@ import type { PythonResult } from "../../eval/py/executor.js";
 import type { BashResult } from "../../exec/bash-executor.js";
 import type { ExecOptions, ExecResult } from "../../exec/exec.js";
 import type * as PiCodingAgent from "../../index.js";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js";
 import type { MemoryRuntimeContext } from "../../memory-backend/index.js";
 import type { CustomEditor } from "../../modes/components/custom-editor.js";
 import type { Theme } from "../../modes/theme/theme.js";
@@ -285,6 +286,8 @@ export interface ExtensionContext {
     sessionManager: ReadonlySessionManager;
     /** Model registry for API key resolution */
     modelRegistry: ModelRegistry;
+    /** Calling session's `local://` root mapping for external tool bridges. */
+    localProtocolOptions?: LocalProtocolOptions;
     /** Current model (may be undefined) */
     model: Model | undefined;
     /** Read-only model query facade: list / current / resolve / family. */

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

@@ -1,7 +1,7 @@
 /**
  * Tool wrappers for extensions.
  */
-import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Static, TSchema } from "@oh-my-pi/pi-ai";
 import type { ExtensionRunner } from "./runner.js";
 import type { RegisteredTool } from "./types.js";
@@ -19,7 +19,7 @@ export declare class RegisteredToolAdapter implements AgentTool<any, any, any> {
     renderCall?: (args: any, options: any, theme: any) => any;
     renderResult?: (result: any, options: any, theme: any, args?: any) => any;
     constructor(registeredTool: RegisteredTool, runner: ExtensionRunner);
-    execute(toolCallId: string, params: any, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<any>, _context?: AgentToolContext): Promise<import("@oh-my-pi/pi-agent-core").AgentToolResult<unknown, unknown>>;
+    execute(toolCallId: string, params: any, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<any>, _context?: AgentToolContext): Promise<AgentToolResult<unknown, unknown>>;
 }
 /**
  * Backward-compatible factory function wrapper.
@@ -47,8 +47,5 @@ export declare class ExtensionToolWrapper<TParameters extends TSchema = TSchema,
      * Forward browser mode changes when available.
      */
     restartForModeChange(): Promise<void>;
-    execute(toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails, TParameters>, context?: AgentToolContext): Promise<{
-        content: any;
-        details?: TDetails;
-    }>;
+    execute(toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails, TParameters>, context?: AgentToolContext): Promise<AgentToolResult<TDetails, TParameters>>;
 }

package/dist/types/extensibility/plugins/bun-git-cache.d.ts

@@ -0,0 +1,3 @@
+import type { GitSource } from "./git-url.js";
+/** Fetches current heads and tags into Bun's matching cached bare clone before a plugin update. */
+export declare function refreshBunGitCache(source: GitSource, cwd: string): Promise<void>;

package/dist/types/goals/guided-setup.d.ts

@@ -14,5 +14,17 @@ export type GuidedGoalTurnResult = {
 export interface GuidedGoalTurnOptions {
     messages: readonly GuidedGoalMessage[];
     signal?: AbortSignal;
+    /**
+     * Stable Codex transport session id reused across every turn of one
+     * interview. `handleGuidedGoalCommand` runs up to six turns; minting a fresh
+     * id per turn opens a new websocket-only Codex socket each time (kept in
+     * `providerSessionState` until session dispose), which can trip
+     * `websocket_connection_limit_reached` and drop back to the SSE path this
+     * fix avoids. Callers pass one id for the whole interview; omitted for
+     * one-shot callers, which mint a unique id per call.
+     */
+    sideSessionId?: string;
 }
+/** Mint a guided-goal Codex side-session id keyed off the main session id. */
+export declare function newGuidedGoalSessionId(session: AgentSession): string;
 export declare function runGuidedGoalTurn(session: AgentSession, options: GuidedGoalTurnOptions): Promise<GuidedGoalTurnResult>;

package/dist/types/internal-urls/history-protocol.d.ts

@@ -2,8 +2,9 @@ import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } fr
 /**
  * Handler for history:// URLs.
  *
- * Resolves agent ids against the global AgentRegistry, serving transcripts
- * for both live and parked agents.
+ * Resolves agent ids against the global AgentRegistry, then falls back to
+ * on-disk `.jsonl` transcripts, serving read-only history for live, parked,
+ * and unregistered agents alike.
  */
 export declare class HistoryProtocolHandler implements ProtocolHandler {
     #private;

package/dist/types/internal-urls/memory-protocol.d.ts

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types.js";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types.js";
 /**
  * Snapshot of memory roots for every registered session, deduped.
  * Each session has its own cwd (possibly a worktree), so subagents and main
@@ -11,14 +11,13 @@ export declare function memoryRootsFromRegistry(): string[];
 export declare function resolveMemoryUrlToPath(url: InternalUrl, memoryRoot: string): string;
 /**
  * Protocol handler for memory:// URLs.
- *
- * Walks every active session's memory root. Worktree-based subagents have
- * their own root; first one containing the file wins. Parent and subagent
- * sharing a cwd see the same file regardless of order.
+ * Resolves file-backed roots against the calling session cwd when provided.
+ * Contextless callers fall back to the live-session registry for legacy
+ * cross-session lookups.
  */
 export declare class MemoryProtocolHandler implements ProtocolHandler {
     readonly scheme = "memory";
     readonly immutable = true;
-    resolve(url: InternalUrl): Promise<InternalResource>;
-    complete(): Promise<UrlCompletion[]>;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+    complete(_query?: string, context?: ResolveContext): Promise<UrlCompletion[]>;
 }

package/dist/types/internal-urls/registry-helpers.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Shared helpers for internal-url protocol handlers that resolve IDs against
+ * registered agent sessions.
+ */
 export declare function registerArtifactsDir(dir: string): () => void;
 export declare function resetRegisteredArtifactDirsForTests(): void;
 /**
@@ -12,3 +16,18 @@ export declare function resetRegisteredArtifactDirsForTests(): void;
  * single entry.
  */
 export declare function artifactsDirsFromRegistry(): string[];
+/**
+ * Recursively scan artifacts dirs for agent session transcripts, keyed by
+ * agent id (the `.jsonl` basename). Used by `history://` so transcripts of
+ * agents no longer in the registry (unregistered one-shot helpers, released
+ * agents, or any agent after session resume) remain reachable — mirroring how
+ * `agent://` reads `.md` outputs straight off disk.
+ *
+ * Layout follows `task/index.ts`: a subagent's transcript is
+ * `<artifactsDir>/<AgentId>.jsonl`, and its own children nest one level deeper
+ * under `<artifactsDir>/<AgentId>/<AgentId>.<ChildId>.jsonl`. Advisor
+ * transcripts (`__advisor*.jsonl`) are observability-only and excluded;
+ * EPERM-rewrite backups (`.bak`) are skipped. When the same id appears in
+ * multiple dirs, the first hit wins (registry dirs are scanned first).
+ */
+export declare function sessionFilesFromDisk(): Promise<Map<string, string>>;

package/dist/types/main.d.ts

@@ -53,6 +53,7 @@ export declare class SessionResolutionError extends Error {
     readonly hint?: string;
     constructor(message: string, hint?: string);
 }
+export declare function normalizeContinueSessionArgs(parsed: Args, rawArgs?: readonly string[]): void;
 /** Resolves CLI session flags into an existing, forked, in-memory, or cancelled session manager. */
 export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings, askToForkSession?: SessionPrompt, askToMoveSession?: SessionPrompt): Promise<SessionManager | undefined>;
 /** Apply resolved CLI/discovered prompt files without bypassing system prompt templates. */

package/dist/types/mcp/oauth-discovery.d.ts

@@ -3,6 +3,8 @@ export interface OAuthEndpoints {
     authorizationUrl: string;
     tokenUrl: string;
     clientId?: string;
+    /** Dynamic client registration endpoint advertised by the authorization server. */
+    registrationUrl?: string;
     scopes?: string;
     resource?: string;
 }

package/dist/types/mcp/oauth-flow.d.ts

@@ -52,6 +52,8 @@ export interface MCPOAuthConfig {
     authorizationUrl: string;
     /** Token endpoint URL */
     tokenUrl: string;
+    /** Dynamic client registration endpoint advertised by the authorization server. */
+    registrationUrl?: string;
     /** Client ID (optional when already embedded in authorization URL) */
     clientId?: string;
     /** Client secret (optional for PKCE flows) */

package/dist/types/modes/components/__tests__/dynamic-border.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modes/components/agent-hub.d.ts

@@ -69,6 +69,16 @@ export declare class AgentHubOverlayComponent extends Container {
     dispose(): void;
     render(width: number): readonly string[];
     handleInput(keyData: string): void;
+    /**
+     * Seed the table's left-left close detector with the current time so a single
+     * subsequent `←` (within {@link LEFT_TAP_WINDOW_MS}) dismisses the hub.
+     *
+     * The editor's own double-tap detector consumes the `←←` that opens the hub,
+     * leaving this detector at its fresh `0` — without this handoff the user would
+     * have to press `←←` a second time to escape. Called by the opener when the hub
+     * was raised by that gesture.
+     */
+    armCloseTap(): void;
     /**
      * Open the fullscreen transcript viewer for an agent id (public for table Enter
      * and tests). Mounts {@link AgentTranscriptViewer} as a `fullscreen` overlay so it