@cohortapp/agent-sdk 2.17.0 → 2.18.5

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

@@ -1,564 +0,0 @@
-/**
- * lib/model-router/integration.test.mjs — end-to-end router resolution +
- * failover, exercised over the REAL bundled catalog + a test policy.
- *
- * This is the seam test the v2 surface is contracted against (SPEC §6 / §12.2):
- * it drives the actual `resolveChain` brain (lib/model-router/resolve.mjs) on top
- * of the real bundled catalog YAMLs (lib/model-router/catalog/*.yaml), through the
- * real cost ledger (estimateCost) and the real failover engine (stepChain) against
- * the real disposition table (taxonomy.mjs DISPOSITION). Nothing here is a wire
- * mock of the router internals — only the OUTSIDE world is injected:
- *
- *   - a tmp agentRoot (real fs) so the catalog + ledger have a hermetic home,
- *   - an injected env so credential gates are deterministic (no real keys),
- *   - an injected clock + rng so decision_ids / cooldowns are reproducible,
- *   - an injected isOpen / in-memory breaker so no breaker files are touched,
- *   - an injected `attempt` fn that returns SCRIPTED FailoverReasons (NO live API).
- *
- * The five lanes mirror the component brief 1–5:
- *   1. cheap-first rule → cheapest catalog row meeting the bar; explain + decision_id.
- *   2. unset auth_env candidate skipped + recorded in tried[] (missing_credential);
- *      resolution falls through to the next chain member.
- *   3. failover: rate_limit steps the chain; a backend:model breaker opens; a
- *      second resolution within cooldown skips the open key; context_overflow does
- *      NOT fail over; network does NOT open a breaker.
- *   4. estCostUSD is catalog-priced + cache-aware; a volatile-priced model
- *      projects at the steady-state (higher) figure, never the promo sticker.
- *   5. MAESTRO_ROUTER_FORCE_ANTHROPIC=1 short-circuits to stock Anthropic.
- *
- * House style: node:test, node:assert/strict, hermetic, no network. Mirrors the
- * DI discipline of failover.test.mjs / health.test.mjs / resource-governor.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { resolveChain } from "./resolve.mjs";
-import { loadCatalog, lookupModel } from "./catalog.mjs";
-import { estimateCost } from "./ledger.mjs";
-import { stepChain } from "./failover.mjs";
-import { keyFor } from "./health.mjs";
-import { DISPOSITION } from "./taxonomy.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const BUNDLED_DIR = join(__dirname, "catalog");
-
-// ---------------------------------------------------------------------------
-// Hermetic harness: tmp agentRoot + injected clock/rng/env + the REAL bundled
-// catalog. resolveChain takes the catalog by injection so no FS read happens on
-// the decision path; loadCatalog reads the real YAMLs once.
-// ---------------------------------------------------------------------------
-
-function tmpRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-router-int-"));
-  mkdirSync(join(root, "state", "model-router"), { recursive: true });
-  mkdirSync(join(root, "state", "cost-tracking"), { recursive: true });
-  return root;
-}
-
-function fakeClock(start = 1_700_000_000_000) {
-  let t = start;
-  const now = () => t;
-  now.advance = (ms) => { t += ms; };
-  now.set = (v) => { t = v; };
-  return now;
-}
-
-/** Deterministic rng so decision_id randomness is reproducible. */
-function seededRng(seed = 0.42) {
-  let s = seed;
-  return () => {
-    s = (s * 9301 + 49297) % 233280;
-    return s / 233280;
-  };
-}
-
-/** The real bundled catalog, loaded once per test (hermetic — reads YAMLs only). */
-function loadBundled(root, overrides = {}) {
-  const res = loadCatalog(root, { bundledDir: BUNDLED_DIR, agentRoot: root, ...overrides });
-  // Sanity: the catalog must have parsed cleanly enough to contain the rows the
-  // policy below references — a fatal catalog error would make every lane lie.
-  assert.ok(res.byRef.size > 0, "bundled catalog parsed at least one row");
-  assert.ok(lookupModel(res, "anthropic/claude-haiku-4-5"), "haiku row present");
-  assert.ok(lookupModel(res, "deepseek/deepseek-v4-flash"), "deepseek flash row present");
-  return res;
-}
-
-/**
- * In-memory breaker matching the health.mjs semantics resolveChain consults
- * (isOpen → {open}) and failover.mjs drives (open/close), with the stepped
- * rate_limit ladder from the real DISPOSITION table. Backend:model scoped.
- */
-function memBreaker(now) {
-  const map = new Map();
-  const clock = typeof now === "function" ? now : () => now;
-  return {
-    map,
-    isOpen(key, at) {
-      const t = Number.isFinite(at) ? at : clock();
-      const s = map.get(key);
-      if (!s) return { open: false, until: 0, reason: null, strikes: 0 };
-      return { open: s.cooldownUntil > t, until: s.cooldownUntil, reason: s.reason, strikes: s.strikes };
-    },
-    open(key, reason, ms, at) {
-      const t = Number.isFinite(at) ? at : clock();
-      const prev = map.get(key) || { strikes: 0, cooldownUntil: 0 };
-      const strikes = prev.strikes + 1;
-      let cd = ms;
-      if (cd == null) {
-        const d = DISPOSITION[reason];
-        if (d && Array.isArray(d.stepped) && d.stepped.length) {
-          cd = d.stepped[Math.min(strikes - 1, d.stepped.length - 1)];
-        } else if (d && d.cooldownMs === Infinity) {
-          cd = Infinity;
-        } else {
-          cd = (d && d.cooldownMs) || 0;
-        }
-      }
-      const until = cd === Infinity ? Infinity : Math.max(prev.cooldownUntil, t + cd);
-      const next = { key, reason, strikes, cooldownUntil: until, openedAt: t };
-      map.set(key, next);
-      return next;
-    },
-    close(key) { map.delete(key); },
-  };
-}
-
-/**
- * A v2 test policy. The chains are ordered cheap→expensive on purpose so the
- * first surviving candidate is the cheapest one that meets the bar (resolveChain
- * picks the first gate-survivor in chain order — §6.1).
- */
-function testPolicy() {
-  return {
-    schema_version: 2,
-    source_path: "<test-policy>",
-    aliases: {
-      frontier: "anthropic/claude-opus-4-8",
-      default: "anthropic/claude-sonnet-4-6",
-      fast: "anthropic/claude-haiku-4-5",
-      cheap: "deepseek/deepseek-v4-flash",
-      "cheap-pro": "deepseek/deepseek-v4-pro",
-    },
-    defaults: {
-      needs_tool_use_for_sessions: true,
-      data_class: "sensitive",
-      cache_ttl: "1h",
-    },
-    backends: {
-      anthropic: { allowed_data_classes: ["public", "internal", "sensitive"] },
-      deepseek: { allowed_data_classes: ["public"] },
-    },
-    routing_policy: [
-      // direct, tool-less lookup: cheapest-first chain. deepseek (grade B) is
-      // legal on the DIRECT lane; the grade-A gate only bites session+tool work.
-      {
-        match: { task_class: "lookup.*" },
-        harness: "direct",
-        needs_tool_use: false,
-        chain: ["cheap", "fast"],
-      },
-      // a public-data direct task that prices a volatile model at steady-state.
-      {
-        match: { task_class: "learning.curate" },
-        harness: "direct",
-        needs_tool_use: false,
-        chain: ["cheap-pro"],
-      },
-      {
-        match: { task_class: "classify.inbox" },
-        harness: "direct",
-        needs_tool_use: false,
-        chain: ["cheap", "fast"],
-      },
-      { default: true, chain: ["default", "fast"] },
-    ],
-    fallback_to_anthropic: true,
-    strip_attribution_header: true,
-    disable_experimental_betas: true,
-  };
-}
-
-function cleanup(root) {
-  try { rmSync(root, { recursive: true, force: true }); } catch { /* */ }
-}
-
-// ===========================================================================
-// 1. Cheap-first: resolves to the cheapest catalog row that meets the bar.
-// ===========================================================================
-
-test("1. cheap-first rule resolves to the cheapest qualifying row; explain + decision_id set", () => {
-  const root = tmpRoot();
-  try {
-    const catalog = loadBundled(root);
-    const now = fakeClock();
-    const policy = testPolicy();
-    // deepseek key PRESENT so the cheap candidate is reachable; the Anthropic
-    // Console key is present too so the direct-api Anthropic failover tail
-    // (haiku) is reachable (gate 6: a DIRECT Anthropic call needs ANTHROPIC_API_KEY).
-    const env = { DEEPSEEK_API_KEY: "sk-test-deepseek", ANTHROPIC_API_KEY: "sk-test-anthropic" };
-
-    const d = resolveChain(
-      {
-        task_class: "lookup.gmail",
-        source: "inbox",
-        data_class: "public", // deepseek is public-only; derived by the caller
-        token_estimate: 5000,
-      },
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: () => ({ open: false }) }
-    );
-
-    // Cheapest qualifying row in the chain ["cheap"=deepseek-flash, "fast"=haiku].
-    // deepseek-v4-flash input $0.14/MTok ≪ haiku input $1.0/MTok → cheap wins.
-    assert.equal(d.chosen.provider, "deepseek", "cheapest qualifying provider chosen");
-    assert.equal(d.chosen.model, "deepseek-v4-flash");
-    assert.equal(d.chosen.harness, "direct");
-    assert.equal(d.chosen.transport, "openai-completions", "direct third-party → openai wire transport");
-    assert.equal(d.chosen.wire, "openai");
-
-    // The chosen row really is the cheaper of the two candidates at this size.
-    const cheapCost = estimateCost(catalog, { ref: "deepseek/deepseek-v4-flash", inputTokens: 5000, outputTokens: 2000, budget: true }).usd;
-    const fastCost = estimateCost(catalog, { ref: "anthropic/claude-haiku-4-5", inputTokens: 5000, outputTokens: 2000, budget: true }).usd;
-    assert.ok(cheapCost < fastCost, `cheap (${cheapCost}) < fast (${fastCost})`);
-
-    // Mandatory contract fields.
-    assert.equal(typeof d.explain, "string");
-    assert.ok(d.explain.length > 0, "explain is a non-empty one-liner");
-    assert.match(d.explain, /deepseek\/deepseek-v4-flash/, "explain names the chosen row");
-    assert.ok(d.decision_id && typeof d.decision_id === "string", "decision_id set");
-    assert.ok(d.decision_id.length >= 10, "decision_id is ulid-ish");
-    assert.equal(typeof d.estCostUSD, "number");
-    assert.ok(d.estCostUSD >= 0);
-
-    // The full chain is visible (cheap then the fast failover tail).
-    assert.deepEqual(d.chain.map((c) => c.ref), ["deepseek/deepseek-v4-flash", "anthropic/claude-haiku-4-5"]);
-    // audit join fields.
-    assert.ok(d.audit, "audit block present");
-    assert.equal(d.audit.config_source, "<test-policy>");
-  } finally {
-    cleanup(root);
-  }
-});
-
-// ===========================================================================
-// 2. Unset auth_env candidate skipped → tried[] missing_credential → next.
-// ===========================================================================
-
-test("2. candidate with unset auth_env is skipped (missing_credential) and falls through to the next", () => {
-  const root = tmpRoot();
-  try {
-    const catalog = loadBundled(root);
-    const now = fakeClock();
-    const policy = testPolicy();
-    // NO DEEPSEEK_API_KEY → the cheap (deepseek) candidate is unreachable. The
-    // Anthropic Console key IS present so the NEXT chain member (direct-api
-    // haiku) is reachable and becomes the fall-through target — demonstrating a
-    // clean fall-through to the next member rather than the safety net.
-    const env = { ANTHROPIC_API_KEY: "sk-test-anthropic" };
-
-    const d = resolveChain(
-      {
-        task_class: "lookup.calendar",
-        source: "inbox",
-        data_class: "public",
-        token_estimate: 4000,
-      },
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: () => ({ open: false }) }
-    );
-
-    // Falls through to the next chain member (haiku).
-    assert.equal(d.chosen.provider, "anthropic", "falls through to anthropic");
-    assert.equal(d.chosen.model, "claude-haiku-4-5");
-
-    // The skip is recorded in tried[] with the exact reason.
-    const skip = d.tried.find((t) => t.ref === "deepseek/deepseek-v4-flash");
-    assert.ok(skip, "deepseek candidate recorded in tried[]");
-    assert.equal(skip.ok, false);
-    assert.equal(skip.reason, "missing_credential", "key-absence-as-enforcement reason");
-
-    // The explain string surfaces the skip (key-absence visible, not silent).
-    assert.match(d.explain, /missing_credential/);
-    assert.ok(d.decision_id);
-  } finally {
-    cleanup(root);
-  }
-});
-
-// ===========================================================================
-// 3. Failover: rate_limit steps the chain; backend:model breaker opens; a
-//    second resolution within cooldown skips the open key. context_overflow
-//    does NOT fail over. network does NOT open a breaker.
-// ===========================================================================
-
-test("3a. rate_limit fails over to the next chain member and opens a backend:model breaker", async () => {
-  const root = tmpRoot();
-  try {
-    const catalog = loadBundled(root);
-    const now = fakeClock();
-    const policy = testPolicy();
-    // Both keys present: deepseek so the cheap candidate resolves first, and the
-    // Anthropic Console key so the direct-api haiku failover tail is reachable.
-    const env = { DEEPSEEK_API_KEY: "sk-test-deepseek", ANTHROPIC_API_KEY: "sk-test-anthropic" };
-    const breaker = memBreaker(now);
-
-    // First resolution: cheap (deepseek) is reachable, no breaker open.
-    const d = resolveChain(
-      { task_class: "lookup.gmail", source: "inbox", data_class: "public", token_estimate: 3000 },
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: (k, at) => breaker.isOpen(k, at) }
-    );
-    assert.equal(d.chosen.ref || `${d.chosen.provider}/${d.chosen.model}`, "deepseek/deepseek-v4-flash");
-
-    // Drive the failover engine over the resolved chain with a SCRIPTED attempt
-    // fn (no live API): the cheap candidate returns rate_limit, then haiku ok.
-    const chain = d.chain.map((c) => ({
-      ref: c.ref,
-      breakerKey: keyFor(c.ref.split("/")[0], c.ref.split("/")[1]),
-      backendKey: keyFor(c.ref.split("/")[0]),
-    }));
-    const script = {
-      "deepseek/deepseek-v4-flash": { ok: false, reason: "rate_limit" },
-      "anthropic/claude-haiku-4-5": { ok: true, value: "answered" },
-    };
-    const attempt = (cand) => script[cand.ref] || { ok: false, reason: "unknown" };
-
-    const out = await stepChain(chain, { attempt, now, breaker });
-
-    assert.equal(out.ok, true, "chain stepped to a working candidate");
-    assert.equal(out.chosen.ref, "anthropic/claude-haiku-4-5", "failed over to haiku");
-    assert.equal(out.value, "answered");
-    // tried[] shows the rate_limit on deepseek then ok on haiku.
-    assert.equal(out.tried[0].ref, "deepseek/deepseek-v4-flash");
-    assert.equal(out.tried[0].reason, "rate_limit");
-
-    // The breaker that opened is the backend:model-scoped key (rate_limit scope),
-    // NOT the bare backend key — Haiku flows while the deepseek-flash bucket is dry.
-    const modelKey = keyFor("deepseek", "deepseek-v4-flash");
-    const backendKey = keyFor("deepseek");
-    assert.ok(breaker.map.has(modelKey), "backend:model breaker opened for the rate-limited model");
-    assert.equal(breaker.map.has(backendKey), false, "the coarse backend breaker is NOT opened (model-scoped cooldown)");
-    assert.equal(DISPOSITION.rate_limit.cooldownScope, "backend:model", "disposition contract: model-scoped");
-    // A SUCCESSFUL failover carries no wake time (work got done — nothing to
-    // re-queue), so the summary's soonestCooldownExpiry is null; the opened
-    // breaker still records a concrete future cooldown (never hot-loops).
-    assert.equal(out.soonestCooldownExpiry, null, "successful failover needs no re-queue wake time");
-    assert.ok(breaker.map.get(modelKey).cooldownUntil > now(), "the opened breaker holds a concrete future cooldown");
-    assert.equal(breaker.map.get(modelKey).cooldownUntil, now() + DISPOSITION.rate_limit.stepped[0], "first rate_limit strike = 30s step");
-
-    // ── Second resolution WITHIN the cooldown: the open backend:model key makes
-    //    the cheap candidate unreachable, so resolution skips it for haiku.
-    const d2 = resolveChain(
-      { task_class: "lookup.gmail", source: "inbox", data_class: "public", token_estimate: 3000 },
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: (k, at) => breaker.isOpen(k, at) }
-    );
-    assert.equal(d2.chosen.provider, "anthropic", "open breaker → second resolution skips deepseek");
-    assert.equal(d2.chosen.model, "claude-haiku-4-5");
-    const skip2 = d2.tried.find((t) => t.ref === "deepseek/deepseek-v4-flash");
-    assert.ok(skip2, "skipped deepseek recorded in tried[]");
-    assert.equal(skip2.reason, "breaker_open", "skip reason is the open breaker");
-
-    // ── After the cooldown expires, the cheap candidate is reachable again.
-    now.advance(DISPOSITION.rate_limit.stepped[0] + 1);
-    const d3 = resolveChain(
-      { task_class: "lookup.gmail", source: "inbox", data_class: "public", token_estimate: 3000 },
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: (k, at) => breaker.isOpen(k, at) }
-    );
-    assert.equal(d3.chosen.provider, "deepseek", "cheap candidate reachable again after cooldown");
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("3b. context_overflow NEVER fails over (terminal, no cooldown)", async () => {
-  const now = fakeClock();
-  const breaker = memBreaker(now);
-  const chain = [
-    { ref: "deepseek/deepseek-v4-flash", breakerKey: keyFor("deepseek", "deepseek-v4-flash"), backendKey: keyFor("deepseek") },
-    { ref: "anthropic/claude-haiku-4-5", breakerKey: keyFor("anthropic", "claude-haiku-4-5"), backendKey: keyFor("anthropic") },
-  ];
-  let calls = 0;
-  const attempt = (cand) => {
-    calls++;
-    if (cand.ref === "deepseek/deepseek-v4-flash") return { ok: false, reason: "context_overflow" };
-    return { ok: true, value: "should-never-reach" };
-  };
-
-  const out = await stepChain(chain, { attempt, now, breaker });
-
-  assert.equal(out.ok, false, "context_overflow terminates the walk");
-  assert.equal(out.reason, "context_overflow");
-  assert.equal(calls, 1, "did NOT advance to the next candidate (no second attempt)");
-  assert.equal(out.soonestCooldownExpiry, null, "no cooldown for context_overflow");
-  assert.equal(breaker.map.size, 0, "context_overflow opens no breaker");
-  // Disposition contract, cell-by-cell.
-  assert.equal(DISPOSITION.context_overflow.failoverNext, false);
-  assert.equal(DISPOSITION.context_overflow.opensBreaker, false);
-});
-
-test("3c. network does NOT fail over and does NOT open a breaker (DEFER-style)", async () => {
-  const now = fakeClock();
-  const breaker = memBreaker(now);
-  const chain = [
-    { ref: "deepseek/deepseek-v4-flash", breakerKey: keyFor("deepseek", "deepseek-v4-flash"), backendKey: keyFor("deepseek") },
-    { ref: "anthropic/claude-haiku-4-5", breakerKey: keyFor("anthropic", "claude-haiku-4-5"), backendKey: keyFor("anthropic") },
-  ];
-  let calls = 0;
-  const attempt = (cand) => {
-    calls++;
-    if (cand.ref === "deepseek/deepseek-v4-flash") return { ok: false, reason: "network" };
-    return { ok: true, value: "should-never-reach" };
-  };
-
-  const out = await stepChain(chain, { attempt, now, breaker });
-
-  assert.equal(out.ok, false, "network terminates the walk (offline → re-queue)");
-  assert.equal(out.reason, "network");
-  assert.equal(calls, 1, "did NOT advance to the next candidate");
-  assert.equal(out.soonestCooldownExpiry, null, "no cooldown burned");
-  assert.equal(breaker.map.size, 0, "network opens NO breaker — burns no retry budget");
-  // Disposition contract.
-  assert.equal(DISPOSITION.network.failoverNext, false);
-  assert.equal(DISPOSITION.network.opensBreaker, false);
-});
-
-// ===========================================================================
-// 4. estCostUSD is catalog-priced + cache-aware; a volatile-priced model
-//    projects at the steady-state figure.
-// ===========================================================================
-
-test("4. estCostUSD is catalog-priced and cache-aware; volatile model budgets at steady-state", () => {
-  const root = tmpRoot();
-  try {
-    const catalog = loadBundled(root);
-    const now = fakeClock();
-    const policy = testPolicy();
-    const env = { DEEPSEEK_API_KEY: "sk-test-deepseek", ANTHROPIC_API_KEY: "sk-test-anthropic" };
-
-    // ── Cache-awareness: a request with a cache-read estimate must cost STRICTLY
-    //    LESS than the same request with no cache hits (cache_read ≪ input rate).
-    const reqBase = {
-      task_class: "lookup.gmail",
-      source: "inbox",
-      data_class: "public",
-      token_estimate: 100000,
-      token_estimate_out: 20000,
-    };
-    const cold = resolveChain(
-      { ...reqBase },
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: () => ({ open: false }) }
-    );
-    const warm = resolveChain(
-      { ...reqBase, cache_read_estimate: 80000 },
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: () => ({ open: false }) }
-    );
-    assert.equal(cold.chosen.model, "deepseek-v4-flash");
-    assert.equal(warm.chosen.model, "deepseek-v4-flash");
-    assert.ok(warm.estCostUSD < cold.estCostUSD, `cache-aware: warm (${warm.estCostUSD}) < cold (${cold.estCostUSD})`);
-
-    // The decision's estimate matches the ledger's catalog-priced figure exactly.
-    const expectCold = estimateCost(catalog, {
-      ref: "deepseek/deepseek-v4-flash",
-      inputTokens: 100000,
-      outputTokens: 20000,
-      cacheReadTokens: 0,
-      budget: true,
-    }).usd;
-    assert.equal(cold.estCostUSD, expectCold, "estCostUSD is exactly the catalog-priced figure");
-
-    // ── Volatile steady-state: deepseek-v4-pro is volatile:true with a
-    //    steady_state tier ($1.74/$3.48). The budget projection must use the
-    //    HIGHER steady-state rate, never the promo sticker ($0.435/$0.87).
-    const proReq = {
-      task_class: "learning.curate",
-      source: "backlog",
-      data_class: "public",
-      token_estimate: 50000,
-      token_estimate_out: 10000,
-    };
-    const proDecision = resolveChain(
-      proReq,
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: () => ({ open: false }) }
-    );
-    assert.equal(proDecision.chosen.model, "deepseek-v4-pro");
-
-    const steady = estimateCost(catalog, {
-      ref: "deepseek/deepseek-v4-pro",
-      inputTokens: 50000,
-      outputTokens: 10000,
-      budget: true, // steady-state projection
-    });
-    const sticker = estimateCost(catalog, {
-      ref: "deepseek/deepseek-v4-pro",
-      inputTokens: 50000,
-      outputTokens: 10000,
-      budget: false, // promo sticker
-    });
-    assert.equal(steady.basis, "steady_state", "volatile row budgeted at steady-state basis");
-    assert.equal(steady.volatile, true);
-    assert.ok(steady.usd > sticker.usd, `steady-state (${steady.usd}) > sticker (${sticker.usd})`);
-    assert.equal(proDecision.estCostUSD, steady.usd, "RouteDecision projects the volatile model at steady-state");
-
-    // Concrete arithmetic check (no cache): the steady-state rates are 1.74 in /
-    // 3.48 out → 50k input * 1.74/MTok + 10k output * 3.48/MTok.
-    const expected = Number((50000 / 1e6 * 1.74 + 10000 / 1e6 * 3.48).toFixed(6));
-    assert.equal(steady.usd, expected, "steady-state arithmetic matches the catalog rates");
-  } finally {
-    cleanup(root);
-  }
-});
-
-// ===========================================================================
-// 5. MAESTRO_ROUTER_FORCE_ANTHROPIC=1 short-circuits to stock Anthropic.
-// ===========================================================================
-
-test("5. MAESTRO_ROUTER_FORCE_ANTHROPIC=1 short-circuits to stock Anthropic regardless of policy", () => {
-  const root = tmpRoot();
-  try {
-    const catalog = loadBundled(root);
-    const now = fakeClock();
-    const policy = testPolicy();
-
-    // A request whose policy would otherwise route to deepseek (cheap-first,
-    // public, key present) — the kill switch must override it.
-    const env = { DEEPSEEK_API_KEY: "sk-test-deepseek", MAESTRO_ROUTER_FORCE_ANTHROPIC: "1" };
-
-    const d = resolveChain(
-      {
-        task_class: "lookup.gmail",
-        source: "inbox",
-        data_class: "public",
-        token_estimate: 3000,
-      },
-      { agentRoot: root, config: policy, catalog, env, now, rng: seededRng(), isOpen: () => ({ open: false }) }
-    );
-
-    assert.equal(d.chosen.provider, "anthropic", "kill switch forces Anthropic");
-    assert.equal(d.chosen.wire, "anthropic");
-    // Anthropic session: stock CLI/Console key, no third-party retarget env.
-    assert.deepEqual(d.envForSpawn, {}, "no ANTHROPIC_BASE_URL retarget under the kill switch");
-    assert.match(d.explain, /kill switch|MAESTRO_ROUTER_FORCE_ANTHROPIC/i, "explain names the kill switch");
-    // No deepseek candidate was even considered.
-    assert.equal(d.tried.find((t) => t.ref && t.ref.startsWith("deepseek/")), undefined, "deepseek never tried under kill switch");
-    assert.ok(d.decision_id);
-
-    // Accepts "true" as well as "1" (boolean env convention).
-    const d2 = resolveChain(
-      { task_class: "lookup.gmail", source: "inbox", data_class: "public", token_estimate: 3000 },
-      {
-        agentRoot: root,
-        config: policy,
-        catalog,
-        env: { DEEPSEEK_API_KEY: "sk-test-deepseek", MAESTRO_ROUTER_FORCE_ANTHROPIC: "true" },
-        now,
-        rng: seededRng(),
-        isOpen: () => ({ open: false }),
-      }
-    );
-    assert.equal(d2.chosen.provider, "anthropic", 'kill switch honors "true" too');
-  } finally {
-    cleanup(root);
-  }
-});