@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/intercom/lazy-subagent-ack.ts

@@ -1,25 +0,0 @@
-import { isStaleExtensionContextError, type ExtensionAPI } from "@bastani/atomic";
-
-const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
-const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
-
-export function rejectLazyResultRelay(
-  pi: ExtensionAPI,
-  eventName: string,
-  payload: unknown,
-  error: unknown,
-): void {
-  if (eventName !== SUBAGENT_RESULT_INTERCOM_EVENT || !payload || typeof payload !== "object") return;
-  const requestId = (payload as { requestId?: unknown }).requestId;
-  if (typeof requestId !== "string") return;
-  try {
-    pi.events.emit(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, {
-      requestId,
-      delivered: false,
-      error: error instanceof Error ? error.message : String(error),
-    });
-  } catch (emitError) {
-    if (!isStaleExtensionContextError(emitError)) throw emitError;
-    // The failed relay can race extension invalidation; no acknowledgement is possible.
-  }
-}

package/dist/builtin/intercom/lazy-tool-execution.ts

@@ -1,39 +0,0 @@
-import type { ExtensionCommandContext, ExtensionContext, ToolDefinition } from "@bastani/atomic";
-
-type CommandHandler = (args: string, ctx: ExtensionCommandContext) => void | Promise<void>;
-type ExecutableHeavy = {
-	tools: Map<string, ToolDefinition>;
-	commands: Map<string, { handler: CommandHandler }>;
-};
-
-export type HeavyHandle<THeavy extends ExecutableHeavy> = {
-	heavy: THeavy;
-	assertCurrent: () => void;
-};
-
-export async function executeHeavyTool<THeavy extends ExecutableHeavy>(
-	loadHeavy: (ctx?: ExtensionContext) => Promise<HeavyHandle<THeavy>>,
-	name: string,
-	args: Parameters<NonNullable<ToolDefinition["execute"]>>,
-): Promise<Awaited<ReturnType<NonNullable<ToolDefinition["execute"]>>>> {
-	const handle = await loadHeavy(args[4]);
-	handle.assertCurrent();
-	const tool = handle.heavy.tools.get(name);
-	if (!tool?.execute) throw new Error(`Intercom tool implementation not found: ${name}`);
-	const result = await tool.execute(...args);
-	handle.assertCurrent();
-	return result as Awaited<ReturnType<NonNullable<ToolDefinition["execute"]>>>;
-}
-
-export async function runHeavyCommand<THeavy extends ExecutableHeavy>(
-	loadHeavy: (ctx?: ExtensionContext) => Promise<HeavyHandle<THeavy>>,
-	args: string | undefined,
-	ctx: ExtensionCommandContext,
-): Promise<void> {
-	const handle = await loadHeavy(ctx);
-	handle.assertCurrent();
-	const command = handle.heavy.commands.get("intercom");
-	if (!command) throw new Error("Intercom command implementation not found");
-	await command.handler(args ?? "", ctx);
-	handle.assertCurrent();
-}

package/dist/builtin/intercom/lifecycle-lease.ts

