@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/lib/org/inbound/hydrate.test.mjs

@@ -1,453 +0,0 @@
-/**
- * hydrate.test.mjs — per-family body/context hydration.
- *
- * Two things are being asserted throughout:
- *   1. every surface produces a body a classifier can actually act on, and
- *   2. hydration only ever uses the agent's OWN entitled reads — the call log is
- *      checked so a hydrator cannot quietly acquire a wider aperture than the
- *      directedness probe that let the item through.
- *
- * Run: node --test lib/org/inbound/hydrate.test.mjs
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { hydrate, clip, renderThread, describeBoardKind, describeApprovalKind } from "./hydrate.mjs";
-import { classifyEvent } from "./directedness.mjs";
-
-const ME = "M-me";
-const THEM = "M-them";
-const okFrame = (result) => ({ ok: true, result });
-
-function fakeIo(routes = {}) {
-  const calls = [];
-  const logs = [];
-  return {
-    calls,
-    logs,
-    log: (level, message, meta) => logs.push({ level, message, meta }),
-    async call(method, params) {
-      calls.push({ method, params });
-      const h = routes[method];
-      if (!h) return { ok: false, error: { code: "NOT_FOUND", message: method } };
-      return typeof h === "function" ? await h(params) : h;
-    },
-    async read() {
-      return { ok: false, error: { code: "NOT_FOUND", message: "read" }, status: 404 };
-    },
-  };
-}
-
-function facts(over = {}) {
-  return {
-    me: ME,
-    myNames: [],
-    channels: new Map(),
-    channelPages: new Map(),
-    myThreadRootIds: new Set(),
-    tasks: null,
-    decisions: null,
-    escalations: null,
-    approvals: null,
-    fileAcl: null,
-    degraded: [],
-    ...over,
-  };
-}
-
-function ev(over) {
-  return { seq: 7, at: "2026-08-11T00:00:00.000Z", actor: THEM, ...over };
-}
-
-// ---------------------------------------------------------------------------
-// messaging
-// ---------------------------------------------------------------------------
-
-test("messaging hydrates from the ACL'd history page — no extra RPC", async () => {
-  const f = facts();
-  f.channels.set("C-pub", { id: "C-pub", kind: "PUBLIC", name: "General", slug: "general" });
-  f.channelPages.set("C-pub", {
-    byId: new Map([
-      ["m1", { id: "m1", authorId: THEM, authorName: "Casey", body: "@Isla take a look", mentions: [ME] }],
-    ]),
-    messages: [{ id: "m1", authorId: THEM, authorName: "Casey", body: "@Isla take a look", mentions: [ME] }],
-  });
-  const c = classifyEvent(ev({ family: "messaging", kind: "send", entity_id: "m1", payload: { actor: THEM, channelId: "C-pub", channelKind: "PUBLIC", mentionCount: 1 } }));
-  const io = fakeIo({});
-  const h = await hydrate({ candidate: c, verdict: { surface: "mention", reason: "mention" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.equal(h.text, "@Isla take a look");
-  assert.deepEqual(h.from, { id: THEM, name: "Casey" });
-  assert.equal(h.channelLabel, "General");
-  assert.equal(io.calls.length, 0, "the body was already on the page");
-});
-
-test("a message that never hydrated is DROPPED, not delivered blank", async () => {
-  const c = classifyEvent(ev({ family: "messaging", kind: "send", entity_id: "m404", payload: { actor: THEM, channelId: "C-pub", channelKind: "PUBLIC" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "mention" }, facts: facts(), io: fakeIo({}) });
-  assert.equal(h.ok, false);
-  assert.equal(h.reason, "message_not_in_page");
-});
-
-test("an empty body is dropped (a blank inbound produces a nonsense reply)", async () => {
-  const f = facts();
-  f.channelPages.set("C", { byId: new Map([["m1", { id: "m1", authorId: THEM, body: "   " }]]), messages: [] });
-  const c = classifyEvent(ev({ family: "messaging", kind: "send", entity_id: "m1", payload: { actor: THEM, channelId: "C", channelKind: "DM" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "dm" }, facts: f, io: fakeIo({}) });
-  assert.equal(h.ok, false);
-  assert.equal(h.reason, "empty_body");
-});
-
-test("a threaded message carries prior-thread context", async () => {
-  const msgs = [
-    { id: "r1", authorId: ME, authorName: "Isla", body: "kick off", threadRootId: null },
-    { id: "m2", authorId: THEM, authorName: "Casey", body: "one more thing", threadRootId: "r1" },
-  ];
-  const f = facts();
-  f.channelPages.set("C-pub", { byId: new Map(msgs.map((m) => [m.id, m])), messages: msgs });
-  const c = classifyEvent(ev({ family: "messaging", kind: "send", entity_id: "m2", payload: { actor: THEM, channelId: "C-pub", channelKind: "PUBLIC", threaded: true } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "thread_reply", reason: "thread" }, facts: f, io: fakeIo({}) });
-
-  assert.equal(h.isReply, true);
-  assert.equal(h.threadId, "r1");
-  assert.match(h.threadContext, /Isla: kick off/);
-  assert.doesNotMatch(h.threadContext, /one more thing/, "the trigger itself is not its own context");
-});
-
-// A DM has no thread root — the CHANNEL is the conversation. Before this, the
-// `if (root)` guard meant a top-level message carried no context at all, so the
-// agent answered "fix this" with no idea what "this" referred to. The page is
-// already in hand from the ACL'd `messaging.history` read, so this costs no RPC.
-test("a top-level DM carries the preceding conversation as context", async () => {
-  // Newest-first, exactly as hq's messaging.history returns it.
-  const msgs = [
-    { id: "m3", authorId: THEM, authorName: "Casey", body: "fix this then", createdAt: "2026-08-11T15:33:54.000Z" },
-    { id: "m2", authorId: ME, authorName: "Alex", body: "16 min pickup on the morning batch", createdAt: "2026-08-11T15:32:00.000Z" },
-    { id: "m1", authorId: THEM, authorName: "Casey", body: "what is the reply latency here", createdAt: "2026-08-11T15:31:00.000Z" },
-  ];
-  const f = facts();
-  f.channels.set("C-dm", { id: "C-dm", kind: "DM", name: "dm-h001-a016" });
-  f.channelPages.set("C-dm", { byId: new Map(msgs.map((m) => [m.id, m])), messages: msgs });
-  const c = classifyEvent(ev({ family: "messaging", kind: "send", entity_id: "m3", payload: { actor: THEM, channelId: "C-dm", channelKind: "DM" } }));
-  const io = fakeIo({});
-  const h = await hydrate({ candidate: c, verdict: { surface: "dm", reason: "dm" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.equal(io.calls.length, 0, "the page was already in hand — context must cost no extra RPC");
-  assert.ok(h.threadContext, "a DM with prior turns must carry them");
-  assert.match(h.threadContext, /Casey: what is the reply latency here/);
-  assert.match(h.threadContext, /Alex: 16 min pickup/);
-  assert.doesNotMatch(h.threadContext, /fix this then/, "the trigger itself is not its own context");
-  assert.ok(
-    h.threadContext.indexOf("what is the reply latency") < h.threadContext.indexOf("16 min pickup"),
-    "oldest first — the conversation must read forwards",
-  );
-});
-
-test("a first-ever message in a channel has no context, not an empty block", async () => {
-  const msgs = [{ id: "m1", authorId: THEM, authorName: "Casey", body: "hello", createdAt: "2026-08-11T15:31:00.000Z" }];
-  const f = facts();
-  f.channels.set("C-dm", { id: "C-dm", kind: "DM" });
-  f.channelPages.set("C-dm", { byId: new Map(msgs.map((m) => [m.id, m])), messages: msgs });
-  const c = classifyEvent(ev({ family: "messaging", kind: "send", entity_id: "m1", payload: { actor: THEM, channelId: "C-dm", channelKind: "DM" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "dm", reason: "dm" }, facts: f, io: fakeIo({}) });
-
-  assert.equal(h.ok, true);
-  assert.equal(h.threadContext, null);
-});
-
-test("messages AFTER the trigger are never passed off as prior context", async () => {
-  const msgs = [
-    { id: "m3", authorId: THEM, authorName: "Casey", body: "later message", createdAt: "2026-08-11T16:00:00.000Z" },
-    { id: "m2", authorId: THEM, authorName: "Casey", body: "the trigger", createdAt: "2026-08-11T15:00:00.000Z" },
-    { id: "m1", authorId: ME, authorName: "Alex", body: "earlier message", createdAt: "2026-08-11T14:00:00.000Z" },
-  ];
-  const f = facts();
-  f.channels.set("C-dm", { id: "C-dm", kind: "DM" });
-  f.channelPages.set("C-dm", { byId: new Map(msgs.map((m) => [m.id, m])), messages: msgs });
-  const c = classifyEvent(ev({ family: "messaging", kind: "send", entity_id: "m2", payload: { actor: THEM, channelId: "C-dm", channelKind: "DM" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "dm", reason: "dm" }, facts: f, io: fakeIo({}) });
-
-  assert.match(h.threadContext, /earlier message/);
-  assert.doesNotMatch(h.threadContext, /later message/);
-});
-
-// ---------------------------------------------------------------------------
-// board
-// ---------------------------------------------------------------------------
-
-test("board hydrates the task card + its comment thread", async () => {
-  const f = facts({ tasks: new Map([["T-1", { id: "T-1", title: "Ship the thing", col: "doing", priority: 1, detail: "make it fast", channelId: "C-eng" }]]) });
-  const io = fakeIo({
-    "board.taskComments": ({ taskId }) =>
-      okFrame({
-        taskId,
-        comments: [
-          { id: "c1", authorId: ME, authorName: "Isla", body: "on it" },
-          { id: "c2", authorId: THEM, authorName: "Casey", body: "any update?" },
-        ],
-      }),
-  });
-  const c = classifyEvent(ev({ family: "board", kind: "item.commented", entity_id: "T-1", payload: { actor: THEM, kind: "human" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "task_comment", reason: "assignee" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /New comment on your board item — "Ship the thing"/);
-  assert.match(h.text, /Column: doing/);
-  assert.match(h.text, /any update\?/);
-  assert.match(h.threadContext, /Isla: on it/);
-  assert.equal(h.threadId, "T-1");
-  assert.deepEqual(io.calls.map((x) => x.method), ["board.taskComments"]);
-});
-
-test("a reviewer is TOLD they are the reviewer", async () => {
-  const f = facts({ tasks: new Map([["T-2", { id: "T-2", title: "Review me", col: "review" }]]) });
-  const io = fakeIo({ "board.taskComments": okFrame({ comments: [] }) });
-  const c = classifyEvent(ev({ family: "board", kind: "item.moved", entity_id: "T-2", payload: { actor: THEM, to: "review" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "task_comment", reason: "reviewer" }, facts: f, io });
-  assert.match(h.text, /You are the REVIEWER/);
-});
-
-test("two candidates on one task share a single taskComments read", async () => {
-  let n = 0;
-  const io = fakeIo({ "board.taskComments": () => { n += 1; return okFrame({ comments: [] }); } });
-  const f = facts({ tasks: new Map([["T-3", { id: "T-3", title: "x" }]]) });
-  const cache = new Map();
-  const mk = (seq, kind) => classifyEvent(ev({ seq, family: "board", kind, entity_id: "T-3", payload: { actor: THEM } }));
-  await hydrate({ candidate: mk(1, "item.commented"), verdict: { surface: "task_comment" }, facts: f, io, cache });
-  await hydrate({ candidate: mk(2, "item.moved"), verdict: { surface: "task_comment" }, facts: f, io, cache });
-  assert.equal(n, 1);
-});
-
-// ---------------------------------------------------------------------------
-// file / doc
-// ---------------------------------------------------------------------------
-
-test("a chat-file comment hydrates through file.listComments, scoped by channel", async () => {
-  const f = facts();
-  f.channels.set("C-team", { id: "C-team", kind: "PRIVATE", name: "Leads" });
-  const io = fakeIo({
-    "file.listComments": okFrame({ comments: [{ id: "fc1", authorId: THEM, authorName: "Casey", body: "typo on slide 3" }] }),
-  });
-  const c = classifyEvent(ev({ family: "file", kind: "file.commented", entity_id: "fc1", payload: { fileKey: "message-attachment:abc", channelId: "C-team", authorId: THEM } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "file_comment", reason: "channel" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /typo on slide 3/);
-  // The channel is forwarded so hq can run its own visibility gate.
-  assert.equal(io.calls[0].params.channelId, "C-team");
-});
-
-test("an unreadable file thread is dropped rather than delivered empty", async () => {
-  const c = classifyEvent(ev({ family: "file", kind: "file.commented", entity_id: "fc2", payload: { fileKey: "message-attachment:z", channelId: "C-team" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "file_comment" }, facts: facts(), io: fakeIo({}) });
-  assert.equal(h.ok, false);
-  assert.equal(h.reason, "file_comment_unreadable");
-});
-
-test("a workspace doc comment hydrates through files.comments", async () => {
-  const f = facts({ fileAcl: new Map([["F-1", { ownerId: ME, shared: false, name: "Spec" }]]) });
-  const io = fakeIo({
-    "files.comments": okFrame({ comments: [{ id: "dc1", authorId: THEM, authorName: "Casey", body: "can we cut section 4?" }] }),
-  });
-  const c = classifyEvent(ev({ family: "files", kind: "doc.comment", entity_id: "F-1", payload: { name: "Spec", commentId: "dc1" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "doc_comment", reason: "owner" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /New comment on "Spec"/);
-  assert.match(h.text, /cut section 4/);
-});
-
-// ---------------------------------------------------------------------------
-// decision / escalation / approval / handoff
-// ---------------------------------------------------------------------------
-
-test("a decision carries status, body, rationale and the latest comment", async () => {
-  const f = facts({
-    decisions: new Map([["D-1", { id: "D-1", title: "Adopt X", status: "proposed", scope: "eng", body: "we adopt X", rationale: "cheaper" }]]),
-  });
-  const io = fakeIo({
-    "decision.listComments": okFrame({ comments: [{ id: "c1", authorId: THEM, authorName: "Casey", body: "what about Y?" }] }),
-  });
-  const c = classifyEvent(ev({ family: "decision", kind: "decision.adjustment_requested", entity_id: "D-1", payload: { commentId: "c1", authorId: THEM } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "decision", reason: "proposer" }, facts: f, io });
-
-  assert.match(h.text, /An adjustment was requested on a decision — "Adopt X"/);
-  assert.match(h.text, /Status: proposed/);
-  assert.match(h.text, /Rationale: cheaper/);
-  assert.match(h.text, /what about Y\?/);
-  assert.match(h.text, /needs a response/);
-});
-
-test("an escalation needs no extra read — the facts pass already had it", async () => {
-  const f = facts({ escalations: new Map([["E-1", { id: "E-1", title: "prod down", severity: "high", detail: "500s on /v1", waitingOn: ME }]]) });
-  const io = fakeIo({});
-  const c = classifyEvent(ev({ family: "escalation", kind: "escalation.raised", entity_id: "E-1", payload: { actor: THEM, severity: "high" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "escalation", reason: "waiting_on" }, facts: f, io });
-
-  assert.match(h.text, /Escalation raised — "prod down"/);
-  assert.match(h.text, /Severity: high/);
-  assert.match(h.text, /Waiting on: M-me/);
-  assert.equal(io.calls.length, 0);
-});
-
-test("an approval renders the whole decision packet", async () => {
-  const f = facts({
-    approvals: new Map([["A-1", { id: "A-1", requester: THEM, approver: ME, status: "pending", actionClass: "spend.over_1k", reason: "vendor renewal", itemId: "T-9", expiresAt: "2026-08-12T00:00:00.000Z" }]]),
-  });
-  const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-1", payload: { requester: THEM, actionClass: "spend.over_1k" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "approval", reason: "approver" }, facts: f, io: fakeIo({}) });
-
-  assert.match(h.text, /An approval is waiting on you — spend\.over_1k/);
-  assert.match(h.text, /Status: pending/);
-  assert.match(h.text, /vendor renewal/);
-  assert.match(h.text, /Board item: T-9/);
-});
-
-test("a handoff renders intent and both ends from the payload alone", async () => {
-  const f = facts({ tasks: new Map([["T-1", { id: "T-1", title: "Migrate DB", detail: "zero downtime" }]]) });
-  const c = classifyEvent(ev({ family: "handoff", kind: "handoff.offered", entity_id: "R-1", payload: { itemId: "T-1", from: THEM, to: ME, intent: "please take this over" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "handoff", reason: "direct" }, facts: f, io: fakeIo({}) });
-
-  assert.match(h.text, /A handoff was offered to you — "Migrate DB"/);
-  assert.match(h.text, /Intent: please take this over/);
-  assert.match(h.text, /From M-them → to M-me/);
-});
-
-// ---------------------------------------------------------------------------
-// email
-// ---------------------------------------------------------------------------
-
-test("email hydrates through email.thread, which hq scopes to MY mailbox", async () => {
-  const io = fakeIo({
-    "email.thread": ({ threadId }) =>
-      okFrame({
-        thread: { id: threadId, subject: "Contract renewal" },
-        messages: [
-          { id: "EM-0", subject: "Contract renewal", text: "here is the draft", from: { name: "Dana", address: "dana@acme.com" } },
-          { id: "EM-1", subject: "Re: Contract renewal", text: "any thoughts?", from: { name: "Dana", address: "dana@acme.com" } },
-        ],
-      }),
-  });
-  const c = classifyEvent(ev({ family: "email", kind: "received", actor: "system", entity_id: "EM-1", payload: { emailMessageId: "EM-1", threadId: "ET-1", mailboxId: "MB-1", memberId: ME } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "email", reason: "direct" }, facts: facts(), io });
-
-  assert.equal(h.ok, true);
-  assert.equal(h.text, "any thoughts?");
-  assert.equal(h.subjectDetail, "Re: Contract renewal");
-  assert.equal(h.from.name, "Dana");
-  assert.match(h.threadContext, /here is the draft/);
-  assert.deepEqual(io.calls.map((x) => x.method), ["email.thread"]);
-});
-
-test("unreadable mail is dropped (not another seat's mail leaking through)", async () => {
-  const c = classifyEvent(ev({ family: "email", kind: "received", entity_id: "EM-9", payload: { emailMessageId: "EM-9", threadId: "ET-9", memberId: ME } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "email" }, facts: facts(), io: fakeIo({}) });
-  assert.equal(h.ok, false);
-  assert.equal(h.reason, "email_unreadable");
-});
-
-// ---------------------------------------------------------------------------
-// robustness
-// ---------------------------------------------------------------------------
-
-test("a hydrator that throws fails open, loudly, and never takes the pull down", async () => {
-  const io = fakeIo({
-    "board.taskComments": () => {
-      throw new Error("boom");
-    },
-  });
-  const c = classifyEvent(ev({ family: "board", kind: "item.commented", entity_id: "T-1", payload: { actor: THEM } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "task_comment" }, facts: facts(), io });
-  assert.equal(h.ok, false);
-  assert.equal(h.reason, "hydrate_threw");
-  assert.ok(io.logs.some((l) => l.level === "warn" && /hydrate board threw/.test(l.message)));
-});
-
-test("clip and renderThread are bounded", () => {
-  assert.equal(clip("abc", 10), "abc");
-  assert.ok(clip("x".repeat(100), 10).length <= 11);
-  assert.equal(renderThread([]), null);
-  assert.equal(renderThread(null), null);
-  assert.match(renderThread([{ authorName: "A", body: "hi" }]), /A: hi/);
-});
-
-// `messaging.history` returns DESCENDING; every comment source returns ASCENDING.
-// A bare slice(-limit) therefore took the OLDEST rows off a message page and
-// printed them backwards — the wrong window, in the wrong order.
-test("renderThread reads forwards and keeps the most RECENT turns", () => {
-  const rows = [];
-  for (let i = 12; i >= 1; i -= 1) {
-    rows.push({ authorName: "A", body: `turn ${i}`, createdAt: `2026-08-11T00:${String(i).padStart(2, "0")}:00.000Z` });
-  }
-  const out = renderThread(rows); // limit 8
-
-  assert.match(out, /turn 12/, "the newest turn is the one that matters most");
-  assert.doesNotMatch(out, /turn 1\b/, "the oldest turns fall off the window, not the newest");
-  assert.ok(out.indexOf("turn 5") < out.indexOf("turn 12"), "oldest first");
-});
-
-test("renderThread leaves undated rows in the order they arrived", () => {
-  const out = renderThread([
-    { authorName: "A", body: "first" },
-    { authorName: "B", body: "second" },
-  ]);
-  assert.ok(out.indexOf("first") < out.indexOf("second"));
-});
-
-// The `limit` window and the `max` CHARACTER budget are two different windows,
-// and only the first was covered: twelve short turns never reach 2000 chars, so
-// the clip never fired and the direction it clips in was never asserted. On the
-// real DM it fired immediately — one long reply filled the budget and the four
-// newest turns, including the question being answered, were the ones discarded.
-test("renderThread keeps the NEWEST turns when the CHARACTER budget binds", () => {
-  const out = renderThread(
-    [
-      { authorName: "A", body: "x".repeat(1500), createdAt: "2026-08-11T00:01:00.000Z" },
-      { authorName: "B", body: "the thing I actually asked", createdAt: "2026-08-11T00:02:00.000Z" },
-    ],
-    { max: 300 },
-  );
-  assert.match(out, /the thing I actually asked/, "the latest turn must survive the budget");
-});
-
-test("renderThread does not let one huge turn starve the turns around it", () => {
-  const out = renderThread(
-    [
-      { authorName: "A", body: "y".repeat(5000), createdAt: "2026-08-11T00:01:00.000Z" },
-      { authorName: "B", body: "second", createdAt: "2026-08-11T00:02:00.000Z" },
-      { authorName: "C", body: "third", createdAt: "2026-08-11T00:03:00.000Z" },
-    ],
-    { max: 2000 },
-  );
-  assert.match(out, /B: second/);
-  assert.match(out, /C: third/);
-  assert.ok(out.length <= 2100, `bounded, got ${out.length}`);
-});
-
-// Until hq's `authorName` denormalisation is deployed every row carries a bare
-// cuid, and the agent must still be able to see which turns are its own.
-test("a transcript labels my own turns even when the server sends no names", async () => {
-  const msgs = [
-    { id: "m1", authorId: ME, body: "already answered that", createdAt: "2026-08-11T14:00:00.000Z" },
-    { id: "m2", authorId: THEM, body: "and the other thing?", createdAt: "2026-08-11T15:00:00.000Z" },
-  ];
-  const f = facts({ myNames: ["Isla"] });
-  f.channels.set("C-dm", { id: "C-dm", kind: "DM" });
-  f.channelPages.set("C-dm", { byId: new Map(msgs.map((m) => [m.id, m])), messages: msgs });
-  const c = classifyEvent(ev({ family: "messaging", kind: "send", entity_id: "m2", payload: { actor: THEM, channelId: "C-dm", channelKind: "DM" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "dm", reason: "dm" }, facts: f, io: fakeIo({}) });
-
-  assert.match(h.threadContext, /Isla: already answered that/, "my own turn is mine, not a cuid");
-});
-
-test("event-kind phrasing is stable and total", () => {
-  assert.match(describeBoardKind("item.assigned"), /assigned to you/);
-  assert.match(describeBoardKind("who.knows"), /Update on your board item/);
-  assert.match(describeApprovalKind("approval.requested"), /waiting on you/);
-  assert.match(describeApprovalKind("approval.rejected"), /REJECTED/);
-});