@oh-my-pi/pi-coding-agent 15.12.3 → 15.13.0

package/dist/types/stt/recorder.d.ts

@@ -5,9 +5,26 @@ export interface RecordingHandle {
  * Returns available recording tools in priority order.
  */
 export declare function detectRecordingTools(): string[];
+export interface ResolvedRecorder {
+    tool: "sox" | "ffmpeg" | "arecord" | "powershell";
+    bin: string;
+}
+export declare function detectRecorder(): ResolvedRecorder | null;
+/**
+ * Ensure a recorder is available, downloading the static ffmpeg binary when
+ * nothing is already present. Returns the resolved recorder.
+ */
+export declare function ensureRecorder(onProgress?: (p: {
+    stage: string;
+    percent?: number;
+}) => void, signal?: AbortSignal): Promise<ResolvedRecorder>;
 export declare function startRecording(outputPath: string): Promise<RecordingHandle>;
 /**
  * Verify a recorded audio file is usable.
  * Returns the file size in bytes, or throws.
  */
 export declare function verifyRecordingFile(filePath: string): Promise<number>;
+export interface StreamingRecordingHandle {
+    stop(): Promise<void>;
+}
+export declare function startStreamingRecording(onAudio: (samples: Float32Array) => void): Promise<StreamingRecordingHandle | null>;

package/dist/types/stt/stt-controller.d.ts

@@ -3,9 +3,15 @@ interface ToggleOptions {
     showWarning(msg: string): void;
     showStatus(msg: string): void;
     onStateChange(state: SttState): void;
+    /** Force a redraw after async edits to the composer (live segment/preview inserts). */
+    requestRender?(): void;
 }
+/** The slice of the composer editor the controller drives. */
 interface Editor {
     insertText(text: string): void;
+    setVolatileText(text: string): void;
+    clearVolatileText(): void;
+    commitVolatileText(text: string): void;
 }
 export declare class STTController {
     #private;

package/dist/types/stt/transcriber.d.ts

@@ -4,13 +4,11 @@ export interface TranscribeOptions {
     signal?: AbortSignal;
 }
 /**
- * Find a usable Python command.
- */
-export declare function resolvePython(): string | null;
-/**
- * Transcribe a WAV file using Python openai-whisper.
+ * Transcribe a WAV file using the local ONNX Whisper worker.
  *
- * Reads the WAV via Python's built-in `wave` module (no ffmpeg needed),
- * resamples to 16 kHz mono, and passes the numpy array directly to whisper.
+ * Decodes the WAV to a 16 kHz mono Float32Array in-process (no Python, no
+ * ffmpeg) and routes it to the warm speech worker, which keeps the model loaded
+ * across calls. Honors `options.signal` (abort) and applies an internal timeout
+ * with the same semantics as the previous Python path.
  */
 export declare function transcribe(audioPath: string, options?: TranscribeOptions): Promise<string>;

package/dist/types/stt/wav.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal WAV (RIFF/PCM) decoder producing the Float32Array @ 16 kHz mono that
+ * transformers.js `automatic-speech-recognition` expects. Ports the decode/
+ * mono-mix/resample logic from the retired Python `transcribe.py` (which read
+ * via the stdlib `wave` module) so STT no longer shells out to Python.
+ *
+ * Supported sample formats: PCM uint8 (8-bit), int16 (16-bit), int32 (32-bit),
+ * and IEEE float32 (format tag 3). Any number of channels is mixed down to mono.
+ */
+/** transformers.js Whisper feature extractor operates at 16 kHz. */
+export declare const TARGET_SAMPLE_RATE = 16000;
+/**
+ * Resample via linear interpolation, mirroring the Python `np.interp` over
+ * `linspace(0, n-1, targetLen)` against `arange(n)`.
+ */
+export declare function resampleLinear(input: Float32Array, fromRate: number, toRate: number): Float32Array;
+/**
+ * Decode a WAV byte buffer into a 16 kHz mono Float32Array suitable for the
+ * transformers.js Whisper pipeline.
+ */
+export declare function decodeWavToMono16k(buffer: ArrayBuffer): Float32Array;
+/**
+ * Decode interleaved little-endian signed 16-bit PCM bytes into normalized
+ * [-1, 1] mono float samples. The live recorder streams raw s16le frames from
+ * sox/ffmpeg/arecord stdout (no RIFF container), so this is the hot-path
+ * counterpart to {@link decodeWavToMono16k}. `bytes` MUST be 2-byte aligned;
+ * callers buffer any trailing odd byte across chunk boundaries.
+ */
+export declare function decodePcmS16LE(bytes: Uint8Array): Float32Array;

package/dist/types/system-prompt.d.ts

@@ -78,6 +78,10 @@ export interface BuildSystemPromptOptions {
     mcpDiscoveryServerSummaries?: string[];
     /** Encourage the agent to delegate via tasks unless changes are trivial. */
     eagerTasks?: boolean;
+    /** When true, the Eager Tasks section uses the hard MUST/ONLY wording (`task.eager: always`) rather than the softer `preferred` nudge. */
+    eagerTasksAlways?: boolean;
+    /** Whether `task.batch` is enabled; gates batch-call guidance in the Eager Tasks section. */
+    taskBatch?: boolean;
     /** Rules with alwaysApply=true — their full content is injected into the prompt. */
     alwaysApplyRules?: AlwaysApplyRule[];
     /** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */

package/dist/types/task/executor.d.ts

@@ -51,6 +51,8 @@ export interface ExecutorOptions {
         content: string;
     };
     description?: string;
+    /** Specialist role/expertise for this spawn; drives the system-prompt preamble, display name, and telemetry identity. */
+    role?: string;
     index: number;
     id: string;
     parentToolCallId?: string;

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

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolSession } from "..";
 import type { Theme } from "../modes/theme/theme";
-import { type AgentDefinition, type SingleResult, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
+import { type AgentDefinition, type SingleResult, type TaskItem, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
 import "../tools/review";
 import { renderResult, renderCall as renderTaskCall } from "./render";
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
@@ -18,6 +18,14 @@ export declare function isReadOnlyAgent(agent: AgentDefinition): boolean;
  * tell a no-op child from one that burned requests before being cancelled.
  */
 export declare function formatResultOutputFallback(result: Pick<SingleResult, "output" | "stderr" | "requests">): string;
+/**
+ * Advisory — never a rejection — nudging the spawner toward tailored
+ * specialists when it spawns generic role-less workers and still holds spawn
+ * capacity (DepthCapacity: it currently has the `task` tool). Fires when a
+ * generic `task`/`quick_task` spawn carries no `role`, or when one call clones
+ * the same agent ≥2× all without roles. Returns undefined when no nudge applies.
+ */
+export declare function buildSpecializationAdvisory(agentName: string | undefined, items: TaskItem[], depthCapacity: boolean): string | undefined;
 /**
  * Task tool - Delegate tasks to specialized agents.
  *

package/dist/types/task/types.d.ts

@@ -1,6 +1,6 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
@@ -51,9 +51,14 @@ export interface SubagentLifecyclePayload {
      */
     detached?: boolean;
 }
+/** Display cap for a normalized one-line label (roster line, registry `displayName`, prompt field). */
+export declare const ROLE_LABEL_MAX = 80;
+/** Schema bound on the raw `role` input, before it is label-normalized at every use site. */
+export declare const ROLE_INPUT_MAX = 256;
 export declare const taskItemSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
     assignment: z.ZodString;
 }, z.core.$strip>;
 /** Single task item. Fields are optional defensively: args stream in token by token. */
@@ -62,6 +67,8 @@ export interface TaskItem {
     id?: string;
     /** UI label, not seen by the subagent. */
     description?: string;
+    /** Specialist role/expertise this subagent embodies; shapes its system-prompt identity and display name. */
+    role?: string;
     /** The work; required by the schema. */
     assignment?: string;
     /** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
@@ -70,6 +77,7 @@ export interface TaskItem {
 export declare const taskSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
     assignment: z.ZodString;
     isolated: z.ZodOptional<z.ZodBoolean>;
     agent: z.ZodString;
@@ -77,12 +85,14 @@ export declare const taskSchema: z.ZodObject<{
 declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
     assignment: z.ZodString;
     isolated: z.ZodOptional<z.ZodBoolean>;
     agent: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
     assignment: z.ZodString;
     agent: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
@@ -91,6 +101,7 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
     tasks: z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
         assignment: z.ZodString;
         isolated: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -100,6 +111,7 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
     tasks: z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
         assignment: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>];
@@ -124,6 +136,8 @@ export interface TaskParams {
     id?: string;
     /** UI label (flat form), not seen by the subagent. */
     description?: string;
+    /** Specialist role/expertise this subagent embodies; shapes its system-prompt identity and display name. */
+    role?: string;
     /** The work (flat form). */
     assignment?: string;
     /** Batch form (`task.batch`): one subagent per item. */
@@ -133,6 +147,28 @@ export interface TaskParams {
     /** Run in an isolated worktree (flat form; per-item in batch form). */
     isolated?: boolean;
 }
+/**
+ * One-line, length-capped label safe for a single roster line, a registry
+ * `displayName`, or a system-prompt field. Collapses every run of whitespace
+ * AND control/format characters — including U+0085 NEL, ESC/ANSI, and the
+ * zero-width separators that `\s` misses — to a single space, then caps length.
+ * So untrusted text (a spawn `role`, a peer activity gist) can neither break the
+ * line, inject prompt structure, nor smuggle terminal escapes. Caps at `max`
+ * characters (clamped to >= 1; default `ROLE_LABEL_MAX`), appending an ellipsis when truncated.
+ */
+export declare function oneLineLabel(text: string, max?: number): string;
+/**
+ * Display name for a spawned subagent: its tailored `role` (label-normalized)
+ * when one is given, else the agent type's name. Empty/whitespace roles fall
+ * back to the agent name.
+ */
+export declare function resolveSubagentDisplayName(role: string | undefined, agentName: string): string;
+/**
+ * Whether an agent at `taskDepth` may still spawn children — i.e. it currently
+ * holds the `task` tool. Mirrors the task-tool availability gate;
+ * `maxRecursionDepth < 0` disables the cap entirely.
+ */
+export declare function canSpawnAtDepth(maxRecursionDepth: number, taskDepth: number): boolean;
 /** A code review finding reported by the reviewer agent */
 export interface ReviewFinding {
     title: string;

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

@@ -16,7 +16,7 @@
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";

package/dist/types/tools/ast-edit.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";

package/dist/types/tools/ast-grep.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
@@ -124,7 +124,7 @@ export declare function createShellRenderer<TArgs>(config: ShellRendererConfig<T
     }, uiTheme: Theme, args?: TArgs): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
-    provisionalPendingPreview: boolean;
+    provisionalPendingPreview: string;
 };
 export declare const bashToolRenderer: {
     renderCall(args: BashRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
@@ -140,6 +140,6 @@ export declare const bashToolRenderer: {
     }, uiTheme: Theme, args?: BashRenderArgs | undefined): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
-    provisionalPendingPreview: boolean;
+    provisionalPendingPreview: string;
 };
 export {};

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

@@ -0,0 +1,202 @@
+import { JsRuntime } from "../../../eval/js/shared/runtime";
+import type { ToolSession } from "../../../sdk";
+import { type ReadableFormat } from "../readable";
+import type { Observation, ReadyInfo, RunResultOk, ScreenshotResult, SessionSnapshot } from "../tab-protocol";
+import type { CmuxSocketClient } from "./socket-client";
+interface ScreenshotOptions {
+    selector?: string;
+    fullPage?: boolean;
+    save?: string;
+    silent?: boolean;
+    encoding?: "base64" | "binary";
+}
+interface ObserveOptions {
+    includeAll?: boolean;
+    viewportOnly?: boolean;
+}
+interface RunContext {
+    session: SessionSnapshot;
+    displays: RunResultOk["displays"];
+    screenshots: ScreenshotResult[];
+    signal?: AbortSignal;
+    timeoutMs: number;
+}
+type WaitUntil = "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
+type DragTarget = string | {
+    readonly x: number;
+    readonly y: number;
+};
+interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface CmuxResponseRecord {
+    id: number;
+    url: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+}
+interface ViewportOptions {
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+}
+export interface RunCmuxCodeOptions {
+    code: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    session: ToolSession;
+    snapshot: SessionSnapshot;
+}
+export declare class CmuxTab {
+    #private;
+    constructor(opts: {
+        client: CmuxSocketClient;
+        surfaceId: string;
+        url?: string;
+        title?: string;
+    });
+    get surfaceId(): string;
+    get page(): CmuxPageFacade;
+    get browser(): CmuxBrowserFacade;
+    viewport(): ReadyInfo["viewport"];
+    setViewport(viewport: ViewportOptions): Promise<void>;
+    url(): string;
+    title(): Promise<string>;
+    readyInfo(viewport?: ReadyInfo["viewport"]): Promise<ReadyInfo>;
+    setRunContext(context: RunContext): void;
+    clearRunContext(): void;
+    goto(url: string, opts?: {
+        waitUntil?: WaitUntil;
+        timeoutMs?: number;
+    }): Promise<void>;
+    observe(opts?: ObserveOptions): Promise<Observation>;
+    click(selector: string): Promise<void>;
+    dblclick(selector: string): Promise<void>;
+    hover(selector: string): Promise<void>;
+    focus(selector: string): Promise<void>;
+    check(selector: string): Promise<void>;
+    uncheck(selector: string): Promise<void>;
+    type(selector: string, text: string): Promise<void>;
+    fill(selector: string, value: string): Promise<void>;
+    press(key: string, opts?: {
+        selector?: string;
+    }): Promise<void>;
+    scroll(dx: number, dy: number): Promise<void>;
+    waitFor(selector: string, opts?: {
+        timeout?: number;
+    }): Promise<CmuxElementHandle>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: string | ((...args: TArgs) => TResult | Promise<TResult>), ...args: TArgs): Promise<TResult>;
+    scrollIntoView(selector: string): Promise<void>;
+    select(selector: string, ...values: string[]): Promise<string[]>;
+    extract(format?: ReadableFormat): Promise<string>;
+    screenshot(opts?: ScreenshotOptions): Promise<ScreenshotResult>;
+    waitForUrl(pattern: string | RegExp, opts?: {
+        timeout?: number;
+    }): Promise<string>;
+    drag(from: DragTarget, to: DragTarget): Promise<void>;
+    uploadFile(selector: string, ...filePaths: string[]): Promise<void>;
+    waitForResponse(pattern: string | RegExp | ((response: CmuxResponse) => boolean | Promise<boolean>), opts?: {
+        timeout?: number;
+    }): Promise<CmuxResponse>;
+    id(id: number): Promise<CmuxElementHandle>;
+    ensureRuntime(session: SessionSnapshot): JsRuntime;
+    elementHandle(selector: string): CmuxElementHandle;
+    elementExists(selector: string): Promise<boolean>;
+    elementBox(selector: string): Promise<BoundingBox | null>;
+    evaluateOnSelector<TResult>(selector: string, source: string, args: unknown[]): Promise<TResult>;
+    pageContent(): Promise<string>;
+    pageScreenshot(opts?: ScreenshotOptions): Promise<Buffer | string>;
+    waitForFunction(fn: string | ((...args: unknown[]) => unknown | Promise<unknown>), opts: {
+        timeout?: number;
+        polling?: number;
+    } | undefined, ...args: unknown[]): Promise<unknown>;
+}
+declare class CmuxResponse {
+    #private;
+    constructor(record: CmuxResponseRecord);
+    url(): string;
+    status(): number;
+    statusText(): string;
+    headers(): Record<string, string>;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+}
+declare class CmuxElementHandle {
+    #private;
+    constructor(tab: CmuxTab, selector: string);
+    click(): Promise<void>;
+    type(text: string): Promise<void>;
+    fill(value: string): Promise<void>;
+    focus(): Promise<void>;
+    hover(): Promise<void>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: (element: unknown, ...args: TArgs) => TResult | Promise<TResult>, ...args: TArgs): Promise<TResult>;
+    boundingBox(): Promise<BoundingBox | null>;
+    uploadFile(...paths: string[]): Promise<void>;
+    dispose(): Promise<void>;
+}
+declare class CmuxLocator {
+    #private;
+    constructor(tab: CmuxTab, selector: string);
+    setTimeout(timeoutMs: number): this;
+    click(): Promise<void>;
+    fill(value: string): Promise<void>;
+    waitHandle(): Promise<CmuxElementHandle>;
+}
+declare class CmuxPageFacade {
+    #private;
+    readonly keyboard: {
+        press: (key: string) => Promise<void>;
+    };
+    readonly mouse: {
+        wheel: (delta: {
+            deltaX?: number;
+            deltaY?: number;
+        }) => Promise<void>;
+        move: (x: number, y: number) => Promise<void>;
+        down: () => Promise<void>;
+        up: () => Promise<void>;
+    };
+    constructor(tab: CmuxTab);
+    url(): string;
+    title(): Promise<string>;
+    viewport(): ReadyInfo["viewport"];
+    setViewport(viewport: ViewportOptions): Promise<void>;
+    goto(url: string, opts?: {
+        waitUntil?: WaitUntil;
+        timeout?: number;
+    }): Promise<{
+        url: string;
+    }>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: string | ((...args: TArgs) => TResult | Promise<TResult>), ...args: TArgs): Promise<TResult>;
+    content(): Promise<string>;
+    locator(selector: string): CmuxLocator;
+    $(selector: string): Promise<CmuxElementHandle | null>;
+    waitForSelector(selector: string, opts?: {
+        timeout?: number;
+    }): Promise<CmuxElementHandle>;
+    waitForFunction(fn: string | ((...args: unknown[]) => unknown | Promise<unknown>), opts?: {
+        timeout?: number;
+        polling?: number;
+    }, ...args: unknown[]): Promise<unknown>;
+    waitForResponse(pattern: string | RegExp | ((response: CmuxResponse) => boolean | Promise<boolean>), opts?: {
+        timeout?: number;
+    }): Promise<CmuxResponse>;
+    screenshot(opts?: ScreenshotOptions): Promise<Buffer | string>;
+}
+declare class CmuxBrowserFacade {
+    #private;
+    connected: boolean;
+    constructor(tab: CmuxTab);
+    pages(): Promise<CmuxPageFacade[]>;
+    version(): Promise<string>;
+    wsEndpoint(): string;
+    disconnect(): void;
+    close(): Promise<void>;
+}
+export declare function runCmuxCode(tab: CmuxTab, opts: RunCmuxCodeOptions): Promise<RunResultOk>;
+export {};

