@cohortapp/agent-sdk 2.5.1 → 2.6.1

package/scripts/daemon/assurance.test.mjs

@@ -0,0 +1,668 @@
+/**
+ * assurance.test.mjs — the four ways an ask used to end in silence, and the
+ * message the human now gets instead of each of them.
+ *
+ * Run: node --test scripts/daemon/assurance.test.mjs
+ *
+ * Every test here uses an INJECTED FAKE for transport. Nothing in this file
+ * touches Slack, Gmail, hq or the live workspace, and no test spawns a model.
+ * That is not only hygiene — it is the point being proven: the whole
+ * acknowledgement path is now deterministic string work, so a test can assert
+ * the exact words a human would read.
+ */
+
+import { test, describe, before, beforeEach, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Point the whole module tree at a scratch root BEFORE importing anything that
+// resolves AGENT_DIR at module load.
+const ROOT = mkdtempSync(join(tmpdir(), "assurance-test-"));
+process.env.AGENT_DIR = ROOT;
+process.env.AGENT_ROOT = ROOT;
+mkdirSync(join(ROOT, "state"), { recursive: true });
+
+const assurance = await import("./assurance.mjs");
+const receipts = await import("../../lib/comms/receipts.mjs");
+
+const {
+  shouldAcknowledge,
+  composeAck,
+  composeProgress,
+  composeFailure,
+  composeSilentSuccess,
+  classifyFailure,
+  openAndAcknowledge,
+  settleSession,
+  sweepObligations,
+  readObligation,
+  openObligations,
+  _resetObligations,
+  ACK_GRACE_MS,
+  PROGRESS_AFTER_MS,
+  PROGRESS_MAX,
+  STALE_AFTER_MS,
+  INTERRUPT_GRACE_MS,
+  ACK_MAX_ATTEMPTS,
+  RETRY_MAX,
+} = assurance;
+
+after(() => { try { rmSync(ROOT, { recursive: true, force: true }); } catch { /* */ } });
+
+// ---------------------------------------------------------------------------
+// Fakes
+// ---------------------------------------------------------------------------
+
+/** A transport that records what a human would have read, and can be told to fail. */
+function fakeTransport(opts = {}) {
+  const sent = [];
+  let failures = opts.failTimes || 0;
+  const impl = async (item, text, o = {}) => {
+    if (failures > 0) { failures--; return { sent: false, via: null, error: opts.error || "network unreachable" }; }
+    sent.push({ to: item.sender, channel: item.channel_id || item.channel, kind: o.kind || "reply", text });
+    return { sent: true, via: "fake", channel: item.channel_id || item.channel };
+  };
+  return { sent, impl, ackSender: async (item, cr) => {
+    const text = composeAck(item, cr);
+    const r = await impl(item, text, { kind: "ack" });
+    return { sent: r.sent, holdingText: text, error: r.error };
+  } };
+}
+
+const ITEM = {
+  id: "msg-1001",
+  raw_ref: "cohort:cmql18026:1001",
+  message_id: "1001",
+  service: "cohort",
+  channel_id: "cmql1802601iihhzpf774vwbk",
+  sender: "Dana Whitfield",
+  content: "with that in mind, fix these issues you just noted please and push their fixes to git",
+};
+
+const CLASS_COMPLEX = { action: "respond", priority: "critical", model: "opus", summary: "Fix the noted issues and push the fixes to git" };
+
+beforeEach(() => { _resetObligations(); });
+
+// ---------------------------------------------------------------------------
+// 1. THE JUDGEMENT — simple asks must NOT get "I'll look into it"
+// ---------------------------------------------------------------------------
+
+describe("shouldAcknowledge — the simple/complex distinction", () => {
+  test("a fast ask answered in this turn gets NO acknowledgement", () => {
+    // The quick path already sent the answer. An ack here is pure noise.
+    const v = shouldAcknowledge({ willSpawnSession: false, item: ITEM, source: "inbox" });
+    assert.equal(v.ack, false);
+    assert.equal(v.reason, "answered-in-turn");
+  });
+
+  test("a slow ask that spawns a session DOES get one", () => {
+    const v = shouldAcknowledge({ willSpawnSession: true, item: ITEM, source: "inbox" });
+    assert.equal(v.ack, true);
+  });
+
+  test("REGRESSION: a `queue` action still gets one", () => {
+    // classifier.mjs's heuristic fallback (used when the LLM classifier itself
+    // fails) emits action:"queue". The old gate was
+    // `respond || draft || research`, so exactly when classification degraded, a
+    // directed DM got a 45-minute session and total silence. The gate no longer
+    // consults the classifier at all.
+    const v = shouldAcknowledge({ willSpawnSession: true, item: ITEM, source: "inbox", classResult: { action: "queue" } });
+    assert.equal(v.ack, true, "a degraded classification must not cost the human their acknowledgement");
+  });
+
+  test("backlog work, which nobody is waiting on, gets none", () => {
+    assert.equal(shouldAcknowledge({ willSpawnSession: true, item: ITEM, source: "backlog" }).ack, false);
+  });
+
+  test("an item with no resolvable reply target gets none (nowhere to send it)", () => {
+    const orphan = { ...ITEM, channel_id: null, channel: null };
+    assert.equal(shouldAcknowledge({ willSpawnSession: true, item: orphan, source: "inbox" }).ack, false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 2. THE ACKNOWLEDGEMENT — composed, not generated
+// ---------------------------------------------------------------------------
+
+describe("composeAck", () => {
+  test("is instant and deterministic — no model, no I/O, no timeout to lose", () => {
+    const t0 = process.hrtime.bigint();
+    const a = composeAck(ITEM, CLASS_COMPLEX);
+    const elapsedMs = Number(process.hrtime.bigint() - t0) / 1e6;
+    assert.ok(elapsedMs < 5, `ack composition took ${elapsedMs}ms; it must be effectively free`);
+    assert.equal(a, composeAck(ITEM, CLASS_COMPLEX), "same input must give the same words");
+  });
+
+  test("names the actual ask and promises to come back either way", () => {
+    const a = composeAck(ITEM, CLASS_COMPLEX);
+    assert.match(a, /fix the noted issues and push the fixes to git/i);
+    assert.match(a, /either way/i, "the promise the rest of the system exists to keep");
+    assert.match(a, /10-20 minutes/, "an opus/critical item is honestly framed as slow");
+  });
+
+  test("degrades gracefully when the classifier gave nothing to go on", () => {
+    const a = composeAck(ITEM, {});
+    assert.ok(a.length > 40);
+    assert.match(a, /either way/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 3. FAILURE CLASSIFICATION — retry the transient, stop on the permanent
+// ---------------------------------------------------------------------------
+
+describe("classifyFailure", () => {
+  const cases = [
+    [{ code: 143, error: "SIGTERM" }, true, "timeout"],
+    [{ code: 137 }, true, "killed"],
+    [{ code: 1, error: "rate limit exceeded (429)" }, true, "rate_limited"],
+    [{ code: null, error: "claude CLI spawn error: ENOENT" }, false, "spawn_failed"],
+    [{ code: 1, error: "essential-only: daily budget cap reached" }, false, "budget_refused"],
+    [{ code: 1, error: "low free memory (need >=3686MB)" }, true, "resource_starved"],
+    [{ code: 0 }, false, "silent_success"],
+  ];
+  for (const [input, transient, label] of cases) {
+    test(`${label} → ${transient ? "retry" : "stop"}`, () => {
+      const f = classifyFailure(input);
+      assert.equal(f.label, label);
+      assert.equal(f.transient, transient);
+      assert.ok(f.human.length > 10, "every cause must have plain-English wording for the human");
+      assert.doesNotMatch(f.human, /error occurred|something went wrong/i, "no content-free apologies");
+    });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 4. THE LEDGER — a debt survives the send failing
+// ---------------------------------------------------------------------------
+
+describe("openAndAcknowledge", () => {
+  test("acknowledges and records the debt as acknowledged", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, service: "cohort", deps: { ackSender: t.ackSender } });
+    assert.equal(r.acked, true);
+    assert.equal(t.sent.length, 1);
+    assert.equal(t.sent[0].kind, "ack");
+    const rec = readObligation(r.key);
+    assert.equal(rec.acknowledged, true);
+    assert.equal(rec.state, "open", "the debt is acknowledged, not discharged — an ack is not an answer");
+  });
+
+  test("REGRESSION: a FAILED acknowledgement leaves an open debt instead of silence", async () => {
+    // This is the exact production case: 20 of 32 acknowledgements died and the
+    // old code did `logResponse(...); return {sent:false}` — the human was never
+    // told, and nothing ever retried.
+    const t = fakeTransport({ failTimes: 99, error: "claude CLI timed out after 60000ms" });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assert.equal(r.acked, false);
+    const rec = readObligation(r.key);
+    assert.equal(rec.acknowledged, false);
+    assert.equal(rec.state, "open");
+    assert.equal(openObligations().length, 1, "the debt must be visible to the sweep");
+  });
+
+  test("acknowledges ONCE — a re-delivered item does not re-announce itself", async () => {
+    const t = fakeTransport();
+    await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assert.equal(t.sent.length, 1, "do not spam");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 5. SESSION SETTLEMENT — the four terminal states
+// ---------------------------------------------------------------------------
+
+describe("settleSession", () => {
+  async function openOne(t) {
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    return r.key;
+  }
+
+  test("exit 0 AND the session spoke → discharge quietly, add nothing", async () => {
+    const t = fakeTransport();
+    const key = await openOne(t);
+    const before = t.sent.length;
+    const r = await settleSession({ key, ok: true, code: 0, deps: { deliverImpl: t.impl, spokeSinceImpl: () => true } });
+    assert.equal(r.verdict, "answered-by-session");
+    assert.equal(t.sent.length, before, "the human already has their answer — saying more is spam");
+    assert.equal(readObligation(key).state, "answered");
+  });
+
+  test("REGRESSION: exit 0 and the session said NOTHING → the daemon speaks", async () => {
+    // Observed live: session s-1786600074079-52, exit 0, 241s, $2.36, its own
+    // result text ending "Nothing was sent." Marked processed forever, emitted
+    // as `sent`, never re-delivered. This is that case.
+    const t = fakeTransport();
+    const key = await openOne(t);
+    const stdout = JSON.stringify({ type: "result", result: "I reviewed the three failing checks and pushed fixes for two. The third needs a decision from you. Nothing was sent." });
+    const r = await settleSession({ key, ok: true, code: 0, stdout, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    assert.equal(r.verdict, "silent-success");
+    assert.equal(r.spoke, true);
+    const msg = t.sent.at(-1).text;
+    assert.match(msg, /didn't get a reply out to you/i);
+    assert.match(msg, /pushed fixes for two/, "the work the session actually did must reach the human");
+    assert.equal(readObligation(key).state, "answered");
+  });
+
+  test("an acknowledgement does NOT count as the session having answered", async () => {
+    const t = fakeTransport();
+    const key = await openOne(t);
+    // A truthful receipt store that only ever saw the ack.
+    const spokeSinceImpl = ({ excludeKinds }) => !(excludeKinds || []).includes("ack") ;
+    const r = await settleSession({ key, ok: true, code: 0, stdout: "", deps: { deliverImpl: t.impl, spokeSinceImpl } });
+    assert.equal(r.verdict, "silent-success", "'I'm on it' is not an answer");
+  });
+
+  test("transient failure with retries left → tell them, keep the debt, retry", async () => {
+    const t = fakeTransport();
+    const key = await openOne(t);
+    const r = await settleSession({ key, ok: false, code: 143, error: "SIGTERM", deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    assert.equal(r.willRetry, true);
+    assert.match(r.verdict, /^retrying:timeout$/);
+    const msg = t.sent.at(-1).text;
+    assert.match(msg, /ran past its time limit/i);
+    assert.match(msg, /retrying it now/i);
+    assert.equal(readObligation(key).state, "open", "still owed — the retry has to be covered too");
+  });
+
+  test("permanent failure → tell them, stop, escalate durably", async () => {
+    const t = fakeTransport();
+    const key = await openOne(t);
+    const r = await settleSession({ key, ok: false, code: 1, error: "claude CLI spawn error: ENOENT", deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    assert.equal(r.willRetry, false);
+    assert.match(r.verdict, /^failed:spawn_failed$/);
+    const msg = t.sent.at(-1).text;
+    assert.match(msg, /couldn't get this done/i);
+    assert.match(msg, /stopped retrying/i);
+    assert.match(msg, /\?$/, "a dead end must end in a question, not a shrug");
+    assert.equal(readObligation(key).state, "failed");
+  });
+
+  test("retries are BOUNDED — the second timeout does not promise a third attempt", async () => {
+    const t = fakeTransport();
+    const key = await openOne(t);
+    // Simulate having already burned the allowed attempts.
+    const rec = readObligation(key);
+    rec.attempts = RETRY_MAX + 1;
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(key)}.json`), JSON.stringify(rec));
+    const r = await settleSession({ key, ok: false, code: 143, error: "SIGTERM", deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    assert.equal(r.willRetry, false, "an unbounded silent retry loop is itself the defect");
+    assert.match(t.sent.at(-1).text, /stopped retrying/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 6. THE SWEEP — the safety net under everything above
+// ---------------------------------------------------------------------------
+
+describe("sweepObligations", () => {
+  test("retries an acknowledgement whose send failed", async () => {
+    const failing = fakeTransport({ failTimes: 99 });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: failing.ackSender } });
+    assert.equal(r.acked, false);
+
+    const working = fakeTransport();
+    const now = Date.now() + ACK_GRACE_MS + 1000;
+    const stats = await sweepObligations({ now, deps: { deliverImpl: working.impl, spokeSinceImpl: () => false } });
+    assert.equal(stats.acked, 1);
+    assert.match(working.sent[0].text, /come back to you/i);
+    assert.equal(readObligation(r.key).acknowledged, true);
+  });
+
+  test("long work gets an interim update, not silence", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const now = Date.now() + PROGRESS_AFTER_MS + 1000;
+    const stats = await sweepObligations({ now, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    assert.equal(stats.progressed, 1);
+    const msg = t.sent.at(-1).text;
+    assert.match(msg, /still working/i);
+    assert.match(msg, /minutes in/i, "an interim update that omits how long it has been is not much of an update");
+  });
+
+  test("interim updates are CAPPED — attentive, not noisy", async () => {
+    const t = fakeTransport();
+    await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false };
+    let now = Date.now();
+    for (let i = 0; i < 10; i++) {
+      now += PROGRESS_AFTER_MS + 60_000 * 11;
+      if (now - Date.now() >= STALE_AFTER_MS) break;
+      await sweepObligations({ now, deps });
+    }
+    const progressCount = t.sent.filter((m) => m.kind === "progress").length;
+    assert.ok(progressCount <= PROGRESS_MAX, `sent ${progressCount} progress updates; cap is ${PROGRESS_MAX}`);
+  });
+
+  test("work that outruns every session timeout is declared dead, not left hanging", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const now = Date.now() + STALE_AFTER_MS + 1000;
+    const stats = await sweepObligations({ now, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    assert.equal(stats.staled, 1);
+    assert.match(t.sent.at(-1).text, /outrun its time limit/i);
+    assert.equal(readObligation(r.key).state, "failed");
+  });
+
+  test("a debt the session has since answered is discharged silently", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const before = t.sent.length;
+    const now = Date.now() + STALE_AFTER_MS + 1000;
+    const stats = await sweepObligations({ now, deps: { deliverImpl: t.impl, spokeSinceImpl: () => true } });
+    assert.equal(stats.closed, 1);
+    assert.equal(t.sent.length, before, "no message when the human already has their answer");
+    assert.equal(readObligation(r.key).state, "answered");
+  });
+
+  test("a debt orphaned by a DEAD daemon is spoken to", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    // Rewrite the record as if a now-dead process had opened it.
+    const rec = readObligation(r.key);
+    rec.daemonPid = process.pid + 99999;
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(r.key)}.json`), JSON.stringify(rec));
+
+    const stats = await sweepObligations({
+      now: Date.now() + INTERRUPT_GRACE_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false },
+    });
+    assert.equal(stats.interrupted, 1);
+    assert.match(t.sent.at(-1).text, /was interrupted before it finished/i);
+  });
+
+  test("REGRESSION: a LIVE daemon's obligation is never declared interrupted", async () => {
+    // Two daemons on one AGENT_DIR is what an operator creates the moment they
+    // run one by hand next to the launchd one. Each sees the other's healthy,
+    // actively-running debts as foreign. With only a pid-mismatch test — which
+    // is what shipped — both then tell those requesters "my session was
+    // interrupted" while the work runs to completion behind the apology.
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const rec = readObligation(r.key);
+    rec.daemonPid = process.pid + 99999;
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(r.key)}.json`), JSON.stringify(rec));
+
+    const before = t.sent.length;
+    const stats = await sweepObligations({
+      now: Date.now() + INTERRUPT_GRACE_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => true },
+    });
+    assert.equal(stats.interrupted, 0, "the owning daemon is alive — its work is not interrupted");
+    assert.equal(t.sent.length, before, "and nobody is told a lie about it");
+  });
+
+  test("REGRESSION: a FRESH obligation is never declared interrupted, dead pid or not", async () => {
+    // The age guard is the backstop for a recycled pid. One second after the ask
+    // arrived, no reading of the evidence supports "your session was interrupted".
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const rec = readObligation(r.key);
+    rec.daemonPid = process.pid + 99999;
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(r.key)}.json`), JSON.stringify(rec));
+
+    const stats = await sweepObligations({
+      now: Date.now() + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false },
+    });
+    assert.equal(stats.interrupted, 0);
+  });
+
+  test("each distinct message carries a distinct idempotency suffix", async () => {
+    // hq de-dups server-side on the client message id. Two progress updates that
+    // both key on "progress" are ONE message as far as hq is concerned, so the
+    // second would be silently swallowed — "never silent" degrading into
+    // "acknowledged once, then silent forever". This is invisible in any test
+    // that stubs transport without inspecting the options, hence this one.
+    const seen = [];
+    const impl = async (item, text, o = {}) => { seen.push(o.idempotencySuffix); return { sent: true, via: "fake", channel: "c" }; };
+    const t = fakeTransport();
+    await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+
+    const deps = { deliverImpl: impl, spokeSinceImpl: () => false };
+    await sweepObligations({ now: Date.now() + PROGRESS_AFTER_MS + 1000, deps });
+    await sweepObligations({ now: Date.now() + PROGRESS_AFTER_MS + 1000 + assurance.PROGRESS_EVERY_MS + 1000, deps });
+
+    assert.ok(seen.length >= 2, `expected two progress sends, saw ${seen.length}`);
+    assert.equal(new Set(seen).size, seen.length, `suffixes must be unique per message, got ${JSON.stringify(seen)}`);
+  });
+
+  test("emits at most ONE message per obligation per tick", async () => {
+    const t = fakeTransport({ failTimes: 1 }); // the ack fails
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assert.equal(r.acked, false);
+    const before = t.sent.length;
+    // Old enough to qualify for BOTH the ack retry and a progress update.
+    const now = Date.now() + PROGRESS_AFTER_MS + 1000;
+    await sweepObligations({ now, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    assert.equal(t.sent.length - before, 1, "two messages in one tick reads as a malfunction");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 7. RECEIPTS — the evidence the whole guarantee rests on
+// ---------------------------------------------------------------------------
+
+describe("delivery receipts", () => {
+  test("a recorded send is visible to a later spokeSince query", () => {
+    const now = Date.now();
+    receipts.recordOutbound({ service: "cohort", channel: "C-RECEIPT-1", kind: "reply", chars: 12, agentRoot: ROOT, now });
+    assert.equal(receipts.spokeSince({ channel: "C-RECEIPT-1", sinceMs: now - 1000, agentRoot: ROOT }), true);
+  });
+
+  test("acks and progress pings are excludable — they are not answers", () => {
+    const now = Date.now();
+    receipts.recordOutbound({ service: "cohort", channel: "C-RECEIPT-2", kind: "ack", agentRoot: ROOT, now });
+    receipts.recordOutbound({ service: "cohort", channel: "C-RECEIPT-2", kind: "progress", agentRoot: ROOT, now });
+    assert.equal(
+      receipts.spokeSince({ channel: "C-RECEIPT-2", sinceMs: now - 1000, excludeKinds: ["ack", "progress", "failure"], agentRoot: ROOT }),
+      false,
+    );
+  });
+
+  test("an unreadable ledger reads as 'the human heard nothing', never as 'fine'", () => {
+    // The fail-open direction is deliberate: the cost of guessing wrong this way
+    // is one redundant message; guessing the other way is the bug being fixed.
+    assert.equal(receipts.spokeSince({ channel: "never-used-channel", sinceMs: Date.now(), agentRoot: ROOT }), false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 7. ATTRIBUTION — a room is shared; a debt is not
+// ---------------------------------------------------------------------------
+
+describe("attribution: which debt did that message actually discharge", () => {
+  const mk = (id, content) => ({
+    id, raw_ref: `cohort:C-SHARED:${id}`, message_id: id, service: "cohort",
+    channel: "C-SHARED", channel_id: "C-SHARED", sender: "Dana Whitfield", content,
+  });
+
+  test("REGRESSION: one session's answer does NOT discharge a different ask in the same room", async () => {
+    // The owner sends two things a minute apart in one DM. Two debts, one room.
+    // Keyed on the room alone — which is what shipped — the first session's
+    // reply closed BOTH, and the second ask, which nobody answered, was recorded
+    // as "answered" with not one word sent about it. This is that scenario.
+    const t = fakeTransport();
+    const a = mk("ASK-A", "what's our runway?");
+    const b = mk("ASK-B", "also please fix the flaky poller test and push it");
+    const ra = await openAndAcknowledge({ item: a, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const rb = await openAndAcknowledge({ item: b, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assurance.noteSession(ra.key, "s-A");
+    assurance.noteSession(rb.key, "s-B");
+
+    // Session A answers, stamping the receipt with the debt it was spawned for.
+    receipts.recordOutbound({
+      service: "cohort", channel: "C-SHARED", kind: "session",
+      obligationKey: ra.key, sessionId: "s-A", agentRoot: ROOT,
+    });
+
+    const before = t.sent.length;
+    const settledA = await settleSession({ key: ra.key, ok: true, code: 0, deps: { deliverImpl: t.impl } });
+    assert.equal(settledA.verdict, "answered-by-session");
+    assert.equal(settledA.basis, "obligation-keyed");
+    assert.equal(t.sent.length, before, "A was answered — saying more would be spam");
+
+    // B exited 0 having said nothing. It must NOT ride on A's receipt.
+    const settledB = await settleSession({
+      key: rb.key, ok: true, code: 0,
+      stdout: JSON.stringify({ type: "result", result: "Could not reproduce the flake." }),
+      deps: { deliverImpl: t.impl },
+    });
+    assert.equal(settledB.verdict, "silent-success", "B was never answered and must be rescued");
+    assert.match(t.sent.at(-1).text, /didn't get a reply out to you/i);
+    assert.match(t.sent.at(-1).text, /Could not reproduce the flake/, "and B's actual work reaches the human");
+  });
+
+  test("an UNATTRIBUTED message in a room holding two open debts discharges neither", async () => {
+    const t = fakeTransport();
+    const a = mk("AMB-A", "first ask");
+    const b = mk("AMB-B", "second ask");
+    const ra = await openAndAcknowledge({ item: a, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    await openAndAcknowledge({ item: b, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assurance.noteSession(ra.key, "s-amb");
+    receipts.recordOutbound({ service: "cohort", channel: "C-SHARED", kind: "session", agentRoot: ROOT });
+
+    const r = await settleSession({ key: ra.key, ok: true, code: 0, stdout: "", deps: { deliverImpl: t.impl } });
+    assert.equal(r.verdict, "silent-success", "ambiguous evidence is not evidence");
+  });
+
+  test("an unattributed message DOES discharge the only open debt in a quiet room", async () => {
+    // The tolerant rung. A send lane that loses the dispatcher's env still leaves
+    // a receipt; treating that as silence would make every such reply produce a
+    // redundant apology. Safe only because the room holds one debt and a session
+    // of ours has actually run.
+    const t = fakeTransport();
+    const solo = { ...ITEM, id: "SOLO-1", raw_ref: "cohort:C-QUIET:SOLO-1", channel: "C-QUIET", channel_id: "C-QUIET" };
+    const r = await openAndAcknowledge({ item: solo, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assurance.noteSession(r.key, "s-solo");
+    receipts.recordOutbound({ service: "cohort", channel: "C-QUIET", kind: "session", agentRoot: ROOT });
+
+    const before = t.sent.length;
+    const settled = await settleSession({ key: r.key, ok: true, code: 0, deps: { deliverImpl: t.impl } });
+    assert.equal(settled.verdict, "answered-by-session");
+    assert.equal(settled.basis, "sole-debt-in-room");
+    assert.equal(t.sent.length, before);
+  });
+
+  test("REGRESSION: a message that arrives before any session of ours ran is not our answer", async () => {
+    // A debt whose acknowledgement failed, and something unrelated posts into the
+    // room. Closing on that leaves a human never acknowledged, never answered,
+    // and the debt recorded as discharged.
+    const t = fakeTransport({ failTimes: 1 });
+    const solo = { ...ITEM, id: "PRE-1", raw_ref: "cohort:C-PRE:PRE-1", channel: "C-PRE", channel_id: "C-PRE" };
+    const r = await openAndAcknowledge({ item: solo, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assert.equal(readObligation(r.key).acknowledged, false);
+    receipts.recordOutbound({ service: "cohort", channel: "C-PRE", kind: "reply", agentRoot: ROOT });
+
+    const stats = await sweepObligations({ now: Date.now() + ACK_GRACE_MS + 1000, deps: { deliverImpl: t.impl } });
+    assert.equal(stats.closed, 0, "no session of ours had run — that message was not our answer");
+    assert.equal(stats.acked, 1, "instead the missing acknowledgement is finally sent");
+    assert.match(t.sent.at(-1).text, /let me look into this|I'm on this now|let me dig into this/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 8. UNREACHABLE CHANNELS — an impossible send must not become a loop
+// ---------------------------------------------------------------------------
+
+describe("channels with no transport", () => {
+  const TELEGRAM = {
+    id: "TG-1", raw_ref: "telegram:12345:9", message_id: "TG-1",
+    service: "telegram", channel_id: "12345", sender: "Dana Whitfield",
+    content: "please redo the deck and send it over",
+  };
+
+  test("no acknowledgement is promised on a service we cannot write to", () => {
+    const v = shouldAcknowledge({ willSpawnSession: true, item: TELEGRAM, source: "inbox" });
+    assert.equal(v.ack, false);
+    assert.equal(v.reason, "no-transport");
+  });
+
+  test("REGRESSION: the debt is still opened, and the sweep escalates it ONCE instead of retrying forever", async () => {
+    // What shipped: the ack branch's `continue` sat above the stale branch, so an
+    // obligation whose send could never succeed was retried once per tick —
+    // 1,440 impossible sends a day, an immortal debt, and a human told nothing.
+    const t = fakeTransport();
+    const opened = await openAndAcknowledge({ item: TELEGRAM, classResult: CLASS_COMPLEX, ack: false });
+    assert.equal(opened.opened, true, "the debt exists even though we cannot speak to it");
+    assert.equal(readObligation(opened.key).deliverable, false);
+
+    let attempts = 0;
+    const counting = async (...a) => { attempts++; return t.impl(...a); };
+    const t0 = Date.now();
+    for (let m = 1; m <= 240; m++) {
+      await sweepObligations({ now: t0 + m * 60_000, deps: { deliverImpl: counting } });
+    }
+    assert.equal(attempts, 0, "not one impossible send is attempted");
+    const rec = readObligation(opened.key);
+    assert.equal(rec.state, "undeliverable", "the debt is resolved, not immortal");
+    assert.equal(openObligations().length, 0);
+  });
+
+  test("an acknowledgement that keeps failing is counted out and escalated", async () => {
+    const t = fakeTransport({ failTimes: 999 });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const t0 = Date.now();
+    let ticks = 0;
+    for (let m = 1; m <= 60; m++) {
+      const s = await sweepObligations({ now: t0 + m * 60_000, deps: { deliverImpl: t.impl } });
+      ticks++;
+      if (s.unreachable) break;
+    }
+    assert.ok(ticks <= ACK_MAX_ATTEMPTS + 2, `gave up after ${ticks} ticks, not forever`);
+    assert.equal(readObligation(r.key).state, "undeliverable");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 9. THE RETRY CLOCK — never contradict a message already sent
+// ---------------------------------------------------------------------------
+
+describe("a running retry is not declared dead", () => {
+  test("REGRESSION: 'I'm retrying it now' is not followed by 'I've stopped retrying' five minutes later", async () => {
+    // Attempt 1 is SIGTERMed at the dispatcher's 45-minute cap. STALE_AFTER_MS is
+    // 50 minutes and the clock used to run from the ORIGINAL arrival, so at
+    // minute 50 the sweep told the same human the exact opposite of what they had
+    // been told at minute 45 — while the retry was still running.
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assurance.noteSession(r.key, "s-1");
+    const t0 = readObligation(r.key).openedAt;
+
+    const settled = await settleSession({
+      key: r.key, ok: false, code: 143, error: "session_close exit 143",
+      now: t0 + 45 * 60_000, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false },
+    });
+    assert.equal(settled.willRetry, true);
+    assert.match(t.sent.at(-1).text, /retrying it now/i);
+
+    const stats = await sweepObligations({ now: t0 + 51 * 60_000, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    assert.equal(stats.staled, 0, "the retry is minutes old, not fifty");
+    assert.equal(readObligation(r.key).state, "open");
+    assert.doesNotMatch(t.sent.at(-1).text, /stopped retrying/i);
+  });
+
+  test("but a retry that itself goes nowhere DOES eventually stale out", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    assurance.noteSession(r.key, "s-1");
+    const t0 = readObligation(r.key).openedAt;
+    await settleSession({
+      key: r.key, ok: false, code: 143, error: "session_close exit 143",
+      now: t0 + 45 * 60_000, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false },
+    });
+    const stats = await sweepObligations({
+      now: t0 + 45 * 60_000 + STALE_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false },
+    });
+    assert.equal(stats.staled, 1, "the promise still has a floor under it");
+    assert.match(t.sent.at(-1).text, /outrun its time limit/i);
+  });
+});