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

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

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.10",
+	"version": "16.1.11",
 	"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.11",
+		"@oh-my-pi/omp-stats": "16.1.11",
+		"@oh-my-pi/pi-agent-core": "16.1.11",
+		"@oh-my-pi/pi-ai": "16.1.11",
+		"@oh-my-pi/pi-catalog": "16.1.11",
+		"@oh-my-pi/pi-mnemopi": "16.1.11",
+		"@oh-my-pi/pi-natives": "16.1.11",
+		"@oh-my-pi/pi-tui": "16.1.11",
+		"@oh-my-pi/pi-utils": "16.1.11",
+		"@oh-my-pi/pi-wire": "16.1.11",
+		"@oh-my-pi/snapcompact": "16.1.11",
 		"@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 {

package/src/discovery/opencode.ts

@@ -91,15 +91,55 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 /** OpenCode MCP server config (from opencode.json "mcp" key) */
 interface OpenCodeMCPConfig {
 	type?: "local" | "remote";
-	command?: string;
+	command?: string | string[];
 	args?: string[];
 	env?: Record<string, string>;
+	environment?: Record<string, string>;
 	url?: string;
 	headers?: Record<string, string>;
 	enabled?: boolean;
 	timeout?: number;
 }
 
+function stringArray(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	for (const item of value) {
+		if (typeof item !== "string") return undefined;
+	}
+	return value;
+}
+
+function stringRecord(value: unknown): Record<string, string> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+
+	const record: Record<string, string> = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (typeof item !== "string") return undefined;
+		record[key] = item;
+	}
+	return record;
+}
+
+function normalizeCommand(
+	commandValue: string | string[] | undefined,
+	argsValue: unknown,
+): { command: string | undefined; args: string[] | undefined } {
+	const configuredArgs = stringArray(argsValue);
+	if (Array.isArray(commandValue)) {
+		const [command, ...commandArgs] = commandValue;
+		const args = configuredArgs ? [...commandArgs, ...configuredArgs] : commandArgs;
+		return {
+			command: typeof command === "string" ? command : undefined,
+			args: args.length > 0 ? args : undefined,
+		};
+	}
+
+	return {
+		command: typeof commandValue === "string" ? commandValue : undefined,
+		args: configuredArgs && configuredArgs.length > 0 ? configuredArgs : undefined,
+	};
+}
+
 async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
@@ -161,11 +201,14 @@ function extractMCPServers(
 			transport = "stdio";
 		}
 
+		const command = normalizeCommand(serverConfig.command, serverConfig.args);
+		const env = stringRecord(serverConfig.environment) ?? stringRecord(serverConfig.env);
+
 		items.push({
 			name,
-			command: serverConfig.command,
-			args: Array.isArray(serverConfig.args) ? (serverConfig.args as string[]) : undefined,
-			env: serverConfig.env && typeof serverConfig.env === "object" ? serverConfig.env : undefined,
+			command: command.command,
+			args: command.args,
+			env,
 			url: typeof serverConfig.url === "string" ? serverConfig.url : undefined,
 			headers: serverConfig.headers && typeof serverConfig.headers === "object" ? serverConfig.headers : undefined,
 			enabled: serverConfig.enabled,

package/src/edit/hashline/filesystem.ts

@@ -20,6 +20,7 @@ import { Filesystem, NotFoundError, type WriteResult } from "@oh-my-pi/hashline"
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
+import { routeWriteThroughBridge } from "../../tools/acp-bridge";
 import { assertEditableFileContent } from "../../tools/auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
@@ -110,6 +111,13 @@ export class HashlineFilesystem extends Filesystem {
 		await this.preflightWrite(relativePath);
 		const absolutePath = this.resolveAbsolute(relativePath);
 		const finalContent = await serializeEditFileText(absolutePath, relativePath, content);
+
+		// Route through ACP bridge when available; skips internal artifacts.
+		if (await routeWriteThroughBridge(this.session, relativePath, absolutePath, finalContent)) {
+			this.#diagnosticsByPath.set(relativePath, undefined);
+			return { text: finalContent };
+		}
+
 		const diagnostics = await this.#writethrough(
 			absolutePath,
 			finalContent,