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

package/dist/builtin/intercom/contact-supervisor-tool.ts

@@ -1,328 +0,0 @@
-import type { ExtensionAPI } from "@bastani/atomic";
-import { randomUUID } from "crypto";
-import { Type } from "typebox";
-import { Text } from "@earendil-works/pi-tui";
-import type { IntercomClient } from "./broker/client.js";
-import type { ReplyWait, ReplyWaitAdmission } from "./reply-waiter.ts";
-import { requestParentAskHandoff } from "./parent-ask-handoff.js";
-import { renderContactSupervisorResult } from "./result-renderers.js";
-import {
-  type ChildOrchestratorMetadata,
-  type ContactSupervisorReason,
-  formatChildOrchestratorMessage,
-  formatSupervisorInterviewRequest,
-  formatAttachments,
-  getErrorMessage,
-  parseStructuredSupervisorReply,
-  previewText,
-  toError,
-  validateSupervisorInterviewRequest,
-} from "./intercom-utils.js";
-
-interface ContactSupervisorDeps {
-  childOrchestratorMetadata: ChildOrchestratorMetadata | null | (() => ChildOrchestratorMetadata | null);
-  ensureConnected(reason: "tool"): Promise<IntercomClient>;
-  syncPresenceIdentity(sessionId: string): void;
-  resolveSessionTarget(activeClient: IntercomClient, nameOrId: string): Promise<string | null>;
-  /**
-   * Atomically reserve the single reply-waiter slot. Returns a structured
-   * refusal when another blocking ask already holds it, so concurrent calls
-   * never observe a rejected promise.
-   */
-  beginReplyWait(from: string, replyTo: string, signal?: AbortSignal): ReplyWaitAdmission;
-  /** Advisory fast-path check; beginReplyWait is the authoritative reservation. */
-  hasReplyWaiter(): boolean;
-}
-
-export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSupervisorDeps): void {
-  const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, resolveSessionTarget, beginReplyWait, hasReplyWaiter } = deps;
-  const getMetadata = typeof childOrchestratorMetadata === "function"
-    ? childOrchestratorMetadata
-    : () => childOrchestratorMetadata;
-  if (childOrchestratorMetadata !== null) {
-    pi.registerTool({
-      name: "contact_supervisor",
-      label: "Contact Supervisor",
-      description: "Subagent-only tool for contacting the supervisor agent that delegated this task. In a live foreground child, need_decision and interview_request end the child and return a fresh-subagent handoff to the supervisor; fallback Intercom delivery waits for a reply when no foreground owner claims the request. progress_update is fire-and-forget. Do not use for routine completion handoffs.",
-      promptSnippet: "Subagent-only: yield decisions or structured interviews to the supervisor for a fresh-child follow-up, or send meaningful plan-changing progress updates.",
-      promptGuidelines: [
-        "Use contact_supervisor with reason='need_decision' when a subagent is blocked, uncertain, needs approval, or faces a product/API/scope decision. A claimed foreground request ends this child; do not wait for a reply.",
-        "Use contact_supervisor with reason='interview_request' when the child needs multiple structured answers. A claimed foreground request ends this child; the supervisor starts a fresh child with the answers.",
-        "Use contact_supervisor with reason='progress_update' only for meaningful progress or unexpected discoveries that change the plan.",
-        "Do not use contact_supervisor for routine completion handoffs; return the final subagent result normally.",
-      ],
-      parameters: Type.Object({
-        reason: Type.String({
-          enum: ["need_decision", "progress_update", "interview_request"],
-          description: "Contact reason: 'need_decision' and 'interview_request' yield a live foreground child for a fresh follow-up; 'progress_update' sends a non-blocking update",
-        }),
-        message: Type.Optional(Type.String({
-          description: "Decision request, optional interview note, or meaningful progress update for the supervisor",
-        })),
-        interview: Type.Optional(Type.Object({
-          title: Type.Optional(Type.String()),
-          description: Type.Optional(Type.String()),
-          questions: Type.Array(Type.Object({
-            id: Type.String(),
-            type: Type.String({ description: "Question type: single, multi, text, image, or info" }),
-            question: Type.String(),
-            options: Type.Optional(Type.Array(Type.Unknown())),
-            context: Type.Optional(Type.String()),
-          })),
-        }, { description: "Structured interview request for reason='interview_request'" })),
-      }),
-      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-        const reason = params.reason as ContactSupervisorReason;
-        if (reason !== "need_decision" && reason !== "progress_update" && reason !== "interview_request") {
-          return {
-            content: [{ type: "text", text: "Invalid reason. Use 'need_decision', 'interview_request', or 'progress_update'." }],
-            isError: true,
-            details: { error: true },
-          };
-        }
-        if (reason === "progress_update" && typeof params.message !== "string") {
-          return {
-            content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
-            isError: true,
-            details: { error: true },
-          };
-        }
-        const interviewValidation = reason === "interview_request"
-          ? validateSupervisorInterviewRequest(params.interview)
-          : undefined;
-        if (interviewValidation?.ok === false) {
-          return {
-            content: [{ type: "text", text: `Invalid interview request: ${interviewValidation.error}` }],
-            isError: true,
-            details: { error: true },
-          };
-        }
-        const supervisorInterview = interviewValidation?.ok === true ? interviewValidation.interview : undefined;
-		const metadata = getMetadata();
-		if (reason === "need_decision" && typeof params.message !== "string" && !metadata) {
-			return {
-				content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
-				isError: true,
-				details: { error: true },
-			};
-		}
-
-		if (!metadata) {
-			return {
-				content: [{ type: "text", text: "Supervisor contact is unavailable for this session" }],
-				isError: true,
-				details: { error: true },
-			};
-		}
-		if (signal?.aborted) {
-			return {
-				content: [{ type: "text", text: "Cancelled" }],
-				isError: true,
-				details: { error: true },
-			};
-		}
-		if (
-			reason !== "progress_update" &&
-			requestParentAskHandoff(pi.events, metadata, {
-				kind: reason === "interview_request" ? "interview" : "decision",
-				question: typeof params.message === "string" ? params.message : "",
-				...(supervisorInterview ? { interview: supervisorInterview } : {}),
-			})
-		) {
-			return {
-				content: [{ type: "text", text: "Parent ask claimed; this child is ending for a fresh subagent start." }],
-				isError: false,
-				details: { yielded: true },
-			};
-		}
-
-		if (reason === "need_decision" && typeof params.message !== "string") {
-			return {
-				content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
-				isError: true,
-				details: { error: true },
-			};
-		}
-		let connectedClient: IntercomClient;
-		try {
-			connectedClient = await ensureConnected("tool");
-		} catch (error) {
-			return {
-				content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
-				isError: true,
-				details: { error: true },
-			};
-		}
-
-		syncPresenceIdentity(ctx.sessionManager.getSessionId());
-
-		if (signal?.aborted) {
-			return {
-				content: [{ type: "text", text: "Cancelled" }],
-				isError: true,
-				details: { error: true },
-			};
-		}
-        let sendTo: string;
-        if (connectedClient.supervisorSessionId || metadata.supervisor) {
-          sendTo = connectedClient.supervisorSessionId ?? metadata.supervisor!.supervisorSessionId;
-        } else {
-          try {
-            sendTo = await resolveSessionTarget(connectedClient, metadata.orchestratorTarget) ?? metadata.orchestratorTarget;
-          } catch (error) {
-            return {
-              content: [{ type: "text", text: `Failed to resolve supervisor target: ${getErrorMessage(error)}` }],
-              isError: true,
-              details: { error: true },
-            };
-          }
-        }
-        if (signal?.aborted) {
-          return {
-            content: [{ type: "text", text: "Cancelled" }],
-            isError: true,
-            details: { error: true },
-          };
-        }
-        if (sendTo === connectedClient.sessionId) {
-          return {
-            content: [{ type: "text", text: "Cannot message the current session" }],
-            isError: true,
-            details: { error: true },
-          };
-        }
-
-        if (reason === "progress_update") {
-          const message = params.message as string;
-          try {
-            const result = await connectedClient.sendToSupervisor(sendTo, {
-              text: formatChildOrchestratorMessage("update", metadata, message),
-            });
-            if (!result.delivered) {
-              const errorText = result.reason ?? "Session may not exist or has disconnected.";
-              return {
-                content: [{ type: "text", text: `Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}` }],
-                isError: true,
-                details: { messageId: result.id, delivered: false, reason: result.reason },
-              };
-            }
-            pi.appendEntry("intercom_sent", {
-              to: metadata.orchestratorTarget,
-              message: { text: message, reason },
-              messageId: result.id,
-              timestamp: Date.now(),
-              subagent: { runId: metadata.runId, agent: metadata.agent, index: metadata.index },
-            });
-            return {
-              content: [{ type: "text", text: `Progress update sent to supervisor ${metadata.orchestratorTarget}` }],
-              isError: false,
-              details: { messageId: result.id, delivered: true },
-            };
-          } catch (error) {
-            return {
-              content: [{ type: "text", text: `Failed to send progress update: ${getErrorMessage(error)}` }],
-              isError: true,
-              details: { error: true },
-            };
-          }
-        }
-
-        if (hasReplyWaiter()) {
-          return {
-            content: [{ type: "text", text: "Already waiting for a reply" }],
-            isError: true,
-            details: { error: true },
-          };
-        }
-
-        let wait: ReplyWait | null = null;
-        try {
-          const questionId = randomUUID();
-          const admission = beginReplyWait(sendTo, questionId, signal);
-          if (!admission.ok) {
-            return {
-              content: [{ type: "text", text: admission.reason === "busy" ? "Already waiting for a reply" : "Cancelled" }],
-              isError: true,
-              details: { error: true },
-            };
-          }
-          wait = admission.wait;
-          const requestText = reason === "interview_request"
-            ? formatChildOrchestratorMessage("interview", metadata, formatSupervisorInterviewRequest(supervisorInterview!, typeof params.message === "string" ? params.message : undefined))
-            : formatChildOrchestratorMessage("ask", metadata, params.message as string);
-          const sendResult = await connectedClient.sendToSupervisor(sendTo, {
-            messageId: questionId,
-            text: requestText,
-            expectsReply: true,
-          });
-          if (!sendResult.delivered) {
-            const errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
-            wait.cancel(new Error(`Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}`));
-            return {
-              content: [{ type: "text", text: `Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}` }],
-              isError: true,
-              details: { error: true },
-            };
-          }
-          pi.appendEntry("intercom_sent", {
-            to: metadata.orchestratorTarget,
-            message: {
-              text: reason === "interview_request" ? requestText : params.message,
-              reason,
-              ...(reason === "interview_request" ? { interview: supervisorInterview } : {}),
-            },
-            messageId: sendResult.id,
-            timestamp: Date.now(),
-            subagent: { runId: metadata.runId, agent: metadata.agent, index: metadata.index },
-          });
-          const replyMessage = await wait.promise;
-          const replyText = replyMessage.content.text;
-          const replyAttachments = replyMessage.content.attachments?.length
-            ? formatAttachments(replyMessage.content.attachments)
-            : "";
-          const structuredReply = reason === "interview_request" ? parseStructuredSupervisorReply(replyText, supervisorInterview!) : undefined;
-          pi.appendEntry("intercom_received", {
-            from: metadata.orchestratorTarget,
-            message: { text: replyText, attachments: replyMessage.content.attachments },
-            messageId: replyMessage.id,
-            timestamp: replyMessage.timestamp,
-            subagent: { runId: metadata.runId, agent: metadata.agent, index: metadata.index },
-          });
-          return {
-            content: [{ type: "text", text: `**Reply from supervisor:**\n${replyText}${replyAttachments}` }],
-            isError: false,
-            details: structuredReply
-              ? structuredReply.value !== undefined
-                ? { structuredReply: structuredReply.value }
-                : { structuredReplyParseError: structuredReply.error }
-              : {},
-          };
-        } catch (error) {
-          // Settle only this call's own waiter; a concurrent call's
-          // reservation must never be torn down from this failure path.
-          wait?.cancel(toError(error));
-          return {
-            content: [{ type: "text", text: `Failed: ${getErrorMessage(error)}` }],
-            isError: true,
-            details: { error: true },
-          };
-        }
-      },
-      renderCall(args, theme) {
-        const reason = typeof args.reason === "string" ? args.reason : "contact";
-        const messagePreview = previewText(args.message, 96);
-        const interview = args.interview && typeof args.interview === "object" ? args.interview as { title?: unknown } : undefined;
-        let text = theme.fg("toolTitle", theme.bold("contact_supervisor "));
-        text += theme.fg(reason === "need_decision" ? "warning" : reason === "progress_update" ? "muted" : "accent", reason);
-        if (typeof interview?.title === "string" && interview.title.trim()) {
-          text += " " + theme.fg("accent", interview.title.trim());
-        }
-        if (messagePreview) {
-          text += "\n  " + theme.fg("dim", messagePreview);
-        }
-        return new Text(text, 0, 0);
-      },
-      renderResult: renderContactSupervisorResult,
-    });
-  }
-}

