@oh-my-pi/pi-coding-agent 17.0.7 → 17.0.9

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

@@ -8,6 +8,7 @@ import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor.js";
 import type { AgentSessionEvent, SessionStats } from "../../session/agent-session.js";
+import { type RpcMessagesPage, type RpcMessagesPageOptions } from "./rpc-messages.js";
 import type { RpcAvailableSlashCommand, RpcHandoffResult, RpcHostToolDefinition, RpcSessionState, RpcSubagentEventFrame, RpcSubagentLifecycleFrame, RpcSubagentMessagesResult, RpcSubagentProgressFrame, RpcSubagentSnapshot, RpcSubagentSubscriptionLevel } from "./rpc-types.js";
 export interface RpcClientOptions {
     /** Path to the CLI entry point (default: searches for dist/cli.js) */
@@ -45,6 +46,12 @@ export interface RpcClientCustomTool<TParams extends Record<string, unknown> = R
     execute(params: TParams, context: RpcClientToolContext<TDetails>): Promise<RpcClientToolResult<TDetails>> | RpcClientToolResult<TDetails>;
 }
 export declare function defineRpcClientTool<TParams extends Record<string, unknown> = Record<string, unknown>, TDetails = unknown>(tool: RpcClientCustomTool<TParams, TDetails>): RpcClientCustomTool<TParams, TDetails>;
