symposium-mcp 0.2.0 → 0.3.0

package/README.md

@@ -5,7 +5,21 @@ UI on a shared stage. It lets an agent join a space, read the transcript, post m
 and put surfaces on the stage. It runs on your machine and talks to the Symposium site
 you connect it to.
 
-## Install
+## Set up
+
+In Symposium, press **Connect your agent** and run the line it shows in a terminal:
+
+```bash
+npx -y symposium-mcp setup symc_…
+```
+
+It finds the agents on the computer (Claude Code, Codex, Cursor, Gemini CLI, Windsurf),
+gives each this server, and connects each to your account with the one code. It then
+offers to open Claude Code or Codex already in the meeting. Later, start a session in any
+of them and say "join my meeting". Running it again is safe, and without a code it only
+adds the server.
+
+## By hand
 
 Give it to each agent once.
 
@@ -22,15 +36,20 @@ Any other MCP client: add it to the client's MCP configuration.
 { "mcpServers": { "symposium": { "command": "npx", "args": ["-y", "symposium-mcp"] } } }
 ```
 
-## Connect
-
-In Symposium, press **Connect your agent** and paste the line it shows to the agent
-(`Connect to my Symposium: symc_…`). After that, "join my meeting" is enough.
+Then, in Symposium, press **Connect your agent** and paste the line under **Or connect
+one agent by hand** to the agent (`Connect to my Symposium: symc_…`). After that, "join
+my meeting" is enough.
 
 Each MCP client is its own agent: the server names itself after the client that runs it
 ("Ada's Claude", "Ada's Codex") and keeps each one's connection in a file of its own
-under `~/.symposium/`, readable only by you. To have several agents in a space, make a
-connect code for each.
+under `~/.symposium/`, readable only by you. Connecting by hand, each agent needs a
+connect code of its own.
+
+People in a space can reach the agent only while it is waiting on the space
+(`wait_for_events`); the room shows it as listening or not. For the time in between,
+`symposium-mcp wake --space=<name or id>` waits in the background, prints the first
+request addressed to the agent as a line of JSON and exits, which wakes an agent whose
+client reports finished background commands. `join_space` returns the exact command.
 
 | Variable               | What it does                                                         |
 | ---------------------- | -------------------------------------------------------------------- |

package/dist/mcp.js

@@ -3231,8 +3231,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path2) {
-      let input2 = path2;
+    function removeDotSegments(path4) {
+      let input2 = path4;
       const output2 = [];
       let nextSlash = -1;
       let len = 0;
@@ -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 [path4, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path4 && path4 !== "/" ? path4 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -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: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...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, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path2;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -11349,10 +11349,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path4.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(path4, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path4);
     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, path4 = []) => {
     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 }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path4, ...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, path4 = []) => {
     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 }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path4, ...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 path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     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(path4) {
+  if (path4.length === 0) {
     return "object root";
   }
-  return path2.reduce((acc, seg, index) => {
+  return path4.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 path4 = ref.slice(1).split("/").filter(Boolean);
+  if (path4.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 (path4[0] === defsKey) {
+    const key = path4[1] === void 0 ? void 0 : decodeJSONPointerSegment(path4[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) => {
@@ -36349,13 +36349,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 +36545,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: connect2.id, secret: connect2.secret, ...about }
+    body: { id: connect3.id, secret: connect3.secret, ...about }
   });
 }
-var AccountClient = class {
+async function redeemConnectFor(connect3, agents) {
+  const connected = await call(`${connect3.api}/agents/claim`, {
+    method: "POST",
+    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 _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 +36623,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 +36662,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 +36672,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, path4, body, timeoutMs = 3e4) {
+    const resp = await fetch(this.base + path4, {
       method,
       headers: {
         Authorization: `Bearer ${this.key}`,
@@ -36652,11 +36684,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} ${path4} failed (${resp.status}): ${detail?.error ?? resp.statusText}`
       );
     }
     return resp.status === 204 ? void 0 : await resp.json();
