@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/background/completion-notification.ts

@@ -12,7 +12,7 @@ export function deliverLocalCompletionNotification(
 	payload: Record<string, unknown>,
 	notificationId: string,
 ): Promise<boolean> {
-	return new Promise((resolve) => {
+	return new Promise((resolve, reject) => {
 		let settled = false;
 		let deferred = false;
 		const finish = (delivered: boolean) => {
@@ -20,6 +20,11 @@ export function deliverLocalCompletionNotification(
 			settled = true;
 			resolve(delivered);
 		};
+		const fail = (error: unknown) => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		};
 		try {
 			events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
 				...payload,
@@ -30,8 +35,8 @@ export function deliverLocalCompletionNotification(
 				acknowledge: finish,
 			} satisfies CompletionNotificationEnvelope);
 			if (!deferred) finish(true);
-		} catch {
-			finish(false);
+		} catch (error) {
+			fail(error);
 		}
 	});
 }

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

@@ -2,16 +2,19 @@
  * Subagent completion notifications.
  */
 
-import type { ExtensionAPI } from "@bastani/atomic";
+import { type ExtensionAPI, isStaleExtensionContextError } 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 {
+interface SubagentStepResult {
 	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;
@@ -41,7 +43,7 @@ interface SubagentResult {
 	shareUrl?: string;
 	gistUrl?: string;
 	shareError?: string;
-	results?: ChainStepResult[];
+	results?: SubagentStepResult[];
 	taskIndex?: number;
 	totalTasks?: number;
 	noticeLabel?: string;
@@ -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") &&
@@ -118,13 +134,6 @@ async function dispatchFallback(
 export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 	const registry = getNotifyRegistry();
 	const previous = registry.get(pi);
-	if (previous) {
-		try {
-			previous.unsubscribe();
-		} catch {
-			// Best effort cleanup for stale handlers from an older reload.
-		}
-	}
 	const seen = getNotifySeen(pi);
 	const ttlMs = 10 * 60 * 1000;
 
@@ -150,24 +159,35 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 		const terminalId = result.notificationId?.startsWith("completion-notify-")
 			? result.notificationId.slice("completion-notify-".length)
 			: result.notificationId;
+		let dispatchStarted = false;
+		const barrierDispatch = dispatch
+			? (prefix: TerminalPreludeMessage[]) => {
+					dispatchStarted = true;
+					return dispatch(prefix);
+				}
+			: undefined;
 		const payload = {
 			runId,
 			...(terminalId ? { terminalId } : {}),
 			terminalAt: Number.isFinite(result.timestamp) ? result.timestamp : Date.now(),
 			source: "background-notify" as const,
 			sourceSessionTargets,
-			...(dispatch ? { dispatch } : {}),
+			...(barrierDispatch ? { dispatch: barrierDispatch } : {}),
 		};
 		Object.defineProperty(payload, "terminalOwner", { value: pi });
-		pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+		try {
+			pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+		} catch (error) {
+			if (!isStaleExtensionContextError(error) || dispatchStarted) throw error;
+		}
 		const globalHandler = (globalThis as Record<string, unknown>).__atomicTerminalOrderingBarrierHandler;
 		if (typeof globalHandler === "function") (globalHandler as (value: unknown) => void)(payload);
 		return (payload as typeof payload & { completion?: Promise<void> }).completion;
 	};
 	const inFlight = new Map<string, Promise<void>>();
-	let registration: NotifyRegistration;
+	let registration: NotifyRegistration | undefined;
 	const handleComplete = (data: unknown): void => {
-		if (registry.get(pi) !== registration) return;
+		if (!registration || registry.get(pi) !== registration) return;
 		const result = data as SubagentResult & Partial<CompletionNotificationEnvelope>;
 		const now = Date.now();
 		const key = result.notificationId
@@ -192,9 +212,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
@@ -287,13 +312,45 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 			fail(error);
 		}
 	};
-
-	const unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
+	let unsubscribe: () => void;
+	try {
+		unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		// A stale API cannot accept a new subscription; keep the prior one usable.
+		return () => {};
+	}
 	registration = { unsubscribe };
 	registry.set(pi, registration);
+	if (previous) {
+		try {
+			previous.unsubscribe();
+		} catch (error) {
+			if (isStaleExtensionContextError(error)) {
+				// The old handler is inert because the registry now belongs to this registration.
+			} else {
+				// A failed replacement cleanup aborts activation; remove the new entry before rethrowing.
+				if (registry.get(pi) === registration) registry.delete(pi);
+				try {
+					unsubscribe();
+				} catch (rollbackError) {
+					if (!isStaleExtensionContextError(rollbackError)) {
+						throw new AggregateError([error, rollbackError], "Failed to roll back notification registration");
+					}
+					// Stale cleanup is best effort after the registry rollback.
+				}
+				throw error;
+			}
+		}
+	}
 	return () => {
-		if (registry.get(pi) !== registration) return;
+		if (!registration || registry.get(pi) !== registration) return;
 		registry.delete(pi);
-		unsubscribe();
+		try {
+			unsubscribe();
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			// Stale event-bus cleanup is best effort.
+		}
 	};
 }

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-updates.ts

@@ -1,7 +1,6 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Details } from "../../shared/types.ts";
 import { isRetryableModelFailure } from "../shared/model-fallback.ts";
-import { isStructuredOutputContractError } from "../shared/structured-output.ts";
 
 export type RunSyncUpdate = AgentToolResult<Details>;
 
@@ -25,7 +24,3 @@ function terminalUpdateFailureText(update: RunSyncUpdate): string | undefined {
 export function shouldSuppressIntermediateRetryableFailureUpdate(update: RunSyncUpdate): boolean {
 	return isRetryableModelFailure(terminalUpdateFailureText(update));
 }
-
-export function shouldSuppressIntermediateStructuredOutputFailureUpdate(update: RunSyncUpdate): boolean {
-	return isStructuredOutputContractError(terminalUpdateFailureText(update));
-}

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

@@ -3,7 +3,4 @@
  */
 
 export { runSync } from "./execution-run-sync.ts";
-export {
-	shouldSuppressIntermediateRetryableFailureUpdate,
-	shouldSuppressIntermediateStructuredOutputFailureUpdate,
-} from "./execution-updates.ts";
+export { shouldSuppressIntermediateRetryableFailureUpdate } from "./execution-updates.ts";