@oh-my-pi/pi-coding-agent 17.1.5 → 17.1.7

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

@@ -11,7 +11,7 @@ export declare function registerProvider<T>(capabilityId: string, provider: Prov
 /**
  * Load a capability by ID.
  */
-export declare function loadCapability<T>(capabilityId: string, options?: LoadOptions): Promise<CapabilityResult<T>>;
+export declare function loadCapability<T>(capabilityId: string, options?: LoadOptions<T>): Promise<CapabilityResult<T>>;
 /**
  * Initialize capability system with settings manager for persistence.
  * Call this once on startup to enable persistent provider state.

package/dist/types/capability/types.d.ts

@@ -51,7 +51,7 @@ export interface Provider<T> {
 /**
  * Options for loading a capability.
  */
-export interface LoadOptions {
+export interface LoadOptions<T = unknown> {
     /** Only use these providers (by ID). Default: all registered */
     providers?: string[];
     /** Exclude these providers (by ID). Default: none */
@@ -64,6 +64,26 @@ export interface LoadOptions {
     includeDisabled?: boolean;
     /** Explicit disabled extension IDs to apply instead of settings. */
     disabledExtensions?: string[];
+    /**
+     * Drop items before deduplication as if they never existed (e.g. scope
+     * exclusions). A dropped item neither survives nor claims its dedupe key,
+     * so it cannot shadow anything. Receives the item with its attached
+     * `_source`.
+     */
+    filter?(item: T & {
+        _source: SourceMeta;
+    }): boolean;
+    /**
+     * Exclude items from the results while letting them claim their dedupe key.
+     * A suppressed higher-priority item still shadows same-key lower-priority
+     * items (a disabled project server keeps the same-named user server off),
+     * but never equivalence-shadows a differently-keyed survivor — so a
+     * suppressed alias cannot starve an enabled equivalent connection.
+     * Return `true` to suppress. Receives the item with its attached `_source`.
+     */
+    suppress?(item: T & {
+        _source: SourceMeta;
+    }): boolean;
 }
 /**
  * Source metadata attached to every loaded item.
@@ -112,6 +132,8 @@ export interface Capability<T> {
      * Return undefined to never deduplicate (all items kept).
      */
     key(item: T): string | undefined;
+    /** Treat items with different keys as aliases; the first equivalent item wins. */
+    equivalent?(left: T, right: T): boolean;
     /**
      * Optional validation. Return error message if invalid, undefined if valid.
      */

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

@@ -846,7 +846,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "appearance";
             readonly group: "Display";
             readonly label: "Terminal Title Run State";
-            readonly description: "Show the agent run state in the terminal title's separator — an animated spinner while working, '>' when it's your turn, '!' when the agent is waiting on you";
+            readonly description: "Show the agent run state in the terminal title's separator — an animated spinner while working (a static ':' on Windows), '>' when it's your turn, '!' when the agent is waiting on you";
         };
     };
     readonly "tui.hyperlinks": {
@@ -3941,11 +3941,26 @@ export declare const SETTINGS_SCHEMA: {
     readonly "inspect_image.enabled": {
         readonly type: "boolean";
         readonly default: false;
+    };
+    readonly "inspect_image.mode": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "on", "off"];
+        readonly default: "auto";
         readonly ui: {
             readonly tab: "tools";
             readonly group: "Available Tools";
             readonly label: "Inspect Image";
-            readonly description: "Enable the inspect_image tool, delegating image understanding to a vision-capable model";
+            readonly description: "Controls the inspect_image tool, which delegates image understanding to a vision-capable model. 'auto' exposes it only when the active model lacks native image input; 'on' always exposes it; 'off' never does.";
+            readonly options: readonly [{
+                readonly value: "auto";
+                readonly label: "Auto (only for models without vision)";
+            }, {
+                readonly value: "on";
+                readonly label: "On";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+            }];
         };
     };
     readonly "computer.enabled": {
@@ -4577,6 +4592,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Switch the task tool to its batch shape: one call carries { context, tasks[] } — one subagent per item, with an optional per-item agent (defaulting to the session spawn-policy agent), per-item isolation, and a required shared context prepended to every assignment. With async.enabled=true, each spawn runs as an independent background agent with the normal idle/parked lifecycle; otherwise the call blocks for merged results. Disable to restore the flat single-spawn schema.";
         };
     };
