@bastani/atomic 0.9.10 → 0.9.11-alpha.10

package/dist/builtin/subagents/src/runs/foreground/execution-attempt-control.ts

@@ -1,13 +1,13 @@
 import type { AgentConfig } from "../../agents/agents.ts";
 import type { AgentProgress, ControlEvent, RunSyncOptions, SingleResult } from "../../shared/types.ts";
+import { nextLongRunningTrigger } from "../shared/long-running-guard.ts";
 import {
-	DEFAULT_CONTROL_CONFIG,
 	buildControlEvent,
 	claimControlNotification,
+	DEFAULT_CONTROL_CONFIG,
 	deriveActivityState,
 	shouldNotifyControlEvent,
 } from "../shared/subagent-control.ts";
-import { nextLongRunningTrigger } from "../shared/long-running-guard.ts";
 
 export type NeedsAttentionInput = {
 	message?: string;
@@ -54,51 +54,56 @@ export function createAttemptControlRuntime(input: {
 		if (!controlConfig.enabled) return false;
 		const previous = input.progress.activityState;
 		input.progress.activityState = "needs_attention";
-		emitControlEvent(buildControlEvent({
-			type: "needs_attention",
-			from: previous,
-			to: "needs_attention",
-			runId: input.options.runId,
-			agent: input.agent.name,
-			index: input.options.index,
-			ts: now,
-			lastActivityAt: input.progress.lastActivityAt,
-			message: details.message,
-			reason: details.reason ?? "idle",
-			turns: input.result.usage.turns,
-			tokens: input.progress.tokens,
-			toolCount: input.progress.toolCount,
-			currentTool: details.currentTool ?? input.progress.currentTool,
-			currentToolDurationMs: details.currentToolDurationMs ?? currentToolDurationMs(now),
-			currentPath: details.currentPath ?? input.progress.currentPath,
-			recentFailureSummary: details.recentFailureSummary,
-		}));
+		emitControlEvent(
+			buildControlEvent({
+				type: "needs_attention",
+				from: previous,
+				to: "needs_attention",
+				runId: input.options.runId,
+				agent: input.agent.name,
+				index: input.options.index,
+				ts: now,
+				lastActivityAt: input.progress.lastActivityAt,
+				message: details.message,
+				reason: details.reason ?? "idle",
+				turns: input.result.usage.turns,
+				tokens: input.progress.tokens,
+				toolCount: input.progress.toolCount,
+				currentTool: details.currentTool ?? input.progress.currentTool,
+				currentToolDurationMs: details.currentToolDurationMs ?? currentToolDurationMs(now),
+				currentPath: details.currentPath ?? input.progress.currentPath,
+				recentFailureSummary: details.recentFailureSummary,
+			}),
+		);
 		return previous !== "needs_attention";
 	};
 
 	const emitActiveLongRunning = (now: number, reason: ControlEvent["reason"]): boolean => {
-		if (!controlConfig.enabled || activeLongRunningNotified || input.progress.activityState === "needs_attention") return false;
+		if (!controlConfig.enabled || activeLongRunningNotified || input.progress.activityState === "needs_attention")
+			return false;
 		activeLongRunningNotified = true;
 		const previous = input.progress.activityState;
 		input.progress.activityState = "active_long_running";
-		emitControlEvent(buildControlEvent({
-			type: "active_long_running",
-			from: previous,
-			to: "active_long_running",
-			runId: input.options.runId,
-			agent: input.agent.name,
-			index: input.options.index,
-			ts: now,
-			message: `${input.agent.name} is still active but long-running`,
-			reason,
-			turns: input.result.usage.turns,
-			tokens: input.progress.tokens,
-			toolCount: input.progress.toolCount,
-			currentTool: input.progress.currentTool,
-			currentToolDurationMs: currentToolDurationMs(now),
-			currentPath: input.progress.currentPath,
-			elapsedMs: now - input.startTime,
-		}));
+		emitControlEvent(
+			buildControlEvent({
+				type: "active_long_running",
+				from: previous,
+				to: "active_long_running",
+				runId: input.options.runId,
+				agent: input.agent.name,
+				index: input.options.index,
+				ts: now,
+				message: `${input.agent.name} is still active but long-running`,
+				reason,
+				turns: input.result.usage.turns,
+				tokens: input.progress.tokens,
+				toolCount: input.progress.toolCount,
+				currentTool: input.progress.currentTool,
+				currentToolDurationMs: currentToolDurationMs(now),
+				currentPath: input.progress.currentPath,
+				elapsedMs: now - input.startTime,
+			}),
+		);
 		return true;
 	};
 

package/dist/builtin/subagents/src/runs/foreground/execution-attempt-finalize.ts

@@ -1,9 +1,9 @@
 import type { AgentProgress, ControlEvent, RunSyncOptions, SingleResult } from "../../shared/types.ts";
 import { detectSubagentError, getFinalOutput } from "../../shared/utils.ts";
-import { readStructuredOutput } from "../shared/structured-output.ts";
 import { formatSavedOutputReference, resolveSingleOutput } from "../shared/single-output.ts";
-import { artifactOutputByResult, snapshotProgress, snapshotResult } from "./execution-utils.ts";
+import { readStructuredOutput } from "../shared/structured-output.ts";
 import type { RunSingleAttemptShared } from "./execution-attempt-types.ts";
+import { artifactOutputByResult, snapshotProgress, snapshotResult } from "./execution-utils.ts";
 
 export function finalizeSingleAttempt(input: {
 	result: SingleResult;
@@ -85,9 +85,10 @@ export function finalizeSingleAttempt(input: {
 	}
 	artifactOutputByResult.set(result, fullOutput);
 	result.outputMode = options.outputMode ?? "inline";
-	result.finalOutput = options.outputMode === "file-only" && result.savedOutputPath && result.outputReference
-		? result.outputReference.message
-		: fullOutput;
+	result.finalOutput =
+		options.outputMode === "file-only" && result.savedOutputPath && result.outputReference
+			? result.outputReference.message
+			: fullOutput;
 	result.controlEvents = allControlEvents.length ? allControlEvents : undefined;
 	if (options.onUpdate) {
 		const finalText = result.finalOutput || result.error || "(no output)";

package/dist/builtin/subagents/src/runs/foreground/execution-attempt.ts

@@ -2,15 +2,18 @@ import { spawn } from "node:child_process";
 import { existsSync, unlinkSync } from "node:fs";
 import type { Message } from "@earendil-works/pi-ai/compat";
 import type { AgentConfig } from "../../agents/agents.ts";
-import { type AgentProgress, type RunSyncOptions, type SingleResult, getSubagentDepthEnv } from "../../shared/types.ts";
-import { extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "../../shared/utils.ts";
+import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
+import { resolveSubagentModelFastMode } from "../../shared/fast-mode.ts";
 import { createJsonlWriter } from "../../shared/jsonl-writer.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
-import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
-import { formatPiSpawnError, getPiSpawnCommand, validatePiSpawnCwd } from "../shared/pi-spawn.ts";
-import { assistantStopReason, isAssistantFailureStopReason, shouldStartSubagentFinalDrain } from "../shared/final-drain.ts";
-import { modelFailureMessage } from "../shared/model-fallback.ts";
+import { type AgentProgress, getSubagentDepthEnv, type RunSyncOptions, type SingleResult } from "../../shared/types.ts";
+import { extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "../../shared/utils.ts";
 import { createAttemptWatchdog } from "../shared/attempt-watchdog.ts";
+import {
+	assistantStopReason,
+	isAssistantFailureStopReason,
+	shouldStartSubagentFinalDrain,
+} from "../shared/final-drain.ts";
 import {
 	createMutatingFailureState,
 	didMutatingToolFail,
@@ -21,13 +24,21 @@ import {
 	shouldEscalateMutatingFailures,
 	summarizeRecentMutatingFailures,
 } from "../shared/long-running-guard.ts";
-import { resolveSubagentModelFastMode } from "../../shared/fast-mode.ts";
-import { appendRecentOutput, emptyUsage, modelFailureSignalByResult, snapshotProgress, snapshotResult } from "./execution-utils.ts";
+import { modelFailureMessage } from "../shared/model-fallback.ts";
+import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
+import { formatPiSpawnError, getPiSpawnCommand, validatePiSpawnCwd } from "../shared/pi-spawn.ts";
+import { buildSubagentSpawnEnv } from "../shared/spawn-env.ts";
 import { createAttemptControlRuntime } from "./execution-attempt-control.ts";
 import { finalizeSingleAttempt } from "./execution-attempt-finalize.ts";
-import { registerExecutionIntercomDetach } from "./execution-intercom-detach.ts";
 import type { RunSingleAttemptShared } from "./execution-attempt-types.ts";
-import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
+import { registerExecutionIntercomDetach } from "./execution-intercom-detach.ts";
+import {
+	appendRecentOutput,
+	emptyUsage,
+	modelFailureSignalByResult,
+	snapshotProgress,
+	snapshotResult,
+} from "./execution-utils.ts";
 export async function runSingleAttempt(
 	runtimeCwd: string,
 	agent: AgentConfig,
@@ -44,10 +55,15 @@ export async function runSingleAttempt(
 		settings: shared.fastModeSettings,
 		scope: shared.fastModeScope,
 	});
-	const supervisorAuthorization = options.orchestratorIntercomTarget && options.intercomSessionName
-		? await requestSupervisorAuthorization(options.intercomEvents, options.intercomSessionName)
-		: undefined;
-	const { args, env: sharedEnv, tempDir } = buildPiArgs({
+	const supervisorAuthorization =
+		options.orchestratorIntercomTarget && options.intercomSessionName
+			? await requestSupervisorAuthorization(options.intercomEvents, options.intercomSessionName)
+			: undefined;
+	const {
+		args,
+		env: sharedEnv,
+		tempDir,
+	} = buildPiArgs({
 		baseArgs: ["--mode", "json", "-p"],
 		task,
 		sessionEnabled: shared.sessionEnabled,
@@ -116,19 +132,26 @@ export async function runSingleAttempt(
 	};
 	result.progress = progress;
 	const controlRuntime = createAttemptControlRuntime({ options, agent, result, progress, startTime });
-	const spawnEnv = {
-		...process.env,
-		...sharedEnv,
-		...getSubagentDepthEnv(options.maxSubagentDepth, {
+	const spawnEnv = buildSubagentSpawnEnv(
+		process.env,
+		sharedEnv,
+		getSubagentDepthEnv(options.maxSubagentDepth, {
 			workflowStageSubagentGuard: options.workflowStageSubagentGuard,
 		}),
-	};
+	);
 	const cwdValidation = validatePiSpawnCwd(runCwd);
 	if (!cwdValidation.ok) {
 		cleanupTempDir(tempDir);
 		result.error = cwdValidation.error;
 		return finalizeSingleAttempt({
-			result, progress, exitCode: 1, interruptedByControl, allControlEvents: controlRuntime.allControlEvents, options, shared, startTime,
+			result,
+			progress,
+			exitCode: 1,
+			interruptedByControl,
+			allControlEvents: controlRuntime.allControlEvents,
+			options,
+			shared,
+			startTime,
 		});
 	}
 	const exitCode = await new Promise<number>((resolve) => {
@@ -156,7 +179,11 @@ export async function runSingleAttempt(
 			result.detachedReason = "intercom coordination";
 			progress.status = "detached";
 			progress.durationMs = Date.now() - startTime;
-			result.progressSummary = { toolCount: progress.toolCount, tokens: progress.tokens, durationMs: progress.durationMs };
+			result.progressSummary = {
+				toolCount: progress.toolCount,
+				tokens: progress.tokens,
+				durationMs: progress.durationMs,
+			};
 			// Settle foreground supervision while retaining process lifecycle ownership.
 			finish(-2, true);
 		};
@@ -185,7 +212,9 @@ export async function runSingleAttempt(
 				if (!termSent) return;
 				forcedTerminationSignal = true;
 				if (!cleanTerminalAssistantStopReceived && !assistantError) {
-					result.error = result.error ?? `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its final message. Forcing termination.`;
+					result.error =
+						result.error ??
+						`Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its final message. Forcing termination.`;
 				}
 				finalHardKillTimer = setTimeout(() => {
 					if (processClosed) return;
@@ -255,7 +284,10 @@ export async function runSingleAttempt(
 			controlRuntime.updateActivityState(now);
 
 			if (evt.type === "tool_execution_start") {
-				const toolArgs = evt.args && typeof evt.args === "object" && !Array.isArray(evt.args) ? evt.args as Record<string, unknown> : {};
+				const toolArgs =
+					evt.args && typeof evt.args === "object" && !Array.isArray(evt.args)
+						? (evt.args as Record<string, unknown>)
+						: {};
 				// Broker delivery is the authoritative detach trigger; tool-start observation
 				// is intentionally not required because the broker event may arrive first.
 				progress.toolCount++;
@@ -263,13 +295,22 @@ export async function runSingleAttempt(
 				progress.currentToolArgs = extractToolArgsPreview(toolArgs);
 				progress.currentToolStartedAt = now;
 				progress.currentPath = resolveCurrentPath(evt.toolName, toolArgs);
-				pendingToolResult = { tool: evt.toolName ?? "tool", path: progress.currentPath, mutates: isMutatingTool(evt.toolName, toolArgs), startedAt: now };
+				pendingToolResult = {
+					tool: evt.toolName ?? "tool",
+					path: progress.currentPath,
+					mutates: isMutatingTool(evt.toolName, toolArgs),
+					startedAt: now,
+				};
 				fireUpdate();
 			}
 
 			if (evt.type === "tool_execution_end") {
 				if (progress.currentTool) {
-					progress.recentTools.push({ tool: progress.currentTool, args: progress.currentToolArgs || "", endMs: now });
+					progress.recentTools.push({
+						tool: progress.currentTool,
+						args: progress.currentToolArgs || "",
+						endMs: now,
+					});
 				}
 				progress.currentTool = undefined;
 				progress.currentToolArgs = undefined;
@@ -324,19 +365,35 @@ export async function runSingleAttempt(
 				const toolSnapshot = pendingToolResult;
 				pendingToolResult = undefined;
 				if (toolSnapshot?.mutates && didMutatingToolFail(resultText)) {
-					recordMutatingFailure(mutatingFailures, {
-						tool: toolSnapshot.tool,
-						path: toolSnapshot.path,
-						error: resultText.split("\n").find((row) => row.trim())?.trim().slice(0, 180) ?? "mutating tool failed",
-						ts: now,
-					}, mutatingFailureWindowMs);
-					if (shouldEscalateMutatingFailures(mutatingFailures, controlRuntime.config.failedToolAttemptsBeforeAttention)) {
+					recordMutatingFailure(
+						mutatingFailures,
+						{
+							tool: toolSnapshot.tool,
+							path: toolSnapshot.path,
+							error:
+								resultText
+									.split("\n")
+									.find((row) => row.trim())
+									?.trim()
+									.slice(0, 180) ?? "mutating tool failed",
+							ts: now,
+						},
+						mutatingFailureWindowMs,
+					);
+					if (
+						shouldEscalateMutatingFailures(
+							mutatingFailures,
+							controlRuntime.config.failedToolAttemptsBeforeAttention,
+						)
+					) {
 						controlRuntime.emitNeedsAttention(now, {
 							message: `${agent.name} needs attention after repeated mutating tool failures`,
 							reason: "tool_failures",
 							currentTool: toolSnapshot.tool,
 							currentPath: toolSnapshot.path,
-							currentToolDurationMs: toolSnapshot.startedAt ? Math.max(0, now - toolSnapshot.startedAt) : undefined,
+							currentToolDurationMs: toolSnapshot.startedAt
+								? Math.max(0, now - toolSnapshot.startedAt)
+								: undefined,
 							recentFailureSummary: summarizeRecentMutatingFailures(mutatingFailures),
 						});
 					}
@@ -396,8 +453,10 @@ export async function runSingleAttempt(
 			clearFinalDrainTimers();
 			clearStdioGuard();
 			attemptWatchdog.clear();
-			removeAbortListener?.(); removeAbortListener = undefined;
-			removeInterruptListener?.(); removeInterruptListener = undefined;
+			removeAbortListener?.();
+			removeAbortListener = undefined;
+			removeInterruptListener?.();
+			removeInterruptListener = undefined;
 			cleanupIntercomDetach();
 			void jsonlWriter.close().catch(() => undefined);
 			cleanupTempDir(tempDir);
@@ -406,17 +465,31 @@ export async function runSingleAttempt(
 			if (assistantFailureSignal !== undefined && result.error === assistantError) {
 				modelFailureSignalByResult.set(result, assistantFailureSignal);
 			}
-			const forcedDrainAfterFinalSuccess = forcedTerminationSignal && cleanTerminalAssistantStopReceived && !result.error;
-			if (code !== 0 && stderrBuf.trim() && !result.error && !forcedDrainAfterFinalSuccess) result.error = stderrBuf.trim();
-			const finalCode = forcedDrainAfterFinalSuccess ? 0 : forcedTerminationSignal || signal ? (code ?? 1) : (code ?? 0);
+			const forcedDrainAfterFinalSuccess =
+				forcedTerminationSignal && cleanTerminalAssistantStopReceived && !result.error;
+			if (code !== 0 && stderrBuf.trim() && !result.error && !forcedDrainAfterFinalSuccess)
+				result.error = stderrBuf.trim();
+			const finalCode = forcedDrainAfterFinalSuccess
+				? 0
+				: forcedTerminationSignal || signal
+					? (code ?? 1)
+					: (code ?? 0);
 			if (detached) {
 				processClosed = true;
 				const recovered: SingleResult = { ...result, detached: undefined, detachedReason: undefined };
 				const recoveredProgress = recovered.progress ? { ...recovered.progress } : progress;
-				options.onDetachedExit?.(finalizeSingleAttempt({
-					result: recovered, progress: recoveredProgress, exitCode: finalCode, interruptedByControl,
-					allControlEvents: controlRuntime.allControlEvents, options: { ...options, onUpdate: undefined }, shared, startTime,
-				}));
+				options.onDetachedExit?.(
+					finalizeSingleAttempt({
+						result: recovered,
+						progress: recoveredProgress,
+						exitCode: finalCode,
+						interruptedByControl,
+						allControlEvents: controlRuntime.allControlEvents,
+						options: { ...options, onUpdate: undefined },
+						shared,
+						startTime,
+					}),
+				);
 				return;
 			}
 			processClosed = true;
@@ -437,7 +510,9 @@ export async function runSingleAttempt(
 			const kill = () => {
 				if (childExited) return;
 				trySignalChild(proc, "SIGTERM");
-				setTimeout(() => { if (!childExited) trySignalChild(proc, "SIGKILL"); }, 3000).unref?.();
+				setTimeout(() => {
+					if (!childExited) trySignalChild(proc, "SIGKILL");
+				}, 3000).unref?.();
 			};
 			if (options.signal.aborted) kill();
 			else {

package/dist/builtin/subagents/src/runs/foreground/execution-detach-reservations.ts

@@ -6,17 +6,27 @@ interface Reservation {
 }
 
 function identity(event: IntercomDetachRoute): string | undefined {
-	if (typeof event.requestId !== "string" || event.requestId.length === 0
-		|| typeof event.messageId !== "string" || event.messageId.length === 0
-		|| typeof event.senderId !== "string" || event.senderId.length === 0
-		|| typeof event.runtimeGeneration !== "number") return undefined;
+	if (
+		typeof event.requestId !== "string" ||
+		event.requestId.length === 0 ||
+		typeof event.messageId !== "string" ||
+		event.messageId.length === 0 ||
+		typeof event.senderId !== "string" ||
+		event.senderId.length === 0 ||
+		typeof event.runtimeGeneration !== "number"
+	)
+		return undefined;
 	return `${event.requestId}\0${event.messageId}\0${event.senderId}\0${event.runtimeGeneration}`;
 }
 
 function sameRoute(left: IntercomDetachRoute, right: IntercomDetachRoute): boolean {
-	return left.requestId === right.requestId && left.messageId === right.messageId
-		&& left.senderId === right.senderId && left.runtimeGeneration === right.runtimeGeneration
-		&& left.childIntercomTarget === right.childIntercomTarget;
+	return (
+		left.requestId === right.requestId &&
+		left.messageId === right.messageId &&
+		left.senderId === right.senderId &&
+		left.runtimeGeneration === right.runtimeGeneration &&
+		left.childIntercomTarget === right.childIntercomTarget
+	);
 }
 
 export class IntercomDetachReservations {

package/dist/builtin/subagents/src/runs/foreground/execution-detach-route.ts

@@ -11,7 +11,9 @@ export function matchesIntercomDetachRoute(
 	event: IntercomDetachRoute,
 	expected: { childIntercomTarget?: string },
 ): boolean {
-	return typeof event.childIntercomTarget === "string"
-		&& event.childIntercomTarget.length > 0
-		&& event.childIntercomTarget === expected.childIntercomTarget;
+	return (
+		typeof event.childIntercomTarget === "string" &&
+		event.childIntercomTarget.length > 0 &&
+		event.childIntercomTarget === expected.childIntercomTarget
+	);
 }

package/dist/builtin/subagents/src/runs/foreground/execution-intercom-detach.ts

@@ -1,47 +1,51 @@
 import {
-  INTERCOM_DETACH_REQUEST_EVENT,
-  INTERCOM_DETACH_RESPONSE_EVENT,
-  type RunSyncOptions,
+	INTERCOM_DETACH_REQUEST_EVENT,
+	INTERCOM_DETACH_RESPONSE_EVENT,
+	type RunSyncOptions,
 } from "../../shared/types.ts";
-import { matchesIntercomDetachRoute, type IntercomDetachRoute } from "./execution-detach-route.ts";
 import { IntercomDetachReservations } from "./execution-detach-reservations.ts";
+import { type IntercomDetachRoute, matchesIntercomDetachRoute } from "./execution-detach-route.ts";
 
 interface ExecutionIntercomDetachState {
-  readonly isUnavailable: () => boolean;
-  readonly isDetached: () => boolean;
-  readonly detach: () => void;
+	readonly isUnavailable: () => boolean;
+	readonly isDetached: () => boolean;
+	readonly detach: () => void;
 }
 
 /** Registers exact-owner and foreground-group detach listeners for one live child attempt. */
 export function registerExecutionIntercomDetach(
-  options: RunSyncOptions,
-  state: ExecutionIntercomDetachState,
+	options: RunSyncOptions,
+	state: ExecutionIntercomDetachState,
 ): () => void {
-  const reservations = new IntercomDetachReservations();
-  const unsubscribe = options.intercomEvents?.on?.(INTERCOM_DETACH_REQUEST_EVENT, (payload) => {
-    if (!options.allowIntercomDetach || state.isUnavailable()) return;
-    if (!payload || typeof payload !== "object") return;
-    const event = payload as IntercomDetachRoute;
-    if (typeof event.requestId !== "string" || !matchesIntercomDetachRoute(event, {
-      childIntercomTarget: options.intercomSessionName,
-    })) return;
-    if (event.phase === "probe") {
-      if (state.isDetached() || !reservations.reserve(event)) return;
-      options.intercomEvents?.emit?.(INTERCOM_DETACH_RESPONSE_EVENT, { ...event, accepted: true });
-      return;
-    }
-    if (event.phase !== "commit" || state.isDetached() || !reservations.commit(event)) return;
-    options.onIntercomDetachCommit?.();
-    state.detach();
-    options.intercomEvents?.emit?.(INTERCOM_DETACH_RESPONSE_EVENT, { ...event, accepted: true });
-  });
-  const detachSibling = () => state.detach();
-  options.intercomDetachSignal?.addEventListener("abort", detachSibling, { once: true });
-  if (options.intercomDetachSignal?.aborted) detachSibling();
+	const reservations = new IntercomDetachReservations();
+	const unsubscribe = options.intercomEvents?.on?.(INTERCOM_DETACH_REQUEST_EVENT, (payload) => {
+		if (!options.allowIntercomDetach || state.isUnavailable()) return;
+		if (!payload || typeof payload !== "object") return;
+		const event = payload as IntercomDetachRoute;
+		if (
+			typeof event.requestId !== "string" ||
+			!matchesIntercomDetachRoute(event, {
+				childIntercomTarget: options.intercomSessionName,
+			})
+		)
+			return;
+		if (event.phase === "probe") {
+			if (state.isDetached() || !reservations.reserve(event)) return;
+			options.intercomEvents?.emit?.(INTERCOM_DETACH_RESPONSE_EVENT, { ...event, accepted: true });
+			return;
+		}
+		if (event.phase !== "commit" || state.isDetached() || !reservations.commit(event)) return;
+		options.onIntercomDetachCommit?.();
+		state.detach();
+		options.intercomEvents?.emit?.(INTERCOM_DETACH_RESPONSE_EVENT, { ...event, accepted: true });
+	});
+	const detachSibling = () => state.detach();
+	options.intercomDetachSignal?.addEventListener("abort", detachSibling, { once: true });
+	if (options.intercomDetachSignal?.aborted) detachSibling();
 
-  return () => {
-    reservations.clear();
-    unsubscribe?.();
-    options.intercomDetachSignal?.removeEventListener("abort", detachSibling);
-  };
+	return () => {
+		reservations.clear();
+		unsubscribe?.();
+		options.intercomDetachSignal?.removeEventListener("abort", detachSibling);
+	};
 }