@ctliz/agent-intercom-claude 0.13.1 → 0.14.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-intercom",
-  "version": "0.1.0",
+  "version": "0.14.1",
   "description": "Claude Code MCP plugin and wakeable worker for local Pi/Codex/Claude intercom messaging.",
   "author": {
     "name": "ctliz",

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 0.14.1 - 2026-09-30
+
+- Expose the existing MCP owner's `runtimeReady` promise to companion Grok/AGY launchers so native identity and title updates use `syncSession` without opening a competing broker connection.
+
+## 0.14.0 - 2026-09-30
+
+- Register ordinary MCP launches before the first prompt/tool call; packaged SessionStart/SessionEnd hooks synchronize native conversation identity without creating a competing broker connection.
+- Forward `cci --tui --name` to Claude's native title and synchronize `/rename` into broker presence in MCP and verified native modes. Preserve launcher IDs, resume targets, and the existing native compatibility gate.
+- Retain messages received during Monitor startup and follow conversation changes after `/clear`.
+- Pause automatic reconnect on `SESSION_ID_IN_USE`, expose the conflict in `intercom_status`, and cancel pending reply waiters when a session ends.
+
 ## 0.13.1 - 2026-09-06
 
 - Stable release of named teams without tmux. `intercom_join`, `/intercom-create`, and `/intercom-join` work outside TmuxDeck.

package/README.md

@@ -185,18 +185,16 @@ With `--transport mcp`, `cci` does this automatically for each normal headless w
 
 The `claude-intercom-mcp` executable is a standard stdio MCP server, but Grok Build and AGY should normally use the dedicated `@ctliz/agent-intercom-grok` and `@ctliz/agent-intercom-agy` packages. Those packages install `agent-intercom-grok-mcp` and `agent-intercom-agy-mcp`, depend on this package, and load its runtime internally. A separate global `claude-intercom-mcp` installation is not required. For a source-only checkout, configure `node` with the absolute path to `dist/claude-server.mjs`. Node 22.19+ is required.
 
-Install the matching host package globally, then install its GitHub plugin at the matching release tag.
+Install the matching host package globally, then install its GitHub plugin at the matching release tag. Companion launchers may await the exported `runtimeReady` promise from `dist/claude-server.mjs` and call `syncSession({ ...runtime.getIdentity(), name })` on that same runtime. This entry starts MCP stdio; do not create a second broker client to synchronize a host title.
 
 Use `AGENT_INTERCOM_SESSION_ID` and `AGENT_INTERCOM_SESSION_NAME` for a host-neutral identity; `CLAUDE_INTERCOM_SESSION_ID` and `CLAUDE_INTERCOM_NAME` remain higher-priority compatibility aliases. Do not share a fixed session ID between concurrent host sessions.
 
 A plain MCP host is connected only while its MCP process is alive. Incoming Intercom messages are durable and appear through `intercom_pending`, but this server cannot itself inject a new prompt into Grok or AGY. Use `intercom_send` plus `intercom_pending` for manual-polling workflows; a host-specific relay is required for wake-on-message.
 
-For Grok Build, register the server and use a unique static ID for an individual long-lived probe or worker:
+For Grok Build, register the dedicated launcher without a fixed identity. It uses Grok's native `GROK_SESSION_ID` when available and synchronizes the exact session's persisted title:
 
 ```bash
 grok mcp add agent-intercom \
-  -e AGENT_INTERCOM_SESSION_ID=grok-probe-01 \
-  -e AGENT_INTERCOM_SESSION_NAME=grok-probe \
   -e CLAUDE_INTERCOM_MODEL=grok-build \
   -- agent-intercom-grok-mcp
 ```
@@ -209,8 +207,6 @@ For AGY, add the equivalent entry to `~/.gemini/config/mcp_config.json`:
     "agent-intercom": {
       "command": "agent-intercom-agy-mcp",
       "env": {
-        "AGENT_INTERCOM_SESSION_ID": "agy-probe-01",
-        "AGENT_INTERCOM_SESSION_NAME": "agy-probe",
         "CLAUDE_INTERCOM_MODEL": "agy"
       }
     }
@@ -218,7 +214,7 @@ For AGY, add the equivalent entry to `~/.gemini/config/mcp_config.json`:
 }
 ```
 
-Both hosts must use the same `AGENT_INTERCOM_SCOPE_ID` as their intended peers, or leave it unset for the default local scope. Call `intercom_whoami` once after startup, then use `intercom_list`, `intercom_send`, and `intercom_pending` to verify delivery.
+Both hosts must use the same `AGENT_INTERCOM_SCOPE_ID` as their intended peers, or leave it unset for the default local scope. Their persistent MCP server registers eagerly, without a first prompt or tool call. AGY's optional native metadata publisher is described in its package README. Use `intercom_whoami`, `intercom_list`, `intercom_send`, and `intercom_pending` to verify identity and delivery.
 
 Optional identity variables can be attached at registration time:
 
@@ -375,6 +371,40 @@ Choose explicitly with `--transport native` or `--transport mcp`, or set `CLAUDE
 
 `--minimal` is ignored in live TUI mode. The native path requires an interactive Claude process that publishes its local messaging socket. The MCP path additionally needs a built checkout (`npm run build`) and an available Monitor feature; Monitor is unavailable when `DISABLE_TELEMETRY` or `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` is set, or on Bedrock/Vertex/Foundry. Both paths remain local and work behind a custom `ANTHROPIC_BASE_URL`/proxy. See [docs/wake-mechanisms.md](docs/wake-mechanisms.md).
 
