@gorlitzer-labs/apiary 1.13.3

package/dist/chunk-ZEFRNAX6.js

@@ -0,0 +1,1771 @@
+import {
+  MODE_DESCRIPTIONS,
+  can,
+  formatEvent,
+  formatTimestamp,
+  messageRef
+} from "./chunk-QL66XSDB.js";
+import {
+  EVENT_ROLE,
+  EventCategory,
+  createEvent
+} from "./chunk-BZ4VDWC2.js";
+
+// src/agent/room-data-source.ts
+var LocalRoomDataSource = class {
+  constructor(_room, _channel) {
+    this._room = _room;
+    this._channel = _channel;
+  }
+  _room;
+  _channel;
+  get roomId() {
+    return this._room.roomId;
+  }
+  get selfId() {
+    return this._channel.participantId;
+  }
+  /** Direct access to the underlying Room (for backward compat / internal use). */
+  get room() {
+    return this._room;
+  }
+  /** Direct access to the underlying Channel (for backward compat / internal use). */
+  get channel() {
+    return this._channel;
+  }
+  listParticipants() {
+    return this._room.listParticipants();
+  }
+  async getMessage(id) {
+    return this._room.getMessage(id);
+  }
+  async searchMessages(query, limit = 10, cursor = null) {
+    return this._room.searchMessages(query, limit, cursor);
+  }
+  async getMessages(limit = 30, cursor = null) {
+    return this._room.listMessages(limit, cursor);
+  }
+  async getEvents(category = null, limit = 50, cursor = null) {
+    return this._room.listEvents(category, limit, cursor);
+  }
+  async sendMessage(content, replyToId, image, attachments, recipients) {
+    return this._channel.sendMessage(content, replyToId, image ?? void 0, attachments, recipients);
+  }
+  async emitEvent(event) {
+    await this._channel.emit(event);
+  }
+};
+
+// src/agent/engagement.ts
+var ENGAGEMENT_MODE_NAMES = [
+  "everyone",
+  "people",
+  "agents",
+  "fight",
+  "standby-everyone",
+  "standby-people",
+  "standby-agents"
+];
+function parseEngagementMode(value) {
+  if (!value) return void 0;
+  const lc = value.trim().toLowerCase();
+  if (lc === "standby") return "standby-everyone";
+  return ENGAGEMENT_MODE_NAMES.includes(lc) ? lc : void 0;
+}
+function senderMatches(filter, senderType, senderId) {
+  switch (filter) {
+    case "everyone":
+      return true;
+    case "fight":
+      return true;
+    case "people":
+      return senderType === "human";
+    case "agents":
+      return senderType === "agent";
+    default:
+      return false;
+  }
+}
+function isWhisperTo(event, selfId) {
+  if (event.type !== "MessageSent") return false;
+  const recipients = event.message.recipients;
+  if (!recipients || recipients.length === 0) return false;
+  return recipients.includes(selfId);
+}
+function classify(event, mode, selfId, senderType, senderId) {
+  const role = EVENT_ROLE[event.type];
+  if (role === "internal") return "drop";
+  if (role !== "mention" && role !== "ping" && event.participant_id === selfId) return "drop";
+  const isStandby = mode.startsWith("standby-");
+  const filter = isStandby ? mode.slice(8) : mode;
+  if (isStandby) {
+    if ((role === "mention" || role === "ping") && event.participant_id === selfId && senderMatches(filter, senderType, senderId)) return "trigger";
+    if (isWhisperTo(event, selfId) && senderMatches(filter, senderType, senderId)) return "trigger";
+    return "drop";
+  }
+  if (role === "ping") return "trigger";
+  if (role === "mention") return "drop";
+  if (role === "message") {
+    return senderMatches(filter, senderType, senderId) ? "trigger" : "content";
+  }
+  if (role === "ambient") return "content";
+  return "drop";
+}
+var StoopsEngagement = class {
+  _modes = /* @__PURE__ */ new Map();
+  _defaultMode;
+  constructor(defaultMode) {
+    this._defaultMode = defaultMode;
+  }
+  /** Get the engagement mode for a room. Falls back to the default mode. */
+  getMode(roomId) {
+    return this._modes.get(roomId) ?? this._defaultMode;
+  }
+  /** Set the engagement mode for a room. */
+  setMode(roomId, mode) {
+    this._modes.set(roomId, mode);
+  }
+  /** Called when a room is disconnected. Removes the room's mode so it doesn't linger. */
+  onRoomDisconnected(roomId) {
+    this._modes.delete(roomId);
+  }
+  classify(event, roomId, selfId, senderType, senderId) {
+    const mode = this._modes.get(roomId) ?? this._defaultMode;
+    return classify(event, mode, selfId, senderType, senderId);
+  }
+};
+function classifyEvent(event, mode, selfId, senderType, senderId) {
+  return classify(event, mode, selfId, senderType, senderId);
+}
+
+// src/agent/remote-room-data-source.ts
+var RemoteRoomDataSource = class {
+  constructor(_serverUrl, _sessionToken, _roomId) {
+    this._serverUrl = _serverUrl;
+    this._sessionToken = _sessionToken;
+    this._roomId = _roomId;
+  }
+  _serverUrl;
+  _sessionToken;
+  _roomId;
+  _participants = [];
+  _selfId = "";
+  _selfName = "";
+  /** Set own identity for populating outgoing message stubs. */
+  setSelf(id, name) {
+    this._selfId = id;
+    this._selfName = name;
+  }
+  get roomId() {
+    return this._roomId;
+  }
+  get selfId() {
+    return this._selfId;
+  }
+  get serverUrl() {
+    return this._serverUrl;
+  }
+  get sessionToken() {
+    return this._sessionToken;
+  }
+  // ── Participant cache ─────────────────────────────────────────────────────
+  /** Set the initial participant list (from join response). */
+  setParticipants(participants) {
+    this._participants = [...participants];
+  }
+  /** Add a participant (on ParticipantJoined event). */
+  addParticipant(participant) {
+    this._participants = this._participants.filter((p) => p.id !== participant.id);
+    this._participants.push(participant);
+  }
+  /** Remove a participant (on ParticipantLeft event). */
+  removeParticipant(participantId) {
+    this._participants = this._participants.filter((p) => p.id !== participantId);
+  }
+  listParticipants() {
+    return [...this._participants];
+  }
+  // ── HTTP-backed data access ───────────────────────────────────────────────
+  async getMessage(id) {
+    try {
+      const res = await fetch(
+        `${this._serverUrl}/message/${encodeURIComponent(id)}`,
+        { headers: { Authorization: `Bearer ${this._sessionToken}` } }
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      return data.message;
+    } catch {
+      return null;
+    }
+  }
+  async searchMessages(query, limit = 10, cursor = null) {
+    const params = new URLSearchParams({ query, count: String(limit) });
+    if (cursor) params.set("cursor", cursor);
+    try {
+      const res = await fetch(`${this._serverUrl}/search?${params}`, {
+        headers: { Authorization: `Bearer ${this._sessionToken}` }
+      });
+      if (!res.ok) return { items: [], has_more: false, next_cursor: null };
+      return await res.json();
+    } catch {
+      return { items: [], has_more: false, next_cursor: null };
+    }
+  }
+  async getMessages(limit = 30, cursor = null) {
+    const params = new URLSearchParams({ count: String(limit) });
+    if (cursor) params.set("cursor", cursor);
+    try {
+      const res = await fetch(`${this._serverUrl}/messages?${params}`, {
+        headers: { Authorization: `Bearer ${this._sessionToken}` }
+      });
+      if (!res.ok) return { items: [], has_more: false, next_cursor: null };
+      return await res.json();
+    } catch {
+      return { items: [], has_more: false, next_cursor: null };
+    }
+  }
+  async getEvents(category = null, limit = 50, cursor = null) {
+    const params = new URLSearchParams({ count: String(limit) });
+    if (category) params.set("category", category);
+    if (cursor) params.set("cursor", cursor);
+    try {
+      const res = await fetch(`${this._serverUrl}/events/history?${params}`, {
+        headers: { Authorization: `Bearer ${this._sessionToken}` }
+      });
+      if (!res.ok) return { items: [], has_more: false, next_cursor: null };
+      return await res.json();
+    } catch {
+      return { items: [], has_more: false, next_cursor: null };
+    }
+  }
+  async sendMessage(content, replyToId, image, attachments, recipients) {
+    const body = { content };
+    if (replyToId) body.replyTo = replyToId;
+    if (image) body.image = image;
+    if (attachments?.length) body.attachments = attachments;
+    if (recipients?.length) body.recipients = recipients;
+    const res = await fetch(`${this._serverUrl}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${this._sessionToken}` },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Failed to send message: ${err}`);
+    }
+    const data = await res.json();
+    return {
+      id: data.messageId,
+      room_id: this._roomId,
+      sender_id: this._selfId,
+      sender_name: this._selfName,
+      content,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  async emitEvent(event) {
+    const res = await fetch(`${this._serverUrl}/event`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${this._sessionToken}` },
+      body: JSON.stringify({ event })
+    });
+    if (!res.ok) {
+    }
+  }
+};
+
+// src/agent/multiplexer.ts
+var EventMultiplexer = class {
+  _queue = [];
+  _waiters = [];
+  _channels = /* @__PURE__ */ new Map();
+  _closed = false;
+  _closeResolve = null;
+  addChannel(roomId, roomName, channel) {
+    if (this._channels.has(roomId) || this._closed) return;
+    const abortController = new AbortController();
+    const loopPromise = this._listenLoop(roomId, roomName, channel, abortController.signal);
+    this._channels.set(roomId, { channel, roomName, abortController, loopPromise });
+  }
+  removeChannel(roomId) {
+    const entry = this._channels.get(roomId);
+    if (!entry) return;
+    entry.abortController.abort();
+    this._channels.delete(roomId);
+  }
+  close() {
+    this._closed = true;
+    for (const [, entry] of this._channels) {
+      entry.abortController.abort();
+    }
+    this._channels.clear();
+    if (this._closeResolve) {
+      this._closeResolve();
+      this._closeResolve = null;
+    }
+    for (const waiter of this._waiters) {
+      waiter.resolve(null);
+    }
+    this._waiters = [];
+  }
+  async _listenLoop(roomId, roomName, channel, signal) {
+    try {
+      for await (const event of channel) {
+        if (signal.aborted) break;
+        this._push({ roomId, roomName, event });
+      }
+    } catch {
+    }
+  }
+  _push(labeled) {
+    if (this._closed) return;
+    if (this._waiters.length > 0) {
+      const waiter = this._waiters.shift();
+      waiter.resolve(labeled);
+    } else {
+      this._queue.push(labeled);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this._queue.length > 0) {
+          return Promise.resolve({ value: this._queue.shift(), done: false });
+        }
+        if (this._closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve) => {
+          this._waiters.push({
+            resolve: (value) => {
+              if (this._closed || value === null) {
+                resolve({ value: void 0, done: true });
+              } else {
+                resolve({ value, done: false });
+              }
+            }
+          });
+        });
+      }
+    };
+  }
+};
+
+// src/agent/ref-map.ts
+var RefMap = class {
+  _counter = Math.floor(Math.random() * 1e4);
+  _refToId = /* @__PURE__ */ new Map();
+  _idToRef = /* @__PURE__ */ new Map();
+  /** Assign a short ref to a message ID. Returns existing ref if already assigned. */
+  assign(messageId) {
+    const existing = this._idToRef.get(messageId);
+    if (existing) return existing;
+    const ref = String(this._counter * 6337 % 1e4).padStart(4, "0");
+    this._counter++;
+    if (this._refToId.has(ref)) {
+      const hex = messageId.replace(/-/g, "");
+      let fallback = null;
+      for (let i = 0; i <= hex.length - 4; i++) {
+        const candidate = hex.slice(i, i + 4);
+        if (!this._refToId.has(candidate)) {
+          fallback = candidate;
+          break;
+        }
+      }
+      if (!fallback) fallback = messageId.slice(0, 8);
+      this._refToId.set(fallback, messageId);
+      this._idToRef.set(messageId, fallback);
+      return fallback;
+    }
+    this._refToId.set(ref, messageId);
+    this._idToRef.set(messageId, ref);
+    return ref;
+  }
+  /** Resolve a ref back to the full message UUID. Returns undefined if unknown. */
+  resolve(ref) {
+    return this._refToId.get(ref);
+  }
+  /** Clear all mappings and reset the counter. Called on context compaction. */
+  clear() {
+    this._refToId.clear();
+    this._idToRef.clear();
+    this._counter = Math.floor(Math.random() * 1e4);
+  }
+};
+
+// src/agent/tool-handlers.ts
+import { readFile } from "fs/promises";
+function resolveOrError(resolver, roomName) {
+  const conn = resolver.resolve(roomName);
+  if (!conn) {
+    return {
+      error: true,
+      result: { content: [{ type: "text", text: `Unknown room "${roomName}".` }] }
+    };
+  }
+  return { error: false, conn };
+}
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+async function formatMsgLine(msg, conn, mkRef) {
+  const ts = formatTimestamp(new Date(msg.timestamp));
+  const ref = mkRef(msg.id);
+  const imageNote = msg.image_url ? ` [[img:${msg.image_url}]]` : "";
+  const attachmentNotes = (msg.attachments ?? []).map((a) => {
+    if (a.type === "path") return ` [attachment: ${a.name} (${a.mime_type}, path: ${a.path} \u2014 same-machine only)]`;
+    return ` [attachment: ${a.name} (${a.mime_type}, ${a.size}B, url: ${a.url})]`;
+  }).join("");
+  const whisperNote = (msg.recipients?.length ?? 0) > 0 ? ` [whisper \u2192 ${conn.dataSource.listParticipants().filter((p) => msg.recipients.includes(p.id)).map((p) => p.name).join(", ")}]` : "";
+  let line = `[${ts}] ${ref} ${msg.sender_name}: ${msg.content}${whisperNote}${imageNote}${attachmentNotes}`;
+  if (msg.reply_to_id) {
+    const target = await conn.dataSource.getMessage(msg.reply_to_id);
+    if (target) {
+      const targetRef = mkRef(target.id);
+      line = `[${ts}] ${ref} ${msg.sender_name} (\u2192 ${targetRef} ${target.sender_name}): ${msg.content}${imageNote}${attachmentNotes}`;
+    }
+  }
+  return line;
+}
+async function tryReadImageAttachment(att) {
+  if (!att.mime_type.startsWith("image/")) return null;
+  try {
+    const bytes = await readFile(att.path);
+    return {
+      type: "image",
+      source: { type: "base64", media_type: att.mime_type, data: bytes.toString("base64") }
+    };
+  } catch {
+    return null;
+  }
+}
+async function buildCatchUpLines(conn, options) {
+  const result = await conn.dataSource.getEvents(null, 50, null);
+  const chronological = [...result.items].reverse();
+  let startIdx = chronological.length;
+  for (let i = 0; i < chronological.length; i++) {
+    if (!options.isEventSeen?.(chronological[i].id)) {
+      startIdx = i;
+      break;
+    }
+  }
+  const unseen = chronological.slice(startIdx);
+  const lines = [];
+  const imageBlocks = [];
+  const seenIds = [];
+  const mkRef = (id) => `#${options.assignRef?.(id) ?? messageRef(id)}`;
+  const selfId = conn.dataSource.selfId || conn.channel?.participantId;
+  for (const event of unseen) {
+    seenIds.push(event.id);
+    const ts = formatTimestamp(new Date(event.timestamp));
+    if (event.type === "MessageSent") {
+      const msg = event.message;
+      if ((msg.recipients?.length ?? 0) > 0 && msg.sender_id !== selfId && (!selfId || !msg.recipients.includes(selfId))) {
+        continue;
+      }
+      lines.push(await formatMsgLine(event.message, conn, (id) => mkRef(id)));
+      for (const att of event.message.attachments ?? []) {
+        if (att.type === "path") {
+          const block = await tryReadImageAttachment(att);
+          if (block) imageBlocks.push(block);
+        }
+      }
+    } else if (event.type === "ParticipantJoined") {
+      const participant = conn.dataSource.listParticipants().find((p) => p.id === event.participant_id);
+      const name = participant?.name ?? event.participant_id;
+      lines.push(`[${ts}] + ${name} joined`);
+    } else if (event.type === "ParticipantLeft") {
+      const name = event.participant?.name ?? event.participant_id;
+      lines.push(`[${ts}] - ${name} left`);
+    } else if (event.type === "ReactionAdded") {
+      const participant = conn.dataSource.listParticipants().find((p) => p.id === event.participant_id);
+      const name = participant?.name ?? event.participant_id;
+      const target = await conn.dataSource.getMessage(event.message_id);
+      const targetRef = target ? ` to ${mkRef(target.id)}` : "";
+      lines.push(`[${ts}] ${name} reacted ${event.emoji}${targetRef}`);
+    }
+  }
+  if (seenIds.length > 0) options.markEventsSeen?.(seenIds);
+  return { lines, imageBlocks };
+}
+async function handleCatchUp(resolver, args, options) {
+  const r = resolveOrError(resolver, args.room);
+  if (r.error) return r.result;
+  const { lines, imageBlocks } = await buildCatchUpLines(r.conn, options);
+  const out = [`Catching up on [${args.room}]:`];
+  if (lines.length > 0) {
+    out.push("", ...lines);
+  } else {
+    out.push("", "(nothing new)");
+  }
+  const content = [{ type: "text", text: out.join("\n") }];
+  content.push(...imageBlocks);
+  return { content };
+}
+async function handleSearchByText(resolver, args, options) {
+  const r = resolveOrError(resolver, args.room);
+  if (r.error) return r.result;
+  const { conn } = r;
+  const count = args.count ?? 3;
+  const mkRef = (id) => `#${options.assignRef?.(id) ?? messageRef(id)}`;
+  const searchResult = await conn.dataSource.searchMessages(args.query, 50, args.cursor ?? null);
+  const totalVisible = searchResult.items.length;
+  if (totalVisible === 0) {
+    return textResult(`No messages found in [${args.room}] matching "${args.query}".`);
+  }
+  const toShow = searchResult.items.slice(0, count);
+  const recentResult = await conn.dataSource.getMessages(100, null);
+  const recentChron = [...recentResult.items].reverse();
+  const msgIdxMap = /* @__PURE__ */ new Map();
+  recentChron.forEach((m, i) => msgIdxMap.set(m.id, i));
+  const clusters = [];
+  let newerCount = null;
+  for (const match of [...toShow].reverse()) {
+    const cluster = [];
+    const matchIdx = msgIdxMap.get(match.id);
+    if (matchIdx !== void 0) {
+      if (matchIdx > 0) {
+        cluster.push(await formatMsgLine(recentChron[matchIdx - 1], conn, mkRef));
+      }
+      cluster.push(await formatMsgLine(match, conn, mkRef) + " \u2190");
+      if (matchIdx < recentChron.length - 1) {
+        cluster.push(await formatMsgLine(recentChron[matchIdx + 1], conn, mkRef));
+      }
+      if (newerCount === null && match.id === toShow[0].id) {
+        newerCount = recentChron.length - matchIdx - 1;
+      }
+    } else {
+      cluster.push(await formatMsgLine(match, conn, mkRef) + " \u2190");
+    }
+    clusters.push(cluster);
+  }
+  const shownCount = toShow.length;
+  const totalNote = searchResult.has_more ? `showing ${shownCount} of 50+` : `${shownCount} of ${totalVisible}`;
+  const out = [`Search results in [${args.room}] for "${args.query}" (${totalNote} matches):`, ""];
+  for (let i = 0; i < clusters.length; i++) {
+    for (const line of clusters[i]) {
+      out.push(`  ${line}`);
+    }
+    if (i < clusters.length - 1) out.push("");
+  }
+  if (newerCount !== null && newerCount > 0) {
+    out.push("", `${newerCount} newer message${newerCount === 1 ? "" : "s"} in this room.`);
+  }
+  if (searchResult.has_more && searchResult.next_cursor) {
+    out.push(`(cursor: "${searchResult.next_cursor}" for next ${count} matches)`);
+  }
+  return textResult(out.join("\n"));
+}
+async function handleSearchByMessage(resolver, args, options) {
+  const r = resolveOrError(resolver, args.room);
+  if (r.error) return r.result;
+  const { conn } = r;
+  const direction = args.direction ?? "before";
+  const count = args.count ?? 10;
+  const mkRef = (id) => `#${options.assignRef?.(id) ?? messageRef(id)}`;
+  const rawRef = args.ref.startsWith("#") ? args.ref.slice(1) : args.ref;
+  const anchorId = options.resolveRef?.(rawRef) ?? rawRef;
+  const anchor = await conn.dataSource.getMessage(anchorId);
+  if (!anchor) return textResult(`Message ${args.ref} not found.`);
+  const recentResult = await conn.dataSource.getMessages(100, null);
+  const recentChron = [...recentResult.items].reverse();
+  const anchorIdx = recentChron.findIndex((m) => m.id === anchor.id);
+  let displayMessages;
+  let newerCount;
+  if (direction === "before") {
+    const beforeResult = await conn.dataSource.getMessages(count, anchor.id);
+    const beforeMessages = [...beforeResult.items].reverse();
+    displayMessages = [...beforeMessages, anchor];
+    newerCount = anchorIdx >= 0 ? recentChron.length - anchorIdx - 1 : 100;
+  } else {
+    if (anchorIdx >= 0) {
+      const afterMessages = recentChron.slice(anchorIdx + 1, anchorIdx + 1 + count);
+      displayMessages = [anchor, ...afterMessages];
+      newerCount = recentChron.length - anchorIdx - 1 - afterMessages.length;
+    } else {
+      displayMessages = [anchor];
+      newerCount = 100;
+    }
+  }
+  const anchorRef = mkRef(anchor.id);
+  const lines = [`Context in [${args.room}] around ${anchorRef}:`, ""];
+  for (const msg of displayMessages) {
+    const line = await formatMsgLine(msg, conn, mkRef);
+    const isAnchor = msg.id === anchor.id;
+    lines.push(`  ${line}${isAnchor ? " \u2190" : ""}`);
+  }
+  if (newerCount > 0) {
+    const countLabel = newerCount >= 100 ? "100+" : String(newerCount);
+    lines.push("", `${countLabel} newer message${newerCount === 1 ? "" : "s"} in this room.`);
+  }
+  return textResult(lines.join("\n"));
+}
+async function handleSendMessage(resolver, args, options) {
+  const r = resolveOrError(resolver, args.room);
+  if (r.error) return r.result;
+  const image = args.image_url ? {
+    url: args.image_url,
+    mimeType: args.image_mime_type ?? "image/*",
+    sizeBytes: args.image_size_bytes ?? 0
+  } : null;
+  let replyToId = args.reply_to_id;
+  if (replyToId) {
+    const rawRef = replyToId.startsWith("#") ? replyToId.slice(1) : replyToId;
+    replyToId = options.resolveRef?.(rawRef) ?? replyToId;
+  }
+  let recipientIds;
+  if (args.to && args.to.length > 0) {
+    const participants = r.conn.dataSource.listParticipants();
+    recipientIds = [];
+    for (const name of args.to) {
+      const matches = participants.filter((p) => p.name === name);
+      if (matches.length === 0) return textResult(`Unknown participant "${name}". Known: ${participants.map((p) => p.name).join(", ")}.`);
+      if (matches.length > 1) return textResult(`Ambiguous name "${name}" \u2014 multiple participants match. Use a more specific name.`);
+      recipientIds.push(matches[0].id);
+    }
+  }
+  const message = await r.conn.dataSource.sendMessage(args.content, replyToId, image, args.attachments, recipientIds);
+  const ref = options.assignRef?.(message.id) ?? messageRef(message.id);
+  return textResult(`Message sent #${ref}.`);
+}
+
+// src/agent/connection-registry.ts
+var ConnectionRegistry = class {
+  _connections = /* @__PURE__ */ new Map();
+  _nameToId = /* @__PURE__ */ new Map();
+  _identifierToId = /* @__PURE__ */ new Map();
+  _lastMessages = /* @__PURE__ */ new Map();
+  add(roomId, conn) {
+    this._connections.set(roomId, conn);
+    this._nameToId.set(conn.name, roomId);
+    if (conn.identifier) this._identifierToId.set(conn.identifier, roomId);
+  }
+  remove(roomId) {
+    const conn = this._connections.get(roomId);
+    if (!conn) return void 0;
+    this._nameToId.delete(conn.name);
+    if (conn.identifier) this._identifierToId.delete(conn.identifier);
+    this._connections.delete(roomId);
+    this._lastMessages.delete(roomId);
+    return conn;
+  }
+  get(roomId) {
+    return this._connections.get(roomId);
+  }
+  has(roomId) {
+    return this._connections.has(roomId);
+  }
+  resolve(roomName) {
+    const roomId = this._nameToId.get(roomName);
+    if (roomId) return this._connections.get(roomId) ?? null;
+    const idFromIdentifier = this._identifierToId.get(roomName);
+    if (idFromIdentifier) return this._connections.get(idFromIdentifier) ?? null;
+    return this._connections.get(roomName) ?? null;
+  }
+  listAll(getModeForRoom) {
+    return [...this._connections.entries()].map(([roomId, conn]) => ({
+      name: conn.name,
+      roomId,
+      ...conn.identifier ? { identifier: conn.identifier } : {},
+      mode: getModeForRoom(roomId),
+      participantCount: conn.dataSource.listParticipants().length,
+      ...this._lastMessages.has(roomId) ? { lastMessage: this._lastMessages.get(roomId) } : {}
+    }));
+  }
+  setLastMessage(roomId, text) {
+    this._lastMessages.set(roomId, text);
+  }
+  entries() {
+    return this._connections.entries();
+  }
+  get size() {
+    return this._connections.size;
+  }
+  clear() {
+    this._connections.clear();
+    this._nameToId.clear();
+    this._identifierToId.clear();
+    this._lastMessages.clear();
+  }
+  values() {
+    return this._connections.values();
+  }
+};
+
+// src/agent/content-buffer.ts
+var ContentBuffer = class {
+  _buffer = /* @__PURE__ */ new Map();
+  push(roomId, item) {
+    const buf = this._buffer.get(roomId) ?? [];
+    buf.push(item);
+    this._buffer.set(roomId, buf);
+  }
+  flush(roomId) {
+    const items = this._buffer.get(roomId) ?? [];
+    this._buffer.delete(roomId);
+    return items;
+  }
+  delete(roomId) {
+    this._buffer.delete(roomId);
+  }
+  clear() {
+    this._buffer.clear();
+  }
+};
+
+// src/agent/event-tracker.ts
+var PROCESSED_CAP = 500;
+var DELIVERED_CAP = 5e3;
+var EventTracker = class {
+  _processedIds = /* @__PURE__ */ new Set();
+  _deliveredIds = /* @__PURE__ */ new Set();
+  /** Returns true if this event was already processed (and adds it if not). */
+  isDuplicate(id) {
+    if (this._processedIds.has(id)) return true;
+    this._processedIds.add(id);
+    if (this._processedIds.size > PROCESSED_CAP) {
+      this._processedIds = halve(this._processedIds);
+    }
+    return false;
+  }
+  isDelivered(id) {
+    return this._deliveredIds.has(id);
+  }
+  markDelivered(id) {
+    this._deliveredIds.add(id);
+    if (this._deliveredIds.size > DELIVERED_CAP) {
+      this._deliveredIds = halve(this._deliveredIds);
+    }
+  }
+  markManyDelivered(ids) {
+    for (const id of ids) {
+      this._deliveredIds.add(id);
+      this._processedIds.add(id);
+    }
+    if (this._deliveredIds.size > DELIVERED_CAP) this._deliveredIds = halve(this._deliveredIds);
+    if (this._processedIds.size > PROCESSED_CAP) this._processedIds = halve(this._processedIds);
+  }
+  clearDelivered() {
+    this._deliveredIds.clear();
+  }
+  clearAll() {
+    this._processedIds.clear();
+    this._deliveredIds.clear();
+  }
+};
+function halve(set) {
+  const arr = [...set];
+  return new Set(arr.slice(arr.length >> 1));
+}
+
+// src/agent/event-processor.ts
+function mergeParts(arrays) {
+  const result = [];
+  for (let i = 0; i < arrays.length; i++) {
+    if (i > 0) result.push({ type: "text", text: "\n" });
+    result.push(...arrays[i]);
+  }
+  return result;
+}
+var ACTIVITY_REPORT_MIN_MS = 1e4;
+function shouldReportActivity(opts) {
+  if (opts.label !== opts.lastLabel || opts.state !== opts.lastState) return true;
+  return opts.now - opts.lastReportAt > (opts.minIntervalMs ?? ACTIVITY_REPORT_MIN_MS);
+}
+var EventProcessor = class {
+  _participantId;
+  _participantName;
+  _options;
+  _engagement;
+  _deliver = null;
+  _multiplexer = new EventMultiplexer();
+  _registry = new ConnectionRegistry();
+  _buffer = new ContentBuffer();
+  _tracker = new EventTracker();
+  _processing = false;
+  _eventQueue = [];
+  _stopped = false;
+  _currentContextRoomId = null;
+  _log = [];
+  _refMap = new RefMap();
+  _injectBuffer = [];
+  /** Per-room participant IDs (for multi-server CLI agents where each server assigns a different ID). */
+  _roomSelfIds = /* @__PURE__ */ new Map();
+  constructor(participantId, participantName, options = {}) {
+    this._participantId = participantId;
+    this._participantName = participantName;
+    this._options = options;
+    this._engagement = options.engagement ?? new StoopsEngagement(options.defaultMode ?? "everyone");
+  }
+  // ── Public accessors ────────────────────────────────────────────────────────
+  get participantId() {
+    return this._participantId;
+  }
+  set participantId(id) {
+    this._participantId = id;
+  }
+  get participantName() {
+    return this._participantName;
+  }
+  get currentContextRoomId() {
+    return this._currentContextRoomId;
+  }
+  /** Set a room-specific participant ID (for multi-server CLI agents). */
+  setRoomParticipantId(roomId, participantId) {
+    this._roomSelfIds.set(roomId, participantId);
+  }
+  /** Get the effective selfId for a room — room-specific if set, otherwise the global one. */
+  getSelfIdForRoom(roomId) {
+    return this._roomSelfIds.get(roomId) ?? this._participantId;
+  }
+  // ── Ref map (consumer calls these for MCP tools) ────────────────────────────
+  assignRef(messageId) {
+    return this._refMap.assign(messageId);
+  }
+  resolveRef(ref) {
+    return this._refMap.resolve(ref);
+  }
+  // ── Seen-event cache (consumer calls these for catch_up MCP tool) ───────────
+  isEventSeen(eventId) {
+    return this._tracker.isDelivered(eventId);
+  }
+  markEventsSeen(eventIds) {
+    this._tracker.markManyDelivered(eventIds);
+  }
+  // ── Inject buffer (LangGraph mid-loop event injection) ──────────────────────
+  drainInjectBuffer() {
+    if (this._injectBuffer.length === 0) return null;
+    const drained = this._injectBuffer;
+    this._injectBuffer = [];
+    return drained;
+  }
+  // ── Consumer hooks (called by consumer during/after delivery) ────────────────
+  /**
+   * Called by the consumer when context was compacted.
+   * Clears seen-event cache and ref map so catch_up returns full history.
+   */
+  onContextCompacted() {
+    this._tracker.clearDelivered();
+    this._refMap.clear();
+  }
+  /**
+   * Called by the consumer when a tool call starts or completes.
+   * Routes ToolUseEvent to the room that triggered the current evaluation.
+   */
+  emitToolUse(toolName, status) {
+    if (this._currentContextRoomId) {
+      const conn = this._registry.get(this._currentContextRoomId);
+      if (conn) {
+        const event = createEvent({
+          type: "ToolUse",
+          category: "ACTIVITY",
+          room_id: this._currentContextRoomId,
+          participant_id: this._participantId,
+          tool_name: toolName,
+          status
+        });
+        const emitter = conn.dataSource.emitEvent ? (e) => conn.dataSource.emitEvent(e) : conn.channel ? (e) => conn.channel.emit(e) : null;
+        if (!emitter) return;
+        emitter(event).catch(() => {
+        });
+      }
+    }
+  }
+  // ── RoomResolver implementation ─────────────────────────────────────────────
+  resolve(roomName) {
+    return this._registry.resolve(roomName);
+  }
+  listAll() {
+    return this._registry.listAll((roomId) => this.getModeForRoom(roomId));
+  }
+  /**
+   * Push a live status label ("Sautéed for 12s", "Compacting…", null=idle)
+   * to every connected REMOTE room (i.e. CLI-path agents talking to an
+   * apiary HTTP server). Local app-path connections are skipped — they don't
+   * have a /activity HTTP endpoint to hit.
+   *
+   * Called from the CLI runtime's tmux poll loop. Best-effort: failures are
+   * swallowed so a flaky network never crashes the agent.
+   */
+  async broadcastActivity(label, state) {
+    for (const conn of this._registry.values()) {
+      const ds = conn.dataSource;
+      if (!(ds instanceof RemoteRoomDataSource)) continue;
+      try {
+        await fetch(`${ds.serverUrl}/activity`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${ds.sessionToken}`
+          },
+          body: JSON.stringify(state === void 0 ? { label } : { label, state })
+        });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Push token usage + last-turn context size to every connected REMOTE
+   * room so the room TUI can show per-agent context size and roll up a
+   * room total. Mirrors broadcastActivity — same best-effort semantics.
+   */
+  async broadcastMetrics(metrics) {
+    for (const conn of this._registry.values()) {
+      const ds = conn.dataSource;
+      if (!(ds instanceof RemoteRoomDataSource)) continue;
+      try {
+        await fetch(`${ds.serverUrl}/metrics`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${ds.sessionToken}`
+          },
+          body: JSON.stringify(metrics)
+        });
+      } catch {
+      }
+    }
+  }
+  // ── Room connection management ──────────────────────────────────────────────
+  async connectRoom(room, roomName, mode, identifier) {
+    if (this._registry.has(room.roomId)) return;
+    const channel = await room.connect(this._participantId, this._participantName, {
+      type: "agent",
+      identifier: this._options.selfIdentifier,
+      subscribe: /* @__PURE__ */ new Set([
+        EventCategory.MESSAGE,
+        EventCategory.PRESENCE,
+        EventCategory.ACTIVITY,
+        EventCategory.MENTION
+      ]),
+      silent: true
+    });
+    const dataSource = new LocalRoomDataSource(room, channel);
+    const conn = { dataSource, room, channel, name: roomName, identifier };
+    this._registry.add(room.roomId, conn);
+    if (mode) this._engagement.setMode?.(room.roomId, mode);
+    const initialMode = this.getModeForRoom(room.roomId);
+    channel.emit(createEvent({
+      type: "Activity",
+      category: "ACTIVITY",
+      room_id: room.roomId,
+      participant_id: this._participantId,
+      action: "mode_changed",
+      detail: { mode: initialMode }
+    })).catch(() => {
+    });
+    this._multiplexer.addChannel(room.roomId, roomName, channel);
+  }
+  /**
+   * Connect a remote room via a RoomDataSource (no local Room/Channel).
+   *
+   * Used by the client-side agent runtime to register rooms that are
+   * accessed over HTTP. Events come from an external source (SSE multiplexer)
+   * passed to run(), not from the internal EventMultiplexer.
+   */
+  connectRemoteRoom(dataSource, roomName, mode, identifier) {
+    if (this._registry.has(dataSource.roomId)) return;
+    const conn = {
+      dataSource,
+      name: roomName,
+      identifier
+    };
+    this._registry.add(dataSource.roomId, conn);
+    if (mode) this._engagement.setMode?.(dataSource.roomId, mode);
+  }
+  /** Disconnect a remote room (by room ID). */
+  disconnectRemoteRoom(roomId) {
+    if (!this._registry.has(roomId)) return;
+    this._registry.remove(roomId);
+    this._engagement.onRoomDisconnected?.(roomId);
+    this._buffer.delete(roomId);
+    this._roomSelfIds.delete(roomId);
+  }
+  async disconnectRoom(roomId) {
+    const conn = this._registry.get(roomId);
+    if (!conn) return;
+    this._multiplexer.removeChannel(roomId);
+    await conn.channel?.disconnect(true);
+    this._registry.remove(roomId);
+    this._engagement.onRoomDisconnected?.(roomId);
+    this._buffer.delete(roomId);
+    this._roomSelfIds.delete(roomId);
+  }
+  // ── Mode management ─────────────────────────────────────────────────────────
+  getModeForRoom(roomId) {
+    return this._engagement.getMode?.(roomId) ?? "everyone";
+  }
+  setModeForRoom(roomId, mode, notifyAgent = true) {
+    this._engagement.setMode?.(roomId, mode);
+    const conn = this._registry.get(roomId);
+    if (conn) {
+      conn.channel?.emit(createEvent({
+        type: "Activity",
+        category: "ACTIVITY",
+        room_id: roomId,
+        participant_id: this._participantId,
+        action: "mode_changed",
+        detail: { mode }
+      }))?.catch(() => {
+      });
+      this._options.onModeChange?.(roomId, conn.name, mode);
+    }
+  }
+  // ── Log ─────────────────────────────────────────────────────────────────────
+  getLog() {
+    return this._log;
+  }
+  // ── Main event loop ─────────────────────────────────────────────────────────
+  /**
+   * Start the event loop.
+   *
+   * @param deliver — callback that receives formatted content and delivers
+   *   it to the agent. This is the consumer's responsibility. The function
+   *   should block until delivery is complete (e.g., LLM evaluation finished).
+   * @param eventSource — optional external event source (e.g. SseMultiplexer).
+   *   If provided, events are consumed from this instead of the internal
+   *   EventMultiplexer. Used by the client-side agent runtime.
+   * @param initialParts — optional content to deliver before entering the
+   *   event loop. Used by the runtime to deliver auto-join confirmation.
+   */
+  async run(deliver, eventSource, initialParts) {
+    this._deliver = deliver;
+    if (initialParts && initialParts.length > 0) {
+      await this._processRaw(
+        initialParts,
+        this._registry.values().next().value?.dataSource.roomId ?? null
+      );
+    }
+    const source = eventSource ?? this._multiplexer;
+    for await (const labeled of source) {
+      if (this._stopped) break;
+      await this._handleLabeledEvent(labeled);
+    }
+  }
+  async stop() {
+    this._stopped = true;
+    this._multiplexer.close();
+    await Promise.allSettled(
+      [...this._registry.values()].filter((conn) => conn.channel).map((conn) => conn.channel.disconnect(true))
+    );
+    this._registry.clear();
+    this._buffer.clear();
+    this._tracker.clearAll();
+    this._refMap.clear();
+    this._roomSelfIds.clear();
+    this._deliver = null;
+  }
+  // ── Full catch-up (kept for app-path consumers) ────────────────────────────
+  async buildFullCatchUp() {
+    return this._buildFullCatchUp();
+  }
+  async _buildFullCatchUp() {
+    const sections = ["[Session context \u2014 loaded automatically]"];
+    const nameCounts = /* @__PURE__ */ new Map();
+    for (const [, c] of this._registry.entries()) nameCounts.set(c.name, (nameCounts.get(c.name) ?? 0) + 1);
+    for (const [roomId, conn] of this._registry.entries()) {
+      const mode = this.getModeForRoom(roomId);
+      const isDuplicate = (nameCounts.get(conn.name) ?? 0) > 1;
+      const ref = isDuplicate ? roomId : conn.identifier ?? roomId;
+      sections.push(`
+${conn.name} [${ref}] \u2014 ${mode}`);
+      if (mode.startsWith("standby-")) {
+        sections.push("  (standby \u2014 @mentions only)");
+      } else {
+        const participants = conn.dataSource.listParticipants().filter((p) => p.id !== this._participantId);
+        if (participants.length > 0) {
+          const pList = participants.map((p) => `${p.type} ${p.name}`).join(", ");
+          sections.push(`Participants: ${pList}`);
+        }
+        const { lines } = await buildCatchUpLines(conn, {
+          isEventSeen: (id) => this._tracker.isDelivered(id),
+          markEventsSeen: (ids) => {
+            this._tracker.markManyDelivered(ids);
+          },
+          assignRef: (id) => this.assignRef(id)
+        });
+        if (lines.length > 0) {
+          for (const line of lines) sections.push(`  ${line}`);
+        } else {
+          sections.push("  (nothing new)");
+        }
+      }
+    }
+    sections.push(
+      "\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "Continue immediately if you see fit, or explore further in any active room."
+    );
+    return [{ type: "text", text: sections.join("\n") }];
+  }
+  // ── Event handling ──────────────────────────────────────────────────────────
+  async _handleLabeledEvent(labeled) {
+    if (this._tracker.isDuplicate(labeled.event.id)) return;
+    const { roomId, event } = labeled;
+    const conn = this._registry.get(roomId);
+    const senderLookupId = event.type === "Mentioned" ? event.message.sender_id : event.participant_id;
+    const sender = conn?.dataSource.listParticipants().find((p) => p.id === senderLookupId);
+    const senderType = sender?.type ?? "human";
+    const selfId = this.getSelfIdForRoom(roomId);
+    const disposition = this._engagement.classify(event, roomId, selfId, senderType, senderLookupId);
+    if (disposition === "drop") return;
+    this._tracker.markDelivered(event.id);
+    if (disposition === "content") {
+      this._buffer.push(roomId, { event, roomId, roomName: labeled.roomName });
+      return;
+    }
+    this._log.push(event);
+    if (this._processing) {
+      this._eventQueue.push(labeled);
+      this._formatForLLM(event, roomId, labeled.roomName).then((parts) => {
+        if (parts) this._injectBuffer.push(parts);
+      }).catch((err) => {
+        console.error(`[${this._participantName}] inject buffer format error:`, err);
+      });
+      return;
+    }
+    await this._processTrigger(labeled);
+    while (this._eventQueue.length > 0) {
+      const queued = this._eventQueue;
+      this._eventQueue = [];
+      const formatted = [];
+      let batchContextRoom = null;
+      const roomsProcessed = /* @__PURE__ */ new Set();
+      for (const qe of queued) {
+        const qConn = this._registry.get(qe.roomId);
+        const qSenderLookupId = qe.event.type === "Mentioned" ? qe.event.message.sender_id : qe.event.participant_id;
+        const qSender = qConn?.dataSource.listParticipants().find((p) => p.id === qSenderLookupId);
+        const qSenderType = qSender?.type ?? "human";
+        const qSelfId = this.getSelfIdForRoom(qe.roomId);
+        const qDisposition = this._engagement.classify(qe.event, qe.roomId, qSelfId, qSenderType, qSenderLookupId);
+        if (qDisposition === "drop") continue;
+        if (!roomsProcessed.has(qe.roomId)) {
+          roomsProcessed.add(qe.roomId);
+          const buffered = this._buffer.flush(qe.roomId);
+          for (const item of buffered) {
+            const parts2 = await this._formatForLLM(item.event, item.roomId, item.roomName);
+            if (parts2) {
+              formatted.push(parts2);
+              if (!batchContextRoom) batchContextRoom = qe.roomId;
+            }
+          }
+        }
+        this._log.push(qe.event);
+        const parts = await this._formatForLLM(qe.event, qe.roomId, qe.roomName);
+        if (parts) {
+          formatted.push(parts);
+          if (!batchContextRoom) batchContextRoom = qe.roomId;
+        }
+      }
+      if (formatted.length > 0) {
+        await this._processRaw(mergeParts(formatted), batchContextRoom);
+      }
+    }
+  }
+  async _processTrigger(labeled) {
+    const { roomId, roomName, event } = labeled;
+    const buffered = this._buffer.flush(roomId);
+    const contentPartArrays = [];
+    for (const item of buffered) {
+      const parts = await this._formatForLLM(item.event, item.roomId, item.roomName);
+      if (parts) contentPartArrays.push(parts);
+    }
+    if (event.type === "MessageSent") {
+      const conn = this._registry.get(roomId);
+      const senderLabel = conn?.dataSource.listParticipants().find((p) => p.id === event.message.sender_id)?.name ?? event.message.sender_name;
+      const contentPreview = event.message.content.length > 60 ? event.message.content.slice(0, 57) + "..." : event.message.content;
+      const preview = event.message.image_url && !event.message.content.trim() ? "sent an image" : contentPreview;
+      this._registry.setLastMessage(roomId, `${senderLabel}: ${preview}`);
+    }
+    const triggerParts = await this._formatForLLM(event, roomId, roomName);
+    if (!triggerParts && contentPartArrays.length === 0) return;
+    const mergedParts = mergeParts([...contentPartArrays, ...triggerParts ? [triggerParts] : []]);
+    await this._processRaw(mergedParts, roomId);
+  }
+  // ── Formatting ──────────────────────────────────────────────────────────────
+  _resolveParticipantForRoom(roomId) {
+    return (id) => {
+      const conn = this._registry.get(roomId);
+      if (!conn) return null;
+      return conn.dataSource.listParticipants().find((p) => p.id === id) ?? null;
+    };
+  }
+  async _resolveReplyContext(event, roomId) {
+    if (event.type !== "MessageSent" && event.type !== "Mentioned") return null;
+    const msg = event.message;
+    if (!msg.reply_to_id) return null;
+    const conn = this._registry.get(roomId);
+    if (!conn) return null;
+    const repliedTo = await conn.dataSource.getMessage(msg.reply_to_id);
+    return repliedTo ? { senderName: repliedTo.sender_name, content: repliedTo.content } : null;
+  }
+  async _resolveReactionTarget(event, roomId) {
+    if (event.type !== "ReactionAdded") return null;
+    const conn = this._registry.get(roomId);
+    if (!conn) return null;
+    const target = await conn.dataSource.getMessage(event.message_id);
+    if (!target) return null;
+    return {
+      senderName: target.sender_name,
+      content: target.content,
+      isSelf: target.sender_id === this._participantId
+    };
+  }
+  async _formatForLLM(event, roomId, roomName) {
+    const mode = this.getModeForRoom(roomId);
+    const label = mode !== "everyone" ? `${roomName} \u2014 ${mode}` : roomName;
+    const replyContext = await this._resolveReplyContext(event, roomId);
+    const reactionTarget = await this._resolveReactionTarget(event, roomId);
+    return formatEvent(
+      event,
+      this._resolveParticipantForRoom(roomId),
+      replyContext,
+      label,
+      reactionTarget,
+      (id) => this.assignRef(id)
+    );
+  }
+  // ── Delivery ────────────────────────────────────────────────────────────────
+  async _processRaw(parts, contextRoomId) {
+    if (this._options.preQuery && !await this._options.preQuery()) {
+      return;
+    }
+    this._processing = true;
+    this._currentContextRoomId = contextRoomId;
+    try {
+      if (!this._deliver) return;
+      await this._deliver(parts);
+    } catch (err) {
+      console.error(`[${this._participantName}] error:`, err);
+    } finally {
+      this._currentContextRoomId = null;
+      this._processing = false;
+    }
+  }
+};
+
+// src/agent/mcp/runtime.ts
+import { createServer } from "http";
+import { z } from "zod";
+var RUNTIME_MODES = /* @__PURE__ */ new Set([
+  "everyone",
+  "people",
+  "agents",
+  "standby-everyone",
+  "standby-people",
+  "standby-agents"
+]);
+var RUNTIME_MODES_LIST = "everyone, people, agents, standby-everyone, standby-people, standby-agents";
+function isValidRuntimeMode(mode) {
+  return RUNTIME_MODES.has(mode);
+}
+function formatJoinResponse(result) {
+  const lines = [];
+  lines.push(`Joined ${result.roomName} as "${result.agentName}" (${result.authority})`);
+  lines.push("");
+  lines.push("Nobody reads your terminal \u2014 only this room:");
+  lines.push("  - Ask questions and report blockers here with send_message, or they are invisible.");
+  lines.push("  - Don't end a turn waiting on an answer you never posted.");
+  lines.push("");
+  if (result.mode) {
+    lines.push(`Mode: ${result.mode}`);
+    const desc = MODE_DESCRIPTIONS[result.mode];
+    if (desc) lines.push(`  ${desc}`);
+    lines.push(`  Change with set_mode.`);
+    lines.push("");
+  }
+  if (result.personName) {
+    lines.push(`Person: ${result.personName}`);
+    lines.push(`  Your person's messages always reach you regardless of mode.`);
+    lines.push("");
+  }
+  if (result.rules && result.rules.length > 0) {
+    lines.push("Room rules \u2014 follow these:");
+    result.rules.forEach((r, i) => lines.push(`  ${i + 1}. ${r}`));
+    lines.push("");
+  }
+  if (result.participants && result.participants.length > 0) {
+    lines.push("Participants:");
+    for (const p of result.participants) {
+      lines.push(`  ${p.name} (${p.authority})`);
+    }
+    lines.push("");
+  }
+  if (result.recentLines && result.recentLines.length > 0) {
+    lines.push("Recent:");
+    for (const line of result.recentLines) {
+      lines.push(`  ${line}`);
+    }
+    lines.push("");
+    lines.push(`${result.recentLines.length} message${result.recentLines.length === 1 ? "" : "s"} shown. Use catch_up("${result.roomName}") for more.`);
+  }
+  return lines.join("\n");
+}
+var RUNTIME_TOOL_NAMES = [
+  "apiary__catch_up",
+  "apiary__search_by_text",
+  "apiary__search_by_message",
+  "apiary__send_message",
+  "apiary__set_mode",
+  "apiary__join_room",
+  "apiary__leave_room",
+  "apiary__ping",
+  "apiary__wait_for_agent",
+  "apiary__admin__set_mode_for",
+  "apiary__admin__mute",
+  "apiary__admin__unmute",
+  "apiary__admin__kick",
+  "apiary__admin__promote",
+  "apiary__admin__demote"
+];
+function registerTools(server, opts) {
+  const { resolver, toolOptions } = opts;
+  server.tool(
+    "apiary__catch_up",
+    "List your rooms and status. Call with no arguments to see connected rooms. With a room name, returns recent activity you haven't seen.",
+    {
+      room: z.string().optional().describe("Room name. Omit to list all connected rooms.")
+    },
+    { readOnlyHint: true },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async ({ room }) => {
+      if (!room) {
+        const rooms = resolver.listAll();
+        if (rooms.length === 0) {
+          return textResult("Not connected to any rooms.");
+        }
+        const lines = ["Connected rooms:", ""];
+        for (const r of rooms) {
+          const idPart = r.identifier ? ` [${r.identifier}]` : "";
+          lines.push(`  ${r.name}${idPart} \u2014 ${r.mode} (${r.participantCount} participants)`);
+          if (r.lastMessage) lines.push(`    Last: ${r.lastMessage}`);
+        }
+        return textResult(lines.join("\n"));
+      }
+      return handleCatchUp(resolver, { room }, toolOptions);
+    }
+  );
+  server.tool(
+    "apiary__search_by_text",
+    "Search chat history by keyword.",
+    {
+      room: z.string().describe("Room name"),
+      query: z.string().describe("Keyword or phrase to search for"),
+      count: z.number().int().min(1).max(10).default(3).optional().describe("Number of matches (default 3)"),
+      cursor: z.string().optional().describe("Pagination cursor")
+    },
+    { readOnlyHint: true },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async (args) => handleSearchByText(resolver, args, toolOptions)
+  );
+  server.tool(
+    "apiary__search_by_message",
+    "Show messages around a known message ref.",
+    {
+      room: z.string().describe("Room name"),
+      ref: z.string().describe("Message ref (e.g. #3847)"),
+      direction: z.enum(["before", "after"]).default("before").optional().describe("'before' to scroll back, 'after' to scroll forward"),
+      count: z.number().int().min(1).max(50).default(10).optional().describe("Number of messages (default 10)")
+    },
+    { readOnlyHint: true },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async (args) => handleSearchByMessage(resolver, args, toolOptions)
+  );
+  server.tool(
+    "apiary__send_message",
+    "Send a message to a room.",
+    {
+      room: z.string().describe("Room name"),
+      content: z.string().describe("Message content. @name will notify that participant \u2014 use sparingly."),
+      reply_to_id: z.string().optional().describe("Message ref to reply to (e.g. #3847)."),
+      attachments: z.array(z.discriminatedUnion("type", [
+        z.object({
+          type: z.literal("path"),
+          id: z.string().describe("Stable ID (use crypto.randomUUID())"),
+          name: z.string().describe("Display filename"),
+          mime_type: z.string().describe("MIME type, e.g. image/png"),
+          size: z.number().optional().describe("File size in bytes"),
+          path: z.string().describe("Absolute local filesystem path \u2014 readable by agents on the same machine")
+        }),
+        z.object({
+          type: z.literal("upload"),
+          id: z.string().describe("Attachment ID returned by POST /attachment"),
+          name: z.string().describe("Display filename"),
+          mime_type: z.string().describe("MIME type, e.g. image/png"),
+          size: z.number().describe("File size in bytes"),
+          url: z.string().describe("URL returned by POST /attachment")
+        })
+      ])).optional().describe("Typed file/image attachments"),
+      to: z.array(z.string()).optional().describe("Participant display names to whisper to. Others see [sender \u2192 recipient] but not the content. Omit for a public message.")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async (args) => handleSendMessage(resolver, args, toolOptions)
+  );
+  server.tool(
+    "apiary__set_mode",
+    "Change your engagement mode. Controls which messages are pushed to you: everyone \u2014 all messages, people \u2014 human messages only, agents \u2014 agent messages only. Prefix with standby- for @mentions only.",
+    {
+      room: z.string().describe("Room name"),
+      mode: z.string().describe("Engagement mode")
+    },
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+    async ({ room, mode }) => {
+      if (!opts.onSetMode) return textResult("Mode changes not supported.");
+      if (!isValidRuntimeMode(mode)) {
+        return textResult(`Invalid mode "${mode}". Valid modes: ${RUNTIME_MODES_LIST}.`);
+      }
+      const result = await opts.onSetMode(room, mode);
+      return result.success ? textResult(`Mode set to ${mode} for [${room}].`) : textResult(result.error ?? "Failed to set mode.");
+    }
+  );
+  server.tool(
+    "apiary__join_room",
+    "Join a room. Returns your identity, participants, mode, and recent activity.",
+    {
+      url: z.string().describe("Share URL to join"),
+      alias: z.string().optional().describe("Local alias for the room (if name collides)"),
+      name: z.string().optional().describe("Display name to use in this room (overrides default)")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ url, alias, name }) => {
+      if (!opts.onJoinRoom) return textResult("Joining rooms not supported.");
+      const result = await opts.onJoinRoom(url, alias, name);
+      if (!result.success) return textResult(result.error ?? "Failed to join room.");
+      if (result.roomName && result.agentName) {
+        return textResult(formatJoinResponse(result));
+      }
+      return textResult(`Joined room successfully.`);
+    }
+  );
+  server.tool(
+    "apiary__leave_room",
+    "Leave a room. Events stop flowing from it.",
+    {
+      room: z.string().describe("Room name to leave")
+    },
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+    async ({ room }) => {
+      if (!opts.onLeaveRoom) return textResult("Leaving rooms not supported.");
+      const result = await opts.onLeaveRoom(room);
+      return result.success ? textResult(`Left [${room}].`) : textResult(result.error ?? "Failed to leave room.");
+    }
+  );
+  server.tool(
+    "apiary__ping",
+    "Ping a participant for a status check. Non-blocking \u2014 they'll see it as context, not an interrupt.",
+    {
+      room: z.string().describe("Room name"),
+      participant: z.string().describe("Participant name to ping")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ room, participant }) => {
+      if (!opts.onPing) return textResult("Ping not supported.");
+      const result = await opts.onPing(room, participant);
+      return result.success ? textResult(`Pinged ${participant} in [${room}].`) : textResult(result.error ?? "Failed to ping participant.");
+    }
+  );
+  server.tool(
+    "apiary__wait_for_agent",
+    "Wait until another agent is idle (finished), blocked (needs a human), or working. Use this instead of re-reading the room in a loop to check on someone \u2014 polling costs a full turn each time, this costs one call. Returns as soon as they reach the state, or after the timeout with whatever state they're in; call again to keep waiting.",
+    {
+      room: z.string().describe("Room name"),
+      participant: z.string().describe("Agent to wait for"),
+      until: z.enum(["idle", "blocked", "working", "change"]).optional().describe("What to wait for. idle = they finished (default). blocked = they need a human. change = any state change."),
+      timeout_sec: z.number().optional().describe("How long to wait, in seconds. Default 60, max 120.")
+    },
+    { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    async ({ room, participant, until, timeout_sec }) => {
+      if (!opts.onWaitForAgent) return textResult("Waiting not supported.");
+      const result = await opts.onWaitForAgent(room, participant, until, timeout_sec);
+      return result.success ? textResult(result.message ?? "Done.") : textResult(result.error ?? "Failed to wait.");
+    }
+  );
+  if (can(opts.authority, "set_mode_for")) {
+    server.tool(
+      "apiary__admin__set_mode_for",
+      "Admin: set engagement mode for another participant.",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name"),
+        mode: z.string().describe("Engagement mode to set")
+      },
+      { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      async ({ room, participant, mode }) => {
+        if (!opts.onAdminSetModeFor) return textResult("Admin mode changes not supported.");
+        if (!isValidRuntimeMode(mode)) {
+          return textResult(`Invalid mode "${mode}". Valid modes: ${RUNTIME_MODES_LIST}.`);
+        }
+        const result = await opts.onAdminSetModeFor(room, participant, mode);
+        return result.success ? textResult(`Set ${participant}'s mode to ${mode} in [${room}].`) : textResult(result.error ?? "Failed to set mode.");
+      }
+    );
+    server.tool(
+      "apiary__admin__mute",
+      "Admin: make a participant read-only (demote to guest).",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name to mute")
+      },
+      { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      async ({ room, participant }) => {
+        if (!opts.onAdminMute) return textResult("Admin mute not supported.");
+        const result = await opts.onAdminMute(room, participant);
+        return result.success ? textResult(`Muted ${participant} in [${room}] (guest).`) : textResult(result.error ?? "Failed to mute participant.");
+      }
+    );
+    server.tool(
+      "apiary__admin__unmute",
+      "Admin: restore a muted participant (promote to member).",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name to unmute")
+      },
+      { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      async ({ room, participant }) => {
+        if (!opts.onAdminUnmute) return textResult("Admin unmute not supported.");
+        const result = await opts.onAdminUnmute(room, participant);
+        return result.success ? textResult(`Unmuted ${participant} in [${room}] (member).`) : textResult(result.error ?? "Failed to unmute participant.");
+      }
+    );
+  }
+  if (can(opts.authority, "kick")) {
+    server.tool(
+      "apiary__admin__kick",
+      "Admin: kick a participant from a room.",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name to kick")
+      },
+      { readOnlyHint: false, destructiveHint: true },
+      async ({ room, participant }) => {
+        if (!opts.onAdminKick) return textResult("Admin kick not supported.");
+        const result = await opts.onAdminKick(room, participant);
+        return result.success ? textResult(`Kicked ${participant} from [${room}].`) : textResult(result.error ?? "Failed to kick participant.");
+      }
+    );
+    server.tool(
+      "apiary__admin__promote",
+      "Admin: promote a participant to product owner (can mute/unmute members, set modes).",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name to promote")
+      },
+      { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      async ({ room, participant }) => {
+        if (!opts.onAdminPromote) return textResult("Admin promote not supported.");
+        const result = await opts.onAdminPromote(room, participant);
+        return result.success ? textResult(`Promoted ${participant} to product owner in [${room}].`) : textResult(result.error ?? "Failed to promote participant.");
+      }
+    );
+    server.tool(
+      "apiary__admin__demote",
+      "Admin: demote a product owner back to member.",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name to demote")
+      },
+      { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      async ({ room, participant }) => {
+        if (!opts.onAdminDemote) return textResult("Admin demote not supported.");
+        const result = await opts.onAdminDemote(room, participant);
+        return result.success ? textResult(`Demoted ${participant} to member in [${room}].`) : textResult(result.error ?? "Failed to demote participant.");
+      }
+    );
+  }
+}
+async function createRuntimeMcpServer(opts) {
+  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+  const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+  const httpServer = createServer(async (req, res) => {
+    if (req.url !== "/mcp") {
+      res.writeHead(404).end();
+      return;
+    }
+    const reqServer = new McpServer({ name: "apiary_runtime", version: "1.0.0" });
+    registerTools(reqServer, opts);
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+    });
+    await reqServer.connect(transport);
+    let body;
+    if (req.method === "POST") {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      try {
+        body = JSON.parse(Buffer.concat(chunks).toString());
+      } catch {
+        body = void 0;
+      }
+    }
+    await transport.handleRequest(req, res, body);
+  });
+  const port = await new Promise((resolve, reject) => {
+    httpServer.listen(0, "127.0.0.1", () => {
+      const addr = httpServer.address();
+      if (addr && typeof addr === "object") resolve(addr.port);
+      else reject(new Error("Could not determine server port"));
+    });
+    httpServer.once("error", reject);
+  });
+  const url = `http://127.0.0.1:${port}/mcp`;
+  let stopPromise = null;
+  const stop = () => {
+    if (!stopPromise) {
+      stopPromise = new Promise(
+        (resolve, reject) => httpServer.close((err) => err ? reject(err) : resolve())
+      );
+    }
+    return stopPromise;
+  };
+  return { url, stop };
+}
+async function createStdioRuntimeMcpServer(opts) {
+  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const mcpServer = new McpServer({ name: "apiary_runtime", version: "1.0.0" });
+  registerTools(mcpServer, opts);
+  const transport = new StdioServerTransport();
+  const closed = new Promise((resolve) => {
+    transport.onclose = () => resolve();
+  });
+  await mcpServer.connect(transport);
+  const stop = async () => {
+    await transport.close();
+    await mcpServer.close();
+  };
+  return { stop, closed };
+}
+
+// src/agent/sse-multiplexer.ts
+var SseMultiplexer = class {
+  _queue = [];
+  _waiters = [];
+  _connections = /* @__PURE__ */ new Map();
+  _closed = false;
+  /**
+   * Add an SSE connection to a stoop server.
+   * Starts streaming events immediately.
+   */
+  addConnection(serverUrl, sessionToken, roomName, roomId) {
+    if (this._connections.has(roomId) || this._closed) return;
+    const abortController = new AbortController();
+    const loopPromise = this._sseLoop(serverUrl, sessionToken, roomName, roomId, abortController.signal);
+    this._connections.set(roomId, { serverUrl, sessionToken, roomName, roomId, abortController, loopPromise });
+  }
+  /** Remove a connection by room ID. */
+  removeConnection(roomId) {
+    const entry = this._connections.get(roomId);
+    if (!entry) return;
+    entry.abortController.abort();
+    this._connections.delete(roomId);
+  }
+  /** Close all connections and signal the iterator to finish. */
+  close() {
+    this._closed = true;
+    for (const [, entry] of this._connections) {
+      entry.abortController.abort();
+    }
+    this._connections.clear();
+    for (const waiter of this._waiters) {
+      waiter.resolve(null);
+    }
+    this._waiters = [];
+  }
+  async _sseLoop(serverUrl, sessionToken, roomName, roomId, signal) {
+    const INITIAL_BACKOFF = 1e3;
+    const MAX_BACKOFF = 3e4;
+    let backoff = INITIAL_BACKOFF;
+    while (!signal.aborted && !this._closed) {
+      try {
+        const res = await fetch(`${serverUrl}/events`, {
+          method: "POST",
+          headers: {
+            Accept: "text/event-stream",
+            Authorization: `Bearer ${sessionToken}`
+          },
+          signal
+        });
+        if (!res.ok || !res.body) {
+          throw new Error(`SSE connect failed: ${res.status}`);
+        }
+        backoff = INITIAL_BACKOFF;
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (!signal.aborted) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const parts = buffer.split("\n\n");
+          buffer = parts.pop();
+          for (const part of parts) {
+            const dataLine = part.split("\n").find((l) => l.startsWith("data: "));
+            if (!dataLine) continue;
+            try {
+              const event = JSON.parse(dataLine.slice(6));
+              this._push({ roomId, roomName, event });
+            } catch {
+            }
+          }
+        }
+      } catch (err) {
+        if (signal.aborted) break;
+      }
+      if (!signal.aborted && !this._closed) {
+        await new Promise((r) => setTimeout(r, backoff));
+        backoff = Math.min(backoff * 2, MAX_BACKOFF);
+      }
+    }
+  }
+  _push(labeled) {
+    if (this._closed) return;
+    if (this._waiters.length > 0) {
+      const waiter = this._waiters.shift();
+      waiter.resolve(labeled);
+    } else {
+      this._queue.push(labeled);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this._queue.length > 0) {
+          return Promise.resolve({ value: this._queue.shift(), done: false });
+        }
+        if (this._closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve) => {
+          this._waiters.push({
+            resolve: (value) => {
+              if (this._closed || value === null) {
+                resolve({ value: void 0, done: true });
+              } else {
+                resolve({ value, done: false });
+              }
+            }
+          });
+        });
+      }
+    };
+  }
+};
+
+export {
+  LocalRoomDataSource,
+  parseEngagementMode,
+  StoopsEngagement,
+  classifyEvent,
+  RemoteRoomDataSource,
+  buildCatchUpLines,
+  EventMultiplexer,
+  RefMap,
+  shouldReportActivity,
+  EventProcessor,
+  RUNTIME_TOOL_NAMES,
+  createRuntimeMcpServer,
+  createStdioRuntimeMcpServer,
+  SseMultiplexer
+};
+//# sourceMappingURL=chunk-ZEFRNAX6.js.map