@cohortapp/agent-sdk 2.11.15 → 2.13.0

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

@@ -47,6 +47,17 @@ const AGENT_DIR = mkdtempSync(join(tmpdir(), "maestro-assurance-e2e-"));
 process.env.AGENT_DIR = AGENT_DIR;
 process.env.AGENT_ROOT = AGENT_DIR;
 process.env.MAESTRO_DAEMON_NO_AUTOSTART = "1";
+// HERMETICITY. `receipts.recordOutbound` attributes a send to an obligation and
+// a session from AMBIENT ENV when the caller does not name them — the seam that
+// lets a CLI send lane inside a spawned session attribute itself. Run this file
+// from inside a live maestro session and those variables are inherited, so the
+// receipt SCENARIO 2 writes to prove "the session answered" is stamped with a
+// DIFFERENT debt's key and reads back as `attributed-elsewhere`. The scenario
+// then fails on a real machine and passes on a bare CI runner, which is the
+// wrong way round for a test to be environment-sensitive.
+delete process.env.MAESTRO_OBLIGATION_KEY;
+delete process.env.MAESTRO_SESSION_ID;
+delete process.env.AGENT_SESSION_ID;
 
 let daemon, assurance, receipts;
 
@@ -103,10 +114,16 @@ function transport(virtualClock = () => null) {
   };
 }
 
