@selesai/code 0.13.39 → 0.14.0

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

@@ -1,18 +1,21 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { tmpdir } from "node:os";
 import { EventEmitter, once } from "node:events";
 import { spawn, type ChildProcess } from "node:child_process";
+import { pathToFileURL } from "node:url";
 import { ReplyTracker } from "./reply-tracker.ts";
 import type { BrokerMessage, Message, SessionInfo } from "./types.ts";
 import {
   INTERCOM_EXTENSION_REGISTER_EVENT,
   INTERCOM_OUTBOX_REQUEST_EVENT,
   INTERCOM_OUTBOX_RESULT_EVENT,
+  INTERCOM_SESSION_IDENTITY_EVENT,
   type IntercomExtensionChannel,
   type IntercomOutboxResultV1,
+  type IntercomSessionIdentityRequestV1,
 } from "./extension-api.ts";
 
 const repoDir = process.cwd();
@@ -27,17 +30,29 @@ const childEnvKeys = [
   "SELESAI_SUBAGENT_INTERCOM_SESSION_NAME",
   "SELESAI_SUBAGENT_SUPERVISOR_CHANNEL_DIR",
 ] as const;
-const sharedHomeDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-home-"));
+// Darwin Unix sockets have a short path limit; its default tmpdir is already ~65 characters.
+const sharedHomeDir = mkdtempSync(path.join(process.platform === "darwin" ? "/tmp" : tmpdir(), "pi-intercom-home-"));
+const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+process.env.SELESAI_CODING_AGENT_DIR = path.join(sharedHomeDir, ".selesai", "agent");
 const previousHome = process.env.HOME;
 const previousUserProfile = process.env.USERPROFILE;
+const previousHerdrPaneId = process.env.HERDR_PANE_ID;
 process.env.HOME = sharedHomeDir;
 process.env.USERPROFILE = sharedHomeDir;
+// Synthetic extension harnesses are not running in the parent test runner's
+// Herdr pane. Individual Herdr integration cases register an explicit pane id.
+delete process.env.HERDR_PANE_ID;
 const { IntercomClient } = await import("./broker/client.ts");
-const { getTsxCliPath } = await import("./broker/spawn.ts");
+const { getTsxLoaderPath } = await import("./broker/spawn.ts");
+const tsxImportArgs = ["--import", pathToFileURL(getTsxLoaderPath()).href];
 const { getAskTimeoutMs, getConfigPath } = await import("./config.ts");
 process.on("exit", () => {
+  if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+  else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
   process.env.HOME = previousHome;
   process.env.USERPROFILE = previousUserProfile;
+  if (previousHerdrPaneId === undefined) delete process.env.HERDR_PANE_ID;
+  else process.env.HERDR_PANE_ID = previousHerdrPaneId;
   rmSync(sharedHomeDir, { recursive: true, force: true });
 });
 
