@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/org/messaging.test.mjs

@@ -1,471 +0,0 @@
-/**
- * messaging.test.mjs — the SP10 org messaging seam: send-gate enforcement,
- * wire shape + idempotency header, afterSend hook + source="messaging"
- * attribution, calling, and the inbound projection. Injected client/fetch +
- * send-gate + hook bus + ledger, so no network and no disk writes leak.
- * Run: node --test lib/org/messaging.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  sendMessage,
-  reactMessage,
-  fetchHistory,
-  listChannels,
-  openDm,
-  openConversation,
-  createChannel,
-  addChannelMember,
-  initiateCall,
-  joinCall,
-  pullInbound,
-  isDirectedAtAgent,
-  toMessageEvent,
-} from "./messaging.mjs";
-import { PROTOCOL_VERSION } from "./protocol.mjs";
-
-const BASE = "https://org.cohortapp.com";
-const TOKEN = "tok-msg";
-const CFG = { org: { cohort: { enabled: true, base: BASE, token: TOKEN, agentId: "agent-1" } } };
-
-delete process.env.COHORT_API_TOKEN;
-delete process.env.COHORT_TOKEN;
-delete process.env.MESSAGING_INBOUND_ESCALATE;
-
-/** A fake fetch that records calls and returns a canned res frame (mirrors client.test). */
-function fakeFetch(responder) {
-  const calls = [];
-  const impl = async (url, init) => {
-    calls.push({ url, init, headers: (init && init.headers) || {}, body: init && init.body ? JSON.parse(init.body) : null });
-    const r = responder ? responder(url, init, calls.length - 1) : null;
-    const status = r && typeof r.status === "number" ? r.status : 200;
-    const ok = r && typeof r.ok === "boolean" ? r.ok : status >= 200 && status < 300;
-    const body = r ? r.body : { ok: true, result: null };
-    return { ok, status, headers: { get: () => undefined }, json: async () => body };
-  };
-  impl.calls = calls;
-  return impl;
-}
-
-/** Allow-all send-gate (the default screen would also allow benign text). */
-const allowGate = async () => ({ allow: true, reason: "" });
-/** A capturing ledger so we can assert source="messaging" without touching disk. */
-function captureLedger() {
-  const rows = [];
-  const writeLedgerRow = (_catalog, entry) => { rows.push(entry); return { row: entry, written: true, path: "" }; };
-  writeLedgerRow.rows = rows;
-  return writeLedgerRow;
-}
-/** A hook bus stub that records afterSend emits. */
-function captureBus() {
-  const emits = [];
-  return { emits, emit: async (ev, ctx) => { emits.push({ ev, ctx }); return { cancelled: false }; } };
-}
-
-// --- send-gate enforcement (the load-bearing invariant) --------------------
-
-test("sendMessage: a banned-phrase message is BLOCKED by the send-gate and NEVER sent", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "m1" } } }));
-  // Real send-gate (no gateImpl): "I'm here to help" is a banned AI-tell.
-  const frame = await sendMessage(
-    { channel: "C-eng", body: "Hi — I'm here to help with the deploy." },
-    { cfg: CFG, fetchImpl: f, ledgerImpl: null }
-  );
-  assert.equal(frame.ok, false, "blocked → not ok");
-  assert.equal(frame.blocked, true, "marked blocked (policy refusal, not transport)");
-  assert.match(frame.error.message, /banned/i);
-  assert.equal(f.calls.length, 0, "NO messaging.send was issued for a blocked message");
-});
-
-test("sendMessage: a clean message posts to /v1/messaging.send with Bearer + protocol + idempotency", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "m2", ts: "t" } } }));
-  const ledger = captureLedger();
-  const bus = captureBus();
-  const frame = await sendMessage(
-    { channel: "C-eng", body: "Deploy is green on staging.", mentions: ["agent-2"], idempotencyId: "msg-xyz" },
-    { cfg: CFG, fetchImpl: f, gateImpl: allowGate, hookBus: bus, ledgerImpl: ledger }
-  );
-  assert.equal(frame.ok, true);
-  assert.equal(f.calls.length, 1);
-  assert.match(f.calls[0].url, /\/v1\/messaging\.send$/);
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(f.calls[0].headers["x-org-protocol"], String(PROTOCOL_VERSION));
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "msg-xyz", "idempotent on the client message id");
-  // wire shape
-  assert.equal(f.calls[0].body.channel, "C-eng");
-  assert.equal(f.calls[0].body.body, "Deploy is green on staging.");
-  // `[{memberId}]`, NOT `["agent-2"]`. hq's mentionSchema is an object schema,
-  // so the bare-string form this used to assert did not merely lose the tag — it
-  // failed zod and 400'd the entire send. The one call an agent makes to bring a
-  // colleague in was the one call guaranteed to fail.
-  assert.deepEqual(f.calls[0].body.mentions, [{ memberId: "agent-2" }]);
-  assert.equal(f.calls[0].body.id, "msg-xyz");
-});
-
-test("sendMessage: mentions accept strings or objects, de-dupe, and keep offsets", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "m2b" } } }));
-  await sendMessage(
-    {
-      channel: "C-eng",
-      body: "hi",
-      mentions: ["agent-2", { memberId: "agent-2" }, { id: "agent-3" }, { memberId: "agent-4", offset: 7 }, "", null],
-      idempotencyId: "msg-m",
-    },
-    { cfg: CFG, fetchImpl: f, gateImpl: allowGate, hookBus: captureBus(), ledgerImpl: captureLedger() },
-  );
-  assert.deepEqual(f.calls[0].body.mentions, [
-    { memberId: "agent-2" },
-    { memberId: "agent-3" },
-    { memberId: "agent-4", offset: 7 },
-  ]);
-});
-
-test("sendMessage: no mentions means the key is absent, not an empty array", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "m2c" } } }));
-  await sendMessage(
-    { channel: "C-eng", body: "hi", mentions: [] },
-    { cfg: CFG, fetchImpl: f, gateImpl: allowGate, hookBus: captureBus(), ledgerImpl: captureLedger() },
-  );
-  assert.equal("mentions" in f.calls[0].body, false);
-});
-
-test("sendMessage: emits afterSend + attributes a source='messaging' ledger row on success", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "m3" } } }));
-  const ledger = captureLedger();
-  const bus = captureBus();
-  await sendMessage(
-    { channel: "C-ops", body: "Status nominal." },
-    { cfg: CFG, agentRoot: "/tmp/agent", fetchImpl: f, gateImpl: allowGate, hookBus: bus, ledgerImpl: ledger }
-  );
-  assert.equal(bus.emits.length, 1, "one afterSend emit");
-  assert.equal(bus.emits[0].ev, "afterSend");
-  assert.equal(bus.emits[0].ctx.source, "messaging");
-  assert.equal(ledger.rows.length, 1, "one ledger row");
-  assert.equal(ledger.rows[0].source, "messaging");
-  assert.equal(ledger.rows[0].inputTokens, 0, "zero-token attribution row (not LLM spend)");
-});
-
-test("sendMessage: redactedText from the gate is what hits the wire", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "m4" } } }));
-  const redactGate = async () => ({ allow: true, reason: "", redactedText: "REDACTED" });
-  await sendMessage({ channel: "C", body: "secret" }, { cfg: CFG, fetchImpl: f, gateImpl: redactGate, ledgerImpl: null });
-  assert.equal(f.calls[0].body.body, "REDACTED");
-});
-
-test("sendMessage: missing channel/body → BAD_REQUEST and never touches the gate or wire", async () => {
-  const f = fakeFetch();
-  assert.equal((await sendMessage({ body: "x" }, { cfg: CFG, fetchImpl: f })).error.code, "BAD_REQUEST");
-  assert.equal((await sendMessage({ channel: "C" }, { cfg: CFG, fetchImpl: f })).error.code, "BAD_REQUEST");
-  assert.equal(f.calls.length, 0);
-});
-
-test("sendMessage: org disabled → fail-open error frame, gate ran but no wire", async () => {
-  const f = fakeFetch();
-  const frame = await sendMessage({ channel: "C", body: "hello team" }, { cfg: { org: { cohort: { enabled: false } } }, fetchImpl: f, gateImpl: allowGate, ledgerImpl: null });
-  assert.equal(frame.ok, false);
-  assert.equal(f.calls.length, 0, "no wire when org is disabled");
-});
-
-test("sendMessage: a gate that throws fails CLOSED (no send)", async () => {
-  const f = fakeFetch();
-  const boom = async () => { throw new Error("gate down"); };
-  const frame = await sendMessage({ channel: "C", body: "hello" }, { cfg: CFG, fetchImpl: f, gateImpl: boom, ledgerImpl: null });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.blocked, true);
-  assert.equal(f.calls.length, 0);
-});
-
-// --- react / history / channels --------------------------------------------
-
-test("reactMessage: posts messaging.react and attributes the action", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  const ledger = captureLedger();
-  const frame = await reactMessage({ channel: "C", messageId: "m1", emoji: "eyes" }, { cfg: CFG, fetchImpl: f, ledgerImpl: ledger });
-  assert.equal(frame.ok, true);
-  assert.match(f.calls[0].url, /messaging\.react$/);
-  assert.equal(ledger.rows[0].source, "messaging");
-});
-
-test("fetchHistory: returns the messages array (fail-open [] on error)", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { messages: [{ id: "a" }, { id: "b" }] } } }));
-  const msgs = await fetchHistory({ channel: "C", limit: 10 }, { cfg: CFG, fetchImpl: f });
-  assert.equal(msgs.length, 2);
-  assert.equal(f.calls[0].body.limit, 10);
-  const bad = fakeFetch(() => ({ ok: false, status: 500, body: { ok: false, error: { code: "INTERNAL" } } }));
-  assert.deepEqual(await fetchHistory({ channel: "C" }, { cfg: CFG, fetchImpl: bad }), []);
-});
-
-test("listChannels: returns the channels array (fail-open [])", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { channels: [{ id: "C1" }] } } }));
-  assert.deepEqual(await listChannels({ cfg: CFG, fetchImpl: f }), [{ id: "C1" }]);
-  assert.deepEqual(await listChannels({ cfg: { org: { cohort: { enabled: false } } } }), []);
-});
-
-// --- calling ----------------------------------------------------------------
-
-test("initiateCall: posts calling.start with invitees + attributes the action", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { callId: "call-1" } } }));
-  const ledger = captureLedger();
-  const frame = await initiateCall({ channel: "C", invitees: ["agent-2"], topic: "sync", idempotencyId: "c1" }, { cfg: CFG, fetchImpl: f, ledgerImpl: ledger });
-  assert.equal(frame.ok, true);
-  assert.match(f.calls[0].url, /calling\.start$/);
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "c1");
-  assert.deepEqual(f.calls[0].body.invitees, ["agent-2"]);
-  assert.equal(ledger.rows[0].source, "messaging");
-});
-
-test("joinCall: posts calling.join (missing callId → BAD_REQUEST)", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  assert.equal((await joinCall({}, { cfg: CFG, fetchImpl: f })).error.code, "BAD_REQUEST");
-  const frame = await joinCall({ callId: "call-1" }, { cfg: CFG, fetchImpl: f, ledgerImpl: null });
-  assert.equal(frame.ok, true);
-  assert.match(f.calls[0].url, /calling\.join$/);
-});
-
-// --- inbound projection -----------------------------------------------------
-
-test("isDirectedAtAgent: @mention / DM-to / invitee = directed; own echo / ambient = not", () => {
-  assert.equal(isDirectedAtAgent({ family: "messaging", payload: { from: "x", mentions: ["me"], body: "hi" } }, "me"), true);
-  assert.equal(isDirectedAtAgent({ family: "messaging", payload: { from: "x", to: ["me"], kind: "dm", body: "hi" } }, "me"), true);
-  assert.equal(isDirectedAtAgent({ family: "calling", payload: { from: "x", invitees: ["me"], topic: "t" } }, "me"), true);
-  assert.equal(isDirectedAtAgent({ family: "messaging", payload: { from: "me", mentions: ["me"], body: "echo" } }, "me"), false, "own echo ignored");
-  assert.equal(isDirectedAtAgent({ family: "messaging", payload: { from: "x", body: "ambient channel chatter" } }, "me"), false);
-  assert.equal(isDirectedAtAgent({ family: "board", payload: {} }, "me"), false, "non-messaging family ignored");
-});
-
-test("toMessageEvent: projects a messaging event onto the MessageEvent contract", () => {
-  const ev = toMessageEvent({ family: "messaging", seq: 7, at: "2026-06-12T00:00:00Z", payload: { id: "m9", channel: "C-eng", from: "agent-2", fromName: "Robin", body: "ping", mentions: ["me"] } }, "me");
-  assert.equal(ev.channel, "cohort");
-  assert.equal(ev.message_id, "m9");
-  assert.equal(ev.text, "ping");
-  assert.equal(ev.channel_id, "C-eng");
-  assert.equal(ev.from.id, "agent-2");
-  assert.equal(ev.kind, "message");
-  assert.equal(ev.priority_signals.mentions_agent, true);
-  assert.equal(ev.ingest_source, "cohort");
-});
-
-test("toMessageEvent: projects channelKind so the daemon can tell a DM from a GROUP_DM", () => {
-  const dm = toMessageEvent({ family: "messaging", seq: 8, payload: { id: "m1", channel: "dm-x", channelKind: "DM", from: "human-1", body: "hi" } }, "me");
-  assert.equal(dm.channel_kind, "DM", "a 1:1 DM carries channel_kind DM (→ is_dm true downstream)");
-  const group = toMessageEvent({ family: "messaging", seq: 9, payload: { id: "m2", channel: "gdm-x", channelKind: "group_dm", from: "human-1", body: "hi all" } }, "me");
-  assert.equal(group.channel_kind, "GROUP_DM", "a GROUP_DM is upper-cased and NOT a 1:1 DM downstream");
-});
-
-test("pullInbound: filters to directed events and advances the cursor to max seq", async () => {
-  const f = fakeFetch(() => ({
-    body: {
-      events: [
-        { family: "messaging", seq: 10, payload: { id: "a", channel: "C", from: "x", body: "ambient" } },
-        { family: "messaging", seq: 11, payload: { id: "b", channel: "C", from: "x", mentions: ["agent-1"], body: "@me hi" } },
-        { family: "calling", seq: 12, payload: { id: "c", callId: "call-9", from: "x", invitees: ["agent-1"], topic: "sync" } },
-      ],
-    },
-  }));
-  const { events, nextCursor } = await pullInbound({ cfg: CFG, agentId: "agent-1", cursor: 9, fetchImpl: f });
-  assert.equal(events.length, 2, "only the @mention + the call-invite are directed");
-  assert.equal(nextCursor, 12, "cursor advanced to the highest seq seen (incl. the skipped ambient)");
-  // the events query carried the family filter + cursor
-  assert.match(f.calls[0].url, /events\?cursor=9/);
-  assert.match(f.calls[0].url, /family=messaging,calling/);
-});
-
-test("pullInbound: org disabled → empty, cursor preserved (fail-open)", async () => {
-  const { events, nextCursor } = await pullInbound({ cfg: { org: { cohort: { enabled: false } } }, cursor: 5 });
-  assert.deepEqual(events, []);
-  assert.equal(nextCursor, 5);
-});
-
-// ---------------------------------------------------------------------------
-// The REAL hq event shape — regression for the silent-DM-drop
-// ---------------------------------------------------------------------------
-
-/** Exactly what hq appends for a human DM (redacted: no body, no recipients). */
-function hqDmEvent(overrides = {}) {
-  return {
-    seq: 9880,
-    family: "messaging",
-    kind: "send",
-    entityId: "cmsnbhmqy004blj016kot2pwi",
-    actor: "human-1",
-    at: "2026-08-10T14:18:55.978Z",
-    payload: {
-      ts: "2026-08-10T14:18:55.978Z",
-      actor: "human-1",
-      threaded: false,
-      channelId: "dm-human-agent",
-      channelKind: "DM",
-      mentionCount: 0,
-      recipientCount: 2,
-      attachmentCount: 0,
-      ...overrides,
-    },
-  };
-}
-
-test("isDirectedAtAgent: a human DM in MY room is directed (the production silent-drop)", () => {
-  // Six real DMs were dropped: the filter wanted a `to` list the redacted
-  // payload never carries, and checked `kind` for "dm" when the kind is "send"
-  // and the room type lives in `channelKind`.
-  const mine = new Set(["dm-human-agent"]);
-  assert.equal(isDirectedAtAgent(hqDmEvent(), "agent-self", { myChannelIds: mine }), true);
-});
-
-test("isDirectedAtAgent: a DM I am NOT in is NOT mine (org feed is org-wide)", () => {
-  // /v1/events is org-scoped, so an agent sees other people's DM events too.
-  // Reacting to those would be barging into private conversations.
-  const mine = new Set(["dm-human-agent"]);
-  const someoneElses = hqDmEvent({ channelId: "dm-human-other" });
-  assert.equal(isDirectedAtAgent(someoneElses, "agent-self", { myChannelIds: mine }), false);
-});
-
-test("isDirectedAtAgent: without membership context it stays CONSERVATIVE on DMs", () => {
-  // Guessing "yes" without knowing the roster is the dangerous direction.
-  assert.equal(isDirectedAtAgent(hqDmEvent(), "agent-self"), false);
-});
-
-test("isDirectedAtAgent: my own echo in my own DM is still ignored", () => {
-  const mine = new Set(["dm-human-agent"]);
-  const echo = hqDmEvent({ actor: "agent-self" });
-  echo.actor = "agent-self";
-  assert.equal(isDirectedAtAgent(echo, "agent-self", { myChannelIds: mine }), false);
-});
-
-test("isDirectedAtAgent: a PUBLIC channel message in my room is NOT directed on its own", () => {
-  // Membership in a public channel is not an invitation to answer everything;
-  // that needs an @mention (which the redacted payload cannot yet express —
-  // hq emits mentionCount, not the ids).
-  const mine = new Set(["general"]);
-  const pub = hqDmEvent({ channelId: "general", channelKind: "PUBLIC" });
-  assert.equal(isDirectedAtAgent(pub, "agent-self", { myChannelIds: mine }), false);
-});
-
-test("isDirectedAtAgent: an explicit mentions[] still wins anywhere", () => {
-  const mine = new Set(["general"]);
-  const pub = hqDmEvent({ channelId: "general", channelKind: "PUBLIC", mentions: ["agent-self"] });
-  assert.equal(isDirectedAtAgent(pub, "agent-self", { myChannelIds: mine }), true);
-});
-
-test("isDirectedAtAgent: a call event in my room is an invite", () => {
-  const mine = new Set(["room-1"]);
-  const ev = { family: "calling", kind: "start", actor: "human-1",
-               payload: { channelId: "room-1", topic: "standup" } };
-  assert.equal(isDirectedAtAgent(ev, "agent-self", { myChannelIds: mine }), true);
-});
-
-test("isDirectedAtAgent: the SHARED feed never names who was mentioned", () => {
-  // hq's chain payload is a REDACTED audit row read by every agent holding
-  // `org.read`, so it carries `mentionCount` and deliberately NOT the member
-  // ids — listing them would leak the association graph of private rooms. This
-  // filter therefore cannot resolve a space @mention on its own, BY DESIGN;
-  // pullInbound confirms candidates against the per-member `messaging.history`
-  // read instead. Asserted so nobody "fixes" the deafness by widening the feed.
-  const shared = {
-    family: "messaging", kind: "send", entityId: "msg_1", actor: "human-1",
-    payload: { channelId: "space-general", channelKind: "PUBLIC", mentionCount: 1 },
-  };
-  assert.equal(isDirectedAtAgent(shared, "agent-self"), false);
-});
-
-test("isDirectedAtAgent: an explicit mentions[] still wins when a producer supplies one", () => {
-  // hq's chain payload used to carry `mentionCount` — a NUMBER — so an agent
-  // tailing the feed could see that a mention happened but not that it was the
-  // one mentioned. Combined with hq deferring to live daemons, an @mention in a
-  // public space reached nobody: the server stayed quiet and the agent was deaf.
-  // hq now emits `mentions: [memberId…]`, which this filter already understood.
-  const ev = {
-    seq: 10500,
-    family: "messaging",
-    kind: "send",
-    entityId: "msg_1",
-    actor: "human-1",
-    payload: {
-      channelId: "space-general",
-      channelKind: "PUBLIC",
-      mentions: ["agent-self"],
-      mentionCount: 1,
-      recipientCount: 12,
-    },
-  };
-  // Membership is NOT required for a mention — being named is the invitation.
-  assert.equal(isDirectedAtAgent(ev, "agent-self"), true);
-  // …and someone else's mention in the same space is still not ours.
-  assert.equal(isDirectedAtAgent(ev, "agent-other"), false);
-});
-
-// ---------------------------------------------------------------------------
-// Rooms — the four verbs the SDK had in its protocol table and could not call
-// ---------------------------------------------------------------------------
-
-test("openDm resolves the 1:1 channel and hands back the id the send needs", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { channelId: "C-dm-1", created: true } } }));
-  const r = await openDm({ memberId: "M-2" }, { cfg: CFG, fetchImpl: f });
-  assert.equal(r.ok, true);
-  assert.equal(r.channelId, "C-dm-1");
-  assert.equal(r.created, true);
-  assert.match(f.calls[0].url, /\/v1\/channel\.resolveOrCreateDm$/);
-  assert.deepEqual(f.calls[0].body, { memberId: "M-2" });
-});
-
-test("openDm reads the channel id out of whichever shape the handler returns", async () => {
-  for (const result of [{ id: "C-x" }, { channelId: "C-x" }, { channel: { id: "C-x" } }]) {
-    const r = await openDm({ memberId: "M-2" }, { cfg: CFG, fetchImpl: fakeFetch(() => ({ body: { ok: true, result } })) });
-    assert.equal(r.channelId, "C-x", JSON.stringify(result));
-  }
-});
-
-test("openConversation de-dupes the member list and sends hq's `memberIds`", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "C-gdm" } } }));
-  const r = await openConversation({ memberIds: ["M-2", "M-3", "M-2", ""], name: "Vendor contract" }, { cfg: CFG, fetchImpl: f });
-  assert.equal(r.ok, true);
-  assert.equal(r.channelId, "C-gdm");
-  assert.match(f.calls[0].url, /\/v1\/channel\.createConversation$/);
-  assert.deepEqual(f.calls[0].body.memberIds, ["M-2", "M-3"]);
-  assert.equal(f.calls[0].body.name, "Vendor contract");
-});
-
-test("openConversation with nobody in it never reaches the wire", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: {} } }));
-  const r = await openConversation({ memberIds: [] }, { cfg: CFG, fetchImpl: f });
-  assert.equal(r.ok, false);
-  assert.equal(f.calls.length, 0);
-});
-
-test("createChannel refuses a slug hq would reject, before spending a round trip", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "C-1" } } }));
-  const bad = await createChannel({ slug: "Vendor Contract!", name: "Vendor" }, { cfg: CFG, fetchImpl: f });
-  assert.equal(bad.ok, false);
-  assert.match(bad.frame.error.message, /lowercase alphanumerics and hyphens/);
-  assert.equal(f.calls.length, 0);
-
-  const good = await createChannel({ slug: "vendor-contract", name: "Vendor", members: ["M-2"] }, { cfg: CFG, fetchImpl: f });
-  assert.equal(good.ok, true);
-  assert.equal(f.calls[0].body.kind, "PRIVATE", "a channel an agent makes is private by default");
-  assert.deepEqual(f.calls[0].body.members, ["M-2"]);
-});
-
-test("addChannelMember reports hq's idempotent re-add as added:false, not as a failure", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { channelId: "C-1", memberId: "M-2", added: false } } }));
-  const r = await addChannelMember({ channelId: "C-1", memberId: "M-2" }, { cfg: CFG, fetchImpl: f });
-  assert.equal(r.ok, true);
-  assert.equal(r.added, false);
-  assert.match(f.calls[0].url, /\/v1\/channel\.addMember$/);
-});
-
-test("every room verb fails open to an error frame when the org is unconfigured", async () => {
-  const off = { org: { cohort: { enabled: false } } };
-  for (const [name, fn, args] of [
-    ["openDm", openDm, { memberId: "M-2" }],
-    ["openConversation", openConversation, { memberIds: ["M-2"] }],
-    ["createChannel", createChannel, { slug: "x", name: "X" }],
-    ["addChannelMember", addChannelMember, { channelId: "C", memberId: "M-2" }],
-  ]) {
-    const r = await fn(args, { cfg: off });
-    assert.equal(r.ok, false, name);
-    assert.equal(r.frame.ok, false, name);
-    assert.ok(r.frame.error.message, `${name} must say why`);
-  }
-});