@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/model-router/pricing-refresh.test.mjs

@@ -1,286 +0,0 @@
-/**
- * pricing-refresh.test.mjs — the OpenClaw external pricing oracle.
- *
- * Verifies: refreshPricing merges an injected LiteLLM + OpenRouter response into
- * the cost-only cache ($/MTok, provenance-stamped); a partial failure backfills
- * from the existing cache; a fully-offline refresh fails open (cache untouched);
- * the written cache is the catalog-consumable flat shape; refresh writes COST
- * fields only; an optional refs allowlist narrows the write.
- *
- * Injected fetchImpl — no network. Run: node --test lib/model-router/pricing-refresh.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  refreshPricing,
-  parseLiteLLM,
-  parseOpenRouter,
-  _internals,
-} from "./pricing-refresh.mjs";
-import { loadCatalog, _internals as catInternals } from "./catalog.mjs";
-
-function tmpStateDir() {
-  return mkdtempSync(join(tmpdir(), "pricing-"));
-}
-
-// A LiteLLM JSON ($/token). deepseek-chat: input 0.14/MTok, output 0.28/MTok.
-const LITELLM_JSON = {
-  sample_spec: { note: "ignored" },
-  "deepseek/deepseek-chat": {
-    litellm_provider: "deepseek",
-    input_cost_per_token: 0.00000014,
-    output_cost_per_token: 0.00000028,
-    cache_read_input_token_cost: 0.000000028,
-  },
-  "claude-sonnet-4-6": {
-    litellm_provider: "anthropic",
-    input_cost_per_token: 0.000003,
-    output_cost_per_token: 0.000015,
-  },
-};
-
-// An OpenRouter /models response ($/token strings).
-const OPENROUTER_JSON = {
-  data: [
-    {
-      id: "deepseek/deepseek-chat",
-      pricing: { prompt: "0.00000020", completion: "0.00000030" },
-    },
-    {
-      id: "moonshotai/kimi-k2.6",
-      pricing: { prompt: "0.0000006", completion: "0.0000025" },
-    },
-  ],
-};
-
-/** A fetch that serves LiteLLM/OpenRouter bodies by URL; `fail` set forces errors. */
-function fakeFetch({ litellm = LITELLM_JSON, openrouter = OPENROUTER_JSON, fail = new Set() } = {}) {
-  const calls = [];
-  const impl = async (url) => {
-    calls.push(url);
-    const isLiteLLM = url.includes("litellm") || url.includes("model_prices");
-    const which = isLiteLLM ? "litellm" : "openrouter";
-    if (fail.has(which)) {
-      return { ok: false, status: 503, text: async () => "" };
-    }
-    const body = isLiteLLM ? litellm : openrouter;
-    return { ok: true, status: 200, text: async () => JSON.stringify(body) };
-  };
-  impl.calls = calls;
-  return impl;
-}
-
-// ---------------------------------------------------------------------------
-// Parsers
-// ---------------------------------------------------------------------------
-
-test("parseLiteLLM normalizes $/token → $/MTok and resolves provider/model refs", () => {
-  const m = parseLiteLLM(LITELLM_JSON);
-  const ds = m.get("deepseek/deepseek-chat");
-  assert.ok(ds);
-  assert.equal(ds.input, 0.14);
-  assert.equal(ds.output, 0.28);
-  assert.equal(ds.cache_read, 0.028);
-  // provider-less key resolves via litellm_provider.
-  assert.ok(m.get("anthropic/claude-sonnet-4-6"));
-  // sample_spec is skipped.
-  assert.equal(m.has("sample_spec"), false);
-});
-
-test("parseOpenRouter normalizes pricing strings and canonicalizes the provider", () => {
-  const m = parseOpenRouter(OPENROUTER_JSON);
-  const ds = m.get("deepseek/deepseek-chat");
-  assert.equal(ds.input, 0.2);
-  assert.equal(ds.output, 0.3);
-  // moonshotai → moonshot (catalog provider key).
-  assert.ok(m.get("moonshot/kimi-k2.6"));
-});
-
-// ---------------------------------------------------------------------------
-// refreshPricing — merge
-// ---------------------------------------------------------------------------
-
-test("refreshPricing merges both sources into the cost-only cache (LiteLLM wins)", async () => {
-  const dir = tmpStateDir();
-  try {
-    const res = await refreshPricing({
-      fetchImpl: fakeFetch(),
-      stateDir: dir,
-      now: () => Date.parse("2026-06-12T00:00:00Z"),
-    });
-    assert.equal(res.ok, true);
-    assert.ok(res.sources.includes("litellm"));
-    assert.ok(res.sources.includes("openrouter"));
-
-    // deepseek-chat is in BOTH → LiteLLM wins field-wise, provenance "litellm+openrouter".
-    const ds = res.cache["deepseek/deepseek-chat"];
-    assert.equal(ds.input, 0.14); // LiteLLM, not OpenRouter's 0.2
-    assert.equal(ds.output, 0.28);
-    assert.equal(ds.cache_read, 0.028);
-    assert.equal(ds.provenance.source, "litellm+openrouter");
-    assert.equal(ds.provenance.volatile, true);
-    assert.equal(ds.provenance.fetched, "2026-06-12T00:00:00.000Z");
-
-    // moonshot only from OpenRouter → provenance "openrouter".
-    assert.equal(res.cache["moonshot/kimi-k2.6"].provenance.source, "openrouter");
-
-    // The cache file is written in the catalog-consumable { models: {...} } shape.
-    const p = join(dir, "pricing-cache.json");
-    assert.equal(existsSync(p), true);
-    const onDisk = JSON.parse(readFileSync(p, "utf-8"));
-    assert.ok(onDisk.models);
-    assert.ok(onDisk.models["deepseek/deepseek-chat"]);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("refreshPricing writes COST fields only (no capability/context fields)", async () => {
-  const dir = tmpStateDir();
-  try {
-    const res = await refreshPricing({ fetchImpl: fakeFetch(), stateDir: dir });
-    const ds = res.cache["deepseek/deepseek-chat"];
-    const allowed = new Set(["input", "output", "cache_read", "cache_write", "tiered", "provenance"]);
-    for (const k of Object.keys(ds)) {
-      assert.ok(allowed.has(k), `unexpected field "${k}" in pricing entry`);
-    }
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// refreshPricing — fail-open + backfill
-// ---------------------------------------------------------------------------
-
-test("refreshPricing fails open when BOTH sources are offline (cache untouched)", async () => {
-  const dir = tmpStateDir();
-  try {
-    const existing = {
-      "deepseek/deepseek-chat": {
-        input: 0.99,
-        output: 1.99,
-        provenance: { source: "litellm", fetched: "2026-06-01T00:00:00.000Z", volatile: true },
-      },
-    };
-    const res = await refreshPricing({
-      fetchImpl: fakeFetch({ fail: new Set(["litellm", "openrouter"]) }),
-      stateDir: dir,
-      existingCache: { models: existing },
-    });
-    assert.equal(res.ok, false);
-    assert.equal(res.written, 0);
-    assert.equal(res.path, null); // nothing written
-    // The returned cache is the untouched existing one.
-    assert.equal(res.cache["deepseek/deepseek-chat"].input, 0.99);
-    // No file written either.
-    assert.equal(existsSync(join(dir, "pricing-cache.json")), false);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("refreshPricing backfills from the existing cache on a partial failure", async () => {
-  const dir = tmpStateDir();
-  try {
-    // OpenRouter offline; only LiteLLM serves. An existing OpenRouter-only entry
-    // (moonshot) must survive the merge (not be deleted).
-    const existing = {
-      "moonshot/kimi-k2.6": {
-        input: 0.6,
-        output: 2.5,
-        provenance: { source: "openrouter", fetched: "2026-06-01T00:00:00.000Z", volatile: true },
-      },
-    };
-    const res = await refreshPricing({
-      fetchImpl: fakeFetch({ fail: new Set(["openrouter"]) }),
-      stateDir: dir,
-      existingCache: { models: existing },
-    });
-    assert.equal(res.ok, true);
-    assert.deepEqual(res.sources, ["litellm"]);
-    // Fresh LiteLLM price merged.
-    assert.equal(res.cache["deepseek/deepseek-chat"].input, 0.14);
-    assert.equal(res.cache["deepseek/deepseek-chat"].provenance.source, "litellm");
-    // Backfilled OpenRouter entry survived.
-    assert.equal(res.cache["moonshot/kimi-k2.6"].input, 0.6);
-    // One error recorded for the offline source.
-    assert.equal(res.errors.some((e) => e.source === "openrouter"), true);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("refreshPricing with no fetchImpl fails open and never throws", async () => {
-  const dir = tmpStateDir();
-  try {
-    const res = await refreshPricing({ stateDir: dir });
-    assert.equal(res.ok, false);
-    assert.equal(existsSync(join(dir, "pricing-cache.json")), false);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("refreshPricing respects an optional refs allowlist", async () => {
-  const dir = tmpStateDir();
-  try {
-    const res = await refreshPricing({
-      fetchImpl: fakeFetch(),
-      stateDir: dir,
-      refs: ["deepseek/deepseek-chat"],
-    });
-    assert.equal(res.ok, true);
-    assert.ok(res.cache["deepseek/deepseek-chat"]);
-    assert.equal(res.cache["moonshot/kimi-k2.6"], undefined);
-    assert.equal(res.cache["anthropic/claude-sonnet-4-6"], undefined);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("a refreshed cache feeds the catalog's cost-only authority layer", () => {
-  // The cache shape the refresh writes is exactly what loadCatalog's pricing-cache
-  // layer consumes — patching cost fields on a bundled row without touching caps.
-  const catalogText = {
-    deepseek: [
-      "provider: deepseek",
-      "auth_env: DEEPSEEK_API_KEY",
-      "endpoints: { anthropic: https://api.deepseek.com/anthropic }",
-      "models:",
-      "  - id: deepseek-chat",
-      "    status: available",
-      "    tool_reliability: B",
-      "    context_window: 64000",
-      "    context_tokens: 60000",
-      "    cost: { input: 9.99, output: 9.99 }",
-    ].join("\n"),
-  };
-  const pricingCache = {
-    models: {
-      "deepseek/deepseek-chat": {
-        input: 0.14,
-        output: 0.28,
-        cache_read: 0.028,
-        provenance: { source: "litellm+openrouter", fetched: "2026-06-12T00:00:00.000Z", volatile: true },
-      },
-    },
-  };
-  const result = loadCatalog(undefined, { catalogText, pricingCache, agentRoot: tmpdir() });
-  const row = result.byRef.get("deepseek/deepseek-chat");
-  assert.ok(row);
-  // Cost overwritten by the cache; capability fields (context) untouched.
-  assert.equal(row.cost.input, 0.14);
-  assert.equal(row.cost.output, 0.28);
-  assert.equal(row.cost.cache_read, 0.028);
-  assert.equal(row.context_window, 64000);
-  assert.equal(row.tool_reliability, "B");
-  assert.equal(row.cost_provenance.source, "litellm+openrouter");
-  assert.equal(row.cost_provenance.volatile, true);
-});

package/lib/model-router/reconcile.test.mjs

@@ -1,316 +0,0 @@
-/**
- * Tests for lib/model-router/reconcile.mjs — the nightly three-way spend
- * reconcile. The Anthropic Admin Cost API is NEVER called live; every test
- * injects a `fetchImpl`. Covers: local-ledger sum, provider-payload parsing
- * (both nested + flat shapes, string/object amounts), drift computation, the
- * >10% flag, the three-way (rollup) leg, and fail-open behavior.
- */
-
-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 {
-  reconcileDaily,
-  sumLocalLedger,
-  fetchProviderCost,
-  computeDrift,
-  DRIFT_THRESHOLD_PCT,
-  _internals,
-} from "./reconcile.mjs";
-
-const DAY = "2026-06-10";
-
-// ---------------------------------------------------------------------------
-// Helpers: write a tmp ledger; build a fake Admin Cost API fetch
-// ---------------------------------------------------------------------------
-
-function tmpLedger(rows, day = DAY) {
-  const dir = mkdtempSync(join(tmpdir(), "reconcile-"));
-  const ledgerDir = join(dir, "state", "cost-tracking");
-  mkdirSync(ledgerDir, { recursive: true });
-  const file = join(ledgerDir, `${day}.jsonl`);
-  writeFileSync(file, rows.map((r) => JSON.stringify(r)).join("\n") + "\n");
-  return { ledgerDir, dir };
-}
-
-/** A fetchImpl that returns a Response-like object wrapping a Cost API payload. */
-function fakeFetch(payload, { ok = true, status = 200 } = {}) {
-  let lastUrl = null;
-  const f = async (url) => {
-    lastUrl = url;
-    return {
-      ok,
-      status,
-      json: async () => payload,
-    };
-  };
-  f.lastUrl = () => lastUrl;
-  return f;
-}
-
-// Documented nested Cost API shape: data[].results[] with object amounts.
-function nestedPayload(items) {
-  return {
-    data: [
-      {
-        starting_at: `${DAY}T00:00:00Z`,
-        results: items.map((it) => ({
-          amount: { amount: String(it.usd), currency: "USD" },
-          model: it.model,
-          api_key_id: it.agent || null,
-        })),
-      },
-    ],
-  };
-}
-
-// ---------------------------------------------------------------------------
-// sumLocalLedger
-// ---------------------------------------------------------------------------
-
-test("sumLocalLedger: sums estimated_usd by model", () => {
-  const { ledgerDir } = tmpLedger([
-    { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 1.5 },
-    { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 0.5 },
-    { agent: "alex", model: "claude-haiku-4-5", estimated_usd: 0.25 },
-  ]);
-  const r = sumLocalLedger({ ledgerDir, day: DAY });
-  assert.equal(r.totalUSD, 2.25);
-  assert.equal(r.rows, 3);
-  assert.equal(r.byModel["claude-sonnet-4-6"], 2);
-  assert.equal(r.byModel["claude-haiku-4-5"], 0.25);
-});
-
-test("sumLocalLedger: falls back to total_cost_usd when estimated_usd absent", () => {
-  const { ledgerDir } = tmpLedger([{ agent: "a", model: "m", total_cost_usd: 3.0 }]);
-  const r = sumLocalLedger({ ledgerDir, day: DAY });
-  assert.equal(r.totalUSD, 3.0);
-});
-
-test("sumLocalLedger: missing file → zeroes, never throws", () => {
-  const r = sumLocalLedger({ ledgerDir: "/nonexistent/path", day: DAY });
-  assert.equal(r.totalUSD, 0);
-  assert.equal(r.rows, 0);
-});
-
-test("sumLocalLedger: skips corrupt lines", () => {
-  const dir = mkdtempSync(join(tmpdir(), "reconcile-"));
-  const ledgerDir = join(dir, "cost");
-  mkdirSync(ledgerDir, { recursive: true });
-  writeFileSync(
-    join(ledgerDir, `${DAY}.jsonl`),
-    `{"model":"m","estimated_usd":1.0}\nNOT JSON\n{"model":"m","estimated_usd":2.0}\n`
-  );
-  const r = sumLocalLedger({ ledgerDir, day: DAY });
-  assert.equal(r.totalUSD, 3.0);
-  assert.equal(r.rows, 2);
-});
-
-// ---------------------------------------------------------------------------
-// fetchProviderCost — injected fetch, payload parsing
-// ---------------------------------------------------------------------------
-
-test("fetchProviderCost: parses the nested Cost API shape", async () => {
-  const fetchImpl = fakeFetch(
-    nestedPayload([
-      { usd: 5.0, model: "claude-sonnet-4-6", agent: "key_alex" },
-      { usd: 1.0, model: "claude-haiku-4-5", agent: "key_alex" },
-    ])
-  );
-  const r = await fetchProviderCost({ fetchImpl, day: DAY });
-  assert.equal(r.ok, true);
-  assert.equal(r.totalUSD, 6.0);
-  assert.equal(r.byModel["claude-sonnet-4-6"], 5.0);
-  assert.equal(r.byAgent["key_alex"], 6.0);
-});
-
-test("fetchProviderCost: parses a flat shape with bare-number amounts", async () => {
-  const fetchImpl = fakeFetch({
-    data: [
-      { amount: 2.5, model: "claude-opus-4-8" },
-      { amount: "1.25", model: "claude-haiku-4-5" },
-    ],
-  });
-  const r = await fetchProviderCost({ fetchImpl, day: DAY });
-  assert.equal(r.totalUSD, 3.75);
-});
-
-test("fetchProviderCost: builds a one-day [starting_at, ending_at) window URL", async () => {
-  const fetchImpl = fakeFetch(nestedPayload([]));
-  await fetchProviderCost({ fetchImpl, day: DAY, url: "https://example/cost" });
-  const url = fetchImpl.lastUrl();
-  assert.match(url, /starting_at=2026-06-10T00%3A00%3A00Z/);
-  assert.match(url, /ending_at=2026-06-11T00%3A00%3A00Z/);
-  assert.match(url, /group_by%5B%5D=model/);
-});
-
-test("fetchProviderCost: no fetchImpl → ok:false, never throws", async () => {
-  const r = await fetchProviderCost({ day: DAY });
-  assert.equal(r.ok, false);
-  assert.equal(r.totalUSD, null);
-});
-
-test("fetchProviderCost: http error → ok:false with note", async () => {
-  const fetchImpl = fakeFetch({}, { ok: false, status: 403 });
-  const r = await fetchProviderCost({ fetchImpl, day: DAY });
-  assert.equal(r.ok, false);
-  assert.match(r.note, /403/);
-});
-
-test("fetchProviderCost: a throwing fetch is caught", async () => {
-  const r = await fetchProviderCost({ fetchImpl: async () => { throw new Error("net"); }, day: DAY });
-  assert.equal(r.ok, false);
-  assert.match(r.note, /threw/);
-});
-
-test("parseAmount: handles units/nanos protobuf-style money", () => {
-  assert.equal(_internals.parseAmount({ units: 1, nanos: 500_000_000 }), 1.5);
-});
-
-// ---------------------------------------------------------------------------
-// computeDrift
-// ---------------------------------------------------------------------------
-
-test("computeDrift: provider-relative signed percentage", () => {
-  // provider billed 110, we recorded 100 → +9.09% (under-counted, dangerous dir).
-  assert.equal(computeDrift(100, 110), 9.09);
-  // provider billed 90, we recorded 100 → -11.11% (over-counted).
-  assert.equal(computeDrift(100, 90), -11.11);
-  assert.equal(computeDrift(100, 100), 0);
-});
-
-test("computeDrift: absent reference → null", () => {
-  assert.equal(computeDrift(100, null), null);
-  assert.equal(computeDrift(100, undefined), null);
-});
-
-test("computeDrift: zero reference → 0 when local 0, 100 when local nonzero", () => {
-  assert.equal(computeDrift(0, 0), 0);
-  assert.equal(computeDrift(5, 0), 100);
-});
-
-// ---------------------------------------------------------------------------
-// reconcileDaily — the three-way reconcile
-// ---------------------------------------------------------------------------
-
-test("reconcileDaily: computes drift and does NOT flag within 10%", async () => {
-  const { ledgerDir } = tmpLedger([
-    { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 100 },
-  ]);
-  const fetchImpl = fakeFetch(nestedPayload([{ usd: 105, model: "claude-sonnet-4-6", agent: "key_alex" }]));
-
-  const r = await reconcileDaily({ ledgerDir, day: DAY, fetchImpl });
-  assert.equal(r.localUSD, 100);
-  assert.equal(r.providerUSD, 105);
-  assert.equal(r.driftPct, 4.76); // (105-100)/105
-  assert.equal(r.flagged, false);
-});
-
-test("reconcileDaily: flags drift > 10%", async () => {
-  const { ledgerDir } = tmpLedger([
-    { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 80 },
-  ]);
-  // provider billed 100, we recorded 80 → +20% (we under-counted).
-  const fetchImpl = fakeFetch(nestedPayload([{ usd: 100, model: "claude-sonnet-4-6", agent: "key_alex" }]));
-
-  const r = await reconcileDaily({ ledgerDir, day: DAY, fetchImpl });
-  assert.equal(r.driftPct, 20);
-  assert.equal(r.flagged, true);
-  assert.ok(r.notes.some((n) => /provider drift/.test(n)));
-});
-
-test("reconcileDaily: three-way per-model view (local vs provider)", async () => {
-  const { ledgerDir } = tmpLedger([
-    { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 50 },
-    { agent: "alex", model: "claude-haiku-4-5", estimated_usd: 5 },
-  ]);
-  const fetchImpl = fakeFetch(
-    nestedPayload([
-      { usd: 52, model: "claude-sonnet-4-6", agent: "key_alex" },
-      { usd: 6, model: "claude-haiku-4-5", agent: "key_alex" },
-    ])
-  );
-  const r = await reconcileDaily({ ledgerDir, day: DAY, fetchImpl });
-  assert.equal(r.byModel["claude-sonnet-4-6"].local, 50);
-  assert.equal(r.byModel["claude-sonnet-4-6"].provider, 52);
-  assert.equal(r.byModel["claude-haiku-4-5"].local, 5);
-  assert.equal(r.byModel["claude-haiku-4-5"].provider, 6);
-  assert.equal(r.byAgent["key_alex"], 58);
-});
-
-test("reconcileDaily: surfaces a model the provider billed but the local ledger missed", async () => {
-  const { ledgerDir } = tmpLedger([
-    { agent: "alex", model: "claude-sonnet-4-6", estimated_usd: 50 },
-  ]);
-  // provider also billed a Haiku flood the ledger never recorded.
-  const fetchImpl = fakeFetch(
-    nestedPayload([
-      { usd: 50, model: "claude-sonnet-4-6", agent: "key_alex" },
-      { usd: 30, model: "claude-haiku-4-5", agent: "key_alex" },
-    ])
-  );
-  const r = await reconcileDaily({ ledgerDir, day: DAY, fetchImpl });
-  assert.equal(r.byModel["claude-haiku-4-5"].local, 0);
-  assert.equal(r.byModel["claude-haiku-4-5"].provider, 30);
-  assert.equal(r.flagged, true); // local 50 vs provider 80 → 37.5%
-});
-
-test("reconcileDaily: optional rollup leg (third way) + its own drift", async () => {
-  const { ledgerDir } = tmpLedger([
-    { agent: "alex", model: "m", estimated_usd: 100 },
-  ]);
-  const fetchImpl = fakeFetch(nestedPayload([{ usd: 100, model: "m", agent: "k" }]));
-  const rollupImpl = async () => ({ totalUSD: 130 }); // rollup says 130 → +23% drift
-
-  const r = await reconcileDaily({ ledgerDir, day: DAY, fetchImpl, rollupImpl });
-  assert.equal(r.providerUSD, 100);
-  assert.equal(r.rollupUSD, 130);
-  assert.equal(r.driftPct, 0); // local==provider
-  assert.equal(r.rollupDriftPct, 23.08);
-  assert.equal(r.flagged, true); // rollup leg trips the flag
-});
-
-test("reconcileDaily: provider leg absent (no fetchImpl) → fail-open, providerUSD null", async () => {
-  const { ledgerDir } = tmpLedger([{ agent: "a", model: "m", estimated_usd: 10 }]);
-  const r = await reconcileDaily({ ledgerDir, day: DAY });
-  assert.equal(r.localUSD, 10);
-  assert.equal(r.providerUSD, null);
-  assert.equal(r.driftPct, null);
-  assert.equal(r.flagged, false);
-  assert.ok(r.notes.some((n) => /provider leg skipped/.test(n)));
-});
-
-test("reconcileDaily: a down provider API does not throw and is reported null", async () => {
-  const { ledgerDir } = tmpLedger([{ agent: "a", model: "m", estimated_usd: 10 }]);
-  const fetchImpl = fakeFetch({}, { ok: false, status: 500 });
-  const r = await reconcileDaily({ ledgerDir, day: DAY, fetchImpl });
-  assert.equal(r.providerUSD, null);
-  assert.equal(r.flagged, false);
-  assert.ok(r.notes.some((n) => /provider leg unavailable/.test(n)));
-});
-
-test("reconcileDaily: a throwing rollupImpl is caught", async () => {
-  const { ledgerDir } = tmpLedger([{ agent: "a", model: "m", estimated_usd: 10 }]);
-  const fetchImpl = fakeFetch(nestedPayload([{ usd: 10, model: "m" }]));
-  const r = await reconcileDaily({
-    ledgerDir, day: DAY, fetchImpl, rollupImpl: async () => { throw new Error("x"); },
-  });
-  assert.equal(r.rollupUSD, null);
-  assert.ok(r.notes.some((n) => /rollup leg threw/.test(n)));
-});
-
-test("reconcileDaily: custom threshold", async () => {
-  const { ledgerDir } = tmpLedger([{ agent: "a", model: "m", estimated_usd: 95 }]);
-  const fetchImpl = fakeFetch(nestedPayload([{ usd: 100, model: "m" }]));
-  // 5% drift, threshold 3% → flagged.
-  const r = await reconcileDaily({ ledgerDir, day: DAY, fetchImpl, thresholdPct: 3 });
-  assert.equal(r.flagged, true);
-  assert.equal(r.thresholdPct, 3);
-});
-
-test("DRIFT_THRESHOLD_PCT default is 10", () => {
-  assert.equal(DRIFT_THRESHOLD_PCT, 10);
-});