@@ -1,51 +0,0 @@
-export interface LifecycleLease<TShutdown> {
-	readonly id: number;
-	readonly priorCleanup: Promise<void>;
-	retired: boolean;
-	shutdown: TShutdown | null;
-	cleanupBarrier: Promise<void>;
-}
-
-export function createLifecycleLease<TShutdown>(
-	id: number,
-	priorCleanup: Promise<void> = Promise.resolve(),
-): LifecycleLease<TShutdown> {
-	return { id, priorCleanup, retired: false, shutdown: null, cleanupBarrier: priorCleanup };
-}
-
-export function retireLifecycleLease<TShutdown>(lease: LifecycleLease<TShutdown>, shutdown: TShutdown): void {
-	if (lease.retired) return;
-	lease.retired = true;
-	lease.shutdown = shutdown;
-}
-
-export function retainSettledLifecycleCleanup<TShutdown>(
-	lease: LifecycleLease<TShutdown>,
-	cleanup: readonly (Promise<unknown> | null)[],
-): Promise<void> {
-	const previousCleanup = lease.cleanupBarrier;
-	const pendingCleanup = cleanup.filter((task): task is Promise<unknown> => task !== null);
-	lease.cleanupBarrier = Promise.allSettled([previousCleanup, ...pendingCleanup]).then(() => undefined);
-	return lease.cleanupBarrier;
-}
-
-export function assertCurrentLifecycleLease<TShutdown>(
-	current: LifecycleLease<TShutdown>,
-	expected: LifecycleLease<TShutdown>,
-	message: string,
-): void {
-	if (current !== expected || expected.retired) throw new Error(message);
-}
-
-/** Rejection-safe FIFO for lifecycle forwarding that must not overtake replay. */
-export class SerializedLifecycleForwarder {
-	private tail: Promise<void> = Promise.resolve();
-
-	get settled(): Promise<void> { return this.tail; }
-
-	enqueue<T>(operation: () => Promise<T>): Promise<T> {
-		const result = this.tail.then(operation, operation);
-		this.tail = result.then(() => undefined, () => undefined);
-		return result;
-	}
-}

package/dist/builtin/intercom/lifecycle.ts

