@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/budget-guard.test.mjs

@@ -1,427 +0,0 @@
-/**
- * budget-guard.test.mjs — node:test coverage for the daily spend cap.
- *
- * Hermetic: each test builds an isolated ledger dir with hand-written JSONL
- * rows and injects a fixed clock + cap so band math is deterministic.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  dailyStatus,
-  maybeNotify,
-  readNotified,
-  BANDS,
-  DEFAULT_DAILY_SPEND_CAP_USD,
-  rollingWindowUsage,
-  windowBand,
-} from "./budget-guard.mjs";
-
-const FIXED = Date.UTC(2026, 5, 9, 12, 0, 0); // 2026-06-09T12:00:00Z
-const DATE = "2026-06-09";
-const clk = () => FIXED;
-
-async function makeLedgerDir() {
-  const dir = join(tmpdir(), `budget-guard-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(dir, { recursive: true });
-  return dir;
-}
-async function rm(dir) { try { await fsp.rm(dir, { recursive: true, force: true }); } catch { /* */ } }
-
-/**
- * Write `rows` (array of {usd}) into today's ledger file as MEASURED sessions.
- *
- * `total_cost_usd` + real token counts, because that is what a row from a
- * correctly-instrumented caller looks like and it is the column the governor
- * now bills against (lib/cost/ledger-row.mjs). A row carrying only
- * `estimated_usd` and no tokens classifies as `unknown` — deliberately, so an
- * unmeasured session can never read as a free one — and would be imputed rather
- * than summed, which is not what these band tests are about.
- */
-function seedLedger(dir, rows) {
-  const body = rows.map((r) => JSON.stringify({
-    ts: `${DATE}T10:00:00.000Z`,
-    total_cost_usd: r.usd,
-    estimated_usd: r.usd,
-    model: "sonnet",
-    cadence: "x",
-    input_tokens: 1000,
-    output_tokens: 200,
-  })).join("\n") + "\n";
-  writeFileSync(join(dir, `${DATE}.jsonl`), body);
-}
-
-// ---------------------------------------------------------------------------
-// banding
-// ---------------------------------------------------------------------------
-
-test("dailyStatus: below 80% is band 0, nothing degraded", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    seedLedger(dir, [{ usd: 4 }]); // $4 of $10 = 40%
-    const s = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10 });
-    assert.equal(s.band, 0);
-    assert.equal(s.mode, "normal");
-    assert.equal(s.essentialOnly, false);
-    assert.equal(s.spentUSD, 4);
-    assert.equal(s.pct, 40);
-  } finally { await rm(dir); }
-});
-
-test("dailyStatus: crossing each threshold lands in the right band", async () => {
-  // The governance ladder: 80 notify · 100 degrade · 125 suspend · 150 refuse.
-  for (const [usd, expected] of [[5, 0], [8, 80], [9.9, 80], [10, 100], [12.5, 125], [15, 150], [40, 150]]) {
-    const dir = await makeLedgerDir();
-    try {
-      seedLedger(dir, [{ usd }]);
-      const s = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10 });
-      assert.equal(s.band, expected, `$${usd}/$10 should be band ${expected}, got ${s.band}`);
-    } finally { await rm(dir); }
-  }
-});
-
-test("dailyStatus: empty/missing ledger reports zero spend, band 0", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    const s = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10 });
-    assert.equal(s.spentUSD, 0);
-    assert.equal(s.band, 0);
-    assert.equal(s.essentialOnly, false);
-  } finally { await rm(dir); }
-});
-
-test("dailyStatus uses the default cap when none configured", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    seedLedger(dir, [{ usd: 1 }]);
-    const s = dailyStatus({ ledgerDir: dir, now: clk });
-    assert.equal(s.capUSD, DEFAULT_DAILY_SPEND_CAP_USD);
-  } finally { await rm(dir); }
-});
-
-test("dailyStatus: iteration cap can be the binding constraint", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    // 10 cheap rows; spend tiny ($1 of $1000 = 0.1%) but 10/10 iterations = 100%.
-    seedLedger(dir, Array.from({ length: 10 }, () => ({ usd: 0.1 })));
-    const s = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 1000, iterationCap: 10 });
-    assert.equal(s.sessions, 10);
-    assert.equal(s.band, 100, "iteration cap should drive band to 100");
-    assert.equal(s.mode, "degraded");
-    assert.equal(s.posture.selfDirected, false, "D3 stops at the degrade rung");
-  } finally { await rm(dir); }
-});
-
-// ---------------------------------------------------------------------------
-// essential-only at 100%
-// ---------------------------------------------------------------------------
-
-test("essentialOnly (the legacy flag) now means the SUSPEND rung at 125%", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    // 100% degrades — inbox + obligations continue on the cheapest class — so
-    // the legacy all-or-nothing flag must NOT be set there. That rung was the
-    // one the old binary gate collapsed.
-    seedLedger(dir, [{ usd: 10 }]);
-    assert.equal(dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10 }).essentialOnly, false);
-    seedLedger(dir, [{ usd: 12.5 }]);
-    assert.equal(dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10 }).essentialOnly, true);
-  } finally { await rm(dir); }
-});
-
-// ---------------------------------------------------------------------------
-// one-notice-per-band
-// ---------------------------------------------------------------------------
-
-test("maybeNotify fires once per band and never repeats within the day", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    const notices = [];
-    const notify = (n) => notices.push(n.band);
-
-    // A supervisor must exist or the notice is logged and sent nowhere by
-    // design — see maybeNotify. Inject one.
-    const seat = { seatEnvelope: { seatBudgetCents: null, supervisorMemberId: "M-SUP" } };
-
-    // 85% → notify band 80 once.
-    seedLedger(dir, [{ usd: 8.5 }]);
-    let r = maybeNotify({ ledgerDir: dir, now: clk, capUSD: 10, notify, ...seat });
-    assert.equal(r.notified, true);
-    assert.equal(r.band, 80);
-    assert.deepEqual(r.recipient, { memberId: "M-SUP", role: "REVIEWER" });
-
-    // Still 85% → no repeat.
-    r = maybeNotify({ ledgerDir: dir, now: clk, capUSD: 10, notify, ...seat });
-    assert.equal(r.notified, false);
-
-    // Climb to 105% → notify band 100 once.
-    seedLedger(dir, [{ usd: 10.5 }]);
-    r = maybeNotify({ ledgerDir: dir, now: clk, capUSD: 10, notify, ...seat });
-    assert.equal(r.notified, true);
-    assert.equal(r.band, 100);
-
-    assert.deepEqual(notices, [80, 100]);
-    assert.deepEqual(readNotified({ ledgerDir: dir, now: clk }).notified_bands, [80, 100]);
-  } finally { await rm(dir); }
-});
-
-test("maybeNotify on a big jump notifies once at the highest crossed band", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    const notices = [];
-    // Jump straight from $0 to 130% — ONE notice at band 125, with 80/100/125
-    // all recorded so they never re-fire.
-    const seat = { seatEnvelope: { seatBudgetCents: null, supervisorMemberId: "M-SUP" } };
-    seedLedger(dir, [{ usd: 13 }]);
-    const r = maybeNotify({ ledgerDir: dir, now: clk, capUSD: 10, notify: (n) => notices.push(n.band), ...seat });
-    assert.equal(r.notified, true);
-    assert.equal(r.band, 125);
-    assert.deepEqual(notices, [125], "exactly one notice surfaced");
-    assert.deepEqual(readNotified({ ledgerDir: dir, now: clk }).notified_bands, [80, 100, 125]);
-
-    // A later check at the same level does nothing.
-    const r2 = maybeNotify({ ledgerDir: dir, now: clk, capUSD: 10, notify: (n) => notices.push(n.band), ...seat });
-    assert.equal(r2.notified, false);
-    assert.deepEqual(notices, [125]);
-  } finally { await rm(dir); }
-});
-
-test("maybeNotify past 150% surfaces the refuse notice once", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    const notices = [];
-    const seat = { seatEnvelope: { seatBudgetCents: null, supervisorMemberId: "M-SUP" } };
-    seedLedger(dir, [{ usd: 16 }]); // 160%
-    const r = maybeNotify({ ledgerDir: dir, now: clk, capUSD: 10, notify: (n) => notices.push(n), ...seat });
-    assert.equal(r.notified, true);
-    assert.equal(r.band, 150);
-    assert.match(r.message, /REFUSING new sessions that are not a direct human reply/);
-    assert.equal(r.status.posture.refuseNonHumanSpawn, true);
-    // All bands recorded; a repeat is a no-op.
-    assert.deepEqual(readNotified({ ledgerDir: dir, now: clk }).notified_bands, [80, 100, 125, 150]);
-    const r2 = maybeNotify({ ledgerDir: dir, now: clk, capUSD: 10, notify: (n) => notices.push(n), ...seat });
-    assert.equal(r2.notified, false);
-    assert.equal(notices.length, 1);
-  } finally { await rm(dir); }
-});
-
-test("a seat with NO supervisor edge is never told its own budget band", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    const notices = [];
-    const logged = [];
-    seedLedger(dir, [{ usd: 9 }]); // 90% → band 80
-    const r = maybeNotify({
-      ledgerDir: dir, now: clk, capUSD: 10,
-      notify: (n) => notices.push(n),
-      log: (level, msg) => logged.push(`${level}:${msg}`),
-    });
-    assert.equal(r.band, 80);
-    assert.equal(r.recipient, null);
-    assert.equal(notices.length, 0, "no notice may be delivered to the owner");
-    assert.ok(logged.some((l) => l.startsWith("error:") && /NO supervisor edge/.test(l)),
-      "the missing edge must be LOUD, not silent");
-  } finally { await rm(dir); }
-});
-
-test("BANDS is the canonical 80/100/125/150 governance ladder", () => {
-  assert.deepEqual(BANDS, [80, 100, 125, 150]);
-});
-
-// ---------------------------------------------------------------------------
-// recovery.yaml cap is honoured (recovery C1)
-// ---------------------------------------------------------------------------
-
-/** Write a config/recovery.yaml under `agentRoot` with the given cap line. */
-async function seedRecoveryYaml(agentRoot, body) {
-  await fsp.mkdir(join(agentRoot, "config"), { recursive: true });
-  writeFileSync(join(agentRoot, "config", "recovery.yaml"), body);
-}
-
-test("dailyStatus reads the cap from config/recovery.yaml when present", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    // agentRoot holds both config/recovery.yaml and the ledger dir.
-    await fsp.mkdir(join(dir, "state", "cost-tracking"), { recursive: true });
-    await seedRecoveryYaml(dir, `budget:\n  daily_spend_cap_usd: 40  # per-agent override\n`);
-    // Ledger lives where ledgerDir() derives it from agentRoot.
-    seedLedger(join(dir, "state", "cost-tracking"), [{ usd: 20 }]);
-    const s = dailyStatus({ agentRoot: dir, now: clk });
-    assert.equal(s.capUSD, 40, "cap should come from recovery.yaml, not the 25 default");
-    assert.equal(s.spentUSD, 20);
-    assert.equal(s.pct, 50, "20/40 = 50%");
-    assert.equal(s.band, 0, "50% of the ceiling degrades nothing");
-  } finally { await rm(dir); }
-});
-
-test("recovery.yaml cap takes precedence over DAILY_SPEND_CAP_USD env", async () => {
-  const dir = await makeLedgerDir();
-  const prevEnv = process.env.DAILY_SPEND_CAP_USD;
-  try {
-    process.env.DAILY_SPEND_CAP_USD = "100"; // would be the cap if yaml were ignored
-    await fsp.mkdir(join(dir, "state", "cost-tracking"), { recursive: true });
-    await seedRecoveryYaml(dir, `budget:\n  daily_spend_cap_usd: 10\n`);
-    seedLedger(join(dir, "state", "cost-tracking"), [{ usd: 10 }]);
-    const s = dailyStatus({ agentRoot: dir, now: clk });
-    assert.equal(s.capUSD, 10, "yaml cap must win over the env cap");
-    assert.equal(s.band, 100, "10/10 spent under the yaml cap is the 100% degrade rung");
-    assert.equal(s.mode, "degraded");
-  } finally {
-    if (prevEnv === undefined) delete process.env.DAILY_SPEND_CAP_USD;
-    else process.env.DAILY_SPEND_CAP_USD = prevEnv;
-    await rm(dir);
-  }
-});
-
-test("an explicit deps.capUSD still overrides the recovery.yaml cap", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    await fsp.mkdir(join(dir, "state", "cost-tracking"), { recursive: true });
-    await seedRecoveryYaml(dir, `budget:\n  daily_spend_cap_usd: 40\n`);
-    seedLedger(join(dir, "state", "cost-tracking"), [{ usd: 5 }]);
-    const s = dailyStatus({ agentRoot: dir, now: clk, capUSD: 10 });
-    assert.equal(s.capUSD, 10, "explicit injected cap wins (test seam preserved)");
-  } finally { await rm(dir); }
-});
-
-test("malformed / capless recovery.yaml falls back to the default cap", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    await fsp.mkdir(join(dir, "state", "cost-tracking"), { recursive: true });
-    await seedRecoveryYaml(dir, `governor:\n  hard_max: 10\n# no budget key here\n`);
-    seedLedger(join(dir, "state", "cost-tracking"), [{ usd: 1 }]);
-    const s = dailyStatus({ agentRoot: dir, now: clk });
-    assert.equal(s.capUSD, DEFAULT_DAILY_SPEND_CAP_USD);
-  } finally { await rm(dir); }
-});
-
-// ---------------------------------------------------------------------------
-// summing REAL ledger rows yields nonzero spend (the $0-forever bug guard)
-// ---------------------------------------------------------------------------
-
-test("summing real cost-ledger rows (with token-derived estimated_usd) yields nonzero spend", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    // Rows shaped exactly like track-claude-usage.mjs#record emits them:
-    // estimated_usd is computed from token counts. A daemon that passed REAL
-    // counts produces nonzero rows; the old --input-tokens 0 bug produced 0.
-    const rows = [
-      // sonnet: (1500/1000*0.003)+(320/1000*0.015) = 0.0045+0.0048 = 0.0093
-      { ts: `${DATE}T10:00:00.000Z`, estimated_usd: 0.0093, model: "sonnet", cadence: "inbox-processor", input_tokens: 1500, output_tokens: 320 },
-      // opus: (5000/1000*0.015)+(900/1000*0.075) = 0.075+0.0675 = 0.1425
-      { ts: `${DATE}T11:00:00.000Z`, estimated_usd: 0.1425, model: "opus", cadence: "backlog-executor", input_tokens: 5000, output_tokens: 900 },
-    ];
-    writeFileSync(join(dir, `${DATE}.jsonl`), rows.map((r) => JSON.stringify(r)).join("\n") + "\n");
-    const s = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 25 });
-    assert.ok(s.spentUSD > 0, `expected nonzero spend, got ${s.spentUSD}`);
-    assert.equal(s.spentUSD, +(0.0093 + 0.1425).toFixed(6));
-    assert.equal(s.sessions, 2);
-  } finally { await rm(dir); }
-});
-
-test("a ledger of only zero-token rows sums to $0 (proves the bug is the input, not the guard)", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    // The pre-fix daemon wrote rows with input_tokens=0/output_tokens=0, so
-    // estimated_usd=0 — the guard reported $0 spend forever. This documents that
-    // the guard math is correct; the defect was the caller's fabricated zeros.
-    const rows = [
-      { ts: `${DATE}T10:00:00.000Z`, estimated_usd: 0, model: "sonnet", cadence: "x", input_tokens: 0, output_tokens: 0 },
-      { ts: `${DATE}T11:00:00.000Z`, estimated_usd: 0, model: "sonnet", cadence: "x", input_tokens: 0, output_tokens: 0 },
-    ];
-    writeFileSync(join(dir, `${DATE}.jsonl`), rows.map((r) => JSON.stringify(r)).join("\n") + "\n");
-    const s = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 25 });
-    assert.equal(s.spentUSD, 0);
-    assert.equal(s.sessions, 2);
-  } finally { await rm(dir); }
-});
-
-test("dailyStatus: a subscription-auth seat is banded on session VOLUME, not dollars", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    seedLedger(dir, [{ usd: 40 }]); // $40 of $10 = 400%
-    // A metered (API) seat: dollars bind → band 150 (refused).
-    assert.equal(dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10, iterationCap: 100 }).band, 150);
-    // A flat-fee subscription seat has no dollar meter — the same API-equivalent
-    // "spend" is fiction. It lands at band 0 / normal so autonomous work keeps
-    // running; only session VOLUME can band it.
-    const sub = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10, iterationCap: 100, subscriptionAuth: true });
-    assert.equal(sub.band, 0);
-    assert.equal(sub.mode, "normal");
-  } finally { await rm(dir); }
-});
-
-test("dailyStatus: a subscription-auth seat STILL bands on session volume (a real limit)", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    seedLedger(dir, Array.from({ length: 12 }, () => ({ usd: 0.01 }))); // 12 sessions
-    const sub = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 1000, iterationCap: 10, subscriptionAuth: true });
-    assert.equal(sub.band, 100, "12 sessions / cap 10 = 120% → degrade even on subscription");
-    assert.equal(sub.mode, "degraded");
-  } finally { await rm(dir); }
-});
-
-// ---------------------------------------------------------------------------
-// rolling usage window (token volume) + windowBand (default-off pacing)
-// ---------------------------------------------------------------------------
-
-function seedWindowLedger(dir, rows) {
-  // rows: [{ minsAgo, tokens }] written to today's + yesterday's files by ts.
-  const now = FIXED;
-  const byFile = {};
-  for (const r of rows) {
-    const at = new Date(now - r.minsAgo * 60_000);
-    const day = at.toISOString().slice(0, 10);
-    (byFile[day] ||= []).push(JSON.stringify({
-      ts: at.toISOString(),
-      total_cost_usd: 0.1, model: "sonnet", cadence: "x",
-      input_tokens: r.tokens, output_tokens: 0,
-    }));
-  }
-  for (const [day, lines] of Object.entries(byFile)) {
-    writeFileSync(join(dir, `${day}.jsonl`), lines.join("\n") + "\n");
-  }
-}
-
-test("rollingWindowUsage sums tokens/sessions in the 5h and 7d windows", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    seedWindowLedger(dir, [
-      { minsAgo: 10, tokens: 1000 },   // in 5h + 7d
-      { minsAgo: 60, tokens: 2000 },   // in 5h + 7d
-      { minsAgo: 400, tokens: 500 },   // >5h (400m), in 7d
-      { minsAgo: 60 * 24 * 8, tokens: 9999 }, // >7d — excluded
-    ]);
-    const u = rollingWindowUsage({ ledgerDir: dir, now: clk });
-    assert.equal(u.window5hTokens, 3000);
-    assert.equal(u.window5hSessions, 2);
-    assert.equal(u.week7dTokens, 3500);
-    assert.equal(u.week7dSessions, 3);
-  } finally { await rm(dir); }
-});
-
-test("windowBand is DEFAULT-OFF: no caps → always 'ok' however high usage climbs", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    seedWindowLedger(dir, [{ minsAgo: 5, tokens: 10_000_000 }]);
-    const b = windowBand({ ledgerDir: dir, now: clk }); // no caps
-    assert.equal(b.band, "ok");
-    assert.equal(b.active, false);
-    assert.equal(b.window5hTokens, 10_000_000);
-  } finally { await rm(dir); }
-});
-
-test("windowBand bands 'approaching' then 'at' once a 5h cap is calibrated", async () => {
-  const dir = await makeLedgerDir();
-  try {
-    seedWindowLedger(dir, [{ minsAgo: 5, tokens: 8500 }]);
-    assert.equal(windowBand({ ledgerDir: dir, now: clk, cap5h: 10_000 }).band, "approaching"); // 85% of 10k
-    assert.equal(windowBand({ ledgerDir: dir, now: clk, cap5h: 8000 }).band, "at");             // over 8k
-    assert.equal(windowBand({ ledgerDir: dir, now: clk, cap5h: 100_000 }).band, "ok");          // well under
-  } finally { await rm(dir); }
-});

