@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/pi-intercom-EEMBGQID.js

@@ -0,0 +1,2215 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/index.js
+import { StringEnum } from "@ashx-j/lunr-ai";
+import { randomUUID as randomUUID3 } from "crypto";
+import { Type } from "typebox";
+import { Text } from "@ashx-j/lunr-tui";
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/broker/client.js
+import { EventEmitter } from "events";
+import net from "net";
+import { randomUUID } from "crypto";
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/broker/framing.js
+function writeMessage(socket, msg) {
+  let json = JSON.stringify(msg), payload = Buffer.from(json, "utf-8"), header = Buffer.alloc(4);
+  header.writeUInt32BE(payload.length, 0), socket.write(Buffer.concat([header, payload]));
+}
+function createMessageReader(onMessage, onError, maxFrameBytes = 1048576) {
+  let buffer = Buffer.alloc(0);
+  function reportMessage(payload) {
+    let msg;
+    try {
+      msg = JSON.parse(payload.toString("utf-8"));
+    } catch (error) {
+      let message = error instanceof Error ? error.message : String(error);
+      return onError(new Error(`Failed to parse intercom message: ${message}`, { cause: error })), !1;
+    }
+    try {
+      return onMessage(msg), !0;
+    } catch (error) {
+      let message = error instanceof Error ? error.message : String(error);
+      return onError(new Error(`Failed to handle intercom message: ${message}`, { cause: error })), !1;
+    }
+  }
+  return (data) => {
+    let remaining = data;
+    for (; remaining.length > 0; ) {
+      if (buffer.length < 4) {
+        let headerBytes = Math.min(4 - buffer.length, remaining.length);
+        if (buffer = Buffer.concat([buffer, remaining.subarray(0, headerBytes)]), remaining = remaining.subarray(headerBytes), buffer.length < 4)
+          return;
+      }
+      let length = buffer.readUInt32BE(0);
+      if (length > maxFrameBytes) {
+        buffer = Buffer.alloc(0), onError(new Error(`Intercom frame length ${length} exceeds maximum ${maxFrameBytes} bytes`));
+        return;
+      }
+      let missingPayloadBytes = length - Math.max(0, buffer.length - 4), payloadBytes = Math.min(missingPayloadBytes, remaining.length);
+      if (payloadBytes > 0 && (buffer = Buffer.concat([buffer, remaining.subarray(0, payloadBytes)]), remaining = remaining.subarray(payloadBytes)), buffer.length < 4 + length)
+        return;
+      let payload = buffer.subarray(4, 4 + length);
+      if (buffer = Buffer.alloc(0), !reportMessage(payload))
+        return;
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/broker/paths.js
+import { chmodSync, mkdirSync, readFileSync } from "fs";
+import { isAbsolute, join, resolve } from "path";
+import { homedir } from "os";
+var INTERCOM_DIR_MODE = 448, INTERCOM_RUNTIME_FILE_MODE = 384, INTERCOM_TCP_HOST = "127.0.0.1", INTERCOM_PROTOCOL_NAME = "pi-intercom", INTERCOM_PROTOCOL_VERSION = 1;
+function sanitizePipeSegment(value) {
+  return value.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "default";
+}
+function getAgentDirPath(env = process.env, homeDir = homedir(), cwd = process.cwd()) {
+  let configured = env.PI_CODING_AGENT_DIR?.trim();
+  return configured ? isAbsolute(configured) ? configured : resolve(cwd, configured) : join(homeDir, ".lunr/agent");
+}
+function getIntercomDirPath(agentDir = getAgentDirPath()) {
+  return join(agentDir, "intercom");
+}
+function shouldUseWindowsTcpTransport(platform = process.platform, env = process.env) {
+  if (platform !== "win32")
+    return !1;
+  if (env.PI_INTERCOM_TRANSPORT?.trim().toLowerCase() === "tcp")
+    return !0;
+  let legacyOptIn = env.PI_INTERCOM_TCP?.trim().toLowerCase();
+  return legacyOptIn === "1" || legacyOptIn === "true";
+}
+function getBrokerPortFilePath(intercomDir = getIntercomDirPath()) {
+  return join(intercomDir, "broker.port.json");
+}
+function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDirPath()) {
+  return platform === "win32" ? `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}` : join(getIntercomDirPath(agentDir), "broker.sock");
+}
+function getBrokerConnectTarget(platform = process.platform, env = process.env, intercomDir = getIntercomDirPath(getAgentDirPath(env))) {
+  if (shouldUseWindowsTcpTransport(platform, env)) {
+    let endpointFile = getBrokerPortFilePath(intercomDir), raw = readFileSync(endpointFile, "utf-8"), parsed = JSON.parse(raw);
+    if (typeof parsed != "object" || parsed === null || Array.isArray(parsed))
+      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}: expected a JSON object`);
+    let endpoint = parsed;
+    if (endpoint.transport !== "tcp" || endpoint.host !== INTERCOM_TCP_HOST || typeof endpoint.port != "number" || !Number.isSafeInteger(endpoint.port) || endpoint.port <= 0 || endpoint.port > 65535 || typeof endpoint.stateId != "string" || endpoint.stateId.length === 0)
+      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}`);
+    return { transport: "tcp", host: endpoint.host, port: endpoint.port, stateId: endpoint.stateId };
+  }
+  return getBrokerSocketPath(platform, getAgentDirPath(env));
+}
+function ensureIntercomRuntimeDir(intercomDir = getIntercomDirPath(), platform = process.platform) {
+  mkdirSync(intercomDir, { recursive: !0, mode: INTERCOM_DIR_MODE }), platform !== "win32" && chmodSync(intercomDir, INTERCOM_DIR_MODE);
+}
+function restrictIntercomRuntimeFile(filePath, platform = process.platform) {
+  platform !== "win32" && chmodSync(filePath, INTERCOM_RUNTIME_FILE_MODE);
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/broker/client.js
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function connectToBrokerTarget(target) {
+  return typeof target == "string" ? net.connect(target) : net.connect({ host: target.host, port: target.port });
+}
+function isAttachment(value) {
+  if (typeof value != "object" || value === null)
+    return !1;
+  let attachment = value;
+  return attachment.type !== "file" && attachment.type !== "snippet" && attachment.type !== "context" || typeof attachment.name != "string" || typeof attachment.content != "string" ? !1 : attachment.language === void 0 || typeof attachment.language == "string";
+}
+function isMessage(value) {
+  if (typeof value != "object" || value === null)
+    return !1;
+  let message = value;
+  if (typeof message.id != "string" || typeof message.timestamp != "number" || message.replyTo !== void 0 && typeof message.replyTo != "string" || message.expectsReply !== void 0 && typeof message.expectsReply != "boolean" || typeof message.content != "object" || message.content === null)
+    return !1;
+  let content = message.content;
+  return typeof content.text != "string" ? !1 : content.attachments === void 0 || Array.isArray(content.attachments) && content.attachments.every(isAttachment);
+}
+function isSessionInfo(value) {
+  if (typeof value != "object" || value === null)
+    return !1;
+  let session = value;
+  return typeof session.id != "string" || typeof session.cwd != "string" || typeof session.model != "string" || typeof session.pid != "number" || typeof session.startedAt != "number" || typeof session.lastActivity != "number" || session.name !== void 0 && typeof session.name != "string" || session.status !== void 0 && typeof session.status != "string" || session.peerUid !== void 0 && typeof session.peerUid != "number" ? !1 : session.trustedLocal === void 0 || typeof session.trustedLocal == "boolean";
+}
+var IntercomClient = class extends EventEmitter {
+  socket = null;
+  _sessionId = null;
+  pendingSends = /* @__PURE__ */ new Map();
+  pendingLists = /* @__PURE__ */ new Map();
+  disconnecting = !1;
+  disconnectError = null;
+  failPending(error) {
+    for (let pending of this.pendingSends.values())
+      pending.reject(error);
+    this.pendingSends.clear();
+    for (let pending of this.pendingLists.values())
+      pending.reject(error);
+    this.pendingLists.clear();
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  isConnected() {
+    let socket = this.socket;
+    return !!(socket && this._sessionId && !this.disconnecting && !socket.destroyed && !socket.writableEnded && socket.writable);
+  }
+  requireActiveSocket() {
+    if (this.disconnecting)
+      throw new Error("Client disconnecting");
+    let socket = this.socket;
+    if (!socket || !this._sessionId)
+      throw new Error("Not connected");
+    if (socket.destroyed || socket.writableEnded || !socket.writable)
+      throw new Error("Client disconnected");
+    return socket;
+  }
+  connect(session, sessionId) {
+    return this.socket ? Promise.reject(new Error("Already connected")) : new Promise((resolve2, reject) => {
+      let socket, target;
+      try {
+        target = getBrokerConnectTarget(), socket = connectToBrokerTarget(target);
+      } catch (error) {
+        reject(toError(error));
+        return;
+      }
+      this.socket = socket, this.disconnectError = null;
+      let settled = !1, timeout = setTimeout(() => {
+        this._sessionId || (cleanupConnectionAttempt(), cleanupSocketListeners(), this.socket === socket && (this.socket = null), socket.destroy(), reject(new Error("Connection timeout")));
+      }, 1e4), connectionEstablished = !1, onRegistered = () => {
+        settled = !0, connectionEstablished = !0, cleanupConnectionAttempt(), resolve2();
+      }, onError = (err) => {
+        settled = !0, cleanupConnectionAttempt(), cleanupSocketListeners(), this.socket === socket && (this.socket = null), socket.destroy(), reject(err);
+      }, onClose = () => {
+        let wasConnecting = !settled && !this._sessionId, wasDisconnecting = this.disconnecting, disconnectError = this.disconnectError ?? new Error("Client disconnected");
+        this.disconnecting = !1, cleanupConnectionAttempt(), cleanupSocketListeners(), this.failPending(disconnectError), this.socket === socket && (this.socket = null), this._sessionId = null, this.disconnectError = null, connectionEstablished && !wasDisconnecting && this.emit("disconnected", disconnectError), wasConnecting && reject(new Error("Connection closed before registration"));
+      }, onSocketError = (err) => {
+        connectionEstablished && (this.disconnectError = err, this.emit("error", err));
+      }, reader = createMessageReader((msg) => {
+        this.handleBrokerMessage(msg);
+      }, (error) => {
+        let protocolError = new Error(`Intercom protocol error: ${error.message}`, { cause: error });
+        if (!connectionEstablished) {
+          onError(protocolError);
+          return;
+        }
+        this.disconnectError = protocolError, this.emit("error", protocolError), socket.destroy();
+      }), cleanupConnectionAttempt = () => {
+        this.off("_registered", onRegistered), socket.off("error", onError), clearTimeout(timeout);
+      }, cleanupSocketListeners = () => {
+        socket.off("data", reader), socket.off("error", onSocketError), socket.off("close", onClose);
+      };
+      socket.on("data", reader), socket.on("error", onError), socket.on("close", onClose), socket.on("error", onSocketError), this.once("_registered", onRegistered);
+      try {
+        writeMessage(socket, {
+          type: "register",
+          session,
+          ...sessionId ? { sessionId } : {},
+          ...typeof target == "string" ? {} : { stateId: target.stateId }
+        });
+      } catch (error) {
+        cleanupConnectionAttempt(), cleanupSocketListeners(), this.socket === socket && (this.socket = null), socket.destroy(), reject(toError(error));
+      }
+    });
+  }
+  handleBrokerMessage(msg) {
+    if (typeof msg != "object" || msg === null || !("type" in msg) || typeof msg.type != "string")
+      throw new Error("Invalid broker message");
+    let brokerMessage = msg;
+    if (this._sessionId === null && brokerMessage.type !== "registered" && brokerMessage.type !== "error")
+      throw new Error(`Received ${brokerMessage.type} before registered`);
+    switch (brokerMessage.type) {
+      case "registered": {
+        if (typeof brokerMessage.sessionId != "string")
+          throw new Error("Invalid registered message");
+        if (this._sessionId !== null)
+          throw new Error("Received duplicate registered message");
+        this._sessionId = brokerMessage.sessionId, this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
+        break;
+      }
+      case "sessions": {
+        let { requestId, sessions } = brokerMessage;
+        if (typeof requestId != "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo))
+          throw new Error("Invalid sessions message");
+        let pending = this.pendingLists.get(requestId);
+        if (!pending)
+          return;
+        this.pendingLists.delete(requestId), pending.resolve(sessions);
+        break;
+      }
+      case "message": {
+        let { from, message } = brokerMessage;
+        if (!isSessionInfo(from) || !isMessage(message))
+          throw new Error("Invalid message event");
+        this.emit("message", from, message);
+        break;
+      }
+      case "delivered": {
+        let { messageId } = brokerMessage;
+        if (typeof messageId != "string")
+          throw new Error("Invalid delivered message");
+        let pending = this.pendingSends.get(messageId);
+        if (!pending)
+          return;
+        this.pendingSends.delete(messageId), pending.resolve({ id: messageId, delivered: !0 });
+        break;
+      }
+      case "delivery_failed": {
+        let { messageId, reason } = brokerMessage;
+        if (typeof messageId != "string" || typeof reason != "string")
+          throw new Error("Invalid delivery_failed message");
+        let pending = this.pendingSends.get(messageId);
+        if (!pending)
+          return;
+        this.pendingSends.delete(messageId), pending.resolve({ id: messageId, delivered: !1, reason });
+        break;
+      }
+      case "session_joined": {
+        if (!isSessionInfo(brokerMessage.session))
+          throw new Error("Invalid session_joined message");
+        this.emit("session_joined", brokerMessage.session);
+        break;
+      }
+      case "session_left": {
+        if (typeof brokerMessage.sessionId != "string")
+          throw new Error("Invalid session_left message");
+        this.emit("session_left", brokerMessage.sessionId);
+        break;
+      }
+      case "presence_update": {
+        if (!isSessionInfo(brokerMessage.session))
+          throw new Error("Invalid presence_update message");
+        this.emit("presence_update", brokerMessage.session);
+        break;
+      }
+      case "error": {
+        if (typeof brokerMessage.error != "string")
+          throw new Error("Invalid error message");
+        if (this._sessionId === null)
+          throw new Error(brokerMessage.error);
+        this.emit("error", new Error(brokerMessage.error));
+        break;
+      }
+      default:
+        throw new Error(`Unknown broker message type: ${brokerMessage.type}`);
+    }
+  }
+  async disconnect() {
+    let socket = this.socket;
+    socket && (this.disconnecting = !0, this.disconnectError = null, this.failPending(new Error("Client disconnected")), await new Promise((resolve2) => {
+      let settled = !1, finish = () => {
+        settled || (settled = !0, clearTimeout(timeout), socket.off("close", onClose), socket.off("error", onError), resolve2());
+      }, onClose = () => finish(), onError = () => {
+        socket.destroy();
+      }, timeout = setTimeout(() => {
+        socket.destroy();
+      }, 2e3);
+      socket.once("close", onClose), socket.once("error", onError);
+      try {
+        writeMessage(socket, { type: "unregister" }), socket.end();
+      } catch {
+        socket.destroy();
+      }
+    }));
+  }
+  listSessions() {
+    let socket;
+    try {
+      socket = this.requireActiveSocket();
+    } catch (error) {
+      return Promise.reject(toError(error));
+    }
+    return new Promise((resolve2, reject) => {
+      let requestId = randomUUID(), wrappedResolve = (sessions) => {
+        clearTimeout(timeout), resolve2(sessions);
+      }, wrappedReject = (error) => {
+        clearTimeout(timeout), reject(error);
+      }, timeout = setTimeout(() => {
+        this.pendingLists.has(requestId) && (this.pendingLists.delete(requestId), wrappedReject(new Error("List sessions timeout")));
+      }, 5e3);
+      this.pendingLists.set(requestId, { resolve: wrappedResolve, reject: wrappedReject });
+      try {
+        writeMessage(socket, { type: "list", requestId });
+      } catch (error) {
+        clearTimeout(timeout), this.pendingLists.delete(requestId), reject(toError(error));
+      }
+    });
+  }
+  send(to, options) {
+    let socket;
+    try {
+      socket = this.requireActiveSocket();
+    } catch (error) {
+      return Promise.reject(toError(error));
+    }
+    let messageId = options.messageId ?? randomUUID(), message = {
+      id: messageId,
+      timestamp: Date.now(),
+      replyTo: options.replyTo,
+      expectsReply: options.expectsReply,
+      content: {
+        text: options.text,
+        attachments: options.attachments
+      }
+    };
+    return new Promise((resolve2, reject) => {
+      let wrappedResolve = (result) => {
+        clearTimeout(timeout), resolve2(result);
+      }, wrappedReject = (error) => {
+        clearTimeout(timeout), reject(error);
+      }, timeout = setTimeout(() => {
+        this.pendingSends.has(messageId) && (this.pendingSends.delete(messageId), wrappedReject(new Error("Send timeout")));
+      }, 1e4);
+      this.pendingSends.set(messageId, { resolve: wrappedResolve, reject: wrappedReject });
+      try {
+        writeMessage(socket, { type: "send", to, message });
+      } catch (error) {
+        clearTimeout(timeout), this.pendingSends.delete(messageId), reject(toError(error));
+      }
+    });
+  }
+  cancelAsk(messageId) {
+    if (this.disconnecting)
+      return;
+    let socket = this.socket;
+    if (!(!socket || !this._sessionId || socket.destroyed || socket.writableEnded || !socket.writable))
+      try {
+        writeMessage(socket, { type: "cancel_ask", messageId });
+      } catch {
+      }
+  }
+  updatePresence(updates) {
+    if (this.disconnecting)
+      return;
+    let socket = this.socket;
+    !socket || !this._sessionId || socket.destroyed || socket.writableEnded || !socket.writable || writeMessage(socket, { type: "presence", ...updates });
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/broker/spawn.js
+import { spawn } from "child_process";
+import { existsSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import net2 from "net";
+import { randomUUID as randomUUID2 } from "crypto";
+var INTERCOM_DIR = getIntercomDirPath(), EXTENSION_DIR = join2(dirname(fileURLToPath(new URL("../builtin-extensions/pi-intercom/broker/spawn.js", import.meta.url).href)), ".."), BROKER_PID = join2(INTERCOM_DIR, "broker.pid"), BROKER_SPAWN_LOCK = join2(INTERCOM_DIR, "broker.spawn.lock");
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function getTsxCliPath(extensionDir = EXTENSION_DIR) {
+  try {
+    let tsxMain = createRequire(new URL("../builtin-extensions/pi-intercom/broker/spawn.js", import.meta.url).href).resolve("tsx");
+    return join2(dirname(tsxMain), "cli.mjs");
+  } catch {
+    return join2(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+  }
+}
+function quoteWindowsArg(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function getWindowsHiddenLauncherPath(intercomDir = INTERCOM_DIR) {
+  return join2(intercomDir, "broker-launch.vbs");
+}
+function usesDefaultBrokerCommand(brokerCommand, brokerArgs) {
+  return brokerCommand === "npx" && brokerArgs.length === 2 && brokerArgs[0] === "--no-install" && brokerArgs[1] === "tsx";
+}
+function getWindowsBrokerCommandLine(brokerPath, extensionDir = EXTENSION_DIR, nodePath = process.execPath, brokerCommand = "npx", brokerArgs = ["--no-install", "tsx"]) {
+  return usesDefaultBrokerCommand(brokerCommand, brokerArgs) ? [quoteWindowsArg(nodePath), quoteWindowsArg(getTsxCliPath(extensionDir)), quoteWindowsArg(brokerPath)].join(" ") : [quoteWindowsArg(brokerCommand), ...brokerArgs.map(quoteWindowsArg), quoteWindowsArg(brokerPath)].join(" ");
+}
+function getWindowsHiddenLauncherScript(commandLine) {
+  return [
+    'Set WshShell = CreateObject("WScript.Shell")',
+    `WshShell.Run "${commandLine.replace(/"/g, '""')}", 0, False`,
+    "Set WshShell = Nothing",
+    ""
+  ].join(`\r
+`);
+}
+function isBrokerHealthOkMessage(message, requestId) {
+  if (typeof message != "object" || message === null || !("type" in message))
+    return !1;
+  let response = message;
+  return response.type === "health_ok" && response.requestId === requestId && response.protocol === INTERCOM_PROTOCOL_NAME && response.version === INTERCOM_PROTOCOL_VERSION;
+}
+function writeWindowsHiddenLauncher(commandLine, launcherPath = getWindowsHiddenLauncherPath()) {
+  return ensureIntercomRuntimeDir(dirname(launcherPath)), writeFileSync(launcherPath, getWindowsHiddenLauncherScript(commandLine), {
+    encoding: "utf-8",
+    mode: INTERCOM_RUNTIME_FILE_MODE
+  }), restrictIntercomRuntimeFile(launcherPath), launcherPath;
+}
+function getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs, extensionDir = EXTENSION_DIR, platform = process.platform, intercomDir = INTERCOM_DIR, nodePath = process.execPath) {
+  if (platform === "win32") {
+    let launcherPath = getWindowsHiddenLauncherPath(intercomDir);
+    return {
+      kind: "windows-launcher",
+      command: "wscript.exe",
+      args: [launcherPath],
+      launcherPath,
+      launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs)
+    };
+  }
+  return usesDefaultBrokerCommand(brokerCommand, brokerArgs) ? {
+    kind: "direct",
+    command: nodePath,
+    args: [getTsxCliPath(extensionDir), brokerPath]
+  } : {
+    kind: "direct",
+    command: brokerCommand,
+    args: [...brokerArgs, brokerPath]
+  };
+}
+function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, env = process.env) {
+  return {
+    detached: !0,
+    stdio: "ignore",
+    cwd: extensionDir,
+    env: { ...env, PI_CODING_AGENT_DIR: getAgentDirPath(env), NODE_NO_WARNINGS: "1" },
+    windowsHide: !0
+  };
+}
+function toError2(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+async function spawnBrokerIfNeeded(brokerCommand, brokerArgs) {
+  if (ensureIntercomRuntimeDir(INTERCOM_DIR), await isBrokerRunning())
+    return;
+  if (!acquireSpawnLock()) {
+    await waitForBroker();
+    return;
+  }
+  try {
+    if (await isBrokerRunning())
+      return;
+    let brokerPath = join2(dirname(fileURLToPath(new URL("../builtin-extensions/pi-intercom/broker/spawn.js", import.meta.url).href)), "broker.ts"), launch = getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs);
+    launch.kind === "windows-launcher" && writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
+    let child = spawn(launch.command, launch.args, getBrokerSpawnOptions());
+    child.unref(), await new Promise((resolve2, reject) => {
+      let cleanup = () => {
+        child.off("error", onError), child.off("exit", onExit);
+      }, onError = (error) => {
+        cleanup(), reject(new Error(`Failed to spawn intercom broker: ${error.message}`, { cause: error }));
+      }, onExit = (code, signal) => {
+        if (!(launch.kind === "windows-launcher" && code === 0 && signal === null)) {
+          if (cleanup(), signal) {
+            reject(new Error(`Intercom broker exited before startup with signal ${signal}`));
+            return;
+          }
+          reject(new Error(`Intercom broker exited before startup with code ${code ?? "unknown"}`));
+        }
+      };
+      child.once("error", onError), child.once("exit", onExit), waitForBroker().then(() => {
+        cleanup(), resolve2();
+      }, (error) => {
+        cleanup(), reject(toError2(error));
+      });
+    });
+  } finally {
+    releaseSpawnLock();
+  }
+}
+async function isBrokerRunning() {
+  if (await checkSocketConnectable())
+    return !0;
+  if (!existsSync(BROKER_PID))
+    return !1;
+  try {
+    let pid = parseInt(readFileSync2(BROKER_PID, "utf-8").trim(), 10);
+    return Number.isFinite(pid) ? (process.kill(pid, 0), checkSocketConnectable()) : !1;
+  } catch {
+    return !1;
+  }
+}
+function connectToBrokerTarget2(target) {
+  return typeof target == "string" ? net2.connect(target) : net2.connect({ host: target.host, port: target.port });
+}
+function checkSocketConnectable() {
+  return new Promise((resolve2) => {
+    let target;
+    try {
+      target = getBrokerConnectTarget();
+    } catch {
+      resolve2(!1);
+      return;
+    }
+    let socket = connectToBrokerTarget2(target), requestId = randomUUID2(), expectedStateId = typeof target == "string" ? void 0 : target.stateId, settled = !1, finish = (isConnected) => {
+      settled || (settled = !0, clearTimeout(timeout), socket.off("connect", onConnect), socket.off("error", onError), socket.off("data", reader), socket.destroy(), resolve2(isConnected));
+    }, onConnect = () => {
+      try {
+        writeMessage(socket, {
+          type: "health",
+          requestId,
+          ...expectedStateId ? { stateId: expectedStateId } : {}
+        });
+      } catch {
+        finish(!1);
+      }
+    }, onError = () => finish(!1), reader = createMessageReader((message) => {
+      finish(isBrokerHealthOkMessage(message, requestId));
+    }, () => finish(!1));
+    socket.on("connect", onConnect), socket.on("error", onError), socket.on("data", reader);
+    let timeout = setTimeout(() => finish(!1), 1e3);
+  });
+}
+function acquireSpawnLock() {
+  for (let attempt = 0; attempt < 5; attempt++)
+    try {
+      return writeFileSync(BROKER_SPAWN_LOCK, `${process.pid}
+${Date.now()}
+`, {
+        flag: "wx",
+        mode: INTERCOM_RUNTIME_FILE_MODE
+      }), restrictIntercomRuntimeFile(BROKER_SPAWN_LOCK), !0;
+    } catch (error) {
+      if (!(error instanceof Error) || error.code !== "EEXIST")
+        throw error;
+      if (isSpawnLockStale()) {
+        try {
+          unlinkSync(BROKER_SPAWN_LOCK);
+        } catch {
+        }
+        continue;
+      }
+      return !1;
+    }
+  return !1;
+}
+function isSpawnLockStale() {
+  if (!existsSync(BROKER_SPAWN_LOCK))
+    return !1;
+  try {
+    let [pidLine = "", createdAtLine = "0"] = readFileSync2(BROKER_SPAWN_LOCK, "utf-8").trim().split(`
+`), pid = Number.parseInt(pidLine, 10), createdAt = Number.parseInt(createdAtLine, 10), ageMs = Date.now() - createdAt;
+    if (Number.isFinite(pid))
+      try {
+        process.kill(pid, 0);
+      } catch {
+        return !0;
+      }
+    return !Number.isFinite(createdAt) || ageMs > 1e4;
+  } catch {
+    return !0;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync(BROKER_SPAWN_LOCK);
+  } catch {
+  }
+}
+async function waitForBroker(timeoutMs = 5e3) {
+  let start = Date.now();
+  for (; Date.now() - start < timeoutMs; ) {
+    if (await checkSocketConnectable())
+      return;
+    await sleep(100);
+  }
+  throw new Error("Broker failed to start within timeout");
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/ui/session-list.js
+import { truncateToWidth, visibleWidth } from "@ashx-j/lunr-tui";
+function middleTruncate(text, maxWidth) {
+  if (visibleWidth(text) <= maxWidth)
+    return text;
+  if (maxWidth <= 3)
+    return truncateToWidth(text, maxWidth, "");
+  let chars = [...text], targetSideWidth = Math.max(1, Math.floor((maxWidth - 1) / 2)), left = "";
+  for (let char of chars) {
+    if (visibleWidth(left + char) > targetSideWidth)
+      break;
+    left += char;
+  }
+  let right = "";
+  for (let char of chars.slice().reverse()) {
+    if (visibleWidth(char + right) > targetSideWidth)
+      break;
+    right = char + right;
+  }
+  return truncateToWidth(`${left}\u2026${right}`, maxWidth, "");
+}
+function shortSessionId(sessionId) {
+  return sessionId.slice(0, 8);
+}
+function sessionTitle(session, options) {
+  let name = session.name || "Unnamed session", tags = [options?.self ? "self" : void 0, options?.sameCwd ? "same cwd" : void 0].filter((tag) => !!tag), suffix = tags.length ? ` [${tags.join(", ")}]` : "";
+  return `${name} (${shortSessionId(session.id)})${suffix}`;
+}
+var SessionListOverlay = class {
+  theme;
+  keybindings;
+  currentSession;
+  done;
+  sessions;
+  selectedIndex = 0;
+  maxVisible = 8;
+  constructor(theme, keybindings, currentSession, sessions, done) {
+    this.theme = theme, this.keybindings = keybindings, this.currentSession = currentSession, this.sessions = sessions, this.done = done;
+  }
+  onSessionSelect(sessionId) {
+    let session = this.sessions.find((s) => s.id === sessionId);
+    session && this.done(session);
+  }
+  invalidate() {
+  }
+  handleInput(data) {
+    if (this.keybindings.matches(data, "tui.select.cancel")) {
+      this.done(void 0);
+      return;
+    }
+    if (this.sessions.length !== 0) {
+      if (this.keybindings.matches(data, "tui.select.up")) {
+        this.selectedIndex = this.selectedIndex === 0 ? this.sessions.length - 1 : this.selectedIndex - 1;
+        return;
+      }
+      if (this.keybindings.matches(data, "tui.select.down")) {
+        this.selectedIndex = this.selectedIndex === this.sessions.length - 1 ? 0 : this.selectedIndex + 1;
+        return;
+      }
+      if (this.keybindings.matches(data, "tui.select.confirm")) {
+        let session = this.sessions[this.selectedIndex];
+        session && this.onSessionSelect(session.id);
+      }
+    }
+  }
+  render(width) {
+    let innerWidth = Math.max(1, Math.min(width, 88));
+    if (innerWidth === 1)
+      return [this.theme.fg("accent", "\u2502")];
+    let contentWidth = Math.max(0, innerWidth - 2), footer = `${this.keybindings.getKeys("tui.select.confirm").join("/")}: Message \u2022 ${this.keybindings.getKeys("tui.select.cancel").join("/")}: Close`, border = (text) => this.theme.fg("accent", text), row = (text = "") => {
+      let clipped = truncateToWidth(text, contentWidth, "", !0);
+      return `${border("\u2502")}${clipped}${" ".repeat(Math.max(0, contentWidth - visibleWidth(clipped)))}${border("\u2502")}`;
+    }, lines = [];
+    if (lines.push(border(`\u256D${"\u2500".repeat(contentWidth)}\u256E`)), lines.push(row(this.theme.bold(" Current Session"))), lines.push(border(`\u251C${"\u2500".repeat(contentWidth)}\u2524`)), lines.push(row()), lines.push(row(`  ${this.theme.fg("dim", sessionTitle(this.currentSession, { self: !0 }))}`)), lines.push(row(`  ${this.theme.fg("dim", `${middleTruncate(this.currentSession.cwd, Math.max(8, contentWidth - 4))} \u2022 ${this.currentSession.model}`)}`)), lines.push(row()), lines.push(border(`\u251C${"\u2500".repeat(contentWidth)}\u2524`)), lines.push(row(this.theme.bold(" Other Sessions"))), lines.push(row()), this.sessions.length === 0)
+      lines.push(row(this.theme.fg("dim", " No other intercom-connected sessions")));
+    else {
+      let startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.sessions.length - this.maxVisible)), endIndex = Math.min(startIndex + this.maxVisible, this.sessions.length);
+      for (let index = startIndex; index < endIndex; index += 1) {
+        let session = this.sessions[index], isSelected = index === this.selectedIndex, sameCwd = session.cwd === this.currentSession.cwd, prefix = isSelected ? this.theme.fg("accent", "\u2192 ") : "  ", title = sessionTitle(session, { sameCwd }), pathText = `${middleTruncate(session.cwd, Math.max(8, contentWidth - 4))} \u2022 ${session.model}`;
+        lines.push(row(`${prefix}${isSelected ? this.theme.fg("accent", title) : title}`)), lines.push(row(`  ${this.theme.fg("dim", pathText)}`)), index < endIndex - 1 && lines.push(row());
+      }
+      (startIndex > 0 || endIndex < this.sessions.length) && (lines.push(row()), lines.push(row(this.theme.fg("dim", ` ${this.selectedIndex + 1}/${this.sessions.length}`))));
+    }
+    return lines.push(row()), lines.push(border(`\u251C${"\u2500".repeat(contentWidth)}\u2524`)), lines.push(row(this.theme.fg("dim", ` ${footer}`))), lines.push(border(`\u2570${"\u2500".repeat(contentWidth)}\u256F`)), lines;
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/ui/compose.js
+import { truncateToWidth as truncateToWidth2, visibleWidth as visibleWidth2 } from "@ashx-j/lunr-tui";
+var ComposeOverlay = class {
+  tui;
+  theme;
+  keybindings;
+  target;
+  targetLabel;
+  client;
+  done;
+  inputBuffer = "";
+  sending = !1;
+  error = null;
+  constructor(tui, theme, keybindings, target, targetLabel, client, done) {
+    this.tui = tui, this.theme = theme, this.keybindings = keybindings, this.target = target, this.targetLabel = targetLabel, this.client = client, this.done = done;
+  }
+  invalidate() {
+  }
+  handleInput(data) {
+    if (this.sending)
+      return;
+    if (this.keybindings.matches(data, "tui.select.cancel")) {
+      this.done({ sent: !1 });
+      return;
+    }
+    if (data.startsWith("\x1B"))
+      return;
+    if (this.keybindings.matches(data, "tui.select.confirm")) {
+      this.inputBuffer.trim() && this.sendMessage();
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.editor.deleteCharBackward")) {
+      this.inputBuffer = [...this.inputBuffer].slice(0, -1).join(""), this.tui.requestRender();
+      return;
+    }
+    let printable = [...data].filter((c) => c >= " ").join("");
+    printable && (this.inputBuffer += printable, this.tui.requestRender());
+  }
+  async sendMessage() {
+    this.sending = !0, this.error = null, this.tui.requestRender();
+    try {
+      let result = await this.client.send(this.target.id, {
+        text: this.inputBuffer.trim()
+      });
+      if (!result.delivered) {
+        this.error = result.reason ?? "Message not delivered. Session may not exist or has disconnected.", this.sending = !1, this.tui.requestRender();
+        return;
+      }
+      this.done({
+        sent: !0,
+        messageId: result.id,
+        text: this.inputBuffer.trim()
+      });
+    } catch (error) {
+      this.error = error instanceof Error ? error.message : String(error), this.sending = !1, this.tui.requestRender();
+    }
+  }
+  render(width) {
+    let innerWidth = Math.max(1, Math.min(width, 72));
+    if (innerWidth === 1)
+      return [this.theme.fg("accent", "\u2502")];
+    let contentWidth = Math.max(0, innerWidth - 2), footer = `${this.keybindings.getKeys("tui.select.confirm").join("/")}: Send \u2022 ${this.keybindings.getKeys("tui.select.cancel").join("/")}: Close`, border = (text) => this.theme.fg("accent", text), row = (text = "") => {
+      let clipped = truncateToWidth2(text, contentWidth, "", !0);
+      return `${border("\u2502")}${clipped}${" ".repeat(Math.max(0, contentWidth - visibleWidth2(clipped)))}${border("\u2502")}`;
+    }, lines = [];
+    return lines.push(border(`\u256D${"\u2500".repeat(contentWidth)}\u256E`)), lines.push(row(this.theme.bold(` Send to: ${this.targetLabel}`))), lines.push(row(this.theme.fg("dim", ` ${this.target.cwd} \u2022 ${this.target.model}`))), lines.push(border(`\u251C${"\u2500".repeat(contentWidth)}\u2524`)), lines.push(row()), this.sending ? lines.push(row(this.theme.fg("dim", " Sending..."))) : this.error ? (lines.push(row(this.theme.fg("error", ` Error: ${this.error}`))), lines.push(row()), lines.push(row(` > ${this.inputBuffer}\u2588`))) : lines.push(row(` > ${this.inputBuffer}\u2588`)), lines.push(row()), lines.push(border(`\u251C${"\u2500".repeat(contentWidth)}\u2524`)), lines.push(row(this.theme.fg("dim", ` ${footer}`))), lines.push(border(`\u2570${"\u2500".repeat(contentWidth)}\u256F`)), lines;
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/ui/inline-message.js
+import { truncateToWidth as truncateToWidth3, visibleWidth as visibleWidth3, wrapTextWithAnsi } from "@ashx-j/lunr-tui";
+var InlineMessageComponent = class {
+  from;
+  message;
+  theme;
+  replyCommand;
+  bodyText;
+  collapsed;
+  constructor(from, message, theme, replyCommand, bodyText, collapsed = !1) {
+    this.from = from, this.message = message, this.theme = theme, this.replyCommand = replyCommand, this.bodyText = bodyText, this.collapsed = collapsed;
+  }
+  invalidate() {
+  }
+  render(width) {
+    let lines = [], senderName = this.from.name || this.from.id.slice(0, 8);
+    if (width < 3)
+      return [truncateToWidth3(`From ${senderName}`, width)];
+    let bodyWidth = Math.max(1, width - 2), header = ` \u{1F4E8} From: ${senderName} (${this.from.cwd}) `, headerText = truncateToWidth3(this.collapsed ? `${header} Ctrl+O expands ` : header, bodyWidth, ""), headerPadding = Math.max(0, bodyWidth - visibleWidth3(headerText));
+    if (lines.push(this.theme.fg("accent", `\u256D${headerText}${"\u2500".repeat(headerPadding)}\u256E`)), this.collapsed) {
+      let preview = (this.bodyText || this.message.content.text).replace(/\s+/g, " ").trim(), previewText2 = truncateToWidth3(preview, bodyWidth, ""), previewPadding = Math.max(0, bodyWidth - visibleWidth3(previewText2));
+      lines.push(this.theme.fg("accent", `\u2502${previewText2}${" ".repeat(previewPadding)}\u2502`));
+      let meta = [];
+      if (this.replyCommand && meta.push(`\u21A9 To reply: ${this.replyCommand}`), this.message.content.attachments?.length) {
+        let count = this.message.content.attachments.length;
+        meta.push(`\u{1F4CE} ${count} attachment${count === 1 ? "" : "s"}`);
+      }
+      this.message.replyTo && !this.message.expectsReply && meta.push(`\u21B3 Reply to ${this.message.replyTo.slice(0, 8)}`), meta.push("Ctrl+O to expand");
+      let metaText = truncateToWidth3(this.theme.fg("dim", ` ${meta.join(" \xB7 ")}`), bodyWidth, ""), metaPadding = Math.max(0, bodyWidth - visibleWidth3(metaText));
+      return lines.push(this.theme.fg("accent", `\u2502${metaText}${" ".repeat(metaPadding)}\u2502`)), lines.push(this.theme.fg("accent", `\u2570${"\u2500".repeat(bodyWidth)}\u256F`)), lines;
+    }
+    let contentLines = wrapTextWithAnsi(this.bodyText || this.message.content.text, bodyWidth);
+    for (let line of contentLines) {
+      let text = truncateToWidth3(line, bodyWidth, ""), padding = Math.max(0, bodyWidth - visibleWidth3(text));
+      lines.push(this.theme.fg("accent", `\u2502${text}${" ".repeat(padding)}\u2502`));
+    }
+    if (this.replyCommand) {
+      lines.push(this.theme.fg("accent", `\u2502${" ".repeat(bodyWidth)}\u2502`));
+      let replyLines = wrapTextWithAnsi(this.theme.fg("dim", ` \u21A9 To reply: ${this.replyCommand}`), bodyWidth);
+      for (let line of replyLines) {
+        let text = truncateToWidth3(line, bodyWidth, ""), padding = Math.max(0, bodyWidth - visibleWidth3(text));
+        lines.push(this.theme.fg("accent", `\u2502${text}${" ".repeat(padding)}\u2502`));
+      }
+    }
+    if (this.message.content.attachments?.length) {
+      lines.push(this.theme.fg("accent", `\u2502${" ".repeat(bodyWidth)}\u2502`));
+      for (let att of this.message.content.attachments) {
+        let label = this.theme.fg("dim", ` \u{1F4CE} ${att.name}`), text = truncateToWidth3(label, bodyWidth, ""), padding = Math.max(0, bodyWidth - visibleWidth3(text));
+        lines.push(this.theme.fg("accent", `\u2502${text}${" ".repeat(padding)}\u2502`));
+      }
+    }
+    if (this.message.replyTo && !this.message.expectsReply) {
+      lines.push(this.theme.fg("accent", `\u2502${" ".repeat(bodyWidth)}\u2502`));
+      let reply = this.theme.fg("dim", ` \u21B3 Reply to ${this.message.replyTo.slice(0, 8)}`), text = truncateToWidth3(reply, bodyWidth, ""), padding = Math.max(0, bodyWidth - visibleWidth3(text));
+      lines.push(this.theme.fg("accent", `\u2502${text}${" ".repeat(padding)}\u2502`));
+    }
+    return lines.push(this.theme.fg("accent", `\u2570${"\u2500".repeat(bodyWidth)}\u256F`)), lines;
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/config.js
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+var DEFAULT_ASK_TIMEOUT_MS = 600 * 1e3;
+function getAskTimeoutMs() {
+  let raw = process.env.PI_INTERCOM_ASK_TIMEOUT_MS;
+  if (raw === void 0 || raw.trim() === "")
+    return DEFAULT_ASK_TIMEOUT_MS;
+  let value = Number(raw);
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw new Error("PI_INTERCOM_ASK_TIMEOUT_MS must be a positive integer number of milliseconds");
+  return value;
+}
+function getConfigPath(intercomDir = getIntercomDirPath()) {
+  return join3(intercomDir, "config.json");
+}
+var defaults = {
+  brokerCommand: "npx",
+  brokerArgs: ["--no-install", "tsx"],
+  confirmSend: !1,
+  inboundTrigger: "always",
+  enabled: !0,
+  replyHint: !0
+};
+function loadConfig() {
+  let configPath = getConfigPath();
+  if (!existsSync2(configPath))
+    return { ...defaults };
+  try {
+    let raw = readFileSync3(configPath, "utf-8"), parsed = JSON.parse(raw);
+    if (typeof parsed != "object" || parsed === null || Array.isArray(parsed))
+      throw new Error("Config must be a JSON object");
+    let parsedConfig = parsed, config = { ...defaults };
+    if (Object.hasOwn(parsedConfig, "brokerCommand")) {
+      if (typeof parsedConfig.brokerCommand != "string")
+        throw new Error('"brokerCommand" must be a string');
+      let brokerCommand = parsedConfig.brokerCommand.trim();
+      if (!brokerCommand)
+        throw new Error('"brokerCommand" must not be empty');
+      config.brokerCommand = brokerCommand;
+    }
+    if (Object.hasOwn(parsedConfig, "brokerArgs")) {
+      if (!Array.isArray(parsedConfig.brokerArgs))
+        throw new Error('"brokerArgs" must be an array');
+      let brokerArgs = [];
+      for (let arg of parsedConfig.brokerArgs) {
+        if (typeof arg != "string")
+          throw new Error('"brokerArgs" items must be strings');
+        brokerArgs.push(arg);
+      }
+      config.brokerArgs = brokerArgs;
+    }
+    if (Object.hasOwn(parsedConfig, "confirmSend")) {
+      if (typeof parsedConfig.confirmSend != "boolean")
+        throw new Error('"confirmSend" must be a boolean');
+      config.confirmSend = parsedConfig.confirmSend;
+    }
+    if (Object.hasOwn(parsedConfig, "enabled")) {
+      if (typeof parsedConfig.enabled != "boolean")
+        throw new Error('"enabled" must be a boolean');
+      config.enabled = parsedConfig.enabled;
+    }
+    if (Object.hasOwn(parsedConfig, "inboundTrigger")) {
+      if (parsedConfig.inboundTrigger !== "always" && parsedConfig.inboundTrigger !== "replies" && parsedConfig.inboundTrigger !== "never")
+        throw new Error('"inboundTrigger" must be "always", "replies", or "never"');
+      config.inboundTrigger = parsedConfig.inboundTrigger;
+    }
+    if (Object.hasOwn(parsedConfig, "replyHint")) {
+      if (typeof parsedConfig.replyHint != "boolean")
+        throw new Error('"replyHint" must be a boolean');
+      config.replyHint = parsedConfig.replyHint;
+    }
+    if (Object.hasOwn(parsedConfig, "status")) {
+      if (typeof parsedConfig.status != "string")
+        throw new Error('"status" must be a string');
+      config.status = parsedConfig.status;
+    }
+    return config;
+  } catch (error) {
+    return console.error(`Failed to load intercom config at ${configPath}:`, error), { ...defaults, inboundTrigger: "never" };
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/reply-tracker.js
+function matchesPendingSender(context, to) {
+  return context.from.id === to ? !0 : context.from.name?.toLowerCase() === to.toLowerCase();
+}
+var ReplyTracker = class {
+  askTimeoutMs;
+  pendingAsks = /* @__PURE__ */ new Map();
+  pendingTurnContexts = [];
+  currentTurnContext = null;
+  constructor(askTimeoutMs = getAskTimeoutMs()) {
+    this.askTimeoutMs = askTimeoutMs;
+  }
+  recordIncomingMessage(from, message, receivedAt = Date.now()) {
+    let context = { from, message, receivedAt };
+    return message.expectsReply && this.pendingAsks.set(message.id, context), context;
+  }
+  queueTurnContext(context) {
+    this.pendingTurnContexts.push(context);
+  }
+  beginTurn(now = Date.now()) {
+    this.pruneExpired(now), this.currentTurnContext = this.pendingTurnContexts.shift() ?? null;
+  }
+  endTurn() {
+    this.currentTurnContext = null;
+  }
+  reset() {
+    this.pendingAsks.clear(), this.pendingTurnContexts.length = 0, this.currentTurnContext = null;
+  }
+  resolveReplyTarget(options, now = Date.now()) {
+    if (this.pruneExpired(now), options.replyTo) {
+      let target = this.pendingAsks.get(options.replyTo);
+      if (!target)
+        throw new Error(`No pending ask with message ID "${options.replyTo}"`);
+      if (options.to && !matchesPendingSender(target, options.to))
+        throw new Error(`Pending ask "${options.replyTo}" is not from "${options.to}"`);
+      return target;
+    }
+    if (this.currentTurnContext)
+      return this.currentTurnContext;
+    let pending = Array.from(this.pendingAsks.values());
+    if (pending.length === 1)
+      return pending[0];
+    if (options.to) {
+      let matches = pending.filter((context) => matchesPendingSender(context, options.to));
+      if (matches.length === 1)
+        return matches[0];
+      if (matches.length > 1)
+        throw new Error(`Multiple pending asks from "${options.to}" \u2014 use the sender session ID instead.`);
+      if (pending.length > 1)
+        throw new Error(`No pending ask from "${options.to}"`);
+    }
+    throw pending.length === 0 ? new Error("No active intercom context to reply to") : new Error("Multiple pending asks \u2014 specify `to`");
+  }
+  markReplied(replyTo) {
+    this.dismissPendingAsk(replyTo);
+  }
+  dismissPendingAsk(replyTo) {
+    this.pendingAsks.delete(replyTo);
+    for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1)
+      this.pendingTurnContexts[index]?.message.id === replyTo && this.pendingTurnContexts.splice(index, 1);
+    this.currentTurnContext?.message.id === replyTo && (this.currentTurnContext = null);
+  }
+  listPending(now = Date.now()) {
+    return this.pruneExpired(now), Array.from(this.pendingAsks.values()).sort((a, b) => a.receivedAt - b.receivedAt);
+  }
+  pruneExpired(now) {
+    for (let [messageId, context] of this.pendingAsks)
+      now - context.receivedAt > this.askTimeoutMs && this.dismissPendingAsk(messageId);
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-intercom/index.js
+var SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom", SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom", SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery", INBOUND_FLUSH_DELAY_MS = 200, INBOUND_IDLE_RETRY_MS = 500, DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX = "subagent-chat", SUBAGENT_ORCHESTRATOR_TARGET_ENV = "PI_SUBAGENT_ORCHESTRATOR_TARGET", SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV = "PI_SUBAGENT_ORCHESTRATOR_SESSION_ID", INTERCOM_SESSION_ID_ENV = "PI_INTERCOM_SESSION_ID", NAME_POLL_MS_ENV = "PI_INTERCOM_NAME_POLL_MS", SUBAGENT_RUN_ID_ENV = "PI_SUBAGENT_RUN_ID", SUBAGENT_CHILD_AGENT_ENV = "PI_SUBAGENT_CHILD_AGENT", SUBAGENT_CHILD_INDEX_ENV = "PI_SUBAGENT_CHILD_INDEX", SUBAGENT_INTERCOM_SESSION_NAME_ENV = "PI_SUBAGENT_INTERCOM_SESSION_NAME";
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function toError3(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function formatAttachments(attachments) {
+  let text = "";
+  for (let att of attachments)
+    att.language ? text += `
+
+---
+\u{1F4CE} ${att.name}
+~~~${att.language}
+${att.content}
+~~~` : text += `
+
+---
+\u{1F4CE} ${att.name}
+${att.content}`;
+  return text;
+}
+function readChildOrchestratorMetadata() {
+  let orchestratorTarget = process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV]?.trim(), orchestratorSessionId = process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV]?.trim() || process.env[INTERCOM_SESSION_ID_ENV]?.trim(), runId = process.env[SUBAGENT_RUN_ID_ENV]?.trim(), agent = process.env[SUBAGENT_CHILD_AGENT_ENV]?.trim(), index = process.env[SUBAGENT_CHILD_INDEX_ENV]?.trim();
+  if (!orchestratorTarget || !runId || !agent || !index)
+    return null;
+  let sessionName = process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV]?.trim();
+  return {
+    orchestratorTarget,
+    ...orchestratorSessionId ? { orchestratorSessionId } : {},
+    runId,
+    agent,
+    index,
+    ...sessionName ? { sessionName } : {}
+  };
+}
+function formatChildOrchestratorMessage(kind, metadata, message) {
+  return [
+    kind === "ask" ? "Subagent needs a supervisor decision." : kind === "interview" ? "Subagent requests a structured supervisor interview." : "Subagent progress update.",
+    `Run: ${metadata.runId}`,
+    `Agent: ${metadata.agent}`,
+    `Child index: ${metadata.index}`,
+    metadata.sessionName ? `Child intercom target: ${metadata.sessionName}` : void 0,
+    "",
+    message
+  ].filter((line) => line !== void 0).join(`
+`);
+}
+function validateSupervisorInterviewRequest(input) {
+  if (!input || typeof input != "object" || Array.isArray(input))
+    return { ok: !1, error: "interview must be an object with a questions array" };
+  let raw = input;
+  if (raw.title !== void 0 && typeof raw.title != "string")
+    return { ok: !1, error: "interview.title must be a string when provided" };
+  if (raw.description !== void 0 && typeof raw.description != "string")
+    return { ok: !1, error: "interview.description must be a string when provided" };
+  if (!Array.isArray(raw.questions) || raw.questions.length === 0)
+    return { ok: !1, error: "interview.questions must be a non-empty array" };
+  let validTypes = /* @__PURE__ */ new Set(["single", "multi", "text", "image", "info"]), ids = /* @__PURE__ */ new Set(), questions = [];
+  for (let index = 0; index < raw.questions.length; index++) {
+    let questionInput = raw.questions[index];
+    if (!questionInput || typeof questionInput != "object" || Array.isArray(questionInput))
+      return { ok: !1, error: `interview.questions[${index}] must be an object` };
+    let question = questionInput;
+    if (typeof question.id != "string" || question.id.trim() === "")
+      return { ok: !1, error: `interview.questions[${index}].id must be a non-empty string` };
+    let id = question.id.trim();
+    if (ids.has(id))
+      return { ok: !1, error: `interview question id must be unique: ${id}` };
+    if (ids.add(id), typeof question.type != "string" || !validTypes.has(question.type))
+      return { ok: !1, error: `interview.questions[${index}].type must be one of: single, multi, text, image, info` };
+    if (typeof question.question != "string" || question.question.trim() === "")
+      return { ok: !1, error: `interview.questions[${index}].question must be a non-empty string` };
+    if (question.context !== void 0 && typeof question.context != "string")
+      return { ok: !1, error: `interview.questions[${index}].context must be a string when provided` };
+    let options;
+    if (question.options !== void 0) {
+      if (!Array.isArray(question.options))
+        return { ok: !1, error: `interview.questions[${index}].options must be an array when provided` };
+      options = [];
+      for (let optionIndex = 0; optionIndex < question.options.length; optionIndex++) {
+        let option = question.options[optionIndex];
+        if (typeof option == "string") {
+          let label = option.trim();
+          if (!label)
+            return { ok: !1, error: `interview.questions[${index}].options[${optionIndex}] must not be empty` };
+          options.push(label);
+        } else {
+          if (!option || typeof option != "object" || Array.isArray(option) || typeof option.label != "string" || option.label.trim() === "")
+            return { ok: !1, error: `interview.questions[${index}].options[${optionIndex}] must be a non-empty string or an object with a non-empty label` };
+          options.push({ ...option, label: option.label.trim() });
+        }
+      }
+    }
+    if ((question.type === "single" || question.type === "multi") && (!options || options.length === 0))
+      return { ok: !1, error: `interview.questions[${index}].options must be a non-empty array for ${question.type} questions` };
+    if (question.type !== "single" && question.type !== "multi" && options)
+      return { ok: !1, error: `interview.questions[${index}].options is only valid for single and multi questions` };
+    questions.push({
+      ...question,
+      id,
+      type: question.type,
+      question: question.question.trim(),
+      ...options ? { options } : {}
+    });
+  }
+  return {
+    ok: !0,
+    interview: {
+      ...raw,
+      ...typeof raw.title == "string" ? { title: raw.title.trim() } : {},
+      ...typeof raw.description == "string" ? { description: raw.description.trim() } : {},
+      questions
+    }
+  };
+}
+function interviewOptionLabel(option) {
+  return typeof option == "string" ? option : option.label;
+}
+function interviewExampleValue(question) {
+  return question.type === "multi" ? question.options?.slice(0, 2).map(interviewOptionLabel) ?? [] : question.type === "single" ? question.options?.[0] !== void 0 ? interviewOptionLabel(question.options[0]) : "option label" : question.type === "image" ? "image/file reference or description" : "answer text";
+}
+function formatSupervisorInterviewRequest(interview, message) {
+  let lines = [], title = interview.title?.trim();
+  title && lines.push(`Interview: ${title}`);
+  let description = interview.description?.trim();
+  description && lines.push(description);
+  let note = message?.trim();
+  note && lines.push(`Child note: ${note}`), lines.length > 0 && lines.push(""), lines.push("Questions:"), interview.questions.forEach((question, index) => {
+    if (lines.push(`${index + 1}. [${question.id}] (${question.type}) ${question.question}`), typeof question.context == "string" && question.context.trim() && lines.push(`   Context: ${question.context.trim()}`), question.options?.length) {
+      lines.push("   Options:");
+      for (let option of question.options)
+        lines.push(`   - ${interviewOptionLabel(option)}`);
+    }
+  });
+  let responseExample = {
+    responses: interview.questions.filter((question) => question.type !== "info").map((question) => ({
+      id: question.id,
+      value: interviewExampleValue(question)
+    }))
+  };
+  return lines.push("", "Supervisor reply instructions:", "Reply with plain JSON or a fenced ```json block using this stable shape. Use the question ids exactly. Info questions are context-only and do not need responses. For single questions, value is one option label. For multi questions, value is an array of option labels. For text/image questions, value is a string unless the question asks otherwise.", "", "```json", JSON.stringify(responseExample, null, 2), "```"), lines.join(`
+`);
+}
+function validateSupervisorInterviewReply(value, interview) {
+  if (!value || typeof value != "object" || Array.isArray(value))
+    throw new Error("reply JSON must be an object with a responses array");
+  let responsesInput = value.responses;
+  if (!Array.isArray(responsesInput))
+    throw new Error("reply JSON must include a responses array");
+  let questionById = new Map(interview.questions.filter((question) => question.type !== "info").map((question) => [question.id, question])), seenIds = /* @__PURE__ */ new Set(), responses = [];
+  for (let index = 0; index < responsesInput.length; index++) {
+    let response = responsesInput[index];
+    if (!response || typeof response != "object" || Array.isArray(response))
+      throw new Error(`responses[${index}] must be an object`);
+    let raw = response;
+    if (typeof raw.id != "string" || raw.id.trim() === "")
+      throw new Error(`responses[${index}].id must be a non-empty string`);
+    let id = raw.id.trim(), question = questionById.get(id);
+    if (!question)
+      throw new Error(`responses[${index}].id must match a non-info interview question id`);
+    if (seenIds.has(id))
+      throw new Error(`responses[${index}].id is duplicated: ${id}`);
+    if (seenIds.add(id), !Object.hasOwn(raw, "value"))
+      throw new Error(`responses[${index}].value is required`);
+    let value2 = raw.value;
+    if (question.type === "single") {
+      if (typeof value2 != "string")
+        throw new Error(`responses[${index}].value must be a string for single questions`);
+      if (!new Set(question.options?.map(interviewOptionLabel)).has(value2.trim()))
+        throw new Error(`responses[${index}].value must match one of the question options`);
+      responses.push({ id, value: value2.trim() });
+      continue;
+    }
+    if (question.type === "multi") {
+      if (!Array.isArray(value2) || value2.some((item) => typeof item != "string"))
+        throw new Error(`responses[${index}].value must be an array of strings for multi questions`);
+      let optionLabels = new Set(question.options?.map(interviewOptionLabel)), selected = value2.map((item) => item.trim()), invalid = selected.find((item) => !optionLabels.has(item));
+      if (invalid)
+        throw new Error(`responses[${index}].value contains an option that is not in the question options: ${invalid}`);
+      responses.push({ id, value: selected });
+      continue;
+    }
+    if (typeof value2 != "string")
+      throw new Error(`responses[${index}].value must be a string for ${question.type} questions`);
+    responses.push({ id, value: value2 });
+  }
+  return { responses };
+}
+function parseStructuredSupervisorReply(text, interview) {
+  let candidate = (text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1] ?? text).trim();
+  if (!(!candidate.startsWith("{") && !candidate.startsWith("[")))
+    try {
+      return { value: validateSupervisorInterviewReply(JSON.parse(candidate), interview) };
+    } catch (error) {
+      return { error: getErrorMessage(error) };
+    }
+}
+function duplicateSessionNames(sessions) {
+  return new Set(sessions.map((s) => s.name?.toLowerCase()).filter((name) => !!name).filter((name, index, names) => names.indexOf(name) !== index));
+}
+function shortSessionId2(sessionId) {
+  return sessionId.slice(0, 8);
+}
+function parseSubagentIntercomPayload(payload) {
+  if (typeof payload != "object" || payload === null)
+    return null;
+  let record = payload;
+  if (typeof record.to != "string" || typeof record.message != "string")
+    return null;
+  let requestId = typeof record.requestId == "string" ? record.requestId : void 0;
+  return { to: record.to, message: record.message, ...requestId ? { requestId } : {} };
+}
+function resolveIntercomPresenceName(sessionName, sessionId) {
+  let trimmedName = sessionName?.trim();
+  if (trimmedName)
+    return trimmedName;
+  let normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice(8) : sessionId;
+  return `${DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
+}
+function buildPresenceIdentity(pi, sessionId) {
+  return {
+    name: resolveIntercomPresenceName(pi.getSessionName(), sessionId)
+  };
+}
+function formatSessionLabel(session, duplicates) {
+  return session.name ? duplicates.has(session.name.toLowerCase()) ? `${session.name} (${shortSessionId2(session.id)})` : session.name : session.id;
+}
+function formatSessionListRow(session, currentCwd, isSelf) {
+  let name = session.name || "Unnamed session", tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : void 0, session.status].filter((tag) => !!tag), suffix = tags.length ? ` [${tags.join(", ")}]` : "";
+  return `\u2022 ${name} (${shortSessionId2(session.id)}) \u2014 ${session.cwd} (${session.model})${suffix}`;
+}
+function previewText(value, maxLength = 72) {
+  if (typeof value != "string")
+    return;
+  let normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized)
+    return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}\u2026` : normalized;
+}
+function firstTextContent(result) {
+  return result.content?.find((item) => item.type === "text" && typeof item.text == "string")?.text?.replace(/\*\*/g, "") ?? "";
+}
+function getNamePollMs() {
+  let configured = process.env[NAME_POLL_MS_ENV];
+  if (configured !== void 0) {
+    let value = Number(configured);
+    if (Number.isFinite(value) && value > 0)
+      return value;
+  }
+  return 1e3;
+}
+function piIntercomExtension(pi) {
+  let client = null, config = loadConfig(), askTimeoutMs = getAskTimeoutMs(), runtimeContext = null, currentSessionId = null, currentModel = "unknown", sessionStartedAt = null, reconnectTimer = null, namePollTimer = null, lastPresenceName = null, previousIntercomSessionId = process.env[INTERCOM_SESSION_ID_ENV], reconnectPromise = null, reconnectPromiseGeneration = null, startupConnectTimer = null, reconnectAttempt = 0, shuttingDown = !1, disposed = !0, runtimeStarted = !1, runtimeGeneration = 0, agentRunning = !1, activeTools = /* @__PURE__ */ new Map(), replyTracker = new ReplyTracker(), pendingIdleMessages = [], inboundFlushTimer = null, replyWaiter = null;
+  function waitForReply(from, replyTo, signal, onCancel) {
+    return replyWaiter ? Promise.reject(new Error("Already waiting for a reply")) : signal?.aborted ? Promise.reject(new Error("Cancelled")) : new Promise((resolve2, reject) => {
+      let timeout = setTimeout(() => {
+        onCancel?.();
+        let timeoutDescription = askTimeoutMs % 6e4 === 0 ? `${askTimeoutMs / 6e4} minutes` : `${askTimeoutMs}ms`;
+        rejectReplyWaiter(new Error(`No reply from "${from}" within ${timeoutDescription}`));
+      }, askTimeoutMs), cleanup = () => {
+        clearTimeout(timeout), signal?.removeEventListener("abort", onAbort), replyWaiter?.replyTo === replyTo && (replyWaiter = null);
+      }, onAbort = () => {
+        onCancel?.(), cleanup(), reject(new Error("Cancelled"));
+      };
+      signal?.addEventListener("abort", onAbort, { once: !0 }), replyWaiter = {
+        from,
+        replyTo,
+        resolve: (message) => {
+          cleanup(), resolve2(message);
+        },
+        reject: (error) => {
+          cleanup(), reject(error);
+        }
+      };
+    });
+  }
+  function rejectReplyWaiter(error) {
+    replyWaiter?.reject(error);
+  }
+  function clearReconnectTimer() {
+    reconnectTimer && (clearTimeout(reconnectTimer), reconnectTimer = null);
+  }
+  function clearStartupConnectTimer() {
+    startupConnectTimer && (clearTimeout(startupConnectTimer), startupConnectTimer = null);
+  }
+  function clearNamePollTimer() {
+    namePollTimer && (clearInterval(namePollTimer), namePollTimer = null);
+  }
+  function clearInboundFlushTimer() {
+    inboundFlushTimer && (clearTimeout(inboundFlushTimer), inboundFlushTimer = null);
+  }
+  function getLiveContext(ctx = runtimeContext, generation = runtimeGeneration) {
+    if (disposed || shuttingDown || generation !== runtimeGeneration || !ctx)
+      return null;
+    try {
+      return currentSessionId && ctx.sessionManager.getSessionId() !== currentSessionId ? null : (ctx.hasUI, ctx);
+    } catch {
+      return null;
+    }
+  }
+  function notifyIfLive(ctx, message, level, generation = runtimeGeneration) {
+    let liveContext = getLiveContext(ctx, generation);
+    if (liveContext?.hasUI)
+      try {
+        liveContext.ui.notify(message, level);
+      } catch {
+      }
+  }
+  function getReconnectDelayMs() {
+    let backoffMs = [1e3, 2e3, 5e3, 1e4, 3e4];
+    return backoffMs[Math.min(reconnectAttempt, backoffMs.length - 1)];
+  }
+  function currentStatus() {
+    let activeToolName = activeTools.values().next().value, lifecycleStatus = activeToolName ? `tool:${activeToolName}` : agentRunning ? "thinking" : "idle";
+    return config.status ? `${lifecycleStatus} \xB7 ${config.status}` : lifecycleStatus;
+  }
+  function buildRegistration() {
+    let liveContext = getLiveContext();
+    if (!liveContext || !currentSessionId || sessionStartedAt === null)
+      throw new Error("Intercom runtime not initialized");
+    return {
+      name: buildPresenceIdentity(pi, currentSessionId).name,
+      cwd: liveContext.cwd,
+      model: currentModel,
+      pid: process.pid,
+      startedAt: sessionStartedAt,
+      lastActivity: Date.now(),
+      status: currentStatus()
+    };
+  }
+  function syncPresenceIdentity(sessionId) {
+    if (!client || !getLiveContext())
+      return;
+    let identity = buildPresenceIdentity(pi, sessionId);
+    lastPresenceName = identity.name, client.updatePresence({ ...identity, status: currentStatus() });
+  }
+  function startNamePoll() {
+    clearNamePollTimer(), lastPresenceName = currentSessionId ? buildPresenceIdentity(pi, currentSessionId).name : null, namePollTimer = setInterval(() => {
+      if (!currentSessionId || !getLiveContext())
+        return;
+      buildPresenceIdentity(pi, currentSessionId).name !== lastPresenceName && syncPresenceIdentity(currentSessionId);
+    }, getNamePollMs()), namePollTimer.unref?.();
+  }
+  function publishIntercomSessionId(sessionId) {
+    process.env[INTERCOM_SESSION_ID_ENV] = sessionId;
+  }
+  function restoreIntercomSessionId() {
+    if (previousIntercomSessionId === void 0) {
+      delete process.env[INTERCOM_SESSION_ID_ENV];
+      return;
+    }
+    process.env[INTERCOM_SESSION_ID_ENV] = previousIntercomSessionId;
+  }
+  function syncPresenceStatus() {
+    !client || !currentSessionId || !getLiveContext() || client.updatePresence({ status: currentStatus() });
+  }
+  function currentSessionTargetMatches(to, resolvedTo, activeClient) {
+    let targets = /* @__PURE__ */ new Set(), addTarget = (target) => {
+      let trimmed = target?.trim();
+      trimmed && targets.add(trimmed.toLowerCase());
+    };
+    return addTarget(currentSessionId), addTarget(activeClient?.sessionId), addTarget(pi.getSessionName()), currentSessionId && addTarget(buildPresenceIdentity(pi, currentSessionId).name), !!(resolvedTo && activeClient?.sessionId && resolvedTo === activeClient.sessionId) || targets.has(to.trim().toLowerCase());
+  }
+  function shouldTriggerInboundMessage(entry, forceTrigger = !1) {
+    return forceTrigger || config.inboundTrigger === "always" ? !0 : config.inboundTrigger === "replies" ? !!entry.message.replyTo : !1;
+  }
+  function sendIncomingMessage(entry, delivery, generation = runtimeGeneration, forceTrigger = !1) {
+    if (runtimeStarted && !getLiveContext(runtimeContext, generation))
+      return;
+    delivery !== "followUp" && replyTracker.queueTurnContext({ from: entry.from, message: entry.message, receivedAt: Date.now() });
+    let senderDisplay = entry.from.name || entry.from.id.slice(0, 8), replyInstruction = entry.replyCommand ? `
+
+To reply, use the intercom tool: ${entry.replyCommand}` : "";
+    pi.sendMessage({
+      customType: "intercom_message",
+      content: `**\u{1F4E8} From ${senderDisplay}** (${entry.from.cwd})${replyInstruction}
+
+${entry.bodyText}`,
+      display: !0,
+      details: entry
+    }, delivery === "trigger" && shouldTriggerInboundMessage(entry, forceTrigger) ? { triggerTurn: !0 } : { deliverAs: "followUp" });
+  }
+  function scheduleInboundFlush(delayMs = INBOUND_FLUSH_DELAY_MS) {
+    if (!getLiveContext())
+      return;
+    let scheduledGeneration = runtimeGeneration;
+    clearInboundFlushTimer(), inboundFlushTimer = setTimeout(() => {
+      inboundFlushTimer = null, flushIdleMessages(scheduledGeneration);
+    }, delayMs);
+  }
+  function flushIdleMessages(generation = runtimeGeneration) {
+    if (pendingIdleMessages.length === 0)
+      return;
+    let ctx = getLiveContext(runtimeContext, generation);
+    if (!ctx)
+      return;
+    let isIdle;
+    try {
+      isIdle = ctx.isIdle();
+    } catch {
+      return;
+    }
+    if (!isIdle) {
+      scheduleInboundFlush(INBOUND_IDLE_RETRY_MS);
+      return;
+    }
+    pendingIdleMessages.splice(0, pendingIdleMessages.length).forEach((entry, index) => {
+      sendIncomingMessage(entry, index === 0 ? "trigger" : "followUp");
+    });
+  }
+  function queueIdleMessage(entry) {
+    pendingIdleMessages.push(entry), scheduleInboundFlush();
+  }
+  function handleIncomingMessage(ctx, from, message) {
+    let messageGeneration = runtimeGeneration, liveContext = getLiveContext(ctx, messageGeneration);
+    if (!liveContext)
+      return;
+    if (replyWaiter) {
+      let fromMatches = (from.name || from.id).toLowerCase() === replyWaiter.from.toLowerCase() || from.id === replyWaiter.from, replyMatches = message.replyTo === replyWaiter.replyTo;
+      if (fromMatches && replyMatches) {
+        replyWaiter.resolve(message);
+        return;
+      }
+    }
+    let attachmentText = message.content.attachments?.length ? formatAttachments(message.content.attachments) : "", bodyText = `${message.content.text}${attachmentText}`, replyCommand = config.replyHint && message.expectsReply ? 'intercom({ action: "reply", message: "..." })' : void 0;
+    replyTracker.recordIncomingMessage(from, message);
+    let entry = { from, message, replyCommand, bodyText };
+    (async () => {
+      let activeContext = getLiveContext(liveContext, messageGeneration);
+      if (activeContext) {
+        if (!activeContext.isIdle()) {
+          if (!activeContext.hasUI) {
+            let activeClient = client;
+            if (!message.replyTo && activeClient?.isConnected())
+              try {
+                (await activeClient.send(from.id, {
+                  text: "This agent is running in non-interactive mode and cannot respond to intercom messages while it is working. It will continue its current task and exit when done.",
+                  replyTo: message.id
+                })).delivered && getLiveContext(liveContext, messageGeneration) && replyTracker.markReplied(message.id);
+              } catch {
+              }
+            return;
+          }
+          queueIdleMessage(entry);
+          return;
+        }
+        getLiveContext(liveContext, messageGeneration) && sendIncomingMessage(entry, "trigger", messageGeneration);
+      }
+    })();
+  }
+  function attachClientHandlers(nextClient) {
+    nextClient.on("message", (from, message) => {
+      let liveContext = getLiveContext();
+      client !== nextClient || !liveContext || handleIncomingMessage(liveContext, from, message);
+    }), nextClient.on("disconnected", (error) => {
+      client === nextClient && (rejectReplyWaiter(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error })), client = null, !shuttingDown && !disposed && (clearReconnectTimer(), scheduleReconnect()));
+    }), nextClient.on("error", () => {
+    });
+  }
+  function scheduleReconnect() {
+    if (disposed || shuttingDown || reconnectTimer || reconnectPromise || !getLiveContext())
+      return;
+    let scheduledGeneration = runtimeGeneration;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null, !(scheduledGeneration !== runtimeGeneration || !getLiveContext()) && (reconnectAttempt += 1, ensureConnected("background").catch(() => {
+      }));
+    }, getReconnectDelayMs());
+  }
+  async function ensureConnected(reason) {
+    if (!config.enabled)
+      throw new Error("Intercom disabled");
+    if (disposed || shuttingDown)
+      throw new Error("Intercom shutting down");
+    if (client && client.isConnected())
+      return client;
+    let contextAtStart = getLiveContext(), generationAtStart = runtimeGeneration;
+    if (!contextAtStart || !currentSessionId || sessionStartedAt === null)
+      throw new Error("Intercom runtime not initialized");
+    if (clearReconnectTimer(), reconnectPromise && reconnectPromiseGeneration === generationAtStart)
+      return reconnectPromise;
+    let nextReconnectPromise = (async () => {
+      let nextClient = new IntercomClient();
+      client = nextClient, attachClientHandlers(nextClient);
+      try {
+        if (await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs), await nextClient.connect(buildRegistration(), currentSessionId), !getLiveContext(contextAtStart, generationAtStart))
+          throw await nextClient.disconnect(), new Error("Intercom runtime no longer active");
+        return client = nextClient, reconnectAttempt = 0, nextClient;
+      } catch (error) {
+        throw client === nextClient && (client = null), reason === "background" && getLiveContext(contextAtStart, generationAtStart) && scheduleReconnect(), toError3(error);
+      } finally {
+        reconnectPromise === nextReconnectPromise && (reconnectPromise = null, reconnectPromiseGeneration = null);
+      }
+    })();
+    return reconnectPromise = nextReconnectPromise, reconnectPromiseGeneration = generationAtStart, nextReconnectPromise;
+  }
+  async function resolveSessionTarget(activeClient, nameOrId) {
+    let sessions = await activeClient.listSessions(), byId = sessions.find((s) => s.id === nameOrId);
+    if (byId)
+      return byId.id;
+    let lowerName = nameOrId.toLowerCase(), byName = sessions.filter((s) => s.name?.toLowerCase() === lowerName);
+    if (byName.length > 1)
+      throw new Error(`Multiple sessions named "${nameOrId}" are connected. Use the session ID instead.`);
+    if (byName.length === 1)
+      return byName[0].id;
+    let byIdPrefix = sessions.filter((s) => s.id.startsWith(nameOrId));
+    if (byIdPrefix.length === 1)
+      return byIdPrefix[0].id;
+    if (byIdPrefix.length > 1)
+      throw new Error(`Multiple sessions match ID prefix "${nameOrId}". Use a longer session ID prefix.`);
+    return null;
+  }
+  async function resolveSupervisorTarget(activeClient, metadata) {
+    if (metadata.orchestratorSessionId) {
+      let bySessionId = await resolveSessionTarget(activeClient, metadata.orchestratorSessionId);
+      if (bySessionId)
+        return bySessionId;
+    }
+    return await resolveSessionTarget(activeClient, metadata.orchestratorTarget) ?? metadata.orchestratorTarget;
+  }
+  function deliverLocalSubagentRelayMessage(sender, status, messageText) {
+    let liveContext = getLiveContext(), now = Date.now();
+    sendIncomingMessage({
+      from: {
+        id: sender,
+        name: sender,
+        cwd: liveContext?.cwd ?? "",
+        model: sender,
+        pid: process.pid,
+        startedAt: now,
+        lastActivity: now,
+        status
+      },
+      message: {
+        id: randomUUID3(),
+        timestamp: now,
+        content: { text: messageText }
+      },
+      bodyText: messageText
+    }, "trigger", runtimeGeneration, !0);
+  }
+  function recordSubagentDeliveryError(entryType, to, message, error) {
+    pi.appendEntry(entryType, {
+      to,
+      message,
+      error: getErrorMessage(error),
+      timestamp: Date.now()
+    });
+  }
+  function startSessionRuntime(ctx) {
+    let previousClient = client;
+    previousClient && (client = null, previousClient.disconnect().catch(() => {
+    })), shuttingDown = !1, disposed = !1, runtimeStarted = !0, runtimeGeneration += 1, reconnectAttempt = 0, clearReconnectTimer(), clearStartupConnectTimer(), clearNamePollTimer(), clearInboundFlushTimer(), rejectReplyWaiter(new Error("Session replaced")), replyTracker.reset(), pendingIdleMessages.length = 0, runtimeContext = ctx, currentSessionId = ctx.sessionManager.getSessionId(), publishIntercomSessionId(currentSessionId), currentModel = ctx.model?.id ?? "unknown", sessionStartedAt = Date.now(), lastPresenceName = buildPresenceIdentity(pi, currentSessionId).name, agentRunning = !1, activeTools.clear(), startNamePoll();
+    let startupGeneration = runtimeGeneration;
+    startupConnectTimer = setTimeout(() => {
+      startupConnectTimer = null, getLiveContext(ctx, startupGeneration) && ensureConnected("startup").catch(() => {
+        getLiveContext(ctx, startupGeneration) && (client = null, scheduleReconnect());
+      });
+    }, 0);
+  }
+  function emitResultDelivery(requestId, delivered, error) {
+    requestId && pi.events.emit(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, {
+      requestId,
+      delivered,
+      ...error ? { error: getErrorMessage(error) } : {}
+    });
+  }
+  function relaySubagentIntercomPayload(payload, options) {
+    let parsed = parseSubagentIntercomPayload(payload);
+    if (!parsed)
+      return;
+    let relayGeneration = runtimeGeneration;
+    (async () => {
+      let relayStillLive = () => !runtimeStarted || !!getLiveContext(runtimeContext, relayGeneration);
+      if (!relayStillLive())
+        return;
+      if (currentSessionTargetMatches(parsed.to)) {
+        deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message), options.acknowledge && emitResultDelivery(parsed.requestId, !0);
+        return;
+      }
+      let activeClient, target;
+      try {
+        activeClient = await ensureConnected("background"), target = await resolveSessionTarget(activeClient, parsed.to) ?? parsed.to;
+      } catch (error) {
+        if (!relayStillLive())
+          return;
+        recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error), options.acknowledge && emitResultDelivery(parsed.requestId, !1, error);
+        return;
+      }
+      if (relayStillLive()) {
+        if (currentSessionTargetMatches(parsed.to, target, activeClient)) {
+          deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message), options.acknowledge && emitResultDelivery(parsed.requestId, !0);
+          return;
+        }
+        try {
+          let result = await activeClient.send(target, { text: parsed.message });
+          if (!relayStillLive())
+            return;
+          if (!result.delivered) {
+            let error = new Error(result.reason ?? "Session may not exist or has disconnected.");
+            recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error), options.acknowledge && emitResultDelivery(parsed.requestId, !1, error);
+            return;
+          }
+          options.acknowledge && emitResultDelivery(parsed.requestId, !0);
+        } catch (error) {
+          if (!relayStillLive())
+            return;
+          recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error), options.acknowledge && emitResultDelivery(parsed.requestId, !1, error);
+        }
+      }
+    })();
+  }
+  let unsubscribeSubagentControlIntercom = pi.events.on(SUBAGENT_CONTROL_INTERCOM_EVENT, (payload) => {
+    relaySubagentIntercomPayload(payload, {
+      sender: "subagent-control",
+      status: "needs_attention",
+      errorEntryType: "intercom_control_error"
+    });
+  }), unsubscribeSubagentResultIntercom = pi.events.on(SUBAGENT_RESULT_INTERCOM_EVENT, (payload) => {
+    relaySubagentIntercomPayload(payload, {
+      sender: "subagent-result",
+      status: "result",
+      errorEntryType: "intercom_result_error",
+      acknowledge: !0
+    });
+  });
+  pi.on("session_start", (_event, ctx) => {
+    config.enabled && startSessionRuntime(ctx);
+  }), pi.on("session_shutdown", async () => {
+    unsubscribeSubagentControlIntercom(), unsubscribeSubagentResultIntercom(), shuttingDown = !0, disposed = !0, runtimeGeneration += 1, clearStartupConnectTimer(), clearReconnectTimer(), clearNamePollTimer(), restoreIntercomSessionId(), rejectReplyWaiter(new Error("Session shutting down")), replyTracker.reset(), pendingIdleMessages.length = 0, clearInboundFlushTimer(), agentRunning = !1, activeTools.clear(), client && (await client.disconnect(), client = null), runtimeContext = null, currentSessionId = null, sessionStartedAt = null;
+  }), pi.on("turn_end", () => {
+    getLiveContext() && (replyTracker.endTurn(), scheduleInboundFlush(0));
+  }), pi.on("agent_start", () => {
+    getLiveContext() && (agentRunning = !0, activeTools.clear(), syncPresenceStatus());
+  }), pi.on("tool_execution_start", (event) => {
+    getLiveContext() && (activeTools.set(event.toolCallId, event.toolName), syncPresenceStatus());
+  }), pi.on("tool_execution_end", (event) => {
+    getLiveContext() && (activeTools.delete(event.toolCallId), syncPresenceStatus());
+  }), pi.on("agent_end", () => {
+    getLiveContext() && (agentRunning = !1, activeTools.clear(), syncPresenceStatus(), scheduleInboundFlush(0));
+  }), pi.on("turn_start", (_event, ctx) => {
+    let sessionId = ctx.sessionManager.getSessionId();
+    if (!currentSessionId || sessionId !== currentSessionId) {
+      if (!config.enabled)
+        return;
+      startSessionRuntime(ctx), replyTracker.beginTurn();
+      return;
+    }
+    getLiveContext(ctx) && (syncPresenceIdentity(sessionId), replyTracker.beginTurn());
+  }), pi.on("model_select", (event, ctx) => {
+    getLiveContext(ctx) && (currentModel = event.model.id, client && client.updatePresence({
+      ...buildPresenceIdentity(pi, ctx.sessionManager.getSessionId()),
+      model: event.model.id,
+      status: currentStatus()
+    }));
+  }), pi.registerMessageRenderer("intercom_message", (message, options, theme) => {
+    let details = message.details;
+    if (!details)
+      return;
+    let sender = details.from?.name || details.from?.id;
+    return sender === "subagent-result" || sender === "subagent-control" ? { render: () => [], invalidate() {
+    } } : new InlineMessageComponent(details.from, details.message, theme, details.replyCommand, details.bodyText, !options.expanded);
+  }), pi.on("tool_result", (event) => {
+    if (event.toolName !== "intercom" && event.toolName !== "contact_supervisor" || !event.details || typeof event.details != "object")
+      return;
+    let details = event.details;
+    if (details.error === !0 || details.delivered === !1)
+      return { isError: !0 };
+  });
+  let childOrchestratorMetadata = readChildOrchestratorMetadata();
+  childOrchestratorMetadata && pi.registerTool({
+    name: "contact_supervisor",
+    label: "Contact Supervisor",
+    description: "Subagent-only tool for contacting the supervisor agent that delegated this task. Use need_decision when blocked, uncertain, needing approval, or facing a product/API/scope decision before continuing; this waits for the supervisor's reply. Use interview_request when multiple structured questions need supervisor answers; this also waits for a reply. Use progress_update only for meaningful progress or unexpected discoveries that change the plan; this does not wait for a reply. Do not use for routine completion handoffs.",
+    promptSnippet: "Subagent-only: contact the supervisor for decisions, structured interviews, or meaningful plan-changing updates. Do not use for routine completion handoffs.",
+    promptGuidelines: [
+      "Use contact_supervisor with reason='need_decision' when a subagent is blocked, uncertain, needs approval, or faces a product/API/scope decision before continuing.",
+      "Use contact_supervisor with reason='interview_request' when the child needs multiple structured answers from the supervisor in one blocking exchange.",
+      "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: StringEnum(["need_decision", "progress_update", "interview_request"], {
+        description: "Contact reason: 'need_decision' waits for a reply; 'interview_request' sends structured questions and waits for a reply; '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: StringEnum(["single", "multi", "text", "image", "info"], {
+            description: "Question type: single, multi, text, image, or info"
+          }),
+          question: Type.String(),
+          options: Type.Optional(Type.Array(Type.Any())),
+          context: Type.Optional(Type.String())
+        }))
+      }, { description: "Structured interview request for reason='interview_request'" }))
+    }),
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      let reason = params.reason;
+      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'." }],
+          details: { error: !0 }
+        };
+      if ((reason === "need_decision" || reason === "progress_update") && typeof params.message != "string")
+        return {
+          content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
+          details: { error: !0 }
+        };
+      let interviewValidation = reason === "interview_request" ? validateSupervisorInterviewRequest(params.interview) : void 0;
+      if (interviewValidation?.ok === !1)
+        return {
+          content: [{ type: "text", text: `Invalid interview request: ${interviewValidation.error}` }],
+          details: { error: !0 }
+        };
+      let supervisorInterview = interviewValidation?.ok === !0 ? interviewValidation.interview : void 0, connectedClient;
+      try {
+        connectedClient = await ensureConnected("tool");
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
+          details: { error: !0 }
+        };
+      }
+      if (syncPresenceIdentity(ctx.sessionManager.getSessionId()), signal?.aborted)
+        return {
+          content: [{ type: "text", text: "Cancelled" }],
+          details: { error: !0 }
+        };
+      let metadata = childOrchestratorMetadata, sendTo;
+      try {
+        sendTo = await resolveSupervisorTarget(connectedClient, metadata);
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to resolve supervisor target: ${getErrorMessage(error)}` }],
+          details: { error: !0 }
+        };
+      }
+      if (signal?.aborted)
+        return {
+          content: [{ type: "text", text: "Cancelled" }],
+          details: { error: !0 }
+        };
+      if (sendTo === connectedClient.sessionId)
+        return {
+          content: [{ type: "text", text: "Cannot message the current session" }],
+          details: { error: !0 }
+        };
+      if (reason === "progress_update") {
+        let message = params.message;
+        try {
+          let result = await connectedClient.send(sendTo, {
+            text: formatChildOrchestratorMessage("update", metadata, message)
+          });
+          if (!result.delivered) {
+            let errorText = result.reason ?? "Session may not exist or has disconnected.";
+            return {
+              content: [{ type: "text", text: `Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}` }],
+              details: { messageId: result.id, delivered: !1, reason: result.reason }
+            };
+          }
+          return 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 }
+          }), {
+            content: [{ type: "text", text: `Progress update sent to supervisor ${metadata.orchestratorTarget}` }],
+            details: { messageId: result.id, delivered: !0 }
+          };
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Failed to send progress update: ${getErrorMessage(error)}` }],
+            details: { error: !0 }
+          };
+        }
+      }
+      if (replyWaiter)
+        return {
+          content: [{ type: "text", text: "Already waiting for a reply" }],
+          details: { error: !0 }
+        };
+      let replyPromise = null;
+      try {
+        let questionId = randomUUID3();
+        if (replyPromise = waitForReply(sendTo, questionId, signal, () => connectedClient.cancelAsk(questionId)), replyPromise.catch(() => {
+        }), signal?.aborted) {
+          rejectReplyWaiter(new Error("Cancelled"));
+          try {
+            await replyPromise;
+          } catch {
+          }
+          return {
+            content: [{ type: "text", text: "Cancelled" }],
+            details: { error: !0 }
+          };
+        }
+        let requestText = reason === "interview_request" ? formatChildOrchestratorMessage("interview", metadata, formatSupervisorInterviewRequest(supervisorInterview, typeof params.message == "string" ? params.message : void 0)) : formatChildOrchestratorMessage("ask", metadata, params.message), sendResult = await connectedClient.send(sendTo, {
+          messageId: questionId,
+          text: requestText,
+          expectsReply: !0
+        });
+        if (!sendResult.delivered) {
+          let errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
+          if (rejectReplyWaiter(new Error(`Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}`)), replyPromise)
+            try {
+              await replyPromise;
+            } catch {
+            }
+          return {
+            content: [{ type: "text", text: `Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}` }],
+            details: { error: !0 }
+          };
+        }
+        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 }
+        });
+        let replyMessage = await replyPromise, replyText = replyMessage.content.text, replyAttachments = replyMessage.content.attachments?.length ? formatAttachments(replyMessage.content.attachments) : "", structuredReply = reason === "interview_request" ? parseStructuredSupervisorReply(replyText, supervisorInterview) : void 0;
+        return 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 }
+        }), {
+          content: [{ type: "text", text: `**Reply from supervisor:**
+${replyText}${replyAttachments}` }],
+          details: structuredReply ? structuredReply.value !== void 0 ? { structuredReply: structuredReply.value } : { structuredReplyParseError: structuredReply.error } : {}
+        };
+      } catch (error) {
+        if (rejectReplyWaiter(toError3(error)), replyPromise)
+          try {
+            await replyPromise;
+          } catch {
+          }
+        return {
+          content: [{ type: "text", text: `Failed: ${getErrorMessage(error)}` }],
+          details: { error: !0 }
+        };
+      }
+    },
+    renderCall(args, theme) {
+      let reason = typeof args.reason == "string" ? args.reason : "contact", messagePreview = previewText(args.message, 96), interview = args.interview && typeof args.interview == "object" ? args.interview : void 0, text = theme.fg("toolTitle", theme.bold("contact_supervisor "));
+      return text += theme.fg(reason === "need_decision" ? "warning" : reason === "progress_update" ? "muted" : "accent", reason), typeof interview?.title == "string" && interview.title.trim() && (text += " " + theme.fg("accent", interview.title.trim())), messagePreview && (text += `
+  ` + theme.fg("dim", messagePreview)), new Text(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme, context) {
+      if (isPartial)
+        return new Text(theme.fg("warning", "Waiting for supervisor..."), 0, 0);
+      let details = result.details, textContent = firstTextContent(result), failed = !!(context.isError || details?.error === !0 || details?.delivered === !1), parseWarning = typeof details?.structuredReplyParseError == "string", text = failed ? theme.fg("error", "\u2717 ") : parseWarning ? theme.fg("warning", "\u26A0 ") : theme.fg("success", "\u2713 ");
+      return text += theme.fg(failed ? "error" : "text", textContent), parseWarning && (text += `
+` + theme.fg("warning", `Structured reply parse issue: ${details.structuredReplyParseError}`)), new Text(text, 0, 0);
+    }
+  }), pi.registerTool({
+    name: "intercom",
+    label: "Intercom",
+    description: `Send a message to another pi session running on this machine.
+Use this to communicate findings, request help, or coordinate work with other sessions.
+
+Usage:
+  intercom({ action: "list" })                    \u2192 List active sessions
+  intercom({ action: "send", to: "session-name", message: "..." })  \u2192 Send message
+  intercom({ action: "ask", to: "session-name", message: "..." })   \u2192 Ask and wait for reply
+  intercom({ action: "reply", message: "..." })                      \u2192 Reply to the active/single pending ask
+  intercom({ action: "pending" })                                      \u2192 List unresolved inbound asks
+  intercom({ action: "status" })                  \u2192 Show connection status`,
+    promptSnippet: "Use to coordinate with other local pi sessions: list peers, send updates, ask for help, or check intercom connectivity.",
+    parameters: Type.Object({
+      action: StringEnum(["list", "send", "ask", "reply", "pending", "status"], {
+        description: "Action: 'list', 'send', 'ask', 'reply', 'pending', or 'status'"
+      }),
+      to: Type.Optional(Type.String({
+        description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')"
+      })),
+      message: Type.Optional(Type.String({
+        description: "Message to send (for 'send', 'ask', or 'reply' action)"
+      })),
+      attachments: Type.Optional(Type.Array(Type.Object({
+        type: StringEnum(["file", "snippet", "context"]),
+        name: Type.String(),
+        content: Type.String(),
+        language: Type.Optional(Type.String())
+      }))),
+      replyTo: Type.Optional(Type.String({
+        description: "Message ID to reply to (for threading or responding to an 'ask')"
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      let connectedClient;
+      try {
+        connectedClient = await ensureConnected("tool");
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
+          details: { error: !0 }
+        };
+      }
+      syncPresenceIdentity(ctx.sessionManager.getSessionId());
+      let { action, to, message, attachments, replyTo } = params;
+      switch (action) {
+        case "list":
+          try {
+            let mySessionId = connectedClient.sessionId, sessions = await connectedClient.listSessions(), currentSession = sessions.find((s) => s.id === mySessionId), otherSessions = sessions.filter((s) => s.id !== mySessionId);
+            if (!currentSession)
+              return {
+                content: [{ type: "text", text: "Current session is missing from intercom session list." }],
+                details: { error: !0 }
+              };
+            let currentSection = `**Current session:**
+${formatSessionListRow(currentSession, currentSession.cwd, !0)}`, otherSection = otherSessions.length === 0 ? `**Other sessions:**
+No other sessions connected.` : `**Other sessions:**
+${otherSessions.map((s) => formatSessionListRow(s, currentSession.cwd, !1)).join(`
+`)}`;
+            return {
+              content: [{ type: "text", text: `${currentSection}
+
+${otherSection}` }],
+              details: {}
+            };
+          } catch (error) {
+            return {
+              content: [{ type: "text", text: `Failed to list sessions: ${getErrorMessage(error)}` }],
+              details: { error: !0 }
+            };
+          }
+        case "send": {
+          if (!to || !message)
+            return {
+              content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
+              details: { error: !0 }
+            };
+          try {
+            let sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
+            if (sendTo === connectedClient.sessionId)
+              return {
+                content: [{ type: "text", text: "Cannot message the current session" }],
+                details: { error: !0 }
+              };
+            if (!replyTo && config.confirmSend && ctx.hasUI) {
+              let attachmentText = attachments?.length ? formatAttachments(attachments) : "";
+              if (!await ctx.ui.confirm("Send Message", `Send to "${to}":
+
+${message}${attachmentText}`))
+                return {
+                  content: [{ type: "text", text: "Message cancelled by user" }],
+                  details: {}
+                };
+            }
+            let result = await connectedClient.send(sendTo, {
+              text: message,
+              attachments,
+              replyTo
+            });
+            if (!result.delivered) {
+              let errorText = result.reason ?? "Session may not exist or has disconnected.";
+              return {
+                content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
+                details: { messageId: result.id, delivered: !1, reason: result.reason }
+              };
+            }
+            return pi.appendEntry("intercom_sent", {
+              to,
+              message: { text: message, attachments, replyTo },
+              messageId: result.id,
+              timestamp: Date.now()
+            }), replyTo && replyTracker.markReplied(replyTo), {
+              content: [{ type: "text", text: `Message sent to ${to}` }],
+              details: { messageId: result.id, delivered: !0 }
+            };
+          } catch (error) {
+            return {
+              content: [{ type: "text", text: `Failed to send: ${getErrorMessage(error)}` }],
+              details: { error: !0 }
+            };
+          }
+        }
+        case "ask": {
+          if (!to || !message)
+            return {
+              content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
+              details: { error: !0 }
+            };
+          if (replyWaiter)
+            return {
+              content: [{ type: "text", text: "Already waiting for a reply" }],
+              details: { error: !0 }
+            };
+          if (_signal?.aborted)
+            return {
+              content: [{ type: "text", text: "Cancelled" }],
+              details: { error: !0 }
+            };
+          let replyPromise = null;
+          try {
+            let sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
+            if (_signal?.aborted)
+              return {
+                content: [{ type: "text", text: "Cancelled" }],
+                details: { error: !0 }
+              };
+            if (sendTo === connectedClient.sessionId)
+              return {
+                content: [{ type: "text", text: "Cannot message the current session" }],
+                details: { error: !0 }
+              };
+            if (replyWaiter)
+              return {
+                content: [{ type: "text", text: "Already waiting for a reply" }],
+                details: { error: !0 }
+              };
+            let questionId = randomUUID3();
+            replyPromise = waitForReply(sendTo, questionId, _signal, () => connectedClient.cancelAsk(questionId)), replyPromise.catch(() => {
+            });
+            let sendResult = await connectedClient.send(sendTo, {
+              messageId: questionId,
+              text: message,
+              attachments,
+              replyTo,
+              expectsReply: !0
+            });
+            if (!sendResult.delivered) {
+              let errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
+              if (rejectReplyWaiter(new Error(`Message to "${to}" was not delivered: ${errorText}`)), replyPromise)
+                try {
+                  await replyPromise;
+                } catch {
+                }
+              return {
+                content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
+                details: { error: !0 }
+              };
+            }
+            pi.appendEntry("intercom_sent", {
+              to,
+              message: { text: message, attachments, replyTo },
+              messageId: sendResult.id,
+              timestamp: Date.now()
+            });
+            let replyMessage = await replyPromise, replyText = replyMessage.content.text, replyAttachments = replyMessage.content.attachments?.length ? formatAttachments(replyMessage.content.attachments) : "";
+            return pi.appendEntry("intercom_received", {
+              from: to,
+              message: { text: replyText, attachments: replyMessage.content.attachments },
+              messageId: replyMessage.id,
+              timestamp: replyMessage.timestamp
+            }), {
+              content: [{ type: "text", text: `**Reply from ${to}:**
+${replyText}${replyAttachments}` }],
+              details: {}
+            };
+          } catch (error) {
+            if (rejectReplyWaiter(toError3(error)), replyPromise)
+              try {
+                await replyPromise;
+              } catch {
+              }
+            return {
+              content: [{ type: "text", text: `Failed: ${getErrorMessage(error)}` }],
+              details: { error: !0 }
+            };
+          }
+        }
+        case "reply": {
+          if (!message)
+            return {
+              content: [{ type: "text", text: "Missing 'message' parameter" }],
+              details: { error: !0 }
+            };
+          try {
+            let target = replyTracker.resolveReplyTarget({ to, replyTo });
+            if (target.from.id === connectedClient.sessionId)
+              return {
+                content: [{ type: "text", text: "Cannot message the current session" }],
+                details: { error: !0 }
+              };
+            let result = await connectedClient.send(target.from.id, {
+              text: message,
+              replyTo: target.message.id
+            });
+            if (!result.delivered) {
+              let errorText = result.reason ?? "Session may not exist or has disconnected.";
+              return result.reason === "Session not found" && replyTracker.dismissPendingAsk(target.message.id), {
+                content: [{ type: "text", text: `Reply to "${target.from.name || target.from.id}" was not delivered: ${errorText}` }],
+                details: { messageId: result.id, delivered: !1, reason: result.reason }
+              };
+            }
+            return replyTracker.markReplied(target.message.id), pi.appendEntry("intercom_sent", {
+              to: target.from.name || target.from.id,
+              message: { text: message, replyTo: target.message.id },
+              messageId: result.id,
+              timestamp: Date.now()
+            }), {
+              content: [{ type: "text", text: `Reply sent to ${target.from.name || target.from.id}` }],
+              details: { messageId: result.id, delivered: !0, replyTo: target.message.id }
+            };
+          } catch (error) {
+            return {
+              content: [{ type: "text", text: `Failed to reply: ${getErrorMessage(error)}` }],
+              details: { error: !0 }
+            };
+          }
+        }
+        case "pending": {
+          let pendingAsks = replyTracker.listPending();
+          if (pendingAsks.length === 0)
+            return {
+              content: [{ type: "text", text: "No unresolved inbound asks." }],
+              details: {}
+            };
+          let now = Date.now();
+          return {
+            content: [{ type: "text", text: `**Pending asks:**
+${pendingAsks.map(({ from, message: message2, receivedAt }) => {
+              let preview = message2.content.text.replace(/\s+/g, " ").slice(0, 80), elapsedSeconds = Math.max(0, Math.floor((now - receivedAt) / 1e3));
+              return `- ${from.name || from.id} \xB7 ${message2.id} \xB7 ${elapsedSeconds}s ago \xB7 ${preview}`;
+            }).join(`
+`)}` }],
+            details: {}
+          };
+        }
+        case "status":
+          try {
+            let mySessionId = connectedClient.sessionId, sessions = await connectedClient.listSessions();
+            return {
+              content: [{
+                type: "text",
+                text: `**Intercom Status:**
+Connected: Yes
+Session ID: ${mySessionId}
+Active sessions: ${sessions.length}`
+              }],
+              details: {}
+            };
+          } catch (error) {
+            return {
+              content: [{ type: "text", text: `Failed to get status: ${getErrorMessage(error)}` }],
+              details: { error: !0 }
+            };
+          }
+        default:
+          return {
+            content: [{ type: "text", text: `Unknown action: ${action}` }],
+            details: { error: !0 }
+          };
+      }
+    },
+    renderCall(args, theme) {
+      let action = typeof args.action == "string" ? args.action : "intercom", target = typeof args.to == "string" && args.to.trim() ? args.to.trim() : void 0, messagePreview = previewText(args.message, 96), attachmentCount = Array.isArray(args.attachments) ? args.attachments.length : 0, text = theme.fg("toolTitle", theme.bold("intercom "));
+      return text += theme.fg(action === "ask" ? "warning" : action === "reply" ? "success" : "accent", action), target && (text += " " + theme.fg("muted", "\u2192") + " " + theme.fg("accent", target)), attachmentCount > 0 && (text += " " + theme.fg("dim", `(${attachmentCount} attachment${attachmentCount === 1 ? "" : "s"})`)), messagePreview && (text += `
+  ` + theme.fg("dim", messagePreview)), new Text(text, 0, 0);
+    },
+    renderResult(result, { isPartial }, theme, context) {
+      if (isPartial)
+        return new Text(theme.fg("warning", "Intercom working..."), 0, 0);
+      let details = result.details, failed = !!(context.isError || details?.error === !0 || details?.delivered === !1), text = failed ? theme.fg("error", "\u2717 ") : theme.fg("success", "\u2713 ");
+      return text += theme.fg(failed ? "error" : "text", firstTextContent(result)), details?.messageId && !context.expanded && (text += theme.fg("dim", ` (${details.messageId.slice(0, 8)})`)), details?.reason && context.expanded && (text += `
+` + theme.fg("dim", `Reason: ${details.reason}`)), new Text(text, 0, 0);
+    }
+  });
+  async function openIntercomOverlay(ctx) {
+    let overlayGeneration = runtimeGeneration, liveContext = getLiveContext(ctx, overlayGeneration);
+    if (!liveContext?.hasUI || liveContext.mode !== "tui")
+      return;
+    let overlayClient;
+    try {
+      overlayClient = await ensureConnected("overlay");
+    } catch (error) {
+      notifyIfLive(ctx, `Intercom unavailable: ${getErrorMessage(error)}`, "error", overlayGeneration);
+      return;
+    }
+    if (!getLiveContext(ctx, overlayGeneration))
+      return;
+    syncPresenceIdentity(ctx.sessionManager.getSessionId());
+    let currentSession, sessions, duplicates;
+    try {
+      let mySessionId = overlayClient.sessionId, allSessions = await overlayClient.listSessions();
+      if (!getLiveContext(ctx, overlayGeneration))
+        return;
+      let foundCurrentSession = allSessions.find((s) => s.id === mySessionId);
+      if (!foundCurrentSession) {
+        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) {
+      notifyIfLive(ctx, `Failed to list sessions: ${getErrorMessage(error)}`, "error", overlayGeneration);
+      return;
+    }
+    let selectedSession = await ctx.ui.custom((_tui, theme, keybindings, done) => new SessionListOverlay(theme, keybindings, currentSession, sessions, done), { overlay: !0, overlayOptions: { width: 88 } }).catch(() => {
+    });
+    if (!selectedSession || !getLiveContext(ctx, overlayGeneration))
+      return;
+    try {
+      overlayClient = await ensureConnected("overlay");
+    } catch (error) {
+      notifyIfLive(ctx, `Intercom unavailable: ${getErrorMessage(error)}`, "error", overlayGeneration);
+      return;
+    }
+    if (!getLiveContext(ctx, overlayGeneration))
+      return;
+    let targetLabel = formatSessionLabel(selectedSession, duplicates), result = await ctx.ui.custom((tui, theme, keybindings, done) => new ComposeOverlay(tui, theme, keybindings, selectedSession, targetLabel, overlayClient, done), { overlay: !0, overlayOptions: { width: 72 } }).catch(() => {
+    });
+    result?.sent && result.messageId && result.text && getLiveContext(ctx, overlayGeneration) && (pi.appendEntry("intercom_sent", {
+      to: selectedSession.name || selectedSession.id,
+      message: { text: result.text },
+      messageId: result.messageId,
+      timestamp: Date.now()
+    }), 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)
+  });
+}
+export {
+  piIntercomExtension as default
+};