@oh-my-pi/pi-coding-agent 17.0.4 → 17.0.5

package/dist/types/advisor/advise-tool.d.ts

@@ -54,6 +54,8 @@ export declare function isAdvisorInterruptImmuneTurnActive(opts: {
 /**
  * Decide how one advisor note reaches the primary agent.
  *
+ * - A `preserveOnly` caller records every note that arrives while the primary
+ *   is idle as a visible card and never starts a new primary turn.
  * - A non-interrupting `nit` always rides the non-interrupting aside queue.
  * - An interrupting `concern`/`blocker` is normally steered into the agent: into
  *   the live turn while one is streaming, or (when idle) a triggered turn so the
@@ -82,6 +84,7 @@ export declare function resolveAdvisorDeliveryChannel(opts: {
     aborting: boolean;
     terminalAnswerNoQueuedWork?: boolean;
     interruptImmuneTurnActive?: boolean;
+    preserveOnly?: boolean;
 }): AdvisorDeliveryChannel;
 /**
  * Derive the advisor loop's telemetry from the primary session's config so the

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

@@ -117,7 +117,13 @@ export declare class AdvisorRuntime {
     onTurnEnd(messages?: AgentMessage[], opts?: {
         willContinue?: boolean;
     }): void;
-    waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<void>;
+    /**
+     * Wait until the advisor backlog falls below `threshold`.
+     *
+     * Returns `false` when the deadline, abort signal, or a runtime failure releases
+     * the waiter before the requested backlog was drained.
+     */
+    waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<boolean>;
     dispose(): void;
     /**
      * Re-prime the advisor after a history rewrite (compaction, session

package/dist/types/async/job-manager.d.ts

@@ -8,6 +8,8 @@ export interface AsyncJob {
     promise: Promise<void>;
     resultText?: string;
     errorText?: string;
+    /** Latest tool-render details reported by the running job. */
+    latestDetails?: Record<string, unknown>;
     /**
      * Registry id of the agent that registered the job (e.g. "Main",
      * "AuthLoader"). Used by scoped cancel/list APIs so a subagent's teardown

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

@@ -124,6 +124,13 @@ export declare class ModelRegistry {
      * {@link ModelRegistry.resolver}.
      */
     hasConfiguredAuth(model: Model<Api>): boolean;
+    /**
+     * Whether the provider's configured API key is resolved from a command.
+     *
+     * Callers use this to distinguish the registry's command-first resolver
+     * path from lower-priority credentials in {@link authStorage}.
+     */
+    hasCommandBackedApiKey(provider: string): boolean;
     getDiscoverableProviders(): string[];
     getProviderDiscoveryState(provider: string): ProviderDiscoveryState | undefined;
     /**

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

@@ -133,6 +133,8 @@ export declare function resolveAgentPrewalkPattern(options: AgentPrewalkResoluti
 export interface ResolvedModelRoleValue {
     model: Model<Api> | undefined;
     thinkingLevel?: ConfiguredThinkingLevel;
+    /** matchedPatternIndex identifies the first configured pattern that matched an available model. */
+    matchedPatternIndex?: number;
     explicitThinkingLevel: boolean;
     warning: string | undefined;
 }
@@ -263,6 +265,10 @@ export declare function resolveAllowedModels(modelRegistry: Pick<ModelRegistry,
 export declare function filterAvailableModelsByEnabledPatterns(available: Model<Api>[], patterns: readonly string[], settings?: Settings): Model<Api>[];
 export interface ResolveCliModelResult {
     model: Model<Api> | undefined;
+    /** configuredPatterns is the full configured fallback chain when the selector resolves through a role. */
+    configuredPatterns?: string[];
+    /** configuredPatternIndex identifies the configured role pattern that matched an available model. */
+    configuredPatternIndex?: number;
     selector?: string;
     thinkingLevel?: ConfiguredThinkingLevel;
     warning: string | undefined;
@@ -270,6 +276,8 @@ export interface ResolveCliModelResult {
 }
 /**
  * Resolve a single model from CLI flags.
+ *
+ * Exact model names take precedence over configured role names.
  */
 export declare function resolveCliModel(options: {
     cliProvider?: string;

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

@@ -47,6 +47,7 @@ export declare const OpenAICompatSchema: import("arktype/internal/variants/objec
     strictResponsesPairing?: boolean | undefined;
     supportsImageDetailOriginal?: boolean | undefined;
     supportsEagerToolInputStreaming?: boolean | undefined;
+    allowAnthropicHeaderOverrides?: boolean | undefined;
     requiresToolResultId?: boolean | undefined;
     replayUnsignedThinking?: boolean | undefined;
     whenThinking?: {
@@ -98,6 +99,7 @@ export declare const OpenAICompatSchema: import("arktype/internal/variants/objec
         strictResponsesPairing?: boolean | undefined;
         supportsImageDetailOriginal?: boolean | undefined;
         supportsEagerToolInputStreaming?: boolean | undefined;
+        allowAnthropicHeaderOverrides?: boolean | undefined;
         requiresToolResultId?: boolean | undefined;
         replayUnsignedThinking?: boolean | undefined;
     } | undefined;
@@ -192,6 +194,7 @@ export declare const ModelOverrideSchema: import("arktype/internal/variants/obje
         strictResponsesPairing?: boolean | undefined;
         supportsImageDetailOriginal?: boolean | undefined;
         supportsEagerToolInputStreaming?: boolean | undefined;
+        allowAnthropicHeaderOverrides?: boolean | undefined;
         requiresToolResultId?: boolean | undefined;
         replayUnsignedThinking?: boolean | undefined;
         whenThinking?: {
@@ -243,6 +246,7 @@ export declare const ModelOverrideSchema: import("arktype/internal/variants/obje
             strictResponsesPairing?: boolean | undefined;
             supportsImageDetailOriginal?: boolean | undefined;
             supportsEagerToolInputStreaming?: boolean | undefined;
+            allowAnthropicHeaderOverrides?: boolean | undefined;
             requiresToolResultId?: boolean | undefined;
             replayUnsignedThinking?: boolean | undefined;
         } | undefined;
@@ -324,6 +328,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                 strictResponsesPairing?: boolean | undefined;
                 supportsImageDetailOriginal?: boolean | undefined;
                 supportsEagerToolInputStreaming?: boolean | undefined;
+                allowAnthropicHeaderOverrides?: boolean | undefined;
                 requiresToolResultId?: boolean | undefined;
                 replayUnsignedThinking?: boolean | undefined;
                 whenThinking?: {
@@ -375,6 +380,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                     strictResponsesPairing?: boolean | undefined;
                     supportsImageDetailOriginal?: boolean | undefined;
                     supportsEagerToolInputStreaming?: boolean | undefined;
+                    allowAnthropicHeaderOverrides?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                 } | undefined;
@@ -486,6 +492,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                     strictResponsesPairing?: boolean | undefined;
                     supportsImageDetailOriginal?: boolean | undefined;
                     supportsEagerToolInputStreaming?: boolean | undefined;
+                    allowAnthropicHeaderOverrides?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                     whenThinking?: {
@@ -537,6 +544,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                         strictResponsesPairing?: boolean | undefined;
                         supportsImageDetailOriginal?: boolean | undefined;
                         supportsEagerToolInputStreaming?: boolean | undefined;
+                        allowAnthropicHeaderOverrides?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                     } | undefined;
@@ -644,6 +652,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                         strictResponsesPairing?: boolean | undefined;
                         supportsImageDetailOriginal?: boolean | undefined;
                         supportsEagerToolInputStreaming?: boolean | undefined;
+                        allowAnthropicHeaderOverrides?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                         whenThinking?: {
@@ -695,6 +704,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                             strictResponsesPairing?: boolean | undefined;
                             supportsImageDetailOriginal?: boolean | undefined;
                             supportsEagerToolInputStreaming?: boolean | undefined;
+                            allowAnthropicHeaderOverrides?: boolean | undefined;
                             requiresToolResultId?: boolean | undefined;
                             replayUnsignedThinking?: boolean | undefined;
                         } | undefined;

package/dist/types/config/models-config.d.ts

@@ -85,6 +85,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                 strictResponsesPairing?: boolean | undefined;
                 supportsImageDetailOriginal?: boolean | undefined;
                 supportsEagerToolInputStreaming?: boolean | undefined;
+                allowAnthropicHeaderOverrides?: boolean | undefined;
                 requiresToolResultId?: boolean | undefined;
                 replayUnsignedThinking?: boolean | undefined;
                 whenThinking?: {
@@ -136,6 +137,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                     strictResponsesPairing?: boolean | undefined;
                     supportsImageDetailOriginal?: boolean | undefined;
                     supportsEagerToolInputStreaming?: boolean | undefined;
+                    allowAnthropicHeaderOverrides?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                 } | undefined;
@@ -231,6 +233,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                     strictResponsesPairing?: boolean | undefined;
                     supportsImageDetailOriginal?: boolean | undefined;
                     supportsEagerToolInputStreaming?: boolean | undefined;
+                    allowAnthropicHeaderOverrides?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                     whenThinking?: {
@@ -282,6 +285,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                         strictResponsesPairing?: boolean | undefined;
                         supportsImageDetailOriginal?: boolean | undefined;
                         supportsEagerToolInputStreaming?: boolean | undefined;
+                        allowAnthropicHeaderOverrides?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                     } | undefined;
@@ -373,6 +377,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                         strictResponsesPairing?: boolean | undefined;
                         supportsImageDetailOriginal?: boolean | undefined;
                         supportsEagerToolInputStreaming?: boolean | undefined;
+                        allowAnthropicHeaderOverrides?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                         whenThinking?: {
@@ -424,6 +429,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                             strictResponsesPairing?: boolean | undefined;
                             supportsImageDetailOriginal?: boolean | undefined;
                             supportsEagerToolInputStreaming?: boolean | undefined;
+                            allowAnthropicHeaderOverrides?: boolean | undefined;
                             requiresToolResultId?: boolean | undefined;
                             replayUnsignedThinking?: boolean | undefined;
                         } | undefined;

package/dist/types/dap/client.d.ts

@@ -23,14 +23,24 @@ export declare class DapClient {
     readonly adapter: DapResolvedAdapter;
     readonly cwd: string;
     readonly proc: DapClientState["proc"];
+    /** TCP server port reused by child DAP sessions. */
+    readonly port?: number;
     constructor(adapter: DapResolvedAdapter, cwd: string, proc: DapClientState["proc"], options?: {
         readable?: ReadableStream<Uint8Array>;
         writeSink?: DapWriteSink;
         socket?: {
             end(): void;
         };
+        port?: number;
     });
     static spawn({ adapter, cwd, socketReadyTimeoutMs }: DapSpawnOptions): Promise<DapClient>;
+    /** Connect to another session on an existing TCP DAP server. */
+    static connect({ adapter, cwd, host, port, }: {
+        adapter: DapResolvedAdapter;
+        cwd: string;
+        host: string;
+        port: number;
+    }): Promise<DapClient>;
     get capabilities(): DapCapabilities | undefined;
     get lastActivity(): number;
     isAlive(): boolean;

package/dist/types/dap/types.d.ts

@@ -418,10 +418,9 @@ export interface DapAdapterConfig {
     launchDefaults?: Record<string, unknown>;
     attachDefaults?: Record<string, unknown>;
     /** "stdio" (default): communicate via stdin/stdout pipes.
-     *  "socket": adapter uses a network socket instead of stdio.
-     *  On Linux, connects via a unix domain socket.
-     *  On macOS, the adapter dials into a local TCP listener (--client-addr). */
-    connectMode?: "stdio" | "socket";
+     *  "socket": adapter-specific socket launch (currently Delve).
+     *  "tcp": spawn a DAP server with `${port}` substituted in `args`, then connect to it. */
+    connectMode?: "stdio" | "socket" | "tcp";
     /** When true, the adapter accepts a directory as the launch `program`
      *  (e.g. dlv treats it as a Go package path). When false/undefined, the
      *  debug tool rejects directory programs upfront. */
@@ -437,7 +436,7 @@ export interface DapResolvedAdapter {
     rootMarkers: string[];
     launchDefaults: Record<string, unknown>;
     attachDefaults: Record<string, unknown>;
-    connectMode: "stdio" | "socket";
+    connectMode: "stdio" | "socket" | "tcp";
     acceptsDirectoryProgram: boolean;
 }
 export interface DapBreakpointRecord {
@@ -508,6 +507,8 @@ export interface DapSessionSummary {
     outputTruncated: boolean;
     exitCode?: number;
     needsConfigurationDone: boolean;
+    parentSessionId?: string;
+    childSessionIds?: string[];
 }
 export interface DapContinueOutcome {
     snapshot: DapSessionSummary;

package/dist/types/extensibility/extensions/runner.d.ts

@@ -113,7 +113,8 @@ export declare class ExtensionRunner {
         path: string;
     }>;
     getCommand(name: string): RegisteredCommand | undefined;
-    createContext(): ExtensionContext;
+    /** Creates an extension context, optionally scoped to a provider request model. */
+    createContext(model?: Model): ExtensionContext;
     /**
      * Request a graceful shutdown. Called by extension tools and event handlers.
      */
@@ -164,7 +165,8 @@ export declare class ExtensionRunner {
     /** Emit input event. Transforms chain, "handled" short-circuits. */
     emitInput(text: string, images: ImageContent[] | undefined, source: "interactive" | "rpc" | "extension"): Promise<InputEventResult>;
     emitContext(messages: AgentMessage[]): Promise<AgentMessage[]>;
-    emitBeforeProviderRequest(payload: unknown): Promise<BeforeProviderRequestEventResult>;
+    /** Runs request payload hooks with the model used for that provider request. */
+    emitBeforeProviderRequest(payload: unknown, model?: Model): Promise<BeforeProviderRequestEventResult>;
     emitAfterProviderResponse(response: ProviderResponseMetadata, _model?: Model): Promise<void>;
     emitBeforeAgentStart(prompt: string, images: ImageContent[] | undefined, systemPrompt: string[]): Promise<BeforeAgentStartCombinedResult | undefined>;
 }

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

@@ -353,6 +353,22 @@ export declare class AuthStorage {
 }
 /** Read the first active credential for a legacy extension provider. */
 export declare function readStoredCredential(provider: string): AuthCredential | undefined;
+export { getProjectDir } from "@oh-my-pi/pi-utils";
+/**
+ * Coding-agent package install directory, matching pi's string-valued
+ * `getPackageDir()` contract (extensions do `path.join(getPackageDir(), ...)`
+ * to auto-allow bundled docs/resources).
+ *
+ * omp's canonical `getPackageDir()` (`../config`) returns `undefined` inside a
+ * `bun --compile` binary — `import.meta.dir` is `/$bunfs/root` and no owning
+ * `package.json` exists (issue #1423). Returning `undefined` there would crash
+ * every legacy `path.join(getPackageDir(), ...)` at runtime in the shipped
+ * binary, the primary distribution. So fall back to the executable's own
+ * directory in compiled mode, where the binary *is* the install root. The
+ * `PI_PACKAGE_DIR` override and dev/source/npm-dist walk-up still win via the
+ * canonical helper.
+ */
+export declare function getPackageDir(): string;
 export * from "../index.js";
 export { formatBytes as formatSize } from "../tools/render-utils.js";
 export { Type } from "./typebox.js";

package/dist/types/launch/spawn-options.d.ts

@@ -0,0 +1,10 @@
+/** Platform-specific options for the launch broker and its non-PTY children. */
+export interface DaemonSpawnOptions {
+    detached: boolean;
+    windowsHide?: boolean;
+}
+/** Keep launch processes headless without discarding an inheritable Windows console. */
+export declare function resolveDaemonSpawnOptions(opts: {
+    platform: NodeJS.Platform;
+    hostHasInheritableConsole: boolean;
+}): DaemonSpawnOptions;

package/dist/types/launch/spawn-options.test.d.ts

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

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

@@ -1,5 +1,6 @@
 import { type Component } from "@oh-my-pi/pi-tui";
 import type { AgentSession } from "../../../session/agent-session.js";
+import { type SegmentContext } from "./segments.js";
 import type { CollabStatus, EffectiveStatusLineSettings, StatusLineSettings } from "./types.js";
 export declare class StatusLineComponent implements Component {
     #private;
@@ -55,9 +56,7 @@ export declare class StatusLineComponent implements Component {
         enabled: boolean;
         paused: boolean;
     } | undefined): void;
-    setLoopModeStatus(status: {
-        enabled: boolean;
-    } | undefined): void;
+    setLoopModeStatus(status: NonNullable<SegmentContext["loopMode"]> | undefined): void;
     setGoalModeStatus(status: {
         enabled: boolean;
         paused: boolean;

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

@@ -2,6 +2,7 @@ import type { CollabSessionState } from "../../../collab/protocol.js";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../../config/settings-schema.js";
 import type { AgentSession } from "../../../session/agent-session.js";
 import type { ActiveRepoContext } from "../../../utils/active-repo-context.js";
+import type { LoopLimitRuntime } from "../../loop-limit.js";
 export type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle };
 /** Collab session indicator + (guest-only) host-state override for segments. */
 export interface CollabStatus {
@@ -64,7 +65,8 @@ export interface SegmentContext {
         enabled: boolean;
     } | null;
     loopMode: {
-        enabled: boolean;
+        state: "waiting" | "running" | "paused";
+        limit?: LoopLimitRuntime;
     } | null;
     goalMode: {
         enabled: boolean;

package/dist/types/modes/components/tool-execution.d.ts

@@ -92,6 +92,8 @@ export declare class ToolExecutionComponent extends Container implements NativeS
      * immutable native scrollback before the result replaces them.
      */
     getNativeScrollbackLiveRegionStart(): number | undefined;
+    /** Keeps the in-flight `vibe_wait` TV wall out of immutable native scrollback. */
+    isNativeScrollbackLiveRegionPinned(): boolean;
     /**
      * Whether this block has reached a terminal state for transcript freezing.
      * Reports `false` while it can still visually change so the

package/dist/types/modes/components/transcript-container.d.ts

@@ -1,4 +1,4 @@
-import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type NativeScrollbackReplay, type RenderStablePrefix, type ViewportTailProvider } from "@oh-my-pi/pi-tui";
+import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type RenderStablePrefix, type ViewportTailProvider } from "@oh-my-pi/pi-tui";
 /**
  * Transcript container that renders every block's current content each frame
  * and reports the native-scrollback exactness boundary
@@ -24,14 +24,15 @@ import { type Component, Container, type NativeScrollbackCommittedRows, type Nat
  * through {@link RenderStablePrefix} so the engine can skip marker scanning,
  * line preparation, and the committed-prefix audit for those rows.
  */
-export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, NativeScrollbackReplay, RenderStablePrefix, ViewportTailProvider {
+export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix, ViewportTailProvider {
     #private;
     invalidate(): void;
     clear(): void;
     setNativeScrollbackCommittedRows(rows: number): void;
-    prepareNativeScrollbackReplay(): void;
     getRenderStablePrefixRows(): number;
     getNativeScrollbackLiveRegionStart(): number | undefined;
+    /** Propagates viewport pinning from the first still-mutating transcript block. */
+    isNativeScrollbackLiveRegionPinned(): boolean;
     /**
      * Whether none of `component`'s rows (per the most recent render) have
      * entered native scrollback. Callers that retract ephemeral blocks (IRC

package/dist/types/modes/components/tree-selector.d.ts

@@ -7,7 +7,9 @@ declare class TreeList implements Component {
     #private;
     private readonly currentLeafId;
     private readonly maxVisibleLines;
-    onSelect?: (entryId: string) => void;
+    onSelect?: (entryId: string, options: {
+        summarize: boolean;
+    }) => void;
     onCancel?: () => void;
     onLabelEdit?: (entryId: string, currentLabel: string | undefined) => void;
     constructor(tree: SessionTreeNode[], currentLeafId: string | null, maxVisibleLines: number, initialFilterMode?: FilterMode, initialSelectedId?: string);
@@ -24,7 +26,9 @@ declare class TreeList implements Component {
 export declare class TreeSelectorComponent extends Container {
     #private;
     private readonly onLabelChangeCallback?;
-    constructor(tree: SessionTreeNode[], currentLeafId: string | null, terminalHeight: number, onSelect: (entryId: string) => void, onCancel: () => void, onLabelChangeCallback?: ((entryId: string, label: string | undefined) => void) | undefined, initialFilterMode?: FilterMode);
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, terminalHeight: number, onSelect: (entryId: string, options: {
+        summarize: boolean;
+    }) => void, onCancel: () => void, onLabelChangeCallback?: ((entryId: string, label: string | undefined) => void) | undefined, initialFilterMode?: FilterMode);
     handleInput(keyData: string): void;
     getTreeList(): TreeList;
 }

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

@@ -108,6 +108,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     vibeModeEnabled: boolean;
     planModePlanFilePath: string | undefined;
     loopModeEnabled: boolean;
+    loopModePaused: boolean;
     loopPrompt: string | undefined;
     loopLimit: LoopLimitRuntime | undefined;
     todoPhases: TodoPhase[];
@@ -195,6 +196,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     applyCwdChange(newCwd: string): Promise<void>;
     getUserInput(): Promise<SubmittedUserInput>;
     disableLoopMode(message?: string): void;
+    setLoopPrompt(prompt: string): void;
     /**
      * Pause the loop without exiting it: drops the captured prompt and any
      * pending auto-resubmit. Loop mode stays enabled — the next prompt the

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

@@ -15,6 +15,10 @@ export interface PrintModeOptions {
     /** If true, include thinking blocks in text output */
     printThoughts?: boolean;
 }
+/** Matches the longest built-in provider request deadline while bounding tool-loop stalls. */
+export declare const PRINT_MODE_ADVISOR_DRAIN_TIMEOUT_MS: number;
+/** Error exits cannot hold automation for the full normal drain budget. */
+export declare const PRINT_MODE_ERROR_ADVISOR_DRAIN_TIMEOUT_MS = 30000;
 /**
  * Shape an event for `--mode json` output.
  *

package/dist/types/modes/rpc/rpc-input.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Claims Bun's singleton stdin reader immediately and exposes a separately readable stream.
+ * RPC startup uses this before extension discovery so in-process modules cannot steal protocol input.
+ */
+export declare function claimRpcInput(): ReadableStream<Uint8Array>;

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

@@ -162,4 +162,4 @@ export declare function requestRpcEditor(pendingRequests: Map<string, PendingExt
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
  */
-export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, eventBus?: EventBus): Promise<never>;
+export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, eventBus?: EventBus, input?: ReadableStream<Uint8Array>): Promise<never>;

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

@@ -139,6 +139,7 @@ export interface InteractiveModeContext {
     goalModeEnabled: boolean;
     goalModePaused: boolean;
     loopModeEnabled: boolean;
+    loopModePaused: boolean;
     loopPrompt?: string;
     loopLimit?: LoopLimitRuntime;
     planModePlanFilePath?: string;
@@ -389,6 +390,7 @@ export interface InteractiveModeContext {
     handleGoalModeCommand(rest?: string): Promise<void>;
     handleGuidedGoalCommand(rest?: string): Promise<void>;
     handleLoopCommand(args?: string): Promise<string | undefined>;
+    setLoopPrompt(prompt: string): void;
     disableLoopMode(): void;
     pauseLoop(): void;
     handlePlanApproval(details: PlanApprovalDetails): Promise<void>;

package/dist/types/sdk.d.ts

@@ -46,6 +46,8 @@ export interface CreateAgentSessionOptions {
     modelPatternAuthFallback?: string;
     /** Role name used to install retry fallbacks after deferred subagent patterns resolve. */
     modelPatternFallbackRole?: string;
+    /** Validated default retry chain to install when a deferred singleton pattern resolves. */
+    modelPatternDefaultFallbackChain?: string[];
     /** Thinking selector. Default: from settings, else unset */
     thinkingLevel?: ConfiguredThinkingLevel;
     /** Models available for cycling (Ctrl+P in interactive mode) */

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

@@ -657,10 +657,26 @@ export declare class AgentSession {
     get isAborting(): boolean;
     /** Wait until streaming and deferred recovery work are fully settled. */
     waitForIdle(): Promise<void>;
+    /**
+     * Prevent advisor notes from starting hidden primary turns while a headless
+     * caller prints and drains the final primary response.
+     */
+    prepareForHeadlessAdvisorDrain(): void;
+    /**
+     * Wait for active advisor reviews and their emitted card events before a
+     * headless caller disposes the session. Returns `false` and logs work disposal
+     * will abandon when the shared deadline expires or an advisor fails.
+     */
+    waitForAdvisorCatchup(timeoutMs: number): Promise<boolean>;
     drainAsyncJobDeliveriesForAcp(options?: {
         timeoutMs?: number;
     }): Promise<boolean>;
-    /** Most recent assistant message in agent state. */
+    /**
+     * Most recent settled assistant message. A classifier-refusal turn pruned
+     * from active context at settle is still reported until the next run
+     * starts, so terminal-outcome consumers (print mode, task executor) see
+     * the refusal error rather than the previous turn — or nothing.
+     */
     getLastAssistantMessage(): AssistantMessage | undefined;
     /** Current effective system prompt blocks (includes any per-turn extension modifications) */
     get systemPrompt(): string[];
@@ -738,6 +754,8 @@ export declare class AgentSession {
      * to avoid racing against the delivery turn.
      */
     get hasPostPromptWork(): boolean;
+    /** Register post-prompt work in tests without driving a full agent turn. */
+    trackPostPromptTaskForTests(task: Promise<unknown>): void;
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
     /** Latest image attachments addressable by tools as `Image #N` or `attachment://N`. */

package/dist/types/session/messages.d.ts

@@ -250,5 +250,11 @@ export declare function sanitizeRehydratedOpenAIResponsesAssistantMessage(messag
  * - Agent's transormToLlm option (for prompt calls and queued messages)
  * - Compaction's generateSummary (for summarization)
  * - Custom extensions and tools
+ *
+ * Settled history converts once and is reused per message identity: an
+ * append-only turn on the same array re-pays only the new suffix, and an
+ * unchanged re-convert of the same array hands back the same outer `Message[]`.
+ * Owner mutations (prune/shake/strip-images) invalidate the affected message
+ * through the shared registry before the next pass.
  */
 export declare function convertToLlm(messages: AgentMessage[]): Message[];

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

@@ -19,13 +19,23 @@ export declare function captureAriaSnapshot(page: Page, root: ElementHandle | nu
  */
 export declare function resolveAriaRefHandle(page: Page, ref: string): Promise<ElementHandle | null>;
 /**
- * Recognize the explicit `[ref=eN]` selector forms and return the bare ref id,
- * else null. Accepts `aria-ref=e5` (Playwright-MCP style), `aria-ref/e5`, and
- * `ariaref/e5` — lets `tab.click("aria-ref=e5")` etc. act on snapshot refs. A
- * bare `e5` is intentionally NOT a ref selector: the cmux backend already uses
- * bare `eN`/`@eN` for its own observe ids, so requiring the prefix keeps action
- * selectors meaning the same thing on both backends. (`tab.ref("e5")` still
- * accepts a bare id directly.)
+ * Guard the selector funnels: `tab.click`/`type`/`fill`/`waitFor*`/`scrollIntoView`
+ * take string selectors only, but user `run` code routinely passes the ElementHandle
+ * from `tab.id(n)`/`tab.ref(...)` (or an un-awaited Promise of one) straight in.
+ * Without this the value reaches `.trim()`/`.startsWith()` and throws the opaque,
+ * minified `A.trim is not a function` instead of a recovery-naming ToolError.
+ */
+export declare function assertSelectorString(selector: unknown): asserts selector is string;
+/**
+ * Recognize a snapshot-ref selector and return the bare ref id, else null.
+ * Accepts `aria-ref=e5` (Playwright-MCP style), `aria-ref/e5`, `ariaref/e5`,
+ * and bare `e5`/`@e5`: agents copy ids straight out of the snapshot YAML
+ * (`[ref=e5]`), so `tab.click("e5")` must act on the ref instead of falling
+ * through to a CSS tag selector that can never match. Bare ids are safe to
+ * claim here — an eN tag name is not real HTML, and the tab-worker backend's
+ * observe ids are numeric (`tab.id(7)`), so refs are its only eN namespace.
+ * (The cmux backend parses selectors itself and routes bare `eN` to its own
+ * observe ids; either way `eN` means "the id from the last page dump".)
  */
 export declare function parseAriaRefSelector(selector: string): string | null;
 /**

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

@@ -9,6 +9,8 @@ export declare class CmuxSocketClient {
     constructor(opts: {
         socketPath: string;
         password?: string;
+        relayId?: string;
+        relayToken?: string;
     });
     connect(): Promise<void>;
     request(method: string, params: Record<string, unknown>, opts?: {

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

@@ -115,6 +115,8 @@ export interface RunErrorPayload {
     stack?: string;
     isToolError: boolean;
     isAbort: boolean;
+    /** The worker could not restore tab-scoped browser state and must be recycled. */
+    recoverTab?: boolean;
 }
 export type WorkerOutbound = {
     type: "ready";

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

@@ -27,6 +27,8 @@ export interface OpTimeouts {
 }
 /** Resolve the per-op fail-fast ceilings for a given cell budget. */
 export declare function resolveOpTimeouts(cellTimeoutMs: number): OpTimeouts;
+/** Queue a wheel event without treating a delayed renderer acknowledgement as dispatch failure. */
+export declare function dispatchScroll(dispatch: () => Promise<void>, ackTimeoutMs?: number): Promise<void>;
 /**
  * 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