@cohortapp/agent-sdk 2.15.0 → 2.16.0

package/lib/assurance/tier.test.mjs

@@ -0,0 +1,174 @@
+/**
+ * tier.test.mjs — the reply tier, across the whole classifier matrix.
+ *
+ * The tier is the ONE decision that says whether a human hears anything before
+ * the answer. Getting it wrong in the loud direction is the 3,069 generic acks
+ * and 961 clock-derived nags measured in production on 2026-09-12; getting it
+ * wrong in the quiet direction is the silence the obligation ledger was built
+ * to end. So every cell of the matrix is pinned here rather than sampled.
+ *
+ * Run: node --test lib/assurance/tier.test.mjs
+ */
+
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  replyTier,
+  TIERS,
+  ANSWER_MAX_RUNG,
+  PLAN_MIN_RUNG,
+  PLAN_ACTIONS,
+  PLAN_PRIORITIES,
+} from "./tier.mjs";
+
+/** Every value `classifier.mjs` can emit — the real enums, not a sample. */
+const ACTIONS = ["respond", "draft", "research", "queue", "archive", "ignore"];
+const PRIORITIES = ["critical", "high", "normal", "ignore"];
+/** Every rung in `lib/execution/route.RUNGS`, plus "not routed yet". */
+const RUNGS = [0, 1, 2, 3, 4, 5, null];
+
+describe("replyTier — the three tiers and nothing else", () => {
+  test("every cell of the matrix returns one of exactly three tiers", () => {
+    for (const action of ACTIONS) {
+      for (const priority of PRIORITIES) {
+        for (const rung of RUNGS) {
+          for (const answerable of [true, false, null, undefined]) {
+            for (const willSpawnSession of [true, false]) {
+              const t = replyTier({ answerable, action, priority, rung, willSpawnSession });
+              assert.ok(TIERS.includes(t), `{${action}/${priority}/rung:${rung}/answerable:${answerable}/spawn:${willSpawnSession}} → ${t}`);
+            }
+          }
+        }
+      }
+    }
+  });
+
+  test("no session spawning ⇒ answer tier, whatever the classifier said", () => {
+    // The reply arrives in this turn. An interim in front of an answer the
+    // human is about to read is the definition of content-free traffic.
+    for (const action of ACTIONS) {
+      for (const priority of PRIORITIES) {
+        for (const rung of RUNGS) {
+          assert.equal(
+            replyTier({ answerable: false, action, priority, rung, willSpawnSession: false }),
+            "answer",
+            `${action}/${priority}/rung:${rung} with no session must be "answer"`,
+          );
+        }
+      }
+    }
+  });
+
+  test("answerable at rung 0 or 1 is the answer tier — the reply IS the acknowledgement", () => {
+    // `willSpawnSession` UNKNOWN: the caller is asking hypothetically (which is
+    // how WP-2's effort router will use it), so the classifier verdict decides.
+    for (const rung of [0, ANSWER_MAX_RUNG]) {
+      assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung }), "answer");
+      assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung, willSpawnSession: false }), "answer");
+    }
+  });
+
+  test("REGRESSION: an ASSERTED session disqualifies the answer tier, however answerable the item looked", () => {
+    // THE QUICK-PATH FALL-THROUGH. agent-daemon.mjs tries a quick reply first;
+    // when that reply fails transiently or is blocked by validation it falls
+    // THROUGH to a full session dispatch and asks for a tier with
+    // willSpawnSession:true while classResult.answerable is still true. The
+    // answer tier's whole premise — "the reply arrives in this turn" — is
+    // exactly what the fall-through has falsified.
+    //
+    // Latent rather than live only because `rung` is null today (R13). The
+    // moment WP-2 routes it, that item would have landed in `answer`,
+    // shouldAcknowledge would have returned ack:false, the sweep would have
+    // read the durable tier as never-speak, and a 15-45 minute session would
+    // have run with the human hearing NOTHING at all. Pinned before WP-2 lands
+    // on top of it.
+    for (const rung of [0, ANSWER_MAX_RUNG]) {
+      assert.equal(
+        replyTier({ answerable: true, action: "respond", priority: "high", rung, willSpawnSession: true }),
+        "work",
+        `rung ${rung}: a spawning session speaks once at most — it is never silent`,
+      );
+    }
+    // …and the plan tier still outranks it, because rung 3+ is a project.
+    assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung: 4, willSpawnSession: true }), "plan");
+  });
+
+  test("a routed rung of 3 or above is the plan tier, whatever the action", () => {
+    for (const rung of RUNGS.filter((r) => r != null && r >= PLAN_MIN_RUNG)) {
+      for (const action of ACTIONS) {
+        assert.equal(
+          replyTier({ answerable: false, action, priority: "normal", rung, willSpawnSession: true }),
+          "plan",
+          `rung ${rung} / ${action} must be "plan"`,
+        );
+      }
+    }
+  });
+
+  test("research or draft at critical/high priority is the plan tier even with no routed rung", () => {
+    for (const action of PLAN_ACTIONS) {
+      for (const priority of PLAN_PRIORITIES) {
+        assert.equal(replyTier({ answerable: false, action, priority, rung: null, willSpawnSession: true }), "plan");
+      }
+    }
+  });
+
+  test("…and the same actions at normal priority are only work", () => {
+    for (const action of PLAN_ACTIONS) {
+      for (const priority of ["normal", "ignore"]) {
+        assert.equal(replyTier({ answerable: false, action, priority, rung: null, willSpawnSession: true }), "work");
+      }
+    }
+  });
+
+  test("the ordinary directed ask — respond/high, unrouted — is work: silence, then at most one line", () => {
+    // This is the shape of the overwhelming majority of the 10,667 measured
+    // agent messages. It must NOT be plan tier, or the flood returns wearing a
+    // better costume.
+    assert.equal(replyTier({ answerable: false, action: "respond", priority: "high", rung: null, willSpawnSession: true }), "work");
+    assert.equal(replyTier({ answerable: false, action: "queue", priority: "critical", rung: null, willSpawnSession: true }), "work");
+  });
+
+  test("an ABSENT rung is never read as the cheapest rung", () => {
+    // `lib/backlog` already learned this: absence is not rung 0. A missing rung
+    // may not buy the answer tier's silence-on-the-strength-of-a-quick-path,
+    // and may not buy the plan tier's licence to speak either.
+    assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung: null, willSpawnSession: true }), "work");
+    assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung: undefined, willSpawnSession: true }), "work");
+  });
+
+  test("a non-numeric or out-of-range rung is treated as unrouted, never as a licence to speak", () => {
+    for (const rung of ["3", "team", NaN, Infinity, -1, 6, {}, []]) {
+      assert.equal(
+        replyTier({ answerable: false, action: "respond", priority: "normal", rung, willSpawnSession: true }),
+        "work",
+        `rung ${JSON.stringify(rung)} must not be trusted`,
+      );
+    }
+  });
+
+  test("answerable only counts when it is strictly true", () => {
+    // classifier.mjs coerces a missing/odd field to false for the same reason:
+    // never guess "answerable".
+    for (const answerable of ["true", 1, {}, null, undefined]) {
+      assert.equal(replyTier({ answerable, action: "respond", priority: "high", rung: 0, willSpawnSession: true }), "work");
+    }
+  });
+
+  test("garbage in gives work out — the tier never throws and never invents silence", () => {
+    // Fail-open direction: the tier that can still speak, never the tier that
+    // cannot. A classifier failure must not silently mute the agent.
+    assert.equal(replyTier(), "work");
+    assert.equal(replyTier(null), "work");
+    assert.equal(replyTier({}), "work");
+    assert.equal(replyTier({ action: 12, priority: [], rung: "x", willSpawnSession: "yes" }), "work");
+  });
+
+  test("the tier is a pure function — same input, same answer, no ambient reads", () => {
+    const args = { answerable: false, action: "research", priority: "critical", rung: null, willSpawnSession: true };
+    const first = replyTier(args);
+    for (let i = 0; i < 50; i++) assert.equal(replyTier(args), first);
+    assert.deepEqual(args, { answerable: false, action: "research", priority: "critical", rung: null, willSpawnSession: true }, "the argument is not mutated");
+  });
+});

