@bastani/atomic 0.9.4-alpha.6 → 0.9.4-alpha.8

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-async.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { APP_NAME } from "@bastani/atomic";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
-import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
+import { collectKnownModelProviders, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
 import { normalizeSkillInput } from "../../agents/skills.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import {
@@ -76,6 +76,7 @@ export function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorD
 		currentModel: currentModelFullId(ctx.model),
 	};
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
+	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
 	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
 	const currentMaxSubagentDepth = depthPolicy.maxSubagentDepth;
 	const workflowStageSubagentGuard = depthPolicy.workflowStageSubagentGuard;
@@ -110,6 +111,7 @@ export function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorD
 			agents,
 			ctx: asyncCtx,
 			availableModels,
+			knownModelProviders,
 			cwd: effectiveCwd,
 			maxOutput: params.maxOutput,
 			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
@@ -139,6 +141,7 @@ export function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorD
 			agents,
 			ctx: asyncCtx,
 			availableModels,
+			knownModelProviders,
 			cwd: effectiveCwd,
 			maxOutput: params.maxOutput,
 			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
@@ -181,6 +184,7 @@ export function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorD
 			agentConfig: a,
 			ctx: asyncCtx,
 			availableModels,
+			knownModelProviders,
 			cwd: effectiveCwd,
 			maxOutput: params.maxOutput,
 			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-parallel-task.ts

