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

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [0.9.4-alpha.7] - 2026-07-02
+
+### Added
+
+- Added dynamic GitHub Copilot model population from the live CAPI `/models` catalog: picker-enabled, non-disabled plain chat ids are synthesized from catalog metadata (endpoints, capabilities, limits, and display names) while built-in `pi-ai` definitions still win, namespaced enterprise deployments such as `org/deployment/model` are skipped, and cached catalog metadata enables the same models on cold start.
+- Added catalog-driven thinking-level gating for GitHub Copilot models so dynamically synthesized entries and bundled `pi-ai` Copilot models only offer the reasoning levels advertised by CAPI's `capabilities.supports.reasoning_effort` arrays, while models without an effort array keep their existing thinking behavior.
+- Added a subagent watchdog escape hatch: setting `ATOMIC_SUBAGENT_ATTEMPT_IDLE_TIMEOUT_MS` or `ATOMIC_SUBAGENT_ATTEMPT_TIMEOUT_MS` to `0` (or a negative value) now disables the corresponding per-attempt timeout entirely; non-numeric values are ignored and the defaults apply. The `ATOMIC_SUBAGENT_ATTEMPT_KILL_GRACE_MS` SIGTERM→SIGKILL grace period intentionally cannot be disabled — `0`, negative, or non-numeric values fall back to its default so escalation always stays bounded ([#1581](https://github.com/bastani-inc/atomic/pull/1581)).
+
+### Fixed
+
+- Reverted the `@types/node` devDependency from `26.0.1` back to `24.12.4` to match the deliberate root `overrides` pin that aligns with upstream Pi's resolved lockfile (see [#1489](https://github.com/bastani-inc/atomic/pull/1489)); the dependabot bump in [#1548](https://github.com/bastani-inc/atomic/pull/1548) was a semantic no-op because the override forced resolution to `24.12.4`. Dependabot now ignores `@types/node` so it stops proposing inert bumps.
+- Fixed the `read` tool to parse colon-delimited `file:START:END` (and grep-style `file:LINE:COL`) path selectors as a line range instead of leaving the leading number glued to the path (`file:395`), which produced a bogus `ENOENT` and pushed models (e.g. Opus) to fall back to `sed` ([#1585](https://github.com/bastani-inc/atomic/issues/1585)).
+- Fixed GitHub Copilot models to use the live `max_output_tokens` value from the Copilot model catalog, preventing `github-copilot/claude-opus-4.8` from being capped by Atomic's stale built-in output-token limit after compaction ([#1582](https://github.com/bastani-inc/atomic/issues/1582)).
+- Fixed active GitHub Copilot sessions to adopt live catalog model metadata as soon as the catalog loads, so fallback models refresh their supported reasoning levels without requiring a restart.
+- Fixed workflow and subagent model fallback chains 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 to the next candidate instead of stopping. This ensures that when none of the configured fallback candidates can serve the current request, Atomic falls back to the currently selected user model rather than failing outright. Refusals, content-filter/safety blocks, cancellations, and task failures still stop the chain and are never retried on another model ([#1580](https://github.com/bastani-inc/atomic/issues/1580)).
+- Fixed foreground and background subagent model attempts that produced no child activity from hanging indefinitely. Atomic now bounds each candidate with an idle watchdog and wall-clock cap, records retryable timeout attempts so fallback continues, and skips known unauthenticated providers before spawning while preserving unknown/custom providers and the current-model last resort ([#1580](https://github.com/bastani-inc/atomic/issues/1580)).
+- Fixed the subagent per-attempt idle watchdog so an in-flight tool execution counts as activity: a slow, quiet tool call (long build or test run with no interim output) is no longer killed as a stalled attempt; the wall-clock cap still bounds such attempts ([#1581](https://github.com/bastani-inc/atomic/pull/1581)).
+- Aligned the subagents and workflows model-failure classifiers' direct-message precedence and added a cross-package conformance test suite so the two classifier copies cannot silently drift ([#1581](https://github.com/bastani-inc/atomic/pull/1581)).
+- Fixed the background subagent runner to spawn one default-model attempt when no model candidates were ever configured (no primary model, no fallbacks, and no current model), mirroring the foreground path instead of silently exiting 1 with no error and no spawn; an explicitly empty candidate list produced by pre-spawn auth filtering is still respected and surfaced as an error ([#1581](https://github.com/bastani-inc/atomic/pull/1581)).
+
 ## [0.9.4-alpha.6] - 2026-07-01
 
 ### Added

package/dist/builtin/cursor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/cursor",
-  "version": "0.9.4-alpha.6",
+  "version": "0.9.4-alpha.7",
   "private": true,
   "description": "Experimental first-party Atomic extension for Cursor OAuth, model discovery, and streaming provider registration.",
   "contributors": [
@@ -40,8 +40,8 @@
     }
   },
   "dependencies": {
-    "@bastani/atomic-natives": "0.9.4-alpha.6",
-    "@bufbuild/protobuf": "^2.0.0",
+    "@bastani/atomic-natives": "0.9.4-alpha.7",
+    "@bufbuild/protobuf": "^2.12.1",
     "@earendil-works/pi-ai": "^0.80.3"
   }
 }

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.4-alpha.6",
+  "version": "0.9.4-alpha.7",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.4-alpha.6",
+  "version": "0.9.4-alpha.7",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [
@@ -48,7 +48,7 @@
     }
   },
   "dependencies": {
-    "@modelcontextprotocol/ext-apps": "^1.7.2",
+    "@modelcontextprotocol/ext-apps": "^1.7.4",
     "@modelcontextprotocol/sdk": "^1.25.1",
     "open": "^11.0.0",
     "typebox": "^1.1.24",

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [0.9.4-alpha.7] - 2026-07-02
+
+### Fixed
+
+- Fixed subagent 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 subagent 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)).
+- Fixed foreground and background subagent model attempts that produced no child activity from hanging indefinitely. Each candidate attempt now has a conservative idle watchdog and absolute wall-clock cap, records a retryable timeout failure, and advances to the next fallback candidate; known providers without configured auth are skipped before spawning while unknown/custom providers and the current-model last resort are still attempted ([#1580](https://github.com/bastani-inc/atomic/issues/1580)).
+- Fixed the per-attempt idle watchdog so an in-flight tool execution counts as activity: a slow, quiet tool call (long build or test run with no interim output) is no longer killed as a stalled attempt; the wall-clock cap still bounds such attempts ([#1581](https://github.com/bastani-inc/atomic/pull/1581)).
+- Aligned the subagents model-failure classifier's direct-message precedence with the workflows classifier (direct-message classification now runs after nested cause/diagnostic traversal and before outer status/code classification), and added a cross-package conformance test suite so the two classifier copies cannot silently drift ([#1581](https://github.com/bastani-inc/atomic/pull/1581)).
+- Fixed the background subagent runner to spawn one default-model attempt when no model candidates were ever configured (no primary model, no fallbacks, and no current model), mirroring the foreground path instead of silently exiting 1 with no error and no spawn. An explicitly empty candidate list produced by pre-spawn auth filtering is still respected and surfaced as an error ([#1581](https://github.com/bastani-inc/atomic/pull/1581)).
+
+### Added
+
+- Added a watchdog escape hatch: setting `ATOMIC_SUBAGENT_ATTEMPT_IDLE_TIMEOUT_MS` or `ATOMIC_SUBAGENT_ATTEMPT_TIMEOUT_MS` to `0` (or a negative value) now disables the corresponding per-attempt timeout entirely; non-numeric values are ignored and the defaults apply. The `ATOMIC_SUBAGENT_ATTEMPT_KILL_GRACE_MS` SIGTERM→SIGKILL grace period intentionally cannot be disabled — `0`, negative, or non-numeric values fall back to its default so escalation always stays bounded ([#1581](https://github.com/bastani-inc/atomic/pull/1581)).
+
 ## [0.9.4-alpha.6] - 2026-07-01
 
 ### Changed

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.4-alpha.6",
+  "version": "0.9.4-alpha.7",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [

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

@@ -12,6 +12,7 @@ import type { RunnerStep } from "../shared/parallel-utils.ts";
 import { injectSingleOutputInstruction, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import { ChainOutputValidationError, validateChainOutputBindings } from "../shared/chain-outputs.ts";
 import { buildModelCandidates, resolveModelCandidate } from "../shared/model-fallback.ts";
+import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
 import { NESTED_RUNS_DIR, nestedResultsPath, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent } from "../shared/nested-events.ts";
 import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
 import { resolveExpectedWorktreeAgentCwd } from "../shared/worktree.ts";
@@ -57,6 +58,7 @@ export function executeAsyncChain(
 	const resultMode = params.resultMode ?? "chain";
 	const chainSkills = params.chainSkills ?? [];
 	const availableModels = params.availableModels;
+	const knownModelProviders = params.knownModelProviders;
 	const fastModeScope = resolveSubagentCodexFastModeScope(workflowStageSubagentGuard);
 	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
 	const firstStep = chain[0];
@@ -149,9 +151,16 @@ export function executeAsyncChain(
 
 		const primaryModel = resolveModelCandidate(behavior.model ?? a.model, availableModels, ctx.currentModelProvider);
 		const model = applyThinkingSuffix(primaryModel, a.thinking);
-		const modelCandidates = buildModelCandidates(behavior.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider, ctx.currentModel, a.fallbackThinkingLevels)
+		const rawModelCandidates = buildModelCandidates(behavior.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider, ctx.currentModel, a.fallbackThinkingLevels)
 			.map((candidate) => applyThinkingSuffix(candidate, a.thinking))
 			.filter((candidate): candidate is string => typeof candidate === "string");
+		const filteredCandidates = filterSpawnableModelCandidates({
+			candidates: rawModelCandidates,
+			availableModels,
+			knownModelProviders,
+			currentModel: applyThinkingSuffix(ctx.currentModel, a.thinking),
+		});
+		const modelCandidates = filteredCandidates.candidates;
 		const fastModeSettings = getSubagentCodexFastModeSettings(stepCwd);
 		return {
 			agent: s.agent,
@@ -165,6 +174,7 @@ export function executeAsyncChain(
 			thinking: resolveEffectiveThinking(model, a.thinking),
 			...resolveSubagentModelFastModeMetadata({ model, modelCandidates, cwd: stepCwd, settings: fastModeSettings, scope: fastModeScope }),
 			modelCandidates,
+			modelAttempts: filteredCandidates.skippedAttempts,
 			codexFastModeSettings: fastModeSettings,
 			codexFastModeScope: fastModeScope,
 			tools: a.tools,

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

@@ -9,6 +9,7 @@ import { resolveChildCwd } from "../../shared/utils.ts";
 import { applyThinkingSuffix, SUBAGENT_INTERCOM_SESSION_NAME_ENV } from "../shared/pi-args.ts";
 import { injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import { buildModelCandidates, resolveModelCandidate } from "../shared/model-fallback.ts";
+import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
 import { NESTED_RUNS_DIR, nestedResultsPath, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent } from "../shared/nested-events.ts";
 import {
 	UNAVAILABLE_SUBAGENT_SKILL_ERROR,
@@ -50,6 +51,7 @@ export function executeAsyncSingle(
 	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
 	const skillNames = params.skills ?? agentConfig.skills ?? [];
 	const availableModels = params.availableModels;
+	const knownModelProviders = params.knownModelProviders;
 	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, runnerCwd, ctx.cwd);
 	if (missingSkills.includes("subagent")) return formatAsyncStartError("single", UNAVAILABLE_SUBAGENT_SKILL_ERROR);
 	let systemPrompt = agentConfig.systemPrompt?.trim() ?? "";
@@ -84,9 +86,16 @@ export function executeAsyncSingle(
 		resolveModelCandidate(params.modelOverride ?? agentConfig.model, availableModels, ctx.currentModelProvider),
 		agentConfig.thinking,
 	);
-	const modelCandidates = buildModelCandidates(params.modelOverride ?? agentConfig.model, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, ctx.currentModel)
+	const rawModelCandidates = buildModelCandidates(params.modelOverride ?? agentConfig.model, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, ctx.currentModel)
 		.map((candidate) => applyThinkingSuffix(candidate, agentConfig.thinking))
 		.filter((candidate): candidate is string => typeof candidate === "string");
+	const filteredCandidates = filterSpawnableModelCandidates({
+		candidates: rawModelCandidates,
+		availableModels,
+		knownModelProviders,
+		currentModel: applyThinkingSuffix(ctx.currentModel, agentConfig.thinking),
+	});
+	const modelCandidates = filteredCandidates.candidates;
 	const fastModeSettings = getSubagentCodexFastModeSettings(runnerCwd);
 	const fastModeScope = resolveSubagentCodexFastModeScope(workflowStageSubagentGuard);
 	let spawnResult: AsyncSpawnResult = {};
@@ -103,6 +112,7 @@ export function executeAsyncSingle(
 						thinking: resolveEffectiveThinking(model, agentConfig.thinking),
 						...resolveSubagentModelFastModeMetadata({ model, modelCandidates, cwd: runnerCwd, settings: fastModeSettings, scope: fastModeScope }),
 						modelCandidates,
+						modelAttempts: filteredCandidates.skippedAttempts,
 						codexFastModeSettings: fastModeSettings,
 						codexFastModeScope: fastModeScope,
 						tools: agentConfig.tools,

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,