@selesai/code 0.13.38 → 0.13.40

package/dist/extensions/pi-intercom/index.ts

@@ -25,7 +25,14 @@ import {
   type IntercomOutboxResultCode,
   type IntercomOutboxResultStatus,
   type IntercomOutboxResultV1,
+  INTERCOM_RPC_REQUEST_EVENT, INTERCOM_RPC_RESULT_EVENT, INTERCOM_RPC_EVENT,
+  intercomRpcTimeout, type IntercomRpcRequest, type IntercomRpcResult,
+  type IntercomRpcEventData as IntercomRpcEvent, type IntercomRpcDelivery,
+  RELEASE_READINESS_EVENT, answerReleaseReadiness,
+  STOP_ALL_BACKGROUND_EVENT, answerStopAllBackground,
 } from "./extension-api.ts";
+import { intercomReleaseBlockers, stopIntercom } from "./release-readiness.ts";
+import { isMessage } from "./broker/protocol.ts";
 import { ReplyTracker } from "./reply-tracker.ts";
 import { resolve as resolvePath } from "node:path";
 import { sameCwd } from "./cwd.ts";
@@ -664,10 +671,11 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
   let replyWaiter: {
     from: string;
     replyTo: string;
+    startedAt: number;
     resolve: (message: Message) => void;
     reject: (error: Error) => void;
   } | null = null;
-  function waitForReply(from: string, replyTo: string, signal?: AbortSignal, cancelOnAbort?: () => void, getDeliveryState: () => string = () => "unknown"): Promise<Message> {
+  function waitForReply(from: string, replyTo: string, signal?: AbortSignal, cancelOnAbort?: () => void, getDeliveryState: () => string = () => "unknown", timeoutMs = askTimeoutMs): Promise<Message> {
     if (replyWaiter) {
       return Promise.reject(new Error("Already waiting for a reply"));
     }
@@ -676,9 +684,9 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     }
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
-        const timeoutDescription = askTimeoutMs % 60000 === 0 ? `${askTimeoutMs / 60000} minutes` : `${askTimeoutMs}ms`;
+        const timeoutDescription = timeoutMs % 60000 === 0 ? `${timeoutMs / 60000} minutes` : `${timeoutMs}ms`;
         rejectReplyWaiter(new Error(`No reply from "${from}" for message ${replyTo} within ${timeoutDescription}. Last known delivery state: ${getDeliveryState()}. This waiter timeout is not cancellation; the delivered message may still be queued or actionable in the recipient session.`));
-      }, askTimeoutMs);
+      }, timeoutMs);
       const cleanup = () => {
         clearTimeout(timeout);
         signal?.removeEventListener("abort", onAbort);
@@ -695,6 +703,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       replyWaiter = {
         from,
         replyTo,
+        startedAt: Date.now(),
         resolve: (message) => {
           cleanup();
           resolve(message);
@@ -1162,6 +1171,126 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       }
     })();
   }