@@ -1,144 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import type { IntercomClient } from "./broker/client.js";
-import type { IntercomConfig } from "./config.ts";
-import { buildPresenceIdentity } from "./intercom-utils.js";
-import type { InboundIdleQueue } from "./inbound-idle-queue.js";
-import type { ReplyTracker } from "./reply-tracker.js";
-
-interface LifecycleDeps {
-  config: IntercomConfig;
-  client(): IntercomClient | null;
-  setClient(client: IntercomClient | null): void;
-  setShuttingDown(value: boolean): void;
-  setDisposed(value: boolean): void;
-  setRuntimeStarted(value: boolean): void;
-  incrementRuntimeGeneration(): number;
-  resetReconnectAttempt(): void;
-  clearReconnectTimer(): void;
-  setRuntimeContext(ctx: ExtensionContext | null): void;
-  setCurrentSessionId(id: string | null): void;
-  setCurrentModel(model: string): void;
-  setSessionStartedAt(value: number | null): void;
-  setAgentRunning(value: boolean): void;
-  activeTools: Map<string, string>;
-  getLiveContext(ctx?: ExtensionContext | null, generation?: number): ExtensionContext | null;
-  rejectReplyWaiter(error: Error): void;
-  replyTracker: ReplyTracker | (() => ReplyTracker);
-  bindReplyTracker?(ctx: ExtensionContext): void;
-  preserveReplyTrackerOnCleanup?(): boolean;
-  pendingIdleMessages: InboundIdleQueue;
-  clearInboundFlushTimer(): void;
-  scheduleInboundFlush(delayMs?: number): void;
-  syncPresenceStatus(): void;
-  syncPresenceIdentity(sessionId: string): void;
-  currentStatus(): string;
-  restoreIntercomSessionIdEnv?(): void;
-}
-
-export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps): void {
-  const activeReplyTracker = (): ReplyTracker =>
-    typeof deps.replyTracker === "function" ? deps.replyTracker() : deps.replyTracker;
-  let hasActiveSession = false;
-
-  async function cleanupRuntime(reason: string): Promise<void> {
-    deps.setRuntimeStarted(false);
-    deps.setShuttingDown(true);
-    deps.setDisposed(true);
-    deps.incrementRuntimeGeneration();
-    deps.clearReconnectTimer();
-    deps.rejectReplyWaiter(new Error(reason));
-    if (deps.preserveReplyTrackerOnCleanup?.() !== true) activeReplyTracker().reset();
-    deps.pendingIdleMessages.clear();
-    deps.clearInboundFlushTimer();
-    deps.setAgentRunning(false);
-    deps.activeTools.clear();
-    const activeClient = deps.client();
-    deps.setClient(null);
-    if (activeClient) {
-      try {
-        await activeClient.disconnect();
-      } catch (error) {
-        console.error(`Intercom failed to disconnect during ${reason.toLowerCase()}; continuing cleanup:`, error);
-      }
-    }
-    deps.restoreIntercomSessionIdEnv?.();
-    deps.setRuntimeContext(null);
-    deps.setCurrentSessionId(null);
-    deps.setSessionStartedAt(null);
-  }
-
-  pi.on("session_start", async (_event, ctx) => {
-    if (!deps.config.enabled) return;
-    if (hasActiveSession) await cleanupRuntime("Session replaced");
-    hasActiveSession = true;
-    deps.setShuttingDown(false);
-    deps.setDisposed(false);
-    deps.setRuntimeStarted(true);
-    deps.incrementRuntimeGeneration();
-    deps.resetReconnectAttempt();
-    deps.clearReconnectTimer();
-    deps.setRuntimeContext(ctx);
-    deps.bindReplyTracker?.(ctx);
-    deps.setCurrentSessionId(ctx.sessionManager.getSessionId());
-    deps.setCurrentModel(ctx.model?.id ?? "unknown");
-    deps.setSessionStartedAt(Date.now());
-    deps.setAgentRunning(false);
-    deps.activeTools.clear();
-  });
-
-  pi.on("session_shutdown", async () => {
-    if (!hasActiveSession) return;
-    hasActiveSession = false;
-    await cleanupRuntime("Session shutting down");
-  });
-
-  pi.on("turn_end", () => {
-    if (!deps.getLiveContext()) return;
-    activeReplyTracker().endTurn();
-    // Preserve the normal grace period so a same-tick terminal barrier can
-    // claim accepted child messages before idle delivery releases ownership.
-    deps.scheduleInboundFlush();
-  });
-  pi.on("agent_start", () => {
-    if (!deps.getLiveContext()) return;
-    deps.setAgentRunning(true);
-    deps.activeTools.clear();
-    deps.syncPresenceStatus();
-  });
-  pi.on("tool_execution_start", (event) => {
-    if (!deps.getLiveContext()) return;
-    deps.activeTools.set(event.toolCallId, event.toolName);
-    deps.syncPresenceStatus();
-  });
-  pi.on("tool_execution_end", (event) => {
-    if (!deps.getLiveContext()) return;
-    deps.activeTools.delete(event.toolCallId);
-    deps.syncPresenceStatus();
-  });
-  pi.on("agent_end", () => {
-    if (!deps.getLiveContext()) return;
-    deps.setAgentRunning(false);
-    deps.activeTools.clear();
-    deps.syncPresenceStatus();
-    deps.scheduleInboundFlush();
-  });
-  pi.on("turn_start", (_event, ctx) => {
-    if (!deps.getLiveContext(ctx)) return;
-    deps.bindReplyTracker?.(ctx);
-    deps.setCurrentSessionId(ctx.sessionManager.getSessionId());
-    deps.syncPresenceIdentity(ctx.sessionManager.getSessionId());
-    activeReplyTracker().beginTurn();
-  });
-  pi.on("model_select", (event, ctx) => {
-    if (!deps.getLiveContext(ctx)) return;
-    deps.setCurrentModel(event.model.id);
-    const activeClient = deps.client();
-    if (activeClient) {
-      activeClient.updatePresence({
-        ...buildPresenceIdentity(pi, ctx.sessionManager.getSessionId()),
-        model: event.model.id,
-        status: deps.currentStatus(),
-      });
-    }
-  });
-}

package/dist/builtin/intercom/overlay.ts

