symposium-mcp 0.2.0 → 0.3.1

package/dist/mcp.js

@@ -3231,8 +3231,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path2) {
-      let input2 = path2;
+    function removeDotSegments(path5) {
+      let input2 = path5;
       const output2 = [];
       let nextSlash = -1;
       let len = 0;
@@ -3324,9 +3324,9 @@ var require_utils = __commonJS({
           const hex3 = input2.slice(i + 1, i + 3);
           if (isHexPair(hex3)) {
             const normalizedHex = hex3.toUpperCase();
-            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
-            if (decodeUnreserved && isUnreserved(decoded)) {
-              output2 += decoded;
+            const decoded2 = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded2)) {
+              output2 += decoded2;
             } else {
               output2 += "%" + normalizedHex;
             }
@@ -3345,9 +3345,9 @@ var require_utils = __commonJS({
           const hex3 = input2.slice(i + 1, i + 3);
           if (isHexPair(hex3)) {
             const normalizedHex = hex3.toUpperCase();
-            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
-            if (decoded !== "." && isUnreserved(decoded)) {
-              output2 += decoded;
+            const decoded2 = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded2 !== "." && isUnreserved(decoded2)) {
+              output2 += decoded2;
             } else {
               output2 += "%" + normalizedHex;
             }
@@ -3484,8 +3484,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path2, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
+        const [path5, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path5 && path5 !== "/" ? path5 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6269,7 +6269,7 @@ var require_discriminator = __commonJS({
       error: error62,
       code(cxt) {
         const { gen, data, schema, parentSchema, it } = cxt;
-        const { oneOf } = parentSchema;
+        const { oneOf: oneOf2 } = parentSchema;
         if (!it.opts.discriminator) {
           throw new Error("discriminator: requires discriminator option");
         }
@@ -6278,7 +6278,7 @@ var require_discriminator = __commonJS({
           throw new Error("discriminator: requires propertyName");
         if (schema.mapping)
           throw new Error("discriminator: mapping is not supported");
-        if (!oneOf)
+        if (!oneOf2)
           throw new Error("discriminator: requires oneOf keyword");
         const valid = gen.let("valid", false);
         const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
@@ -6306,8 +6306,8 @@ var require_discriminator = __commonJS({
           const oneOfMapping = {};
           const topRequired = hasRequired(parentSchema);
           let tagRequired = true;
-          for (let i = 0; i < oneOf.length; i++) {
-            let sch = oneOf[i];
+          for (let i = 0; i < oneOf2.length; i++) {
+            let sch = oneOf2[i];
             if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
               const ref = sch.$ref;
               sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
@@ -6898,7 +6898,7 @@ var require_dist = __commonJS({
 });
 
 // src/mcp.ts
-import { hostname as hostname3 } from "node:os";
+import { hostname as hostname4 } from "node:os";
 
 // ../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v3/helpers/util.js
 var util;
@@ -7274,8 +7274,8 @@ function getErrorMap() {
 
 // ../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path2, errorMaps, issueData } = params;
-  const fullPath = [...path2, ...issueData.path || []];
+  const { data, path: path5, errorMaps, issueData } = params;
+  const fullPath = [...path5, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7390,11 +7390,11 @@ var errorUtil;
 
 // ../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path2, key) {
+  constructor(parent, value, path5, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path2;
+    this._path = path5;
     this._key = key;
   }
   get path() {
@@ -7790,14 +7790,14 @@ function isValidJWT(jwt2, alg) {
     if (!header)
       return false;
     const base643 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
-    const decoded = JSON.parse(atob(base643));
-    if (typeof decoded !== "object" || decoded === null)
+    const decoded2 = JSON.parse(atob(base643));
+    if (typeof decoded2 !== "object" || decoded2 === null)
       return false;
-    if ("typ" in decoded && decoded?.typ !== "JWT")
+    if ("typ" in decoded2 && decoded2?.typ !== "JWT")
       return false;
-    if (!decoded.alg)
+    if (!decoded2.alg)
       return false;
-    if (alg && decoded.alg !== alg)
+    if (alg && decoded2.alg !== alg)
       return false;
     return true;
   } catch {
@@ -11349,10 +11349,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11692,11 +11692,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -12158,16 +12158,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path2 = []) => {
+  const processError = (error63, path5 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -12206,17 +12206,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path2 = []) => {
+  const processError = (error63, path5 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12255,8 +12255,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13358,9 +13358,9 @@ var asciiTabOrNewline = /[\t\n\r]/g;
 function stripTabAndNewline(value) {
   return value.replace(asciiTabOrNewline, "");
 }
-function urlHostnameOk(url2, hostname4) {
-  hostname4.lastIndex = 0;
-  return hostname4.test(url2.hostname);
+function urlHostnameOk(url2, hostname5) {
+  hostname5.lastIndex = 0;
+  return hostname5.test(url2.hostname);
 }
 function urlProtocolOk(url2, protocol) {
   protocol.lastIndex = 0;
@@ -27807,11 +27807,11 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
-function getDotPath(path2) {
-  if (path2.length === 0) {
+function getDotPath(path5) {
+  if (path5.length === 0) {
     return "object root";
   }
-  return path2.reduce((acc, seg, index) => {
+  return path5.reduce((acc, seg, index) => {
     if (index === 0) {
       return String(seg);
     }
@@ -30038,13 +30038,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path2 = ref.slice(1).split("/").filter(Boolean);
-  if (path2.length === 0) {
+  const path5 = ref.slice(1).split("/").filter(Boolean);
+  if (path5.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path2[0] === defsKey) {
-    const key = path2[1] === void 0 ? void 0 : decodeJSONPointerSegment(path2[1]);
+  if (path5[0] === defsKey) {
+    const key = path5[1] === void 0 ? void 0 : decodeJSONPointerSegment(path5[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -33507,13 +33507,13 @@ var zodToJsonSchema = (schema, options) => {
     }, true) ?? parseAnyDef(refs)
   }), {}) : void 0;
   const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
-  const main = parseDef(schema._def, name === void 0 ? refs : {
+  const main2 = parseDef(schema._def, name === void 0 ? refs : {
     ...refs,
     currentPath: [...refs.basePath, refs.definitionPath, name]
   }, false) ?? parseAnyDef(refs);
   const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
   if (title !== void 0) {
-    main.title = title;
+    main2.title = title;
   }
   if (refs.flags.hasReferencedOpenAiAnyType) {
     if (!definitions) {
@@ -33534,9 +33534,9 @@ var zodToJsonSchema = (schema, options) => {
     }
   }
   const combined = name === void 0 ? definitions ? {
-    ...main,
+    ...main2,
     [refs.definitionPath]: definitions
-  } : main : {
+  } : main2 : {
     $ref: [
       ...refs.$refStrategy === "relative" ? [] : refs.basePath,
       refs.definitionPath,
@@ -33544,7 +33544,7 @@ var zodToJsonSchema = (schema, options) => {
     ].join("/"),
     [refs.definitionPath]: {
       ...definitions,
-      [name]: main
+      [name]: main2
     }
   };
   if (refs.target === "jsonSchema7") {
@@ -34190,7 +34190,7 @@ var Protocol = class {
           }
         };
       }
-      const cancel = (reason) => {
+      const cancel = (reason2) => {
         this._responseHandlers.delete(messageId);
         this._progressHandlers.delete(messageId);
         this._cleanupTimeout(messageId);
@@ -34199,10 +34199,10 @@ var Protocol = class {
           method: "notifications/cancelled",
           params: {
             requestId: messageId,
-            reason: String(reason)
+            reason: String(reason2)
           }
         }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error63) => this._onerror(new Error(`Failed to send cancellation: ${error63}`)));
-        const error62 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
+        const error62 = reason2 instanceof McpError ? reason2 : new McpError(ErrorCode.RequestTimeout, String(reason2));
         reject(error62);
       };
       this._responseHandlers.set(messageId, (response) => {
@@ -36301,6 +36301,7 @@ var StdioServerTransport = class {
 
 // ../lib/meeting/protocol.ts
 var MAX_DOC_PACKET_BYTES = 12 * 1024;
+var MAIN_DOC_ID = "main";
 var DOC_EDIT_OPS = ["append", "replace_section", "replace_all"];
 var MAX_WAIT_SECONDS = 50;
 var MAX_SURFACE_HTML_BYTES = 512 * 1024;
@@ -36315,6 +36316,15 @@ function agentIdOfKey(key) {
 }
 var PROPOSAL_PROGRESS = ["working", "done", "failed"];
 var REQUEST_STATUSES = ["acknowledged", "working", "done", "failed"];
+var WORK_KINDS = [
+  "thinking",
+  "searching",
+  "writing",
+  "drawing",
+  "charting",
+  "building"
+];
+var AGENT_WORK_TTL_MS = 3 * 6e4;
 var PRESENCE_IDLE_AFTER_MS = 5 * 6e4;
 var SPACE_EVENT_TYPES = [
   "speech",
@@ -36324,6 +36334,7 @@ var SPACE_EVENT_TYPES = [
   "proposal",
   "proposal_decided",
   "doc_changed",
+  "doc_removed",
   "ui_event",
   "state_changed",
   "surface_changed",
@@ -36349,13 +36360,13 @@ function fromBase64Url(code) {
 function findConnect(pasted) {
   for (const [, body] of pasted.matchAll(/symc_([A-Za-z0-9_-]{20,})/g)) {
     try {
-      const connect2 = JSON.parse(fromBase64Url(body));
-      if (typeof connect2?.api === "string" && typeof connect2?.id === "string" && typeof connect2?.secret === "string") {
+      const connect3 = JSON.parse(fromBase64Url(body));
+      if (typeof connect3?.api === "string" && typeof connect3?.id === "string" && typeof connect3?.secret === "string") {
         return {
-          api: connect2.api,
-          id: connect2.id,
-          secret: connect2.secret,
-          ...typeof connect2.space === "string" ? { space: connect2.space } : {}
+          api: connect3.api,
+          id: connect3.id,
+          secret: connect3.secret,
+          ...typeof connect3.space === "string" ? { space: connect3.space } : {}
         };
       }
     } catch {
@@ -36545,19 +36556,36 @@ async function call(url2, init) {
   }
   return resp.status === 204 ? void 0 : await resp.json();
 }
-function redeemConnect(connect2, about) {
-  return call(`${connect2.api}/agents/claim`, {
+function redeemConnect(connect3, about) {
+  return call(`${connect3.api}/agents/claim`, {
+    method: "POST",
+    body: { id: connect3.id, secret: connect3.secret, ...about }
+  });
+}
+async function redeemConnectFor(connect3, agents) {
+  const connected = await call(`${connect3.api}/agents/claim`, {
     method: "POST",
-    body: { id: connect2.id, secret: connect2.secret, ...about }
+    body: { id: connect3.id, secret: connect3.secret, agents }
   });
+  if (connected.all?.length !== agents.length) {
+    throw new Error("This Symposium site cannot connect several agents with one code yet.");
+  }
+  return { person: connected.person, all: connected.all };
 }
-var AccountClient = class {
+var AccountClient = class _AccountClient {
   constructor(api, token) {
     this.api = api;
     this.token = token;
   }
   api;
   token;
+  /**
+   * The same credential at another site. Only for a site that shares this one's
+   * accounts, which is what a summons naming it (`Summons.api`) says.
+   */
+  at(api) {
+    return api === this.api ? this : new _AccountClient(api, this.token);
+  }
   /** The spaces this agent's person owns or is a member of, most recently active first. */
   async spaces() {
     return (await call(`${this.api}/agents/me/spaces`, {
@@ -36606,6 +36634,18 @@ var AccountClient = class {
     }
   }
 };
+function summonsApi(summons, fallback) {
+  if (!summons.api) return fallback;
+  try {
+    const url2 = new URL(summons.api);
+    const local = /^(localhost|127\.0\.0\.1|\[::1\]|.+\.localhost)$/.test(url2.hostname);
+    if (url2.protocol !== "https:" && !(url2.protocol === "http:" && local)) return fallback;
+    if (url2.username || url2.password || url2.search || url2.hash) return fallback;
+    return url2.href.replace(/\/$/, "");
+  } catch {
+    return fallback;
+  }
+}
 var SUMMONS_FRESH_MS = 10 * 60 * 1e3;
 function chooseSpace(spaces, wanted, summoned) {
   const query = wanted?.trim().toLowerCase();
@@ -36633,6 +36673,8 @@ var SpaceClient = class {
   space;
   /** Origin of the Symposium app this space lives on. */
   appOrigin;
+  /** Base URL of that app's REST API, as the invite gave it (no trailing slash). */
+  api;
   base;
   key;
   cursor;
@@ -36641,10 +36683,11 @@ var SpaceClient = class {
     this.space = space2;
     this.key = key;
     this.appOrigin = new URL(api).origin;
-    this.base = `${api.replace(/\/$/, "")}/spaces/${encodeURIComponent(space2)}`;
+    this.api = api.replace(/\/$/, "");
+    this.base = `${this.api}/spaces/${encodeURIComponent(space2)}`;
   }
-  async request(method, path2, body, timeoutMs = 3e4) {
-    const resp = await fetch(this.base + path2, {
+  async request(method, path5, body, timeoutMs = 3e4) {
+    const resp = await fetch(this.base + path5, {
       method,
       headers: {
         Authorization: `Bearer ${this.key}`,
@@ -36652,11 +36695,16 @@ var SpaceClient = class {
       },
       body: body !== void 0 ? JSON.stringify(body) : void 0,
       signal: AbortSignal.timeout(timeoutMs)
+    }).catch((e) => {
+      const why = e instanceof Error ? e.message : String(e);
+      throw new Error(
+        `Could not reach ${this.appOrigin} (${why}). If that site is no longer running, call join_space to join again.`
+      );
     });
     if (!resp.ok) {
       const detail = await resp.json().catch(() => null);
       throw new Error(
-        `${method} ${path2} failed (${resp.status}): ${detail?.error ?? resp.statusText}`
+        `${method} ${path5} failed (${resp.status}): ${detail?.error ?? resp.statusText}`
       );
     }
     return resp.status === 204 ? void 0 : await resp.json();
@@ -36705,23 +36753,46 @@ var SpaceClient = class {
   postMessage(text2) {
     return this.request("POST", "/timeline", { text: text2 });
   }
-  // --- shared document -------------------------------------------------------------
-  /** The space's shared document, as Markdown. */
-  async readDocument() {
-    return (await this.request("GET", "/doc")).markdown;
+  // --- shared documents ------------------------------------------------------------
+  /** The space's shared documents, the one it started with (`main`) first. */
+  async listDocuments() {
+    return (await this.request("GET", "/docs")).docs;
+  }
+  /** Add a document to the space, optionally with its first text in Markdown. */
+  createDocument(input2) {
+    return this.request("POST", "/docs", input2);
   }
   /**
-   * Edit the shared document. People may be typing in it at the same time, so prefer
+   * One of the shared documents, as Markdown (`main` unless you name another). People see
+   * this agent on the document's tab for a little while afterwards.
+   */
+  async readDocument(id = MAIN_DOC_ID) {
+    return (await this.request("GET", `/docs/${encodeURIComponent(id)}`)).markdown;
+  }
+  /**
+   * Edit a shared document. People may be typing in it at the same time, so prefer
    * `append` or `replace_section` (which only touch part of it) to `replace_all`.
-   * Returns the document after the edit, as Markdown.
+   * What the edit adds or changes is shown to everyone as written by this agent, until a
+   * person edits it. Returns the document after the edit, as Markdown.
    */
-  async editDocument(edit) {
-    return (await this.request("POST", "/doc/edits", edit)).markdown;
+  async editDocument(edit, id = MAIN_DOC_ID) {
+    return (await this.request(
+      "POST",
+      `/docs/${encodeURIComponent(id)}/edits`,
+      edit
+    )).markdown;
+  }
+  renameDocument(id, title) {
+    return this.request("PATCH", `/docs/${encodeURIComponent(id)}`, { title });
+  }
+  /** Remove a document this agent made. The first document (`main`) cannot be removed. */
+  removeDocument(id) {
+    return this.request("DELETE", `/docs/${encodeURIComponent(id)}`);
   }
   // --- proposals -------------------------------------------------------------------
   /**
    * Offer to do something and wait for a person to approve. Shows as a card in the
-   * Conversation tab. Do not act until a `proposal_decided` event arrives with this
+   * conversation. Do not act until a `proposal_decided` event arrives with this
    * proposal's `seq` and decision `approved`.
    */
   propose(text2, options = {}) {
@@ -36733,12 +36804,16 @@ var SpaceClient = class {
   }
   // --- attention -------------------------------------------------------------------
   /**
-   * Bring everyone's stage to one tab: a surface (yours or anyone's), or the
-   * Conversation tab. People are switched to it, with a note saying you did it and a
-   * way to go back. Use it when you have put up something everyone should look at now.
+   * Bring everyone's stage to one tab: a surface (yours or anyone's), a document or
+   * Agents. People are switched to it, with a note saying you did it and a way to go
+   * back. Use it when you have put up something everyone should look at now. The
+   * conversation is a column beside the stage, not a tab: that target opens it for
+   * anyone who has closed it. `size` asks for it large: `expanded` gives the stage the
+   * screen, `alone` opens a surface on its own instead of as a tile among the others.
+   * Nobody's stage is made smaller.
    */
-  bringEveryoneTo(target) {
-    return this.request("POST", "/focus", { target });
+  bringEveryoneTo(target, size) {
+    return this.request("POST", "/focus", { target, size });
   }
   // --- requests --------------------------------------------------------------------
   /** This agent's id, as it appears in `request` events' `to` list. */
@@ -36749,10 +36824,23 @@ var SpaceClient = class {
    * Tell everyone in the space how you are getting on with a request addressed to you
    * (a `request` event; its `seq` is the request id). People see this next to the
    * request: `acknowledged` as soon as you have seen it, `working` (with a short note
-   * on what you are doing) while you act, then `done` or `failed`.
+   * on what you are doing) while you act, then `done` or `failed`. `surfaceId` says
+   * which surface the work is on: people see this agent on that tab meanwhile. `doing`
+   * says what kind of work it is, which the agent's figure shows. `doc` says which shared
+   * document the work is in, and under which heading: people see this agent on that
+   * document's tab, and beside that section in the text.
+   */
+  updateRequest(id, status, note, surfaceId, doing, doc) {
+    return this.request("PATCH", `/requests/${id}`, { status, note, surfaceId, doing, ...doc });
+  }
+  /**
+   * Show the space what this agent is working on when it is not an answer to a request.
+   * Its figure plays the matching animation for everyone, on the surface's or the
+   * document's tab if one is named. Say it again to renew or change it (it lapses after a few minutes), and
+   * pass `done` when finished. `key` tells several pieces of work apart.
    */
-  updateRequest(id, status, note) {
-    return this.request("PATCH", `/requests/${id}`, { status, note });
+  setWork(work) {
+    return this.request("PUT", "/work", work);
   }
   // --- events ----------------------------------------------------------------------
   /** How far through the event log this client has read: save it to carry on later. */
@@ -36852,16 +36940,73 @@ function agentName(client2, configured = process.env.SYMPOSIUM_AGENT_NAME) {
   return words.map((w) => w[0].toUpperCase() + w.slice(1)).join(" ") || "Agent";
 }
 
+// src/setup.ts
+import { spawn, spawnSync } from "node:child_process";
+import { copyFileSync, existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2, hostname as hostname3 } from "node:os";
+import path3 from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+
+// src/command.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+function whereIs(command, env = process.env, exists = existsSync) {
+  const extensions = (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  for (const dir of (env.PATH ?? env.Path ?? "").split(";")) {
+    if (!dir) continue;
+    for (const extension of extensions) {
+      const file3 = path.win32.join(dir, command + extension.toLowerCase());
+      if (exists(file3)) return file3;
+    }
+  }
+  return void 0;
+}
+var quoted = (arg) => /^[\w\-./:\\=@]+$/.test(arg) ? arg : `"${arg.replace(/["%]/g, "")}"`;
+function starting(command, args, platform = process.platform, find = whereIs) {
+  if (platform !== "win32") return { file: command, args, shell: false };
+  const file3 = find(command);
+  if (!file3) return void 0;
+  if (!/\.(cmd|bat)$/i.test(file3)) return { file: file3, args, shell: false };
+  return { file: [file3, ...args].map(quoted).join(" "), args: [], shell: true };
+}
+function relaxed(text2) {
+  let out = "";
+  for (let i = 0; i < text2.length; i++) {
+    const c = text2[i];
+    if (c === '"') {
+      const start2 = i;
+      for (i++; i < text2.length && text2[i] !== '"'; i++) if (text2[i] === "\\") i++;
+      out += text2.slice(start2, i + 1);
+    } else if (c === "/" && text2[i + 1] === "/") {
+      while (i < text2.length && text2[i] !== "\n") i++;
+      out += "\n";
+    } else if (c === "/" && text2[i + 1] === "*") {
+      const end = text2.indexOf("*/", i + 2);
+      i = end < 0 ? text2.length : end + 1;
+    } else if (c === "}" || c === "]") {
+      out = out.replace(/,\s*$/, "") + c;
+    } else {
+      out += c;
+    }
+  }
+  return out;
+}
+function decoded(bytes) {
+  if (bytes[0] === 255 && bytes[1] === 254) return bytes.subarray(2).toString("utf16le");
+  return bytes.toString("utf8").replace(/^/, "");
+}
+
 // src/remembered.ts
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import path from "node:path";
+import path2 from "node:path";
 var FIRST_AGENT = "Claude";
 function stateFile(agent2, home = homedir(), override = process.env.SYMPOSIUM_STATE_FILE) {
   if (override) return override;
   const slug = agent2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
   const name = slug === FIRST_AGENT.toLowerCase() ? "mcp.json" : `mcp.${slug || "agent"}.json`;
-  return path.join(home, ".symposium", name);
+  return path2.join(home, ".symposium", name);
 }
 var agent = FIRST_AGENT;
 function rememberAs(name) {
@@ -36879,7 +37024,7 @@ function load() {
 function save(next) {
   try {
     const target = file2();
-    mkdirSync(path.dirname(target), { recursive: true, mode: 448 });
+    mkdirSync(path2.dirname(target), { recursive: true, mode: 448 });
     const temp = `${target}.${process.pid}.tmp`;
     writeFileSync(temp, JSON.stringify(next), { mode: 384 });
     renameSync(temp, target);
@@ -36897,12 +37042,408 @@ function startingInvite(configured = process.env.SYMPOSIUM_INVITE) {
 function rememberInvite(invite, configured = process.env.SYMPOSIUM_INVITE) {
   return save({ ...load(), invite, configured: configured ?? "" });
 }
-function savedAccount() {
-  const account2 = load().account;
-  return typeof account2?.api === "string" && typeof account2?.token === "string" ? account2 : void 0;
+var isAccount = (value) => {
+  const account2 = value;
+  return typeof account2?.api === "string" && typeof account2?.token === "string";
+};
+var accounts = (saved) => [saved.account, ...Array.isArray(saved.others) ? saved.others : []].filter(isAccount);
+function savedAccount(api) {
+  const all = accounts(load());
+  return api && all.find((a) => a.api === api) || all[0];
 }
 function rememberAccount(account2) {
-  return save({ ...load(), account: account2 });
+  const saved = load();
+  if (!account2) return save({ ...saved, account: void 0, others: void 0 });
+  const [first, ...rest] = accounts(saved);
+  if (!first || first.api === account2.api) return save({ ...saved, account: account2, others: rest });
+  return save({
+    ...saved,
+    account: first,
+    others: [...rest.filter((a) => a.api !== account2.api), account2]
+  });
+}
+
+// src/setup.ts
+var SERVER = "symposium";
+var realHost = {
+  run(command, args) {
+    const how = starting(command, args);
+    if (!how) return void 0;
+    const done = spawnSync(how.file, how.args, {
+      stdio: ["ignore", "ignore", "pipe"],
+      encoding: "utf8",
+      shell: how.shell,
+      timeout: 6e4
+    });
+    if (done.error) {
+      const missing = done.error.code === "ENOENT";
+      return missing ? void 0 : { status: 1, said: done.error.message };
+    }
+    return { status: done.status ?? 1, said: lastLine(done.stderr ?? "") };
+  },
+  redeem: redeemConnectFor,
+  join: (account2, space2) => new AccountClient(account2.api, account2.token).join(space2),
+  say: (line) => void process.stdout.write(`${line}
+`),
+  async ask(question) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) return void 0;
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    const gone = new Promise(
+      (resolve) => prompt.once("close", () => resolve(void 0))
+    );
+    try {
+      const answer = await Promise.race([prompt.question(question), gone]).catch(() => void 0);
+      if (answer === void 0) process.stdout.write("\n");
+      return answer;
+    } finally {
+      prompt.close();
+    }
+  },
+  open(command, args) {
+    return new Promise((resolve) => {
+      const how = starting(command, args);
+      if (!how) return resolve();
+      const ignore = () => {
+      };
+      process.on("SIGINT", ignore);
+      const child = spawn(how.file, how.args, { stdio: "inherit", shell: how.shell });
+      const done = () => {
+        process.off("SIGINT", ignore);
+        resolve();
+      };
+      child.on("error", done);
+      child.on("exit", done);
+    });
+  }
+};
+function lastLine(output2) {
+  const lines = output2.replace(/\x1b\[[0-9;]*m/g, "").split("\n").map((line) => line.trim()).filter(Boolean);
+  return (lines.at(-1) ?? "").slice(0, 200);
+}
+function serverCommand(self = fileURLToPath(import.meta.url), platform = process.platform) {
+  const npx = self.endsWith(".ts") ? ["npx", "-y", "tsx", path3.join(path3.dirname(self), "mcp.ts")] : ["npx", "-y", "symposium-mcp"];
+  return platform === "win32" ? ["cmd", "/c", ...npx] : npx;
+}
+var withCommand = (label, agent2, bin, add) => ({
+  label,
+  agent: agent2,
+  // Installed and working: a command that cannot say its version cannot be set up either.
+  found: (host) => host.run(bin, ["--version"])?.status === 0,
+  register(host, command) {
+    if (host.run(bin, ["mcp", "get", SERVER])?.status === 0) return { tools: "present" };
+    const added = host.run(bin, add(command));
+    if (added?.status !== 0) {
+      throw new Error(`\`${bin} mcp add\` failed${added?.said ? ` (${added.said})` : ""}`);
+    }
+    return { tools: "added" };
+  },
+  start: (prompt) => [bin, prompt]
+});
+var withConfigFile = (label, agent2, dir, file3) => {
+  const entry = (command) => ({
+    command: command[0],
+    args: command.slice(1),
+    env: { SYMPOSIUM_AGENT_NAME: agent2 }
+  });
+  const target = () => path3.join(homedir2(), ...dir, file3);
+  return {
+    label,
+    agent: agent2,
+    found: () => existsSync2(path3.join(homedir2(), ...dir)),
+    register(_host, command) {
+      let settings = {};
+      let loose = false;
+      const text2 = existsSync2(target()) ? decoded(readFileSync2(target())) : "";
+      if (text2.trim()) {
+        let parsed;
+        try {
+          parsed = JSON.parse(text2);
+        } catch {
+          loose = true;
+          try {
+            parsed = JSON.parse(relaxed(text2));
+          } catch {
+            parsed = null;
+          }
+        }
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+          throw new Error(`${target()} could not be read as JSON`);
+        }
+        settings = parsed;
+      }
+      const servers = settings.mcpServers;
+      const existing = typeof servers === "object" && servers !== null && !Array.isArray(servers) ? servers : {};
+      if (SERVER in existing) return { tools: "present" };
+      const kept = `${target()}.before-symposium`;
+      if (loose) copyFileSync(target(), kept);
+      settings.mcpServers = { ...existing, [SERVER]: entry(command) };
+      writeFileSync2(target(), `${JSON.stringify(settings, null, 2)}
+`);
+      return {
+        tools: "added",
+        note: loose ? `the file's comments are kept in ${path3.basename(kept)}` : void 0
+      };
+    },
+    byHand: (command) => `${label}: add this inside "mcpServers" in ${target()}
+    "${SERVER}": ${JSON.stringify(entry(command))}`
+  };
+};
+var TARGETS = [
+  withCommand("Claude Code", "Claude", "claude", (command) => [
+    "mcp",
+    "add",
+    "--scope",
+    "user",
+    SERVER,
+    "--",
+    ...command
+  ]),
+  withCommand("Codex", "Codex", "codex", (command) => ["mcp", "add", SERVER, "--", ...command]),
+  withConfigFile("Cursor", "Cursor", [".cursor"], "mcp.json"),
+  withConfigFile("Gemini CLI", "Gemini", [".gemini"], "settings.json"),
+  withConfigFile("Windsurf", "Windsurf", [".codeium", "windsurf"], "mcp_config.json")
+];
+var reason = (e) => e instanceof Error ? e.message : String(e);
+async function setup(argv, host = realHost) {
+  const pasted = argv.join(" ").trim();
+  const code = pasted ? findConnect(pasted) : void 0;
+  if (pasted && !code) {
+    host.say(
+      'That is not a Symposium connect code. Press "Connect your agent" in Symposium and copy the line again.'
+    );
+    return 1;
+  }
+  const command = serverCommand();
+  const found = TARGETS.filter((target) => target.found(host));
+  if (found.length === 0) {
+    host.say("No agent that setup knows was found on this computer.");
+    host.say(`It looks for: ${TARGETS.map((t) => t.label).join(", ")}.`);
+    host.say(`For any other MCP client, add this as a stdio server: ${command.join(" ")}`);
+    return 1;
+  }
+  const rows = found.map((target) => {
+    try {
+      return { target, note: "", ...target.register(host, command) };
+    } catch (e) {
+      return { target, tools: "failed", note: reason(e) };
+    }
+  });
+  let failed = rows.some((row) => row.tools === "failed");
+  const connection = /* @__PURE__ */ new Map();
+  const paired = (name) => {
+    rememberAs(name);
+    const account2 = savedAccount(code?.api);
+    return code && account2?.api === code.api ? account2 : void 0;
+  };
+  if (code) {
+    const names = [...new Set(rows.filter((r) => r.tools !== "failed").map((r) => r.target.agent))];
+    const fresh = names.filter((name) => !paired(name));
+    for (const name of names) if (!fresh.includes(name)) connection.set(name, "already connected");
+    if (fresh.length) {
+      try {
+        const { person, all } = await host.redeem(
+          code,
+          fresh.map((name) => ({ name, device: hostname3() }))
+        );
+        fresh.forEach((name, i) => {
+          rememberAs(name);
+          const saved = rememberAccount({ api: code.api, token: all[i].token, person });
+          connection.set(
+            name,
+            saved ? `connected for ${person}` : "connected, but the connection could not be saved"
+          );
+          failed ||= !saved;
+        });
+      } catch (e) {
+        failed = true;
+        for (const name of fresh) connection.set(name, `not connected: ${reason(e)}`);
+      }
+    }
+    if (code.space) {
+      for (const name of names) {
+        const account2 = paired(name);
+        if (!account2) continue;
+        try {
+          rememberInvite(encodeInvite(await host.join(account2, code.space)));
+        } catch (e) {
+          connection.set(name, `${connection.get(name)}; could not join the space: ${reason(e)}`);
+        }
+      }
+    }
+  }
+  const width = Math.max(...rows.map((row) => row.target.label.length));
+  host.say("Symposium setup");
+  host.say("");
+  for (const row of rows) {
+    const tools = row.tools === "added" ? "tools added" : row.tools === "present" ? "tools already there" : `could not add the tools: ${row.note}`;
+    const link = row.tools === "failed" ? void 0 : connection.get(row.target.agent);
+    const note = row.tools !== "failed" && row.note ? `(${row.note})` : void 0;
+    host.say(
+      `  ${row.target.label.padEnd(width)}  ${[tools, link].filter(Boolean).join(", ")}${note ? ` ${note}` : ""}`
+    );
+  }
+  host.say("");
+  const byHand = rows.filter((row) => row.tools === "failed" && row.target.byHand);
+  for (const row of byHand) host.say(row.target.byHand(command));
+  if (byHand.length) host.say("");
+  const working = rows.filter((row) => row.tools !== "failed");
+  if (!code) {
+    if (working.length) {
+      host.say(
+        'To connect them: press "Connect your agent" in Symposium and run the line it shows.'
+      );
+    }
+    return failed ? 1 : 0;
+  }
+  const connected = working.filter((row) => paired(row.target.agent));
+  if (connected.length === 0) {
+    host.say(
+      'No agent was connected. Once the above is sorted out, press "Connect your agent" in Symposium again and run the new line.'
+    );
+    return 1;
+  }
+  const ready = connected.filter((row) => row.target.start);
+  const chosen = ready.length ? await choose(
+    host,
+    ready.map((row) => row.target)
+  ) : void 0;
+  if (!chosen) {
+    host.say(
+      `Start a new session in ${oneOf(connected.map((row) => row.target.label))} and say "join my meeting".`
+    );
+    return failed ? 1 : 0;
+  }
+  const [bin, ...args] = chosen.start(
+    code.space && /^[\w .-]+$/.test(code.space) ? `Join my Symposium meeting in the space ${code.space}.` : "Join my Symposium meeting."
+  );
+  await host.open(bin, args);
+  return failed ? 1 : 0;
+}
+var oneOf = (names) => names.length < 2 ? names.join("") : `${names.slice(0, -1).join(", ")} or ${names.at(-1)}`;
+async function choose(host, targets) {
+  const question = targets.length === 1 ? `Open ${targets[0].label} in the meeting now? [Y/n] ` : `Open one in the meeting now? ${targets.map((t, i) => `${i + 1}) ${t.label}`).join("  ")}  [1, or n for none] `;
+  const answer = (await host.ask(question))?.trim().toLowerCase();
+  if (answer === void 0 || answer.startsWith("n")) return void 0;
+  if (answer === "" || answer.startsWith("y")) return targets[0];
+  return targets[Number(answer) - 1];
+}
+
+// src/wake.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import path4 from "node:path";
+import { pathToFileURL } from "node:url";
+function wakeEvents(events, agentId, now, maxAgeMs) {
+  return events.filter(
+    (e) => now - e.ts <= maxAgeMs && (e.type !== "request" || e.to.includes(agentId))
+  );
+}
+var flag = (name, fallback) => {
+  const hit = process.argv.find((a) => a.startsWith(`--${name}=`));
+  return hit ? hit.slice(name.length + 3) : fallback;
+};
+var minutes = (name, fallback) => {
+  const n = Number(flag(name, String(fallback)));
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+function positionFile(client2) {
+  const safe = (s) => s.replace(/[^\w-]/g, "_");
+  return path4.join(
+    path4.dirname(stateFile("")),
+    `wake-${safe(client2.space)}-${safe(client2.agentId)}`
+  );
+}
+function readPosition(file3) {
+  try {
+    const n = Number(readFileSync3(file3, "utf8"));
+    return Number.isInteger(n) && n >= 0 ? n : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function savePosition(file3, position) {
+  if (position === void 0) return;
+  try {
+    mkdirSync2(path4.dirname(file3), { recursive: true, mode: 448 });
+    const temp = `${file3}.${process.pid}.tmp`;
+    writeFileSync3(temp, String(position), { mode: 384 });
+    renameSync2(temp, file3);
+  } catch {
+  }
+}
+function rememberPosition(client2) {
+  const position = client2.position;
+  if (position === void 0) return;
+  const file3 = positionFile(client2);
+  if ((readPosition(file3) ?? -1) < position) savePosition(file3, position);
+}
+function withoutHeard(client2, events) {
+  const heard = readPosition(positionFile(client2)) ?? -1;
+  return events.filter(
+    (e) => !(e.type === "request" && e.seq <= heard && e.to.includes(client2.agentId))
+  );
+}
+async function connect() {
+  const wanted = flag("space", "");
+  if (!wanted) {
+    const invite = startingInvite();
+    return invite ? new SpaceClient(invite) : "No space to join: pass --space=<name or id>.";
+  }
+  const api = flag("api", "").replace(/\/$/, "");
+  const saved = savedAccount(api || void 0);
+  if (!saved) return "--space needs this agent connected to an account (use connect first).";
+  const paired = new AccountClient(api || saved.api, saved.token);
+  const choice = chooseSpace(await paired.spaces(), wanted);
+  if (!("space" in choice)) {
+    return `${choice.why} Try one of: ${choice.candidates.map((s) => s.name || s.id).join(", ")}`;
+  }
+  return new SpaceClient(await paired.join(choice.space.id));
+}
+async function main() {
+  const agent2 = flag("agent", "");
+  if (agent2) rememberAs(agent2);
+  const client2 = await connect();
+  if (typeof client2 === "string") {
+    console.error(client2);
+    return 2;
+  }
+  const types = flag("types", "request").split(",").filter(Boolean);
+  const maxAgeMs = minutes("max-age-minutes", 10) * 6e4;
+  const deadline = Date.now() + minutes("max-minutes", 30) * 6e4;
+  const file3 = positionFile(client2);
+  const saved = readPosition(file3);
+  if (saved !== void 0) client2.resumeFrom(saved);
+  console.error(`Listening for ${types.join(", ")} in space ${client2.space} as ${client2.agentId}`);
+  let failures = 0;
+  while (Date.now() < deadline) {
+    try {
+      const events = await client2.waitForEvents(deadline - Date.now(), types);
+      failures = 0;
+      savePosition(file3, client2.position);
+      const wake = wakeEvents(events, client2.agentId, Date.now(), maxAgeMs);
+      if (wake.length) {
+        for (const event of wake) process.stdout.write(`${JSON.stringify(event)}
+`);
+        return 0;
+      }
+    } catch (e) {
+      if (++failures >= 5) {
+        console.error(e instanceof Error ? e.message : String(e));
+        return 1;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 2e3 * failures));
+    }
+  }
+  console.error("Nothing arrived in time; start it again.");
+  return 3;
+}
+if (process.argv[1] && path4.basename(process.argv[1]).startsWith("wake.") && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().then(
+    (code) => process.exit(code),
+    (e) => {
+      console.error(e instanceof Error ? e.message : String(e));
+      process.exit(1);
+    }
+  );
 }
 
 // src/mcp.ts
@@ -36973,6 +37514,18 @@ away. Do not run it as a shell command, and do not change the MCP configuration:
 switches spaces and remembers the choice for later sessions by itself. Then tell them in a
 line that you are in, and stay engaged by calling wait_for_events in a loop.
 
+People in the space can only reach you while you are waiting on it: the room shows you as
+"not listening" otherwise, and what they ask goes unheard. join_space tells you two things
+about that; act on both. \`unansweredRequests\` are requests sent to you while nobody was
+waiting. \`listen.command\` is a shell command that waits for you in the background and
+exits when a request arrives: if you can run background commands, start it whenever you
+stop calling wait_for_events (before ending your turn, or before a long piece of other
+work), and start it again after handling what it printed.
+
+Everyone in the space sees you as a small figure that shows what you are doing. Keep it
+true: pass \`doing\` (and \`surfaceId\` once there is one) to update_request while you
+work on a request, and call working_on for anything else you do in the space.
+
 When the user pastes a connect code \u2014 a line like "Connect to my Symposium: symc_\u2026" \u2014
 call connect with what they pasted, straight away. It links you to their account for
 good (and joins the space it was made in, if any).
@@ -36995,7 +37548,7 @@ function start() {
 var client;
 function account() {
   begin();
-  const saved = savedAccount();
+  const saved = savedAccount(client?.api);
   return saved ? new AccountClient(saved.api, saved.token) : void 0;
 }
 var NOT_PAIRED = `You are not connected to the user's Symposium account. Ask them to press "Connect your agent" in Symposium (on the home page, or Stage \u2192 Agents in a space) and paste you the line it shows; then call connect with it. It is needed once.`;
@@ -37018,23 +37571,61 @@ var markSeen = (at) => {
   summonsSeen = Math.max(summonsSeen ?? 0, at);
 };
 var summonsFollowed = 0;
+var lastSummons;
+async function joinWhereCalled(paired, space2, called) {
+  const site = called?.space === space2 ? summonsApi(called, paired.api) : paired.api;
+  if (site === paired.api) return paired.join(space2);
+  return paired.at(site).join(space2).catch(() => paired.join(space2));
+}
+var quoteArg = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`;
+function wakeCommand(target) {
+  const script = process.argv[1];
+  if (!script) return void 0;
+  const where = savedAccount(target.api)?.token.startsWith(PAIRED_KEY_PREFIX) ? [`--space=${target.space}`, `--api=${target.api}`, `--agent=${whoAmI()}`] : [];
+  return [process.execPath, ...process.execArgv, script, "wake", ...where].map(quoteArg).join(" ");
+}
+var UNANSWERED_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var unfinishedWait;
 async function enter(next, invite) {
   begin();
-  const target = client?.space === next.space && client.agentId === next.agentId ? client : next;
+  const same = client?.space === next.space && client.agentId === next.agentId;
+  const target = same && client.api === next.api ? client : next;
+  if (same && target === next && client.position !== void 0) {
+    next.resumeFrom(client.position);
+  }
   const snap = await target.snapshot();
   client = target;
+  rememberPosition(target);
   const remembered = rememberInvite(invite);
+  const now = Date.now();
+  const unanswered = snap.timeline.filter(
+    (e) => e.kind === "request" && now - e.ts < UNANSWERED_MAX_AGE_MS && e.request?.to.some((t) => t.agentId === target.agentId && t.status === "sent")
+  ).map((e) => ({
+    id: e.seq,
+    from: e.name,
+    text: e.text,
+    asked: `${Math.max(0, Math.round((now - e.ts) / 6e4))} min ago`
+  }));
+  const command = wakeCommand(target);
   return {
     space: snap.id,
     ...snap.name ? { name: snap.name } : {},
     you: snap.agents.find((a) => a.id === target.agentId)?.name ?? target.agentId,
-    liveParticipants: snap.participants,
-    presence: snap.presence,
+    liveParticipants: withoutPhotos(snap.participants),
+    presence: withoutPhotos(snap.presence),
     surfaces: snap.surfaces.map((s) => ({ id: s.id, title: s.title })),
+    ...unanswered.length ? {
+      unansweredRequests: unanswered,
+      aboutUnanswered: 'Sent to you while you were not listening, and still showing as unanswered in the room. For a recent one, call update_request with "acknowledged" and do it. For one that is hours old or plainly overtaken, ask the user whether they still want it, and otherwise close it with update_request "failed" and a note saying it was not picked up in time.'
+    } : {},
+    listen: {
+      how: "People can reach you only while you are waiting: call wait_for_events in a loop. When you stop (before ending your turn, or before long work elsewhere) and you can run a shell command in the background, start `command` there: it exits as soon as a request for you arrives and prints it. Handle it, then start the command again.",
+      ...command ? { command } : {}
+    },
     remembered: remembered ? "Later sessions start in this space. No configuration change is needed." : "Could not save this space; later sessions will need to join again."
   };
 }
+var withoutPhotos = (people) => people.map((person) => ({ ...person, picture: void 0 }));
 var text = (value) => ({
   content: [
     {
@@ -37050,6 +37641,13 @@ var LINE_LABELS = {
   request: " (request to agents)",
   proposal: " (agent proposal)"
 };
+var DOING = 'The kind of work, which your figure in the room shows: "thinking" (working something out), "searching" (looking things up, reading), "writing" (text, the shared document), "drawing" (making an image or illustration), "charting" (charts, numbers, dashboards), "building" (putting a surface or other UI together).';
+var WORK_DOCUMENT = external_exports.string().optional().describe(
+  `The shared document this work is in, if any: its id from list_documents ("main" for the first). You are shown on that document's tab while you work.`
+);
+var WORK_SECTION = external_exports.string().max(200).optional().describe(
+  "With documentId: the text of the heading you are writing under. People see you beside that section in the document, which tells them not to type there while you work."
+);
 var fmtTime = (ts) => new Date(ts).toISOString().slice(0, 19).replace("T", " ");
 var server = new McpServer(
   { name: "symposium", version: "0.2.0" },
@@ -37064,9 +37662,35 @@ function begin() {
   client = start();
 }
 server.server.oninitialized = begin;
-async function connect(code) {
+async function connect2(code) {
   begin();
-  const connected = await redeemConnect(code, { name: whoAmI(), device: hostname3() });
+  const known = savedAccount(code.api);
+  if (known && known.api !== code.api) {
+    const there = new AccountClient(code.api, known.token);
+    const shared = await there.spaces().then(
+      () => true,
+      () => false
+    );
+    if (shared) {
+      const result2 = {
+        connected: true,
+        with: known.person,
+        note: `This site shares its accounts with ${new URL(known.api).origin}, where you were already connected. That connection is used here too; the code was not needed.`
+      };
+      if (!code.space) {
+        return text({
+          ...result2,
+          next: "Call join_space to join the meeting the user is in, or list_spaces to see their spaces."
+        });
+      }
+      const joined2 = await there.join(code.space);
+      return text({
+        ...result2,
+        joined: await enter(new SpaceClient(joined2), encodeInvite(joined2))
+      });
+    }
+  }
+  const connected = await redeemConnect(code, { name: whoAmI(), device: hostname4() });
   const saved = rememberAccount({
     api: code.api,
     token: connected.token,
@@ -37105,7 +37729,7 @@ server.registerTool(
         'There is no Symposium connect code in that text. Ask the user to press "Connect your agent" in Symposium and copy the line again.'
       );
     }
-    return connect(code);
+    return connect2(code);
   }
 );
 server.registerTool(
@@ -37142,7 +37766,7 @@ server.registerTool(
     const invite = pasted ? findInvite(pasted) : void 0;
     if (invite) return text(await enter(new SpaceClient(invite), invite));
     const code = pasted ? findConnect(pasted) : void 0;
-    if (code) return connect(code);
+    if (code) return connect2(code);
     const paired = account();
     if (!paired) {
       throw new Error(
@@ -37151,11 +37775,14 @@ server.registerTool(
     }
     const named = wanted ?? pasted;
     const recentSummons = async () => {
-      const fresh = await paired.serverNow() - SUMMONS_FRESH_MS;
-      return paired.summons(Math.max(fresh, summonsFollowed));
+      const fresh2 = await paired.serverNow() - SUMMONS_FRESH_MS;
+      return paired.summons(Math.max(fresh2, summonsFollowed));
     };
     const [spaces, called] = await Promise.all([paired.spaces(), named ? null : recentSummons()]);
-    if (called) markSeen(called.at);
+    if (called) {
+      markSeen(called.at);
+      lastSummons = called;
+    }
     const choice = chooseSpace(spaces, named, called?.space);
     if ("candidates" in choice) {
       return text({
@@ -37171,7 +37798,8 @@ server.registerTool(
     }
     const target = choice.space.id;
     if (called?.space === target) summonsFollowed = called.at;
-    const joined = await paired.join(target);
+    const fresh = !choice.space.here && lastSummons?.space === target && await paired.serverNow() - lastSummons.at < SUMMONS_FRESH_MS;
+    const joined = await joinWhereCalled(paired, target, fresh ? lastSummons : null);
     return text(await enter(new SpaceClient(joined), encodeInvite(joined)));
   }
 );
@@ -37184,14 +37812,15 @@ server.registerTool(
     const snap = await space().snapshot();
     return text({
       space: snap.id,
-      liveParticipants: snap.participants,
-      presence: snap.presence,
+      liveParticipants: withoutPhotos(snap.participants),
+      presence: withoutPhotos(snap.presence),
       surfaces: snap.surfaces.map((s) => ({
         id: s.id,
         title: s.title,
         by: s.agentName,
         state: s.state
       })),
+      documents: (snap.docs ?? []).map((d) => ({ id: d.id, title: d.title })),
       you: space().agentId,
       agents: snap.agents.map((a) => ({ id: a.id, name: a.name, owner: a.owner })),
       latestSeq: snap.seq
@@ -37353,7 +37982,7 @@ server.registerTool(
       "- request: someone asked agents to do something. `to` lists the agent ids it is for and `seq` is its id; if yours is in `to`, call update_request right away.",
       '- proposal_decided: a person approved or dismissed a proposal. If `agentId` is yours and `decision` is "approved", go ahead and report with update_proposal.',
       "- proposal: another agent offered to do something.",
-      "- doc_changed: the shared document changed (at most every 30 seconds); call read_document to see it.",
+      "- doc_changed: a shared document (`docId`, `title`) was edited (at most every 30 seconds per document), renamed or, with `created`, made; call read_document with that id to see it. doc_removed: one was removed.",
       "- speech, chat, message: what people said, what they typed, what other agents posted.",
       "- ui_event (meeting.emit from a surface), state_changed (surface state), surface_changed / surface_removed (another agent edited the stage).",
       'When you are connected to their account, it can instead return a `summons`: the user pressed "Bring my agent" in a space; join_space there.'
@@ -37368,9 +37997,11 @@ server.registerTool(
     const paired = account();
     const summoned = (called2) => {
       markSeen(called2.at);
+      lastSummons = called2;
+      const here = called2.space === client?.space && summonsApi(called2, client.api) === client.api;
       return text({
         summons: { space: called2.space, ...called2.name ? { name: called2.name } : {} },
-        do: called2.space === client?.space ? 'The user pressed "Bring my agent" in the space you are already in. Tell them you are here.' : `The user pressed "Bring my agent" in another space. Call join_space with space "${called2.space}" now.`
+        do: here ? 'The user pressed "Bring my agent" in the space you are already in. Tell them you are here.' : `The user pressed "Bring my agent" in ${called2.space === client?.space ? "this space on another site" : "another space"}. Call join_space with space "${called2.space}" now.`
       });
     };
     if (!client && paired) {
@@ -37378,7 +38009,11 @@ server.registerTool(
       return called2 ? summoned(called2) : text("(no events)");
     }
     const current = space();
-    const events = unfinishedWait?.client === current ? unfinishedWait.events : current.waitForEvents(timeoutMs, types);
+    const events = unfinishedWait?.client === current ? unfinishedWait.events : current.waitForEvents(timeoutMs, types).then((list) => {
+      const unheard = withoutHeard(current, list);
+      rememberPosition(current);
+      return unheard;
+    });
     unfinishedWait = void 0;
     if (!paired) {
       const list = await events;
@@ -37412,38 +38047,73 @@ server.registerTool(
 server.registerTool(
   "bring_everyone_to",
   {
-    description: "Switch everyone's stage to one tab so they are all looking at the same thing: one surface (pass its id; it can be yours or another agent's), or the Conversation tab (omit `surfaceId`). Each person sees a note saying you brought them there and can go back. Use it sparingly: when you have just put up or updated something the whole room should look at now, or someone asked you to show something. Do not use it for every small update.",
+    description: "Switch everyone's stage to one tab so they are all looking at the same thing: one surface (pass its id; it can be yours or another agent's) or one shared document. Each person sees a note saying you brought them there and can go back. With neither, it opens the conversation column for anyone who has closed it; the conversation is beside the stage, not a tab on it, so this is rarely needed. Use it sparingly: when you have just put up or updated something the whole room should look at now, or someone asked you to show something. Do not use it for every small update.",
     inputSchema: {
-      surfaceId: external_exports.string().optional().describe("Surface to show; omit for the Conversation tab"),
-      document: external_exports.boolean().optional().describe("Set true to show the shared document instead")
+      surfaceId: external_exports.string().optional().describe("Surface to show; omit to open the conversation"),
+      documentId: external_exports.string().optional().describe("A shared document to show instead: its id from list_documents"),
+      document: external_exports.boolean().optional().describe('Set true to show the first shared document ("main") instead')
     }
   },
-  async ({ surfaceId, document }) => {
+  async ({ surfaceId, documentId, document }) => {
     const result = await space().bringEveryoneTo(
-      document ? { kind: "document" } : surfaceId ? { kind: "surface", id: surfaceId } : { kind: "conversation" }
+      documentId || document ? { kind: "document", id: documentId || MAIN_DOC_ID } : surfaceId ? { kind: "surface", id: surfaceId } : { kind: "conversation" }
     );
     return text({ showing: result.target });
   }
 );
+var DOCUMENT = external_exports.string().optional().describe(
+  `Which document: its id from list_documents. Omit for the first one ("main"), the space's notes.`
+);
 server.registerTool(
-  "read_document",
+  "list_documents",
   {
-    description: "Read the space's shared document as Markdown. Everyone in the space can edit it together, in a meeting or between meetings; it is where notes, agendas, decisions and drafts live. Read it before editing so you know its headings.",
+    description: `List the shared documents in the space: each one's id and title, who made it, when it last changed, and which agent last wrote in it. Every space has the document "main" (its notes); people and agents add others beside it, each on its own tab of the stage.`,
     inputSchema: {}
   },
-  async () => text(await space().readDocument() || "(the document is empty)")
+  async () => text(
+    (await space().listDocuments()).map((d) => ({
+      id: d.id,
+      title: d.title,
+      ...d.createdBy ? { madeBy: d.createdBy.name } : {},
+      ...d.updatedAt ? { changed: fmtTime(d.updatedAt) } : {},
+      ...d.agentEdit ? { lastAgentEdit: d.agentEdit.name } : {}
+    }))
+  )
+);
+server.registerTool(
+  "create_document",
+  {
+    description: 'Add a shared document to the space, on a tab of its own, optionally with its first text in Markdown. Use it for a piece of writing that stands by itself (a draft, a brief, a write-up, minutes of one meeting) instead of putting it into the notes people are keeping in "main". Returns its id, which read_document, edit_document and bring_everyone_to take.',
+    inputSchema: {
+      title: external_exports.string().max(80).describe('Short tab title, e.g. "Launch brief"'),
+      markdown: external_exports.string().optional().describe("Its first text")
+    }
+  },
+  async ({ title, markdown }) => {
+    const doc = await space().createDocument({ title, markdown });
+    return text({ id: doc.id, title: doc.title });
+  }
+);
+server.registerTool(
+  "read_document",
+  {
+    description: "Read one of the space's shared documents as Markdown. Everyone in the space can edit them together, in a meeting or between meetings; they are where notes, agendas, decisions and drafts live. Read a document before editing it so you know its headings. People see you on the document's tab for a little while after you read it.",
+    inputSchema: { document: DOCUMENT }
+  },
+  async ({ document }) => text(await space().readDocument(document) || "(the document is empty)")
 );
 server.registerTool(
   "edit_document",
   {
-    description: 'Edit the shared document, in Markdown (headings, lists, bold, italic, links, quotes, code blocks). People may be typing in it at the same moment, so make the narrowest edit that does the job: "append" adds to the end; "replace_section" replaces everything under one heading, keeping the heading, and creates the section at the end if the heading does not exist yet; "replace_all" rewrites the whole document and should be used only when asked to. Returns the document after your edit.',
+    description: 'Edit a shared document, in Markdown (headings, lists, bold, italic, links, quotes, code blocks). People may be typing in it at the same moment, so make the narrowest edit that does the job: "append" adds to the end; "replace_section" replaces everything under one heading, keeping the heading, and creates the section at the end if the heading does not exist yet; "replace_all" rewrites the whole document and should be used only when asked to. Everyone sees what you added or changed marked as written by you until a person edits it; text you send back unchanged is not marked, so send the rest of a section back exactly as it was. Before you start composing anything that takes more than a moment, say where you are about to write with update_request (or working_on): doing "writing", `documentId` and, for replace_section, `section`. People then see you beside that section and know not to type in it. Returns the document after your edit.',
     inputSchema: {
+      document: DOCUMENT,
       op: external_exports.enum(DOC_EDIT_OPS),
       heading: external_exports.string().optional().describe("For replace_section: the text of the heading whose section to replace"),
       markdown: external_exports.string().describe("The new content")
     }
   },
-  async ({ op, heading, markdown }) => {
+  async ({ document, op, heading, markdown }) => {
     if (op === "replace_section" && !heading) {
       throw new Error(
         "replace_section needs `heading`: the text of the heading whose section to replace."
@@ -37451,15 +38121,27 @@ server.registerTool(
     }
     return text(
       await space().editDocument(
-        op === "replace_section" ? { op, heading, markdown } : { op, markdown }
+        op === "replace_section" ? { op, heading, markdown } : { op, markdown },
+        document
       )
     );
   }
 );
+server.registerTool(
+  "remove_document",
+  {
+    description: 'Remove a shared document you made, for good. You cannot remove documents other people or agents made, nor the first one ("main").',
+    inputSchema: { document: external_exports.string().describe("Its id from list_documents") }
+  },
+  async ({ document }) => {
+    await space().removeDocument(document);
+    return text({ removed: document });
+  }
+);
 server.registerTool(
   "propose",
   {
-    description: 'Offer to do something and wait for a person to approve it. Everyone sees it as a card in the Conversation tab with an approve button and Dismiss. Use it before anything that reaches outside the meeting or is hard to undo (sending a message, filing a ticket, changing files, spending money), and when you have a suggestion the room may not want ("Add this to the decisions list?"). Do NOT act until you receive a `proposal_decided` event from wait_for_events with this proposal\'s id and decision "approved"; if it is "dismissed", drop it. After approval, report progress with update_proposal.',
+    description: 'Offer to do something and wait for a person to approve it. Everyone sees it as a card in the conversation with an approve button and Dismiss. Use it before anything that reaches outside the meeting or is hard to undo (sending a message, filing a ticket, changing files, spending money), and when you have a suggestion the room may not want ("Add this to the decisions list?"). Do NOT act until you receive a `proposal_decided` event from wait_for_events with this proposal\'s id and decision "approved"; if it is "dismissed", drop it. After approval, report progress with update_proposal.',
     inputSchema: {
       text: external_exports.string().describe("What you are offering to do, as a question or a plain statement"),
       action: external_exports.string().max(40).optional().describe('Label for the approve button (default "Do it")'),
@@ -37491,16 +38173,73 @@ server.registerTool(
 server.registerTool(
   "update_request",
   {
-    description: 'Report progress on a request that was addressed to you (a `request` event from wait_for_events whose `to` includes your agent id; its `seq` is the id). Everyone in the meeting sees the status next to the request, so keep it current: call with "acknowledged" the moment you receive the request, "working" with a short note on what you are doing before each slow step, and finish with "done" (note: what you did or where to look) or "failed" (note: why). A request left without a final status keeps showing as in progress.',
+    description: 'Report progress on a request that was addressed to you (a `request` event from wait_for_events whose `to` includes your agent id; its `seq` is the id). Everyone in the meeting sees the status next to the request, and sees your figure in the room busy with it (several at once, if you are working on several), so keep it current: call with "acknowledged" the moment you receive the request, "working" with a short note on what you are doing before each slow step, and finish with "done" (note: what you did or where to look) or "failed" (note: why). A request left without a final status keeps showing as in progress.',
     inputSchema: {
       id: external_exports.number().int().describe("The request id: `seq` of the request event"),
       status: external_exports.enum(REQUEST_STATUSES),
-      note: external_exports.string().max(200).optional().describe("One short line shown next to the status")
+      note: external_exports.string().max(200).optional().describe("One short line shown next to the status"),
+      surfaceId: external_exports.string().optional().describe(
+        "The surface this work is on, if any. You are shown on that tab while you work, so people see where to look. Pass it once you have created or picked the surface."
+      ),
+      doing: external_exports.enum(WORK_KINDS).optional().describe(DOING),
+      documentId: WORK_DOCUMENT,
+      section: WORK_SECTION
     }
   },
-  async ({ id, status, note }) => {
-    const entry = await space().updateRequest(id, status, note);
+  async ({ id, status, note, surfaceId, doing, documentId, section }) => {
+    const entry = await space().updateRequest(
+      id,
+      status,
+      note,
+      surfaceId,
+      doing,
+      documentId ? { docId: documentId, section } : void 0
+    );
     return text({ request: entry.seq, status, to: entry.request?.to });
   }
 );
-await server.connect(new StdioServerTransport());
+server.registerTool(
+  "working_on",
+  {
+    description: "Show everyone in the space what you are doing right now, when it is not an answer to a request (for a request, update_request takes the same `doing`). Your figure in the room plays the matching animation, on the surface's tab if you name one. Call it before any piece of work that takes more than a few seconds (your person asked you for something in your own conversation, say), again when what you are doing changes, and with `done: true` when you finish; it lapses by itself after three minutes. To show several things at once, give each its own `key`.",
+    inputSchema: {
+      doing: external_exports.enum(WORK_KINDS).optional().describe(DOING),
+      note: external_exports.string().max(200).optional().describe("A few words on what it is"),
+      surfaceId: external_exports.string().optional().describe("The surface it is happening on, if any"),
+      documentId: WORK_DOCUMENT,
+      section: WORK_SECTION,
+      key: external_exports.string().max(40).optional().describe('Names this piece of work, when you have several at once (default "main")'),
+      done: external_exports.boolean().optional().describe("Set true when this piece of work is finished")
+    }
+  },
+  async ({ doing, note, surfaceId, documentId, section, key, done }) => {
+    if (done) return text(await space().setWork({ key, done: true }));
+    if (!doing) throw new Error(`working_on needs \`doing\`: one of ${WORK_KINDS.join(", ")}.`);
+    return text(
+      await space().setWork({
+        key,
+        doing,
+        note,
+        surfaceId,
+        ...documentId ? { docId: documentId, section } : {}
+      })
+    );
+  }
+);
+if (process.argv[2] === "setup") {
+  process.exit(
+    await setup(process.argv.slice(3)).catch((e) => {
+      console.error(e instanceof Error ? e.message : String(e));
+      return 1;
+    })
+  );
+} else if (process.argv[2] === "wake") {
+  process.exit(
+    await main().catch((e) => {
+      console.error(e instanceof Error ? e.message : String(e));
+      return 1;
+    })
+  );
+} else {
+  await server.connect(new StdioServerTransport());
+}