@bastani/atomic 0.9.12 → 0.9.13-alpha.1

package/dist/builtin/subagents/src/runs/background/notify.ts

@@ -4,14 +4,17 @@
 
 import type { ExtensionAPI } from "@bastani/atomic";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT } from "../../shared/types.ts";
-import { buildCompletionKey, hasSeenWithTtl, recordSeen } from "./completion-dedupe.ts";
+import {
+	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT,
+	type SubagentAttemptStatus,
+} from "../../shared/types.ts";
 import type { CompletionNotificationEnvelope } from "./completion-notification.ts";
 
 interface ChainStepResult {
 	agent: string;
 	output: string;
-	success: boolean;
+	status: SubagentAttemptStatus;
 	intercomTarget?: string;
 	index?: number;
 }
@@ -31,9 +34,8 @@ interface SubagentResult {
 	runId?: string;
 	notificationId?: string;
 	agent: string | null;
-	success: boolean;
+	status: SubagentAttemptStatus;
 	summary: string;
-	exitCode?: number;
 	state?: string;
 	timestamp: number;
 	durationMs?: number;
@@ -87,6 +89,20 @@ function getNotifySeen(pi: ExtensionAPI): Map<string, number> {
 	return seen;
 }
 
+function buildCompletionKey(data: SubagentResult, fallback: string): string {
+	if (data.runId) return `run:${data.runId}`;
+	if (data.id) return `id:${data.id}`;
+	return `meta:${data.agent ?? "unknown"}:${data.timestamp}:${data.taskIndex ?? "-"}:${fallback}`;
+}
+
+function hasSeenWithTtl(seen: Map<string, number>, key: string, now: number, ttlMs: number): boolean {
+	for (const [seenKey, seenAt] of seen) if (now - seenAt > ttlMs) seen.delete(seenKey);
+	return seen.has(key);
+}
+
+function recordSeen(seen: Map<string, number>, key: string, now: number): void {
+	seen.set(key, now);
+}
 function isPromiseLike(value: unknown): value is PromiseLike<void> {
 	return (
 		(typeof value === "object" || typeof value === "function") &&
@@ -192,9 +208,14 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 		const agent = result.agent ?? "unknown";
 		const summary = typeof result.summary === "string" ? result.summary : "";
 		const paused =
-			!result.success &&
-			(result.exitCode === 0 || result.state === "paused" || summary.startsWith("Paused after interrupt."));
-		const status = paused ? "paused" : result.success ? "completed" : "failed";
+			result.status === "interrupted" || result.state === "paused" || summary.startsWith("Paused after interrupt.");
+		const status = paused
+			? "paused"
+			: result.status === "ok"
+				? "completed"
+				: result.status === "continued"
+					? "paused"
+					: "failed";
 
 		const taskInfo =
 			result.taskIndex !== undefined && result.totalTasks !== undefined

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

@@ -222,7 +222,7 @@ export async function runDynamicParallelChainStep(input: {
 	}
 	const failures = parallelResults
 		.map((result, originalIndex) => ({ ...result, originalIndex }))
-		.filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
+		.filter((result) => result.status === "error");
 	if (failures.length > 0) {
 		const failureSummary = failures
 			.map(
@@ -269,7 +269,7 @@ export async function runDynamicParallelChainStep(input: {
 		agent: result.agent,
 		taskIndex: index,
 		output: getSingleResultOutput(result),
-		exitCode: result.exitCode,
+		status: result.status,
 		error: result.error,
 	}));
 	state.prev = aggregateParallelOutputs(

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

@@ -53,7 +53,7 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 			return {
 				agent: task.agent,
 				task: input.parallelTemplates[taskIndex] ?? task.task ?? "{previous}",
-				exitCode: -1,
+				status: "skipped",
 				messages: [],
 				usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
 				error: "Skipped after foreground group detached for intercom coordination",
@@ -63,7 +63,7 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 			return {
 				agent: task.agent,
 				task: "(skipped)",
-				exitCode: -1,
+				status: "skipped",
 				messages: [],
 				usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
 				error: "Skipped due to fail-fast",
@@ -210,8 +210,8 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 			input.foregroundControl.updatedAt = Date.now();
 		}
 
-		if (result.exitCode !== 0 && failFast) aborted = true;
-		recordRun(task.agent, cleanTask, result.exitCode, result.progressSummary?.durationMs ?? 0);
+		if (result.status === "error" && failFast) aborted = true;
+		recordRun(task.agent, cleanTask, result.status, result.progressSummary?.durationMs ?? 0);
 		return result;
 	});
 }

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

@@ -213,7 +213,7 @@ export async function runStaticParallelChainStep(input: {
 
 		const failures = parallelResults
 			.map((result, originalIndex) => ({ ...result, originalIndex }))
-			.filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
+			.filter((result) => result.status === "error");
 		if (failures.length > 0) {
 			const failureSummary = failures
 				.map((failure) => `- Task ${failure.originalIndex + 1} (${failure.agent}): ${failure.error || "failed"}`)
@@ -251,7 +251,7 @@ export async function runStaticParallelChainStep(input: {
 				agent: result.agent,
 				taskIndex: index,
 				output: getSingleResultOutput(result),
-				exitCode: result.exitCode,
+				status: result.status,
 				error: result.error,
 				outputTargetPath,
 				outputTargetExists: outputTargetPath ? fs.existsSync(outputTargetPath) : undefined,

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

@@ -199,7 +199,7 @@ export async function runSequentialChainStep(input: {
 		context.foregroundControl.interrupt = undefined;
 		context.foregroundControl.updatedAt = Date.now();
 	}
-	recordRun(seqStep.agent, cleanTask, result.exitCode, result.progressSummary?.durationMs ?? 0);
+	recordRun(seqStep.agent, cleanTask, result.status, result.progressSummary?.durationMs ?? 0);
 
 	state.globalTaskIndex++;
 	state.results.push(result);
@@ -232,7 +232,7 @@ export async function runSequentialChainStep(input: {
 			),
 		};
 	}
-	if (result.exitCode !== 0) {
+	if (result.status !== "ok") {
 		const summary = buildChainSummary(context.chainSteps, state.results, context.chainDir, "failed", {
 			index: stepIndex,
 			error: result.error || "Chain failed",

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

@@ -1,281 +1 @@
-import { existsSync } from "node:fs";
-import type { AgentConfig } from "../../agents/agents.ts";
-import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.ts";
-import { ensureArtifactsDir, getArtifactPaths, writeArtifact, writeMetadata } from "../../shared/artifacts.ts";
-import { getSubagentCodexFastModeSettings, resolveSubagentCodexFastModeScope } from "../../shared/fast-mode.ts";
-import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import {
-	type ArtifactPaths,
-	DEFAULT_MAX_OUTPUT,
-	type ModelAttempt,
-	type RunSyncOptions,
-	type SingleResult,
-	truncateOutput,
-} from "../../shared/types.ts";
-import { findLatestSessionFile } from "../../shared/utils.ts";
-import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
-import { buildModelCandidates, formatModelAttemptNote, isRetryableModelFailure } from "../shared/model-fallback.ts";
-import { applyThinkingSuffix } from "../shared/pi-args.ts";
-import { captureSingleOutputSnapshot, validateFileOnlyOutputMode } from "../shared/single-output.ts";
-import { runSingleAttemptWithStructuredOutputRetries } from "./execution-structured-retries.ts";
-import { shouldSuppressIntermediateRetryableFailureUpdate } from "./execution-updates.ts";
-import { artifactOutputByResult, emptyUsage, modelFailureSignalByResult, sumUsage } from "./execution-utils.ts";
-
-/**
- * Run a subagent synchronously (blocking until complete)
- */
-export async function runSync(
-	runtimeCwd: string,
-	agents: AgentConfig[],
-	agentName: string,
-	task: string,
-	options: RunSyncOptions,
-): Promise<SingleResult> {
-	const agent = agents.find((a) => a.name === agentName);
-	if (!agent) {
-		return {
-			agent: agentName,
-			task,
-			exitCode: 1,
-			messages: [],
-			usage: emptyUsage(),
-			error: `Unknown agent: ${agentName}`,
-		};
-	}
-	const outputModeValidationError = validateFileOnlyOutputMode(
-		options.outputMode,
-		options.outputPath,
-		`Single run (${agentName})`,
-	);
-	if (outputModeValidationError) {
-		return {
-			agent: agentName,
-			task,
-			exitCode: 1,
-			messages: [],
-			usage: emptyUsage(),
-			outputMode: options.outputMode,
-			error: outputModeValidationError,
-		};
-	}
-
-	const shareEnabled = options.share === true;
-	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
-	const skillNames = options.skills ?? agent.skills ?? [];
-	const skillCwd = options.cwd ?? runtimeCwd;
-	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(
-		skillNames,
-		skillCwd,
-		runtimeCwd,
-	);
-	if (skillNames.some((skill) => skill.trim() === "subagent") && missingSkills.includes("subagent")) {
-		return {
-			agent: agentName,
-			task,
-			exitCode: 1,
-			messages: [],
-			usage: emptyUsage(),
-			error: "Skills not found: subagent",
-		};
-	}
-	let systemPrompt = agent.systemPrompt?.trim() || "";
-	if (resolvedSkills.length > 0) {
-		const skillInjection = buildSkillInjection(resolvedSkills);
-		systemPrompt = systemPrompt ? `${systemPrompt}\n\n${skillInjection}` : skillInjection;
-	}
-
-	const rawCandidates = buildModelCandidates(
-		options.modelOverride ?? agent.model,
-		agent.fallbackModels,
-		options.availableModels,
-		options.preferredModelProvider,
-		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[] = [...filteredCandidates.skippedAttempts];
-	const aggregateUsage = emptyUsage();
-	const attemptNotes: string[] = filteredCandidates.skippedAttempts.map((attempt) => `[fallback] ${attempt.error}`);
-	const pendingAttemptNotes: string[] = [];
-	let totalToolCount = 0;
-	let totalDurationMs = 0;
-
-	let artifactPathsResult: ArtifactPaths | undefined;
-	let jsonlPath: string | undefined;
-	if (options.artifactsDir && options.artifactConfig?.enabled !== false) {
-		artifactPathsResult = getArtifactPaths(options.artifactsDir, options.runId, agentName, options.index);
-		ensureArtifactsDir(options.artifactsDir);
-		if (options.artifactConfig?.includeInput !== false) {
-			writeArtifact(artifactPathsResult.inputPath, `# Task for ${agentName}\n\n${task}`);
-		}
-		if (options.artifactConfig?.includeJsonl !== false) jsonlPath = artifactPathsResult.jsonlPath;
-	}
-	const persistArtifacts = (value: SingleResult): void => {
-		if (!artifactPathsResult || options.artifactConfig?.enabled === false) return;
-		value.artifactPaths = artifactPathsResult;
-		if (options.artifactConfig?.includeOutput !== false) {
-			writeArtifact(artifactPathsResult.outputPath, artifactOutputByResult.get(value) ?? value.finalOutput ?? "");
-		}
-		if (options.artifactConfig?.includeMetadata !== false) {
-			writeMetadata(artifactPathsResult.metadataPath, {
-				runId: options.runId,
-				agent: agentName,
-				task,
-				exitCode: value.exitCode,
-				usage: value.usage,
-				model: value.model,
-				fastMode: value.fastMode,
-				attemptedModels: value.attemptedModels,
-				modelAttempts: value.modelAttempts,
-				durationMs: value.progressSummary?.durationMs,
-				toolCount: value.progressSummary?.toolCount,
-				error: value.error,
-				skills: value.skills,
-				skillsWarning: value.skillsWarning,
-				timestamp: Date.now(),
-			});
-		}
-	};
-
-	let lastResult: SingleResult | 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);
-		const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
-		const detachedExit = options.onDetachedExit;
-		let attemptOptions: RunSyncOptions = {
-			...options,
-			onDetachedExit: (recovered) => {
-				recovered.attemptedModels = attemptedModels.length > 0 ? [...attemptedModels] : undefined;
-				const recoveredModel =
-					applyThinkingSuffix(candidate, agent.thinking) ?? recovered.model ?? agent.model ?? "default";
-				const completedAttempt: ModelAttempt = {
-					model: recoveredModel,
-					reasoningLevel: resolveEffectiveThinking(recoveredModel, agent.thinking),
-					success: recovered.exitCode === 0 && !recovered.error,
-					exitCode: recovered.exitCode,
-					error: recovered.error,
-					usage: { ...recovered.usage },
-				};
-				recovered.modelAttempts = [...modelAttempts.slice(0, -1), completedAttempt];
-				persistArtifacts(recovered);
-				detachedExit?.(recovered);
-			},
-		};
-		if (i < modelsToTry.length - 1 && options.onUpdate) {
-			const forwardUpdate = options.onUpdate;
-			attemptOptions = {
-				...attemptOptions,
-				onUpdate: (update) => {
-					if (shouldSuppressIntermediateRetryableFailureUpdate(update)) return;
-					forwardUpdate(update);
-				},
-			};
-		}
-		const result = await runSingleAttemptWithStructuredOutputRetries(
-			runtimeCwd,
-			agent,
-			task,
-			candidate,
-			attemptOptions,
-			{
-				sessionEnabled,
-				systemPrompt,
-				resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
-				skillsWarning: missingSkills.length > 0 ? `Skills not found: ${missingSkills.join(", ")}` : undefined,
-				jsonlPath,
-				artifactPaths: artifactPathsResult,
-				attemptNotes,
-				outputSnapshot,
-				fastModeSettings,
-				fastModeScope,
-				originalTask: task,
-			},
-		);
-		lastResult = result;
-		sumUsage(aggregateUsage, result.usage);
-		totalToolCount += result.progressSummary?.toolCount ?? 0;
-		totalDurationMs += result.progressSummary?.durationMs ?? 0;
-		const attemptSucceeded = result.exitCode === 0 && !result.error;
-		const attemptModel = applyThinkingSuffix(candidate, agent.thinking) ?? result.model ?? agent.model ?? "default";
-		const attempt: ModelAttempt = {
-			model: attemptModel,
-			reasoningLevel: resolveEffectiveThinking(attemptModel, agent.thinking),
-			success: attemptSucceeded,
-			exitCode: result.exitCode,
-			error: result.error,
-			usage: { ...result.usage },
-		};
-		modelAttempts.push(attempt);
-		if (attemptSucceeded) break;
-		if (result.detached) break;
-		const retrySignal = modelFailureSignalByResult.get(result) ?? result.error;
-		if (isRetryableModelFailure(retrySignal) && i < modelsToTry.length - 1) {
-			pendingAttemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[i + 1]));
-			continue;
-		}
-		attemptNotes.push(...pendingAttemptNotes);
-		break;
-	}
-
-	const result =
-		lastResult ??
-		({
-			agent: agentName,
-			task,
-			exitCode: 1,
-			messages: [],
-			usage: emptyUsage(),
-			error:
-				modelAttempts.length > 0
-					? "No spawnable subagent model candidates after pre-spawn filtering."
-					: "Subagent did not produce a result.",
-		} satisfies SingleResult);
-
-	result.usage = aggregateUsage;
-	result.attemptedModels = attemptedModels.length > 0 ? attemptedModels : undefined;
-	result.modelAttempts = modelAttempts.length > 0 ? modelAttempts : undefined;
-	result.progressSummary = {
-		toolCount: totalToolCount,
-		tokens: aggregateUsage.input + aggregateUsage.output,
-		durationMs: totalDurationMs,
-	};
-	if (attemptNotes.length > 0 && result.progress) {
-		result.progress.recentOutput = [...attemptNotes, ...result.progress.recentOutput];
-		if (result.progress.recentOutput.length > 50) result.progress.recentOutput.splice(50);
-	}
-
-	if (artifactPathsResult && options.artifactConfig?.enabled !== false && !result.detached) {
-		persistArtifacts(result);
-
-		if (options.maxOutput) {
-			const config = { ...DEFAULT_MAX_OUTPUT, ...options.maxOutput };
-			const truncationResult = truncateOutput(result.finalOutput ?? "", config, artifactPathsResult.outputPath);
-			if (truncationResult.truncated) result.truncation = truncationResult;
-		}
-	} else if (options.maxOutput) {
-		const config = { ...DEFAULT_MAX_OUTPUT, ...options.maxOutput };
-		const truncationResult = truncateOutput(result.finalOutput ?? "", config);
-		if (truncationResult.truncated) result.truncation = truncationResult;
-	}
-
-	if (options.sessionFile && (existsSync(options.sessionFile) || result.messages?.length)) {
-		result.sessionFile = options.sessionFile;
-	} else if (shareEnabled && options.sessionDir) {
-		const sessionFile = findLatestSessionFile(options.sessionDir);
-		if (sessionFile) result.sessionFile = sessionFile;
-	}
-
-	return result;
-}
+export { runSingleInProcess, runSync } from "./inprocess-run-sync.ts";

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

@@ -1,83 +1,19 @@
-import type { AgentConfig } from "../../agents/agents.ts";
+import type { AgentConfig } from "../../agents/agent-types.ts";
 import type { RunSyncOptions, SingleResult } from "../../shared/types.ts";
-import {
-	formatStructuredOutputCorrectionPrompt,
-	isStructuredOutputContractError,
-	latestStructuredOutputToolErrorFromMessages,
-	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
-} from "../shared/structured-output.ts";
-import { runSingleAttempt } from "./execution-attempt.ts";
-import type { RunSingleAttemptShared } from "./execution-attempt-types.ts";
-import { type RunSyncUpdate, shouldSuppressIntermediateStructuredOutputFailureUpdate } from "./execution-updates.ts";
-import { emptyUsage, sumUsage } from "./execution-utils.ts";
+import { runSingleInProcess } from "./inprocess-run-sync.ts";
 
-export async function runSingleAttemptWithStructuredOutputRetries(
+/**
+ * Kept as the local foreground seam while callers migrate to the in-process door.
+ * Structured output correction is handled by the SDK custom-tool policy in the
+ * new runner; no process retry or stdout parser remains here.
+ */
+export function runSingleAttemptWithStructuredOutputRetries(
 	runtimeCwd: string,
 	agent: AgentConfig,
 	task: string,
-	model: string | undefined,
+	_model: string | undefined,
 	options: RunSyncOptions,
-	shared: RunSingleAttemptShared,
+	_shared: object,
 ): Promise<SingleResult> {
-	let nextTask = task;
-	let correctiveAttempts = 0;
-	let finalResult: SingleResult | undefined;
-	const aggregateUsage = emptyUsage();
-	let totalToolCount = 0;
-	let totalDurationMs = 0;
-
-	while (true) {
-		const suppressIntermediateStructuredOutputFailure =
-			options.structuredOutput !== undefined &&
-			correctiveAttempts < STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS &&
-			options.onUpdate !== undefined;
-		const attemptOptions = suppressIntermediateStructuredOutputFailure
-			? {
-					...options,
-					onUpdate: (update: RunSyncUpdate) => {
-						if (shouldSuppressIntermediateStructuredOutputFailureUpdate(update)) return;
-						options.onUpdate?.(update);
-					},
-				}
-			: options;
-		const result = await runSingleAttempt(runtimeCwd, agent, nextTask, model, attemptOptions, shared);
-		finalResult = result;
-		sumUsage(aggregateUsage, result.usage);
-		totalToolCount += result.progressSummary?.toolCount ?? 0;
-		totalDurationMs += result.progressSummary?.durationMs ?? 0;
-
-		if (!options.structuredOutput || !isStructuredOutputContractError(result.error)) break;
-		const correctionError =
-			latestStructuredOutputToolErrorFromMessages(result.messages) ??
-			result.error ??
-			"Structured output contract failed.";
-		if (correctiveAttempts >= STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS) {
-			result.error = correctionError;
-			break;
-		}
-		correctiveAttempts += 1;
-		nextTask = formatStructuredOutputCorrectionPrompt({
-			originalTask: task,
-			error: correctionError,
-			attempt: correctiveAttempts,
-		});
-	}
-
-	const result =
-		finalResult ??
-		({
-			agent: agent.name,
-			task,
-			exitCode: 1,
-			messages: [],
-			usage: emptyUsage(),
-			error: "Subagent did not produce a result.",
-		} satisfies SingleResult);
-	result.usage = aggregateUsage;
-	result.progressSummary = {
-		toolCount: totalToolCount,
-		tokens: aggregateUsage.input + aggregateUsage.output,
-		durationMs: totalDurationMs,
-	};
-	return result;
+	return runSingleInProcess(runtimeCwd, agent, task, options);
 }