@composer-app/mcp 0.0.1-beta.4 → 0.0.1-beta.7

package/dist/{chunk-UVXQZ2TN.js → chunk-EJUJPBX2.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,24 @@ 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 RoomState = class _RoomState {
+  doc;
   actingAs;
   identity;
   roomId;
@@ -4185,58 +4565,62 @@ var RoomState = class {
    * on every remote edit, comment, suggestion, or activity-feed write.
    */
   _lastRemoteActivityAt = Date.now();
+  monitoringOn = false;
+  /**
+   * Set true when `composer_next_event`'s goodbye branch has fired. Tells
+   * `handleNextEvent` to refuse subsequent calls until the user explicitly
+   * re-engages (which happens via `composer_create_room` / `composer_join_room`,
+   * both of which build a fresh `RoomState` so this flag resets naturally).
+   */
+  goodbyeIssued = false;
   constructor(opts) {
     this.roomId = opts.roomId;
     this.actingAs = opts.actingAs;
     this.identity = opts.identity;
+    this.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: true,
-      WebSocketPolyfill: WebSocket
-    });
-    this.provider.awareness.setLocalStateField("user", {
-      name: opts.actingAs,
-      color: opts.identity.color,
-      userId: opts.identity.userId,
-      isAgent: true
-    });
-    this.installAwarenessHeartbeat();
+    if (opts._providerForTest) {
+      this.provider = opts._providerForTest;
+    } else {
+      this.provider = new YProvider(opts.serverHost, opts.roomId, this.doc, {
+        party: "composer-room",
+        connect: false,
+        WebSocketPolyfill: WebSocket
+      });
+    }
   }
   /**
-   * Re-broadcast the MCP's awareness every 15s.
-   *
-   * y-partyserver's provider disables the y-protocols awareness
-   * `_checkInterval` (see `clearInterval(awareness._checkInterval)` in
-   * `y-partyserver/dist/provider/index.js`), so the MCP sends its awareness
-   * exactly once — on connect — and never heartbeats after that. Combined
-   * with Cloudflare Durable Object hibernation (which evicts the server's
-   * in-memory `document.awareness` Map on wake), this means a browser that
-   * connects more than ~60s after the MCP sees an empty awareness dump in
-   * `onConnect` and never learns the agent is there. The user's own
-   * awareness flows the other direction fine (they send on connect, server
-   * broadcasts to the MCP), which is why the failure is asymmetric.
-   *
-   * y-partyserver's provider listens to `awareness.on("change", ...)`, and
-   * y-protocols only fires `change` when the new state is deep-unequal to
-   * the previous one. Re-setting an identical state emits `update` but NOT
-   * `change`, so the provider never sends a wire frame. We bump a throwaway
-   * `_hb` field each tick to guarantee deep-inequality, forcing the change
-   * event and a broadcast. 15s is well under any realistic hibernation gap.
+   * 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`.
    */
-  installAwarenessHeartbeat() {
-    const heartbeat = setInterval(() => {
-      const local = this.provider.awareness.getLocalState();
-      if (local !== null) {
-        this.provider.awareness.setLocalState({ ...local, _hb: Date.now() });
+  static createForTest(opts) {
+    const doc = new Y5.Doc();
+    const awareness = new Awareness(doc);
+    const fake = {
+      awareness,
+      synced: true,
+      destroy() {
+        awareness.destroy();
       }
-    }, 15e3);
-    heartbeat.unref?.();
+    };
+    return new _RoomState({
+      roomId: opts.roomId,
+      serverHost: "test://noop",
+      actingAs: opts.actingAs,
+      identity: opts.identity,
+      _providerForTest: fake,
+      _docForTest: doc
+    });
+  }
+  /** Test-only accessor for the underlying awareness instance. */
+  get awarenessForTest() {
+    return this.provider.awareness;
   }
   /**
    * Resolves when the provider has completed its first sync handshake.
@@ -4246,24 +4630,142 @@ var RoomState = class {
    */
   async waitForInitialSync(timeoutMs = 15e3) {
     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);
+        offSub("sync", onSync);
         resolve();
       };
       const timer = setTimeout(() => {
-        this.provider.off("sync", onSync);
+        offSub("sync", onSync);
         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);
     });
   }