package/lib/cadence-bus-requeue.test.mjs

@@ -1,83 +0,0 @@
-/**
- * cadence-bus-requeue.test.mjs — deferred ticks are re-keyed to the TAIL
- * (audit F8: head-of-line block).
- *
- * `requeueTick(root, event)` used to write the event back under its own id.
- * Ids are time-sortable and `claimNextTick` takes the lowest, so a deferred
- * tick was re-claimed FIRST on the very next scan — forever, ahead of every
- * newer tick, until whatever deferred it cleared. With `{defer:true}` the
- * event is written under a NEW id (minted now, so it sorts last), carrying
- * `metadata.deferrals` and `metadata.originalId`; the plain call is unchanged.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { enqueueTick, claimNextTick, requeueTick, listInbox, getBusPaths, listClaimed } from "./cadence-bus.mjs";
-
-async function root() {
-  const p = join(tmpdir(), `cadence-requeue-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(p, { recursive: true });
-  return p;
-}
-async function rm(p) { try { await fsp.rm(p, { recursive: true, force: true }); } catch { /* */ } }
-
-test("requeueTick({defer:true}) re-keys the event to the tail and carries deferrals + originalId", async () => {
-  const dir = await root();
-  try {
-    const a = enqueueTick({ cadence: "goal-steward", source: "manual", agentRoot: dir });
-    await new Promise((r) => setTimeout(r, 2));
-    const b = enqueueTick({ cadence: "inbox-processor", source: "manual", agentRoot: dir });
-    assert.deepEqual(listInbox(dir), [a.id, b.id]);
-
-    const claim = claimNextTick(dir);
-    assert.equal(claim.event.id, a.id);
-    await new Promise((r) => setTimeout(r, 2));
-    const r = requeueTick(dir, claim.event, { defer: true });
-    assert.equal(r.ok, true);
-    assert.notEqual(r.id, a.id, "a new id");
-    // The deferred tick now sorts AFTER b: b is claimed next, not a again.
-    assert.deepEqual(listInbox(dir), [b.id, r.id]);
-    assert.equal(existsSync(join(getBusPaths(dir).claimed, `${a.id}.json`)), false, "old claim removed");
-    assert.equal(existsSync(join(getBusPaths(dir).inbox, `${a.id}.json`)), false, "old id not left in inbox");
-    const on = JSON.parse(readFileSync(join(getBusPaths(dir).inbox, `${r.id}.json`), "utf-8"));
-    assert.equal(on.cadence, "goal-steward");
-    assert.equal(on.metadata.deferrals, 1);
-    assert.equal(on.metadata.originalId, a.id);
-    assert.equal(on.attempts, 0, "a deferral is not a failed attempt");
-
-    // Deferring again increments the count and KEEPS the original id.
-    const claim2 = claimNextTick(dir); // b
-    assert.equal(claim2.event.id, b.id);
-    requeueTick(dir, claim2.event); // plain requeue: unchanged id
-    assert.deepEqual(listInbox(dir), [b.id, r.id]);
-    const claimB = claimNextTick(dir);
-    assert.equal(claimB.event.id, b.id);
-    const claimA = claimNextTick(dir);
-    assert.equal(claimA.event.id, r.id);
-    await new Promise((res) => setTimeout(res, 2));
-    const r2 = requeueTick(dir, claimA.event, { defer: true });
-    const on2 = JSON.parse(readFileSync(join(getBusPaths(dir).inbox, `${r2.id}.json`), "utf-8"));
-    assert.equal(on2.metadata.deferrals, 2);
-    assert.equal(on2.metadata.originalId, a.id);
-    // The deferred tick's old claim is gone; only b (claimed above) is still held.
-    assert.deepEqual(listClaimed(dir), [b.id]);
-    assert.equal(existsSync(join(getBusPaths(dir).claimed, `${r.id}.json`)), false, "the re-key unlinked its claim");
-  } finally { await rm(dir); }
-});
-
-test("requeueTick without defer is byte-for-byte the old behaviour (same id, returns true)", async () => {
-  const dir = await root();
-  try {
-    const a = enqueueTick({ cadence: "goal-steward", source: "manual", agentRoot: dir });
-    const claim = claimNextTick(dir);
-    const ok = requeueTick(dir, claim.event);
-    assert.equal(ok, true);
-    assert.deepEqual(listInbox(dir), [a.id]);
-    assert.equal(JSON.parse(readFileSync(join(getBusPaths(dir).inbox, `${a.id}.json`), "utf-8")).metadata.deferrals, undefined);
-  } finally { await rm(dir); }
-});