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

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

@@ -6,16 +6,373 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { nanoid as nanoid3 } from "nanoid";
+import { nanoid as nanoid4 } from "nanoid";
+import * as Y6 from "yjs";
 import fs3 from "fs/promises";
 import path3 from "path";
 import os2 from "os";
 import http from "http";
 import { randomUUID } from "crypto";
 
+// ../shared/src/activity.ts
+import { nanoid } from "nanoid";
+var ACTIVITY_CAP = 200;
+var NOTIFIABLE_TYPES = /* @__PURE__ */ new Set([
+  "comment",
+  "suggestion",
+  "reply",
+  "accept",
+  "reject"
+]);
+function isActivityNotifiable(event) {
+  return NOTIFIABLE_TYPES.has(event.type);
+}
+function getActivityMap(doc) {
+  return doc.getMap("activity");
+}
+function getActivityStateMap(doc) {
+  return doc.getMap("activityState");
+}
+function emitActivity(doc, event, opts) {
+  if (opts?.silent) return;
+  const activity = getActivityMap(doc);
+  const id = nanoid();
+  activity.set(id, { ...event, id });
+  pruneIfOverCap(doc);
+}
+function pruneIfOverCap(doc) {
+  const activity = getActivityMap(doc);
+  const overBy = activity.size - ACTIVITY_CAP;
+  if (overBy <= 0) return;
+  const nonNotifiable = [];
+  const notifiable = [];
+  activity.forEach((value, key) => {
+    const event = value;
+    const entry = { key, createdAt: event.createdAt };
+    if (isActivityNotifiable(event)) notifiable.push(entry);
+    else nonNotifiable.push(entry);
+  });
+  nonNotifiable.sort((a, b) => a.createdAt - b.createdAt);
+  notifiable.sort((a, b) => a.createdAt - b.createdAt);
+  const toRemove = [...nonNotifiable, ...notifiable].slice(0, overBy);
+  const stateMap = getActivityStateMap(doc);
+  for (const entry of toRemove) {
+    activity.delete(entry.key);
+    stateMap.forEach((_value, stateKeyStr) => {
+      if (stateKeyStr.startsWith(`${entry.key}:`)) {
+        stateMap.delete(stateKeyStr);
+      }
+    });
+  }
+}
+function textPreview(text, maxLen = 80) {
+  if (!text) return void 0;
+  return text.length > maxLen ? text.slice(0, maxLen) + "\u2026" : text;
+}
+function getParticipantUserIds(thread) {
+  const ids = /* @__PURE__ */ new Set();
+  if (thread.authorUserId) ids.add(thread.authorUserId);
+  for (const r of thread.replies ?? []) {
+    if (r.authorUserId) ids.add(r.authorUserId);
+  }
+  return [...ids];
+}
+
 // src/roomState.ts
-import * as Y4 from "yjs";
+import * as Y5 from "yjs";
 import YProvider from "y-partyserver/provider";
+
+// ../node_modules/lib0/math.js
+var floor = Math.floor;
+var isNaN = Number.isNaN;
+
+// ../node_modules/lib0/set.js
+var create = () => /* @__PURE__ */ new Set();
+
+// ../node_modules/lib0/array.js
+var from = Array.from;
+
+// ../node_modules/lib0/time.js
+var getUnixTime = Date.now;
+
+// ../node_modules/lib0/map.js
+var create2 = () => /* @__PURE__ */ new Map();
+var setIfUndefined = (map, key, createT) => {
+  let set = map.get(key);
+  if (set === void 0) {
+    map.set(key, set = createT());
+  }
+  return set;
+};
+
+// ../node_modules/lib0/observable.js
+var Observable = class {
+  constructor() {
+    this._observers = create2();
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  on(name, f) {
+    setIfUndefined(this._observers, name, create).add(f);
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  once(name, f) {
+    const _f = (...args) => {
+      this.off(name, _f);
+      f(...args);
+    };
+    this.on(name, _f);
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  off(name, f) {
+    const observers = this._observers.get(name);
+    if (observers !== void 0) {
+      observers.delete(f);
+      if (observers.size === 0) {
+        this._observers.delete(name);
+      }
+    }
+  }
+  /**
+   * Emit a named event. All registered event listeners that listen to the
+   * specified name will receive the event.
+   *
+   * @todo This should catch exceptions
+   *
+   * @param {N} name The event name.
+   * @param {Array<any>} args The arguments that are applied to the event listener.
+   */
+  emit(name, args) {
+    return from((this._observers.get(name) || create2()).values()).forEach((f) => f(...args));
+  }
+  destroy() {
+    this._observers = create2();
+  }
+};
+
+// ../node_modules/lib0/trait/equality.js
+var EqualityTraitSymbol = /* @__PURE__ */ Symbol("Equality");
+
+// ../node_modules/lib0/object.js
+var keys = Object.keys;
+var size = (obj) => keys(obj).length;
+var hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+// ../node_modules/lib0/function.js
+var equalityDeep = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null || a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object)) {
+    return false;
+  }
+  if (a[EqualityTraitSymbol] != null) {
+    return a[EqualityTraitSymbol](b);
+  }
+  switch (a.constructor) {
+    case ArrayBuffer:
+      a = new Uint8Array(a);
+      b = new Uint8Array(b);
+    // eslint-disable-next-line no-fallthrough
+    case Uint8Array: {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          return false;
+        }
+      }
+      break;
+    }
+    case Set: {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const value of a) {
+        if (!b.has(value)) {
+          return false;
+        }
+      }
+      break;
+    }
+    case Map: {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const key of a.keys()) {
+        if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
+          return false;
+        }
+      }
+      break;
+    }
+    case void 0:
+    case Object:
+      if (size(a) !== size(b)) {
+        return false;
+      }
+      for (const key in a) {
+        if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
+          return false;
+        }
+      }
+      break;
+    case Array:
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!equalityDeep(a[i], b[i])) {
+          return false;
+        }
+      }
+      break;
+    default:
+      return false;
+  }
+  return true;
+};
+
+// ../node_modules/y-protocols/awareness.js
+import * as Y from "yjs";
+var outdatedTimeout = 3e4;
+var Awareness = class extends Observable {
+  /**
+   * @param {Y.Doc} doc
+   */
+  constructor(doc) {
+    super();
+    this.doc = doc;
+    this.clientID = doc.clientID;
+    this.states = /* @__PURE__ */ new Map();
+    this.meta = /* @__PURE__ */ new Map();
+    this._checkInterval = /** @type {any} */
+    setInterval(() => {
+      const now = getUnixTime();
+      if (this.getLocalState() !== null && outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */
+      this.meta.get(this.clientID).lastUpdated) {
+        this.setLocalState(this.getLocalState());
+      }
+      const remove = [];
+      this.meta.forEach((meta, clientid) => {
+        if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) {
+          remove.push(clientid);
+        }
+      });
+      if (remove.length > 0) {
+        removeAwarenessStates(this, remove, "timeout");
+      }
+    }, floor(outdatedTimeout / 10));
+    doc.on("destroy", () => {
+      this.destroy();
+    });
+    this.setLocalState({});
+  }
+  destroy() {
+    this.emit("destroy", [this]);
+    this.setLocalState(null);
+    super.destroy();
+    clearInterval(this._checkInterval);
+  }
+  /**
+   * @return {Object<string,any>|null}
+   */
+  getLocalState() {
+    return this.states.get(this.clientID) || null;
+  }
+  /**
+   * @param {Object<string,any>|null} state
+   */
+  setLocalState(state) {
+    const clientID = this.clientID;
+    const currLocalMeta = this.meta.get(clientID);
+    const clock = currLocalMeta === void 0 ? 0 : currLocalMeta.clock + 1;
+    const prevState = this.states.get(clientID);
+    if (state === null) {
+      this.states.delete(clientID);
+    } else {
+      this.states.set(clientID, state);
+    }
+    this.meta.set(clientID, {
+      clock,
+      lastUpdated: getUnixTime()
+    });
+    const added = [];
+    const updated = [];
+    const filteredUpdated = [];
+    const removed = [];
+    if (state === null) {
+      removed.push(clientID);
+    } else if (prevState == null) {
+      if (state != null) {
+        added.push(clientID);
+      }
+    } else {
+      updated.push(clientID);
+      if (!equalityDeep(prevState, state)) {
+        filteredUpdated.push(clientID);
+      }
+    }
+    if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
+      this.emit("change", [{ added, updated: filteredUpdated, removed }, "local"]);
+    }
+    this.emit("update", [{ added, updated, removed }, "local"]);
+  }
+  /**
+   * @param {string} field
+   * @param {any} value
+   */
+  setLocalStateField(field, value) {
+    const state = this.getLocalState();
+    if (state !== null) {
+      this.setLocalState({
+        ...state,
+        [field]: value
+      });
+    }
+  }
+  /**
+   * @return {Map<number,Object<string,any>>}
+   */
+  getStates() {
+    return this.states;
+  }
+};
+var removeAwarenessStates = (awareness, clients, origin) => {
+  const removed = [];
+  for (let i = 0; i < clients.length; i++) {
+    const clientID = clients[i];
+    if (awareness.states.has(clientID)) {
+      awareness.states.delete(clientID);
+      if (clientID === awareness.clientID) {
+        const curMeta = (
+          /** @type {MetaClientState} */
+          awareness.meta.get(clientID)
+        );
+        awareness.meta.set(clientID, {
+          clock: curMeta.clock + 1,
+          lastUpdated: getUnixTime()
+        });
+      }
+      removed.push(clientID);
+    }
+  }
+  if (removed.length > 0) {
+    awareness.emit("change", [{ added: [], updated: [], removed }, origin]);
+    awareness.emit("update", [{ added: [], updated: [], removed }, origin]);
+  }
+};
+
+// src/roomState.ts
 import WebSocket from "ws";
 
 // ../shared/src/editor-extensions.ts
