@oh-my-pi/pi-coding-agent 17.2.12 → 17.2.13

package/dist/types/advisor/delta-split.d.ts

@@ -0,0 +1,24 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+/**
+ * Obfuscation surface the split renderer needs: a single text redaction pass.
+ * Narrowed from the full SecretObfuscator class to the method actually
+ * consumed, so tests can satisfy the contract with a typed helper instead of
+ * an `as any` escape. A SecretObfuscator instance is structurally assignable.
+ */
+export interface AdvisorObfuscator {
+    obfuscate(text: string, sharedRegexSecretValues?: ReadonlySet<string>): string;
+}
+/** Render options shared by the advisor single-block and multi-message paths. */
+export declare const ADVISOR_RENDER_OPTIONS: {
+    readonly includeToolIntent: true;
+    readonly watchedRoles: true;
+    readonly expandPrimaryContext: true;
+    readonly expandEditDiffs: true;
+};
+export interface RenderAdvisorDeltaChunksOptions {
+    wip: boolean;
+    includeThinking: boolean;
+    obfuscator?: AdvisorObfuscator;
+    advisorRegexSecretValues: ReadonlySet<string>;
+}
+export declare function renderAdvisorDeltaChunks(delta: AgentMessage[], opts: RenderAdvisorDeltaChunksOptions): AgentMessage[] | null;

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

