@oh-my-pi/pi-coding-agent 16.1.9 → 16.1.11

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

@@ -912,6 +912,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Surface the active model identifier in the system prompt so the agent knows which model it is";
         };
     };
+    readonly includeWorkspaceTree: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Prompt";
+            readonly label: "Include Workspace Tree";
+            readonly description: "Render the workspace directory tree in the system prompt. WARNING: This can bust prompt caching across sessions when files are modified.";
+        };
+    };
     readonly personality: {
         readonly type: "enum";
         readonly values: readonly ["default", "friendly", "pragmatic", "none"];

package/dist/types/edit/streaming.d.ts

@@ -63,12 +63,12 @@ export interface EditStreamingStrategy<Args = unknown> {
 }
 /**
  * Given an edits array parsed from partial JSON, drop the last entry when the
- * corresponding object in `partialJson` does not yet end with a closed `}`.
+ * corresponding object in `partialJson` has not yet closed with `}`.
  *
- * This guards against `partial-json` silently coercing truncated tails like
- * `"write":nu` / `"write":nul` into `{ write: null }`, which would make the
- * last entry render a spurious null-write error until the value finishes
- * streaming.
+ * The streaming parser materializes a trailing edit object from the fields seen
+ * so far before its closing `}` arrives, so an unfinished last entry can render
+ * as a (partial) edit mid-stream. Dropping it until the object closes keeps the
+ * preview from showing an incomplete edit.
  */
 export declare function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: string | undefined, listKey: string): T[];
 export declare const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>>;

package/dist/types/export/html/index.d.ts

@@ -5,12 +5,41 @@ import { SessionManager } from "../../session/session-manager";
 export declare function getTemplate(): string;
 export interface ExportOptions {
     outputPath?: string;
+    /**
+     * Which color palette the export ships with.
+     * - `"web"` (default) — the omp brand identity (collab-web pink/purple),
+     *   so public HTML exports and the `/s/<id>` share viewer match the live
+     *   `my.omp.sh` client. See `web-palette.ts`.
+     * - `"theme"` — derive from `themeName` (or the active TUI theme), preserving
+     *   the pre-15.12 behavior where an export mirrored the user's terminal.
+     */
+    palette?: "web" | "theme";
+    /**
+     * TUI theme to derive colors from when `palette: "theme"`. Ignored for the
+     * default `"web"` palette. Resolves to the active TUI theme when omitted.
+     */
     themeName?: string;
     /** Embed subagent session transcripts found next to the session file (default true). */
     includeSubSessions?: boolean;
 }