@@ -1,96 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import type { IntercomClient } from "./broker/client.js";
-import type { ComposeResult } from "./ui/compose.ts";
-import { ComposeOverlay } from "./ui/compose.ts";
-import { SessionListOverlay } from "./ui/session-list.ts";
-import type { SessionInfo } from "./types.js";
-import { duplicateSessionNames, formatSessionLabel, getErrorMessage } from "./intercom-utils.js";
-
-interface OverlayDeps {
-  runtimeGeneration(): number;
-  getLiveContext(ctx?: ExtensionContext | null, generation?: number): ExtensionContext | null;
-  notifyIfLive(ctx: ExtensionContext, message: string, level: "info" | "warning" | "error", generation?: number): void;
-  ensureConnected(reason: "overlay"): Promise<IntercomClient>;
-  syncPresenceIdentity(sessionId: string): void;
-}
-
-export function registerIntercomOverlay(pi: ExtensionAPI, deps: OverlayDeps): void {
-  async function openIntercomOverlay(ctx: ExtensionContext): Promise<void> {
-    const overlayGeneration = deps.runtimeGeneration();
-    const liveContext = deps.getLiveContext(ctx, overlayGeneration);
-    if (!liveContext?.hasUI) return;
-
-    let overlayClient: IntercomClient;
-    try {
-      overlayClient = await deps.ensureConnected("overlay");
-    } catch (error) {
-      deps.notifyIfLive(ctx, `Intercom unavailable: ${getErrorMessage(error)}`, "error", overlayGeneration);
-      return;
-    }
-    if (!deps.getLiveContext(ctx, overlayGeneration)) return;
-
-    deps.syncPresenceIdentity(ctx.sessionManager.getSessionId());
-
-    let currentSession: SessionInfo;
-    let sessions: SessionInfo[];
-    let duplicates: Set<string>;
-    try {
-      const mySessionId = overlayClient.sessionId;
-      const allSessions = await overlayClient.listSessions();
-      if (!deps.getLiveContext(ctx, overlayGeneration)) return;
-      const foundCurrentSession = allSessions.find(s => s.id === mySessionId);
-      if (!foundCurrentSession) {
-        deps.notifyIfLive(ctx, "Current session is missing from intercom session list", "error", overlayGeneration);
-        return;
-      }
-      currentSession = foundCurrentSession;
-      duplicates = duplicateSessionNames(allSessions);
-      sessions = allSessions.filter(s => s.id !== mySessionId);
-    } catch (error) {
-      deps.notifyIfLive(ctx, `Failed to list sessions: ${getErrorMessage(error)}`, "error", overlayGeneration);
-      return;
-    }
-
-    const selectedSession = await ctx.ui.custom<SessionInfo | undefined>(
-      (_tui, theme, keybindings, done) => new SessionListOverlay(theme, keybindings, currentSession, sessions, done),
-      { overlay: true }
-    ).catch(() => undefined);
-
-    if (!selectedSession || !deps.getLiveContext(ctx, overlayGeneration)) return;
-
-    try {
-      overlayClient = await deps.ensureConnected("overlay");
-    } catch (error) {
-      deps.notifyIfLive(ctx, `Intercom unavailable: ${getErrorMessage(error)}`, "error", overlayGeneration);
-      return;
-    }
-    if (!deps.getLiveContext(ctx, overlayGeneration)) return;
-
-    const targetLabel = formatSessionLabel(selectedSession, duplicates);
-
-    const result = await ctx.ui.custom<ComposeResult>(
-      (tui, theme, keybindings, done) => new ComposeOverlay(tui, theme, keybindings, selectedSession, targetLabel, overlayClient, done),
-      { overlay: true }
-    ).catch(() => undefined);
-
-    if (result?.sent && result.messageId && result.text && deps.getLiveContext(ctx, overlayGeneration)) {
-      pi.appendEntry("intercom_sent", {
-        to: selectedSession.name || selectedSession.id,
-        message: { text: result.text },
-        messageId: result.messageId,
-        timestamp: Date.now(),
-      });
-      deps.notifyIfLive(ctx, `Message sent to ${targetLabel}`, "info", overlayGeneration);
-    }
-  }
-
-  pi.registerCommand("intercom", {
-    description: "Open session intercom overlay",
-    handler: async (_args, ctx) => openIntercomOverlay(ctx),
-  });
-
-  pi.registerShortcut("alt+m", {
-    description: "Open session intercom",
-    handler: async (ctx) => openIntercomOverlay(ctx),
-  });
-}

