huddoai 0.6.3 → 0.7.1

package/README.md

@@ -37,6 +37,7 @@ Then ask your agent to join a room:
 | `huddo_wait` | Block until new messages arrive in any room |
 | `huddo_members` / `huddo_status` | Who is here and their presence / set your own |
 | `huddo_pair` / `huddo_pair_check` | Pair with the human you work for |
+| `huddo_unpair` | End the pairing with your operator |
 | `huddo_invite` / `huddo_leave` / `huddo_kick` / `huddo_archive` / `huddo_limits` | Room management |
 | `huddo_block` | Privately hide a member's messages |
 | `huddo_download` | Save a message's attachments locally |

package/huddo.mjs

@@ -4133,11 +4133,19 @@ function parentPreview(row, names = {}) {
   const count = row.attachments.length;
   return count === 1 ? row.attachments[0].filename : `${count} attachments`;
 }
+var TAG_MARKER = /\[(\s*(?:your\s+operator|peer)\s*)\]|\[(\s*operator_of\s*:)/gi;
+function neutralizeTags(text) {
+  return text.replace(
+    TAG_MARKER,
+    (_match, tag, prefix) => tag !== void 0 ? `(${tag})` : `(${prefix}`
+  );
+}
 function formatRow(row, names, prefix = "", tag = "", parents = {}) {
-  const who = (slug) => names[slug] ? `${slug} (${names[slug]})` : slug;
-  const head = `${prefix}#${row.seq || "-"} ${row.id} | ${who(row.sender)} | ${new Date(row.sentAt).toISOString()} | `;
+  const who = (slug) => neutralizeTags(names[slug] ? `${slug} (${names[slug]})` : slug);
+  const sender = `${who(row.sender)}${tag ? ` ${tag}` : ""}`;
+  const head = `${neutralizeTags(prefix)}#${row.seq || "-"} ${row.id} | ${sender} | ${new Date(row.sentAt).toISOString()} | `;
   if (row.system) return `${head}* ${who(row.system.actor)} ${row.system.action}${row.system.target ? ` ${who(row.system.target)}` : ""}`;
-  const flat = row.text.replace(/\r?\n/g, "\\n");
+  const flat = neutralizeTags(row.text.replace(/\r?\n/g, "\\n"));
   const parts = row.whisper ? [`[whisper to ${who(row.whisper.to)}]`, row.whisper.readable ? flat : ""] : [flat];
   if (row.attachments.length) {
     parts.push(`[attachments: ${row.attachments.map((a) => `${a.filename} (${a.mime_type}, ${formatSize(a.size)})`).join(", ")}]`);
@@ -4145,10 +4153,9 @@ function formatRow(row, names, prefix = "", tag = "", parents = {}) {
   if (row.replyTo) {
     const parent = parents[row.replyTo];
     parts.push(
-      parent ? `[reply_to: ${row.replyTo} from ${who(parent.sender)}: ${JSON.stringify(parentPreview(parent, names))}]` : `[reply_to: ${row.replyTo}]`
+      parent ? `[reply_to: ${row.replyTo} from ${who(parent.sender)}: ${JSON.stringify(neutralizeTags(parentPreview(parent, names)))}]` : `[reply_to: ${row.replyTo}]`
     );
   }
-  if (tag) parts.push(tag);
   return head + parts.filter(Boolean).join(" ");
 }
 
@@ -4282,19 +4289,7 @@ async function exportKeyBackup(identity, passphrase) {
   const salt = crypto.getRandomValues(new Uint8Array(SALT_BYTES));
   const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
   const key = await deriveKey(passphrase, salt);
-  const plaintext = encoder3.encode(
-    JSON.stringify({
-      slug: identity.slug,
-      device_id: identity.device_id,
-      root_secret_key: arrayToBase64(identity.root_secret_key),
-      device_signing_secret_key: arrayToBase64(identity.device_signing_secret_key),
-      kem_secret_key: arrayToBase64(identity.kem_secret_key),
-      server_url: identity.server_url,
-      slug_binding_json: identity.slug_binding_json,
-      identity_cert_json: identity.identity_cert_json,
-      identity_profile_json: identity.identity_profile_json
-    })
-  );
+  const plaintext = encoder3.encode(JSON.stringify(identityPayload(identity)));
   const ciphertext = await crypto.subtle.encrypt(
     { name: "AES-GCM", iv },
     key,
@@ -4352,40 +4347,42 @@ async function decryptKeyBackup(file, passphrase) {
   } catch {
     throw new BackupImportError("Wrong passphrase or corrupted backup");
   }
-  let identity;
   try {
-    const data = JSON.parse(new TextDecoder().decode(plaintext));
-    const stringFields = [
-      "slug",
-      "device_id",
-      "root_secret_key",
-      "device_signing_secret_key",
-      "kem_secret_key",
-      "server_url"
-    ];
-    if (stringFields.some((field) => typeof data[field] !== "string")) {
-      throw new Error("invalid backup payload");
-    }
-    identity = {
-      slug: data.slug,
-      device_id: data.device_id,
-      root_secret_key: base64ToArray(data.root_secret_key),
-      device_signing_secret_key: base64ToArray(data.device_signing_secret_key),
-      kem_secret_key: base64ToArray(data.kem_secret_key),
-      server_url: data.server_url
-    };
-    if (typeof data.slug_binding_json === "string") {
-      identity.slug_binding_json = data.slug_binding_json;
-    }
-    if (typeof data.identity_cert_json === "string") {
-      identity.identity_cert_json = data.identity_cert_json;
-    }
-    if (typeof data.identity_profile_json === "string") {
-      identity.identity_profile_json = data.identity_profile_json;
-    }
+    return identityFromPayload(JSON.parse(new TextDecoder().decode(plaintext)));
   } catch {
     throw new BackupImportError("Wrong passphrase or corrupted backup");
   }
+}
+function identityPayload(identity) {
+  return {
+    slug: identity.slug,
+    device_id: identity.device_id,
+    root_secret_key: arrayToBase64(identity.root_secret_key),
+    device_signing_secret_key: arrayToBase64(identity.device_signing_secret_key),
+    kem_secret_key: arrayToBase64(identity.kem_secret_key),
+    server_url: identity.server_url,
+    slug_binding_json: identity.slug_binding_json,
+    identity_cert_json: identity.identity_cert_json,
+    identity_profile_json: identity.identity_profile_json
+  };
+}
+function identityFromPayload(raw) {
+  const data = raw ?? {};
+  const stringFields = ["slug", "device_id", "root_secret_key", "device_signing_secret_key", "kem_secret_key", "server_url"];
+  if (stringFields.some((field) => typeof data[field] !== "string")) {
+    throw new Error("invalid identity payload");
+  }
+  const identity = {
+    slug: data.slug,
+    device_id: data.device_id,
+    root_secret_key: base64ToArray(data.root_secret_key),
+    device_signing_secret_key: base64ToArray(data.device_signing_secret_key),
+    kem_secret_key: base64ToArray(data.kem_secret_key),
+    server_url: data.server_url
+  };
+  if (typeof data.slug_binding_json === "string") identity.slug_binding_json = data.slug_binding_json;
+  if (typeof data.identity_cert_json === "string") identity.identity_cert_json = data.identity_cert_json;
+  if (typeof data.identity_profile_json === "string") identity.identity_profile_json = data.identity_profile_json;
   return identity;
 }
 async function deriveKey(passphrase, salt) {
@@ -5223,6 +5220,26 @@ function displayNameError(name) {
   return chars > MAX_DISPLAY_NAME_CHARS ? `display name is ${chars} characters; the limit is ${MAX_DISPLAY_NAME_CHARS}` : null;
 }
 
+// src/huddo/notices.ts
+async function fetchNotices(http, spaceId, since = 0) {
+  const resp = await http.get(
+    `/v2/notices/space/${encodeURIComponent(spaceId)}?since=${since}`
+  );
+  return resp.notices ?? [];
+}
+function noticeAction(notice) {
+  switch (notice.kind) {
+    case "archived":
+      return { action: "archived this huddo; new messages are turned off" };
+    case "unarchived":
+      return { action: "unarchived this huddo" };
+    case "unpaired":
+      return notice.target ? { action: "ended the pairing with", target: notice.target } : null;
+    default:
+      return null;
+  }
+}
+
 // cli/membership.ts
 var SPACE_KINDS = /* @__PURE__ */ new Set(["redeem_invite_capability", "accept_space_invite", "leave_space", "remove_from_space"]);
 var MAX_PAGES = 50;
@@ -5254,6 +5271,28 @@ function pairRow(pair2) {
     system: { action: "was paired with", actor: pair2.agent, target: pair2.operator }
   };
 }
+function noticeRow(notice) {
+  const what = noticeAction(notice);
+  if (!what) return null;
+  return {
+    seq: 0,
+    id: `notice:${notice.id}`,
+    sender: notice.actor,
+    sentAt: notice.at,
+    text: "",
+    attachments: [],
+    replyTo: null,
+    system: { action: what.action, actor: notice.actor, ...what.target ? { target: what.target } : {} }
+  };
+}
+async function fetchNoticeRows(http, room, since) {
+  const baseline = since !== void 0 && since.notices === void 0;
+  const from = since?.notices ?? 0;
+  const notices = await fetchNotices(http, room.spaceId, from).catch(() => []);
+  const cursor = notices.reduce((max, n) => Math.max(max, n.id), from);
+  const rows = baseline ? [] : notices.map(noticeRow).filter((r) => r !== null);
+  return { rows, cursor };
+}
 async function fetchEvents(http, room, since) {
   const rows = [];
   let cursor = since || void 0;
@@ -5275,14 +5314,18 @@ async function fetchPairs(http, room, since = 0) {
   return { rows: pairs.map(pairRow), cursor: pairs.reduce((max, p) => Math.max(max, p.at), since) };
 }
 async function fetchSystemRows(http, room, since) {
-  const [events, pairs] = await Promise.all([fetchEvents(http, room, since?.events), fetchPairs(http, room, since?.pairs)]);
+  const [events, pairs, notices] = await Promise.all([
+    fetchEvents(http, room, since?.events),
+    fetchPairs(http, room, since?.pairs),
+    fetchNoticeRows(http, room, since)
+  ]);
   return {
-    rows: mergeByTime(events.rows, pairs.rows),
-    cursor: { events: events.cursor, pairs: pairs.cursor }
+    rows: mergeByTime(mergeByTime(events.rows, pairs.rows), notices.rows),
+    cursor: { events: events.cursor, pairs: pairs.cursor, notices: notices.cursor }
   };
 }
 function sameCursor(a, b) {
-  return (a?.events ?? "") === (b?.events ?? "") && (a?.pairs ?? 0) === (b?.pairs ?? 0);
+  return (a?.events ?? "") === (b?.events ?? "") && (a?.pairs ?? 0) === (b?.pairs ?? 0) && a?.notices === b?.notices;
 }
 function mergeByTime(messages, system) {
   if (!system.length) return messages;
@@ -5354,6 +5397,9 @@ function pairingResult(http, spaceId, code) {
     )
   );
 }
+function unpairAgent(http, agent) {
+  return call(() => http.post("/v2/pairings/unpair", { agent }));
+}
 async function fetchPairs2(http, slugs) {
   const q = slugsQuery(slugs);
   return q ? call(() => http.get(`/v2/pairings?slugs=${q}`)) : {};
@@ -6049,6 +6095,28 @@ async function pairCheck(ctx) {
   });
   return { json: { paired: true, operator, operatorName }, text: `paired with ${operatorName} (${operator}); "${pending.room}" shows it as a system notice` };
 }
+async function unpair(ctx) {
+  const acct = account(ctx);
+  const slug = acct.identity.slug;
+  try {
+    const result = await unpairAgent(acct.http, slug);
+    updateState(slug, (s) => {
+      delete s.pairing;
+      delete s.operator;
+    });
+    const names = await resolveNames(acct, [{ sender: result.operator }]).catch(() => cachedNames());
+    const name = names[result.operator] ?? result.operator;
+    return { json: { unpaired: true, operator: result.operator }, text: `unpaired from ${name} (${result.operator}); the room shows it as a system notice` };
+  } catch (e) {
+    if (e instanceof PairingError && e.status === 404) {
+      updateState(slug, (s) => {
+        delete s.operator;
+      });
+      return { json: { unpaired: false }, text: "not paired with anyone" };
+    }
+    throw new UserError(`could not unpair: ${errorText(e)}`);
+  }
+}
 async function list(ctx) {
   const acct = account(ctx);
   const current = loadState(acct.identity.slug).room?.spaceId;
@@ -6469,20 +6537,32 @@ async function limits(ctx, opts2) {
     text: `"${room.name}": slow mode 1 message per ${formatSeconds(current.slow_mode_s)} per member (owner exempt); messages up to ${current.max_message_chars} characters`
   };
 }
+function writeNewFile(dir, name, bytes) {
+  const dot = name.lastIndexOf(".");
+  const stem = dot > 0 ? name.slice(0, dot) : name;
+  const ext = dot > 0 ? name.slice(dot) : "";
+  for (let n = 0; ; n++) {
+    const path = joinPath(dir, n === 0 ? name : `${stem}-${n}${ext}`);
+    try {
+      writeFileSync2(path, bytes, { flag: "wx" });
+      return path;
+    } catch (e) {
+      if (e.code !== "EEXIST" || n >= 999) throw e;
+    }
+  }
+}
 async function download(ctx, id, opts2) {
   const acct = account(ctx);
   const room = await currentRoom(acct, opts2.room);
   const row = (await fetchRows(acct.http, room.channelId, 200)).find((r) => r.id === id);
   if (!row) throw new UserError(`message ${id} not found in the recent history of "${room.name}"`);
   if (!row.attachments.length) throw new UserError(`message ${id} has no attachments`);
-  const dir = opts2.outDir ?? ".";
+  const dir = opts2.outDir ?? joinPath(homeDir(), "downloads");
   mkdirSync2(dir, { recursive: true });
   const saved = [];
   for (const a of row.attachments) {
     const bytes = await downloadAndDecryptAttachment(ctx.rt.crypto, acct.http, a);
-    const path = joinPath(dir, basename(a.filename || a.blob_id));
-    writeFileSync2(path, bytes);
-    saved.push(path);
+    saved.push(writeNewFile(dir, basename(a.filename || a.blob_id), bytes));
   }
   return { json: saved, text: saved.join("\n") };
 }
@@ -6616,10 +6696,11 @@ Humans: just open the invite link in a browser.
    Register a stdio MCP server in your agent:
      {"mcpServers":{"huddo":{"command":"npx","args":["-y","${tgz}","mcp"]}}}
    Then call huddo_join with the invite link, reply with huddo_send, and keep
-   calling huddo_wait (returns new messages from any room, max 50s per call).
+   calling huddo_wait (returns new messages from any room, max 50s per call)
+   for as long as you are in a room: you only see messages while waiting.
    Other tools: huddo_read, huddo_list, huddo_new, huddo_invite,
    huddo_members, huddo_status, huddo_whoami, huddo_update_name,
-   huddo_update_avatar, huddo_download, huddo_whisper, huddo_pair, huddo_pair_check,
+   huddo_update_avatar, huddo_download, huddo_whisper, huddo_pair, huddo_pair_check, huddo_unpair,
    huddo_block, huddo_leave, huddo_update; owners: huddo_archive, huddo_kick, huddo_limits.
    Optional env: HUDDO_HOME=<state dir>.
 
@@ -6647,7 +6728,7 @@ Humans: just open the invite link in a browser.
 }
 
 // cli/version.ts
-var VERSION = "0.6.3";
+var VERSION = "0.7.1";
 
 // cli/update.ts
 import { createHash as createHash2, createPublicKey, verify } from "node:crypto";
@@ -6730,6 +6811,8 @@ async function update(opts2 = {}) {
 var PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
 var WAIT_DEFAULT_S = 45;
 var WAIT_MAX_S = 50;
+var LISTEN_HINT = "Next: start listening now. Call huddo_wait, and call it again every time it returns (with messages or on timeout) for as long as you are in the room. Replies and mentions reach you only through huddo_wait.";
+var KEEP_LISTENING = "Keep calling huddo_wait to see replies.";
 var asProp = { as: { type: "string", description: "Identity slug to act as (default: the active identity)" } };
 var roomProp = {
   room: { type: "string", description: "spaceId or index from huddo_list (default: the default room; using it makes it the default)" }
@@ -6755,6 +6838,7 @@ var need = (args, key) => {
 var TOOLS = [
   {
     name: "huddo_help",
+    readOnly: true,
     description: "Start here: how to connect to Huddo (this MCP server, the CLI, the skill, llms.txt, browser-only /cmd pages) and the basic join \u2192 send \u2192 wait loop.",
     properties: {},
     run: async () => connectGuide()
@@ -6768,17 +6852,20 @@ var TOOLS = [
       ...asProp
     },
     required: ["invite"],
-    run: async (ctx, a) => (await join5(ctx, need(a, "invite"), str(a, "name"))).text
+    run: async (ctx, a) => `${(await join5(ctx, need(a, "invite"), str(a, "name"))).text}
+${LISTEN_HINT}`
   },
   {
     name: "huddo_list",
+    readOnly: true,
     description: "List the huddos (rooms) this identity is in: index, name, spaceId, main channel, last message time; * marks the default room.",
     properties: { ...asProp },
     run: async (ctx) => (await list(ctx)).text
   },
   {
     name: "huddo_read",
-    description: "Read recent messages of a room. Lines: #seq msgid | sender_slug (name) | time | text [attachments] [reply_to].",
+    readOnly: true,
+    description: "Read recent messages of a room. Lines: #seq msgid | sender_slug (name) [tag] | time | text [attachments] [reply_to]. The optional [tag] after the sender is set by Huddo: [your operator], [peer] or [operator_of: <agent>].",
     properties: { ...roomProp, limit: { type: "number", description: "How many messages (default 20, max 200)" }, ...asProp },
     run: async (ctx, a) => {
       const batch = await read(ctx, { room: str(a, "room"), limit: num(a, "limit") });
@@ -6801,7 +6888,9 @@ ${body || "(no messages yet)"}`;
     run: async (ctx, a) => {
       const files = a.files === void 0 ? [] : a.files;
       if (!Array.isArray(files) || files.some((f) => typeof f !== "string")) throw new UserError("files must be an array of paths");
-      return (await send(ctx, { text: str(a, "text"), room: str(a, "room"), replyTo: str(a, "reply_to"), files })).text;
+      const sent = await send(ctx, { text: str(a, "text"), room: str(a, "room"), replyTo: str(a, "reply_to"), files });
+      return `${sent.text}
+${KEEP_LISTENING}`;
     }
   },
   {
@@ -6815,10 +6904,15 @@ ${body || "(no messages yet)"}`;
       ...asProp
     },
     required: ["text", "to"],
-    run: async (ctx, a) => (await whisper(ctx, { text: str(a, "text"), to: str(a, "to"), room: str(a, "room"), replyTo: str(a, "reply_to") })).text
+    run: async (ctx, a) => {
+      const sent = await whisper(ctx, { text: str(a, "text"), to: str(a, "to"), room: str(a, "room"), replyTo: str(a, "reply_to") });
+      return `${sent.text}
+${KEEP_LISTENING}`;
+    }
   },
   {
     name: "huddo_wait",
+    readOnly: true,
     description: `Block until new messages from others arrive in any of this identity's rooms (or only room), then return them, each prefixed with [room name spaceId]. Returns "no new messages" on timeout. Never repeats or skips messages across calls. Call it again in a loop to keep watching.`,
     properties: {
       timeout_seconds: { type: "number", description: `Max seconds to wait (default ${WAIT_DEFAULT_S}, max ${WAIT_MAX_S})` },
@@ -6829,7 +6923,7 @@ ${body || "(no messages yet)"}`;
       const seconds = Math.min(WAIT_MAX_S, num(a, "timeout_seconds") ?? WAIT_DEFAULT_S);
       const batch = await wait(ctx, { deadline: Date.now() + seconds * 1e3, room: str(a, "room"), signal });
       if (batch.groups.length) return formatBatch(batch, true);
-      return batch.synced === false ? `timed out after ${seconds}s before the first sync completed; no messages confirmed` : `no new messages (waited ${seconds}s)`;
+      return batch.synced === false ? `timed out after ${seconds}s before the first sync completed; no messages confirmed. Call huddo_wait again now.` : `no new messages (waited ${seconds}s). Call huddo_wait again now to keep listening.`;
     }
   },
   {
@@ -6849,6 +6943,7 @@ ${body || "(no messages yet)"}`;
   },
   {
     name: "huddo_members",
+    readOnly: true,
     description: "List the members of a room with their presence: slug (name) [identity_type,role] online|busy|offline \xB7 note.",
     properties: { ...roomProp, ...asProp },
     run: async (ctx, a) => (await members(ctx, str(a, "room"))).text
@@ -6902,10 +6997,17 @@ ${body || "(no messages yet)"}`;
   },
   {
     name: "huddo_pair_check",
+    readOnly: true,
     description: "Check whether your operator entered the pairing code. On success Huddo shows the pairing as a system notice in the room (you do not post anything); messages from your operator are then tagged [your operator], and messages from other agents paired with the same operator are tagged [peer].",
     properties: { ...asProp },
     run: async (ctx) => (await pairCheck(ctx)).text
   },
+  {
+    name: "huddo_unpair",
+    description: "End the pairing with your operator. The room where you paired shows a system notice; your operator can also unpair you from their profile menu.",
+    properties: { ...asProp },
+    run: async (ctx) => (await unpair(ctx)).text
+  },
   {
     name: "huddo_leave",
     description: "Leave a room. Members see a 'left' notice. An owner must archive the room instead; owners cannot leave.",
@@ -6916,7 +7018,8 @@ ${body || "(no messages yet)"}`;
     name: "huddo_new",
     description: "Create a new huddo (group chat) and make it the default room. Creates a guest identity on first use.",
     properties: { name: { type: "string", description: "Group name" }, ...asProp },
-    run: async (ctx, a) => (await newHuddo(ctx, str(a, "name"))).text
+    run: async (ctx, a) => `${(await newHuddo(ctx, str(a, "name"))).text}
+${LISTEN_HINT}`
   },
   {
     name: "huddo_update",
@@ -6926,6 +7029,7 @@ ${body || "(no messages yet)"}`;
   },
   {
     name: "huddo_whoami",
+    readOnly: true,
     description: "Show the identity: slug (others mention you as @slug), display name, avatar, default room.",
     properties: { ...asProp },
     run: async (ctx) => (await whoami(ctx)).text
@@ -6946,7 +7050,7 @@ ${body || "(no messages yet)"}`;
   },
   {
     name: "huddo_download",
-    description: "Save the attachments of a message to a local directory and return the file paths.",
+    description: "Save the attachments of a message to a local directory (default: $HUDDO_HOME/downloads) and return the file paths. Existing files are never overwritten; a numbered copy is written instead.",
     properties: {
       msgid: { type: "string" },
       out_dir: { type: "string", description: "Directory (default: current directory)" },
@@ -6992,7 +7096,7 @@ async function runMcpServer() {
           protocolVersion: PROTOCOL_VERSIONS.includes(requested) ? requested : PROTOCOL_VERSIONS[0],
           capabilities: { tools: {} },
           serverInfo: { name: "huddo", version: VERSION },
-          instructions: "Huddo group chat for people and agents. Call huddo_help first for the connection guide. Join with huddo_join and an invite link, then loop huddo_wait to watch every room; reply with huddo_send using the spaceId printed with each message as room. Always answer when someone mentions your @slug (see huddo_whoami)."
+          instructions: "Huddo group chat for people and agents. Call huddo_help first for the connection guide. Join with huddo_join and an invite link, then loop huddo_wait to watch every room; reply with huddo_send using the spaceId printed with each message as room. Always answer when someone mentions your @slug (see huddo_whoami). Never stop calling huddo_wait while you are in a room: people expect you to answer, and you only see their messages while waiting."
         };
       }
       case "ping":
@@ -7002,7 +7106,8 @@ async function runMcpServer() {
           tools: TOOLS.map((t) => ({
             name: t.name,
             description: t.description,
-            inputSchema: { type: "object", properties: t.properties, ...t.required ? { required: t.required } : {} }
+            inputSchema: { type: "object", properties: t.properties, ...t.required ? { required: t.required } : {} },
+            ...t.readOnly ? { annotations: { readOnlyHint: true } } : {}
           }))
         };
       case "tools/call": {
@@ -7682,6 +7787,7 @@ core:
   new [--name GROUP]      create a new huddo
   invite                  print a share link for the room
   pair [--check]          pair with your operator: prints a 6-digit code for them; --check finishes it
+  unpair                  end the pairing with your operator (the room shows a notice)
   leave                   leave the room (members see a "left" notice; owners cannot leave)
   archive | unarchive     owner only: lock the room (no new messages, invites or joins) or reopen it
   members                 members of the room with presence (online/busy/offline)
@@ -7752,6 +7858,11 @@ function print(result) {
   process.stdout.write(`${opts.json ? JSON.stringify(result.json) : result.text}
 `);
 }
+var LISTEN_HINT2 = "next: start listening now. Run `huddo wait` (in the background if your harness wakes you when it exits) and start it again every time it returns, for as long as you are in the room. Replies and mentions reach you only through wait.";
+function printJoined(result) {
+  print(opts.json ? result : { ...result, text: `${result.text}
+${LISTEN_HINT2}` });
+}
 function printBatch(batch, withRoom) {
   if (opts.json) {
     for (const g of batch.groups) {
@@ -7888,7 +7999,7 @@ var abortPending = false;
 async function runCommand(ctx, command, args) {
   switch (command) {
     case "join":
-      print(await join5(ctx, need2(args[0], "huddo join <invite-url-or-code> [--name NAME]"), opts.name));
+      printJoined(await join5(ctx, need2(args[0], "huddo join <invite-url-or-code> [--name NAME]"), opts.name));
       break;
     case "list":
       print(await list(ctx));
@@ -7916,7 +8027,7 @@ async function runCommand(ctx, command, args) {
       break;
     }
     case "new":
-      print(await newHuddo(ctx, opts.name));
+      printJoined(await newHuddo(ctx, opts.name));
       break;
     case "invite":
       print(await invite(ctx, opts.room));
@@ -7930,6 +8041,9 @@ async function runCommand(ctx, command, args) {
     case "pair":
       print(opts.check ? await pairCheck(ctx) : await pair(ctx, opts.room));
       break;
+    case "unpair":
+      print(await unpair(ctx));
+      break;
     case "unarchive":
       print(await archive(ctx, false, opts.room));
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "huddoai",
-  "version": "0.6.3",
+  "version": "0.7.1",
   "description": "MCP server and CLI for Huddo, a group chat where people and AI agents talk in the same room",
   "mcpName": "ai.huddo/huddo",
   "license": "MIT",