@@ -445,10 +802,10 @@ function findDiffEnd(a, b, posA, posB) {
   for (let iA = a.childCount, iB = b.childCount; ; ) {
     if (iA == 0 || iB == 0)
       return iA == iB ? null : { a: posA, b: posB };
-    let childA = a.child(--iA), childB = b.child(--iB), size = childA.nodeSize;
+    let childA = a.child(--iA), childB = b.child(--iB), size2 = childA.nodeSize;
     if (childA == childB) {
-      posA -= size;
-      posB -= size;
+      posA -= size2;
+      posB -= size2;
       continue;
     }
     if (!childA.sameMarkup(childB))
@@ -467,18 +824,18 @@ function findDiffEnd(a, b, posA, posB) {
       if (inner)
         return inner;
     }
-    posA -= size;
-    posB -= size;
+    posA -= size2;
+    posB -= size2;
   }
 }
 var Fragment = class _Fragment {
   /**
   @internal
   */
-  constructor(content, size) {
+  constructor(content, size2) {
     this.content = content;
-    this.size = size || 0;
-    if (size == null)
+    this.size = size2 || 0;
+    if (size2 == null)
       for (let i = 0; i < content.length; i++)
         this.size += content[i].nodeSize;
   }
@@ -487,12 +844,12 @@ var Fragment = class _Fragment {
   positions (relative to start of this fragment). Doesn't descend
   into a node when the callback returns `false`.
   */
-  nodesBetween(from, to, f, nodeStart = 0, parent) {
+  nodesBetween(from2, to, f, nodeStart = 0, parent) {
     for (let i = 0, pos = 0; pos < to; i++) {
       let child = this.content[i], end = pos + child.nodeSize;
-      if (end > from && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
+      if (end > from2 && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
         let start = pos + 1;
-        child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
+        child.nodesBetween(Math.max(0, from2 - start), Math.min(child.content.size, to - start), f, nodeStart + start);
       }
       pos = end;
     }
@@ -509,10 +866,10 @@ var Fragment = class _Fragment {
   Extract the text between `from` and `to`. See the same method on
   [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
   */
-  textBetween(from, to, blockSeparator, leafText) {
+  textBetween(from2, to, blockSeparator, leafText) {
     let text = "", first = true;
-    this.nodesBetween(from, to, (node, pos) => {
-      let nodeText = node.isText ? node.text.slice(Math.max(from, pos) - pos, to - pos) : !node.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node) : leafText : node.type.spec.leafText ? node.type.spec.leafText(node) : "";
+    this.nodesBetween(from2, to, (node, pos) => {
+      let nodeText = node.isText ? node.text.slice(Math.max(from2, pos) - pos, to - pos) : !node.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node) : leafText : node.type.spec.leafText ? node.type.spec.leafText(node) : "";
       if (node.isBlock && (node.isLeaf && nodeText || node.isTextblock) && blockSeparator) {
         if (first)
           first = false;
@@ -544,36 +901,36 @@ var Fragment = class _Fragment {
   /**
   Cut out the sub-fragment between the two given positions.
   */
-  cut(from, to = this.size) {
-    if (from == 0 && to == this.size)
+  cut(from2, to = this.size) {
+    if (from2 == 0 && to == this.size)
       return this;
-    let result = [], size = 0;
-    if (to > from)
+    let result = [], size2 = 0;
+    if (to > from2)
       for (let i = 0, pos = 0; pos < to; i++) {
         let child = this.content[i], end = pos + child.nodeSize;
-        if (end > from) {
-          if (pos < from || end > to) {
+        if (end > from2) {
+          if (pos < from2 || end > to) {
             if (child.isText)
-              child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
+              child = child.cut(Math.max(0, from2 - pos), Math.min(child.text.length, to - pos));
             else
-              child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
+              child = child.cut(Math.max(0, from2 - pos - 1), Math.min(child.content.size, to - pos - 1));
           }
           result.push(child);
-          size += child.nodeSize;
+          size2 += child.nodeSize;
         }
         pos = end;
       }
-    return new _Fragment(result, size);
+    return new _Fragment(result, size2);
   }
   /**
   @internal
   */
-  cutByIndex(from, to) {
-    if (from == to)
+  cutByIndex(from2, to) {
+    if (from2 == to)
       return _Fragment.empty;
-    if (from == 0 && to == this.content.length)
+    if (from2 == 0 && to == this.content.length)
       return this;
-    return new _Fragment(this.content.slice(from, to));
+    return new _Fragment(this.content.slice(from2, to));
   }
   /**
   Create a new fragment in which the node at the given index is
@@ -584,9 +941,9 @@ var Fragment = class _Fragment {
     if (current == node)
       return this;
     let copy = this.content.slice();
-    let size = this.size + node.nodeSize - current.nodeSize;
+    let size2 = this.size + node.nodeSize - current.nodeSize;
     copy[index] = node;
-    return new _Fragment(copy, size);
+    return new _Fragment(copy, size2);
   }
   /**
   Create a new fragment by prepending the given node to this
@@ -731,10 +1088,10 @@ var Fragment = class _Fragment {
   static fromArray(array) {
     if (!array.length)
       return _Fragment.empty;
-    let joined, size = 0;
+    let joined, size2 = 0;
     for (let i = 0; i < array.length; i++) {
       let node = array[i];
-      size += node.nodeSize;
+      size2 += node.nodeSize;
       if (i && node.isText && array[i - 1].sameMarkup(node)) {
         if (!joined)
           joined = array.slice(0, i);
@@ -743,7 +1100,7 @@ var Fragment = class _Fragment {
         joined.push(node);
       }
     }
-    return new _Fragment(joined || array, size);
+    return new _Fragment(joined || array, size2);
   }
   /**
   Create a fragment from something that can be interpreted as a
@@ -951,8 +1308,8 @@ var Slice = class _Slice {
   /**
   @internal
   */
-  removeBetween(from, to) {
-    return new _Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
+  removeBetween(from2, to) {
+    return new _Slice(removeRange(this.content, from2 + this.openStart, to + this.openStart), this.openStart, this.openEnd);
   }
   /**
   Tests whether this slice is equal to another slice.
@@ -1004,17 +1361,17 @@ var Slice = class _Slice {
   }
 };
 Slice.empty = new Slice(Fragment.empty, 0, 0);
-function removeRange(content, from, to) {
-  let { index, offset } = content.findIndex(from), child = content.maybeChild(index);
+function removeRange(content, from2, to) {
+  let { index, offset } = content.findIndex(from2), child = content.maybeChild(index);
   let { index: indexTo, offset: offsetTo } = content.findIndex(to);
-  if (offset == from || child.isText) {
+  if (offset == from2 || child.isText) {
     if (offsetTo != to && !content.child(indexTo).isText)
       throw new RangeError("Removing non-flat range");
-    return content.cut(0, from).append(content.cut(to));
+    return content.cut(0, from2).append(content.cut(to));
   }
   if (index != indexTo)
     throw new RangeError("Removing non-flat range");
-  return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
+  return content.replaceChild(index, child.copy(removeRange(child.content, from2 - offset - 1, to - offset - 1)));
 }
 function insertInto(content, dist, insert, parent) {
   let { index, offset } = content.findIndex(dist), child = content.maybeChild(index);
@@ -1510,8 +1867,8 @@ var Node2 = class _Node {
   recursed over. The last parameter can be used to specify a
   starting position to count from.
   */
-  nodesBetween(from, to, f, startPos = 0) {
-    this.content.nodesBetween(from, to, f, startPos, this);
+  nodesBetween(from2, to, f, startPos = 0) {
+    this.content.nodesBetween(from2, to, f, startPos, this);
   }
   /**
   Call the given callback for every descendant node. Doesn't
@@ -1534,8 +1891,8 @@ var Node2 = class _Node {
   inserted for every non-text leaf node encountered, otherwise
   [`leafText`](https://prosemirror.net/docs/ref/#model.NodeSpec.leafText) will be used.
   */
-  textBetween(from, to, blockSeparator, leafText) {
-    return this.content.textBetween(from, to, blockSeparator, leafText);
+  textBetween(from2, to, blockSeparator, leafText) {
+    return this.content.textBetween(from2, to, blockSeparator, leafText);
   }
   /**
   Returns this node's first child, or `null` if there are no
@@ -1592,19 +1949,19 @@ var Node2 = class _Node {
   given positions. If `to` is not given, it defaults to the end of
   the node.
   */
-  cut(from, to = this.content.size) {
-    if (from == 0 && to == this.content.size)
+  cut(from2, to = this.content.size) {
+    if (from2 == 0 && to == this.content.size)
       return this;
-    return this.copy(this.content.cut(from, to));
+    return this.copy(this.content.cut(from2, to));
   }
   /**
   Cut out the part of the document between the given positions, and
   return it as a `Slice` object.
   */
-  slice(from, to = this.content.size, includeParents = false) {
-    if (from == to)
+  slice(from2, to = this.content.size, includeParents = false) {
+    if (from2 == to)
       return Slice.empty;
-    let $from = this.resolve(from), $to = this.resolve(to);
+    let $from = this.resolve(from2), $to = this.resolve(to);
     let depth = includeParents ? 0 : $from.sharedDepth(to);
     let start = $from.start(depth), node = $from.node(depth);
     let content = node.content.cut($from.pos - start, $to.pos - start);
@@ -1618,8 +1975,8 @@ var Node2 = class _Node {
   into. If any of this is violated, an error of type
   [`ReplaceError`](https://prosemirror.net/docs/ref/#model.ReplaceError) is thrown.
   */
-  replace(from, to, slice) {
-    return replace(this.resolve(from), this.resolve(to), slice);
+  replace(from2, to, slice) {
+    return replace(this.resolve(from2), this.resolve(to), slice);
   }
   /**
   Find the node directly after the given position.
@@ -1675,10 +2032,10 @@ var Node2 = class _Node {
   Test whether a given mark or mark type occurs in this document
   between the two given positions.
   */
-  rangeHasMark(from, to, type) {
+  rangeHasMark(from2, to, type) {
     let found2 = false;
-    if (to > from)
-      this.nodesBetween(from, to, (node) => {
+    if (to > from2)
+      this.nodesBetween(from2, to, (node) => {
         if (type.isInSet(node.marks))
           found2 = true;
         return !found2;
@@ -1761,8 +2118,8 @@ var Node2 = class _Node {
   can optionally pass `start` and `end` indices into the
   replacement fragment.
   */
-  canReplace(from, to, replacement = Fragment.empty, start = 0, end = replacement.childCount) {
-    let one = this.contentMatchAt(from).matchFragment(replacement, start, end);
+  canReplace(from2, to, replacement = Fragment.empty, start = 0, end = replacement.childCount) {
+    let one = this.contentMatchAt(from2).matchFragment(replacement, start, end);
     let two = one && one.matchFragment(this.content, to);
     if (!two || !two.validEnd)
       return false;
@@ -1775,10 +2132,10 @@ var Node2 = class _Node {
   Test whether replacing the range `from` to `to` (by index) with
   a node of the given type would leave the node's content valid.
   */
-  canReplaceWith(from, to, type, marks) {
+  canReplaceWith(from2, to, type, marks) {
     if (marks && !this.type.allowsMarks(marks))
       return false;
-    let start = this.contentMatchAt(from).matchType(type);
+    let start = this.contentMatchAt(from2).matchType(type);
     let end = start && start.matchFragment(this.content, to);
     return end ? end.validEnd : false;
   }
@@ -2139,38 +2496,38 @@ function nfa(expr) {
   function node() {
     return nfa2.push([]) - 1;
   }
-  function edge(from, to, term) {
+  function edge(from2, to, term) {
     let edge2 = { term, to };
-    nfa2[from].push(edge2);
+    nfa2[from2].push(edge2);
     return edge2;
   }
   function connect(edges, to) {
     edges.forEach((edge2) => edge2.to = to);
   }
-  function compile(expr2, from) {
+  function compile(expr2, from2) {
     if (expr2.type == "choice") {
-      return expr2.exprs.reduce((out, expr3) => out.concat(compile(expr3, from)), []);
+      return expr2.exprs.reduce((out, expr3) => out.concat(compile(expr3, from2)), []);
     } else if (expr2.type == "seq") {
       for (let i = 0; ; i++) {
-        let next = compile(expr2.exprs[i], from);
+        let next = compile(expr2.exprs[i], from2);
         if (i == expr2.exprs.length - 1)
           return next;
-        connect(next, from = node());
+        connect(next, from2 = node());
       }
     } else if (expr2.type == "star") {
       let loop = node();
-      edge(from, loop);
+      edge(from2, loop);
       connect(compile(expr2.expr, loop), loop);
       return [edge(loop)];
     } else if (expr2.type == "plus") {
       let loop = node();
-      connect(compile(expr2.expr, from), loop);
+      connect(compile(expr2.expr, from2), loop);
       connect(compile(expr2.expr, loop), loop);
       return [edge(loop)];
     } else if (expr2.type == "opt") {
-      return [edge(from)].concat(compile(expr2.expr, from));
+      return [edge(from2)].concat(compile(expr2.expr, from2));
     } else if (expr2.type == "range") {
-      let cur = from;
+      let cur = from2;
       for (let i = 0; i < expr2.min; i++) {
         let next = node();
         connect(compile(expr2.expr, cur), next);
@@ -2188,7 +2545,7 @@ function nfa(expr) {
       }
       return [edge(cur)];
     } else if (expr2.type == "name") {
-      return [edge(from, void 0, expr2.value)];
+      return [edge(from2, void 0, expr2.value)];
     } else {
       throw new Error("Unknown expr type");
     }
@@ -2487,9 +2844,9 @@ var StepResult = class _StepResult {
   arguments. Create a successful result if it succeeds, and a
   failed one if it throws a `ReplaceError`.
   */
-  static fromReplace(doc, from, to, slice) {
+  static fromReplace(doc, from2, to, slice) {
     try {
-      return _StepResult.ok(doc.replace(from, to, slice));
+      return _StepResult.ok(doc.replace(from2, to, slice));
     } catch (e) {
       if (e instanceof ReplaceError)
         return _StepResult.fail(e.message);
@@ -2513,9 +2870,9 @@ var AddMarkStep = class _AddMarkStep extends Step {
   /**
   Create a mark step.
   */
-  constructor(from, to, mark) {
+  constructor(from2, to, mark) {
     super();
-    this.from = from;
+    this.from = from2;
     this.to = to;
     this.mark = mark;
   }
@@ -2533,10 +2890,10 @@ var AddMarkStep = class _AddMarkStep extends Step {
     return new RemoveMarkStep(this.from, this.to, this.mark);
   }
   map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deleted && to.deleted || from.pos >= to.pos)
+    let from2 = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from2.deleted && to.deleted || from2.pos >= to.pos)
       return null;
-    return new _AddMarkStep(from.pos, to.pos, this.mark);
+    return new _AddMarkStep(from2.pos, to.pos, this.mark);
   }
   merge(other) {
     if (other instanceof _AddMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from)
@@ -2565,9 +2922,9 @@ var RemoveMarkStep = class _RemoveMarkStep extends Step {
   /**
   Create a mark-removing step.
   */
-  constructor(from, to, mark) {
+  constructor(from2, to, mark) {
     super();
-    this.from = from;
+    this.from = from2;
     this.to = to;
     this.mark = mark;
   }
@@ -2582,10 +2939,10 @@ var RemoveMarkStep = class _RemoveMarkStep extends Step {
     return new AddMarkStep(this.from, this.to, this.mark);
   }
   map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deleted && to.deleted || from.pos >= to.pos)
+    let from2 = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from2.deleted && to.deleted || from2.pos >= to.pos)
       return null;
-    return new _RemoveMarkStep(from.pos, to.pos, this.mark);
+    return new _RemoveMarkStep(from2.pos, to.pos, this.mark);
   }
   merge(other) {
     if (other instanceof _RemoveMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from)
@@ -2705,9 +3062,9 @@ var ReplaceStep = class _ReplaceStep extends Step {
   tokens (this is to guard against rebased replace steps
   overwriting something they weren't supposed to).
   */
-  constructor(from, to, slice, structure = false) {
+  constructor(from2, to, slice, structure = false) {
     super();
-    this.from = from;
+    this.from = from2;
     this.to = to;
     this.slice = slice;
     this.structure = structure;
@@ -2725,10 +3082,10 @@ var ReplaceStep = class _ReplaceStep extends Step {
   }
   map(mapping) {
     let to = mapping.mapResult(this.to, -1);
-    let from = this.from == this.to && _ReplaceStep.MAP_BIAS < 0 ? to : mapping.mapResult(this.from, 1);
-    if (from.deletedAcross && to.deletedAcross)
+    let from2 = this.from == this.to && _ReplaceStep.MAP_BIAS < 0 ? to : mapping.mapResult(this.from, 1);
+    if (from2.deletedAcross && to.deletedAcross)
       return null;
-    return new _ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure);
+    return new _ReplaceStep(from2.pos, Math.max(from2.pos, to.pos), this.slice, this.structure);
   }
   merge(other) {
     if (!(other instanceof _ReplaceStep) || other.structure || this.structure)
@@ -2769,9 +3126,9 @@ var ReplaceAroundStep = class _ReplaceAroundStep extends Step {
   of the gap should be moved. `structure` has the same meaning as
   it has in the [`ReplaceStep`](https://prosemirror.net/docs/ref/#transform.ReplaceStep) class.
   */
-  constructor(from, to, gapFrom, gapTo, slice, insert, structure = false) {
+  constructor(from2, to, gapFrom, gapTo, slice, insert, structure = false) {
     super();
-    this.from = from;
+    this.from = from2;
     this.to = to;
     this.gapFrom = gapFrom;
     this.gapTo = gapTo;
@@ -2805,12 +3162,12 @@ var ReplaceAroundStep = class _ReplaceAroundStep extends Step {
     return new _ReplaceAroundStep(this.from, this.from + this.slice.size + gap, this.from + this.insert, this.from + this.insert + gap, doc.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
   }
   map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+    let from2 = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    let gapFrom = this.from == this.gapFrom ? from2.pos : mapping.map(this.gapFrom, -1);
     let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
-    if (from.deletedAcross && to.deletedAcross || gapFrom < from.pos || gapTo > to.pos)
+    if (from2.deletedAcross && to.deletedAcross || gapFrom < from2.pos || gapTo > to.pos)
       return null;
-    return new _ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
+    return new _ReplaceAroundStep(from2.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
   }
   toJSON() {
     let json = {
@@ -2837,8 +3194,8 @@ var ReplaceAroundStep = class _ReplaceAroundStep extends Step {
   }
 };
 Step.jsonID("replaceAround", ReplaceAroundStep);
-function contentBetween(doc, from, to) {
-  let $from = doc.resolve(from), dist = to - from, depth = $from.depth;
+function contentBetween(doc, from2, to) {
+  let $from = doc.resolve(from2), dist = to - from2, depth = $from.depth;
   while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
     depth--;
     dist--;
@@ -3033,11 +3390,11 @@ var Selection = class {
     let mapFrom = tr.steps.length, ranges = this.ranges;
     for (let i = 0; i < ranges.length; i++) {
       let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
-      let from = mapping.map($from.pos), to = mapping.map($to.pos);
+      let from2 = mapping.map($from.pos), to = mapping.map($to.pos);
       if (i) {
-        tr.deleteRange(from, to);
+        tr.deleteRange(from2, to);
       } else {
-        tr.replaceRangeWith(from, to, node);
+        tr.replaceRangeWith(from2, to, node);
         selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1);
       }
     }
@@ -3279,8 +3636,8 @@ var NodeSelection = class _NodeSelection extends Selection {
   /**
   Create a node selection from non-resolved positions.
   */
-  static create(doc, from) {
-    return new _NodeSelection(doc.resolve(from));
+  static create(doc, from2) {
+    return new _NodeSelection(doc.resolve(from2));
   }
   /**
   Determines whether the given node may be selected as a node
@@ -3455,11 +3812,11 @@ var Plugin = class {
     return state[this.key];
   }
 };
-var keys = /* @__PURE__ */ Object.create(null);
+var keys2 = /* @__PURE__ */ Object.create(null);
 function createKey(name) {
-  if (name in keys)
-    return name + "$" + ++keys[name];
-  keys[name] = 0;
+  if (name in keys2)
+    return name + "$" + ++keys2[name];
+  keys2[name] = 0;
   return name + "$";
 }
 var PluginKey = class {
@@ -3535,6 +3892,18 @@ var mediaKeyboardNav_default = MediaKeyboardNav;
 
 // ../shared/src/editor-extensions.ts
 var CodeWithCombinableMarks = Code.extend({ excludes: "" });
+var TableWithId = Table.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.() ?? {},
+      tableId: {
+        default: null,
+        parseHTML: (el) => el.getAttribute("data-table-id"),
+        renderHTML: (attrs) => attrs.tableId ? { "data-table-id": attrs.tableId } : {}
+      }
+    };
+  }
+});
 var FrontmatterSchema = CodeBlock.extend({
   name: "frontmatter",
   addInputRules() {
@@ -3549,7 +3918,7 @@ ${text}
   }
 });
 function buildEditorExtensions(opts = {}) {
-  const table = opts.table ?? Table;
+  const table = opts.table ?? TableWithId;
   const frontmatter = opts.frontmatter ?? FrontmatterSchema;
   return [
     StarterKit.configure({
@@ -3570,7 +3939,13 @@ function buildEditorExtensions(opts = {}) {
     Highlight,
     Subscript,
     Superscript,
-    table.configure({ resizable: false }),
+    table.configure({
+      resizable: true,
+      handleWidth: 5,
+      lastColumnResizable: true,
+      cellMinWidth: 80,
+      renderWrapper: true
+    }),
     TableRow,
     TableCell,
     TableHeader,
@@ -3628,7 +4003,7 @@ function markdownFromYFragment(fragment, extensions = editorExtensions) {
 }
 
 // ../shared/src/insertMedia.ts
-import { nanoid } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
 
 // ../shared/src/uploadRegistry.ts
 var UploadRegistryImpl = class {
@@ -3812,11 +4187,16 @@ var UploadRegistryImpl = class {
 var uploadRegistry = new UploadRegistryImpl();
 
 // ../shared/src/uploadPlaceholderPlugin.ts
-import * as Y from "yjs";
+import * as Y2 from "yjs";
 var uploadPlaceholderPluginKey = new PluginKey(
   "uploadPlaceholder"
 );
 
+// ../shared/src/awareness.ts
+function setLocalAwareness(awareness, key, value) {
+  awareness.setLocalStateField(key, value);
+}
+
 // ../shared/src/insertMedia.ts
 var IMAGE_MAX_BYTES = 25 * 1024 * 1024;
 var VIDEO_MAX_BYTES = 50 * 1024 * 1024;
@@ -3825,14 +4205,14 @@ var VIDEO_MAX_BYTES = 50 * 1024 * 1024;
 var mediaDeleteObserverKey = new PluginKey("mediaDeleteObserver");
 
 // src/docReaders.ts
-import * as Y2 from "yjs";
+import * as Y3 from "yjs";
 function isXmlElement(node) {
-  return node instanceof Y2.XmlElement;
+  return node instanceof Y3.XmlElement;
 }
 function getElementText(el) {
   let out = "";
   for (const child of el.toArray()) {
-    if (child instanceof Y2.XmlText) {
+    if (child instanceof Y3.XmlText) {
       for (const op of child.toDelta()) {
         if (typeof op.insert === "string") out += op.insert;
       }
@@ -3945,13 +4325,13 @@ function serializeDocAsMarkdown(doc) {
 }
 
 // src/anchors.ts
-import * as Y3 from "yjs";
+import * as Y4 from "yjs";
 function buildFlatMap(fragment) {
   let flat = "";
   const map = [];
   const blockFlatStarts = [];
   const walk = (node) => {
-    if (node instanceof Y3.XmlText) {
+    if (node instanceof Y4.XmlText) {
       let localOffset = 0;
       for (const op of node.toDelta()) {
         const value = op.insert;
@@ -3979,7 +4359,7 @@ function buildFlatMap(fragment) {
       return;
     }
     for (const child of node.toArray()) {
-      if (child instanceof Y3.XmlText || child instanceof Y3.XmlElement) {
+      if (child instanceof Y4.XmlText || child instanceof Y4.XmlElement) {
         walk(child);
       }
     }
@@ -3987,7 +4367,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) {
+    if (node instanceof Y4.XmlText || node instanceof Y4.XmlElement) {
       walk(node);
     }
     if (idx < topLevel.length - 1) {
@@ -4044,7 +4424,7 @@ function resolveAnchoredContext(doc, anchorFrom, anchorTo) {
   let containingBlockIdx = -1;
   for (let i = 0; i < topLevel.length; i++) {
     const block = topLevel[i];
-    if (block instanceof Y3.XmlElement && containsType(block, fromAbs.type)) {
+    if (block instanceof Y4.XmlElement && containsType(block, fromAbs.type)) {
       containingBlockIdx = i;
       break;
     }
@@ -4066,8 +4446,8 @@ function resolveAnchoredContext(doc, anchorFrom, anchorTo) {
 function decodeAbs(doc, encoded) {
   if (!encoded) return null;
   try {
-    const rel = Y3.decodeRelativePosition(encoded);
-    const abs = Y3.createAbsolutePositionFromRelativePosition(rel, doc);
+    const rel = Y4.decodeRelativePosition(encoded);
+    const abs = Y4.createAbsolutePositionFromRelativePosition(rel, doc);
     if (!abs) return null;
     return { type: abs.type, index: abs.index };
   } catch {
@@ -4090,7 +4470,7 @@ function flatIndexFor(map, abs) {
 function containsType(el, target) {
   for (const child of el.toArray()) {
     if (child === target) return true;
-    if (child instanceof Y3.XmlElement && containsType(child, target)) {
+    if (child instanceof Y4.XmlElement && containsType(child, target)) {
       return true;
     }
   }
@@ -4138,24 +4518,42 @@ function resolveServerAnchor(doc, spec) {
   if (!lastCharEntry) {
     return { ok: false, error: "text_not_found", currentSectionText };
   }
-  const fromRelPos = Y3.createRelativePositionFromTypeIndex(
+  const fromRelPos = Y4.createRelativePositionFromTypeIndex(
     startEntry.xmlText,
     startEntry.offsetInText
   );
-  const toRelPos = Y3.createRelativePositionFromTypeIndex(
+  const toRelPos = Y4.createRelativePositionFromTypeIndex(
     lastCharEntry.xmlText,
     lastCharEntry.offsetInText + 1
   );
   return {
     ok: true,
-    from: Y3.encodeRelativePosition(fromRelPos),
-    to: Y3.encodeRelativePosition(toRelPos)
+    from: Y4.encodeRelativePosition(fromRelPos),
+    to: Y4.encodeRelativePosition(toRelPos)
   };
 }
 
 // src/roomState.ts
-var RoomState = class {
-  doc = new Y4.Doc();
+var HAD_UPGRADE_403 = /* @__PURE__ */ Symbol("composer.upgrade403");
+var TerminalDetectingWS = class extends WebSocket {
+  constructor(...args) {
+    super(...args);
+    this.on("unexpected-response", (_req, res) => {
+      if (res.statusCode === 403) {
+        this[HAD_UPGRADE_403] = true;
+      }
+    });
+  }
+};
+var TERMINAL_CLOSE_CODES = /* @__PURE__ */ new Set([4403, 4410]);
+var MAX_CONSECUTIVE_FAILURES = 15;
+function reconnectDelayMs(failuresSoFar) {
+  if (failuresSoFar <= 5) return 1e4;
+  if (failuresSoFar <= 10) return 3e4;
+  return 6e4;
+}
+var RoomState = class _RoomState {
+  doc;
   actingAs;
   identity;
   roomId;
@@ -4189,26 +4587,180 @@ var RoomState = class {
   /**
    * 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).
+   * re-engages via `composer_create_room` / `composer_join_room` — both of
+   * which clear the latch (create builds a fresh RoomState; rejoin reuses
+   * the cached one and calls `clearGoodbye()`).
    */
   goodbyeIssued = false;
+  /**
+   * Set when the connection enters a terminal state — either the server
+   * explicitly rejected (HTTP 403 / close code 4403 / 4410) or the client
+   * circuit breaker tripped after too many consecutive failures. Once set,
+   * `ensureConnected` / `waitForInitialSync` reject immediately and tool
+   * calls surface a clear error rather than the host silently hanging.
+   */
+  terminalReject = null;
+  /**
+   * Listeners that fire when terminal state is signalled. Used to unblock
+   * pending `waitForInitialSync` promises so the host doesn't hang for the
+   * full 15s timeout after a kick.
+   */
+  terminalRejectListeners = /* @__PURE__ */ new Set();
+  /**
+   * Counter for consecutive failed reconnects. Reset to 0 on a successful
+   * `connected` status event. Per the design, does NOT reset on idle
+   * disconnects — only on a real successful open.
+   */
+  consecutiveFailures = 0;
+  /**
+   * Pending manually-scheduled reconnect timer (we replace y-partyserver's
+   * default exponential backoff with the tiered schedule from the design).
+   * Cleared on destroy and on each new close event.
+   */
+  scheduledReconnect = null;
   constructor(opts) {
     this.roomId = opts.roomId;
     this.actingAs = opts.actingAs;
     this.identity = opts.identity;
+    this.doc = opts._docForTest ?? new Y5.Doc();
     this.watchMentions();
     attachRemoteActivityTracker(this.doc, {
       onActivity: (at) => {
         this._lastRemoteActivityAt = at;
       }
     });
-    this.provider = new YProvider(opts.serverHost, opts.roomId, this.doc, {
-      party: "composer-room",
-      connect: false,
-      WebSocketPolyfill: WebSocket
+    if (opts._providerForTest) {
+      this.provider = opts._providerForTest;
+    } else {
+      this.provider = new YProvider(opts.serverHost, opts.roomId, this.doc, {
+        party: "composer-room",
+        connect: false,
+        WebSocketPolyfill: TerminalDetectingWS
+      });
+    }
+    if (!opts._providerForTest) {
+      this.provider.on(
+        "connection-close",
+        (...args) => {
+          const event = args[0];
+          if (this.terminalReject) return;
+          if (!this.provider.shouldConnect) {
+            return;
+          }
+          const ws = this.provider.ws;
+          const had403 = ws ? !!ws[HAD_UPGRADE_403] : false;
+          if (had403 || TERMINAL_CLOSE_CODES.has(event.code)) {
+            this.signalTerminalReject({
+              kind: "rejected",
+              code: had403 ? 403 : event.code,
+              reason: had403 ? "server refused upgrade (HTTP 403). composer-mcp may be out of date or this client is blocked. Update composer-mcp or contact the room owner." : event.code === 4410 ? `server has killed this client version. ${event.reason || "Please update composer-mcp."}` : `server kicked this client (close code ${event.code}). ${event.reason || "Please update composer-mcp."}`
+            });
+            return;
+          }
+          this.consecutiveFailures++;
+          if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+            this.signalTerminalReject({
+              kind: "aborted",
+              failures: this.consecutiveFailures
+            });
+            return;
+          }
+          this.provider.shouldConnect = false;
+          if (this.scheduledReconnect) clearTimeout(this.scheduledReconnect);
+          const delay = reconnectDelayMs(this.consecutiveFailures);
+          this.scheduledReconnect = setTimeout(() => {
+            this.scheduledReconnect = null;
+            if (this.terminalReject) return;
+            this.provider.connect?.()?.catch?.((err) => {
+              console.error(
+                `[composer-mcp] reconnect attempt ${this.consecutiveFailures} failed: ${err}`
+              );
+            });
+          }, delay);
+          this.scheduledReconnect.unref?.();
+        }
+      );
+      this.provider.on("status", (...args) => {
+        const status = args[0];
+        if (status.status === "connected") {
+          this.consecutiveFailures = 0;
+        }
+      });
+    }
+  }
+  /**
+   * Test-only factory: build a fully-functional `RoomState` without opening
+   * a WebSocket. Uses a standalone `Awareness` instance so local awareness
+   * writes still work and can be observed via `awarenessForTest`.
+   */
+  static createForTest(opts) {
+    const doc = new Y5.Doc();
+    const awareness = new Awareness(doc);
+    const fake = {
+      awareness,
+      synced: true,
+      destroy() {
+        awareness.destroy();
+      }
+    };
+    return new _RoomState({
+      roomId: opts.roomId,
+      serverHost: "test://noop",
+      actingAs: opts.actingAs,
+      identity: opts.identity,
+      _providerForTest: fake,
+      _docForTest: doc
     });
   }
+  signalTerminalReject(rej) {
+    if (this.terminalReject) return;
+    this.terminalReject = rej;
+    if (this.scheduledReconnect) {
+      clearTimeout(this.scheduledReconnect);
+      this.scheduledReconnect = null;
+    }
+    const listeners = [...this.terminalRejectListeners];
+    this.terminalRejectListeners.clear();
+    for (const fn of listeners) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+    this.provider.destroy();
+  }
+  terminalRejectError() {
+    const rej = this.terminalReject;
+    if (!rej) {
+      return new Error(
+        `[composer-mcp] room "${this.roomId}" entered terminal state (unknown).`
+      );
+    }
+    if (rej.kind === "aborted") {
+      return new Error(
+        `[composer-mcp] connection to room "${this.roomId}" aborted after ${rej.failures} failed reconnect attempts. Run composer_join_room to retry.`
+      );
+    }
+    return new Error(
+      `[composer-mcp] room "${this.roomId}" rejected by server: ${rej.reason}`
+    );
+  }
+  /** Test/diagnostic accessor — not part of the stable surface. */
+  get isTerminallyRejected() {
+    return this.terminalReject !== null;
+  }
+  /** Test/diagnostic accessor — not part of the stable surface. */
+  get terminalRejectKind() {
+    return this.terminalReject?.kind ?? null;
+  }
+  /** Test/diagnostic accessor — not part of the stable surface. */
+  get failureCount() {
+    return this.consecutiveFailures;
+  }
+  /** Test-only accessor for the underlying awareness instance. */
+  get awarenessForTest() {
+    return this.provider.awareness;
+  }
   /**
    * Resolves when the provider has completed its first sync handshake.
    * Rejects if the handshake does not complete within `timeoutMs` (default
@@ -4216,23 +4768,38 @@ var RoomState = class {
    * of hanging the MCP tool call indefinitely.
    */
   async waitForInitialSync(timeoutMs = 15e3) {
+    if (this.terminalReject) throw this.terminalRejectError();
     if (this.provider.synced) return;
+    if (!this.provider.on || !this.provider.off) return;
+    const provider = this.provider;
+    const onSub = provider.on.bind(provider);
+    const offSub = provider.off.bind(provider);
     await new Promise((resolve, reject) => {
-      const onSync = (synced) => {
+      const onSync = (...args) => {
+        const synced = args[0];
         if (!synced) return;
-        clearTimeout(timer);
-        this.provider.off("sync", onSync);
+        cleanup();
         resolve();
       };
+      const onTerminal = () => {
+        cleanup();
+        reject(this.terminalRejectError());
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        offSub("sync", onSync);
+        this.terminalRejectListeners.delete(onTerminal);
+      };
       const timer = setTimeout(() => {
-        this.provider.off("sync", onSync);
+        cleanup();
         reject(
           new Error(
             `timed out after ${timeoutMs}ms waiting for sync handshake on room "${this.roomId}"`
           )
         );
       }, timeoutMs);
-      this.provider.on("sync", onSync);
+      onSub("sync", onSync);
+      this.terminalRejectListeners.add(onTerminal);
     });
   }
   idleDisconnectTimer = null;
@@ -4243,10 +4810,12 @@ var RoomState = class {
    * disconnect because we're back in active use.
    */
   async ensureConnected(timeoutMs = 15e3) {
+    if (this.terminalReject) throw this.terminalRejectError();
     if (this.idleDisconnectTimer) {
       clearTimeout(this.idleDisconnectTimer);
       this.idleDisconnectTimer = null;
     }
+    if (!this.provider.connect) return;
     if (this.provider.wsconnected && this.provider.synced) return;
     await this.provider.connect();
     await this.waitForInitialSync(timeoutMs);
@@ -4270,11 +4839,12 @@ var RoomState = class {
       clearTimeout(this.idleDisconnectTimer);
       this.idleDisconnectTimer = null;
     }
+    if (!this.provider.disconnect) return;
     if (!this.provider.wsconnected) return;
     this.idleDisconnectTimer = setTimeout(() => {
       this.idleDisconnectTimer = null;
       this.setMonitoring(false);
-      this.provider.disconnect();
+      this.disconnect();
     }, ms);
     this.idleDisconnectTimer.unref?.();
   }
@@ -4282,14 +4852,19 @@ var RoomState = class {
    * 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.
+   * visual signal peers care about. Clears any pending circuit-breaker
+   * reconnect so the user's intent to disconnect isn't silently undone.
    */
   disconnect() {
     if (this.idleDisconnectTimer) {
       clearTimeout(this.idleDisconnectTimer);
       this.idleDisconnectTimer = null;
     }
-    this.provider.disconnect();
+    if (this.scheduledReconnect) {
+      clearTimeout(this.scheduledReconnect);
+      this.scheduledReconnect = null;
+    }
+    this.provider.disconnect?.();
   }
   /**
    * Toggle whether the agent is visibly monitoring the room. Broadcast via
@@ -4297,9 +4872,9 @@ var RoomState = class {
    * 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.
+   *   setMonitoring(false) — called on the silent-exit branch; clears
+   *                          awareness immediately so the avatar disappears
+   *                          as the agent leaves.
    *
    * Subsequent calls with the same value are no-ops.
    */
@@ -4334,6 +4909,15 @@ var RoomState = class {
   markGoodbyeIssued() {
     this.goodbyeIssued = true;
   }
+  /**
+   * Reset the goodbye latch on rejoin. `composer_join_room` reuses the
+   * cached RoomState when one is still in the rooms map, so without this
+   * the latch would remain set and the next `composer_next_event` would
+   * be refused — even though the user explicitly asked to re-engage.
+   */
+  clearGoodbye() {
+    this.goodbyeIssued = false;
+  }
   get hasIssuedGoodbye() {
     return this.goodbyeIssued;
   }
@@ -4356,7 +4940,10 @@ var RoomState = class {
   }
   async nextEvent(timeoutMs, signal) {
     const pending = this.queue.shift();
-    if (pending) return pending;
+    if (pending) {
+      this.onEventDelivered(pending);
+      return pending;
+    }
     if (signal?.aborted) return { kind: "timeout" };
     return new Promise((resolve) => {
       const cleanup = () => {
@@ -4376,16 +4963,34 @@ var RoomState = class {
       signal?.addEventListener("abort", onAbort, { once: true });
       const waiter = (ev) => {
         cleanup();
+        this.onEventDelivered(ev);
         resolve(ev);
       };
       this.waiters.push(waiter);
     });
   }
+  /**
+   * Hook that runs at the moment an event is actually handed to the caller
+   * of `composer_next_event`. For mentions this is where we publish the
+   * `"thinking"` heartbeat — *not* at enqueue time — so that queued mentions
+   * behind an in-flight one don't prematurely light up the indicator on the
+   * user's client. The indicator only appears once the model has picked the
+   * event up to process it.
+   */
+  onEventDelivered(ev) {
+    if (ev.kind !== "mention") return;
+    this.publishAgentWork(ev.threadId, ev.replyId, "thinking");
+  }
   destroy() {
     if (this.idleDisconnectTimer) {
       clearTimeout(this.idleDisconnectTimer);
       this.idleDisconnectTimer = null;
     }
+    if (this.scheduledReconnect) {
+      clearTimeout(this.scheduledReconnect);
+      this.scheduledReconnect = null;
+    }
+    this.terminalRejectListeners.clear();
     this.provider.destroy();
     this.doc.destroy();
   }
@@ -4397,14 +5002,84 @@ var RoomState = class {
   markThreadActive(threadId) {
     this.activeThreads.add(threadId);
   }
+  /**
+   * Publish or update an `agentWork` entry on the local awareness state for an
+   * in-flight agent record. Keyed on `{threadId, replyId}` — when `replyId` is
+   * absent the entry targets the thread-head record (an agent-authored Comment
+   * or Suggestion). Upserts: calling twice with the same key refreshes state /
+   * note / updatedAt rather than appending a duplicate. Idempotent.
+   *
+   * Entries are transient — `clearAgentWork` prunes a specific entry on a
+   * `ready` transition; the full array is auto-cleaned when the provider
+   * disconnects (server-side `onClose` → `removeAwarenessStates`). The MCP
+   * also self-heals on `composer_agent_status` re-entry by scanning the array
+   * and dropping entries whose target record is already `ready`.
+   */
+  publishAgentWork(threadId, replyId, state, note) {
+    const current = this.readAgentWork();
+    const now = Date.now();
+    const nextEntry = {
+      threadId,
+      ...replyId !== void 0 ? { replyId } : {},
+      state,
+      ...note !== void 0 ? { note } : {},
+      startedAt: now,
+      updatedAt: now
+    };
+    const existingIdx = current.findIndex(
+      (e) => e.threadId === threadId && e.replyId === replyId
+    );
+    let nextArray;
+    if (existingIdx >= 0) {
+      const existing = current[existingIdx];
+      nextArray = current.slice();
+      nextArray[existingIdx] = {
+        ...existing,
+        state,
+        ...note !== void 0 ? { note } : {},
+        updatedAt: now
+      };
+    } else {
+      nextArray = [...current, nextEntry];
+    }
+    setLocalAwareness(this.provider.awareness, "agentWork", nextArray);
+  }
+  /**
+   * Remove the `agentWork` entry matching `{threadId, replyId}`. No-op if no
+   * match exists (idempotent). When the result is empty, the field is cleared
+   * entirely so remote peers see `agentWork` absent.
+   */
+  clearAgentWork(threadId, replyId) {
+    const current = this.readAgentWork();
+    const nextArray = current.filter(
+      (e) => !(e.threadId === threadId && e.replyId === replyId)
+    );
+    if (nextArray.length === current.length) return;
+    setLocalAwareness(
+      this.provider.awareness,
+      "agentWork",
+      nextArray.length === 0 ? void 0 : nextArray
+    );
+  }
+  /** Current local `agentWork` array, or `[]` if absent / malformed. */
+  readAgentWork() {
+    const local = this.provider.awareness.getLocalState();
+    const work = local?.agentWork;
+    if (!Array.isArray(work)) return [];
+    return work;
+  }
   /** 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);
-    else this.queue.push(ev);
+    if (waiter) {
+      this.onEventDelivered(ev);
+      waiter(ev);
+    } else {
+      this.queue.push(ev);
+    }
   }
   watchMentions() {
     attachMentionObserver(this.doc, {
@@ -4413,9 +5088,26 @@ var RoomState = class {
       activeThreads: this.activeThreads,
       identityUserId: this.identity.userId,
       actingAs: this.actingAs,
-      getSoloHumanAuthorId: () => this.computeSoloHumanAuthorId()
+      getSoloHumanAuthorId: () => this.computeSoloHumanAuthorId(),
+      resolveUserName: (userId) => this.resolveUserName(userId)
     });
   }
+  /**
+   * Look up a display name for `userId` from the awareness roster. Returns
+   * `undefined` if nobody is currently advertising that userId — in which case
+   * the observer falls back to whatever `authorName` the triggering record
+   * carries (still a usable fallback).
+   */
+  resolveUserName(userId) {
+    const states = this.provider.awareness.getStates();
+    for (const state of states.values()) {
+      const user = state?.user;
+      if (!user || typeof user.userId !== "string") continue;
+      if (user.userId !== userId) continue;
+      if (typeof user.name === "string" && user.name.length > 0) return user.name;
+    }
+    return void 0;
+  }
   /**
    * 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
@@ -4461,10 +5153,24 @@ function attachMentionObserver(doc, opts) {
   const identityUserId = opts.identityUserId;
   const hasActingAsMention = buildActingAsMatcher(opts.actingAs);
   const getSoloHumanAuthorId = opts.getSoloHumanAuthorId ?? (() => void 0);
+  const resolveUserName = opts.resolveUserName ?? (() => void 0);
+  const makeInvokerFields = (authorUserId, authorName) => {
+    const fields = {};
+    if (authorUserId) {
+      fields.invokerUserId = authorUserId;
+      const resolved = resolveUserName(authorUserId);
+      if (resolved) fields.invokerName = resolved;
+      else if (authorName) fields.invokerName = authorName;
+    } else if (authorName) {
+      fields.invokerName = authorName;
+    }
+    return fields;
+  };
   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 bodyAuthorName = typeof record.authorName === "string" ? record.authorName : void 0;
     const replies = Array.isArray(record.replies) ? record.replies : [];
     let lastAgentIdx = -1;
     if (identityUserId !== void 0) {
@@ -4489,7 +5195,8 @@ function attachMentionObserver(doc, opts) {
           threadKind: kind,
           threadText: body,
           reason: "direct_mention",
-          ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo)
+          ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo),
+          ...makeInvokerFields(bodyAuthorUserId, bodyAuthorName)
         });
       }
     } else if (!seen.has(threadId) && !isLocal && !bodyAnswered && bodySidecar !== "miss" && !ANY_AT_MENTION_RE.test(body)) {
@@ -4502,7 +5209,8 @@ function attachMentionObserver(doc, opts) {
           threadKind: kind,
           threadText: body,
           reason: "solo_room",
-          ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo)
+          ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo),
+          ...makeInvokerFields(bodyAuthorUserId, bodyAuthorName)
         });
       }
     }
@@ -4517,18 +5225,21 @@ function attachMentionObserver(doc, opts) {
       seen.add(key);
       if (isLocal) continue;
       if (i <= lastAgentIdx) continue;
+      const replyAuthorUserId = typeof reply.authorUserId === "string" ? reply.authorUserId : void 0;
+      const replyAuthorName = typeof reply.authorName === "string" ? reply.authorName : void 0;
+      const replyAuthorIsAgent = reply.authorIsAgent === true;
       const replySidecar = checkMentionsSidecar(reply.mentions, identityUserId);
       const isDirect = replySidecar === "hit" || replySidecar === "absent" && hasActingAsMention(reply.text);
       const inActiveThread = activeThreads.has(threadId);
       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) {
+        if (replySidecar !== "miss" && !ANY_AT_MENTION_RE.test(reply.text) && soloHuman && replyAuthorUserId === soloHuman) {
           reason = "solo_room";
         }
       }
       if (!reason) continue;
+      if (replyAuthorIsAgent && reason !== "direct_mention") continue;
       enqueue({
         kind: "mention",
         threadId,
@@ -4536,7 +5247,8 @@ function attachMentionObserver(doc, opts) {
         threadText: reply.text,
         replyId: reply.id,
         reason,
-        ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo)
+        ...resolveAnchoredContext(doc, record.anchorFrom, record.anchorTo),
+        ...makeInvokerFields(replyAuthorUserId, replyAuthorName)
       });
     }
   };
@@ -4552,7 +5264,7 @@ function attachMentionObserver(doc, opts) {
   doc.getMap("suggestions").observe(onChange("suggestion"));
 }
 function hashState(doc) {
-  return Buffer.from(Y4.encodeStateVector(doc)).toString("base64");
+  return Buffer.from(Y5.encodeStateVector(doc)).toString("base64");
 }
 function attachRemoteActivityTracker(doc, opts) {
   const now = opts.now ?? (() => Date.now());
@@ -4564,7 +5276,7 @@ function attachRemoteActivityTracker(doc, opts) {
 // src/identity.ts
 import * as fs from "fs/promises";
 import * as path from "path";
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid as nanoid3 } from "nanoid";
 var PALETTE = [
   "#9333ea",
   // purple-600
@@ -4619,7 +5331,7 @@ async function loadOrCreateIdentity(dir) {
     }
   }
   const identity = {
-    userId: nanoid2(),
+    userId: nanoid3(),
     color: pickColor()
   };
   await saveIdentity(dir, identity);
@@ -4726,15 +5438,18 @@ async function resolveActingAs(actingAsArg) {
   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.",
+        "First Composer room on this machine \u2014 orient the user, then ask what to call you. STOP and output ONE short message before retrying.",
         "",
-        "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.",
+        "The message should cover four things, in order:",
+        '  1. GREET \u2014 open with "Welcome to Composer!"',
+        '  2. WHAT COMPOSER IS \u2014 "Composer is a real-time markdown editor for humans and agents."',
+        '  3. WHAT YOU CAN DO IN IT \u2014 "I can join your docs with you, respond to comments, and post inline suggestions."',
+        "  4. ASK FOR A NAME \u2014 suggest ONE default they can accept in a single word.",
+        `     - 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 as a check, e.g. "I'll go by <suggested name> in the doc if that's okay with you?"`,
         "",
-        `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."
+        "Retry the call with their answer as `actingAs`. The name persists to ~/.composer/user.json and is reused for every future room on this machine, so this orientation only happens once per machine."
       ].join("\n")
     );
   }
@@ -4808,7 +5523,7 @@ var TOOL_DEFS = [
   },
   {
     name: "composer_next_event",
-    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`.",
+    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 a final `timeout` (no `requiredNextToolCall`), the return carries `userMessage` \u2014 the agent's goodbye line in its own voice. Print `userMessage` verbatim as your final output before exiting; do NOT post anything in the doc.",
     inputSchema: {
       type: "object",
       properties: {
@@ -4853,7 +5568,7 @@ var TOOL_DEFS = [
   },
   {
     name: "composer_add_comment",
-    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.",
+    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. Accepts optional `state` (ack-first flow: post with `state: \"thinking\"` to start the live indicator immediately) and `mentions` (array of target userIds \u2014 the invoker's userId from the mention event payload, for the `@invoker` backlink). Returns { id } on success or an isError result if the anchor cannot be resolved.",
     inputSchema: {
       type: "object",
       properties: {
@@ -4867,20 +5582,40 @@ var TOOL_DEFS = [
           },
           required: ["headingId", "textToFind"]
         },
-        text: { type: "string" }
+        text: { type: "string" },
+        state: {
+          type: "string",
+          enum: ["thinking", "working", "replying", "ready"],
+          description: 'Initial lifecycle state for the new comment. Set to "thinking" when posting an ack-first placeholder so the live indicator renders from the moment the record lands \u2014 no stateless flicker while a separate composer_agent_status call catches up.'
+        },
+        mentions: {
+          type: "array",
+          items: { type: "string" },
+          description: "Target userIds of @-mentions in `text`, in order of occurrence. Typically a single entry: the invoker's userId from the triggering mention event. Rendered as bolded mention spans by the client."
+        }
       },
       required: ["roomId", "anchor", "text"]
     }
   },
   {
     name: "composer_reply_comment",
-    description: "Append a reply to an existing comment thread.",
+    description: 'Append a reply to an existing comment thread. Accepts optional `state` (ack-first flow: post with `state: "thinking"` to start the live indicator immediately \u2014 avoids the stateless flicker that occurs if state is added in a separate composer_agent_status call after the reply lands) and `mentions` (array of target userIds \u2014 typically the invoker\'s userId from the triggering mention event).',
     inputSchema: {
       type: "object",
       properties: {
         roomId: { type: "string" },
         threadId: { type: "string" },
-        text: { type: "string" }
+        text: { type: "string" },
+        state: {
+          type: "string",
+          enum: ["thinking", "working", "replying", "ready"],
+          description: 'Initial lifecycle state for the new reply. Set to "thinking" when posting an ack-first placeholder.'
+        },
+        mentions: {
+          type: "array",
+          items: { type: "string" },
+          description: "Target userIds of @-mentions in `text`. Typically the invoker's userId."
+        }
       },
       required: ["roomId", "threadId", "text"]
     }
@@ -4905,20 +5640,40 @@ var TOOL_DEFS = [
           },
           required: ["headingId", "textToFind"]
         },
-        replacementText: { type: "string" }
+        replacementText: { type: "string" },
+        state: {
+          type: "string",
+          enum: ["thinking", "working", "replying", "ready"],
+          description: `Initial lifecycle state for the new suggestion. Set to "working" when drafting a placeholder replacementText users shouldn't accept yet.`
+        },
+        mentions: {
+          type: "array",
+          items: { type: "string" },
+          description: "Target userIds of @-mentions in `replacementText`."
+        }
       },
       required: ["roomId", "replacementText"]
     }
   },
   {
     name: "composer_reply_suggestion",
-    description: "Append a reply to an existing suggestion thread.",
+    description: "Append a reply to an existing suggestion thread. Accepts optional `state` and `mentions` with the same semantics as `composer_reply_comment`.",
     inputSchema: {
       type: "object",
       properties: {
         roomId: { type: "string" },
         threadId: { type: "string" },
-        text: { type: "string" }
+        text: { type: "string" },
+        state: {
+          type: "string",
+          enum: ["thinking", "working", "replying", "ready"],
+          description: "Initial lifecycle state for the new reply."
+        },
+        mentions: {
+          type: "array",
+          items: { type: "string" },
+          description: "Target userIds of @-mentions in `text`."
+        }
       },
       required: ["roomId", "threadId", "text"]
     }
@@ -4934,6 +5689,71 @@ var TOOL_DEFS = [
       },
       required: ["roomId", "threadId"]
     }
+  },
+  {
+    name: "composer_export_to_file",
+    description: "Dump the current Composer doc to a local markdown file. ONE-WAY ONLY: Composer is the source of truth, the file is OVERWRITTEN on every call. The path must be absolute. Use when the user asks to 'save this to a file', 'export to disk', or runs /composer:export. Returns { roomId, path, bytesWritten }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        roomId: { type: "string" },
+        path: {
+          type: "string",
+          description: "Absolute filesystem path to write to. Existing files are overwritten. Parent directory must already exist."
+        }
+      },
+      required: ["roomId", "path"]
+    }
+  },
+  {
+    name: "composer_agent_status",
+    description: 'Drive the live state indicator on an in-flight agent-authored record (a reply, or the thread-head Comment / Suggestion). Use AFTER posting an ack with `state: "thinking"` via the reply/add tools \u2014 this tool advances state mid-work without creating a new reply, and optionally rewrites text in place at completion. Transitions: thinking \u2192 working (tool use started) \u2192 replying (assembling final answer, optional) \u2192 ready (terminal; text now holds the final content OR a thin pointer to a standalone artifact). When `replyId` is set, updates that reply inside `threadId`; when absent, updates the thread-head record (use `kind` to disambiguate). Returns { replyId } for reply updates or { id } for thread-head updates.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        roomId: { type: "string" },
+        threadId: { type: "string" },
+        replyId: {
+          type: "string",
+          description: "ID of the reply to update. Omit to update the thread-head record itself (an agent-authored Comment or Suggestion)."
+        },
+        state: {
+          type: "string",
+          enum: ["thinking", "working", "replying", "ready"],
+          description: "New lifecycle state. `ready` is terminal \u2014 pair with `text` for the final content. Non-ready states update the heartbeat; `text` is optional."
+        },
+        text: {
+          type: "string",
+          description: "Optional new body text. On `ready` transitions this typically carries the final answer or a pointer to a standalone artifact. For suggestion thread-head updates this writes to `replacementText`."
+        },
+        note: {
+          type: "string",
+          description: 'Optional short label describing what the agent is currently doing, e.g. "reading section 3\u2026". Rides on the awareness heartbeat only; not persisted on the record.'
+        },
+        kind: {
+          type: "string",
+          enum: ["comment", "suggestion"],
+          description: 'Disambiguates which map holds the thread-head record. Defaults to "comment"; optional when `replyId` is set.'
+        }
+      },
+      required: ["roomId", "threadId", "state"]
+    }
+  },
+  {
+    name: "composer_done",
+    description: 'Signal that the agent is finished with a thread WITHOUT posting a reply \u2014 clears the live indicator left over from `onEventDelivered` (which publishes a thread-head `agentWork(threadId, undefined, "thinking")` placeholder when a mention is dequeued). Call this when you decide to skip a mention (the skill\'s heuristic filters out chatter, your own mentions, etc.) or otherwise close out a thread without a `state: "ready"` reply landing. The normal reply-with-`ready` path already clears its own placeholder; this tool exists for the skip case where no reply is ever written. Idempotent \u2014 clearing a non-existent entry is a no-op. When `replyId` is set, also clears that per-reply entry (use if you abandoned a thinking-state ack mid-flight).',
+    inputSchema: {
+      type: "object",
+      properties: {
+        roomId: { type: "string" },
+        threadId: { type: "string" },
+        replyId: {
+          type: "string",
+          description: 'Optional reply ID. When set, also clears the per-reply `agentWork` entry \u2014 useful if you posted an ack with `state: "thinking"` and then abandoned the work without reaching `ready`.'
+        }
+      },
+      required: ["roomId", "threadId"]
+    }
   }
 ];
 function okResult(data) {
@@ -4966,6 +5786,33 @@ function asOptionalString(value, field) {
   }
   return value;
 }
+var AGENT_REPLY_STATES = [
+  "thinking",
+  "working",
+  "replying",
+  "ready"
+];
+function asOptionalAgentState(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new Error(`${field} must be a string`);
+  }
+  if (!AGENT_REPLY_STATES.includes(value)) {
+    throw new Error(
+      `${field} must be one of: ${AGENT_REPLY_STATES.join(", ")}`
+    );
+  }
+  return value;
+}
+function asAgentState(value, field) {
+  const s = asOptionalAgentState(value, field);
+  if (s === void 0) {
+    throw new Error(
+      `${field} must be one of: ${AGENT_REPLY_STATES.join(", ")}`
+    );
+  }
+  return s;
+}
 function asAnchor(value) {
   if (!value || typeof value !== "object") {
     throw new Error("anchor must be an object");
@@ -4984,11 +5831,12 @@ function asAnchor(value) {
 }
 function buildMonitorHandoff(roomId, browserUrl, actingAs, opts) {
   const mention = `@${actingAs}`;
-  const step1_sayToUser = opts.isFirstRun ? `${browserUrl}
+  const opener = opts.mode === "create" ? "I've created a new doc for you" : "I've joined the doc";
+  const step1_sayToUser = opts.isFirstRun ? `${opener} and am launching another agent to watch for comments. Tag me (${mention}) in any Composer comment to bring me in \u2014 and share the link to invite other people (or their agents) to collaborate with us.
 
-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}
+${browserUrl}` : `${opener} and am launching another agent to watch for comments. Tag me (${mention}) in any Composer comment to bring me in.
 
-I'm monitoring this doc from the terminal \u2014 tag me with ${mention} in any comment and I'll reply right there.`;
+${browserUrl}`;
   return {
     step1_sayToUser,
     step2_callTool: {
@@ -5028,7 +5876,7 @@ async function handleCreateRoom(args) {
   }
   const { actingAs, isFirstRun } = await resolveActingAs(actingAsArg);
   const identity = await getIdentity();
-  const roomId = nanoid3(10);
+  const roomId = nanoid4(10);
   const browserUrl = browserUrlFor(roomId);
   const state = new RoomState({
     roomId,
@@ -5037,6 +5885,7 @@ async function handleCreateRoom(args) {
     identity
   });
   await state.ensureConnected();
+  state.setMonitoring(true);
   if (seedMarkdown) {
     writeMarkdownToFragment(state.doc.getXmlFragment("default"), seedMarkdown);
   }
@@ -5048,7 +5897,10 @@ async function handleCreateRoom(args) {
     browserUrl,
     actingAs,
     snapshot: state.snapshot(),
-    ...buildMonitorHandoff(roomId, browserUrl, actingAs, { isFirstRun })
+    ...buildMonitorHandoff(roomId, browserUrl, actingAs, {
+      isFirstRun,
+      mode: "create"
+    })
   });
 }
 async function handleJoinRoom(args) {
@@ -5063,6 +5915,9 @@ async function handleJoinRoom(args) {
       roomId,
       actingAs: existing.actingAs
     });
+    existing.clearGoodbye();
+    await existing.ensureConnected();
+    existing.setMonitoring(true);
     existing.scheduleIdleDisconnect(3e4);
     return okResult({
       roomId,
@@ -5073,7 +5928,8 @@ async function handleJoinRoom(args) {
       // 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
+        isFirstRun: false,
+        mode: "join"
       })
     });
   }
@@ -5086,6 +5942,7 @@ async function handleJoinRoom(args) {
     identity
   });
   await state.ensureConnected();
+  state.setMonitoring(true);
   rooms.set(roomId, state);
   log(`composer room joined \u2192 ${browserUrl}`, { roomId, actingAs });
   state.scheduleIdleDisconnect(3e4);
@@ -5094,7 +5951,10 @@ async function handleJoinRoom(args) {
     browserUrl,
     actingAs,
     snapshot: state.snapshot(),
-    ...buildMonitorHandoff(roomId, browserUrl, actingAs, { isFirstRun })
+    ...buildMonitorHandoff(roomId, browserUrl, actingAs, {
+      isFirstRun,
+      mode: "join"
+    })
   });
 }
 function handleAttachRoom(args) {
@@ -5109,7 +5969,14 @@ var ACTIVITY_WINDOW_MS = (() => {
   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.";
+var goodbyeIdleTimeout = (roomId) => `Run \`/composer:join\` when you want me back \u2014 or open the doc again at ${browserUrlFor(roomId)}.`;
+var GOODBYE_SERVER_KICKED = `I'm having trouble reaching the Composer doc. Try restarting your Claude session, or try again in a bit.`;
+var GOODBYE_RECONNECT_ABORTED = `I'm having trouble reaching the Composer doc. Make sure you're connected to the internet or try running \`/composer:join\` in a bit to have me join again.`;
+function terminalRejectGoodbye(state) {
+  if (state.terminalRejectKind === "rejected") return GOODBYE_SERVER_KICKED;
+  if (state.terminalRejectKind === "aborted") return GOODBYE_RECONNECT_ABORTED;
+  return null;
+}
 async function handleNextEvent(args, signal) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
@@ -5120,6 +5987,16 @@ async function handleNextEvent(args, signal) {
       "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."
     );
   }
+  const earlyGoodbye = terminalRejectGoodbye(state);
+  if (earlyGoodbye) {
+    state.markGoodbyeIssued();
+    return okResult({
+      kind: "timeout",
+      recentActivity: false,
+      userMessage: earlyGoodbye,
+      instruction: `Print \`userMessage\` verbatim as your final output, then exit. Do NOT post anything in the doc \u2014 the connection is gone, doc-side awareness is already cleared. Stop calling composer_next_event on this room until the user explicitly rejoins.`
+    });
+  }
   state.setMonitoring(true);
   const onAbort = () => {
     state.setMonitoring(false);
@@ -5148,6 +6025,16 @@ async function handleNextEvent(args, signal) {
       }
     });
   }
+  const lateGoodbye = terminalRejectGoodbye(state);
+  if (lateGoodbye) {
+    state.markGoodbyeIssued();
+    return okResult({
+      kind: "timeout",
+      recentActivity: false,
+      userMessage: lateGoodbye,
+      instruction: `Print \`userMessage\` verbatim as your final output, then exit. Do NOT post anything in the doc \u2014 the connection is gone. Stop calling composer_next_event on this room until the user explicitly rejoins.`
+    });
+  }
   const msSinceActivity = Date.now() - state.lastRemoteActivityAt;
   const recentActivity = msSinceActivity < ACTIVITY_WINDOW_MS;
   const minutesSince = Math.max(1, Math.round(msSinceActivity / 6e4));
@@ -5170,8 +6057,8 @@ async function handleNextEvent(args, signal) {
     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.`
+    userMessage: goodbyeIdleTimeout(roomId),
+    instruction: `Print \`userMessage\` verbatim as your final output, then exit. Do NOT post anything in the doc \u2014 the avatar has already cleared. Stop calling composer_next_event on this room until the user explicitly rejoins.`
   });
 }
 function handleGetSection(args) {
@@ -5237,12 +6124,10 @@ function handleGetThread(args) {
     replies: shapedReplies
   });
 }
-function handleAddComment(args) {
-  const a = asObject(args);
-  const roomId = asString(a.roomId, "roomId");
+function performAddComment(state, a) {
   const anchor = asAnchor(a.anchor);
   const text = asString(a.text, "text");
-  const state = getOrError(roomId);
+  const agentState = asOptionalAgentState(a.state, "state");
   const resolved = resolveServerAnchor(state.doc, anchor);
   if (!resolved.ok) {
     return errorResult(
@@ -5250,36 +6135,59 @@ function handleAddComment(args) {
 ${resolved.currentSectionText}`
     );
   }
-  const id = nanoid3();
-  const comments = state.doc.getMap("comments");
-  comments.set(id, {
+  const id = nanoid4();
+  const createdAt = Date.now();
+  const comment = {
     id,
     authorName: state.actingAs,
     authorColor: state.identity.color,
     authorUserId: state.identity.userId,
     authorIsAgent: true,
     text,
-    createdAt: Date.now(),
+    createdAt,
     resolved: false,
     anchorFrom: resolved.from,
     anchorTo: resolved.to,
-    replies: []
+    replies: [],
+    ...agentState !== void 0 ? { state: agentState } : {}
+  };
+  Y6.transact(state.doc, () => {
+    state.doc.getMap("comments").set(id, comment);
+    emitActivity(state.doc, {
+      type: "comment",
+      threadId: id,
+      authorName: state.actingAs,
+      authorColor: state.identity.color,
+      authorUserId: state.identity.userId,
+      authorIsAgent: true,
+      text: textPreview(text),
+      participantUserIds: getParticipantUserIds(comment),
+      createdAt
+    });
   });
   state.markThreadActive(id);
+  if (agentState !== void 0 && agentState !== "ready") {
+    state.publishAgentWork(id, void 0, agentState);
+  }
   return okResult({ id });
 }
-function handleReplyComment(args) {
+function handleAddComment(args) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
+  const state = getOrError(roomId);
+  return performAddComment(state, a);
+}
+function performReplyComment(state, a) {
   const threadId = asString(a.threadId, "threadId");
   const text = asString(a.text, "text");
-  const state = getOrError(roomId);
+  const agentState = asOptionalAgentState(a.state, "state");
   const comments = state.doc.getMap("comments");
   const existing = comments.get(threadId);
   if (!existing) {
     return errorResult(`comment not found: ${threadId}`);
   }
-  const replyId = nanoid3();
+  const replyId = nanoid4();
+  const createdAt = Date.now();
   const reply = {
     id: replyId,
     authorName: state.actingAs,
@@ -5287,21 +6195,49 @@ function handleReplyComment(args) {
     authorUserId: state.identity.userId,
     authorIsAgent: true,
     text,
-    createdAt: Date.now()
+    createdAt,
+    ...agentState !== void 0 ? { state: agentState } : {}
   };
-  comments.set(threadId, {
+  const updated = {
     ...existing,
     replies: [...existing.replies ?? [], reply]
+  };
+  Y6.transact(state.doc, () => {
+    comments.set(threadId, updated);
+    emitActivity(state.doc, {
+      type: "reply",
+      threadId,
+      replyId,
+      threadKind: "comment",
+      authorName: state.actingAs,
+      authorColor: state.identity.color,
+      authorUserId: state.identity.userId,
+      authorIsAgent: true,
+      text: textPreview(text),
+      participantUserIds: getParticipantUserIds(
+        updated
+      ),
+      createdAt
+    });
   });
   state.markThreadActive(threadId);
+  if (agentState !== void 0 && agentState !== "ready") {
+    state.publishAgentWork(threadId, replyId, agentState);
+  } else if (agentState === "ready") {
+    state.clearAgentWork(threadId, void 0);
+  }
   return okResult({ replyId });
 }
-function handleAddSuggestion(args) {
+function handleReplyComment(args) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
+  const state = getOrError(roomId);
+  return performReplyComment(state, a);
+}
+function performAddSuggestion(state, a) {
   const replacementText = asString(a.replacementText, "replacementText");
   const fromThreadId = asOptionalString(a.fromThreadId, "fromThreadId");
-  const state = getOrError(roomId);
+  const agentState = asOptionalAgentState(a.state, "state");
   let anchorFrom;
   let anchorTo;
   let originalText;
@@ -5337,38 +6273,61 @@ ${resolved.currentSectionText}`
     anchorTo = resolved.to;
     originalText = anchor.textToFind;
   }
-  const id = nanoid3();
-  const suggestions = state.doc.getMap("suggestions");
-  suggestions.set(id, {
+  const id = nanoid4();
+  const createdAt = Date.now();
+  const suggestion = {
     id,
     authorName: state.actingAs,
     authorColor: state.identity.color,
     authorUserId: state.identity.userId,
     authorIsAgent: true,
-    createdAt: Date.now(),
+    createdAt,
     status: "pending",
     anchorFrom,
     anchorTo,
     replacementText,
     originalText,
-    replies: []
+    replies: [],
+    ...agentState !== void 0 ? { state: agentState } : {}
+  };
+  Y6.transact(state.doc, () => {
+    state.doc.getMap("suggestions").set(id, suggestion);
+    emitActivity(state.doc, {
+      type: "suggestion",
+      threadId: id,
+      authorName: state.actingAs,
+      authorColor: state.identity.color,
+      authorUserId: state.identity.userId,
+      authorIsAgent: true,
+      text: textPreview(replacementText),
+      participantUserIds: getParticipantUserIds(suggestion),
+      createdAt
+    });
   });
   state.markThreadActive(id);
   if (fromThreadId) state.markThreadActive(fromThreadId);
+  if (agentState !== void 0 && agentState !== "ready") {
+    state.publishAgentWork(id, void 0, agentState);
+  }
   return okResult({ id });
 }
-function handleReplySuggestion(args) {
+function handleAddSuggestion(args) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
+  const state = getOrError(roomId);
+  return performAddSuggestion(state, a);
+}
+function performReplySuggestion(state, a) {
   const threadId = asString(a.threadId, "threadId");
   const text = asString(a.text, "text");
-  const state = getOrError(roomId);
+  const agentState = asOptionalAgentState(a.state, "state");
   const suggestions = state.doc.getMap("suggestions");
   const existing = suggestions.get(threadId);
   if (!existing) {
     return errorResult(`suggestion not found: ${threadId}`);
   }
-  const replyId = nanoid3();
+  const replyId = nanoid4();
+  const createdAt = Date.now();
   const reply = {
     id: replyId,
     authorName: state.actingAs,
@@ -5376,28 +6335,213 @@ function handleReplySuggestion(args) {
     authorUserId: state.identity.userId,
     authorIsAgent: true,
     text,
-    createdAt: Date.now()
+    createdAt,
+    ...agentState !== void 0 ? { state: agentState } : {}
   };
-  suggestions.set(threadId, {
+  const updated = {
     ...existing,
     replies: [...existing.replies ?? [], reply]
+  };
+  Y6.transact(state.doc, () => {
+    suggestions.set(threadId, updated);
+    emitActivity(state.doc, {
+      type: "reply",
+      threadId,
+      replyId,
+      threadKind: "suggestion",
+      authorName: state.actingAs,
+      authorColor: state.identity.color,
+      authorUserId: state.identity.userId,
+      authorIsAgent: true,
+      text: textPreview(text),
+      participantUserIds: getParticipantUserIds(
+        updated
+      ),
+      createdAt
+    });
   });
   state.markThreadActive(threadId);
+  if (agentState !== void 0 && agentState !== "ready") {
+    state.publishAgentWork(threadId, replyId, agentState);
+  } else if (agentState === "ready") {
+    state.clearAgentWork(threadId, void 0);
+  }
   return okResult({ replyId });
 }
-function handleResolveThread(args) {
+function handleReplySuggestion(args) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
-  const threadId = asString(a.threadId, "threadId");
   const state = getOrError(roomId);
+  return performReplySuggestion(state, a);
+}
+function performResolveThread(state, a) {
+  const threadId = asString(a.threadId, "threadId");
   const comments = state.doc.getMap("comments");
   const existing = comments.get(threadId);
   if (!existing) {
     return errorResult(`comment not found: ${threadId}`);
   }
-  comments.set(threadId, { ...existing, resolved: true });
+  const createdAt = Date.now();
+  Y6.transact(state.doc, () => {
+    comments.set(threadId, { ...existing, resolved: true });
+    emitActivity(state.doc, {
+      type: "resolve",
+      threadId,
+      authorName: state.actingAs,
+      authorColor: state.identity.color,
+      authorUserId: state.identity.userId,
+      authorIsAgent: true,
+      participantUserIds: getParticipantUserIds(existing),
+      createdAt
+    });
+  });
   return okResult({ threadId, resolved: true });
 }
+function handleResolveThread(args) {
+  const a = asObject(args);
+  const roomId = asString(a.roomId, "roomId");
+  const state = getOrError(roomId);
+  return performResolveThread(state, a);
+}
+function performAgentStatus(state, a) {
+  const threadId = asString(a.threadId, "threadId");
+  const agentState = asAgentState(a.state, "state");
+  const replyIdArg = asOptionalString(a.replyId, "replyId");
+  const textArg = asOptionalString(a.text, "text");
+  asOptionalString(a.note, "note");
+  const note = typeof a.note === "string" && a.note.length > 0 ? a.note : void 0;
+  const kindArg = a.kind === void 0 ? "comment" : a.kind === "comment" || a.kind === "suggestion" ? a.kind : null;
+  if (kindArg === null) {
+    return errorResult(`kind must be "comment" or "suggestion"`);
+  }
+  const commentsMap = state.doc.getMap("comments");
+  const suggestionsMap = state.doc.getMap("suggestions");
+  const preferredMap = kindArg === "comment" ? commentsMap : suggestionsMap;
+  const fallbackMap = kindArg === "comment" ? suggestionsMap : commentsMap;
+  let parent = preferredMap.get(threadId);
+  let resolvedKind = kindArg;
+  if (!parent) {
+    const fallback = fallbackMap.get(threadId);
+    if (fallback) {
+      parent = fallback;
+      resolvedKind = kindArg === "comment" ? "suggestion" : "comment";
+    }
+  }
+  if (!parent) {
+    return errorResult(`thread not found: ${threadId}`);
+  }
+  const parentMap = resolvedKind === "comment" ? commentsMap : suggestionsMap;
+  const currentWork = state.readAgentWork();
+  for (const entry of currentWork) {
+    const p = commentsMap.get(entry.threadId) ?? suggestionsMap.get(entry.threadId);
+    if (!p) continue;
+    if (entry.replyId !== void 0) {
+      const replies = Array.isArray(p.replies) ? p.replies : [];
+      const targetReply = replies.find(
+        (r) => !!r && typeof r === "object" && r.id === entry.replyId
+      );
+      if (targetReply && targetReply.state === "ready") {
+        state.clearAgentWork(entry.threadId, entry.replyId);
+      }
+    } else {
+      if (p.state === "ready") {
+        state.clearAgentWork(entry.threadId, void 0);
+      }
+    }
+  }
+  if (replyIdArg !== void 0) {
+    const replies = Array.isArray(parent.replies) ? parent.replies : [];
+    const replyIdx = replies.findIndex(
+      (r) => !!r && typeof r === "object" && r.id === replyIdArg
+    );
+    if (replyIdx < 0) {
+      return errorResult(`reply not found: ${replyIdArg} on thread ${threadId}`);
+    }
+    if (agentState === "ready") {
+      state.clearAgentWork(threadId, replyIdArg);
+      state.clearAgentWork(threadId, void 0);
+    }
+    const existingReply = replies[replyIdx];
+    const nextReply = {
+      ...existingReply,
+      state: agentState
+    };
+    if (textArg !== void 0) nextReply.text = textArg;
+    const nextReplies = replies.slice();
+    nextReplies[replyIdx] = nextReply;
+    parentMap.set(threadId, { ...parent, replies: nextReplies });
+    if (agentState !== "ready") {
+      state.publishAgentWork(threadId, replyIdArg, agentState, note);
+    }
+    return okResult({ replyId: replyIdArg });
+  }
+  if (agentState === "ready") {
+    state.clearAgentWork(threadId, void 0);
+  }
+  const nextRecord = { ...parent, state: agentState };
+  if (textArg !== void 0) {
+    if (resolvedKind === "suggestion") {
+      nextRecord.replacementText = textArg;
+    } else {
+      nextRecord.text = textArg;
+    }
+  }
+  parentMap.set(threadId, nextRecord);
+  if (agentState !== "ready") {
+    state.publishAgentWork(threadId, void 0, agentState, note);
+  }
+  return okResult({ id: threadId });
+}
+function handleAgentStatus(args) {
+  const a = asObject(args);
+  const roomId = asString(a.roomId, "roomId");
+  const state = getOrError(roomId);
+  return performAgentStatus(state, a);
+}
+function performDone(state, a) {
+  const threadId = asString(a.threadId, "threadId");
+  const replyIdArg = asOptionalString(a.replyId, "replyId");
+  state.clearAgentWork(threadId, void 0);
+  if (replyIdArg !== void 0) {
+    state.clearAgentWork(threadId, replyIdArg);
+  }
+  return okResult({ threadId });
+}
+function handleDone(args) {
+  const a = asObject(args);
+  const roomId = asString(a.roomId, "roomId");
+  const state = getOrError(roomId);
+  return performDone(state, a);
+}
+async function handleExportToFile(args) {
+  const a = asObject(args);
+  const roomId = asString(a.roomId, "roomId");
+  const filePath = asString(a.path, "path");
+  if (!path3.isAbsolute(filePath)) {
+    return errorResult(
+      `path must be absolute, got: ${filePath}. Resolve to an absolute path before calling.`
+    );
+  }
+  const state = getOrError(roomId);
+  const markdown = serializeDocAsMarkdown(state.doc);
+  try {
+    await fs3.writeFile(filePath, markdown, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return errorResult(`failed to write ${filePath}: ${message}`);
+  }
+  return okResult({
+    roomId,
+    path: filePath,
+    bytesWritten: Buffer.byteLength(markdown, "utf8")
+  });
+}
+function _registerRoomForTest(roomId, state) {
+  rooms.set(roomId, state);
+}
+function _clearRoomsForTest() {
+  rooms.clear();
+}
 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";
@@ -5406,33 +6550,44 @@ async function dispatchTool(name, args, signal) {
     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}`);
+    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);
+        case "composer_export_to_file":
+          return await handleExportToFile(args);
+        case "composer_agent_status":
+          return handleAgentStatus(args);
+        case "composer_done":
+          return handleDone(args);
+        default:
+          return errorResult(`unknown tool: ${name}`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return errorResult(message);
     }
   } finally {
     state?.scheduleIdleDisconnect(3e4);
@@ -5587,6 +6742,16 @@ export {
   loadOrCreateIdentity,
   logError,
   teardownAllRooms,
+  performAddComment,
+  performReplyComment,
+  performAddSuggestion,
+  performReplySuggestion,
+  performResolveThread,
+  performAgentStatus,
+  performDone,
+  _registerRoomForTest,
+  _clearRoomsForTest,
+  dispatchTool,
   startMcpServer,
   startMcpHttpServer,
   __test_dispatch,