+/** Failed RPC command; `code` mirrors the server's machine-readable error code when present. */
+export declare class RpcCommandError extends Error {
+    readonly command: string;
+    readonly code?: string | undefined;
+    constructor(message: string, command: string, code?: string | undefined);
+}
 export declare class RpcClient {
     #private;
     private options;
@@ -254,8 +261,10 @@ export declare class RpcClient {
      */
     getLastAssistantText(): Promise<string | null>;
     /**
-     * Get all messages in the session.
+     * Get one stable, byte-bounded message page.
      */
+    getMessagesPage(options?: RpcMessagesPageOptions): Promise<RpcMessagesPage>;
+    /** Get all messages, draining stable pages when protocol v2 is available. */
     getMessages(): Promise<AgentMessage[]>;
     /**
      * Get list of OAuth providers available for login, with their current authentication status.

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

@@ -1,9 +1,25 @@
 /** Maximum UTF-8 size of one newline-delimited RPC frame, including the newline. */
 export declare const MAX_RPC_FRAME_BYTES: number;
+/** Maximum UTF-8 size of one logical frame reassembled by protocol v2. */
+export declare const MAX_RPC_REASSEMBLED_BYTES: number;
+export type RpcProtocolVersion = 1 | 2;
+/** Reassemble protocol v2 chunk frames after each JSONL line has been parsed. */
+export declare class RpcFrameDecoder {
+    #private;
+    push(value: unknown): object | undefined;
+}
 /** Serialize a complete JSONL frame while enforcing the transport byte ceiling. */
 export declare function encodeRpcFrame(frame: object, streamedMessageCount?: number, streamedMessages?: readonly unknown[]): string;
 /** Stateful encoder that tracks which messages a client has already received. */
 export declare class RpcFrameEncoder {
     #private;
+    setProtocolVersion(version: number): void;
+    /**
+     * Encode one logical frame into physical JSONL lines. Encoder bookkeeping runs
+     * eagerly; only chunk emission is lazy, so a chunked result can be streamed to
+     * stdout with backpressure without holding the whole transport in memory. The
+     * returned iterable MUST be fully consumed exactly once.
+     */
+    encodeFrames(frame: object): Iterable<string>;
     encode(frame: object): string;
 }

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

@@ -0,0 +1,26 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+export declare const RPC_MESSAGES_PAGE_BUSY_ERROR = "Cannot page messages while the session is changing";
+export declare const RPC_MESSAGES_PAGE_STALE_ERROR = "RPC message cursor is stale";
+/** Machine-readable reasons a `get_messages_page` request can fail; carried as `code` on the error response. */
+export type RpcMessagesPageErrorCode = "session_busy" | "stale_cursor";
+/** Paging failure that maps to a structured wire `code`, so clients can react without matching message text. */
+export declare class RpcMessagesPageError extends Error {
+    readonly code: RpcMessagesPageErrorCode;
+    constructor(message: string, code: RpcMessagesPageErrorCode);
+}
+export interface RpcMessageSnapshot {
+    sessionId: string;
+    leafId: string | null;
+    messageCount: number;
+}
+export interface RpcMessagesPage {
+    messages: AgentMessage[];
+    nextCursor?: string;
+    totalMessages: number;
+}
+export interface RpcMessagesPageOptions {
+    cursor?: string;
+    limit?: number;
+}
+/** Page one stable in-memory message snapshot without crossing the v1 frame budget. */
+export declare function pageRpcMessages(messages: readonly AgentMessage[], snapshot: RpcMessageSnapshot, options?: RpcMessagesPageOptions): RpcMessagesPage;

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

@@ -14,7 +14,12 @@ import type { FileEntry } from "../../session/session-entries.js";
 import type { AvailableSlashCommandSource } from "../../slash-commands/available-commands.js";
 import type { AgentProgress, SubagentEventPayload, SubagentLifecyclePayload, SubagentProgressPayload } from "../../task/index.js";
 import type { TodoPhase } from "../../tools/todo.js";
+import type { RpcMessagesPage } from "./rpc-messages.js";
 export type RpcCommand = {
+    id?: string;
+    type: "negotiate_protocol";
+    protocolVersion: number;
+} | {
     id?: string;
     type: "prompt";
     message: string;
@@ -157,6 +162,11 @@ export type RpcCommand = {
 } | {
     id?: string;
     type: "get_messages";
+} | {
+    id?: string;
+    type: "get_messages_page";
+    cursor?: string;
+    limit?: number;
 } | {
     id?: string;
     type: "get_login_providers";
@@ -214,6 +224,21 @@ export interface RpcPromptResultFrame {
     id?: string;
     agentInvoked: boolean;
 }
+export interface RpcReadyFrame {
+    type: "ready";
+    protocolVersion: 1;
+    supportedProtocolVersions: [1, 2];
+    maxFrameBytes: number;
+    maxReassembledFrameBytes: number;
+}
+export interface RpcChunkFrame {
+    type: "rpc_chunk";
+    chunkId: string;
+    index: number;
+    count: number;
+    byteLength: number;
+    data: string;
+}
 export interface RpcHandoffResult {
     savedPath?: string;
 }
@@ -241,6 +266,14 @@ export interface RpcSubagentMessagesResult {
     messages: AgentMessage[];
 }
 export type RpcResponse = {
+    id?: string;
+    type: "response";
+    command: "negotiate_protocol";
+    success: true;
+    data: {
+        protocolVersion: 2;
+    };
+} | {
     id?: string;
     type: "response";
     command: "prompt";
@@ -489,6 +522,12 @@ export type RpcResponse = {
     data: {
         messages: AgentMessage[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_messages_page";
+    success: true;
+    data: RpcMessagesPage;
 } | {
     id?: string;
     type: "response";
@@ -516,6 +555,7 @@ export type RpcResponse = {
     command: string;
     success: false;
     error: string;
+    code?: string;
 };
 export interface RpcSubagentLifecycleFrame {
     type: "subagent_lifecycle";

package/dist/types/modes/setup-wizard/scenes/sign-in.d.ts

@@ -18,5 +18,5 @@ export declare class SignInTab implements SetupTab {
     handleInput(data: string): void;
     /** Forward mouse to the provider selector; pointer is inert during an active login or code prompt. */
     routeMouse(event: SgrMouseEvent, line: number, col: number): void;
-    render(width: number): readonly string[];
+    render(width: number, maxLines?: number): readonly string[];
 }

package/dist/types/modes/setup-wizard/scenes/types.d.ts

@@ -14,6 +14,13 @@ export interface SetupSceneController extends Component {
     onMount?(): void | Promise<void>;
     onUnmount?(): void;
     dispose?(): void;
+    /**
+     * Render the scene body. `maxLines` is the number of body rows the wizard
+     * will actually display (header and footer already subtracted); scenes
+     * shrink list windows and drop decorative chrome so the selected row stays
+     * inside the budget. Overflow beyond `maxLines` is clipped by the wizard.
+     */
+    render(width: number, maxLines?: number): readonly string[];
     /**
      * Route an SGR mouse report (tracking is on while the wizard holds the
      * alternate screen). `line`/`col` are 0-based within this controller's
@@ -34,7 +41,8 @@ export interface SetupTab {
      * login). The parent scene MUST NOT switch tabs or finish while modal.
      */
     readonly modal: boolean;
-    render(width: number): readonly string[];
+    /** See {@link SetupSceneController.render}: `maxLines` is the tab-local row budget. */
+    render(width: number, maxLines?: number): readonly string[];
     handleInput(data: string): void;
     invalidate(): void;
     /** Called when the tab becomes active (including initial mount). */

package/dist/types/modes/setup-wizard/scenes/web-search.d.ts

@@ -19,5 +19,5 @@ export declare class WebSearchTab implements SetupTab {
     routeMouse(event: SgrMouseEvent, line: number, _col: number): void;
     invalidate(): void;
     dispose(): void;
-    render(width: number): readonly string[];
+    render(width: number, maxLines?: number): readonly string[];
 }

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;
@@ -645,6 +666,8 @@ export declare class AgentSession {
     get state(): AgentState;
     /** Current model (may be undefined if not yet selected) */
     get model(): Model | undefined;
+    /** Resolved selector while retry routing is using a fallback model. */
+    get retryFallbackModel(): string | undefined;
     /** Effective thinking level applied to the agent (the resolved level when `auto`). */
     get thinkingLevel(): ThinkingLevel | undefined;
     /** The selector the user configured: `auto` when auto mode is active, else the effective level. */
@@ -1214,7 +1237,22 @@ export declare class AgentSession {
     setAutoRetryEnabled(enabled: boolean): void;
     /**
      * Manually retry the last failed assistant turn.
-     * Removes the error message from agent state and re-attempts with a fresh retry budget.
+     * Removes the error message from active agent state when present 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.
+     *
+     * A restored session deliberately omits failed assistant turns from provider
+     * context. In that case, the persisted display transcript remains the source
+     * of truth for whether the current branch has a retryable failed tail.
+     *
      * @returns true if retry was initiated, false if no failed turn to retry or agent is busy
      */
     retry(): Promise<boolean>;
@@ -1380,6 +1418,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 +1445,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/session/session-loader.d.ts

@@ -21,9 +21,11 @@ export declare function parseSessionEntries(content: string): FileEntry[];
 export declare function loadEntriesFromFile(filePath: string, storage?: SessionStorage): Promise<FileEntry[]>;
 export declare function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void>;
 /**
- * Read-only message view of a session file: load entries, migrate to the
- * current version, resolve blob refs, and build the context along the
- * persisted leaf path (last entry). Does NOT create a writer or take the
- * session lock — safe to call against a file another session is writing.
+ * Read-only transcript view of a session file: load entries, migrate to the
+ * current version, resolve blob refs, and build the display transcript along
+ * the persisted leaf path (last entry). Uses transcript mode (collapsed to the
+ * latest compaction) so failed/aborted tail turns stay visible, unlike the
+ * provider-context builder which drops them. Does NOT create a writer or take
+ * the session lock — safe to call against a file another session is writing.
  */
 export declare function loadSessionMessagesReadOnly(filePath: string): Promise<AgentMessage[]>;

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/task/types.d.ts

@@ -83,6 +83,7 @@ export declare const taskItemSchema: import("arktype/internal/variants/object.ts
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    model?: string | string[] | undefined;
     outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
 }, {}>;
@@ -94,6 +95,8 @@ export interface TaskItem {
     agent?: string;
     /** The work; required by the schema. */
     task?: string;
+    /** Explicit model selector or fallback chain for this spawn, including optional reasoning suffixes. */
+    model?: string | string[];
     /** Caller-provided output schema; its presence overrides the selected agent's schema. */
     outputSchema?: unknown;
     /** Validation behavior for a caller-provided or inherited output schema. */
@@ -105,6 +108,7 @@ export declare const taskSchema: import("arktype/internal/variants/object.ts").O
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    model?: string | string[] | undefined;
     outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
@@ -113,6 +117,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    model?: string | string[] | undefined;
     outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
@@ -120,6 +125,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    model?: string | string[] | undefined;
     outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
@@ -128,6 +134,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
+        model?: string | string[] | undefined;
         outputSchema?: string | boolean | object | null | undefined;
         schemaMode?: "permissive" | "strict" | undefined;
         isolated?: boolean | undefined;
@@ -138,6 +145,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
+        model?: string | string[] | undefined;
         outputSchema?: string | boolean | object | null | undefined;
         schemaMode?: "permissive" | "strict" | undefined;
     }[];
@@ -168,6 +176,8 @@ export interface TaskParams {
     agent?: string;
     /** The work (flat form). */
     task?: string;
+    /** Explicit model selector or fallback chain for the spawn, including optional reasoning suffixes. */
+    model?: string | string[];
     /** Caller-provided output schema; its presence overrides the selected agent's schema. */
     outputSchema?: unknown;
     /** Validation behavior for a caller-provided or inherited output schema. */
@@ -291,6 +301,8 @@ export interface AgentProgress {
     modelOverride?: string | string[];
     /** Resolved model display string in the form `<provider>/<id>`, optionally suffixed with `:<thinkingLevel>` when the level was set explicitly. Undefined when the model could not be resolved. */
     resolvedModel?: string;
+    /** True when {@link resolvedModel} is the target of an active retry fallback (not the originally configured model). Lets observer-only UIs (collab guests, Agent Hub rows with no live session) flag the fallback and keep the provider. */
+    resolvedModelIsFallback?: boolean;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /**
@@ -357,6 +369,8 @@ export interface SingleResult {
     modelOverride?: string | string[];
     /** Resolved model display string in the form `<provider>/<id>`, optionally suffixed with `:<thinkingLevel>` when the level was set explicitly. Omitted from tool-result JSON when undefined to keep wire payloads small. */
     resolvedModel?: string;
+    /** True when {@link resolvedModel} is the target of an active retry fallback. Mirrors {@link AgentProgress.resolvedModelIsFallback} onto the settled result. */
+    resolvedModelIsFallback?: boolean;
     error?: string;
     aborted?: boolean;
     abortReason?: string;

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/hub/jobs.d.ts

@@ -55,7 +55,7 @@ export declare function noMatchingJobsResult(session: ToolSession, ids: string[]
 /** Bare `wait` with no running jobs and nobody who could message: nothing to block on. */
 export declare function nothingToWaitForResult(session: ToolSession): AgentToolResult<CoordinationDetails>;
 /** `cancel`: kill the named jobs; returns immediately with outcomes + snapshots. */
-export declare function executeCancel(session: ToolSession, manager: AsyncJobManager, ownerId: string | undefined, ids: string[]): AgentToolResult<CoordinationDetails>;
+export declare function executeCancel(session: ToolSession, manager: AsyncJobManager, ownerId: string | undefined, ids: string[]): Promise<AgentToolResult<CoordinationDetails>>;
 /** `jobs`: read-only snapshot of every job plus the jobless running-agent roster. */
 export declare function executeJobsSnapshot(session: ToolSession, manager: AsyncJobManager, ownerId: string | undefined): AgentToolResult<CoordinationDetails>;
 /** Pending-call frame for job ops (wait/cancel/jobs). */

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

@@ -13,6 +13,7 @@ import type { LocalProtocolOptions } from "../internal-urls/index.js";
 import type { MCPManager } from "../mcp/index.js";
 import type { MnemopiSessionState } from "../mnemopi/state.js";
 import type { PlanModeState } from "../plan-mode/state.js";
+import type { AgentLifecycleManager } from "../registry/agent-lifecycle.js";
 import type { AgentRegistry } from "../registry/agent-registry.js";
 import type { ArtifactManager } from "../session/artifacts.js";
 import type { ClientBridge } from "../session/client-bridge.js";
@@ -200,6 +201,8 @@ export interface ToolSession {
     xdevRegistry?: XdevRegistry;
     /** Agent registry for IRC routing across live sessions. */
     agentRegistry?: AgentRegistry;
+    /** Idle→parked→revive lifecycle owner; lets the hub kill a non-job-backed agent registration. Default: AgentLifecycleManager.global(). */
+    agentLifecycle?: () => AgentLifecycleManager;
     /** Get artifacts directory for artifact:// URLs */
     getArtifactsDir?: () => string | null;
     /** Get the ArtifactManager backing this session (shared across parent + subagents). */