@bastani/atomic 0.9.12 → 0.9.13-alpha.1

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

@@ -0,0 +1,89 @@
+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;
+	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" | "chain", 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/runs/inprocess/child-policy.ts

@@ -0,0 +1,27 @@
+import type { SubagentChildPolicy } from "@bastani/atomic";
+
+export type ChildModePolicy = SubagentChildPolicy;
+
+/**
+ * Resolve the child-mode capabilities at the in-process admission door.
+ *
+ * Every admitted child is management-restricted. Fanout is granted only when
+ * the admitted tool allowlist explicitly includes the subagent tool; an
+ * omitted allowlist cannot widen a descendant's capabilities.
+ */
+export function resolveChildModePolicy(spec: {
+	readonly tools?: readonly string[];
+	readonly agent: {
+		readonly tools?: readonly string[];
+		readonly inheritProjectContext: boolean;
+		readonly inheritSkills: boolean;
+	};
+}): ChildModePolicy {
+	const tools = spec.tools ?? spec.agent.tools;
+	return {
+		managementActions: "restricted",
+		fanoutAuthorized: tools?.includes("subagent") === true,
+		inheritProjectContext: spec.agent.inheritProjectContext,
+		inheritSkills: spec.agent.inheritSkills,
+	};
+}

package/dist/builtin/subagents/src/runs/inprocess/control-registry.ts

@@ -0,0 +1,55 @@
+import type { ChildIdentity } from "@bastani/atomic-natives";
+import { createSubagentControl, type ParentContext, type SubagentControlRuntime } from "./runner.ts";
+
+/**
+ * Host-local registry for the Rust control planes owned by the current Atomic
+ * session. The native registry remains authoritative for child identity and
+ * status; this map only lets management actions find the corresponding
+ * in-process runtime without a file-backed run directory.
+ */
+const controls = new Map<string, SubagentControlRuntime>();
+
+export function registerSubagentControl(control: SubagentControlRuntime): void {
+	controls.set(control.parent.path, control);
+}
+
+export function getOrCreateSubagentControl(parent: ParentContext, sessionRoot: string): SubagentControlRuntime {
+	const existing = controls.get(parent.path);
+	// The control plane is parent-scoped. Parallel callers pass their per-child
+	// session directories here, but those storage paths must not split identity
+	// allocation across fresh native registries.
+	if (existing) return existing;
+	const control = createSubagentControl(parent, sessionRoot);
+	controls.set(parent.path, control);
+	return control;
+}
+
+export function unregisterSubagentControl(control: SubagentControlRuntime): void {
+	if (controls.get(control.parent.path) === control) controls.delete(control.parent.path);
+}
+
+export function findSubagentControl(id: string): SubagentControlRuntime | undefined {
+	const direct = controls.get(id);
+	if (direct) return direct;
+	for (const control of controls.values()) {
+		if (control.native.listChildren().some((child) => child.path === id)) return control;
+	}
+	return undefined;
+}
+
+export function listSubagentControls(): readonly SubagentControlRuntime[] {
+	return [...controls.values()];
+}
+
+export function findChildIdentity(
+	id: string,
+): { control: SubagentControlRuntime; identity: ChildIdentity } | undefined {
+	const control = findSubagentControl(id);
+	if (!control) return undefined;
+	const identity = control.native.listChildren().find((child) => child.path === id);
+	return identity ? { control, identity } : undefined;
+}
+
+export function clearSubagentControls(): void {
+	controls.clear();
+}

package/dist/builtin/subagents/src/runs/inprocess/control-status.ts

