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

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

@@ -4,7 +4,8 @@
 
 import type { SessionWorkflowMetadata } from "@bastani/atomic";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { NestedRouteInfo } from "./types-async.ts";
+import type { CandidateModelResolver } from "./model-resolution.ts";
+import type { NestedRouteInfo } from "./types-nested.ts";
 import type {
 	ArtifactConfig,
 	ControlConfig,
@@ -41,9 +42,8 @@ export interface IntercomEventBus {
 }
 
 export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
+export const SUBAGENT_COMPLETE_EVENT = "subagent:complete";
 export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
-export const SUBAGENT_ASYNC_STARTED_EVENT = "subagent:async-started";
-export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
 export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
 export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
 export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
@@ -59,8 +59,6 @@ export interface RunSyncOptions {
 	signal?: AbortSignal;
 	interruptSignal?: AbortSignal;
 	allowIntercomDetach?: boolean;
-	/** Start the admitted child and settle this call with a continued result immediately. */
-	backgroundContinuation?: boolean;
 	intercomEvents?: IntercomEventBus;
 	onDetachedExit?: (result: SingleResult) => void;
 	/** Shared foreground-group signal used to release sibling supervision after one exact child commits Intercom detach. */
@@ -87,8 +85,6 @@ export interface RunSyncOptions {
 	index?: number;
 	sessionDir?: string;
 	sessionFile?: string;
-	/** Override the Atomic CLI entrypoint used by foreground child processes. */
-	piArgv1?: string;
 	share?: boolean;
 	outputPath?: string;
 	outputMode?: OutputMode;
@@ -104,6 +100,13 @@ export interface RunSyncOptions {
 	availableModels?: Array<{ provider: string; id: string; fullId: string }>;
 	/** Providers known to the registry before auth filtering */
 	knownModelProviders?: string[];
+	/**
+	 * Resolve the selected `provider/model[:thinking]` candidate to a concrete
+	 * registry model. Without it the child session receives no model and a
+	 * fork-context child silently runs on the model restored from the parent's
+	 * session file.
+	 */
+	resolveCandidateModel?: CandidateModelResolver;
 	/** Current parent-session provider to prefer for ambiguous bare model ids */
 	preferredModelProvider?: string;
 	/** Current parent-session model to try after configured fallback models */
@@ -144,8 +147,6 @@ interface TopLevelParallelConfig {
 }
 
 export interface ExtensionConfig {
-	asyncByDefault?: boolean;
-	forceTopLevelAsync?: boolean;
 	defaultSessionDir?: string;
 	maxSubagentDepth?: number;
 	control?: ControlConfig;

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

@@ -0,0 +1,127 @@
+/**
+ * Nested foreground run and extension state public types.
+ */
+
+import type { ExtensionContext } from "@bastani/atomic";
+import type {
+	ActivityState,
+	SingleResult,
+	SubagentResultStatus,
+	SubagentRunMode,
+	TokenUsage,
+} from "./types-results.ts";
+
+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 {
+	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 ForegroundResumeChild {
+	agent: string;
+	index: number;
+	sessionFile?: string;
+	status: SubagentResultStatus;
+	result?: SingleResult;
+	/** Effective delegation limit retained for a resumed child. */
+	maxSubagentDepth?: number;
+}
+
+export interface ForegroundResumeRun {
+	runId: string;
+	mode: SubagentRunMode;
+	cwd: string;
+	updatedAt: number;
+	children: ForegroundResumeChild[];
+}
+
+export interface SubagentState {
+	baseCwd: string;
+	currentSessionId: string | null;
+	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>>;
+	lastUiContext: ExtensionContext | null;
+}

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

@@ -5,7 +5,7 @@
 import type { SessionStats } from "@bastani/atomic";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Message } from "@earendil-works/pi-ai/compat";
-import type { NestedRunAddress, NestedRunSummary, NestedStepSummary } from "./types-async.ts";
+import type { NestedRunAddress, NestedRunSummary, NestedStepSummary } from "./types-nested.ts";
 
 export interface MaxOutputConfig {
 	bytes?: number;
@@ -46,7 +46,7 @@ export interface TokenUsage {
 
 export type ActivityState = "active_long_running" | "needs_attention";
 export type ControlEventType = "active_long_running" | "needs_attention";
-export type ControlNotificationChannel = "event" | "async" | "intercom";
+export type ControlNotificationChannel = "event" | "intercom";
 
 export interface ControlConfig {
 	enabled?: boolean;
@@ -122,7 +122,6 @@ export type PublicNestedRunSummary = Pick<
 	| "parentAgent"
 	| "depth"
 	| "path"
-	| "asyncDir"
 	| "sessionId"
 	| "sessionFile"
 	| "intercomTarget"
@@ -169,10 +168,7 @@ export interface SubagentResultIntercomPayload {
 	mode: SubagentRunMode;
 	status: SubagentResultStatus;
 	summary: string;
-	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
-	asyncId?: string;
-	asyncDir?: string;
 	agent?: string;
 	index?: number;
 	artifactPath?: string;
@@ -278,8 +274,6 @@ export interface Details {
 	context?: "fresh" | "fork";
 	results: SingleResult[];
 	controlEvents?: ControlEvent[];
-	asyncId?: string;
-	asyncDir?: string;
 	progress?: AgentProgress[];
 	totalSteps?: number;
 	progressSummary?: ProgressSummary;

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

@@ -74,18 +74,13 @@ export function resolveTempScopeId(options?: {
 export const MAX_PARALLEL_TASKS = 50;
 export const MAX_CONCURRENCY = 4;
 export const TEMP_ROOT_DIR = path.join(os.tmpdir(), `${APP_NAME}-subagents-${resolveTempScopeId()}`);
-export const RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
-export const ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs");
 export const TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts");
-export const WIDGET_KEY = "subagent-async";
 export const SLASH_RESULT_TYPE = "subagent-slash-result";
 export const SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request";
 export const SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started";
 export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
 export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
 export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
-export const POLL_INTERVAL_MS = 250;
-export const MAX_WIDGET_JOBS = 4;
 export const MAX_SUBAGENT_NESTING_DEPTH = 5;
 export const DEFAULT_SUBAGENT_MAX_DEPTH = MAX_SUBAGENT_NESTING_DEPTH;
 export const SUBAGENT_ACTIONS = [
@@ -121,10 +116,6 @@ export function resolveTopLevelParallelConcurrency(override: unknown, configValu
 	return normalizeTopLevelParallelValue(override) ?? normalizeTopLevelParallelValue(configValue) ?? MAX_CONCURRENCY;
 }
 
-export function getAsyncConfigPath(suffix: string): string {
-	return path.join(TEMP_ROOT_DIR, `async-cfg-${suffix}.json`);
-}
-
 export function wrapForkTask(task: string, preamble?: string | false): string {
 	if (preamble === false) return task;
 	const effectivePreamble = preamble ?? DEFAULT_FORK_PREAMBLE;

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

@@ -5,9 +5,9 @@
  * focused sibling modules that hold the concrete type groups and helpers.
  */
 
-export * from "./types-async.ts";
 export * from "./types-config.ts";
 export * from "./types-depth.ts";
+export * from "./types-nested.ts";
 export * from "./types-output.ts";
 export * from "./types-results.ts";
 export * from "./types-runtime.ts";

package/dist/builtin/subagents/src/shared/utils.ts

@@ -2,20 +2,11 @@
  * General utility functions for the subagent extension
  */
 
-import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir as getAtomicAgentDir } from "@bastani/atomic";
 import type { Message } from "@earendil-works/pi-ai/compat";
 import { formatToolCall } from "./formatters.ts";
-import type {
-	AgentProgress,
-	AsyncStatus,
-	Details,
-	DisplayItem,
-	ErrorInfo,
-	SingleResult,
-	ToolCallSummary,
-} from "./types.ts";
+import type { AgentProgress, Details, DisplayItem, ErrorInfo, SingleResult, ToolCallSummary } from "./types.ts";
 
 // ============================================================================
 // File System Utilities
@@ -25,110 +16,11 @@ export function getAgentDir(): string {
 	return getAtomicAgentDir();
 }
 
-const statusCache = new Map<string, { mtime: number; status: AsyncStatus }>();
-
-function getErrorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
 export function resolveChildCwd(baseCwd: string, childCwd: string | undefined): string {
 	if (!childCwd) return baseCwd;
 	return path.isAbsolute(childCwd) ? childCwd : path.resolve(baseCwd, childCwd);
 }
 
-function isNotFoundError(error: unknown): boolean {
-	return (
-		typeof error === "object" &&
-		error !== null &&
-		"code" in error &&
-		(error as NodeJS.ErrnoException).code === "ENOENT"
-	);
-}
-
-/**
- * Read async job status from disk (with mtime-based caching)
- */
-export function readStatus(asyncDir: string): AsyncStatus | null {
-	const statusPath = path.join(asyncDir, "status.json");
-
-	let stat: fs.Stats;
-	try {
-		stat = fs.statSync(statusPath);
-	} catch (error) {
-		if (isNotFoundError(error)) return null;
-		throw new Error(`Failed to inspect async status file '${statusPath}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-
-	const cached = statusCache.get(statusPath);
-	if (cached && cached.mtime === stat.mtimeMs) {
-		return cached.status;
-	}
-
-	let content: string;
-	try {
-		content = fs.readFileSync(statusPath, "utf-8");
-	} catch (error) {
-		if (isNotFoundError(error)) return null;
-		throw new Error(`Failed to read async status file '${statusPath}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-
-	let status: AsyncStatus;
-	try {
-		status = JSON.parse(content) as AsyncStatus;
-	} catch (error) {
-		throw new Error(`Failed to parse async status file '${statusPath}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-
-	statusCache.set(statusPath, { mtime: stat.mtimeMs, status });
-	if (statusCache.size > 50) {
-		const firstKey = statusCache.keys().next().value;
-		if (firstKey) statusCache.delete(firstKey);
-	}
-	return status;
-}
-
-/**
- * Get human-readable last activity time for a file
- */
-export function getLastActivity(outputFile: string | undefined): string {
-	if (!outputFile) return "";
-	try {
-		const stat = fs.statSync(outputFile);
-		const ago = Date.now() - stat.mtimeMs;
-		if (ago < 1000) return "active now";
-		if (ago < 60000) return `active ${Math.floor(ago / 1000)}s ago`;
-		return `active ${Math.floor(ago / 60000)}m ago`;
-	} catch {
-		// Last-activity text is best effort; missing files should simply omit the hint.
-		return "";
-	}
-}
-
-/**
- * Find the latest session file in a directory
- */
-export function findLatestSessionFile(sessionDir: string): string | null {
-	if (!fs.existsSync(sessionDir)) return null;
-	const files = fs
-		.readdirSync(sessionDir)
-		.filter((f) => f.endsWith(".jsonl"))
-		.map((f) => {
-			const filePath = path.join(sessionDir, f);
-			return {
-				path: filePath,
-				mtime: fs.statSync(filePath).mtimeMs,
-			};
-		})
-		.sort((a, b) => b.mtime - a.mtime);
-	return files.length > 0 ? files[0].path : null;
-}
-
 // ============================================================================
 // Message Parsing Utilities
 // ============================================================================

package/dist/builtin/subagents/src/slash/slash-commands.ts

@@ -80,17 +80,10 @@ const parseAgentToken = (token: string): { name: string; config: InlineConfig }
 	};
 };
 
-const extractExecutionFlags = (rawArgs: string): { args: string; bg: boolean; fork: boolean } => {
+const extractExecutionFlags = (rawArgs: string): { args: string; fork: boolean } => {
 	let args = rawArgs.trim();
-	let bg = false;
 	let fork = false;
-
 	while (true) {
-		if (args.endsWith(" --bg") || args === "--bg") {
-			bg = true;
-			args = args === "--bg" ? "" : args.slice(0, -5).trim();
-			continue;
-		}
 		if (args.endsWith(" --fork") || args === "--fork") {
 			fork = true;
 			args = args === "--fork" ? "" : args.slice(0, -7).trim();
@@ -98,8 +91,7 @@ const extractExecutionFlags = (rawArgs: string): { args: string; bg: boolean; fo
 		}
 		break;
 	}
-
-	return { args, bg, fork };
+	return { args, fork };
 };
 
 const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (prefix: string) => {
@@ -413,14 +405,14 @@ const parseAgentArgs = (
 };
 export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): void {
 	pi.registerCommand("run", {
-		description: "Run a subagent directly: /run agent[output=file] [task] [--bg] [--fork]",
+		description: "Run a subagent directly: /run agent[output=file] [task] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(state, false),
 		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
+			const { args: cleanedArgs, fork } = extractExecutionFlags(args);
 			const input = cleanedArgs.trim();
 			const firstSpace = input.indexOf(" ");
 			if (!input) {
-				ctx.ui.notify("Usage: /run <agent> [task] [--bg] [--fork]", "error");
+				ctx.ui.notify("Usage: /run <agent> [task] [--fork]", "error");
 				return;
 			}
 			const { name: agentName, config: inline } = parseAgentToken(
@@ -442,16 +434,15 @@ export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): v
 			if (inline.outputMode !== undefined) params.outputMode = inline.outputMode;
 			if (inline.skill !== undefined) params.skill = inline.skill;
 			if (inline.model) params.model = inline.model;
-			if (bg) params.async = true;
 			if (fork) params.context = "fork";
 			await runSlashSubagent(pi, ctx, params);
 		},
 	});
 	pi.registerCommand("parallel", {
-		description: 'Run agents in parallel: /parallel scout "task1" -> reviewer "task2" [--bg] [--fork]',
+		description: 'Run agents in parallel: /parallel scout "task1" -> reviewer "task2" [--fork]',
 		getArgumentCompletions: makeAgentCompletions(state, true),
 		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
+			const { args: cleanedArgs, fork } = extractExecutionFlags(args);
 			const parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
 			if (!parsed) return;
 			const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
@@ -465,7 +456,6 @@ export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): v
 				...(config.progress !== undefined ? { progress: config.progress } : {}),
 			}));
 			const params: SubagentParamsLike = { tasks, agentScope: "both" };
-			if (bg) params.async = true;
 			if (fork) params.context = "fork";
 			await runSlashSubagent(pi, ctx, params);
 		},