package/dist/builtin/intercom/parent-ask-handoff.ts

@@ -1,72 +0,0 @@
-import { isStaleExtensionContextError, type ExtensionAPI } from "@bastani/atomic";
-import type {
-  ChildOrchestratorMetadata,
-  SupervisorInterviewRequest,
-} from "./intercom-utils.js";
-import type { Attachment } from "./types.js";
-
-export const PARENT_ASK_HANDOFF_REQUEST_EVENT = "subagent:parent-ask-handoff-request";
-
-const PROCESS_PARENT_ASK_CLAIMS = Symbol.for("atomic/subagents/parent-ask-claims@1");
-
-type ProcessParentAskClaimHandler = (payload: unknown) => void;
-
-interface ProcessParentAskClaimRegistry {
-  handlers: Set<ProcessParentAskClaimHandler>;
-}
-
-function processClaimRegistry(): ProcessParentAskClaimRegistry | undefined {
-  const slots = globalThis as typeof globalThis & Record<symbol, ProcessParentAskClaimRegistry | undefined>;
-  return slots[PROCESS_PARENT_ASK_CLAIMS];
-}
-
-export type ParentAskKind = "decision" | "interview" | "intercom";
-
-export interface ParentAskHandoffRequest {
-  runId: string;
-  index: number;
-  agent: string;
-  childIntercomTarget: string;
-  orchestratorTarget: string;
-  kind: ParentAskKind;
-  question: string;
-  attachments?: Attachment[];
-  interview?: SupervisorInterviewRequest;
-  resolvedTargetId?: string;
-  taskContext?: string;
-  claimed: boolean;
-}
-
-export function requestParentAskHandoff(
-  events: ExtensionAPI["events"] | undefined,
-  metadata: ChildOrchestratorMetadata,
-  input: Pick<ParentAskHandoffRequest, "kind" | "question" | "attachments" | "interview" | "resolvedTargetId">,
-): boolean {
-  const index = Number(metadata.index);
-  if (!events || !Number.isInteger(index) || index < 0 || !metadata.sessionName) return false;
-  const request: ParentAskHandoffRequest = {
-    runId: metadata.runId,
-    index,
-    agent: metadata.agent,
-    childIntercomTarget: metadata.sessionName,
-    orchestratorTarget: metadata.orchestratorTarget,
-    kind: input.kind,
-    question: input.question,
-    ...(input.attachments ? { attachments: input.attachments } : {}),
-    ...(input.interview ? { interview: input.interview } : {}),
-    ...(input.resolvedTargetId ? { resolvedTargetId: input.resolvedTargetId } : {}),
-    claimed: false,
-  };
-  try {
-    events.emit(PARENT_ASK_HANDOFF_REQUEST_EVENT, request);
-  } catch (error) {
-    if (!isStaleExtensionContextError(error)) throw error;
-  }
-  if (!request.claimed) {
-    for (const handler of [...(processClaimRegistry()?.handlers ?? [])]) {
-      handler(request);
-      if (request.claimed) break;
-    }
-  }
-  return request.claimed;
-}

package/dist/builtin/intercom/reconnect-backoff.ts

@@ -1,6 +0,0 @@
-const BACKOFF_MS = [1000, 2000, 5000, 10000, 30000] as const;
-
-/** Reconnect backoff delay for the given zero-based attempt (clamped to the max step). */
-export function reconnectDelayMs(attempt: number): number {
-  return BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)]!;
-}

package/dist/builtin/intercom/reply-routing.ts

@@ -1,17 +0,0 @@
-import type { Message, SessionInfo } from "./types.js";
-
-export interface PendingReplyRoute {
-	from: string;
-	replyTo: string;
-	resolve(message: Message): void;
-}
-
-/** Routes only the exact sender/thread pair to a blocking tool waiter. */
-export function routeIncomingReply(waiter: PendingReplyRoute | null | undefined, from: SessionInfo, message: Message): boolean {
-	if (!waiter) return false;
-	const senderTarget = from.name || from.id;
-	const fromMatches = senderTarget.toLowerCase() === waiter.from.toLowerCase() || from.id === waiter.from;
-	if (!fromMatches || message.replyTo !== waiter.replyTo) return false;
-	waiter.resolve(message);
-	return true;
-}

