@bastani/atomic 0.9.5-alpha.1 → 0.9.5-alpha.10

package/dist/builtin/intercom/broker/spawn.ts

@@ -2,16 +2,25 @@ import { spawn } from "child_process";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
+import { createRequire } from "module";
 import net from "net";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
-import { getBrokerSocketPath } from "./paths.js";
-
-const INTERCOM_DIR = join(homedir(), CONFIG_DIR_NAME, "agent", "intercom");
+import { isBunBinary } from "@bastani/atomic";
+import {
+  getBrokerPidPath,
+  getBrokerSocketPath,
+  getBrokerSpawnLockPath,
+  getIntercomDirPath,
+} from "./paths.js";
+
+const INTERCOM_DIR = getIntercomDirPath();
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
 const BROKER_SOCKET = getBrokerSocketPath();
-const BROKER_PID = join(INTERCOM_DIR, "broker.pid");
-const BROKER_SPAWN_LOCK = join(INTERCOM_DIR, "broker.spawn.lock");
+const BROKER_PID = getBrokerPidPath();
+const BROKER_SPAWN_LOCK = getBrokerSpawnLockPath();
+
+type BrokerRuntime = "node" | "bun-source" | "bun-binary";
+
+export const INTERNAL_INTERCOM_BROKER_ARG = "--atomic-internal-intercom-broker";
 
 type BrokerLaunchSpec =
   | {
@@ -31,8 +40,55 @@ function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+function getCurrentBrokerRuntime(): BrokerRuntime {
+  if (!process.versions.bun) return "node";
+  return isBunBinary ? "bun-binary" : "bun-source";
+}
+
+function requireFromExtensionDir(extensionDir: string): NodeJS.Require {
+  return createRequire(join(extensionDir, "package.json"));
+}
+
+function resolveTsxCliPath(extensionDir: string): string | null {
+  try {
+    const tsxMain = requireFromExtensionDir(extensionDir).resolve("tsx");
+    return join(dirname(tsxMain), "cli.mjs");
+  } catch {
+    const bundledTsx = join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+    return existsSync(bundledTsx) ? bundledTsx : null;
+  }
+}
+
 export function getTsxCliPath(extensionDir: string = EXTENSION_DIR): string {
-  return join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+  return resolveTsxCliPath(extensionDir) ?? join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+}
+
+export function getJitiCliPath(extensionDir: string = EXTENSION_DIR): string {
+  try {
+    const jitiPackage = requireFromExtensionDir(extensionDir).resolve("jiti/package.json");
+    return join(dirname(jitiPackage), "lib", "jiti-cli.mjs");
+  } catch {
+    return join(extensionDir, "node_modules", "jiti", "lib", "jiti-cli.mjs");
+  }
+}
+
+function getDefaultBrokerRunnerPath(extensionDir: string): string {
+  return resolveTsxCliPath(extensionDir) ?? getJitiCliPath(extensionDir);
+}
+
+function getDefaultBrokerCommandParts(
+  brokerPath: string,
+  extensionDir: string,
+  runtimePath: string,
+  runtime: BrokerRuntime,
+): { command: string; args: string[] } {
+  if (runtime === "bun-source") {
+    return { command: runtimePath, args: [brokerPath] };
+  }
+  if (runtime === "bun-binary") {
+    return { command: runtimePath, args: [INTERNAL_INTERCOM_BROKER_ARG, brokerPath] };
+  }
+  return { command: runtimePath, args: [getDefaultBrokerRunnerPath(extensionDir), brokerPath] };
 }
 
 function quoteWindowsArg(value: string): string {
@@ -56,9 +112,11 @@ export function getWindowsBrokerCommandLine(
   nodePath: string = process.execPath,
   brokerCommand = "npx",
   brokerArgs: string[] = ["--no-install", "tsx"],
+  runtime: BrokerRuntime = getCurrentBrokerRuntime(),
 ): string {
   if (usesDefaultBrokerCommand(brokerCommand, brokerArgs)) {
-    return [quoteWindowsArg(nodePath), quoteWindowsArg(getTsxCliPath(extensionDir)), quoteWindowsArg(brokerPath)].join(" ");
+    const launch = getDefaultBrokerCommandParts(brokerPath, extensionDir, nodePath, runtime);
+    return [quoteWindowsArg(launch.command), ...launch.args.map(quoteWindowsArg)].join(" ");
   }
 
   return [quoteWindowsArg(brokerCommand), ...brokerArgs.map(quoteWindowsArg), quoteWindowsArg(brokerPath)].join(" ");
@@ -90,6 +148,7 @@ export function getBrokerLaunchSpec(
   platform: NodeJS.Platform = process.platform,
   intercomDir: string = INTERCOM_DIR,
   nodePath: string = process.execPath,
+  runtime: BrokerRuntime = getCurrentBrokerRuntime(),
 ): BrokerLaunchSpec {
   if (platform === "win32") {
     const launcherPath = getWindowsHiddenLauncherPath(intercomDir);
@@ -98,7 +157,16 @@ export function getBrokerLaunchSpec(
       command: "wscript.exe",
       args: [launcherPath],
       launcherPath,
-      launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs),
+      launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs, runtime),
+    };
+  }
+
+  if (usesDefaultBrokerCommand(brokerCommand, brokerArgs)) {
+    const launch = getDefaultBrokerCommandParts(brokerPath, extensionDir, nodePath, runtime);
+    return {
+      kind: "direct",
+      command: launch.command,
+      args: launch.args,
     };
   }
 

package/dist/builtin/intercom/config.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "fs";
 import { getAgentConfigPaths } from "@bastani/atomic";
 
 export interface IntercomConfig {
-  /** Broker command used to spawn the broker process (e.g. "npx" or "bun") */
+  /** Broker command used to spawn the broker process (e.g. "npx", "bun", or "node") */
   brokerCommand: string;
 
   /** Arguments passed to the broker command before the broker script path */
@@ -24,9 +24,12 @@ export interface IntercomConfig {
 const CONFIG_PATHS = getAgentConfigPaths("intercom", "config.json");
 const CONFIG_PATH = CONFIG_PATHS.find((path) => existsSync(path)) ?? CONFIG_PATHS[0]!;
 
+export const DEFAULT_BROKER_COMMAND = "npx";
+export const DEFAULT_BROKER_ARGS = ["--no-install", "tsx"] as const;
+
 const defaults: IntercomConfig = {
-  brokerCommand: "npx",
-  brokerArgs: ["--no-install", "tsx"],
+  brokerCommand: DEFAULT_BROKER_COMMAND,
+  brokerArgs: [...DEFAULT_BROKER_ARGS],
   confirmSend: false,
   enabled: true,
   replyHint: true,

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

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@bastani/atomic";
 import { randomUUID } from "crypto";
 import { Type } from "typebox";
-import { Text } from "@mariozechner/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 import type { IntercomClient } from "./broker/client.ts";
 import type { Message } from "./types.ts";
 import { renderContactSupervisorResult } from "./result-renderers.js";
@@ -249,9 +249,11 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
           return {
             content: [{ type: "text", text: `**Reply from supervisor:**\n${replyText}${replyAttachments}` }],
             isError: false,
-            ...(structuredReply
-              ? { details: structuredReply.value !== undefined ? { structuredReply: structuredReply.value } : { structuredReplyParseError: structuredReply.error } }
-              : {}),
+            details: structuredReply
+              ? structuredReply.value !== undefined
+                ? { structuredReply: structuredReply.value }
+                : { structuredReplyParseError: structuredReply.error }
+              : {},
           };
         } catch (error) {
           rejectReplyWaiter(toError(error));

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

@@ -0,0 +1,136 @@
+import 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;
+}
+
+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;
+  }
+
+  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 !== "acknowledged" || !input.isCurrent() || this.generation !== input.generation) return "abandoned";
+    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);
+        unsubscribe?.();
+        signal.removeEventListener("abort", cancel);
+        resolve(disposition);
+      };
+      const cancel = () => finish("cancelled");
+      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");
+      });
+      signal.addEventListener("abort", cancel, { once: true });
+      timeout = setTimeout(() => finish("timed-out"), this.ackTimeoutMs);
+      if (signal.aborted) {
+        cancel();
+        return;
+      }
+      this.pi.events?.emit(INTERCOM_DETACH_REQUEST_EVENT, route);
+    });
+  }
+
+  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;
+}): Promise<void> {
+  const disposition = await input.handoff.deliver(input);
+  if (disposition === "unclaimed" && input.isCurrent()) input.onUnclaimed();
+}