+    readonly "task.enableEffort": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly group: "Subagents";
+            readonly label: "Per-Task Effort";
+            readonly description: "Expose the optional effort parameter on task spawns, allowing callers to override each subagent's thinking level";
+        };
+    };
     readonly "task.maxConcurrency": {
         readonly type: "number";
         readonly default: 32;
@@ -4719,6 +4744,18 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Inject one steering notice when a subagent crosses its soft request budget, asking it to wrap up before the 1.5x forced-yield stop.";
         };
     };
+    readonly "task.maxEffort": {
+        readonly type: "enum";
+        readonly values: readonly import("@oh-my-pi/pi-catalog").Effort[];
+        readonly default: "max";
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly group: "Subagents";
+            readonly label: "Maximum Per-Spawn Effort";
+            readonly description: "Maximum reasoning effort allowed for the task tool's per-spawn effort hint. Lower values prevent callers from escalating subagents above this ceiling; the default preserves the model's full range.";
+            readonly options: import("../thinking.js").ThinkingLevelMetadata[];
+        };
+    };
     readonly "task.disabledAgents": {
         readonly type: "array";
         readonly default: string[];

package/dist/types/cursor.d.ts

@@ -5,7 +5,8 @@ interface CursorExecBridgeOptions {
     cwd: string;
     getCwd?: () => string;
     tools: Map<string, AgentTool>;
-    getTool?: (name: string) => AgentTool | undefined;
+    /** Resolves execution overrides (mounted-device permission wrappers) before the canonical map. */
+    getExecutableTool?: (name: string) => AgentTool | undefined;
     getToolContext?: () => AgentToolContext | undefined;
     emitEvent?: (event: AgentEvent) => void;
     /**

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

@@ -69,6 +69,10 @@ export declare class ExtensionRunner {
     private readonly modelRegistry;
     private readonly settings?;
     private readonly localProtocolOptions?;
+    /** Records that the loop already emitted `tool_call` for this dispatch. */
+    markToolCallEmitted(toolCallId: string, toolName: string): void;
+    /** Consumes a {@link markToolCallEmitted} marker; true when the loop already emitted. */
+    consumeToolCallEmitted(toolCallId: string, toolName: string): boolean;
     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;
     /**

package/dist/types/extensibility/shared-events.d.ts

@@ -228,13 +228,30 @@ export interface TodoReminderEvent {
 }
 /**
  * Return type for `tool_call` handlers.
- * Allows handlers to block tool execution.
+ * Allows handlers to block tool execution or revise the input the tool runs with.
  */
 export interface ToolCallEventResult {
     /** If true, block the tool from executing */
     block?: boolean;
     /** Reason for blocking (returned to LLM as error) */
     reason?: string;
+    /**
+     * Replacement input the tool executes with, instead of the original arguments. Ignored when
+     * `block` is true. This is the raw execution input passed to the tool's `execute` (the handler
+     * owns its correctness) — not the normalized `event.input` view, which may carry derived
+     * gate-only fields (e.g. hashline `edit` `path`/`paths`) that are not real parameters. When
+     * multiple handlers set `input`, the last one wins; handlers do not observe each other's
+     * revisions (each sees the original `event.input`). Not applied to `computer` tool calls.
+     *
+     * For model-issued tool calls the event fires at arg-prep time in the agent loop, before
+     * concurrency scheduling, `tool_execution_start`, and the approval gate: the revision is
+     * revalidated against the tool schema and becomes what the loop schedules, displays, persists,
+     * and executes — the user always approves what actually runs. For dispatches the loop never
+     * sees (nested `write xd://` device calls, Cursor direct execution) the tool wrapper applies
+     * the revision before its own approval gate; a revised nested xd:// input forfeits the outer
+     * write gate's approval and faces the full prompt again.
+     */
+    input?: Record<string, unknown>;
 }
 /**
  * Return type for `tool_result` handlers.

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

@@ -1,9 +1,10 @@
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types.js";
 /**
- * Protocol handler for mcp:// URLs.
+ * Protocol handler for MCP resources.
  *
- * URL form:
+ * URL forms:
  * - mcp://<resource-uri> (e.g. mcp://test://notes, mcp://ibkr://portfolio/positions)
+ * - A resource's native URI when its scheme has no OMP handler (e.g. ags://capabilities/current-host)
  */
 export declare class McpProtocolHandler implements ProtocolHandler {
     readonly scheme = "mcp";

package/dist/types/internal-urls/parse.d.ts

@@ -10,6 +10,18 @@
  * MUST use this function instead of calling `new URL()` directly.
  */
 import type { InternalUrl } from "./types.js";
+/**
+ * Extract the lowercased scheme from a URI-shaped input, or `undefined` when
+ * the input does not look like a URI.
+ *
+ * Accepts both hierarchical (`scheme://…`) and opaque (`scheme:rest`) forms —
+ * MCP resource URIs may be opaque (`urn:example:document`, `custom:item`).
+ * The opaque form is guarded against path-like false positives:
+ * - Windows drive paths (`C:\…`, `C:/…`, `C:foo`) — single-letter scheme.
+ * - Filenames with extensions (`foo.ts:50`) — dot in the scheme segment.
+ * - Read-tool selector tails (`Makefile:12`, `README:raw:1-20`).
+ */
+export declare function extractUriScheme(input: string): string | undefined;
 /**
  * Parse an internal URL into an InternalUrl.
  *

package/dist/types/internal-urls/router.d.ts

@@ -10,6 +10,12 @@ export declare class InternalUrlRouter {
     unregister(scheme: string): boolean;
     getHandler(scheme: string): ProtocolHandler | undefined;
     canHandle(input: string): boolean;
+    /**
+     * Whether read can resolve this URL through either a native handler or the
+     * MCP resource fallback. MCP resources may use arbitrary custom schemes and
+     * may be opaque (`urn:example:document`) rather than hierarchical.
+     */
+    canResolve(input: string): boolean;
     /** Schemes whose handler supports host/path autocomplete. */
     completionSchemes(): string[];
     /**

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

@@ -66,6 +66,12 @@ export interface InternalUrl extends URL {
      * Raw pathname extracted from input, preserving traversal markers before URL normalization.
      */
     rawPathname?: string;
+    /**
+     * Exact input string this URL was parsed from, before any normalization.
+     * Set by `parseInternalUrl`; used where byte-exact URI matching matters
+     * (e.g. MCP resource URIs compared by string equality).
+     */
+    rawHref?: string;
 }
 /**
  * Caller-supplied context that the router threads into protocol handlers.

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

@@ -52,6 +52,7 @@ export declare function resolveCommand(command: string, cwd: string, options?: R
  *       "command": "/path/to/server",
  *       "args": ["--stdio"],
  *       "fileTypes": [".xyz"],
+ *       "languageId": "xyz",
  *       "rootMarkers": [".xyz-project"]
  *     }
  *   }

package/dist/types/lsp/types.d.ts

@@ -200,6 +200,8 @@ export interface ServerConfig {
     command: string;
     args?: string[];
     fileTypes: string[];
+    /** LSP language identifier sent in didOpen; inferred from the file path when omitted. */
+    languageId?: string;
     rootMarkers: string[];
     initOptions?: Record<string, unknown>;
     settings?: Record<string, unknown>;

package/dist/types/mcp/manager.d.ts

@@ -174,6 +174,11 @@ export declare class MCPManager {
      * Refresh resources from a specific server.
      */
     refreshServerResources(name: string): Promise<void>;
+    /**
+     * Wait until a connected server's resource catalog has been loaded.
+     * Coalesces with initial loading and notification-driven refreshes.
+     */
+    ensureServerResources(name: string): Promise<void>;
     /**
      * Refresh prompts from a specific server.
      */

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

@@ -35,6 +35,19 @@ export interface MCPToolDetails {
     meta?: OutputMeta;
 }
 export declare function createMCPToolName(serverName: string, toolName: string): string;
+/**
+ * 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
+ * tool name), NOT array order: MCPManager re-appends a reconnecting server's
+ * tools, so insertion order is mutable across reconnects and first-wins would
+ * 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[];
 /**
  * Parse an MCP tool name back to server and tool components.
  *

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

@@ -103,6 +103,11 @@ export declare class CustomEditor extends Editor {
      *  reset the editor text and all pending draft-image state. The shared tail of
      *  every "message submitted" path; pass no argument for a plain discard. */
     clearDraft(historyText?: string): void;
+    /** Replace the composer draft with a restored historical prompt: sets the text and
+     *  re-attaches the message's images so positional `[Image #N]` markers resolve on
+     *  resubmit instead of degrading to literal text (esc-esc branch, `/tree`). Source
+     *  links are unknown for restored drafts, so every link slot is `undefined`. */
+    setDraft(text: string, images?: readonly ImageContent[]): void;
     /** Treat image/paste markers as indivisible: a stray backspace deletes the whole token
      *  instead of corrupting `[Paste #1, +30 lines]` into plain text. */
     atomicTokenPattern: RegExp;

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

@@ -54,7 +54,7 @@ export declare class ExtensionUiController {
     /**
      * Show a confirmation dialog for hooks.
      */
-    showHookConfirm(title: string, message: string): Promise<boolean>;
+    showHookConfirm(title: string, message: string, dialogOptions?: ExtensionUIDialogOptions): Promise<boolean>;
     /**
      * Show a text input for hooks.
      */

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

@@ -158,6 +158,8 @@ export declare function handleRpcSessionChange(session: RpcSessionChangeSession,
 export declare function requestRpcEditor(pendingRequests: Map<string, PendingExtensionRequest>, output: RpcOutput, title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
     promptStyle?: boolean;
 }): Promise<string | undefined>;
+/** Sends an RPC extension dialog and cancels the remote presentation when its signal aborts. */
+export declare function requestRpcDialog<T>(pendingRequests: Map<string, PendingExtensionRequest>, output: RpcOutput, opts: ExtensionUIDialogOptions | undefined, defaultValue: T, request: Record<string, unknown>, parseResponse: (response: RpcExtensionUIResponse) => T): Promise<T>;
 /**
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.

package/dist/types/sdk.d.ts

@@ -1,5 +1,5 @@
 import { Agent, type AgentOptions, type AgentTelemetryConfig, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
+import type { Effort, Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import { type Rule } from "./capability/rule.js";
 import { ModelRegistry } from "./config/model-registry.js";
@@ -52,6 +52,8 @@ export interface CreateAgentSessionOptions {
     modelPatternDefaultFallbackChain?: string[];
     /** Thinking selector. Default: from settings, else unset */
     thinkingLevel?: ConfiguredThinkingLevel;
+    /** Hard ceiling on the session's thinking effort (e.g. a task spawn's `task.maxEffort`-capped hint); retry-fallback recovery re-clamps to it. */
+    thinkingLevelCeiling?: Effort;
     /** Models available for cycling (Ctrl+P in interactive mode) */
     scopedModels?: Array<{
         model: Model;

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

@@ -1,5 +1,5 @@
 import type { Agent, AgentMessage, AgentTool, StreamFn, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Context, ImageContent, Message, MessageAttribution, Model, OAuthAccountSummary, ServiceTierByFamily, SimpleStreamOptions, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { Context, Effort, ImageContent, Message, MessageAttribution, Model, OAuthAccountSummary, ServiceTierByFamily, SimpleStreamOptions, ToolChoice } from "@oh-my-pi/pi-ai";
 import type { postmortem } from "@oh-my-pi/pi-utils";
 import type { AdvisorConfig } from "../advisor/index.js";
 import type { AsyncJob, AsyncJobDeliveryState, AsyncJobManager } from "../async/index.js";
@@ -15,7 +15,7 @@ import type { Skill, SkillWarning } from "../extensibility/skills.js";
 import type { FileSlashCommand } from "../extensibility/slash-commands.js";
 import type { SecretObfuscator } from "../secrets/obfuscator.js";
 import type { ConfiguredThinkingLevel } from "../thinking.js";
-import type { XdevRegistry } from "../tools/xdev.js";
+import type { XdevState } from "../tools/xdev.js";
 import type { SessionManager } from "./session-manager.js";
 /** Maximum time the interactive shutdown path waits for Mnemopi consolidation. */
 export declare const SHUTDOWN_CONSOLIDATE_BUDGET_MS = 1500;
@@ -88,6 +88,8 @@ export interface AgentSessionConfig {
     }>;
     /** Initial session thinking selector. */
     thinkingLevel?: ConfiguredThinkingLevel;
+    /** Hard ceiling on the session's thinking effort (e.g. a task spawn's `task.maxEffort`-capped hint); every later change, including retry-fallback recovery, is re-clamped to it. */
+    thinkingLevelCeiling?: Effort;
     /** Retry chain ownership when startup selected one of its fallback entries. */
     initialRetryFallback?: InitialRetryFallbackState;
     /** Prewalk from the starting model to a fast/cheap target after implementation begins. */
@@ -119,6 +121,8 @@ export interface AgentSessionConfig {
     createMemoryTools?: () => Promise<AgentTool[]>;
     /** Creates the built-in `computer` tool for session-scoped runtime enablement (see {@link AgentSession.setComputerToolEnabled}). */
     createComputerTool?: () => Promise<AgentTool | null>;
+    /** Creates the built-in `inspect_image` tool for session-scoped runtime enablement (see {@link AgentSession.setInspectImageMode}). */
+    createInspectImageTool?: () => Promise<AgentTool | null>;
     /** Model registry for API key resolution and model discovery. */
     modelRegistry: ModelRegistry;
     /** Tool registry for LSP and settings. */
@@ -162,10 +166,8 @@ export interface AgentSessionConfig {
         name: string;
         summary: string;
     }>;
-    /** Session-owned `xd://` registry. */
-    xdevRegistry?: XdevRegistry;
-    /** Discoverable tools mounted under `xd://` in the initial enabled set. */
-    initialMountedXdevToolNames?: string[];
+    /** `xd://` presentation state backed by the canonical tool map. */
+    xdev?: XdevState;
     /** Names pinned top-level during runtime repartitioning. */
     presentationPinnedToolNames?: ReadonlySet<string>;
     /** Accessor for live MCP server instructions. */

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

@@ -46,6 +46,7 @@ import { type AskToolDetails, type AskToolInput } from "../tools/ask.js";
 import type { CheckpointState, CompletedRewindState } from "../tools/checkpoint.js";
 import { type PlanProposalHandler } from "../tools/resolve.js";
 import type { TodoPhase } from "../tools/todo.js";
+import type { InspectImageMode } from "../utils/inspect-image-mode.js";
 import type { VibeModeState } from "../vibe/state.js";
 import type { AgentSessionEventListener } from "./agent-session-events.js";
 import type { AgentSessionConfig, AgentSessionDisposeOptions, AsyncJobSnapshot, CommandMetadataChangedListener, ContextUsageBreakdown, FollowUpOptions, FreshSessionResult, HandoffResult, ModelCycleResult, Prewalk, PromptOptions, ResolvedRoleModel, RestoredQueuedMessage, RoleModelCycle, RoleModelCycleResult, SessionHandoffOptions, SessionOAuthAccountList, SessionStats, UsageFallbackConfirmation } from "./agent-session-types.js";
@@ -283,6 +284,26 @@ export declare class AgentSession {
      * tool (e.g. restricted child sessions have no factory).
      */
     setComputerToolEnabled(enabled: boolean): Promise<boolean>;
+    /**
+     * Session-scoped inspect_image mode (`/vision`). `auto` clears the override
+     * and returns to the persisted `inspect_image.mode` setting; `on`/`off`
+     * force the tool for this session only. See {@link SessionTools.setInspectImageMode}.
+     */
+    setInspectImageMode(mode: InspectImageMode): Promise<boolean>;
+    /** Effective inspect_image state for `/vision status`. */
+    inspectImageState(): {
+        mode: InspectImageMode;
+        active: boolean;
+        model: string | undefined;
+    };
+    /** Session-scoped `/vision` override; undefined means "follow the persisted setting". */
+    getInspectImageModeOverride(): InspectImageMode | undefined;
+    /**
+     * Reconciles the inspect_image tool set after the persisted
+     * `inspect_image.mode` setting changed (e.g. via the settings selector), so
+     * the new value takes effect immediately instead of on the next model switch.
+     */
+    applyInspectImageModeChange(): Promise<boolean>;
     /** Cancels the local rollout-memory startup owned by this session. */
     cancelLocalMemoryStartup(): void;
     /** Starts a new local rollout-memory generation and cancels its predecessor. */
@@ -766,10 +787,12 @@ export declare class AgentSession {
      * @param entryId ID of the entry to branch from
      * @returns Object with:
      *   - selectedText: The text of the selected user message (for editor pre-fill)
+     *   - selectedImages: Image attachments of the selected user message (for editor draft restore)
      *   - cancelled: True if a hook cancelled the branch
      */
     branch(entryId: string): Promise<{
         selectedText: string;
+        selectedImages: ImageContent[];
         cancelled: boolean;
     }>;
     branchFromBtw(question: string, assistantMessage: AssistantMessage): Promise<{
@@ -783,7 +806,7 @@ export declare class AgentSession {
      * @param targetId The entry ID to navigate to
      * @param options.summarize Whether user wants to summarize abandoned branch
      * @param options.customInstructions Custom instructions for summarizer
-     * @returns Result with editorText (if user message) and cancelled status
+     * @returns Result with editorText/editorImages (if user message) and cancelled status
      */
     navigateTree(targetId: string, options?: {
         summarize?: boolean;
@@ -810,6 +833,8 @@ export declare class AgentSession {
         reanswerAskResult?: AgentToolResult<AskToolDetails>;
     }): Promise<{
         editorText?: string;
+        /** Image attachments of the target user message, parallel to the positional `[Image #N]` markers in {@link editorText}. */
+        editorImages?: ImageContent[];
         cancelled: boolean;
         aborted?: boolean;
         summaryEntry?: BranchSummaryEntry;
@@ -1011,6 +1036,8 @@ export declare class AgentSession {
             status: AdvisorRuntimeStatus;
         }[];
     };
+    /** Return cumulative cost recorded for the current session's advisor activity. */
+    getAdvisorCost(): number;
     /**
      * Return structured advisor stats for the status command and TUI panel.
      */

package/dist/types/session/model-controls.d.ts

@@ -21,7 +21,7 @@ export interface ModelControlsHost {
     promptGeneration(): number;
     resolveActiveEditMode(): EditMode;
     syncAfterModelChange(previousEditMode: EditMode): Promise<void>;
-    setModelWithProviderSessionReset(model: Model): void;
+    setModelWithProviderSessionReset(model: Model): Promise<void>;
     clearActiveRetryFallback(): void;
     clearInheritedProviderPromptCacheKey(): void;
     magicKeywordEnabled(keyword: "orchestrate" | "ultrathink" | "workflow"): boolean;
@@ -38,10 +38,13 @@ export declare class ModelControls {
             thinkingLevel?: ThinkingLevel;
         }>;
         thinkingLevel?: ConfiguredThinkingLevel;
+        thinkingLevelCeiling?: Effort;
         serviceTierByFamily?: ServiceTierByFamily;
     });
     /** Effective metadata-clamped thinking level applied to the agent. */
     get thinkingLevel(): ThinkingLevel | undefined;
+    /** Hard per-session effort ceiling every thinking-level change is clamped to. */
+    get thinkingLevelCeiling(): Effort | undefined;
     /** Configured selector, preserving `auto` while classification is active. */
     configuredThinkingLevel(): ConfiguredThinkingLevel | undefined;
     /** Whether per-turn automatic thinking classification is enabled. */

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

@@ -121,7 +121,11 @@ export declare class SessionAdvisors {
     /** Detaches and drains recorder feeds before transcript artifacts are removed. */
     detachAndCloseRecorders(): Promise<void>;
     /** Re-primes advisor transcript views across a conversation boundary. */
-    resetSessionState(): void;
+    resetSessionState(options?: {
+        preserveCost?: boolean;
+    }): void;
+    /** Drop the recorded spend once a conversation boundary has committed. */
+    clearCost(): void;
     /**
      * Rebind every live advisor to the active primary conversation's provider
      * identity (session id, prompt-cache key, credential + metadata resolvers,
@@ -216,6 +220,8 @@ export declare class SessionAdvisors {
             status: AdvisorRuntimeStatus;
         }[];
     };
+    /** Return cumulative advisor cost recorded for the current session. */
+    getAdvisorCost(): number;
     /**
      * Return structured advisor stats for the status command and TUI panel.
      */

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

@@ -7,8 +7,9 @@ import type { ExtensionRunner } from "../extensibility/extensions/index.js";
 import { type Skill, type SkillWarning } from "../extensibility/skills.js";
 import { type LocalProtocolOptions } from "../internal-urls/index.js";
 import type { MemoryBackendStartOptions } from "../memory-backend/types.js";
-import { type XdevRegistry } from "../tools/xdev.js";
+import { type XdevState } from "../tools/xdev.js";
 import { type EditMode } from "../utils/edit-mode.js";
+import { type InspectImageMode } from "../utils/inspect-image-mode.js";
 import type { ClientBridge } from "./client-bridge.js";
 import type { CustomMessage } from "./messages.js";
 import type { SessionManager } from "./session-manager.js";
@@ -33,12 +34,17 @@ export interface SessionToolsHost {
     emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
     notifyCommandMetadataChanged(): void;
     localProtocolOptions(): LocalProtocolOptions;
+    /** Session-scoped `/vision` override; undefined means "follow the persisted setting". */
+    getInspectImageModeOverride(): InspectImageMode | undefined;
+    setInspectImageModeOverride(mode: InspectImageMode | undefined): void;
 }
 interface SessionToolsOptions {
     autoApprove?: boolean;
     toolRegistry?: Map<string, AgentTool>;
     createVibeTools?: () => AgentTool[];
     createComputerTool?: () => Promise<AgentTool | null>;
+    /** Creates the built-in `inspect_image` tool for session-scoped runtime enablement (see {@link SessionTools.setInspectImageMode}). */
+    createInspectImageTool?: () => Promise<AgentTool | null>;
     builtInToolNames?: Iterable<string>;
     presentationPinnedToolNames?: ReadonlySet<string>;
     ensureWriteRegistered?: () => Promise<boolean>;
@@ -47,8 +53,7 @@ interface SessionToolsOptions {
     }>;
     getLocalCalendarDate?: () => string;
     getMcpServerInstructions?: () => Map<string, string> | undefined;
-    xdevRegistry?: XdevRegistry;
-    initialMountedXdevToolNames?: string[];
+    xdev?: XdevState;
     setActiveToolNames?: (names: Iterable<string>) => void;
     baseSystemPrompt: string[];
     skills?: Skill[];
@@ -99,13 +104,13 @@ export declare class SessionTools {
     get skillsSettings(): SkillsSettings | undefined;
     /** Drops cached per-session ACP `allow_always`/`reject_always` decisions. */
     clearAcpPermissionDecisions(): void;
-    /** Re-wraps active and mounted tools after the ACP client changes. */
+    /** Drops cached ACP decisions and re-wraps active tools after the client changes. */
     refreshAcpPermissionGates(): void;
     /** Names of tools currently exposed at the top level. */
     getActiveToolNames(): string[];
     /** Enabled top-level and discoverable tool names. */
     getEnabledToolNames(): string[];
-    /** Names of dynamic tools mounted under `xd://`. */
+    /** Names currently presented as `xd://` devices. */
     getMountedXdevToolNames(): string[];
     /** Whether the edit tool is registered. */
     get hasEditTool(): boolean;
@@ -139,7 +144,7 @@ export declare class SessionTools {
      * Restore an enabled tool set with its exact top-level versus `xd://` partition.
      *
      * Both inputs are required because {@link setActiveToolsByName} only receives the
-     * enabled name list and classifies mounts from the current `#mountedXdevToolNames`.
+     * enabled name list and classifies mounts from the current presentation set.
      * Rollback/restore callers must pass the snapshotted mounted subset so names that
      * were top-level stay pinned (`#runtimeSelectedToolNames`) and names that were under
      * `xd://` remain mount-eligible, even when the live mount set has drifted.
@@ -166,6 +171,39 @@ export declare class SessionTools {
      * tool (e.g. restricted child sessions have no factory).
      */
     setComputerToolEnabled(enabled: boolean): Promise<boolean>;
+    /** Current effective inspect_image state for `/vision status`. */
+    inspectImageState(): {
+        mode: InspectImageMode;
+        active: boolean;
+        model: string | undefined;
+    };
+    /**
+     * Brings the active tool set in line with the effective inspect_image state
+     * (mode setting, `/vision` override, active-model image capability).
+     * Mirrors {@link setComputerToolEnabled}: enabling builds the tool through
+     * the config factory on first use and reuses the registry entry afterwards.
+     * Idempotent — safe to call from every model/settings change path.
+     *
+     * @returns false when the tool should be active but this session cannot
+     *   build it (e.g. restricted child sessions have no factory).
+     */
+    reconcileInspectImageTool(): Promise<boolean>;
+    /**
+     * Reconciles inspect_image after a model change and surfaces a notice when
+     * the visible tool set actually flipped. Called from every model-change
+     * path — including retry-fallback switches that bypass
+     * {@link syncAfterModelChange}.
+     */
+    reconcileInspectImageAfterModelChange(): Promise<void>;
+    /**
+     * Session-scoped `/vision` override. `auto` clears the override so the
+     * persisted `inspect_image.mode` setting (itself possibly `auto`) decides;
+     * `on`/`off` force the tool for this session only. Takes effect before the
+     * next model call.
+     *
+     * @returns false when `on` was requested but the tool cannot be built here.
+     */
+    setInspectImageMode(mode: InspectImageMode): Promise<boolean>;
     /** Rebuilds the stable base prompt for the current tools and model. */
     refreshBaseSystemPrompt(): Promise<void>;
     /** Applies one-turn memory prompt injection before an agent run. */

package/dist/types/session/streaming-output.d.ts

@@ -34,12 +34,17 @@ export interface OutputSummary {
 export interface OutputSinkOptions {
     artifactPath?: string;
     artifactId?: string;
-    /** Tail buffer budget (bytes). Default DEFAULT_MAX_BYTES. */
+    /**
+     * Total inline body budget (bytes). Default DEFAULT_MAX_BYTES. The head
+     * window and rolling tail window share this budget, so a composed
+     * `dump()` body never exceeds it (plus the elision marker).
+     */
     spillThreshold?: number;
     /**
      * When > 0, the sink keeps the first `headBytes` of output in addition to
      * the rolling tail window. Output between the two windows is elided
-     * (middle elision). Default 0 = tail-only behavior.
+     * (middle elision). Clamped to `spillThreshold / 2` so the tail keeps at
+     * least half the inline budget. Default 0 = tail-only behavior.
      */
     headBytes?: number;
     /**