package/dist/builtin/intercom/reply-tracker.ts

@@ -1,110 +0,0 @@
-import type { Message, SessionInfo } from "./types.js";
-import { resolveSessionTarget, sessionTargetFailureReason } from "./session-target.js";
-
-export interface IntercomContext {
-  from: SessionInfo;
-  message: Message;
-  receivedAt: number;
-}
-
-export class ReplyTracker {
-  private readonly pendingAsks = new Map<string, IntercomContext>();
-  private readonly pendingTurnContexts: IntercomContext[] = [];
-  private currentTurnContext: IntercomContext | null = null;
-
-  constructor(private readonly askTimeoutMs = 10 * 60 * 1000) {}
-
-  recordIncomingMessage(from: SessionInfo, message: Message, receivedAt = Date.now()): IntercomContext {
-    const context = { from, message, receivedAt };
-    if (message.expectsReply) {
-      this.pendingAsks.set(message.id, context);
-    }
-    return context;
-  }
-
-  queueTurnContext(context: IntercomContext): void {
-    this.pendingTurnContexts.push(context);
-  }
-
-  forgetIncomingMessage(context: IntercomContext): void {
-    if (this.pendingAsks.get(context.message.id) === context) this.pendingAsks.delete(context.message.id);
-    for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
-      if (this.pendingTurnContexts[index] === context) this.pendingTurnContexts.splice(index, 1);
-    }
-    if (this.currentTurnContext === context) this.currentTurnContext = null;
-  }
-
-  beginTurn(now = Date.now()): void {
-    this.pruneExpired(now);
-    this.currentTurnContext = this.pendingTurnContexts.shift() ?? null;
-  }
-
-  endTurn(): void {
-    this.currentTurnContext = null;
-  }
-
-  reset(): void {
-    this.pendingAsks.clear();
-    this.pendingTurnContexts.length = 0;
-    this.currentTurnContext = null;
-  }
-
-  resolveReplyTarget(options: { to?: string }, now = Date.now()): IntercomContext {
-    this.pruneExpired(now);
-
-    if (this.currentTurnContext) {
-      return this.currentTurnContext;
-    }
-
-    const pending = Array.from(this.pendingAsks.values());
-    if (options.to) {
-      const senders = [...new Map(
-        pending.map((context) => [context.from.id, context.from] as const),
-      ).values()];
-      const resolution = resolveSessionTarget(senders, options.to);
-      if (resolution.kind !== "resolved") {
-        if (resolution.kind === "not_found") {
-          throw new Error(`No pending ask from "${options.to}"`);
-        }
-        throw new Error(sessionTargetFailureReason(options.to, resolution));
-      }
-      const matches = pending.filter(
-        (context) => context.from.id === resolution.session.id,
-      );
-      if (matches.length === 1) return matches[0]!;
-      if (matches.length > 1) {
-        throw new Error(`Multiple pending asks from "${options.to}"`);
-      }
-      throw new Error(`No pending ask from "${options.to}"`);
-    }
-    if (pending.length === 1) {
-      return pending[0]!;
-    }
-
-    if (pending.length === 0) {
-      throw new Error("No active intercom context to reply to");
-    }
-
-    throw new Error("Multiple pending asks — specify `to`");
-  }
-
-  markReplied(replyTo: string): void {
-    this.pendingAsks.delete(replyTo);
-    if (this.currentTurnContext?.message.id === replyTo) {
-      this.currentTurnContext = null;
-    }
-  }
-
-  listPending(now = Date.now()): IntercomContext[] {
-    this.pruneExpired(now);
-    return Array.from(this.pendingAsks.values()).sort((a, b) => a.receivedAt - b.receivedAt);
-  }
-
-  private pruneExpired(now: number): void {
-    for (const [messageId, context] of this.pendingAsks) {
-      if (now - context.receivedAt > this.askTimeoutMs) {
-        this.pendingAsks.delete(messageId);
-      }
-    }
-  }
-}