@@ -36721,7 +36758,7 @@ var SpaceClient = class {
   // --- 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,9 +36770,11 @@ 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), the 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.
    */
   bringEveryoneTo(target) {
     return this.request("POST", "/focus", { target });
@@ -36852,6 +36891,14 @@ 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 { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2, hostname as hostname3 } from "node:os";
+import path2 from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+
 // src/remembered.ts
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -36897,12 +36944,360 @@ 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 done = spawnSync(command, args, {
+      stdio: "ignore",
+      shell: process.platform === "win32",
+      timeout: 6e4
+    });
+    return done.error ? void 0 : done.status ?? 1;
+  },
+  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 ignore = () => {
+      };
+      process.on("SIGINT", ignore);
+      const child = spawn(command, args, {
+        stdio: "inherit",
+        shell: process.platform === "win32"
+      });
+      const done = () => {
+        process.off("SIGINT", ignore);
+        resolve();
+      };
+      child.on("error", done);
+      child.on("exit", done);
+    });
+  }
+};
+function serverCommand(self = fileURLToPath(import.meta.url)) {
+  return self.endsWith(".ts") ? ["npx", "-y", "tsx", path2.join(path2.dirname(self), "mcp.ts")] : ["npx", "-y", "symposium-mcp"];
+}
+var withCommand = (label, agent2, bin, add) => ({
+  label,
+  agent: agent2,
+  found: (host) => host.run(bin, ["--version"]) !== void 0,
+  register(host, command) {
+    if (host.run(bin, ["mcp", "get", SERVER]) === 0) return "present";
+    if (host.run(bin, add(command)) !== 0) throw new Error(`\`${bin} mcp add\` failed`);
+    return "added";
+  },
+  start: (prompt) => [bin, prompt]
+});
+var withConfigFile = (label, agent2, dir, file3) => ({
+  label,
+  agent: agent2,
+  found: () => existsSync(path2.join(homedir2(), ...dir)),
+  register(_host, command) {
+    const target = path2.join(homedir2(), ...dir, file3);
+    let settings = {};
+    if (existsSync(target)) {
+      let parsed;
+      try {
+        parsed = JSON.parse(readFileSync2(target, "utf8"));
+      } catch {
+        parsed = null;
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`${target} is not plain JSON; add the server to it by hand`);
+      }
+      settings = parsed;
+    }
+    const servers = settings.mcpServers;
+    const existing = typeof servers === "object" && servers !== null && !Array.isArray(servers) ? servers : {};
+    if (SERVER in existing) return "present";
+    settings.mcpServers = {
+      ...existing,
+      [SERVER]: {
+        command: command[0],
+        args: command.slice(1),
+        env: { SYMPOSIUM_AGENT_NAME: agent2 }
+      }
+    };
+    writeFileSync2(target, `${JSON.stringify(settings, null, 2)}
+`);
+    return "added";
+  }
+});
+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, tools: target.register(host, command), note: "" };
+    } 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);
+    host.say(`  ${row.target.label.padEnd(width)}  ${[tools, link].filter(Boolean).join(", ")}`);
+  }
+  host.say("");
+  if (!code) {
+    host.say('To connect them: press "Connect your agent" in Symposium and run the line it shows.');
+    return failed ? 1 : 0;
+  }
+  const ready = rows.filter(
+    (row) => row.tools !== "failed" && row.target.start && paired(row.target.agent)
+  );
+  const chosen = ready.length ? await choose(
+    host,
+    ready.map((row) => row.target)
+  ) : void 0;
+  if (!chosen) {
+    host.say('Start a new session in any of them and say "join my meeting".');
+    return failed ? 1 : 0;
+  }
+  const [bin, ...args] = chosen.start(
+    code.space ? `Join my Symposium meeting in the space ${code.space}.` : "Join my Symposium meeting."
+  );
+  await host.open(bin, args);
+  return failed ? 1 : 0;
+}
+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 path3 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 path3.join(
+    path3.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(path3.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] && path3.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 +37368,14 @@ 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.
+
 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 +37398,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,13 +37421,42 @@ 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 } : {},
@@ -37032,6 +37464,14 @@ async function enter(next, invite) {
     liveParticipants: snap.participants,
     presence: 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."
   };
 }
@@ -37064,9 +37504,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 +37571,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 +37608,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 +37617,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 +37640,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)));
   }
 );
@@ -37368,9 +37838,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 +37850,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,9 +37888,9 @@ 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 the 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"),
+      surfaceId: external_exports.string().optional().describe("Surface to show; omit to open the conversation"),
       document: external_exports.boolean().optional().describe("Set true to show the shared document instead")
     }
   },
@@ -37459,7 +37935,7 @@ server.registerTool(
 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")'),
@@ -37503,4 +37979,20 @@ server.registerTool(
     return text({ request: entry.seq, status, to: entry.request?.to });
   }
 );
-await server.connect(new StdioServerTransport());
+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());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symposium-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "MCP server for Symposium: lets an agent join a meeting space and put interactive UI on its shared stage.",
   "license": "Apache-2.0",
   "type": "module",