+  function emitRpcEvent(event: IntercomRpcEvent): void {
+    pi.events.emit(INTERCOM_RPC_EVENT, { sessionId: currentSessionId, event });
+  }
+  function emitRpcConnection(connected: boolean, reason?: string): void {
+    emitRpcEvent({ type: "intercom_connection", enabled: config.enabled, connected,
+      sessionId: currentIntercomSessionId, ...(reason ? { reason } : {}) });
+  }
+  const rpcRequests = new Map<string, { controller: AbortController; settle(result: IntercomRpcResult): void }>();
+  function endRpcRequests(): void {
+    for (const [requestId, request] of [...rpcRequests]) {
+      request.settle({ requestId, success: false, error: "Intercom session ended" });
+      request.controller.abort();
+    }
+  }
+  function handleRpcRequest(payload: unknown): void {
+    const request = payload as IntercomRpcRequest;
+    if (!request || typeof request.accept !== "function" || !request.command || !request.signal) return;
+    request.accept();
+    const { requestId, command } = request;
+    const controller = new AbortController();
+    const signal = AbortSignal.any([request.signal, controller.signal]);
+    const generation = runtimeGeneration;
+    const ctx = getLiveContext();
+    const settle = (result: IntercomRpcResult) => {
+      signal.removeEventListener("abort", onAbort);
+      if (!rpcRequests.delete(requestId)) return;
+      pi.events.emit(INTERCOM_RPC_RESULT_EVENT, result);
+    };
+    const onAbort = () => settle({ requestId, success: false, error: "Intercom session ended or request timed out" });
+    rpcRequests.set(requestId, { controller, settle });
+    signal.addEventListener("abort", onAbort, { once: true });
+    const checkLive = () => {
+      if (signal.aborted || !getLiveContext(ctx, generation)) throw new Error("Intercom session ended or request timed out");
+    };
+    void (async () => {
+      if (!["intercom_status", "intercom_list", "intercom_send", "intercom_ask", "intercom_reply", "intercom_pending"].includes(command.type)) throw new Error("Unknown Intercom RPC command");
+      if (signal.aborted) throw new Error("Intercom request ended");
+      const timeoutMs = intercomRpcTimeout(command);
+      if (command.type === "intercom_status") {
+        return { enabled: config.enabled, connected: Boolean(client?.isConnected()), sessionId: currentIntercomSessionId,
+          ...(currentSessionId ? { name: buildPresenceIdentity(pi, currentIntercomSessionId ?? currentSessionId).name } : {}) };
+      }
+      if (!config.enabled) throw new Error("Intercom disabled");
+      checkLive();
+      if (command.type === "intercom_pending") return { asks: replyTracker.listPending() };
+      if (command.type !== "intercom_list") {
+        if (typeof command.message !== "string" || !command.message.trim()) throw new Error("message must be a non-empty string");
+        if (command.to !== undefined && (typeof command.to !== "string" || !command.to.trim())) throw new Error("to must be a non-empty string");
+        if (command.type !== "intercom_reply" && !command.to) throw new Error("to is required");
+        if (command.replyTo !== undefined && (typeof command.replyTo !== "string" || !command.replyTo.trim())) throw new Error("replyTo must be a non-empty string");
+        if (!isMessage({ id: "validation", timestamp: Date.now(), replyTo: command.replyTo,
+          content: { text: command.message, attachments: command.attachments } })) throw new Error("Invalid message or attachments");
+      }
+      const activeClient = await ensureConnected("tool");
+      checkLive();
+      if (command.type === "intercom_list") {
+        const sessions = await activeClient.listSessions();
+        checkLive();
+        return { sessionId: activeClient.sessionId!, sessions };
+      }
+      let replyTo = command.replyTo;
+      let to: string;
+      if (command.type === "intercom_reply") {
+        const target = replyTracker.resolveReplyTarget({ to: command.to, replyTo });
+        to = target.from.id;
+        replyTo = target.message.id;
+      } else {
+        to = await resolveSessionTarget(activeClient, command.to) ?? command.to;
+        if (command.type === "intercom_ask" && !(await activeClient.listSessions()).some(peer => peer.id === to)) {
+          throw new Error("Recipient is not currently connected; blocking asks are not queued");
+        }
+      }
+      checkLive();
+      if (currentSessionTargetMatches(to, to, activeClient)) throw new Error("Cannot message the current session");
+      if (command.type === "intercom_send" && !replyTo) {
+        const mismatch = replyTracker.findActiveReplyTargetMismatch(to);
+        if (mismatch) throw new Error(`Use reply for active ask ${mismatch.message.id}; refusing misdirected send`);
+        replyTo = replyTracker.findUniquePendingAskFrom(to)?.message.id;
+      }
+      if (command.type === "intercom_send" && !command.replyTo && config.confirmSend) {
+        if (!ctx!.hasUI) throw new Error("confirmation_unavailable: confirmSend requires UI");
+        const confirmed = await ctx!.ui.confirm("Send message", `Send to "${command.to}":\n\n${command.message}${command.attachments?.length ? formatAttachments(command.attachments) : ""}`,
+          { signal, timeout: 30_000 });
+        checkLive();
+        if (!confirmed) throw new Error("Message cancelled by user");
+      }
+      const questionId = randomUUID();
+      let replyPromise: Promise<Message> | undefined;
+      let deliveryState = "created";
+      // Reserve the shared waiter before sending, so a fast reply cannot be lost.
+      if (command.type === "intercom_ask") {
+        if (replyWaiter) throw new Error("Already waiting for a reply");
+        replyPromise = waitForReply(to, questionId, signal, undefined,
+          () => latestDeliveryState(questionId, deliveryState), timeoutMs);
+        replyPromise.catch(() => undefined);
+      }
+      try {
+        checkLive();
+        const result = await activeClient.send(to, { text: command.message, attachments: command.attachments, replyTo,
+          ...(replyPromise ? { messageId: questionId, expectsReply: true } : {}) });
+        deliveryState = result.delivery;
+        checkLive();
+        const data: IntercomRpcDelivery = { messageId: result.id, delivered: result.delivered, to, replyTo,
+          delivery: result.delivery, retryable: result.retryable, outcomeKnown: result.outcomeKnown,
+          ...(result.code ? { code: result.code } : {}), ...(result.reason ? { reason: result.reason } : {}) };
+        if (!result.delivered) throw new Error(`Message ${result.id} not delivered: ${result.reason ?? result.delivery}`);
+        pi.appendEntry("intercom_sent", { to, message: { text: command.message, attachments: command.attachments, replyTo }, messageId: result.id, timestamp: Date.now() });
+        if (replyTo) dismissIncomingAsk(replyTo);
+        if (!replyPromise) return data;
+        const reply = await replyPromise;
+        checkLive();
+        pi.appendEntry("intercom_received", { from: to, message: reply.content, messageId: reply.id, timestamp: reply.timestamp });
+        return { ...data, reply };
+      } catch (error) {
+        // Only the owner of this waiter may reject it; concurrent asks fail without replacing it.
+        if (replyPromise && replyWaiter?.replyTo === questionId) rejectReplyWaiter(toError(error));
+        throw error;
+      }
+    })().then(data => settle({ requestId, success: true, data }), error => settle({ requestId, success: false, error: getErrorMessage(error) }));
+  }
   function shouldTriggerInboundMessage(entry: InboundMessageEntry, forceTrigger = false): boolean {
     if (forceTrigger) {
       return true;
@@ -1219,6 +1348,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       return;
     }
     const receivedMessage = { ...message, receiverReceivedAt };
+    emitRpcEvent({ type: "intercom_message", from, message: receivedMessage });
     emitMessageReceipt(receivedMessage.id, "receiver_received");
     if (replyWaiter) {
       const senderTarget = from.name || from.id;
@@ -1277,6 +1407,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       if (client !== nextClient) return;
       switch (message.type) {
         case "registered": {
+          emitRpcConnection(true);
           const supported = message.features?.includes(EXTENSION_BUS_FEATURE) ?? false;
           if (supported && localExtensions.size > 0) {
             nextClient.updateExtensionCapabilities(currentExtensionCapabilities());
@@ -1323,7 +1454,12 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
             ...(message.reason ? { reason: message.reason } : {}),
           });
           break;
+        case "delivered":
+        case "delivery_failed":
+          emitRpcEvent({ type: "intercom_delivery", result: message });
+          break;
         case "message_receipt":
+          emitRpcEvent({ type: "intercom_receipt", from: message.from, receipt: message.receipt });
           latestOutboundReceipts.set(message.receipt.messageId, {
             status: message.receipt.status,
             timestamp: message.receipt.timestamp,
@@ -1334,16 +1470,19 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
           handleMessageControl(message.control);
           break;
         case "session_joined":
+          emitRpcEvent({ type: "intercom_session_joined", session: message.session });
           for (const namespace of localExtensions.keys()) {
             emitLocalExtensionEvent(namespace, { type: "session_joined", session: message.session });
           }
           break;
         case "session_left":
+          emitRpcEvent({ type: "intercom_session_left", sessionId: message.sessionId });
           for (const namespace of localExtensions.keys()) {
             emitLocalExtensionEvent(namespace, { type: "session_left", sessionId: message.sessionId });
           }
           break;
         case "presence_update":
+          emitRpcEvent({ type: "intercom_presence", session: message.session });
           for (const namespace of localExtensions.keys()) {
             emitLocalExtensionEvent(namespace, { type: "presence_update", session: message.session });
           }
@@ -1361,6 +1500,8 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       if (client !== nextClient) {
         return;
       }
+      emitRpcConnection(false, error.message);
+      endRpcRequests();
       rejectReplyWaiter(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
       for (const [namespace, extension] of localExtensions) {
         extension.owner = undefined;
@@ -1433,6 +1574,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
         if (reason === "background" && getLiveContext(contextAtStart, generationAtStart)) {
           scheduleReconnect();
         }
+        if (getLiveContext(contextAtStart, generationAtStart)) emitRpcConnection(false, getErrorMessage(error));
         throw toError(error);
       } finally {
         if (reconnectPromise === nextReconnectPromise) {
@@ -1556,6 +1698,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
   }
   function startSessionRuntime(ctx: ExtensionContext): void {
     const previousClient = client;
+    endRpcRequests();
     failPendingOutboxRequests(runtimeGeneration, "session_ended", "Session replaced");
     shuttingDown = false;
     disposed = false;
@@ -1576,6 +1719,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     currentSessionId = ctx.sessionManager.getSessionId();
     currentIntercomSessionId = resolveConfiguredIntercomSessionId(currentSessionId, config);
     publishIntercomSessionId(currentIntercomSessionId);
+    emitRpcConnection(false, "Session started");
     currentModel = ctx.model?.id ?? "unknown";
     sessionStartedAt = Date.now();
     const initialPresenceIdentity = buildPresenceIdentity(pi, currentIntercomSessionId);
@@ -1695,9 +1839,40 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       acknowledge: true,
     });
   });
+  const unsubscribeRpcRequest = pi.events.on(INTERCOM_RPC_REQUEST_EVENT, handleRpcRequest);
+  // Release readiness (release:readiness:v1): answer only for the session this extension is bound to.
+  const unsubscribeReleaseReadiness = pi.events.on(RELEASE_READINESS_EVENT, (payload) => {
+    answerReleaseReadiness(payload, "intercom", currentSessionId, () => intercomReleaseBlockers({
+      pendingAsks: replyTracker.listPending(),
+      outboundAsk: replyWaiter,
+      pendingOutboxRequests: pendingOutboxRequests.size,
+    }));
+  });
+  // Kill switch (stop_all_background): cancel this session's blocking outbound ask; inbound asks cannot be cancelled by the receiver.
+  const unsubscribeStopAll = pi.events.on(STOP_ALL_BACKGROUND_EVENT, (payload) => {
+    answerStopAllBackground(payload, "intercom", currentSessionId, (request) => stopIntercom({
+      pendingAsks: replyTracker.listPending(),
+      outboundAsk: replyWaiter,
+      cancelOutboundAsk: (ask) => {
+        const activeClient = client;
+        // Broker first (drops the ask edge + pending-ask record), then free the blocked tool call.
+        activeClient?.cancelAsk(ask.replyTo);
+        rejectReplyWaiter(new Error("Cancelled: session background work was stopped"));
+        // Also ask the recipient to drop the ask. Best-effort: it may already be injected or processed.
+        if (!activeClient?.isConnected()) return undefined;
+        return activeClient.cancelMessage(ask.replyTo).then(
+          (result) => result.delivered ? "recipient asked to drop it" : "recipient could not be asked to drop it (it may already be handled)",
+          () => "recipient could not be asked to drop it (it may already be handled)",
+        );
+      },
+    }, request));
+  });
   const unsubscribeOutboxRequest = pi.events.on(INTERCOM_OUTBOX_REQUEST_EVENT, handleOutboxRequest);
   pi.on("session_start", (_event, ctx) => {
     if (!config.enabled) {
+      runtimeContext = ctx;
+      currentSessionId = ctx.sessionManager.getSessionId();
+      emitRpcConnection(false, "Intercom disabled");
       return;
     }
     startSessionRuntime(ctx);
@@ -1708,6 +1883,11 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     unsubscribeSubagentControlIntercom();
     unsubscribeSubagentResultIntercom();
     unsubscribeOutboxRequest();
+    unsubscribeRpcRequest();
+    unsubscribeReleaseReadiness();
+    unsubscribeStopAll();
+    endRpcRequests();
+    emitRpcConnection(false, "Session shutting down");
     shuttingDown = true;
     disposed = true;
     failPendingOutboxRequests(runtimeGeneration, "session_ended", "Session shutting down");
@@ -1976,7 +2156,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
           replyPromise = waitForReply(sendTo, questionId, signal, () => connectedClient.cancelAsk(questionId!), () => latestDeliveryState(questionId, deliveryState));
           replyPromise.catch(() => undefined);
           if (signal?.aborted) {
-            rejectReplyWaiter(new Error("Cancelled"));
+            if (replyWaiter?.replyTo === questionId) rejectReplyWaiter(new Error("Cancelled"));
             try {
               await replyPromise;
             } catch {
@@ -1998,7 +2178,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
           deliveryState = sendResult.delivered ? "socket_delivered" : "delivery_failed";
           if (!sendResult.delivered) {
             const errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
-            rejectReplyWaiter(new Error(`Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}`));
+            if (replyWaiter?.replyTo === questionId) rejectReplyWaiter(new Error(`Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}`));
             if (replyPromise) {
               try {
                 await replyPromise;
@@ -2044,7 +2224,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
               : {},
           };
         } catch (error) {
-          rejectReplyWaiter(toError(error));
+          if (questionId && replyWaiter?.replyTo === questionId) rejectReplyWaiter(toError(error));
           if (replyPromise) {
             try {
               await replyPromise;
@@ -2478,7 +2658,7 @@ Usage:
             deliveryState = sendResult.delivery;
             if (!sendResult.delivered) {
               const errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
-              rejectReplyWaiter(new Error(`Message to "${targetDisplay}" was not delivered: ${errorText}`));
+              if (replyWaiter?.replyTo === questionId) rejectReplyWaiter(new Error(`Message to "${targetDisplay}" was not delivered: ${errorText}`));
               if (replyPromise) {
                 try {
                   await replyPromise;
@@ -2513,7 +2693,7 @@ Usage:
               details: target.projectPane ? { openedProjectPane: true, paneId: target.projectPane.paneId, projectRoot: target.projectPane.projectRoot } : {},
             };
           } catch (error) {
-            rejectReplyWaiter(toError(error));
+            if (questionId && replyWaiter?.replyTo === questionId) rejectReplyWaiter(toError(error));
             if (replyPromise) {
               try {
                 await replyPromise;

package/dist/extensions/pi-intercom/intercom.integration.test.ts

@@ -236,6 +236,7 @@ function createExtensionHarness(sessionName: string | (() => string) = "child-wo
     entries,
     sentMessages,
     getActiveTools: () => pi.getActiveTools(),
+    clearLifecycleHandlers: () => lifecycleHandlers.clear(),
     async emitLifecycle(event: string, payload: unknown = {}, eventContext: unknown = ctx) {
       for (const handler of lifecycleHandlers.get(event) ?? []) {
         await handler(payload, eventContext);
@@ -4349,3 +4350,282 @@ test("failed delivery from an inferred reply preserves the pending ask", { concu
     await cleanup();
   }
 });
+
+test("structured RPC uses the shared runtime for commands, fast replies, receipts, presence and idle/busy incoming messages", { concurrency: false }, async () => {
+  const { RpcIntercomBridge } = await import("../../modes/rpc/intercom-bridge.ts");
+  const { INTERCOM_RPC_EVENT } = await import("./extension-api.ts");
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, orchestrator, cleanup } = await setupClients();
+  let idle = true;
+  const harness = createExtensionHarness("rpc-worker", { mode: "rpc", hasUI: true, isIdle: () => idle });
+  const events: Array<{ type: string; [key: string]: unknown }> = [];
+  const bridge = new RpcIntercomBridge(harness.pi.events, event => events.push(event as never), harness.ctx.sessionManager.getSessionId());
+  try {
+    await withIntercomConfig({ inboundTrigger: "always" }, async () => {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      const self = await waitForSessionByName(planner, "rpc-worker");
+      assert.equal((await bridge.request({ type: "intercom_status" })).success, true);
+      const unknown = await bridge.request({ type: "intercom_arbitrary", to: "planner", message: "must not send" } as never);
+      assert.ok(!unknown.success);
+      assert.match(unknown.error, /Unknown/);
+      const list = await bridge.request({ type: "intercom_list" });
+      assert.ok(list.success && "data" in list && "sessions" in list.data);
+      assert.equal(list.data.sessions.filter(peer => peer.name === "rpc-worker").length, 1);
+      assert.ok(events.some(event => event.type === "intercom_connection" && event.connected === true));
+      const sent = await bridge.request({ type: "intercom_send", to: planner.sessionId!, message: "Desktop update" });
+      assert.ok(sent.success && "data" in sent && "messageId" in sent.data);
+      planner.sendMessageReceipt({ messageId: sent.data.messageId, status: "receiver_received", timestamp: Date.now() });
+      assert.equal((await bridge.request({ type: "intercom_send", to: self.id, message: "self" })).success, false);
+      assert.equal((await bridge.request({ type: "intercom_ask", to: "missing-peer", message: "?", timeoutMs: 100 })).success, false);
+      assert.equal((await bridge.request({ type: "intercom_send", to: planner.sessionId!, message: "", attachments: [] })).success, false);
+      assert.equal((await bridge.request({ type: "intercom_send", to: planner.sessionId!, message: "bad", attachments: [{ type: "invalid", name: "x", content: "x" }] as never })).success, false);
+      const answer = (from: SessionInfo, message: Message) => {
+        if (message.expectsReply && message.content.text === "Fast question") void planner.send(from.id, { text: "Fast answer", replyTo: message.id });
+      };
+      planner.on("message", answer);
+      const asked = await bridge.request({ id: "ask-correlation", type: "intercom_ask", to: planner.sessionId!, message: "Fast question", timeoutMs: 2000 });
+      planner.off("message", answer);
+      assert.ok(asked.success && "data" in asked && "reply" in asked.data);
+      assert.equal(asked.id, "ask-correlation");
+      assert.equal(asked.data.reply.replyTo, asked.data.messageId);
+      assert.equal(asked.data.reply.content.text, "Fast answer");
+      const askId = "rpc-inbound-ask";
+      await planner.send(self.id, { messageId: askId, text: "Inbound", expectsReply: true });
+      await new Promise(resolve => setTimeout(resolve, 30));
+      assert.ok(harness.sentMessages.some(item => item.options?.triggerTurn));
+      const pending = await bridge.request({ type: "intercom_pending" });
+      assert.ok(pending.success && "data" in pending && "asks" in pending.data);
+      assert.equal(pending.data.asks[0]?.message.id, askId);
+      const replyReceived = waitForReply(planner, askId);
+      assert.equal((await bridge.request({ type: "intercom_reply", message: "Desktop answer", replyTo: askId })).success, true);
+      assert.equal((await replyReceived).message.content.text, "Desktop answer");
+      idle = false;
+      const messagesBefore = harness.sentMessages.length;
+      await orchestrator.send(self.id, { text: "Busy message" });
+      await new Promise(resolve => setTimeout(resolve, 30));
+      assert.equal(harness.sentMessages.length, messagesBefore + 1);
+      assert.equal(harness.sentMessages.at(-1)?.options?.deliverAs, "steer");
+      orchestrator.updatePresence({ status: "thinking" });
+      await new Promise(resolve => setTimeout(resolve, 30));
+      assert.ok(events.some(event => event.type === "intercom_message"));
+      assert.ok(events.some(event => event.type === "intercom_receipt"));
+      assert.ok(events.some(event => event.type === "intercom_delivery"));
+      assert.ok(events.some(event => event.type === "intercom_presence"));
+      await orchestrator.disconnect();
+      await new Promise(resolve => setTimeout(resolve, 30));
+      assert.ok(events.some(event => event.type === "intercom_session_left"));
+      // Duplicate broker messages must not create a second structured incoming event.
+      const incomingCount = events.filter(event => event.type === "intercom_message").length;
+      await planner.send(self.id, { messageId: askId, text: "Inbound", expectsReply: true });
+      await new Promise(resolve => setTimeout(resolve, 30));
+      assert.equal(events.filter(event => event.type === "intercom_message").length, incomingCount);
+      const timedOut = await bridge.request({ type: "intercom_ask", to: planner.sessionId!, message: "Unanswered", timeoutMs: 30 });
+      assert.ok(!timedOut.success);
+      assert.match(timedOut.error, /not cancellation/);
+      const blocked = bridge.request({ type: "intercom_ask", to: planner.sessionId!, message: "Pending at shutdown", timeoutMs: 1000 });
+      await new Promise(resolve => setTimeout(resolve, 30));
+      const competing = await bridge.request({ type: "intercom_ask", to: planner.sessionId!, message: "Competing ask", timeoutMs: 1000 });
+      assert.ok(!competing.success);
+      assert.match(competing.error, /Already waiting/);
+      await harness.emitLifecycle("session_shutdown");
+      assert.equal((await blocked).success, false);
+      assert.equal((await bridge.request({ type: "intercom_list" })).success, false);
+      assert.ok(events.some(event => event.type === "intercom_connection" && event.reason === "Session shutting down"));
+      // Reload installs exactly one listener on the same bus and stale results are ignored.
+      harness.clearLifecycleHandlers();
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      assert.equal((await bridge.request({ type: "intercom_list" })).success, true);
+      await harness.emitLifecycle("session_shutdown");
+      harness.pi.events.emit(INTERCOM_RPC_EVENT, { type: "intercom_connection", enabled: true, connected: false, sessionId: null });
+    });
+  } finally {
+    bridge.dispose();
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
+test("stop_all_background cancels the blocking outbound ask and reports inbound asks it cannot cancel", { concurrency: false }, async () => {
+  const { RpcIntercomBridge } = await import("../../modes/rpc/intercom-bridge.ts");
+  const { RpcReleaseBridge } = await import("../../modes/rpc/release-bridge.ts");
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, orchestrator, cleanup } = await setupClients();
+  const harness = createExtensionHarness("stop-all-worker", { mode: "rpc", hasUI: true, isIdle: () => true });
+  const sessionId = harness.ctx.sessionManager.getSessionId();
+  const intercomBridge = new RpcIntercomBridge(harness.pi.events, () => undefined, sessionId);
+  const releaseBridge = new RpcReleaseBridge(harness.pi.events, { version: 1, sessionId, epoch: "e1" });
+  const stopCommand = { type: "stop_all_background" as const, version: 1 as const };
+  try {
+    await withIntercomConfig({ inboundTrigger: "always" }, async () => {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      const self = await waitForSessionByName(planner, "stop-all-worker");
+      // Idle: nothing to stop, and the intercom contributor answered.
+      const idle = await releaseBridge.stopAll(stopCommand, () => [], () => []);
+      assert.ok(idle.success && idle.command === "stop_all_background");
+      assert.deepEqual(idle.data.stopped, []);
+
+      await planner.send(self.id, { messageId: "stop-all-inbound", text: "Please answer", expectsReply: true });
+      // A different peer than the inbound asker: the broker refuses mutual asks.
+      const blocked = intercomBridge.request({ type: "intercom_ask", to: orchestrator.sessionId!, message: "Pending ask", timeoutMs: 20_000 });
+      await new Promise(resolve => setTimeout(resolve, 100));
+      const reply = await releaseBridge.stopAll(stopCommand, () => [], () => []);
+      assert.ok(reply.success && reply.command === "stop_all_background");
+      const intercomItems = reply.data.stopped.filter(item => item.source === "intercom");
+      const outbound = intercomItems.find(item => item.kind === "outbound_ask");
+      assert.ok(outbound, JSON.stringify(reply.data.stopped));
+      assert.equal(outbound.ok, true);
+      assert.match(outbound.detail, /^Cancelled blocking ask to /);
+      assert.deepEqual(intercomItems.filter(item => item.kind === "inbound_ask").map(item => [item.id, item.ok, item.error]), [["stop-all-inbound", false, "cannot cancel inbound"]]);
+      // The blocked tool call returned with the cancellation instead of waiting for its 20s timeout.
+      const settled = await blocked;
+      assert.equal(settled.success, false);
+      assert.match((settled as { error: string }).error, /Cancelled: session background work was stopped/);
+      // Readiness afterwards has no outbound ask; the inbound ask is still ours to answer.
+      assert.deepEqual(reply.data.remaining.blockers.filter(b => b.source === "intercom").map(b => b.kind), ["inbound_ask"]);
+      // Idempotent: only the inbound ask is reported the second time.
+      const again = await releaseBridge.stopAll(stopCommand, () => [], () => []);
+      assert.ok(again.success && again.command === "stop_all_background");
+      assert.deepEqual(again.data.stopped.map(item => [item.kind, item.ok]), [["inbound_ask", false]]);
+    });
+  } finally {
+    intercomBridge.dispose();
+    releaseBridge.dispose();
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
+test("structured RPC fails closed for disabled runtime, missing backend, and rejected/unavailable confirmation", { concurrency: false }, async () => {
+  const { RpcIntercomBridge } = await import("../../modes/rpc/intercom-bridge.ts");
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, cleanup } = await setupClients();
+  try {
+    for (const options of [
+      { config: { enabled: false }, hasUI: true },
+      { config: { confirmSend: true }, hasUI: false },
+      { config: { confirmSend: true }, hasUI: true },
+    ]) {
+      const harness = createExtensionHarness("rpc-consent", { mode: "rpc", hasUI: options.hasUI, ui: { confirm: async () => false } });
+      const bridge = new RpcIntercomBridge(harness.pi.events, () => {}, harness.ctx.sessionManager.getSessionId());
+      await withIntercomConfig(options.config, async () => {
+        piIntercomExtension(harness.pi as never);
+        await harness.emitLifecycle("session_start");
+        const sent = await bridge.request({ type: "intercom_send", to: planner.sessionId!, message: "Must not send" });
+        assert.ok(!sent.success);
+        assert.match(sent.error, /disabled|confirmation_unavailable|cancelled/);
+        if (options.config.enabled === false) {
+          const status = await bridge.request({ type: "intercom_status" });
+          assert.ok(status.success && "data" in status && "enabled" in status.data);
+          assert.equal(status.data.enabled, false);
+        }
+        await harness.emitLifecycle("session_shutdown");
+        const missing = await bridge.request({ type: "intercom_list" });
+        assert.ok(!missing.success);
+        assert.match(missing.error, /unavailable/);
+      });
+      bridge.dispose();
+    }
+  } finally { await cleanup(); }
+});
+
+test("structured RPC aborts a pending confirmation on disconnect and can reconnect", { concurrency: false }, async () => {
+  const { RpcIntercomBridge } = await import("../../modes/rpc/intercom-bridge.ts");
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, cleanup } = await setupClients();
+  let confirmSignal: AbortSignal | undefined;
+  let signalAborted = false;
+  let enteredConfirm!: () => void;
+  const confirming = new Promise<void>(resolve => { enteredConfirm = resolve; });
+  const harness = createExtensionHarness("rpc-disconnect-confirm", { mode: "rpc", hasUI: true,
+    ui: { confirm: (_title: string, _message: string, options: { signal: AbortSignal }) => new Promise<boolean>(resolve => {
+      confirmSignal = options.signal;
+      options.signal.addEventListener("abort", () => { signalAborted = true; resolve(false); }, { once: true });
+      enteredConfirm();
+    }) } });
+  const bridge = new RpcIntercomBridge(harness.pi.events, () => {}, harness.ctx.sessionManager.getSessionId());
+  const originalList = IntercomClient.prototype.listSessions;
+  let extensionClient: InstanceType<typeof IntercomClient> | undefined;
+  try {
+    await withIntercomConfig({ confirmSend: true }, async () => {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      IntercomClient.prototype.listSessions = function (options) {
+        extensionClient = this;
+        return originalList.call(this, options);
+      };
+      assert.equal((await bridge.request({ type: "intercom_list" })).success, true);
+      IntercomClient.prototype.listSessions = originalList;
+      const sent = bridge.request({ type: "intercom_send", to: planner.sessionId!, message: "Do not send after disconnect" });
+      await confirming;
+      assert.ok(confirmSignal && !confirmSignal.aborted);
+      // Destroy the live transport without graceful unregister so the real disconnect handler runs.
+      (extensionClient as unknown as { socket: { destroy(): void } }).socket.destroy();
+      const response = await Promise.race([sent, new Promise<never>((_, reject) => setTimeout(() => reject(new Error("Disconnect did not settle confirmation promptly")), 1000).unref())]);
+      assert.ok(!response.success);
+      assert.match(response.error, /session ended/);
+      assert.equal(signalAborted, true);
+      assert.equal((await bridge.request({ type: "intercom_list" })).success, true);
+      assert.equal(harness.entries.filter(entry => entry.type === "intercom_sent").length, 0);
+    });
+  } finally {
+    IntercomClient.prototype.listSessions = originalList;
+    bridge.dispose();
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
+test("structured RPC ask survives a concurrent model ask target-resolution failure", { concurrency: false }, async () => {
+  const { RpcIntercomBridge } = await import("../../modes/rpc/intercom-bridge.ts");
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, cleanup } = await setupClients();
+  const harness = createExtensionHarness("rpc-model-waiter-owner", { mode: "rpc", hasUI: true });
+  const bridge = new RpcIntercomBridge(harness.pi.events, () => {}, harness.ctx.sessionManager.getSessionId());
+  const originalList = IntercomClient.prototype.listSessions;
+  let releaseResolution!: () => void;
+  let startedResolution!: () => void;
+  const resolving = new Promise<void>(resolve => { startedResolution = resolve; });
+  const resolutionGate = new Promise<void>(resolve => { releaseResolution = resolve; });
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    assert.equal((await bridge.request({ type: "intercom_list" })).success, true);
+    IntercomClient.prototype.listSessions = async function () {
+      startedResolution();
+      await resolutionGate;
+      throw new Error("Injected model target-resolution failure");
+    };
+    const tool = harness.tools.find(tool => tool.name === "intercom")!;
+    const modelAsk = tool.execute("model-resolution-race", { action: "ask", to: "planner", message: "Model question" }, new AbortController().signal, undefined, harness.ctx);
+    await resolving;
+    IntercomClient.prototype.listSessions = originalList;
+    const rpcQuestion = new Promise<{ from: SessionInfo; message: Message }>(resolve => {
+      const handler = (from: SessionInfo, message: Message) => {
+        if (message.content.text !== "RPC question owns waiter") return;
+        planner.off("message", handler);
+        resolve({ from, message });
+      };
+      planner.on("message", handler);
+    });
+    const rpcAsk = bridge.request({ type: "intercom_ask", to: planner.sessionId!, message: "RPC question owns waiter", timeoutMs: 3000 });
+    const question = await rpcQuestion;
+    releaseResolution();
+    const modelResult = await modelAsk;
+    assert.equal(modelResult.details?.error, true);
+    assert.match(modelResult.content[0].text, /target-resolution failure/);
+    await planner.send(question.from.id, { text: "RPC waiter was preserved", replyTo: question.message.id });
+    const rpcResult = await rpcAsk;
+    assert.ok(rpcResult.success && "data" in rpcResult && "reply" in rpcResult.data);
+    assert.equal(rpcResult.data.reply.content.text, "RPC waiter was preserved");
+    assert.equal(rpcResult.data.reply.replyTo, rpcResult.data.messageId);
+  } finally {
+    releaseResolution?.();
+    IntercomClient.prototype.listSessions = originalList;
+    bridge.dispose();
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});

package/dist/extensions/pi-intercom/package.json

@@ -18,7 +18,7 @@
     "skills/**/*"
   ],
   "scripts": {
-    "test": "tsx --test broker/client.test.ts broker/client-liveness.test.ts broker/extension.test.ts broker/framing.test.ts broker/paths.test.ts broker/runtime-claim.test.ts broker/spawn.test.ts config.test.ts cwd.test.ts format-context.test.ts project-agent.test.ts reply-tracker.test.ts intercom.integration.test.ts test/inline-message.test.ts test/overlay-width.test.ts"
+    "test": "tsx --test broker/client.test.ts broker/client-liveness.test.ts broker/extension.test.ts broker/framing.test.ts broker/mailbox-persistence.test.ts broker/paths.test.ts broker/runtime-claim.test.ts broker/spawn.test.ts config.test.ts cwd.test.ts format-context.test.ts project-agent.test.ts reply-tracker.test.ts intercom.integration.test.ts test/inline-message.test.ts test/overlay-width.test.ts"
   },
   "keywords": [
     "pi-package"