+  idleDisconnectTimer = null;
+  /**
+   * Open the WebSocket (if not already) and await the first sync handshake.
+   * Idempotent — no-op if already connected and synced. Call at the top of
+   * every tool handler that touches the doc. Cancels any pending idle
+   * disconnect because we're back in active use.
+   */
+  async ensureConnected(timeoutMs = 15e3) {
+    if (this.idleDisconnectTimer) {
+      clearTimeout(this.idleDisconnectTimer);
+      this.idleDisconnectTimer = null;
+    }
+    if (!this.provider.connect) return;
+    if (this.provider.wsconnected && this.provider.synced) return;
+    await this.provider.connect();
+    await this.waitForInitialSync(timeoutMs);
+  }
+  /**
+   * Arm a timer that turns monitoring off and closes the socket after `ms`
+   * of no further tool-handler activity. Cancelled by `ensureConnected`.
+   * Call at the end of every tool handler. Defaults to 30s — long enough
+   * to bridge a normal multi-step monitor turn (mention → reply →
+   * `composer_next_event` again), short enough that an abandoned monitor
+   * loop fades the avatar within the "within a minute" window the user
+   * requested.
+   *
+   * Both presence cleanup paths converge here: setMonitoring(false) clears
+   * our local awareness state, then disconnect() closes the socket which
+   * triggers y-partyserver's onClose → removeAwarenessStates. Either alone
+   * would suffice; doing both keeps local and server state consistent.
+   */
+  scheduleIdleDisconnect(ms = 3e4) {
+    if (this.idleDisconnectTimer) {
+      clearTimeout(this.idleDisconnectTimer);
+      this.idleDisconnectTimer = null;
+    }
+    if (!this.provider.disconnect) return;
+    if (!this.provider.wsconnected) return;
+    this.idleDisconnectTimer = setTimeout(() => {
+      this.idleDisconnectTimer = null;
+      this.setMonitoring(false);
+      this.provider.disconnect?.();
+    }, ms);
+    this.idleDisconnectTimer.unref?.();
+  }
+  /**
+   * Close the socket immediately. Available for explicit teardown
+   * (e.g., destroy()). Does not touch monitoring state — the socket close
+   * causes y-partyserver to broadcast the awareness removal, which is the
+   * visual signal peers care about.
+   */
+  disconnect() {
+    if (this.idleDisconnectTimer) {
+      clearTimeout(this.idleDisconnectTimer);
+      this.idleDisconnectTimer = null;
+    }
+    this.provider.disconnect?.();
+  }
+  /**
+   * Toggle whether the agent is visibly monitoring the room. Broadcast via
+   * the `user` awareness field — present ↔ avatar visible to peers. The
+   * socket must already be open (caller should have ensured this).
+   *
+   *   setMonitoring(true)  — called once on first composer_next_event entry.
+   *   setMonitoring(false) — called on the goodbye branch; clears awareness
+   *                          immediately so the avatar disappears as the
+   *                          farewell lands.
+   *
+   * Subsequent calls with the same value are no-ops.
+   */
+  setMonitoring(on) {
+    if (this.monitoringOn === on) return;
+    this.monitoringOn = on;
+    if (on) {
+      const current = this.provider.awareness.getLocalState() ?? {};
+      this.provider.awareness.setLocalState({
+        ...current,
+        user: {
+          name: this.actingAs,
+          color: this.identity.color,
+          userId: this.identity.userId,
+          isAgent: true
+        }
+      });
+    } else {
+      this.provider.awareness.setLocalState(null);
+    }
+  }
+  get isMonitoring() {
+    return this.monitoringOn;
+  }
+  /**
+   * Latch flipped by `composer_next_event`'s goodbye branch. Once set, the
+   * model is expected to stop calling `composer_next_event` until the user
+   * explicitly asks to rejoin — which builds a fresh RoomState, resetting
+   * the latch. The MCP refuses further next_event calls on this RoomState
+   * instead of silently re-entering the monitor loop.
+   */
+  markGoodbyeIssued() {
+    this.goodbyeIssued = true;
+  }
+  get hasIssuedGoodbye() {
+    return this.goodbyeIssued;
+  }
+  /**
+   * Read-only view of this client's local awareness state. Exposed for
+   * tests/diagnostics only — production code should not depend on this.
+   * Returns `null` when monitoring is off (local state cleared) or when
+   * the provider hasn't written any fields yet.
+   */
+  getLocalAwareness() {
+    return this.provider.awareness.getLocalState();
+  }
   snapshot() {
     return {
       fullDoc: serializeDocAsMarkdown(this.doc),
@@ -4272,23 +4774,54 @@ var RoomState = class {
       threadsBacklog: []
     };
   }
-  async nextEvent(timeoutMs) {
+  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 timer = setTimeout(() => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
         const idx = this.waiters.indexOf(waiter);
         if (idx >= 0) this.waiters.splice(idx, 1);
+      };
+      const timer = setTimeout(() => {
+        cleanup();
         resolve({ kind: "timeout" });
       }, timeoutMs);
+      const onAbort = () => {
+        cleanup();
+        resolve({ kind: "timeout" });
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
       const waiter = (ev) => {
-        clearTimeout(timer);
+        cleanup();
+        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;
+    }
     this.provider.destroy();
     this.doc.destroy();
   }
@@ -4300,14 +4833,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, {
@@ -4316,9 +4919,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
@@ -4364,10 +4984,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) {
@@ -4392,7 +5026,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)) {
@@ -4405,7 +5040,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)
         });
       }
     }