@@ -8,7 +8,7 @@ import type { SecretObfuscator } from "../secrets/obfuscator.js";
  * this field after every prompt to detect a failed turn.
  */
 export interface AdvisorAgent {
-    prompt(input: string): Promise<void>;
+    prompt(input: string | AgentMessage[]): Promise<void>;
     abort(reason?: unknown): void;
     reset(): void;
     /**
@@ -129,7 +129,7 @@ export declare class AdvisorRuntime {
      * post-compaction — transcript, giving the advisor fresh context instead of
      * leaving it blind to everything before the rewrite.
      */
-    reset(): void;
+    reset(reason?: string): void;
     /**
      * Seed the cursor to the current transcript length when the advisor is enabled
      * mid-session. Prevents the next turn from replaying the entire history to the

package/dist/types/async/job-manager.d.ts

@@ -1,3 +1,5 @@
+/** Abort reason used only when the owning session shuts down the entire manager. */
+export declare const ASYNC_JOB_MANAGER_SHUTDOWN_REASON: unique symbol;
 export interface AsyncJob {
     id: string;
     type: "bash" | "task";
@@ -132,8 +134,13 @@ export declare class AsyncJobManager {
      * Cancel running jobs. With `filter.ownerId` set, cancels only jobs the
      * matching agent registered; with no filter, cancels every running job
      * (used by `dispose()` to nuke the manager's state).
+     *
+     * `reason` is forwarded to each job's `AbortController.abort`, so a session
+     * teardown can tag its owned jobs with {@link ASYNC_JOB_MANAGER_SHUTDOWN_REASON}
+     * before `dispose()` runs — the task executor reads it to park (not
+     * tombstone) a subagent interrupted purely by process shutdown.
      */
-    cancelAll(filter?: AsyncJobFilter): void;
+    cancelAll(filter?: AsyncJobFilter, reason?: unknown): void;
     /**
      * Immediately evict completed and failed jobs matching the filter instead of
      * waiting for retention expiry, dropping every queued delivery so a prior

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

@@ -1,9 +1,37 @@
+/** Distribution channel advertised by a release's published npm manifest. */
+export type ReleaseDist = "npm" | "binary";
 export interface ReleaseBinaryAsset {
     url: string;
     size: number;
     digest: string;
 }
 type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/**
+ * Parse the `omp.dist` field from a published package manifest.
+ *
+ * Forward-compatibility contract with future releases: a release that is not
+ * installable as an npm package (e.g. a native rewrite) publishes
+ * `"omp": { "dist": "binary" }` in its package.json. Any value other than
+ * "npm" — including values this updater does not know yet — maps to "binary"
+ * so already-deployed updaters never run a package-manager install against a
+ * release that no longer supports it.
+ */
+export declare function resolveReleaseDist(manifest: unknown): ReleaseDist | undefined;
+/**
+ * Whether the update must bypass bun/npm and install the release binary.
+ *
+ * An explicit `omp.dist` wins in both directions. Without one, a release with
+ * a higher major than the running build is assumed not npm-installable: the
+ * runtime may have changed out from under the package layout, and the pinned
+ * `@oh-my-pi/pi-natives*` companions ({@link buildBunInstallArgs}) may not
+ * exist at that version, which would strand bun/npm-managed installs behind a
+ * hard install failure. Homebrew and mise installs are unaffected — both
+ * already pull GitHub release binaries.
+ */
+export declare function shouldForceBinaryUpdate(release: {
+    version: string;
+    dist?: ReleaseDist;
+}, currentVersion?: string): boolean;
 /**
  * Select and validate the binary asset from GitHub release metadata.
  */
@@ -86,7 +114,11 @@ interface MuslDetectionOptions {
 /** Test seam for libc detection. */
 export declare function isMuslLinuxForTest(options: Required<MuslDetectionOptions>): boolean;
 /**
- * Run the resolved omp binary and check if it reports the expected version.
+ * Run a specific binary and check if it reports the expected version.
+ */
+declare function verifyBinaryAtPath(binaryPath: string, expectedVersion: string): Promise<InstalledVersionVerification>;
+/**
+ * Run the PATH-resolved omp binary and check if it reports the expected version.
  */
 declare function verifyInstalledVersion(expectedVersion: string): Promise<InstalledVersionVerification>;
 /**
@@ -149,6 +181,26 @@ export declare function updateViaBinaryAt(targetPath: string, expectedVersion: s
     githubToken?: string;
     verifyInstalledVersion?: typeof verifyInstalledVersion;
 }): Promise<void>;
+/**
+ * Take over a Windows script-launcher install for a binary-only release.
+ *
+ * npm-managed Windows installs are launched through script shims
+ * (`omp`/`omp.cmd`/`omp.ps1`) that cannot be overwritten with a native
+ * executable. The release binary is installed as `omp.exe` beside them and
+ * the shims are then renamed aside: cmd.exe would already prefer `.exe` via
+ * PATHEXT, but PowerShell resolves `.ps1` first, so the takeover only sticks
+ * once the shims are out of the way. A working launcher exists at every
+ * step — the exe lands before any shim moves, a shim that refuses to move
+ * (a running `.cmd` can be renamed but may be held open some other way) is
+ * rewritten in place as a forwarder to the exe, and a failed version
+ * verification moves everything back.
+ */
+export declare function updateViaShimTakeover(shimPath: string, expectedVersion: string, options?: {
+    binaryName?: string;
+    fetchImpl?: Fetch;
+    githubToken?: string;
+    verifyBinary?: typeof verifyBinaryAtPath;
+}): Promise<void>;
 /**
  * Run the update command.
  */

package/dist/types/config/keybindings.d.ts

@@ -371,6 +371,16 @@ export declare class KeybindingsManager extends TuiKeybindingsManager {
      */
     getDisplayString(keybinding: Keybinding): string;
 }
+/** Pin the platform used to render modifier labels (test seam). */
+export declare function setKeyHintPlatform(platform: NodeJS.Platform | undefined): void;
+/** Platform currently used for key-hint rendering. */
+export declare function keyHintPlatform(): NodeJS.Platform;
+type Modifier = "ctrl" | "shift" | "alt" | "super";
+/**
+ * Human label for a modifier, using each platform's own key names. `ctrl` and
+ * `shift` are the same everywhere; `alt`/`super` become `Option`/`Cmd` on macOS.
+ */
+export declare function modifierLabel(mod: Modifier, platform?: NodeJS.Platform): string;
 export declare function formatKeyHint(key: KeyId): string;
 export declare function formatKeyHints(keys: KeyId | KeyId[]): string;
 export type { Keybinding, KeybindingsConfig, KeyId };

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

@@ -120,8 +120,21 @@ export interface AgentModelPatternResolutionOptions {
     activeModelPattern?: string;
     fallbackModelPattern?: string;
 }
-/** Return the raw selector source that supplies the effective agent patterns. */
-export declare function resolveAgentModelSource(options: AgentModelPatternResolutionOptions): string | string[] | undefined;
+/** Effective agent model patterns paired with the pre-expansion role alias behind them. */
+export interface AgentModelSelection {
+    /** Expanded model patterns to spawn with. */
+    patterns: string[];
+    /** Role alias the patterns came from (`@task` -> `task`), when the source named one. */
+    role: string | undefined;
+}
+/**
+ * Resolve an agent's model patterns together with the role identity they were
+ * expanded from. Spawn paths MUST take both from this single call: the child's
+ * inherited retry-fallback chain is keyed off the role, which the expansion
+ * discards, and deriving the two halves separately is how they drift apart.
+ */
+export declare function resolveAgentModelSelection(options: AgentModelPatternResolutionOptions): AgentModelSelection;
+/** Effective agent model patterns alone, for callers with no interest in role identity. */
 export declare function resolveAgentModelPatterns(options: AgentModelPatternResolutionOptions): string[];
 /** Default prewalk hand-off target when no explicit target is configured. */
 export declare const DEFAULT_PREWALK_TARGET = "@smol";

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

@@ -6030,6 +6030,10 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "string";
         readonly default: undefined;
     };
+    readonly "searxng.safesearch": {
+        readonly type: "number";
+        readonly default: undefined;
+    };
     readonly "commit.mapReduceEnabled": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/discovery/agents-md.d.ts

@@ -1 +1,10 @@
-export {};
+import { type ContextFile } from "../capability/context-file.js";
+import type { LoadContext, LoadResult } from "../capability/types.js";
+/**
+ * Load standalone AGENTS.md files.
+ *
+ * When a repository is nested below the user's home directory, continue past
+ * the Git root to discover workspace-level AGENTS.md files, but stop before
+ * loading the home directory's own AGENTS.md as project context.
+ */
+export declare function loadAgentsMd(ctx: LoadContext): Promise<LoadResult<ContextFile>>;

package/dist/types/eval/runner-cache.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Stage `script` under `os.tmpdir()/<dirName>` and return the runner path.
+ *
+ * The staged path is memoized per `dirName` but re-checked with `fs.existsSync`
+ * before reuse, so a runner deleted mid-session is re-written on the next call
+ * instead of handing back a path to a missing file (issue #8140).
+ *
+ * @param dirName Cache subdirectory under the OS temp dir (unique per language).
+ * @param ext Runner file extension without the dot (e.g. `py`, `jl`, `rb`).
+ * @param script Runner source, hashed to key the cached file per version.
+ */
+export declare function stageRunnerScript(dirName: string, ext: string, script: string): Promise<string>;

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

@@ -1,6 +1,3 @@
-/**
- * Extension runner - executes extensions and manages their lifecycle.
- */
 import type { AgentMessage, AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMetadata } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
@@ -152,11 +149,23 @@ export declare class ExtensionRunner {
     emitMcpNotification(event: Omit<McpNotificationEvent, "type">): Promise<void>;
     /** Emits a session stop pass that can be cancelled with the active settle signal. */
     emitSessionStop(event: Omit<SessionStopEvent, "type">): Promise<SessionStopEventResult | undefined>;
+    /** Registers the interactive transcript gate that must settle before a tool approval is presented. */
+    setToolApprovalPreviewWaiter(waiter: (toolCallId: string) => Promise<void>): () => void;
+    /** Waits until the interactive transcript can show the tool call being approved. */
+    waitForToolApprovalPreview(toolCallId: string): Promise<void>;
     getUIContext(): ExtensionUIContext;
     hasUI(): boolean;
     getExtensionPaths(): string[];
     /** Get all registered tools from all extensions. */
     getAllRegisteredTools(): RegisteredTool[];
+    /** Get the effective registered tool for a name using normal last-extension-wins precedence. */
+    getRegisteredTool(name: string): RegisteredTool | undefined;
+    /**
+     * Observe tools registered after extension factories have loaded. Listener
+     * promises are drained before the lifecycle handler that registered them
+     * completes, keeping the model tool snapshot and system prompt coherent.
+     */
+    onToolRegistered(listener: (tool: RegisteredTool, signal?: AbortSignal) => void | Promise<void>): () => void;
     /**
      * Aggregate the registered CLI flags across a set of extensions (last write
      * wins on name collision). Static so callers that need the flag set before a

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

@@ -14,7 +14,7 @@ import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLe
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Model, ModelSpec, ProviderResponseMetadata, ServiceTier, ServiceTierByFamily, ServiceTierFamily, SimpleStreamOptions, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
-import type { AutocompleteItem, AutocompleteProvider, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
+import type { AutocompleteItem, AutocompleteProvider, Component, EditorTheme, KeyId, OverlayHandle, OverlayOptions, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
 import type { KeybindingsManager } from "../../config/keybindings.js";
 import type { ModelRegistry } from "../../config/model-registry.js";
@@ -36,6 +36,7 @@ import type { ApprovalMode } from "../../tools/approval.js";
 import type { EventBus } from "../../utils/event-bus.js";
 import type { AgentEndEvent, AgentStartEvent, AutoCompactionEndEvent, AutoCompactionStartEvent, AutoRetryEndEvent, AutoRetryStartEvent, ContextEvent, GoalUpdatedEvent, SessionBeforeBranchEvent, SessionBeforeBranchResult, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionBranchEvent, SessionCompactEvent, SessionCompactingEvent, SessionCompactingResult, SessionEvent, SessionShutdownEvent, SessionStartEvent, SessionStopEvent, SessionStopEventResult, SessionSwitchEvent, SessionTreeEvent, TodoReminderEvent, ToolCallEventResult, ToolResultEventResult, TtsrTriggeredEvent, TurnEndEvent, TurnStartEvent } from "../shared-events.js";
 import type { SlashCommandInfo } from "../slash-commands.js";
+export type { OverlayHandle, OverlayOptions } from "@oh-my-pi/pi-tui";
 export type { AppKeybinding, KeybindingsManager } from "../../config/keybindings.js";
 export type { ExecOptions, ExecResult } from "../../exec/exec.js";
 export type { AgentToolResult, AgentToolUpdateCallback };
@@ -129,6 +130,15 @@ export type ExtensionUiComponent = Component & {
 };
 export type ExtensionUiComponentFactory = (tui: TUI, theme: Theme) => ExtensionUiComponent;
 export type ExtensionWidgetContent = string[] | ExtensionUiComponentFactory | undefined;
+/** Options for `ExtensionUIContext.custom()` (overlay rendering of a custom component). */
+export interface ExtensionCustomOptions {
+    /** Render the component as an overlay over the transcript instead of replacing the editor area. */
+    overlay?: boolean;
+    /** Static or lazily resolved overlay positioning/sizing options forwarded to `showOverlay`. */
+    overlayOptions?: OverlayOptions | (() => OverlayOptions);
+    /** Invoked with the overlay handle once the overlay is created (overlay mode only). */
+    onHandle?: (handle: OverlayHandle) => void;
+}
 /** Wrap the current autocomplete provider with additional behavior (pi-compatible). */
 export type AutocompleteProviderFactory = (current: AutocompleteProvider) => AutocompleteProvider;
 /**
@@ -163,9 +173,7 @@ export interface ExtensionUIContext {
     /** Set the terminal window/tab title. */
     setTitle(title: string): void;
     /** Show a custom component with keyboard focus. */
-    custom<T>(factory: (tui: TUI, theme: Theme, keybindings: KeybindingsManager, done: (result: T) => void) => ExtensionUiComponent | Promise<ExtensionUiComponent>, options?: {
-        overlay?: boolean;
-    }): Promise<T>;
+    custom<T>(factory: (tui: TUI, theme: Theme, keybindings: KeybindingsManager, done: (result: T) => void) => ExtensionUiComponent | Promise<ExtensionUiComponent>, options?: ExtensionCustomOptions): Promise<T>;
     /** Set the text in the core input editor. */
     setEditorText(text: string): void;
     /**
@@ -1003,6 +1011,8 @@ export interface RegisteredTool<TParams extends TSchema = TSchema, TDetails = un
     definition: ToolDefinition<TParams, TDetails>;
     extensionPath: string;
 }
+/** Internal observer invoked when an already-loaded extension registers or replaces a tool. */
+export type ToolRegistrationListener = (toolName: string) => void;
 export interface ExtensionFlag {
     name: string;
     description?: string;
@@ -1119,6 +1129,7 @@ export interface Extension {
     label?: string;
     handlers: Map<string, HandlerFn[]>;
     tools: Map<string, RegisteredTool<any, any>>;
+    toolRegistrationListeners?: Set<ToolRegistrationListener>;
     assistantThinkingRenderers: AssistantThinkingRenderer[];
     messageRenderers: Map<string, MessageRenderer>;
     commands: Map<string, RegisteredCommand>;

package/dist/types/extensibility/plugins/marketplace/manager.d.ts

@@ -36,7 +36,10 @@ export declare class MarketplaceManager {
         force?: boolean;
         scope?: "user" | "project";
     }): Promise<InstalledPluginEntry>;
-    uninstallPlugin(pluginId: string, scope?: "user" | "project"): Promise<void>;
+    /** Validates and removes a marketplace plugin, or only validates when `dryRun` is set. */
+    uninstallPlugin(pluginId: string, scope?: "user" | "project", options?: {
+        dryRun?: boolean;
+    }): Promise<void>;
     listInstalledPlugins(): Promise<InstalledPluginSummary[]>;
     setPluginEnabled(pluginId: string, enabled: boolean, scope?: "user" | "project"): Promise<void>;
     refreshStaleMarketplaces(): Promise<void>;

package/dist/types/lib/xai-http.d.ts

@@ -4,7 +4,6 @@ interface XAICredentials {
     apiKey: string;
     baseURL: string;
 }
-export declare function ohMyPiXAIUserAgent(): string;
 /** xAI provider ids supported by shared HTTP tool transport resolution. */
 export type XAIHttpProvider = "xai-oauth" | "xai";
 /** Resolved endpoint and configured headers for an xAI HTTP tool request. */

package/dist/types/mcp/tool-bridge.d.ts

@@ -35,6 +35,13 @@ export interface MCPToolDetails {
     meta?: OutputMeta;
 }
 export declare function createMCPToolName(serverName: string, toolName: string): string;
+export interface MCPToolOriginSource {
+    readonly name: string;
+    readonly mcpServerName?: unknown;
+    readonly mcpToolName?: unknown;
+}
+/** Stable identity for a tool's original MCP route, before its public name was normalized. */
+export declare function getMCPToolOriginKey(tool: MCPToolOriginSource): string | undefined;
 /**
  * Keeps one MCP tool per minted name and logs collisions between distinct MCP
  * origins. The winner is chosen by a stable origin key (server name + original
@@ -43,11 +50,7 @@ export declare function createMCPToolName(serverName: string, toolName: string):
  * silently flip ownership of the minted name. Non-MCP tools pass through
  * unchanged.
  */
-export declare function deduplicateMCPToolsByName<T extends {
-    name: string;
-    mcpServerName?: unknown;
-    mcpToolName?: unknown;
-}>(tools: readonly T[]): T[];
+export declare function deduplicateMCPToolsByName<T extends MCPToolOriginSource>(tools: readonly T[]): T[];
 /**
  * Parse an MCP tool name back to server and tool components.
  *

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

@@ -21,7 +21,12 @@ export declare function formatRoleBadge(role: string, settings: Settings): strin
 /**
  * Resolved model + reasoning level for a hub row. Exact executor progress is
  * authoritative (and survives completion); direct live sessions are the
- * fallback for agents without an observer snapshot.
+ * fallback for agents without an observer snapshot — the main session has no
+ * snapshot at all, so its row is read straight off the live session.
+ *
+ * Every source reports the model that produced the row's work, never the one
+ * the session merely points at: an armed fallback that has not served yet stays
+ * attributed to whichever model last actually spoke.
  */
 export declare function modelBadge(ref: AgentRef, observed: ObservableSession | undefined): string | undefined;
 export declare function formatMetricDuration(metrics: AgentMetrics): string | undefined;

package/dist/types/modes/components/status-line/types.d.ts

@@ -137,6 +137,10 @@ export interface SegmentContext {
             percent: number;
             resetHours?: number;
         };
+        monthly?: {
+            percent: number;
+            resetHours?: number;
+        };
     } | null;
 }
 export interface RenderedSegment {

package/dist/types/modes/controllers/extension-ui-controller.d.ts

@@ -1,6 +1,6 @@
 import type { Component, TUI } from "@oh-my-pi/pi-tui";
 import { KeybindingsManager } from "../../config/keybindings.js";
-import type { ExtensionAskDialogQuestion, ExtensionAskDialogResult, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions/index.js";
+import type { ExtensionAskDialogQuestion, ExtensionAskDialogResult, ExtensionCustomOptions, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions/index.js";
 import { type HookSelectorSlider } from "../../modes/components/hook-selector.js";
 import { type Theme } from "../../modes/theme/theme.js";
 import type { InteractiveModeContext, InteractiveSelectorDialogOptions } from "../../modes/types.js";
@@ -84,9 +84,7 @@ export declare class ExtensionUiController {
         dispose?(): void;
     }) | Promise<Component & {
         dispose?(): void;
-    }>, options?: {
-        overlay?: boolean;
-    }): Promise<T>;
+    }>, options?: ExtensionCustomOptions): Promise<T>;
     /**
      * Show an extension error in the UI.
      */

package/dist/types/modes/interactive-mode.d.ts

@@ -7,7 +7,7 @@ import type { CollabGuestLink } from "../collab/guest.js";
 import type { CollabHost } from "../collab/host.js";
 import { KeybindingsManager } from "../config/keybindings.js";
 import { Settings } from "../config/settings.js";
-import type { AutocompleteProviderFactory, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions/index.js";
+import type { AutocompleteProviderFactory, ExtensionCustomOptions, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions/index.js";
 import type { CompactOptions } from "../extensibility/extensions/types.js";
 import type { Skill } from "../extensibility/skills.js";
 import type { MCPManager } from "../mcp/index.js";
@@ -94,6 +94,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     omfgContainer: Container;
     errorBannerContainer: Container;
     modelCycleContainer: Container;
+    deferredCommandContainer: Container;
     editor: CustomEditor;
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
@@ -224,6 +225,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
         customType?: string;
         display?: boolean;
         streamingBehavior?: "steer" | "followUp";
+    }, options?: {
+        preserveDraft?: boolean;
     }): SubmittedUserInput;
     cancelPendingSubmission(): boolean;
     markPendingSubmissionStarted(input: SubmittedUserInput): boolean;
@@ -257,7 +260,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }, extra?: {
         slider?: HookSelectorSlider;
     }): Promise<string | undefined>;
-    handlePlanModeCommand(initialPrompt?: string): Promise<void>;
+    handlePlanModeCommand(initialPrompt?: string, input?: Pick<SubmittedUserInput, "images" | "imageLinks">): Promise<boolean>;
     /**
      * `/vibe` toggle. Entering installs the ephemeral vibe tools, strips the
      * active toolset down to `read`, optional parent-owned `todo`, plus those
@@ -265,9 +268,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
      * the previous toolset, and kills every worker session so workers cannot
      * outlive the mode that directs them.
      */
-    handleVibeModeCommand(initialPrompt?: string): Promise<void>;
-    handleGoalModeCommand(rest?: string): Promise<void>;
-    handleGuidedGoalCommand(rest?: string): Promise<void>;
+    handleVibeModeCommand(initialPrompt?: string, input?: Pick<SubmittedUserInput, "images" | "imageLinks">): Promise<boolean>;
+    handleGoalModeCommand(rest?: string, input?: Pick<SubmittedUserInput, "images" | "imageLinks">): Promise<boolean>;
+    handleGuidedGoalCommand(rest?: string, input?: Pick<SubmittedUserInput, "images" | "imageLinks">): Promise<boolean>;
     /** Manually (re-)open the plan-review overlay — bound to `/plan-review`. Lets
      *  the operator pull the review back up after dismissing it, or review a plan
      *  the agent wrote without dispatching approval. There is no fixed plan filename:
@@ -291,6 +294,14 @@ export declare class InteractiveMode implements InteractiveModeContext {
      * flushed there. That is preferred over leaving it queued behind a command
      * the user runs during the pause, which mounts immediately and would put the
      * older panel out of order.
+     *
+     * The deferral is acknowledged in {@link deferredCommandContainer}, an
+     * anchored container above the editor. Nothing is mounted into the
+     * transcript: a mid-turn transcript mount re-renders rows below the growing
+     * live block and duplicates them in native scrollback (issues #4806/#6767),
+     * which is why the earlier `showStatus` acknowledgment was reverted. An
+     * anchored container is cleared and rebuilt in place, so it costs no
+     * scrollback rows — the same reason the ctrl+p role-cycle track lives there.
      */
     presentCommandOutput(content: Component | readonly Component[]): void;
     /** Mount every command panel queued for the current session while the agent was streaming. */
@@ -440,9 +451,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
         dispose?(): void;
     }) | Promise<Component & {
         dispose?(): void;
-    }>, options?: {
-        overlay?: boolean;
-    }): Promise<T>;
+    }>, options?: ExtensionCustomOptions): Promise<T>;
     showExtensionError(extensionPath: string, error: string): void;
     showToolError(toolName: string, error: string): void;
 }