package/dist/builtin/intercom/reply-waiter.ts

@@ -1,115 +0,0 @@
-import type { Message } from "./types.js";
-
-export interface ReplyWaiterRecord {
-  from: string;
-  replyTo: string;
-  resolve(message: Message): void;
-  reject(error: Error): void;
-}
-
-/** Handle owned by the tool call that won waiter admission. */
-export interface ReplyWait {
-  /**
-   * Resolves with the correlated reply, or rejects on timeout, cancellation,
-   * send failure, or disconnect. The rejection is pre-handled internally, so
-   * the promise can safely sit unawaited between other awaits (for example
-   * while the question is still being sent) without ever becoming an
-   * unhandled rejection.
-   */
-  promise: Promise<Message>;
-  /** Rejects only this waiter. No-op once it settled or was replaced. */
-  cancel(error: Error): void;
-}
-
-export type ReplyWaitAdmission =
-  | { ok: true; wait: ReplyWait }
-  | { ok: false; reason: "busy" | "cancelled" };
-
-export const DEFAULT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
-
-/**
- * Single-slot reply waiter with atomic admission.
- *
- * Admission is a synchronous check-and-reserve: when two blocking asks race
- * (parallel tool calls, cross-tool intercom/contact_supervisor concurrency),
- * the first reservation wins and every concurrent loser receives a structured
- * `{ ok: false, reason: "busy" }` refusal instead of a rejected promise.
- * Cancellation and failure paths settle only their own waiter, so a losing or
- * failing call can never tear down a reservation owned by another call.
- */
-export class ReplyWaiterSlot {
-  private waiter: ReplyWaiterRecord | null = null;
-
-  constructor(private readonly timeoutMs: number = DEFAULT_REPLY_TIMEOUT_MS) {}
-
-  /** The currently pending waiter, used for inbound reply correlation. */
-  current(): ReplyWaiterRecord | null {
-    return this.waiter;
-  }
-
-  has(): boolean {
-    return this.waiter !== null;
-  }
-
-  /**
-   * Rejects whichever waiter is currently pending. Reserved for slot-wide
-   * teardown (session shutdown/replacement, broker disconnect); individual
-   * tool calls must use their own `ReplyWait.cancel` instead.
-   */
-  rejectCurrent(error: Error): void {
-    this.waiter?.reject(error);
-  }
-
-  begin(from: string, replyTo: string, signal?: AbortSignal): ReplyWaitAdmission {
-    if (this.waiter) {
-      return { ok: false, reason: "busy" };
-    }
-    if (signal?.aborted) {
-      return { ok: false, reason: "cancelled" };
-    }
-    let record!: ReplyWaiterRecord;
-    const promise = new Promise<Message>((resolve, reject) => {
-      let settled = false;
-      const timeout = setTimeout(() => {
-        record.reject(new Error(`No reply from "${from}" within ${Math.round(this.timeoutMs / 60_000)} minutes`));
-      }, this.timeoutMs);
-      const onAbort = () => {
-        record.reject(new Error("Cancelled"));
-      };
-      const cleanup = () => {
-        settled = true;
-        clearTimeout(timeout);
-        signal?.removeEventListener("abort", onAbort);
-        if (this.waiter === record) {
-          this.waiter = null;
-        }
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-      record = {
-        from,
-        replyTo,
-        resolve: (message) => {
-          if (settled) return;
-          cleanup();
-          resolve(message);
-        },
-        reject: (error) => {
-          if (settled) return;
-          cleanup();
-          reject(error);
-        },
-      };
-      this.waiter = record;
-    });
-    // Pre-attach a handler so a rejection that fires while the owner is
-    // between awaits can never crash the process as an unhandled rejection.
-    promise.catch(() => undefined);
-    return {
-      ok: true,
-      wait: {
-        promise,
-        cancel: (error) => record.reject(error),
-      },
-    };
-  }
-}