@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/cadence-bus.test.mjs

@@ -1,720 +0,0 @@
-/**
- * cadence-bus.test.mjs — node:test coverage for the cadence bus primitive.
- *
- * Every test creates its own AGENT_ROOT under tmpdir() and cleans up.
- * No real network, no real Claude. Time is injectable via `now` arguments
- * where the API supports it; otherwise tests use real wall-clock with
- * generous epsilons.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "fs";
-import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, statSync } from "node:fs";
-import { tmpdir } from "os";
-import { join } from "path";
-
-import {
-  enqueueTick,
-  claimNextTick,
-  completeTick,
-  failTick,
-  requeueTick,
-  recoverStaleClaims,
-  sweepRetention,
-  writeJsonAtomic,
-  writeHealth,
-  readHealth,
-  busDepth,
-  ensureBusDirs,
-  bootstrapBus,
-  getBusPaths,
-  nextEventId,
-  listInbox,
-  listClaimed,
-  isProcessedId,
-  logBusEvent,
-  BUS_VERSION,
-} from "./cadence-bus.mjs";
-
-async function makeAgentRoot() {
-  const path = join(
-    tmpdir(),
-    `cadence-bus-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
-  );
-  await fsp.mkdir(path, { recursive: true });
-  return path;
-}
-
-async function rmRoot(path) {
-  try { await fsp.rm(path, { recursive: true, force: true }); } catch { /* */ }
-}
-
-// ---------------------------------------------------------------------------
-// Path resolution + bootstrap
-// ---------------------------------------------------------------------------
-
-test("getBusPaths derives every path under state/cadence-bus/", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const p = getBusPaths(root);
-    assert.equal(p.agentRoot, root);
-    assert.equal(p.base, join(root, "state/cadence-bus"));
-    assert.equal(p.inbox, join(root, "state/cadence-bus/inbox"));
-    assert.equal(p.claimed, join(root, "state/cadence-bus/claimed"));
-    assert.equal(p.processed, join(root, "state/cadence-bus/processed"));
-    assert.equal(p.dlq, join(root, "state/cadence-bus/dlq"));
-    assert.equal(p.queueJsonl, join(root, "state/cadence-bus/queue.jsonl"));
-    assert.equal(p.health, join(root, "state/cadence-bus/health.json"));
-    assert.equal(p.logsDir, join(root, "logs/cadence-bus"));
-  } finally { await rmRoot(root); }
-});
-
-test("ensureBusDirs is idempotent and writes VERSION marker", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const p = ensureBusDirs(root);
-    assert.ok(existsSync(p.inbox));
-    assert.ok(existsSync(p.claimed));
-    assert.ok(existsSync(p.processed));
-    assert.ok(existsSync(p.failed));
-    assert.ok(existsSync(p.dlq));
-    assert.ok(existsSync(p.logsDir));
-    assert.equal(readFileSync(p.version, "utf-8").trim(), BUS_VERSION);
-    // Calling again must not throw and must not duplicate the VERSION file.
-    ensureBusDirs(root);
-    ensureBusDirs(root);
-    assert.equal(readFileSync(p.version, "utf-8").trim(), BUS_VERSION);
-  } finally { await rmRoot(root); }
-});
-
-test("bootstrapBus writes .gitkeep stubs in every bus dir", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const p = bootstrapBus(root);
-    for (const d of [p.inbox, p.claimed, p.processed, p.failed, p.dlq, p.logsDir]) {
-      assert.ok(existsSync(join(d, ".gitkeep")), `.gitkeep missing in ${d}`);
-    }
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Event ids
-// ---------------------------------------------------------------------------
-
-test("nextEventId yields unique sortable ids", () => {
-  const ids = new Set();
-  for (let i = 0; i < 200; i++) ids.add(nextEventId());
-  assert.equal(ids.size, 200);
-  // Sortability: with a fixed clock, the ISO prefix is identical so the
-  // hex suffix breaks ties — pass an explicit clock to check.
-  const a = nextEventId(new Date(0));
-  const b = nextEventId(new Date(0));
-  assert.notEqual(a, b);
-  assert.match(a, /^evt-1970-01-01T00:00:00\.000Z-[0-9a-f]{8}$/);
-});
-
-// ---------------------------------------------------------------------------
-// Enqueue
-// ---------------------------------------------------------------------------
-
-test("enqueueTick rejects missing cadence", async () => {
-  const root = await makeAgentRoot();
-  try {
-    assert.throws(() => enqueueTick({ agentRoot: root }), /cadence is required/);
-  } finally { await rmRoot(root); }
-});
-
-test("enqueueTick writes inbox JSON + queue.jsonl audit row", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const out = enqueueTick({
-      cadence: "inbox-processor",
-      source: "launchd",
-      metadata: { note: "smoke" },
-      agentRoot: root,
-    });
-    assert.equal(out.fallbackOnly, false);
-    assert.ok(out.path);
-    const event = JSON.parse(readFileSync(out.path, "utf-8"));
-    assert.equal(event.cadence, "inbox-processor");
-    assert.equal(event.source, "launchd");
-    assert.equal(event.metadata.note, "smoke");
-    assert.equal(event.priority, "normal");
-    assert.equal(event.attempts, 0);
-    // queue.jsonl mirror
-    const paths = getBusPaths(root);
-    const audit = readFileSync(paths.queueJsonl, "utf-8").trim();
-    const rec = JSON.parse(audit);
-    assert.equal(rec.id, out.id);
-  } finally { await rmRoot(root); }
-});
-
-test("enqueueTick suppresses when .emergency-stop exists but still audits", async () => {
-  const root = await makeAgentRoot();
-  try {
-    writeFileSync(join(root, ".emergency-stop"), new Date().toISOString());
-    const out = enqueueTick({
-      cadence: "weekly-strategic-memo",
-      source: "launchd",
-      agentRoot: root,
-    });
-    assert.equal(out.skipped, "emergency-stop");
-    assert.equal(out.fallbackOnly, true);
-    assert.equal(listInbox(root).length, 0);
-    const paths = getBusPaths(root);
-    const audit = readFileSync(paths.queueJsonl, "utf-8").trim();
-    const rec = JSON.parse(audit);
-    assert.equal(rec._suppressed, "emergency-stop");
-  } finally { await rmRoot(root); }
-});
-
-test("enqueueTick coerces unknown priority to 'normal'", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const out = enqueueTick({ cadence: "x", priority: "BOGUS", agentRoot: root });
-    const event = JSON.parse(readFileSync(out.path, "utf-8"));
-    assert.equal(event.priority, "normal");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Claim / complete / fail / DLQ
-// ---------------------------------------------------------------------------
-
-test("claimNextTick is atomic — only one claimer wins per event", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    enqueueTick({ cadence: "x", agentRoot: root });
-    enqueueTick({ cadence: "x", agentRoot: root });
-    assert.equal(listInbox(root).length, 3);
-
-    const seen = new Set();
-    let c;
-    while ((c = claimNextTick(root)) !== null) {
-      assert.ok(!seen.has(c.event.id), "duplicate claim");
-      seen.add(c.event.id);
-    }
-    assert.equal(seen.size, 3);
-    assert.equal(listInbox(root).length, 0);
-    assert.equal(listClaimed(root).length, 3);
-  } finally { await rmRoot(root); }
-});
-
-test("claimNextTick does NOT bump attempts (single-sourced in failTick, M5)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    const { event, claimedPath } = claimNextTick(root);
-    // Claiming is not a failed attempt — attempts must stay 0 so a
-    // successful first run never burns retry budget and a crash-recover
-    // can't double-count. Attempt accounting lives solely in failTick.
-    assert.equal(event.attempts, 0);
-    const reloaded = JSON.parse(readFileSync(claimedPath, "utf-8"));
-    assert.equal(reloaded.attempts, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("claimNextTick returns null on empty inbox", async () => {
-  const root = await makeAgentRoot();
-  try {
-    assert.equal(claimNextTick(root), null);
-  } finally { await rmRoot(root); }
-});
-
-test("completeTick archives the claim under processed/<utc-date>/", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    const { event } = claimNextTick(root);
-    const dst = completeTick(root, event.id, { decision: "inline", duration_ms: 42 });
-    assert.ok(dst);
-    const archived = JSON.parse(readFileSync(dst, "utf-8"));
-    assert.equal(archived.result.decision, "inline");
-    assert.equal(archived.result.duration_ms, 42);
-    assert.ok(archived.completed_at);
-    assert.equal(listClaimed(root).length, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("failTick re-queues to inbox while under retry budget", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    const { event } = claimNextTick(root);
-    const out = failTick(root, event.id, "transient");
-    assert.equal(out.destination, "inbox");
-    assert.equal(listInbox(root).length, 1);
-    assert.equal(listClaimed(root).length, 0);
-    // Reload and confirm last_error set.
-    const requeued = JSON.parse(readFileSync(join(getBusPaths(root).inbox, `${event.id}.json`), "utf-8"));
-    assert.equal(requeued.last_error, "transient");
-  } finally { await rmRoot(root); }
-});
-
-test("failTick routes to dlq once attempts hit the budget", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    // Cycle claim/fail until the event lands in dlq.
-    let last;
-    for (let i = 0; i < 10; i++) {
-      const c = claimNextTick(root);
-      if (!c) break;
-      last = failTick(root, c.event.id, `attempt-${i}`);
-      if (last?.destination === "dlq") break;
-    }
-    assert.equal(last.destination, "dlq");
-    assert.equal(listInbox(root).length, 0);
-    assert.equal(listClaimed(root).length, 0);
-    const dlqDir = getBusPaths(root).dlq;
-    assert.ok(readdirSync(dlqDir).length >= 1);
-  } finally { await rmRoot(root); }
-});
-
-test("failTick { terminal: true } sends straight to dlq", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    const { event } = claimNextTick(root);
-    const out = failTick(root, event.id, "no-prompt", { terminal: true });
-    assert.equal(out.destination, "dlq");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Stale claim recovery
-// ---------------------------------------------------------------------------
-
-test("recoverStaleClaims returns aging claims to inbox", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    const { event, claimedPath } = claimNextTick(root);
-    // Backdate the claim's mtime by 2 hours.
-    const oldMs = Date.now() - 2 * 60 * 60 * 1000;
-    await fsp.utimes(claimedPath, new Date(oldMs), new Date(oldMs));
-
-    const stats = recoverStaleClaims(root, 60 * 60 * 1000); // 1 hour threshold
-    assert.equal(stats.scanned, 1);
-    assert.equal(stats.recovered, 1);
-    assert.equal(listInbox(root).length, 1);
-    assert.equal(listClaimed(root).length, 0);
-    // The recovered event retains its bumped attempts.
-    const requeued = JSON.parse(readFileSync(join(getBusPaths(root).inbox, `${event.id}.json`), "utf-8"));
-    assert.ok(requeued.attempts >= 1);
-  } finally { await rmRoot(root); }
-});
-
-test("recoverStaleClaims leaves fresh claims alone", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    claimNextTick(root);
-    const stats = recoverStaleClaims(root, 60 * 60 * 1000);
-    assert.equal(stats.scanned, 1);
-    assert.equal(stats.recovered, 0);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Health
-// ---------------------------------------------------------------------------
-
-test("writeHealth + readHealth round-trip", async () => {
-  const root = await makeAgentRoot();
-  try {
-    writeHealth(root, { stats: { foo: 1 } });
-    const h = readHealth(root);
-    assert.ok(h);
-    assert.equal(h.version, BUS_VERSION);
-    assert.equal(h.stats.foo, 1);
-    assert.ok(h.ts);
-  } finally { await rmRoot(root); }
-});
-
-test("readHealth returns null when missing or corrupt", async () => {
-  const root = await makeAgentRoot();
-  try {
-    assert.equal(readHealth(root), null);
-    ensureBusDirs(root);
-    writeFileSync(join(root, "state/cadence-bus/health.json"), "{not json");
-    assert.equal(readHealth(root), null);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Depth
-// ---------------------------------------------------------------------------
-
-test("busDepth reports counts per stage", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    enqueueTick({ cadence: "x", agentRoot: root });
-    claimNextTick(root);
-    const d = busDepth(root);
-    assert.equal(d.inbox, 1);
-    assert.equal(d.claimed, 1);
-    assert.equal(d.dlq, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("enqueueTick dedups a replayed explicit id but always writes auto ids (H12)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    // First write with an explicit id lands in inbox.
-    const r1 = enqueueTick({ cadence: "inbox-processor", id: "replay-1", agentRoot: root });
-    assert.ok(r1.path && existsSync(r1.path));
-    assert.ok(!r1.deduped);
-
-    // Replaying the same explicit id is deduped — no second inbox file, no clobber.
-    const r2 = enqueueTick({ cadence: "inbox-processor", id: "replay-1", agentRoot: root });
-    assert.equal(r2.deduped, "inbox");
-    assert.equal(r2.path, null);
-    assert.equal(busDepth(root).inbox, 1);
-
-    // Auto-generated ids never dedup against each other.
-    const r3 = enqueueTick({ cadence: "inbox-processor", agentRoot: root });
-    assert.ok(r3.path && !r3.deduped);
-    assert.equal(busDepth(root).inbox, 2);
-  } finally { await rmRoot(root); }
-});
-
-test("enqueueTick dedups an explicit id already processed (H12)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "inbox-processor", id: "done-1", agentRoot: root });
-    const claimed = claimNextTick(root);
-    assert.equal(claimed.event.id, "done-1");
-    completeTick(root, claimed.event.id, {});
-    assert.equal(isProcessedId(root, "done-1"), true);
-    // Re-enqueue of an already-processed explicit id is suppressed.
-    const r2 = enqueueTick({ cadence: "inbox-processor", id: "done-1", agentRoot: root });
-    assert.equal(r2.deduped, "processed");
-    assert.equal(busDepth(root).inbox, 0);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Attempt accounting (audit M5/M6/M7) — increment once, never decrement
-// ---------------------------------------------------------------------------
-
-test("attempts increments exactly once per failed attempt and reaches dlq at maxAttempts", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    // maxAttempts=3: fail #1 → attempts 1 (inbox), #2 → 2 (inbox), #3 → 3 (dlq).
-    const expected = [
-      { dest: "inbox", attempts: 1 },
-      { dest: "inbox", attempts: 2 },
-      { dest: "dlq", attempts: 3 },
-    ];
-    for (const step of expected) {
-      const c = claimNextTick(root);
-      assert.ok(c, "expected a claimable event");
-      // Claim never bumps — count only moves inside failTick.
-      const beforeFail = c.event.attempts;
-      const out = failTick(root, c.event.id, "boom", { maxAttempts: 3 });
-      assert.equal(out.destination, step.dest, `destination for attempts=${step.attempts}`);
-      if (step.dest === "inbox") {
-        const requeued = JSON.parse(
-          readFileSync(join(getBusPaths(root).inbox, `${c.event.id}.json`), "utf-8")
-        );
-        assert.equal(requeued.attempts, step.attempts, "requeued attempts");
-        // Exactly +1 over what claim handed us — no double-count, no drift.
-        assert.equal(requeued.attempts, beforeFail + 1);
-      }
-    }
-    // Final: exactly one file in dlq, with attempts === maxAttempts (no overshoot).
-    const dlqFiles = readdirSync(getBusPaths(root).dlq).filter((n) => n.endsWith(".json"));
-    assert.equal(dlqFiles.length, 1);
-    const dlqEvent = JSON.parse(readFileSync(join(getBusPaths(root).dlq, dlqFiles[0]), "utf-8"));
-    assert.equal(dlqEvent.attempts, 3);
-    assert.equal(listInbox(root).length, 0);
-    assert.equal(listClaimed(root).length, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("requeueTick atomically returns an event to inbox without touching attempts (M6)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    const { event } = claimNextTick(root);
-    assert.equal(listClaimed(root).length, 1);
-    // Simulate a circuit-open re-queue: same event, attempts unchanged.
-    const ok = requeueTick(root, event);
-    assert.equal(ok, true);
-    assert.equal(listInbox(root).length, 1);
-    assert.equal(listClaimed(root).length, 0);
-    const requeued = JSON.parse(
-      readFileSync(join(getBusPaths(root).inbox, `${event.id}.json`), "utf-8")
-    );
-    assert.equal(requeued.attempts, event.attempts); // no drift
-  } finally { await rmRoot(root); }
-});
-
-test("requeueTick rejects an event without an id", async () => {
-  const root = await makeAgentRoot();
-  try {
-    assert.throws(() => requeueTick(root, {}), /id is required/);
-  } finally { await rmRoot(root); }
-});
-
-test("writeJsonAtomic is exported and writes valid JSON via temp+rename", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const target = join(root, "atomic-probe.json");
-    writeJsonAtomic(target, { a: 1, nested: { b: 2 } });
-    const parsed = JSON.parse(readFileSync(target, "utf-8"));
-    assert.equal(parsed.a, 1);
-    assert.equal(parsed.nested.b, 2);
-  } finally { await rmRoot(root); }
-});
-
-test("writeJsonAtomic round-trips, leaves no .tmp sibling, and overwrites atomically (L3)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const dir = join(root, "atomic-dir");
-    mkdirSync(dir, { recursive: true });
-    const target = join(dir, "probe.json");
-
-    // First write — fsync-before-rename path runs on a normal fs.
-    writeJsonAtomic(target, { v: 1, s: "first" });
-    assert.deepEqual(JSON.parse(readFileSync(target, "utf-8")), { v: 1, s: "first" });
-
-    // Overwrite — must replace contents wholesale, still valid JSON.
-    writeJsonAtomic(target, { v: 2, s: "second" });
-    assert.deepEqual(JSON.parse(readFileSync(target, "utf-8")), { v: 2, s: "second" });
-
-    // Atomicity hygiene: no orphaned temp file is left behind in the dir.
-    const leftover = readdirSync(dir).filter((n) => n.includes(".tmp."));
-    assert.deepEqual(leftover, [], `unexpected temp leftovers: ${leftover.join(", ")}`);
-    // Exactly one durable file remains.
-    assert.deepEqual(readdirSync(dir).sort(), ["probe.json"]);
-  } finally { await rmRoot(root); }
-});
-
-test("writeJsonAtomic cleans up the temp file when the write/rename cannot complete (L3)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    // A target whose parent path component is a FILE (not a dir) makes the
-    // open/write of the sibling temp fail; writeJsonAtomic must throw and
-    // leave nothing behind under root.
-    const blocker = join(root, "as-file");
-    writeFileSync(blocker, "x");
-    const target = join(blocker, "child.json"); // parent is a file
-    assert.throws(() => writeJsonAtomic(target, { a: 1 }));
-    // No stray .tmp file should survive at root level.
-    const leftover = readdirSync(root).filter((n) => n.includes(".tmp."));
-    assert.deepEqual(leftover, []);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Observable best-effort write failures (L4)
-// ---------------------------------------------------------------------------
-
-// Read every structured log line the bus has written for a root.
-function readBusLogs(root) {
-  const dir = join(root, "logs/cadence-bus");
-  if (!existsSync(dir)) return [];
-  const lines = [];
-  for (const n of readdirSync(dir).filter((f) => f.endsWith(".jsonl"))) {
-    const body = readFileSync(join(dir, n), "utf-8");
-    for (const line of body.split("\n").filter(Boolean)) {
-      try { lines.push(JSON.parse(line)); } catch { /* skip partials */ }
-    }
-  }
-  return lines;
-}
-
-test("completeTick logs best_effort_write_failed when annotation read-back is corrupt, control flow preserved (L4)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    enqueueTick({ cadence: "x", agentRoot: root });
-    const { event } = claimNextTick(root);
-
-    // Corrupt the claimed payload so that after completeTick moves it to
-    // processed/, the annotate read/JSON.parse throws inside the best-effort
-    // block. completeTick must still return the dst (control flow preserved)
-    // and emit a warn instead of silently swallowing.
-    const paths = getBusPaths(root);
-    writeFileSync(join(paths.claimed, `${event.id}.json`), "{ this is not json");
-
-    const dst = completeTick(root, event.id, { decision: "inline" });
-    assert.ok(dst, "completeTick must still return a destination");
-
-    const warned = readBusLogs(root).filter(
-      (l) => l.stage === "best_effort_write_failed" && l.op === "complete_annotate"
-    );
-    assert.ok(warned.length >= 1, "expected a complete_annotate best_effort_write_failed warn");
-    assert.equal(warned[0].level, "warn");
-    assert.equal(warned[0].id, event.id);
-    assert.ok(warned[0].error, "warn must carry the error message");
-  } finally { await rmRoot(root); }
-});
-
-test("failTick still reaches dlq and persists the bumped attempt count (L4 control-flow guard)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    // maxAttempts=1 makes the first fail terminal. Even if the in-place persist
-    // of the bumped count were to fail, the L4 change only ADDS a warn log and
-    // never alters control flow — the event must still land in dlq.
-    enqueueTick({ cadence: "x", id: "dlq-1", agentRoot: root });
-    const claimed = claimNextTick(root);
-    assert.equal(claimed.event.id, "dlq-1");
-
-    const out = failTick(root, "dlq-1", "boom", { maxAttempts: 1 });
-    assert.equal(out.destination, "dlq");
-    assert.equal(busDepth(root).dlq, 1);
-
-    const paths = getBusPaths(root);
-    const dlqFiles = readdirSync(paths.dlq).filter((n) => n.endsWith(".json"));
-    assert.equal(dlqFiles.length, 1);
-    const dlqEvent = JSON.parse(readFileSync(join(paths.dlq, dlqFiles[0]), "utf-8"));
-    assert.equal(dlqEvent.attempts, 1);
-  } finally { await rmRoot(root); }
-});
-
-test("logBusEvent returns false (never throws) when its target is unwritable — L4 observability primitive", async () => {
-  const root = await makeAgentRoot();
-  try {
-    // logBusEvent is the primitive the L4 catch blocks call. It must never
-    // throw; a failure to log is swallowed and surfaced via the boolean return.
-    ensureBusDirs(root);
-    await rmRoot(join(root, "logs"));
-    writeFileSync(join(root, "logs"), "blocker"); // logs/ is now a file → mkdir/append fail
-    const ok = logBusEvent(root, { level: "warn", stage: "probe" });
-    assert.equal(ok, false, "logBusEvent must return false on I/O failure, never throw");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Retention sweep (audit M8)
-// ---------------------------------------------------------------------------
-
-test("sweepRetention deletes old processed/ dirs but keeps recent ones", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const paths = ensureBusDirs(root);
-    const dayMs = 24 * 60 * 60 * 1000;
-    const now = Date.UTC(2026, 4, 31); // 2026-05-31 UTC midnight
-    const dateName = (ms) => new Date(ms).toISOString().slice(0, 10);
-
-    const oldDir = join(paths.processed, dateName(now - 30 * dayMs));  // 30d old → delete
-    const edgeDir = join(paths.processed, dateName(now - 13 * dayMs)); // 13d old → keep (<14)
-    const freshDir = join(paths.processed, dateName(now - 1 * dayMs)); // 1d old → keep
-    for (const d of [oldDir, edgeDir, freshDir]) {
-      mkdirSync(d, { recursive: true });
-      writeFileSync(join(d, "evt.json"), "{}");
-    }
-
-    const stats = sweepRetention(root, { now, processedDays: 14 });
-    assert.equal(stats.processedDirsDeleted, 1);
-    assert.equal(existsSync(oldDir), false, "old dir should be deleted");
-    assert.equal(existsSync(edgeDir), true, "13-day dir should be kept");
-    assert.equal(existsSync(freshDir), true, "fresh dir should be kept");
-  } finally { await rmRoot(root); }
-});
-
-test("sweepRetention caps dlq/ to the newest terminalKeep files", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const paths = ensureBusDirs(root);
-    // Create 10 dlq files with increasing mtimes so ordering is deterministic.
-    const base = Date.now() - 10 * 60 * 1000;
-    for (let i = 0; i < 10; i++) {
-      const name = `evt-${String(i).padStart(2, "0")}.json`;
-      const full = join(paths.dlq, name);
-      writeFileSync(full, JSON.stringify({ i }));
-      const t = new Date(base + i * 60 * 1000);
-      await fsp.utimes(full, t, t);
-    }
-    const stats = sweepRetention(root, { terminalKeep: 3 });
-    assert.equal(stats.dlqDeleted, 7);
-    const remaining = readdirSync(paths.dlq).filter((n) => n.endsWith(".json")).sort();
-    assert.equal(remaining.length, 3);
-    // Newest three (07, 08, 09) survive; oldest are gone.
-    assert.deepEqual(remaining, ["evt-07.json", "evt-08.json", "evt-09.json"]);
-  } finally { await rmRoot(root); }
-});
-
-test("sweepRetention rotates an oversized queue.jsonl keeping the tail", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const paths = ensureBusDirs(root);
-    // Write many rows; mark the last one so we can confirm the tail survives.
-    const rows = [];
-    for (let i = 0; i < 5000; i++) rows.push(JSON.stringify({ id: `evt-${i}`, pad: "x".repeat(50) }));
-    rows.push(JSON.stringify({ id: "LAST-ROW" }));
-    writeFileSync(paths.queueJsonl, rows.join("\n") + "\n");
-    const before = statSync(paths.queueJsonl).size;
-
-    const stats = sweepRetention(root, { queueMaxBytes: 4096 });
-    assert.equal(stats.queueRotated, true);
-    const after = statSync(paths.queueJsonl).size;
-    assert.ok(after < before, "queue.jsonl should shrink");
-    assert.ok(after <= 4096, "queue.jsonl should be at/under the cap after rotation");
-    const tail = readFileSync(paths.queueJsonl, "utf-8");
-    assert.ok(tail.includes("LAST-ROW"), "most recent row must survive rotation");
-    // Every retained line must be valid JSON (no partial leading line).
-    for (const line of tail.split("\n").filter(Boolean)) {
-      JSON.parse(line);
-    }
-  } finally { await rmRoot(root); }
-});
-
-test("sweepRetention deletes stale log files older than logDays", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const paths = ensureBusDirs(root);
-    const dayMs = 24 * 60 * 60 * 1000;
-    const now = Date.UTC(2026, 4, 31);
-    const dateName = (ms) => new Date(ms).toISOString().slice(0, 10);
-    const oldLog = join(paths.logsDir, `${dateName(now - 40 * dayMs)}.jsonl`);
-    const freshLog = join(paths.logsDir, `${dateName(now - 2 * dayMs)}.jsonl`);
-    writeFileSync(oldLog, '{"x":1}\n');
-    writeFileSync(freshLog, '{"x":2}\n');
-
-    const stats = sweepRetention(root, { now, logDays: 14 });
-    assert.equal(stats.logsDeleted, 1);
-    assert.equal(existsSync(oldLog), false);
-    assert.equal(existsSync(freshLog), true);
-  } finally { await rmRoot(root); }
-});
-
-test("sweepRetention is a no-op (no throw) on an empty/missing bus", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const stats = sweepRetention(root);
-    assert.equal(stats.processedDirsDeleted, 0);
-    assert.equal(stats.dlqDeleted, 0);
-    assert.equal(stats.queueRotated, false);
-    assert.equal(stats.logsDeleted, 0);
-  } finally { await rmRoot(root); }
-});
-
-test("sweepRetention honours MAESTRO_RETENTION_DAYS env for processed dirs", async () => {
-  const root = await makeAgentRoot();
-  const prev = process.env.MAESTRO_RETENTION_DAYS;
-  try {
-    const paths = ensureBusDirs(root);
-    const dayMs = 24 * 60 * 60 * 1000;
-    const now = Date.UTC(2026, 4, 31);
-    const dateName = (ms) => new Date(ms).toISOString().slice(0, 10);
-    const dir = join(paths.processed, dateName(now - 5 * dayMs)); // 5 days old
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, "evt.json"), "{}");
-
-    process.env.MAESTRO_RETENTION_DAYS = "3"; // 5d > 3d → delete
-    const stats = sweepRetention(root, { now });
-    assert.equal(stats.processedDirsDeleted, 1);
-    assert.equal(existsSync(dir), false);
-  } finally {
-    if (prev === undefined) delete process.env.MAESTRO_RETENTION_DAYS;
-    else process.env.MAESTRO_RETENTION_DAYS = prev;
-    await rmRoot(root);
-  }
-});