-/** The daemon's ack seam, shaped exactly like responder.sendHoldingMessage. */
-function ackSeam() {
+/** The daemon's ack seam, shaped exactly like responder.sendHoldingMessage:
+ *  the line is GENERATED (here through the REAL generateAck with an injected
+ *  runner — no spawn in tests), and a failed generation means silence, never
+ *  a canned fallback. */
+function ackSeam(runImpl) {
   return async (item, classResult) => {
-    const text = assurance.composeAck(item, classResult);
+    const text = await assurance.generateAck(item, classResult, {
+      runImpl: runImpl || (async () => "Taking the git fixes now — push coming shortly."),
+    });
+    if (text == null) return { sent: false, holdingText: null, error: "ack_generation_failed", genFailed: true };
     heard("ack", text);
     return { sent: true, holdingText: text, via: "fake" };
   };
@@ -136,6 +153,24 @@ function makeItem(id, content) {
   return item;
 }
 
+/**
+ * Every scenario injects both seams that would otherwise spawn: `dispatch` (no
+ * child process) and `sendHoldingMessage` (the ack line comes from an injected
+ * runner). No scenario in this file ever needs the real `claude` binary.
+ *
+ * The daemon's ack path is nevertheless gated on `claudeAvailable()` — a
+ * NECESSARY production fail-safe (never post "on it" when the CLI that would
+ * answer cannot start). Left to the real probe, that gate reads a fact about
+ * the MACHINE, not about the scenario: these tests pass on a developer box with
+ * the CLI installed and suppress every acknowledgement on a CI runner without
+ * it. That is precisely how SCENARIOS 2, 3 and 6 came to be red on main and
+ * green everywhere they were written. The premise is declared here instead.
+ *
+ * The gate's false branch is not untested by this — see "the ack is suppressed
+ * when the CLI is unavailable" at the end of this file.
+ */
+const CLI_PRESENT = () => true;
+
 const COMPLEX = {
   priority: "critical", action: "respond", model: "opus", category: "action_required",
   directed_at_agent: true, summary: "Fix the issues you just noted and push the fixes to git",
@@ -152,6 +187,7 @@ test("SCENARIO 1 — a fast ask gets a direct answer, with no pointless holding
 
   let holdingCalls = 0;
   await daemon.processItem(item, "cohort", {
+    claudeAvailable: CLI_PRESENT,
     classify: async () => ({ priority: "normal", action: "respond", model: "sonnet", category: "question", directed_at_agent: true, summary: "board call time" }),
     isQuickReply: () => true,
     sendQuickResponse: async (it) => {
@@ -181,6 +217,7 @@ test("SCENARIO 2 — a slow ask is acknowledged at once, updated while it runs,
 
   let onCloseHook = null;
   await daemon.processItem(item, "cohort", {
+    claudeAvailable: CLI_PRESENT,
     classify: async () => COMPLEX,
     isQuickReply: () => false,
     sendHoldingMessage: ackSeam(),
@@ -189,9 +226,10 @@ test("SCENARIO 2 — a slow ask is acknowledged at once, updated while it runs,
 
   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 — the old path budgeted 60,000ms and missed 2 times in 3`);
-  assert.match(ack.text, /on it|looking now|digging in/i);
-  assert.ok(ack.text.length <= 40, "the ack is one short human line, not a templated paragraph");
+  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");
 
   const key = assurance.openObligations()[0].key;
   note("obligation opened and acknowledged; session running");
@@ -230,6 +268,7 @@ test("SCENARIO 3 — a timing-out session tells the human what happened and that
 
   let onCloseHook = null;
   await daemon.processItem(item, "cohort", {
+    claudeAvailable: CLI_PRESENT,
     classify: async () => ({ ...COMPLEX, summary: "Reconcile July spend against forecast" }),
     isQuickReply: () => false,
     sendHoldingMessage: ackSeam(),
@@ -265,6 +304,7 @@ test("SCENARIO 4 — a crashing session tells the human it failed, stops, and es
 
   let onCloseHook = null;
   await daemon.processItem(item, "cohort", {
+    claudeAvailable: CLI_PRESENT,
     classify: async () => ({ ...COMPLEX, summary: "Draft the Q3 investor update" }),
     isQuickReply: () => false,
     sendHoldingMessage: ackSeam(),
@@ -299,6 +339,7 @@ test("SCENARIO 5 — a session that exits 0 without replying no longer passes as
 
   let onCloseHook = null;
   await daemon.processItem(item, "cohort", {
+    claudeAvailable: CLI_PRESENT,
     classify: async () => ({ ...COMPLEX, summary: "Check whether the migration landed cleanly" }),
     isQuickReply: () => false,
     sendHoldingMessage: ackSeam(),
@@ -333,6 +374,7 @@ test("SCENARIO 6 — a debt orphaned by a daemon restart is spoken to on the nex
   const item = makeItem("ORPHAN-1", ask);
 
   await daemon.processItem(item, "cohort", {
+    claudeAvailable: CLI_PRESENT,
     classify: async () => ({ ...COMPLEX, summary: "Fix DNS on the staging domain" }),
     isQuickReply: () => false,
     sendHoldingMessage: ackSeam(),
@@ -357,6 +399,65 @@ test("SCENARIO 6 — a debt orphaned by a daemon restart is spoken to on the nex
   note("previously: the typing dot stopped and that was the last the human ever heard", 30_000);
 });
 
+// ===========================================================================
+// SCENARIO 6b — A PEER AGENT'S ACK ARRIVES AS INBOUND. The dispatch gate reads
+// it, and NEITHER an ack goes out NOR a session spawns — the machinery half of
+// the 25/27/30 Aug loop, closed at the gate.
+// ===========================================================================
+
+test("SCENARIO 6b — an ack-shaped one-liner from a peer agent seat spawns nothing and acks nothing", async () => {
+  const echoAck = "On it — taking a look now.";
+  beginScenario("SCENARIO 6b — PEER AGENT ACK (emitter-class inbound)", echoAck);
+  const item = {
+    id: "PEER-ACK-1",
+    raw_ref: "cohort:dm-a016-a039:PEER-ACK-1",
+    message_id: "PEER-ACK-1",
+    service: "cohort",
+    channel: "dm-a016-a039", // an agent↔agent DM — the structural seat signal
+    channel_id: "CDM-PEER-ACK-1",
+    is_dm: true,
+    sender: "Piotr Novak",
+    sender_id: "A039",
+    content: echoAck,
+  };
+  writeFileSync(join(AGENT_DIR, "state", "inbox", "cohort", "PEER-ACK-1.yaml"), "id: PEER-ACK-1\n");
+
+  let holdingCalls = 0;
+  let dispatched = 0;
+  await daemon.processItem(item, "cohort", {
+    claudeAvailable: CLI_PRESENT,
+    classify: async () => ({ ...COMPLEX, summary: "peer says it's on it" }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => { holdingCalls++; return { sent: true, holdingText: "x" }; },
+    dispatch: () => { dispatched++; },
+  });
+
+  assert.equal(holdingCalls, 0, "no acknowledgement at machinery");
+  assert.equal(dispatched, 0, "and no session burned answering a reflex");
+  assert.equal(transcript.length, 0, "the peer seat hears nothing");
+  assert.ok(!assurance.openObligations().some((o) => o.key === item.raw_ref), "no debt opened for emitter-class inbound");
+  // The refusal is on the audit trail — same log family as the self-echo drops.
+  const { readFileSync } = await import("node:fs");
+  const drops = readFileSync(join(AGENT_DIR, "logs", "daemon", "dispatch-gate-drops.jsonl"), "utf-8")
+    .split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  const drop = drops.find((d) => d.raw_ref === item.raw_ref);
+  assert.ok(drop, "the gate refusal is audited");
+  assert.equal(drop.reason, "peer-ack-shaped");
+  note("gate refusal audited to logs/daemon/dispatch-gate-drops.jsonl; item retired");
+
+  // The CONTRAST: the same shape from a human sender still gets the full path.
+  const humanItem = makeItem("HUMAN-TERSE-1", "On it — will do.");
+  let humanDispatched = 0;
+  await daemon.processItem(humanItem, "cohort", {
+    claudeAvailable: CLI_PRESENT,
+    classify: async () => COMPLEX,
+    isQuickReply: () => false,
+    sendHoldingMessage: ackSeam(async () => "Got it — I'll pick this up now."),
+    dispatch: () => { humanDispatched++; },
+  });
+  assert.equal(humanDispatched, 1, "a human's terse line is still worked on");
+});
+
 // ===========================================================================
 // SCENARIO 7 — TWO ASKS, ONE ROOM. The owner sends a second thing before the
 // first is done. One session answers; the other exits 0 in silence.
@@ -420,3 +521,37 @@ test("SCENARIO 7 — a second ask in the same DM is not discharged by the first
   assert.match(rescue.text, /race between the poller's lock release/, "and B's actual work reaches the human");
   note("previously: B closed as `answered` on A's receipt — zero messages, ask gone");
 });
+
+// ===========================================================================
+// THE GATE'S OTHER SIDE — the fail-safe every scenario above suppresses.
+// ===========================================================================
+
+/**
+ * Mutation proof for `CLI_PRESENT`. Every scenario above declares the CLI
+ * present so that the ack path is exercised rather than skipped; this asserts
+ * the branch they are stepping over still behaves. Flip `CLI_PRESENT` to
+ * `() => false` and the scenarios go red; delete the `claudeAvailable` seam
+ * from THIS test and it goes red on any box with the CLI installed.
+ */
+test("the ack is suppressed when the CLI is unavailable — but the debt is still opened", async () => {
+  const ask = "rebuild the index and tell me when it's done";
+  beginScenario("CLI UNAVAILABLE — silence with a tracked debt, never a promise", ask);
+  const item = makeItem("NO-CLI-1", ask);
+
+  let dispatched = 0;
+  await daemon.processItem(item, "cohort", {
+    claudeAvailable: () => false,
+    classify: async () => COMPLEX,
+    isQuickReply: () => false,
+    sendHoldingMessage: ackSeam(),
+    dispatch: () => { dispatched++; },
+  });
+
+  assert.equal(transcript.filter((m) => m.kind === "ack").length, 0,
+    "never promise a reply the CLI that would write it cannot start");
+  const rec = assurance.openObligations().find((o) => o.key === item.raw_ref);
+  assert.ok(rec, "the debt is opened anyway — silence is compensated by the sweep, not forgotten");
+  assert.equal(rec.state, "open");
+  assert.equal(dispatched, 1, "the work is still attempted; only the promise is withheld");
+  note("no ack, obligation open: the assurance sweep owns the compensation");
+});