package/dist/types/tools/browser/cmux/rpc.d.ts

@@ -0,0 +1,70 @@
+import type { Observation } from "../tab-protocol";
+export interface CmuxKind {
+    kind: "cmux";
+    socketPath: string;
+    password?: string;
+    surface?: string;
+}
+export interface CmuxOpenSplitResult {
+    surface_id?: unknown;
+    url?: unknown;
+    workspace_id?: unknown;
+    created_split?: unknown;
+    placement_strategy?: unknown;
+}
+export interface CmuxSnapshotRef {
+    role?: unknown;
+    name?: unknown;
+}
+export interface CmuxSnapshotPage {
+    title?: unknown;
+    url?: unknown;
+    ready_state?: unknown;
+    text?: unknown;
+    html?: unknown;
+}
+export interface CmuxSnapshotResult {
+    snapshot?: unknown;
+    refs?: Record<string, CmuxSnapshotRef>;
+    page?: CmuxSnapshotPage;
+    url?: unknown;
+    title?: unknown;
+    ready_state?: unknown;
+    surface_id?: unknown;
+}
+export interface CmuxEvalResult {
+    value?: unknown;
+    surface_id?: unknown;
+    content_world?: unknown;
+}
+export interface CmuxUrlGetResult {
+    url?: unknown;
+    surface_id?: unknown;
+    workspace_id?: unknown;
+}
+export interface CmuxScreenshotResult {
+    png_base64?: unknown;
+    path?: unknown;
+    url?: unknown;
+    surface_id?: unknown;
+    width?: unknown;
+    height?: unknown;
+}
+export interface CmuxGeometry {
+    innerWidth: number;
+    innerHeight: number;
+    dpr: number;
+    scrollX: number;
+    scrollY: number;
+    scrollWidth: number;
+    scrollHeight: number;
+}
+export declare const GEOMETRY_SCRIPT = "(() => ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, dpr: window.devicePixelRatio||1, scrollX: window.scrollX, scrollY: window.scrollY, scrollWidth: document.documentElement.scrollWidth, scrollHeight: document.documentElement.scrollHeight }))()";
+export declare function cmuxSnapshotToObservation(result: CmuxSnapshotResult, viewport: Observation["viewport"], geometry: CmuxGeometry): Observation;
+export declare function serializeEval(fn: string | ((...args: unknown[]) => unknown), args: unknown[]): string;
+export declare function mapWaitUntil(waitUntil: string | undefined): "interactive" | "complete";
+export interface ResolveCmuxKindOptions {
+    surface?: string;
+    settingEnabled?: boolean;
+}
+export declare function resolveCmuxKind(options?: ResolveCmuxKindOptions | null, env?: Record<string, string | undefined>): CmuxKind | null;