package/dist/types/modes/types.d.ts

@@ -6,7 +6,7 @@ import type { CollabGuestLink } from "../collab/guest.js";
 import type { CollabHost } from "../collab/host.js";
 import type { KeybindingsManager } from "../config/keybindings.js";
 import type { Settings } from "../config/settings.js";
-import type { AutocompleteProviderFactory, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions/index.js";
+import type { AutocompleteProviderFactory, ExtensionCustomOptions, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions/index.js";
 import type { CompactOptions } from "../extensibility/extensions/types.js";
 import type { Skill } from "../extensibility/skills.js";
 import type { MCPManager } from "../mcp/index.js";
@@ -96,6 +96,7 @@ export interface InteractiveModeContext {
     omfgContainer: Container;
     errorBannerContainer: Container;
     modelCycleContainer: Container;
+    deferredCommandContainer: Container;
     editor: CustomEditor;
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
@@ -401,12 +402,10 @@ export interface InteractiveModeContext {
     toggleToolOutputExpansion(): void;
     setToolsExpanded(expanded: boolean): void;
     toggleThinkingBlockVisibility(): void;
-    openExternalEditor(): void;
-    registerExtensionShortcuts(): void;
-    handlePlanModeCommand(initialPrompt?: string): Promise<void>;
-    handleVibeModeCommand(initialPrompt?: string): Promise<void>;
-    handleGoalModeCommand(rest?: string): Promise<void>;
-    handleGuidedGoalCommand(rest?: string): Promise<void>;
+    handlePlanModeCommand(initialPrompt?: string, input?: Pick<SubmittedUserInput, "images" | "imageLinks">): Promise<boolean>;
+    handleVibeModeCommand(initialPrompt?: string, input?: Pick<SubmittedUserInput, "images" | "imageLinks">): Promise<boolean>;
+    handleGoalModeCommand(rest?: string, input?: Pick<SubmittedUserInput, "images" | "imageLinks">): Promise<boolean>;
+    handleGuidedGoalCommand(rest?: string, input?: Pick<SubmittedUserInput, "images" | "imageLinks">): Promise<boolean>;
     handleLoopCommand(args?: string): Promise<string | undefined>;
     setLoopPrompt(prompt: string): void;
     disableLoopMode(): void;
@@ -437,9 +436,7 @@ export interface InteractiveModeContext {
         dispose?(): void;
     }) | Promise<Component & {
         dispose?(): void;
-    }>, options?: {
-        overlay?: boolean;
-    }): Promise<T>;
+    }>, options?: ExtensionCustomOptions): Promise<T>;
     showExtensionError(extensionPath: string, error: string): void;
     showToolError(toolName: string, error: string): void;
 }

