@selesai/code 0.13.39 → 0.14.0

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

@@ -1,16 +1,26 @@
 {
   "name": "pi-intercom",
-  "version": "0.13.0",
+  "version": "0.16.1",
   "license": "MIT",
   "type": "module",
   "main": "index.ts",
+  "bin": {
+    "pi-intercom": "cli.mjs"
+  },
   "files": [
+    "cli.mjs",
+    "cli.ts",
+    "cross-machine-discovery.ts",
+    "cross-machine-envelope.ts",
+    "cross-machine-transport.ts",
     "index.ts",
     "types.ts",
     "config.ts",
     "cwd.ts",
     "extension-api.ts",
     "format-context.ts",
+    "handover.ts",
+    "herdr-location.ts",
     "project-agent.ts",
     "reply-tracker.ts",
     "broker/**/*.ts",
@@ -18,7 +28,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 handover.test.ts herdr-location.test.ts cross-machine-envelope.test.ts cross-machine-discovery.test.ts cross-machine-transport.test.ts cross-machine-integration.test.ts cli.test.ts broker/cross-machine-provenance.test.ts broker/client.test.ts broker/client-liveness.test.ts broker/mailbox-persistence.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 human-priority.pi.test.ts test/inline-message.test.ts test/overlay-width.test.ts test/handover-picker.test.ts"
   },
   "keywords": [
     "pi-package"

package/dist/extensions/pi-intercom/project-agent.ts

@@ -65,7 +65,7 @@ function normalizeCode(raw: unknown): HerdrErrorCode {
   return "VALIDATION_ERROR";
 }
 
-function createHerdrClient(options: { bin?: string; spawn?: SpawnHerdr } = {}): HerdrClient {
+export function createHerdrClient(options: { bin?: string; spawn?: SpawnHerdr } = {}): HerdrClient {
   const bin = options.bin ?? process.env.HERDR_BIN ?? "herdr";
   const spawnImpl = options.spawn ?? spawn;
   return {

package/dist/extensions/pi-intercom/release-readiness.test.ts

@@ -0,0 +1,116 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { intercomReleaseBlockers, stopIntercom, type IntercomStopState } from "./release-readiness.ts";
+import { ReplyTracker } from "./reply-tracker.ts";
+import type { Message, SessionInfo } from "./types.ts";
+
+function createSession(id: string, name?: string): SessionInfo {
+  return { id, name, cwd: "/tmp/project", model: "test-model", pid: 1, startedAt: 1, lastActivity: 1 };
+}
+
+function createMessage(id: string, expectsReply: boolean): Message {
+  return { id, timestamp: 1, expectsReply, content: { text: "hello" } };
+}
+
+const idle = { pendingAsks: [], outboundAsk: null, pendingOutboxRequests: 0 };
+
+test("an idle intercom has no release blockers", () => {
+  assert.deepEqual(intercomReleaseBlockers(idle), []);
+});
+
+test("unanswered inbound asks block; plain messages and answered asks do not", () => {
+  const tracker = new ReplyTracker();
+  tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", true), 1000);
+  tracker.recordIncomingMessage(createSession("other-id"), createMessage("ask-2", true), 2000);
+  tracker.recordIncomingMessage(createSession("fyi-id", "fyi"), createMessage("note-1", false), 1500);
+  assert.deepEqual(intercomReleaseBlockers({ ...idle, pendingAsks: tracker.listPending(2500) }), [
+    { source: "intercom", kind: "inbound_ask", id: "ask-1", detail: "Ask from planner is awaiting our reply", since: 1000 },
+    { source: "intercom", kind: "inbound_ask", id: "ask-2", detail: "Ask from other-id is awaiting our reply", since: 2000 },
+  ]);
+  tracker.markReplied("ask-1");
+  assert.deepEqual(intercomReleaseBlockers({ ...idle, pendingAsks: tracker.listPending(2500) }).map(blocker => blocker.id), ["ask-2"]);
+});
+
+test("a blocking outbound ask is reported with its reply id and start time", () => {
+  assert.deepEqual(intercomReleaseBlockers({ ...idle, outboundAsk: { from: "planner", replyTo: "reply-9", startedAt: 4242 } }), [
+    { source: "intercom", kind: "outbound_ask", id: "reply-9", detail: "Blocking ask to planner is awaiting a reply", since: 4242 },
+  ]);
+  // A missing start time is omitted rather than invented.
+  const [blocker] = intercomReleaseBlockers({ ...idle, outboundAsk: { from: "planner", replyTo: "reply-9" } });
+  assert.equal("since" in blocker!, false);
+});
+
+test("unsettled outbox requests block", () => {
+  assert.deepEqual(intercomReleaseBlockers({ ...idle, pendingOutboxRequests: 2 }), [
+    { source: "intercom", kind: "outbound_message", detail: "2 outbound message request(s) have not settled" },
+  ]);
+});
+
+test("blockers are bounded and never carry invalid timestamps", () => {
+  const long = "x".repeat(600);
+  const [blocker] = intercomReleaseBlockers({
+    ...idle,
+    pendingAsks: [{ from: createSession("id", long), message: createMessage(long, true), receivedAt: Number.NaN }],
+  });
+  assert.equal(blocker!.id!.length, 256);
+  assert.equal(blocker!.detail.length, 512);
+  assert.equal("since" in blocker!, false);
+});
+
+const farDeadline = () => Date.now() + 5_000;
+const stopState = (overrides: Partial<IntercomStopState> = {}): IntercomStopState => ({ pendingAsks: [], outboundAsk: null, cancelOutboundAsk: () => undefined, ...overrides });
+
+test("stop: an idle intercom has nothing to stop", () => {
+  assert.deepEqual(stopIntercom(stopState(), { deadline: farDeadline() }), []);
+});
+
+test("stop: cancels the blocking outbound ask through the client cancel and reports it", () => {
+  const cancelled: Array<{ from: string; replyTo: string }> = [];
+  const items = stopIntercom(
+    stopState({ outboundAsk: { from: "planner", replyTo: "reply-9", startedAt: 1 }, cancelOutboundAsk: ask => { cancelled.push(ask); } }),
+    { deadline: farDeadline() },
+  );
+  assert.deepEqual(cancelled, [{ from: "planner", replyTo: "reply-9" }]);
+  assert.deepEqual(items, [{ source: "intercom", kind: "outbound_ask", id: "reply-9", detail: "Cancelled blocking ask to planner", ok: true }]);
+});
+
+test("stop: reports a failing cancel as ok:false instead of throwing", () => {
+  const items = stopIntercom(
+    stopState({ outboundAsk: { from: "planner", replyTo: "reply-9" }, cancelOutboundAsk: () => { throw new Error("socket closed"); } }),
+    { deadline: farDeadline() },
+  );
+  assert.deepEqual(items, [{ source: "intercom", kind: "outbound_ask", id: "reply-9", detail: "Failed to cancel blocking ask to planner: socket closed", ok: false, error: "socket closed" }]);
+});
+
+test("stop: inbound asks cannot be cancelled by the receiver and are reported ok:false, left untouched", () => {
+  const tracker = new ReplyTracker();
+  tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", true), 1000);
+  tracker.recordIncomingMessage(createSession("fyi-id", "fyi"), createMessage("note-1", false), 1500);
+  const items = stopIntercom(stopState({ pendingAsks: tracker.listPending(2000) }), { deadline: farDeadline() });
+  assert.deepEqual(items, [{
+    source: "intercom", kind: "inbound_ask", id: "ask-1",
+    detail: "cannot cancel inbound: ask from planner is awaiting our reply and keeps waiting", ok: false, error: "cannot cancel inbound",
+  }]);
+  assert.equal(tracker.listPending(2000).length, 1, "the ask is still pending");
+});
+
+test("stop: appends the recipient-side outcome when the best-effort message cancel settles within the deadline", async () => {
+  const items = await stopIntercom(
+    stopState({ outboundAsk: { from: "planner", replyTo: "reply-9" }, cancelOutboundAsk: () => Promise.resolve("recipient asked to drop it") }),
+    { deadline: farDeadline() },
+  );
+  assert.deepEqual(items, [{ source: "intercom", kind: "outbound_ask", id: "reply-9", detail: "Cancelled blocking ask to planner; recipient asked to drop it", ok: true }]);
+});
+
+test("stop: a hanging or rejecting recipient-side cancel does not change the result or outlive the deadline", async () => {
+  const hanging = await stopIntercom(
+    stopState({ outboundAsk: { from: "planner", replyTo: "reply-9" }, cancelOutboundAsk: () => new Promise<string>(() => undefined) }),
+    { deadline: Date.now() + 40 },
+  );
+  assert.deepEqual(hanging.map(item => [item.kind, item.ok, item.detail]), [["outbound_ask", true, "Cancelled blocking ask to planner"]]);
+  const rejecting = await stopIntercom(
+    stopState({ outboundAsk: { from: "planner", replyTo: "reply-9" }, cancelOutboundAsk: () => Promise.reject(new Error("Cancel timeout")) }),
+    { deadline: farDeadline() },
+  );
+  assert.deepEqual(rejecting.map(item => [item.kind, item.ok]), [["outbound_ask", true]]);
+});

package/dist/extensions/pi-intercom/release-readiness.ts

@@ -0,0 +1,93 @@
+import type { ReleaseBlocker, StopAllBackgroundItem } from "@selesai/code";
+import type { IntercomContext } from "./reply-tracker.ts";
+
+export interface IntercomReleaseState {
+  /** Inbound asks still awaiting OUR reply (`ReplyTracker.listPending()`). */
+  pendingAsks: readonly IntercomContext[];
+  /** The module-level blocking outbound ask (`replyWaiter`), if one is in flight. */
+  outboundAsk: { from: string; replyTo: string; startedAt?: number } | null;
+  /** Outbound outbox requests from other extensions that have not settled. */
+  pendingOutboxRequests: number;
+}
+
+const clip = (value: string, max: number) => value.length > max ? value.slice(0, max) : value;
+
+/** Release blockers owned by the intercom extension. Pure: callers pass a snapshot of live state. */
+export function intercomReleaseBlockers(state: IntercomReleaseState): ReleaseBlocker[] {
+  const blockers: ReleaseBlocker[] = [];
+  for (const ask of state.pendingAsks) {
+    const sender = ask.from.name?.trim() || ask.from.id;
+    blockers.push({
+      source: "intercom", kind: "inbound_ask", id: clip(ask.message.id, 256),
+      detail: clip(`Ask from ${sender} is awaiting our reply`, 512),
+      ...(Number.isFinite(ask.receivedAt) && ask.receivedAt >= 0 ? { since: Math.trunc(ask.receivedAt) } : {}),
+    });
+  }
+  if (state.outboundAsk) {
+    const { from, replyTo, startedAt } = state.outboundAsk;
+    blockers.push({
+      source: "intercom", kind: "outbound_ask", id: clip(replyTo, 256),
+      detail: clip(`Blocking ask to ${from} is awaiting a reply`, 512),
+      ...(startedAt !== undefined && Number.isFinite(startedAt) && startedAt >= 0 ? { since: Math.trunc(startedAt) } : {}),
+    });
+  }
+  if (state.pendingOutboxRequests > 0) {
+    blockers.push({ source: "intercom", kind: "outbound_message", detail: `${state.pendingOutboxRequests} outbound message request(s) have not settled` });
+  }
+  return blockers;
+}
+
+export interface IntercomStopState {
+  /** Inbound asks still awaiting OUR reply (`ReplyTracker.listPending()`). */
+  pendingAsks: readonly IntercomContext[];
+  /** The module-level blocking outbound ask (`replyWaiter`), if one is in flight. */
+  outboundAsk: { from: string; replyTo: string; startedAt?: number } | null;
+  /**
+   * Cancels the outbound ask: tells the broker (`client.cancelAsk`, drops the ask edge and its pending-ask record) and rejects the
+   * local waiter so the blocked tool call returns. Synchronous. Optionally returns the settled outcome of asking the recipient to
+   * drop the message (`client.cancelMessage`); that part is best-effort because the recipient may already have acted on it.
+   */
+  cancelOutboundAsk(ask: { from: string; replyTo: string }): void | PromiseLike<string | undefined>;
+}
+
+/**
+ * Kill-switch handler. Outbound asks have a cancel (broker `cancel_ask` / `cancel_message`, exposed by the client), so they are
+ * cancelled. Inbound asks waiting on THIS session cannot be cancelled by the receiver (the protocol has no "decline"), so they are
+ * left alone and reported as `ok:false` so the caller can show who is still waiting. Never throws.
+ */
+export function stopIntercom(state: IntercomStopState, request: { deadline: number }, now: () => number = Date.now): StopAllBackgroundItem[] | PromiseLike<StopAllBackgroundItem[]> {
+  const items: StopAllBackgroundItem[] = [];
+  let pendingCancel: PromiseLike<string | undefined> | undefined;
+  const ask = state.outboundAsk;
+  let outbound: StopAllBackgroundItem | undefined;
+  if (ask) {
+    const base = { source: "intercom", kind: "outbound_ask", id: clip(ask.replyTo, 256) };
+    try {
+      const outcome = state.cancelOutboundAsk({ from: ask.from, replyTo: ask.replyTo });
+      outbound = { ...base, detail: clip(`Cancelled blocking ask to ${ask.from}`, 512), ok: true };
+      if (outcome) pendingCancel = outcome;
+    } catch (error) {
+      const text = error instanceof Error ? error.message : String(error);
+      outbound = { ...base, detail: clip(`Failed to cancel blocking ask to ${ask.from}: ${text}`, 512), ok: false, error: clip(text, 256) };
+    }
+    items.push(outbound);
+  }
+  for (const inbound of state.pendingAsks) {
+    const sender = inbound.from.name?.trim() || inbound.from.id;
+    items.push({
+      source: "intercom", kind: "inbound_ask", id: clip(inbound.message.id, 256),
+      detail: clip(`cannot cancel inbound: ask from ${sender} is awaiting our reply and keeps waiting`, 512), ok: false, error: "cannot cancel inbound",
+    });
+  }
+  if (!pendingCancel || !outbound) return items;
+  const finished = outbound;
+  const budget = Math.max(0, request.deadline - now());
+  return new Promise<StopAllBackgroundItem[]>((resolve) => {
+    const timer = setTimeout(() => resolve(items), budget);
+    pendingCancel!.then((note) => {
+      clearTimeout(timer);
+      if (note) finished.detail = clip(`${finished.detail}; ${note}`, 512);
+      resolve(items);
+    }, () => { clearTimeout(timer); resolve(items); });
+  });
+}

package/dist/extensions/pi-intercom/skills/pi-intercom/SKILL.md

@@ -71,7 +71,8 @@ Before sending, verify who's connected:
 
 ```typescript
 intercom({ action: "list" })
-// → Shows all connected sessions with names, cwd, models, and live status (`idle`, `thinking`, `tool:<name>`)
+// → Shows all connected sessions with names, cwd, models, live status, and
+//   current Herdr workspace/tab/pane (or explicit not-hosted/unavailable state)
 ```
 
 ### Pattern 3: Reply Naturally
@@ -159,6 +160,25 @@ intercom({
 If a live session already exists in that `cwd`, intercom reuses it. If multiple
 sessions are active there, pass `to` to select one by name or session ID.
 
+### Pattern 6b: Hand Over Your Session
+
+When the user moves work to another session, `handover` summarizes this
+session (next task, decisions, files, current state, open questions) with the
+current model and sends it. The receiver acts on it like any inbound message.
+Pass the next task as `message`; targeting works exactly like `send`.
+
+```typescript
+intercom({
+  action: "handover",
+  cwd: "/path/to/other-repo",
+  openProjectPaneIfMissing: true,
+  message: "Port the schema fix here and run the adapter tests"
+})
+```
+
+Humans can run `/handover <target> [next task]` to review the summary in an
+editor before it is sent. `/handover` alone opens a picker for the target.
+
 ### Pattern 7: Handle Subagent Escalations (Orchestrator Side)
 
 When `pi-subagents` spawns a delegated child and supplies child bridge metadata,
@@ -235,7 +255,7 @@ new visible project panes should go through the supervisor.
 | `ask` | Blocks until reply (10 min default, configurable with `PI_INTERCOM_ASK_TIMEOUT_MS`) | You need an answer to continue |
 | `reply` | Responds to the active or pending inbound ask | You were asked something and need to answer naturally |
 | `pending` | Lists unresolved inbound asks | You need to see who is waiting before replying |
-| `list` | Returns all sessions with live status | You need to discover targets or choose an idle peer |
+| `list` | Returns all sessions with live status and freshly resolved Herdr location | You need to discover targets or choose an idle peer |
 | `status` | Returns your connection state | Troubleshooting |
 
 ## Visible Peer Sessions
@@ -274,6 +294,10 @@ if (result.isError && result.content[0].text.includes("Already waiting")) {
 
 ## Best Practices
 
+### Use list location instead of guessing
+
+For a Herdr-hosted session, `list` displays readable workspace and tab labels plus stable opaque IDs and a diagnostic pane ID. The workspace/tab values come from a fresh bounded Herdr snapshot for that list request, joined by the Pi session identity that remains stable when Herdr changes the workspace-qualified pane ID, so use them instead of inferring location from cwd or session name. `not under Herdr` means the session did not register a Herdr pane. `Herdr location unavailable` means it did register one, but the current snapshot failed or no longer contained that pane. Use `herdrLocation.paneId`, not the launch-time `herdrPaneId`, when current diagnostic pane metadata is needed. Do not use pane IDs as intercom addressing handles; target the session name or intercom session ID. If no connected session is Herdr-hosted, `list` does not call Herdr or add location lines.
+
 ### Use `ask` for blocking workflows
 
 When the worker needs information to proceed:

package/dist/extensions/pi-intercom/test/handover-picker.test.ts

@@ -0,0 +1,134 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { HandoverPicker, type HandoverPickerResult, type RemoteSessionLister } from "../ui/handover-picker.ts";
+import { SessionListOverlay, type SessionListSelection } from "../ui/session-list.ts";
+import type { SessionInfo } from "../types.ts";
+
+const theme = { fg: (_name: string, text: string) => text, bold: (text: string) => text };
+const KEYS: Record<string, string> = {
+  "tui.select.up": "\x1b[A",
+  "tui.select.down": "\x1b[B",
+  "tui.select.confirm": "\r",
+  "tui.select.cancel": "\x1b",
+  "tui.input.tab": "\t",
+  "tui.editor.deleteCharBackward": "\x7f",
+};
+const keybindings = {
+  matches: (data: string, id: string) => KEYS[id] === data,
+  getKeys: (id: string) => [id.split(".").pop()!],
+};
+
+function session(id: string, name: string, extra: Partial<SessionInfo> = {}): SessionInfo {
+  return { id, name, cwd: `/work/${name}`, model: "model", pid: 1, startedAt: 0, lastActivity: 0, ...extra };
+}
+
+const self = session("self-0000", "planner");
+const roster = [
+  self,
+  session("subagent-worker-run-1", "worker: You are the writer for lane x"),
+  session("unnamed-00", "subagent-chat-unnamed", { runtimeFallbackAlias: true, lastActivity: 1 }),
+  session("adapter-00", "adapter", { lastActivity: 2 }),
+];
+const noRemote: RemoteSessionLister = {
+  listMachines: async () => assert.fail("remote listing must not run on open"),
+  listAgents: async () => [],
+};
+
+function open(options: { lister?: RemoteSessionLister; preselectSessionId?: string } = {}) {
+  const results: Array<HandoverPickerResult | undefined> = [];
+  const picker = new HandoverPicker(
+    { requestRender() {} } as any,
+    theme as any,
+    keybindings as any,
+    { currentSession: self, sessions: roster, lister: options.lister ?? noRemote, preselectSessionId: options.preselectSessionId },
+    (result) => results.push(result),
+  );
+  const press = (...keys: string[]) => keys.forEach((key) => picker.handleInput(KEYS[key] ?? key));
+  return { picker, results, press, text: () => picker.render(88).join("\n") };
+}
+
+test("handover picker lists local peers without self or subagent children", () => {
+  const { text, press, results } = open();
+  assert.doesNotMatch(text(), /planner|You are the writer/);
+  assert.match(text(), /adapter \(adapter-\)[\s\S]*subagent-chat-unnamed/);
+  press("tui.select.confirm");
+  assert.equal(results[0]?.target.kind === "local" && results[0].target.session.id, "adapter-00");
+});
+
+test("handover picker returns the next task typed in the task field", () => {
+  const { press, results } = open({ preselectSessionId: "unnamed-00" });
+  press("port", " the fix", "tui.select.confirm");
+  assert.deepEqual(results, [{ target: { kind: "local", session: roster[2] }, goal: "port the fix" }]);
+});
+
+test("handover picker accepts pasted and Kitty-encoded next-task text", () => {
+  const { press, results } = open();
+  press("tui.input.tab", "\x1b[200~port the fix\x1b[201~", "\x1b[32u", "\x1b[97u", "tui.select.confirm");
+  assert.equal(results[0]?.goal, "port the fix a");
+});
+
+test("session list starts a handover on plain or Kitty-encoded h and messages on Enter", () => {
+  for (const [key, action] of [["h", "handover"], ["\x1b[104u", "handover"], ["\r", "message"]] as const) {
+    const selections: Array<SessionListSelection | undefined> = [];
+    new SessionListOverlay(theme as any, keybindings as any, self, [roster[3]!], (selection) => selections.push(selection)).handleInput(key);
+    assert.deepEqual(selections, [{ session: roster[3], action }], key);
+  }
+});
+
+test("handover picker fetches other machines on demand and targets a remote session by id", async () => {
+  const sessionId = "00000000-0000-4000-8000-000000000001";
+  const lister: RemoteSessionLister = {
+    listMachines: async () => [
+      { label: "workmac", target: "10.0.0.1", enabled: true },
+      { label: "macmini", target: "10.0.0.2", enabled: true },
+      { label: "off", target: "10.0.0.3", enabled: false },
+    ],
+    listAgents: async (machine) => {
+      if (machine.label === "macmini") throw new Error(`Saved Herdr machine "macmini" is unreachable: ${"slow ".repeat(20)}end-of-error.`);
+      return [{ name: sessionId, sessionId, cwd: "/work/remote", status: "idle" }];
+    },
+  };
+  const { press, results, text } = open({ lister });
+  press("tui.select.down", "tui.select.down", "tui.select.down", "tui.select.confirm");
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.match(text(), /00000000@workmac · idle/);
+  assert.match(text(), /Saved Herdr machine "macmini" is unreachable/);
+  assert.match(text(), /end-of-error\./, "long machine errors wrap instead of being cut off");
+  assert.doesNotMatch(text(), /off/);
+  press("tui.select.down", "tui.select.confirm");
+  assert.deepEqual(results, [{ target: { kind: "remote", target: `${sessionId}@workmac` }, goal: undefined }]);
+});
+
+test("handover picker keeps the highlighted remote session when an earlier machine answers later", async () => {
+  let answerSlow: (agents: Array<{ name: string }>) => void = () => {};
+  const lister: RemoteSessionLister = {
+    listMachines: async () => [
+      { label: "slow", target: "10.0.0.1", enabled: true },
+      { label: "fast", target: "10.0.0.2", enabled: true },
+    ],
+    listAgents: (machine) => machine.label === "fast"
+      ? Promise.resolve([{ name: "fast-agent" }])
+      : new Promise((resolve) => { answerSlow = resolve; }),
+  };
+  const { press, results } = open({ lister });
+  press("tui.select.down", "tui.select.down", "tui.select.down", "tui.select.confirm");
+  await new Promise((resolve) => setImmediate(resolve));
+  press("tui.select.down");
+  answerSlow([{ name: "slow-agent" }]);
+  await new Promise((resolve) => setImmediate(resolve));
+  press("tui.select.confirm");
+  assert.deepEqual(results, [{ target: { kind: "remote", target: "fast-agent@fast" }, goal: undefined }]);
+});
+
+test("handover picker renders lines at the declared overlay width", () => {
+  const { picker, press } = open();
+  for (const focus of ["list", "task"]) {
+    for (const width of [1, 2, 20, 50, 88, 120]) {
+      for (const line of picker.render(width)) assert.equal(visibleWidth(line), Math.min(width, 88), `${focus} ${width}`);
+    }
+    press("tui.input.tab", "a long next task that does not fit in a narrow overlay");
+  }
+});

package/dist/extensions/pi-intercom/test/inline-message.test.ts

@@ -51,6 +51,49 @@ test("expanded inline intercom messages show the full body without collapse cont
   assert.doesNotMatch(rendered, /Ctrl\+O/);
 });
 
+test("cross-machine messages label the asserted identity as unverified", () => {
+  const component = new InlineMessageComponent(from, {
+    ...message,
+    crossMachine: {
+      type: "ssh-relay",
+      version: 1,
+      origin: { name: "worker", sessionId: "00000000-0000-4000-8000-000000000001", machine: "laptop" },
+      trust: "ssh-asserted",
+    },
+  }, theme as any, 'intercom({ action: "send", to: "worker@laptop", message: "..." })');
+
+  const rendered = component.render(120).join("\n");
+  assert.match(rendered, /worker@laptop · unverified cross-machine/);
+  assert.match(rendered, /To send a new message to worker@laptop: intercom/);
+  assert.doesNotMatch(rendered, /To reply/);
+});
+
+test("collapsed cross-machine messages keep the unverified identity and new-message affordance explicit", () => {
+  const component = new InlineMessageComponent(from, {
+    ...message,
+    crossMachine: {
+      type: "ssh-relay",
+      version: 1,
+      origin: { name: "worker", sessionId: "00000000-0000-4000-8000-000000000001", machine: "laptop" },
+      trust: "ssh-asserted",
+    },
+  }, theme as any, 'intercom({ action: "send", to: "worker@laptop", message: "..." })', undefined, true);
+
+  const rendered = component.render(160).join("\n");
+  assert.match(rendered, /From: worker@laptop · unverified cross-machine/);
+  assert.match(rendered, /To send a new message to worker@laptop: intercom/);
+  assert.doesNotMatch(rendered, /To reply/);
+});
+
+test("local message header and reply affordance remain unchanged", () => {
+  const component = new InlineMessageComponent(from, message, theme as any, "intercom reply");
+
+  const rendered = component.render(100).join("\n");
+  assert.match(rendered, /From: sender \(\/tmp\/project\)/);
+  assert.match(rendered, /To reply: intercom reply/);
+  assert.doesNotMatch(rendered, /unverified cross-machine|To send a new message to/);
+});
+
 test("collapsed inline intercom messages keep preview, reply hint, and expand key visible", () => {
   const component = new InlineMessageComponent(
     from,