package/dist/types/tools/browser/cmux/socket-client.d.ts

@@ -0,0 +1,19 @@
+type CmuxErrorPayload = {
+    code?: unknown;
+    message?: unknown;
+    details?: unknown;
+};
+export declare function formatCmuxError(error: CmuxErrorPayload | undefined): string;
+export declare class CmuxSocketClient {
+    #private;
+    constructor(opts: {
+        socketPath: string;
+        password?: string;
+    });
+    connect(): Promise<void>;
+    request(method: string, params: Record<string, unknown>, opts?: {
+        timeoutMs?: number;
+    }): Promise<Record<string, unknown>>;
+    close(): void;
+}
+export {};

package/dist/types/tools/browser/registry.d.ts

@@ -1,7 +1,9 @@
 import type { Subprocess } from "bun";
 import type { Browser, CDPSession } from "puppeteer-core";
+import type { CmuxKind } from "./cmux/rpc";
+import { CmuxSocketClient } from "./cmux/socket-client";
 import { type UserAgentOverride } from "./launch";
-export type BrowserKind = {
+export type PuppeteerBrowserKind = {
     kind: "headless";
     headless: boolean;
 } | {
@@ -11,20 +13,30 @@ export type BrowserKind = {
     kind: "connected";
     cdpUrl: string;
 };
+export type BrowserKind = PuppeteerBrowserKind | CmuxKind;
 export type BrowserKindTag = BrowserKind["kind"];
-export interface BrowserHandle {
+interface BrowserHandleCommon {
     key: string;
     kind: BrowserKind;
+    refCount: number;
+}
+export interface PuppeteerBrowserHandle extends BrowserHandleCommon {
+    kind: PuppeteerBrowserKind;
     browser: Browser;
     cdpUrl?: string;
     pid?: number;
     subprocess?: Subprocess;
-    refCount: number;
     stealth: {
         browserSession: CDPSession | null;
         override: UserAgentOverride | null;
     };
 }
+export interface CmuxBrowserHandle extends BrowserHandleCommon {
+    kind: CmuxKind;
+    client: CmuxSocketClient;
+    surface?: string;
+}
+export type BrowserHandle = PuppeteerBrowserHandle | CmuxBrowserHandle;
 export interface AcquireBrowserOptions {
     cwd: string;
     viewport?: {
@@ -41,3 +53,4 @@ export declare function holdBrowser(handle: BrowserHandle): void;
 export declare function releaseBrowser(handle: BrowserHandle, opts: {
     kill: boolean;
 }): Promise<void>;
+export {};

package/dist/types/tools/browser/render.d.ts

@@ -20,6 +20,8 @@ interface BrowserRenderArgs {
         path?: string;
         cdp_url?: string;
         target?: string;
+        cmux?: boolean;
+        surface?: string;
     };
     viewport?: {
         width: number;

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

@@ -37,6 +37,8 @@ export interface ScreenshotResult {
 export interface SessionSnapshot {
     cwd: string;
     browserScreenshotDir?: string;
+    /** Force non-WebP screenshot encoding (e.g. for Ollama). Unset honors `OMP_NO_WEBP`. */
+    excludeWebP?: boolean;
 }
 export type WorkerInitPayload = {
     mode: "headless";