@gajae-code/coding-agent 0.11.9 → 0.11.11

package/src/skill-state/workflow-mutation-guard.ts

@@ -35,17 +35,28 @@ function planningPhaseBlockMessage(skill: CanonicalGjcWorkflowSkill): string {
 }
 
 const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit", "bash"]);
+/**
+ * Only `/dev/null` is exempt. `/dev/stdout`, `/dev/stderr`, and `/dev/fd/<n>` are descriptor
+ * aliases: `exec 1<>src/product.ts; printf x >/dev/stdout` reaches a real repository file
+ * through a rebound descriptor, so they must stay blocked.
+ */
+const DEVICE_SINK_PATHS = new Set(["/dev/null"]);
+/** Bash write forms the plain `>`/`>>` scanner misses: clobber, dup-to-path, and read-write open. */
+const BASH_EXTENDED_WRITE_RE = /(?:>\||<>|>&(?![\s;&|]*(?:\d+|-)(?:[\s;&|]|$)))\s*([^\s;&|]+)/g;
+/** Descriptor rebinding is not statically resolvable; any `exec` redirection forces a fail-closed verdict. */
+const BASH_EXEC_REDIRECT_RE = /(?:^|[;&|\n])\s*(?:sudo\s+)?exec\b[^;&|\n]*[<>]/i;
+
 const ARCHIVE_OR_SQLITE_BASE_RE = /^(.+?\.(?:tar\.gz|sqlite3|sqlite|db3|zip|tgz|tar|db))(?:$|:)/i;
 const INTERNAL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
 const VIM_FILE_SWITCH_RE = /^\s*:(?:e|e!|edit|edit!)(?:\s+([^<\r\n]+))?(?:<CR>|\r|\n|$)/i;
 const BASH_MUTATION_COMMAND_RE =
