@bastani/atomic 0.9.12 → 0.9.13-alpha.1

package/dist/builtin/subagents/src/runs/{shared/nested-events.ts → inprocess/runtime-support/nested-api.ts}

@@ -6,14 +6,14 @@ export {
 	readNestedControlResults,
 	writeNestedControlRequest,
 	writeNestedControlResult,
-} from "./nested-events-control.ts";
+} from "./nested-control.ts";
 export type {
 	NestedControlRequestRecord,
 	NestedControlResultRecord,
 	NestedEventRecord,
 	NestedRegistry,
 	NestedRoute,
-} from "./nested-events-core.ts";
+} from "./nested-core.ts";
 export {
 	assertSafeNestedId,
 	cleanupOldNestedRuntimeDirs,
@@ -31,7 +31,13 @@ export {
 	resolveNestedParentAddressFromEnv,
 	resolveNestedRouteFromEnv,
 	validateNestedRouteShape,
-} from "./nested-events-core.ts";
+} from "./nested-core.ts";
+export {
+	encodeNestedPathEnv,
+	MAX_NESTED_PATH_ENTRIES,
+	parseNestedPathEnv,
+	sanitizeNestedPath,
+} from "./nested-paths.ts";
 export {
 	attachRootChildrenToSteps,
 	hasLiveNestedDescendants,
@@ -41,8 +47,8 @@ export {
 	nestedSummaryFromAsyncStatus,
 	updateAsyncJobNestedProjection,
 	updateForegroundNestedProjection,
-} from "./nested-events-projection.ts";
-export type { NestedRunMatch, NestedRunResolutionScope } from "./nested-events-registry.ts";
+} from "./nested-projection.ts";
+export type { NestedRunMatch, NestedRunResolutionScope } from "./nested-registry.ts";
 export {
 	findNestedRouteForRootId,
 	findNestedRun,
@@ -52,5 +58,5 @@ export {
 	projectNestedRegistryForRoot,
 	readNestedRegistry,
 	writeNestedEvent,
-} from "./nested-events-registry.ts";
-export { applyNestedEvent, parseNestedEventRecords, sanitizeSummary } from "./nested-events-sanitize.ts";
+} from "./nested-registry.ts";
+export { applyNestedEvent, parseNestedEventRecords, sanitizeSummary } from "./nested-sanitize.ts";

package/dist/builtin/subagents/src/runs/{shared/nested-events-control.ts → inprocess/runtime-support/nested-control.ts}

@@ -1,5 +1,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import {
+	appendInProcessControlRequest,
+	appendInProcessControlResult,
+	hasInProcessNestedRoute,
+	readInProcessControlRequests,
+	readInProcessControlResults,
+} from "../nested-routing.ts";
 import {
 	assertSafeId,
 	clampNumber,
@@ -11,14 +18,8 @@ import {
 	type NestedRoute,
 	stringValue,
 	validateRouteShape,
-} from "./nested-events-core.ts";
-import { writeRouteRecord } from "./nested-events-registry.ts";
-import {
-	SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV,
-	SUBAGENT_PARENT_CONTROL_INBOX_ENV,
-	SUBAGENT_PARENT_EVENT_SINK_ENV,
-	SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
-} from "./pi-args.ts";
+} from "./nested-core.ts";
+import { writeRouteRecord } from "./nested-registry.ts";
 
 export function parseNestedControlRequest(content: string, route: NestedRoute): NestedControlRequestRecord | undefined {
 	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES) return undefined;
@@ -90,13 +91,16 @@ export function writeNestedControlRequest(
 	};
 	const sanitized = parseNestedControlRequest(JSON.stringify(record), route);
 	if (!sanitized) throw new Error("Nested control request failed validation.");