package/dist/builtin/intercom/foreground-detach-handoff.ts

@@ -1,164 +0,0 @@
-import { isStaleExtensionContextError, type ExtensionAPI } from "@bastani/atomic";
-import type { Message, SessionInfo } from "./types.js";
-
-export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
-export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
-
-interface DetachHandshake {
-  phase: "probe" | "commit";
-  requestId: string;
-  messageId: string;
-  childIntercomTarget: string;
-  senderId: string;
-  runtimeGeneration: number;
-}
-
-export type ForegroundDeliveryDisposition = "delivered" | "unclaimed" | "abandoned";
-
-/** Claims a busy inbound message only when its exact foreground owner acknowledges it. */
-export class ForegroundDetachHandoff {
-  private generation = -1;
-  private readonly delivered = new Set<string>();
-  private readonly pending = new Map<string, Promise<ForegroundDeliveryDisposition>>();
-  private generationCancellation = new AbortController();
-
-  constructor(
-    private readonly pi: Pick<ExtensionAPI, "events">,
-    private readonly ackTimeoutMs = 50,
-  ) {}
-
-  deliver(input: {
-    from: SessionInfo;
-    message: Message;
-    generation: number;
-    surface: () => void;
-    isCurrent: () => boolean;
-  }): Promise<ForegroundDeliveryDisposition> {
-    if (!input.isCurrent()) return Promise.resolve("abandoned");
-    if (this.generation !== input.generation) this.resetForGeneration(input.generation);
-    const deliveryKey = `${input.from.id}\0${input.message.id}`;
-    const pendingKey = `${input.generation}\0${deliveryKey}`;
-    if (this.delivered.has(deliveryKey)) return Promise.resolve("delivered");
-    const existing = this.pending.get(pendingKey);
-    if (existing) return existing;
-
-    const attempt = this.claimAndDeliver(input, deliveryKey).finally(() => {
-      if (this.pending.get(pendingKey) === attempt) this.pending.delete(pendingKey);
-    });
-    this.pending.set(pendingKey, attempt);
-    return attempt;
-  }
-
-  claim(
-    from: SessionInfo,
-    message: Message,
-    generation: number,
-    isCurrent: () => boolean,
-  ): Promise<ForegroundDeliveryDisposition> {
-    return this.deliver({ from, message, generation, isCurrent, surface: () => {} });
-  }
-
-  reset(): void { this.resetForGeneration(-1); }
-
-  private async claimAndDeliver(
-    input: { from: SessionInfo; message: Message; generation: number; surface: () => void; isCurrent: () => boolean },
-    deliveryKey: string,
-  ): Promise<ForegroundDeliveryDisposition> {
-    const route: DetachHandshake = {
-      phase: "probe",
-      requestId: input.message.id,
-      messageId: input.message.id,
-      childIntercomTarget: input.from.name || input.from.id,
-      senderId: input.from.id,
-      runtimeGeneration: input.generation,
-    };
-    const signal = this.generationCancellation.signal;
-    const probed = await this.awaitAcknowledgement(route, signal);
-    if (probed === "cancelled" || !input.isCurrent() || this.generation !== input.generation) return "abandoned";
-    if (probed === "timed-out") return "unclaimed";
-
-    const committed = await this.awaitAcknowledgement({ ...route, phase: "commit" }, signal);
-    if (committed === "cancelled" || !input.isCurrent() || this.generation !== input.generation) return "abandoned";
-    if (committed === "timed-out") return "unclaimed";
-    input.surface();
-    this.delivered.add(deliveryKey);
-    return "delivered";
-  }
-
-  private awaitAcknowledgement(
-    route: DetachHandshake,
-    signal: AbortSignal,
-  ): Promise<"acknowledged" | "timed-out" | "cancelled"> {
-    return new Promise((resolve) => {
-      let settled = false;
-      let unsubscribe: (() => void) | undefined;
-      let timeout: ReturnType<typeof setTimeout> | undefined;
-      const finish = (disposition: "acknowledged" | "timed-out" | "cancelled") => {
-        if (settled) return;
-        settled = true;
-        if (timeout) clearTimeout(timeout);
-        try {
-          unsubscribe?.();
-        } catch (error) {
-          if (!isStaleExtensionContextError(error)) throw error;
-          // Stale event-bus cleanup must not change the handshake result.
-        }
-        signal.removeEventListener("abort", cancel);
-        resolve(disposition);
-      };
-      const cancel = () => finish("cancelled");
-      try {
-        unsubscribe = this.pi.events?.on(INTERCOM_DETACH_RESPONSE_EVENT, (payload) => {
-          if (!payload || typeof payload !== "object") return;
-          const response = payload as Partial<DetachHandshake> & { accepted?: unknown };
-          if (response.accepted === true
-            && response.phase === route.phase
-            && response.requestId === route.requestId
-            && response.messageId === route.messageId
-            && response.childIntercomTarget === route.childIntercomTarget
-            && response.senderId === route.senderId
-            && response.runtimeGeneration === route.runtimeGeneration) finish("acknowledged");
-        });
-      } catch (error) {
-        if (!isStaleExtensionContextError(error)) throw error;
-        finish("timed-out");
-        return;
-      }
-      signal.addEventListener("abort", cancel, { once: true });
-      timeout = setTimeout(() => finish("timed-out"), this.ackTimeoutMs);
-      if (signal.aborted) {
-        cancel();
-        return;
-      }
-      try {
-        this.pi.events?.emit(INTERCOM_DETACH_REQUEST_EVENT, route);
-      } catch (error) {
-        if (!isStaleExtensionContextError(error)) throw error;
-        finish("timed-out");
-      }
-    });
-  }
-
-  private resetForGeneration(generation: number): void {
-    this.generationCancellation.abort();
-    this.generationCancellation = new AbortController();
-    this.pending.clear();
-    this.delivered.clear();
-    this.generation = generation;
-  }
-}
-
-export async function handleForegroundInboundDelivery(input: {
-  handoff: ForegroundDetachHandoff;
-  from: SessionInfo;
-  message: Message;
-  generation: number;
-  surface: () => void;
-  isCurrent: () => boolean;
-  onUnclaimed: () => void;
-  onDelivered?: () => void;
-}): Promise<void> {
-  const disposition = await input.handoff.deliver(input);
-  if (disposition === "delivered") input.onDelivered?.();
-  else if (disposition === "unclaimed" && input.isCurrent()) input.onUnclaimed();
-}

