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

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

@@ -3,34 +3,32 @@
  */
 
 import type { ExtensionContext, SessionWorkflowMetadata } from "@bastani/atomic";
-import {
-	APP_NAME,
-	getEnvValue,
-	WORKFLOW_SESSION_METADATA_ENV,
-	WORKFLOW_STAGE_SUBAGENT_GUARD_ENV,
-} from "@bastani/atomic";
 import { DEFAULT_SUBAGENT_MAX_DEPTH, MAX_SUBAGENT_NESTING_DEPTH } from "./types-runtime.ts";
 
-const ENV_PREFIX = APP_NAME.toUpperCase();
-const SUBAGENT_MAX_DEPTH_ENV = `${ENV_PREFIX}_SUBAGENT_MAX_DEPTH`;
-const SUBAGENT_DEPTH_ENV = `${ENV_PREFIX}_SUBAGENT_DEPTH`;
-
-export { WORKFLOW_STAGE_SUBAGENT_GUARD_ENV };
+// Depth is admission state carried in the typed child policy, not process environment.
 
 // ============================================================================
-
 export function normalizeMaxSubagentDepth(value: unknown): number | undefined {
 	const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
 	if (!Number.isInteger(parsed) || parsed < 0) return undefined;
 	return Math.min(parsed, MAX_SUBAGENT_NESTING_DEPTH);
 }
 
-export function resolveCurrentMaxSubagentDepth(configMaxDepth?: number): number {
-	return (
-		normalizeMaxSubagentDepth(getEnvValue(SUBAGENT_MAX_DEPTH_ENV)) ??
-		normalizeMaxSubagentDepth(configMaxDepth) ??
-		DEFAULT_SUBAGENT_MAX_DEPTH
-	);
+/**
+ * The effective limit is the stricter of the local configuration and any limit
+ * inherited through the child policy, both clamped by the global ceiling.
+ */
+export function resolveCurrentMaxSubagentDepth(configMaxDepth?: number, inheritedMaxDepth?: number): number {
+	const local = normalizeMaxSubagentDepth(configMaxDepth) ?? DEFAULT_SUBAGENT_MAX_DEPTH;
+	const inherited = normalizeMaxSubagentDepth(inheritedMaxDepth);
+	return inherited === undefined ? local : Math.min(local, inherited);
+}
+
+/** Read the delegation limit a parent admission issued to this child session. */
+export function getInheritedMaxSubagentDepth(
+	ctx: Partial<Pick<ExtensionContext, "subagentPolicy">>,
+): number | undefined {
+	return ctx.subagentPolicy?.maxSubagentDepth;
 }
 
 export function resolveChildMaxSubagentDepth(parentMaxDepth: number, agentMaxDepth?: number): number {
@@ -39,10 +37,6 @@ export function resolveChildMaxSubagentDepth(parentMaxDepth: number, agentMaxDep
 	return normalizedAgent === undefined ? normalizedParent : Math.min(normalizedParent, normalizedAgent);
 }
 
-export function hasWorkflowStageSubagentGuard(): boolean {
-	return getEnvValue(WORKFLOW_STAGE_SUBAGENT_GUARD_ENV) === "1";
-}
-
 export function isWorkflowStageOrchestrationContext(ctx: Pick<ExtensionContext, "orchestrationContext">): boolean {
 	return ctx.orchestrationContext?.kind === "workflow-stage";
 }
@@ -59,21 +53,11 @@ export function workflowSessionMetadataFromContext(
 	};
 }
 
-export function workflowSessionEnv(metadata: SessionWorkflowMetadata | undefined): Record<string, string> {
-	return metadata ? { [WORKFLOW_SESSION_METADATA_ENV]: JSON.stringify(metadata) } : {};
-}
-
-export function workflowSessionEnvFromContext(
-	ctx: Pick<ExtensionContext, "orchestrationContext">,
-): Record<string, string> {
-	return workflowSessionEnv(workflowSessionMetadataFromContext(ctx));
-}
-
 export function resolveWorkflowStageMaxSubagentDepth(
-	ctx: Pick<ExtensionContext, "orchestrationContext">,
+	ctx: Pick<ExtensionContext, "orchestrationContext"> & Partial<Pick<ExtensionContext, "subagentPolicy">>,
 	configMaxDepth?: number,
 ): number {
-	const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth);
+	const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth, getInheritedMaxSubagentDepth(ctx));
 	return isWorkflowStageOrchestrationContext(ctx)
 		? // Workflow stages receive an explicit host constraint, clamped by the
 			// inherited/global nesting ceiling. A 0-depth workflow constraint still
