@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/scripts/cloud-relay/voice/relay-identity.test.mjs

@@ -1,96 +0,0 @@
-/**
- * relay-identity.test.mjs — the PSTN relay must never invent an employer.
- *
- * WHAT BROKE
- *   `buildSessionUpdate()` built its last-resort instructions as:
- *     `You are ${identity.name || "the agent"}, ${identity.role || "an executive
- *      operator"} at ${identity.company || "Northwind"}.`
- *   This service is the DEPLOYED Railway relay that answers inbound PSTN calls.
- *   The fallback fires whenever the local agent queues a call with a bare
- *   `brief` and no `instructions`, and whatever it says is spoken to a person on
- *   a phone line — it leaves the org irrecoverably.
- *
- * WHY THE FIX IS SERVER-SIDE REFUSAL
- *   The relay runs on Railway with no access to config/agent.json or
- *   config/company.json. Everything it knows about the agent arrived in the
- *   queue entry. A field that did not arrive is a field this process CANNOT
- *   know, so the only honest behaviour is to drop the clause.
- *
- * HOW IT RUNS
- *   The relay ships its own package.json and depends on `ws`, which is not
- *   resolvable from this repo root, so server.mjs cannot be imported in-process.
- *   The identity helpers are pure, so we lift their REAL source out of the
- *   shipped file and evaluate that — the text under test is the text that ships.
- *
- * Run: node --test scripts/cloud-relay/voice/relay-identity.test.mjs
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-
-const SRC = readFileSync(new URL("./server.mjs", import.meta.url), "utf8");
-
-function extractFunction(src, name) {
-  const re = new RegExp(`(?:export\\s+)?function\\s+${name}\\s*\\(`);
-  const m = re.exec(src);
-  assert.ok(m, `server.mjs no longer defines ${name}() — update this test deliberately`);
-  const open = src.indexOf("{", m.index + m[0].length - 1);
-  let depth = 0;
-  for (let i = open; i < src.length; i++) {
-    if (src[i] === "{") depth++;
-    else if (src[i] === "}" && --depth === 0) return src.slice(m.index, i + 1).replace(/^export\s+/, "");
-  }
-  throw new Error(`unbalanced braces extracting ${name}`);
-}
-
-const names = ["configured", "fallbackInstructions"];
-const mod = new Function(
-  `${names.map((n) => extractFunction(SRC, n)).join("\n\n")}\nreturn { ${names.join(", ")} };`,
-)();
-const { fallbackInstructions } = mod;
-
-// ── GROUNDED — the local agent shipped a real identity ──────────────────────
-
-test("grounded: the full identity from the queue entry is spoken", () => {
-  const out = fallbackInstructions({ name: "Robin Okafor", role: "VP Operations", company: "Meridian Freight" });
-  assert.equal(out, "You are Robin Okafor, VP Operations at Meridian Freight. Reply briefly in your voice.");
-});
-
-// ── EMPTY — omit the clause, never substitute a default ─────────────────────
-
-test("empty: no company ⇒ the 'at <company>' clause is DROPPED, not defaulted", () => {
-  const out = fallbackInstructions({ name: "Robin Okafor", role: "VP Operations" });
-  assert.equal(out, "You are Robin Okafor, VP Operations. Reply briefly in your voice.");
-  assert.doesNotMatch(out, / at /);
-});
-
-test("empty: the UNCONFIGURED sentinel is treated as absent", () => {
-  const out = fallbackInstructions({ name: "Robin Okafor", role: "VP Operations", company: "UNCONFIGURED" });
-  assert.doesNotMatch(out, /UNCONFIGURED/);
-  assert.doesNotMatch(out, / at /);
-});
-
-test("empty: no role ⇒ no invented role", () => {
-  const out = fallbackInstructions({ name: "Robin Okafor" });
-  assert.equal(out, "You are Robin Okafor. Reply briefly in your voice.");
-  assert.doesNotMatch(out, /executive operator/i);
-});
-
-test("empty: nothing at all ⇒ NO persona is asserted to the caller", () => {
-  for (const id of [{}, { name: "", role: "", company: "" }, { name: "   " }]) {
-    const out = fallbackInstructions(id);
-    assert.equal(out, "Reply briefly in your voice.", JSON.stringify(id));
-    assert.doesNotMatch(out, /You are/);
-  }
-});
-
-// ── The literal is gone from the deployed source ────────────────────────────
-
-test("the deployed relay source carries no default employer", () => {
-  assert.doesNotMatch(SRC, /\bNorthwind\b/i);
-  assert.doesNotMatch(SRC, /identity\.company \|\|/, "no `|| <default>` on the employer");
-  assert.doesNotMatch(SRC, /an executive operator/, "no `|| <default>` on the role");
-});

package/scripts/collective/hook-runner.test.mjs

@@ -1,173 +0,0 @@
-/**
- * hook-runner.test.mjs — integration test for the global hook entry point.
- * Spawns the runner against a temp MAESTRO_COLLECTIVE_ROOT so it never touches
- * the real repo state.
- * Run: node --test scripts/collective/hook-runner.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
-
-import { register } from "../../lib/collective/presence.mjs";
-import { appendCards } from "../../lib/collective/cards.mjs";
-
-const RUNNER = join(dirname(fileURLToPath(import.meta.url)), "hook-runner.mjs");
-
-function tmpRoot() {
-  const root = mkdtempSync(join(tmpdir(), "collective-hook-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  return root;
-}
-function run(event, input, root, extraEnv = {}) {
-  const env = { ...process.env, MAESTRO_COLLECTIVE_ROOT: root };
-  delete env.MAESTRO_DAEMON; // never inherit a daemon marker from the runner's own environment
-  Object.assign(env, extraEnv);
-  return spawnSync(process.execPath, [RUNNER, event], {
-    input: JSON.stringify(input),
-    encoding: "utf8",
-    env,
-  });
-}
-
-test("prime: silent (exit 0, no output) when nothing to say", () => {
-  const root = tmpRoot();
-  try {
-    const r = run("prime", { session_id: "me", cwd: "/x/maestro" }, root);
-    assert.equal(r.status, 0);
-    assert.equal(r.stdout.trim(), "", "no presence + no cards → no digest");
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("prime: injects a digest when peers are active / cards exist", () => {
-  const root = tmpRoot();
-  try {
-    register(root, { sessionId: "other", cwd: "/x/openclaw", intent: "research" });
-    appendCards(root, [{ kind: "decision", title: "Shipped billing", salience: 0.9, ts: new Date().toISOString() }], { sessionId: "prev" });
-    const r = run("prime", { session_id: "me", cwd: "/x/maestro" }, root);
-    assert.equal(r.status, 0);
-    const payload = JSON.parse(r.stdout);
-    const ctx = payload.hookSpecificOutput.additionalContext;
-    assert.match(ctx, /maestro:collective-digest/);
-    assert.match(ctx, /Active now:/);
-    assert.match(ctx, /Shipped billing/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("prime: denylisted cwd gets NO memory injected (leak guard)", () => {
-  const root = tmpRoot();
-  try {
-    writeFileSync(join(root, "config", "collective.yaml"), "repoDenylist: [client-secret]\n");
-    register(root, { sessionId: "other", cwd: "/x/openclaw" });
-    appendCards(root, [{ title: "sensitive agent memory", ts: new Date().toISOString() }], { sessionId: "p" });
-    const r = run("prime", { session_id: "me", cwd: "/work/client-secret" }, root);
-    assert.equal(r.status, 0);
-    assert.equal(r.stdout.trim(), "", "denylisted session must not receive the digest");
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("beat + stop: exit 0 and manage presence", () => {
-  const root = tmpRoot();
-  try {
-    assert.equal(run("prime", { session_id: "s1", cwd: "/x/maestro" }, root).status, 0);
-    assert.equal(run("beat", { session_id: "s1", cwd: "/x/maestro" }, root).status, 0);
-    const stop = run("stop", { session_id: "s1", cwd: "/x/maestro", transcript_path: "" }, root);
-    assert.equal(stop.status, 0);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("disabled config → fully silent no-op", () => {
-  const root = tmpRoot();
-  try {
-    writeFileSync(join(root, "config", "collective.yaml"), "enabled: false\n");
-    register(root, { sessionId: "other", cwd: "/x/openclaw" });
-    const r = run("prime", { session_id: "me", cwd: "/x/maestro" }, root);
-    assert.equal(r.status, 0);
-    assert.equal(r.stdout.trim(), "");
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-// ── WP-M4: the front-door primer (identity block + session status) ─────────
-
-test("prime: injects the identity block + one-line session status + handoff/board counts when the repo has an identity", () => {
-  const root = tmpRoot();
-  try {
-    writeFileSync(join(root, "config", "agent.json"), JSON.stringify({
-      firstName: "Alex", fullName: "Alex Rivera", title: "Chief of Staff", company: "Acme",
-      principal: { fullName: "Jordan Lee", title: "CEO" }, repoSlug: "alex-ai",
-    }));
-    mkdirSync(join(root, "state", "session", "handoffs"), { recursive: true });
-    mkdirSync(join(root, "state", "org"), { recursive: true });
-    writeFileSync(join(root, "state", "session", "heartbeat.json"), JSON.stringify({ pid: 1, name: "alex-main", ts: Date.now() }));
-    writeFileSync(join(root, "state", "session", "handoffs", "t1.json"), "{}");
-    writeFileSync(join(root, "state", "session", "handoffs", "t2.json"), "{}");
-    writeFileSync(join(root, "state", "org", "board-mine.json"), JSON.stringify({ items: [{ itemId: "i1" }], fetchedAt: new Date().toISOString() }));
-    const r = run("prime", { session_id: "me", cwd: "/x/maestro" }, root);
-    assert.equal(r.status, 0);
-    const payload = JSON.parse(r.stdout);
-    const ctx = payload.hookSpecificOutput.additionalContext;
-    assert.match(ctx, /maestro:identity/);
-    assert.match(ctx, /Alex Rivera/);
-    assert.match(ctx, /Chief of Staff/);
-    assert.match(ctx, /`alex-main`/);
-    assert.match(ctx, /Session status: main session alex-main live/);
-    assert.match(ctx, /2 open handoffs/);
-    assert.match(ctx, /1 board item/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("prime: identity primer and memory digest are emitted together in ONE hook frame", () => {
-  const root = tmpRoot();
-  try {
-    writeFileSync(join(root, "config", "agent.json"), JSON.stringify({ firstName: "Alex", fullName: "Alex Rivera" }));
-    register(root, { sessionId: "other", cwd: "/x/openclaw", intent: "research" });
-    appendCards(root, [{ kind: "decision", title: "Shipped billing", salience: 0.9, ts: new Date().toISOString() }], { sessionId: "prev" });
-    const r = run("prime", { session_id: "me", cwd: "/x/maestro" }, root);
-    assert.equal(r.status, 0);
-    const frames = r.stdout.trim().split("\n").filter(Boolean);
-    assert.equal(frames.length, 1, "exactly one JSON frame on stdout");
-    const ctx = JSON.parse(frames[0]).hookSpecificOutput.additionalContext;
-    assert.match(ctx, /maestro:collective-digest/);
-    assert.match(ctx, /Shipped billing/);
-    assert.match(ctx, /maestro:identity/);
-    assert.match(ctx, /Session status: main session not running/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("prime: a denylisted cwd gets neither memory nor identity", () => {
-  const root = tmpRoot();
-  try {
-    writeFileSync(join(root, "config", "collective.yaml"), "repoDenylist: [client-secret]\n");
-    writeFileSync(join(root, "config", "agent.json"), JSON.stringify({ firstName: "Alex", fullName: "Alex Rivera" }));
-    const r = run("prime", { session_id: "me", cwd: "/work/client-secret" }, root);
-    assert.equal(r.status, 0);
-    assert.equal(r.stdout.trim(), "");
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("prime: the daemon's own `claude --print` children (MAESTRO_DAEMON=1) get the memory digest but NOT the identity primer", () => {
-  const root = tmpRoot();
-  try {
-    writeFileSync(join(root, "config", "agent.json"), JSON.stringify({ firstName: "Alex", fullName: "Alex Rivera" }));
-    // No digest material → a daemon child is fully silent.
-    const quiet = run("prime", { session_id: "d1", cwd: "/x/maestro" }, root, { MAESTRO_DAEMON: "1" });
-    assert.equal(quiet.status, 0);
-    assert.equal(quiet.stdout.trim(), "", "no identity block for a daemon child");
-    // With digest material → the digest still flows, the identity block still does not.
-    register(root, { sessionId: "other", cwd: "/x/openclaw", intent: "research" });
-    appendCards(root, [{ kind: "decision", title: "Shipped billing", salience: 0.9, ts: new Date().toISOString() }], { sessionId: "prev" });
-    const r = run("prime", { session_id: "d2", cwd: "/x/maestro" }, root, { MAESTRO_DAEMON: "1" });
-    assert.equal(r.status, 0);
-    const ctx = JSON.parse(r.stdout).hookSpecificOutput.additionalContext;
-    assert.match(ctx, /Shipped billing/);
-    assert.ok(!/maestro:identity/.test(ctx), "identity primer is skipped for daemon children");
-    // An interactive session on the same repo still gets it.
-    const i = run("prime", { session_id: "i1", cwd: "/x/maestro" }, root);
-    assert.match(JSON.parse(i.stdout).hookSpecificOutput.additionalContext, /maestro:identity/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});

package/scripts/cost/fleet-digest.test.mjs

@@ -1,207 +0,0 @@
-/**
- * Tests for scripts/cost/fleet-digest.mjs — the daily fleet cost digest.
- * Covers: local-ledger aggregation (byAgent/byModel/totalUSD), the cacheReadRatio
- * KPI computed from raw token columns (incl. the >=60% target flag), top spenders,
- * and the optional org-rollup leg (injected rollupImpl, both pre-aggregated and
- * raw-rows shapes) with fail-open fallback to local.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  fleetDigest,
-  aggregateRows,
-  aggregateFromRollup,
-  topSpenders,
-} from "./fleet-digest.mjs";
-
-const DAY = "2026-06-10";
-
-function tmpLedger(rows, day = DAY) {
-  const dir = mkdtempSync(join(tmpdir(), "fleet-digest-"));
-  const ledgerDir = join(dir, "state", "cost-tracking");
-  mkdirSync(ledgerDir, { recursive: true });
-  writeFileSync(join(ledgerDir, `${day}.jsonl`), rows.map((r) => JSON.stringify(r)).join("\n") + "\n");
-  return { ledgerDir, dir };
-}
-
-// ---------------------------------------------------------------------------
-// aggregateRows — the pure aggregator
-// ---------------------------------------------------------------------------
-
-test("aggregateRows: byAgent + byModel + total", () => {
-  const a = aggregateRows([
-    { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 2.0 },
-    { agent: "alex", model: "claude-haiku-4-5", estimated_usd: 0.5 },
-    { agent: "robin", model: "claude-sonnet-4-6", estimated_usd: 1.0 },
-  ]);
-  assert.equal(a.totalUSD, 3.5);
-  assert.equal(a.sessions, 3);
-  assert.equal(a.byAgent.alex, 2.5);
-  assert.equal(a.byAgent.robin, 1.0);
-  assert.equal(a.byModel["claude-sonnet-4-6"], 3.0);
-  assert.equal(a.byModel["claude-haiku-4-5"], 0.5);
-});
-
-test("aggregateRows: cacheReadRatio from raw token columns", () => {
-  // input(miss)=200, cache_read=800, cache_creation=0 → 800/1000 = 0.8
-  const a = aggregateRows([
-    { agent: "a", model: "m", estimated_usd: 1, input_tokens: 200, cache_read_tokens: 800, cache_creation_tokens: 0 },
-  ]);
-  assert.equal(a.cacheReadRatio, 0.8);
-  assert.equal(a.tokens.cache_read, 800);
-});
-
-test("aggregateRows: cacheReadRatio denominator includes cache_creation", () => {
-  // input=100, cache_read=100, cache_creation=300 → 100/500 = 0.2
-  const a = aggregateRows([
-    { agent: "a", model: "m", estimated_usd: 1, input_tokens: 100, cache_read_tokens: 100, cache_creation_tokens: 300 },
-  ]);
-  assert.equal(a.cacheReadRatio, 0.2);
-});
-
-test("aggregateRows: no tokens → ratio 0, never NaN", () => {
-  const a = aggregateRows([{ agent: "a", model: "m", estimated_usd: 1 }]);
-  assert.equal(a.cacheReadRatio, 0);
-});
-
-test("aggregateRows: empty input → zeroed digest, never throws", () => {
-  const a = aggregateRows([]);
-  assert.equal(a.totalUSD, 0);
-  assert.equal(a.sessions, 0);
-  assert.deepEqual(a.byAgent, {});
-});
-
-test("aggregateRows: total_cost_usd fallback when estimated_usd absent", () => {
-  const a = aggregateRows([{ agent: "a", model: "m", total_cost_usd: 4.0 }]);
-  assert.equal(a.totalUSD, 4.0);
-});
-
-// ---------------------------------------------------------------------------
-// topSpenders
-// ---------------------------------------------------------------------------
-
-test("topSpenders: ranks descending and limits", () => {
-  const t = topSpenders({ alex: 5, robin: 9, sam: 1 }, 2);
-  assert.deepEqual(t, [{ agent: "robin", usd: 9 }, { agent: "alex", usd: 5 }]);
-});
-
-// ---------------------------------------------------------------------------
-// fleetDigest — local leg
-// ---------------------------------------------------------------------------
-
-test("fleetDigest: local-only digest from a tmp ledger", async () => {
-  const { ledgerDir } = tmpLedger([
-    { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 3.0, input_tokens: 100, cache_read_tokens: 900, cache_creation_tokens: 0 },
-    { agent: "robin", model: "claude-haiku-4-5", estimated_usd: 1.0, input_tokens: 50, cache_read_tokens: 50, cache_creation_tokens: 0 },
-  ]);
-  const d = await fleetDigest({ ledgerDir, day: DAY });
-  assert.equal(d.source, "local");
-  assert.equal(d.totalUSD, 4.0);
-  assert.equal(d.sessions, 2);
-  assert.equal(d.byAgent.alex, 3.0);
-  assert.equal(d.topSpenders[0].agent, "alex");
-  // combined cache ratio: cache_read=950, denom=100+900+50+50+0 = 1100 → 950/1100
-  assert.equal(d.cacheReadRatio, Number((950 / 1100).toFixed(4)));
-});
-
-test("fleetDigest: cacheReadKpiOk reflects the >=60% target", async () => {
-  const okLedger = tmpLedger([
-    { agent: "a", model: "m", estimated_usd: 1, input_tokens: 100, cache_read_tokens: 900, cache_creation_tokens: 0 },
-  ]);
-  const okDigest = await fleetDigest({ ledgerDir: okLedger.ledgerDir, day: DAY });
-  assert.equal(okDigest.cacheReadKpiOk, true);
-
-  const badLedger = tmpLedger([
-    { agent: "a", model: "m", estimated_usd: 1, input_tokens: 900, cache_read_tokens: 100, cache_creation_tokens: 0 },
-  ]);
-  const badDigest = await fleetDigest({ ledgerDir: badLedger.ledgerDir, day: DAY });
-  assert.equal(badDigest.cacheReadKpiOk, false);
-});
-
-test("fleetDigest: missing ledger → empty digest, never throws", async () => {
-  const d = await fleetDigest({ ledgerDir: "/nonexistent", day: DAY });
-  assert.equal(d.totalUSD, 0);
-  assert.equal(d.sessions, 0);
-  assert.equal(d.source, "local");
-});
-
-// ---------------------------------------------------------------------------
-// fleetDigest — org rollup leg (injected rollupImpl)
-// ---------------------------------------------------------------------------
-
-test("fleetDigest: org leg with pre-aggregated rollup payload", async () => {
-  const { ledgerDir } = tmpLedger([{ agent: "alex", model: "m", estimated_usd: 1.0 }]);
-  const rollupImpl = async () => ({
-    totalUSD: 120.5,
-    byAgent: { alex: 60, robin: 40.5, sam: 20 },
-    byModel: { "claude-sonnet-4-6": 100, "claude-haiku-4-5": 20.5 },
-    sessions: 42,
-    tokens: { input: 1000, cache_read: 4000, cache_creation: 0 }, // 4000/5000 = 0.8
-  });
-  const d = await fleetDigest({ ledgerDir, day: DAY, org: true, rollupImpl });
-  assert.equal(d.source, "org-rollup");
-  assert.equal(d.totalUSD, 120.5);
-  assert.equal(d.sessions, 42);
-  assert.equal(d.cacheReadRatio, 0.8);
-  assert.equal(d.topSpenders[0].agent, "alex");
-  assert.equal(d.topSpenders[0].usd, 60);
-});
-
-test("fleetDigest: org leg with raw-rows rollup payload", async () => {
-  const { ledgerDir } = tmpLedger([{ agent: "x", model: "m", estimated_usd: 999 }]);
-  const rollupImpl = async () => ({
-    rows: [
-      { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 10, input_tokens: 100, cache_read_tokens: 100, cache_creation_tokens: 0 },
-      { agent: "robin", model: "claude-haiku-4-5", estimated_usd: 5 },
-    ],
-  });
-  const d = await fleetDigest({ ledgerDir, day: DAY, org: true, rollupImpl });
-  assert.equal(d.source, "org-rollup");
-  assert.equal(d.totalUSD, 15); // NOT the local 999
-  assert.equal(d.byAgent.alex, 10);
-});
-
-test("fleetDigest: org leg unavailable → fall back to local with a note", async () => {
-  const { ledgerDir } = tmpLedger([{ agent: "alex", model: "m", estimated_usd: 7.0 }]);
-  const rollupImpl = async () => null; // server down / disabled
-  const d = await fleetDigest({ ledgerDir, day: DAY, org: true, rollupImpl });
-  assert.equal(d.source, "local");
-  assert.equal(d.totalUSD, 7.0);
-  assert.ok(d.notes.some((n) => /unavailable\/empty/.test(n)));
-});
-
-test("fleetDigest: a throwing rollupImpl is caught and falls back to local", async () => {
-  const { ledgerDir } = tmpLedger([{ agent: "alex", model: "m", estimated_usd: 2.0 }]);
-  const d = await fleetDigest({ ledgerDir, day: DAY, org: true, rollupImpl: async () => { throw new Error("boom"); } });
-  assert.equal(d.source, "local");
-  assert.equal(d.totalUSD, 2.0);
-});
-
-// ---------------------------------------------------------------------------
-// aggregateFromRollup — recompute KPI from tokens, ignore stale server ratio
-// ---------------------------------------------------------------------------
-
-test("aggregateFromRollup: recomputes cacheReadRatio from tokens (stale server ratio ignored)", () => {
-  const agg = aggregateFromRollup({
-    totalUSD: 10,
-    byAgent: { a: 10 },
-    cacheReadRatio: 0.99, // server claims 99% ...
-    tokens: { input: 500, cache_read: 500, cache_creation: 0 }, // ... but tokens say 50%
-  });
-  assert.equal(agg.cacheReadRatio, 0.5);
-});
-
-test("aggregateFromRollup: trusts server ratio only when tokens absent", () => {
-  const agg = aggregateFromRollup({ totalUSD: 10, byAgent: { a: 10 }, cache_read_ratio: 0.65 });
-  assert.equal(agg.cacheReadRatio, 0.65);
-});
-
-test("aggregateFromRollup: empty/garbage payload → zeroed, never throws", () => {
-  assert.equal(aggregateFromRollup(null).totalUSD, 0);
-  assert.equal(aggregateFromRollup("nope").sessions, 0);
-});

package/scripts/cost/track-claude-usage-pricing.test.mjs

@@ -1,183 +0,0 @@
-/**
- * track-claude-usage-pricing.test.mjs — an unknown model must not be priced.
- *
- * WHAT BROKE
- *   `estimateUsd()` ended `loadPrices()[model] || DEFAULT_PRICES.sonnet`. An
- *   unknown model — a third-party backend, a retired catalog id, a typo in a
- *   spawn flag — was silently priced at Sonnet's rate and written as a real
- *   `estimated_usd`. lib/cost/ledger-row.mjs#billableUsd then reported
- *   basis:"estimated", a MEASURED tier, and that laundered number flowed into
- *   budget-guard's degrade/refuse band, fleet-digest, and the presence beat's
- *   `machine.spend24h` — which peers and humans read as this seat's REAL spend.
- *   A guessed price is a fabricated measurement of money.
- *
- * WHAT THESE TESTS PIN (end-to-end, through the real CLI)
- *   1. GROUNDED — a model priced by a REAL source (the local tier table, or a
- *      lib/model-router/catalog row with its cost_provenance stamp) still bills.
- *   2. EMPTY — a model no real source prices writes `estimated_usd: null`, an
- *      `unpriced_reason`, and lands in the UNKNOWN class as basis:"unpriced" —
- *      the vocabulary lib/cost/ledger-row.mjs already has for exactly this case
- *      — so it is imputed, not counted as a free session.
- *
- * Run: node --test scripts/cost/track-claude-usage-pricing.test.mjs
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import { mkdtempSync, mkdirSync, copyFileSync, readFileSync, readdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { billableUsd, classifyRow, summariseRows, UNKNOWN } from "../../lib/cost/ledger-row.mjs";
-
-const CLI = new URL("./track-claude-usage.mjs", import.meta.url).pathname;
-
-/** Run `record` against a throwaway ledger dir and return {stdout, row}. */
-function record(root, args) {
-  const out = execFileSync(process.execPath, [CLI, "record", ...args], {
-    env: { ...process.env, AGENT_ROOT: root },
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  const dir = join(root, "state/cost-tracking");
-  const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
-  const lines = readFileSync(join(dir, files[0]), "utf8").trim().split("\n");
-  return { stdout: JSON.parse(out), row: JSON.parse(lines[lines.length - 1]) };
-}
-
-// ── 1. GROUNDED ─────────────────────────────────────────────────────────────
-
-test("grounded: a tier alias in the local price table still bills", () => {
-  const root = mkdtempSync(join(tmpdir(), "cost-"));
-  const { stdout, row } = record(root, [
-    "--cadence", "inbox", "--model", "sonnet",
-    "--input-tokens", "1000", "--output-tokens", "500", "--exit", "0",
-  ]);
-  assert.equal(stdout.basis, "estimated");
-  assert.ok(row.estimated_usd > 0, "a real price produces a real figure");
-  assert.equal(row.unpriced_reason, undefined);
-  rmSync(root, { recursive: true, force: true });
-});
-
-test("grounded: a concrete catalog id is priced from lib/model-router/catalog", () => {
-  const root = mkdtempSync(join(tmpdir(), "cost-"));
-  const { stdout, row } = record(root, [
-    "--cadence", "inbox", "--model", "claude-opus-4-8",
-    "--input-tokens", "1000000", "--output-tokens", "0", "--exit", "0",
-  ]);
-  assert.equal(stdout.basis, "estimated");
-  // anthropic.yaml: claude-opus-4-8 input = $5.00/MTok. This is the catalog's
-  // own figure, not a family guess.
-  assert.equal(row.estimated_usd, 5);
-  rmSync(root, { recursive: true, force: true });
-});
-
-test("grounded: the CLI's authoritative total_cost_usd always wins", () => {
-  const root = mkdtempSync(join(tmpdir(), "cost-"));
-  const { stdout } = record(root, [
-    "--cadence", "inbox", "--model", "sonnet",
-    "--input-tokens", "16", "--output-tokens", "10", "--cache-read-tokens", "553181",
-    "--total-cost-usd", "0.533412", "--exit", "0",
-  ]);
-  assert.equal(stdout.basis, "authoritative");
-  assert.equal(stdout.billable_usd, 0.533412);
-  rmSync(root, { recursive: true, force: true });
-});
-
-// ── 2. EMPTY — no real price, no number ─────────────────────────────────────
-
-test("empty: an unknown model is UNPRICED, not silently billed at the Sonnet rate", () => {
-  const root = mkdtempSync(join(tmpdir(), "cost-"));
-  const { stdout, row } = record(root, [
-    "--cadence", "inbox", "--model", "some-vendor-model-v9",
-    "--input-tokens", "1000", "--output-tokens", "500", "--exit", "0",
-  ]);
-
-  assert.equal(row.estimated_usd, null, "no guessed figure is written");
-  assert.equal(row.total_cost_usd, undefined, "and none is invented");
-  assert.match(row.unpriced_reason, /no price for model "some-vendor-model-v9"/);
-
-  // The reader's verdict is the thing that matters downstream.
-  const { usd, basis } = billableUsd(row);
-  assert.equal(usd, null, "spend is UNKNOWN, not zero");
-  assert.equal(basis, "unpriced");
-  assert.equal(classifyRow(row), "measured");
-  assert.equal(billableUsd(row).cls, UNKNOWN, "it falls into the UNKNOWN class");
-  assert.equal(stdout.billable_usd, null);
-  assert.equal(stdout.basis, "unpriced");
-  rmSync(root, { recursive: true, force: true });
-});
-
-test("empty: an unpriced row is counted in `unmeasured` and flagged as a degradation", () => {
-  const root = mkdtempSync(join(tmpdir(), "cost-"));
-  const { row } = record(root, [
-    "--cadence", "inbox", "--model", "some-vendor-model-v9",
-    "--input-tokens", "1000", "--output-tokens", "500", "--exit", "0",
-  ]);
-  const s = summariseRows([row]);
-  assert.equal(s.unmeasured, 1, "imputeUnmeasured's base, not a measured $0");
-  assert.equal(s.measured, 0);
-  assert.equal(s.measuredUsd, 0);
-  assert.ok(s.degradations.some((d) => /NO price/.test(d)), "the reader says pricing is broken");
-  rmSync(root, { recursive: true, force: true });
-});
-
-test("empty: the unpriced row does NOT sneak into a spend total via summarise", () => {
-  const root = mkdtempSync(join(tmpdir(), "cost-"));
-  record(root, ["--cadence", "inbox", "--model", "some-vendor-model-v9", "--input-tokens", "1000", "--output-tokens", "500", "--exit", "0"]);
-  const out = JSON.parse(
-    execFileSync(process.execPath, [CLI, "summarise", "--days", "7"], {
-      env: { ...process.env, AGENT_ROOT: root },
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-    }),
-  );
-  assert.equal(out.totals.sessions, 1);
-  assert.equal(out.totals.unmeasured_sessions, 1, "counted as unmeasured");
-  assert.equal(out.totals.unpriced_sessions, 1, "and specifically as unpriced");
-  assert.equal(out.totals.billable_usd, 0, "no null-arithmetic leaked a number in");
-  assert.equal(out.measurement.unmeasured_sessions, 1);
-  rmSync(root, { recursive: true, force: true });
-});
-
-test("the tracker still RECORDS when lib/model-router is absent (a lost row is worse)", () => {
-  // The tracker runs as a detached child from an agent repo whose lib/ tree may
-  // not carry the model router. A hard dependency on it would kill `record` on
-  // import and write NOTHING — invisible spend, which is strictly worse than an
-  // unpriced row. Stage a synthetic root with ONLY the billing contract present.
-  const root = mkdtempSync(join(tmpdir(), "cost-norouter-"));
-  mkdirSync(join(root, "scripts/cost"), { recursive: true });
-  mkdirSync(join(root, "lib/cost"), { recursive: true });
-  copyFileSync(new URL("./track-claude-usage.mjs", import.meta.url), join(root, "scripts/cost/track-claude-usage.mjs"));
-  copyFileSync(new URL("../../lib/cost/ledger-row.mjs", import.meta.url), join(root, "lib/cost/ledger-row.mjs"));
-
-  const out = execFileSync(
-    process.execPath,
-    [join(root, "scripts/cost/track-claude-usage.mjs"), "record",
-      "--cadence", "inbox", "--model", "sonnet",
-      "--input-tokens", "1000", "--output-tokens", "500", "--exit", "0"],
-    { env: { ...process.env, AGENT_ROOT: root }, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
-  );
-  const res = JSON.parse(out);
-  assert.equal(res.ok, true, "the row is still written with no model router present");
-  assert.equal(res.basis, "estimated", "the local tier table still prices the tier aliases");
-
-  // …and an unknown model there is still UNPRICED, not guessed.
-  const out2 = execFileSync(
-    process.execPath,
-    [join(root, "scripts/cost/track-claude-usage.mjs"), "record",
-      "--cadence", "inbox", "--model", "claude-opus-4-8",
-      "--input-tokens", "1000", "--output-tokens", "500", "--exit", "0"],
-    { env: { ...process.env, AGENT_ROOT: root }, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
-  );
-  assert.equal(JSON.parse(out2).basis, "unpriced", "no catalog ⇒ a catalog-only id is unpriced, not guessed");
-  rmSync(root, { recursive: true, force: true });
-});
-
-test("the source no longer defaults an unknown model to a known tier's price", () => {
-  const src = readFileSync(new URL("./track-claude-usage.mjs", import.meta.url), "utf8");
-  assert.doesNotMatch(src, /loadPrices\(\)\[model\]\s*\|\|\s*DEFAULT_PRICES/);
-});