package/dist/builtin/intercom/group.ts

@@ -1,85 +0,0 @@
-/**
- * Group primitives shared by the detached broker and the host extension.
- * Keep this module free of host-package imports: the broker loads it in a
- * detached process with only Node built-ins and Intercom-local modules.
- */
-
-/**
- * Mirrors `getEnvValue("ATOMIC_INTERCOM_GROUP")` locally so the detached broker subprocess
- * needs no host package. `getEnvValue` returns the first value that is `!== undefined` across
- * `[ATOMIC_INTERCOM_GROUP, PI_INTERCOM_GROUP]`, so a defined-but-empty ATOMIC value
- * deliberately shadows the legacy name and yields `""`; `resolveHomeGroup` then falls through
- * on the empty string. `??` reproduces that exactly — do not "improve" it to `||`.
- */
-function intercomGroupFromEnv(): string | undefined {
-	return process.env.ATOMIC_INTERCOM_GROUP ?? process.env.PI_INTERCOM_GROUP;
-}
-
-/** The implicit group every ungrouped session belongs to. */
-export const DEFAULT_GROUP = "default";
-
-const RESERVED_RUNTIME_GROUPS = new Set(["true", "auto"]);
-
-/**
- * Normalize an intercom group id. Undefined, empty, or whitespace-only values
- * collapse to the shared {@link DEFAULT_GROUP} so ungrouped sessions all compare
- * equal and can still talk to each other (backward compatible).
- */
-export function normalizeGroup(value?: string | null): string {
-	if (typeof value !== "string") return DEFAULT_GROUP;
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : DEFAULT_GROUP;
-}
-
-/**
- * Validate a group requested by the runtime join action. `default` is a real,
- * explicit group name; `true` and `auto` remain reserved for subagent auto-grouping.
- */
-export function validateRuntimeGroup(value: unknown): string {
-	if (typeof value !== "string" || value.trim().length === 0) {
-		throw new Error("A non-empty intercom group name is required");
-	}
-	const group = normalizeGroup(value);
-	if (RESERVED_RUNTIME_GROUPS.has(group.toLowerCase())) {
-		throw new Error(`Intercom group name "${group}" is reserved; choose another name`);
-	}
-	return group;
-}
-
-interface HomeGroupContext {
-	orchestrationContext?: { intercomGroup?: string } | undefined;
-	subagentPolicy?: { intercomGroup?: string } | undefined;
-	/** Accepted from the live extension context but intentionally ignored for home resolution. */
-	sessionManager?: { getSessionId(): string } | undefined;
-}
-
-/**
- * Resolve a session's static home intercom group with precedence (most specific first):
- * admitted subagentPolicy.intercomGroup > orchestrationContext.intercomGroup >
- * env ATOMIC_INTERCOM_GROUP (also PI_INTERCOM_GROUP legacy) > config.json "group" > "default".
- * Always returns a concrete normalized string.
- *
- * Runtime join entries are deliberately not read here. They are child-inheritance state, not
- * home state, so a reconnect cannot turn the joined group into the destination of `leave`.
- */
-export function resolveHomeGroup(
-	config: { group?: string } | undefined,
-	ctx?: HomeGroupContext | null,
-): string {
-	const fromPolicy = ctx?.subagentPolicy?.intercomGroup;
-	if (typeof fromPolicy === "string" && fromPolicy.trim().length > 0) {
-		return normalizeGroup(fromPolicy);
-	}
-	const fromContext = ctx?.orchestrationContext?.intercomGroup;
-	if (typeof fromContext === "string" && fromContext.trim().length > 0) {
-		return normalizeGroup(fromContext);
-	}
-	const fromEnv = intercomGroupFromEnv();
-	if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
-		return normalizeGroup(fromEnv);
-	}
-	if (config && typeof config.group === "string" && config.group.trim().length > 0) {
-		return normalizeGroup(config.group);
-	}
-	return DEFAULT_GROUP;
-}

