@oh-my-pi/pi-coding-agent 16.2.13 → 16.3.0

package/dist/types/advisor/config.d.ts

@@ -1,8 +1,10 @@
 /**
  * One advisor declared in a `WATCHDOG.yml` file. `model` is a model selector
  * with an optional `:level` thinking suffix (e.g. `x-ai/grok-code-fast:high`),
- * resolved exactly like any other model override; `tools` is a subset of the
- * read-only investigative tool names (default: all). `instructions` is the
+ * resolved exactly like any other model override; `tools` is a subset of
+ * `BUILTIN_TOOL_NAMES` — any built-in name, including mutating tools such as
+ * `edit`/`write`/`bash` (the advisor is a full agent). Omitted or empty falls
+ * back to the default `read`/`grep`/`glob` subset. `instructions` is the
  * advisor's specialization, appended to the shared baseline.
  */
 export interface AdvisorConfig {

package/dist/types/collab/host.d.ts

@@ -8,8 +8,23 @@
  * agent-registry snapshots (Agent Hub table), hub chat/kill/revive commands,
  * and incremental subagent-transcript reads.
  */
+import type { CollabUiRequestDraft, CollabUiResponseValue } from "@oh-my-pi/pi-wire";
 import type { InteractiveModeContext } from "../modes/types";
 import { type CollabParticipant } from "./protocol";
+/** Max bytes served per fetch-transcript reply (guest re-requests from `newSize`). */
+export declare const TRANSCRIPT_READ_CAP: number;
+/**
+ * Outcome of {@link CollabHost.requestGuestUi}. `answered` carries the guest's
+ * response (an `undefined` value is a genuine guest cancel); `unavailable`
+ * means the collab channel went away (teardown, relay drop) or the request was
+ * aborted before any guest answered — callers MUST NOT treat it as a cancel.
+ */
+export type CollabGuestUiResult = {
+    kind: "answered";
+    value: CollabUiResponseValue;
+} | {
+    kind: "unavailable";
+};
 export declare class CollabHost {
     #private;
     constructor(ctx: InteractiveModeContext);
@@ -21,6 +36,7 @@ export declare class CollabHost {
     /** Read-only variant of {@link webLink}. */
     get webViewLink(): string;
     get participants(): CollabParticipant[];
+    requestGuestUi(request: CollabUiRequestDraft, signal?: AbortSignal): Promise<CollabGuestUiResult> | null;
     start(relayUrl: string, webUrl?: string): Promise<void>;
     /** Broadcast a goodbye, detach all taps, and close the socket. */
     stop(reason: string): Promise<void>;

package/dist/types/collab/protocol.d.ts

@@ -7,12 +7,12 @@
  * control messages that carry no session data.
  */
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
-import type { BusChannel, GuestFrame, ParsedCollabLink, Participant, SessionState, AgentSnapshot as WireAgentSnapshot } from "@oh-my-pi/pi-wire";
+import type { BusChannel, CollabUiRequest, GuestFrame, ParsedCollabLink, Participant, SessionState, AgentSnapshot as WireAgentSnapshot } from "@oh-my-pi/pi-wire";
 import { DEFAULT_RELAY_URL, ENVELOPE_HEADER_LENGTH, ROOM_ID_BYTES } from "@oh-my-pi/pi-wire";
 import type { ContextUsage } from "../extensibility/extensions/types";
 import type { AgentSessionEvent } from "../session/agent-session";
 import type { SessionEntry, SessionHeader } from "../session/session-entries";
-export type { CollabPromptDetails, ParsedCollabLink, RelayControlMessage, RelayControlToGuest, RelayControlToHost, } from "@oh-my-pi/pi-wire";
+export type { CollabPromptDetails, CollabUiRequest, CollabUiRequestDraft, CollabUiResponseValue, CollabUiSelectItem, ParsedCollabLink, RelayControlMessage, RelayControlToGuest, RelayControlToHost, } from "@oh-my-pi/pi-wire";
 export { COLLAB_PROMPT_MESSAGE_TYPE, COLLAB_PROTO } from "@oh-my-pi/pi-wire";
 export { DEFAULT_RELAY_URL, ENVELOPE_HEADER_LENGTH, ROOM_ID_BYTES };
 export type CollabParticipant = Participant;
@@ -86,8 +86,14 @@ export type CollabFrame = Exclude<GuestFrame, {
  | {
     t: "agents";
     agents: AgentSnapshot[];
+} | {
+    t: "ui-request";
+    request: CollabUiRequest;
+} | {
+    t: "ui-request-end";
+    reqId: number;
 }
-/** Targeted reply to fetch-transcript; `text` is decoded JSONL from `fromByte`, `newSize` the next offset base. */
+/** Targeted reply to fetch-transcript; `error` marks a terminal read failure that guests must surface without hot retrying. */
  | {
     t: "transcript";
     reqId: number;

package/dist/types/commit/model-selection.d.ts

@@ -11,6 +11,11 @@ export interface ResolvedCommitModel {
      * central force-refresh + account-rotation policy.
      */
     apiKey: ApiKey;
+    /**
+     * Commit-time inference is stateless: session-level auto classification
+     * isn't available, so an explicit `:auto` selector collapses to "no
+     * override" and the model's own default level fills in.
+     */
     thinkingLevel?: ThinkingLevel;
 }
 type CommitModelRegistry = ModelLookupRegistry & ApiKeyResolverRegistry & {

package/dist/types/config/model-resolver.d.ts

@@ -16,6 +16,7 @@
  */
 import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Effort, Model } from "@oh-my-pi/pi-ai";
+import { type ConfiguredThinkingLevel } from "../thinking";
 import { type ModelRegistry } from "./model-registry";
 import { type ModelRole } from "./model-roles";
 import type { Settings } from "./settings";
@@ -34,6 +35,7 @@ export interface ScopedModel {
 }
 interface ThinkingSuffixOptions {
     allowMaxAlias?: boolean;
+    allowAutoAlias?: boolean;
 }
 interface ModelStringParseOptions extends ThinkingSuffixOptions {
     isLiteralModelId?: (provider: string, id: string) => boolean;
@@ -45,14 +47,14 @@ interface ModelStringParseOptions extends ThinkingSuffixOptions {
 export declare function parseModelString(modelStr: string, options?: ModelStringParseOptions): {
     provider: string;
     id: string;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
 } | undefined;
 /**
  * Format a model as "provider/modelId" string.
  */
 export declare function formatModelString(model: Model<Api>): string;
 export declare function formatModelStringWithRouting(model: Model<Api>): string;
-export declare function formatModelSelectorValue(selector: string, thinkingLevel: ThinkingLevel | undefined): string;
+export declare function formatModelSelectorValue(selector: string, thinkingLevel: ConfiguredThinkingLevel | undefined): string;
 /**
  * Split a trailing `@<upstream>` provider-routing selector off a model pattern.
  *
@@ -83,7 +85,7 @@ export declare function getModelMatchPreferences(settings?: Partial<Pick<Setting
 export interface ParsedModelResult {
     model: Model<Api> | undefined;
     /** Thinking level if explicitly specified in pattern, undefined otherwise */
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
     /** Upstream provider slug from an `@upstream` routing selector, if present. */
     upstream?: string;
     warning: string | undefined;
@@ -110,7 +112,7 @@ export declare function resolveAgentModelPatterns(options: AgentModelPatternReso
  */
 export interface ResolvedModelRoleValue {
     model: Model<Api> | undefined;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
     explicitThinkingLevel: boolean;
     warning: string | undefined;
 }
@@ -121,7 +123,7 @@ export declare function resolveModelRoleValue(roleValue: string | undefined, ava
 interface ExplicitThinkingSelectorOptions {
     isLiteralModelId?: (provider: string, id: string) => boolean;
 }
-export declare function extractExplicitThinkingSelector(value: string | undefined, settings?: Settings, options?: ExplicitThinkingSelectorOptions): ThinkingLevel | undefined;
+export declare function extractExplicitThinkingSelector(value: string | undefined, settings?: Settings, options?: ExplicitThinkingSelectorOptions): ConfiguredThinkingLevel | undefined;
 /**
  * Resolve a model identifier or pattern to a Model instance.
  */
@@ -140,7 +142,7 @@ export declare function resolveModelFromSettings(options: {
  */
 export declare function resolveModelOverride(modelPatterns: string[], modelRegistry: ModelLookupRegistry, settings?: Settings): {
     model?: Model<Api>;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
     explicitThinkingLevel: boolean;
 };
 /**
@@ -166,7 +168,7 @@ export declare function resolveModelOverride(modelPatterns: string[], modelRegis
  */
 export declare function resolveModelOverrideWithAuthFallback(modelPatterns: string[], parentActiveModelPattern: string | undefined, modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">, settings?: Settings): Promise<{
     model?: Model<Api>;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
     explicitThinkingLevel: boolean;
     authFallbackUsed: boolean;
 }>;
@@ -175,7 +177,7 @@ export declare function resolveModelOverrideWithAuthFallback(modelPatterns: stri
  */
 export declare function resolveRoleSelection(roles: readonly string[], settings: Settings, availableModels: Model<Api>[]): {
     model: Model<Api>;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
 } | undefined;
 /**
  * Resolve the model for the `advisor` role. A configured `modelRoles.advisor`
@@ -187,7 +189,7 @@ export declare function resolveRoleSelection(roles: readonly string[], settings:
  */
 export declare function resolveAdvisorRoleSelection(settings: Settings, availableModels: Model<Api>[]): {
     model: Model<Api>;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
 } | undefined;
 /**
  * Resolve model patterns to actual Model objects with optional thinking levels
@@ -234,7 +236,7 @@ export declare function filterAvailableModelsByEnabledPatterns(available: Model<
 export interface ResolveCliModelResult {
     model: Model<Api> | undefined;
     selector?: string;
-    thinkingLevel?: ThinkingLevel;
+    thinkingLevel?: ConfiguredThinkingLevel;
     warning: string | undefined;
     error: string | undefined;
 }

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

@@ -85,7 +85,7 @@ interface StringDef {
 }
 interface NumberDef {
     type: "number";
-    default: number;
+    default: number | undefined;
     ui?: UiNumber;
 }
 interface EnumDef<T extends readonly string[]> {
@@ -1401,6 +1401,16 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "providers.anthropic.serverSideFallback": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Retry & Fallback";
+            readonly label: "Anthropic Server-Side Fallback (Fable 5)";
+            readonly description: "When a Claude Fable 5 / Mythos 5 request is blocked by Anthropic's safety classifier, retry it on Claude Opus 4.8 server-side (Anthropic `server-side-fallback-2026-06-01` beta). Opt-in — leaving this off preserves the pre-fallback behavior for every request.";
+        };
+    };
     readonly steeringMode: {
         readonly type: "enum";
         readonly values: readonly ["all", "one-at-a-time"];
@@ -2071,7 +2081,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "compaction.reserveTokens": {
         readonly type: "number";
-        readonly default: 16384;
+        readonly default: undefined;
     };
     readonly "compaction.keepRecentTokens": {
         readonly type: "number";
@@ -4286,7 +4296,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "tasks";
             readonly group: "Subagents";
             readonly label: "Soft Subagent Request Budget";
-            readonly description: "Soft per-subagent request budget (assistant requests per run). Crossing it injects one steering notice asking the subagent to wrap up; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled explore/sonic agents use a lower built-in budget.";
+            readonly description: "Soft per-subagent request budget (assistant requests per run). Crossing it can inject a steering notice when task.softRequestBudgetNotice is enabled; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled explore/sonic agents use a lower built-in budget.";
             readonly options: readonly [{
                 readonly value: "0";
                 readonly label: "Disabled";
@@ -4303,6 +4313,16 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "task.softRequestBudgetNotice": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly group: "Subagents";
+            readonly label: "Soft Request Budget Notice";
+            readonly description: "Inject one steering notice when a subagent crosses its soft request budget. Off by default; enabling it asks the child to wrap up before the 1.5x graceful abort guard.";
+        };
+    };
     readonly "task.disabledAgents": {
         readonly type: "array";
         readonly default: string[];
@@ -4552,7 +4572,7 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "duckduckgo";
                 readonly label: "DuckDuckGo";
-                readonly description: "Scrapes the DuckDuckGo HTML frontend (no API key)";
+                readonly description: "Credential-free best-effort fallback; may be bot-challenged on datacenter/shared-egress IPs";
             }];
         };
     };
@@ -5414,6 +5434,9 @@ export type SettingValue<P extends SettingPath> = Schema[P] extends {
     type: "string";
 } ? string | undefined : Schema[P] extends {
     type: "number";
+    default: undefined;
+} ? number | undefined : Schema[P] extends {
+    type: "number";
 } ? number : Schema[P] extends {
     type: "enum";
     values: infer V;
@@ -5449,7 +5472,7 @@ export interface CompactionSettings {
     strategy: "context-full" | "handoff" | "shake" | "snapcompact" | "off";
     thresholdPercent: number;
     thresholdTokens: number;
-    reserveTokens: number;
+    reserveTokens: number | undefined;
     keepRecentTokens: number;
     midTurnEnabled: boolean;
     handoffSaveToDisk: boolean;

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

@@ -40,6 +40,14 @@ export interface ApplyPatchOptions {
     fuzzyThreshold?: number;
     allowFuzzy?: boolean;
     fs?: FileSystem;
+    /**
+     * Permit `op: "create"` to replace an existing file (full-file overwrite).
+     * The JSON `patch` edit mode sanctions create-as-overwrite for major
+     * restructures (see prompts/tools/patch.md); the Codex `apply_patch`
+     * envelope documents `*** Add File` as strictly non-overwriting and must
+     * leave this unset.
+     */
+    allowCreateOverwrite?: boolean;
 }
 /** Default filesystem implementation using Bun APIs */
 export declare const defaultFileSystem: FileSystem;
@@ -54,6 +62,7 @@ export declare function previewPatch(input: PatchInput, options: ApplyPatchOptio
 export declare function computePatchDiff(input: PatchInput, cwd: string, options?: {
     fuzzyThreshold?: number;
     allowFuzzy?: boolean;
+    allowCreateOverwrite?: boolean;
 }): Promise<{
     diff: string;
     firstChangedLine: number | undefined;
@@ -83,6 +92,8 @@ export interface ExecutePatchSingleOptions {
     batchRequest?: LspBatchRequest;
     allowFuzzy: boolean;
     fuzzyThreshold: number;
+    /** See {@link ApplyPatchOptions.allowCreateOverwrite}; set by the JSON `patch` mode only. */
+    allowCreateOverwrite?: boolean;
     writethrough: WritethroughCallback;
     beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }

package/dist/types/eval/agent-bridge.d.ts

@@ -4,7 +4,11 @@ import type { JsStatusEvent } from "./js/shared/types";
 import "../tools/review";
 /** Synthetic bridge name reserved for the `agent()` helper across both runtimes. */
 export declare const EVAL_AGENT_BRIDGE_NAME = "__agent__";
-/** Hard recursion limit for eval-driven subagents. */
+/**
+ * Hard recursion ceiling for eval-driven subagents. The user setting
+ * `task.maxRecursionDepth` is honored on top of this — whichever is tighter
+ * wins, so a maintainer-friendly cap can't get raised by a user setting.
+ */
 export declare const EVAL_AGENT_MAX_DEPTH = 3;
 export interface EvalAgentBridgeOptions {
     session: ToolSession;

package/dist/types/exec/bash-executor.d.ts

@@ -38,6 +38,7 @@ export interface BashResult {
     outputLines: number;
     outputBytes: number;
     artifactId?: string;
+    workingDir?: string;
 }
 /** Translate `ShellMinimizerSettings` into native `MinimizerOptions`, or `undefined` when disabled. */
 export declare function buildMinimizerOptions(group: ShellMinimizerSettings): MinimizerOptions | undefined;

package/dist/types/extensibility/legacy-pi-coding-agent-shim.d.ts

@@ -14,18 +14,102 @@
 import type { TSchema } from "@oh-my-pi/pi-ai";
 import { Settings } from "../config/settings";
 import type { ToolDefinition } from "./extensions/types";
-import { Type } from "./typebox";
+export interface BashSpawnContext {
+    command: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export type BashSpawnHook = (context: BashSpawnContext) => BashSpawnContext;
+export interface BashOperations {
+    exec: (command: string, cwd: string, options: {
+        onData: (data: Buffer) => void;
+        signal?: AbortSignal;
+        timeout?: number;
+        env?: NodeJS.ProcessEnv;
+    }) => Promise<{
+        exitCode: number | null;
+    }>;
+}
+export interface BashToolOptions {
+    operations?: BashOperations;
+    commandPrefix?: string;
+    spawnHook?: BashSpawnHook;
+}
+export interface ReadToolOptions {
+    /** Auto-resize large images; maps onto the `images.autoResize` setting. Default: true. */
+    autoResizeImages?: boolean;
+}
+export interface GrepToolOptions {
+    /**
+     * Unsupported. The historical grep operations seam (isDirectory/readFile for
+     * context lines) never delegated the search itself — ripgrep always ran
+     * locally — and the built-in native grep tool exposes no filesystem seam at
+     * all. Supplying operations throws at tool creation instead of silently
+     * searching the local filesystem.
+     */
+    operations?: unknown;
+}
+export interface FindOperations {
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    glob: (pattern: string, cwd: string, options: {
+        ignore: string[];
+        limit: number;
+    }) => Promise<string[]> | string[];
+}
+export interface FindToolOptions {
+    operations?: FindOperations;
+}
+export interface LsOperations {
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    stat: (absolutePath: string) => Promise<{
+        isDirectory(): boolean;
+    }> | {
+        isDirectory(): boolean;
+    };
+    readdir: (absolutePath: string) => Promise<string[]> | string[];
+}
+export interface LsToolOptions {
+    operations?: LsOperations;
+}
+/** Parse frontmatter using the historical Pi package-root helper. */
 export interface ParsedFrontmatter<T extends Record<string, unknown> = Record<string, unknown>> {
     frontmatter: T;
     body: string;
 }
+/** Parse YAML frontmatter and throw on invalid metadata. */
 export declare function parseFrontmatter<T extends Record<string, unknown> = Record<string, unknown>>(content: string): ParsedFrontmatter<T>;
+/** Return content without YAML frontmatter. */
 export declare function stripFrontmatter(content: string): string;
+/** Mark an extension-authored tool as a Pi-compatible tool definition. */
 export declare function defineTool<TParams extends TSchema = TSchema, TDetails = unknown>(tool: ToolDefinition<TParams, TDetails>): ToolDefinition<TParams, TDetails>;
+/** Create the legacy read tool definition. */
+export declare function createReadToolDefinition(cwd: string, options?: ReadToolOptions): ToolDefinition;
+/** Create the legacy read tool. */
+export declare function createReadTool(cwd: string, options?: ReadToolOptions): ToolDefinition;
+/** Create the legacy bash tool definition. */
+export declare function createBashToolDefinition(cwd: string, options?: BashToolOptions): ToolDefinition;
+/** Create the legacy bash tool. */
+export declare function createBashTool(cwd: string, options?: BashToolOptions): ToolDefinition;
+/** Create the legacy grep tool definition. */
+export declare function createGrepToolDefinition(cwd: string, options?: GrepToolOptions): ToolDefinition;
+/** Create the legacy grep tool. */
+export declare function createGrepTool(cwd: string, options?: GrepToolOptions): ToolDefinition;
+/** Create the legacy find tool definition. */
+export declare function createFindToolDefinition(cwd: string, options?: FindToolOptions): ToolDefinition;
+/** Create the legacy find tool. */
+export declare function createFindTool(cwd: string, options?: FindToolOptions): ToolDefinition;
+/** Create the legacy ls tool definition. */
+export declare function createLsToolDefinition(cwd: string, options?: LsToolOptions): ToolDefinition;
+/** Create the legacy ls tool. */
+export declare function createLsTool(cwd: string, options?: LsToolOptions): ToolDefinition;
+/** Create legacy read, bash, edit, and write tools. */
 export declare function createCodingTools(cwd: string): ToolDefinition[];
+/** Create legacy read, grep, find, and ls tools. */
+export declare function createReadOnlyTools(cwd: string): ToolDefinition[];
 export declare const SettingsManager: {
     readonly create: (cwd: string, agentDir?: string) => Promise<Settings>;
     readonly inMemory: () => Settings;
 };
 export * from "../index";
-export { Type };
+export { formatBytes as formatSize } from "../tools/render-utils";
+export { Type } from "./typebox";

package/dist/types/extensibility/skills.d.ts

@@ -93,4 +93,5 @@ export interface ParsedSkillInvocation {
  * meant as skill invocations.
  */
 export declare function parseSkillInvocation(text: string): ParsedSkillInvocation | undefined;
-export declare function buildSkillPromptMessage(skill: Pick<Skill, "name" | "filePath">, args: string): Promise<BuiltSkillPromptMessage>;
+export type SkillInvocationKind = "user" | "autoload";
+export declare function buildSkillPromptMessage(skill: Pick<Skill, "name" | "filePath" | "baseDir">, args: string, invocation?: SkillInvocationKind): Promise<BuiltSkillPromptMessage>;

package/dist/types/mnemopi/state.d.ts

@@ -108,9 +108,21 @@ export declare class MnemopiSessionState {
      * e.g. `mnemopiBackend.clear` — pass `{ consolidate: false }` to skip the
      * extraction/sleep pass, since spending tokens on memories that will be
      * wiped on the next line is wasted work (PR #2327 review).
+     *
+     * `timeoutMs` caps how long the consolidate await blocks the caller
+     * (the user-visible `/quit` / `/exit` shutdown path passes this so
+     * dispose returns within a UX budget — issue #3641). When the cap is
+     * hit, dispose returns immediately and detaches the still-in-flight
+     * consolidate; the SQLite handles are closed in the background once
+     * the consolidate settles so writes never race a closed handle, and
+     * any pending embeddings are SIGKILL'd along with the embed worker
+     * (a tolerable loss — working memory rows are durable; only the
+     * episodic promotion / embedding for the LAST few turns is skipped,
+     * and `maybeRetainOnAgentEnd` has already retained earlier turns).
      */
     dispose(options?: {
         consolidate?: boolean;
+        timeoutMs?: number;
     }): Promise<void>;
 }
 export declare function getMnemopiScopedDbPaths(config: MnemopiBackendConfig): readonly string[];

package/dist/types/modes/components/agent-hub.d.ts

@@ -6,16 +6,20 @@ import { IrcBus } from "../../irc/bus";
 import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
 import { AgentRegistry } from "../../registry/agent-registry";
 import type { SessionObserverRegistry } from "../session-observer-registry";
+/** Result of one host-backed transcript read for the Agent Hub viewer. */
+export interface AgentHubRemoteTranscript {
+    text: string;
+    newSize: number;
+    /** Terminal read failure reported by the host; guests should surface it instead of retrying hot. */
+    error?: string;
+}
 /** Guest-side proxy for hub actions executed on the collab host. */
 export interface AgentHubRemote {
     chat(id: string, text: string): void;
     kill(id: string): void;
     revive(id: string): void;
-    /** Mirrors readFileIncremental: text from fromByte (complete JSONL lines), newSize = next fromByte base; null = unavailable. */
-    readTranscript(id: string, fromByte: number): Promise<{
-        text: string;
-        newSize: number;
-    } | null>;
+    /** Mirrors readFileIncremental: text from fromByte (complete JSONL lines), newSize = next fromByte base; null = temporarily unavailable. */
+    readTranscript(id: string, fromByte: number): Promise<AgentHubRemoteTranscript | null>;
 }
 export interface AgentHubDeps {
     /** Progress/status snapshot source (task lifecycle + progress channels). */

package/dist/types/modes/components/status-line/component.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modes/components/usage-row.d.ts

@@ -1,3 +1,3 @@
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { Container } from "@oh-my-pi/pi-tui";
-export declare function createUsageRowBlock(usage: Usage): Container;
+export declare function createUsageRowBlock(usage: Usage, durationMs?: number, ttftMs?: number): Container;

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

@@ -48,7 +48,6 @@ export declare class CommandController {
      * `images` strips image blocks. Rebuilds the chat and reports counts.
      */
     handleShakeCommand(mode: ShakeMode): Promise<void>;
-    handleSkillCommand(skillPath: string, args: string): Promise<void>;
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>, mode?: CompactMode): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
 }

package/dist/types/modes/controllers/extension-ui-controller.d.ts

@@ -26,6 +26,12 @@ export declare class ExtensionUiController {
      * Set hook status text in the footer.
      */
     setHookStatus(key: string, text: string | undefined): void;
+    showCollabAwareSelector(title: string, options: ExtensionUISelectItem[], dialogOptions?: InteractiveSelectorDialogOptions, extra?: {
+        slider?: HookSelectorSlider;
+    }): Promise<string | undefined>;
+    showCollabAwareEditor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
     /**
      * Show a selector for hooks.
      */

package/dist/types/modes/controllers/streaming-reveal.d.ts

@@ -4,14 +4,30 @@ export declare const STREAMING_REVEAL_FRAME_MS: number;
 export declare const MIN_STEP = 3;
 export declare const CATCHUP_FRAMES = 8;
 type StreamingRevealComponent = Pick<AssistantMessageComponent, "updateContent">;
+type GraphemeSlicer = (index: number, text: string, units: number) => string;
 type StreamingRevealControllerOptions = {
     getSmoothStreaming(): boolean;
     getHideThinkingBlock(): boolean;
     getProseOnlyThinking(): boolean;
     requestRender(): void;
 };
+/** Memoizes per-block grapheme counts across reveal ticks. Streaming blocks only
+ *  grow by appending, and an append can only alter the final grapheme cluster of
+ *  the previous text, so only the suffix from that cluster needs re-segmenting. */
+export declare class BlockUnitCounter {
+    #private;
+    count(index: number, text: string): number;
+    reset(): void;
+    /** Slice `text` to its first `units` graphemes. Memoized across reveal ticks:
+     *  streaming blocks grow only by appending and the reveal target advances
+     *  monotonically, so a previously sliced prefix is reused and only the suffix
+     *  from the boundary cluster is re-segmented. Only an exact (text, units) hit
+     *  skips segmentation entirely — an append can extend the boundary cluster, so
+     *  the incremental path still re-segments from that cluster's start. */
+    slice(index: number, text: string, units: number): string;
+}
 export declare function visibleUnits(message: AssistantMessage, hideThinking: boolean, proseOnly?: boolean): number;
-export declare function buildDisplayMessage(target: AssistantMessage, revealed: number, hideThinking: boolean, proseOnly?: boolean, countOf?: (index: number, text: string) => number): AssistantMessage;
+export declare function buildDisplayMessage(target: AssistantMessage, revealed: number, hideThinking: boolean, proseOnly?: boolean, countOf?: (index: number, text: string) => number, sliceOf?: GraphemeSlicer): AssistantMessage;
 export declare function nextStep(backlog: number): number;
 export declare class StreamingRevealController {
     #private;

package/dist/types/modes/controllers/tool-args-reveal.d.ts

@@ -2,6 +2,8 @@
 type ToolArgsRevealComponent = {
     updateArgs(args: unknown, toolCallId?: string): void;
 };
+/** String fields the streamed-args decode reads incrementally for `toolName`. */
+export declare function streamingStringKeysForTool(toolName: string, rawInput: boolean): readonly string[] | undefined;
 type ToolArgsRevealControllerOptions = {
     getSmoothStreaming(): boolean;
     requestRender(): void;
@@ -9,8 +11,29 @@ type ToolArgsRevealControllerOptions = {
 type ToolArgsRevealTarget = {
     rawInput: boolean;
     exposeRawPartialJson: boolean;
-    fullArgs: Record<string, unknown>;
+    streamingStringKeys?: readonly string[];
 };
+type StreamedToolArgsSource = {
+    /** Custom-tool raw text stream (`customWireName` tools): never JSON-parsed. */
+    rawInput: boolean;
+    /** Provider-parsed arguments, spread UNDER the fresh decode: a dialect
+     *  projector may carry keys a raw re-parse cannot recover, but any key the
+     *  fresh parse does recover wins — provider parses lag the stream by up to
+     *  STREAMING_JSON_PARSE_MIN_GROWTH bytes mid-stream. */
+    fullArgs?: Record<string, unknown>;
+    /** See {@link streamingStringKeysForTool}. */
+    streamingStringKeys?: readonly string[];
+};
+/**
+ * One-shot decode of a streamed tool-call argument buffer into display args —
+ * the same decode the live reveal applies frame-by-frame, for paths that see
+ * the buffer once (transcript rebuilds on theme change, settings, focus
+ * replay). Keeps a rebuilt preview identical to the live preview: parsed
+ * fields come from a fresh parse of the full buffer, `streamingStringKeys`
+ * fields from the incremental string decoder (which also wins ties in the
+ * live path), never from the provider's throttled `arguments`.
+ */
+export declare function decodeStreamedToolArgs(partialJson: string, source: StreamedToolArgsSource): Record<string, unknown>;
 /**
  * Paces streamed tool-call arguments the same way StreamingRevealController
  * paces assistant text: providers that deliver `partialJson` in large batches
@@ -30,8 +53,12 @@ export declare class ToolArgsRevealController {
     constructor(options: ToolArgsRevealControllerOptions);
     /**
      * Record the latest streamed argument text for a tool call and return the
-     * args to render right now. With smoothing disabled the full target passes
-     * through in the caller's legacy shape (`{ ...args, __partialJson }`).
+     * args to render right now. With smoothing disabled nothing is paced — the
+     * full received buffer decodes in one step — but the entry still runs the
+     * incremental string decoder + parse throttle, so streamed text fields
+     * (write `content`, edit bodies, eval `code`) stay fresh between the
+     * provider's own throttled full-JSON parses instead of lagging up to
+     * STREAMING_JSON_PARSE_MIN_GROWTH bytes behind.
      */
     setTarget(id: string, partialJson: string, target: ToolArgsRevealTarget): Record<string, unknown>;
     /** Attach the component future ticks push frames into. */