@cohortapp/agent-sdk 2.15.0 → 2.17.0

package/scripts/daemon/assurance.test.mjs

@@ -31,7 +31,6 @@ const {
   shouldAcknowledge,
   generateAck,
   sanitiseAckText,
-  composeProgress,
   composeFailure,
   composeSilentSuccess,
   isOwnNarratorText,
@@ -43,9 +42,11 @@ const {
   readObligation,
   openObligations,
   _resetObligations,
-  ACK_GRACE_MS,
-  PROGRESS_AFTER_MS,
-  PROGRESS_MAX,
+  ACK_AFTER_MS,
+  ACK_MIN_CHARS,
+  RETIRED_NARRATOR_TEMPLATES,
+  notePlan,
+  NOTICE,
   STALE_AFTER_MS,
   INTERRUPT_GRACE_MS,
   ACK_MAX_ATTEMPTS,
@@ -244,10 +245,14 @@ describe("shouldAcknowledge — the dispatch gate reads item.content", () => {
   });
 
   test("REGRESSION: the daemon's OWN narrator lines are refused — built from the real compose* strings, so the list cannot drift", () => {
-    const rec = { openedAt: Date.now() - 6 * 60_000, progressSent: 0 };
     const narrations = [
-      composeProgress(rec, {}),                                                          // "Still on this — N minutes in. …"
-      composeProgress({ ...rec, progressSent: 1 }, {}),                                  // "Still going — N minutes in. …"
+      // The two RETIRED progress lines. Nothing composes them any more, but an
+      // older seat on the same fleet still emits them until its autoupdate
+      // lands, and acking a peer's progress ping spawns a 45-minute session
+      // behind it — the 25/27/30 Aug loop.
+      ...RETIRED_NARRATOR_TEMPLATES,
+      "Still on this — 7 minutes in. I'll come back as soon as I've got something.",
+      "Still going — 22 minutes in. I'll follow up the moment it's done.",
       composeFailure({}, { failure: { human: "the working session ended unexpectedly" }, willRetry: true }),
       composeFailure({}, { failure: { human: "the work never came back with a result and has now outrun its time limit" }, willRetry: false }),
       assurance.composeInterrupted(),
@@ -424,23 +429,44 @@ describe("classifyFailure", () => {
 // ---------------------------------------------------------------------------
 
 describe("openAndAcknowledge", () => {
-  test("acknowledges and records the debt as acknowledged", async () => {
+  test("POLICY: opening a debt says NOTHING — the interim belongs to the sweep", async () => {
+    // 3,069 opening acknowledgements in fourteen days were exactly this call
+    // speaking at t=0. The record is still written first (a crash between here
+    // and the session's first token must leave a debt the sweep finds); what is
+    // gone is the reflex in front of it.
     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 r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, service: "cohort", tier: "work", deps: { ackSender: t.ackSender } });
+    assert.equal(t.sent.length, 0, "not one byte at open time");
+    assert.equal(r.acked, false);
+    assert.equal(r.ackText, null);
+    assert.equal(r.reason, "tier-work-deferred");
     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");
+    assert.equal(rec.state, "open", "the debt is open and owed");
+    assert.equal(rec.tier, "work");
+    assert.equal(rec.interimSaid, false, "and the one-interim latch is still unspent");
   });
 
-  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.
+  test("the answer tier opens the debt and forbids any interim, ever", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "answer", ack: false, deps: { ackSender: t.ackSender } });
+    assert.equal(t.sent.length, 0);
+    const rec = readObligation(r.key);
+    assert.equal(rec.interimForbidden, true, "durable on the record — the sweep runs in another tick, maybe another process");
+    const after = await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 60_000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    assert.equal(after.acked, 0);
+    assert.equal(t.sent.length, 0, "the answer tier is silence, at open and at every sweep after it");
+  });
+
+  test("REGRESSION: an un-acknowledged debt is still visible to the sweep", async () => {
+    // The original 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. Nothing is sent at open time any more, so
+    // what this now pins is the half that still matters: the debt exists.
     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 } });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work", deps: { ackSender: t.ackSender } });
     assert.equal(r.acked, false);
     const rec = readObligation(r.key);
     assert.equal(rec.acknowledged, false);
@@ -448,32 +474,20 @@ describe("openAndAcknowledge", () => {
     assert.equal(openObligations().length, 1, "the debt must be visible to the sweep");
   });
 
-  test("REGRESSION: generation failure at open ⇒ NOTHING is sent, and the debt records why", async () => {
-    // sendHoldingMessage's new contract on a failed generation: {sent:false,
-    // holdingText:null, genFailed:true}. Silence — never a placeholder.
-    const t = fakeTransport({ genFail: true });
-    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
-    assert.equal(r.acked, false);
-    assert.equal(r.ackText, null, "no text was composed — there is nothing canned to fall back to");
+  test("REGRESSION: a generation failure in the interim branch sends NOTHING and records why", async () => {
+    // The ack generator's contract on failure is silence, never a placeholder.
+    // The branch moved from open time to the sweep; the contract did not.
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => null },
+    });
     assert.equal(t.sent.length, 0, "not one byte reached the human");
     const rec = readObligation(r.key);
     assert.equal(rec.acknowledged, false);
-    assert.equal(rec.ackGenFailures, 1, "the failure is counted, so the sweep's retry is bounded");
-    assert.equal(rec.state, "open", "the debt survives — progress/failure notices still owe the human");
-  });
-
-  test("the DEFAULT ack path generates before sending — generation failure short-circuits transport entirely", async () => {
-    // No injected ackSender here: this drives openAndAcknowledge's own default,
-    // which must consult generateAck FIRST and never touch transport on null.
-    const r = await openAndAcknowledge({
-      item: ITEM,
-      classResult: CLASS_COMPLEX,
-      deps: { ackGen: { runImpl: async () => { throw new Error("model down"); } } },
-    });
-    assert.equal(r.acked, false);
-    assert.equal(r.reason, "ack-generation-failed");
-    assert.equal(r.ackText, null);
-    assert.equal(readObligation(r.key).state, "open");
+    assert.equal(rec.ackGenFailures, 1, "the failure is counted, so the retry is bounded");
+    assert.equal(rec.state, "open", "the debt survives — the failure and stale notices still owe the human");
   });
 
   test("the stored summary keeps the classifier's casing — the board row and escalations read from it", async () => {
@@ -488,14 +502,42 @@ describe("openAndAcknowledge", () => {
     });
     const rec = readObligation(r.key);
     assert.equal(rec.summary, "CEO checking in on work progress");
-    assert.doesNotMatch(composeProgress(rec, { now: Date.now() + 6 * 60_000 }), /CEO checking in on work progress/, "the summary is never leaked into a progress update");
+    // It must not leak into anything a human reads. Every deterministic notice
+    // the module can still compose is checked, so a future composer that starts
+    // interpolating `rec.summary` fails here.
+    for (const text of [
+      composeFailure(rec, { failure: { human: "the work ran past its time limit and got cut off" }, willRetry: true }),
+      composeFailure(rec, { failure: { human: "the work never came back with a result" }, willRetry: false }),
+      assurance.composeInterrupted(rec),
+      composeSilentSuccess(rec, {}),
+    ]) {
+      assert.doesNotMatch(text, /CEO checking in on work progress/, "the summary is internal framing, never copy");
+    }
   });
 
-  test("acknowledges ONCE — a re-delivered item does not re-announce itself", async () => {
+  test("speaks ONCE — a re-delivered item, and a RETRY that reopens the key, do not re-announce", async () => {
+    // The retry half is R4: a failed obligation is CLOSED, the item is
+    // re-delivered by the next poll, and a brand-new record opens under the
+    // same key. Without inheritance that record starts clean and acks from
+    // scratch — which is `On it.` arriving immediately after a failure notice,
+    // as sampled live.
     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");
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 1);
+    assert.equal(readObligation(r.key).interimSaid, true);
+
+    assurance.closeObligation(r.key, { outcome: "failed" });
+    const again = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    assert.equal(readObligation(again.key).interimSaid, true, "the latch is INHERITED across the reopen");
+    await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 10 * 60_000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 1, "one interim per ask, across every attempt at it");
   });
 
   test("opens NO board row of its own — there is exactly one writer per ask", async () => {
@@ -628,72 +670,134 @@ describe("settleSession", () => {
 // ---------------------------------------------------------------------------
 
 describe("sweepObligations", () => {
-  test("retries an acknowledgement whose send failed — with a freshly GENERATED line, not a canned one", async () => {
-    const failing = fakeTransport({ failTimes: 99 });
-    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: failing.ackSender } });
-    assert.equal(r.acked, false);
+  test("THE ONE INTERIM: nothing before ACK_AFTER_MS, then exactly one bespoke line", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => "Back on the git fixes now." };
 
-    const working = fakeTransport();
-    const now = Date.now() + ACK_GRACE_MS + 1000;
-    const stats = await sweepObligations({ now, deps: {
-      deliverImpl: working.impl,
-      spokeSinceImpl: () => false,
-      generateAckImpl: async () => "Back on the git fixes now.",
-    } });
+    const early = await sweepObligations({ now: Date.now() + ACK_AFTER_MS - 1000, deps });
+    assert.equal(early.acked, 0);
+    assert.equal(t.sent.length, 0, "below ninety seconds the typing indicator IS the acknowledgement");
+
+    const stats = await sweepObligations({ now: Date.now() + ACK_AFTER_MS + 1000, deps });
     assert.equal(stats.acked, 1);
-    assert.equal(working.sent[0].text, "Back on the git fixes now.");
-    assert.doesNotMatch(working.sent[0].text, /^(on it|looking now)/i, "never the retired rotation");
-    assert.equal(readObligation(r.key).acknowledged, true);
+    assert.equal(t.sent[0].kind, "ack");
+    assert.equal(t.sent[0].text, "Back on the git fixes now.");
+    assert.doesNotMatch(t.sent[0].text, /^(on it|looking now)/i, "never the retired rotation");
+    assert.equal(readObligation(r.key).interimSaid, true);
+
+    // …and never a second one, however long the work runs.
+    for (let m = 2; m < 40; m++) {
+      const now = Date.now() + ACK_AFTER_MS + m * 60_000;
+      if (now - Date.now() >= STALE_AFTER_MS) break;
+      await sweepObligations({ now, deps });
+    }
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 1, "one interim per obligation, full stop");
+  });
+
+  test("ONE SEAT, eight concurrent obligations in ONE room, exactly ONE interim", async () => {
+    // WHAT THIS IS AND IS NOT. It is the per-seat guarantee: one daemon holding
+    // eight concurrent debts in one channel emits one holding line, not eight.
+    //
+    // It is NOT `capital-formation` reproduced, and the title used to say it
+    // was. That room's 9,187 messages in 21 days came from EIGHT SEPARATE
+    // SEATS, each with its own AGENT_DIR on its own machine and therefore its
+    // own ledger — see room-budget.test.mjs, "the budget is per (SEAT, service,
+    // channel)". This gate's ceiling in that room is 8 x (60/15) = 32/h against
+    // a measured content-free rate of ~14/h, so it would not have been the
+    // binding constraint there. What removed the measured traffic is the
+    // deleted progress branch (961 -> 0), the sanitiser, and TIME+ONCE; this
+    // gate is the backstop that bounds what survives all three.
+    const t = fakeTransport();
+    for (let i = 0; i < 8; i++) {
+      await openAndAcknowledge({
+        item: { ...ITEM, id: `msg-${i}`, raw_ref: `cohort:capform:${i}`, message_id: `${i}` },
+        classResult: CLASS_COMPLEX,
+        tier: "work",
+      });
+    }
+    assert.equal(openObligations().length, 8, "every ask is still opened and tracked");
+
+    const stats = await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 1, `eight obligations, one message — got ${t.sent.length}`);
+    assert.equal(stats.acked, 1);
+    assert.equal(stats.suppressed, 7, "…and the seven suppressions are COUNTED, so a quiet sweep can still prove it decided");
+
+    // Over budget is not a drop: every debt is still open and still owed.
+    assert.equal(openObligations().length, 8);
   });
 
-  test("REGRESSION: a failed generation in the sweep sends NOTHING — bounded, then given up on", async () => {
-    const t = fakeTransport({ genFail: true }); // the open-time generation already failed once
-    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
-    assert.equal(r.acked, false);
+  test("…and the suppressed debts stay silent afterwards rather than queueing up a burst", async () => {
+    const t = fakeTransport();
+    for (let i = 0; i < 8; i++) {
+      await openAndAcknowledge({ item: { ...ITEM, id: `m-${i}`, raw_ref: `cohort:capform2:${i}` }, classResult: CLASS_COMPLEX, tier: "work" });
+    }
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE };
+    await sweepObligations({ now: Date.now() + ACK_AFTER_MS + 1000, deps });
+    await sweepObligations({ now: Date.now() + 20 * 60_000, deps });
+    await sweepObligations({ now: Date.now() + 40 * 60_000, deps });
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 1, "the window reopening must not release a backlog");
+  });
+
+  test("a DIFFERENT room is never gagged by a busy one", async () => {
+    const t = fakeTransport();
+    for (let i = 0; i < 5; i++) {
+      await openAndAcknowledge({ item: { ...ITEM, id: `b-${i}`, raw_ref: `cohort:busy:${i}` }, classResult: CLASS_COMPLEX, tier: "work" });
+    }
+    await openAndAcknowledge({
+      item: { ...ITEM, id: "quiet-1", raw_ref: "cohort:quiet:1", channel_id: "C-QUIET" },
+      classResult: CLASS_COMPLEX,
+      tier: "work",
+    });
+    const stats = await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    assert.equal(stats.acked, 2, "one per room");
+    assert.equal(new Set(t.sent.map((m) => m.channel)).size, 2);
+  });
+
+  test("REGRESSION: a failed generation sends NOTHING — bounded, then given up on", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
 
     let genCalls = 0;
     const t0 = Date.now();
     for (let m = 1; m <= 8; m++) {
-      await sweepObligations({ now: t0 + ACK_GRACE_MS + m * 60_000, deps: {
+      await sweepObligations({ now: t0 + ACK_AFTER_MS + m * 60_000, deps: {
         deliverImpl: t.impl,
         spokeSinceImpl: () => false,
         generateAckImpl: async () => { genCalls++; return null; },
       } });
     }
     assert.equal(t.sent.filter((s) => s.kind === "ack").length, 0, "no canned line went out in place of the failed generation");
-    assert.ok(genCalls < ACK_GEN_MAX_FAILURES + 1, `generation retries are bounded, not once-a-tick forever (saw ${genCalls})`);
+    assert.ok(genCalls <= ACK_GEN_MAX_FAILURES, `generation retries are bounded, not once-a-tick forever (saw ${genCalls})`);
     const rec = readObligation(r.key);
-    assert.equal(rec.ackSuppressed, true, "the ack is given up on…");
-    assert.equal(rec.state, "open", "…but the DEBT is not — progress and failure notices still speak");
-    assert.ok(t.sent.some((s) => s.kind === "progress"), "and indeed the human still hears about the long-running work");
-  });
-
-  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 on this/i);
-    assert.match(msg, /minutes in/i, "an interim update that omits how long it has been is not much of an update");
-    // Six minutes in is INSIDE the 10-20 minute window the ack just promised
-    // for opus work; claiming it here contradicts a message the same human read.
-    assert.doesNotMatch(msg, /longer than I expected/i);
+    assert.equal(rec.ackSuppressed, true, "the interim is given up on…");
+    assert.equal(rec.state, "open", "…but the DEBT is not — the stale check still owes the human");
   });
 
-  test("interim updates are CAPPED — attentive, not noisy", async () => {
+  test("a failed generation does NOT spend the room's budget", async () => {
+    // Ask, compose, THEN spend. A budget burned on a message that was never
+    // composed gags the room for fifteen minutes in exchange for nothing.
     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}`);
+    await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    await openAndAcknowledge({ item: { ...ITEM, id: "x2", raw_ref: "cohort:same-room:2" }, classResult: CLASS_COMPLEX, tier: "work" });
+    let calls = 0;
+    const stats = await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: {
+        deliverImpl: t.impl,
+        spokeSinceImpl: () => false,
+        // The first obligation's generation fails; the second's succeeds.
+        generateAckImpl: async () => (++calls === 1 ? null : "Back on the git fixes now."),
+      },
+    });
+    assert.equal(stats.acked, 1, "the room's one interim went to the ask that could actually compose one");
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 1);
   });
 
   test("work that outruns every session timeout is declared dead, not left hanging", async () => {
@@ -728,10 +832,33 @@ describe("sweepObligations", () => {
 
     const stats = await sweepObligations({
       now: Date.now() + INTERRUPT_GRACE_MS + 1000,
-      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false },
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
     });
     assert.equal(stats.interrupted, 1);
     assert.match(t.sent.at(-1).text, /was interrupted before it finished/i);
+    assert.equal(t.sent.at(-1).kind, "notice", "an interrupted notice is an OUTCOME, not a progress ping — the kind it used to borrow no longer exists");
+  });
+
+  test("…and a SECOND interruption of the same ask says nothing more", async () => {
+    // Said once per (channel, obligationKey). Two daemon restarts over one long
+    // ask are one apology, not two — and a retry that reopens the same key
+    // inherits the notice ledger, so it is not two either.
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    const { writeFileSync } = await import("node:fs");
+    const orphan = (extra = {}) => {
+      const rec = { ...readObligation(r.key), daemonPid: process.pid + 99999, ...extra };
+      writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(r.key)}.json`), JSON.stringify(rec));
+    };
+    orphan();
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE };
+    await sweepObligations({ now: Date.now() + INTERRUPT_GRACE_MS + 1000, deps });
+    assert.equal(t.sent.filter((m) => /interrupted/i.test(m.text)).length, 1);
+
+    orphan({ interruptedNotifiedAt: null });
+    const second = await sweepObligations({ now: Date.now() + INTERRUPT_GRACE_MS + 120_000, deps });
+    assert.equal(second.interrupted, 0);
+    assert.equal(t.sent.filter((m) => /interrupted/i.test(m.text)).length, 1, "one apology per ask, per room");
   });
 
   test("REGRESSION: a LIVE daemon's obligation is never declared interrupted", async () => {
@@ -750,7 +877,7 @@ describe("sweepObligations", () => {
     const before = t.sent.length;
     const stats = await sweepObligations({
       now: Date.now() + INTERRUPT_GRACE_MS + 1000,
-      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => true },
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => true, generateAckImpl: async () => FAKE_ACK_LINE },
     });
     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");
@@ -768,7 +895,7 @@ describe("sweepObligations", () => {
 
     const stats = await sweepObligations({
       now: Date.now() + 1000,
-      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false },
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
     });
     assert.equal(stats.interrupted, 0);
   });
@@ -779,7 +906,7 @@ describe("sweepObligations", () => {
     // the owner is alive and will; two daemons acking is one human hearing
     // double.
     const failing = fakeTransport({ failTimes: 99 });
-    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: failing.ackSender } });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work", deps: { ackSender: failing.ackSender } });
     assert.equal(r.acked, false);
     const rec = readObligation(r.key);
     rec.daemonPid = process.pid + 99999;
@@ -788,7 +915,7 @@ describe("sweepObligations", () => {
 
     const working = fakeTransport();
     const stats = await sweepObligations({
-      now: Date.now() + ACK_GRACE_MS + 1000,
+      now: Date.now() + ACK_AFTER_MS + 1000,
       deps: {
         deliverImpl: working.impl,
         spokeSinceImpl: () => false,
@@ -799,11 +926,12 @@ describe("sweepObligations", () => {
     assert.equal(stats.acked, 0, "the live owner narrates its own debt");
     assert.equal(working.sent.length, 0, "not one byte from the non-owner");
     assert.equal(readObligation(r.key).acknowledged, false);
+    assert.equal(readObligation(r.key).interimSaid, false, "and the non-owner does not spend the latch either");
   });
 
-  test("…but once the owning daemon is DEAD, this daemon takes the ack over", async () => {
+  test("…but once the owning daemon is DEAD, this daemon takes the interim over", async () => {
     const failing = fakeTransport({ failTimes: 99 });
-    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: failing.ackSender } });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work", deps: { ackSender: failing.ackSender } });
     const rec = readObligation(r.key);
     rec.daemonPid = process.pid + 99999;
     const { writeFileSync } = await import("node:fs");
@@ -811,7 +939,7 @@ describe("sweepObligations", () => {
 
     const working = fakeTransport();
     const stats = await sweepObligations({
-      now: Date.now() + ACK_GRACE_MS + 1000,
+      now: Date.now() + ACK_AFTER_MS + 1000,
       deps: {
         deliverImpl: working.impl,
         spokeSinceImpl: () => false,
@@ -823,27 +951,26 @@ describe("sweepObligations", () => {
     assert.equal(readObligation(r.key).acknowledged, true);
   });
 
-  test("REGRESSION: a debt OWNED by another LIVE daemon gets no progress ping from this one", async () => {
+  test("REGRESSION: a debt OWNED by another LIVE daemon gets no interim from this one", async () => {
     const t = fakeTransport();
-    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
     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() + PROGRESS_AFTER_MS + 1000,
-      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => true },
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => true, generateAckImpl: async () => FAKE_ACK_LINE },
     });
-    assert.equal(stats.progressed, 0, "the live owner sends its own progress updates");
+    assert.equal(stats.acked, 0, "the live owner speaks for its own debt");
     assert.equal(stats.interrupted, 0, "and a live owner is certainly not 'interrupted'");
-    assert.equal(t.sent.length, before);
+    assert.equal(t.sent.length, 0);
   });
 
-  test("…and a dead owner's debt DOES get this daemon's progress ping (after the interrupted notice is done)", async () => {
+  test("…and a dead owner's debt DOES get this daemon's interim (after the interrupted notice is done)", async () => {
     const t = fakeTransport();
-    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
     const rec = readObligation(r.key);
     rec.daemonPid = process.pid + 99999;
     rec.interruptedNotifiedAt = Date.now(); // the orphan apology already went out
@@ -851,41 +978,43 @@ describe("sweepObligations", () => {
     writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(r.key)}.json`), JSON.stringify(rec));
 
     const stats = await sweepObligations({
-      now: Date.now() + PROGRESS_AFTER_MS + 1000,
-      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false },
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false, generateAckImpl: async () => "Back on the git fixes now." },
     });
-    assert.equal(stats.progressed, 1);
-    assert.match(t.sent.at(-1).text, /still on this/i);
+    assert.equal(stats.acked, 1);
+    assert.equal(t.sent.at(-1).text, "Back on the git fixes now.");
   });
 
   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.
+    // hq de-dups server-side on the client message id, so two messages that key
+    // on the same suffix are ONE message as far as hq is concerned and the
+    // second is silently swallowed — "never silent" degrading into "spoke once,
+    // then silent forever". Invisible to 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 r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
 
-    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 });
+    const deps = { deliverImpl: impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE };
+    await sweepObligations({ now: Date.now() + ACK_AFTER_MS + 1000, deps });          // the interim
+    await settleSession({ key: r.key, ok: false, code: 143, error: "SIGTERM", deps }); // the failure notice
+    await sweepObligations({ now: Date.now() + STALE_AFTER_MS + 1000, deps });         // the stale notice
 
-    assert.ok(seen.length >= 2, `expected two progress sends, saw ${seen.length}`);
+    assert.ok(seen.length >= 2, `expected several distinct 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, generateAckImpl: async () => FAKE_ACK_LINE } });
-    assert.equal(t.sent.length - before, 1, "two messages in one tick reads as a malfunction");
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    // Old enough to qualify for BOTH the interrupted notice and the interim.
+    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 now = Date.now() + INTERRUPT_GRACE_MS + 1000;
+    await sweepObligations({ now, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE } });
+    assert.equal(t.sent.length, 1, "two messages in one tick reads as a malfunction");
   });
 });
 
@@ -910,6 +1039,67 @@ describe("delivery receipts", () => {
     );
   });
 
+  test("REGRESSION: an 'interrupted' notice is not an answer either", async () => {
+    // The interrupted apology moved from kind "progress" to kind "notice" when
+    // progress pings were deleted. A kind that is not in the non-answer set
+    // reads to `spokeFor` as "the human was spoken to", which would discharge
+    // an unanswered debt the moment a daemon restarted — the exact class of bug
+    // the receipt ledger exists to prevent.
+    const { NON_ANSWER_KINDS } = await import("../../lib/comms/receipts.mjs");
+    assert.ok(NON_ANSWER_KINDS.includes("notice"), "every courtesy kind the daemon can emit belongs in the non-answer set");
+    const now = Date.now();
+    receipts.recordOutbound({ service: "cohort", channel: "C-NOTICE", kind: "notice", agentRoot: ROOT, now });
+    assert.equal(
+      receipts.spokeFor({ obligation: { key: "k", channel: "C-NOTICE", openedAt: now - 1000 }, now, siblingOpenCount: 1, agentRoot: ROOT }).heard,
+      false,
+    );
+  });
+
+  test("every kind the daemon actually sends is classified as answer or courtesy — none left unclassified", async () => {
+    // A new kind that nobody adds to the set silently becomes "this discharged
+    // the debt" — the discharge-an-unanswered-debt bug the receipt ledger
+    // exists to prevent.
+    //
+    // DERIVED FROM THE EMITTERS, not hand-listed. The hand-written literal this
+    // replaces could not fail when a kind was added, and had ALREADY missed one:
+    // `plan` was being emitted by notePlan and was absent from the list. Same
+    // shape as narratorPatterns(), which derives its strings from the composers
+    // rather than restating them.
+    const { NON_ANSWER_KINDS } = await import("../../lib/comms/receipts.mjs");
+    const { readFileSync } = await import("node:fs");
+    const here = new URL(".", import.meta.url).pathname;
+    // Line-scoped, and `counters.bump` lines are skipped: a counter LABEL is
+    // not a delivery kind (responder.mjs tags its dedup/generation counters
+    // `kind: "holding"`, which never reaches a receipt). Erring toward a false
+    // alarm is deliberate — a spurious failure sends someone to look, a silent
+    // miss is the bug this test is for.
+    const emitted = new Set();
+    for (const f of ["assurance.mjs", "responder.mjs"]) {
+      for (const line of readFileSync(join(here, f), "utf-8").split("\n")) {
+        if (line.includes("counters.bump")) continue;
+        const m = /\bkind:\s*"([a-z-]+)"/.exec(line);
+        if (m) emitted.add(m[1]);
+      }
+    }
+    assert.ok(emitted.size >= 5, `the scan must find the emitters — found ${[...emitted].join(", ")}`);
+    // The ONE kind that is an answer. Everything else the daemon emits about an
+    // ask is a courtesy and must not discharge the debt.
+    const ANSWERS = new Set(["reply"]);
+    for (const kind of emitted) {
+      assert.equal(
+        NON_ANSWER_KINDS.includes(kind),
+        !ANSWERS.has(kind),
+        `"${kind}" is emitted by the daemon and is ${ANSWERS.has(kind) ? "an answer" : "a courtesy"} — lib/comms/receipts.mjs NON_ANSWER_KINDS must say so`,
+      );
+    }
+    // Pinned explicitly as well, so a scan that silently stops matching is also
+    // a failure rather than a green run over an empty set.
+    for (const kind of ["ack", "notice", "failure", "plan"]) {
+      assert.ok(emitted.has(kind), `"${kind}" must still be found by the scan`);
+      assert.ok(NON_ANSWER_KINDS.includes(kind), `"${kind}" is a courtesy`);
+    }
+  });
+
   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.
@@ -998,15 +1188,15 @@ describe("attribution: which debt did that message actually discharge", () => {
     // 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 t = fakeTransport();
     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);
+    const r = await openAndAcknowledge({ item: solo, classResult: CLASS_COMPLEX, tier: "work" });
+    assert.equal(readObligation(r.key).acknowledged, false, "nothing is said at open time any more");
     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, generateAckImpl: async () => "Finally picking your ask up now." } });
+    const stats = await sweepObligations({ now: Date.now() + ACK_AFTER_MS + 1000, deps: { deliverImpl: t.impl, generateAckImpl: async () => "Finally picking your ask up now." } });
     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.equal(stats.acked, 1, "instead the interim is finally sent");
     assert.equal(t.sent.at(-1).text, "Finally picking your ask up now.");
   });
 });