package/dist/builtin/intercom/inbound-idle-queue.ts

@@ -1,82 +0,0 @@
-import type { InboundMessageEntry } from "./intercom-utils.js";
-
-export interface InboundIdleClaim {
-  entries: InboundMessageEntry[];
-  rollbackFrom(index: number): void;
-}
-
-/**
- * FIFO ownership for ordinary inbound messages accepted while the parent is
- * busy. A terminal barrier may claim only entries from its exact child session
- * target; unrelated children retain their original queue positions.
- */
-export class InboundIdleQueue {
-  private entries: InboundMessageEntry[] = [];
-
-  get size(): number {
-    return this.entries.length;
-  }
-
-  enqueue(entry: InboundMessageEntry): void {
-    this.entries.push(entry);
-  }
-
-  has(entry: InboundMessageEntry): boolean {
-    return this.entries.includes(entry);
-  }
-
-  remove(entry: InboundMessageEntry): boolean {
-    const index = this.entries.indexOf(entry);
-    if (index < 0) return false;
-    this.entries.splice(index, 1);
-    return true;
-  }
-
-  drain(): InboundMessageEntry[] {
-    const entries = this.entries;
-    this.entries = [];
-    return entries;
-  }
-
-  claimOrdinarySourceTargets(runId: string, sourceSessionTargets: readonly string[], terminalAt = Number.POSITIVE_INFINITY): InboundIdleClaim {
-    const targets = new Set(sourceSessionTargets);
-    const original = this.entries;
-    const legacyIdsByName = new Map<string, Set<string>>();
-    for (const entry of original) {
-      if (entry.message.source?.subagentRunId !== undefined || entry.from.name === undefined) continue;
-      const ids = legacyIdsByName.get(entry.from.name) ?? new Set<string>();
-      ids.add(entry.from.id);
-      legacyIdsByName.set(entry.from.name, ids);
-    }
-    const selected = original.filter((entry) => {
-      if (entry.message.expectsReply) return false;
-      if (entry.message.timestamp > terminalAt) return false;
-      const idMatches = targets.has(entry.from.id);
-      const nameMatches = entry.from.name !== undefined && targets.has(entry.from.name);
-      if (!idMatches && !nameMatches) return false;
-      const sourceRunId = entry.message.source?.subagentRunId;
-      if (sourceRunId !== undefined) return sourceRunId === runId;
-      return idMatches || (entry.from.name !== undefined && legacyIdsByName.get(entry.from.name)?.size === 1);
-    });
-    const selectedSet = new Set(selected);
-    const originalSet = new Set(original);
-    this.entries = original.filter((entry) => !selectedSet.has(entry));
-    let settled = false;
-    return {
-      entries: selected,
-      rollbackFrom: (index) => {
-        if (settled) return;
-        settled = true;
-        const undelivered = new Set(selected.slice(index));
-        const laterEntries = this.entries.filter((entry) => !originalSet.has(entry));
-        this.entries = original
-          .filter((entry) => !selectedSet.has(entry) || undelivered.has(entry))
-          .concat(laterEntries);
-      },
-    };
-  }
-
-  clear(): void {
-    this.entries = [];
-  }
-}