-	return writeRouteRecord(route.controlInbox, sanitized.ts, sanitized);
+	const filePath = writeRouteRecord(route.controlInbox, sanitized.ts, sanitized);
+	appendInProcessControlRequest(route, { ...sanitized, filePath });
+	return filePath;
 }
 
 export function readNestedControlRequests(
 	route: NestedRoute,
 ): Array<NestedControlRequestRecord & { filePath: string }> {
 	validateRouteShape(route);
+	if (hasInProcessNestedRoute(route)) return [...readInProcessControlRequests(route)];
 	let entries: string[] = [];
 	try {
 		entries = fs
@@ -135,11 +139,13 @@ export function writeNestedControlResult(
 	};
 	const sanitized = parseNestedControlResult(JSON.stringify(record), route);
 	if (!sanitized) throw new Error("Nested control result failed validation.");
-	writeRouteRecord(route.eventSink, sanitized.ts, sanitized);
+	const filePath = writeRouteRecord(route.eventSink, sanitized.ts, sanitized);
+	appendInProcessControlResult(route, { ...sanitized, filePath });
 }
 
 export function readNestedControlResults(route: NestedRoute): NestedControlResultRecord[] {
 	validateRouteShape(route);
+	if (hasInProcessNestedRoute(route)) return [...readInProcessControlResults(route)] as NestedControlResultRecord[];
 	let entries: string[] = [];
 	try {
 		entries = fs
@@ -167,11 +173,6 @@ export function readNestedControlResults(route: NestedRoute): NestedControlResul
 	return results;
 }
 
-export function nestedRouteEnv(route: NestedRoute): Record<string, string> {
-	return {
-		[SUBAGENT_PARENT_EVENT_SINK_ENV]: route.eventSink,
-		[SUBAGENT_PARENT_CONTROL_INBOX_ENV]: route.controlInbox,
-		[SUBAGENT_PARENT_ROOT_RUN_ID_ENV]: route.rootRunId,
-		[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]: route.capabilityToken,
-	};
+export function nestedRouteEnv(_route: NestedRoute): Record<string, string> {
+	return {};
 }

package/dist/builtin/subagents/src/runs/{shared/nested-events-core.ts → inprocess/runtime-support/nested-core.ts}

@@ -1,20 +1,10 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getEnvValue } from "@bastani/atomic";
-import { type NestedRouteInfo, type NestedRunSummary, TEMP_ROOT_DIR } from "../../shared/types.ts";
-import { isSafeNestedPathId, type NestedPathEntry, parseNestedPathEnv } from "./nested-path.ts";
-import {
-	SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV,
-	SUBAGENT_PARENT_CHILD_INDEX_ENV,
-	SUBAGENT_PARENT_CONTROL_INBOX_ENV,
-	SUBAGENT_PARENT_DEPTH_ENV,
-	SUBAGENT_PARENT_EVENT_SINK_ENV,
-	SUBAGENT_PARENT_MAX_DEPTH,
-	SUBAGENT_PARENT_PATH_ENV,
-	SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
-	SUBAGENT_PARENT_RUN_ID_ENV,
-} from "./pi-args.ts";
+import { type NestedRouteInfo, type NestedRunSummary, TEMP_ROOT_DIR } from "../../../shared/types.ts";
+import { MAX_SUBAGENT_NESTING_DEPTH } from "../../../shared/types-runtime.ts";
+import { registerInProcessNestedRoute } from "../nested-routing.ts";
+import { isSafeNestedPathId, type NestedPathEntry } from "./nested-paths.ts";
 
 export const NESTED_EVENTS_DIR = path.join(TEMP_ROOT_DIR, "nested-subagent-events");
 export const NESTED_RUNS_DIR = path.join(TEMP_ROOT_DIR, "nested-subagent-runs");
@@ -23,7 +13,7 @@ export const REGISTRY_FILE = "registry.json";
 export const MAX_NESTED_EVENT_BYTES = 64 * 1024;
 export const MAX_NESTED_STEPS = 12;
 export const MAX_NESTED_CHILDREN = 16;
-export const MAX_NESTED_DEPTH = SUBAGENT_PARENT_MAX_DEPTH;
+export const MAX_NESTED_DEPTH = MAX_SUBAGENT_NESTING_DEPTH;
 export const MAX_PROCESSED_NESTED_EVENTS = 20_000;
 type NestedStatusEventType = "subagent.nested.started" | "subagent.nested.updated" | "subagent.nested.completed";
 type NestedControlResultEventType = "subagent.nested.control-result";
@@ -119,7 +109,9 @@ export function createNestedRoute(rootRunId: string): NestedRoute {
 		`${JSON.stringify({ rootRunId, capabilityToken, createdAt: Date.now() })}\n`,
 		{ mode: 0o600 },
 	);
-	return { rootRunId, eventSink, controlInbox, capabilityToken };
+	const route = { rootRunId, eventSink, controlInbox, capabilityToken };
+	registerInProcessNestedRoute(route);
+	return route;
 }
 
 /** Whether any entry in the tree rooted at filePath has an mtime at or after cutoff, stopping at the first hit. */
@@ -174,57 +166,18 @@ export function cleanupOldNestedRuntimeDirs(maxAgeDays: number): void {
 	cleanupOldSubdirectories(NESTED_RUNS_DIR, maxAgeDays);
 }
 
-export function readSubagentEnv(env: NodeJS.ProcessEnv, name: string): string | undefined {
-	if (env === process.env) return getEnvValue(name);
-	// Atomic keeps reading legacy pi-prefixed env vars so older parent processes can route nested children.
-	const legacyName = name.replace(/^[A-Z0-9]+_/, "PI_");
-	return env[name] ?? (legacyName === name ? undefined : env[legacyName]);
+export function resolveNestedRouteFromEnv(_env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
+	return undefined;
 }
 
-export function resolveNestedRouteFromEnv(env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
-	const rootRunId = readSubagentEnv(env, SUBAGENT_PARENT_ROOT_RUN_ID_ENV);
-	const eventSink = readSubagentEnv(env, SUBAGENT_PARENT_EVENT_SINK_ENV);
-	const controlInbox = readSubagentEnv(env, SUBAGENT_PARENT_CONTROL_INBOX_ENV);
-	const capabilityToken = readSubagentEnv(env, SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV);
-	if (!rootRunId || !eventSink || !controlInbox || !capabilityToken) return undefined;
-	const route = { rootRunId, eventSink, controlInbox, capabilityToken };
-	validateRouteShape(route);
-	const routeFile = path.join(commonRouteRoot(route), ROUTE_FILE);
-	const metadata = JSON.parse(fs.readFileSync(routeFile, "utf-8")) as {
-		rootRunId?: unknown;
-		capabilityToken?: unknown;
-	};
-	if (metadata.rootRunId !== rootRunId || metadata.capabilityToken !== capabilityToken) {
-		throw new Error("Nested event route metadata does not match the provided root id and capability token.");
-	}
-	return route;
-}
-
-export function resolveInheritedNestedRouteFromEnv(env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
-	try {
-		return resolveNestedRouteFromEnv(env);
-	} catch (error) {
-		console.error("Ignoring invalid nested subagent event route:", error);
-		return undefined;
-	}
+export function resolveInheritedNestedRouteFromEnv(_env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
+	return undefined;
 }
 
 export function resolveNestedParentAddressFromEnv(
-	env: NodeJS.ProcessEnv = process.env,
+	_env: NodeJS.ProcessEnv = process.env,
 ): { parentRunId: string; parentStepIndex?: number; depth: number; path: NestedPathEntry[] } | undefined {
-	const parentRunId = readSubagentEnv(env, SUBAGENT_PARENT_RUN_ID_ENV);
-	if (!isSafeNestedId(parentRunId)) return undefined;
-	const rawIndex = readSubagentEnv(env, SUBAGENT_PARENT_CHILD_INDEX_ENV);
-	const parentStepIndex = rawIndex && /^\d+$/.test(rawIndex) ? Number(rawIndex) : undefined;
-	const depth = Math.min(
-		Math.max(1, clampNumber(Number(readSubagentEnv(env, SUBAGENT_PARENT_DEPTH_ENV))) ?? 1),
-		MAX_NESTED_DEPTH,
-	);
-	const parsedPath = parseNestedPathEnv(readSubagentEnv(env, SUBAGENT_PARENT_PATH_ENV));
-	const nestedPath = parsedPath.length
-		? parsedPath
-		: [{ runId: parentRunId, ...(parentStepIndex !== undefined ? { stepIndex: parentStepIndex } : {}) }];
-	return { parentRunId, ...(parentStepIndex !== undefined ? { parentStepIndex } : {}), depth, path: nestedPath };
+	return undefined;
 }
 
 export function resolveNestedAsyncDir(rootRunId: string, run: NestedRunSummary): string | undefined {

package/dist/builtin/subagents/src/runs/{shared/nested-events-projection.ts → inprocess/runtime-support/nested-projection.ts}

@@ -8,16 +8,10 @@ import {
 	RESULTS_DIR,
 	type SubagentRunMode,
 	type SubagentState,
-} from "../../shared/types.ts";
-import {
-	assertSafeId,
-	containedPath,
-	MAX_NESTED_CHILDREN,
-	MAX_NESTED_STEPS,
-	NESTED_RUNS_DIR,
-} from "./nested-events-core.ts";
-import { projectNestedEvents } from "./nested-events-registry.ts";
-import { terminal } from "./nested-events-sanitize.ts";
+} from "../../../shared/types.ts";
+import { assertSafeId, containedPath, MAX_NESTED_CHILDREN, MAX_NESTED_STEPS, NESTED_RUNS_DIR } from "./nested-core.ts";
+import { projectNestedEvents } from "./nested-registry.ts";
+import { terminal } from "./nested-sanitize.ts";
 
 export function attachRootChildrenToSteps<T extends { children?: NestedRunSummary[]; index?: number }>(
 	rootRunId: string,

package/dist/builtin/subagents/src/runs/{shared/nested-events-registry.ts → inprocess/runtime-support/nested-registry.ts}

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { writeAtomicJson } from "../../shared/atomic-json.ts";
-import type { NestedRunSummary } from "../../shared/types.ts";
+import { writeAtomicJson } from "../../../shared/atomic-json.ts";
+import type { NestedRunSummary } from "../../../shared/types.ts";
+import { appendInProcessNestedEvent, hasInProcessNestedRoute, readInProcessNestedEvents } from "../nested-routing.ts";
 import {
 	assertSafeId,
 	commonRouteRoot,
@@ -16,8 +17,8 @@ import {
 	REGISTRY_FILE,
 	ROUTE_FILE,
 	validateRouteShape,
-} from "./nested-events-core.ts";
-import { applyNestedEvent, parseNestedEventRecords, parseRecord, sanitizeSummary } from "./nested-events-sanitize.ts";
+} from "./nested-core.ts";
+import { applyNestedEvent, parseNestedEventRecords, parseRecord, sanitizeSummary } from "./nested-sanitize.ts";
 
 const REGISTRY_LOCK_DIR = ".registry.lock";
 const REGISTRY_LOCK_TIMEOUT_MS = 2_000;
@@ -260,6 +261,19 @@ export function readNestedRegistry(route: NestedRoute): NestedRegistry {
 
 export function projectNestedEvents(route: NestedRoute): NestedRegistry {
 	validateRouteShape(route);
+	if (hasInProcessNestedRoute(route)) {
+		const release = acquireRegistryLock(route);
+		try {
+			let registry = readNestedRegistry(route);
+			for (const event of readInProcessNestedEvents(route)) {
+				const parsed = parseRecord(JSON.stringify(event), route);
+				if (parsed) registry = applyNestedEvent(registry, parsed);
+			}
+			return registry;
+		} finally {
+			release();
+		}
+	}
 	const release = acquireRegistryLock(route);
 	try {
 		let registry = readNestedRegistry(route);
@@ -333,5 +347,6 @@ export function writeNestedEvent(
 	};
 	const sanitized = parseRecord(JSON.stringify(record), route);
 	if (!sanitized) throw new Error("Nested event record failed validation.");
+	appendInProcessNestedEvent(route, sanitized);
 	writeRouteRecord(route.eventSink, sanitized.ts, sanitized);
 }

package/dist/builtin/subagents/src/runs/{shared/nested-render.ts → inprocess/runtime-support/nested-rendering.ts}

@@ -1,6 +1,6 @@
-import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.ts";
-import { formatActivityLabel } from "../../shared/status-format.ts";
-import { type ActivityState, MAX_SUBAGENT_NESTING_DEPTH, type NestedRunSummary } from "../../shared/types.ts";
+import { formatDuration, formatTokens, shortenPath } from "../../../shared/formatters.ts";
+import { formatActivityLabel } from "../../../shared/status-format.ts";
+import { type ActivityState, MAX_SUBAGENT_NESTING_DEPTH, type NestedRunSummary } from "../../../shared/types.ts";
 
 export interface NestedRunCounts {
 	total: number;

package/dist/builtin/subagents/src/runs/{shared/nested-events-sanitize.ts → inprocess/runtime-support/nested-sanitize.ts}

@@ -1,4 +1,4 @@
-import type { NestedRunState, NestedRunSummary, NestedStepSummary } from "../../shared/types.ts";
+import type { NestedRunState, NestedRunSummary, NestedStepSummary } from "../../../shared/types.ts";
 import {
 	clampNumber,
 	isSafeNestedId,
@@ -10,8 +10,8 @@ import {
 	type NestedRegistry,
 	type NestedRoute,
 	stringValue,
-} from "./nested-events-core.ts";
-import { sanitizeNestedPath } from "./nested-path.ts";
+} from "./nested-core.ts";
+import { sanitizeNestedPath } from "./nested-paths.ts";
 
 function sanitizeTokenUsage(value: unknown): NestedRunSummary["totalTokens"] | undefined {
 	if (!value || typeof value !== "object") return undefined;

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

@@ -0,0 +1 @@
+export * from "./inprocess/index.ts";

package/dist/builtin/subagents/src/runs/shared/dynamic-fanout.ts

@@ -1,5 +1,11 @@
 import type { DynamicParallelStep, ParallelTaskItem } from "../../shared/settings.ts";
-import type { ArtifactPaths, ChainOutputMap, JsonSchemaObject, SingleResult } from "../../shared/types.ts";
+import type {
+	ArtifactPaths,
+	ChainOutputMap,
+	JsonSchemaObject,
+	SingleResult,
+	SubagentAttemptStatus,
+} from "../../shared/types.ts";
 import { getSingleResultOutput } from "../../shared/utils.ts";
 import { validateStructuredOutputValue } from "./structured-output.ts";
 
@@ -22,7 +28,7 @@ export interface DynamicCollectedResult {
 	index: number;
 	item: unknown;
 	agent: string;
-	exitCode: number | null;
+	status: SubagentAttemptStatus;
 	text: string;
 	structured?: unknown;
 	error?: string;
@@ -350,7 +356,7 @@ export function collectDynamicResults(
 	step: DynamicParallelStep,
 	items: DynamicMaterializedItem[],
 	results: Array<
-		Pick<SingleResult, "agent" | "exitCode" | "error" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & {
+		Pick<SingleResult, "agent" | "status" | "error" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & {
 			output?: string;
 			finalOutput?: string;
 		}
@@ -368,7 +374,7 @@ export function collectDynamicResults(
 			index: entry.index,
 			item: entry.item,
 			agent: result?.agent ?? step.parallel.agent,
-			exitCode: result?.exitCode ?? null,
+			status: result?.status ?? "skipped",
 			text,
 			...(result?.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
 			...(result?.error ? { error: result.error } : {}),

package/dist/builtin/subagents/src/runs/shared/model-candidate-filter.ts

@@ -18,7 +18,6 @@ export function skippedModelAttempt(model: string, reason: string): ModelAttempt
 	return {
 		model,
 		success: false,
-		exitCode: null,
 		error: reason,
 	};
 }