@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/budget-escalate.test.mjs

@@ -1,232 +0,0 @@
-/**
- * budget-escalate.test.mjs — the 80% rung reaches a HUMAN, or says why not.
- *
- * The rule under test is the anti-Goodhart one: the notice goes to the
- * supervisor and NEVER to the seat that is spending the money. Everything else
- * here is about the second rule — a notice that cannot be delivered is an ERROR
- * in the log, never a silent no-op.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { escalateBudget } from "./budget-escalate.mjs";
-
-const STATUS = { date: "2026-06-15", spentUSD: 27, capUSD: 30, pct: 90, capSource: "seat-envelope" };
-const CONN = { base: "https://hq.example", token: "t0ken", orgId: "org_1" };
-
-function notice(over = {}) {
-  return {
-    notified: true,
-    band: 80,
-    message: "Seat spend at 90% ($27.00 / $30.00 today) — heads-up only.",
-    recipient: { memberId: "M-SUPERVISOR", role: "REVIEWER" },
-    status: STATUS,
-    ...over,
-  };
-}
-
-test("a due notice is DM'd to the supervisor over resolveOrCreateDm + messaging.send", async () => {
-  const calls = [];
-  const sent = [];
-  const r = await escalateBudget(
-    { agentRoot: "/tmp/x", conn: CONN },
-    {
-      log: () => {},
-      notifyImpl: () => notice(),
-      callImpl: async (method, params) => {
-        calls.push([method, params]);
-        return { ok: true, result: { channelId: "chan_dm_1", created: false } };
-      },
-      sendImpl: async (params) => { sent.push(params); return { ok: true, result: { id: "msg_1" } }; },
-    }
-  );
-
-  assert.equal(r.ok, true);
-  assert.equal(r.delivered, true);
-  assert.deepEqual(calls[0], ["channel.resolveOrCreateDm", { memberId: "M-SUPERVISOR" }]);
-  assert.equal(sent[0].channel, "chan_dm_1");
-  assert.match(sent[0].body, /band 80%/i);
-  assert.match(sent[0].body, /an agent must not be handed its own meter/);
-  // Idempotent per (period, band): a retry does not DM the supervisor twice.
-  assert.equal(sent[0].idempotencyId, "budget-2026-06-15-80");
-});
-
-test("no supervisor edge → nothing is sent ANYWHERE, least of all to the owner", async () => {
-  const calls = [];
-  const sent = [];
-  const r = await escalateBudget(
-    { agentRoot: "/tmp/x", conn: CONN },
-    {
-      log: () => {},
-      notifyImpl: () => notice({ recipient: null }),
-      callImpl: async (...a) => { calls.push(a); return { ok: true, result: {} }; },
-      sendImpl: async (p) => { sent.push(p); return { ok: true }; },
-    }
-  );
-  assert.equal(r.notified, true);
-  assert.equal(r.delivered, false);
-  assert.equal(r.reason, "no-supervisor-edge");
-  assert.equal(calls.length, 0, "no channel is opened");
-  assert.equal(sent.length, 0, "and no message is sent — the seat is never told its own band");
-});
-
-test("an undeliverable notice is an ERROR in the log, never a silent no-op", async () => {
-  for (const [label, deps, expected] of [
-    [
-      "no credential",
-      { notifyImpl: () => notice(), callImpl: async () => ({ ok: true, result: { channelId: "c" } }), sendImpl: async () => ({ ok: true }) },
-      "no-credential",
-    ],
-    [
-      "DM resolve rejected",
-      {
-        notifyImpl: () => notice(),
-        callImpl: async () => ({ ok: false, error: { code: "FORBIDDEN_SCOPE" } }),
-        sendImpl: async () => ({ ok: true }),
-      },
-      "dm-resolve-failed:FORBIDDEN_SCOPE",
-    ],
-    [
-      "send rejected",
-      {
-        notifyImpl: () => notice(),
-        callImpl: async () => ({ ok: true, result: { channelId: "c" } }),
-        sendImpl: async () => ({ ok: false, error: { code: "BAD_REQUEST" } }),
-      },
-      "send-failed:BAD_REQUEST",
-    ],
-  ]) {
-    const logged = [];
-    const conn = label === "no credential" ? {} : CONN;
-    const r = await escalateBudget({ agentRoot: "/tmp/x", conn }, { ...deps, log: (l, m) => logged.push(`${l}:${m}`) });
-    assert.equal(r.delivered, false, label);
-    assert.equal(r.reason, expected, label);
-    assert.ok(logged.some((l) => l.startsWith("error:")), `${label} must log an error`);
-  }
-});
-
-test("a throwing transport degrades to a logged failure, never an exception", async () => {
-  const logged = [];
-  const r = await escalateBudget(
-    { agentRoot: "/tmp/x", conn: CONN },
-    {
-      log: (l, m) => logged.push(`${l}:${m}`),
-      notifyImpl: () => notice(),
-      callImpl: async () => { throw new Error("socket hang up"); },
-    }
-  );
-  assert.equal(r.ok, false);
-  assert.equal(r.reason, "dm-resolve-threw");
-  assert.ok(logged.some((l) => /socket hang up/.test(l)));
-});
-
-test("no band due → no traffic at all", async () => {
-  let calls = 0;
-  const r = await escalateBudget(
-    { agentRoot: "/tmp/x", conn: CONN },
-    { log: () => {}, notifyImpl: () => ({ notified: false, band: 0, status: STATUS }), callImpl: async () => { calls++; return { ok: true }; } }
-  );
-  assert.equal(r.notified, false);
-  assert.equal(calls, 0);
-});
-
-test("a throwing budget guard does not take the daemon down", async () => {
-  const logged = [];
-  const r = await escalateBudget(
-    { agentRoot: "/tmp/x", conn: CONN },
-    { log: (l, m) => logged.push(`${l}:${m}`), notifyImpl: () => { throw new Error("ledger unreadable"); } }
-  );
-  assert.equal(r.ok, false);
-  assert.equal(r.reason, "guard-threw");
-  assert.ok(logged.some((l) => l.startsWith("error:") && /NO notice was sent/.test(l)));
-});
-
-// ---------------------------------------------------------------------------
-// THE REAL maybeNotify — write-AFTER-delivery, not write-then-hope
-// ---------------------------------------------------------------------------
-// Every test above stubs `notifyImpl`, i.e. it mocks the component that owns the
-// ordering under test. These use the real guard against a real temp agent root,
-// which is the only way to catch "the band was consumed before the first byte
-// went out".
-
-import { promises as fsp } from "node:fs";
-import { writeFileSync, mkdirSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-const FIXED = Date.UTC(2026, 5, 15, 12, 0, 0);
-const DAY = "2026-06-15";
-
-async function escalateRoot({ spentUsd = 27, seatBudgetCents = 3_000 } = {}) {
-  const dir = join(tmpdir(), `bg-escalate-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  mkdirSync(join(dir, "state", "cost-tracking"), { recursive: true });
-  mkdirSync(join(dir, "state", "mandate"), { recursive: true });
-  writeFileSync(
-    join(dir, "state", "mandate", "cache.json"),
-    JSON.stringify({
-      version: 1, checksum: "x", source: "server", fetchedAt: new Date(FIXED).toISOString(),
-      body: {
-        contractVersion: 1, memberId: "A016", objectives: [], seatBudgetCents,
-        budgetPeriod: "monthly", budgetSource: "employee.payBasis.meteredBudget",
-        collaborators: [{ memberId: "M-SUPERVISOR", role: "REVIEWER", source: "workforceMember.supervisorId" }],
-        degradations: [],
-      },
-    })
-  );
-  writeFileSync(
-    join(dir, "state", "cost-tracking", `${DAY}.jsonl`),
-    JSON.stringify({ ts: `${DAY}T10:00:00Z`, model: "opus", source: "dispatcher", input_tokens: 10, output_tokens: 10, total_cost_usd: spentUsd, estimated_usd: spentUsd }) + "\n"
-  );
-  return dir;
-}
-const notifiedBands = (dir) => {
-  const p = join(dir, "state", "cost-tracking", `${DAY}.budget.json`);
-  return existsSync(p) ? (JSON.parse(readFileSync(p, "utf-8")).notified_bands || []) : [];
-};
-
-test("a transient delivery failure does NOT burn the period's band — it is retried", async () => {
-  // The defect: `maybeNotify` wrote `notified_bands` BEFORE any delivery was
-  // attempted, and nothing could un-mark it. One ECONNREFUSED (or a daemon that
-  // started before the org credential resolved) permanently dropped the 80% rung
-  // for the whole period, and the 5-minute timer then polled forever without
-  // ever retrying. The rung's entire purpose is to tell the supervisor.
-  const dir = await escalateRoot();
-  try {
-    const deps = (callImpl) => ({
-      log: () => {}, now: () => FIXED, retryMs: 0, callImpl,
-      sendImpl: async () => ({ ok: true, result: { id: "m1" } }),
-    });
-
-    const t1 = await escalateBudget({ agentRoot: dir, conn: CONN }, deps(async () => { throw new Error("ECONNREFUSED"); }));
-    assert.equal(t1.notified, true);
-    assert.equal(t1.delivered, false);
-    assert.deepEqual(notifiedBands(dir), [], "the band is NOT consumed by a failed attempt");
-
-    // hq recovers. The next tick must actually deliver.
-    const sent = [];
-    const t2 = await escalateBudget({ agentRoot: dir, conn: CONN }, {
-      ...deps(async () => ({ ok: true, result: { channelId: "chan_1" } })),
-      sendImpl: async (p) => { sent.push(p); return { ok: true, result: { id: "m1" } }; },
-    });
-    assert.equal(t2.delivered, true, "the retry lands");
-    assert.equal(sent.length, 1);
-    assert.ok(notifiedBands(dir).includes(80), "and NOW the band is consumed");
-
-    // And it does not re-send afterwards.
-    const t3 = await escalateBudget({ agentRoot: dir, conn: CONN }, deps(async () => ({ ok: true, result: { channelId: "chan_1" } })));
-    assert.equal(t3.notified, false, "at most one notice per band per period");
-  } finally { await fsp.rm(dir, { recursive: true, force: true }); }
-});
-
-test("a persistent outage gives up LOUDLY rather than retrying forever in silence", async () => {
-  const dir = await escalateRoot();
-  try {
-    const logged = [];
-    const deps = { log: (lvl, msg) => logged.push(`${lvl} ${msg}`), now: () => FIXED, retryMs: 0,
-      callImpl: async () => { throw new Error("ECONNREFUSED"); }, sendImpl: async () => ({ ok: true }) };
-    for (let i = 0; i < 8; i++) await escalateBudget({ agentRoot: dir, conn: CONN }, deps);
-    assert.ok(notifiedBands(dir).includes(80), "the band is finally consumed so the log stops spinning");
-    assert.ok(logged.some((l) => /ABANDONED after/.test(l)), "and giving up is an ERROR, not a shrug");
-  } finally { await fsp.rm(dir, { recursive: true, force: true }); }
-});