@bastani/atomic 0.9.12 → 0.9.13-alpha.2

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

@@ -6,25 +6,17 @@ import type { FSWatcher } from "node:fs";
 import type { ExtensionContext } from "@bastani/atomic";
 import type {
 	ActivityState,
-	ChainOutputMap,
 	ModelAttempt,
 	SingleResult,
 	SubagentResultStatus,
 	SubagentRunMode,
 	TokenUsage,
-	WorkflowGraphSnapshot,
 } from "./types-results.ts";
 
 // ============================================================================
 // Async Execution
 // ============================================================================
 
-export interface AsyncParallelGroupStatus {
-	start: number;
-	count: number;
-	stepIndex: number;
-}
-
 export type NestedRunState = "queued" | "running" | "complete" | "failed" | "paused";
 export type NestedOwnerState = "live" | "gone" | "unknown";
 
@@ -69,9 +61,6 @@ export interface NestedRunSummary extends NestedRunAddress {
 	state: NestedRunState;
 	agent?: string;
 	agents?: string[];
-	currentStep?: number;
-	chainStepCount?: number;
-	parallelGroups?: AsyncParallelGroupStatus[];
 	steps?: NestedStepSummary[];
 	children?: NestedRunSummary[];
 	activityState?: ActivityState;
@@ -103,10 +92,9 @@ export interface AsyncStartedEvent {
 	mode?: SubagentRunMode;
 	agent?: string;
 	agents?: string[];
-	chain?: string[];
-	chainStepCount?: number;
-	parallelGroups?: AsyncParallelGroupStatus[];
-	workflowGraph?: WorkflowGraphSnapshot;
+	model?: string;
+	thinking?: string;
+	fastMode?: boolean;
 	nestedRoute?: NestedRouteInfo;
 }
 
@@ -127,16 +115,8 @@ export interface AsyncStatus {
 	lastUpdate?: number;
 	pid?: number;
 	cwd?: string;
-	currentStep?: number;
-	chainStepCount?: number;
-	parallelGroups?: AsyncParallelGroupStatus[];
-	workflowGraph?: WorkflowGraphSnapshot;
 	steps?: Array<{
 		agent: string;
-		phase?: string;
-		label?: string;
-		outputName?: string;
-		structured?: boolean;
 		status: "pending" | "running" | "complete" | "completed" | "failed" | "paused";
 		children?: NestedRunSummary[];
 		sessionFile?: string;
@@ -153,7 +133,6 @@ export interface AsyncStatus {
 		startedAt?: number;
 		endedAt?: number;
 		durationMs?: number;
-		exitCode?: number | null;
 		tokens?: TokenUsage;
 		skills?: string[];
 		model?: string;
@@ -162,15 +141,11 @@ export interface AsyncStatus {
 		attemptedModels?: string[];
 		modelAttempts?: ModelAttempt[];
 		error?: string;
-		structuredOutput?: unknown;
-		structuredOutputPath?: string;
-		structuredOutputSchemaPath?: string;
 	}>;
 	sessionDir?: string;
 	outputFile?: string;
 	totalTokens?: TokenUsage;
 	sessionFile?: string;
-	outputs?: ChainOutputMap;
 }
 
 export type AsyncJobStep = NonNullable<AsyncStatus["steps"]>[number] & {
@@ -192,14 +167,10 @@ export interface AsyncJobState {
 	toolCount?: number;
 	mode?: SubagentRunMode;
 	agents?: string[];
-	currentStep?: number;
-	chainStepCount?: number;
-	parallelGroups?: AsyncParallelGroupStatus[];
 	steps?: AsyncJobStep[];
 	stepsTotal?: number;
 	runningSteps?: number;
 	completedSteps?: number;
-	hasParallelGroups?: boolean;
 	activeParallelGroup?: boolean;
 	startedAt?: number;
 	updatedAt?: number;
@@ -218,6 +189,11 @@ export interface ForegroundResumeChild {
 	sessionFile?: string;
 	status: SubagentResultStatus;
 	result?: SingleResult;
+	/**
+	 * Effective delegation limit this child ran under. Retained per child because
+	 * edit to the agent definition must not widen a resumed child's budget.
+	 */
+	maxSubagentDepth?: number;
 }
 
 export interface ForegroundResumeRun {

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

@@ -10,7 +10,6 @@ import type {
 	ControlConfig,
 	ControlEvent,
 	Details,
-	JsonSchemaObject,
 	MaxOutputConfig,
 	OutputMode,
 	ResolvedControlConfig,
@@ -60,6 +59,8 @@ 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. */
@@ -71,6 +72,12 @@ export interface RunSyncOptions {
 	controlConfig?: ResolvedControlConfig;
 	intercomSessionName?: string;
 	orchestratorIntercomTarget?: string;
+	/** Typed supervisor capability issued for this child; never read from environment. */
+	supervisorAuthorization?: {
+		capability: string;
+		supervisorSessionId: string;
+		childName: string;
+	};
 	/** Resolved intercom home group for the spawned child (explicit subagent group or inherited stage group). */
 	intercomGroup?: string;
 	maxOutput?: MaxOutputConfig;
@@ -86,6 +93,8 @@ export interface RunSyncOptions {
 	outputPath?: string;
 	outputMode?: OutputMode;
 	maxSubagentDepth?: number;
+	/** Current session depth passed to the in-process admission door. */
+	parentDepth?: number;
 	workflowStageSubagentGuard?: boolean;
 	workflowSessionMetadata?: SessionWorkflowMetadata;
 	nestedRoute?: NestedRouteInfo;
@@ -101,11 +110,25 @@ export interface RunSyncOptions {
 	currentModel?: string;
 	/** Skills to inject (overrides agent default if provided) */
 	skills?: string[];
-	structuredOutput?: {
-		schema: JsonSchemaObject;
-		schemaPath: string;
-		outputPath: string;
-	};
+	/** Test-only in-process session stub configuration; production runs create a real AgentSession. */
+	testSession?:
+		| false
+		| {
+				output?: string;
+				promptLogPath?: string;
+				/** Hold a test prompt open until the caller releases the supplied promise. */
+				promptGate?: Promise<void>;
+				/** Match AgentSession.abort() settling an active prompt without throwing. */
+				abortResolvesPrompt?: boolean;
+				/** Emit a fallback event for tests that exercise live model metadata. */
+				fallbackModel?: string;
+				/** Emit the effective thinking level applied to the fallback candidate. */
+				fallbackThinkingLevel?: string;
+				/** Test-only session model exposed through the AgentSession accessors. */
+				sessionModel?: string;
+				/** Test-only effective thinking level exposed through the AgentSession accessors. */
+				sessionThinkingLevel?: string;
+		  };
 }
 
 export type IntercomBridgeMode = "off" | "fork-only" | "always";
@@ -120,12 +143,6 @@ interface TopLevelParallelConfig {
 	concurrency?: number;
 }
 
-interface ExtensionChainConfig {
-	dynamicFanout?: {
-		maxItems?: number;
-	};
-}
-
 export interface ExtensionConfig {
 	asyncByDefault?: boolean;
 	forceTopLevelAsync?: boolean;
@@ -133,7 +150,6 @@ export interface ExtensionConfig {
 	maxSubagentDepth?: number;
 	control?: ControlConfig;
 	parallel?: TopLevelParallelConfig;
-	chain?: ExtensionChainConfig;
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
 	intercomBridge?: IntercomBridgeConfig;

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-results.ts

@@ -2,6 +2,7 @@
  * Result, progress, and core subagent public types.
  */
 
+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";
@@ -13,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;
@@ -136,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,
@@ -176,9 +133,6 @@ export type PublicNestedRunSummary = Pick<
 	| "state"
 	| "agent"
 	| "agents"
-	| "currentStep"
-	| "chainStepCount"
-	| "parallelGroups"
 	| "activityState"
 	| "lastActivityAt"
 	| "currentTool"
@@ -219,7 +173,6 @@ export interface SubagentResultIntercomPayload {
 	children: SubagentResultIntercomChild[];
 	asyncId?: string;
 	asyncDir?: string;
-	chainSteps?: number;
 	agent?: string;
 	index?: number;
 	artifactPath?: string;
@@ -236,6 +189,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;
@@ -271,21 +230,28 @@ export interface ModelAttempt {
 	model: string;
 	reasoningLevel?: string;
 	success: boolean;
-	exitCode?: number | null;
 	error?: string;
 	usage?: Usage;
 }
 
+export type SubagentAttemptStatus = "ok" | "error" | "skipped" | "interrupted" | "continued";
+
 export interface SingleResult {
 	agent: string;
 	task: string;
-	exitCode: number;
+	/** Typed terminal outcome; this is the only result discriminator. */
+	status: SubagentAttemptStatus;
+	cause?: string;
+	stats?: SessionStats;
+	path?: string;
+	envelope?: string;
 	detached?: boolean;
 	detachedReason?: string;
 	interrupted?: boolean;
 	messages?: Message[];
 	usage: Usage;
 	model?: string;
+	thinking?: string;
 	fastMode?: boolean;
 	attemptedModels?: string[];
 	modelAttempts?: ModelAttempt[];
@@ -304,9 +270,6 @@ export interface SingleResult {
 	savedOutputPath?: string;
 	outputReference?: SavedOutputReference;
 	outputSaveError?: string;
-	structuredOutput?: unknown;
-	structuredOutputPath?: string;
-	structuredOutputSchemaPath?: string;
 }
 
 export interface Details {
@@ -318,6 +281,7 @@ export interface Details {
 	asyncId?: string;
 	asyncDir?: string;
 	progress?: AgentProgress[];
+	totalSteps?: number;
 	progressSummary?: ProgressSummary;
 	artifacts?: {
 		dir: string;
@@ -329,12 +293,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

@@ -76,7 +76,6 @@ 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";

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

@@ -133,6 +133,11 @@ export function findLatestSessionFile(sessionDir: string): string | 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;
+	}
+}