@@ -88,7 +72,7 @@ export interface SubagentDepthPolicy {
 }
 
 export function resolveSubagentDepthPolicy(
-	ctx: Pick<ExtensionContext, "orchestrationContext">,
+	ctx: Pick<ExtensionContext, "orchestrationContext"> & Partial<Pick<ExtensionContext, "subagentPolicy">>,
 	configMaxDepth?: number,
 ): SubagentDepthPolicy {
 	return {
@@ -128,31 +112,21 @@ export interface SubagentDepthCheck {
 	blocked: boolean;
 	depth: number;
 	maxDepth: number;
-	workflowStageGuard: boolean;
 }
 
-export function checkSubagentDepth(configMaxDepth?: number): SubagentDepthCheck {
-	const depth = Number(getEnvValue(SUBAGENT_DEPTH_ENV) ?? "0");
-	const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth);
-	const blocked = Number.isFinite(depth) && depth >= maxDepth;
-	return { blocked, depth, maxDepth, workflowStageGuard: hasWorkflowStageSubagentGuard() };
+/** Read the admitted depth carried by an in-process child session. */
+export function getCurrentSubagentDepth(ctx: Pick<ExtensionContext, "subagentPolicy">): number {
+	const depth = ctx.subagentPolicy?.depth;
+	return typeof depth === "number" && Number.isInteger(depth) && depth >= 0 ? depth : 0;
 }
 
-export function getSubagentDepthEnv(
-	maxDepth?: number,
-	options?: { workflowStageSubagentGuard?: boolean },
-): Record<string, string> {
-	const parentDepth = Number(getEnvValue(SUBAGENT_DEPTH_ENV) ?? "0");
-	// Preserve an inherited workflow-stage marker for descendants; callers that
-	// mutate process.env in tests must clear it to avoid intentional propagation.
-	const nextDepth = Number.isFinite(parentDepth) ? parentDepth + 1 : 1;
-	return {
-		[SUBAGENT_DEPTH_ENV]: String(nextDepth),
-		[SUBAGENT_MAX_DEPTH_ENV]: String(normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth()),
-		...(options?.workflowStageSubagentGuard || hasWorkflowStageSubagentGuard()
-			? { [WORKFLOW_STAGE_SUBAGENT_GUARD_ENV]: "1" }
-			: {}),
-	};
+export function checkSubagentDepth(
+	ctx: Pick<ExtensionContext, "subagentPolicy">,
+	configMaxDepth?: number,
+): SubagentDepthCheck {
+	const depth = getCurrentSubagentDepth(ctx);
+	const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth, getInheritedMaxSubagentDepth(ctx));
+	return { blocked: Number.isFinite(depth) && depth >= maxDepth, depth, maxDepth };
 }
 
 // ============================================================================

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;
@@ -14,50 +14,6 @@ export interface MaxOutputConfig {
 
 export type OutputMode = "inline" | "file-only";
 
-export type JsonSchemaObject = Record<string, unknown>;
-
-export interface ChainOutputMapEntry {
-	text: string;
-	structured?: unknown;
-	agent: string;
-	stepIndex: number;
-}
-
-export type ChainOutputMap = Record<string, ChainOutputMapEntry>;
-
-export type WorkflowNodeStatus = "pending" | "running" | "completed" | "failed" | "paused" | "detached";
-
-export interface WorkflowGraphNode {
-	id: string;
-	kind: "step" | "parallel-group" | "dynamic-parallel-group" | "agent";
-	agent?: string;
-	phase?: string;
-	label: string;
-	status: WorkflowNodeStatus;
-	flatIndex?: number;
-	stepIndex?: number;
-	children?: WorkflowGraphNode[];
-	dynamic?: {
-		sourceOutput: string;
-		sourcePath: string;
-		itemName: string;
-		maxItems?: number;
-		collectAs?: string;
-	};
-	itemKey?: string;
-	outputName?: string;
-	structured?: boolean;
-	error?: string;
-}
-
-export interface WorkflowGraphSnapshot {
-	runId: string;
-	mode: "chain" | "parallel" | "single";
-	phases: Array<{ title: string; nodeIds: string[] }>;
-	nodes: WorkflowGraphNode[];
-	currentNodeId?: string;
-}
-
 export interface SavedOutputReference {
 	path: string;
 	bytes: number;
@@ -90,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;
@@ -137,7 +93,7 @@ export interface ControlEvent {
 }
 
 export type SubagentResultStatus = "completed" | "failed" | "paused" | "detached";
-export type SubagentRunMode = "single" | "parallel" | "chain";
+export type SubagentRunMode = "single" | "parallel";
 
 export type PublicNestedStepSummary = Pick<
 	NestedStepSummary,
@@ -166,7 +122,6 @@ export type PublicNestedRunSummary = Pick<
 	| "parentAgent"
 	| "depth"
 	| "path"
-	| "asyncDir"
 	| "sessionId"
 	| "sessionFile"
 	| "intercomTarget"
@@ -177,9 +132,6 @@ export type PublicNestedRunSummary = Pick<
 	| "state"
 	| "agent"
 	| "agents"
-	| "currentStep"
-	| "chainStepCount"
-	| "parallelGroups"
 	| "activityState"
 	| "lastActivityAt"
 	| "currentTool"
@@ -216,11 +168,7 @@ export interface SubagentResultIntercomPayload {
 	mode: SubagentRunMode;
 	status: SubagentResultStatus;
 	summary: string;
-	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
-	asyncId?: string;
-	asyncDir?: string;
-	chainSteps?: number;
 	agent?: string;
 	index?: number;
 	artifactPath?: string;
@@ -237,6 +185,12 @@ export interface AgentProgress {
 	status: "pending" | "running" | "completed" | "failed" | "detached";
 	activityState?: ActivityState;
 	task: string;
+	/** Effective model for this live attempt, including fallback changes. */
+	model?: string;
+	/** Effective thinking level for this live attempt. */
+	thinking?: string;
+	/** Whether Codex fast mode applies to this attempt. */
+	fastMode?: boolean;
 	skills?: string[];
 	lastActivityAt?: number;
 	currentTool?: string;
@@ -293,6 +247,7 @@ export interface SingleResult {
 	messages?: Message[];
 	usage: Usage;
 	model?: string;
+	thinking?: string;
 	fastMode?: boolean;
 	attemptedModels?: string[];
 	modelAttempts?: ModelAttempt[];
@@ -311,9 +266,6 @@ export interface SingleResult {
 	savedOutputPath?: string;
 	outputReference?: SavedOutputReference;
 	outputSaveError?: string;
-	structuredOutput?: unknown;
-	structuredOutputPath?: string;
-	structuredOutputSchemaPath?: string;
 }
 
 export interface Details {
@@ -322,9 +274,8 @@ export interface Details {
 	context?: "fresh" | "fork";
 	results: SingleResult[];
 	controlEvents?: ControlEvent[];
-	asyncId?: string;
-	asyncDir?: string;
 	progress?: AgentProgress[];
+	totalSteps?: number;
 	progressSummary?: ProgressSummary;
 	artifacts?: {
 		dir: string;
@@ -336,12 +287,6 @@ export interface Details {
 		originalLines?: number;
 		artifactPath?: string;
 	};
-	// Chain metadata for observability
-	chainAgents?: string[]; // Agent names in order, e.g., ["scout", "planner"]
-	totalSteps?: number; // Total steps in chain
-	currentStepIndex?: number; // 0-indexed current step (for running chains)
-	workflowGraph?: WorkflowGraphSnapshot;
-	outputs?: ChainOutputMap;
 }
 
 // Upstream AgentToolResult omits the runtime isError flag that subagent tool results still emit/read.

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

@@ -74,19 +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 CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-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 = [
@@ -122,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,114 +16,20 @@ 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
 // ============================================================================
 
+/**
+ * A child may end its turn by calling a terminating tool named `structured_output`.
+ * Atomic no longer registers such a tool itself, but an extension can still provide
+ * one, so this generic parser keeps surfacing its result as the final output.
+ */
 const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
 
 type TextContentCandidate = {

package/dist/builtin/subagents/src/slash/bridge-settlement.ts

@@ -0,0 +1,87 @@
+import { isStaleExtensionContextError } from "@bastani/atomic";
+
+export interface BridgeRequestSettlement {
+	reject(error: unknown): void;
+}
+
+interface BridgeEventSurface {
+	emit(event: string, data: unknown): void;
+}
+
+export type BridgeSettlementScope = "slash" | "prompt-template";
+
+function bridgeSettlementRegistry(): Map<string, BridgeRequestSettlement> {
+	const key = "__atomicSubagentBridgeRequestSettlements";
+	const store = globalThis as Record<string, unknown>;
+	const existing = store[key];
+	if (existing instanceof Map) return existing as Map<string, BridgeRequestSettlement>;
+	const registry = new Map<string, BridgeRequestSettlement>();
+	store[key] = registry;
+	return registry;
+}
+
+function settlementKey(scope: BridgeSettlementScope, requestId: string): string {
+	return `${scope}\0${requestId}`;
+}
+
+export function registerBridgeRequestSettlement(
+	scope: BridgeSettlementScope,
+	requestId: string,
+	settlement: BridgeRequestSettlement,
+): () => void {
+	const registry = bridgeSettlementRegistry();
+	const key = settlementKey(scope, requestId);
+	registry.set(key, settlement);
+	return () => {
+		if (registry.get(key) === settlement) registry.delete(key);
+	};
+}
+
+export function readBridgeRequestSettlement(
+	data: unknown,
+	scope: BridgeSettlementScope,
+): BridgeRequestSettlement | undefined {
+	if (!data || typeof data !== "object") return undefined;
+	const requestId = (data as { requestId?: unknown }).requestId;
+	if (typeof requestId !== "string") return undefined;
+	return bridgeSettlementRegistry().get(settlementKey(scope, requestId));
+}
+
+/** A bridge was stopped before its caller received a terminal response. */
+export class BridgeRequestStoppedError extends Error {
+	constructor() {
+		super(
+			"Subagent response delivery stopped because its bridge was stopped before the response arrived (extension deactivation or replacement).",
+		);
+		this.name = "BridgeRequestStoppedError";
+	}
+}
+
+export function rejectStoppedBridgeRequest(settlement: BridgeRequestSettlement | undefined): void {
+	settlement?.reject(new BridgeRequestStoppedError());
+}
+
+/**
+ * Emit through the captured extension runtime. A stale runtime means the event
+ * was dropped, so reject the request's direct settlement path instead of
+ * letting an event-only caller wait forever.
+ */
+export function emitBridgeEvent(
+	events: BridgeEventSurface,
+	event: string,
+	data: unknown,
+	settlement: BridgeRequestSettlement | undefined,
+): boolean {
+	try {
+		events.emit(event, data);
+		return true;
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		if (settlement) {
+			settlement.reject(error);
+		} else {
+			console.error(`Subagent bridge dropped '${event}' because its extension runtime is stale.`, error);
+		}
+		return false;
+	}
+}