@cohortapp/agent-sdk 2.11.15 → 2.13.0

package/scripts/daemon/assurance.test.mjs

@@ -29,10 +29,13 @@ const receipts = await import("../../lib/comms/receipts.mjs");
 
 const {
   shouldAcknowledge,
-  composeAck,
+  generateAck,
+  sanitiseAckText,
   composeProgress,
   composeFailure,
   composeSilentSuccess,
+  isOwnNarratorText,
+  SILENT_SUCCESS_EXCERPT_LIMIT,
   classifyFailure,
   openAndAcknowledge,
   settleSession,
@@ -46,6 +49,7 @@ const {
   STALE_AFTER_MS,
   INTERRUPT_GRACE_MS,
   ACK_MAX_ATTEMPTS,
+  ACK_GEN_MAX_FAILURES,
   RETRY_MAX,
 } = assurance;
 
@@ -55,7 +59,11 @@ after(() => { try { rmSync(ROOT, { recursive: true, force: true }); } catch { /*
 // Fakes
 // ---------------------------------------------------------------------------
 
-/** A transport that records what a human would have read, and can be told to fail. */
+/** A transport that records what a human would have read, and can be told to fail.
+ *  The ackSender mirrors responder.sendHoldingMessage's NEW contract exactly:
+ *  a generated bespoke line on success, and `{sent:false, holdingText:null,
+ *  genFailed:true}` — i.e. deliberate silence — when generation fails. */
+const FAKE_ACK_LINE = "Give me a few minutes on the git fixes.";
 function fakeTransport(opts = {}) {
   const sent = [];
   let failures = opts.failTimes || 0;
@@ -65,7 +73,8 @@ function fakeTransport(opts = {}) {
     return { sent: true, via: "fake", channel: item.channel_id || item.channel };
   };
   return { sent, impl, ackSender: async (item, cr) => {
-    const text = composeAck(item, cr);
+    if (opts.genFail) return { sent: false, holdingText: null, error: "ack_generation_failed", genFailed: true };
+    const text = opts.ackText || FAKE_ACK_LINE;
     const r = await impl(item, text, { kind: "ack" });
     return { sent: r.sent, holdingText: text, error: r.error };
   } };
@@ -120,52 +129,268 @@ describe("shouldAcknowledge — the simple/complex distinction", () => {
     const orphan = { ...ITEM, channel_id: null, channel: null };
     assert.equal(shouldAcknowledge({ willSpawnSession: true, item: orphan, source: "inbox" }).ack, false);
   });
+
+  test("REGRESSION: the agent's OWN echoed message is never acknowledged (self-echo guard #2)", async () => {
+    // 25/27/30 Aug 2026: the poll lane re-ingested the agent's own outbound
+    // sends and the daemon said "Looking now." to itself — in shared DMs two
+    // agents traded canned acks at each other. Ingestion now drops echoes
+    // (agent-daemon + self-echo.mjs); this is the second, independent guard on
+    // the ack decision itself.
+    const { writeFileSync } = await import("node:fs");
+    const selfEcho = await import("./lib/self-echo.mjs");
+    mkdirSync(join(ROOT, "config"), { recursive: true });
+    writeFileSync(join(ROOT, "config", "agent.json"), JSON.stringify({
+      firstName: "Isla", fullName: "Isla Roselli", memberId: "cmqh0tcml004ihhl6zev6ocb5",
+    }));
+    selfEcho._resetSelfIdentity();
+    try {
+      // The REAL echoed shape: display name verbatim, spaces and all.
+      const echo = { ...ITEM, sender: "Isla Roselli" };
+      const v = shouldAcknowledge({ willSpawnSession: true, item: echo, source: "inbox" });
+      assert.equal(v.ack, false);
+      assert.equal(v.reason, "self-sender");
+      // The old filter's normalised form must ALSO match — it is how the echo
+      // slipped through three times.
+      assert.equal(shouldAcknowledge({ willSpawnSession: true, item: { ...ITEM, sender: "isla-roselli" }, source: "inbox" }).ack, false);
+      // And a genuine human sender still gets their acknowledgement.
+      assert.equal(shouldAcknowledge({ willSpawnSession: true, item: ITEM, source: "inbox" }).ack, true);
+    } finally {
+      rmSync(join(ROOT, "config", "agent.json"), { force: true });
+      selfEcho._resetSelfIdentity();
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 1b. THE DISPATCH GATE READS THE INBOUND — a seat must not ack (and its
+//     caller must not spawn) on output its own emitter class produces.
+// ---------------------------------------------------------------------------
+
+describe("shouldAcknowledge — the dispatch gate reads item.content", () => {
+  // A peer AGENT seat, identified structurally (seat-slug id / agent↔agent DM),
+  // never by name.
+  const PEER_ACK = {
+    ...ITEM,
+    sender: "Piotr Novak",
+    sender_id: "A039",
+    content: "On it — taking a look now.",
+  };
+
+  test("REGRESSION: an ack-shaped one-liner from a peer agent seat gets NO ack and signals NO spawn", () => {
+    const v = shouldAcknowledge({ willSpawnSession: true, item: PEER_ACK, source: "inbox" });
+    assert.equal(v.ack, false);
+    assert.equal(v.reason, "peer-ack-shaped");
+    assert.equal(v.emitterClass, true, "the caller reads this to skip the session spawn too");
+  });
+
+  test("the SHAPE matches, not a phrase list — every 'Looking now' variant from a seat is refused", () => {
+    for (const content of ["On it.", "Looking now", "Taking the git fixes now — push coming.", "Still digging into this."]) {
+      const v = shouldAcknowledge({ willSpawnSession: true, item: { ...PEER_ACK, content }, source: "inbox" });
+      assert.equal(v.ack, false, `"${content}" is ack-shaped`);
+      assert.equal(v.emitterClass, true);
+    }
+  });
+
+  test("an agent↔agent DM channel is an agent-seat signal too", () => {
+    const v = shouldAcknowledge({
+      willSpawnSession: true,
+      item: { ...ITEM, sender: "Piotr Novak", channel: "dm-a016-a039", content: "On it." },
+      source: "inbox",
+    });
+    assert.equal(v.ack, false);
+    assert.equal(v.reason, "peer-ack-shaped");
+  });
+
+  test("the SAME short line from a HUMAN sender passes — shape alone is not enough", () => {
+    // No seat-slug id, no agent DM channel: treated as human, and a human's
+    // terse "On it" must never be met with silence.
+    const v = shouldAcknowledge({ willSpawnSession: true, item: { ...ITEM, content: "On it — will do." }, source: "inbox" });
+    assert.equal(v.ack, true);
+  });
+
+  test("a QUESTION or a REQUEST from a peer agent seat still passes the gate", () => {
+    for (const content of [
+      "did the migration land cleanly?",
+      "please push the fix to git",
+      "can you rerun the failing suite",
+      "fix the flaky poller test and push it",
+    ]) {
+      const v = shouldAcknowledge({ willSpawnSession: true, item: { ...PEER_ACK, content }, source: "inbox" });
+      assert.equal(v.ack, true, `"${content}" is substantive and must pass`);
+    }
+  });
+
+  test("an INFORMATION-BEARING terse line from a peer agent seat passes — facts, links, decisions and completions are not acks", () => {
+    // Re-review finding on d5abda3: the shape test alone consumed essentially
+    // every terse peer utterance — including decision grants and direct
+    // answers to questions this seat asked — and a false consume is silent to
+    // the sender and unrecoverable. Only commitment-shaped acks may be eaten.
+    for (const content of [
+      "Runway is 14 months.",           // carries a fact (digit)
+      "Yes.",                            // direct answer
+      "No.",                             // direct answer
+      "Approved.",                       // decision grant
+      "Go ahead.",                       // decision grant
+      "LGTM.",                           // review verdict
+      "Ship it.",                        // decision grant
+      "Done.",                           // completion report
+      "Merged.",                         // completion report
+      "Deployed, all green.",            // completion report
+      "Spec is at https://example.com/doc", // carries a link
+    ]) {
+      const v = shouldAcknowledge({ willSpawnSession: true, item: { ...PEER_ACK, content }, source: "inbox" });
+      assert.equal(v.ack, true, `"${content}" is information-bearing and must pass`);
+    }
+  });
+
+  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. …"
+      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(),
+      composeSilentSuccess({}, {}),
+      composeSilentSuccess({}, { finalText: "Here is what I found before it died." }),
+    ];
+    for (const content of narrations) {
+      const v = shouldAcknowledge({ willSpawnSession: true, item: { ...ITEM, content }, source: "inbox" });
+      assert.equal(v.ack, false, `narrator line must be refused: "${content.slice(0, 50)}…"`);
+      assert.equal(v.reason, "own-narrator-pattern");
+      assert.equal(v.emitterClass, true);
+    }
+  });
+
+  test("a human QUOTING a narrator line inside a longer message still passes (anchored full match)", () => {
+    const content = `why did you send me this?\n\n${composeSilentSuccess({}, {})}`;
+    const v = shouldAcknowledge({ willSpawnSession: true, item: { ...ITEM, content }, source: "inbox" });
+    assert.equal(v.ack, true);
+  });
+
+  test("a genuine substantive ask is untouched by the gate", () => {
+    const v = shouldAcknowledge({ willSpawnSession: true, item: ITEM, source: "inbox" });
+    assert.equal(v.ack, true);
+    assert.equal(v.reason, "session-dispatched");
+  });
+
+  test("every refusal is AUDITED — one JSONL row, self-echo-drop style", async () => {
+    const { readFileSync, rmSync: rm } = await import("node:fs");
+    const auditPath = join(ROOT, "logs", "daemon", "dispatch-gate-drops.jsonl");
+    try { rm(auditPath, { force: true }); } catch { /* */ }
+    shouldAcknowledge({ willSpawnSession: true, item: PEER_ACK, source: "inbox" });
+    shouldAcknowledge({ willSpawnSession: true, item: { ...ITEM, content: composeSilentSuccess({}, {}) }, source: "inbox" });
+    const rows = readFileSync(auditPath, "utf-8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+    assert.equal(rows.length, 2);
+    assert.equal(rows[0].stage, "dispatch-gate");
+    assert.equal(rows[0].reason, "peer-ack-shaped");
+    assert.equal(rows[0].sender, "Piotr Novak");
+    assert.equal(rows[1].reason, "own-narrator-pattern");
+  });
 });
 
 // ---------------------------------------------------------------------------
-// 2. THE ACKNOWLEDGEMENT — composed, not generated
+// 2. THE ACKNOWLEDGEMENT — one bespoke generated line, or SILENCE. Never a
+//    canned rotation (CEO directive, 2026-08-30).
 // ---------------------------------------------------------------------------
 
-describe("composeAck", () => {
-  test("is instant and deterministic — no model, no I/O, no timeout to lose", () => {
-    const t0 = process.hrtime.bigint();
-    const a = composeAck(ITEM, CLASS_COMPLEX);
-    const elapsedMs = Number(process.hrtime.bigint() - t0) / 1e6;
-    assert.ok(elapsedMs < 5, `ack composition took ${elapsedMs}ms; it must be effectively free`);
-    assert.equal(a, composeAck(ITEM, CLASS_COMPLEX), "same input must give the same words");
+describe("generateAck — bespoke line or silence, never boilerplate", () => {
+  test("the model's line is used verbatim once stripped to one clean line", async () => {
+    const a = await generateAck(ITEM, CLASS_COMPLEX, {
+      runImpl: async () => '```\n"Taking the poller fixes now — push coming."\n```',
+    });
+    assert.equal(a, "Taking the poller fixes now — push coming.");
+  });
+
+  test("REGRESSION: a failing generator yields NULL — the caller sends NOTHING, no canned fallback", async () => {
+    // The retired behaviour rotated "On it." / "Looking now." / "On it —
+    // digging in now." when convenient. The CEO's verdict: a reflex string is
+    // worse than no ack. Null is the contract for "say nothing".
+    const a = await generateAck(ITEM, CLASS_COMPLEX, {
+      runImpl: async () => { throw new Error("claude CLI spawn error: ENOENT"); },
+    });
+    assert.equal(a, null);
+  });
+
+  test("a HANGING generator is cut off at the budget and yields NULL", async () => {
+    const a = await generateAck(ITEM, CLASS_COMPLEX, {
+      timeoutMs: 25,
+      runImpl: () => new Promise(() => { /* never settles */ }),
+    });
+    assert.equal(a, null);
+  });
+
+  test("unusable output — empty, essay-length, refusals, assistant filler — yields NULL", () => {
+    assert.equal(sanitiseAckText(""), null);
+    assert.equal(sanitiseAckText("   \n\n  "), null);
+    assert.equal(sanitiseAckText("x".repeat(300)), null, "a paragraph is a reply, not an ack");
+    assert.equal(sanitiseAckText("I cannot help with that request."), null);
+    assert.equal(sanitiseAckText("I'm here to help! Let me know if you need anything else."), null);
   });
 
-  test("is one short human line — no filler, no promise-of-followup boilerplate", () => {
-    const a = composeAck(ITEM, CLASS_COMPLEX);
-    assert.ok(a.length <= 40, `an ack is one short line, got ${a.length} chars: ${a}`);
-    // The templated filler communication-style.md bans.
-    assert.doesNotMatch(a, /either way|full answer|within a few minutes|within 10-20|I want to get this right|hear from me|come back to you/i);
+  test("multi-line output is reduced to the FIRST usable line", () => {
+    assert.equal(
+      sanitiseAckText("Taking the poller fixes now.\nsecond line that must not leak"),
+      "Taking the poller fixes now.",
+    );
   });
 
-  test("degrades gracefully when the classifier gave nothing to go on", () => {
-    const a = composeAck(ITEM, {});
-    assert.ok(a.length > 0);
-    assert.doesNotMatch(a, /\(.*\)/, "no parenthetical aside");
+  test("REGRESSION: assistant-y openers are rejected — 'Sure — here it is:' is a chatbot, not a colleague", () => {
+    for (const t of [
+      "Sure — here it is:",
+      "Sure, taking a look at the git fixes.",
+      "Certainly! On the deck now.",
+      "Absolutely — picking the poller fix up.",
+      "Happy to — starting on the memo.",
+      "Of course, I'll dig into the runway numbers.",
+    ]) {
+      assert.equal(sanitiseAckText(t), null, `"${t}" must be rejected`);
+    }
+    // …while a plain colleague line still passes untouched.
+    assert.equal(sanitiseAckText("Taking the git fixes now — push coming."), "Taking the git fixes now — push coming.");
+  });
+
+  test("REGRESSION: the canned rotation is GONE from the module, not merely bypassed", async () => {
+    const { readFileSync } = await import("node:fs");
+    const src = readFileSync(new URL("./assurance.mjs", import.meta.url), "utf-8");
+    // The three retired strings may survive in comments as history, but never
+    // as a string-literal ARRAY a code path could pick from.
+    assert.doesNotMatch(src, /\[\s*"On it\.",/, "the canned rotation array must not exist");
+  });
+});
+
+describe("composeSilentSuccess — a finished answer is delivered, not silently clipped", () => {
+  const LIMIT = SILENT_SUCCESS_EXCERPT_LIMIT;
+
+  test("a normal multi-point answer (over the old 900 cap) comes through WHOLE", () => {
+    // The exact failure mode the old cap produced: a substantive multi-point
+    // answer, ~1200 chars — comfortably over the old 900 cap, well under the new
+    // budget. The reader must get every word, with no ellipsis and no marker.
+    const answer =
+      "Queue placement. A discrete task I own lands cleanest in action-stack.yaml, " +
+      "not follow-ups.yaml — the latter is external commitments with due dates, and " +
+      "this is a capture I own, not a promise to a counterparty. ".repeat(16).trim();
+    assert.ok(answer.length > 900 && answer.length < LIMIT, "fixture must straddle old cap / new budget");
+    const out = composeSilentSuccess({}, { finalText: answer });
+    assert.ok(out.includes(answer), "the full answer must be present verbatim");
+    assert.ok(!out.includes("…"), "a whole answer carries no truncation ellipsis");
   });
 
-  test("REGRESSION: the classifier summary NEVER reaches the human — no '(CEO …)' bleed", () => {
-    // Owner screenshot, verbatim: the ack carried the classifier's internal
-    // summary in a parenthetical aside — "(CEO asking what machine/infrastructure
-    // is being used)" reached a real human. The summary is now stored on the
-    // obligation for the board row but never shown in a message anyone reads.
-    const a = composeAck(ITEM, { ...CLASS_COMPLEX, summary: "CEO asking what machine/infrastructure is being used" });
-    assert.doesNotMatch(a, /CEO asking/i);
-    assert.doesNotMatch(a, /machine\/infrastructure/i);
-    assert.doesNotMatch(a, /\(.*\)/, "no parenthetical aside at all");
+  test("a genuinely huge output is bounded but truncated HONESTLY — count + resend offer, never a bare ellipsis", () => {
+    const huge = "x".repeat(LIMIT + 2000);
+    const out = composeSilentSuccess({}, { finalText: huge });
+    assert.ok(out.length < huge.length, "oversized output is bounded, not dumped whole");
+    assert.ok(out.includes(String(huge.length)), "must state the true full length so nothing is lost silently");
+    assert.match(out, /resend|full/i, "must offer a path to the dropped remainder");
   });
 
-  test("reads like a colleague, not a template — no internal framing shown to the human", () => {
-    // "Picking up:" is triage vocabulary and "It needs a bit of work" is the
-    // daemon explaining its own dispatch decision. Both leaked the machinery at
-    // the person being acknowledged.
-    const a = composeAck(ITEM, CLASS_COMPLEX);
-    assert.doesNotMatch(a, /picking up:/i);
-    assert.doesNotMatch(a, /needs a bit of work/i);
+  test("REGRESSION: a truncated recovery note is STILL recognised as the daemon's own narrator line (self-echo gate holds)", () => {
+    // If truncation broke narrator-recognition, the daemon would re-ingest and
+    // re-ack its own rescue message — the exact self-echo failure the gate exists
+    // to prevent. The honesty marker must live inside the variable excerpt slot.
+    const huge = "y".repeat(LIMIT + 2000);
+    const truncated = composeSilentSuccess({}, { finalText: huge });
+    assert.equal(isOwnNarratorText(truncated), true, "truncated silent-success must match a narrator pattern");
   });
 });
 
@@ -223,6 +448,34 @@ 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");
+    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");
+  });
+
   test("the stored summary keeps the classifier's casing — the board row and escalations read from it", async () => {
     // `rec.summary` feeds board-mirror's row title and the needs-attention
     // escalation record. A summary mangled at open time would resurface there.
@@ -375,19 +628,46 @@ describe("settleSession", () => {
 // ---------------------------------------------------------------------------
 
 describe("sweepObligations", () => {
-  test("retries an acknowledgement whose send failed", async () => {
+  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);
 
     const working = fakeTransport();
     const now = Date.now() + ACK_GRACE_MS + 1000;
-    const stats = await sweepObligations({ now, deps: { deliverImpl: working.impl, spokeSinceImpl: () => false } });
+    const stats = await sweepObligations({ now, deps: {
+      deliverImpl: working.impl,
+      spokeSinceImpl: () => false,
+      generateAckImpl: async () => "Back on the git fixes now.",
+    } });
     assert.equal(stats.acked, 1);
-    assert.match(working.sent[0].text, /on it|looking now|digging in/i);
+    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);
   });
 
+  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);
+
+    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: {
+        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})`);
+    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 } });
@@ -493,6 +773,91 @@ describe("sweepObligations", () => {
     assert.equal(stats.interrupted, 0);
   });
 
+  test("REGRESSION: a debt OWNED by another LIVE daemon is not ack-retried by this one (two-daemon narration)", async () => {
+    // Two live daemons on one AGENT_DIR both sweep the same ledger. The one
+    // that did NOT open this debt must not compensate its acknowledgement —
+    // 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 } });
+    assert.equal(r.acked, false);
+    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 working = fakeTransport();
+    const stats = await sweepObligations({
+      now: Date.now() + ACK_GRACE_MS + 1000,
+      deps: {
+        deliverImpl: working.impl,
+        spokeSinceImpl: () => false,
+        generateAckImpl: async () => "Back on this now.",
+        isPidAliveImpl: () => true, // the owner is provably alive
+      },
+    });
+    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);
+  });
+
+  test("…but once the owning daemon is DEAD, this daemon takes the ack over", async () => {
+    const failing = fakeTransport({ failTimes: 99 });
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: failing.ackSender } });
+    const rec = readObligation(r.key);
+    rec.daemonPid = process.pid + 99999;
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(r.key)}.json`), JSON.stringify(rec));
+
+    const working = fakeTransport();
+    const stats = await sweepObligations({
+      now: Date.now() + ACK_GRACE_MS + 1000,
+      deps: {
+        deliverImpl: working.impl,
+        spokeSinceImpl: () => false,
+        generateAckImpl: async () => "Picking your ask up now.",
+        isPidAliveImpl: () => false, // the owner is gone
+      },
+    });
+    assert.equal(stats.acked, 1, "an orphaned debt is this daemon's to speak to");
+    assert.equal(readObligation(r.key).acknowledged, true);
+  });
+
+  test("REGRESSION: a debt OWNED by another LIVE daemon gets no progress ping from this one", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const rec = readObligation(r.key);
+    rec.daemonPid = process.pid + 99999;
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(r.key)}.json`), JSON.stringify(rec));
+
+    const before = t.sent.length;
+    const stats = await sweepObligations({
+      now: Date.now() + PROGRESS_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => true },
+    });
+    assert.equal(stats.progressed, 0, "the live owner sends its own progress updates");
+    assert.equal(stats.interrupted, 0, "and a live owner is certainly not 'interrupted'");
+    assert.equal(t.sent.length, before);
+  });
+
+  test("…and a dead owner's debt DOES get this daemon's progress ping (after the interrupted notice is done)", async () => {
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
+    const rec = readObligation(r.key);
+    rec.daemonPid = process.pid + 99999;
+    rec.interruptedNotifiedAt = Date.now(); // the orphan apology already went out
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(join(ROOT, "state", "obligations", `${assurance.sanitiseKey(r.key)}.json`), JSON.stringify(rec));
+
+    const stats = await sweepObligations({
+      now: Date.now() + PROGRESS_AFTER_MS + 1000,
+      deps: { deliverImpl: t.impl, spokeSinceImpl: () => false, isPidAliveImpl: () => false },
+    });
+    assert.equal(stats.progressed, 1);
+    assert.match(t.sent.at(-1).text, /still on this/i);
+  });
+
   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
@@ -519,7 +884,7 @@ describe("sweepObligations", () => {
     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 } });
+    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");
   });
 });
@@ -639,10 +1004,10 @@ describe("attribution: which debt did that message actually discharge", () => {
     assert.equal(readObligation(r.key).acknowledged, false);
     receipts.recordOutbound({ service: "cohort", channel: "C-PRE", kind: "reply", agentRoot: ROOT });
 
-    const stats = await sweepObligations({ now: Date.now() + ACK_GRACE_MS + 1000, deps: { deliverImpl: t.impl } });
+    const stats = await sweepObligations({ now: Date.now() + ACK_GRACE_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.match(t.sent.at(-1).text, /on it|looking now|digging in/i);
+    assert.equal(t.sent.at(-1).text, "Finally picking your ask up now.");
   });
 });
 
@@ -690,7 +1055,7 @@ describe("channels with no transport", () => {
     const t0 = Date.now();
     let ticks = 0;
     for (let m = 1; m <= 60; m++) {
-      const s = await sweepObligations({ now: t0 + m * 60_000, deps: { deliverImpl: t.impl } });
+      const s = await sweepObligations({ now: t0 + m * 60_000, deps: { deliverImpl: t.impl, generateAckImpl: async () => FAKE_ACK_LINE } });
       ticks++;
       if (s.unreachable) break;
     }