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

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

@@ -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;
@@ -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,
@@ -177,9 +133,6 @@ export type PublicNestedRunSummary = Pick<
 	| "state"
 	| "agent"
 	| "agents"
-	| "currentStep"
-	| "chainStepCount"
-	| "parallelGroups"
 	| "activityState"
 	| "lastActivityAt"
 	| "currentTool"
@@ -220,7 +173,6 @@ export interface SubagentResultIntercomPayload {
 	children: SubagentResultIntercomChild[];
 	asyncId?: string;
 	asyncDir?: string;
-	chainSteps?: number;
 	agent?: string;
 	index?: number;
 	artifactPath?: string;
@@ -237,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;
@@ -293,6 +251,7 @@ export interface SingleResult {
 	messages?: Message[];
 	usage: Usage;
 	model?: string;
+	thinking?: string;
 	fastMode?: boolean;
 	attemptedModels?: string[];
 	modelAttempts?: ModelAttempt[];
@@ -311,9 +270,6 @@ export interface SingleResult {
 	savedOutputPath?: string;
 	outputReference?: SavedOutputReference;
 	outputSaveError?: string;
-	structuredOutput?: unknown;
-	structuredOutputPath?: string;
-	structuredOutputSchemaPath?: string;
 }
 
 export interface Details {
@@ -325,6 +281,7 @@ export interface Details {
 	asyncId?: string;
 	asyncDir?: string;
 	progress?: AgentProgress[];
+	totalSteps?: number;
 	progressSummary?: ProgressSummary;
 	artifacts?: {
 		dir: string;
@@ -336,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;
+	}
+}

package/dist/builtin/subagents/src/slash/prompt-template-bridge.ts

@@ -1,9 +1,28 @@
+import {
+	type BridgeRequestSettlement,
+	emitBridgeEvent,
+	readBridgeRequestSettlement,
+	registerBridgeRequestSettlement,
+	rejectStoppedBridgeRequest,
+} from "./bridge-settlement.ts";
 export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = "prompt-template:subagent:request";
 export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = "prompt-template:subagent:started";
 export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = "prompt-template:subagent:response";
 export const PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT = "prompt-template:subagent:update";
 export const PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT = "prompt-template:subagent:cancel";
 
+/**
+ * Register the rejection path for an out-of-tree prompt-template requester.
+ * The requester must unregister this hook when its response or cancellation
+ * path settles; the hook is used only when a stale bridge drops an emit.
+ */
+export function registerPromptTemplateBridgeRequestSettlement(
+	requestId: string,
+	reject: (error: unknown) => void,
+): () => void {
+	return registerBridgeRequestSettlement("prompt-template", requestId, { reject });
+}
+
 interface PromptTemplateDelegationTask {
 	agent: string;
 	task: string;
@@ -294,6 +313,7 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 	dispose: () => void;
 } {
 	const controllers = new Map<string, AbortController>();
+	const activeSettlements = new Map<string, BridgeRequestSettlement>();
 	const pendingCancels = new Set<string>();
 	const subscriptions: Array<() => void> = [];
 
@@ -317,6 +337,7 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 	subscribe(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, async (data) => {
 		const request = parsePromptTemplateRequest(data);
 		if (!request) return;
+		const settlement = readBridgeRequestSettlement(data, "prompt-template");
 
 		const ctx = options.getContext();
 		if (!ctx) {
@@ -326,12 +347,13 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				isError: true,
 				errorText: "No active extension context for delegated subagent execution.",
 			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response, settlement);
 			return;
 		}
 
 		const controller = new AbortController();
 		controllers.set(request.requestId, controller);
+		if (settlement) activeSettlements.set(request.requestId, settlement);
 
 		if (pendingCancels.delete(request.requestId)) {
 			controller.abort();
@@ -341,18 +363,33 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				isError: true,
 				errorText: "Delegated prompt cancelled.",
 			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response, settlement);
 			controllers.delete(request.requestId);
+			activeSettlements.delete(request.requestId);
 			return;
 		}
 
-		options.events.emit(PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT, { requestId: request.requestId });
+		if (
+			!emitBridgeEvent(
+				options.events,
+				PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT,
+				{ requestId: request.requestId },
+				settlement,
+			)
+		) {
+			controller.abort();
+			controllers.delete(request.requestId);
+			activeSettlements.delete(request.requestId);
+			return;
+		}
 
 		try {
 			const result = await options.execute(request.requestId, request, controller.signal, ctx, (update) => {
 				const payload = toDelegationUpdate(request.requestId, update);
 				if (!payload) return;
-				options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
+				if (!emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload, settlement)) {
+					controller.abort();
+				}
 			});
 			const contentText = firstTextContent(result.content);
 			const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
@@ -384,7 +421,7 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				isError: result.isError === true,
 				errorText: result.isError ? contentText : undefined,
 			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response, settlement);
 		} catch (error) {
 			const response: PromptTemplateDelegationResponse = {
 				...request,
@@ -392,18 +429,21 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				isError: true,
 				errorText: error instanceof Error ? error.message : String(error),
 			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response, settlement);
 		} finally {
 			controllers.delete(request.requestId);
+			activeSettlements.delete(request.requestId);
 		}
 	});
 
 	return {
 		cancelAll: () => {
-			for (const controller of controllers.values()) {
+			for (const [requestId, controller] of controllers) {
+				rejectStoppedBridgeRequest(activeSettlements.get(requestId));
 				controller.abort();
 			}
 			controllers.clear();
+			activeSettlements.clear();
 			pendingCancels.clear();
 		},
 		dispose: () => {

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

@@ -9,6 +9,12 @@ import {
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
 } from "../shared/types.ts";
+import {
+	type BridgeRequestSettlement,
+	emitBridgeEvent,
+	readBridgeRequestSettlement,
+	rejectStoppedBridgeRequest,
+} from "./bridge-settlement.ts";
 
 interface SlashSubagentRequest {
 	requestId: string;
@@ -51,6 +57,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 	dispose: () => void;
 } {
 	const controllers = new Map<string, AbortController>();
+	const activeSettlements = new Map<string, BridgeRequestSettlement>();
 	const pendingCancels = new Set<string>();
 	const subscriptions: Array<() => void> = [];
 
@@ -76,6 +83,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 		const request = data as Partial<SlashSubagentRequest>;
 		if (typeof request.requestId !== "string" || !request.params) return;
 		const { requestId, params } = request as SlashSubagentRequest;
+		const settlement = readBridgeRequestSettlement(data, "slash");
 
 		const ctx = options.getContext();
 		if (!ctx) {
@@ -88,12 +96,13 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 				isError: true,
 				errorText: "No active extension context.",
 			};
-			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, SLASH_SUBAGENT_RESPONSE_EVENT, response, settlement);
 			return;
 		}
 
 		const controller = new AbortController();
 		controllers.set(requestId, controller);
+		if (settlement) activeSettlements.set(requestId, settlement);
 
 		if (pendingCancels.delete(requestId)) {
 			controller.abort();
@@ -106,12 +115,18 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 				isError: true,
 				errorText: "Cancelled before start.",
 			};
-			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, SLASH_SUBAGENT_RESPONSE_EVENT, response, settlement);
 			controllers.delete(requestId);
+			activeSettlements.delete(requestId);
 			return;
 		}
 
