@bastani/atomic 0.9.13-alpha.2 → 0.9.13-alpha.4

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

@@ -1,195 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { isStaleExtensionContextError } from "@bastani/atomic";
-import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.ts";
-import { injectSingleProgressInstruction, writeInitialProgressFile } from "../../shared/settings.ts";
-import {
-	ASYNC_DIR,
-	resolveChildMaxSubagentDepth,
-	SUBAGENT_ASYNC_COMPLETE_EVENT,
-	SUBAGENT_ASYNC_STARTED_EVENT,
-} from "../../shared/types.ts";
-import { resolveChildCwd } from "../../shared/utils.ts";
-import { runSingleInProcess } from "../foreground/inprocess-run-sync.ts";
-import { resolveChildIntercomGroup } from "../shared/intercom-group.js";
-import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
-import { buildModelCandidates } from "../shared/model-fallback.ts";
-import {
-	injectSingleOutputInstruction,
-	normalizeSingleOutputOverride,
-	resolveSingleOutputPath,
-	validateFileOnlyOutputMode,
-} from "../shared/single-output.ts";
-import {
-	type AsyncExecutionResult,
-	type AsyncSingleParams,
-	formatAsyncStartError,
-	formatAsyncStartedMessage,
-	UNAVAILABLE_SUBAGENT_SKILL_ERROR,
-} from "./background.ts";
-
-/**
- * Execute a single agent asynchronously using the in-process runner.
- *
- * The returned promise resolves after admission and continuation, not after the
- * model attempt. Terminal delivery happens through the existing detached-exit
- * callback and in-memory result path.
- */
-export async function executeAsyncSingle(id: string, params: AsyncSingleParams): Promise<AsyncExecutionResult> {
-	const {
-		agent,
-		agentConfig,
-		ctx,
-		cwd,
-		maxOutput,
-		artifactsDir,
-		artifactConfig,
-		sessionRoot,
-		sessionFile,
-		maxSubagentDepth,
-		parentDepth,
-		workflowStageSubagentGuard,
-		controlConfig,
-		controlIntercomTarget,
-		childIntercomTarget,
-	} = params;
-	const task = params.task ?? "";
-	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
-	const skillNames = params.skills ?? agentConfig.skills ?? [];
-	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() ?? "";
-	if (resolvedSkills.length > 0) {
-		const injection = buildSkillInjection(resolvedSkills);
-		systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
-	}
-
-	const asyncDir = path.join(ASYNC_DIR, id);
-	try {
-		fs.mkdirSync(asyncDir, { recursive: true });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return formatAsyncStartError("single", `Failed to create async run directory '${asyncDir}': ${message}`);
-	}
-
-	const effectiveOutput = normalizeSingleOutputOverride(params.output, agentConfig.output);
-	const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, runnerCwd);
-	const outputMode = params.outputMode ?? "inline";
-	const validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
-	if (validationError) return formatAsyncStartError("single", validationError);
-	let taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath);
-	if (params.progress) {
-		const progressDir =
-			artifactConfig.enabled && artifactsDir
-				? path.join(artifactsDir, "progress", id)
-				: path.join(asyncDir, "progress");
-		writeInitialProgressFile(progressDir);
-		taskWithOutputInstruction = injectSingleProgressInstruction(taskWithOutputInstruction, progressDir);
-	}
-
-	const availableModels = params.availableModels;
-	const knownModelProviders = params.knownModelProviders;
-	const rawModelCandidates = buildModelCandidates(
-		params.modelOverride ?? agentConfig.model,
-		agentConfig.fallbackModels,
-		availableModels,
-		ctx.currentModelProvider,
-		ctx.currentModel,
-		agentConfig.fallbackThinkingLevels,
-	);
-	const filteredCandidates = filterSpawnableModelCandidates({
-		candidates: rawModelCandidates,
-		availableModels,
-		knownModelProviders,
-		currentModel: ctx.currentModel,
-	});
-	if (rawModelCandidates.length > 0 && filteredCandidates.candidates.length === 0) {
-		return formatAsyncStartError("single", "No spawnable subagent model candidates after pre-spawn filtering.");
-	}
-
-	const childAgent = { ...agentConfig, systemPrompt };
-	const result = await runSingleInProcess(runnerCwd, childAgent, taskWithOutputInstruction, {
-		cwd: runnerCwd,
-		runId: id,
-		sessionDir: path.join(sessionRoot ?? asyncDir, "session"),
-		sessionFile,
-		artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-		artifactConfig,
-		maxOutput,
-		outputPath,
-		outputMode,
-		backgroundContinuation: true,
-		maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
-		parentDepth,
-		workflowStageSubagentGuard,
-		workflowSessionMetadata: ctx.workflowSessionMetadata,
-		controlConfig,
-		supervisorAuthorization: params.supervisorAuthorization,
-		intercomSessionName: childIntercomTarget?.(agent, 0),
-		orchestratorIntercomTarget: controlIntercomTarget,
-		intercomGroup: resolveChildIntercomGroup(params.group, ctx.intercomGroup, undefined),
-		modelOverride: filteredCandidates.candidates[0] ?? params.modelOverride ?? agentConfig.model,
-		availableModels,
-		knownModelProviders,
-		preferredModelProvider: ctx.currentModelProvider,
-		currentModel: ctx.currentModel,
-		skills: resolvedSkills.map((skill) => skill.name),
-		testSession: params.testSession,
-		onDetachedExit: (completed) => {
-			const envelope = completed.envelope?.trim() ? completed.envelope : "(no output)";
-			try {
-				ctx.pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
-					id,
-					runId: id,
-					asyncDir,
-					agent,
-					status: completed.status,
-					summary: envelope,
-					envelope,
-					timestamp: Date.now(),
-					sessionFile: completed.sessionFile,
-					results: [
-						{
-							agent,
-							output: envelope,
-							status: completed.status,
-							index: 0,
-							intercomTarget: childIntercomTarget?.(agent, 0),
-						},
-					],
-					result: completed,
-				});
-			} catch (error) {
-				if (!isStaleExtensionContextError(error)) throw error;
-				// A detached child may finish after its parent extension runtime reloads.
-			}
-		},
-	});
-
-	try {
-		ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
-			id,
-			asyncDir,
-			sessionId: result.path,
-			mode: "single",
-			agent,
-			agents: [agent],
-			...(result.model !== undefined ? { model: result.model } : {}),
-			...(result.thinking !== undefined ? { thinking: result.thinking } : {}),
-			...(result.fastMode ? { fastMode: true } : {}),
-		});
-	} catch (error) {
-		if (!isStaleExtensionContextError(error)) throw error;
-		// The launch result remains useful when the captured runtime is stale.
-	}
-	return {
-		content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`) }],
-		details: { mode: "single", runId: id, results: [result], asyncId: id, asyncDir },
-		...(result.status === "error" ? { isError: true } : {}),
-	};
-}

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

@@ -1,90 +0,0 @@
-import type { ExtensionAPI, SessionWorkflowMetadata } from "@bastani/atomic";
-import type { AgentConfig } from "../../agents/agents.ts";
-import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
-import type { ModelInfo } from "../../shared/model-info.ts";
-import type { RunSyncOptions } from "../../shared/types.ts";
-
-export interface AsyncExecutionContext {
-	pi: ExtensionAPI;
-	cwd: string;
-	currentSessionId: string;
-	currentModelProvider?: string;
-	currentModel?: string;
-	intercomGroup?: string;
-	workflowSessionMetadata?: SessionWorkflowMetadata;
-}
-
-export interface AsyncSingleParams {
-	agent: string;
-	task?: string;
-	group?: string | true;
-	agentConfig: AgentConfig;
-	ctx: AsyncExecutionContext;
-	cwd?: string;
-	maxOutput?: { bytes?: number; lines?: number };
-	artifactsDir?: string;
-	artifactConfig: {
-		enabled: boolean;
-		includeInput: boolean;
-		includeOutput: boolean;
-		includeJsonl: boolean;
-		includeMetadata: boolean;
-		cleanupDays: number;
-	};
-	shareEnabled: boolean;
-	sessionRoot?: string;
-	sessionFile?: string;
-	skills?: string[];
-	output?: string | boolean;
-	outputMode?: "inline" | "file-only";
-	progress?: boolean;
-	modelOverride?: string;
-	availableModels?: ModelInfo[];
-	knownModelProviders?: string[];
-	maxSubagentDepth: number;
-	parentDepth?: number;
-	workflowStageSubagentGuard?: boolean;
-	worktreeSetupHook?: string;
-	worktreeSetupHookTimeoutMs?: number;
-	controlConfig?: import("../../shared/types.ts").ResolvedControlConfig;
-	controlIntercomTarget?: string;
-	childIntercomTarget?: (agent: string, index: number) => string | undefined;
-	supervisorAuthorization?: SupervisorAuthorization;
-	nestedRoute?: import("../../shared/types.ts").NestedRouteInfo;
-	/** Internal seam used by focused runtime tests. */
-	testSession?: RunSyncOptions["testSession"];
-}
-
-export interface AsyncExecutionResult {
-	content: Array<{ type: "text"; text: string }>;
-	details: import("../../shared/types.ts").Details;
-	isError?: boolean;
-}
-
-export function formatAsyncStartedMessage(headline: string): string {
-	return [
-		`Launched: ${headline}`,
-		"Completion pending; Atomic will deliver the result when the in-process child finishes.",
-		"",
-		"The async child is tied to the current parent process and does not survive parent exit.",
-		'Use subagent({ action: "status", id: "..." }) when you need the current status/result.',
-	].join("\n");
-}
-
-/** Async execution is always available because it no longer depends on a jiti child process. */
-export function isAsyncAvailable(): boolean {
-	return true;
-}
-
-export function formatAsyncStartError(mode: "single" | "parallel", message: string): AsyncExecutionResult {
-	return {
-		content: [{ type: "text", text: message }],
-		isError: true,
-		details: { mode, results: [] },
-	};
-}
-
-export const UNAVAILABLE_SUBAGENT_SKILL_ERROR = "Skills not found: subagent";
-
-export class UnavailableSubagentSkillError extends Error {}
-export class AsyncStartValidationError extends Error {}

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

@@ -1,247 +0,0 @@
-/**
- * Async job, nested run, and extension state public types.
- */
-
-import type { FSWatcher } from "node:fs";
-import type { ExtensionContext } from "@bastani/atomic";
-import type {
-	ActivityState,
-	ModelAttempt,
-	SingleResult,
-	SubagentResultStatus,
-	SubagentRunMode,
-	TokenUsage,
-} from "./types-results.ts";
-
-// ============================================================================
-// Async Execution
-// ============================================================================
-
-export type NestedRunState = "queued" | "running" | "complete" | "failed" | "paused";
-export type NestedOwnerState = "live" | "gone" | "unknown";
-
-export interface NestedRunAddress {
-	id: string;
-	parentRunId: string;
-	parentStepIndex?: number;
-	parentAgent?: string;
-	depth: number;
-	path: Array<{ runId: string; stepIndex?: number; agent?: string }>;
-}
-
-export interface NestedStepSummary {
-	agent: string;
-	status: "pending" | "running" | "complete" | "completed" | "failed" | "paused";
-	sessionFile?: string;
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	startedAt?: number;
-	endedAt?: number;
-	error?: string;
-	children?: NestedRunSummary[];
-}
-
-export interface NestedRunSummary extends NestedRunAddress {
-	asyncDir?: string;
-	pid?: number;
-	sessionId?: string;
-	sessionFile?: string;
-	intercomTarget?: string;
-	ownerIntercomTarget?: string;
-	leafIntercomTarget?: string;
-	ownerState?: NestedOwnerState;
-	controlInbox?: string;
-	capabilityToken?: string;
-	mode?: SubagentRunMode;
-	state: NestedRunState;
-	agent?: string;
-	agents?: string[];
-	steps?: NestedStepSummary[];
-	children?: NestedRunSummary[];
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	totalTokens?: TokenUsage;
-	startedAt?: number;
-	endedAt?: number;
-	lastUpdate?: number;
-	error?: string;
-}
-
-export interface NestedRouteInfo {
-	rootRunId: string;
-	eventSink: string;
-	controlInbox: string;
-	capabilityToken: string;
-}
-
-export interface AsyncStartedEvent {
-	id?: string;
-	asyncDir?: string;
-	pid?: number;
-	sessionId?: string;
-	mode?: SubagentRunMode;
-	agent?: string;
-	agents?: string[];
-	model?: string;
-	thinking?: string;
-	fastMode?: boolean;
-	nestedRoute?: NestedRouteInfo;
-}
-
-export interface AsyncStatus {
-	runId: string;
-	sessionId?: string;
-	mode: SubagentRunMode;
-	state: "queued" | "running" | "complete" | "failed" | "paused";
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	startedAt: number;
-	endedAt?: number;
-	lastUpdate?: number;
-	pid?: number;
-	cwd?: string;
-	steps?: Array<{
-		agent: string;
-		status: "pending" | "running" | "complete" | "completed" | "failed" | "paused";
-		children?: NestedRunSummary[];
-		sessionFile?: string;
-		activityState?: ActivityState;
-		lastActivityAt?: number;
-		currentTool?: string;
-		currentToolArgs?: string;
-		currentToolStartedAt?: number;
-		currentPath?: string;
-		recentTools?: Array<{ tool: string; args: string; endMs: number }>;
-		recentOutput?: string[];
-		turnCount?: number;
-		toolCount?: number;
-		startedAt?: number;
-		endedAt?: number;
-		durationMs?: number;
-		tokens?: TokenUsage;
-		skills?: string[];
-		model?: string;
-		thinking?: string;
-		fastMode?: boolean;
-		attemptedModels?: string[];
-		modelAttempts?: ModelAttempt[];
-		error?: string;
-	}>;
-	sessionDir?: string;
-	outputFile?: string;
-	totalTokens?: TokenUsage;
-	sessionFile?: string;
-}
-
-export type AsyncJobStep = NonNullable<AsyncStatus["steps"]>[number] & {
-	index?: number;
-};
-
-export interface AsyncJobState {
-	asyncId: string;
-	asyncDir: string;
-	status: "queued" | "running" | "complete" | "failed" | "paused";
-	pid?: number;
-	sessionId?: string;
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	mode?: SubagentRunMode;
-	agents?: string[];
-	steps?: AsyncJobStep[];
-	stepsTotal?: number;
-	runningSteps?: number;
-	completedSteps?: number;
-	activeParallelGroup?: boolean;
-	startedAt?: number;
-	updatedAt?: number;
-	sessionDir?: string;
-	outputFile?: string;
-	totalTokens?: TokenUsage;
-	sessionFile?: string;
-	controlEventCursor?: number;
-	nestedRoute?: NestedRouteInfo;
-	nestedChildren?: NestedRunSummary[];
-}
-
-export interface ForegroundResumeChild {
-	agent: string;
-	index: number;
-	sessionFile?: string;
-	status: SubagentResultStatus;
-	result?: SingleResult;
-	/**
-	 * Effective delegation limit this child ran under. Retained per child because
-	 * edit to the agent definition must not widen a resumed child's budget.
-	 */
-	maxSubagentDepth?: number;
-}
-
-export interface ForegroundResumeRun {
-	runId: string;
-	mode: SubagentRunMode;
-	cwd: string;
-	updatedAt: number;
-	children: ForegroundResumeChild[];
-}
-
-export interface SubagentState {
-	baseCwd: string;
-	currentSessionId: string | null;
-	asyncJobs: Map<string, AsyncJobState>;
-	subagentInProgress?: boolean;
-	foregroundRuns?: Map<string, ForegroundResumeRun>;
-	foregroundControls: Map<
-		string,
-		{
-			runId: string;
-			mode: SubagentRunMode;
-			startedAt: number;
-			updatedAt: number;
-			currentAgent?: string;
-			currentIndex?: number;
-			currentActivityState?: ActivityState;
-			lastActivityAt?: number;
-			currentTool?: string;
-			currentToolStartedAt?: number;
-			currentPath?: string;
-			turnCount?: number;
-			tokens?: number;
-			toolCount?: number;
-			nestedRoute?: NestedRouteInfo;
-			nestedChildren?: NestedRunSummary[];
-			interrupt?: () => boolean;
-		}
-	>;
-	lastForegroundControlId: string | null;
-	pendingForegroundControlNotices?: Map<string, ReturnType<typeof setTimeout>>;
-	cleanupTimers: Map<string, ReturnType<typeof setTimeout>>;
-	lastUiContext: ExtensionContext | null;
-	poller: NodeJS.Timeout | null;
-	completionSeen: Map<string, number | { seenAt: number; signature?: string }>;
-	watcher: FSWatcher | null;
-	watcherRestartTimer: ReturnType<typeof setTimeout> | null;
-	resultFileCoalescer: {
-		schedule(file: string, delayMs?: number): boolean;
-		clear(): void;
-	};
-}