package/dist/types/modes/utils/hotkeys-markdown.d.ts

@@ -1,4 +1,4 @@
-import type { KeybindingsManager } from "../../config/keybindings.js";
+import { type KeybindingsManager } from "../../config/keybindings.js";
 export interface HotkeysMarkdownBindings {
     keybindings: Pick<KeybindingsManager, "getDisplayString">;
 }

package/dist/types/session/agent-session-types.d.ts

@@ -148,6 +148,8 @@ export interface AgentSessionConfig {
     createVibeTools?: () => AgentTool[];
     /** Names whose current registry entry is the built-in implementation. */
     builtInToolNames?: Iterable<string>;
+    /** MCP names whose initial registry entries came from the manager snapshot. */
+    mcpManagerToolNames?: Iterable<string>;
     /** Updates tool-session predicates from the live active tool set. */
     setActiveToolNames?: (names: Iterable<string>) => void;
     /** Registers the write transport when runtime xdev mounts first need it. */

package/dist/types/session/agent-session.d.ts

@@ -53,6 +53,7 @@ import type { AgentSessionEventListener } from "./agent-session-events.js";
 import type { AgentSessionConfig, AgentSessionDisposeOptions, AsyncJobSnapshot, CommandMetadataChangedListener, ContextUsageBreakdown, FollowUpOptions, FreshSessionResult, HandoffResult, ModelCycleResult, Prewalk, PromptOptions, ResetSessionContextResult, ResolvedRoleModel, RestoredQueuedMessage, RoleModelCycle, RoleModelCycleResult, SessionHandoffOptions, SessionOAuthAccountList, SessionStats, UsageFallbackConfirmer } from "./agent-session-types.js";
 import type { ClientBridge } from "./client-bridge.js";
 import { type CustomMessage, type CustomMessagePayload } from "./messages.js";
+import type { ServingModel } from "./retry-fallback-chains.js";
 import { type AdvisorStats } from "./session-advisors.js";
 import type { BuildSessionContextOptions, SessionContext } from "./session-context.js";
 import type { BranchSummaryEntry, NewSessionOptions } from "./session-entries.js";
@@ -225,8 +226,12 @@ export declare class AgentSession {
     get state(): AgentState;
     /** Current model (may be undefined if not yet selected) */
     get model(): Model | undefined;
-    /** Resolved selector while retry routing is using a fallback model. */
-    get retryFallbackModel(): string | undefined;
+    /**
+     * Model this session's produced work is attributed to. Holds the last model
+     * that actually served while a fallback is armed but unproven, so observers
+     * never credit a run to a candidate that produced nothing.
+     */
+    get servingModel(): ServingModel | undefined;
     /** Install the interactive decision surface for reserve-triggered model changes. */
     setUsageFallbackConfirmer(confirmer: UsageFallbackConfirmer | undefined): void;
     /** Effective thinking level applied to the agent (the resolved level when `auto`). */
@@ -283,6 +288,20 @@ export declare class AgentSession {
     getToolByName(name: string): AgentTool | undefined;
     /** Whether a registry entry came from a built-in factory. */
     hasBuiltInTool(name: string): boolean;
+    /** Updates source provenance when a live registry entry is replaced or restored. */
+    setToolBuiltIn(name: string, builtIn: boolean): void;
+    /** Whether the live registry entry is owned by the RPC host. */
+    hasRpcHostTool(name: string): boolean;
+    /** Whether the current MCP entry came from the manager snapshot. */
+    hasMCPManagerTool(name: string): boolean;
+    /** Restores manager ownership after a lifecycle registration rollback. */
+    setMCPManagerTool(name: string, managerOwned: boolean): void;
+    /** Current extension-owned MCP entry retained across manager refreshes. */
+    getExtensionMCPTool(name: string): AgentTool | undefined;
+    /** Updates extension MCP ownership after a lifecycle registration commit or rollback. */
+    setExtensionMCPTool(name: string, tool: AgentTool | undefined): void;
+    /** Runs a registry/presentation mutation in this session's shared queue. */
+    runToolRegistryMutation<T>(mutation: () => Promise<T>, signal?: AbortSignal): Promise<T>;
     /** Names of every registered tool. */
     getAllToolNames(): string[];
     /** Full metadata for every registered tool, including source provenance (backs `getAllTools()`). */
@@ -300,7 +319,7 @@ export declare class AgentSession {
     /** Selects enabled tools, ignoring names absent from the registry. */
     setActiveToolsByName(toolNames: string[]): Promise<void>;
     /** Restores an exact top-level versus `xd://` tool partition. */
-    setActiveToolPresentation(toolNames: string[], mountedToolNames: string[]): Promise<void>;
+    setActiveToolPresentation(toolNames: string[], mountedToolNames: string[], forcePromptRefresh?: boolean, signal?: AbortSignal): Promise<void>;
     /**
      * Session-scoped enable/disable for the settings-gated `computer` tool.
      *

package/dist/types/session/messages.d.ts

@@ -120,6 +120,26 @@ export declare function shouldRenderAbortReason(message: Pick<AssistantMessage,
  *  the error is surfaced live (pinned) instead. A turn that streamed partial text,
  *  reasoning, or tool calls is NOT empty and stays in history. */
 export declare function isEmptyErrorTurn(message: Pick<AssistantMessage, "stopReason" | "content">): boolean;
+/** A `stop`/`toolUse` turn that produced nothing actionable. Any other stop
+ *  reason is not an "empty stop": an `error`/`aborted` turn is a failure rather
+ *  than an empty completion, and a `length` stop was cut off mid-output. */
+export declare function isEmptyAssistantStop(message: Pick<AssistantMessage, "stopReason" | "content">): boolean;
+/**
+ * True when this assistant turn actually produced output, making its model the
+ * one that served the run.
+ *
+ * Attribution asks this from two places that MUST reach the same verdict: the
+ * live session, which flips a fallback to "served", and the offline walk
+ * replaying a transcript. `error` and `aborted` are both failures — a stalled or
+ * dropped stream is finalized as `aborted` with its partial block still
+ * attached, so a stop reason alone is not proof.
+ *
+ * Actionable content is required on top of the empty-stop rule, which only
+ * inspects `stop`/`toolUse`. A `length` stop burns the whole output budget
+ * without necessarily emitting anything usable, and every other stop reason
+ * bypasses that rule entirely.
+ */
+export declare function assistantTurnProducedOutput(message: Pick<AssistantMessage, "stopReason" | "content">): boolean;
 /** Sentinel `errorMessage` the agent stamps on any abort that carried no custom
  *  reason (bare `abort()`). Renderers treat it as "no specific reason given". */
 export declare const GENERIC_ABORT_SENTINEL = "Request was aborted";