package/dist/builtin/intercom/index-heavy.ts

@@ -1,35 +1,33 @@
-import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
+import { APP_NAME, type ExtensionAPI, type ExtensionContext } from "@bastani/atomic";
 import { appendFileSync } from "node:fs";
-import { IntercomClient } from "./broker/client.ts";
-import { spawnBrokerIfNeeded } from "./broker/spawn.ts";
-import { InlineMessageComponent } from "./ui/inline-message.ts";
-import { loadConfig, type IntercomConfig } from "./config.ts";
-import type { SessionInfo, Message } from "./types.ts";
-import { ReplyTracker } from "./reply-tracker.ts";
+import { IntercomClient } from "./broker/client.js";
+import { spawnBrokerIfNeeded } from "./broker/spawn.js";
+import { InlineMessageComponent } from "./ui/inline-message.js";
+import { loadConfig, type IntercomConfig } from "./config.js";
+import type { SessionInfo, Message } from "./types.js";
+import { ReplyTracker } from "./reply-tracker.js";
 import { registerContactSupervisorTool } from "./contact-supervisor-tool.js";
 import { registerIntercomTool } from "./intercom-tool.js";
 import { registerIntercomOverlay } from "./overlay.js";
 import { registerIntercomLifecycle } from "./lifecycle.js";
 import { registerSubagentRelay } from "./subagent-relay.js";
