@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/scripts/daemon/deliver.test.mjs

@@ -1,564 +0,0 @@
-/**
- * deliver.test.mjs — node:test coverage for the Cohort reply CHOKEPOINT.
- *
- * These pin the `task/<title>` regression: a board comment used to be answered
- * by calling `messaging.send({channel: "task/Roll out tier-3 guardrails…"})`,
- * because `sendCohortReply` fell back to `item.channel` — the human LABEL —
- * when the surface had no room. hq resolved that to nothing, threw NOT_FOUND,
- * and the daemon retried the impossible send three times a sweep forever.
- *
- * What is pinned here:
- *   1. a board item routes to board.addTaskComment with the REAL task id;
- *   2. a room item still routes to messaging.send, unchanged;
- *   3. an unaddressable item (approval) fails explicitly and PERMANENTLY;
- *   4. no route, on any surface, is ever derived from `item.channel`.
- *
- * Hermetic: the transport is stubbed at both seams (`callImpl` for entity
- * threads, `sendMessageImpl` for rooms), the send-gate is stubbed, and
- * AGENT_DIR is pointed at a scratch dir BEFORE the module loads so the receipt
- * writer never touches the real agent state.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// Must be set before the module is evaluated — AGENT_REPO_DIR is a load-time
-// constant and it is where receipts land.
-const SCRATCH = mkdtempSync(join(tmpdir(), "deliver-test-"));
-process.env.AGENT_DIR = SCRATCH;
-process.on("exit", () => { try { rmSync(SCRATCH, { recursive: true, force: true }); } catch { /* best effort */ } });
-
-const {
-  deliver,
-  deliverWithRetry,
-  cohortReplyRoute,
-  cohortSurfaceOf,
-  replyTargetOf,
-  canDeliverTo,
-} = await import("./deliver.mjs");
-
-// ---------------------------------------------------------------------------
-// Fixtures — the real on-disk shapes, taken from live inbox items.
-// ---------------------------------------------------------------------------
-
-/** A board comment. Note `channel_id` is blank and `channel` is a TITLE. */
-const TASK_ITEM = Object.freeze({
-  service: "cohort",
-  kind: "task_comment",
-  channel: "task/Roll out tier-3 guardrails to agents with financial-action scopes",
-  channel_id: "",
-  thread_id: "cmrlw2l3600e9hh8n10hprdrd",
-  scope_id: "cmrlw2l3600e9hh8n10hprdrd",
-  raw_ref: "cohort:task_comment:cmrlw2l3600e9hh8n10hprdrd:25029",
-  id: "25029",
-});
-
-/** An ordinary room message. */
-const DM_ITEM = Object.freeze({
-  service: "cohort",
-  channel: "#eng",
-  channel_id: "cmql1802601iihhzpf774vwbk",
-  thread_id: "",
-  raw_ref: "cohort:dm:cmsnbgwsz003flj014spp4i1z:812",
-  id: "cmsnbgwsz003flj014spp4i1z",
-});
-
-/** An approval — a verdict surface, with no prose thread to write into. */
-const APPROVAL_ITEM = Object.freeze({
-  service: "cohort",
-  kind: "approval",
-  channel: "approval/journey",
-  channel_id: "",
-  thread_id: "aprv_journey_msopegu4",
-  scope_id: "cmrlw2l3600e9hh8n10hprdrd",
-  raw_ref: "cohort:approval:aprv_journey_msopegu4:13546",
-  id: "13546",
-});
-
-const OK_GATE = () => ({ allow: true });
-const CFG = { org: { cohort: { enabled: true, base: "https://hq.example", token: "t" } } };
-
-/** A stubbed org RPC that records what it was asked to do. */
-function recordingCall(frame = { ok: true, result: { id: "c1" } }) {
-  const calls = [];
-  const fn = async (method, params, o) => { calls.push({ method, params, o }); return frame; };
-  fn.calls = calls;
-  return fn;
-}
-
-/** A stubbed messaging.send. */
-function recordingSend(frame = { ok: true, result: { id: "m1" } }) {
-  const calls = [];
-  const fn = async (params, o) => { calls.push({ params, o }); return frame; };
-  fn.calls = calls;
-  return fn;
-}
-
-/**
- * Both seams at once, so "did it use the OTHER transport" is always assertable.
- *
- * `ledgerImpl: null` is the documented opt-out in `lib/org/messaging.mjs` —
- * a delivered entity comment now writes a cost-attribution row, and a unit test
- * must not put one on disk.
- */
-function seams(o = {}) {
-  const callImpl = recordingCall(o.callFrame);
-  const sendMessageImpl = recordingSend(o.sendFrame);
-  return { callImpl, sendMessageImpl, gateImpl: OK_GATE, cfg: CFG, ledgerImpl: null };
-}
-
-// ---------------------------------------------------------------------------
-// (1) A board item is answered ON THE BOARD.
-// ---------------------------------------------------------------------------
-
-test("task_comment routes to board.addTaskComment with the real task id", async () => {
-  const s = seams();
-  const r = await deliver(TASK_ITEM, "On it — the guardrail rollout is unblocked.", { kind: "reply", ...s });
-
-  assert.equal(r.sent, true, `expected sent, got ${JSON.stringify(r)}`);
-  assert.equal(r.via, "board.addTaskComment");
-  assert.equal(r.channel, "task:cmrlw2l3600e9hh8n10hprdrd");
-
-  assert.equal(s.sendMessageImpl.calls.length, 0, "a board comment must NOT go through messaging.send");
-  assert.equal(s.callImpl.calls.length, 1);
-  const [c] = s.callImpl.calls;
-  assert.equal(c.method, "board.addTaskComment");
-  // `kind:"agent"`, not "human": hq renders a "human" task comment as the
-  // VIEWER'S OWN bubble with no AI avatar (`components/board/task-conversation
-  // .tsx`), so the daemon's reply used to arrive looking like something the
-  // reading human had written themselves.
-  assert.deepEqual(c.params, {
-    taskId: "cmrlw2l3600e9hh8n10hprdrd",
-    kind: "agent",
-    body: "On it — the guardrail rollout is unblocked.",
-  });
-  // The whole point: the TITLE never reaches the wire.
-  assert.ok(!JSON.stringify(c.params).includes("task/"), "the channel label leaked into the RPC params");
-});
-
-test("the ACK path benefits too — one chokepoint, so deliverWithRetry lands on the board as well", async () => {
-  const s = seams();
-  const r = await deliverWithRetry(TASK_ITEM, "On it — looking now.", { kind: "ack", ...s, sleep: async () => {} });
-  assert.equal(r.sent, true);
-  assert.equal(r.attempts, 1);
-  assert.equal(s.callImpl.calls.length, 1);
-  assert.equal(s.callImpl.calls[0].method, "board.addTaskComment");
-  assert.equal(s.callImpl.calls[0].params.taskId, "cmrlw2l3600e9hh8n10hprdrd");
-  // The ack and the eventual answer must not collide on hq's dedup.
-  assert.equal(s.callImpl.calls[0].o.idempotencyKey, "reply-25029-ack");
-});
-
-test("task_assigned routes to the board too, and prefers the id over any label", () => {
-  const route = cohortReplyRoute({ ...TASK_ITEM, kind: "task_assigned", raw_ref: "cohort:task_assigned:T-9:1", scope_id: "T-9", thread_id: "T-9" });
-  assert.equal(route.transport, "rpc");
-  assert.equal(route.method, "board.addTaskComment");
-  assert.equal(route.params.taskId, "T-9");
-});
-
-test("doc_comment routes to files.commentAdd; decision routes to decision.comment (param `text`, not `body`)", async () => {
-  const doc = { service: "cohort", kind: "file_comment", channel: "doc/CHARTER.pdf", channel_id: "", thread_id: "cmsu0pbez00m7lx01u6mbqk9g", scope_id: "cmsu0pbez00m7lx01u6mbqk9g", raw_ref: "cohort:doc_comment:cmsu0pbez00m7lx01u6mbqk9g:27088" };
-  const s1 = seams();
-  const r1 = await deliver(doc, "Section 3 reads fine to me.", { ...s1 });
-  assert.equal(r1.sent, true);
-  assert.equal(s1.callImpl.calls[0].method, "files.commentAdd");
-  assert.deepEqual(s1.callImpl.calls[0].params, { fileId: "cmsu0pbez00m7lx01u6mbqk9g", body: "Section 3 reads fine to me." });
-
-  const dec = { service: "cohort", kind: "decision", channel: "decision/Adopt tier-3", channel_id: "", thread_id: "D-1", scope_id: "D-1", raw_ref: "cohort:decision:D-1:9" };
-  const s2 = seams();
-  const r2 = await deliver(dec, "Signed.", { ...s2 });
-  assert.equal(r2.sent, true);
-  assert.equal(s2.callImpl.calls[0].method, "decision.comment");
-  assert.deepEqual(s2.callImpl.calls[0].params, { decisionId: "D-1", text: "Signed." });
-});
-
-// ---------------------------------------------------------------------------
-// (2) A room item is unchanged.
-// ---------------------------------------------------------------------------
-
-test("a normal channel item still routes to messaging.send, unchanged", async () => {
-  const s = seams();
-  const r = await deliver(DM_ITEM, "hello", { kind: "reply", ...s });
-
-  assert.equal(r.sent, true);
-  assert.equal(r.via, "cohort");
-  assert.equal(r.channel, "cmql1802601iihhzpf774vwbk");
-
-  assert.equal(s.callImpl.calls.length, 0, "a room message must NOT go through an entity comment method");
-  assert.equal(s.sendMessageImpl.calls.length, 1);
-  const [c] = s.sendMessageImpl.calls;
-  assert.equal(c.params.channel, "cmql1802601iihhzpf774vwbk");
-  assert.equal(c.params.body, "hello");
-  assert.equal(c.params.idempotencyId, "reply-cmsnbgwsz003flj014spp4i1z");
-});
-
-test("ack and reply on the same room item get distinct idempotency ids", async () => {
-  const s = seams();
-  await deliver(DM_ITEM, "on it", { kind: "ack", ...s });
-  await deliver(DM_ITEM, "here you go", { kind: "reply", ...s });
-  assert.deepEqual(
-    s.sendMessageImpl.calls.map((c) => c.params.idempotencyId),
-    ["reply-cmsnbgwsz003flj014spp4i1z-ack", "reply-cmsnbgwsz003flj014spp4i1z"],
-  );
-});
-
-test("a room surface with no channel_id is undeliverable — it does not fall back to the label", async () => {
-  const orphan = { ...DM_ITEM, channel_id: "" };
-  assert.equal(replyTargetOf(orphan), null);
-  assert.equal(canDeliverTo(orphan), false);
-  const s = seams();
-  const r = await deliver(orphan, "hello", { ...s });
-  assert.equal(r.sent, false);
-  assert.equal(r.permanent, true);
-  assert.equal(s.sendMessageImpl.calls.length, 0);
-  assert.equal(s.callImpl.calls.length, 0);
-});
-
-// ---------------------------------------------------------------------------
-// (3) An unaddressable item fails loudly, and does not retry.
-// ---------------------------------------------------------------------------
-
-test("an approval produces an explicit, permanent error naming the surface and the reason", async () => {
-  const s = seams();
-  const r = await deliver(APPROVAL_ITEM, "Approved.", { kind: "ack", ...s });
-
-  assert.equal(r.sent, false);
-  assert.equal(r.permanent, true, "an unroutable item must be permanent, or the sweep retries it forever");
-  assert.equal(r.surface, "approval");
-  assert.match(r.error, /cannot address a reply to approval item cohort:approval:aprv_journey_msopegu4:13546/);
-  assert.match(r.error, /approval\.resolve/);
-  assert.equal(s.callImpl.calls.length, 0);
-  assert.equal(s.sendMessageImpl.calls.length, 0);
-});
-
-test("assurance's pre-flight predicates refuse an approval instead of promising", () => {
-  assert.equal(replyTargetOf(APPROVAL_ITEM), null);
-  assert.equal(canDeliverTo(APPROVAL_ITEM), false);
-  // …and still say yes to the surfaces that DO have a route.
-  assert.equal(replyTargetOf(TASK_ITEM), "task:cmrlw2l3600e9hh8n10hprdrd");
-  assert.equal(canDeliverTo(TASK_ITEM), true);
-  assert.equal(replyTargetOf(DM_ITEM), "cmql1802601iihhzpf774vwbk");
-  assert.equal(canDeliverTo(DM_ITEM), true);
-});
-
-test("deliverWithRetry stops after ONE attempt on an unroutable item", async () => {
-  const s = seams();
-  let slept = 0;
-  const r = await deliverWithRetry(APPROVAL_ITEM, "Approved.", { kind: "ack", ...s, sleep: async () => { slept++; } });
-  assert.equal(r.sent, false);
-  assert.equal(r.attempts, 1, "the old code logged attempts:3 against an impossible send");
-  assert.equal(slept, 0);
-});
-
-test("a NOT_FOUND from hq is permanent — it is not retried three times", async () => {
-  const s = seams({ callFrame: { ok: false, error: { code: "NOT_FOUND", message: "no such task T-gone" } } });
-  let slept = 0;
-  const r = await deliverWithRetry({ ...TASK_ITEM, scope_id: "T-gone", thread_id: "T-gone" }, "hi", { ...s, sleep: async () => { slept++; } });
-  assert.equal(r.sent, false);
-  assert.equal(r.permanent, true);
-  assert.equal(r.code, "NOT_FOUND");
-  assert.equal(r.attempts, 1);
-  assert.equal(slept, 0);
-  assert.equal(s.callImpl.calls.length, 1);
-});
-
-test("a transient failure IS still retried", async () => {
-  const s = seams({ callFrame: { ok: false, error: { code: "INTERNAL", message: "hq restarting" } } });
-  let slept = 0;
-  const r = await deliverWithRetry(TASK_ITEM, "hi", { ...s, attempts: 3, sleep: async () => { slept++; } });
-  assert.equal(r.sent, false);
-  assert.equal(r.attempts, 3);
-  assert.equal(slept, 2);
-  assert.equal(s.callImpl.calls.length, 3);
-});
-
-// ---------------------------------------------------------------------------
-// (4) The send-gate still guards the new lane, and it fails CLOSED.
-// ---------------------------------------------------------------------------
-
-test("the send-gate screens board comments too, and a block never reaches the wire", async () => {
-  const s = { ...seams(), gateImpl: async () => ({ allow: false, reason: "banned phrase" }) };
-  const r = await deliver(TASK_ITEM, "guaranteed returns", { ...s });
-  assert.equal(r.sent, false);
-  assert.equal(r.permanent, true);
-  assert.match(r.error, /FORBIDDEN_SCOPE: banned phrase/);
-  assert.equal(s.callImpl.calls.length, 0, "a blocked message must never reach the RPC");
-});
-
-test("a send-gate fault fails CLOSED on the entity lane", async () => {
-  const s = { ...seams(), gateImpl: async () => { throw new Error("policy file unreadable"); } };
-  const r = await deliver(TASK_ITEM, "hi", { ...s });
-  assert.equal(r.sent, false);
-  assert.equal(s.callImpl.calls.length, 0);
-  assert.match(r.error, /send-gate error/);
-});
-
-test("the gate screens the ROUTABLE target, never the label", async () => {
-  const seen = [];
-  const s = { ...seams(), gateImpl: async (a) => { seen.push(a.recipient); return { allow: true }; } };
-  await deliver(TASK_ITEM, "hi", { ...s });
-  assert.deepEqual(seen, ["task:cmrlw2l3600e9hh8n10hprdrd"]);
-});
-
-// ---------------------------------------------------------------------------
-// Surface resolution
-// ---------------------------------------------------------------------------
-
-test("cohortSurfaceOf reads raw_ref, and tolerates the LEGACY cohort:<channelId>:<msgId> shape", () => {
-  assert.equal(cohortSurfaceOf(TASK_ITEM), "task_comment");
-  assert.equal(cohortSurfaceOf(APPROVAL_ITEM), "approval");
-  // Legacy raw_ref: the middle segment is a channel id, not a surface name.
-  assert.equal(cohortSurfaceOf({ raw_ref: "cohort:cmql1802601iihhzpf774vwbk:cmsnbgwsz003flj014spp4i1z", channel_id: "cmql1802601iihhzpf774vwbk" }), "dm");
-  // An all-lowercase legacy channel id must NOT be mistaken for a surface.
-  assert.equal(cohortSurfaceOf({ raw_ref: "cohort:abcdef:xyz", channel_id: "abcdef" }), "dm");
-  // `file_comment` is the kind of TWO surfaces; the room tells them apart.
-  assert.equal(cohortSurfaceOf({ kind: "file_comment", channel_id: "C-1" }), "file_comment");
-  assert.equal(cohortSurfaceOf({ kind: "file_comment", channel_id: "" }), "doc_comment");
-});
-
-test("a chat-attached file comment routes to file.addComment with fileKey + its room", () => {
-  const route = cohortReplyRoute({ service: "cohort", kind: "file_comment", channel: "#eng", channel_id: "C-9", thread_id: "fk_abc", raw_ref: "cohort:file_comment:cmt-1:3" });
-  assert.equal(route.method, "file.addComment");
-  assert.deepEqual(route.params, { fileKey: "fk_abc", channelId: "C-9" });
-});
-
-test("handoff and email are named as unaddressable rather than guessed into a channel", () => {
-  const h = cohortReplyRoute({ service: "cohort", kind: "handoff", channel: "handoff/Ship it", channel_id: "", thread_id: "run-1", raw_ref: "cohort:handoff:run-1:4" });
-  assert.equal(h.transport, null);
-  assert.match(h.error, /handoff\.accept\/decline/);
-  // `channel_id` on the email surface is a MAILBOX id — messaging.send would
-  // reject it exactly as it rejected a task title.
-  const e = cohortReplyRoute({ service: "cohort", kind: "email", channel: "email", channel_id: "MB-1", thread_id: "th-1", raw_ref: "cohort:email:e-1:2" });
-  assert.equal(e.transport, null);
-  assert.match(e.error, /mailbox id, not a channel/);
-});
-
-test("escalation and calendar use their own room when hq attached one, and refuse when it did not", () => {
-  const bound = cohortReplyRoute({ service: "cohort", kind: "escalation", channel: "escalation/DB down", channel_id: "C-7", thread_id: "esc-1", raw_ref: "cohort:escalation:esc-1:1" });
-  assert.equal(bound.transport, "channel");
-  assert.equal(bound.target, "C-7");
-  const loose = cohortReplyRoute({ service: "cohort", kind: "escalation", channel: "escalation/DB down", channel_id: "", thread_id: "esc-1", raw_ref: "cohort:escalation:esc-1:1" });
-  assert.equal(loose.transport, null);
-  assert.match(loose.error, /no comment surface/);
-});
-
-test("no route on any surface is ever derived from item.channel", () => {
-  const surfaces = [
-    "dm", "mention", "thread_reply", "call", "task_assigned", "task_comment",
-    "file_comment", "doc_comment", "approval", "decision", "escalation",
-    "calendar", "handoff", "email",
-  ];
-  for (const surface of surfaces) {
-    const item = { service: "cohort", channel: `${surface}/A LABEL`, channel_id: "", thread_id: "", scope_id: "", raw_ref: `cohort:${surface}:E-1:1` };
-    const route = cohortReplyRoute(item);
-    const blob = JSON.stringify(route);
-    assert.ok(!blob.includes("A LABEL"), `${surface}: the label leaked into the route (${blob})`);
-    assert.notEqual(replyTargetOf(item), item.channel, `${surface}: replyTargetOf returned the label`);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Non-cohort services are untouched.
-// ---------------------------------------------------------------------------
-
-test("slack and gmail targeting is unchanged", () => {
-  assert.equal(replyTargetOf({ service: "slack", channel: "D099N1JGKRQ" }), "D099N1JGKRQ");
-  assert.equal(replyTargetOf({ service: "slack", raw_ref: "slack:D099N1JGKRQ:1775331885.690669" }), "D099N1JGKRQ");
-  assert.equal(replyTargetOf({ service: "gmail", sender_email: "a@b.com", sender: "A B" }), "a@b.com");
-  assert.equal(canDeliverTo({ service: "telegram", channel_id: "12345", channel: "dm/casey" }), false);
-});
-
-// ---------------------------------------------------------------------------
-// (5) THE REAL SEND-GATE. Every test above stubs it, and that is exactly how a
-//     lane that was blocked 100% of the time shipped with 21 green tests: the
-//     routing table reached the right method with the right params, and the
-//     gate in front of it refused every one of them before the wire.
-//
-//     `screenOutbound` defaults `firstContact` to TRUE, and under the shipped
-//     `disclose-always` posture that blocks any message which does not
-//     proactively disclose AI. The room lane passes `false`; the entity lane
-//     did not pass it at all. FORBIDDEN_SCOPE is permanent, so the reply was
-//     dropped on the first attempt — a different error string for the same
-//     "the board never hears from us".
-//
-//     These run the module's OWN screenOutbound against a real policy file on
-//     disk. Nothing is stubbed but the wire.
-// ---------------------------------------------------------------------------
-
-import { mkdirSync, writeFileSync } from "node:fs";
-
-/** An agent root with the shipped `disclose-always` posture on disk. */
-function policyRoot() {
-  const root = mkdtempSync(join(tmpdir(), "deliver-policies-"));
-  mkdirSync(join(root, "policies"), { recursive: true });
-  // The SHIPPED shape (isla-ai policies/ai-disclosure.yaml), not a shorthand:
-  // `posture` is a MAP of posture-name → config and `default_posture` selects
-  // one. A bare `posture: disclose-always` scalar resolves to an EMPTY posture
-  // object, `proactive_disclosure` is undefined, and the disclosure screen
-  // silently never fires — which would make this whole section vacuous.
-  writeFileSync(
-    join(root, "policies", "ai-disclosure.yaml"),
-    [
-      "version: 1",
-      "invariant:",
-      "  answer_truthfully_if_asked: true",
-      "posture:",
-      "  disclose-always:",
-      "    proactive_disclosure: true",
-      "    machine_readable_marking: true",
-      "default_posture: disclose-always",
-      "jurisdictions:",
-      "  default:",
-      "    posture: disclose-always",
-      "",
-    ].join("\n"),
-    "utf8",
-  );
-  writeFileSync(join(root, "policies", "information-barriers.yaml"), "walls: []\n", "utf8");
-  return root;
-}
-
-test("REAL GATE: a board comment reaches the wire — the entity lane is not first contact", async () => {
-  const agentRoot = policyRoot();
-  const callImpl = recordingCall();
-  const r = await deliver(TASK_ITEM, "The guardrail rollout is unblocked — moving it to review.", {
-    kind: "reply", callImpl, cfg: CFG, agentRoot, ledgerImpl: null,
-  });
-
-  assert.equal(r.sent, true, `the real gate blocked the entity lane: ${JSON.stringify(r)}`);
-  assert.equal(r.via, "board.addTaskComment");
-  assert.equal(callImpl.calls.length, 1, "nothing reached the wire");
-  assert.equal(callImpl.calls[0].method, "board.addTaskComment");
-});
-
-test("REAL GATE: doc and decision replies reach the wire too", async () => {
-  const agentRoot = policyRoot();
-  for (const [item, method] of [
-    [{ service: "cohort", kind: "file_comment", channel: "doc/CHARTER.pdf", channel_id: "", thread_id: "cmsu0pbez00m7lx01u6mbqk9g", scope_id: "cmsu0pbez00m7lx01u6mbqk9g", raw_ref: "cohort:doc_comment:cmsu0pbez00m7lx01u6mbqk9g:27088" }, "files.commentAdd"],
-    [{ service: "cohort", kind: "decision", channel: "decision/Adopt tier-3", channel_id: "", thread_id: "cmdec0000000000000000000", scope_id: "cmdec0000000000000000000", raw_ref: "cohort:decision:cmdec0000000000000000000:9" }, "decision.comment"],
-  ]) {
-    const callImpl = recordingCall();
-    const r = await deliver(item, "Section 3 reads fine to me.", { callImpl, cfg: CFG, agentRoot, ledgerImpl: null });
-    assert.equal(r.sent, true, `${method} blocked by the real gate: ${JSON.stringify(r)}`);
-    assert.equal(callImpl.calls[0].method, method);
-  }
-});
-
-test("REAL GATE: the room lane is unchanged — same policies, same text, still sends", async () => {
-  const agentRoot = policyRoot();
-  const sendMessageImpl = recordingSend();
-  const r = await deliver(DM_ITEM, "The guardrail rollout is unblocked.", {
-    sendMessageImpl, cfg: CFG, agentRoot, ledgerImpl: null,
-  });
-  assert.equal(r.sent, true, `the room lane regressed: ${JSON.stringify(r)}`);
-  assert.equal(sendMessageImpl.calls.length, 1);
-});
-
-test("REAL GATE: the entity target classifies INTERNAL, so a policy fault does not fail closed", async () => {
-  // An agentRoot with NO policies/ at all — the "unreadable required policy"
-  // case. It gags an EXTERNAL recipient and must not gag a board thread.
-  const bare = mkdtempSync(join(tmpdir(), "deliver-nopolicy-"));
-  const callImpl = recordingCall();
-  const r = await deliver(TASK_ITEM, "Moving it to review.", { callImpl, cfg: CFG, agentRoot: bare, ledgerImpl: null });
-  assert.equal(r.sent, true, `board lane failed closed on a policy fault: ${JSON.stringify(r)}`);
-  assert.equal(callImpl.calls.length, 1);
-});
-
-test("REAL GATE: banned prose is still refused on the entity lane", async () => {
-  // The gate must still be a gate — this is the half the stub was proving.
-  const agentRoot = policyRoot();
-  const callImpl = recordingCall();
-  const r = await deliver(TASK_ITEM, "Certainly! I guarantee returns on this rollout.", {
-    callImpl, cfg: CFG, agentRoot, ledgerImpl: null,
-  });
-  assert.equal(r.sent, false);
-  assert.equal(callImpl.calls.length, 0, "banned prose reached the wire");
-});
-
-// ---------------------------------------------------------------------------
-// (6) The author kind, and its one fallback.
-// ---------------------------------------------------------------------------
-
-test("an unassigned task falls back to the acting member rather than losing the reply", async () => {
-  // hq's board/addTaskComment.ts refuses `kind:"agent"` when the task has no
-  // assignee AND no reviewer. That is a different request, not a flaky one, so
-  // it is re-asked once — not retried.
-  let n = 0;
-  const calls = [];
-  const callImpl = async (method, params, o) => {
-    calls.push(params);
-    n += 1;
-    return n === 1
-      ? { ok: false, error: { code: "BAD_REQUEST", message: "this task has no responsible agent to reply" } }
-      : { ok: true, result: { id: "c1" } };
-  };
-  const r = await deliver(TASK_ITEM, "Picking this up.", { callImpl, gateImpl: OK_GATE, cfg: CFG, ledgerImpl: null });
-  assert.equal(r.sent, true, `the fallback did not fire: ${JSON.stringify(r)}`);
-  assert.deepEqual(calls.map((c) => c.kind), ["agent", "human"]);
-});
-
-test("an UNRELATED BAD_REQUEST is still permanent — the fallback is not a blanket retry", async () => {
-  const s = seams({ callFrame: { ok: false, error: { code: "BAD_REQUEST", message: "body must be a string" } } });
-  const r = await deliverWithRetry(TASK_ITEM, "hi", { ...s, sleep: async () => {} });
-  assert.equal(r.sent, false);
-  assert.equal(r.permanent, true);
-  assert.equal(r.attempts, 1);
-  assert.equal(s.callImpl.calls.length, 1, "an unrelated BAD_REQUEST must not be re-asked");
-});
-
-test("a 401 is TRANSIENT — a token rotation must not throw the reply away", async () => {
-  // UNAUTHORIZED describes the credential at one instant, not the request.
-  const s = seams({ callFrame: { ok: false, error: { code: "UNAUTHORIZED", message: "token expired" } } });
-  let slept = 0;
-  const r = await deliverWithRetry(TASK_ITEM, "hi", { ...s, attempts: 3, sleep: async () => { slept++; } });
-  assert.equal(r.sent, false);
-  assert.equal(r.permanent, undefined);
-  assert.equal(r.attempts, 3);
-  assert.equal(slept, 2);
-});
-
-// ---------------------------------------------------------------------------
-// (7) hq must be able to DEDUPE the retry the line above just re-enabled.
-// ---------------------------------------------------------------------------
-
-test("the entity comment methods are declared idempotent, so a retry cannot double-post", async () => {
-  // hq replays a stored result ONLY for `def.idempotent === true`
-  // (server/rpc/dispatch.ts); without the flag the `x-idempotency-key` this
-  // lane sends is ignored and a timeout-after-commit posts the comment twice.
-  const { methodDef } = await import("../../lib/org/protocol.mjs");
-  for (const m of ["board.addTaskComment", "files.commentAdd", "decision.comment", "file.addComment"]) {
-    assert.equal(methodDef(m).idempotent, true, `${m} is retried but not idempotent`);
-  }
-  // …and the lane actually sends a key.
-  const s = seams();
-  await deliver(TASK_ITEM, "hi", { ...s });
-  assert.equal(s.callImpl.calls[0].o.idempotencyKey, "reply-25029");
-});
-
-// ---------------------------------------------------------------------------
-// (8) The assurance sweep must route the SAME item the live path did.
-// ---------------------------------------------------------------------------
-
-test("the sweep's item snapshot routes IDENTICALLY to the live item", async () => {
-  // `itemSnapshot` persisted channel/channel_id/thread_id/raw_ref but NOT
-  // `scope_id` — which `cohortReplyRoute` names FIRST for every roomless
-  // surface. The sweep re-delivers from the snapshot, so it was routing a
-  // different item than the live path. Masked only by every hydrator happening
-  // to set thread_id too.
-  const { itemSnapshot } = await import("./assurance.mjs");
-  for (const live of [
-    TASK_ITEM,
-    APPROVAL_ITEM,
-    DM_ITEM,
-    // The unmasked case: an id in scope_id and nowhere else.
-    { service: "cohort", kind: "decision", channel: "decision/x", channel_id: "", thread_id: "", scope_id: "cmdec0000000000000000000", raw_ref: "" },
-  ]) {
-    assert.deepEqual(
-      cohortReplyRoute(itemSnapshot(live)),
-      cohortReplyRoute(live),
-      `the sweep routes ${live.kind} differently from the live path`,
-    );
-  }
-});