@bastani/atomic 0.9.3 → 0.9.4-alpha.10

package/dist/builtin/subagents/src/runs/background/async-execution-types.ts

@@ -26,6 +26,7 @@ export interface AsyncChainParams {
 	agents: AgentConfig[];
 	ctx: AsyncExecutionContext;
 	availableModels?: AvailableModelInfo[];
+	knownModelProviders?: string[];
 	cwd?: string;
 	maxOutput?: MaxOutputConfig;
 	artifactsDir?: string;
@@ -62,6 +63,7 @@ export interface AsyncSingleParams {
 	outputMode?: "inline" | "file-only";
 	modelOverride?: string;
 	availableModels?: AvailableModelInfo[];
+	knownModelProviders?: string[];
 	maxSubagentDepth: number;
 	workflowStageSubagentGuard?: boolean;
 	worktreeSetupHook?: string;

package/dist/builtin/subagents/src/runs/background/subagent-runner-step.ts

@@ -17,7 +17,7 @@ import {
 import { formatModelAttemptNote, isRetryableModelFailure } from "../shared/model-fallback.ts";
 import type { ArtifactPaths, ModelAttempt } from "../../shared/types.ts";
 import type { RunPiStreamingResult, SingleStepContext, SubagentStep } from "./subagent-runner-types.ts";
-import { fastModeForStepAttempt } from "./subagent-runner-utils.ts";
+import { emptyUsage, fastModeForStepAttempt } from "./subagent-runner-utils.ts";
 import { runPiStreaming } from "./subagent-runner-streaming.ts";
 
 export { outputEntryFromAsyncResult };
@@ -61,14 +61,26 @@ export async function runSingleStep(
 		}
 	}
 
-	const candidates = step.modelCandidates && step.modelCandidates.length > 0
+	// `!== undefined` is intentional: an explicitly empty array means every candidate
+	// was removed by pre-spawn filtering (see filterSpawnableModelCandidates) and must
+	// be respected — do not "simplify" this back to `.length > 0`, which would spawn a
+	// doomed default attempt. Pre-spawn filtering always records each removal as a
+	// skipped attempt in step.modelAttempts, so an empty array WITHOUT skipped attempts
+	// means no candidates were configured at all (no primary model, no fallbacks, no
+	// current model); mirror the foreground path (execution-run-sync.ts `modelsToTry`)
+	// and run one default-model attempt instead of silently exiting with no attempt.
+	// The filtered-to-empty case is surfaced as an error below.
+	const preSkippedAttempts = step.modelAttempts ?? [];
+	const candidates = step.modelCandidates !== undefined && (step.modelCandidates.length > 0 || preSkippedAttempts.length > 0)
 		? step.modelCandidates
 		: step.model
 			? [step.model]
 			: [undefined];
 	const attemptedModels: string[] = [];
-	const modelAttempts: ModelAttempt[] = [];
-	const attemptNotes: string[] = [];
+	const modelAttempts: ModelAttempt[] = [...preSkippedAttempts];
+	const attemptNotes: string[] = modelAttempts
+		.filter((attempt) => !attempt.success && attempt.exitCode === null && attempt.error)
+		.map((attempt) => `[fallback] ${attempt.error}`);
 	const pendingAttemptNotes: string[] = [];
 	const eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
 	let finalResult: RunPiStreamingResult | undefined;
@@ -205,6 +217,17 @@ export async function runSingleStep(
 		if (!tryNextModel) break;
 	}
 
+	if (!finalResult && candidates.length === 0 && modelAttempts.length > 0) {
+		finalResult = {
+			stderr: "",
+			exitCode: 1,
+			messages: [],
+			usage: emptyUsage(),
+			error: "No spawnable subagent model candidates after pre-spawn filtering.",
+			finalOutput: "",
+		};
+	}
+
 	const rawOutput = finalResult?.finalOutput ?? "";
 	const outputForPersistence = rawOutput;
 	const resolvedOutput = step.outputPath && finalResult?.exitCode === 0

package/dist/builtin/subagents/src/runs/background/subagent-runner-streaming.ts

@@ -12,6 +12,7 @@ import {
 	shouldStartSubagentFinalDrain,
 } from "../shared/final-drain.ts";
 import { modelFailureMessage } from "../shared/model-fallback.ts";
+import { createAttemptWatchdog } from "../shared/attempt-watchdog.ts";
 import type { ChildEvent, ChildEventContext, RunPiStreamingResult } from "./subagent-runner-types.ts";
 import { emptyUsage } from "./subagent-runner-utils.ts";
 
@@ -55,6 +56,7 @@ export function runPiStreaming(
 		let assistantError: string | undefined;
 		let assistantFailureSignal: unknown;
 		let interrupted = false;
+		let activeToolExecutions = 0;
 		const rawStdoutLines: string[] = [];
 
 		const writeOutputLine = (line: string) => {
@@ -99,6 +101,11 @@ export function runPiStreaming(
 			appendChildEvent(event);
 			onChildEvent?.(event);
 
+			// Track in-flight tool executions so the idle watchdog does not mistake a
+			// slow, quiet tool call for a stalled attempt.
+			if (event.type === "tool_execution_start") activeToolExecutions += 1;
+			else if (event.type === "tool_execution_end") activeToolExecutions = Math.max(0, activeToolExecutions - 1);
+
 			if (event.type === "tool_execution_start" && event.toolName) {
 				const toolArgs = extractToolArgsPreview(event.args ?? {});
 				writeOutputLine(toolArgs ? `${event.toolName}: ${toolArgs}` : event.toolName);
@@ -163,7 +170,22 @@ export function runPiStreaming(
 		let finalHardKillTimer: NodeJS.Timeout | undefined;
 		let settled = false;
 		const clearStdioGuard = attachPostExitStdioGuard(child, { idleMs: 2000, hardMs: 8000 });
+		const attemptWatchdog = createAttemptWatchdog({
+			child,
+			isSettled: () => settled,
+			// An in-flight tool execution counts as watchdog activity so a slow, quiet
+			// tool call is not mistaken for a stalled attempt. Caveat: the counter only
+			// decrements on tool_execution_end, so if a tool ends abnormally without its
+			// end event the idle watchdog is deferred indefinitely and the wall-clock cap
+			// becomes the sole backstop — do not lower the wall cap assuming idle fires.
+			isToolActive: () => activeToolExecutions > 0,
+			onTimeout(message) {
+				forcedTerminationSignal = true;
+				error ??= message;
+			},
+		});
 		child.stdout.on("data", (chunk: Buffer) => {
+			attemptWatchdog.activity();
 			const text = chunk.toString();
 			stdoutBuf += text;
 			const lines = stdoutBuf.split("\n");
@@ -172,6 +194,7 @@ export function runPiStreaming(
 		});
 
 		child.stderr.on("data", (chunk: Buffer) => {
+			attemptWatchdog.activity();
 			processStderrText(chunk.toString());
 		});
 		registerInterrupt?.(() => {
@@ -220,6 +243,7 @@ export function runPiStreaming(
 			registerInterrupt?.(undefined);
 			clearDrainTimers();
 			clearStdioGuard();
+			attemptWatchdog.clear();
 			if (stdoutBuf.trim()) processStdoutLine(stdoutBuf);
 			if (stderrBuf.trim()) appendChildLine("subagent.child.stderr", stderrBuf);
 			outputStream.end();
@@ -246,6 +270,7 @@ export function runPiStreaming(
 			registerInterrupt?.(undefined);
 			clearDrainTimers();
 			clearStdioGuard();
+			attemptWatchdog.clear();
 			outputStream.end();
 			const finalOutput = getFinalOutput(messages) || rawStdoutLines.join("\n").trim();
 			const spawnErrorMessage = spawnError instanceof Error ? spawnError.message : String(spawnError);

package/dist/builtin/subagents/src/runs/foreground/chain-execution-dynamic-step.ts

@@ -96,6 +96,7 @@ export async function runDynamicParallelChainStep(input: {
 		agents: context.agents,
 		stepIndex,
 		availableModels: context.availableModels,
+		knownModelProviders: context.knownModelProviders,
 		chainDir: context.chainDir,
 		prev: state.prev,
 		originalTask: context.originalTask,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-parallel-runner.ts

@@ -125,6 +125,7 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 			nestedRoute: input.nestedRoute,
 			modelOverride: effectiveModel,
 			availableModels: input.availableModels,
+			knownModelProviders: input.knownModelProviders,
 			currentModel: currentModelFullId(input.ctx.model),
 			preferredModelProvider: input.ctx.model?.provider,
 			skills: behavior.skills === false ? [] : behavior.skills,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-parallel-step.ts

@@ -78,6 +78,7 @@ export async function runStaticParallelChainStep(input: {
 			agents: context.agents,
 			stepIndex,
 			availableModels: context.availableModels,
+			knownModelProviders: context.knownModelProviders,
 			chainDir: context.chainDir,
 			prev: state.prev,
 			originalTask: context.originalTask,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-sequential-step.ts

@@ -126,6 +126,7 @@ export async function runSequentialChainStep(input: {
 		nestedRoute: context.params.nestedRoute,
 		modelOverride: effectiveModel,
 		availableModels: context.availableModels,
+		knownModelProviders: context.knownModelProviders,
 		currentModel: currentModelFullId(context.ctx.model),
 		preferredModelProvider: context.ctx.model?.provider,
 		skills: behavior.skills === false ? [] : behavior.skills,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-types.ts

@@ -109,6 +109,7 @@ export interface ParallelChainRunInput {
 	agents: AgentConfig[];
 	stepIndex: number;
 	availableModels: ModelInfo[];
+	knownModelProviders: string[];
 	chainDir: string;
 	prev: string;
 	originalTask: string;
@@ -179,6 +180,7 @@ export interface ChainRuntimeContext {
 	chainSkills: string[];
 	chainDir: string;
 	availableModels: ModelInfo[];
+	knownModelProviders: string[];
 	originalTask: string;
 	chainAgents: string[];
 	chainSteps: ChainStep[];

package/dist/builtin/subagents/src/runs/foreground/chain-execution.ts

@@ -2,7 +2,7 @@
  * Public foreground chain execution API.
  */
 
-import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
+import { collectKnownModelProviders, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
 import {
 	createChainDir,
 	isDynamicParallelStep,
@@ -117,6 +117,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 	let templates: ResolvedTemplates = resolveChainTemplates(chainSteps);
 	let tuiBehaviorOverrides: Awaited<ReturnType<typeof resolveChainClarification>>["tuiBehaviorOverrides"];
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
+	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
 	const context: ChainRuntimeContext = {
 		params,
 		agents,
@@ -140,6 +141,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 		chainSkills,
 		chainDir,
 		availableModels,
+		knownModelProviders,
 		originalTask,
 		chainAgents,
 		chainSteps,

package/dist/builtin/subagents/src/runs/foreground/execution-attempt.ts

@@ -17,6 +17,7 @@ import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/pi-a
 import { getPiSpawnCommand } from "../shared/pi-spawn.ts";
 import { assistantStopReason, isAssistantFailureStopReason, shouldStartSubagentFinalDrain } from "../shared/final-drain.ts";
 import { modelFailureMessage } from "../shared/model-fallback.ts";
+import { createAttemptWatchdog } from "../shared/attempt-watchdog.ts";
 import {
 	createMutatingFailureState,
 	didMutatingToolFail,
@@ -204,6 +205,7 @@ export async function runSingleAttempt(
 			settled = true;
 			clearFinalDrainTimers();
 			clearStdioGuard();
+			attemptWatchdog.clear();
 			if (activityTimer) {
 				clearInterval(activityTimer);
 				activityTimer = undefined;
@@ -358,13 +360,31 @@ export async function runSingleAttempt(
 
 		let stderrBuf = "";
 		const clearStdioGuard = attachPostExitStdioGuard(proc, { idleMs: 2000, hardMs: 8000 });
+		const attemptWatchdog = createAttemptWatchdog({
+			child: proc,
+			isSettled: () => settled || processClosed || detached,
+			// A slow, quiet tool call (long build/test run) must not be mistaken for a
+			// stalled attempt: an in-flight tool execution counts as watchdog activity.
+			// Caveat: `progress.currentTool` is cleared on tool_execution_end, so if a
+			// tool ends abnormally without emitting its end event the idle watchdog is
+			// deferred indefinitely and the wall-clock cap becomes the sole backstop for
+			// this attempt — do not lower the wall cap assuming idle always fires.
+			isToolActive: () => progress.currentTool !== undefined,
+			onTimeout(message) {
+				forcedTerminationSignal = true;
+				result.error ??= message;
+				progress.error = message;
+			},
+		});
 		proc.stdout.on("data", (d) => {
+			attemptWatchdog.activity();
 			buf += d.toString();
 			const lines = buf.split("\n");
 			buf = lines.pop() || "";
 			lines.forEach(processLine);
 		});
 		proc.stderr.on("data", (d) => {
+			attemptWatchdog.activity();
 			stderrBuf += d.toString();
 		});
 		proc.on("exit", () => {
@@ -374,6 +394,7 @@ export async function runSingleAttempt(
 		proc.on("close", (code, signal) => {
 			clearFinalDrainTimers();
 			clearStdioGuard();
+			attemptWatchdog.clear();
 			void jsonlWriter.close().catch(() => undefined);
 			cleanupTempDir(tempDir);
 			if (detached) {
@@ -394,6 +415,7 @@ export async function runSingleAttempt(
 		proc.on("error", (error) => {
 			clearFinalDrainTimers();
 			clearStdioGuard();
+			attemptWatchdog.clear();
 			void jsonlWriter.close().catch(() => undefined);
 			cleanupTempDir(tempDir);
 			if (!result.error) result.error = error instanceof Error ? error.message : String(error);

package/dist/builtin/subagents/src/runs/foreground/execution-run-sync.ts

@@ -20,6 +20,7 @@ import {
 	formatModelAttemptNote,
 	isRetryableModelFailure,
 } from "../shared/model-fallback.ts";
+import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
 import { artifactOutputByResult, emptyUsage, modelFailureSignalByResult, sumUsage } from "./execution-utils.ts";
 import { runSingleAttemptWithStructuredOutputRetries } from "./execution-structured-retries.ts";
 import { shouldSuppressIntermediateRetryableFailureUpdate } from "./execution-updates.ts";
@@ -65,7 +66,7 @@ export async function runSync(
 		systemPrompt = systemPrompt ? `${systemPrompt}\n\n${skillInjection}` : skillInjection;
 	}
 
-	const candidates = buildModelCandidates(
+	const rawCandidates = buildModelCandidates(
 		options.modelOverride ?? agent.model,
 		agent.fallbackModels,
 		options.availableModels,
@@ -73,13 +74,20 @@ export async function runSync(
 		options.currentModel,
 		agent.fallbackThinkingLevels,
 	);
+	const filteredCandidates = filterSpawnableModelCandidates({
+		candidates: rawCandidates,
+		availableModels: options.availableModels,
+		knownModelProviders: options.knownModelProviders,
+		currentModel: options.currentModel,
+	});
+	const candidates = filteredCandidates.candidates;
 	const fastModeCwd = options.cwd ?? runtimeCwd;
 	const fastModeSettings = getSubagentCodexFastModeSettings(fastModeCwd);
 	const fastModeScope = resolveSubagentCodexFastModeScope(options.workflowStageSubagentGuard);
 	const attemptedModels: string[] = [];
-	const modelAttempts: ModelAttempt[] = [];
+	const modelAttempts: ModelAttempt[] = [...filteredCandidates.skippedAttempts];
 	const aggregateUsage = emptyUsage();
-	const attemptNotes: string[] = [];
+	const attemptNotes: string[] = filteredCandidates.skippedAttempts.map((attempt) => `[fallback] ${attempt.error}`);
 	const pendingAttemptNotes: string[] = [];
 	let totalToolCount = 0;
 	let totalDurationMs = 0;
@@ -96,7 +104,7 @@ export async function runSync(
 	}
 
 	let lastResult: SingleResult | undefined;
-	const modelsToTry = candidates.length > 0 ? candidates : [undefined];
+	const modelsToTry = candidates.length > 0 ? candidates : (rawCandidates.length === 0 ? [undefined] : []);
 	for (let i = 0; i < modelsToTry.length; i++) {
 		const candidate = modelsToTry[i];
 		if (candidate) attemptedModels.push(candidate);
@@ -156,7 +164,9 @@ export async function runSync(
 		exitCode: 1,
 		messages: [],
 		usage: emptyUsage(),
-		error: "Subagent did not produce a result.",
+		error: modelAttempts.length > 0
+			? "No spawnable subagent model candidates after pre-spawn filtering."
+			: "Subagent did not produce a result.",
 	} satisfies SingleResult;
 
 	result.usage = aggregateUsage;

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