-	/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:tee|touch|rm|mkdir|cp|mv|install|truncate)\b([^;&|\n]*)|(?:^|[^<>])(?:>>?|\d>>?)\s*([^\s;&|]+)/gi;
+	/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:[^\s;&|]*\/)?(?:tee|touch|rm|mkdir|cp|mv|install|truncate)\b([^;&|\n]*)|(?:^|[^<>])(?:>>?|\d>>?)\s*([^\s;&|]+)/gi;
 const BASH_IN_PLACE_MUTATION_COMMAND_RE = /(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:sed|perl)\b([^;&|\n]*)/gi;
 const BASH_OPAQUE_INTERPRETER_WRITE_RE =
 	/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:python3?|node|ruby)\b[^;&|\n]*(?:-c|-e)\b[^;&|\n]*(?:open\s*\(|writeFile(?:Sync)?\s*\(|\.write\s*\()/i;
 const BASH_HEREDOC_OPAQUE_INTERPRETER_WRITE_RE =
 	/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:python3?|node|ruby)\b[^;&|\n]*(?:<<[-]?\s*['"]?\w+['"]?)[\s\S]*(?:open\s*\(|writeFile(?:Sync)?\s*\(|\.write\s*\()/i;
-const BASH_DD_OUTPUT_RE = /(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?dd\b([^;&|\n]*)/gi;
+const BASH_DD_OUTPUT_RE = /(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:[^\s;&|]*\/)?dd\b([^;&|\n]*)/gi;
 
 type ToolWithEditMode = AgentTool & {
 	mode?: unknown;
@@ -371,6 +382,10 @@ function cleanShellWord(value: string): string {
 	return value.replace(/^['"]|['"]$/g, "");
 }
 
+function isDeviceSinkPath(value: string): boolean {
+	return DEVICE_SINK_PATHS.has(cleanShellWord(value));
+}
+
 function extractBashTargets(args: unknown): ExtractedTargets {
 	const record = getRecord(args);
 	const command = safeString(record?.command);
@@ -382,11 +397,25 @@ function extractBashTargets(args: unknown): ExtractedTargets {
 	if (BASH_OPAQUE_INTERPRETER_WRITE_RE.test(command) || BASH_HEREDOC_OPAQUE_INTERPRETER_WRITE_RE.test(command)) {
 		targets.unknown = true;
 	}
+	// `exec 1<>file` rebinds a descriptor, so a later `>/dev/null` may not reach the device at all.
+	if (BASH_EXEC_REDIRECT_RE.test(command)) {
+		targets.unknown = true;
+	}
+	for (const match of command.matchAll(BASH_EXTENDED_WRITE_RE)) {
+		const cleaned = cleanShellWord(match[1] ?? "");
+		if (!cleaned) targets.unknown = true;
+		else if (!isDeviceSinkPath(cleaned)) addPath(targets, cleaned);
+	}
 	for (const match of command.matchAll(BASH_DD_OUTPUT_RE)) {
 		const parts = shellWords(match[1] ?? "").map(cleanShellWord);
-		const output = parts.find(part => part.startsWith("of="));
-		if (output) addPath(targets, output.slice(3));
-		else targets.unknown = true;
+		// Every `of=` counts: GNU dd honors the last one, so `of=/dev/null of=real.ts` writes real.ts.
+		const outputs = parts.filter(part => part.startsWith("of="));
+		if (outputs.length === 0) targets.unknown = true;
+		for (const output of outputs) {
+			const outputPath = cleanShellWord(output.slice(3));
+			if (!outputPath) targets.unknown = true;
+			else if (!isDeviceSinkPath(outputPath)) addPath(targets, outputPath);
+		}
 	}
 	for (const match of command.matchAll(BASH_IN_PLACE_MUTATION_COMMAND_RE)) {
 		const parts = shellWords(match[1] ?? "").map(cleanShellWord);
@@ -399,12 +428,17 @@ function extractBashTargets(args: unknown): ExtractedTargets {
 	for (const match of command.matchAll(BASH_MUTATION_COMMAND_RE)) {
 		const redirected = match[2]?.trim();
 		if (redirected) {
-			addPath(targets, cleanShellWord(redirected));
+			const cleaned = cleanShellWord(redirected);
+			// A capture that dequotes to nothing (e.g. `>" src.ts"`) is a truncated parse, not a safe no-op.
+			if (!cleaned) targets.unknown = true;
+			else if (!isDeviceSinkPath(cleaned)) addPath(targets, cleaned);
 			continue;
 		}
 		const parts = shellWords(match[1] ?? "");
 		const commandName = match[0]
-			?.match(/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(tee|touch|rm|mkdir|cp|mv|install|truncate)\b/i)?.[1]
+			?.match(
+				/(?:^|[;&|\n])\s*(?:\w+=[^\s]+\s+)*(?:sudo\s+)?(?:[^\s;&|]*\/)?(tee|touch|rm|mkdir|cp|mv|install|truncate)\b/i,
+			)?.[1]
 			?.toLowerCase();
 		const targetParts =
 			commandName === "cp" || commandName === "mv" || commandName === "install" || commandName === "truncate"

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 {
@@ -66,6 +67,7 @@ import {
 	TASK_SUBAGENT_PROGRESS_CHANNEL,
 	type TaskToolDetails,
 } from "./types";
+import { type ExecutorExecutionMode, resolveUltragoalRedTeamActivation } from "./ultragoal-redteam-activation";
 
 /** Agent event types to forward for progress tracking. */
 const agentEventTypes = new Set<AgentEvent["type"]>([
@@ -81,6 +83,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"]);
 
@@ -174,6 +191,11 @@ export interface ExecutorOptions {
 	agent: AgentDefinition;
 	task: string;
 	assignment?: string;
+	/**
+	 * Typed executor execution mode. When set, overrides assignment-text heuristics
+	 * for ultragoal red-team prompt injection (#2698 / #2456).
+	 */
+	executionMode?: ExecutorExecutionMode;
 	context?: string;
 	description?: string;
 	index: number;
@@ -845,7 +867,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 +955,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 +964,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				agentSource: agent.source,
 				task,
 				assignment,
-				progress: { ...progress },
+				progress: progressSnapshot,
 				sessionFile: null,
 			});
 		}
@@ -990,6 +1019,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 +1106,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 +1125,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 +1262,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 +1280,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 +1293,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 +1461,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			);
 			if (model) {
 				resolvedModelString = formatModelString(model);
+				activeProviderModelString = resolvedModelString;
 			}
 			if (authFallbackUsed && model && requestedModel) {
 				modelSubstitutionWarning = {
@@ -1504,6 +1599,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,
@@ -1513,9 +1609,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					systemPrompt: defaultPrompt => {
 						const subagentPrompt = prompt.render(subagentSystemPromptTemplate, {
 							agent: prompt.render(agent.systemPrompt, {
-								ultragoalRedTeam: /ultragoal\s+completion\s+(?:qa|red-team)|executorQa/i.test(
-									options.assignment ?? task,
-								),
+								// Typed executionMode wins; assignment text is compatibility-only (#2698 / #2456).
+								ultragoalRedTeam: resolveUltragoalRedTeamActivation({
+									executionMode: options.executionMode,
+									assignment: options.assignment ?? task,
+								}),
 							}),
 							context: options.context?.trim() ?? "",
 							worktree: worktree ?? "",
@@ -1737,11 +1835,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 +1872,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/index.ts

@@ -1446,6 +1446,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						agent: effectiveAgent,
 						task: renderTaskAssignment(task.assignment, simpleMode),
 						assignment: task.assignment.trim(),
+						executionMode: task.executionMode,
 						context: sharedContext,
 						description: task.description,
 						index,
@@ -1518,6 +1519,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						agent: effectiveAgent,
 						task: renderTaskAssignment(task.assignment, simpleMode),
 						assignment: task.assignment.trim(),
+						executionMode: task.executionMode,
 						context: sharedContext,
 						description: task.description,
 						index,

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));
+}