@@ -4420,18 +5056,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,
@@ -4439,7 +5078,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)
       });
     }
   };
@@ -4455,7 +5095,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());
@@ -4467,7 +5107,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
@@ -4522,7 +5162,7 @@ async function loadOrCreateIdentity(dir) {
     }
   }
   const identity = {
-    userId: nanoid2(),
+    userId: nanoid3(),
     color: pickColor()
   };
   await saveIdentity(dir, identity);
@@ -4605,6 +5245,18 @@ var SERVER_HOST = process.env.COMPOSER_SERVER_HOST ?? "usecomposer.app";
 var APP_BASE = process.env.COMPOSER_APP_BASE ?? "https://usecomposer.app";
 var rooms = /* @__PURE__ */ new Map();
 var identityCache = null;
+function teardownAllRooms() {
+  for (const [roomId, state] of rooms) {
+    try {
+      state.setMonitoring(false);
+      state.disconnect();
+      state.destroy();
+    } catch (err) {
+      logError(`teardown error for room ${roomId}`, err);
+    }
+  }
+  rooms.clear();
+}
 async function getIdentity() {
   if (!identityCache) {
     identityCache = await loadOrCreateIdentity(COMPOSER_DIR2);
@@ -4699,12 +5351,12 @@ var TOOL_DEFS = [
   },
   {
     name: "composer_next_event",
-    description: "Block for up to `timeoutSec` (default 600 / 10 min) 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 `timeout`, `recentActivity` tells you whether to keep monitoring or exit with the goodbye line from `userMessage`.",
     inputSchema: {
       type: "object",
       properties: {
         roomId: { type: "string" },
-        timeoutSec: { type: "number", default: 600 }
+        timeoutSec: { type: "number", default: 30 }
       },
       required: ["roomId"]
     }
@@ -4744,7 +5396,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: {
@@ -4758,20 +5410,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"]
     }
@@ -4796,20 +5468,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"]
     }
@@ -4825,6 +5517,56 @@ var TOOL_DEFS = [
       },
       required: ["roomId", "threadId"]
     }
+  },
+  {
+    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) {
@@ -4857,6 +5599,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");
@@ -4919,7 +5688,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,
@@ -4927,12 +5696,13 @@ async function handleCreateRoom(args) {
     actingAs,
     identity
   });
