@oh-my-pi/pi-coding-agent 16.1.10 → 16.1.12

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/export/share.d.ts

@@ -1,6 +1,6 @@
 import type { AgentState } from "@oh-my-pi/pi-agent-core";
 import { DEFAULT_SHARE_URL } from "@oh-my-pi/pi-wire";
-import type { SecretObfuscator } from "../secrets/obfuscator";
+import { type SecretObfuscator } from "../secrets/obfuscator";
 import type { SessionManager } from "../session/session-manager";
 import { type SessionData } from "./html";
 export { DEFAULT_SHARE_URL };
@@ -12,10 +12,15 @@ export interface ShareSessionOptions {
     /** Agent state for system prompt + tool descriptions in the snapshot. */
     state?: AgentState;
     /**
-     * Redacts the snapshot before sealing: deep-walks every string (entries,
-     * header, system prompt, tool descriptions) through the obfuscator, so
-     * secrets that landed in persisted entries (tool outputs reading .env,
-     * etc.) never leave the machine. Pass undefined to skip.
+     * Redacts the snapshot before sealing via a typed, per-field walk over the
+     * session (header title/cwd, system prompt, tool descriptions, entry summaries,
+     * labels, and message text — including tool-result output and `@file` mentions),
+     * so secrets that landed in persisted entries (tool outputs reading .env, etc.)
+     * never leave the machine. Inline image bytes are preserved (size-trimmed
+     * separately); opaque provider-replay blobs (`providerPayload`,
+     * `redactedThinking`, `compaction.preserveData`) and untyped extension payloads
+     * (`details`/`data`/`outputSchema`) are dropped rather than walked. Pass
+     * undefined to skip redaction entirely.
      */
     obfuscator?: SecretObfuscator;
 }

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/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/secrets/index.d.ts

@@ -1,5 +1,5 @@
 import type { SecretEntry } from "./obfuscator";
-export { deobfuscateSessionContext, obfuscateMessages, obfuscateProviderContext, obfuscateProviderTools, type SecretEntry, SecretObfuscator, } from "./obfuscator";
+export { deobfuscateSessionContext, deobfuscateToolArguments, obfuscateMessages, obfuscateProviderContext, type SecretEntry, SecretObfuscator, } from "./obfuscator";
 /**
  * Load secrets from project-local and global secrets.yml files.
  * Project-local entries override global entries with matching content.

package/dist/types/secrets/obfuscator.d.ts

@@ -1,4 +1,5 @@
-import type { Context, Message, Tool } from "@oh-my-pi/pi-ai";
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, Context, Message } from "@oh-my-pi/pi-ai";
 import type { SessionContext } from "../session/session-context";
 export interface SecretEntry {
     type: "plain" | "regex";
@@ -7,6 +8,12 @@ export interface SecretEntry {
     replacement?: string;
     flags?: string;
 }
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue | undefined;
+};
+export type JsonRecord = {
+    [key: string]: JsonValue | undefined;
+};
 export declare class SecretObfuscator {
     #private;
     constructor(entries: SecretEntry[]);
@@ -15,15 +22,42 @@ export declare class SecretObfuscator {
     obfuscate(text: string): string;
     /** Deobfuscate obfuscate-mode placeholders back to original secrets. Replace-mode is NOT reversed. */
     deobfuscate(text: string): string;
-    /** Deep-walk an object, deobfuscating all string values. */
-    deobfuscateObject<T>(obj: T): T;
-    /** Deep-walk an object, obfuscating all string values. */
-    obfuscateObject<T>(obj: T): T;
 }
+/**
+ * Restore secret placeholders for local display. Only message kinds the model
+ * itself authored from obfuscated context carry placeholders — assistant
+ * content and the LLM-written branch/compaction summaries. User, developer, and
+ * tool-result messages are persisted with their literal text, so a literal
+ * `#ABCD#` the operator typed must survive untouched; those roles are never
+ * walked.
+ */
 export declare function deobfuscateSessionContext(sessionContext: SessionContext, obfuscator: SecretObfuscator | undefined): SessionContext;