-/** Generate CSS custom properties for theme. Exported for the share-viewer build script. */
-export declare function generateThemeVars(themeName?: string): Promise<string>;
+/**
+ * Generate CSS custom properties for the export `:root`.
+ *
+ * Two call shapes:
+ *   • `generateThemeVars("web" | "theme", themeName?)` — explicit palette.
+ *     `"web"` (the default for public artifacts) returns the fixed omp brand
+ *     palette from `web-palette.ts` — collab-web pink/purple identity, shared
+ *     with the live `my.omp.sh` client, so exports and the share viewer render
+ *     identically to it. `"theme"` derives from the TUI theme via
+ *     `getResolvedThemeColors(themeName)` plus the three
+ *     `export.{pageBg,cardBg,infoBg}` surface overrides.
+ *   • `generateThemeVars(themeName)` — legacy single-arg form: derive from the
+ *     named TUI theme. Kept so existing callers (and the theme-islight test)
+ *     keep working; equivalent to `generateThemeVars("theme", themeName)`.
+ *
+ * Exported for the share-viewer build script.
+ */
+export declare function generateThemeVars(palette?: "web" | "theme" | (string & {}), themeName?: string): Promise<string>;
 /** Embedded subagent session transcript, keyed by slash-joined agent path in `SessionData.subSessions`. */
 export interface SubSession {
     /** Bare agent id (session file stem), e.g. "ToolAsk". */

package/dist/types/export/html/web-palette.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Web/export palette — the omp brand identity shared by the collab-web live
+ * client (`my.omp.sh/`) and every public HTML export / share viewer (`/s/<id>`).
+ *
+ * Why this exists separately from `modes/theme/dark.json`: the `dark` theme is
+ * the **default TUI theme** — its amber accent (`#febc38`) drives the terminal
+ * status line, syntax highlighting, thinking levels, and bash/python mode
+ * colors for every omp user. The public web artifacts want the collab-web
+ * pink/purple identity instead, so they pin this palette rather than inheriting
+ * the TUI's. Editing `dark.json` to repurpose it for the web would repaint
+ * every terminal; this file keeps the two surfaces decoupled.
+ *
+ * Token layout — emitted as CSS custom properties on `:root`:
+ *   • Legacy export names consumed by `template.css` / `template.js`
+ *     (`--text`, `--body-bg`, `--container-bg`, `--info-bg`, `--accent`,
+ *      `--border`, `--success`, `--error`, `--warning`, `--muted`, `--dim`,
+ *      `--borderAccent`, `--selectedBg`, `--userMessageBg`, `--customMessageBg`,
+ *      `--customMessageLabel`, `--mdHeading`, `--mdLink`, `--mdCode`,
+ *      `--mdListBullet`, `--toolOutput`, `--thinkingText`, syntax*, …).
+ *   • collab-web-native aliases consumed by the `tv-` tool-render bridge
+ *     (`tool-render.css`: `var(--bg-inset, …)`, `var(--fg, …)`, …) so embedded
+ *     tool cards resolve to the *real* collab-web tokens and render
+ *     pixel-identical to the live client.
+ *
+ * Alpha-bearing tokens (`--border`, `--ring`, `--accent-muted`, …) keep their
+ * `oklch(… / N%)` form — flattening them to opaque hex would produce harsh
+ * white borders and non-matching translucent focus rings. Opaque surfaces are
+ * sRGB hex (the collab-web `tokens.css` OKLCH dark-theme tokens converted via
+ * the standard OKLab→linear-sRGB→gamma path); if the live client palette
+ * changes, regenerate those from there.
+ */
+export declare const WEB_EXPORT_PALETTE: {
+    readonly "--bg": "#0f0b14";
+    readonly "--bg-raised": "#16111c";
+    readonly "--bg-inset": "#09060c";
+    readonly "--bg-overlay": "#211b28";
+    readonly "--fg": "#e6e3ea";
+    readonly "--fg-muted": "#a49faa";
+    readonly "--fg-faint": "#6e6974";
+    readonly "--accent": "#ed4abf";
+    readonly "--accent-muted": "oklch(0.674 0.23 341 / 18%)";
+    readonly "--ok": "#68ca80";
+    readonly "--err": "#f05653";
+    readonly "--warn": "#e4b33f";
+    readonly "--ring": "oklch(0.817 0.112 205 / 70%)";
+    readonly "--font-mono": 'ui-monospace, "SF Mono", "JetBrains Mono", "Cascadia Mono", Menlo, Consolas, monospace';
+    readonly "--body-bg": "#0f0b14";
+    readonly "--container-bg": "#16111c";
+    readonly "--info-bg": "#09060c";
+    readonly "--text": "#e6e3ea";
+    readonly "--muted": "#a49faa";
+    readonly "--dim": "#6e6974";
+    readonly "--thinkingText": "#a49faa";
+    readonly "--border": "oklch(1 0 0 / 9%)";
+    readonly "--borderMuted": "oklch(1 0 0 / 6%)";
+    readonly "--borderAccent": "#945ff9";
+    readonly "--selectedBg": "#2d2535";
+    readonly "--success": "#68ca80";
+    readonly "--error": "#f05653";
+    readonly "--warning": "#e4b33f";
+    readonly "--userMessageBg": "oklch(0.674 0.23 341 / 6%)";
+    readonly "--userMessageText": "#e6e3ea";
+    readonly "--customMessageBg": "#211b28";
+    readonly "--customMessageText": "#a49faa";
+    readonly "--customMessageLabel": "#b281d6";
+    readonly "--toolPendingBg": "#16111c";
+    readonly "--toolSuccessBg": "#09060c";
+    readonly "--toolErrorBg": "oklch(0.66 0.19 25 / 14%)";
+    readonly "--toolTitle": "#e6e3ea";
+    readonly "--toolOutput": "#a49faa";
+    readonly "--mdHeading": "#ed4abf";
+    readonly "--mdLink": "#5ad8e5";
+    readonly "--mdLinkUrl": "#6e6974";
+    readonly "--mdCode": "#e6e3ea";
+    readonly "--mdCodeBlock": "#e6e3ea";
+    readonly "--mdCodeBlockBorder": "oklch(1 0 0 / 9%)";
+    readonly "--mdQuote": "#a49faa";
+    readonly "--mdQuoteBorder": "oklch(1 0 0 / 13%)";
+    readonly "--mdHr": "oklch(1 0 0 / 9%)";
+    readonly "--mdListBullet": "#ed4abf";
+    readonly "--toolDiffAdded": "#68ca80";
+    readonly "--toolDiffRemoved": "#f05653";
+    readonly "--toolDiffContext": "#6e6974";
+    readonly "--syntaxComment": "#6e6974";
+    readonly "--syntaxKeyword": "#945ff9";
+    readonly "--syntaxFunction": "#e4b33f";
+    readonly "--syntaxVariable": "#5ad8e5";
+    readonly "--syntaxString": "#68ca80";
+    readonly "--syntaxNumber": "#ed4abf";
+    readonly "--syntaxType": "#b281d6";
+    readonly "--syntaxOperator": "#e6e3ea";
+    readonly "--syntaxPunctuation": "#a49faa";
+    readonly "--thinkingOff": "#6e6974";
+    readonly "--thinkingMinimal": "#6e6974";
+    readonly "--thinkingLow": "#945ff9";
+    readonly "--thinkingMedium": "#b281d6";
+    readonly "--thinkingHigh": "#ed4abf";
+    readonly "--thinkingXhigh": "#e4b33f";
+    readonly "--bashMode": "#5ad8e5";
+    readonly "--pythonMode": "#e4b33f";
+    readonly "--statusLineBg": "#0f0b14";
+    readonly "--statusLineSep": "#6e6974";
+    readonly "--statusLineModel": "#ed4abf";
+    readonly "--statusLinePath": "#5ad8e5";
+    readonly "--statusLineGitClean": "#68ca80";
+    readonly "--statusLineGitDirty": "#e4b33f";
+    readonly "--statusLineContext": "#a49faa";
+    readonly "--statusLineSpend": "#5ad8e5";
+    readonly "--statusLineStaged": "#68ca80";
+    readonly "--statusLineDirty": "#e4b33f";
+    readonly "--statusLineUntracked": "#945ff9";
+    readonly "--statusLineOutput": "#b281d6";
+    readonly "--statusLineCost": "#b281d6";
+    readonly "--statusLineSubagents": "#ed4abf";
+};
+/** Serialize the palette as `--key: value;` declarations for `:root { … }`. */
+export declare function webExportThemeVars(): string;

package/dist/types/hindsight/content.d.ts

@@ -28,6 +28,13 @@ export interface RecallResultLike {
  * retaining.
  */
 export declare function stripMemoryTags(content: string): string;
+/**
+ * True when `content` carries at least one letter or digit. Used by retain
+ * and recall paths to drop placeholder assistant turns ("." / "..." / pure
+ * whitespace) that would otherwise pollute the bank and waste tokens on
+ * embeddings with no semantic content.
+ */
+export declare function hasSubstantiveContent(content: string): boolean;
 /** Format recall results into a bullet list for context injection. */
 export declare function formatMemories(results: RecallResultLike[]): string;
 /** Format current UTC time for the recall preamble. */

package/dist/types/hindsight/transcript.d.ts

@@ -7,7 +7,7 @@
  * surviving message's `TextContent` parts are joined with newlines.
  */
 import type { SessionEntry } from "../session/session-entries";
-import type { HindsightMessage } from "./content";
+import { type HindsightMessage } from "./content";
 export interface ReadonlySessionManagerLike {
     getEntries(): SessionEntry[];
 }

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

@@ -3,7 +3,8 @@
  * Supports Ctrl+G for external editor.
  *
  * Two modes:
- * - Default (hook): Enter inserts newline, Ctrl+Enter submits, bordered popup
+ * - Default (hook): Enter inserts newline, the `app.message.followUp` chord
+ *   (Ctrl+Q / Ctrl+Enter) submits, bordered popup
  * - Prompt-style (ask): Enter submits, Shift+Enter inserts newline, legacy ask chrome
  */
 import { Container, type TUI } from "@oh-my-pi/pi-tui";

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -1,7 +1,6 @@
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { SessionObserverRegistry } from "../session-observer-registry";
-export declare function formatTemporaryModelStatus(modelLabel: string, roleSelectorHint?: string): string;
 export declare class SelectorController {
     #private;
     private ctx;

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

@@ -95,6 +95,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     hookWidgetContainerBelow: Container;
     statusLine: StatusLineComponent;
     isInitialized: boolean;
+    initialChatRendered: boolean;
     isBashMode: boolean;
     toolOutputExpanded: boolean;
     todoExpanded: boolean;
@@ -183,6 +184,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     withLocalSubmission<T>(text: string, fn: () => Promise<T>, options?: {
         imageCount?: number;
     }): Promise<T>;
+    clearOptimisticUserMessage(): void;
+    replaceOptimisticUserMessage(message: AgentMessage, options?: {
+        imageLinks?: readonly (string | undefined)[];
+    }): void;
     startPendingSubmission(input: {
         text: string;
         images?: ImageContent[];

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

@@ -118,6 +118,17 @@ export interface InteractiveModeContext {
     eventController: EventController;
     eventBus?: EventBus;
     isInitialized: boolean;
+    /**
+     * `true` once `renderInitialMessages` has rendered the session transcript
+     * into `chatContainer` at least once.
+     *
+     * Extension chat-rebuilds (`ExtensionUiController.#applyCustomMessageDisplay`)
+     * are gated on this: rebuilding before the initial render would plant a
+     * session-derived component into the chat that `renderInitialMessages` then
+     * both re-renders from session entries AND re-appends via
+     * `preserveExistingChat`, duplicating the message (issue #1955).
+     */
+    initialChatRendered: boolean;
     isBashMode: boolean;
     toolOutputExpanded: boolean;
     todoExpanded: boolean;
@@ -237,6 +248,12 @@ export interface InteractiveModeContext {
     withLocalSubmission<T>(text: string, fn: () => Promise<T>, options?: {
         imageCount?: number;
     }): Promise<T>;
+    /** Clears bookkeeping for an optimistic local user message once the matching session event arrives. */
+    clearOptimisticUserMessage(): void;
+    /** Replaces the raw optimistic user render with the canonical message emitted by the session. */
+    replaceOptimisticUserMessage(message: AgentMessage, options?: {
+        imageLinks?: readonly (string | undefined)[];
+    }): void;
     isKnownSlashCommand(text: string): boolean;
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;

package/dist/types/modes/utils/keybinding-matchers.d.ts

@@ -17,3 +17,16 @@ export declare function matchesSelectPageUp(data: string): boolean;
 /** Match the generic selector page-down keybinding. */
 export declare function matchesSelectPageDown(data: string): boolean;
 export declare function matchesAppExternalEditor(data: string): boolean;
+/**
+ * Match the "submit multi-line text input" keybinding (`app.message.followUp`).
+ *
+ * Used by forms where plain Enter inserts a newline and a modified-Enter chord
+ * submits — the main editor's follow-up handler, the agent dashboard's new-agent
+ * description, and the hook editor's hook-style mode. The keybinding defaults to
+ * `["ctrl+q", "ctrl+enter"]` so Windows Terminal (which can't deliver a distinct
+ * Ctrl+Enter event; #1903) still has a working chord without user remapping.
+ *
+ * Also recognizes modifier-tagged LF as Ctrl+Enter only when Ctrl+Enter is an
+ * effective follow-up binding.
+ */
+export declare function matchesAppFollowUp(data: string): boolean;

package/dist/types/sdk.d.ts

@@ -318,6 +318,7 @@ export interface BuildSystemPromptOptions {
     customPrompt?: string;
     appendPrompt?: string;
     inlineToolDescriptors?: boolean;
+    includeWorkspaceTree?: boolean;
 }
 /**
  * Build the default provider-facing system prompt blocks.

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

@@ -156,6 +156,8 @@ export interface AgentSessionConfig {
     modelRegistry: ModelRegistry;
     /** Tool registry for LSP and settings */
     toolRegistry?: Map<string, AgentTool>;
+    /** Tool names whose current registry entry is still the built-in implementation. */
+    builtInToolNames?: Iterable<string>;
     /** Current session pre-LLM message transform pipeline */
     transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => AgentMessage[] | Promise<AgentMessage[]>;
     /** Provider payload hook used by the active session request path */
@@ -511,6 +513,8 @@ export declare class AgentSession {
      * Get a tool by name from the registry.
      */
     getToolByName(name: string): AgentTool | undefined;
+    /** True when the current registry entry for `name` came from a built-in factory. */
+    hasBuiltInTool(name: string): boolean;
     /**
      * Get all configured tool names (built-in via --tools or default, plus custom tools).
      */

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

@@ -4,6 +4,8 @@ import { type CompactionEntry, type SessionEntry } from "./session-entries";
 export interface SessionContext {
     messages: AgentMessage[];
     thinkingLevel?: string;
+    /** Configured thinking selector (`"auto"` or a concrete level) from the latest change. */
+    configuredThinkingLevel?: string;
     serviceTier?: ServiceTier;
     /** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
     models: Record<string, string>;

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

@@ -30,6 +30,12 @@ export interface SessionMessageEntry extends SessionEntryBase {
 export interface ThinkingLevelChangeEntry extends SessionEntryBase {
     type: "thinking_level_change";
     thinkingLevel?: string | null;
+    /**
+     * The user-configured selector at the time of this change: `"auto"` when auto
+     * mode was active, otherwise the concrete level. Absent on entries written
+     * before auto-mode persistence existed; readers fall back to `thinkingLevel`.
+     */
+    configured?: string | null;
 }
 export interface ModelChangeEntry extends SessionEntryBase {
     type: "model_change";

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

@@ -138,7 +138,8 @@ export declare class SessionManager {
      * top-level entries via appendCompaction()/branchWithSummary().
      */
     appendMessage(message: Message | CustomMessage | HookMessage | BashExecutionMessage | PythonExecutionMessage | FileMentionMessage): string;
-    appendThinkingLevelChange(thinkingLevel?: string): string;
+    /** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
+    appendThinkingLevelChange(thinkingLevel?: string, configured?: string): string;
     appendServiceTierChange(serviceTier: ServiceTier | null): string;
     appendModeChange(mode: string, data?: Record<string, unknown>): string;
     /**

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

@@ -110,6 +110,8 @@ export interface BuildSystemPromptOptions {
     model?: string;
     /** Personality preset rendered into the default system prompt. "none" omits the block. Default: "default" */
     personality?: Personality;
+    /** Whether to include the workspace directory tree in the system prompt. Default: false */
+    includeWorkspaceTree?: boolean;
 }
 /** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {

package/dist/types/tools/acp-bridge.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared ACP client bridge routing for file-write sites.
+ *
+ * When an ACP client (e.g. Zed) advertises the `fs.writeTextFile` capability,
+ * all write-mode tools must route through it so the editor's open buffer is
+ * updated immediately. Internal artifacts ('/Users/theo/.omp/agent/sessions/-Projects-oh-my-pi/2026-06-10T09-11-41-506Z_019eb0cd-3ec2-7000-92aa-1b82aa4d78f0/local' plan files, other scheme
+ * URLs) are always written directly to disk — those are OMP-owned and should
+ * never be pushed into the editor.
+ */
+import type { ToolSession } from ".";
+/**
+ * Return `true` when an ACP client bridge write is appropriate for this path.
+ *
+ * Returns `false` for internal-URL paths (e.g. `'/Users/theo/.omp/agent/sessions/-Projects-oh-my-pi/2026-06-10T09-11-41-506Z_019eb0cd-3ec2-7000-92aa-1b82aa4d78f0/local/PLAN.md'`) and for the
+ * active plan file while plan mode is enabled — both are OMP-internal artifacts
+ * that must stay off the editor's buffer.
+ */
+export declare function shouldRouteWriteThroughBridge(session: ToolSession, requestedPath: string, absolutePath: string): boolean;
+/**
+ * Try to route a file write through the ACP client bridge.
+ *
+ * Performs the full guard check, bridge call (wrapped in {@link ToolError}),
+ * FS-scan cache invalidation, and session mutation-version bump.
+ *
+ * Returns `true` when the bridge was used and the caller must skip the
+ * writethrough path. Returns `false` when the bridge is unavailable or the
+ * path should not be routed through it.
+ */
+export declare function routeWriteThroughBridge(session: ToolSession, requestedPath: string, absolutePath: string, content: string): Promise<boolean>;

package/dist/types/tools/browser/aria/aria-snapshot.d.ts

@@ -0,0 +1,39 @@
+import type { ElementHandle, Page } from "puppeteer-core";
+export interface AriaSnapshotOptions {
+    /** Maximum tree depth to render. */
+    depth?: number;
+    /** Append `[box=x,y,w,h]` bounding boxes to each node. */
+    boxes?: boolean;
+}
+/**
+ * Capture a Playwright-format ARIA snapshot of `root` (or the whole document when
+ * null). Always runs in `ai` mode so every node carries a `[ref=eN]` id; resolve
+ * those to elements with {@link resolveAriaRefHandle}. Ids are renumbered from e1
+ * on each call and remain valid until the next snapshot.
+ */
+export declare function captureAriaSnapshot(page: Page, root: ElementHandle | null, options?: AriaSnapshotOptions): Promise<string>;
+/**
+ * Resolve a `[ref=eN]` id from the latest snapshot to a live `ElementHandle`, or
+ * null when the ref no longer matches any element. Runs in the main world so it
+ * sees the `_ariaRef` expandos the snapshot wrote.
+ */
+export declare function resolveAriaRefHandle(page: Page, ref: string): Promise<ElementHandle | null>;
+/**
+ * Recognize the explicit `[ref=eN]` selector forms and return the bare ref id,
+ * else null. Accepts `aria-ref=e5` (Playwright-MCP style), `aria-ref/e5`, and
+ * `ariaref/e5` — lets `tab.click("aria-ref=e5")` etc. act on snapshot refs. A
+ * bare `e5` is intentionally NOT a ref selector: the cmux backend already uses
+ * bare `eN`/`@eN` for its own observe ids, so requiring the prefix keeps action
+ * selectors meaning the same thing on both backends. (`tab.ref("e5")` still
+ * accepts a bare id directly.)
+ */
+export declare function parseAriaRefSelector(selector: string): string | null;
+/**
+ * Build a self-contained expression script that runs the vendored bundle in the
+ * page and returns the ARIA snapshot YAML. Used by the cmux backend, whose
+ * `browser.eval` RPC takes a script string and returns the completion value (it
+ * has no ElementHandle to pass in). The script resolves `selector` via
+ * `document.querySelector` in-page (CSS selectors only) or falls back to the
+ * whole document. Like the puppeteer path it installs nothing on `window`.
+ */
+export declare function buildAriaSnapshotScript(selector: string | undefined, options?: AriaSnapshotOptions): string;

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

@@ -1,5 +1,6 @@
 import { JsRuntime } from "../../../eval/js/shared/runtime";
 import type { ToolSession } from "../../../sdk";
+import { type AriaSnapshotOptions } from "../aria/aria-snapshot";
 import { type ReadableFormat } from "../readable";
 import type { Observation, ReadyInfo, RunResultOk, ScreenshotResult, SessionSnapshot } from "../tab-protocol";
 import type { CmuxSocketClient } from "./socket-client";
@@ -75,6 +76,8 @@ export declare class CmuxTab {
         timeoutMs?: number;
     }): Promise<void>;
     observe(opts?: ObserveOptions): Promise<Observation>;
+    ariaSnapshot(selector?: string, opts?: AriaSnapshotOptions): Promise<string>;
+    ref(id: string): Promise<CmuxElementHandle>;
     click(selector: string): Promise<void>;
     dblclick(selector: string): Promise<void>;
     hover(selector: string): Promise<void>;
@@ -90,6 +93,9 @@ export declare class CmuxTab {
     waitFor(selector: string, opts?: {
         timeout?: number;
     }): Promise<CmuxElementHandle>;
+    waitForSelector(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[]>;
@@ -98,6 +104,10 @@ export declare class CmuxTab {
     waitForUrl(pattern: string | RegExp, opts?: {
         timeout?: number;
     }): Promise<string>;
+    waitForNavigation(opts?: {
+        waitUntil?: WaitUntil;
+        timeout?: number;
+    }): Promise<null>;
     drag(from: DragTarget, to: DragTarget): Promise<void>;
     uploadFile(selector: string, ...filePaths: string[]): Promise<void>;
     waitForResponse(pattern: string | RegExp | ((response: CmuxResponse) => boolean | Promise<boolean>), opts?: {

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

@@ -11,12 +11,32 @@ declare global {
         elementFromPoint(x: number, y: number): Element | null;
     };
 }
+export interface OpTimeouts {
+    /** Largest per-op deadline allowed — strictly below the cell budget. */
+    budgetBound: number;
+    /** Ceiling for quick page reads. */
+    quickOpMs: number;
+    /** Ceiling for interactive actions + default for waits. */
+    actionOpMs: number;
+}
+/** Resolve the per-op fail-fast ceilings for a given cell budget. */
+export declare function resolveOpTimeouts(cellTimeoutMs: number): OpTimeouts;
+/**
+ * Effective timeout for a wait helper (`waitFor*`). A positive explicit `{ timeout }` is
+ * honored but clamped to the cell budget so it still fails fast + named; raising the tool
+ * `timeout` raises that cap, so a longer budget stays meaningful. No `{ timeout }` → the
+ * action ceiling. Puppeteer's `{ timeout: 0 }` / `Infinity` ("disable") maps to the largest
+ * bounded wait (`budgetBound`) — the harness never permits an unbounded wait. Garbage input
+ * (negative, `NaN`) falls back to the action ceiling rather than the longest wait.
+ */
+export declare function resolveWaitTimeout(cellTimeoutMs: number, explicit?: number): number;
 interface ScreenshotOptions {
     selector?: string;
     fullPage?: boolean;
     save?: string;
     silent?: boolean;
 }
+export declare function normalizeSelector(selector: string): string;
 export interface InflightOp {
     label: string;
     startedAt: number;

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

@@ -4,6 +4,7 @@ import type { ToolSession } from "../sdk";
 import { type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
 import type { OutputMeta } from "./output-meta";
+export { type AriaSnapshotOptions, buildAriaSnapshotScript, parseAriaRefSelector, } from "./browser/aria/aria-snapshot";
 export { cmuxSnapshotToObservation, mapWaitUntil, resolveCmuxKind, serializeEval } from "./browser/cmux/rpc";
 export { CmuxSocketClient } from "./browser/cmux/socket-client";
 export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } from "./browser/readable";

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

@@ -60,8 +60,7 @@ export declare class FindTool implements AgentTool<typeof findSchema, FindToolDe
     private readonly session;
     readonly name = "find";
     readonly approval: "read";
-    readonly summary = "Find files and directories matching a glob pattern";
-    readonly loadMode = "discoverable";
+    readonly loadMode = "essential";
     readonly label = "Find";
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{

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

@@ -40,8 +40,7 @@ export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToo
     }, {}>;
     readonly strict = true;
     readonly concurrency = "exclusive";
-    readonly loadMode = "discoverable";
-    readonly summary = "Write content to a file (creates or overwrites)";
+    readonly loadMode = "essential";
     /** Stream matchers should see the real file content, not its JSON-escaped argument encoding. */
     matcherDigest(args: unknown): string | undefined;
     constructor(session: ToolSession);

package/dist/types/utils/image-loading.d.ts

@@ -4,9 +4,10 @@ export declare const MAX_IMAGE_INPUT_BYTES: number;
 export declare const SUPPORTED_INPUT_IMAGE_MIME_TYPES: Set<string>;
 /**
  * Ollama and its local-backend family decode image input through llama.cpp /
- * `stb_image`, which is compiled without WebP support, so a WebP upload fails
- * with an opaque HTTP 400. Detect those models so the resize pipeline encodes
- * to PNG/JPEG instead — the automatic equivalent of `OMP_NO_WEBP=1`.
+ * `stb_image`, which is compiled without WebP support. The first-party Codex
+ * Responses backend also rejects WebP `input_image.image_url` data URLs. Detect
+ * those models so the resize pipeline encodes to PNG/JPEG instead — the
+ * automatic equivalent of `OMP_NO_WEBP=1`.
  */
 export declare function modelLacksWebpSupport(model: Pick<Model, "provider" | "api" | "imageInputDecoder"> | undefined): boolean;
 /**

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

@@ -47,3 +47,28 @@ export declare const repo: {
     /** Check whether `cwd` is inside a Jujutsu repository. */
     is(cwd: string): Promise<boolean>;
 };
+/**
+ * Detect a "pure" Jujutsu workspace — one where Git-mutating automation has
+ * no safe Git target. Invoking `git checkout -b`, `git worktree add`, or
+ * `git apply` against a pure jj workspace either fails outright (no `.git/`
+ * present) or mutates state that jj itself cannot reconcile.
+ *
+ * `cwd` is "pure jj" iff its nearest jj workspace ancestor is **closer than**
+ * its nearest Git checkout ancestor (or no Git checkout is present at all).
+ * Both lookups walk upward from `cwd`, so the deeper ancestor is the one the
+ * user is actually working inside.
+ *
+ * Returns:
+ * - `false` for plain Git checkouts (no jj metadata anywhere up the tree).
+ * - `false` for colocated jj-git workspaces — `jj git init --colocate` keeps
+ *   `.jj/` and `.git/` at the same root.
+ * - `false` when a nested Git checkout (e.g. a vendored repo or fixture)
+ *   lives **under** an outer jj workspace; Git automation targets the inner
+ *   repo and never touches the surrounding jj tree.
+ * - `true` when jj is the deeper ancestor — either a standalone pure jj
+ *   workspace, or a jj workspace nested under an unrelated outer Git
+ *   checkout, where Git automation against the outer root would silently
+ *   bypass jj.
+ * - `false` for directories backed by neither tool.
+ */
+export declare function isPureJjRepo(cwd: string): Promise<boolean>;

package/dist/types/utils/title-generator.d.ts

@@ -1,8 +1,6 @@
 import { type Api, type Model } from "@oh-my-pi/pi-ai";
 import type { ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
-export declare const TITLE_LOCAL_FALLBACK_DELAY_MS = 10000;
-export declare function raceFirstNonNull<T>(primary: Promise<T | null>, startFallback: () => Promise<T | null>, delayMs?: number, onPrimaryWinAfterFallback?: () => void): Promise<T | null>;
 /**
  * Generate a title for a session based on the first user message.
  *