+### Startup registration and native session names
+
+The MCP server now registers as soon as it starts, without waiting for a prompt
+or an Intercom tool call. Bare MCP configuration provides discovery and queued
+messages; load the packaged plugin for hooks and automatic Monitor delivery:
+
+```bash
+claude --plugin-dir /path/to/agent-intercom-claude --name reviewer
+```
+
+On macOS/Linux, the plugin's `SessionStart`/`SessionEnd` hooks publish private
+metadata only. The persistent MCP server is the **only** broker connection.
+Without a launcher-provided ID, Intercom uses `claude-<native-session-id>`, so
+resuming a conversation preserves its target and `/clear` releases the old
+conversation before registering the new one. Explicit Claude/generic launcher
+IDs retain their existing precedence.
+
+`cci --tui --name reviewer` also passes Claude's native `--name` flag. `/rename`
+updates broker presence without changing the stable ID. MCP mode incrementally
+tails only native `custom-title` transcript records; it never replaces your
+statusline configuration. Native mode follows the verified socket registry's
+name. The native transport version gate remains **2.1.220–2.1.226**; Claude
+2.1.285 was smoke-tested through MCP, not added to that gate.
+
+The Monitor skips historical inbox entries but retains messages that arrived
+after `SessionStart`, even if they preceded Monitor startup. Unsupported host
+process discovery falls back to eager MCP registration and explicit launcher
+identity/inbox settings, as used by `cci`.
+
+Enable Intercom once per Claude process: loading the plugin and a second manual
+MCP entry for the same identity creates competing runtimes. `SESSION_ID_IN_USE`
+leaves the incumbent authoritative, pauses automatic retries, and is exposed by
+`intercom_status`. Do not share a fixed launcher ID between concurrent sessions.
+
 ## Normal And Minimal Workers
 
 Like Codex's `coi` (normal) and `coim` (minimal), `cci` has a minimal mode. Codex

package/claude/cci.ts

@@ -21,7 +21,7 @@ import {
   type ResolvedClaudeIntercomTransport,
 } from "./transport.ts";
 import { NativeClaudeBrokerBridge } from "./native-bridge.ts";
-import { waitForNativeClaudePeer } from "./native-protocol.ts";
+import { nativePeerNameBySocket, waitForNativeClaudePeer } from "./native-protocol.ts";
 import { INTERCOM_SCOPE_ENV, intercomScopeIdFromEnvForRegistration } from "../protocol-v4/contract.ts";
 
 export interface CciOptions {
@@ -325,7 +325,7 @@ async function runCciTui(options: CciOptions, id: string, name: string, scopeId:
     rmSync(inboxPath, { force: true }); // fresh session: only surface messages that arrive from now on
   }
 
-  const args: string[] = ["--append-system-prompt", buildTuiAppendSystemPrompt(name, id, resolution.selected)];
+  const args: string[] = ["--name", name, "--append-system-prompt", buildTuiAppendSystemPrompt(name, id, resolution.selected)];
   if (resolution.selected === "mcp") args.unshift("--plugin-dir", root);
   const permission = resolveClaudePermissionPolicy(options);
   if (options.model) args.push("--model", options.model);
@@ -354,12 +354,21 @@ async function runCciTui(options: CciOptions, id: string, name: string, scopeId:
     },
   });
   let bridge: NativeClaudeBrokerBridge | undefined;