-		options.events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId });
+		if (!emitBridgeEvent(options.events, SLASH_SUBAGENT_STARTED_EVENT, { requestId }, settlement)) {
+			controller.abort();
+			controllers.delete(requestId);
+			activeSettlements.delete(requestId);
+			return;
+		}
 
 		try {
 			const result = await options.execute(
@@ -127,7 +142,9 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 						currentTool: first?.currentTool,
 						toolCount: first?.toolCount,
 					};
-					options.events.emit(SLASH_SUBAGENT_UPDATE_EVENT, payload);
+					if (!emitBridgeEvent(options.events, SLASH_SUBAGENT_UPDATE_EVENT, payload, settlement)) {
+						controller.abort();
+					}
 				},
 				ctx,
 			);
@@ -140,7 +157,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 					? result.content.find((c) => c.type === "text")?.text
 					: undefined,
 			};
-			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, SLASH_SUBAGENT_RESPONSE_EVENT, response, settlement);
 		} catch (error) {
 			const response: SlashSubagentResponse = {
 				requestId,
@@ -151,18 +168,21 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 				isError: true,
 				errorText: error instanceof Error ? error.message : String(error),
 			};
-			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, SLASH_SUBAGENT_RESPONSE_EVENT, response, settlement);
 		} finally {
 			controllers.delete(requestId);
+			activeSettlements.delete(requestId);
 		}
 	});
 
 	return {
 		cancelAll: () => {
-			for (const controller of controllers.values()) {
+			for (const [requestId, controller] of controllers) {
+				rejectStoppedBridgeRequest(activeSettlements.get(requestId));
 				controller.abort();
 			}
 			controllers.clear();
+			activeSettlements.clear();
 			pendingCancels.clear();
 		},
 		dispose: () => {