@gajae-code/coding-agent 0.11.9 → 0.11.10

package/src/task/executor.ts

@@ -15,7 +15,7 @@ import type {
 } from "@gajae-code/agent-core";
 import { recordHandoff, resolveTelemetry } from "@gajae-code/agent-core";
 import { estimateMessageTokensHeuristic } from "@gajae-code/agent-core/compaction";
-import type { Message, Model, ServiceTier } from "@gajae-code/ai";
+import type { AssistantMessage, Message, Model, ServiceTier } from "@gajae-code/ai";
 import { type JsonSchemaValidationIssue, validateJsonSchemaValue } from "@gajae-code/ai/utils/schema";
 import { logger, prompt, untilAborted } from "@gajae-code/utils";
 import { AsyncJobManager } from "../async";
@@ -50,6 +50,7 @@ import type { EventBus } from "../utils/event-bus";
 import { buildNamedToolChoiceResult } from "../utils/tool-choice";
 import type { WorkspaceTree } from "../workspace-tree";
 import { validateAllocatedTaskId } from "./id";
+import { classifyProviderRetry, providerNameFromModel } from "./provider-retry-status";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import { persistTaskTokenLog, taskTokenLogFromUsage } from "./token-log";
 import {
@@ -81,6 +82,21 @@ const agentEventTypes = new Set<AgentEvent["type"]>([
 	"tool_execution_end",
 ]);
 
+const providerStreamingUpdateTypes = new Set<string>([
+	"text_start",
+	"text_delta",
+	"text_end",
+	"thinking_start",
+	"thinking_delta",
+	"thinking_end",
+	"reasoning_summary_start",
+	"reasoning_summary_delta",
+	"reasoning_summary_end",
+	"toolcall_start",
+	"toolcall_delta",
+	"toolcall_end",
+]);
+
 const isAgentEvent = (event: AgentSessionEvent): event is AgentEvent =>
 	agentEventTypes.has(event.type as AgentEvent["type"]);
 
@@ -845,7 +861,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	let modelSubstitutionWarning: ModelSubstitutionWarning | undefined;
 	let resolvedModelString: string | undefined;
 	let lastAssistantModelString: string | undefined;
+	let activeProviderModelString: string | undefined;
 	let effectiveThinkingLevelForWarning: ThinkingLevel | undefined;
+	let lastProviderProgressAtMs: number | undefined;
+	let sessionEventOrdinal = 0;
+	let retryStartOrdinal = 0;
+	const seenAssistantMessages = new WeakSet<AgentMessage>();
+	const seenAssistantMessageIdentities = new Set<string>();
 
 	// Accumulate usage incrementally from message_end events (no memory for streaming events)
 	const accumulatedUsage = {
@@ -927,7 +949,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	const emitProgressNow = () => {
 		progress.durationMs = Date.now() - startTime;
-		onProgress?.({ ...progress });
+		const progressSnapshot = structuredClone(progress);
+		onProgress?.(progressSnapshot);
 		if (options.eventBus) {
 			options.eventBus.emit(TASK_SUBAGENT_PROGRESS_CHANNEL, {
 				index,
@@ -935,7 +958,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				agentSource: agent.source,
 				task,
 				assignment,
-				progress: { ...progress },
+				progress: progressSnapshot,
 				sessionFile: null,
 			});
 		}
@@ -990,6 +1013,79 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			: undefined;
 	};
 
+	const getAssistantMessageIdentity = (message: AgentMessage): string | undefined => {
+		if (message.role !== "assistant") return undefined;
+		const model = getMessageModelString(message);
+		const timestamp = "timestamp" in message ? message.timestamp : undefined;
+		if (!model || typeof timestamp !== "number") return undefined;
+		const responseId = "responseId" in message && typeof message.responseId === "string" ? message.responseId : "";
+		return JSON.stringify([model, timestamp, responseId]);
+	};
+
+	const rememberAssistantMessage = (message: AgentMessage): void => {
+		seenAssistantMessages.add(message);
+		const identity = getAssistantMessageIdentity(message);
+		if (identity) seenAssistantMessageIdentities.add(identity);
+	};
+
+	const isProviderAssistantMessage = (message: AgentMessage): message is AssistantMessage =>
+		message.role === "assistant" &&
+		"stopReason" in message &&
+		Array.isArray(message.content) &&
+		getMessageModelString(message) !== undefined;
+
+	const isSuccessfulProviderAssistantMessage = (message: AgentMessage): message is AssistantMessage =>
+		isProviderAssistantMessage(message) &&
+		message.stopReason !== "error" &&
+		message.stopReason !== "aborted" &&
+		message.errorMessage === undefined &&
+		message.errorKind === undefined &&
+		message.transportFailure === undefined;
+
+	const hasMatchingActiveProviderModel = (message: AgentMessage): message is AssistantMessage =>
+		isProviderAssistantMessage(message) &&
+		activeProviderModelString !== undefined &&
+		getMessageModelString(message) === activeProviderModelString;
+
+	const isProviderStreamingUpdate = (event: Extract<AgentEvent, { type: "message_update" }>): boolean => {
+		const update = event.assistantMessageEvent;
+		if (!update || typeof update !== "object" || !providerStreamingUpdateTypes.has(update.type)) return false;
+		if (!("partial" in update) || getMessageModelString(update.partial) !== activeProviderModelString) return false;
+		switch (update.type) {
+			case "text_delta":
+			case "thinking_delta":
+			case "reasoning_summary_delta":
+			case "toolcall_delta":
+				return typeof update.delta === "string";
+			default:
+				return typeof update.contentIndex === "number";
+		}
+	};
+
+	const getProviderTextDelta = (event: Extract<AgentEvent, { type: "message_update" }>): string | undefined => {
+		const update = (event as { assistantMessageEvent?: unknown }).assistantMessageEvent;
+		if (!update || typeof update !== "object") return undefined;
+		const record = update as { type?: unknown; delta?: unknown };
+		return record.type === "text_delta" && typeof record.delta === "string" ? record.delta : undefined;
+	};
+
+	const isProviderBackedRecoveryEvent = (
+		event: Extract<AgentEvent, { type: "message_start" | "message_update" }>,
+		eventOrdinal: number,
+	): boolean => {
+		const messageIdentity = getAssistantMessageIdentity(event.message);
+		if (
+			!progress.retryState ||
+			eventOrdinal <= retryStartOrdinal ||
+			seenAssistantMessages.has(event.message) ||
+			(messageIdentity !== undefined && seenAssistantMessageIdentities.has(messageIdentity))
+		)
+			return false;
+		if (!hasMatchingActiveProviderModel(event.message)) return false;
+		if (event.type === "message_start") return isSuccessfulProviderAssistantMessage(event.message);
+		return isProviderStreamingUpdate(event);
+	};
+
 	const updateRecentOutputLines = () => {
 		const lines = recentOutputTail.split("\n").filter(line => line.trim());
 		progress.recentOutput = lines.slice(-8).reverse();
@@ -1004,21 +1100,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		updateRecentOutputLines();
 	};
 
-	const replaceRecentOutputFromContent = (content: unknown[]) => {
-		recentOutputTail = "";
-		for (const block of content) {
-			if (!block || typeof block !== "object") continue;
-			const record = block as { type?: unknown; text?: unknown };
-			if (record.type !== "text" || typeof record.text !== "string") continue;
-			if (!record.text) continue;
-			recentOutputTail += record.text;
-			if (recentOutputTail.length > RECENT_OUTPUT_TAIL_BYTES) {
-				recentOutputTail = recentOutputTail.slice(-RECENT_OUTPUT_TAIL_BYTES);
-			}
-		}
-		updateRecentOutputLines();
-	};
-
 	const resetRecentOutput = () => {
 		recentOutputTail = "";
 		progress.recentOutput = [];
@@ -1038,20 +1119,32 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		});
 	};
 