@@ -38,6 +38,7 @@ interface ForegroundParallelRunInput {
 	maxSubagentDepths: number[];
 	workflowStageSubagentGuard?: boolean;
 	availableModels: ModelInfo[];
+	knownModelProviders: string[];
 	modelOverrides: (string | undefined)[];
 	behaviors: ResolvedStepBehavior[];
 	firstProgressIndex: number;
@@ -110,6 +111,7 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 			nestedRoute: input.foregroundControl?.nestedRoute,
 			modelOverride: input.modelOverrides[index],
 			availableModels: input.availableModels,
+			knownModelProviders: input.knownModelProviders,
 			preferredModelProvider: input.ctx.model?.provider,
 			currentModel: currentModelFullId(input.ctx.model),
 			skills: effectiveSkills === false ? [] : effectiveSkills,

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-parallel.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { APP_NAME } from "@bastani/atomic";
 import { ChainClarifyComponent, type ChainClarifyResult } from "./chain-clarify.ts";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
-import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
+import { collectKnownModelProviders, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
 import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.ts";
 import { aggregateParallelOutputs } from "../shared/parallel-utils.ts";
 import { recordRun } from "../shared/run-history.ts";
@@ -108,6 +108,7 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 
 	const currentProvider = ctx.model?.provider;
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
+	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
 	let taskTexts = tasks.map((t) => t.task);
 	const skillOverrides: (string[] | false | undefined)[] = tasks.map((t) =>
 		normalizeSkillInput(t.skill),
@@ -205,6 +206,7 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 				agents,
 				ctx: asyncCtx,
 				availableModels,
+				knownModelProviders,
 				cwd: effectiveCwd,
 				maxOutput: params.maxOutput,
 				artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
@@ -281,6 +283,7 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 			paramsCwd: effectiveCwd,
 			workflowStageSubagentGuard,
 			availableModels,
+			knownModelProviders,
 			modelOverrides,
 			behaviors,
 			firstProgressIndex: parallelProgressPrecreated ? -1 : firstProgressIndex,

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-single.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { APP_NAME } from "@bastani/atomic";
 import { ChainClarifyComponent, type ChainClarifyResult } from "./chain-clarify.ts";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
-import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
+import { collectKnownModelProviders, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
 import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.ts";
 import { recordRun } from "../shared/run-history.ts";
 import { getSingleResultOutput, compactForegroundDetails } from "../../shared/utils.ts";
@@ -76,6 +76,7 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 
 	const currentProvider = ctx.model?.provider;
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
+	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
 	let task = params.task ?? "";
 	let modelOverride: string | undefined = resolveModelCandidate(
 		(params.model as string | undefined) ?? agentConfig.model,
@@ -145,6 +146,7 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 				agentConfig,
 				ctx: asyncCtx,
 				availableModels,
+				knownModelProviders,
 				cwd: effectiveCwd,
 				maxOutput: params.maxOutput,
 				artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
@@ -246,6 +248,7 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 		index: 0,
 		modelOverride,
 		availableModels,
+		knownModelProviders,
 		preferredModelProvider: currentProvider,
 		currentModel: currentModelFullId(ctx.model),
 		skills: effectiveSkills,

package/dist/builtin/subagents/src/runs/shared/attempt-watchdog.ts

@@ -0,0 +1,126 @@
+import type { ChildProcess } from "node:child_process";
+import { trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
+
+const DEFAULT_IDLE_MS = 5 * 60_000;
+const DEFAULT_WALL_MS = 60 * 60_000;
+const DEFAULT_KILL_GRACE_MS = 3_000;
+
+export interface AttemptTimeoutConfig {
+	idleMs: number;
+	wallMs: number;
+	killGraceMs: number;
+}
+
+export interface AttemptWatchdog {
+	activity(): void;
+	clear(): void;
+}
+
+/** Parse a millisecond override from the environment. Non-numeric values are
+ * silently ignored (the default applies). Zero or negative values are clamped
+ * to `0`, which callers treat as "timeout disabled". */
+function envMs(name: string): number | undefined {
+	const raw = process.env[name];
+	if (!raw) return undefined;
+	const value = Number(raw);
+	if (!Number.isFinite(value)) return undefined;
+	return value > 0 ? Math.floor(value) : 0;
+}
+
+function positiveEnvMs(name: string): number | undefined {
+	const value = envMs(name);
+	return value !== undefined && value > 0 ? value : undefined;
+}
+
+export function resolveAttemptTimeoutConfig(): AttemptTimeoutConfig {
+	return {
+		// `0` (or a negative value) disables the corresponding timeout entirely.
+		idleMs: envMs("ATOMIC_SUBAGENT_ATTEMPT_IDLE_TIMEOUT_MS") ?? DEFAULT_IDLE_MS,
+		wallMs: envMs("ATOMIC_SUBAGENT_ATTEMPT_TIMEOUT_MS") ?? DEFAULT_WALL_MS,
+		// The SIGTERM→SIGKILL grace period intentionally cannot be disabled: once a
+		// watchdog trips, escalation must always be bounded. `0`, negative, or
+		// non-numeric values fall back to the default.
+		killGraceMs: positiveEnvMs("ATOMIC_SUBAGENT_ATTEMPT_KILL_GRACE_MS") ?? DEFAULT_KILL_GRACE_MS,
+	};
+}
+
+export function idleTimeoutMessage(idleMs: number): string {
+	return `Subagent model attempt timed out after ${idleMs}ms without child activity.`;
+}
+
+export function wallTimeoutMessage(wallMs: number): string {
+	return `Subagent model attempt timed out after ${wallMs}ms.`;
+}
+
+export function createAttemptWatchdog(params: {
+	child: ChildProcess;
+	config?: Partial<AttemptTimeoutConfig>;
+	onTimeout: (message: string) => void;
+	isSettled: () => boolean;
+	/** Reports whether a tool call is currently executing in the child. A slow tool
+	 * (long build, large test suite) can legitimately stay silent past the idle
+	 * window, so an in-flight tool execution counts as activity and defers the idle
+	 * trip. The wall-clock cap still bounds the whole attempt. */
+	isToolActive?: () => boolean;
+}): AttemptWatchdog {
+	const config = { ...resolveAttemptTimeoutConfig(), ...(params.config ?? {}) };
+	let idleTimer: NodeJS.Timeout | undefined;
+	let wallTimer: NodeJS.Timeout | undefined;
+	let killTimer: NodeJS.Timeout | undefined;
+	let tripped = false;
+
+	const clearIdle = () => {
+		if (!idleTimer) return;
+		clearTimeout(idleTimer);
+		idleTimer = undefined;
+	};
+	const clearAll = () => {
+		clearIdle();
+		if (wallTimer) {
+			clearTimeout(wallTimer);
+			wallTimer = undefined;
+		}
+		if (killTimer) {
+			clearTimeout(killTimer);
+			killTimer = undefined;
+		}
+	};
+	const trip = (message: string) => {
+		if (tripped || params.isSettled()) return;
+		tripped = true;
+		clearIdle();
+		params.onTimeout(message);
+		trySignalChild(params.child, "SIGTERM");
+		killTimer = setTimeout(() => {
+			if (!params.isSettled()) trySignalChild(params.child, "SIGKILL");
+		}, config.killGraceMs);
+		killTimer.unref?.();
+	};
+	const scheduleIdle = () => {
+		clearIdle();
+		if (config.idleMs <= 0) return; // idle watchdog disabled
+		idleTimer = setTimeout(() => {
+			if (params.isToolActive?.()) {
+				// Do not kill a healthy attempt that is busy inside a slow tool call;
+				// re-arm the idle window and let the wall-clock cap bound the attempt.
+				scheduleIdle();
+				return;
+			}
+			trip(idleTimeoutMessage(config.idleMs));
+		}, config.idleMs);
+		idleTimer.unref?.();
+	};
+
+	scheduleIdle();
+	if (config.wallMs > 0) {
+		wallTimer = setTimeout(() => trip(wallTimeoutMessage(config.wallMs)), config.wallMs);
+		wallTimer.unref?.();
+	}
+
+	return {
+		activity() {
+			if (!tripped && !params.isSettled()) scheduleIdle();
+		},
+		clear: clearAll,
+	};
+}

package/dist/builtin/subagents/src/runs/shared/model-candidate-filter.ts

@@ -0,0 +1,53 @@
+import { splitKnownThinkingSuffix } from "../../shared/model-info.ts";
+import type { ModelAttempt } from "../../shared/types.ts";
+import type { AvailableModelInfo } from "./model-fallback.ts";
+
+export interface FilteredModelCandidates {
+	candidates: string[];
+	skippedAttempts: ModelAttempt[];
+}
+
+function providerFromModel(model: string | undefined): string | undefined {
+	if (!model) return undefined;
+	const { baseModel } = splitKnownThinkingSuffix(model);
+	const slash = baseModel.indexOf("/");
+	return slash > 0 ? baseModel.slice(0, slash) : undefined;
+}
+
+export function skippedModelAttempt(model: string, reason: string): ModelAttempt {
+	return {
+		model,
+		success: false,
+		exitCode: null,
+		error: reason,
+	};
+}
+
+export function filterSpawnableModelCandidates(params: {
+	candidates: string[];
+	availableModels?: AvailableModelInfo[];
+	knownModelProviders?: string[];
+	currentModel?: string;
+}): FilteredModelCandidates {
+	const providersWithAvailableAuth = new Set((params.availableModels ?? []).map((model) => model.provider));
+	const knownProviders = new Set(params.knownModelProviders ?? []);
+	const currentModel = params.currentModel;
+	const filtered: string[] = [];
+	const skippedAttempts: ModelAttempt[] = [];
+	for (const candidate of params.candidates) {
+		if (currentModel && candidate === currentModel) {
+			filtered.push(candidate);
+			continue;
+		}
+		const provider = providerFromModel(candidate);
+		const shouldSkip = provider !== undefined
+			&& knownProviders.has(provider)
+			&& !providersWithAvailableAuth.has(provider);
+		if (!shouldSkip) {
+			filtered.push(candidate);
+			continue;
+		}
+		skippedAttempts.push(skippedModelAttempt(candidate, `Skipped ${candidate}: provider '${provider}' has no configured API key/auth in the current session.`));
+	}
+	return { candidates: filtered, skippedAttempts };
+}

package/dist/builtin/subagents/src/runs/shared/model-fallback.ts

@@ -117,6 +117,7 @@ export type ModelFallbackFailureKind =
 	| "provider_unavailable"
 	| "network_timeout"
 	| "model_unavailable"
+	| "request_incompatible"
 	| "cancelled"
 	| "task_failure"
 	| "unknown";
@@ -144,6 +145,7 @@ const FALLBACKABLE_FAILURE_KINDS: ReadonlySet<ModelFallbackFailureKind> = new Se
 	"provider_unavailable",
 	"network_timeout",
 	"model_unavailable",
+	"request_incompatible",
 ]);
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
@@ -222,6 +224,9 @@ function normalizeCode(value: string | number | undefined): string | undefined {
 
 function kindFromStatus(status: number | undefined): ModelFallbackFailureKind | undefined {
 	switch (status) {
+		case 400:
+		case 413: case 422:
+			return "request_incompatible";
 		case 401:
 		case 403:
 			return "auth_on_candidate_provider";
@@ -237,6 +242,15 @@ function kindFromStatus(status: number | undefined): ModelFallbackFailureKind |
 	}
 }
 
+const REQUEST_INCOMPATIBLE_CODES: ReadonlySet<string> = new Set([
+	"invalid_request", "invalid_request_error", "bad_request", "context_length_exceeded",
+	"request_too_large", "too_large", "request_entity_too_large", "max_tokens",
+	"max_context_length", "context_window_exceeded",
+]);
+function requestIncompatibleKindFromCode(code: string | number | undefined): ModelFallbackFailureKind | undefined {
+	const normalizedCode = normalizeCode(code);
+	return normalizedCode !== undefined && REQUEST_INCOMPATIBLE_CODES.has(normalizedCode) ? "request_incompatible" : undefined;
+}
 function refusalKindFromCode(code: string | number | undefined): ModelFallbackFailureKind | undefined {
 	const normalizedCode = normalizeCode(code);
 	if (normalizedCode === undefined) return undefined;
@@ -258,6 +272,14 @@ function refusalKindFromCode(code: string | number | undefined): ModelFallbackFa
 	}
 }
 
+const CODE_KINDS_BY_KIND: ReadonlyArray<readonly [ModelFallbackFailureKind, ReadonlySet<string>]> = [
+	["auth_on_candidate_provider", new Set(["auth", "auth_required", "authentication_required", "unauthorized", "forbidden", "invalid_api_key", "missing_api_key", "invalid_key"])],
+	["network_timeout", new Set(["etimedout", "econnreset", "econnrefused", "enotfound", "eai_again", "fetch_failed", "network_error", "timeout", "timeout_error", "und_err_connect_timeout"])],
+	["rate_limit", new Set(["rate_limit", "rate_limit_exceeded", "too_many_requests", "quota_exceeded"])],
+	["cancelled", new Set(["aborterror", "aborted", "cancelled", "canceled"])],
+	["model_unavailable", new Set(["model_not_found", "model_unavailable", "model_disabled", "unknown_model"])],
+	["provider_unavailable", new Set(["provider_error", "api_error", "service_unavailable", "temporarily_unavailable", "overloaded"])],
+];
 function kindFromCode(code: string | number | undefined): ModelFallbackFailureKind | undefined {
 	const normalizedCode = normalizeCode(code);
 	if (normalizedCode === undefined) return undefined;
@@ -265,54 +287,19 @@ function kindFromCode(code: string | number | undefined): ModelFallbackFailureKi
 	if (refusalKind !== undefined) return refusalKind;
 	const httpStatusKind = kindFromStatus(integerFrom(code));
 	if (httpStatusKind !== undefined) return httpStatusKind;
-
-	switch (normalizedCode) {
-		case "auth":
-		case "auth_required":
-		case "authentication_required":
-		case "unauthorized":
-		case "forbidden":
-		case "invalid_api_key":
-		case "missing_api_key":
-		case "invalid_key":
-			return "auth_on_candidate_provider";
-		case "etimedout":
-		case "econnreset":
-		case "econnrefused":
-		case "enotfound":
-		case "eai_again":
-		case "fetch_failed":
-		case "network_error":
-		case "timeout":
-		case "timeout_error":
-		case "und_err_connect_timeout":
-			return "network_timeout";
-		case "rate_limit":
-		case "rate_limit_exceeded":
-		case "too_many_requests":
-		case "quota_exceeded":
-			return "rate_limit";
-		case "aborterror":
-		case "aborted":
-		case "cancelled":
-		case "canceled":
-			return "cancelled";
-		case "model_not_found":
-		case "model_unavailable":
-		case "model_disabled":
-		case "unknown_model":
-			return "model_unavailable";
-		case "provider_error":
-		case "api_error":
-		case "service_unavailable":
-		case "temporarily_unavailable":
-		case "overloaded":
-			return "provider_unavailable";
-		default:
-			return undefined;
-	}
-}
-
+	const requestIncompatibleKind = requestIncompatibleKindFromCode(code);
+	if (requestIncompatibleKind !== undefined) return requestIncompatibleKind;
+	return CODE_KINDS_BY_KIND.find(([_, codes]) => codes.has(normalizedCode))?.[0];
+}
+
+const REQUEST_INCOMPATIBLE_FAILURE_PATTERNS: readonly RegExp[] = [
+	/\bcontext[_\s-]?(?:length|window)(?:[_\s-]?exceeded)?\b/i,
+	/\bmax[_\s-]?(?:context|tokens?)\b/i,
+	/\b(?:request(?:[_\s-]?entity)?[_\s-]?too|too)[_\s-]?large\b/i,
+	/\b(?:unsupported|unknown|invalid)\s+(?:tool|parameter|function)\b/i,
+	/\b(?:tool|parameter|function)\s+(?:not\s+(?:supported|found|allowed)|unknown|invalid)\b/i,
+	/\b(?:invalid[_\s-]?request(?:[_\s-]?error)?|bad[_\s-]?request)\b/i,
+];
 const PROVIDER_REFUSAL_FAILURE_PATTERNS: readonly RegExp[] = [
 	/\bfinish[_\s-]?reason\b[^\n]*\bcontent[_\s-]?filter\b/i,
 	/\bcontent[_\s-]?filter(?:ed|ing)?\b/i,
@@ -335,6 +322,7 @@ function refusalKindFromMessage(message: string): ModelFallbackFailureKind | und
 function fallbackKindFromMessage(message: string, name: string | undefined): ModelFallbackFailureKind | undefined {
 	const refusalKind = refusalKindFromMessage(message);
 	if (refusalKind !== undefined) return refusalKind;
+	if (REQUEST_INCOMPATIBLE_FAILURE_PATTERNS.some((pattern) => pattern.test(message))) return "request_incompatible";
 	const nameKind = kindFromCode(name);
 	if (nameKind !== undefined) return nameKind;
 	if (!RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(message))) return undefined;
@@ -372,15 +360,21 @@ function makeSignal(
 	};
 }
 
-function fallbackSignalFromMessage(
+function fallbackSignalForMessage(
+	message: string | undefined,
 	value: unknown,
 	source: ModelFallbackFailureSource | undefined,
 ): ModelFallbackFailureSignal | undefined {
-	const message = modelFailureMessage(value);
-	if (!message.trim()) return undefined;
+	if (message === undefined || message.trim().length === 0) return undefined;
 	const kind = fallbackKindFromMessage(message, errorName(value));
 	return kind === undefined ? undefined : makeSignal(kind, value, source);
 }
+function fallbackSignalFromMessage(value: unknown, source: ModelFallbackFailureSource | undefined): ModelFallbackFailureSignal | undefined {
+	return fallbackSignalForMessage(modelFailureMessage(value), value, source);
+}
+function fallbackSignalFromDirectMessage(value: unknown, source: ModelFallbackFailureSource | undefined): ModelFallbackFailureSignal | undefined {
+	return fallbackSignalForMessage(directMessageFrom(value), value, source);
+}
 
 function classifyAssistantRefusalSignal(
 	value: unknown,
@@ -433,6 +427,12 @@ function structuredSignal(
 		if (isRefusalSignal(causeSignal)) return causeSignal;
 		firstNestedFallbackSignal ??= causeSignal;
 	}
+	// Direct-message classification runs after nested traversal so a generic wrapper
+	// ("invalid request"/"400 bad request") cannot mask a non-retryable nested signal.
+	// Kept in the same position as the workflows classifier so the two copies stay
+	// behaviorally parallel (see test/unit/model-fallback-classifier-conformance.test.ts).
+	const directMessageSignal = fallbackSignalFromDirectMessage(value, source);
+	if (directMessageSignal !== undefined) return directMessageSignal;
 	const statusKind = kindFromStatus(statusFrom(value));
 	if (statusKind !== undefined) return makeSignal(statusKind, value, source);
 	if (codeKind !== undefined) return makeSignal(codeKind, value, source);
@@ -463,8 +463,7 @@ function messageFromUnknown(value: unknown, seen: Set<unknown>): string | undefi
 	const status = statusFrom(value);
 	if (status !== undefined) return `Model request failed with status ${status}`;
 	const code = codeFrom(value);
-	if (code !== undefined) return `Model request failed with code ${String(code)}`;
-	return undefined;
+	return code !== undefined ? `Model request failed with code ${String(code)}` : undefined;
 }
 export function modelFailureMessage(error: unknown): string {
 	const structuredMessage = messageFromUnknown(error, new Set());

package/dist/builtin/subagents/src/runs/shared/parallel-utils.ts

@@ -1,4 +1,5 @@
 import type { CodexFastModeResolvedSettings, CodexFastModeScope } from "@bastani/atomic";
+import type { ModelAttempt } from "../../shared/types.ts";
 
 export interface RunnerSubagentStep {
 	agent: string;
@@ -13,6 +14,7 @@ export interface RunnerSubagentStep {
 	fastMode?: boolean;
 	modelFastModes?: Record<string, boolean>;
 	modelCandidates?: string[];
+	modelAttempts?: ModelAttempt[];
 	codexFastModeSettings?: CodexFastModeResolvedSettings;
 	codexFastModeScope?: CodexFastModeScope;
 	tools?: string[];

package/dist/builtin/subagents/src/shared/model-info.ts

@@ -27,6 +27,22 @@ export function toModelInfo(model: RegistryModelLike): ModelInfo {
 	};
 }
 
+interface KnownProviderRegistryLike {
+	getAvailable(): ReadonlyArray<{ provider: string }>;
+	/** Older hosts may not expose `getAll()`; callers probe at runtime and fall back
+	 * to `getAvailable()`. */
+	getAll?: () => ReadonlyArray<{ provider: string }>;
+}
+
+/** Collect the distinct providers of every model the registry knows about — including
+ * providers without configured auth — falling back to `getAvailable()` when the host
+ * registry does not expose `getAll()`. Used to pre-filter spawn candidates whose
+ * provider is known but keyless. */
+export function collectKnownModelProviders(registry: KnownProviderRegistryLike): string[] {
+	const models = typeof registry.getAll === "function" ? registry.getAll() : registry.getAvailable();
+	return [...new Set(models.map((model) => model.provider))];
+}
+
 /** Resolve the effective thinking level from a model string (which may contain a known suffix like `:high`)
  * and an explicit thinking config value. Returns `undefined` when no thinking is applicable
  * (e.g. no model was specified, or the model has no suffix and no config was provided). */

package/dist/builtin/subagents/src/shared/types-config.ts

@@ -80,6 +80,8 @@ export interface RunSyncOptions {
 	modelOverride?: string;
 	/** Registry models available for heuristic bare-model resolution */
 	availableModels?: Array<{ provider: string; id: string; fullId: string }>;
+	/** Providers known to the registry before auth filtering */
+	knownModelProviders?: string[];
 	/** Current parent-session provider to prefer for ambiguous bare model ids */
 	preferredModelProvider?: string;
 	/** Current parent-session model to try after configured fallback models */

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.4-alpha.6",
+  "version": "0.9.4-alpha.8",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.4-alpha.8] - 2026-07-02
+
+### Changed
+
+- Changed the Claude Fable 5 reasoning level from `xhigh` to `high` across all builtin workflow model chains (`ralph` prompt-engineer/reviewer-a/reviewer-b/reviewer-c, `goal` reviewer, `deep-research-codebase` planner, and `open-claude-design`), covering both the native `anthropic/claude-fable-5` entries and their OpenRouter mirrors.
+
+### Fixed
+
+- Fixed the builtin `goal` reviewer and `deep-research-codebase` planner model fallback chains missing the OpenRouter mirror of their primary model: `openrouter/anthropic/claude-fable-5` is now the first OpenRouter fallback candidate in both chains, matching the ordering already used by the `ralph` prompt-engineer/reviewer and `open-claude-design` chains.
+
+## [0.9.4-alpha.7] - 2026-07-02
+
+### Fixed
+
+- Fixed workflow stage model fallback so request/context incompatibility failures (HTTP 400/413/422 bad/unprocessable/payload-too-large request, unsupported tool/parameter, context-length/context-window overflow, `invalid_request`/`bad_request`/`too_large` errors) advance the chain to the next candidate instead of stopping. When none of the configured candidates can serve the request, the stage now falls back to the current user-selected model. Refusals, content-filter/safety blocks, cancellations, and task failures still stop the chain ([#1580](https://github.com/bastani-inc/atomic/issues/1580)).
+
 ## [0.9.4-alpha.6] - 2026-07-01
 
 ### Changed

package/dist/builtin/workflows/builtin/deep-research-codebase-utils.ts

@@ -32,7 +32,7 @@ export interface DeepResearchCodebaseResult {
 export const FILE_ONLY_OUTPUT = "file-only" satisfies WorkflowOutputMode;
 
 export const PLANNER_MODEL_CONFIG = {
-  model: "anthropic/claude-fable-5:xhigh",
+  model: "anthropic/claude-fable-5:high",
   fallbackModels: [
     "openai-codex/gpt-5.5:xhigh",
     "github-copilot/gpt-5.5:xhigh",
@@ -41,15 +41,22 @@ export const PLANNER_MODEL_CONFIG = {
     "anthropic/claude-opus-4-8:xhigh",
     "zai/glm-5.2:xhigh",
     "zai-coding-cn/glm-5.2:xhigh",
+    "github-copilot/claude-sonnet-5 (1m):high",
+    "anthropic/claude-sonnet-5:high",
+    "github-copilot/claude-sonnet-4.6 (1m):high",
+    "anthropic/claude-sonnet-4-6:high",
     "github-copilot/gemini-3.5-flash (1m):high",
     "google/gemini-3.5-flash:high",
     "google-vertex/gemini-3.5-flash:high",
     "github-copilot/gemini-3.1-pro-preview (1m):high",
     "google/gemini-3.1-pro-preview:high",
     "google-vertex/gemini-3.1-pro-preview:high",
+    "openrouter/anthropic/claude-fable-5:high",
     "openrouter/openai/gpt-5.5:xhigh",
     "openrouter/anthropic/claude-opus-4-8:xhigh",
     "openrouter/z-ai/glm-5.2:xhigh",
+    "openrouter/anthropic/claude-sonnet-5:high",
+    "openrouter/anthropic/claude-sonnet-4-6:high",
     "openrouter/google/gemini-3.5-flash:high",
     "openrouter/google/gemini-3.1-pro-preview:high"
   ],

package/dist/builtin/workflows/builtin/goal-runner.ts

@@ -101,6 +101,10 @@ export async function runGoalWorkflow(ctx: GoalRunnerContext, options: GoalWorkf
           "anthropic/claude-opus-4-8:medium",
           "zai/glm-5.2:medium",
           "zai-coding-cn/glm-5.2:medium",
+          "github-copilot/claude-sonnet-5 (1m):medium",
+          "anthropic/claude-sonnet-5:medium",
+          "github-copilot/claude-sonnet-4.6 (1m):medium",
+          "anthropic/claude-sonnet-4-6:medium",
           "github-copilot/gemini-3.5-flash (1m):medium",
           "google/gemini-3.5-flash:medium",
           "google-vertex/gemini-3.5-flash:medium",
@@ -110,6 +114,8 @@ export async function runGoalWorkflow(ctx: GoalRunnerContext, options: GoalWorkf
           "openrouter/openai/gpt-5.5:medium",
           "openrouter/anthropic/claude-opus-4-8:medium",
           "openrouter/z-ai/glm-5.2:medium",
+          "openrouter/anthropic/claude-sonnet-5:medium",
+          "openrouter/anthropic/claude-sonnet-4-6:medium",
           "openrouter/google/gemini-3.5-flash:medium",
           "openrouter/google/gemini-3.1-pro-preview:medium"
       ],
@@ -117,7 +123,7 @@ export async function runGoalWorkflow(ctx: GoalRunnerContext, options: GoalWorkf
     };
 
     const reviewerModelConfig = {
-      model: "anthropic/claude-fable-5:xhigh",
+      model: "anthropic/claude-fable-5:high",
       fallbackModels: [
           "openai-codex/gpt-5.5:xhigh",
           "github-copilot/gpt-5.5:xhigh",
@@ -126,15 +132,22 @@ export async function runGoalWorkflow(ctx: GoalRunnerContext, options: GoalWorkf
           "anthropic/claude-opus-4-8:xhigh",
           "zai/glm-5.2:xhigh",
           "zai-coding-cn/glm-5.2:xhigh",
+          "github-copilot/claude-sonnet-5 (1m):high",
+          "anthropic/claude-sonnet-5:high",
+          "github-copilot/claude-sonnet-4.6 (1m):high",
+          "anthropic/claude-sonnet-4-6:high",
           "github-copilot/gemini-3.5-flash (1m):high",
           "google/gemini-3.5-flash:high",
           "google-vertex/gemini-3.5-flash:high",
           "github-copilot/gemini-3.1-pro-preview (1m):high",
           "google/gemini-3.1-pro-preview:high",
           "google-vertex/gemini-3.1-pro-preview:high",
+          "openrouter/anthropic/claude-fable-5:high",
           "openrouter/openai/gpt-5.5:xhigh",
           "openrouter/anthropic/claude-opus-4-8:xhigh",
           "openrouter/z-ai/glm-5.2:xhigh",
+          "openrouter/anthropic/claude-sonnet-5:high",
+          "openrouter/anthropic/claude-sonnet-4-6:high",
           "openrouter/google/gemini-3.5-flash:high",
           "openrouter/google/gemini-3.1-pro-preview:high"
       ],