@oh-my-pi/pi-coding-agent 17.0.6 → 17.0.8

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

@@ -44,7 +44,7 @@ interface ProviderOverride {
  * See `xiaomi-tp-discovery-merge.test.ts` and the `refresh()` baseUrl-override
  * regression in `model-registry.test.ts`.
  */
-export declare function mergeDiscoveredModel<TApi extends Api>(model: Model<TApi>, existing: Model<Api> | undefined, providerOverride?: Pick<ProviderOverride, "baseUrl" | "headers" | "remoteCompaction" | "transport">): Model<TApi>;
+export declare function mergeDiscoveredModel<TApi extends Api>(model: Model<TApi>, existing: Model<Api> | undefined, providerOverride?: Pick<ProviderOverride, "baseUrl" | "compat" | "headers" | "remoteCompaction" | "transport">): Model<TApi>;
 export type ProviderDiscoveryStatus = "idle" | "ok" | "empty" | "cached" | "unavailable" | "unauthenticated";
 export interface ProviderDiscoveryState {
     provider: string;

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

@@ -265,8 +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 contains the role's ordered primary candidates. */
     configuredPatterns?: string[];
+    /** configuredRole identifies the role expanded into configuredPatterns. */
+    configuredRole?: string;
     /** configuredPatternIndex identifies the configured role pattern that matched an available model. */
     configuredPatternIndex?: number;
     selector?: string;
@@ -283,6 +285,8 @@ export declare function resolveCliModel(options: {
     cliProvider?: string;
     cliModel?: string;
     modelRegistry: CliModelRegistry;
+    /** Authenticated models to prefer for unqualified selectors; omit to preserve catalog-order behavior. */
+    availableModels?: Model<Api>[];
     settings?: Settings;
     preferences?: ModelMatchPreferences;
 }): ResolveCliModelResult;

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

@@ -2968,6 +2968,22 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "boolean";
         readonly default: false;
     };
+    readonly "hindsight.requestTimeoutMs": {
+        readonly type: "number";
+        readonly default: 30000;
+    };
+    readonly "hindsight.reflectTimeoutMs": {
+        readonly type: "number";
+        readonly default: 120000;
+    };
+    readonly "hindsight.recallTimeoutMs": {
+        readonly type: "number";
+        readonly default: 30000;
+    };
+    readonly "hindsight.retainTimeoutMs": {
+        readonly type: "number";
+        readonly default: 60000;
+    };
     readonly "hindsight.mentalModelsEnabled": {
         readonly type: "boolean";
         readonly default: true;

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

@@ -53,4 +53,23 @@ export declare class DapClient {
     sendResponse(request: DapRequestMessage, success: boolean, body?: unknown, message?: string): Promise<void>;
     dispose(): Promise<void>;
 }
+/**
+ * Give the adapter a chance to announce it is listening on `port` before the
+ * first connect. vscode-js-debug prints `Debug server listening at HOST:PORT`
+ * to stdout from inside its `listen()` callback; waiting for the port to appear
+ * there means we only connect once the child genuinely owns the reserved port,
+ * which closes the WSL2-mirrored ghost-accept window (issue #6055) at its root.
+ *
+ * Best-effort: resolves on the banner, on process exit, or on timeout — the
+ * subsequent connect loop and `proc.exitCode` checks surface real failures, so
+ * an adapter that never prints a banner still proceeds (just without the gate).
+ * Also drains stdout for the wait's duration: in tcp mode the DAP protocol
+ * flows over the socket, so nothing else consumes the adapter's stdout.
+ *
+ * Exported so tests can drive the gate deterministically with a synthetic stdout.
+ */
+export declare function waitForTcpServerListening(proc: {
+    stdout: ReadableStream<Uint8Array>;
+    exitCode: number | null;
+}, port: number, timeoutMs: number): Promise<void>;
 export {};

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

@@ -54,8 +54,10 @@ export type SwitchSessionHandler = (sessionPath: string) => Promise<{
 }>;
 export type ShutdownHandler = () => void;
 /**
- * Helper function to emit session_shutdown event to extensions.
- * Returns true if the event was emitted, false if there were no handlers.
+ * Emit `session_shutdown` and clear timers owned by an extension runner.
+ *
+ * Returns whether any shutdown handlers were present. Timer cleanup runs even
+ * when a handler fails so extension background work cannot outlive its host.
  */
 export declare function emitSessionShutdownEvent(extensionRunner: ExtensionRunner | undefined): Promise<boolean>;
 export declare class ExtensionRunner {

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

@@ -398,6 +398,9 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
     /** Tool approval tier. Defaults to `"exec"` when omitted.
      *  `"read"`: read-only operations. `"write"`: mutations. `"exec"`: code execution. */
     approval?: ToolApproval;
+    /** Structured-output strict grammar opt-in/out. `false` is meaningful: OpenAI-family
+     *  serializers preserve an explicit `strict: false` on the wire (#4336/#4340). */
+    strict?: boolean;
     /** MCP server name for discovery/search metadata when this tool fronts an MCP server. */
     mcpServerName?: string;
     /** Original MCP tool name for discovery/search metadata. */

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

@@ -33,6 +33,8 @@ export type TOptional<_E extends ArkSchema> = ArkSchema;
 export type TUnion<_T extends readonly ArkSchema[] = readonly ArkSchema[]> = ArkSchema;
 export type TEnum<_T extends readonly (string | number)[] = readonly (string | number)[]> = ArkSchema;
 export type TRecord<_K extends ArkSchema, _V extends ArkSchema> = ArkSchema;
+/** TypeBox-compatible wrapper for raw JSON Schema documents. */
+export type TUnsafe<_T = unknown> = ArkSchema;
 declare const VALIDATION_FAILURE: unique symbol;
 interface ValidationFailure {
     message: string;
@@ -126,6 +128,7 @@ export declare const Type: {
     readonly Null: typeof tNull;
     readonly Any: typeof tAny;
     readonly Unknown: typeof tUnknown;
+    readonly Unsafe: <T = unknown>(jsonSchema?: Record<string, unknown>) => TUnsafe<T>;
     readonly Never: typeof tNever;
     readonly Literal: typeof tLiteral;
     readonly Union: typeof tUnion;
@@ -155,6 +158,7 @@ declare const _default: {
         readonly Null: typeof tNull;
         readonly Any: typeof tAny;
         readonly Unknown: typeof tUnknown;
+        readonly Unsafe: <T = unknown>(jsonSchema?: Record<string, unknown>) => TUnsafe<T>;
         readonly Never: typeof tNever;
         readonly Literal: typeof tLiteral;
         readonly Union: typeof tUnion;

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

@@ -12,10 +12,20 @@ export type Budget = "low" | "mid" | "high" | string;
 export type TagsMatch = "any" | "all" | "any_strict" | "all_strict";
 export type UpdateMode = "replace" | "append";
 export type ConsolidationState = "failed" | "pending" | "done";
+/** Per-operation request deadlines (ms). Each falls back to a built-in default. */
+export interface HindsightTimeouts {
+    /** Default deadline for ops without a specific override. */
+    request?: number;
+    reflect?: number;
+    recall?: number;
+    retain?: number;
+}
 export interface HindsightApiOptions {
     baseUrl: string;
     apiKey?: string;
     userAgent?: string;
+    /** Per-op deadlines; unset entries fall back to built-in defaults. */
+    timeouts?: HindsightTimeouts;
 }
 /** Caller cancellation shared by Hindsight request option bags. */
 export interface HindsightRequestOptions {

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

@@ -32,6 +32,14 @@ export interface HindsightConfig {
     recallMaxQueryChars: number;
     recallPromptPreamble: string;
     debug: boolean;
+    /** Default per-request client deadline (ms) for ops without a specific override. */
+    requestTimeoutMs: number;
+    /** Client deadline (ms) for reflect (agentic synthesis; costlier than a metadata fetch). */
+    reflectTimeoutMs: number;
+    /** Client deadline (ms) for recall. */
+    recallTimeoutMs: number;
+    /** Client deadline (ms) for retain / retainBatch. */
+    retainTimeoutMs: number;
     mentalModelsEnabled: boolean;
     mentalModelAutoSeed: boolean;
     mentalModelRefreshIntervalMs: number;

package/dist/types/mcp/tool-bridge.d.ts

@@ -59,6 +59,13 @@ export declare class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
     readonly approval: "write";
     /** Render completed MCP calls with the result header replacing the pending call header. */
     readonly mergeCallAndResult = true;
+    /**
+     * MCP-backed tools opt out of strict structured-output grammar. The server
+     * owns validation, and strict mode makes OpenAI-family models over-fill
+     * mutually exclusive optional fields (#4336/#4340). Serializers preserve an
+     * explicit `false`; an omitted flag would leave nothing to preserve.
+     */
+    readonly strict: false;
     /** Create MCPTool instances for all tools from an MCP server connection */
     static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[], reconnect?: MCPReconnect): MCPTool[];
     constructor(connection: MCPServerConnection, tool: MCPToolDefinition, reconnect?: MCPReconnect | undefined);
@@ -86,6 +93,8 @@ export declare class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetai
     readonly approval: "write";
     /** Render completed MCP calls with the result header replacing the pending call header. */
     readonly mergeCallAndResult = true;
+    /** See {@link MCPTool.strict}: MCP servers own validation, so stay non-strict. */
+    readonly strict: false;
     /** Create DeferredMCPTool instances for all tools from an MCP server */
     static fromTools(serverName: string, tools: MCPToolDefinition[], getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect): DeferredMCPTool[];
     constructor(serverName: string, tool: MCPToolDefinition, getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect | undefined);

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

@@ -74,6 +74,7 @@ export interface MnemopiSessionStateOptions {
     hasRecalledForFirstTurn?: boolean;
 }
 export declare class MnemopiSessionState {
+    #private;
     sessionId: string;
     readonly config: MnemopiBackendConfig;
     readonly session: AgentSession;
@@ -124,6 +125,7 @@ export declare class MnemopiSessionState {
         content: string;
     }>, sourceId: string, options?: {
         extract?: boolean;
+        retainedThroughUserTurn?: number;
     }): Promise<void>;
     attachSessionListeners(): void;
     maybeRecallOnAgentStart(): Promise<void>;

package/dist/types/modes/components/user-message.d.ts

@@ -1,4 +1,4 @@
-import { Container } from "@oh-my-pi/pi-tui";
+import { type Component, Container } from "@oh-my-pi/pi-tui";
 /**
  * Component that renders a user message
  */
@@ -7,3 +7,27 @@ export declare class UserMessageComponent extends Container {
     constructor(text: string, synthetic?: boolean, imageLinks?: readonly (string | undefined)[]);
     render(width: number): readonly string[];
 }
+/**
+ * Collapsed placeholder for a synthetic (agent-attributed) user input in the
+ * file/remote-backed transcript viewer — chiefly the advisor's `Session update`
+ * replay dumps, which can each be hundreds of KiB of Markdown and, on cold open,
+ * blocked the TUI for tens of seconds while every historical body was laid out
+ * before the viewport clip (issue #6308).
+ *
+ * Collapsed by default: renders one dim summary row (label · size · line count ·
+ * expand hint) and builds NO Markdown. The heavy {@link UserMessageComponent} is
+ * constructed lazily only when expanded via `ctrl+o`, so blocks above the
+ * viewport never pay layout cost until the reader asks to see them. The raw
+ * observability data stays intact in `__advisor.jsonl`.
+ */
+export declare class CollapsedSyntheticMessageComponent implements Component {
+    #private;
+    private readonly text;
+    private readonly imageLinks?;
+    constructor(text: string, imageLinks?: readonly (string | undefined)[] | undefined);
+    /** ctrl+o toggle: reveal/hide the full Markdown body. */
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): readonly string[];
+}

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

@@ -12,6 +12,14 @@ export declare class ExtensionUiController {
      * Initialize the hook system with TUI-based UI context.
      */
     initHooksAndCustomTools(): Promise<void>;
+    /**
+     * The `ExtensionUIContext` built in `initHooksAndCustomTools()` — the same
+     * picker/dialog primitives passed as `context.ui` for every live tool
+     * call. `/tree` `ask` re-answer (issue #5642) reuses this to drive a
+     * standalone `AskTool.execute()` call outside a normal agent turn.
+     * `undefined` before hooks have initialized.
+     */
+    getToolUIContext(): ExtensionUIContext | undefined;
     setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
     initializeHookRunner(uiContext: ExtensionUIContext, _hasUI: boolean): void;
     /**

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

@@ -128,6 +128,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     proseOnlyThinking: boolean;
     compactionQueuedMessages: CompactionQueuedMessage[];
     pendingTools: Map<string, ToolExecutionHandle>;
+    transcriptMessageComponents: WeakMap<AgentMessage, Component>;
     pendingBashComponents: BashExecutionComponent[];
     bashComponent: BashExecutionComponent | undefined;
     pendingPythonComponents: EvalExecutionComponent[];
@@ -228,7 +229,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     syncRunningSubagentBadge(options?: {
         requestRender?: boolean;
     }): void;
-    rebuildChatFromMessages(): void;
+    rebuildChatFromMessages(options?: {
+        reuseSettledComponents?: boolean;
+    }): void;
     /**
      * Render the ctrl+p model-role cycle chip track into its own anchored
      * container (just above the editor), mirroring the todo HUD: the container is
@@ -301,10 +304,12 @@ export declare class InteractiveMode implements InteractiveModeContext {
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;
         imageLinks?: readonly (string | undefined)[];
+        reuseSettledComponent?: boolean;
     }): Component[];
     renderSessionContext(sessionContext: SessionContext, options?: {
         updateFooter?: boolean;
         populateHistory?: boolean;
+        reuseSettledComponents?: boolean;
     }): void;
     renderInitialMessages(options?: {
         preserveExistingChat?: boolean;
@@ -399,6 +404,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     openExternalEditor(): void;
     registerExtensionShortcuts(): void;
     initHooksAndCustomTools(): Promise<void>;
+    getToolUIContext(): ExtensionUIContext | undefined;
     emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
     setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
     setHookStatus(key: string, text: string | undefined): void;

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

@@ -156,6 +156,8 @@ export interface InteractiveModeContext {
     noteDisplayableThinkingContent(message: AgentMessage): boolean;
     proseOnlyThinking: boolean;
     compactionQueuedMessages: CompactionQueuedMessage[];
+    /** Settled user/assistant components reusable across post-compaction transcript rebuilds. */
+    transcriptMessageComponents: WeakMap<AgentMessage, Component>;
     pendingTools: Map<string, ToolExecutionHandle>;
     pendingBashComponents: BashExecutionComponent[];
     bashComponent: BashExecutionComponent | undefined;
@@ -280,10 +282,12 @@ export interface InteractiveModeContext {
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;
         imageLinks?: readonly (string | undefined)[];
+        reuseSettledComponent?: boolean;
     }): Component[];
     renderSessionContext(sessionContext: SessionContext, options?: {
         updateFooter?: boolean;
         populateHistory?: boolean;
+        reuseSettledComponents?: boolean;
     }): void;
     renderInitialMessages(options?: {
         preserveExistingChat?: boolean;
@@ -295,7 +299,9 @@ export interface InteractiveModeContext {
     /** Refresh the running-subagents status badge from the active local or collab registry. */
     syncRunningSubagentBadge(): void;
     updateEditorBorderColor(): void;
-    rebuildChatFromMessages(): void;
+    rebuildChatFromMessages(options?: {
+        reuseSettledComponents?: boolean;
+    }): void;
     setTodos(todos: TodoItem[] | TodoPhase[]): void;
     reloadTodos(): Promise<void>;
     toggleTodoExpansion(): void;
@@ -396,6 +402,13 @@ export interface InteractiveModeContext {
     handlePlanApproval(details: PlanApprovalDetails): Promise<void>;
     openPlanReview(): Promise<void>;
     initHooksAndCustomTools(): Promise<void>;
+    /**
+     * The live `ExtensionUIContext` (picker/dialog primitives) used for tool
+     * execution, `undefined` before hooks have initialized. `/tree` `ask`
+     * re-answer (issue #5642) reuses it to drive a standalone
+     * `AskTool.execute()` call.
+     */
+    getToolUIContext(): ExtensionUIContext | undefined;
     emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
     setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
     setHookStatus(key: string, text: string | undefined): void;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -7,6 +7,16 @@ interface RenderInitialMessagesOptions {
     preserveExistingChat?: boolean;
     clearTerminalHistory?: boolean;
 }
+type AddMessageOptions = {
+    populateHistory?: boolean;
+    imageLinks?: readonly (string | undefined)[];
+    reuseSettledComponent?: boolean;
+};
+type RenderSessionContextOptions = {
+    updateFooter?: boolean;
+    populateHistory?: boolean;
+    reuseSettledComponents?: boolean;
+};
 export declare class UiHelpers {
     #private;
     private ctx;
@@ -22,20 +32,14 @@ export declare class UiHelpers {
     showStatus(message: string, options?: {
         dim?: boolean;
     }): void;
-    addMessageToChat(message: AgentMessage, options?: {
-        populateHistory?: boolean;
-        imageLinks?: readonly (string | undefined)[];
-    }): Component[];
+    addMessageToChat(message: AgentMessage, options?: AddMessageOptions): Component[];
     /**
      * Render session context to chat. Used for initial load and rebuild after compaction.
      * @param sessionContext Session context to render
      * @param options.updateFooter Update footer state
      * @param options.populateHistory Add user messages to editor history
      */
-    renderSessionContext(sessionContext: SessionContext, options?: {
-        updateFooter?: boolean;
-        populateHistory?: boolean;
-    }): void;
+    renderSessionContext(sessionContext: SessionContext, options?: RenderSessionContextOptions): void;
     renderInitialMessages(options?: RenderInitialMessagesOptions): void;
     clearEditor(): void;
     showError(errorMessage: string): void;

package/dist/types/sdk.d.ts

@@ -359,6 +359,7 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export declare function customToolToDefinition(tool: CustomTool): ToolDefinition;
 /** Dependencies used to construct an isolated auto-learn capture agent. */
 export interface AutoLearnCaptureRunnerOptions {
     sourceAgent: Agent;

package/dist/types/session/agent-session-error-log.test.d.ts

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

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

@@ -13,7 +13,7 @@
  * Modes use this class and add their own I/O layer on top.
  */
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
-import { Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type AgentToolResult, type StreamFn, ThinkingLevel, type ToolChoiceDirective } from "@oh-my-pi/pi-agent-core";
+import { Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type AgentToolContext, type AgentToolResult, type StreamFn, ThinkingLevel, type ToolChoiceDirective } from "@oh-my-pi/pi-agent-core";
 import { type CompactionResult, type ShakeConfig } from "@oh-my-pi/pi-agent-core/compaction";
 import type { AssistantMessage, Context, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, ServiceTierByFamily, ServiceTierFamily, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
@@ -31,7 +31,7 @@ import { type BashResult } from "../exec/bash-executor.js";
 import type { TtsrManager } from "../export/ttsr.js";
 import type { LoadedCustomCommand } from "../extensibility/custom-commands/index.js";
 import type { CustomTool } from "../extensibility/custom-tools/types.js";
-import type { ExtensionRunner } from "../extensibility/extensions/index.js";
+import type { ExtensionRunner, ExtensionUIContext } from "../extensibility/extensions/index.js";
 import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types.js";
 import type { RecoveredRetryError } from "../extensibility/shared-events.js";
 import { type Skill, type SkillWarning } from "../extensibility/skills.js";
@@ -45,6 +45,7 @@ import { type PlanApprovalDetails } from "../plan-mode/approved-plan.js";
 import type { PlanModeState } from "../plan-mode/state.js";
 import { type SecretObfuscator } from "../secrets/obfuscator.js";
 import { type ConfiguredThinkingLevel } from "../thinking.js";
+import { type AskToolDetails, type AskToolInput } from "../tools/ask.js";
 import type { CheckpointState, CompletedRewindState } from "../tools/checkpoint.js";
 import { type PlanProposalHandler } from "../tools/resolve.js";
 import { type TodoItem, type TodoPhase } from "../tools/todo.js";
@@ -180,6 +181,15 @@ export interface PlanYolo {
     target: Model;
     thinkingLevel?: ConfiguredThinkingLevel;
 }
+/** Identifies a retry fallback chain already entered during startup model resolution. */
+export interface InitialRetryFallbackState {
+    /** Role whose configured primary was unavailable. */
+    role: string;
+    /** Configured primary selector retained for restoration when it becomes available. */
+    originalSelector: string;
+    /** Thinking selector configured for the unavailable primary. */
+    originalThinkingLevel: ConfiguredThinkingLevel | undefined;
+}
 export interface AgentSessionConfig {
     agent: Agent;
     sessionManager: SessionManager;
@@ -193,6 +203,8 @@ export interface AgentSessionConfig {
     }>;
     /** Initial session thinking selector. */
     thinkingLevel?: ConfiguredThinkingLevel;
+    /** Retry chain ownership when startup selected one of its fallback entries. */
+    initialRetryFallback?: InitialRetryFallbackState;
     /** Prewalk from the starting model to a fast/cheap target at the first edit/write once the todo list exists. */
     prewalk?: Prewalk;
     /** Force read-only plan mode at start, auto-approve on the model's first
@@ -520,6 +532,15 @@ export type RestoredQueuedMessage = {
     text: string;
     images?: ImageContent[];
 };
+/**
+ * Emit a warn-level log for a turn that ended in a provider error so recurring
+ * stream failures are diagnosable from the main log alone. The `agent_end`
+ * routing trace is debug-only and omits the error fields; without this a
+ * session dying on provider errors leaves only `stopReason:"error"` debug lines
+ * and the real cause lives solely in the session transcript (issue #6177).
+ * No-op for any non-error stop reason.
+ */
+export declare function logProviderTurnError(msg: AssistantMessage): void;
 type SessionNameTrigger = "replan";
 export declare class AgentSession {
     #private;
@@ -1215,6 +1236,16 @@ export declare class AgentSession {
     /**
      * Manually retry the last failed assistant turn.
      * Removes the error message from agent state and re-attempts with a fresh retry budget.
+     *
+     * A stream that stalls or aborts mid-tool-call ends the turn with
+     * `stopReason: "error" | "aborted"` and then appends one synthetic
+     * {@link isSyntheticToolResultMessage tool_result} per emitted tool call to
+     * preserve the provider's tool_use/tool_result pairing (see
+     * `createAbortedToolResult` in `agent-loop.ts`). Those placeholders trail the
+     * failed assistant turn, so the retry lookback walks back over them before
+     * checking the assistant message; it strips both the placeholders and the
+     * failed turn before re-attempting.
+     *
      * @returns true if retry was initiated, false if no failed turn to retry or agent is busy
      */
     retry(): Promise<boolean>;
@@ -1380,6 +1411,26 @@ export declare class AgentSession {
     navigateTree(targetId: string, options?: {
         summarize?: boolean;
         customInstructions?: string;
+        /**
+         * Opts into the two-phase `ask` toolResult re-answer protocol
+         * (issue #5642): set only by the interactive `/tree` selector, which
+         * knows how to re-open the picker on `reopenAsk` and complete the
+         * navigation with `reanswerAskResult`. Every other public caller
+         * (extensions, hooks, ACP, session-extension actions) leaves this
+         * unset and gets the pre-#5642 plain leaf move onto `ask`
+         * toolResults instead — they have no picker to re-open and would
+         * otherwise report a successful no-op navigation (roboomp review on
+         * #5895).
+         */
+        allowAskReopen?: boolean;
+        /**
+         * Completes an in-progress `ask` re-answer (issue #5642): the caller
+         * already received `reopenAsk` from a prior call on the same
+         * `targetId`, re-opened the picker, and is handing back the fresh
+         * answer. Branches a new toolResult sibling instead of landing on
+         * the original one.
+         */
+        reanswerAskResult?: AgentToolResult<AskToolDetails>;
     }): Promise<{
         editorText?: string;
         cancelled: boolean;
@@ -1387,7 +1438,32 @@ export declare class AgentSession {
         summaryEntry?: BranchSummaryEntry;
         /** Raw session context built during navigation — pass to renderInitialMessages to skip a second O(N) walk. */
         sessionContext?: SessionContext;
+        /**
+         * Set when `targetId` is an `ask` toolResult, `options.allowAskReopen`
+         * was set, and `options.reanswerAskResult` was not supplied: nothing was
+         * mutated. The caller must re-open the ask picker with these
+         * `questions`, then call `navigateTree(targetId, { ...options,
+         * reanswerAskResult })` with the produced result to actually branch
+         * (issue #5642).
+         */
+        reopenAsk?: {
+            toolCallId: string;
+            questions: AskToolInput["questions"];
+        };
     }>;
+    /**
+     * Build a standalone `AgentToolContext` for running `AskTool.execute()`
+     * outside a normal agent turn, for `/tree` `ask` re-answer (issue #5642).
+     * `SelectorController` has no reachable `ToolContextStore` (that store is
+     * built inside `sdk.ts` and never threaded through to mode controllers),
+     * so this mirrors `refreshMCPTools()`'s `getCustomToolContext` factory
+     * with real session state instead of a `{ ... } as unknown as
+     * AgentToolContext` cast that could silently compile with an incomplete
+     * context (roboomp review on #5895) — every `CustomToolContext` field is
+     * backed by live session state, so a future required field fails to
+     * compile here instead of surfacing as `undefined` at runtime.
+     */
+    buildAskReanswerContext(uiContext: ExtensionUIContext): AgentToolContext;
     /**
      * Get all user messages from session for branch selector.
      */

package/dist/types/task/executor.d.ts

@@ -219,6 +219,16 @@ export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent
 export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
 /**
  * Create proxy tools that reuse the parent's MCP connections.
+ *
+ * Each proxy delegates to the current source `MCPTool`/`DeferredMCPTool` rather
+ * than rebuilding a raw `tools/call` request, so the Task/subagent path shares
+ * the source tool's authoritative outbound boundary: harness-intent (`i`)
+ * stripping, optional-placeholder pruning, local-URL resolution, reconnect
+ * retry, abort handling, and result/provider metadata. The source tool is
+ * re-resolved on every call by raw MCP server/tool metadata (not the normalized
+ * display name), so a reconnect that swaps the instance in `getTools()` is
+ * always honored. The proxy adds only the Task-specific 60s call timeout,
+ * combining its abort signal with the caller's around source execution.
  */
 export declare function createMCPProxyTools(mcpManager: MCPManager): CustomTool[];
 export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTierByFamily | null): Settings;

package/dist/types/task/index.d.ts

@@ -66,6 +66,7 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
     readonly summary = "Spawn subagents to complete delegated tasks";
     readonly strict = false;
     readonly loadMode = "essential";
+    readonly lenientArgValidation = true;
     readonly renderResult: typeof renderResult;
     readonly mergeCallAndResult = true;
     get parameters(): TaskToolSchemaInstance;

package/dist/types/task/prewalk.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from "./types.js";
+/** Resolve an agent's prewalk default, including the bundled task opt-in. */
+export declare function resolveAgentPrewalkDefault(agent: AgentDefinition, taskPrewalk: boolean): boolean | string | undefined;

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

@@ -35,6 +35,16 @@ declare const askSchema: import("arktype/internal/variants/object.ts").ObjectTyp
     }[];
 }, {}>;
 export type AskToolInput = typeof askSchema.infer;
+/**
+ * Recover a validated `questions` payload from a persisted `ask` toolCall's
+ * `arguments`. Used by `/tree` re-answer (issue #5642): selecting a past
+ * `ask` toolResult re-opens the picker with the *original* questions, so the
+ * new answer branches as a sibling instead of mutating the old one. Runs the
+ * same schema the live tool call validated against — legacy/corrupted
+ * persisted args fail closed (`undefined`) rather than feeding malformed
+ * data back into the picker.
+ */
+export declare function recoverAskQuestions(toolCallArguments: unknown): AskToolInput["questions"] | undefined;
 /** Result for a single question */
 export interface QuestionResult {
     id: string;

package/dist/types/tools/tool-timeouts.d.ts

@@ -46,6 +46,12 @@ export declare const TOOL_TIMEOUTS: {
 export type ToolWithTimeout = keyof typeof TOOL_TIMEOUTS;
 /**
  * Clamp a raw timeout to the allowed range for a tool.
- * If rawTimeout is undefined, returns the tool's default.
+ *
+ * When `rawTimeout` is undefined the tool's `default` is used. A positive
+ * `maxTimeout` (the `tools.maxTimeout` global ceiling) caps the *resolved*
+ * value — including the default-fallback path — before the per-tool `min`/`max`
+ * floor and ceiling apply, so a configured global cap governs calls where the
+ * agent omits `timeout`, not only explicitly-passed values. `maxTimeout <= 0`
+ * means no global cap.
  */
-export declare function clampTimeout(tool: ToolWithTimeout, rawTimeout?: number): number;
+export declare function clampTimeout(tool: ToolWithTimeout, rawTimeout?: number, maxTimeout?: number): number;

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

@@ -23,13 +23,11 @@ export interface StartupChangelogSelection {
     selectedEntries: number;
 }
 /**
- * Parse changelog entries from the file at `changelogPath`. Scans for `## [x.y.z]`
- * headings and collects each block until the next heading or EOF.
+ * Parse changelog entries from omp's package asset when available, falling back
+ * to the copy embedded in compiled binaries.
  *
- * Returns `[]` when `changelogPath` is `undefined` (package directory not
- * resolvable — see `getChangelogPath`) or the file is missing. Callers MUST NOT
- * synthesize a fallback path from the host project's cwd; doing so caused issue
- * #1423 (the host project's `CHANGELOG.md` was rendered as omp's).
+ * The embedded fallback keeps standalone binaries self-contained without
+ * resolving relative to the host project's cwd, which caused issue #1423.
  */
 export declare function parseChangelog(changelogPath: string | undefined): Promise<ChangelogEntry[]>;
 /**