-/** Obfuscate all string content in LLM messages (for outbound interception). */
+export declare function deobfuscateAgentMessages(obfuscator: SecretObfuscator, messages: AgentMessage[]): AgentMessage[];
+/**
+ * Restore placeholders in assistant content: visible text, thinking text, and
+ * tool-call arguments/intent/rawBlock. Signatures and redacted-thinking bytes
+ * are opaque provider-replay data and pass through byte-identical.
+ */
+export declare function deobfuscateAssistantContent(obfuscator: SecretObfuscator, content: AssistantMessage["content"]): AssistantMessage["content"];
+/**
+ * Restore placeholders inside a tool call's arguments. Arguments are arbitrary
+ * model-authored JSON, so tool-call arguments are the ONLY place a recursive
+ * JSON walk runs.
+ */
+export declare function deobfuscateToolArguments(obfuscator: SecretObfuscator, args: Record<string, unknown>): Record<string, unknown>;
+/** Redact secrets inside a tool call's arguments (same JSON-walk exception as {@link deobfuscateToolArguments}). */
+export declare function obfuscateToolArguments(obfuscator: SecretObfuscator, args: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Redact secrets from outbound messages. Opt-in by origin: only user messages,
+ * tool results, and user-authored developer messages (e.g. `@file` mentions)
+ * can carry operator secrets. System prompts, tool schemas, and assistant
+ * output are author-controlled or model-generated and pass through untouched.
+ * Within a targeted message only `text` blocks are rewritten — inline image
+ * bytes are never walked.
+ */
 export declare function obfuscateMessages(obfuscator: SecretObfuscator, messages: Message[]): Message[];
-/** Obfuscate provider request context without walking live tool schema instances. */
+/**
+ * Redact outbound provider context. Only conversation messages are rewritten;
+ * the static system prompt and tool schemas pass through unchanged.
+ */
 export declare function obfuscateProviderContext(obfuscator: SecretObfuscator | undefined, context: Context): Context;
-/** Convert tool schemas to wire JSON Schema before obfuscating provider-visible strings. */
-export declare function obfuscateProviderTools(obfuscator: SecretObfuscator | undefined, tools: Tool[] | undefined): Tool[] | undefined;

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/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/cmux/cmux-tab.d.ts

@@ -93,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[]>;
@@ -101,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/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.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.10",
+	"version": "16.1.12",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.10",
-		"@oh-my-pi/omp-stats": "16.1.10",
-		"@oh-my-pi/pi-agent-core": "16.1.10",
-		"@oh-my-pi/pi-ai": "16.1.10",
-		"@oh-my-pi/pi-catalog": "16.1.10",
-		"@oh-my-pi/pi-mnemopi": "16.1.10",
-		"@oh-my-pi/pi-natives": "16.1.10",
-		"@oh-my-pi/pi-tui": "16.1.10",
-		"@oh-my-pi/pi-utils": "16.1.10",
-		"@oh-my-pi/pi-wire": "16.1.10",
-		"@oh-my-pi/snapcompact": "16.1.10",
+		"@oh-my-pi/hashline": "16.1.12",
+		"@oh-my-pi/omp-stats": "16.1.12",
+		"@oh-my-pi/pi-agent-core": "16.1.12",
+		"@oh-my-pi/pi-ai": "16.1.12",
+		"@oh-my-pi/pi-catalog": "16.1.12",
+		"@oh-my-pi/pi-mnemopi": "16.1.12",
+		"@oh-my-pi/pi-natives": "16.1.12",
+		"@oh-my-pi/pi-tui": "16.1.12",
+		"@oh-my-pi/pi-utils": "16.1.12",
+		"@oh-my-pi/pi-wire": "16.1.12",
+		"@oh-my-pi/snapcompact": "16.1.12",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/generate-share-viewer.ts

@@ -19,8 +19,10 @@ if (!outPath) {
 }
 
 const loaderJs = await Bun.file(new URL("../src/export/html/share-loader.js", import.meta.url).pathname).text();
-// Pin a built-in theme: the viewer is a public artifact, not a per-user export.
-const themeVars = await generateThemeVars("dark");
+// Pin the omp brand palette (collab-web pink/purple identity) — the viewer is
+// a public artifact matching the live my.omp.sh client, not a per-user export
+// that should mirror the host's terminal theme.
+const themeVars = await generateThemeVars("web");
 
 const html = getTemplate()
 	.replace("<theme-vars/>", () => `<style>:root { ${themeVars} }</style>`)

package/src/autoresearch/git.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "../extensibility/extensions";
 import * as git from "../utils/git";
+import * as jj from "../utils/jj";
 import { normalizePathSpec } from "./helpers";
 
 const AUTORESEARCH_BRANCH_PREFIX = "autoresearch/";
@@ -37,6 +38,17 @@ export async function ensureAutoresearchBranch(
 	workDir: string,
 	goal: string | null,
 ): Promise<EnsureAutoresearchBranchResult> {
+	// Pure-jj check runs first so a jj workspace nested under an unrelated
+	// outer Git checkout is rejected at its own root rather than silently
+	// creating `autoresearch/*` branches and commits in the surrounding Git
+	// tree behind jj's back.
+	if (await jj.isPureJjRepo(workDir)) {
+		return {
+			ok: false,
+			error: "Autoresearch needs a Git checkout for branch isolation and baseline commits, but this workspace is pure Jujutsu (`.jj/` without a colocated `.git/`). Run `jj git init --colocate` to add a Git checkout before starting autoresearch.",
+		};
+	}
+
 	const repoRoot = await git.repo.root(workDir);
 	if (!repoRoot) {
 		return {