@@ -187,6 +202,7 @@ function createExtensionHarness(sessionName: string | (() => string) = "child-wo
   let activeToolNames = [...(options.activeTools ?? [])];
   const entries: Array<{ type: string; data: unknown }> = [];
   const sentMessages: Array<{ message: { customType?: string; content?: string; details?: unknown }; options?: { triggerTurn?: boolean; deliverAs?: string }; activeTools: string[] }> = [];
+  const userMessages: string[] = [];
   const pi = {
     getSessionName: () => typeof sessionName === "function" ? sessionName() : currentSessionName,
     setSessionName: (name: string) => { currentSessionName = name; },
@@ -216,6 +232,7 @@ function createExtensionHarness(sessionName: string | (() => string) = "child-wo
     sendMessage: (message: { customType?: string; content?: string; details?: unknown }, options?: { triggerTurn?: boolean; deliverAs?: string }) => {
       sentMessages.push({ message, options, activeTools: [...activeToolNames] });
     },
+    sendUserMessage: (content: string) => { userMessages.push(content); },
     appendEntry: (type: string, data: unknown) => entries.push({ type, data }),
   };
   const ctx = {
@@ -235,7 +252,9 @@ function createExtensionHarness(sessionName: string | (() => string) = "child-wo
     commands,
     entries,
     sentMessages,
+    userMessages,
     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);
@@ -291,7 +310,7 @@ test("opt-in TCP broker requires endpoint state for health and registration", {
   const { createMessageReader, writeMessage } = await import("./broker/framing.ts");
   const agentDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-tcp-agent-"));
   const broker = spawn(process.execPath, [
-    getTsxCliPath(),
+    ...tsxImportArgs,
     "-e",
     "Object.defineProperty(process, 'platform', { value: 'win32' }); import('./broker/broker.ts').catch((error) => { console.error(error); process.exit(1); });",
   ], {
@@ -405,7 +424,7 @@ test("opt-in TCP broker requires endpoint state for health and registration", {
 });
 
 async function setupClients() {
-  const broker = spawn(process.execPath, [getTsxCliPath(), path.join(repoDir, "broker", "broker.ts")], {
+  const broker = spawn(process.execPath, [...tsxImportArgs, path.join(repoDir, "broker", "broker.ts")], {
     cwd: repoDir,
     env: { ...process.env, HOME: sharedHomeDir, USERPROFILE: sharedHomeDir },
     stdio: ["ignore", "pipe", "pipe"],
@@ -439,13 +458,19 @@ async function setupClients() {
       cleanup: async () => {
         await planner.disconnect().catch(() => undefined);
         await orchestrator.disconnect().catch(() => undefined);
-        broker.kill("SIGTERM");
-        await once(broker, "exit").catch(() => undefined);
+        if (broker.exitCode === null && broker.signalCode === null) {
+          const exited = once(broker, "exit").catch(() => undefined);
+          broker.kill("SIGTERM");
+          await exited;
+        }
       },
     };
   } catch (error) {
-    broker.kill("SIGTERM");
-    await once(broker, "exit").catch(() => undefined);
+    if (broker.exitCode === null && broker.signalCode === null) {
+      const exited = once(broker, "exit").catch(() => undefined);
+      broker.kill("SIGTERM");
+      await exited;
+    }
     throw error;
   }
 }
@@ -497,6 +522,14 @@ function waitForOutboxResults(results: IntercomOutboxResultV1[], count: number,
   });
 }
 
+async function waitForCondition(condition: () => boolean, description: string): Promise<void> {
+  const deadline = Date.now() + 3000;
+  while (!condition() && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  assert.ok(condition(), `Timed out waiting for ${description}`);
+}
+
 async function waitForReplyMessage(messages: Message[], messageId: string, timeoutMs = 3000): Promise<Message> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -658,7 +691,7 @@ test("broker accepts caller supplied stable IDs across reconnect", { concurrency
 });
 
 test("broker scopes discovery, routing, mailbox, and presence", { concurrency: false }, async () => {
-  const broker = spawn(process.execPath, [getTsxCliPath(), path.join(repoDir, "broker", "broker.ts")], {
+  const broker = spawn(process.execPath, [...tsxImportArgs, path.join(repoDir, "broker", "broker.ts")], {
     cwd: repoDir,
     env: { ...process.env, HOME: sharedHomeDir, USERPROFILE: sharedHomeDir },
     stdio: ["ignore", "pipe", "pipe"],
@@ -731,8 +764,11 @@ test("broker scopes discovery, routing, mailbox, and presence", { concurrency: f
     await waitForReplyMessage(recovered, "alpha-scoped-mailbox");
   } finally {
     await Promise.all(clients.map((client) => client.disconnect().catch(() => undefined)));
-    if (broker.exitCode === null && broker.signalCode === null) broker.kill("SIGTERM");
-    await once(broker, "exit").catch(() => undefined);
+    if (broker.exitCode === null && broker.signalCode === null) if (broker.exitCode === null && broker.signalCode === null) {
+      const exited = once(broker, "exit").catch(() => undefined);
+      broker.kill("SIGTERM");
+      await exited;
+    }
   }
 });
 
@@ -908,6 +944,94 @@ test("broker rejects changed message content after a rebound exact-target failur
   }
 });
 
+test("all-non-Herdr rosters preserve upstream structured and text output without invoking Herdr", { concurrency: false }, async () => {
+  const fixtureDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-no-herdr-"));
+  const marker = path.join(fixtureDir, "invoked");
+  const fixtureBin = path.join(fixtureDir, "herdr-must-not-run");
+  writeFileSync(fixtureBin, `#!/bin/sh\ntouch ${JSON.stringify(marker)}\nexit 99\n`);
+  chmodSync(fixtureBin, 0o755);
+  const previousHerdrBin = process.env.HERDR_BIN;
+  process.env.HERDR_BIN = fixtureBin;
+  let setup: Awaited<ReturnType<typeof setupClients>>;
+  try {
+    setup = await setupClients();
+  } finally {
+    if (previousHerdrBin === undefined) delete process.env.HERDR_BIN;
+    else process.env.HERDR_BIN = previousHerdrBin;
+  }
+  const harness = createExtensionHarness("plain-worker", { sessionId: "plain-worker-session" });
+
+  try {
+    const structured = await setup.planner.listSessions();
+    assert.equal(structured.every((session) => !("herdrLocation" in session)), true);
+    assert.equal(existsSync(marker), false);
+
+    const { default: piIntercomExtension } = await import("./index.ts");
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    await waitForSessionByName(setup.planner, "plain-worker");
+    const intercomTool = harness.tools.find((tool) => tool.name === "intercom")!;
+    const result = await intercomTool.execute("plain-list", { action: "list" }, new AbortController().signal, undefined, harness.ctx);
+    const text = result.content.map((part) => part.text).join("\n");
+    assert.match(text, /Current session:/);
+    assert.match(text, /Other sessions:/);
+    assert.doesNotMatch(text, /Herdr|not under/);
+    assert.equal(existsSync(marker), false);
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await setup.cleanup();
+    rmSync(fixtureDir, { recursive: true, force: true });
+  }
+});
+
+test("broker resolves a registered Herdr pane through one live snapshot", { concurrency: false }, async () => {
+  const fixtureDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-herdr-"));
+  const fixtureBin = path.join(fixtureDir, "herdr-fixture");
+  writeFileSync(fixtureBin, `#!/usr/bin/env node
+console.log(JSON.stringify({ result: { snapshot: {
+  panes: [{ pane_id: "pane-current", tab_id: "tab-current", workspace_id: "workspace-current", agent_session: { kind: "path", source: "herdr:pi", value: "/sessions/worker.jsonl" } }],
+  tabs: [{ tab_id: "tab-current", workspace_id: "workspace-current", label: "Review" }],
+  workspaces: [{ workspace_id: "workspace-current", label: "Research" }]
+} } }));
+`);
+  chmodSync(fixtureBin, 0o755);
+  const previousHerdrBin = process.env.HERDR_BIN;
+  process.env.HERDR_BIN = fixtureBin;
+  let setup: Awaited<ReturnType<typeof setupClients>>;
+  try {
+    setup = await setupClients();
+  } finally {
+    if (previousHerdrBin === undefined) delete process.env.HERDR_BIN;
+    else process.env.HERDR_BIN = previousHerdrBin;
+  }
+  const worker = new IntercomClient();
+
+  try {
+    await worker.connect({
+      name: "herdr-worker",
+      cwd: repoDir,
+      model: "test-model",
+      pid: process.pid,
+      startedAt: Date.now(),
+      lastActivity: Date.now(),
+      herdrPaneId: "pane-at-launch",
+      herdrSessionPath: "/sessions/worker.jsonl",
+    });
+    const session = await waitForSessionByName(setup.planner, "herdr-worker");
+    assert.deepEqual(session.herdrLocation && { ...session.herdrLocation, refreshedAt: 0 }, {
+      status: "current",
+      workspace: { id: "workspace-current", label: "Research" },
+      tab: { id: "tab-current", label: "Review" },
+      paneId: "pane-current",
+      refreshedAt: 0,
+    });
+  } finally {
+    await worker.disconnect().catch(() => undefined);
+    await setup.cleanup();
+    rmSync(fixtureDir, { recursive: true, force: true });
+  }
+});
+
 test("broker propagates a session's tmux pane id into the roster", { concurrency: false }, async () => {
   const { planner, cleanup } = await setupClients();
   const worker = new IntercomClient();
@@ -1314,6 +1438,84 @@ test("extension can pin a restart-stable intercom session id", { concurrency: fa
   }
 });
 
+test("a session identity claim sets the intercom id and keeps the readable session name", { concurrency: false }, async () => {
+  const { planner, cleanup } = await setupClients();
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const previousStableId = process.env.PI_INTERCOM_STABLE_ID;
+  const previousPublishedId = process.env.PI_INTERCOM_SESSION_ID;
+  process.env.PI_INTERCOM_STABLE_ID = "process-wide-id";
+  const harness = createExtensionHarness("worker: fix auth refresh", { sessionId: "transient-pi-session" });
+  harness.pi.events.on(INTERCOM_SESSION_IDENTITY_EVENT, (request) => {
+    (request as IntercomSessionIdentityRequestV1).claim(" subagent-worker-run1-1 ");
+  });
+
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    const session = await waitForSessionId(planner, "subagent-worker-run1-1");
+    assert.equal(session.name, "worker: fix auth refresh");
+    await harness.emitLifecycle("session_shutdown");
+  } finally {
+    if (previousStableId === undefined) delete process.env.PI_INTERCOM_STABLE_ID;
+    else process.env.PI_INTERCOM_STABLE_ID = previousStableId;
+    if (previousPublishedId === undefined) delete process.env.PI_INTERCOM_SESSION_ID;
+    else process.env.PI_INTERCOM_SESSION_ID = previousPublishedId;
+    await cleanup();
+  }
+});
+
+test("intercom handover summarizes the session and delivers it to the target", { concurrency: false }, async () => {
+  const { orchestrator, cleanup } = await setupClients();
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const harness = createExtensionHarness("handover-sender");
+  const modelRequests: Array<{ systemPrompt?: string; messages: Array<{ content: Array<{ text: string }> }> }> = [];
+  const ctx = {
+    ...harness.ctx,
+    sessionManager: {
+      ...harness.ctx.sessionManager,
+      getSessionFile: () => "/sessions/handover-sender.jsonl",
+      getBranch: () => [{ type: "message", id: "a", parentId: null, timestamp: "2026-09-30T00:00:00.000Z", message: { role: "user", content: "fix the adapter", timestamp: 0 } }],
+    },
+    modelRegistry: {
+      complete: async (_model: unknown, context: (typeof modelRequests)[number]) => {
+        modelRequests.push(context);
+        return { stopReason: "stop", content: [{ type: "text", text: "## Next task\nPort the fix" }] };
+      },
+    },
+  };
+
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    const intercomTool = harness.tools.find((tool) => tool.name === "intercom")!;
+
+    const rejected = await intercomTool.execute("handover-reply", { action: "handover", to: "orchestrator", replyTo: "m1" }, new AbortController().signal, undefined, ctx);
+    assert.equal(rejected.details?.error, true);
+    const withAttachment = await intercomTool.execute("handover-attach", { action: "handover", to: "orchestrator", attachments: [{ type: "file", name: "a", content: "b" }] }, new AbortController().signal, undefined, ctx);
+    assert.equal(withAttachment.details?.error, true);
+    assert.equal(modelRequests.length, 0);
+
+    const sender = await waitForSessionByName(orchestrator, "handover-sender");
+    assert.equal((await orchestrator.send(sender.id, { messageId: "handover-pending-ask", text: "What's next?", expectsReply: true })).delivered, true);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    const received = once(orchestrator, "message") as Promise<[SessionInfo, Message]>;
+    const result = await intercomTool.execute("handover", { action: "handover", to: "orchestrator", message: "continue in pi-mcp-adapter" }, new AbortController().signal, undefined, ctx);
+    assert.notEqual(result.details?.error, true);
+    assert.equal(result.details?.delivery, "socket_delivered");
+    assert.equal(result.details?.replyTo, undefined);
+
+    const [, message] = await received;
+    assert.match(message.content.text, /^# Handover from handover-sender\n/);
+    assert.equal(message.replyTo, undefined);
+    assert.match(message.content.text, /Sender session file: \/sessions\/handover-sender\.jsonl/);
+    assert.ok(message.content.text.endsWith("## Next task\nPort the fix"));
+    assert.match(modelRequests[0]!.messages[0]!.content[0]!.text, /fix the adapter[\s\S]*continue in pi-mcp-adapter/);
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
 test("intercom-id inserts a stable handoff snippet into the editor", { concurrency: false }, async () => {
   const { cleanup } = await setupClients();
   const { default: piIntercomExtension } = await import("./index.ts");
@@ -1765,6 +1967,36 @@ test("intercom tool renders compact call and result rows", async () => {
   }, { isPartial: false, expanded: true }, renderTheme, { isError: false, expanded: true }));
   assert.match(errorText, /✗ Missing 'to' or 'message' parameter/);
   assert.match(errorText, /Reason: Missing target/);
+
+  const roster = {
+    content: [{ type: "text", text: "**Current session:**\n• me\n\n**Other sessions (cwd: /repo):**\n• peer-a\n• peer-b" }],
+    details: { roster: { peers: 2, total: 3, cwd: "/repo" } },
+  };
+  const collapsedRoster = renderToText(intercomTool.renderResult(roster, { isPartial: false, expanded: false }, renderTheme, { isError: false, expanded: false }));
+  assert.equal(collapsedRoster, "✓ 2 other sessions in /repo (3 connected)");
+  const expandedRoster = renderToText(intercomTool.renderResult(roster, { isPartial: false, expanded: true }, renderTheme, { isError: false, expanded: true }));
+  assert.match(expandedRoster, /peer-a\n• peer-b/);
+});
+
+test("outgoing tool calls preserve full messages when expanded", async () => {
+  const { default: piIntercomExtension } = await import("./index.ts");
+  await withChildOrchestratorEnv({
+    orchestratorTarget: "orchestrator", runId: "expanded-call-test", agent: "worker", index: "0",
+  }, () => {
+    const harness = createExtensionHarness();
+    piIntercomExtension(harness.pi as never);
+    const message = `  ${"a".repeat(100)}\n\n    中文🧪 tail`;
+    for (const [name, args, title] of [
+      ["intercom", { action: "send", to: "planner", message }, "intercom send → planner"],
+      ["contact_supervisor", { reason: "progress_update", message }, "contact_supervisor progress_update"],
+    ] as const) {
+      const tool = harness.tools.find((candidate) => candidate.name === name)!;
+      assert.ok(tool.renderCall);
+      assert.equal(renderToText(tool.renderCall(args, renderTheme, { expanded: true })), `${title}\n  ${message}`);
+      assert.equal(renderToText(tool.renderCall(args, renderTheme, { expanded: false })), `${title}\n  ${"a".repeat(95)}…`);
+      assert.equal(args.message, message);
+    }
+  });
 });
 
 test("intercom tool result hook marks failed details as errors", async () => {
@@ -1806,7 +2038,7 @@ test("obsolete toolVisibility config never hides or reveals the intercom tool",
         custom: async () => {
           overlayStep += 1;
           return overlayStep === 1
-            ? selectedSession
+            ? { session: selectedSession, action: "message" }
             : { sent: true, messageId: "overlay-message", text: "Hello from the overlay" };
         },
       },
@@ -1991,6 +2223,7 @@ test("busy interactive sessions steer top-level asks without aborting", { concur
     await harness.emitLifecycle("session_start");
 
     const target = await waitForSessionByName(planner, "interactive-worker");
+    await harness.emitLifecycle("agent_start");
 
     const delivered = await planner.send(target.id, {
       messageId: 'interactive-busy-"ask',
@@ -2021,7 +2254,7 @@ test("busy interactive sessions steer top-level asks without aborting", { concur
   }
 });
 
-test("idle interactive sessions trigger a new turn immediately", { concurrency: false }, async () => {
+test("idle interactive sessions wake through a user prompt instead of triggerTurn", { concurrency: false }, async () => {
 	const { default: piIntercomExtension } = await import("./index.ts");
 	const { planner, cleanup } = await setupClients();
 	const harness = createExtensionHarness("idle-trigger-worker", {
@@ -2038,8 +2271,14 @@ test("idle interactive sessions trigger a new turn immediately", { concurrency:
 		await new Promise((resolve) => setTimeout(resolve, 20));
 
 		assert.equal(harness.sentMessages.length, 1);
-		assert.equal(harness.sentMessages[0]?.options?.triggerTurn, true);
-		assert.equal(harness.sentMessages[0]?.options?.deliverAs, undefined);
+		assert.equal(harness.sentMessages[0]?.options, undefined, "triggerTurn would bypass before_agent_start");
+		assert.deepEqual(harness.userMessages, ["New intercom message above."]);
+
+		await harness.emitLifecycle("agent_start");
+		await harness.emitLifecycle("agent_end");
+		assert.equal((await planner.send(worker.id, { messageId: "idle-trigger-2", text: "And this" })).delivered, true);
+		await waitForCondition(() => harness.sentMessages.length === 2, "second injected message");
+		assert.equal(harness.userMessages.length, 2, "a started run re-arms the wake");
 	} finally {
 		await harness.emitLifecycle("session_shutdown");
 		await cleanup();
@@ -2109,6 +2348,7 @@ test("busy interactive sessions steer same-sender messages in sequence order", {
     piIntercomExtension(harness.pi as never);
     await harness.emitLifecycle("session_start");
     const worker = await waitForSessionByName(planner, "sequence-worker");
+    await harness.emitLifecycle("agent_start");
     const receipts = new Map<string, string[]>();
     const unsubscribeReceipts = planner.onMessageReceipt((_from, receipt) => {
       const statuses = receipts.get(receipt.messageId) ?? [];
@@ -2142,6 +2382,208 @@ test("busy interactive sessions steer same-sender messages in sequence order", {
   }
 });
 
+for (const outcome of ["success", "failure", "abort", "cancel"]) {
+  test(`busy without an agent run holds inbound messages through compaction ${outcome}`, { concurrency: false }, async () => {
+    const { default: piIntercomExtension } = await import("./index.ts");
+    const { planner, cleanup } = await setupClients();
+    let idle = false;
+    const harness = createExtensionHarness(`compact-${outcome}`, { hasUI: true, isIdle: () => idle });
+    try {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      const target = await waitForSessionByName(planner, `compact-${outcome}`);
+      const receipts = new Map<string, string[]>();
+      const unsubscribe = planner.onMessageReceipt((_from, receipt) => {
+        const statuses = receipts.get(receipt.messageId) ?? [];
+        statuses.push(receipt.status);
+        receipts.set(receipt.messageId, statuses);
+      });
+      assert.equal((await planner.send(target.id, { messageId: `${outcome}-1`, text: "First held" })).delivered, true);
+      assert.equal((await planner.send(target.id, { messageId: `${outcome}-2`, text: "Second held" })).delivered, true);
+      await waitForCondition(() => receipts.get(`${outcome}-1`)?.includes("queued") === true, "first queued receipt");
+      await waitForCondition(() => receipts.get(`${outcome}-2`)?.includes("queued") === true, "second queued receipt");
+      assert.equal(harness.sentMessages.length, 0);
+      assert.deepEqual(receipts.get(`${outcome}-1`), ["receiver_received", "acknowledged", "queued"]);
+      assert.deepEqual(receipts.get(`${outcome}-2`), ["receiver_received", "acknowledged", "queued"]);
+      // No lifecycle event is needed: Pi becomes idle after success, failure, abort or cancellation.
+      idle = true;
+      await waitForCondition(() => harness.sentMessages.length === 2, "two injected messages");
+      assert.equal(harness.sentMessages.length, 2);
+      assert.match(harness.sentMessages[0]?.message.content ?? "", /First held/);
+      assert.match(harness.sentMessages[1]?.message.content ?? "", /Second held/);
+      assert.deepEqual(harness.sentMessages.map(({ options }) => options), [undefined, undefined]);
+      assert.deepEqual(harness.userMessages, ["New intercom message above."], "one wake covers both messages");
+      await waitForCondition(() => receipts.get(`${outcome}-1`)?.includes("injected") === true, "first injected receipt");
+      await waitForCondition(() => receipts.get(`${outcome}-2`)?.includes("injected") === true, "second injected receipt");
+      assert.deepEqual(receipts.get(`${outcome}-1`), ["receiver_received", "acknowledged", "queued", "injected"]);
+      assert.deepEqual(receipts.get(`${outcome}-2`), ["receiver_received", "acknowledged", "queued", "injected"]);
+      unsubscribe();
+    } finally {
+      await harness.emitLifecycle("session_shutdown");
+      await cleanup();
+    }
+  });
+}
+
+test("shutdown discards inbound messages held during compaction", { concurrency: false }, async () => {
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, cleanup } = await setupClients();
+  let idle = false;
+  const harness = createExtensionHarness("compact-shutdown", { hasUI: true, isIdle: () => idle });
+  const receipts: string[] = [];
+  const unsubscribe = planner.onMessageReceipt((_from, receipt) => {
+    if (receipt.messageId === "compact-shutdown-message") receipts.push(receipt.status);
+  });
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    const target = await waitForSessionByName(planner, "compact-shutdown");
+    assert.equal((await planner.send(target.id, { messageId: "compact-shutdown-message", text: "Held" })).delivered, true);
+    await waitForCondition(() => receipts.includes("queued"), "compaction queued receipt");
+    assert.equal(harness.sentMessages.length, 0);
+    await harness.emitLifecycle("session_shutdown");
+    await waitForCondition(() => receipts.includes("expired"), "shutdown expired receipt");
+    idle = true;
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    assert.equal(harness.sentMessages.length, 0);
+    assert.deepEqual(receipts, ["receiver_received", "acknowledged", "queued", "expired"]);
+  } finally {
+    unsubscribe();
+    await cleanup();
+  }
+});
+
+test("cancelling a compaction-held message drops it before injection", { concurrency: false }, async () => {
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, cleanup } = await setupClients();
+  let idle = false;
+  const harness = createExtensionHarness("compact-cancel", { hasUI: true, isIdle: () => idle });
+  const receipts: string[] = [];
+  const unsubscribe = planner.onMessageReceipt((_from, receipt) => {
+    if (receipt.messageId === "compact-cancel-message") receipts.push(receipt.status);
+  });
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    const target = await waitForSessionByName(planner, "compact-cancel");
+    assert.equal((await planner.send(target.id, { messageId: "compact-cancel-message", text: "Held" })).delivered, true);
+    await waitForCondition(() => receipts.includes("queued"), "compaction queued receipt");
+    assert.equal((await planner.cancelMessage("compact-cancel-message")).delivered, true);
+    await waitForCondition(() => receipts.includes("cancelled"), "compaction cancelled receipt");
+    idle = true;
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    assert.equal(harness.sentMessages.length, 0);
+    assert.deepEqual(receipts, ["receiver_received", "acknowledged", "queued", "cancelled"]);
+  } finally {
+    unsubscribe();
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
+test("runtime replacement discards held inbound messages", { concurrency: false }, async () => {
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, cleanup } = await setupClients();
+  let idle = false;
+  const harness = createExtensionHarness("compact-replacement", { hasUI: true, isIdle: () => idle });
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    const target = await waitForSessionByName(planner, "compact-replacement");
+    assert.equal((await planner.send(target.id, { messageId: "compact-replacement-message", text: "Old runtime" })).delivered, true);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.equal(harness.sentMessages.length, 0);
+    await harness.emitLifecycle("session_start");
+    idle = true;
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    assert.equal(harness.sentMessages.length, 0);
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
+test("held inbound messages steer when an agent run is busy after compaction", { concurrency: false }, async () => {
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { planner, cleanup } = await setupClients();
+  const harness = createExtensionHarness("compact-busy", { hasUI: true, isIdle: () => false });
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    const target = await waitForSessionByName(planner, "compact-busy");
+    assert.equal((await planner.send(target.id, { messageId: "compact-busy-message", text: "Steer later" })).delivered, true);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.equal(harness.sentMessages.length, 0);
+    await harness.emitLifecycle("agent_start");
+    assert.equal(harness.sentMessages.length, 1);
+    assert.equal(harness.sentMessages[0]?.options?.deliverAs, "steer");
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
+test("human-first leaves non-UI sessions on the busy auto-reply path after compaction", { concurrency: false }, async () => {
+  await withIntercomConfig({ busyDelivery: "human-first" }, async () => {
+    const { default: piIntercomExtension } = await import("./index.ts");
+    const { planner, cleanup } = await setupClients();
+    const harness = createExtensionHarness("human-first-pipe", { hasUI: false, isIdle: () => false });
+    try {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      const target = await waitForSessionByName(planner, "human-first-pipe");
+      const askId = "human-first-pipe-ask";
+      const replyPromise = waitForReply(planner, askId, 1000);
+      assert.equal((await planner.send(target.id, { messageId: askId, text: "Still there?", expectsReply: true })).delivered, true);
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      await harness.emitLifecycle("agent_start");
+      const reply = await replyPromise;
+      assert.match(reply.message.content.text, /non-interactive|cannot respond/i);
+      assert.equal(harness.sentMessages.length, 0);
+    } finally {
+      await harness.emitLifecycle("session_shutdown");
+      await cleanup();
+    }
+  });
+});
+
+test("human-first releases the next held peer only after the woken run starts", { concurrency: false }, async () => {
+  await withIntercomConfig({ busyDelivery: "human-first" }, async () => {
+    const { default: piIntercomExtension } = await import("./index.ts");
+    const { planner, cleanup } = await setupClients();
+    let idle = false;
+    const harness = createExtensionHarness("human-first-wake", { hasUI: true, isIdle: () => idle });
+    try {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      const target = await waitForSessionByName(planner, "human-first-wake");
+      await harness.emitLifecycle("agent_start");
+      const queued = new Set<string>();
+      const unsubscribe = planner.onMessageReceipt((_from, receipt) => {
+        if (receipt.status === "queued") queued.add(receipt.messageId);
+      });
+      assert.equal((await planner.send(target.id, { messageId: "peer-a", text: "Peer A" })).delivered, true);
+      assert.equal((await planner.send(target.id, { messageId: "peer-b", text: "Peer B" })).delivered, true);
+      await waitForCondition(() => queued.has("peer-a") && queued.has("peer-b"), "both peers held");
+      unsubscribe();
+
+      // The run ends; the wake prompt's preflight keeps Pi idle across several flush ticks.
+      idle = true;
+      await waitForCondition(() => harness.sentMessages.length === 1, "peer A injected");
+      await new Promise((resolve) => setTimeout(resolve, 350));
+      assert.equal(harness.sentMessages.length, 1, "peer B must wait for a later turn");
+      assert.deepEqual(harness.userMessages, ["New intercom message above."]);
+
+      await harness.emitLifecycle("agent_start");
+      await waitForCondition(() => harness.sentMessages.length === 2, "peer B injected");
+      assert.match(harness.sentMessages[1]?.message.content ?? "", /Peer B/);
+    } finally {
+      await harness.emitLifecycle("session_shutdown");
+      await cleanup();
+    }
+  });
+});
+
 test("explicit cancel acknowledges that a steered inbound message may already be processed", { concurrency: false }, async () => {
   const { default: piIntercomExtension } = await import("./index.ts");
   const { planner, cleanup } = await setupClients();
@@ -2155,6 +2597,7 @@ test("explicit cancel acknowledges that a steered inbound message may already be
     piIntercomExtension(harness.pi as never);
     await harness.emitLifecycle("session_start");
     const worker = await waitForSessionByName(planner, "cancel-worker");
+    await harness.emitLifecycle("agent_start");
     const receipts: string[] = [];
     const unsubscribeReceipts = planner.onMessageReceipt((_from, receipt) => {
       if (receipt.messageId === "cancel-steered") receipts.push(receipt.status);
@@ -2197,6 +2640,7 @@ test("intercom cancel action requests cancellation for a sent message", { concur
     await senderHarness.emitLifecycle("session_start");
     await receiverHarness.emitLifecycle("session_start");
     await waitForSessionByName(planner, "cancel-tool-worker");
+    await receiverHarness.emitLifecycle("agent_start");
     const intercomTool = senderHarness.tools.find((tool) => tool.name === "intercom")!;
 
     const sendResult = await intercomTool.execute("send-before-cancel", { action: "send", to: "cancel-tool-worker", message: "Cancel this through the tool" }, new AbortController().signal, undefined, senderHarness.ctx);
@@ -2235,6 +2679,7 @@ test("same-sender supersede reports an already-steered inbound message", { concu
     piIntercomExtension(harness.pi as never);
     await harness.emitLifecycle("session_start");
     const worker = await waitForSessionByName(planner, "supersede-worker");
+    await harness.emitLifecycle("agent_start");
     const receipts = new Map<string, string[]>();
     const unsubscribeReceipts = planner.onMessageReceipt((_from, receipt) => {
       const statuses = receipts.get(receipt.messageId) ?? [];
@@ -2290,6 +2735,8 @@ test("supersede is scoped to the same sender and receiver", { concurrency: false
     await secondHarness.emitLifecycle("session_start");
     const first = await waitForSessionByName(planner, "supersede-first");
     const second = await waitForSessionByName(planner, "supersede-second");
+    await firstHarness.emitLifecycle("agent_start");
+    await secondHarness.emitLifecycle("agent_start");
 
     assert.equal((await planner.send(first.id, { messageId: "wrong-target-old", text: "Old target" })).delivered, true);
     const wrongReceiver = await planner.send(second.id, { messageId: "wrong-target-new", text: "Wrong receiver", supersedes: "wrong-target-old" });
@@ -2319,6 +2766,7 @@ test("replied steered asks are not injected again after the current turn", { con
     piIntercomExtension(harness.pi as never);
     await harness.emitLifecycle("session_start");
     const worker = await waitForSessionByName(planner, "reply-while-busy-worker");
+    await harness.emitLifecycle("agent_start");
 
     const askId = "reply-while-busy-ask";
     const replyReceived = waitForReply(planner, askId);
@@ -2402,7 +2850,7 @@ test("stale overlay work stops after same-session restart", { concurrency: false
     const plannerSession = await waitForSessionByName(planner, "planner");
     await harness.emitLifecycle("session_shutdown");
     await harness.emitLifecycle("session_start");
-    resolveFirstCustom(plannerSession);
+    resolveFirstCustom({ session: plannerSession, action: "message" });
     await overlayPromise;
 
     assert.equal(customCalls, 1);
@@ -2425,6 +2873,7 @@ test("steered inbound messages are not reinjected after shutdown", { concurrency
     piIntercomExtension(harness.pi as never);
     await harness.emitLifecycle("session_start");
     const target = await waitForSessionByName(planner, "disposed-worker");
+    await harness.emitLifecycle("agent_start");
     const receipts: string[] = [];
     const unsubscribeReceipts = planner.onMessageReceipt((_from, receipt) => {
       if (receipt.messageId === "disposed-ask") receipts.push(receipt.status);
@@ -2468,6 +2917,7 @@ test("busy non-interactive sessions auto-reply to top-level asks without abortin
     await harness.emitLifecycle("session_start");
 
     const target = await waitForSessionByName(planner, "pipe-worker");
+    await harness.emitLifecycle("agent_start");
 
     const askId = "pipe-mode-ask";
     const replyPromise = waitForReply(planner, askId, 1000);
@@ -3809,12 +4259,13 @@ test("intercom reply queues mail for a disconnected named sender", { concurrency
   }
 });
 
-test("subagent control intercom events wake the current orchestrator session", async () => {
+test("subagent control intercom events reach the current orchestrator session", async () => {
   const { default: piIntercomExtension } = await import("./index.ts");
   const events = new EventEmitter();
   const sentMessages: Array<{ message: { customType?: string; content?: string }; options?: { triggerTurn?: boolean } }> = [];
   const pi = {
     getSessionName: () => "orchestrator",
+    getActiveTools: () => ["intercom"],
     events: {
       on: (channel: string, handler: (payload: unknown) => void) => {
         events.on(channel, handler);
@@ -3844,10 +4295,9 @@ test("subagent control intercom events wake the current orchestrator session", a
   assert.equal(sentMessages[0]?.message.customType, "intercom_message");
   assert.match(sentMessages[0]?.message.content ?? "", /From subagent-control/);
   assert.match(sentMessages[0]?.message.content ?? "", /worker needs attention in run 78f659a3/);
-  assert.equal(sentMessages[0]?.options?.triggerTurn, true);
 });
 
-test("subagent result intercom events wake the current orchestrator session", async () => {
+test("subagent result intercom events reach the current orchestrator session", async () => {
   const { default: piIntercomExtension } = await import("./index.ts");
   const events = new EventEmitter();
   const sentMessages: Array<{ message: { customType?: string; content?: string }; options?: { triggerTurn?: boolean } }> = [];
@@ -3855,6 +4305,7 @@ test("subagent result intercom events wake the current orchestrator session", as
   events.on("subagent:result-intercom-delivery", (payload) => deliveryAcks.push(payload));
   const pi = {
     getSessionName: () => "orchestrator",
+    getActiveTools: () => ["intercom"],
     events: {
       on: (channel: string, handler: (payload: unknown) => void) => {
         events.on(channel, handler);
@@ -3885,10 +4336,64 @@ test("subagent result intercom events wake the current orchestrator session", as
   assert.equal(sentMessages[0]?.message.customType, "intercom_message");
   assert.match(sentMessages[0]?.message.content ?? "", /From subagent-result/);
   assert.match(sentMessages[0]?.message.content ?? "", /Status: completed/);
-  assert.equal(sentMessages[0]?.options?.triggerTurn, true);
   assert.deepEqual(deliveryAcks, [{ requestId: "result-1", delivered: true }]);
 });
 
+test("subagent relay events wake an idle orchestrator and steer a busy one", { concurrency: false }, async () => {
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { cleanup } = await setupClients();
+  let idle = true;
+  const harness = createExtensionHarness("relay-orchestrator", { hasUI: true, isIdle: () => idle });
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+
+    harness.pi.events.emit("subagent:result-intercom", { to: "relay-orchestrator", requestId: "idle-result", message: "subagent result\n\nStatus: completed" });
+    await waitForCondition(() => harness.sentMessages.length === 1, "idle relay message");
+    assert.equal(harness.sentMessages[0]?.options, undefined);
+    assert.deepEqual(harness.userMessages, ["New intercom message above."]);
+
+    await harness.emitLifecycle("agent_start");
+    idle = false;
+    harness.pi.events.emit("subagent:control-intercom", { to: "relay-orchestrator", message: "subagent needs attention" });
+    await waitForCondition(() => harness.sentMessages.length === 2, "busy relay message");
+    assert.equal(harness.sentMessages[1]?.options, undefined, "Pi steers untriggered messages while streaming");
+    assert.equal(harness.userMessages.length, 1, "a busy session must not get a wake prompt");
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
+test("a wake prompt that never starts a run stops blocking later wakes after its window", { concurrency: false }, async (t) => {
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const { cleanup } = await setupClients();
+  const realNow = Date.now.bind(Date);
+  let offset = 0;
+  t.mock.method(Date, "now", () => realNow() + offset);
+  const harness = createExtensionHarness("unstarted-wake", { hasUI: true, isIdle: () => true });
+  const relay = (message: string) => harness.pi.events.emit("subagent:control-intercom", { to: "unstarted-wake", message });
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+
+    // An input handler can handle the wake prompt, so no agent_start follows it.
+    relay("first");
+    await waitForCondition(() => harness.sentMessages.length === 1, "first relay message");
+    relay("second");
+    await waitForCondition(() => harness.sentMessages.length === 2, "second relay message");
+    assert.equal(harness.userMessages.length, 1, "a recent wake may still be starting");
+
+    offset += 10_001;
+    relay("third");
+    await waitForCondition(() => harness.sentMessages.length === 3, "third relay message");
+    assert.equal(harness.userMessages.length, 2, "an expired wake must not block the next one");
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
 test("async ask can be replied to later from the single pending ask fallback", { concurrency: false }, async () => {
   const { planner, orchestrator, cleanup } = await setupClients();
   const replyTracker = new ReplyTracker();
@@ -4075,6 +4580,68 @@ test("confirmSend still gates an inferred reply; cancellation preserves the pend
   });
 });
 
+test("confirmSend decline blocks explicit cross-machine transport after fail-closed validation", { concurrency: false }, async () => {
+  await withConfirmSendEnabled(async () => {
+    const { cleanup } = await setupClients();
+    const { default: piIntercomExtension } = await import("./index.ts");
+    const temp = mkdtempSync(path.join(repoDir, ".cross-machine-confirm-"));
+    const marker = path.join(temp, "transport-called");
+    const herdr = path.join(temp, "herdr");
+    const previousHerdrBin = process.env.HERDR_BIN_PATH;
+    writeFileSync(herdr, `#!/bin/sh\ntouch ${JSON.stringify(marker)}\nexit 1\n`);
+    chmodSync(herdr, 0o755);
+    process.env.HERDR_BIN_PATH = herdr;
+    const confirmCalls: Array<[string, string]> = [];
+    const harness = createExtensionHarness("cross-machine-confirm-worker", {
+      hasUI: true,
+      ui: {
+        confirm: async (title: string, text: string) => {
+          confirmCalls.push([title, text]);
+          return false;
+        },
+      },
+    });
+
+    try {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      const intercomTool = harness.tools.find((tool) => tool.name === "intercom")!;
+
+      const unsupported = await intercomTool.execute("remote-unsupported", {
+        action: "send",
+        to: "reviewer@workstation",
+        message: "hello",
+        attachments: [{ type: "snippet", name: "note", content: "body" }],
+      }, new AbortController().signal, undefined, harness.ctx);
+      assert.equal(unsupported.details?.error, true);
+
+      const malformed = await intercomTool.execute("remote-malformed", {
+        action: "send",
+        to: "review er@workstation",
+        message: "hello",
+      }, new AbortController().signal, undefined, harness.ctx);
+      assert.equal(malformed.details?.error, true);
+      assert.equal(confirmCalls.length, 0);
+
+      const declined = await intercomTool.execute("remote-declined", {
+        action: "send",
+        to: "reviewer@workstation",
+        message: "hello",
+      }, new AbortController().signal, undefined, harness.ctx);
+      assert.equal(declined.content[0]?.text, "Message cancelled by user");
+      assert.equal(confirmCalls.length, 1);
+      assert.match(confirmCalls[0]![1], /reviewer@workstation/);
+      assert.equal(existsSync(marker), false);
+    } finally {
+      await harness.emitLifecycle("session_shutdown");
+      await cleanup();
+      if (previousHerdrBin === undefined) delete process.env.HERDR_BIN_PATH;
+      else process.env.HERDR_BIN_PATH = previousHerdrBin;
+      rmSync(temp, { recursive: true, force: true });
+    }
+  });
+});
+
 test("contact_supervisor progress_update stays unthreaded despite a pending ask; a later inferred send resolves it", { concurrency: false }, async () => {
   const { orchestrator, cleanup } = await setupClients();
 
@@ -4349,3 +4916,284 @@ 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.userMessages.includes("New intercom message above."));
+      assert.ok(harness.sentMessages.every(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;
+      await harness.emitLifecycle("agent_start");
+      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();
+  }
+});