package/lib/comms/receipts.mjs

@@ -211,12 +211,28 @@ export function spokeSince(q = {}) {
  * @param {string} [q.agentRoot]
  * @returns {{heard:boolean, basis:string}}
  */
+/**
+ * Receipt kinds that are COURTESIES, not answers.
+ *
+ * A receipt of one of these proves the agent said something in the room; it
+ * does not prove the ask was answered, and discharging a debt on one closes an
+ * unanswered question as answered.
+ *
+ * `progress` is retained although nothing emits it any more (deleted
+ * 2026-09-12 — see `scripts/daemon/assurance.mjs`): receipts already on disk
+ * carry it, and a historical progress ping must not start discharging debts on
+ * the day it stops being written. `notice` is the interrupted/orphan apology —
+ * information about the MACHINE, not about the ask. `plan` is the plan-tier
+ * interim.
+ */
+export const NON_ANSWER_KINDS = Object.freeze(["ack", "progress", "notice", "failure", "plan"]);
+
 export function spokeFor(q = {}) {
   const rec = q.obligation || {};
   const ch = channelKey(rec.channel);
   const since = Number.isFinite(rec.openedAt) ? rec.openedAt : q.now;
   if (!ch || !Number.isFinite(since)) return { heard: false, basis: "no-channel" };
-  const exclude = Array.isArray(q.excludeKinds) ? q.excludeKinds : ["ack", "progress", "failure"];
+  const exclude = Array.isArray(q.excludeKinds) ? q.excludeKinds : NON_ANSWER_KINDS;
   const recs = readReceiptsSince(since, q).filter(
     (r) => r.channel === ch && !exclude.includes(r.kind),
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.15.0",
+  "version": "2.16.0",
   "description": "Cohort Agent SDK — autonomous AI colleague runtime. Deploy senior AI colleagues on dedicated Mac minis, wired to the Cohort operating surface.",
   "type": "module",
   "bin": {

package/plugins/maestro-skills/skills/inbound-triage.md

@@ -1,13 +1,13 @@
 ---
 name: inbound-triage
-description: Decide, for each inbound Cohort event, whether to answer in this turn, acknowledge and file it on the board and run a workflow, or hand it to a peer session — and always acknowledge in the same turn. Use when a feed `inbound` line arrives, when reading `maestro inbox list`, or when you are unsure whether an ask is a reply or a task.
+description: Decide, for each inbound Cohort event, whether to answer in this turn, file it on the board and run a workflow, or hand it to a peer session — and whether the person hears anything before the answer (usually not). Use when a feed `inbound` line arrives, when reading `maestro inbox list`, or when you are unsure whether an ask is a reply or a task.
 ---
 
 # Inbound triage
 
-Every inbound event is one of three things. Decide in the first turn, and say
-something to the person in that same turn — a person who asked gets a reply
-or an acknowledgement before you do anything else.
+Every inbound event is one of three things. Decide in the first turn. Whether
+you SAY anything in that turn is a separate question, and the default answer is
+no: see "The one-interim rule" at the foot of this skill.
 
 ## The three outcomes
 
@@ -17,12 +17,10 @@ or an acknowledgement before you do anything else.
    --text "…"` → `maestro inbox done <id>`. No board row: the ledger on the
    server already records that you answered.
 
-2. **Acknowledge, file, work here.** The ask needs real work — reading,
-   drafting, building, several steps — but you can finish it in this session
-   inside an hour or two without blocking the front door. In ONE turn:
+2. **File it, work here.** The ask needs real work — reading, drafting,
+   building, several steps — but you can finish it in this session inside an
+   hour or two without blocking the front door. In ONE turn:
    - `maestro inbox claim <id>`
-   - `maestro inbox reply <id> --text "On it — I'll have <X> to you by <when>."`
-     (specific deliverable, specific time; never "I'll look into it")
    - `maestro board track <id> --stage accepted --title "<what you took on>"
      --why "<one line: why this is more than a reply>"`
    - then run the work — a `Workflow` when it has distinct steps, plain tool
@@ -34,10 +32,10 @@ or an acknowledgement before you do anything else.
      (or `messaging_send` to the thread), then `maestro board track <id>
      --stage done` and `maestro inbox done <id>`.
 
-3. **Acknowledge, file, hand to a peer.** Same as 2, but the work is long
-   (hours), heavy (a repo build, a large research pass), or would block you
-   from answering the next person. After the acknowledgement and the
-   `--stage accepted` track, `maestro session spawn --name <slug> "<prompt>"`
+3. **File it, hand to a peer.** Same as 2, but the work is long (hours), heavy
+   (a repo build, a large research pass), or would block you from answering the
+   next person. After the `--stage accepted` track — and, if the ask is big
+   enough to warrant one, the plan (below) — `maestro session spawn --name <slug> "<prompt>"`
    with a prompt that names the deliverable, the channel and thread to report
    to, the inbox id, and the instruction to `SendMessage` you a two-line
    status when done. You stay the one who talks to the human; the peer talks to
@@ -54,14 +52,14 @@ or an acknowledgement before you do anything else.
   space's board. You do not choose the board.
 - Will it take longer than the next inbound can wait? → peer.
 - Is it a question you should not answer alone (a commitment, spend, an
-  external promise)? → acknowledge, file with `--stage blocked` and `notify`
-  your principal; do not guess.
+  external promise)? → file with `--stage blocked` and `notify` your principal,
+  and say in-channel what you need and from whom. That is a message with
+  content in it, so it is always worth sending; do not guess.
 
 ## Special topics
 
-- **Calls** (`topic: call`): acknowledge in the channel and either join if
-  you are free now or propose a time; the media stays with the avatar service,
-  you do not handle audio here.
+- **Calls** (`topic: call`): answer in the channel — join if you are free now,
+  or propose a time. Either is a real answer, not an acknowledgement.
 - **Comments on files/boards**: reply in the thread of the comment, not in a
   DM; a comment that asks for a change to a document is outcome 2.
 - **Inbound email** (`surface: email`): the same three outcomes; reply through
@@ -71,10 +69,40 @@ or an acknowledgement before you do anything else.
   the same message re-delivered after a crash — check the thread before you
   answer twice.
 
-## The same-turn rule
+## The one-interim rule
 
-Whatever the outcome, the person hears from you in the turn the event
-arrived. An acknowledgement is one or two sentences with a concrete next step
-and time. Do not open with filler and do not describe how you work — say what
-they will get and when. The persona rules (`persona-discipline`) apply to the
-acknowledgement too.
+~~"Whatever the outcome, the person hears from you in the turn the event
+arrived."~~ — struck 2026-09-12. Measured over fourteen days in
+`org_default_adaptic`: of 10,667 agent messages, 3,069 (28.8 %) were opening
+acknowledgements and 961 (9.0 %) were progress nags, and 272 of those
+acknowledgements were never followed by a substantive reply inside an hour.
+Agent-to-human volume went from 2:1 to 158:1 in a fortnight, 80 % of it into one
+channel.
+
+**Silence is the default. A message before the answer is never a reflex; it is
+either absent or it is a plan.**
+
+- **Outcome 1 (reply now):** the reply IS the acknowledgement. Nothing before it.
+- **Outcome 2 or 3, ordinary size:** say nothing. Claim it, file it, do it, and
+  let the result be the first thing they read. A person who has been waiting two
+  minutes has lost nothing; a person who got "On it" and then nothing for an
+  hour has lost their trust in you.
+- **Outcome 2 or 3, large enough that the shape matters** (a workflow, a peer
+  team, a multi-day research pass, anything where the approach is itself a
+  decision): post the PLAN, once, as the first step of doing the work — what you
+  will do, in what order, and what comes back. Three bullets at most, in your own
+  words about this specific ask.
+- **Never** a generic opener. `On it`, `Looking into it`, `Checking`, `One
+  moment`, `Got it`, `Will do`, `Working on it`, `Taking a look`, `Digging in`:
+  the daemon's sanitiser now refuses every one of these outright, and so should
+  you.
+- **Never** a promise you have no mechanism to keep. "I'll come back as soon as
+  I've got something" is only sayable because the obligation ledger will in fact
+  chase it; do not say it about work that has no such ledger behind it.
+- **At most one** such message per channel per fifteen minutes, whatever else is
+  in flight there. If a teammate or the daemon has already spoken in that room
+  inside the window, you have had your turn.
+
+The persona rules (`persona-discipline`) apply to a plan exactly as to a reply.
+The daemon's half of the same policy — tiers, the room budget, the sanitiser —
+is `docs/guides/poller-daemon-setup.md` §2.6a.

package/plugins/maestro-skills/skills/main-session.md

@@ -43,8 +43,9 @@ Each line is a JSON object with a `type`. Handle it in the turn it arrives.
 
 - `inbound` — `{id, surface, topic, from, channelId, threadId, preview, path}`.
   `maestro inbox show <id>` for the full item, then follow the
-  `inbound-triage` skill: reply now, or acknowledge + `maestro board track
-  <id> --stage accepted` + work it, or spawn a peer. Claim it first
+  `inbound-triage` skill: reply now, or `maestro board track <id> --stage
+  accepted` + work it, or spawn a peer. Saying something BEFORE the answer is
+  the exception, not the rule — see that skill's one-interim rule. Claim it first
   (`maestro inbox claim <id>`) so the daemon's sweep does not re-deliver it,
   reply with `maestro inbox reply <id> --text "…"`, and close with
   `maestro inbox done <id>`. The reply command is the reply lane: it runs the
@@ -67,8 +68,9 @@ Each line is a JSON object with a `type`. Handle it in the turn it arrives.
   disk.
 
 Do not batch: an inbound line that sits while you finish something else is a
-person waiting. Acknowledge in the same turn (see `inbound-triage`), then
-finish the other thing.
+person waiting. DECIDE it in the turn it arrives (see `inbound-triage`) — claim
+it, file it, start it — then finish the other thing. Deciding in the same turn
+is the rule; speaking in the same turn is not.
 
 ## The idle loop
 

package/scripts/daemon/agent-daemon.mjs

@@ -69,6 +69,7 @@ import { sendQuickResponse, sendHoldingMessage, isQuickReply } from "./responder
 // imported here because this file is where every one of those moments happens —
 // the dispatch decision, the session close, and the tick loop.
 import {
+  ACK_AFTER_MS,
   shouldAcknowledge,
   openAndAcknowledge,
   noteSession,
@@ -933,6 +934,13 @@ export async function answerItem(item, service, itemId, trace_id, deps = {}, rou
     // paths; passing only the text to buildPrompt made every failed ack read to
     // the session as a delivered one.
     let holdingDelivered = false;
+    // An interim reached this human but THIS process does not hold its text —
+    // the re-delivery path, where the debt is already open with interimSaid and
+    // `openAndAcknowledge` answers {acked:true, ackText:null}. Without carrying
+    // the fact separately from the text, the prompt's no-contact block asserted
+    // silence at a session whose sender had already had a holding line and a
+    // "Hit a problem — … Retrying now".
+    let interimAlreadySent = false;
     let obligationKeyForItem = null;
     // FAIL-SAFE, the storm's OTHER half: never post a holding "let me look into
     // it" the seat cannot keep. If the Claude CLI is not even available, the
@@ -942,8 +950,14 @@ export async function answerItem(item, service, itemId, trace_id, deps = {}, rou
     // still opening the durable debt, so the assurance sweep escalates instead of
     // a human staring at "on it" that never resolves.
     const ackVerdict = _claudeAvailable()
-      ? shouldAcknowledge({ willSpawnSession: true, item, source: "inbox" })
-      : { ack: false, reason: "claude-unavailable" };
+      // `classResult` is passed so the verdict carries a TIER (answer / work /
+      // plan). The tier is what decides whether this ask may make the agent
+      // speak AT ALL: an answerable question at a cheap rung never earns an
+      // interim, and nothing at all is said at this point on any tier — the
+      // sweep owns the single interim, after ACK_AFTER_MS and inside the room's
+      // budget. `item.rung` is null today; WP-2 routes it.
+      ? shouldAcknowledge({ willSpawnSession: true, item, source: "inbox", classResult, rung: item.rung })
+      : { ack: false, reason: "claude-unavailable", tier: "work" };
     // ── DISPATCH GATE: emitter-class inbound spawns NOTHING ─────────────────
     // `emitterClass: true` means the gate read the inbound and recognised output
     // this seat's own machinery class produces — a peer agent's ack-shaped
@@ -973,17 +987,27 @@ export async function answerItem(item, service, itemId, trace_id, deps = {}, rou
         service,
         traceId: trace_id,
         ack: ackVerdict.ack,
+        tier: ackVerdict.tier,
+        // Retained seam: `openAndAcknowledge` no longer sends anything at open
+        // time, so this is never called from the acknowledgement path. It stays
+        // wired because `deps.sendHoldingMessage` is a documented injection
+        // point for the whole fleet and silently dropping it would break
+        // callers that still pass one.
         deps: { ackSender: _sendHoldingMessage },
       });
       obligationKeyForItem = opened.key;
+      // SILENCE IS THE DEFAULT. Nothing has been said to this human yet and
+      // nothing may be until ACK_AFTER_MS, so the session's prompt must not be
+      // told a holding message exists — see prompt-builder's two blocks, which
+      // now render only when one genuinely did go out.
       holdingText = opened.ackText;
       holdingDelivered = Boolean(opened.acked);
+      interimAlreadySent = Boolean(opened.acked) && !opened.ackText;
       if (opened.acked) {
         updateLock(itemId, { holdingSent: true });
       } else if (ackVerdict.ack) {
-        // NOT fatal, NOT silent, NOT forgotten. Loud here; retried by the sweep.
-        console.warn(`[daemon] acknowledgement not delivered for ${itemId} (${opened.error}) — obligation ${opened.key} left open for the assurance sweep`);
-        counters.bump("assurance.ack_deferred", { service });
+        console.log(`[daemon] no interim yet for ${itemId} (${opened.reason}) — the sweep owns it from ${Math.round(ACK_AFTER_MS / 1000)}s, inside the room's budget`);
+        counters.bump("assurance.interim_deferred", { service, tier: ackVerdict.tier || "work" });
       } else {
         console.log(`[daemon] no acknowledgement for ${itemId} (${ackVerdict.reason}) — debt ${opened.key} still tracked`);
       }
@@ -1035,6 +1059,7 @@ export async function answerItem(item, service, itemId, trace_id, deps = {}, rou
       type: "inbox",
       holdingMessage: holdingText,
       holdingSent: holdingDelivered,
+      interimAlreadySent,
     });
     // F1/H2: record a DURABLE in-flight admission and DEFER markProcessed() to
     // the dispatch onClose SUCCESS path. The previous code marked the item
@@ -2528,8 +2553,11 @@ async function main() {
     // sweep is the thing that speaks to humans.
     Promise.resolve(sweepObligations())
       .then((s) => {
-        if (s.acked || s.progressed || s.staled || s.interrupted) {
-          console.log(`[daemon] assurance sweep — acked:${s.acked} progress:${s.progressed} stale:${s.staled} interrupted:${s.interrupted} closed:${s.closed} (open:${s.swept})`);
+        if (s.acked || s.suppressed || s.staled || s.interrupted) {
+          // `suppressed` is the room budget doing its job — it is logged
+          // BECAUSE it is the quiet half: a sweep that says nothing must still
+          // be able to prove it decided to say nothing.
+          console.log(`[daemon] assurance sweep — interim:${s.acked} suppressed:${s.suppressed} stale:${s.staled} interrupted:${s.interrupted} closed:${s.closed} (open:${s.swept})`);
         }
       })
       .catch((err) => console.error("[daemon] assurance sweep error:", err.message));

package/scripts/daemon/agent-daemon.test.mjs

@@ -683,13 +683,22 @@ test("ELECTION: an @mention/named-address responds WITHOUT calling electResponde
   cls._resetAgentRegistry();
 });
 
-test("FAIL-SAFE: no holding ack is posted when the reply session cannot run (claude unavailable)", async () => {
+test("FAIL-SAFE: an ask the reply session cannot answer is never promised one (claude unavailable)", async () => {
   resetState();
   // A slack DM — always directed, so this isolates the ack gate from the election.
   // is_dm is normally set by enrichItem; answerItem is called directly here, so
   // set it on the item as the poller/enrichment would.
   // Distinct channel + subject per run so the request-claim from one run does not
   // deny the other (the claim key is recipient + subject + action_type).
+  //
+  // WHAT THIS PINS SINCE 2026-09-12. Nothing is said at open time on any path
+  // any more — `openAndAcknowledge` writes the debt and returns — so the old
+  // control ("with claude available a holding ack IS attempted") no longer
+  // describes the system. The fail-safe itself is unchanged and is what this
+  // asserts: when the CLI that would answer cannot start, the debt is opened
+  // with the interim FORBIDDEN on the record, so no sweep in any later tick or
+  // process can post a promise the seat cannot keep.
+  const assurance = await import("./assurance.mjs");
   const mkItem = (tag) => ({ id: `MSG-ACK-${tag}`, raw_ref: `slack:DACK${tag}:1`, service: "slack", channel: "dm/ceo", channel_id: `DACK${tag}0001`, is_dm: true, sender: "ceo", content: "please draft the memo" });
   const baseDeps = (spy, claudeUp, tag) => ({
     classify: async () => ({ priority: "critical", action: "respond", model: "opus", summary: `draft memo ${tag}`, category: "action_required", directed_at_agent: true }),
@@ -699,19 +708,27 @@ test("FAIL-SAFE: no holding ack is posted when the reply session cannot run (cla
     claudeAvailable: () => claudeUp,
   });
 
-  // CONTROL: claude available ⇒ the ack path runs (holding message attempted).
+  // CONTROL: claude available ⇒ the debt is opened and an interim is PERMITTED
+  // later, by the sweep, after ACK_AFTER_MS and inside the room's budget.
   const up = { calls: 0, dispatched: false };
   await daemon.answerItem(mkItem("UP"), "slack", "slack:DACKUP:1", "trace-ack-up", baseDeps(up, true, "UP"));
-  assert.equal(up.calls, 1, "with claude available, a holding ack IS attempted");
+  assert.equal(up.calls, 0, "nothing is said at open time on ANY path — the interim belongs to the sweep");
   assert.equal(up.dispatched, true, "control: the session is dispatched");
+  const upRec = assurance.readObligation("slack:DACKUP:1");
+  assert.ok(upRec, "the debt exists");
+  assert.notEqual(upRec.interimForbidden, true, "and an interim is permitted for it");
 
-  // TREATMENT: claude unavailable ⇒ NO ack is emitted, but the session still runs
-  // (the assurance sweep owns the outcome; the human just isn't promised a reply).
+  // TREATMENT: claude unavailable ⇒ the interim is forbidden on the record, but
+  // the session still runs (the assurance sweep owns the outcome; the human
+  // just isn't promised a reply the seat cannot produce).
   const down = { calls: 0, dispatched: false };
   const res = await daemon.answerItem(mkItem("DN"), "slack", "slack:DACKDN:1", "trace-ack-down", baseDeps(down, false, "DN"));
-  assert.equal(down.calls, 0, "with claude unavailable, NO holding ack is posted before the working session");
+  assert.equal(down.calls, 0, "with claude unavailable, no interim is ever posted for this ask");
   assert.equal(down.dispatched, true, "the session is still dispatched");
   assert.equal(res.path, "session", "answerItem took the session path");
+  const downRec = assurance.readObligation("slack:DACKDN:1");
+  assert.ok(downRec, "the debt is opened all the same — an ask we cannot promise is exactly the one an operator must see");
+  assert.equal(downRec.interimForbidden, true, "durable on the record, because the sweep runs in another tick");
 });
 
 // ===========================================================================

package/scripts/daemon/assurance-e2e.test.mjs

@@ -207,10 +207,42 @@ test("SCENARIO 1 — a fast ask gets a direct answer, with no pointless holding
 });
 
 // ===========================================================================
-// SCENARIO 2 — A SLOW ASK. Acknowledged in milliseconds, updated, then answered.
+// SCENARIO 2 — A SLOW ASK. Silent for ninety seconds, one line, then answered.
+//
+// WHY THIS SCENARIO CHANGED ON 2026-09-12, AND WHY THE PROGRESS PING IS GONE
+//
+// It used to assert an acknowledgement at t≈0 and EXACTLY ONE progress ping at
+// six minutes. Both assertions were faithful to the code and both encoded the
+// defect that code had become.
+//
+// Measured over fourteen days in org_default_adaptic: 10,667 agent messages, of
+// which 3,069 (28.8%) were opening acknowledgements and 961 (9.0%) were progress
+// nags — 37.8% of everything this fleet said carried no content at all. 272 of
+// those acknowledgements were never followed by a substantive reply inside an
+// hour, i.e. the promise in them ("I'll come back as soon as I've got
+// something") was simply not kept. Agent-to-human volume went from 2:1 to 158:1
+// in a fortnight, and 9,187 of ~11,400 messages in 21 days landed in ONE
+// channel from eight agents, ~45% of them exact duplicates. Sampled live at
+// 06:32Z: "Still on this — 5 minutes in" beside "Still going — 15 minutes in"
+// at the SAME timestamp, two independent per-obligation timers narrating one
+// piece of overlapping work.
+//
+// The progress ping could not have been better written. `composeProgress` was a
+// pure function of `now - openedAt`; nothing read the session's stdout, its
+// tool calls or its partial findings, so the message could not contain anything
+// a reader could not already see on the clock. A message that says only what
+// the timestamp says is not an update. It is deleted, and this scenario now
+// asserts that NONE is emitted — not because the assertion was wrong about the
+// code, but because the behaviour it pinned was the bug.
+//
+// What replaces it: silence below ACK_AFTER_MS (the typing indicator is the
+// acknowledgement), then AT MOST ONE bespoke line, and only if the room has not
+// already heard one inside its budget window. Beyond that the agent either says
+// something with content in it — the plan the session itself stated — or it says
+// nothing and lets the answer be the answer.
 // ===========================================================================
 
-test("SCENARIO 2 — a slow ask is acknowledged at once, updated while it runs, then answered", async () => {
+test("SCENARIO 2 — a slow ask is silent, then gets ONE line, then the answer — and no progress nag", async () => {
   const ask = "with that in mind, fix these issues you just noted please and push their fixes to git";
   beginScenario("SCENARIO 2 — SLOW ASK (the owner's actual message)", ask);
   const item = makeItem("SLOW-1", ask);
@@ -224,23 +256,45 @@ test("SCENARIO 2 — a slow ask is acknowledged at once, updated while it runs,
     dispatch: (_p, _it, _cr, _s, opts) => { onCloseHook = opts.onClose; },
   });
 
-  const ack = transcript.find((m) => m.kind === "ack");
-  assert.ok(ack, "the acknowledgement must go out");
-  assert.ok(ack.ms < 1000, `acknowledged in ${ack.ms}ms`);
-  assert.match(ack.text, /git fixes/i, "the ack is bespoke to the actual ask, not a rotation pick");
-  assert.doesNotMatch(ack.text, /^(on it|looking now)[.!—]?\s*$/i, "never the retired canned lines");
-  assert.ok(ack.text.length <= 120, "the ack is one short human line, not a templated paragraph");
-
+  assert.equal(transcript.length, 0, "NOTHING at t=0 — the reflex ack is what 3,069 content-free messages were");
   const key = assurance.openObligations()[0].key;
-  note("obligation opened and acknowledged; session running");
+  assert.equal(assurance.readObligation(key).state, "open", "the DEBT is opened all the same: silence about timing is not silence about outcome");
+  note("obligation opened, nothing said; session running");
 
-  // ── 6 minutes later: still working. The sweep speaks rather than let the
-  //    human sit behind a typing indicator wondering.
-  let virtual = 6 * 60_000;
+  // ── Thirty seconds in: still nothing. Below ACK_AFTER_MS the typing
+  //    indicator is the acknowledgement.
+  let virtual = 30_000;
   const clock = () => virtual;
-  const deps = { deliverImpl: transport(clock), spokeSinceImpl: () => false };
-  let stats = await assurance.sweepObligations({ now: Date.now() + virtual, deps });
-  assert.equal(stats.progressed, 1, "long work must produce an interim update");
+  const deps = () => ({
+    deliverImpl: transport(clock),
+    spokeSinceImpl: () => false,
+    generateAckImpl: async () => "Taking the git fixes now — push coming.",
+  });
+  let stats = await assurance.sweepObligations({ now: Date.now() + virtual, deps: deps() });
+  assert.equal(stats.acked, 0);
+  assert.equal(transcript.length, 0, "under ninety seconds, silence is the right answer");
+
+  // ── Two minutes in: ONE line, specific to the ask.
+  virtual = 2 * 60_000;
+  stats = await assurance.sweepObligations({ now: Date.now() + virtual, deps: deps() });
+  assert.equal(stats.acked, 1, "past ACK_AFTER_MS the human gets exactly one line");
+  const ack = transcript.find((m) => m.kind === "ack");
+  assert.ok(ack, "…and it is that line");
+  assert.match(ack.text, /git fixes/i, "bespoke to the actual ask, not a rotation pick");
+  assert.doesNotMatch(ack.text, /^(on it|looking now|checking|one moment|got it|will do)\b/i, "never a generic opener — the sanitiser now enforces the prompt");
+  assert.ok(ack.text.length <= 120, "one short human line, not a templated paragraph");
+
+  // ── Six minutes in — where the progress ping used to land. NOTHING.
+  virtual = 6 * 60_000;
+  stats = await assurance.sweepObligations({ now: Date.now() + virtual, deps: deps() });
+  assert.equal(stats.acked, 0);
+  const progressish = transcript.filter((m) => /still (on this|going)/i.test(m.text));
+  assert.equal(progressish.length, 0, "a message that is a pure function of elapsed minutes cannot carry progress");
+
+  // ── Sixteen minutes: and still nothing, however long it runs.
+  virtual = 16 * 60_000;
+  await assurance.sweepObligations({ now: Date.now() + virtual, deps: deps() });
+  assert.equal(transcript.length, 1, `the whole wait costs the human ONE message, got ${transcript.length}`);
 
   // ── 17 minutes: the session finally answers the human itself.
   virtual = 17 * 60_000;
@@ -251,9 +305,8 @@ test("SCENARIO 2 — a slow ask is acknowledged at once, updated while it runs,
 
   const rec = assurance.readObligation(key);
   assert.equal(rec.state, "answered", "the debt is discharged by evidence of a delivered reply");
-  const progress = transcript.filter((m) => m.kind === "progress");
-  assert.equal(progress.length, 1);
   assert.equal(transcript.filter((m) => m.kind === "ack").length, 1, "acknowledge once, never twice");
+  assert.equal(transcript.filter((m) => m.kind === "progress").length, 0, "and never a progress ping — the branch that emitted them is deleted");
   note("obligation discharged by receipt — the daemon added nothing on top of the session's own answer", virtual);
 });
 
@@ -275,7 +328,10 @@ test("SCENARIO 3 — a timing-out session tells the human what happened and that
     dispatch: (_p, _it, _cr, _s, opts) => { onCloseHook = opts.onClose; },
   });
   const key = assurance.openObligations().find((o) => o.key === item.raw_ref).key;
-  assert.ok(transcript.find((m) => m.kind === "ack"));
+  // Nothing has been said yet — the ask is 45 minutes old in VIRTUAL time only,
+  // and the sweep has not run. What matters for this scenario is that the debt
+  // exists, so the failure has somewhere to be reported from.
+  assert.equal(transcript.length, 0, "silence is the default; the failure notice below is the first thing this human hears");
 
   // 45 minutes in, the dispatcher's SIGTERM lands and the session closes 143.
   const virtual = { v: 45 * 60_000 };