@cohortapp/agent-sdk 2.9.1 → 2.10.0

package/scripts/daemon/deliver.test.mjs

@@ -0,0 +1,564 @@
+/**
+ * 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`,
+    );
+  }
+});

package/scripts/daemon/responder-history.test.mjs

@@ -76,6 +76,22 @@ test("cohort: an empty channel is null, not an empty transcript", async () => {
   assert.equal(text, null);
 });
 
+test("cohort: a roomless surface never asks messaging.history for its LABEL", async () => {
+  // A board / doc / decision item has a blank `channel_id` by design and its
+  // `channel` is the human label (`task/<title>`). This used to fall back to
+  // that label, so the history read asked hq for a channel named after a task
+  // title and got nothing — the same label-for-an-id substitution that had the
+  // REPLY posted to a task title. The entity's own thread already rides on the
+  // item as `thread_context`, so there is nothing to fetch here.
+  const seen = [];
+  const text = await loadConversationHistory(
+    { sender: "Dana Okafor", service: "cohort", kind: "task_comment", channel: "task/Roll out tier-3 guardrails", channel_id: "", content: "?" },
+    { fetchHistory: async (params) => { seen.push(params); return []; }, loadOrgConfig: () => ({}) },
+  );
+  assert.equal(seen.length, 0, "no history call may be made with a label");
+  assert.equal(text, null);
+});
+
 test("cohort: a failing history call degrades to null and never throws", async () => {
   const text = await loadConversationHistory(cohortItem, {
     fetchHistory: async () => { throw new Error("cohort unreachable"); },
@@ -132,7 +148,7 @@ test("cohort: falls back to the local mirror when the server is unreachable", as
   );
 
   const text = await loadConversationHistory(
-    { sender: "Dana Okafor", service: "cohort", channel: "chan-1", content: "?" },
+    { sender: "Dana Okafor", service: "cohort", channel: "chan-1", channel_id: "chan-1", content: "?" },
     {
       agentRepoDir: root,
       loadOrgConfig: () => ({}),
@@ -154,7 +170,7 @@ test("cohort: server history wins over the local mirror", async () => {
   );
 
   const text = await loadConversationHistory(
-    { sender: "Dana Okafor", service: "cohort", channel: "chan-1", content: "?" },
+    { sender: "Dana Okafor", service: "cohort", channel: "chan-1", channel_id: "chan-1", content: "?" },
     {
       agentRepoDir: root,
       loadOrgConfig: () => ({}),

package/scripts/daemon/responder.mjs

@@ -556,7 +556,13 @@ const COHORT_HISTORY_CHARS = 400;
  * Fails open to null on every path. No amount of history is worth failing a send.
  */
 async function loadCohortHistory(item, deps = {}) {
-  const channel = item.channel_id || item.channel || "";
+  // `channel_id` ONLY. `item.channel` is the display label (`task/<title>`,
+  // `doc/<name>`) and `messaging.history` wants a channel id — the same
+  // label-for-an-id substitution that had board replies posted to a task's
+  // title. A surface with no room simply has no channel history: the board /
+  // doc / decision hydrators already put the entity's OWN thread on the item as
+  // `thread_context`, so nothing is lost by not asking for a room's.
+  const channel = item.channel_id || "";
   if (!channel) return null;
 
   try {