@oh-my-pi/pi-coding-agent 17.1.6 → 17.1.8

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;
     /**

package/dist/types/session/turn-recovery.d.ts

@@ -43,7 +43,7 @@ export interface TurnRecoveryHost {
     waitForSessionMessagePersistence(message: AssistantMessage): Promise<void>;
     appendSessionMessage(message: AssistantMessage): void;
     sessionMessageAlreadyPersisted(message: AssistantMessage): boolean;
-    setModelWithProviderSessionReset(model: Model): void;
+    setModelWithProviderSessionReset(model: Model): Promise<void>;
     resetCurrentResponsesProviderSession(reason: string): void;
     maybeAutoRedeemCodexReset(): Promise<boolean>;
     runAutoCompaction(reason: "overflow" | "threshold" | "idle" | "incomplete", willRetry: boolean, deferred?: boolean, allowDefer?: boolean, options?: {

package/dist/types/task/isolation-ownership.d.ts

@@ -0,0 +1,34 @@
+/** Marker file written into a task-isolation base dir identifying its owner. */
+export declare const ISOLATION_OWNER_FILE = ".omp-isolation-owner.json";
+/** Recorded owner of a task-isolation sandbox. */
+export interface IsolationOwner {
+    /** PID of the omp process that created and owns the sandbox. */
+    pid: number;
+    /** Task id the sandbox was materialised for. */
+    id: string;
+    /**
+     * Process-instance start-time token for {@link pid}, when the OS can report
+     * it. Distinguishes the owning process from an unrelated process that later
+     * inherits a recycled pid, so a crashed sandbox is never pinned live.
+     */
+    startToken?: string;
+}
+/**
+ * Record the current process as owner of the sandbox rooted at `baseDir`.
+ *
+ * Written before the isolation backend materialises `m` so a concurrent
+ * `omp worktree clear` never sees an owner-less sandbox mid-creation.
+ */
+export declare function writeIsolationOwner(baseDir: string, id: string): Promise<void>;
+/**
+ * Whether a live omp process still owns the sandbox at `baseDir`.
+ *
+ * A missing or malformed marker means no verifiable owner — a crashed run or a
+ * sandbox from before markers existed, both safe to reclaim. `process.kill(pid,
+ * 0)` can fail with `EPERM` even when the process is alive, so only an explicit
+ * `ESRCH` ("no such process") counts as dead; any other error is treated as
+ * alive to avoid deleting a sandbox that is actually in use. When the marker
+ * carries a {@link IsolationOwner.startToken}, a live pid whose current token no
+ * longer matches is a recycled pid — a different process — and counts as dead.
+ */
+export declare function hasLiveIsolationOwner(baseDir: string): Promise<boolean>;

package/dist/types/tools/browser/cmux/cmux-tab.d.ts

@@ -8,7 +8,6 @@ import type { CmuxSocketClient } from "./socket-client.js";
 interface ScreenshotOptions {
     selector?: string;
     fullPage?: boolean;
-    save?: string;
     silent?: boolean;
     encoding?: "base64" | "binary";
 }
