@bastani/atomic 0.9.12 → 0.9.13-alpha.2

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,
@@ -95,8 +89,6 @@ export function nestedSummaryFromAsyncStatus(
 		...(status.sessionId ? { sessionId: status.sessionId } : {}),
 		mode: status.mode ?? fallback.mode,
 		state: status.state,
-		...(status.currentStep !== undefined ? { currentStep: status.currentStep } : {}),
-		...(status.chainStepCount !== undefined ? { chainStepCount: status.chainStepCount } : {}),
 		...(status.activityState ? { activityState: status.activityState } : {}),
 		...(status.lastActivityAt !== undefined ? { lastActivityAt: status.lastActivityAt } : {}),
 		...(status.currentTool ? { currentTool: status.currentTool } : {}),

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;
@@ -109,7 +109,7 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 			: {}),
 		...(stringValue(raw.controlInbox, 2048) ? { controlInbox: stringValue(raw.controlInbox, 2048) } : {}),
 		...(stringValue(raw.capabilityToken, 128) ? { capabilityToken: stringValue(raw.capabilityToken, 128) } : {}),
-		...(raw.mode === "single" || raw.mode === "parallel" || raw.mode === "chain" ? { mode: raw.mode } : {}),
+		...(raw.mode === "single" || raw.mode === "parallel" ? { mode: raw.mode } : {}),
 		...(stringValue(raw.agent, 128) ? { agent: stringValue(raw.agent, 128) } : {}),
 		...(Array.isArray(raw.agents)
 			? {
@@ -119,8 +119,6 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 						.slice(0, MAX_NESTED_STEPS),
 				}
 			: {}),
-		...(clampNumber(raw.currentStep) !== undefined ? { currentStep: clampNumber(raw.currentStep) } : {}),
-		...(clampNumber(raw.chainStepCount) !== undefined ? { chainStepCount: clampNumber(raw.chainStepCount) } : {}),
 		...(raw.activityState === "active_long_running" || raw.activityState === "needs_attention"
 			? { activityState: raw.activityState }
 			: {}),

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

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

package/dist/builtin/subagents/src/runs/shared/intercom-group.ts

@@ -1,8 +1,5 @@
 import { randomUUID } from "node:crypto";
-
-interface OrchestrationCarrier {
-	orchestrationContext?: { intercomGroup?: string } | undefined;
-}
+import { readRuntimeIntercomGroup } from "@bastani/atomic";
 
 /** Normalize agent-serialized auto-group sentinels without changing real group names. */
 export function normalizeAutoGroupSentinel(group: string | true | undefined): string | true | undefined {
@@ -11,15 +8,34 @@ export function normalizeAutoGroupSentinel(group: string | true | undefined): st
 	return sentinel === "true" || sentinel === "auto" ? true : group;
 }
 
-/** Read the inherited stage/session intercom group from the extension context (never from process.env). */
+/** Runtime joins are intentionally inherited before static child policy and stage context. */
+function runtimeIntercomGroup(sessionId: string | undefined): string | undefined {
+	return readRuntimeIntercomGroup(sessionId);
+}
+
+interface OrchestrationCarrier {
+	orchestrationContext?: { intercomGroup?: string } | undefined;
+	subagentPolicy?: { intercomGroup?: string } | undefined;
+	sessionManager?: { getSessionId(): string } | undefined;
+}
+
+/**
+ * Read the live joined group before the admitted child or static stage group. The runtime env
+ * entry is a deliberate exception to the no-process-env rule for admission capabilities: it
+ * carries only the current group so children launched after `join` follow their parent.
+ */
 export function inheritedIntercomGroup(ctx: OrchestrationCarrier | undefined): string | undefined {
+	const runtimeGroup = runtimeIntercomGroup(ctx?.sessionManager?.getSessionId());
+	if (runtimeGroup !== undefined) return runtimeGroup;
+	const policyGroup = ctx?.subagentPolicy?.intercomGroup;
+	if (typeof policyGroup === "string" && policyGroup.trim().length > 0) return policyGroup.trim();
 	const group = ctx?.orchestrationContext?.intercomGroup;
 	return typeof group === "string" && group.trim().length > 0 ? group.trim() : undefined;
 }
 
 /**
- * Resolve the intercom group for a spawned subagent child. Precedence:
- * explicit task/parallel/chain group > inherited current-session (stage) group.
+ * Resolve the intercom group for a spawned subagent child. Explicit task group
+ * takes precedence over the inherited current-session group.
  * `true` resolves to `sharedAutoGroup` (a single UUID minted once per parallel
  * set) so every child in the set shares one isolated group. Returns undefined
  * when nothing applies, so the child inherits env/config/default itself.

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,
 	};
 }