@cohortapp/agent-sdk 2.17.0 → 2.18.4

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

@@ -1,908 +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,
-  priorComments,
-  isCommentKind,
-  htmlToText,
-  clampDocHtml,
-  DOC_HTML_MAX_CHARS,
-  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(),
-    visibleChannelIds: null,
-    channelPages: new Map(),
-    myEvents: null,
-    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/);
-});
-
-// ---------------------------------------------------------------------------
-// the slice(0,-1) guard — four surfaces used to lose their newest comment
-//
-// `renderThread(comments.slice(0,-1))` assumed the event was always a comment.
-// It is not: item.assigned, item.moved, file.shared and decision.signed are
-// events ABOUT an entity that HAS a thread, and for those the newest comment is
-// context, not the trigger. On a freshly assigned task with one comment, that
-// comment was the whole of the context and the agent saw none of it.
-// ---------------------------------------------------------------------------
-
-test("item.assigned KEEPS its newest comment — it is context, not the trigger", async () => {
-  const f = facts({ tasks: new Map([["T-1", { id: "T-1", title: "Ship the thing", col: "todo" }]]) });
-  const io = fakeIo({
-    "board.taskComments": () => okFrame({ comments: [{ id: "c1", authorName: "Casey", body: "the client needs this by Friday" }] }),
-  });
-  const c = classifyEvent(ev({ family: "board", kind: "item.assigned", entity_id: "T-1", payload: { actor: THEM, assignee: ME } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "task_assigned", reason: "assignee" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.threadContext, /Casey: the client needs this by Friday/);
-  assert.equal(h.isReply, true);
-});
-
-test("item.moved keeps its newest comment", async () => {
-  const f = facts({ tasks: new Map([["T-2", { id: "T-2", title: "Rework", col: "blocked" }]]) });
-  const io = fakeIo({
-    "board.taskComments": () => okFrame({ comments: [{ id: "c9", authorName: "Casey", body: "moving this back, the numbers are wrong" }] }),
-  });
-  const c = classifyEvent(ev({ family: "board", kind: "item.moved", entity_id: "T-2", payload: { actor: THEM } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "task_comment", reason: "assignee" }, facts: f, io });
-  assert.match(h.threadContext, /the numbers are wrong/);
-});
-
-test("file.shared keeps its newest comment", async () => {
-  const f = facts({ fileAcl: new Map([["F-1", { ownerId: ME, shared: true, name: "Q3 plan", kind: "DOC" }]]) });
-  const io = fakeIo({
-    "files.comments": () => okFrame({ comments: [{ id: "k1", authorName: "Casey", body: "read section two first" }] }),
-    "files.docRead": () => okFrame({ html: "<p>Q3 plan</p>" }),
-  });
-  const c = classifyEvent(ev({ family: "files", kind: "file.shared", entity_id: "F-1", payload: { actor: THEM, name: "Q3 plan" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "doc_comment", reason: "shared" }, facts: f, io });
-  assert.match(h.threadContext, /Casey: read section two first/);
-});
-
-test("decision.signed keeps its newest comment", async () => {
-  const f = facts({ decisions: new Map([["D-1", { id: "D-1", title: "Pick a vendor", status: "signed" }]]) });
-  const io = fakeIo({
-    "decision.listComments": () => okFrame({ comments: [{ id: "d1", authorName: "Casey", body: "signing on the understanding we revisit in Q4" }] }),
-  });
-  const c = classifyEvent(ev({ family: "decision", kind: "decision.signed", entity_id: "D-1", payload: { actor: THEM, signedBy: THEM } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "decision", reason: "voice" }, facts: f, io });
-  assert.match(h.threadContext, /revisit in Q4/);
-});
-
-test("a comment event still drops its OWN comment from the context", async () => {
-  const f = facts({ tasks: new Map([["T-3", { id: "T-3", title: "Ship it" }]]) });
-  const io = fakeIo({
-    "board.taskComments": () => okFrame({ comments: [
-      { id: "c1", authorName: "Isla", body: "first pass is up" },
-      { id: "c2", authorName: "Casey", body: "any update?" },
-    ] }),
-  });
-  const c = classifyEvent(ev({ family: "board", kind: "item.commented", entity_id: "T-3", payload: { actor: THEM } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "task_comment", reason: "assignee" }, facts: f, io });
-  assert.match(h.threadContext, /first pass is up/);
-  assert.doesNotMatch(h.threadContext, /any update\?/, "the trigger is not its own context");
-});
-
-test("the payload's commentId drops the RIGHT comment when a newer one raced in", async () => {
-  const f = facts({ tasks: new Map([["T-4", { id: "T-4", title: "Ship it" }]]) });
-  const io = fakeIo({
-    "board.taskComments": () => okFrame({ comments: [
-      { id: "c1", authorName: "Isla", body: "first pass is up" },
-      { id: "c2", authorName: "Casey", body: "the trigger comment" },
-      { id: "c3", authorName: "Dana", body: "landed while we were reading" },
-    ] }),
-  });
-  const c = classifyEvent(ev({ family: "board", kind: "item.commented", entity_id: "T-4", payload: { actor: THEM, commentId: "c2" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "task_comment", reason: "assignee" }, facts: f, io });
-  assert.match(h.threadContext, /first pass is up/);
-  assert.match(h.threadContext, /landed while we were reading/);
-  assert.doesNotMatch(h.threadContext, /the trigger comment/);
-});
-
-// ---------------------------------------------------------------------------
-// pure guards
-// ---------------------------------------------------------------------------
-
-test("priorComments never mutates the caller's array", () => {
-  const rows = [{ id: "a" }, { id: "b" }];
-  const out = priorComments(rows, { kind: "item.commented" });
-  assert.equal(rows.length, 2);
-  assert.equal(out.length, 1);
-});
-
-test("isCommentKind knows the six kinds that ARE comments", () => {
-  for (const k of ["item.commented", "board.commented", "file.commented", "doc.comment", "decision.comment", "decision.adjustment_requested"]) {
-    assert.equal(isCommentKind(k), true, k);
-  }
-  for (const k of ["item.assigned", "item.moved", "file.shared", "decision.signed", "", null]) {
-    assert.equal(isCommentKind(k), false, String(k));
-  }
-});
-
-test("htmlToText keeps the prose and drops the markup", () => {
-  assert.equal(htmlToText("<h1>Title</h1><p>One &amp; two</p><p>Three</p>"), "Title\nOne & two\nThree");
-  assert.equal(htmlToText("<script>bad()</script><p>ok</p>"), "ok");
-  assert.equal(htmlToText(null), "");
-});
-
-// ---------------------------------------------------------------------------
-// call — participants, the room, and the transcript
-// ---------------------------------------------------------------------------
-
-test("a call carries the roster, the room's recent messages and the transcript", async () => {
-  const msgs = [
-    { id: "m1", authorId: THEM, authorName: "Casey", body: "can we talk through the pricing", createdAt: "2026-08-11T09:00:00.000Z" },
-    { id: "m2", authorId: ME, authorName: "Isla", body: "yes — starting a huddle", createdAt: "2026-08-11T09:01:00.000Z" },
-  ];
-  const f = facts({ visibleChannelIds: new Set(["C-eng"]) });
-  f.channels.set("C-eng", { id: "C-eng", kind: "PUBLIC", name: "engineering" });
-  f.channelPages.set("C-eng", { byId: new Map(msgs.map((m) => [m.id, m])), messages: msgs });
-  const io = fakeIo({
-    "calling.getDetails": () => okFrame({ callId: "CALL-1", live: true, participantCount: 2, participants: [
-      { kind: "MEMBER", memberId: THEM, inCall: true },
-      { kind: "GUEST", contactId: "contact-9", inCall: true },
-    ] }),
-    "calling.getTranscript": () => okFrame({ lines: [
-      { id: "l1", memberName: "Casey", text: "the list price is wrong on tier two", at: "2026-08-11T09:02:00.000Z" },
-    ] }),
-  });
-  const c = classifyEvent(ev({ family: "calling", kind: "start", entity_id: "CALL-1", payload: { actor: THEM, channelId: "C-eng", topic: "pricing" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "call", reason: "member" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /Call invite: pricing/);
-  assert.match(h.text, new RegExp(`In the call: ${THEM}, contact-9`));
-  assert.match(h.threadContext, /Casey: can we talk through the pricing/);
-  assert.match(h.threadContext, /Call transcript so far:/);
-  assert.match(h.threadContext, /the list price is wrong on tier two/);
-  assert.equal(io.calls.filter((k) => k.method === "messaging.history").length, 0, "the page was already in hand");
-});
-
-test("a call whose probes all fail still hydrates — fail-open, never blank", async () => {
-  const f = facts({ visibleChannelIds: new Set(["C-eng"]) });
-  f.channels.set("C-eng", { id: "C-eng", kind: "PUBLIC", name: "engineering" });
-  const io = fakeIo({}); // every method NOT_FOUND
-  const c = classifyEvent(ev({ family: "calling", kind: "start", entity_id: "CALL-2", payload: { actor: THEM, channelId: "C-eng", topic: "standup" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "call", reason: "member" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /Call invite: standup/);
-  assert.equal(h.threadContext, null);
-});
-
-test("a call in a room outside my roster is never paged for history", async () => {
-  const f = facts({ visibleChannelIds: new Set(["C-mine"]) });
-  const io = fakeIo({ "calling.getDetails": () => okFrame({ participants: [] }) });
-  const c = classifyEvent(ev({ family: "calling", kind: "start", entity_id: "CALL-3", payload: { actor: THEM, channelId: "C-not-mine", topic: "x" } }));
-  await hydrate({ candidate: c, verdict: { surface: "call", reason: "invited" }, facts: f, io });
-  assert.equal(io.calls.some((k) => k.method === "messaging.history"), false, "a room outside the roster must never be touched");
-});
-
-test("an UNREADABLE roster is not permission — no room is paged when visibleChannelIds is null", async () => {
-  // The guard read `visible instanceof Set && !visible.has(id)`, so the null
-  // case — the roster call failed, or has not run — fell straight through into
-  // `messaging.history` on a channel id that arrived on the EVENT PAYLOAD.
-  // facts.mjs enforces the opposite (`if (!visible) … return`) and this file's
-  // own docstring claimed it; now the code does too.
-  const f = facts({ visibleChannelIds: null });
-  const io = fakeIo({ "calling.getDetails": () => okFrame({ participants: [] }) });
-  const c = classifyEvent(ev({ family: "calling", kind: "start", entity_id: "CALL-4", payload: { actor: THEM, channelId: "C-PRIVATE-NOT-MINE", topic: "x" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "call", reason: "invited" }, facts: f, io });
-  assert.equal(h.ok, true, "declining a read is not a failed hydration");
-  assert.equal(
-    io.calls.some((k) => k.method === "messaging.history"),
-    false,
-    "an unknown roster must decline, not page an arbitrary payload-supplied channel",
-  );
-});
-
-test("an UNREADABLE roster is not permission — pinned files are not listed either", async () => {
-  const f = facts({ visibleChannelIds: null });
-  f.channels.set("C-PRIVATE-NOT-MINE", { id: "C-PRIVATE-NOT-MINE", kind: "PRIVATE", name: "board" });
-  const io = fakeIo({ "file.listComments": () => okFrame({ comments: [
-    { id: "fc1", authorId: THEM, authorName: "Casey", body: "@Isla thoughts?" },
-  ] }) });
-  const c = classifyEvent(ev({
-    family: "file", kind: "comment", entity_id: "FK-1",
-    payload: { actor: THEM, channelId: "C-PRIVATE-NOT-MINE", fileKey: "FK-1", body: "@Isla thoughts?", mentions: [ME] },
-  }));
-  await hydrate({ candidate: c, verdict: { surface: "chatFile", reason: "mention" }, facts: f, io });
-  assert.equal(io.calls.some((k) => k.method === "file.listPinned"), false);
-});
-
-// ---------------------------------------------------------------------------
-// approval / escalation / handoff / calendar
-// ---------------------------------------------------------------------------
-
-test("an approval carries the thread of the item it is an approval OF", async () => {
-  const f = facts({
-    approvals: new Map([["A-1", { id: "A-1", status: "pending", requester: THEM, actionClass: "financial", itemId: "T-9" }]]),
-    tasks: new Map([["T-9", { id: "T-9", title: "Wire the retainer", col: "doing", priority: 1 }]]),
-  });
-  const io = fakeIo({
-    "board.taskComments": () => okFrame({ comments: [
-      { id: "c1", authorName: "Casey", body: "legal cleared this on Tuesday" },
-    ] }),
-  });
-  const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-1", payload: { actor: THEM, requester: THEM, itemId: "T-9", actionClass: "financial" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "approval", reason: "approver" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /Board item "Wire the retainer" — doing · priority 1/);
-  assert.match(h.threadContext, /legal cleared this on Tuesday/);
-});
-
-test("an approval on a DECISION falls back to the decision thread, and only then", async () => {
-  const f = facts({ approvals: new Map([["A-2", { id: "A-2", status: "pending", requester: THEM, itemId: "D-7" }]]) });
-  const io = fakeIo({
-    "decision.listComments": () => okFrame({ comments: [{ id: "c1", authorName: "Casey", body: "we ruled out the cheaper vendor" }] }),
-  });
-  const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-2", payload: { actor: THEM, requester: THEM, itemId: "D-7" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "approval", reason: "approver" }, facts: f, io });
-
-  assert.match(h.threadContext, /we ruled out the cheaper vendor/);
-  assert.equal(io.calls.filter((k) => k.method === "board.taskComments").length, 1, "board is tried first, once");
-});
-
-test("an approval whose board thread is EMPTY does not pay for a second probe", async () => {
-  const f = facts({ approvals: new Map([["A-3", { id: "A-3", status: "pending", requester: THEM, itemId: "T-8" }]]) });
-  const io = fakeIo({ "board.taskComments": () => okFrame({ comments: [] }) });
-  const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-3", payload: { actor: THEM, requester: THEM, itemId: "T-8" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "approval", reason: "approver" }, facts: f, io });
-
-  assert.equal(h.threadContext, null);
-  assert.equal(io.calls.some((k) => k.method === "decision.listComments"), false, "an empty thread is an answer, not a refusal");
-});
-
-test("an escalation carries the escalated task's row and its comments", async () => {
-  const f = facts({
-    escalations: new Map([["E-1", { id: "E-1", title: "Blocked on credentials", severity: "high", taskId: "T-5" }]]),
-    tasks: new Map([["T-5", { id: "T-5", title: "Migrate the vault", col: "blocked", priority: 0 }]]),
-  });
-  const io = fakeIo({
-    "board.taskComments": () => okFrame({ comments: [{ id: "c1", authorName: "Casey", body: "the rotation script needs an admin key" }] }),
-  });
-  const c = classifyEvent(ev({ family: "escalation", kind: "escalation.created", entity_id: "E-1", payload: { actor: THEM, taskId: "T-5", severity: "high" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "escalation", reason: "assignee" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /Board item "Migrate the vault" — blocked · priority 0/);
-  assert.match(h.threadContext, /needs an admin key/);
-});
-
-test("an escalation whose task thread is unreadable still hydrates", async () => {
-  const f = facts({ escalations: new Map([["E-2", { id: "E-2", title: "Stuck", severity: "low", taskId: "T-6" }]]) });
-  const io = fakeIo({});
-  const c = classifyEvent(ev({ family: "escalation", kind: "escalation.created", entity_id: "E-2", payload: { actor: THEM, taskId: "T-6" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "escalation", reason: "assignee" }, facts: f, io });
-  assert.equal(h.ok, true);
-  assert.equal(h.threadContext, null);
-});
-
-test("a handoff carries the originating task's thread", async () => {
-  const f = facts({ tasks: new Map([["T-7", { id: "T-7", title: "Draft the board pack", col: "doing", detail: "for Thursday" }]]) });
-  const io = fakeIo({
-    "board.taskComments": () => okFrame({ comments: [
-      { id: "c1", authorName: "Casey", body: "sections 1-3 are done, 4 needs the latest numbers" },
-    ] }),
-  });
-  const c = classifyEvent(ev({ family: "handoff", kind: "handoff.offered", entity_id: "R-1", payload: { actor: THEM, to: ME, from: THEM, itemId: "T-7", intent: "take over section 4" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "handoff", reason: "named" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /Intent: take over section 4/);
-  assert.match(h.text, /Board item "Draft the board pack" — doing/);
-  assert.match(h.threadContext, /4 needs the latest numbers/);
-});
-
-test("a calendar event carries the room it was agreed in and earlier occurrences", async () => {
-  const msgs = [{ id: "m1", authorId: THEM, authorName: "Casey", body: "let's move the weekly to Thursdays", createdAt: "2026-08-10T09:00:00.000Z" }];
-  const f = facts({
-    visibleChannelIds: new Set(["C-ops"]),
-    myEvents: new Map([
-      ["E-now", { id: "E-now", title: "Ops weekly", startsAt: "2026-08-13T09:00:00.000Z", channelId: "C-ops" }],
-      ["E-old", { id: "E-old", title: "Ops weekly", startsAt: "2026-08-06T09:00:00.000Z", location: "Room 2" }],
-      ["E-other", { id: "E-other", title: "Board review", startsAt: "2026-08-05T09:00:00.000Z" }],
-    ]),
-  });
-  f.channels.set("C-ops", { id: "C-ops", kind: "PUBLIC", name: "ops" });
-  f.channelPages.set("C-ops", { byId: new Map(msgs.map((m) => [m.id, m])), messages: msgs });
-  const io = fakeIo({});
-  const c = classifyEvent(ev({ family: "calendar", kind: "event.rescheduled", entity_id: "E-now", payload: { actor: THEM, channelId: "C-ops", title: "Ops weekly" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "calendar", reason: "attendee" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.threadContext, /move the weekly to Thursdays/);
-  assert.match(h.threadContext, /Earlier in this series:/);
-  assert.match(h.threadContext, /2026-08-06T09:00:00.000Z · Room 2/);
-  assert.doesNotMatch(h.threadContext, /Board review/, "a different meeting is not this series");
-});
-
-test("a calendar event with no room and no series carries no invented context", async () => {
-  const f = facts({ myEvents: new Map([["E-1", { id: "E-1", title: "1:1", startsAt: "2026-08-13T09:00:00.000Z" }]]) });
-  const io = fakeIo({});
-  const c = classifyEvent(ev({ family: "calendar", kind: "event.created", entity_id: "E-1", payload: { actor: THEM, calendarMemberId: ME, title: "1:1" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "calendar", reason: "owner" }, facts: f, io });
-  assert.equal(h.ok, true);
-  assert.equal(h.threadContext, null);
-  assert.equal(io.calls.length, 0);
-});
-
-// ---------------------------------------------------------------------------
-// artifact bodies — the agent must have READ the thing it is commenting on
-// ---------------------------------------------------------------------------
-
-test("a doc comment carries the document body, bounded", async () => {
-  const f = facts({ fileAcl: new Map([["F-2", { ownerId: ME, shared: true, name: "Pricing memo", kind: "DOC" }]]) });
-  const io = fakeIo({
-    "files.comments": () => okFrame({ comments: [{ id: "k1", authorName: "Casey", body: "is the tier-two number right?" }] }),
-    "files.docRead": () => okFrame({ html: `<h1>Pricing memo</h1><p>Tier two is ${"$"}4,800 per seat.</p>` }),
-  });
-  const c = classifyEvent(ev({ family: "files", kind: "doc.comment", entity_id: "F-2", payload: { actor: THEM, name: "Pricing memo", commentId: "k1" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "doc_comment", reason: "owner" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /Document:/);
-  assert.match(h.text, /Tier two is \$4,800 per seat\./);
-  assert.match(h.text, /is the tier-two number right\?/);
-  assert.doesNotMatch(h.text, /<p>/, "markup must not reach the model");
-});
-
-test("a doc body that is too long is clipped, and the comment still survives", async () => {
-  const f = facts({ fileAcl: new Map([["F-3", { ownerId: ME, shared: true, name: "Long", kind: "DOC" }]]) });
-  const io = fakeIo({
-    "files.comments": () => okFrame({ comments: [{ id: "k1", authorName: "Casey", body: "THE QUESTION" }] }),
-    "files.docRead": () => okFrame({ html: `<p>${"w".repeat(20000)}</p>` }),
-  });
-  const c = classifyEvent(ev({ family: "files", kind: "doc.comment", entity_id: "F-3", payload: { actor: THEM, commentId: "k1" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "doc_comment", reason: "owner" }, facts: f, io });
-
-  assert.ok(h.text.length < 6000, `doc body was not bounded (${h.text.length} chars)`);
-  assert.match(h.text, /THE QUESTION/, "the comment being answered must survive the doc body");
-});
-
-test("clampDocHtml bounds what a pull holds and converts", () => {
-  // files.docRead has no `limit` on the wire (ui-parity documents `{ fileId }`),
-  // so the only place this can be bounded is the instant it lands — before
-  // htmlToText walks it and before the per-pull cache keeps it. Measured before
-  // the clamp: 8 MB of HTML → 7,435,349 characters converted to retain 4,000.
-  assert.equal(clampDocHtml("<p>short</p>"), "<p>short</p>");
-  assert.equal(clampDocHtml("x".repeat(DOC_HTML_MAX_CHARS + 10)).length, DOC_HTML_MAX_CHARS);
-  assert.equal(clampDocHtml(null), "");
-  assert.ok(DOC_HTML_MAX_CHARS > 4000, "the clamp must leave room for a full text budget after markup");
-});
-
-test("a HUGE doc is clamped before it is converted, and never exceeds the shared ceiling", async () => {
-  // Two separate bounds, and the second one used to be missing entirely.
-  //   1. the raw HTML is sliced the instant it lands, so an 8 MB document does
-  //      not walk 7.4 M characters through htmlToText to retain 4,000;
-  //   2. the JOINED text is clipped like every other surface's — hydrateDoc had
-  //      dropped its outer clip(), making it the one hydrator that could hand
-  //      `item.content` more than the shared clamp allows.
-  // The name is unbounded on the wire (it rides `c.ids.name` / the ACL row), so
-  // it is the part that proves the OUTER clip is doing work rather than sitting
-  // above a ceiling the parts can never reach.
-  const f = facts({ fileAcl: new Map([["F-BIG", { ownerId: ME, shared: true, name: "N".repeat(50_000), kind: "DOC" }]]) });
-  const huge = `<p>${"w".repeat(2_000_000)}</p>`;
-  const io = fakeIo({
-    "files.comments": () => okFrame({ comments: [{ id: "k1", authorName: "Casey", body: "z".repeat(9000) }] }),
-    "files.docRead": () => okFrame({ html: huge }),
-  });
-  const c = classifyEvent(ev({ family: "files", kind: "doc.comment", entity_id: "F-BIG", payload: { actor: THEM, commentId: "k1" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "doc_comment", reason: "owner" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.ok(h.text.length <= 5601, `hydrateDoc must honour its declared ceiling (${h.text.length} chars)`);
-});
-
-test("a SHEET is never asked for a doc body — hq would only refuse", async () => {
-  const f = facts({ fileAcl: new Map([["F-4", { ownerId: ME, shared: true, name: "Model", kind: "SHEET" }]]) });
-  const io = fakeIo({ "files.comments": () => okFrame({ comments: [{ id: "k1", authorName: "Casey", body: "row 12?" }] }) });
-  const c = classifyEvent(ev({ family: "files", kind: "doc.comment", entity_id: "F-4", payload: { actor: THEM, commentId: "k1" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "doc_comment", reason: "owner" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.equal(io.calls.some((k) => k.method === "files.docRead"), false);
-});
-
-test("an unreadable doc body leaves the comment thread intact", async () => {
-  const f = facts({ fileAcl: new Map([["F-5", { ownerId: ME, shared: true, name: "Memo", kind: "DOC" }]]) });
-  const io = fakeIo({ "files.comments": () => okFrame({ comments: [{ id: "k1", authorName: "Casey", body: "thoughts?" }] }) });
-  const c = classifyEvent(ev({ family: "files", kind: "doc.comment", entity_id: "F-5", payload: { actor: THEM, commentId: "k1" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "doc_comment", reason: "owner" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /thoughts\?/);
-  assert.doesNotMatch(h.text, /Document:/);
-});
-
-test("a file comment names the file — type and size, not just an opaque key", async () => {
-  const f = facts({ visibleChannelIds: new Set(["C-eng"]) });
-  f.channels.set("C-eng", { id: "C-eng", kind: "PUBLIC", name: "engineering" });
-  const io = fakeIo({
-    "file.listComments": () => okFrame({ comments: [{ id: "fc1", authorName: "Casey", body: "page 3 is stale" }] }),
-    "file.listPinned": () => okFrame({ files: [
-      { id: "pf1", fileKey: "fk-1", name: "q3-forecast.pdf", mimeType: "application/pdf", sizeBytes: 1258291 },
-    ] }),
-  });
-  const c = classifyEvent(ev({ family: "file", kind: "file.commented", entity_id: "fc1", payload: { actor: THEM, fileKey: "fk-1", channelId: "C-eng" } }));
-  const h = await hydrate({ candidate: c, verdict: { surface: "file_comment", reason: "member" }, facts: f, io });
-
-  assert.equal(h.ok, true);
-  assert.match(h.text, /Comment on file q3-forecast\.pdf/);
-  assert.match(h.text, /File: q3-forecast\.pdf · application\/pdf · 1\.2 MB/);
-  assert.match(h.text, /page 3 is stale/);
-  assert.equal(h.subjectDetail, "q3-forecast.pdf");
-});
-
-test("a file in a room outside my roster is never asked about", async () => {
-  const f = facts({ visibleChannelIds: new Set(["C-mine"]) });
-  const io = fakeIo({ "file.listComments": () => okFrame({ comments: [{ id: "fc1", authorName: "Casey", body: "x" }] }) });
-  const c = classifyEvent(ev({ family: "file", kind: "file.commented", entity_id: "fc1", payload: { actor: THEM, fileKey: "fk-2", channelId: "C-not-mine" } }));
-  await hydrate({ candidate: c, verdict: { surface: "file_comment", reason: "member" }, facts: f, io });
-  assert.equal(io.calls.some((k) => k.method === "file.listPinned"), false);
-});
-
-test("two comments on files in ONE room share a single listPinned read", async () => {
-  const f = facts({ visibleChannelIds: new Set(["C-eng"]) });
-  const io = fakeIo({
-    "file.listComments": () => okFrame({ comments: [{ id: "fc1", authorName: "Casey", body: "x" }] }),
-    "file.listPinned": () => okFrame({ files: [] }),
-  });
-  const cache = new Map();
-  for (const key of ["fk-a", "fk-b"]) {
-    const c = classifyEvent(ev({ family: "file", kind: "file.commented", entity_id: `c-${key}`, payload: { actor: THEM, fileKey: key, channelId: "C-eng" } }));
-    await hydrate({ candidate: c, verdict: { surface: "file_comment", reason: "member" }, facts: f, io, cache });
-  }
-  assert.equal(io.calls.filter((k) => k.method === "file.listPinned").length, 1);
-});