@@ -1109,3 +1299,493 @@ describe("a running retry is not declared dead", () => {
     assert.match(t.sent.at(-1).text, /outrun its time limit/i);
   });
 });
+
+// ---------------------------------------------------------------------------
+// 10. ACKNOWLEDGEMENT DISCIPLINE — the 2026-09-12 policy, against the measured
+//     production strings that made it necessary.
+// ---------------------------------------------------------------------------
+
+describe("sanitiseAckText enforces the prompt the model was already given", () => {
+  // The ack system prompt has said "Never a generic 'on it' or 'looking into
+  // it'" since it was written. Nothing checked. 3,069 generic acknowledgements
+  // shipped in fourteen days — 28.8% of every message this fleet sent — and 272
+  // of them were never followed by a substantive reply within the hour.
+  //
+  // These are the REAL strings, as observed in org_default_adaptic.
+  const OBSERVED_IN_PRODUCTION = [
+    "On it.",
+    "On it",
+    "On it — digging in now.",
+    "Looking now.",
+    "Looking into it.",
+    "Looking into this now.",
+    "Checking.",
+    "Checking now.",
+    "One moment.",
+    "Got it.",
+    "Got it — will do.",
+    "Will do.",
+    "Working on it.",
+    "Taking a look.",
+    "Digging in now.",
+  ];
+
+  for (const line of OBSERVED_IN_PRODUCTION) {
+    test(`rejects the measured generic ack: ${JSON.stringify(line)}`, () => {
+      assert.equal(sanitiseAckText(line), null, "rejection ⇒ null ⇒ send nothing, which is the existing correct failure mode");
+    });
+  }
+
+  test("rejects anything under the minimum length, whatever its phrasing", () => {
+    // The second, phrasing-independent net. A line too short to name the thing
+    // that was asked cannot be specific to it, which is the one thing the
+    // prompt requires.
+    assert.equal(ACK_MIN_CHARS, 20);
+    assert.equal(sanitiseAckText("Sorted, starting."), null);
+    assert.equal(sanitiseAckText("Yep."), null);
+    assert.equal(sanitiseAckText("Onto it now, boss."), null);
+  });
+
+  test("…and still accepts a line that actually names the ask", () => {
+    // The discipline must not become a gag. A bespoke line is exactly what the
+    // prompt asks for, and it survives.
+    for (const good of [
+      "Give me a few minutes on the git fixes.",
+      "Pulling the July ledger against the forecast now.",
+      "Starting on the regulator gap analysis — the Thursday one.",
+    ]) {
+      assert.equal(sanitiseAckText(good), good, `"${good}" is specific and must pass`);
+    }
+  });
+
+  test("REGRESSION: the ack prompt and the filter read the same pattern, so they cannot drift again", async () => {
+    // The whole defect was an instruction with no enforcement behind it. The
+    // filter now imports GENERIC_OPENER from the copy-rule module; this pins
+    // that every opener the prompt names is in fact refused.
+    const { GENERIC_OPENER } = await import("../../lib/assurance/plan-note.mjs");
+    for (const opener of ["on it", "looking now", "looking into", "checking", "one moment", "got it", "will do", "working on it", "taking a look", "digging in"]) {
+      assert.match(opener, GENERIC_OPENER, `the prompt forbids "${opener}" — the filter must too`);
+    }
+  });
+});
+
+describe("failure notices are said ONCE per (channel, obligationKey)", () => {
+  test("REGRESSION: the same failure sentence does not reach one room three times in a minute", async () => {
+    // Sampled live at 06:32Z on 2026-09-12: the same failure sentence three
+    // times inside one minute, and `On it.` again immediately after. The cause
+    // was a retry loop that narrated every attempt — notice, retry, a FRESH
+    // obligation under the same key, notice again — with nothing suppressing
+    // the repeat.
+    const t = fakeTransport();
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE };
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+      assurance.noteSession(r.key, `s-${attempt}`);
+      await settleSession({ key: r.key, ok: false, code: 143, error: "SIGTERM", deps });
+      // Whatever the outcome, the item is re-delivered and the key reopens.
+      assurance.closeObligation(r.key, { outcome: "failed" });
+    }
+
+    const failures = t.sent.filter((m) => m.kind === "failure");
+    assert.equal(failures.length, 1, `the same sentence went out ${failures.length} times; the whole point is once`);
+    assert.match(failures[0].text, /hit a problem/i);
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 0, "and no `On it.` behind it either");
+  });
+
+  test("…but 'a retry is running' and 'I have stopped' remain two separate, sayable facts", async () => {
+    // Collapsing them would leave a human who was told a retry was in flight
+    // never learning it had been abandoned. What is suppressed is the REPEAT of
+    // one fact, not the second fact.
+    const t = fakeTransport();
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false };
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    assurance.noteSession(r.key, "s-1");
+    const first = await settleSession({ key: r.key, ok: false, code: 143, error: "SIGTERM", deps });
+    assert.equal(first.willRetry, true);
+
+    // The retry runs and fails terminally.
+    assurance.noteSession(r.key, "s-2");
+    const second = await settleSession({ key: r.key, ok: false, code: null, error: "claude CLI spawn error: ENOENT", deps });
+    assert.equal(second.willRetry, false);
+
+    const texts = t.sent.filter((m) => m.kind === "failure").map((m) => m.text);
+    assert.equal(texts.length, 2);
+    assert.match(texts[0], /retrying now/i);
+    assert.match(texts[1], /stopped retrying/i);
+  });
+
+  test("the notice ledger records WHICH notice reached WHICH room", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    await settleSession({ key: r.key, ok: false, code: 143, error: "SIGTERM", deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
+    const rec = readObligation(r.key);
+    const ids = Object.keys(rec.notices || {});
+    assert.equal(ids.length, 1);
+    assert.ok(ids[0].startsWith(NOTICE.FAILURE_RETRYING), `expected a ${NOTICE.FAILURE_RETRYING} stamp, got ${ids[0]}`);
+    assert.ok(ids[0].includes(String(ITEM.channel_id).toLowerCase()), "the channel is part of the key — the same ask re-routed elsewhere genuinely has not been answered there");
+  });
+
+  test("a stale notice is not repeated for a key that already heard one", async () => {
+    const t = fakeTransport();
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE };
+    for (let attempt = 0; attempt < 3; attempt++) {
+      await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+      await sweepObligations({ now: Date.now() + STALE_AFTER_MS + 1000, deps });
+    }
+    assert.equal(t.sent.filter((m) => m.kind === "failure").length, 1);
+  });
+
+  // ── THE SIBLING SHAPE, which the per-record ledger structurally cannot reach ─
+  //
+  // The dedupe above is keyed on the obligation RECORD, so it covers the RETRY
+  // loop: notice → retry → fresh record under the same key → notice again. It
+  // does NOT cover SIBLINGS. Twenty separate inbound asks in one room whose
+  // sessions all die the same way are twenty separate records, and the stale
+  // branch's sentence contains nothing about which ask it is — so the room gets
+  // the identical line twenty times and the reader cannot tell any of them
+  // apart. That is the commoner shape whenever a dispatcher or model path is
+  // down, and it is the one the sampled "same failure sentence three times in
+  // one minute" is most likely to have actually been.
+
+  test("REGRESSION: twenty SIBLING debts staling together say the identical sentence ONCE", async () => {
+    const t = fakeTransport();
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE };
+    for (let i = 0; i < 20; i++) {
+      await openAndAcknowledge({
+        item: { ...ITEM, id: `sib-${i}`, raw_ref: `cohort:sibling:${i}`, message_id: `${i}` },
+        classResult: CLASS_COMPLEX,
+        tier: "work",
+      });
+    }
+    assert.equal(openObligations().length, 20, "every ask is still opened and tracked");
+
+    await sweepObligations({ now: Date.now() + STALE_AFTER_MS + 60_000, deps });
+
+    const failures = t.sent.filter((m) => m.kind === "failure");
+    assert.equal(failures.length, 1, `twenty byte-identical failure sentences reached one room ${failures.length} times`);
+    // Nothing is LOST: every dead ask is still escalated for an operator, and
+    // every debt is still closed. Only the duplicate sentence is withheld.
+    assert.equal(openObligations().length, 0, "all twenty debts were still discharged");
+    const { readdirSync } = await import("node:fs");
+    assert.equal(readdirSync(join(ROOT, "state", "obligations", "needs-attention")).length, 20,
+      "…and an operator still sees all twenty in needs-attention");
+  });
+
+  test("…but twenty siblings that fail DIFFERENTLY are all said, because each is a fact the reader lacks", async () => {
+    // The safety argument for the suppression above. Only an IDENTICAL sentence
+    // is withheld; suppressing information a person does not have re-creates
+    // the original bug — someone never told their work died.
+    const t = fakeTransport();
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false };
+    const CAUSES = [
+      { code: null, error: "claude CLI spawn error: ENOENT" },
+      { code: 0, error: "" },
+    ];
+    let sent = 0;
+    for (let i = 0; i < CAUSES.length; i++) {
+      const r = await openAndAcknowledge({
+        item: { ...ITEM, id: `diff-${i}`, raw_ref: `cohort:different:${i}` },
+        classResult: CLASS_COMPLEX,
+        tier: "work",
+      });
+      assurance.noteSession(r.key, `s-${i}`);
+      const res = await settleSession({ key: r.key, ok: false, ...CAUSES[i], deps });
+      if (res.spoke) sent++;
+    }
+    assert.equal(sent, CAUSES.length, "distinct causes are distinct sentences and every one is said");
+    const texts = new Set(t.sent.filter((m) => m.kind === "failure").map((m) => m.text));
+    assert.equal(texts.size, CAUSES.length);
+  });
+
+  test("a sibling in a DIFFERENT room still hears it — the coalescing is per room", async () => {
+    const t = fakeTransport();
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE };
+    await openAndAcknowledge({ item: { ...ITEM, id: "r1-a", raw_ref: "cohort:r1:a" }, classResult: CLASS_COMPLEX, tier: "work" });
+    await openAndAcknowledge({ item: { ...ITEM, id: "r1-b", raw_ref: "cohort:r1:b" }, classResult: CLASS_COMPLEX, tier: "work" });
+    await openAndAcknowledge({
+      item: { ...ITEM, id: "r2-a", raw_ref: "cohort:r2:a", channel_id: "C-OTHER-ROOM" },
+      classResult: CLASS_COMPLEX, tier: "work",
+    });
+    await sweepObligations({ now: Date.now() + STALE_AFTER_MS + 60_000, deps });
+    const failures = t.sent.filter((m) => m.kind === "failure");
+    assert.equal(failures.length, 2, "one per room");
+    assert.equal(new Set(failures.map((m) => m.channel)).size, 2);
+  });
+
+  test("a suppressed duplicate is still stamped on its own record, so it cannot leak out later", async () => {
+    // If the record's own ledger did not learn the fact had been told in this
+    // room, the next tick would re-say it the moment the room window rolled
+    // over — turning suppression into a delay.
+    const t = fakeTransport();
+    const deps = { deliverImpl: t.impl, spokeSinceImpl: () => false };
+    const a = await openAndAcknowledge({ item: { ...ITEM, id: "st-a", raw_ref: "cohort:stamp:a" }, classResult: CLASS_COMPLEX, tier: "work" });
+    const b = await openAndAcknowledge({ item: { ...ITEM, id: "st-b", raw_ref: "cohort:stamp:b" }, classResult: CLASS_COMPLEX, tier: "work" });
+    assurance.noteSession(a.key, "s-a");
+    assurance.noteSession(b.key, "s-b");
+    await settleSession({ key: a.key, ok: false, code: 143, error: "SIGTERM", deps });
+    await settleSession({ key: b.key, ok: false, code: 143, error: "SIGTERM", deps });
+    assert.equal(t.sent.filter((m) => m.kind === "failure").length, 1);
+    const recB = readObligation(b.key);
+    assert.ok(Object.keys(recB.notices || {}).some((k) => k.startsWith(NOTICE.FAILURE_RETRYING)),
+      "the suppressed record carries the stamp, so a later tick does not re-say it");
+  });
+});
+
+describe("the sweep is not re-entrant", () => {
+  // agent-daemon.mjs fires sweepObligations() on a 60-second setInterval with no
+  // in-flight guard of its own, and ONE TICK IS NOT BOUNDED BY 60 SECONDS:
+  // branch (e) peeks the room budget with commit:false, then awaits a cold
+  // `claude --print` spawn, serialised per obligation. A daemon with a dozen-plus
+  // eligible obligations in distinct rooms spends more than a tick in generation
+  // alone, so tick N+1 begins while tick N is still composing — and BOTH peek the
+  // same room's budget and read "allowed", because the spend is only committed
+  // after a successful send.
+
+  test("an overlapping sweep is refused rather than allowed to double-spend a room", async () => {
+    const t = fakeTransport();
+    await openAndAcknowledge({ item: { ...ITEM, id: "re-1", raw_ref: "cohort:reentry:1" }, classResult: CLASS_COMPLEX, tier: "work" });
+    await openAndAcknowledge({ item: { ...ITEM, id: "re-2", raw_ref: "cohort:reentry:2" }, classResult: CLASS_COMPLEX, tier: "work" });
+
+    const now = Date.now() + ACK_AFTER_MS + 1000;
+    let overlapped = null;
+    // A generator that starts a SECOND sweep while the first is still awaiting
+    // it — exactly the shape a slow `claude --print` produces on the timer.
+    const deps = {
+      deliverImpl: t.impl,
+      spokeSinceImpl: () => false,
+      generateAckImpl: async () => {
+        if (overlapped === null) overlapped = await sweepObligations({ now, deps });
+        return FAKE_ACK_LINE;
+      },
+    };
+
+    const first = await sweepObligations({ now, deps });
+    assert.equal(overlapped && overlapped.skipped, true, "the re-entrant call was refused");
+    assert.equal(overlapped.acked, 0, "…and it spoke to nobody");
+    assert.equal(first.acked, 1, "the outer sweep still did its one room's work");
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 1, "one room, one interim, even across overlapping ticks");
+  });
+
+  test("the guard is released even when the sweep throws, so it cannot disable the daemon", async () => {
+    await openAndAcknowledge({ item: { ...ITEM, id: "thr-1", raw_ref: "cohort:throw:1" }, classResult: CLASS_COMPLEX, tier: "work" });
+    const boom = {
+      deliverImpl: async () => { throw new Error("transport exploded"); },
+      spokeSinceImpl: () => false,
+      generateAckImpl: async () => FAKE_ACK_LINE,
+    };
+    await assert.rejects(() => sweepObligations({ now: Date.now() + ACK_AFTER_MS + 1000, deps: boom }));
+    // The very next tick must run. Before the `finally`, this returned skipped.
+    const after = await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 2000,
+      deps: { deliverImpl: async () => ({ sent: true, via: "fake" }), spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    assert.notEqual(after.skipped, true, "a throw must not leave the sweep disabled for the life of the daemon");
+  });
+});
+
+describe("the room-budget ledger is not an obligation", () => {
+  // It lives at state/obligations/room-budget.json — the path the design names
+  // — inside a directory whose reader JSON-parses every *.json as a debt record.
+  // Parsed as one it was a phantom with no `key` and no `state`: it inflated
+  // every count derived from listObligations(), and pruneObligations() called
+  // unlinkSync(pathFor(undefined)) -> state/obligations/unknown.json on every
+  // tick, swallowed by a catch. Harmless only because nothing can key to
+  // "unknown" today.
+  test("a sweep that spends a room's budget does not add an obligation to the ledger", async () => {
+    const t = fakeTransport();
+    await openAndAcknowledge({ item: { ...ITEM, id: "led-1", raw_ref: "cohort:ledger:1" }, classResult: CLASS_COMPLEX, tier: "work" });
+    await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    const { existsSync } = await import("node:fs");
+    assert.equal(existsSync(join(ROOT, "state", "obligations", "room-budget.json")), true, "the budget really was written there");
+    const all = assurance.listObligations();
+    assert.equal(all.length, 1, `one ask, one record — got ${all.length}`);
+    assert.equal(all.every((r) => typeof r.key === "string" && r.key), true, "every record the reader returns is addressable");
+  });
+
+  test("pruning never unlinks state/obligations/unknown.json", async () => {
+    const { writeFileSync, existsSync } = await import("node:fs");
+    const decoy = join(ROOT, "state", "obligations", "unknown.json");
+    writeFileSync(decoy, JSON.stringify({ not: "an obligation" }));
+    assurance.pruneObligations({ now: Date.now() + 10 * 24 * 3600_000 });
+    assert.equal(existsSync(decoy), true, "a keyless record must never be resolved to a path and deleted");
+    try { (await import("node:fs")).unlinkSync(decoy); } catch { /* cleanup only */ }
+  });
+});
+
+describe("notePlan — the plan tier says the plan, or says nothing", () => {
+  const FIRST_TURN = {
+    type: "assistant",
+    message: { content: [{ type: "text", text: "1. Pull the July ledger rows and the signed forecast.\n2. Reconcile them line by line and mark every variance over 5%.\n3. Write up the three biggest gaps with the numbers behind each." }] },
+  };
+
+  test("posts the plan the SESSION stated, once", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "plan" });
+    const res = await notePlan({ key: r.key, firstTurn: FIRST_TURN, now: Date.now(), deps: { deliverImpl: t.impl } });
+    assert.equal(res.spoke, true);
+    assert.equal(t.sent.length, 1);
+    assert.match(t.sent[0].text, /Pull the July ledger rows/);
+    assert.match(t.sent[0].text, /three biggest gaps/);
+    assert.equal(readObligation(r.key).interimSaid, true);
+
+    const again = await notePlan({ key: r.key, firstTurn: FIRST_TURN, now: Date.now(), deps: { deliverImpl: t.impl } });
+    assert.equal(again.spoke, false);
+    assert.equal(again.reason, "interim-already-said");
+    assert.equal(t.sent.length, 1, "one message, and it is the plan");
+  });
+
+  test("NEVER FABRICATES: no stated plan ⇒ nothing is posted", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "plan" });
+    for (const turn of [null, undefined, "", "Sure, happy to look at that.", { type: "result" }, "{truncated"]) {
+      const res = await notePlan({ key: r.key, firstTurn: turn, now: Date.now(), deps: { deliverImpl: t.impl } });
+      assert.equal(res.spoke, false, `${JSON.stringify(turn)} must post nothing`);
+      assert.equal(res.reason, "no-plan-stated");
+    }
+    assert.equal(t.sent.length, 0);
+    assert.equal(readObligation(r.key).interimSaid, false, "and the latch is left unspent, so the sweep's one interim is still available");
+  });
+
+  test("the ROOM budget outranks the plan tier too", async () => {
+    const t = fakeTransport();
+    const a = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "plan" });
+    const b = await openAndAcknowledge({ item: { ...ITEM, id: "p2", raw_ref: "cohort:same-room:p2" }, classResult: CLASS_COMPLEX, tier: "plan" });
+    assert.equal((await notePlan({ key: a.key, firstTurn: FIRST_TURN, now: Date.now(), deps: { deliverImpl: t.impl } })).spoke, true);
+    const second = await notePlan({ key: b.key, firstTurn: FIRST_TURN, now: Date.now(), deps: { deliverImpl: t.impl } });
+    assert.equal(second.spoke, false);
+    assert.equal(second.reason, "room-budget-spent");
+    assert.equal(t.sent.length, 1);
+  });
+
+  test("a plan-tier debt is NEVER silent, even though no caller supplies a first turn yet", async () => {
+    // `notePlan` is exported and tested but not called by the daemon:
+    // dispatcher.mjs spawns with `--output-format json` (not `stream-json`), so
+    // the session's stdout arrives as one object at exit — after the answer has
+    // gone out. Streaming is a dispatcher change and belongs with WP-2.
+    //
+    // What must hold in the meantime is that the plan tier degrades to the WORK
+    // path rather than to silence. The sweep gates on `tier !== "answer"`, so it
+    // does; this pins it, because a tier that mutes a 15-45 minute session is
+    // the one failure this whole package exists to end.
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: { ...ITEM, id: "plan-fb", raw_ref: "cohort:planfb:1" }, classResult: CLASS_COMPLEX, tier: "plan" });
+    const stats = await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    assert.equal(stats.acked, 1, "the plan tier falls back to the one interim, not to nothing");
+    assert.equal(t.sent.filter((m) => m.kind === "ack").length, 1);
+    assert.equal(readObligation(r.key).interimSaid, true, "…and it is still only one");
+  });
+
+  test("a work-tier or answer-tier debt is never given a plan", async () => {
+    const t = fakeTransport();
+    for (const tier of ["work", "answer"]) {
+      const r = await openAndAcknowledge({ item: { ...ITEM, id: `t-${tier}`, raw_ref: `cohort:tier:${tier}` }, classResult: CLASS_COMPLEX, tier });
+      const res = await notePlan({ key: r.key, firstTurn: FIRST_TURN, now: Date.now(), deps: { deliverImpl: t.impl } });
+      assert.equal(res.spoke, false);
+      assert.equal(res.reason, `tier-${tier}`);
+    }
+    assert.equal(t.sent.length, 0);
+  });
+
+  test("a plan posted, then the session answers — the debt discharges with no extra word", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "plan" });
+    await notePlan({ key: r.key, firstTurn: FIRST_TURN, now: Date.now(), deps: { deliverImpl: t.impl } });
+    const before = t.sent.length;
+    const settled = await settleSession({ key: r.key, ok: true, code: 0, deps: { deliverImpl: t.impl, spokeForImpl: () => ({ heard: true, basis: "receipt" }) } });
+    assert.equal(settled.verdict, "answered-by-session");
+    assert.equal(t.sent.length, before, "the daemon adds nothing on top of the session's own answer");
+  });
+});
+
+describe("COPY: no promise without a mechanism", async () => {
+  // §5.1.5. An interim may not contain a future-tense commitment unless a
+  // DURABLE obligation exists and the sweep can close it. The two deleted
+  // progress lines broke this twice over: they promised ("I'll come back as
+  // soon as I've got something") from a timer that had no idea whether anything
+  // would ever come back, and 272 acknowledgements proved the promise empty.
+  // IMPORTED, never re-typed. The sibling test one describe-block up exists to
+  // stop the ack prompt and its filter drifting apart; a copy test that
+  // re-declares the pattern it is checking has the identical defect. The local
+  // copy this replaces had already drifted: it was missing the `revert`
+  // alternative and the whole `i will (come back|...)` branch, so
+  // "I will report back once the reconciliation is done" was dropped by the
+  // implementation and would have PASSED the test's own check.
+  const { FORWARD_PROMISE } = await import("../../lib/assurance/plan-note.mjs");
+
+  test("the deleted progress lines are gone from the module entirely", () => {
+    assert.equal(typeof assurance.composeProgress, "undefined", "composeProgress may not be reintroduced");
+    assert.equal(typeof assurance.PROGRESS_AFTER_MS, "undefined");
+    assert.equal(typeof assurance.PROGRESS_EVERY_MS, "undefined");
+    assert.equal(typeof assurance.PROGRESS_MAX, "undefined");
+  });
+
+  test("…and the retired strings are still RECOGNISED, so a peer running older code cannot restart the loop", () => {
+    for (const line of RETIRED_NARRATOR_TEMPLATES) {
+      assert.equal(isOwnNarratorText(line), true, `"${line}" must still be recognised as machinery talking`);
+    }
+  });
+
+  test("every interim the system can emit is promise-free", async () => {
+    // The plan note is the only composed interim left; the other is the
+    // model-generated ack, which the sanitiser governs. Both are checked.
+    const { renderPlanNote } = await import("../../lib/assurance/plan-note.mjs");
+    const note = renderPlanNote("1. Pull the ledger rows for July.\n2. Reconcile them against the signed forecast.\n3. I'll come back as soon as I've got something.");
+    assert.ok(note);
+    assert.doesNotMatch(note, FORWARD_PROMISE, "a plan bullet carries no durable backing and may not promise a return");
+
+    // A generated ack that promises is still admissible ONLY because a durable
+    // obligation is what carries it — pinned here so the coupling is explicit.
+    const promising = "Starting on the July reconciliation now; I'll come back with the variances.";
+    assert.equal(sanitiseAckText(promising), promising);
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "work" });
+    await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => promising },
+    });
+    assert.equal(t.sent.length, 1);
+    const rec = readObligation(r.key);
+    assert.equal(rec.state, "open", "the promise is backed: the debt is durable…");
+    assert.equal(openObligations().some((o) => o.key === r.key), true, "…and the sweep can still find it and close it");
+  });
+
+  test("an obligation the sweep CANNOT close never gets to promise anything", async () => {
+    // No transport ⇒ no interim, at open time or ever. A promise into a channel
+    // that does not exist is the purest form of the broken-promise failure.
+    const t = fakeTransport();
+    const TELEGRAM_ITEM = { ...ITEM, id: "TG-9", raw_ref: "telegram:9", service: "telegram", channel: null, channel_id: null };
+    const r = await openAndAcknowledge({ item: TELEGRAM_ITEM, classResult: CLASS_COMPLEX, tier: "work", ack: false });
+    assert.equal(readObligation(r.key).interimForbidden, true);
+    await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => "I'll come back as soon as I've got something." },
+    });
+    assert.equal(t.sent.length, 0);
+  });
+});
+
+describe("the answer tier is silent even when a caller gets the flag wrong", () => {
+  test("a record whose TIER is answer never produces an interim, ack:true or not", async () => {
+    // Defence in depth. `shouldAcknowledge` returns ack:false for the answer
+    // tier and the daemon turns that into `interimForbidden`, but the tier is
+    // the durable fact on the record and is what "never speak about this one"
+    // actually means. A caller that passes the tier and forgets the flag must
+    // not be able to re-open the flood.
+    const t = fakeTransport();
+    await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, tier: "answer", ack: true });
+    assert.equal(readObligation(ITEM.raw_ref).interimForbidden, undefined, "the flag was NOT set — this is the caller bug being defended against");
+    const stats = await sweepObligations({
+      now: Date.now() + ACK_AFTER_MS + 60_000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, generateAckImpl: async () => FAKE_ACK_LINE },
+    });
+    assert.equal(stats.acked, 0);
+    assert.equal(t.sent.length, 0, "the tier alone is enough to keep it quiet");
+  });
+});