@@ -101,7 +100,7 @@ export declare class CmuxTab {
     scrollIntoView(selector: string): Promise<void>;
     select(selector: string, ...values: string[]): Promise<string[]>;
     extract(format?: ReadableFormat): Promise<string>;
-    screenshot(opts?: ScreenshotOptions): Promise<ScreenshotResult>;
+    screenshot(opts?: ScreenshotOptions): Promise<string>;
     waitForUrl(pattern: string | RegExp, opts?: {
         timeout?: number;
     }): Promise<string>;

package/dist/types/tools/browser/tab-worker.d.ts

@@ -1,5 +1,5 @@
 import type { HTMLElement } from "linkedom";
-import type { ElementHandle, ImageFormat } from "puppeteer-core";
+import type { ElementHandle } from "puppeteer-core";
 import type { Transport } from "./tab-protocol.js";
 declare module "puppeteer-core" {
     interface Frame {
@@ -41,7 +41,6 @@ export declare function resolveWaitTimeout(cellTimeoutMs: number, explicit?: num
 interface ScreenshotOptions {
     selector?: string;
     fullPage?: boolean;
-    save?: string;
     silent?: boolean;
 }
 export declare function normalizeSelector(selector: string): string;
@@ -67,8 +66,6 @@ export interface InflightOp {
 }
 /** Human-readable label for a screenshot op, used in op tracking + timeout errors. */
 export declare function describeScreenshot(opts?: ScreenshotOptions): string;
-/** Map an explicit save path's extension to a puppeteer capture format (default png). */
-export declare function imageFormatForPath(filePath: string): ImageFormat;
 /** Summarize still-running helpers (oldest first) so a cell timeout names what stalled. */
 export declare function describeInflight(inflight: Map<number, InflightOp>): string;
 export declare class WorkerCore {

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

@@ -24,12 +24,13 @@ import type { ToolChoiceQueue } from "../session/tool-choice-queue.js";
 import type { AgentOutputManager } from "../task/output-manager.js";
 import { type StructuredSubagentSchemaMode } from "../task/types.js";
 import type { EventBus } from "../utils/event-bus.js";
+import { type InspectImageMode } from "../utils/inspect-image-mode.js";
 import type { WorkspaceTree } from "../workspace-tree.js";
 import { type BuiltinToolName, type HiddenToolName } from "./builtin-names.js";
 import { type CheckpointState, type CompletedRewindState } from "./checkpoint.js";
 import type { PlanProposalHandler } from "./resolve.js";
 import { type TodoPhase } from "./todo.js";
-import { XdevRegistry } from "./xdev.js";
+import { type XdevState } from "./xdev.js";
 export * from "../edit/index.js";
 export * from "../goals/index.js";
 export * from "../lsp/index.js";
@@ -204,8 +205,10 @@ export interface ToolSession {
     isToolActive?: (name: string) => boolean;
     /** Update the active built-in tool predicate when a session changes tools mid-run. */
     setActiveToolNames?: (names: Iterable<string>) => void;
-    /** Tools mounted under `xd://` (set by createTools when `tools.xdev` is active); read/write consult it at execute time. */
-    xdevRegistry?: XdevRegistry;
+    /** Canonical map containing every registered tool exactly once. */
+    toolRegistry?: Map<string, Tool>;
+    /** `xd://` presentation state backed by {@link toolRegistry}. */
+    xdev?: XdevState;
     /** Agent registry for IRC routing across live sessions. */
     agentRegistry?: AgentRegistry;
     /** Idle→parked→revive lifecycle owner; lets the hub kill a non-job-backed agent registration. Default: AgentLifecycleManager.global(). */
@@ -227,6 +230,8 @@ export interface ToolSession {
     getActiveModelString?: () => string | undefined;
     /** Get the current session model object (provider/api capabilities), regardless of how it was chosen. */
     getActiveModel?: () => Model | undefined;
+    /** Session-scoped inspect_image mode override set by `/vision`; wins over the persisted setting. */
+    getInspectImageModeOverride?: () => InspectImageMode | undefined;
     /** Get the session's live per-family service tiers (undefined = none). Source of truth for subagent `tier.subagent: inherit`. */
     getServiceTierByFamily?: () => ServiceTierByFamily | undefined;
     /** Auth storage for passing to subagents (avoids re-discovery) */

package/dist/types/tools/output-meta.d.ts

@@ -197,6 +197,11 @@ export declare function stripOutputNotice(text: string, meta: OutputMeta | undef
  * middle elision with the same per-user configuration.
  */
 export declare function resolveOutputSinkHeadBytes(s: Settings | undefined): number;
+/**
+ * Resolve the `enforceInlineByteCap` budget for streaming tools (bash/ssh)
+ * from session settings: the user's spill threshold plus notice slack.
+ */
+export declare function resolveInlineByteCapBudget(s: Settings | undefined): number;
 /**
  * Resolve the per-line column cap from session settings. Shared by streaming
  * executors (bash/python/ssh/eval via OutputSink) and the `read` tool's

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

@@ -56,12 +56,20 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
     readonly approval: (args: unknown) => ToolTier;
     readonly label = "Read";
     readonly loadMode = "essential";
-    readonly description: string;
+    description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         path: string;
     }, {}>;
     readonly strict = true;
     constructor(session: ToolSession);
+    /**
+     * Re-evaluate the effective inspect_image state; it can flip when the model
+     * or the `/vision` override changes after this tool was constructed. Keeps
+     * the behavior branch and the advertised description in lockstep. Called
+     * per image read and by tool reconciliation before prompt rebuilds (which
+     * passes the post-change availability as `availableOverride`).
+     */
+    syncInspectImageState(availableOverride?: boolean): boolean;
     execute(_toolCallId: string, params: ReadParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ReadToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<ReadToolDetails>>;
 }
 interface ReadRenderArgs {

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

@@ -9,15 +9,20 @@
  *   read  xd://<tool>    → tool docs + JSON parameter schema
  *   write xd://<tool>    → execute: `content` is the JSON args object
  *
+ * Direct and device dispatch share one canonical tool map. The mounted-name
+ * set controls presentation only; dispatch accepts the enabled union of
+ * top-level active and mounted names. Listing and prompt docs stay
+ * mounted-only because top-level tools already ship their schemas.
+ *
  * Args go through the same machinery as native tool calls: validated with
  * pi-ai's `validateToolArguments` (the schema is returned on mismatch, so a
  * malformed call self-corrects without a round trip) and streamed through
  * the write tool's existing incremental `content` decoding for live render
  * previews. Compared to a dispatcher def this still costs zero *schema
  * duplication* — one wire schema per tool instead of one per dispatcher
- * branch — but full docs + schema for every mounted device are inlined into
- * the system prompt (`XdevRegistry.docsAll()`) so no discovery `read` is
- * needed before first use; `read xd://<tool>` remains for on-demand re-fetch.
+ * branch — but full docs + schema for every mounted device can be inlined
+ * into the system prompt, so no discovery read is needed before first use;
+ * `read xd://<tool>` remains for on-demand re-fetch.
  *
  * Rendering: the write renderer draws NOTHING until the streamed `path` is
  * known and provably does not target `xd://`; device writes then delegate to
@@ -54,8 +59,7 @@ export type XdevDocsMode = "inline" | "builtins" | "catalog";
  * while the `xd://` transport is active. Discoverable tools mount unless they
  * are pinned top-level by {@link XDEV_KEEP_TOP_LEVEL} or carry the transport
  * itself ({@link XDEV_TRANSPORT_TOOLS}); essential tools never do. The caller
- * gates this on the transport being active (a session-owned
- * {@link XdevRegistry} existing).
+ * gates this on the transport being active.
  */
 export declare function isMountableUnderXdev(tool: {
     name: string;
@@ -72,69 +76,51 @@ export interface XdevDispatch {
 }
 /** Wire the wrapped-renderer lookup. Called once by `renderers.ts`. */
 export declare function setXdevRendererLookup(lookup: (name: string) => ToolRenderer | undefined): void;
-/**
- * Registry of tools mounted under `xd://` for one session. `createTools`
- * mounts discoverable built-ins first; SDK assembly adds custom tools that do
- * not opt out. `read`/`write` consult it at execute time.
- */
-export declare class XdevRegistry {
-    #private;
-    constructor(builtins: Iterable<Tool>);
-    /**
-     * Replace the dynamic mount set while preserving the built-in devices. Order
-     * follows `tools`; names absent from it are dropped. A built-in device is
-     * never shadowed by a same-named dynamic entry.
-     */
-    reconcile(tools: Iterable<Tool>): void;
-    get size(): number;
-    /** Mounted tools in catalog order: built-ins first, then dynamic mounts. */
-    list(): readonly Tool[];
-    get(name: string): Tool | undefined;
-    /** `{name, summary}` pairs for prompt templates and /tools display. */
-    entries(): Array<{
-        name: string;
-        summary: string;
-    }>;
-    /** `read xd://` listing with one device per line. */
-    listing(): string;
-    /** Docs + schema for one device; throws with the listing when unknown. */
-    docs(name: string): string;
-    /**
-     * Char budget for the full docs inlined into the system prompt. Large MCP
-     * catalogs previously shipped every schema top-level; without a cap they
-     * would bloat every request. Devices past the budget fall back to a
-     * one-line summary — their docs stay one `read xd://<tool>` away.
-     */
-    static readonly DOCS_TOTAL_BUDGET = 48000;
-    /** A single device's docs above this size never inline: one pathological
-     *  MCP description must not starve every later device. */
-    static readonly DOCS_PER_DEVICE_CAP = 10000;
-    /** Description cap for EXTERNAL devices (dynamic mounts: MCP, custom,
-     *  extension, …) in the system-prompt embedding. Built-in devices inline
-     *  their full curated docs; external descriptions are server-controlled
-     *  prose the model can re-fetch, so only the lede earns prompt space. */
-    static readonly EXTERNAL_DESCRIPTION_CAP = 200;
-    /**
-     * Docs + schema for mounted devices, nested under `##` headings for
-     * system-prompt embedding. Inlines full docs in catalog order (built-ins
-     * first) until {@link DOCS_TOTAL_BUDGET} is spent; the rest are listed by
-     * name + summary with a pointer to on-demand `read xd://<tool>` docs.
-     * Dynamic mounts embed at most {@link EXTERNAL_DESCRIPTION_CAP} description
-     * chars (schema always intact); `read xd://<tool>` returns the full text.
-     */
-    docsAll(mode?: XdevDocsMode, inlinePatterns?: readonly string[]): string;
-    /** Docs for selected mounted devices under the configured prompt-doc policy. */
-    docsFor(names: Iterable<string>, mode: XdevDocsMode, inlinePatterns?: readonly string[]): string;
-    /**
-     * Execute a device write: `content` is the JSON args object (empty, `?`, or
-     * `help` returns docs). Args validate against the wrapped tool's schema —
-     * the schema comes back in the error on mismatch.
-     */
-    dispatch(name: string, content: string, toolCallId: string, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback, context?: AgentToolContext): Promise<{
-        result: AgentToolResult<unknown>;
-        xdev: XdevDispatch;
-    }>;
+/** Shared tool state consumed by the `xd://` presentation layer. */
+export interface XdevState {
+    /** Canonical session tool map; direct and device dispatch read the same instances. */
+    readonly tools: Map<string, Tool>;
+    /** Ordered names currently presented as mounted devices. */
+    readonly mountedNames: Set<string>;
+    /** Names originating from built-in factories, used only for prompt presentation. */
+    readonly builtInNames: Set<string>;
+    /** Whether a name is active at the top level. */
+    readonly isActive: (name: string) => boolean;
+    /** Optional execution-only decorator, such as the ACP permission gate. */
+    decorateExecution?(tool: Tool): Tool;
 }
+/** Full-doc character budget for system-prompt mounted-device sections. */
+export declare const XDEV_DOCS_TOTAL_BUDGET = 48000;
+/** Per-device cap preventing one pathological description from starving later devices. */
+export declare const XDEV_DOCS_PER_DEVICE_CAP = 10000;
+/** Description cap for external mounted tools; their full docs remain readable on demand. */
+export declare const XDEV_EXTERNAL_DESCRIPTION_CAP = 200;
+/** Resolve any enabled tool through the canonical session map. */
+export declare function resolveXdevTool(state: XdevState, name: string): Tool | undefined;
+/** Resolve a mounted tool for top-level fallback execution. */
+export declare function resolveMountedXdevTool(state: XdevState, name: string): Tool | undefined;
+/** Resolve a mounted tool with its execution-only permission decorator. */
+export declare function resolveMountedXdevExecutable(state: XdevState, name: string): Tool | undefined;
+/** Mounted tools in presentation order, resolved from the canonical map. */
+export declare function listXdevTools(state: XdevState): Tool[];
+/** `{name, summary}` pairs for prompt templates and `/tools` display. */
+export declare function xdevEntries(state: XdevState): Array<{
+    name: string;
+    summary: string;
+}>;
+/** `read xd://` listing with one device per line. */
+export declare function xdevListing(state: XdevState): string;
+/** Docs + schema for any enabled tool. */
+export declare function xdevDocs(state: XdevState, name: string): string;
+/** Docs + schema for mounted devices under the configured prompt-doc policy. */
+export declare function xdevDocsAll(state: XdevState, mode?: XdevDocsMode, inlinePatterns?: readonly string[]): string;
+/** Docs for selected mounted devices under the configured prompt-doc policy. */
+export declare function xdevDocsFor(state: XdevState, names: Iterable<string>, mode: XdevDocsMode, inlinePatterns?: readonly string[]): string;
+/** Execute an enabled canonical tool through `write xd://<tool>`. */
+export declare function dispatchXdevTool(state: XdevState, name: string, content: string, toolCallId: string, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback, context?: AgentToolContext): Promise<{
+    result: AgentToolResult<unknown>;
+    xdev: XdevDispatch;
+}>;
 /**
  * Streaming-safe call preview for an `xd://` write: forwards the decoded inner
  * args to the mounted tool's renderer (session instance first, then the static

package/dist/types/tui/output-block.d.ts

@@ -16,6 +16,7 @@ export interface OutputBlockOptions {
     width: number;
     applyBg?: boolean;
     contentPaddingLeft?: number;
+    contentPaddingRight?: number;
     /** Override the state-derived border color. Used for muted "legacy" tool
      * frames that should not visually compete with framed-output tools. */
     borderColor?: ThemeColor;
@@ -28,12 +29,11 @@ export declare function markFramedBlockComponent<T extends Component>(component:
 export declare function isFramedBlockComponent(component: Component): boolean;
 /**
  * Inner content width that {@link renderOutputBlock} wraps its body to, for a
- * given outer `width`: both vertical borders (1 cell each) plus the left
- * content padding. Renderers that size a tail window MUST budget visual rows
- * against this, not the outer width — otherwise the block re-wraps their lines
- * into more rows than they counted and the box overflows its intended height.
+ * given outer `width`: both vertical borders plus symmetric content padding.
+ * An explicit left padding of zero keeps legacy flush blocks flush on both
+ * sides unless a right padding is provided separately.
  */
-export declare function outputBlockContentWidth(width: number, contentPaddingLeft?: number): number;
+export declare function outputBlockContentWidth(width: number, contentPaddingLeft?: number, contentPaddingRight?: number): number;
 export declare function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[];
 /**
  * Cached wrapper around `renderOutputBlock`.

package/dist/types/utils/cpuprofile.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Parser and renderer for V8 `.cpuprofile` files (emitted by `node --cpu-prof`,
+ * `bun --cpu-prof`, Chrome DevTools, and the CDP `Profiler` domain).
+ *
+ * The raw file is a JSON blob with a flat node table and up to millions of
+ * sample/timestamp entries — useless to read directly. `renderCpuProfile`
+ * converts it into a compact bottleneck summary:
+ *
+ * - the hot-path call tree, pruned to frames with meaningful self time,
+ *   with pass-through chains collapsed and direct recursion flattened
+ * - `(idle)` time excluded from on-CPU totals
+ * - a profile-wide "top functions by self time" table
+ *
+ * Consumed by the read tool: `*.cpuprofile` reads show the summary, `:raw`
+ * returns the original JSON.
+ */
+/** Matches paths the read tool should treat as V8 CPU profiles. */
+export declare function isCpuProfilePath(filePath: string): boolean;
+/** Call-site metadata of one profile node. `lineNumber` is 0-based. */
+export interface CpuProfileCallFrame {
+    functionName: string;
+    url?: string;
+    lineNumber?: number;
+}
+/** One node in the flat profile tree; `children` are node ids. */
+export interface CpuProfileNode {
+    id: number;
+    callFrame: CpuProfileCallFrame;
+    hitCount?: number;
+    children?: number[];
+}
+/** Parsed V8 CPU profile. `startTime`/`endTime`/`timeDeltas` are microseconds. */
+export interface CpuProfile {
+    nodes: CpuProfileNode[];
+    startTime: number;
+    endTime: number;
+    samples?: number[];
+    timeDeltas?: number[];
+}
+/**
+ * Parse a `.cpuprofile` JSON blob. Accepts both the bare profile and the CDP
+ * `Profiler.stop` result shape (`{ profile: {...} }`). Returns null when the
+ * text is not a structurally valid V8 CPU profile.
+ */
+export declare function parseCpuProfile(text: string): CpuProfile | null;
+/**
+ * Render a V8 CPU profile as an agent-friendly bottleneck summary.
+ * Returns null when `text` is not a CPU profile (caller falls back to the
+ * plain-text path).
+ */
+export declare function renderCpuProfile(text: string): string | null;

package/dist/types/utils/inspect-image-mode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Effective-state resolution for the `inspect_image` tool.
+ *
+ * The tool delegates image understanding to a (possibly different)
+ * vision-capable model. That indirection is only useful when the active model
+ * cannot consume images itself; when it can (`model.input` includes
+ * `"image"`), the tool is redundant and its presence actively degrades the
+ * `read` tool, which reduces image reads to metadata-only plus an
+ * inspect_image suggestion. `auto` mode therefore exposes the tool only for
+ * models without native image input. `on`/`off` force registration regardless
+ * of model capability. A session-scoped override (the `/vision` command)
+ * takes precedence over the persisted setting for the current session only.
+ */
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { Settings } from "../config/settings.js";
+export type InspectImageMode = "auto" | "on" | "off";
+export declare const INSPECT_IMAGE_MODES: readonly ["auto", "on", "off"];
+/** Minimal session surface needed to resolve the effective inspect_image state. */
+export interface InspectImageModeContext {
+    settings: Pick<Settings, "get">;
+    getActiveModel?: () => Model | undefined;
+    getInspectImageModeOverride?: () => InspectImageMode | undefined;
+}
+/**
+ * Whether the `inspect_image` tool should be registered/active right now.
+ * `auto` registers it only when the active model lacks native image input;
+ * an unresolved model is treated as text-only so the tool stays available.
+ */
+export declare function isInspectImageToolActive(session: InspectImageModeContext): boolean;

package/dist/types/utils/profile-tree.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared display-tree machinery for profile summaries (macOS `sample` reports,
+ * V8 `.cpuprofile` files). Callers build {@link ProfileNode} trees with a
+ * domain-specific metric (on-CPU samples, self microseconds, …); this module
+ * merges same-key siblings, flattens direct recursion, collapses pass-through
+ * chains, and renders the pruned hot-path tree.
+ */
+/** Display node: merged, recursion-flattened mirror of a profile subtree. */
+export interface ProfileNode {
+    /** Merge/recursion identity (demangled symbol, function@call-site, …). */
+    key: string;
+    /** Human-readable label; recursion and truncation decorations are applied at render time. */
+    label: string;
+    /** Inclusive metric for this subtree (on-CPU samples, self µs, …); drives pruning and display. */
+    value: number;
+    /** Levels of direct recursion flattened into this node. */
+    recursion: number;
+    children: ProfileNode[];
+}
+/** Merge `b` into `a` (same key), combining values and child lists. */
+export declare function mergeInto(a: ProfileNode, b: ProfileNode): void;
+/**
+ * Flatten direct recursion: children carrying the node's own key are dissolved
+ * into it (their children promoted and merged), so a 15-deep recursive spine
+ * renders as one annotated node.
+ */
+export declare function flattenRecursion(node: ProfileNode): void;
+/** `n` as a percentage of `total`, one decimal (`"12.3%"`); `"0%"` when total is empty. */
+export declare function formatPct(n: number, total: number): string;
+/** Options for {@link renderProfileNode}. */
+export interface RenderTreeContext {
+    out: string[];
+    /** Denominator for percentage annotations. */
+    total: number;
+    /** Minimum subtree value a child needs to stay visible. */
+    minValue: number;
+    /** Format a metric value for the left column. */
+    formatValue: (value: number) => string;
+    /** Left-column width (characters) for formatted values. */
+    valueWidth: number;
+}
+/**
+ * Render one hot-path subtree: pass-through chains (single kept child, no own
+ * contribution above `minValue`) collapse into a single `a › b › c` line, and
+ * children below `minValue` are pruned.
+ */
+export declare function renderProfileNode(node: ProfileNode, indent: number, ctx: RenderTreeContext): void;