+  let nativeNameTimer: NodeJS.Timeout | undefined;
+  let nativeNameSync = Promise.resolve();
   if (resolution.selected === "native") {
     try {
       if (!child.pid) throw new Error("Claude started without a process id; native transport cannot attach");
       const peer = await waitForNativeClaudePeer(child.pid);
       bridge = new NativeClaudeBrokerBridge({ id, name, cwd: options.cwd, model: options.model }, { scopeId });
       await bridge.start(peer.socketPath);
+      nativeNameTimer = setInterval(() => {
+        const name = nativePeerNameBySocket(peer.socketPath);
+        if (name) nativeNameSync = nativeNameSync.then(() => bridge!.syncName(name)).catch((error) => {
+          process.stderr.write(`cci: native name sync failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        });
+      }, 1000);
+      nativeNameTimer.unref();
     } catch (error) {
       child.kill("SIGTERM");
       await waitForChildExit(child).catch(() => undefined);
@@ -370,6 +379,8 @@ async function runCciTui(options: CciOptions, id: string, name: string, scopeId:
     }
   }
   const [code, signal] = await waitForChildExit(child);
+  clearInterval(nativeNameTimer);
+  await nativeNameSync;
   await bridge?.stop();
   if (resolution.selected === "mcp") rmSync(inboxPath, { force: true });
   if (typeof code === "number") return code;

package/claude/inbox-monitor.ts

@@ -6,7 +6,11 @@
 import { existsSync, readFileSync } from "node:fs";
 import { setTimeout as delay } from "node:timers/promises";
 import { basename } from "node:path";
-import { formatInboxLine, inboxBatchFrom } from "./inbox.ts";
+import { defaultInboxPath, formatInboxLine, inboxBatchFrom } from "./inbox.ts";
+import {
+  ClaudeSessionReader, claudeIdentityForSession, claudeSessionMetadataPath,
+  findClaudeHost, waitForClaudeSession,
+} from "./session-lifecycle.ts";
 
 const POLL_MS = 1000;
 
@@ -18,12 +22,24 @@ function readContent(path: string): string {
   }
 }
 
-export async function runInboxMonitor(path: string, signal?: { aborted: boolean }): Promise<void> {
-  // Start after the current backlog so only new messages are surfaced.
-  let emitted = inboxBatchFrom(readContent(path), 0).total;
+type InboxSource = string | (() => { path: string; startedAt?: number });
+
+export async function runInboxMonitor(source: InboxSource, signal?: { aborted: boolean }): Promise<void> {
+  let path = "";
+  let emitted = 0;
   for (;;) {
     if (signal?.aborted) return;
-    const { entries, total } = inboxBatchFrom(readContent(path), emitted);
+    const next = typeof source === "string" ? { path: source } : source();
+    const content = readContent(next.path);
+    if (path !== next.path) {
+      path = next.path;
+      const backlog = inboxBatchFrom(content, 0);
+      // Skip old history, not messages received after SessionStart but before
+      // Monitor startup. A resumed/cleared conversation gets its own cutoff.
+      emitted = next.startedAt === undefined ? backlog.total
+        : backlog.entries.filter((entry) => entry.ts < next.startedAt!).length;
+    }
+    const { entries, total } = inboxBatchFrom(content, emitted);
     for (const entry of entries) {
       process.stdout.write(`${formatInboxLine(entry)}\n`);
     }
@@ -33,12 +49,20 @@ export async function runInboxMonitor(path: string, signal?: { aborted: boolean
 }
 
 async function main(): Promise<void> {
-  const path = process.env.CLAUDE_INTERCOM_INBOX || process.argv[2];
-  if (!path) {
-    process.stderr.write("inbox-monitor: no inbox path (set CLAUDE_INTERCOM_INBOX or pass a path)\n");
-    process.exit(1);
+  const explicitPath = process.env.CLAUDE_INTERCOM_INBOX || process.argv[2];
+  const host = findClaudeHost();
+  if (!host) {
+    if (!explicitPath) throw new Error("Cannot determine this Claude session's inbox");
+    await runInboxMonitor(explicitPath);
+    return;
   }
-  await runInboxMonitor(path);
+  const reader = new ClaudeSessionReader(claudeSessionMetadataPath(host), host);
+  await waitForClaudeSession(reader);
+  await runInboxMonitor(() => {
+    const metadata = reader.read();
+    const identity = claudeIdentityForSession(metadata, process.env, host.pid);
+    return { path: explicitPath || defaultInboxPath(identity.sessionId), startedAt: metadata?.startedAt };
+  });
 }
 
 if (process.argv[1] && (basename(process.argv[1]) === "inbox-monitor.ts" || basename(process.argv[1]) === "inbox-monitor.mjs")) {

package/claude/mcp-protocol.ts

@@ -248,7 +248,7 @@ export async function handleMcpRequest(request: JsonRpcRequest, runtime: ClaudeI
       return ok(request.id, {
         protocolVersion: "2025-06-18",
         capabilities: { tools: {} },
-        serverInfo: { name: "claude-intercom", version: "0.1.0" },
+        serverInfo: { name: "claude-intercom", version: "0.14.0" },
       });
     case "ping":
       return ok(request.id, {});

package/claude/native-bridge.ts

@@ -36,7 +36,7 @@ interface NativeBridgeClient {
   disconnect(): Promise<void>;
   acknowledgeMessage(deliveryId: string): void;
   send(to: string, message: { text: string; replyTo?: string }): Promise<{ delivered: boolean; reason?: string }>;
-  updatePresence(update: { status?: string }): void;
+  updatePresence(update: { name?: string; status?: string }): void;
 }
 
 export interface NativeClaudeBridgeIdentity {
@@ -153,6 +153,13 @@ export class NativeClaudeBrokerBridge {
     this.started = true;
   }
 
+  async syncName(name: string): Promise<void> {
+    if (!this.started || !name.trim() || name === this.identity.name) return;
+    this.identity.name = name;
+    this.client.updatePresence({ name });
+    await updateNativeClaudePeer(this.pid, { name: `${name} bridge` }, this.options.registryDir);
+  }
+
   private async handleBrokerMessage(from: SessionInfo, message: Message, deliveryId: string): Promise<void> {
     try {
       this.client.updatePresence({ status: "active" });

package/claude/runtime.ts

@@ -6,7 +6,7 @@ import { IntercomClient } from "../broker/client.ts";
 import { intercomScopeIdFromEnvForRegistration } from "../protocol-v4/contract.ts";
 import { spawnBrokerIfNeeded } from "../broker/spawn.ts";
 import { getAskTimeoutMs, loadConfig } from "../config.ts";
-import { appendInboxMessage } from "./inbox.ts";
+import { appendInboxMessage, defaultInboxPath } from "./inbox.ts";
 import type { Attachment, Message, SessionInfo } from "../types.ts";
 import { formatIntercomTeam, resolveIntercomTeam } from "./team.ts";
 import {
@@ -219,6 +219,7 @@ export class ClaudeIntercomRuntime {
   private reconnectTimer: NodeJS.Timeout | null = null;
   private reconnectAttempt = 0;
   private reconnectEnabled = true;
+  private registrationConflict: Error | null = null;
   private identity: ClaudeRuntimeIdentity;
   private unread: PendingInboundMessage[] = [];
   private unresolvedAsks = new Map<string, PendingInboundMessage>();
@@ -251,7 +252,37 @@ export class ClaudeIntercomRuntime {
     return this.identity;
   }
 
+  async syncSession(identity: ClaudeRuntimeIdentity): Promise<void> {
+    const changed = identity.sessionId !== this.identity.sessionId || identity.cwd !== this.identity.cwd;
+    if (changed) {
+      await this.disconnect();
+      this.unread = [];
+      this.unresolvedAsks.clear();
+      this.registrationConflict = null;
+    }
+    const renamed = identity.name !== this.identity.name;
+    const modelChanged = identity.model !== this.identity.model;
+    this.identity = identity;
+    if (changed) await this.connect();
+    else if (renamed || modelChanged) this.client?.updatePresence({ name: identity.name, model: identity.model });
+  }
+
+  private pauseOnRegistrationConflict(error: unknown): boolean {
+    // Framing/client wrappers preserve the broker error as an Error.cause.
+    let cause = error;
+    for (let depth = 0; cause instanceof Error && depth < 8; depth++, cause = cause.cause) {
+      if ((cause as Error & { code?: string }).code === "SESSION_ID_IN_USE") {
+        this.registrationConflict = cause;
+        this.reconnectEnabled = false;
+        this.clearReconnectTimer();
+        return true;
+      }
+    }
+    return false;
+  }
+
   async connect(): Promise<IntercomClient> {
+    if (this.registrationConflict) throw this.registrationConflict;
     this.reconnectEnabled = true;
     this.clearReconnectTimer();
     if (this.client?.isConnected()) return this.client;
@@ -259,6 +290,9 @@ export class ClaudeIntercomRuntime {
     this.connectPromise = this.connectOnce();
     try {
       return await this.connectPromise;
+    } catch (error) {
+      this.pauseOnRegistrationConflict(error);
+      throw error;
     } finally {
       this.connectPromise = null;
     }
@@ -271,26 +305,29 @@ export class ClaudeIntercomRuntime {
       this.handleIncomingMessage(from, message);
       client.acknowledgeMessage(deliveryId);
     });
+    client.on("error", (error: Error) => {
+      this.pauseOnRegistrationConflict(error);
+      process.stderr.write(`claude-intercom: ${error.message}\n`);
+    });
     client.on("disconnected", (error: Error) => {
-      for (const waiter of this.replyWaiters.values()) {
-        clearTimeout(waiter.timeout);
-        waiter.cleanup?.();
-        waiter.reject(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
-      }
-      this.replyWaiters.clear();
+      this.rejectReplyWaiters(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
       if (this.client === client) this.client = null;
       this.scheduleReconnect();
     });
+    const registeredIdentity = this.identity;
     await client.connect({
-      name: this.identity.name,
-      cwd: this.identity.cwd,
-      model: this.identity.model,
+      name: registeredIdentity.name,
+      cwd: registeredIdentity.cwd,
+      model: registeredIdentity.model,
       pid: process.pid,
-      startedAt: this.identity.startedAt,
+      startedAt: registeredIdentity.startedAt,
       lastActivity: Date.now(),
       status: "idle",
-    }, this.identity.sessionId);
+    }, registeredIdentity.sessionId);
     this.client = client;
+    if (registeredIdentity.name !== this.identity.name || registeredIdentity.model !== this.identity.model) {
+      client.updatePresence({ name: this.identity.name, model: this.identity.model });
+    }
     this.reconnectAttempt = 0;
     return client;
   }
@@ -319,8 +356,18 @@ export class ClaudeIntercomRuntime {
     this.reconnectTimer = null;
   }
 
+  private rejectReplyWaiters(error: Error): void {
+    for (const waiter of this.replyWaiters.values()) {
+      clearTimeout(waiter.timeout);
+      waiter.cleanup?.();
+      waiter.reject(error);
+    }
+    this.replyWaiters.clear();
+  }
+
   async disconnect(): Promise<void> {
     this.reconnectEnabled = false;
+    this.rejectReplyWaiters(new Error("Claude session disconnected while waiting for reply"));
     this.clearReconnectTimer();
     if (this.connectPromise) {
       try {
@@ -398,16 +445,12 @@ export class ClaudeIntercomRuntime {
       this.unresolvedAsks.set(message.id, entry);
     }
 
-    // TUI mode: mirror the message to the session inbox so the plugin monitor
-    // can inject it into the live interactive session. Never let inbox I/O
-    // break normal message handling.
-    const inboxPath = process.env.CLAUDE_INTERCOM_INBOX;
-    if (inboxPath) {
-      try {
-        appendInboxMessage(inboxPath, from, message);
-      } catch {
-        // Best-effort delivery mirror only.
-      }
+    // Ordinary plugin launches and cci share the same inbox/Monitor delivery.
+    // Keep the persistent MCP connection as the sole owner of this identity.
+    try {
+      appendInboxMessage(process.env.CLAUDE_INTERCOM_INBOX || defaultInboxPath(this.identity.sessionId), from, message);
+    } catch {
+      // Best-effort delivery mirror only; never break broker ACK handling.
     }
   }
 
@@ -462,6 +505,13 @@ export class ClaudeIntercomRuntime {
   }
 
   async status(): Promise<ToolResult> {
+    if (this.registrationConflict) {
+      return textResult(`Connected: No\nSession ID: ${this.identity.sessionId}\nRegistration conflict: ${this.registrationConflict.message}\nAutomatic reconnect paused; the incumbent session was not replaced.`, {
+        connected: false, session_id: this.identity.sessionId,
+        registration_conflict: { code: "SESSION_ID_IN_USE", message: this.registrationConflict.message },
+        reconnect_paused: true,
+      }, true);
+    }
     const client = await this.connect();
     const sessions = await client.listSessions();
     return textResult(

package/claude/server.ts

@@ -2,24 +2,56 @@ import readline from "node:readline";
 import { stdin, stdout } from "node:process";
 import { ClaudeIntercomRuntime } from "./runtime.ts";
 import { handleMcpRequest } from "./mcp-protocol.ts";
+import {
+  ClaudeSessionReader, claudeIdentityForSession, claudeSessionMetadataPath,
+  findClaudeHost, waitForClaudeSession,
+} from "./session-lifecycle.ts";
 
-const runtime = new ClaudeIntercomRuntime();
+let shuttingDown = false;
+let stopPolling = () => {};
+let pendingSync = Promise.resolve();
+const report = (error: unknown) => {
+  process.stderr.write(`claude-intercom: ${error instanceof Error ? error.message : String(error)}\n`);
+};
 
-// TUI/live mode (`cci --tui` sets CLAUDE_INTERCOM_INBOX): register on the broker
-// immediately so peers can reach this session and inbound messages flow into the
-// inbox before the first tool call. Otherwise registration is lazy (first tool).
-if (process.env.CLAUDE_INTERCOM_INBOX) {
-  void runtime.connect().catch((error) => {
-    process.stderr.write(`claude-intercom: eager connect failed: ${error instanceof Error ? error.message : String(error)}\n`);
-  });
-}
+// Companion MCP launchers await this same owner to synchronize native titles.
+export const runtimeReady = (async () => {
+  const host = findClaudeHost();
+  const reader = host ? new ClaudeSessionReader(claudeSessionMetadataPath(host), host) : undefined;
+  const metadata = reader ? await waitForClaudeSession(reader) : undefined;
+  const runtime = new ClaudeIntercomRuntime(claudeIdentityForSession(metadata, process.env, host?.pid));
+  // Always register, including ordinary MCP launches. Hook/Monitor processes
+  // never connect to the broker, so there is still exactly one owner.
+  if (!shuttingDown && !metadata?.ended) void runtime.connect().catch(report);
+  if (reader && !shuttingDown) {
+    let previous = JSON.stringify(metadata);
+    let syncing = false;
+    const timer = setInterval(() => {
+      if (syncing || shuttingDown) return;
+      const next = reader.read();
+      const signature = JSON.stringify(next);
+      if (!next || signature === previous) return;
+      previous = signature;
+      syncing = true;
+      pendingSync = (async () => {
+        if (next.ended) await runtime.disconnect();
+        else {
+          await runtime.syncSession(claudeIdentityForSession(next, process.env, host!.pid));
+          await runtime.connect();
+        }
+      })().catch(report).finally(() => { syncing = false; });
+    }, 250);
+    timer.unref();
+    stopPolling = () => clearInterval(timer);
+  }
+  return runtime;
+})();
 
 const rl = readline.createInterface({
   input: stdin,
   crlfDelay: Infinity,
 });
 
-let shuttingDown = false;
 let pendingRequests = 0;
 
 function writeResponse(response: Record<string, unknown> | undefined): void {
@@ -29,7 +61,11 @@ function writeResponse(response: Record<string, unknown> | undefined): void {
 
 function maybeShutdown(): void {
   if (!shuttingDown || pendingRequests > 0) return;
-  void runtime.disconnect().finally(() => process.exit(0));
+  stopPolling();
+  void runtimeReady.then(async (runtime) => {
+    await pendingSync;
+    await runtime.disconnect();
+  }).finally(() => process.exit(0));
 }
 
 rl.on("line", (line) => {
@@ -39,7 +75,7 @@ rl.on("line", (line) => {
   void (async () => {
     try {
       const request = JSON.parse(trimmed);
-      writeResponse(await handleMcpRequest(request, runtime));
+      writeResponse(await handleMcpRequest(request, await runtimeReady));
     } catch (error) {
       writeResponse({
         jsonrpc: "2.0",

package/claude/session-hook.ts

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+import { findClaudeHost, publishClaudeSessionMetadata } from "./session-lifecycle.ts";
+
+// Do not connect to the broker here: short-lived hooks must never compete with
+// the session's persistent MCP runtime for the same stable ID.
+try {
+  const input = JSON.parse(readFileSync(0, "utf8"));
+  const host = findClaudeHost();
+  if (host && input && typeof input === "object" && !Array.isArray(input)) {
+    publishClaudeSessionMetadata(input, host);
+  }
+} catch (error) {
+  process.stderr.write(`claude-intercom hook: ${error instanceof Error ? error.message : String(error)}\n`);
+}