@@ -0,0 +1,106 @@
+import type { SubagentToolResult } from "../../shared/types.ts";
+import { findSubagentControl, listSubagentControls } from "./control-registry.ts";
+import type { ModelCandidate } from "./runner.ts";
+
+function canonicalChildren(control: NonNullable<ReturnType<typeof findSubagentControl>>) {
+	return [...control.listChildren()].sort((left, right) => left.path.localeCompare(right.path));
+}
+
+function resumeTarget(control: NonNullable<ReturnType<typeof findSubagentControl>>, id: string) {
+	if (id !== control.parent.path) return control.findChild(id);
+	const children = canonicalChildren(control);
+	return children.find((child) => child.status === "interrupted") ?? children[0];
+}
+
+function childLines(control: ReturnType<typeof findSubagentControl>, id?: string): string[] {
+	if (!control) return [];
+	if (id) {
+		const child = control.findChild(id);
+		if (!child) return [];
+		const delivered = control.getDeliveredResult(id);
+		return [
+			`Child: ${child.path}`,
+			`Parent: ${child.parentPath}`,
+			`Task: ${child.taskName}`,
+			`Depth: ${child.depth}`,
+			`Status: ${child.status}`,
+			`Residency: ${child.loaded ? "loaded" : "cold"}`,
+			...(delivered?.sessionFile ? [`Session: ${delivered.sessionFile}`] : []),
+		];
+	}
+	return control
+		.listChildren()
+		.map((child) => `${child.path} — ${child.status} (${child.loaded ? "loaded" : "cold"})`);
+}
+
+export function inspectInProcessChildStatus(id?: string): SubagentToolResult | undefined {
+	if (id) {
+		const control = findSubagentControl(id);
+		if (!control) return undefined;
+		const text =
+			id === control.parent.path
+				? [`Parent: ${control.parent.path}`, ...childLines(control)].join("\n")
+				: childLines(control, id).join("\n");
+		if (!text) return undefined;
+		return {
+			content: [{ type: "text", text }],
+			details: { mode: "management", results: [] },
+		};
+	}
+	const lines = listSubagentControls().flatMap((control) => [
+		`Parent: ${control.parent.path}`,
+		...childLines(control),
+	]);
+	if (lines.length === 0) return undefined;
+	return {
+		content: [{ type: "text", text: lines.join("\n") }],
+		details: { mode: "management", results: [] },
+	};
+}
+
+export async function interruptInProcessChild(id: string): Promise<SubagentToolResult | undefined> {
+	const control = findSubagentControl(id);
+	if (!control) return undefined;
+	const identities = canonicalChildren(control);
+	const candidates = id === control.parent.path ? identities : identities.filter((child) => child.path === id);
+	for (const child of candidates) {
+		if (await control.interruptChild(child.path)) {
+			return {
+				content: [{ type: "text", text: `Interrupt requested for in-process child ${child.path}.` }],
+				details: { mode: "management", results: [] },
+			};
+		}
+	}
+	return {
+		content: [{ type: "text", text: `No running in-process child found for '${id}'.` }],
+		isError: true,
+		details: { mode: "management", results: [] },
+	};
+}
+
+export async function resumeInProcessChild(
+	id: string,
+	message: string,
+	candidate: ModelCandidate,
+): Promise<SubagentToolResult | undefined> {
+	const control = findSubagentControl(id);
+	if (!control) return undefined;
+	const target = resumeTarget(control, id);
+	if (!target) {
+		return {
+			content: [{ type: "text", text: `No in-process child found for '${id}'.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	const outcome = await control.resumeChild(target.path, message, candidate);
+	const selection =
+		id === control.parent.path && control.listChildren().length > 1
+			? `Bare run id resolved to ${target.path}; interrupted children are preferred, then canonical path order.\n\n`
+			: "";
+	return {
+		content: [{ type: "text", text: `${selection}${outcome.envelope}` }],
+		isError: outcome.status === "error" || outcome.status === "interrupted" ? true : undefined,
+		details: { mode: "management", results: [] },
+	};
+}

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

@@ -0,0 +1,50 @@
+export {
+	appendInProcessControlRequest,
+	appendInProcessControlResult,
+	appendInProcessNestedEvent,
+	clearInProcessNestedRouting,
+	hasInProcessNestedRoute,
+	interruptInProcessNestedAttempt,
+	readInProcessControlRequests,
+	readInProcessControlResults,
+	readInProcessNestedEvents,
+	registerInProcessNestedAttempt,
+	registerInProcessNestedRoute,
+	removeInProcessControlRequest,
+	resumeInProcessNestedAttempt,
+	subscribeInProcessControlRequests,
+	unregisterInProcessNestedRoute,
+} from "./nested-routing.ts";
+export type {
+	AdmissionRefusal,
+	AdmittedResult,
+	AttemptOutcome,
+	AttemptSignals,
+	AttemptStats,
+	ChildPolicy,
+	ChildSpec,
+	ChildStatus,
+	ContinuationReason,
+	InProcessControlRequest,
+	InProcessControlResult,
+	InProcessNestedAttemptHandle,
+	InProcessNestedResumeOutcome,
+	InProcessNestedRouteKey,
+	ModelCandidate,
+	ParentContext,
+	ResultEnvelope,
+	RunningAttempt,
+	TerminalStatus,
+	TerminationCauseName,
+} from "./runner.ts";
+export {
+	AdmittedChild,
+	admit_child_session,
+	continue_in_background,
+	createSubagentControl,
+	deliver_child_result,
+	reload_cold_child,
+	run_child_attempt,
+	SubagentControlRuntime,
+	terminate_child_attempt,
+} from "./runner.ts";

package/dist/builtin/subagents/src/runs/inprocess/nested-routing.ts

@@ -0,0 +1,218 @@
+/**
+ * In-process nested routing and control registry.
+ *
+ * Routes still expose the file-backed shape for compatibility with cold starts and
+ * older sessions, but a live host registers the same route here. Live children are
+ * addressed by their run id or canonical task path, so control never needs a
+ * request file, an inherited capability-token environment variable, or a poller.
+ */
+
+export interface InProcessNestedRouteKey {
+	readonly rootRunId: string;
+	readonly capabilityToken: string;
+}
+
+export interface InProcessControlRequest {
+	readonly type: "subagent.nested.control-request";
+	readonly rootRunId: string;
+	readonly capabilityToken: string;
+	readonly ts: number;
+	readonly requestId: string;
+	readonly targetRunId: string;
+	readonly action: "interrupt" | "resume";
+	readonly message?: string;
+	readonly filePath: string;
+}
+
+export interface InProcessControlResult {
+	readonly ts: number;
+	readonly requestId: string;
+	readonly targetRunId: string;
+	readonly ok: boolean;
+	readonly message: string;
+	readonly filePath?: string;
+}
+
+export interface InProcessNestedResumeOutcome {
+	readonly status: "ok" | "error" | "interrupted" | "continued";
+	readonly path: string;
+	readonly sessionFile?: string;
+	readonly envelope?: string;
+}
+
+export interface InProcessNestedAttemptHandle {
+	readonly runId: string;
+	readonly path: string;
+	readonly status: () => string;
+	readonly interrupt: () => Promise<void>;
+	readonly resume: (message: string) => Promise<InProcessNestedResumeOutcome>;
+}
+
+interface RouteState {
+	readonly key: InProcessNestedRouteKey;
+	readonly events: object[];
+	readonly controlRequests: Map<string, InProcessControlRequest>;
+	readonly controlResults: Map<string, InProcessControlResult>;
+	readonly listeners: Set<(request: InProcessControlRequest) => void | Promise<void>>;
+}
+
+const routeStates = new Map<string, RouteState>();
+const attemptHandles = new Map<string, Map<string, InProcessNestedAttemptHandle>>();
+
+function routeKey(route: InProcessNestedRouteKey): string {
+	return `${route.rootRunId}\u0000${route.capabilityToken}`;
+}
+
+function attemptKey(id: string): string {
+	return id.trim();
+}
+
+function stateFor(route: InProcessNestedRouteKey): RouteState | undefined {
+	return routeStates.get(routeKey(route));
+}
+
+export function registerInProcessNestedRoute(route: InProcessNestedRouteKey): void {
+	const key = routeKey(route);
+	if (!routeStates.has(key)) {
+		routeStates.set(key, {
+			key: { rootRunId: route.rootRunId, capabilityToken: route.capabilityToken },
+			events: [],
+			controlRequests: new Map(),
+			controlResults: new Map(),
+			listeners: new Set(),
+		});
+	}
+}
+
+export function unregisterInProcessNestedRoute(route: InProcessNestedRouteKey): void {
+	routeStates.delete(routeKey(route));
+}
+
+export function hasInProcessNestedRoute(route: InProcessNestedRouteKey): boolean {
+	return stateFor(route) !== undefined;
+}
+
+export function appendInProcessNestedEvent(route: InProcessNestedRouteKey, event: object): void {
+	const state = stateFor(route);
+	if (!state) return;
+	state.events.push(event);
+	if (state.events.length > 20_000) state.events.splice(0, state.events.length - 20_000);
+}
+
+export function readInProcessNestedEvents(route: InProcessNestedRouteKey): readonly object[] {
+	return stateFor(route)?.events ?? [];
+}
+
+export function appendInProcessControlRequest(route: InProcessNestedRouteKey, request: InProcessControlRequest): void {
+	const state = stateFor(route);
+	if (!state) return;
+	state.controlRequests.set(request.requestId, request);
+	for (const listener of state.listeners) queueMicrotask(() => void listener(request));
+}
+
+export function readInProcessControlRequests(route: InProcessNestedRouteKey): readonly InProcessControlRequest[] {
+	return stateFor(route) ? [...stateFor(route)!.controlRequests.values()] : [];
+}
+
+export function removeInProcessControlRequest(route: InProcessNestedRouteKey, requestId: string): void {
+	stateFor(route)?.controlRequests.delete(requestId);
+}
+
+export function appendInProcessControlResult(route: InProcessNestedRouteKey, result: InProcessControlResult): void {
+	const state = stateFor(route);
+	if (!state) return;
+	state.controlResults.set(result.requestId, result);
+}
+
+export function readInProcessControlResults(route: InProcessNestedRouteKey): readonly InProcessControlResult[] {
+	return stateFor(route) ? [...stateFor(route)!.controlResults.values()] : [];
+}
+
+export function subscribeInProcessControlRequests(
+	route: InProcessNestedRouteKey,
+	listener: (request: InProcessControlRequest) => void | Promise<void>,
+): (() => void) | undefined {
+	const state = stateFor(route);
+	if (!state) return undefined;
+	state.listeners.add(listener);
+	for (const request of state.controlRequests.values()) queueMicrotask(() => void listener(request));
+	return () => state.listeners.delete(listener);
+}
+
+export function registerInProcessNestedAttempt(handle: InProcessNestedAttemptHandle): () => void {
+	const key = attemptKey(handle.runId);
+	let handles = attemptHandles.get(key);
+	if (!handles) {
+		handles = new Map();
+		attemptHandles.set(key, handles);
+	}
+	handles.set(handle.path, handle);
+	const pathKey = attemptKey(handle.path);
+	if (pathKey !== key) {
+		let byPath = attemptHandles.get(pathKey);
+		if (!byPath) {
+			byPath = new Map();
+			attemptHandles.set(pathKey, byPath);
+		}
+		byPath.set(handle.path, handle);
+	}
+	return () => {
+		for (const lookupKey of [key, pathKey]) {
+			const current = attemptHandles.get(lookupKey);
+			if (!current || current.get(handle.path) !== handle) continue;
+			current.delete(handle.path);
+			if (current.size === 0) attemptHandles.delete(lookupKey);
+		}
+	};
+}
+
+function handlesFor(id: string): InProcessNestedAttemptHandle[] {
+	return [...(attemptHandles.get(attemptKey(id))?.values() ?? [])];
+}
+
+export interface InProcessNestedControlResult {
+	readonly ok: boolean;
+	readonly message: string;
+	readonly outcome?: InProcessNestedResumeOutcome;
+}
+
+export async function interruptInProcessNestedAttempt(
+	targetId: string,
+): Promise<InProcessNestedControlResult | undefined> {
+	const handles = handlesFor(targetId);
+	if (handles.length === 0) return undefined;
+	const active = handles.filter((handle) => handle.status() === "running" || handle.status() === "continued");
+	if (active.length === 0) {
+		return { ok: false, message: `Nested run ${targetId} has no active child attempt to interrupt.` };
+	}
+	await Promise.all(active.map((handle) => handle.interrupt()));
+	return { ok: true, message: `Interrupt requested for nested run ${targetId}.` };
+}
+
+export async function resumeInProcessNestedAttempt(
+	targetId: string,
+	message: string,
+): Promise<InProcessNestedControlResult | undefined> {
+	const handles = handlesFor(targetId);
+	if (handles.length === 0) return undefined;
+	const handle =
+		handles.find((candidate) => candidate.status() === "interrupted" || candidate.status() === "error") ?? handles[0];
+	if (!handle) return undefined;
+	if (handle.status() === "running" || handle.status() === "continued") {
+		return { ok: false, message: `Nested run ${targetId} is still running; resume is not required.` };
+	}
+	const outcome = await handle.resume(message);
+	return {
+		ok: outcome.status === "ok" || outcome.status === "continued",
+		message:
+			outcome.status === "ok"
+				? `Reloaded nested run ${targetId} through the in-process control plane.`
+				: `Nested run ${targetId} resume ended with status '${outcome.status}'.`,
+		outcome,
+	};
+}
+
+export function clearInProcessNestedRouting(): void {
+	routeStates.clear();
+	attemptHandles.clear();
+}