-import {
-  INBOUND_FLUSH_DELAY_MS,
-  INBOUND_IDLE_RETRY_MS,
-  type InboundMessageEntry,
-  buildPresenceIdentity,
-  formatAttachments,
-  readChildOrchestratorMetadata,
-  toError,
-} from "./intercom-utils.js";
-
+import { ForegroundDetachHandoff, handleForegroundInboundDelivery } from "./foreground-detach-handoff.js";
+import { routeIncomingReply } from "./reply-routing.js";
+import { INBOUND_FLUSH_DELAY_MS, INBOUND_IDLE_RETRY_MS, type InboundMessageEntry, buildPresenceIdentity, formatAttachments, readChildOrchestratorMetadata, toError } from "./intercom-utils.js";
 if (process.env.ATOMIC_TEST_LAZY_IMPORT_SENTINEL === "1") {
   process.env.ATOMIC_INTERCOM_HEAVY_IMPORTED = "1";
 }
-
 if (process.env.ATOMIC_TEST_LAZY_IMPORT_SENTINEL_FILE) {
   appendFileSync(process.env.ATOMIC_TEST_LAZY_IMPORT_SENTINEL_FILE, "intercom\n");
 }
 
+const INTERCOM_SESSION_ID_ENV = `${APP_NAME.toUpperCase()}_INTERCOM_SESSION_ID`;
 export default function piIntercomExtension(pi: ExtensionAPI) {
+  const inheritedIntercomSessionId = process.env[INTERCOM_SESSION_ID_ENV];
+  const restoreIntercomSessionIdEnv = (): void => {
+    if (inheritedIntercomSessionId === undefined) delete process.env[INTERCOM_SESSION_ID_ENV];
+    else process.env[INTERCOM_SESSION_ID_ENV] = inheritedIntercomSessionId;
+  };
   let client: IntercomClient | null = null;
   const config: IntercomConfig = loadConfig();
   let runtimeContext: ExtensionContext | null = null;
@@ -48,6 +46,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
   let agentRunning = false;
   const activeTools = new Map<string, string>();
   const replyTracker = new ReplyTracker();
+  const foregroundDetachHandoff = new ForegroundDetachHandoff(pi);
   const pendingIdleMessages: InboundMessageEntry[] = [];
   let inboundFlushTimer: NodeJS.Timeout | null = null;
   let replyWaiter: {
@@ -97,24 +96,15 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     replyWaiter?.reject(error);
   }
   function clearReconnectTimer(): void {
-    if (!reconnectTimer) {
-      return;
-    }
-    clearTimeout(reconnectTimer);
+    if (reconnectTimer) clearTimeout(reconnectTimer);
     reconnectTimer = null;
   }
   function clearStartupConnectTimer(): void {
-    if (!startupConnectTimer) {
-      return;
-    }
-    clearTimeout(startupConnectTimer);
+    if (startupConnectTimer) clearTimeout(startupConnectTimer);
     startupConnectTimer = null;
   }
   function clearInboundFlushTimer(): void {
-    if (!inboundFlushTimer) {
-      return;
-    }
-    clearTimeout(inboundFlushTimer);
+    if (inboundFlushTimer) clearTimeout(inboundFlushTimer);
     inboundFlushTimer = null;
   }
   function getLiveContext(ctx: ExtensionContext | null = runtimeContext, generation = runtimeGeneration): ExtensionContext | null {
@@ -157,7 +147,6 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     if (!liveContext || !currentSessionId || sessionStartedAt === null) {
       throw new Error("Intercom runtime not initialized");
     }
-
     const identity = buildPresenceIdentity(pi, currentSessionId);
     return {
       name: identity.name,
@@ -198,7 +187,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     if (runtimeStarted && !getLiveContext(runtimeContext, generation)) {
       return;
     }
-    if (delivery !== "followUp") {
+    if (delivery === "trigger") {
       replyTracker.queueTurnContext({ from: entry.from, message: entry.message, receivedAt: Date.now() });
     }
     const senderDisplay = entry.from.name || entry.from.id.slice(0, 8);
@@ -210,9 +199,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
         display: true,
         details: entry,
       },
-      delivery === "trigger"
-        ? { triggerTurn: true }
-        : { deliverAs: "followUp" }
+      delivery === "trigger" ? { triggerTurn: true } : { deliverAs: "followUp" },
     );
   }
   function scheduleInboundFlush(delayMs = INBOUND_FLUSH_DELAY_MS): void {
@@ -234,7 +221,6 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     if (!ctx) {
       return;
     }
-
     let isIdle: boolean;
     try {
       isIdle = ctx.isIdle();
@@ -252,26 +238,13 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       sendIncomingMessage(entry, index === 0 ? "trigger" : "followUp");
     });
   }