-  await state.waitForInitialSync();
+  await state.ensureConnected();
   if (seedMarkdown) {
     writeMarkdownToFragment(state.doc.getXmlFragment("default"), seedMarkdown);
   }
   rooms.set(roomId, state);
   log(`composer room created \u2192 ${browserUrl}`, { roomId, actingAs });
+  state.scheduleIdleDisconnect(3e4);
   return okResult({
     roomId,
     browserUrl,
@@ -4953,6 +5723,7 @@ async function handleJoinRoom(args) {
       roomId,
       actingAs: existing.actingAs
     });
+    existing.scheduleIdleDisconnect(3e4);
     return okResult({
       roomId,
       browserUrl,
@@ -4974,9 +5745,10 @@ async function handleJoinRoom(args) {
     actingAs,
     identity
   });
-  await state.waitForInitialSync();
+  await state.ensureConnected();
   rooms.set(roomId, state);
   log(`composer room joined \u2192 ${browserUrl}`, { roomId, actingAs });
+  state.scheduleIdleDisconnect(3e4);
   return okResult({
     roomId,
     browserUrl,
@@ -4991,14 +5763,41 @@ function handleAttachRoom(args) {
   const state = getOrError(roomId);
   return okResult({ roomId, snapshot: state.snapshot() });
 }
-var ACTIVITY_WINDOW_MS = 10 * 60 * 1e3;
+var ACTIVITY_WINDOW_MS = (() => {
+  const raw = process.env.COMPOSER_ACTIVITY_WINDOW_MS;
+  if (!raw) return 15 * 60 * 1e3;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : 15 * 60 * 1e3;
+})();
 var LEAVE_MESSAGE = "I've left the document. You can ask me to rejoin anytime and I'll continue replying.";
-async function handleNextEvent(args) {
+async function handleNextEvent(args, signal) {
   const a = asObject(args);
   const roomId = asString(a.roomId, "roomId");
-  const timeoutSec = typeof a.timeoutSec === "number" && Number.isFinite(a.timeoutSec) ? a.timeoutSec : 600;
+  const timeoutSec = typeof a.timeoutSec === "number" && Number.isFinite(a.timeoutSec) ? a.timeoutSec : 30;
   const state = getOrError(roomId);
-  const event = await state.nextEvent(timeoutSec * 1e3);
+  if (state.hasIssuedGoodbye) {
+    return errorResult(
+      "Already said goodbye for this room. The user must explicitly ask you to rejoin (which will trigger a fresh `composer_join_room`). Do not call `composer_next_event` again on this roomId."
+    );
+  }
+  state.setMonitoring(true);
+  const onAbort = () => {
+    state.setMonitoring(false);
+    state.disconnect();
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  let event;
+  try {
+    event = await state.nextEvent(timeoutSec * 1e3, signal);
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+  }
+  if (signal?.aborted) {
+    return okResult({ kind: "aborted" });
+  }
   if (event.kind === "mention") {
     return okResult({
       ...event,
@@ -5024,6 +5823,9 @@ async function handleNextEvent(args) {
       }
     });
   }
+  state.setMonitoring(false);
+  state.disconnect();
+  state.markGoodbyeIssued();
   return okResult({
     kind: "timeout",
     recentActivity: false,
@@ -5095,12 +5897,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(
@@ -5108,36 +5908,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,
@@ -5145,21 +5968,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;
@@ -5195,38 +6046,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,
@@ -5234,56 +6108,237 @@ 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 });
 }
-async function dispatchTool(name, args) {
-  switch (name) {
-    case "composer_create_room":
-      return handleCreateRoom(args);
-    case "composer_join_room":
-      return handleJoinRoom(args);
-    case "composer_attach_room":
-      return handleAttachRoom(args);
-    case "composer_next_event":
-      return handleNextEvent(args);
-    case "composer_get_section":
-      return handleGetSection(args);
-    case "composer_get_full_doc":
-      return handleGetFullDoc(args);
-    case "composer_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}`);
+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);
+}
+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";
+  const state = needsExistingRoom && typeof roomId === "string" ? rooms.get(roomId) : void 0;
+  if (state) {
+    await state.ensureConnected();
+  }
+  try {
+    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_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);
   }
 }
 function buildServer() {
@@ -5294,13 +6349,13 @@ function buildServer() {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOL_DEFS
   }));
-  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
     const { name, arguments: args } = req.params;
     const roomId = args && typeof args === "object" && "roomId" in args ? args.roomId : void 0;
     const started = Date.now();
     log(`tool ${name} call`, { roomId });
     try {
-      const result = await dispatchTool(name, args);
+      const result = await dispatchTool(name, args, extra.signal);
       const elapsedMs = Date.now() - started;
       if (result.isError) {
         const detail = result.content[0]?.text ?? "";
@@ -5327,7 +6382,7 @@ async function startMcpServer() {
   log("mcp server starting", {
     pid: process.pid,
     node: process.version,
-    build: "awareness-heartbeat-v1"
+    build: "socket-driven-v1"
   });
   const server = buildServer();
   const transport = new StdioServerTransport();
@@ -5339,6 +6394,28 @@ async function startMcpServer() {
     logFile: LOG_FILE_PATH,
     pid: process.pid
   });
+  installShutdownHandlers("stdio");
+}
+function installShutdownHandlers(transport) {
+  let shuttingDown = false;
+  const shutdown = (reason) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log(`mcp shutdown \u2014 ${reason}`, { transport });
+    try {
+      teardownAllRooms();
+    } catch (err) {
+      logError("teardownAllRooms failed", err);
+    }
+    setTimeout(() => process.exit(0), 200).unref?.();
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGHUP", () => shutdown("SIGHUP"));
+  if (transport === "stdio") {
+    process.stdin.on("end", () => shutdown("stdin-end"));
+    process.stdin.on("close", () => shutdown("stdin-close"));
+  }
 }
 async function startMcpHttpServer(opts) {
   installCrashHandlers();
@@ -5346,7 +6423,7 @@ async function startMcpHttpServer(opts) {
     port: opts.port,
     pid: process.pid,
     node: process.version,
-    build: "awareness-heartbeat-v1"
+    build: "socket-driven-v1"
   });
   const server = buildServer();
   const transport = new StreamableHTTPServerTransport({
@@ -5392,18 +6469,40 @@ async function startMcpHttpServer(opts) {
   appBase=${APP_BASE}`
     );
   });
-  const shutdown = () => {
-    log("mcp http server shutting down");
+  installShutdownHandlers("http");
+  const closeServer = () => {
     httpServer.close(() => process.exit(0));
     setTimeout(() => process.exit(0), 500).unref();
   };
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", closeServer);
+  process.on("SIGINT", closeServer);
+  process.on("SIGHUP", closeServer);
 }
+var __test_dispatch = dispatchTool;
+var __test_setRoom = (id, state) => {
+  rooms.set(id, state);
+};
+var __test_clearRooms = () => {
+  rooms.clear();
+};
 
 export {
   loadOrCreateIdentity,
   logError,
+  teardownAllRooms,
+  performAddComment,
+  performReplyComment,
+  performAddSuggestion,
+  performReplySuggestion,
+  performResolveThread,
+  performAgentStatus,
+  performDone,
+  _registerRoomForTest,
+  _clearRoomsForTest,
+  dispatchTool,
   startMcpServer,
-  startMcpHttpServer
+  startMcpHttpServer,
+  __test_dispatch,
+  __test_setRoom,
+  __test_clearRooms
 };