-	const processEvent = (event: AgentEvent) => {
+	const processEvent = (event: AgentEvent, eventOrdinal: number) => {
 		if (resolved) return;
 
 		forwardSubagentEvent(event);
 
 		const now = Date.now();
 		let flushProgress = false;
+		// A retry is recovered at the first assistant provider event, before the
+		// session emits auto_retry_end after message completion.
 
 		switch (event.type) {
-			case "message_start":
-				if (event.message?.role === "assistant") {
+			case "message_start": {
+				if (event.message.role !== "assistant") break;
+				const retryWasActive = Boolean(progress.retryState);
+				const recoversRetry = isProviderBackedRecoveryEvent(event, eventOrdinal);
+				rememberAssistantMessage(event.message);
+				if (recoversRetry || !retryWasActive) {
+					lastProviderProgressAtMs = now;
 					resetRecentOutput();
 				}
+				if (recoversRetry) {
+					progress.retryState = undefined;
+					flushProgress = true;
+				}
 				break;
+			}
 
 			case "tool_execution_start": {
 				progress.toolCount++;
@@ -1163,24 +1256,17 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			}
 
 			case "message_update": {
-				if (event.message?.role !== "assistant") break;
-				const assistantEvent = (
-					event as AgentEvent & {
-						assistantMessageEvent?: { type?: string; delta?: string };
-					}
-				).assistantMessageEvent;
-				if (assistantEvent?.type === "text_delta" && typeof assistantEvent.delta === "string") {
-					appendRecentOutputTail(assistantEvent.delta);
-					break;
-				}
-				if (assistantEvent && assistantEvent.type !== "text_delta") {
-					break;
-				}
-				const updateContent =
-					getMessageContent(event.message) || (event as AgentEvent & { content?: unknown }).content;
-				if (updateContent && Array.isArray(updateContent)) {
-					replaceRecentOutputFromContent(updateContent);
+				if (event.message.role !== "assistant") break;
+				const retryWasActive = Boolean(progress.retryState);
+				const recoversRetry = isProviderBackedRecoveryEvent(event, eventOrdinal);
+				if (!retryWasActive) rememberAssistantMessage(event.message);
+				if (recoversRetry || !retryWasActive) lastProviderProgressAtMs = now;
+				if (recoversRetry) {
+					progress.retryState = undefined;
+					flushProgress = true;
 				}
+				const textDelta = getProviderTextDelta(event);
+				if (textDelta !== undefined) appendRecentOutputTail(textDelta);
 				break;
 			}
 
@@ -1188,6 +1274,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				// Extract text from assistant and toolResult messages (not user prompts)
 				const role = event.message?.role;
 				if (role === "assistant") {
+					if (isSuccessfulProviderAssistantMessage(event.message)) lastProviderProgressAtMs = now;
 					const messageContent =
 						getMessageContent(event.message) || (event as AgentEvent & { content?: unknown }).content;
 					if (messageContent && Array.isArray(messageContent)) {
@@ -1200,6 +1287,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					const assistantModel = getMessageModelString(event.message);
 					if (assistantModel) {
 						lastAssistantModelString = assistantModel;
+						activeProviderModelString = assistantModel;
 						if (resolvedModelString && assistantModel !== resolvedModelString && !modelSubstitutionWarning) {
 							modelSubstitutionWarning = {
 								requested: resolvedModelString,
@@ -1367,6 +1455,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			);
 			if (model) {
 				resolvedModelString = formatModelString(model);
+				activeProviderModelString = resolvedModelString;
 			}
 			if (authFallbackUsed && model && requestedModel) {
 				modelSubstitutionWarning = {
@@ -1504,6 +1593,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 							? { requestedModel, reason: modelSubstitutionWarning.reason }
 							: undefined,
 					toolNames,
+					alwaysActiveToolNames: ircEnabled ? ["irc"] : undefined,
 					outputSchema,
 					requireYieldTool: true,
 					contextFiles: options.contextFiles,
@@ -1737,11 +1827,22 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			const MAX_YIELD_RETRIES = 3;
 			unsubscribe = session.subscribe(event => {
+				sessionEventOrdinal += 1;
+				const eventOrdinal = sessionEventOrdinal;
 				if (event.type === "auto_retry_start") {
+					retryStartOrdinal = eventOrdinal;
+					for (const message of session.messages) {
+						if (message.role === "assistant") rememberAssistantMessage(message);
+					}
 					progress.retryState = {
 						attempt: event.attempt,
 						maxAttempts: event.maxAttempts,
 						unbounded: event.unbounded,
+						kind: classifyProviderRetry(event.errorMessage),
+						provider: providerNameFromModel(
+							activeProviderModelString ?? lastAssistantModelString ?? resolvedModelString,
+						),
+						lastProviderProgressAtMs,
 						delayMs: event.delayMs,
 						errorMessage: event.errorMessage,
 						startedAtMs: Date.now(),
@@ -1763,12 +1864,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					return;
 				}
 				if (event.type === "model_fallback_switched") {
+					activeProviderModelString = event.to;
 					forwardSubagentEvent(event);
 					return;
 				}
 				if (isAgentEvent(event)) {
 					try {
-						processEvent(event);
+						processEvent(event, eventOrdinal);
 					} catch (err) {
 						logger.error("Subagent event processing failed", {
 							error: err instanceof Error ? err.message : String(err),

package/src/task/provider-retry-status.ts

@@ -0,0 +1,88 @@
+import type { AgentProgress, TaskToolDetails } from "./types";
+
+export type ProviderRetryKind = NonNullable<AgentProgress["retryState"]>["kind"];
+
+const FIRST_EVENT_TIMEOUT_PATTERN = /stream timed out while waiting for the first event/i;
+const IDLE_STREAM_STALL_PATTERN = /stream stalled while waiting for the next event/i;
+
+export function classifyProviderRetry(errorMessage: string): ProviderRetryKind {
+	if (FIRST_EVENT_TIMEOUT_PATTERN.test(errorMessage)) return "first_event_timeout";
+	if (IDLE_STREAM_STALL_PATTERN.test(errorMessage)) return "idle_stream_stall";
+	return "provider_error";
+}
+
+export function providerNameFromModel(model: string | undefined): string | undefined {
+	const provider = model?.split("/", 1)[0]?.trim();
+	return provider || undefined;
+}
+
+export function providerRetryPhaseLabel(kind: ProviderRetryKind): string {
+	switch (kind) {
+		case "first_event_timeout":
+			return "first event timeout";
+		case "idle_stream_stall":
+			return "stream stalled";
+		case "provider_error":
+			return "provider error";
+	}
+}
+
+export function providerProgressAgeLabel(retryState: NonNullable<AgentProgress["retryState"]>, nowMs: number): string {
+	if (retryState.lastProviderProgressAtMs === undefined) return "no provider events yet";
+	const ageSeconds = Math.max(0, Math.floor((nowMs - retryState.lastProviderProgressAtMs) / 1000));
+	return `last provider progress ${ageSeconds}s ago`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object";
+}
+
+function isTaskToolDetails(value: unknown): value is TaskToolDetails {
+	return (
+		isRecord(value) && Array.isArray(value.results) && (value.progress === undefined || Array.isArray(value.progress))
+	);
+}
+
+function isAgentProgress(value: unknown): value is AgentProgress {
+	return isRecord(value) && typeof value.status === "string";
+}
+
+export function hasActiveProviderRetryInTaskDetails(details: TaskToolDetails, seen = new WeakSet<object>()): boolean {
+	if (!isTaskToolDetails(details) || seen.has(details)) return false;
+	seen.add(details);
+	for (const progress of details.progress ?? []) {
+		if (isAgentProgress(progress) && hasActiveProviderRetryInProgress(progress, seen)) return true;
+	}
+	return false;
+}
+
+export function hasActiveProviderRetryInProgress(progress: AgentProgress, seen = new WeakSet<object>()): boolean {
+	if (!isAgentProgress(progress) || seen.has(progress)) return false;
+	seen.add(progress);
+	if (progress.status === "running" && progress.retryState) return true;
+
+	const nestedTaskData = isRecord(progress.extractedToolData) ? progress.extractedToolData.task : undefined;
+	if (Array.isArray(nestedTaskData)) {
+		for (const nestedDetails of nestedTaskData) {
+			if (hasActiveProviderRetryInTaskDetails(nestedDetails as TaskToolDetails, seen)) return true;
+		}
+	}
+	return hasActiveProviderRetryInTaskDetails(progress.inflightTaskDetails as TaskToolDetails, seen);
+}
+
+export interface ProviderDegradationGroup {
+	provider: string;
+	count: number;
+}
+
+export function collectProviderDegradationGroups(progress: readonly AgentProgress[]): ProviderDegradationGroup[] {
+	const counts = new Map<string, number>();
+	for (const item of progress) {
+		if (!isAgentProgress(item) || item.status !== "running" || !item.retryState) continue;
+		const provider = item.retryState.provider ?? "provider";
+		counts.set(provider, (counts.get(provider) ?? 0) + 1);
+	}
+	return Array.from(counts, ([provider, count]) => ({ provider, count }))
+		.filter(group => group.count > 1)
+		.sort((a, b) => b.count - a.count || a.provider.localeCompare(b.provider));
+}

package/src/task/render.ts

@@ -28,6 +28,12 @@ import {
 	type SubmitReviewDetails,
 } from "../tools/review";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine } from "../tui";
+import {
+	collectProviderDegradationGroups,
+	hasActiveProviderRetryInTaskDetails,
+	providerProgressAgeLabel,
+	providerRetryPhaseLabel,
+} from "./provider-retry-status";
 import type { TaskResultReceipt } from "./receipt";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import type { AgentProgress, TaskParams, TaskToolDetails } from "./types";
@@ -123,6 +129,15 @@ function formatModelSubstitutionWarning(warning: { requested: string; effective:
 	return `Requested model substituted: ${warning.requested} -> ${warning.effective}`;
 }
 
+function renderProviderDegradationNotices(progress: readonly AgentProgress[], theme: Theme): string[] {
+	return collectProviderDegradationGroups(progress).map(group =>
+		theme.fg(
+			"warning",
+			truncateToWidth(replaceTabs(`provider degraded: ${group.count} subagents retrying on ${group.provider}`), 100),
+		),
+	);
+}
+
 function formatJsonScalar(value: unknown, _theme: Theme): string {
 	if (value === null) return "null";
 	if (typeof value === "string") {
@@ -548,14 +563,11 @@ function renderAgentProgress(
 	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
 	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)}`;
 
-	// Show retry-blocked badge so the parent immediately sees that a child
-	// is sleeping on a provider 429, not silently progressing. Wins over the
-	// generic running spinner because "we're waiting on a quota window" is
-	// the operationally meaningful state.
+	// A provider recovery loop is operationally distinct from normal agent work.
 	if (progress.retryState && progress.status === "running") {
-		statusLine += ` ${formatBadge("retrying", "warning", theme)}`;
+		statusLine += ` ${formatBadge("provider degraded", "warning", theme)}`;
 	} else if (progress.retryFailure && (progress.status === "failed" || progress.status === "aborted")) {
-		statusLine += ` ${formatBadge("rate-limited", "error", theme)}`;
+		statusLine += ` ${formatBadge("provider failed", "error", theme)}`;
 	} else if (progress.status === "failed" || progress.status === "aborted") {
 		const statusLabel = progress.status === "failed" ? "failed" : "aborted";
 		statusLine += ` ${formatBadge(statusLabel, iconColor, theme)}`;
@@ -615,8 +627,10 @@ function renderAgentProgress(
 	// keep spinning while a child sleeps on a 3-hour provider rate-limit.
 	if (progress.retryState && progress.status === "running") {
 		const attemptLabel = progress.retryState.unbounded
-			? `attempt ${progress.retryState.attempt}`
-			: `${progress.retryState.attempt}/${progress.retryState.maxAttempts}`;
+			? `attempt ${progress.retryState.attempt}, unbounded`
+			: `attempt ${progress.retryState.attempt} of ${progress.retryState.maxAttempts}, bounded`;
+		const phaseLabel = providerRetryPhaseLabel(progress.retryState.kind);
+		const progressAge = staticTime ? "" : ` · ${providerProgressAgeLabel(progress.retryState, Date.now())}`;
 		// `staticTime` omits the wall-clock countdown so a cached await body stays a
 		// pure function of its key (the producer already drops time-only churn).
 		let waitLabel = "";
@@ -624,7 +638,7 @@ function renderAgentProgress(
 			const remainingMs = Math.max(0, progress.retryState.startedAtMs + progress.retryState.delayMs - Date.now());
 			waitLabel = remainingMs > 0 ? ` in ${formatDuration(remainingMs)}` : " now";
 		}
-		const summary = `retrying ${attemptLabel}${waitLabel}: ${truncateToWidth(replaceTabs(progress.retryState.errorMessage), 60)}`;
+		const summary = `${phaseLabel} · retrying ${attemptLabel}${waitLabel}${progressAge}: ${truncateToWidth(replaceTabs(progress.retryState.errorMessage), 60)}`;
 		lines.push(`${continuePrefix}${theme.tree.hook} ${theme.fg("warning", summary)}`);
 	} else if (progress.retryFailure && progress.status !== "running") {
 		const summary = `auto-retry gave up after ${progress.retryFailure.attempt} attempt${
@@ -953,23 +967,28 @@ export function renderResult(
 				.u32(spinnerFrame ?? 0)
 				.u32(width)
 				.digest();
-			if (cached?.key === key) return cached.lines;
+			const hasDynamicRetry = hasActiveProviderRetryInTaskDetails(details);
+			if (!hasDynamicRetry && cached?.key === key) return cached.lines;
 
 			const lines: string[] = [];
 
-			const shouldRenderProgress =
-				Boolean(details.progress && details.progress.length > 0) && (isPartial || details.results.length === 0);
+			const hasProgress = Boolean(details.progress && details.progress.length > 0);
+			const shouldRenderProgress = hasProgress && (isPartial || details.results.length === 0);
+			const hasResults = details.results.length > 0;
+			if (hasResults) {
+				details.results.forEach((res, i) => {
+					const isLast = !shouldRenderProgress && i === details.results.length - 1;
+					lines.push(...renderAgentResult(res, isLast, expanded, theme));
+				});
+			}
 			if (shouldRenderProgress && details.progress) {
+				lines.push(...renderProviderDegradationNotices(details.progress, theme));
 				details.progress.forEach((progress, i) => {
 					const isLast = i === details.progress!.length - 1;
 					lines.push(...renderAgentProgress(progress, isLast, expanded, theme, spinnerFrame));
 				});
-			} else if (details.results && details.results.length > 0) {
-				details.results.forEach((res, i) => {
-					const isLast = i === details.results.length - 1;
-					lines.push(...renderAgentResult(res, isLast, expanded, theme));
-				});
-
+			}
+			if (hasResults && !shouldRenderProgress) {
 				const abortedCount = details.results.filter(r => r.status === "aborted").length;
 				const mergeFailedCount = details.results.filter(r => r.status === "merge_failed").length;
 				const successCount = details.results.filter(r => r.status === "completed").length;
@@ -997,7 +1016,7 @@ export function renderResult(
 			if (lines.length === 0) {
 				const text = fallbackText.trim() ? fallbackText : "No results";
 				const result = [theme.fg("dim", truncateToWidth(text, width))];
-				cached = { key, lines: result };
+				if (!hasDynamicRetry) cached = { key, lines: result };
 				return result;
 			}
 
@@ -1019,9 +1038,9 @@ export function renderResult(
 			}
 
 			const indented = lines.map(line =>
-				line.length > 0 ? truncateToWidth(`   ${line}`, width, Ellipsis.Omit) : "",
+				line.length > 0 ? truncateToWidth(`   ${replaceTabs(line)}`, width, Ellipsis.Omit) : "",
 			);
-			cached = { key, lines: indented };
+			if (!hasDynamicRetry) cached = { key, lines: indented };
 			return indented;
 		},
 		invalidate() {
@@ -1065,16 +1084,16 @@ function renderNestedTaskTree(
 ): string[] {
 	const lines: string[] = [];
 	for (const details of detailsList) {
-		const hasResults = Boolean(details.results && details.results.length > 0);
-		if (hasResults) {
+		const inflight = details.progress;
+		const hasInflight = Boolean(inflight && inflight.length > 0);
+		if (details.results && details.results.length > 0) {
 			details.results.forEach((result, index) => {
-				const isLast = index === details.results.length - 1;
+				const isLast = !hasInflight && index === details.results.length - 1;
 				lines.push(...renderAgentResult(result, isLast, expanded, theme));
 			});
-			continue;
 		}
-		const inflight = details.progress;
 		if (inflight && inflight.length > 0) {
+			lines.push(...renderProviderDegradationNotices(inflight, theme));
 			inflight.forEach((prog, index) => {
 				const isLast = index === inflight.length - 1;
 				lines.push(...renderAgentProgress(prog, isLast, expanded, theme, spinnerFrame, staticTime));

package/src/task/types.ts

@@ -285,6 +285,9 @@ export interface AgentProgress {
 		attempt: number;
 		maxAttempts: number;
 		unbounded?: boolean;
+		kind: "first_event_timeout" | "idle_stream_stall" | "provider_error";
+		provider?: string;
+		lastProviderProgressAtMs?: number;
 		delayMs: number;
 		errorMessage: string;
 		startedAtMs: number;

package/src/tools/bash-allowed-prefixes.ts

@@ -18,7 +18,14 @@ export interface BashRestrictionOptions {
 }
 
 const SHELL_CONTROL_CHARS = new Set([";", "|", "&", "<", ">", "(", ")"]);
-const UNSAFE_UNQUOTED_EXPANSION_CHARS = new Set(["$", "*", "?", "[", "]", "{", "}", "~"]);
+// `~` is handled separately: bash performs tilde expansion only at positions where a
+// tilde can open an expansion - the start of a word, and inside an assignment word
+// directly after the first `=` or after a `:` in the assigned value. A tilde anywhere
+// else (e.g. the git revision `HEAD~1`) is a literal character.
+const UNSAFE_UNQUOTED_EXPANSION_CHARS = new Set(["$", "*", "?", "[", "]", "{", "}"]);
+// A bash assignment word has a plain assignment name before its first unquoted `=`,
+// in either the `name=value` or the compound `name+=value` form.
+const ASSIGNMENT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*\+?$/u;
 const ALLOWED_STATE_ACTIONS = new Set(["read", "write", "contract"]);
 const CANONICAL_STATE_TARGETS = new Set<string>(CANONICAL_GJC_WORKFLOW_SKILLS);
 const READ_ONLY_COMMANDS = new Set(["grep", "rg", "tree", "ls", "pwd", "wc", "du", "file", "stat"]);
@@ -29,6 +36,14 @@ function parseShellWords(command: string): { words: string[]; reason?: string }
 	let quote: "single" | "double" | null = null;
 
 	let wordStarted = false;
+	// Per-token tilde-expansion state. `assignmentNameCandidate` stays true while the
+	// characters before the first unquoted `=` could still form an assignment name (any
+	// quoting in that region disqualifies the token), `sawAssignmentEquals` records that
+	// the token is an assignment word, and `tildeExpandable` means an unquoted `~` at the
+	// current index would actually be expanded by bash.
+	let assignmentNameCandidate = true;
+	let sawAssignmentEquals = false;
+	let tildeExpandable = false;
 	for (let index = 0; index < command.length; index += 1) {
 		const char = command[index]!;
 		const next = command[index + 1];
@@ -63,11 +78,15 @@ function parseShellWords(command: string): { words: string[]; reason?: string }
 		if (char === "'") {
 			quote = "single";
 			wordStarted = true;
+			if (!sawAssignmentEquals) assignmentNameCandidate = false;
+			tildeExpandable = false;
 			continue;
 		}
 		if (char === '"') {
 			quote = "double";
 			wordStarted = true;
+			if (!sawAssignmentEquals) assignmentNameCandidate = false;
+			tildeExpandable = false;
 			continue;
 		}
 		if (char === "`" || (char === "$" && next === "(")) {
@@ -82,17 +101,42 @@ function parseShellWords(command: string): { words: string[]; reason?: string }
 		if (UNSAFE_UNQUOTED_EXPANSION_CHARS.has(char)) {
 			return { words, reason: `shell expansion character '${char}' is not allowed in restricted bash commands` };
 		}
+		// Tilde expansion is positional: bash expands a tilde only where one can open an
+		// expansion, i.e. at the start of a word or, inside an assignment word, directly
+		// after the first `=` or after a `:` in the assigned value. A tilde anywhere else
+		// is literal, which is what git revision syntax such as `HEAD~1` relies on.
+		if (char === "~" && (!wordStarted || tildeExpandable)) {
+			return { words, reason: "shell expansion character '~' is not allowed in restricted bash commands" };
+		}
 		if (/\s/u.test(char)) {
 			if (wordStarted) {
 				words.push(current);
 				current = "";
 				wordStarted = false;
 			}
+			assignmentNameCandidate = true;
+			sawAssignmentEquals = false;
+			tildeExpandable = false;
 			continue;
 		}
 		if (char === "\\") {
 			return { words, reason: "backslash escapes are not allowed in restricted bash commands" };
 		}
+		if (char === "=" && !sawAssignmentEquals) {
+			// Only a plain assignment name before the first unquoted `=` makes this an
+			// assignment word whose value bash scans for tilde expansions.
+			if (assignmentNameCandidate && ASSIGNMENT_NAME_PATTERN.test(current)) {
+				sawAssignmentEquals = true;
+				tildeExpandable = true;
+			} else {
+				assignmentNameCandidate = false;
+				tildeExpandable = false;
+			}
+		} else if (char === ":" && sawAssignmentEquals) {
+			tildeExpandable = true;
+		} else {
+			tildeExpandable = false;
+		}
 		current += char;
 		wordStarted = true;
 	}

package/src/tools/index.ts

@@ -275,9 +275,11 @@ export interface ToolSession {
 	/** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
 	getAgentId?: () => string | null;
 	/** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+	getToolByName?: (name: string) => AgentTool | undefined;
+	/** Look up a registered tool with the session's execution guards applied. */
+	getToolForExecution?: (name: string) => AgentTool | undefined;
 	/** Purge undelivered queued custom messages matching the predicate. Returns counts. */
 	purgeQueuedCustomMessages?: (predicate: (message: CustomMessage) => boolean) => PurgeQueuedCustomMessagesResult;
-	getToolByName?: (name: string) => AgentTool | undefined;
 	/** Agent registry for IRC routing across live sessions. */
 	agentRegistry?: AgentRegistry;
 	/** Optional restricted bash command prefixes for read-only role agents and constrained modes. */