-  function queueIdleMessage(entry: InboundMessageEntry): void {
-    pendingIdleMessages.push(entry);
-    scheduleInboundFlush();
-  }
   function handleIncomingMessage(ctx: ExtensionContext, from: SessionInfo, message: Message): void {
     const messageGeneration = runtimeGeneration;
     const liveContext = getLiveContext(ctx, messageGeneration);
     if (!liveContext) {
       return;
     }
-    if (replyWaiter) {
-      const senderTarget = from.name || from.id;
-      const fromMatches = senderTarget.toLowerCase() === replyWaiter.from.toLowerCase()
-        || from.id === replyWaiter.from;
-      const replyMatches = message.replyTo === replyWaiter.replyTo;
-      if (fromMatches && replyMatches) {
-        replyWaiter.resolve(message);
-        return;
-      }
-    }
+    if (routeIncomingReply(replyWaiter, from, message)) return;
     const attachmentText = message.content.attachments?.length
       ? formatAttachments(message.content.attachments)
       : "";
@@ -304,7 +277,20 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
           }
           return;
         }
-        queueIdleMessage(entry);
+        await handleForegroundInboundDelivery({
+          handoff: foregroundDetachHandoff,
+          from,
+          message,
+          generation: messageGeneration,
+          surface: () => sendIncomingMessage(entry, "trigger", messageGeneration),
+          isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration)),
+          onUnclaimed: () => {
+            // No exact foreground owner acknowledged the target. Preserve the
+            // established background/cross-session behavior by waiting for idle.
+            pendingIdleMessages.push(entry);
+            scheduleInboundFlush(INBOUND_IDLE_RETRY_MS);
+          },
+        });
         return;
       }
       if (getLiveContext(liveContext, messageGeneration)) {
@@ -326,6 +312,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       }
       rejectReplyWaiter(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
       client = null;
+      if (process.env[INTERCOM_SESSION_ID_ENV] === nextClient.sessionId) restoreIntercomSessionIdEnv();
       if (!shuttingDown && !disposed) {
         clearReconnectTimer();
         scheduleReconnect();
@@ -382,6 +369,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
           throw new Error("Intercom runtime no longer active");
         }
         client = nextClient;
+        if (nextClient.sessionId) process.env[INTERCOM_SESSION_ID_ENV] = nextClient.sessionId;
         reconnectAttempt = 0;
         return nextClient;
       } catch (error) {
@@ -393,7 +381,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
         }
         throw toError(error);
       } finally {
-        if (reconnectPromise === nextReconnectPromise) {
+        if (reconnectPromiseGeneration === generationAtStart) {
           reconnectPromise = null;
           reconnectPromiseGeneration = null;
         }
@@ -427,7 +415,6 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     resolveSessionTarget,
   });
 
-
   registerIntercomLifecycle(pi, {
     config,
     client: () => client,
@@ -435,7 +422,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     setShuttingDown: (value) => { shuttingDown = value; },
     setDisposed: (value) => { disposed = value; },
     setRuntimeStarted: (value) => { runtimeStarted = value; },
-    incrementRuntimeGeneration: () => { runtimeGeneration += 1; return runtimeGeneration; },
+    incrementRuntimeGeneration: () => { runtimeGeneration += 1; foregroundDetachHandoff.reset(); return runtimeGeneration; },
     resetReconnectAttempt: () => { reconnectAttempt = 0; },
     clearReconnectTimer,
     clearStartupConnectTimer,
@@ -456,6 +443,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     scheduleInboundFlush,
     syncPresenceStatus,
     syncPresenceIdentity,
+    restoreIntercomSessionIdEnv,
     currentStatus,
   });
 
@@ -492,4 +480,12 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     ensureConnected,
     syncPresenceIdentity,
   });
+  return { enabled: config.enabled,
+    async awaitAutomaticBrokerReady(): Promise<void> {
+      if (config.enabled) await ensureConnected("startup");
+    },
+    async awaitForegroundBrokerReady(): Promise<void> {
+      if (config.enabled) await ensureConnected("tool");
+    },
+  };
 }