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

package/src/session/agent-session.ts

@@ -30,6 +30,8 @@ import {
 	type AgentMessage,
 	type AgentState,
 	type AgentTool,
+	type AgentToolCall,
+	type AgentToolContext,
 	type AgentToolResult,
 	type AgentTurnEndContext,
 	AppendOnlyContextManager,
@@ -37,6 +39,7 @@ import {
 	type CompactionSummaryMessage,
 	countTokens,
 	createToolScopedAbortReason,
+	isSyntheticToolResultMessage,
 	resolveTelemetry,
 	type StreamFn,
 	TERMINAL_TOOL_RESULT_ABORT_REASON,
@@ -105,6 +108,7 @@ import type {
 	TextContent,
 	ToolCall,
 	ToolChoice,
+	ToolResultMessage,
 	Usage,
 	UsageReport,
 } from "@oh-my-pi/pi-ai";
@@ -238,6 +242,7 @@ import type {
 	TurnEndEvent,
 	TurnStartEvent,
 } from "../extensibility/extensions";
+import { emitSessionShutdownEvent } from "../extensibility/extensions";
 import { ManagedTimers } from "../extensibility/extensions/managed-timers";
 import { createExtensionModelQuery } from "../extensibility/extensions/model-api";
 import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types";
@@ -302,6 +307,7 @@ import { AgentRegistry } from "../registry/agent-registry";
 import {
 	deobfuscateAssistantContent,
 	deobfuscateSessionContext,
+	deobfuscateToolArguments,
 	obfuscateMessages,
 	obfuscateProviderContext,
 	type SecretObfuscator,
@@ -320,6 +326,7 @@ import {
 } from "../thinking";
 import { formatTitleConversationContext, type TitleConversationTurn } from "../tiny/message-preproc";
 import { shutdownTinyTitleClient } from "../tiny/title-client";
+import { type AskToolDetails, type AskToolInput, recoverAskQuestions } from "../tools/ask";
 import { assertEditableFile } from "../tools/auto-generated-guard";
 import { releaseTabsForOwner } from "../tools/browser/tab-supervisor";
 import { isMCPToolName, normalizeToolNames } from "../tools/builtin-names";
@@ -872,6 +879,16 @@ export interface PlanYolo {
 // Types
 // ============================================================================
 
+/** 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;
@@ -882,6 +899,8 @@ export interface AgentSessionConfig {
 	scopedModels?: Array<{ model: Model; thinkingLevel?: ThinkingLevel }>;
 	/** 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
@@ -1682,6 +1701,25 @@ function isAdvisorCard(message: AgentMessage): message is CustomMessage {
 	return message.role === "custom" && message.customType === "advisor";
 }
 
+/**
+ * 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 function logProviderTurnError(msg: AssistantMessage): void {
+	if (msg.stopReason !== "error") return;
+	logger.warn("agent turn ended with provider error", {
+		provider: msg.provider,
+		model: msg.model,
+		errorMessage: msg.errorMessage,
+		errorStatus: msg.errorStatus,
+		errorId: msg.errorId,
+	});
+}
+
 function isTerminalTextAssistantAnswer(message: AgentMessage | undefined): message is AssistantMessage {
 	if (message?.role !== "assistant" || message.stopReason !== "stop") return false;
 	let hasText = false;
@@ -1843,6 +1881,22 @@ function titleConversationTurnFromMessage(message: AgentMessage): TitleConversat
 	return { role: message.role, ...(text ? { text } : {}), ...(thinking ? { thinking } : {}) };
 }
 
+function syntheticToolResultTailStart(messages: readonly AgentMessage[]): number {
+	let index = messages.length;
+	while (index > 0 && isSyntheticToolResultMessage(messages[index - 1])) {
+		index--;
+	}
+	return index;
+}
+
+function retryableAssistantTurnEnd(messages: readonly AgentMessage[]): number | undefined {
+	const turnEnd = syntheticToolResultTailStart(messages);
+	const message = messages[turnEnd - 1];
+	if (message?.role !== "assistant") return undefined;
+	if (message.stopReason !== "error" && message.stopReason !== "aborted") return undefined;
+	return turnEnd;
+}
+
 export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
@@ -2698,6 +2752,13 @@ export class AgentSession {
 		} else {
 			this.#thinkingLevel = config.thinkingLevel;
 		}
+		if (config.initialRetryFallback) {
+			this.#activeRetryFallback = {
+				...config.initialRetryFallback,
+				lastAppliedFallbackThinkingLevel: this.configuredThinkingLevel(),
+				pinned: false,
+			};
+		}
 		if (config.prewalk) {
 			this.#prewalk = config.prewalk;
 		}
@@ -4828,9 +4889,10 @@ export class AgentSession {
 				if (toolName === "edit" && editedPath) {
 					this.#invalidateFileCacheForPath(editedPath);
 				}
+				// TodoTool commits its state during execute. Replaying the result after
+				// awaited event fan-out can overwrite a newer call from the same batch.
 				const phases = details?.phases;
 				if (toolName === "todo" && !isError && details && Array.isArray(phases) && phases.every(isTodoPhase)) {
-					this.setTodoPhases(phases);
 					if (this.#isTodoInitResult(details, toolCallId)) {
 						this.#scheduleReplanTitleRefresh();
 					}
@@ -4930,6 +4992,12 @@ export class AgentSession {
 			};
 			maintenanceRoute("entered");
 
+			// Surface provider stream failures in the main log. The routing trace
+			// above is debug-only and drops the error fields, so a session dying
+			// repeatedly on provider errors otherwise leaves no actionable trace
+			// outside the session transcript (issue #6177).
+			logProviderTurnError(msg);
+
 			// Invalidate GitHub Copilot credentials on auth failure so stale tokens
 			// aren't reused on the next request
 			if (
@@ -5081,6 +5149,15 @@ export class AgentSession {
 			if (this.#isClassifierRefusal(msg)) {
 				this.#prunedTerminalRefusal = msg;
 				this.#removeAssistantMessageFromActiveContext(msg);
+			} else if (!AIError.isContextOverflow(msg, this.model?.contextWindow ?? 0)) {
+				// No retry, fallback, or compaction continuation fired: this errored
+				// turn ends the run. #persistSessionMessageIfMissing dropped it as an
+				// empty error turn, so record it here — otherwise the JSONL stops at
+				// the last tool result and the provider's errorMessage is lost (#6249).
+				// Idempotent and a no-op for non-empty turns. Content-less overflow
+				// rejections stay live-UI only per the auto-compaction progress guard:
+				// persisting one would replay an empty assistant turn on reload.
+				await this.#persistTerminalEmptyErrorTurn(msg);
 			}
 			this.#resolveRetry();
 
@@ -6399,6 +6476,10 @@ export class AgentSession {
 		messages: AgentMessage[],
 		lastAssistantMessage = this.getLastAssistantMessage(),
 	): Promise<boolean> {
+		if (this.#abortInProgress || this.#isDisposed) {
+			this.#resetSessionStopContinuationState();
+			return false;
+		}
 		if (this.#agentKind === "sub" || !this.#extensionRunner?.hasHandlers("session_stop")) {
 			return false;
 		}
@@ -6882,15 +6963,12 @@ export class AgentSession {
 		this.#cancelExitRecorder?.();
 		this.#cancelExitRecorder = undefined;
 		try {
-			if (this.#extensionRunner?.hasHandlers("session_shutdown")) {
-				await this.#extensionRunner.emit({ type: "session_shutdown" });
-			}
+			await emitSessionShutdownEvent(this.#extensionRunner);
 		} catch (error) {
 			logger.warn("Failed to emit session_shutdown event", { error: String(error) });
 		}
 
-		// Stop extension timers before aborting deferred work they could enqueue.
-		this.#extensionRunner?.clearManagedTimers?.();
+		// Stop fallback extension timers before aborting deferred work they could enqueue.
 		this.#fallbackExtensionTimers?.clearAll();
 		this.abortRetry();
 		this.abortCompaction();
@@ -6991,6 +7069,12 @@ export class AgentSession {
 		return this.agent.state.model;
 	}
 
+	/** Resolved selector while retry routing is using a fallback model. */
+	get retryFallbackModel(): string | undefined {
+		const model = this.model;
+		return this.#activeRetryFallback && model ? formatRetryFallbackSelector(model, this.thinkingLevel) : undefined;
+	}
+
 	/** Effective thinking level applied to the agent (the resolved level when `auto`). */
 	get thinkingLevel(): ThinkingLevel | undefined {
 		return this.#thinkingLevel;
@@ -8889,12 +8973,16 @@ export class AgentSession {
 				);
 			}
 
-			// Check if we need to compact before sending (catches aborted responses). Run
-			// inline (allowDefer=false) so the handoff/maintenance fully settles before this
-			// prompt's agent loop starts — otherwise a deferred handoff would fire on the
-			// next microtask alongside the new turn.
+			// Recover a previously failed/incomplete assistant turn before sending.
+			// Successful historical turns take the cheaper pre-prompt threshold path
+			// below; re-running the full post-turn check on resume can synchronously
+			// rewrite/re-render old context before the new prompt starts.
 			const lastAssistant = this.#findLastAssistantMessage();
-			if (lastAssistant && !options?.skipCompactionCheck) {
+			if (
+				lastAssistant &&
+				!options?.skipCompactionCheck &&
+				(lastAssistant.stopReason === "error" || lastAssistant.stopReason === "length")
+			) {
 				await this.#checkCompaction(lastAssistant, false, false, false);
 			}
 
@@ -11988,7 +12076,17 @@ export class AgentSession {
 		this.#pendingRecoveredRetryErrors = [];
 	}
 
-	async #persistRetryLifecycleErrorMessage(message: AssistantMessage): Promise<void> {
+	/**
+	 * Durably record a terminal empty error turn (`stopReason: "error"` with no
+	 * substantive content) that `#persistSessionMessageIfMissing` skipped, so the
+	 * session JSONL keeps a record of why the run stopped instead of ending at the
+	 * last tool result. A no-op for non-empty/non-error turns and idempotent via
+	 * the already-persisted guard; the turn is dropped from active context by the
+	 * caller (or `isProviderRefusalMessage`/`isEmptyErrorTurn` filters) so it is
+	 * never replayed on the wire. Used by the retry-lifecycle dead-ends and the
+	 * non-retry terminal error tail.
+	 */
+	async #persistTerminalEmptyErrorTurn(message: AssistantMessage): Promise<void> {
 		await this.#waitForSessionMessagePersistence(message);
 		if (!isEmptyErrorTurn(message)) return;
 		if (this.#sessionMessageAlreadyPersisted(message)) return;
@@ -12030,7 +12128,7 @@ export class AgentSession {
 		id: number,
 		options: { switchedCredential: boolean; switchedModel: boolean; delayMs: number },
 	): Promise<void> {
-		await this.#persistRetryLifecycleErrorMessage(message);
+		await this.#persistTerminalEmptyErrorTurn(message);
 		const persistenceKey = sessionMessagePersistenceKey(message);
 		if (!persistenceKey) return;
 		let branchEntry: SessionEntry | undefined;
@@ -14810,15 +14908,34 @@ export class AgentSession {
 		return message.content.some(block => block.type === "toolCall");
 	}
 
+	/**
+	 * OpenRouter can repeatedly close Gemini streams at the reasoning-to-payload
+	 * transition. One retry covers a transient edge failure; the normal ten-retry
+	 * budget would otherwise re-run the same expensive reasoning cycle unchanged.
+	 */
+	#isOpenRouterThinkingStreamClose(message: AssistantMessage): boolean {
+		return (
+			message.provider === "openrouter" &&
+			/server_error:\s*stream closed with reason:\s*error/i.test(message.errorMessage ?? "") &&
+			message.content.some(block => block.type === "thinking" && block.thinking.trim().length > 0)
+		);
+	}
+
 	#isClassifierRefusal(message: AssistantMessage): boolean {
 		if (message.stopReason !== "error") return false;
 		const stopType = message.stopDetails?.type;
 		return stopType === "refusal" || stopType === "sensitive";
 	}
 
-	/** True when any registered model belongs to `provider`. */
-	#hasProviderModels(provider: string): boolean {
-		return this.#modelRegistry.getAll().some(model => model.provider === provider);
+	/**
+	 * True when `provider` has registered models or is configured for dynamic
+	 * discovery. Discovery-only providers (e.g. a models.yml provider with
+	 * `discovery:` and no static models) can hold zero models until the online
+	 * refresh completes, so a models-only check would misreport them as
+	 * unknown during session construction.
+	 */
+	#isKnownProvider(provider: string): boolean {
+		return this.#modelRegistry.hasProvider(provider);
 	}
 
 	#getRetryFallbackChains(): RetryFallbackChains {
@@ -14851,8 +14968,8 @@ export class AgentSession {
 			const keyKind = isRetryFallbackModelKey(key) ? "model" : "role";
 			if (keyKind === "model") {
 				if (isRetryFallbackWildcardKey(key)) {
-					const { provider } = parseRetryFallbackWildcard(key, p => this.#hasProviderModels(p));
-					if (!this.#hasProviderModels(provider)) {
+					const { provider } = parseRetryFallbackWildcard(key, p => this.#isKnownProvider(p));
+					if (!this.#isKnownProvider(provider)) {
 						const msg = `retry.fallbackChains wildcard key references unknown provider: ${key}`;
 						logger.warn(msg);
 						this.configWarnings.push(msg);
@@ -14884,8 +15001,8 @@ export class AgentSession {
 					continue;
 				}
 				if (isRetryFallbackWildcardKey(selectorStr)) {
-					const { provider } = parseRetryFallbackWildcard(selectorStr, p => this.#hasProviderModels(p));
-					if (!this.#hasProviderModels(provider)) {
+					const { provider } = parseRetryFallbackWildcard(selectorStr, p => this.#isKnownProvider(p));
+					if (!this.#isKnownProvider(provider)) {
 						const msg = `Fallback chain for ${keyKind} '${key}' references unknown provider: ${selectorStr}`;
 						logger.warn(msg);
 						this.configWarnings.push(msg);
@@ -14985,7 +15102,7 @@ export class AgentSession {
 		let wildcardPrefixLength = -1;
 		for (const key in chains) {
 			if (!isRetryFallbackWildcardKey(key) || !Array.isArray(chains[key])) continue;
-			const { provider, idPrefix } = parseRetryFallbackWildcard(key, p => this.#hasProviderModels(p));
+			const { provider, idPrefix } = parseRetryFallbackWildcard(key, p => this.#isKnownProvider(p));
 			if (provider !== parsedCurrent.provider) continue;
 			if (idPrefix !== undefined && !parsedCurrent.id.startsWith(`${idPrefix}/`)) continue;
 			const prefixLength = idPrefix === undefined ? 0 : idPrefix.length;
@@ -15025,7 +15142,7 @@ export class AgentSession {
 	): RetryFallbackSelector | undefined {
 		if (isRetryFallbackWildcardKey(entry)) {
 			if (!current) return undefined;
-			const { provider, idPrefix } = parseRetryFallbackWildcard(entry, p => this.#hasProviderModels(p));
+			const { provider, idPrefix } = parseRetryFallbackWildcard(entry, p => this.#isKnownProvider(p));
 			const bareId = current.id.slice(current.id.lastIndexOf("/") + 1);
 			let id: string;
 			if (idPrefix !== undefined) {
@@ -15408,7 +15525,10 @@ export class AgentSession {
 		// (every rotation sets switchedCredential and skips it), so without
 		// this last resort a provider-wide usage cap never fails over to the
 		// configured chain.
-		const retryBudgetExhausted = this.#retryAttempt > retrySettings.maxRetries;
+		const maxRetries = this.#isOpenRouterThinkingStreamClose(message)
+			? Math.min(retrySettings.maxRetries, 1)
+			: retrySettings.maxRetries;
+		const retryBudgetExhausted = this.#retryAttempt > maxRetries;
 
 		const errorMessage = message.errorMessage || "Unknown error";
 		const id = this.#classifyRetryMessage(message);
@@ -15501,7 +15621,7 @@ export class AgentSession {
 		}
 		if (retryBudgetExhausted) {
 			if (!switchedModel) {
-				await this.#persistRetryLifecycleErrorMessage(message);
+				await this.#persistTerminalEmptyErrorTurn(message);
 				// Max retries exceeded and no fallback model to switch to: emit
 				// final failure and reset.
 				await this.#emitSessionEvent({
@@ -15548,7 +15668,7 @@ export class AgentSession {
 		// can act on it.
 		const maxDelayMs = retrySettings.maxDelayMs;
 		if (maxDelayMs > 0 && delayMs > maxDelayMs && !switchedCredential && !switchedModel) {
-			await this.#persistRetryLifecycleErrorMessage(message);
+			await this.#persistTerminalEmptyErrorTurn(message);
 			const attempt = this.#retryAttempt;
 			this.#retryAttempt = 0;
 			await this.#emitSessionEvent({
@@ -15567,7 +15687,7 @@ export class AgentSession {
 		await this.#emitSessionEvent({
 			type: "auto_retry_start",
 			attempt: this.#retryAttempt,
-			maxAttempts: retrySettings.maxRetries,
+			maxAttempts: maxRetries,
 			delayMs,
 			errorMessage,
 			errorId: message.errorId,
@@ -15692,21 +15812,40 @@ export class AgentSession {
 	}
 	/**
 	 * 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
 	 */
 	async retry(): Promise<boolean> {
 		if (this.isStreaming || this.isCompacting || this.isRetrying) return false;
 
 		const messages = this.agent.state.messages;
-		const lastMsg = messages[messages.length - 1];
-		if (lastMsg?.role !== "assistant") return false;
-
-		const assistantMsg = lastMsg as AssistantMessage;
-		if (assistantMsg.stopReason !== "error" && assistantMsg.stopReason !== "aborted") return false;
-
-		// Remove the failed/aborted assistant message (same as auto-retry does before re-attempting)
-		this.agent.replaceMessages(messages.slice(0, -1));
+		const activeTurnEnd = retryableAssistantTurnEnd(messages);
+		if (activeTurnEnd !== undefined) {
+			// Remove the failed/aborted assistant message plus its synthetic tool
+			// results (same as auto-retry does before re-attempting).
+			this.agent.replaceMessages(messages.slice(0, activeTurnEnd - 1));
+		} else {
+			// A restored session already dropped the failed assistant turn (and its
+			// paired synthetic tool results) from provider context, so the persisted
+			// display transcript is the source of truth for a retryable failed tail.
+			const transcriptMessages = this.sessionManager.buildSessionContext({ transcript: true }).messages;
+			if (retryableAssistantTurnEnd(transcriptMessages) === undefined) return false;
+		}
 
 		// Reset retry budget for a fresh attempt
 		this.#retryAttempt = 0;
@@ -15941,7 +16080,7 @@ export class AgentSession {
 					signal: abortController.signal,
 					sessionKey: target.sessionId,
 					cwd,
-					timeout: clampTimeout("bash") * 1000,
+					timeout: clampTimeout("bash", undefined, this.settings.get("tools.maxTimeout")) * 1000,
 					onMinimizedSave: originalText => this.#saveBashOriginalArtifact(target, originalText),
 					useUserShell: options?.useUserShell,
 				});
@@ -17023,7 +17162,30 @@ export class AgentSession {
 	 */
 	async navigateTree(
 		targetId: string,
-		options: { summarize?: boolean; customInstructions?: 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;
@@ -17031,12 +17193,36 @@ export 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"] };
 	}> {
 		await this.#flushPendingBashMessages();
 		const oldLeafId = this.sessionManager.getLeafId();
 
-		// No-op if already at target
-		if (targetId === oldLeafId) {
+		const targetEntry = this.sessionManager.getEntry(targetId);
+		if (!targetEntry) {
+			throw new Error(`Entry ${targetId} not found`);
+		}
+		const targetIsAskResult =
+			targetEntry.type === "message" &&
+			targetEntry.message.role === "toolResult" &&
+			targetEntry.message.toolName === "ask";
+
+		// No-op if already at target — except mid-flight through the `ask`
+		// re-answer protocol (issue #5642): a probe or completion call can
+		// legitimately target the *current* leaf (e.g. the user interrupted
+		// right after answering `ask`, before a follow-up assistant message
+		// landed, or another caller navigated straight onto the ask result),
+		// and must still return `reopenAsk` / branch the new answer instead of
+		// silently reporting a no-op (chatgpt-codex review on #5895).
+		if (targetId === oldLeafId && !(options.allowAskReopen && targetIsAskResult)) {
 			return { cancelled: false };
 		}
 
@@ -17045,16 +17231,47 @@ export class AgentSession {
 			throw new Error("No model available for summarization");
 		}
 
-		const targetEntry = this.sessionManager.getEntry(targetId);
-		if (!targetEntry) {
-			throw new Error(`Entry ${targetId} not found`);
-		}
-
-		// Collect entries to summarize (from old leaf to common ancestor)
+		// `ask` toolResult, first pass: hand control back to the caller to
+		// re-open the picker instead of landing on the stale answer in place.
+		// Nothing is mutated here — see the `reanswerAskResult` branch below for
+		// the actual sibling-branch construction once the caller has an answer.
+		// Gated on `allowAskReopen` — callers that don't understand `reopenAsk`
+		// fall straight through to the plain leaf move below instead of
+		// reporting a successful no-op (roboomp review on #5895).
+		if (
+			options.allowAskReopen &&
+			!options.reanswerAskResult &&
+			targetEntry.type === "message" &&
+			targetEntry.message.role === "toolResult" &&
+			targetEntry.message.toolName === "ask"
+		) {
+			const toolCallId = targetEntry.message.toolCallId;
+			const questions = this.#recoverAskReanswerQuestions(targetEntry.parentId, toolCallId);
+			if (questions) {
+				return { cancelled: false, reopenAsk: { toolCallId, questions } };
+			}
+			// Original arguments couldn't be recovered (corrupted/legacy session
+			// data) — fall through to a plain leaf move so navigation still works.
+		}
+
+		// Collect entries to summarize (from old leaf to common ancestor). For an
+		// `ask` re-answer completion, the branch point is `targetEntry.parentId`
+		// (the new sibling toolResult lands there, not on `targetId`) — anchor
+		// the collection there too, or the old answer entry is neither on the
+		// new branch nor included in the summary (chatgpt-codex review on
+		// #5895).
+		const summaryAnchorId =
+			options.reanswerAskResult !== undefined &&
+			targetEntry.type === "message" &&
+			targetEntry.message.role === "toolResult" &&
+			targetEntry.message.toolName === "ask" &&
+			targetEntry.parentId !== null
+				? targetEntry.parentId
+				: targetId;
 		const { entries: entriesToSummarize, commonAncestorId } = collectEntriesForBranchSummary(
 			this.sessionManager,
 			oldLeafId,
-			targetId,
+			summaryAnchorId,
 		);
 
 		// Prepare event data
@@ -17150,6 +17367,27 @@ export class AgentSession {
 							.filter((c): c is { type: "text"; text: string } => c.type === "text")
 							.map(c => c.text)
 							.join("");
+		} else if (
+			targetEntry.type === "message" &&
+			targetEntry.message.role === "toolResult" &&
+			targetEntry.message.toolName === "ask" &&
+			options.reanswerAskResult
+		) {
+			// `ask` toolResult, second pass: the caller re-opened the picker and
+			// is handing back a fresh answer. Branch a *new* sibling toolResult
+			// off the same `ask` toolCall instead of reusing `targetId` — the
+			// original answer's branch stays reachable (issue #5642).
+			const reanswer = options.reanswerAskResult;
+			const toolResultMessage: ToolResultMessage = {
+				role: "toolResult",
+				toolCallId: targetEntry.message.toolCallId,
+				toolName: "ask",
+				content: reanswer.content,
+				details: reanswer.details,
+				isError: reanswer.isError === true,
+				timestamp: Date.now(),
+			};
+			newLeafId = this.sessionManager.appendMessageToBranch(toolResultMessage, targetEntry.parentId);
 		} else {
 			// Non-user message (or a user-invoked skill-prompt injection): land the
 			// leaf on the selected node so it stays on the active branch. Skill
@@ -17212,6 +17450,73 @@ export class AgentSession {
 		return { editorText, cancelled: false, summaryEntry, sessionContext: stateContext };
 	}
 
+	/**
+	 * Look up the `ask` toolCall's persisted `arguments` and validate them
+	 * back into `questions`, for `/tree` `ask` re-answer (issue #5642). Walks
+	 * up from the toolResult's parent past any interleaved ancestor entries
+	 * — sibling toolResults from other tool calls in the same turn (`ask`
+	 * runs `exclusive`, which only serializes *execution*, not persistence
+	 * order — roboomp review on #5895), and bookkeeping entries such as the
+	 * `tool_execution_start` custom entry `#recordToolExecutionStart()`
+	 * appends before every toolResult in real persisted sessions (chatgpt-codex
+	 * review on #5895) — until it finds the assistant entry that actually
+	 * emitted `toolCallId`. Stops at a `user` message (turn boundary) or a
+	 * dead end. Returns `undefined` when no ancestor entry holds a matching
+	 * `ask` toolCall, or the arguments can't be resolved — the caller falls
+	 * back to a plain leaf move rather than opening a picker with bad data.
+	 */
+	#recoverAskReanswerQuestions(parentId: string | null, toolCallId: string): AskToolInput["questions"] | undefined {
+		let current = parentId;
+		while (current !== null) {
+			const entry = this.sessionManager.getEntry(current);
+			if (!entry) return undefined;
+			if (entry.type === "message") {
+				if (entry.message.role === "assistant") {
+					const toolCall = entry.message.content.find(
+						(block): block is AgentToolCall => block.type === "toolCall" && block.id === toolCallId,
+					);
+					if (!toolCall) return undefined;
+					if (toolCall.name !== "ask") return undefined;
+					const args = this.#obfuscator?.hasSecrets()
+						? deobfuscateToolArguments(this.#obfuscator, toolCall.arguments)
+						: toolCall.arguments;
+					return recoverAskQuestions(args);
+				}
+				if (entry.message.role === "user") return undefined;
+			}
+			current = entry.parentId;
+		}
+		return undefined;
+	}
+
+	/**
+	 * 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 {
+		return {
+			sessionManager: this.sessionManager,
+			modelRegistry: this.#modelRegistry,
+			model: this.model,
+			isIdle: () => !this.isStreaming,
+			hasQueuedMessages: () => this.queuedMessageCount > 0,
+			abort: () => {
+				this.agent.abort();
+			},
+			settings: this.settings,
+			ui: uiContext,
+			hasUI: true,
+		};
+	}
+
 	/**
 	 * Get all user messages from session for branch selector.
 	 */