@composer-app/mcp 0.0.1-beta.3 → 0.0.1-beta.5

package/dist/{chunk-VVYEIOFH.js → chunk-A5KBJAJW.js}

@@ -3833,7 +3833,9 @@ function getElementText(el) {
   let out = "";
   for (const child of el.toArray()) {
     if (child instanceof Y2.XmlText) {
-      out += child.toString();
+      for (const op of child.toDelta()) {
+        if (typeof op.insert === "string") out += op.insert;
+      }
     } else if (isXmlElement(child)) {
       out += getElementText(child);
     }
@@ -3879,6 +3881,31 @@ function getOutline(doc) {
   });
   return outline;
 }
+function getSectionBlockRange(doc, headingId) {
+  const blocks = topLevelBlocks(doc);
+  let startIndex = -1;
+  let startLevel = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.nodeName !== "heading") continue;
+    const id = makeHeadingId(getElementText(block), i);
+    if (id === headingId) {
+      startIndex = i;
+      startLevel = getHeadingLevel(block);
+      break;
+    }
+  }
+  if (startIndex === -1) return null;
+  let endIndex = blocks.length;
+  for (let i = startIndex + 1; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.nodeName === "heading" && getHeadingLevel(block) <= startLevel) {
+      endIndex = i;
+      break;
+    }
+  }
+  return { start: startIndex, end: endIndex };
+}
 function getSection(doc, headingId) {
   const blocks = topLevelBlocks(doc);
   let startIndex = -1;
@@ -3922,17 +3949,33 @@ import * as Y3 from "yjs";
 function buildFlatMap(fragment) {
   let flat = "";
   const map = [];
+  const blockFlatStarts = [];
   const walk = (node) => {
     if (node instanceof Y3.XmlText) {
-      const text = node.toString();
-      for (let i = 0; i < text.length; i++) {
-        map.push({
-          xmlText: node,
-          offsetInText: i,
-          flatIndex: flat.length + i
-        });
+      let localOffset = 0;
+      for (const op of node.toDelta()) {
+        const value = op.insert;
+        if (typeof value === "string") {
+          const base = flat.length;
+          for (let i = 0; i < value.length; i++) {
+            map.push({
+              xmlText: node,
+              offsetInText: localOffset + i,
+              flatIndex: base + i
+            });
+          }
+          flat += value;
+          localOffset += value.length;
+        } else if (value !== void 0) {
+          map.push({
+            xmlText: node,
+            offsetInText: localOffset,
+            flatIndex: flat.length
+          });
+          flat += "\uFFFC";
+          localOffset += 1;
+        }
       }
-      flat += text;
       return;
     }
     for (const child of node.toArray()) {
@@ -3943,6 +3986,7 @@ function buildFlatMap(fragment) {
   };
   const topLevel = fragment.toArray();
   topLevel.forEach((node, idx) => {
+    blockFlatStarts.push(flat.length);
     if (node instanceof Y3.XmlText || node instanceof Y3.XmlElement) {
       walk(node);
     }
@@ -3950,7 +3994,7 @@ function buildFlatMap(fragment) {
       flat += "\n";
     }
   });
-  return { flat, map };
+  return { flat, map, blockFlatStarts };
 }
 function findNthOccurrence(flat, needle, n) {
   if (needle.length === 0) return null;
@@ -4068,11 +4112,23 @@ function resolveServerAnchor(doc, spec) {
     return { ok: false, error: "text_not_found", currentSectionText };
   }
   const fragment = doc.getXmlFragment("default");
-  const { flat, map } = buildFlatMap(fragment);
-  const flatStart = findNthOccurrence(flat, spec.textToFind, occurrence);
-  if (flatStart === null) {
+  const { flat, map, blockFlatStarts } = buildFlatMap(fragment);
+  const range = getSectionBlockRange(doc, spec.headingId);
+  if (!range) {
+    return {
+      ok: false,
+      error: "section_not_found",
+      currentSectionText
+    };
+  }
+  const sectionFlatStart = blockFlatStarts[range.start] ?? 0;
+  const sectionFlatEnd = range.end < blockFlatStarts.length ? blockFlatStarts[range.end] : flat.length;
+  const sectionFlat = flat.slice(sectionFlatStart, sectionFlatEnd);
+  const sectionRelStart = findNthOccurrence(sectionFlat, spec.textToFind, occurrence);
+  if (sectionRelStart === null) {
     return { ok: false, error: "text_not_found", currentSectionText };
   }
+  const flatStart = sectionFlatStart + sectionRelStart;
   const flatEnd = flatStart + spec.textToFind.length;
   const startEntry = lookupFlatIndex(map, flatStart);
   if (!startEntry) {
@@ -4116,58 +4172,42 @@ var RoomState = class {
   /**
    * Threads the agent has already written to (created a comment, added a
    * suggestion, or replied). Once a thread is "active", subsequent remote
-   * replies on it are surfaced to the model even if they don't say
-   * `@agent` — the conversation is already in progress, and requiring a
+   * replies on it are surfaced to the model even if they don't name the
+   * agent — the conversation is already in progress, and requiring a
    * re-mention every turn is bad UX.
    */
   activeThreads = /* @__PURE__ */ new Set();
+  /**
+   * Timestamp (ms since epoch) of the most recent non-local transaction on
+   * this doc. Initialized to construction time so a freshly-attached room
+   * with an idle user bails out after the first full timeout window rather
+   * than looking "fresh" forever. Bumped by `attachRemoteActivityTracker`
+   * on every remote edit, comment, suggestion, or activity-feed write.
+   */
+  _lastRemoteActivityAt = Date.now();
+  monitoringOn = false;
+  /**
+   * Set true when `composer_next_event`'s goodbye branch has fired. Tells
+   * `handleNextEvent` to refuse subsequent calls until the user explicitly
+   * re-engages (which happens via `composer_create_room` / `composer_join_room`,
+   * both of which build a fresh `RoomState` so this flag resets naturally).
+   */
+  goodbyeIssued = false;
   constructor(opts) {
     this.roomId = opts.roomId;
     this.actingAs = opts.actingAs;
     this.identity = opts.identity;
     this.watchMentions();
+    attachRemoteActivityTracker(this.doc, {
+      onActivity: (at) => {
+        this._lastRemoteActivityAt = at;
+      }
+    });
     this.provider = new YProvider(opts.serverHost, opts.roomId, this.doc, {
       party: "composer-room",
-      connect: true,
+      connect: false,
       WebSocketPolyfill: WebSocket
     });
-    this.provider.awareness.setLocalStateField("user", {
-      name: opts.actingAs,
-      color: opts.identity.color,
-      userId: opts.identity.userId,
-      isAgent: true
-    });
-    this.installAwarenessHeartbeat();
-  }
-  /**
-   * Re-broadcast the MCP's awareness every 15s.
-   *
-   * y-partyserver's provider disables the y-protocols awareness
-   * `_checkInterval` (see `clearInterval(awareness._checkInterval)` in
-   * `y-partyserver/dist/provider/index.js`), so the MCP sends its awareness
-   * exactly once — on connect — and never heartbeats after that. Combined
-   * with Cloudflare Durable Object hibernation (which evicts the server's
-   * in-memory `document.awareness` Map on wake), this means a browser that
-   * connects more than ~60s after the MCP sees an empty awareness dump in
-   * `onConnect` and never learns the agent is there. The user's own
-   * awareness flows the other direction fine (they send on connect, server
-   * broadcasts to the MCP), which is why the failure is asymmetric.
-   *
-   * y-partyserver's provider listens to `awareness.on("change", ...)`, and
-   * y-protocols only fires `change` when the new state is deep-unequal to
-   * the previous one. Re-setting an identical state emits `update` but NOT
-   * `change`, so the provider never sends a wire frame. We bump a throwaway
-   * `_hb` field each tick to guarantee deep-inequality, forcing the change
-   * event and a broadcast. 15s is well under any realistic hibernation gap.
-   */
-  installAwarenessHeartbeat() {
-    const heartbeat = setInterval(() => {
-      const local = this.provider.awareness.getLocalState();
-      if (local !== null) {
-        this.provider.awareness.setLocalState({ ...local, _hb: Date.now() });
-      }
-    }, 15e3);
-    heartbeat.unref?.();
   }
   /**
    * Resolves when the provider has completed its first sync handshake.
@@ -4195,6 +4235,117 @@ var RoomState = class {
       this.provider.on("sync", onSync);
     });
   }
+  idleDisconnectTimer = null;
+  /**
+   * Open the WebSocket (if not already) and await the first sync handshake.
+   * Idempotent — no-op if already connected and synced. Call at the top of
+   * every tool handler that touches the doc. Cancels any pending idle
+   * disconnect because we're back in active use.
+   */
+  async ensureConnected(timeoutMs = 15e3) {
+    if (this.idleDisconnectTimer) {
+      clearTimeout(this.idleDisconnectTimer);
+      this.idleDisconnectTimer = null;
+    }
+    if (this.provider.wsconnected && this.provider.synced) return;
+    await this.provider.connect();
+    await this.waitForInitialSync(timeoutMs);
+  }
+  /**
+   * Arm a timer that turns monitoring off and closes the socket after `ms`
+   * of no further tool-handler activity. Cancelled by `ensureConnected`.
+   * Call at the end of every tool handler. Defaults to 30s — long enough
+   * to bridge a normal multi-step monitor turn (mention → reply →
+   * `composer_next_event` again), short enough that an abandoned monitor
+   * loop fades the avatar within the "within a minute" window the user
+   * requested.
+   *
+   * Both presence cleanup paths converge here: setMonitoring(false) clears
+   * our local awareness state, then disconnect() closes the socket which
+   * triggers y-partyserver's onClose → removeAwarenessStates. Either alone
+   * would suffice; doing both keeps local and server state consistent.
+   */
+  scheduleIdleDisconnect(ms = 3e4) {
+    if (this.idleDisconnectTimer) {
+      clearTimeout(this.idleDisconnectTimer);
+      this.idleDisconnectTimer = null;
+    }
+    if (!this.provider.wsconnected) return;
+    this.idleDisconnectTimer = setTimeout(() => {
+      this.idleDisconnectTimer = null;
+      this.setMonitoring(false);
+      this.provider.disconnect();
+    }, ms);
+    this.idleDisconnectTimer.unref?.();
+  }
+  /**
+   * Close the socket immediately. Available for explicit teardown
+   * (e.g., destroy()). Does not touch monitoring state — the socket close
+   * causes y-partyserver to broadcast the awareness removal, which is the
+   * visual signal peers care about.
+   */
+  disconnect() {
+    if (this.idleDisconnectTimer) {
+      clearTimeout(this.idleDisconnectTimer);
+      this.idleDisconnectTimer = null;
+    }
+    this.provider.disconnect();
+  }
+  /**
+   * Toggle whether the agent is visibly monitoring the room. Broadcast via
+   * the `user` awareness field — present ↔ avatar visible to peers. The
+   * socket must already be open (caller should have ensured this).
+   *
+   *   setMonitoring(true)  — called once on first composer_next_event entry.
+   *   setMonitoring(false) — called on the goodbye branch; clears awareness
+   *                          immediately so the avatar disappears as the
+   *                          farewell lands.
+   *
+   * Subsequent calls with the same value are no-ops.
+   */
+  setMonitoring(on) {
+    if (this.monitoringOn === on) return;
+    this.monitoringOn = on;
+    if (on) {
+      const current = this.provider.awareness.getLocalState() ?? {};
+      this.provider.awareness.setLocalState({
+        ...current,
+        user: {
+          name: this.actingAs,
+          color: this.identity.color,
+          userId: this.identity.userId,
+          isAgent: true
+        }
+      });
+    } else {
+      this.provider.awareness.setLocalState(null);
+    }
+  }
+  get isMonitoring() {
+    return this.monitoringOn;
+  }
+  /**
+   * Latch flipped by `composer_next_event`'s goodbye branch. Once set, the
+   * model is expected to stop calling `composer_next_event` until the user
+   * explicitly asks to rejoin — which builds a fresh RoomState, resetting
+   * the latch. The MCP refuses further next_event calls on this RoomState
+   * instead of silently re-entering the monitor loop.
+   */
+  markGoodbyeIssued() {
+    this.goodbyeIssued = true;
+  }
+  get hasIssuedGoodbye() {
+    return this.goodbyeIssued;
+  }
+  /**
+   * Read-only view of this client's local awareness state. Exposed for
+   * tests/diagnostics only — production code should not depend on this.
+   * Returns `null` when monitoring is off (local state cleared) or when
+   * the provider hasn't written any fields yet.
+   */
+  getLocalAwareness() {
+    return this.provider.awareness.getLocalState();
+  }
   snapshot() {
     return {
       fullDoc: serializeDocAsMarkdown(this.doc),
@@ -4203,34 +4354,53 @@ var RoomState = class {
       threadsBacklog: []
     };
   }
-  async nextEvent(timeoutMs) {
+  async nextEvent(timeoutMs, signal) {
     const pending = this.queue.shift();
     if (pending) return pending;
+    if (signal?.aborted) return { kind: "timeout" };
     return new Promise((resolve) => {
-      const timer = setTimeout(() => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
         const idx = this.waiters.indexOf(waiter);
         if (idx >= 0) this.waiters.splice(idx, 1);
+      };
+      const timer = setTimeout(() => {
+        cleanup();
         resolve({ kind: "timeout" });
       }, timeoutMs);
+      const onAbort = () => {
+        cleanup();
+        resolve({ kind: "timeout" });
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
       const waiter = (ev) => {
-        clearTimeout(timer);
+        cleanup();
         resolve(ev);
       };
       this.waiters.push(waiter);
     });
   }
   destroy() {
+    if (this.idleDisconnectTimer) {
+      clearTimeout(this.idleDisconnectTimer);
+      this.idleDisconnectTimer = null;
+    }
     this.provider.destroy();
     this.doc.destroy();
   }
   /**
    * Mark a thread as active so subsequent remote replies on it surface as
-   * mentions even without an explicit `@agent`. Called by MCP write-tool
-   * handlers right after the agent creates or replies on a thread.
+   * mentions even without an explicit mention of this agent. Called by MCP
+   * write-tool handlers right after the agent creates or replies on a thread.
    */
   markThreadActive(threadId) {
     this.activeThreads.add(threadId);
   }
+  /** Timestamp (ms) of the most recent non-local transaction on this doc. */
+  get lastRemoteActivityAt() {
+    return this._lastRemoteActivityAt;
+  }
   enqueue(ev) {
     const waiter = this.waiters.shift();
     if (waiter) waiter(ev);
@@ -4241,20 +4411,60 @@ var RoomState = class {
       enqueue: (ev) => this.enqueue(ev),
       seen: this.seen,
       activeThreads: this.activeThreads,
-      identityUserId: this.identity.userId
+      identityUserId: this.identity.userId,
+      actingAs: this.actingAs,
+      getSoloHumanAuthorId: () => this.computeSoloHumanAuthorId()
     });
   }
+  /**
+   * Read the provider's awareness map and decide whether the room is "solo"
+   * right now — exactly one agent (us) and exactly one human. Returns the
+   * sole human's `userId` in that case, else `undefined`. Any other shape
+   * (multiple humans, multiple agents, empty, no `user` payload) returns
+   * `undefined` so the observer stays silent unless the gate passes.
+   */
+  computeSoloHumanAuthorId() {
+    const states = this.provider.awareness.getStates();
+    let humanCount = 0;
+    let agentCount = 0;
+    let soloHuman;
+    for (const state of states.values()) {
+      const user = state?.user;
+      if (!user || typeof user.userId !== "string") continue;
+      if (user.isAgent) {
+        agentCount++;
+      } else {
+        humanCount++;
+        soloHuman = user.userId;
+      }
+    }
+    if (humanCount !== 1 || agentCount !== 1) return void 0;
+    return soloHuman;
+  }
 };
-var AGENT_MENTION_RE = /@agent/i;
-var hasAgentMention = (text) => AGENT_MENTION_RE.test(text);
+function buildActingAsMatcher(actingAs) {
+  if (!actingAs) return () => false;
+  const escaped = actingAs.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`@${escaped}(?![\\w])`, "i");
+  return (text) => re.test(text);
+}
+function checkMentionsSidecar(mentions, identityUserId) {
+  if (!Array.isArray(mentions) || mentions.length === 0) return "absent";
+  if (identityUserId && mentions.includes(identityUserId)) return "hit";
+  return "miss";
+}
+var ANY_AT_MENTION_RE = /@\w/;
 function attachMentionObserver(doc, opts) {
   const seen = opts.seen ?? /* @__PURE__ */ new Set();
   const activeThreads = opts.activeThreads ?? /* @__PURE__ */ new Set();
   const enqueue = opts.enqueue;
   const identityUserId = opts.identityUserId;
+  const hasActingAsMention = buildActingAsMatcher(opts.actingAs);
+  const getSoloHumanAuthorId = opts.getSoloHumanAuthorId ?? (() => void 0);
   const scan = (kind, threadId, entry, isLocal) => {
     if (!entry || typeof entry !== "object") return;
     const record = entry;
+    const bodyAuthorUserId = typeof record.authorUserId === "string" ? record.authorUserId : void 0;
     const replies = Array.isArray(record.replies) ? record.replies : [];
     let lastAgentIdx = -1;
     if (identityUserId !== void 0) {
@@ -4268,7 +4478,9 @@ function attachMentionObserver(doc, opts) {
     }
     const bodyAnswered = lastAgentIdx >= 0;
     const body = typeof record.text === "string" ? record.text : typeof record.replacementText === "string" ? record.replacementText : "";
-    if (hasAgentMention(body) && !seen.has(threadId)) {
+    const bodySidecar = checkMentionsSidecar(record.mentions, identityUserId);
+    const bodyHit = bodySidecar === "hit" || bodySidecar === "absent" && hasActingAsMention(body);
+    if (bodyHit && !seen.has(threadId)) {
       seen.add(threadId);
       if (!isLocal && !bodyAnswered) {
         enqueue({
@@ -4280,6 +4492,19 @@ function attachMentionObserver(doc, opts) {
           ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo)
         });
       }
+    } else if (!seen.has(threadId) && !isLocal && !bodyAnswered && bodySidecar !== "miss" && !ANY_AT_MENTION_RE.test(body)) {
+      const soloHuman = getSoloHumanAuthorId();
+      if (soloHuman && bodyAuthorUserId === soloHuman) {
+        seen.add(threadId);
+        enqueue({
+          kind: "mention",
+          threadId,
+          threadKind: kind,
+          threadText: body,
+          reason: "solo_room",
+          ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo)
+        });
+      }
     }
     for (let i = 0; i < replies.length; i++) {
       const r = replies[i];
@@ -4292,16 +4517,25 @@ function attachMentionObserver(doc, opts) {
       seen.add(key);
       if (isLocal) continue;
       if (i <= lastAgentIdx) continue;
-      const isDirect = hasAgentMention(reply.text);
+      const replySidecar = checkMentionsSidecar(reply.mentions, identityUserId);
+      const isDirect = replySidecar === "hit" || replySidecar === "absent" && hasActingAsMention(reply.text);
       const inActiveThread = activeThreads.has(threadId);
-      if (!isDirect && !inActiveThread) continue;
+      let reason = isDirect ? "direct_mention" : inActiveThread ? "active_thread" : null;
+      if (!reason) {
+        const replyAuthor = typeof reply.authorUserId === "string" ? reply.authorUserId : void 0;
+        const soloHuman = getSoloHumanAuthorId();
+        if (replySidecar !== "miss" && !ANY_AT_MENTION_RE.test(reply.text) && soloHuman && replyAuthor === soloHuman) {
+          reason = "solo_room";
+        }
+      }
+      if (!reason) continue;
       enqueue({
         kind: "mention",
         threadId,
         threadKind: kind,
         threadText: reply.text,
         replyId: reply.id,
-        reason: isDirect ? "direct_mention" : "active_thread",
+        reason,
         ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo)
       });
     }
@@ -4320,6 +4554,12 @@ function attachMentionObserver(doc, opts) {
 function hashState(doc) {
   return Buffer.from(Y4.encodeStateVector(doc)).toString("base64");
 }
+function attachRemoteActivityTracker(doc, opts) {
+  const now = opts.now ?? (() => Date.now());
+  doc.on("afterTransaction", (tr) => {
+    if (!tr.local) opts.onActivity(now());
+  });
+}
 
 // src/identity.ts
 import * as fs from "fs/promises";
@@ -4352,7 +4592,9 @@ function pickColor() {
 function isValidIdentity(value) {
   if (typeof value !== "object" || value === null) return false;
   const v = value;
-  return typeof v.userId === "string" && typeof v.color === "string";
+  if (typeof v.userId !== "string" || typeof v.color !== "string") return false;
+  if (v.name !== void 0 && typeof v.name !== "string") return false;
+  return true;
 }
 async function loadOrCreateIdentity(dir) {
   const filePath = path.join(dir, FILE_NAME);
@@ -4360,18 +4602,16 @@ async function loadOrCreateIdentity(dir) {
     const raw = await fs.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (isValidIdentity(parsed)) {
-      if (isPaletteColor(parsed.color)) {
-        return { userId: parsed.userId, color: parsed.color };
-      }
-      const migrated = {
+      const base = {
         userId: parsed.userId,
-        color: pickColor()
+        color: isPaletteColor(parsed.color) ? parsed.color : pickColor(),
+        ...parsed.name ? { name: parsed.name } : {}
       };
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(filePath, JSON.stringify(migrated, null, 2), {
-        mode: FILE_MODE
-      });
-      return migrated;
+      if (base.color === parsed.color) {
+        return base;
+      }
+      await saveIdentity(dir, base);
+      return base;
     }
   } catch (err) {
     const code = err.code;
@@ -4382,11 +4622,15 @@ async function loadOrCreateIdentity(dir) {
     userId: nanoid2(),
     color: pickColor()
   };
+  await saveIdentity(dir, identity);
+  return identity;
+}
+async function saveIdentity(dir, identity) {
+  const filePath = path.join(dir, FILE_NAME);
   await fs.mkdir(dir, { recursive: true });
   await fs.writeFile(filePath, JSON.stringify(identity, null, 2), {
     mode: FILE_MODE
   });
-  return identity;
 }
 
 // src/mdToFragment.ts
@@ -4458,12 +4702,48 @@ var SERVER_HOST = process.env.COMPOSER_SERVER_HOST ?? "usecomposer.app";
 var APP_BASE = process.env.COMPOSER_APP_BASE ?? "https://usecomposer.app";
 var rooms = /* @__PURE__ */ new Map();
 var identityCache = null;
+function teardownAllRooms() {
+  for (const [roomId, state] of rooms) {
+    try {
+      state.setMonitoring(false);
+      state.disconnect();
+      state.destroy();
+    } catch (err) {
+      logError(`teardown error for room ${roomId}`, err);
+    }
+  }
+  rooms.clear();
+}
 async function getIdentity() {
   if (!identityCache) {
     identityCache = await loadOrCreateIdentity(COMPOSER_DIR2);
   }
   return identityCache;
 }
+async function resolveActingAs(actingAsArg) {
+  const identity = await getIdentity();
+  if (identity.name) return { actingAs: identity.name, isFirstRun: false };
+  if (!actingAsArg) {
+    throw new Error(
+      [
+        "First Composer room on this machine \u2014 you need a persistent name before proceeding. STOP and ask the user what to call you.",
+        "",
+        "Offer ONE suggested default they can accept with a tap:",
+        `  - If you know the user's first name from conversation context, suggest "<FirstName>'s Agent" (e.g. "Josh's Agent").`,
+        "  - Otherwise pick something playful from outside the model-family space (e.g. Monty, Gerty, Rosie, Otto, Pip). Do NOT suggest Claude / Gemini / GPT / Sonnet / Opus / Haiku / other model names.",
+        "",
+        `Phrase it like: "I'll go by <suggested name> in Composer docs \u2014 sound good, or pick your own?"`,
+        "",
+        "Retry with their answer as `actingAs`. It persists to ~/.composer/user.json and is reused for every future room on this machine, so only ask once."
+      ].join("\n")
+    );
+  }
+  const next = { ...identity, name: actingAsArg };
+  await saveIdentity(COMPOSER_DIR2, next);
+  identityCache = next;
+  log("agent name persisted", { name: actingAsArg, userId: identity.userId });
+  return { actingAs: actingAsArg, isFirstRun: true };
+}
 function getOrError(roomId) {
   const state = rooms.get(roomId);
   if (!state) throw new Error(`not attached to room: ${roomId}`);
@@ -4482,7 +4762,7 @@ function parseRoomIdFromUrl(url) {
 var TOOL_DEFS = [
   {
     name: "composer_create_room",
-    description: "Create a new Composer room. Returns { roomId, browserUrl, snapshot }. Seed the doc by passing either `seedMarkdownPath` (absolute path to a markdown file on disk \u2014 preferred when the markdown already lives in a file, avoids streaming the content through the model) OR `seedMarkdown` (inline string, for content you generated in-turn). Pass exactly one. The seed file is read once at creation and never written back \u2014 edits in Composer stay in the room.",
+    description: "Create a new Composer room. Returns { roomId, browserUrl, snapshot, actingAs, step1_sayToUser, step2_callTool }. EXECUTE step1 AND step2 IN ORDER before ending your turn: first output `step1_sayToUser` (it contains the browserUrl \u2014 the user needs that link or they can't open the doc), then call the tool named in `step2_callTool`. Skipping step2 means your agent is silent in the room; skipping step1 means the user has no way in. Seed the doc by passing either `seedMarkdownPath` (absolute path to a markdown file on disk \u2014 preferred when the markdown already lives in a file, avoids streaming the content through the model) OR `seedMarkdown` (inline string, for content you generated in-turn). Pass exactly one. The seed file is read once at creation and never written back \u2014 edits in Composer stay in the room.",
     inputSchema: {
       type: "object",
       properties: {
@@ -4497,22 +4777,24 @@ var TOOL_DEFS = [
         },
         actingAs: {
           type: "string",
-          description: `Agent display name for this room, e.g. "Josh's Agent".`
+          description: 'Your display name in the doc. FIRST-RUN FLOW: if you haven\'t saved a name yet, do NOT guess \u2014 call without `actingAs`, the MCP returns an error that instructs you to ask the user. Ask them ("what should I be called in Composer?") and retry with their answer. The name persists to ~/.composer/user.json. OPTIONAL on subsequent calls \u2014 the stored name wins and any value here is ignored.'
         }
-      },
-      required: ["actingAs"]
+      }
     }
   },
   {
     name: "composer_join_room",
-    description: "Join an existing Composer room by browser URL. Returns the attach snapshot.",
+    description: "Join an existing Composer room by browser URL. Returns { roomId, browserUrl, snapshot, actingAs, step1_sayToUser, step2_callTool }. EXECUTE step1 AND step2 IN ORDER before ending your turn: first output `step1_sayToUser` (it contains the browserUrl so the user can confirm which doc you joined), then call the tool named in `step2_callTool`. Skipping step2 means your agent is silent in the room; skipping step1 leaves the user guessing which doc you landed in.",
     inputSchema: {
       type: "object",
       properties: {
         url: { type: "string" },
-        actingAs: { type: "string" }
+        actingAs: {
+          type: "string",
+          description: "Your display name in the doc. FIRST-RUN FLOW: if you haven't saved a name yet, call without `actingAs`, get the error, ASK THE USER what to be called, then retry with their answer. Persists to ~/.composer/user.json. OPTIONAL on subsequent calls \u2014 the stored name wins."
+        }
       },
-      required: ["url", "actingAs"]
+      required: ["url"]
     }
   },
   {
@@ -4526,12 +4808,12 @@ var TOOL_DEFS = [
   },
   {
     name: "composer_next_event",
-    description: "Block until a remote @agent mention arrives or the timeout elapses.",
+    description: "Block for up to `timeoutSec` (default 30s) waiting for a remote event. Returns `{ kind: 'mention' | 'timeout', ... }`. **The monitor loop is always-on** \u2014 every return carries a directive you must follow without waiting for user input. On `mention`, the `reason` is one of: `direct_mention` (sidecar or text named you \u2014 always reply), `active_thread` (plain reply on a thread you're already in \u2014 reply if the content invites one), or `solo_room` (you're alone with one human who didn't explicitly tag anyone \u2014 default to a helpful reply, but skip if the text reads like a note-to-self, acknowledgement, or aside). Handle the event, then execute the return's `requiredNextToolCall`. On `timeout`, `recentActivity` tells you whether to keep monitoring or exit with the goodbye line from `userMessage`.",
     inputSchema: {
       type: "object",
       properties: {
         roomId: { type: "string" },
-        timeoutSec: { type: "number", default: 300 }
+        timeoutSec: { type: "number", default: 30 }
       },
       required: ["roomId"]
     }
@@ -4557,9 +4839,21 @@ var TOOL_DEFS = [
       required: ["roomId"]
     }
   },
+  {
+    name: "composer_get_thread",
+    description: "Read the full state of a comment or suggestion thread by id. Returns the body (or replacementText), every reply (with author, text, timestamp, optional mentions sidecar), the thread's anchored text, and the containing section as markdown. Use when `composer_next_event` surfaces an event and you need history: the event only gives you the triggering message, so call this to catch up on everything said before you were tagged.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        roomId: { type: "string" },
+        threadId: { type: "string" }
+      },
+      required: ["roomId", "threadId"]
+    }
+  },
   {
     name: "composer_add_comment",
-    description: "Post a comment anchored to a text span. Anchor is { headingId, textToFind, occurrence? }. Returns { id } on success or an isError result if the anchor cannot be resolved.",
+    description: "Post a new top-level comment anchored to a text span anywhere in the doc. Anchor is { headingId, textToFind, occurrence? }. Use this to flag something the user didn't ask about \u2014 cross-referencing related sections, raising a concern elsewhere in the doc, or seeding a thread on a new span. Use `composer_reply_comment` instead when continuing an existing thread. Returns { id } on success or an isError result if the anchor cannot be resolved.",
     inputSchema: {
       type: "object",
       properties: {
@@ -4593,7 +4887,7 @@ var TOOL_DEFS = [
   },
   {
     name: "composer_add_suggestion",
-    description: "Post a text replacement suggestion. When responding to a thread, default to passing fromThreadId \u2014 the suggestion inherits the source thread's exact stored anchor, which is the right span whenever the user's request is scoped to what they selected (the common case). Supply an `anchor` instead when the user's request explicitly targets a different span (e.g. they highlight one word but ask to rewrite the whole paragraph), or for proactive suggestions with no source thread. Pick one: supplying both is rejected. Returns { id } on success or an isError result if the anchor cannot be resolved.",
+    description: "Post a text replacement suggestion. A suggestion can target ANY span anywhere in the doc \u2014 not just the span of the thread that triggered you. Pick exactly one of:\n  - `fromThreadId` \u2014 inherit the source thread's exact stored anchor. Right when the user's request is scoped to what they selected (the common case: 'rewrite this', 'make this shorter').\n  - `anchor` \u2014 specify a span yourself via `{ headingId, textToFind, occurrence? }`. Use this when the user's request targets different text ('also update the intro', 'the bullet list in Section 3 is stale') OR for proactive suggestions with no source thread.\n**Anchor = what gets deleted.** Your `textToFind` is literally cut when the user accepts and `replacementText` is inserted in its place. Anchor the whole unit you're changing (full sentence including terminal punctuation; full list item text; full paragraph), match your replacementText's shape (inline for mid-paragraph edits, full markdown block for block replacements), end replacement at the same boundary as the anchor, and include any formatting you want preserved in the replacement itself \u2014 the anchor's bold / link / heading level is gone on accept. A too-narrow or mid-token anchor leaves broken spacing or smashed-together words. See SKILL.md 'Pick the right span' for the full rubric.\n**Ripple coverage is your responsibility.** If the change requires edits nearby or elsewhere (enumeration counts, cross-references, subject/verb agreement, restated facts), call this tool MULTIPLE times in the same turn \u2014 one suggestion per span \u2014 so accepting leaves the doc correct. If you're unsure whether ripples exist elsewhere in the doc, call `composer_get_full_doc` first. Returns { id } on success or an isError result if the anchor cannot be resolved.",
     inputSchema: {
       type: "object",
       properties: {
@@ -4688,9 +4982,25 @@ function asAnchor(value) {
   }
   return { headingId, textToFind, occurrence };
 }
+function buildMonitorHandoff(roomId, browserUrl, actingAs, opts) {
+  const mention = `@${actingAs}`;
+  const step1_sayToUser = opts.isFirstRun ? `${browserUrl}
+
+First time using Composer? Here's how it works: I'm monitoring this doc right here in your terminal. Reach me anytime by tagging ${mention} in any comment or reply \u2014 I'll answer right in the thread, and I can also post suggestions you accept or reject inline.` : `${browserUrl}
+
+I'm monitoring this doc from the terminal \u2014 tag me with ${mention} in any comment and I'll reply right there.`;
+  return {
+    step1_sayToUser,
+    step2_callTool: {
+      tool: "composer_next_event",
+      args: { roomId },
+      why: "MANDATORY and STRICTLY AFTER step 1. First output `step1_sayToUser` to the user \u2014 they need the URL to open the doc \u2014 THEN call this tool. The room is attached but NOT being watched until you enter the composer_next_event loop. Two failure modes to avoid: (a) outputting 'I'm monitoring' without calling this tool = silent agent; (b) calling this tool without first outputting the URL = user has no way in."
+    }
+  };
+}
 async function handleCreateRoom(args) {
   const a = asObject(args);
-  const actingAs = asString(a.actingAs, "actingAs");
+  const actingAsArg = asOptionalString(a.actingAs, "actingAs");
   const seedMarkdownInline = asOptionalString(a.seedMarkdown, "seedMarkdown");
   const seedMarkdownPath = asOptionalString(
     a.seedMarkdownPath,
@@ -4716,44 +5026,76 @@ async function handleCreateRoom(args) {
       return errorResult(`failed to read seedMarkdownPath: ${message}`);
     }
   }
+  const { actingAs, isFirstRun } = await resolveActingAs(actingAsArg);
   const identity = await getIdentity();
   const roomId = nanoid3(10);
+  const browserUrl = browserUrlFor(roomId);
   const state = new RoomState({
     roomId,
     serverHost: SERVER_HOST,
     actingAs,
     identity
   });
-  await state.waitForInitialSync();
+  await state.ensureConnected();
   if (seedMarkdown) {
     writeMarkdownToFragment(state.doc.getXmlFragment("default"), seedMarkdown);
   }
   rooms.set(roomId, state);
+  log(`composer room created \u2192 ${browserUrl}`, { roomId, actingAs });
+  state.scheduleIdleDisconnect(3e4);
   return okResult({
     roomId,
-    browserUrl: browserUrlFor(roomId),
-    snapshot: state.snapshot()
+    browserUrl,
+    actingAs,
+    snapshot: state.snapshot(),
+    ...buildMonitorHandoff(roomId, browserUrl, actingAs, { isFirstRun })
   });
 }
 async function handleJoinRoom(args) {
   const a = asObject(args);
   const url = asString(a.url, "url");
-  const actingAs = asString(a.actingAs, "actingAs");
+  const actingAsArg = asOptionalString(a.actingAs, "actingAs");
   const roomId = parseRoomIdFromUrl(url);
-  const identity = await getIdentity();
+  const browserUrl = browserUrlFor(roomId);
   const existing = rooms.get(roomId);
   if (existing) {
-    return okResult({ roomId, snapshot: existing.snapshot() });
+    log(`composer room rejoined \u2192 ${browserUrl}`, {
+      roomId,
+      actingAs: existing.actingAs
+    });
+    existing.scheduleIdleDisconnect(3e4);
+    return okResult({
+      roomId,
+      browserUrl,
+      actingAs: existing.actingAs,
+      snapshot: existing.snapshot(),
+      // Rejoining a room already attached in this process is never a
+      // first-run situation — we already wrote a name to disk at least
+      // once in this process lifetime to have created `existing`.
+      ...buildMonitorHandoff(roomId, browserUrl, existing.actingAs, {
+        isFirstRun: false
+      })
+    });
   }
+  const { actingAs, isFirstRun } = await resolveActingAs(actingAsArg);
+  const identity = await getIdentity();
   const state = new RoomState({
     roomId,
     serverHost: SERVER_HOST,
     actingAs,
     identity
   });
-  await state.waitForInitialSync();
+  await state.ensureConnected();
   rooms.set(roomId, state);
-  return okResult({ roomId, snapshot: state.snapshot() });
+  log(`composer room joined \u2192 ${browserUrl}`, { roomId, actingAs });
+  state.scheduleIdleDisconnect(3e4);
+  return okResult({
+    roomId,
+    browserUrl,
+    actingAs,
+    snapshot: state.snapshot(),
+    ...buildMonitorHandoff(roomId, browserUrl, actingAs, { isFirstRun })
+  });
 }
 function handleAttachRoom(args) {
   const a = asObject(args);
@@ -4761,13 +5103,76 @@ function handleAttachRoom(args) {
   const state = getOrError(roomId);
   return okResult({ roomId, snapshot: state.snapshot() });
 }
-async function handleNextEvent(args) {
+var ACTIVITY_WINDOW_MS = (() => {
+  const raw = process.env.COMPOSER_ACTIVITY_WINDOW_MS;
+  if (!raw) return 15 * 60 * 1e3;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : 15 * 60 * 1e3;
+})();
+var LEAVE_MESSAGE = "I've left the document. You can ask me to rejoin anytime and I'll continue replying.";
+async function handleNextEvent(args, signal) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
-  const timeoutSec = typeof a.timeoutSec === "number" && Number.isFinite(a.timeoutSec) ? a.timeoutSec : 300;
+  const timeoutSec = typeof a.timeoutSec === "number" && Number.isFinite(a.timeoutSec) ? a.timeoutSec : 30;
   const state = getOrError(roomId);
-  const event = await state.nextEvent(timeoutSec * 1e3);
-  return okResult(event);
+  if (state.hasIssuedGoodbye) {
+    return errorResult(
+      "Already said goodbye for this room. The user must explicitly ask you to rejoin (which will trigger a fresh `composer_join_room`). Do not call `composer_next_event` again on this roomId."
+    );
+  }
+  state.setMonitoring(true);
+  const onAbort = () => {
+    state.setMonitoring(false);
+    state.disconnect();
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  let event;
+  try {
+    event = await state.nextEvent(timeoutSec * 1e3, signal);
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+  }
+  if (signal?.aborted) {
+    return okResult({ kind: "aborted" });
+  }
+  if (event.kind === "mention") {
+    return okResult({
+      ...event,
+      requiredNextToolCall: {
+        tool: "composer_next_event",
+        args: { roomId },
+        why: "MANDATORY \u2014 call this immediately after you've posted your reply / suggestion / resolve. The monitor loop is always-on; ending your turn without this call drops you out of the room and the user will think you stopped listening."
+      }
+    });
+  }
+  const msSinceActivity = Date.now() - state.lastRemoteActivityAt;
+  const recentActivity = msSinceActivity < ACTIVITY_WINDOW_MS;
+  const minutesSince = Math.max(1, Math.round(msSinceActivity / 6e4));
+  if (recentActivity) {
+    return okResult({
+      kind: "timeout",
+      recentActivity: true,
+      secondsSinceActivity: Math.round(msSinceActivity / 1e3),
+      requiredNextToolCall: {
+        tool: "composer_next_event",
+        args: { roomId },
+        why: `MANDATORY \u2014 call this immediately. The user was active in the doc ~${minutesSince} minute${minutesSince === 1 ? "" : "s"} ago; do NOT exit the monitor loop.`
+      }
+    });
+  }
+  state.setMonitoring(false);
+  state.disconnect();
+  state.markGoodbyeIssued();
+  return okResult({
+    kind: "timeout",
+    recentActivity: false,
+    secondsSinceActivity: Math.round(msSinceActivity / 1e3),
+    userMessage: LEAVE_MESSAGE,
+    instruction: `Say \`userMessage\` EXACTLY as written \u2014 do not paraphrase the goodbye. Then stop calling composer_next_event until the user asks you to rejoin. No requiredNextToolCall field: the loop is intentionally over.`
+  });
 }
 function handleGetSection(args) {
   const a = asObject(args);
@@ -4783,6 +5188,55 @@ function handleGetFullDoc(args) {
   const state = getOrError(roomId);
   return okResult({ markdown: serializeDocAsMarkdown(state.doc) });
 }
+function handleGetThread(args) {
+  const a = asObject(args);
+  const roomId = asString(a.roomId, "roomId");
+  const threadId = asString(a.threadId, "threadId");
+  const state = getOrError(roomId);
+  const commentRaw = state.doc.getMap("comments").get(threadId);
+  const suggestionRaw = state.doc.getMap("suggestions").get(threadId);
+  const raw = commentRaw ?? suggestionRaw;
+  if (!raw) {
+    return errorResult(`thread not found: ${threadId}`);
+  }
+  const kind = commentRaw ? "comment" : "suggestion";
+  const anchoredContext = resolveAnchoredContext(
+    state.doc,
+    raw.anchorFrom,
+    raw.anchorTo
+  );
+  const replies = Array.isArray(raw.replies) ? raw.replies : [];
+  const shapedReplies = replies.filter(
+    (r) => !!r && typeof r === "object" && typeof r.id === "string" && typeof r.text === "string"
+  ).map((r) => ({
+    id: r.id,
+    text: r.text,
+    authorName: typeof r.authorName === "string" ? r.authorName : void 0,
+    authorUserId: typeof r.authorUserId === "string" ? r.authorUserId : void 0,
+    authorIsAgent: typeof r.authorIsAgent === "boolean" ? r.authorIsAgent : void 0,
+    mentions: Array.isArray(r.mentions) ? r.mentions.filter((m) => typeof m === "string") : void 0,
+    createdAt: typeof r.createdAt === "number" ? r.createdAt : void 0
+  }));
+  return okResult({
+    threadId,
+    kind,
+    body: typeof raw.text === "string" ? raw.text : void 0,
+    replacementText: kind === "suggestion" && typeof raw.replacementText === "string" ? raw.replacementText : void 0,
+    originalText: kind === "suggestion" && typeof raw.originalText === "string" ? raw.originalText : void 0,
+    authorName: typeof raw.authorName === "string" ? raw.authorName : void 0,
+    authorUserId: typeof raw.authorUserId === "string" ? raw.authorUserId : void 0,
+    authorIsAgent: typeof raw.authorIsAgent === "boolean" ? raw.authorIsAgent : void 0,
+    createdAt: typeof raw.createdAt === "number" ? raw.createdAt : void 0,
+    resolved: kind === "comment" && typeof raw.resolved === "boolean" ? raw.resolved : void 0,
+    status: kind === "suggestion" && (raw.status === "pending" || raw.status === "accepted" || raw.status === "rejected") ? raw.status : void 0,
+    mentions: Array.isArray(raw.mentions) ? raw.mentions.filter((m) => typeof m === "string") : void 0,
+    anchoredText: anchoredContext.anchoredText,
+    headingId: anchoredContext.headingId,
+    headingText: anchoredContext.headingText,
+    sectionMarkdown: anchoredContext.sectionMarkdown,
+    replies: shapedReplies
+  });
+}
 function handleAddComment(args) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
@@ -4944,32 +5398,44 @@ function handleResolveThread(args) {
   comments.set(threadId, { ...existing, resolved: true });
   return okResult({ threadId, resolved: true });
 }
-async function dispatchTool(name, args) {
-  switch (name) {
-    case "composer_create_room":
-      return handleCreateRoom(args);
-    case "composer_join_room":
-      return handleJoinRoom(args);
-    case "composer_attach_room":
-      return handleAttachRoom(args);
-    case "composer_next_event":
-      return handleNextEvent(args);
-    case "composer_get_section":
-      return handleGetSection(args);
-    case "composer_get_full_doc":
-      return handleGetFullDoc(args);
-    case "composer_add_comment":
-      return handleAddComment(args);
-    case "composer_reply_comment":
-      return handleReplyComment(args);
-    case "composer_add_suggestion":
-      return handleAddSuggestion(args);
-    case "composer_reply_suggestion":
-      return handleReplySuggestion(args);
-    case "composer_resolve_thread":
-      return handleResolveThread(args);
-    default:
-      return errorResult(`unknown tool: ${name}`);
+async function dispatchTool(name, args, signal) {
+  const roomId = args && typeof args === "object" && "roomId" in args ? args.roomId : void 0;
+  const needsExistingRoom = name !== "composer_create_room" && name !== "composer_join_room";
+  const state = needsExistingRoom && typeof roomId === "string" ? rooms.get(roomId) : void 0;
+  if (state) {
+    await state.ensureConnected();
+  }
+  try {
+    switch (name) {
+      case "composer_create_room":
+        return await handleCreateRoom(args);
+      case "composer_join_room":
+        return await handleJoinRoom(args);
+      case "composer_attach_room":
+        return handleAttachRoom(args);
+      case "composer_next_event":
+        return await handleNextEvent(args, signal);
+      case "composer_get_section":
+        return handleGetSection(args);
+      case "composer_get_full_doc":
+        return handleGetFullDoc(args);
+      case "composer_get_thread":
+        return handleGetThread(args);
+      case "composer_add_comment":
+        return handleAddComment(args);
+      case "composer_reply_comment":
+        return handleReplyComment(args);
+      case "composer_add_suggestion":
+        return handleAddSuggestion(args);
+      case "composer_reply_suggestion":
+        return handleReplySuggestion(args);
+      case "composer_resolve_thread":
+        return handleResolveThread(args);
+      default:
+        return errorResult(`unknown tool: ${name}`);
+    }
+  } finally {
+    state?.scheduleIdleDisconnect(3e4);
   }
 }
 function buildServer() {
@@ -4980,13 +5446,13 @@ function buildServer() {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOL_DEFS
   }));
-  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
     const { name, arguments: args } = req.params;
     const roomId = args && typeof args === "object" && "roomId" in args ? args.roomId : void 0;
     const started = Date.now();
     log(`tool ${name} call`, { roomId });
     try {
-      const result = await dispatchTool(name, args);
+      const result = await dispatchTool(name, args, extra.signal);
       const elapsedMs = Date.now() - started;
       if (result.isError) {
         const detail = result.content[0]?.text ?? "";
@@ -5013,7 +5479,7 @@ async function startMcpServer() {
   log("mcp server starting", {
     pid: process.pid,
     node: process.version,
-    build: "awareness-heartbeat-v1"
+    build: "socket-driven-v1"
   });
   const server = buildServer();
   const transport = new StdioServerTransport();
@@ -5025,6 +5491,28 @@ async function startMcpServer() {
     logFile: LOG_FILE_PATH,
     pid: process.pid
   });
+  installShutdownHandlers("stdio");
+}
+function installShutdownHandlers(transport) {
+  let shuttingDown = false;
+  const shutdown = (reason) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log(`mcp shutdown \u2014 ${reason}`, { transport });
+    try {
+      teardownAllRooms();
+    } catch (err) {
+      logError("teardownAllRooms failed", err);
+    }
+    setTimeout(() => process.exit(0), 200).unref?.();
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGHUP", () => shutdown("SIGHUP"));
+  if (transport === "stdio") {
+    process.stdin.on("end", () => shutdown("stdin-end"));
+    process.stdin.on("close", () => shutdown("stdin-close"));
+  }
 }
 async function startMcpHttpServer(opts) {
   installCrashHandlers();
@@ -5032,7 +5520,7 @@ async function startMcpHttpServer(opts) {
     port: opts.port,
     pid: process.pid,
     node: process.version,
-    build: "awareness-heartbeat-v1"
+    build: "socket-driven-v1"
   });
   const server = buildServer();
   const transport = new StreamableHTTPServerTransport({
@@ -5078,18 +5566,30 @@ async function startMcpHttpServer(opts) {
   appBase=${APP_BASE}`
     );
   });
-  const shutdown = () => {
-    log("mcp http server shutting down");
+  installShutdownHandlers("http");
+  const closeServer = () => {
     httpServer.close(() => process.exit(0));
     setTimeout(() => process.exit(0), 500).unref();
   };
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", closeServer);
+  process.on("SIGINT", closeServer);
+  process.on("SIGHUP", closeServer);
 }
+var __test_dispatch = dispatchTool;
+var __test_setRoom = (id, state) => {
+  rooms.set(id, state);
+};
+var __test_clearRooms = () => {
+  rooms.clear();
+};
 
 export {
   loadOrCreateIdentity,
   logError,
+  teardownAllRooms,
   startMcpServer,
-  startMcpHttpServer
+  startMcpHttpServer,
+  __test_dispatch,
+  __test_setRoom,
+  __test_clearRooms
 };