@cohortapp/agent-sdk 2.15.0 → 2.17.0

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 };