@tokenbuddy/tokenbuddy 1.0.36 → 1.0.38

package/tests/seller-pool.test.ts

@@ -1,365 +0,0 @@
-import { CreditTracker } from "../src/credit-tracker.js";
-import { ModelIndex } from "../src/model-index.js";
-import { PrewarmCache } from "../src/prewarm-cache.js";
-import { SellerPool, type FailureKind } from "../src/seller-pool.js";
-import type { RegistrySeller } from "../src/seller-catalog.js";
-
-function makeSeller(overrides: Partial<RegistrySeller> & { id: string; models?: string[] }): RegistrySeller {
-  return {
-    id: overrides.id,
-    name: overrides.name ?? overrides.id,
-    url: overrides.url ?? `https://${overrides.id}.example.com`,
-    supportedProtocols: overrides.supportedProtocols ?? ["chat_completions"],
-    paymentMethods: overrides.paymentMethods ?? ["clawtip"],
-    models: overrides.models
-  };
-}
-
-function makeClock(start = 1_000_000): { now: number; advance: (ms: number) => void } {
-  const clock = { now: start, advance: (ms: number) => { clock.now += ms; } };
-  return clock;
-}
-
-function build(seed: { id: string; healthScore?: number }[] = []): { index: ModelIndex; cache: PrewarmCache; credit: CreditTracker; sellers: RegistrySeller[] } {
-  const sellers: RegistrySeller[] = seed.map((s) =>
-    makeSeller({ id: s.id, models: ["gpt-4o"] })
-  );
-  const index = new ModelIndex();
-  index.rebuild(sellers, { registryVersion: 1, defaultSellerId: seed[0]?.id });
-  const cache = new PrewarmCache();
-  cache.commitWarm({
-    modelId: "gpt-4o",
-    protocol: "chat_completions",
-    paymentMethod: "clawtip",
-    candidates: seed.map((s) => ({
-      sellerId: s.id,
-      url: `https://${s.id}.example.com`,
-      healthScore: s.healthScore ?? 80
-    }))
-  });
-  const credit = new CreditTracker();
-  return { index, cache, credit, sellers };
-}
-
-describe("SellerPool", () => {
-  test("sync rebuilds entries from the prewarm cache", () => {
-    const ctx = build([{ id: "s1" }, { id: "s2" }]);
-    const pool = new SellerPool({
-      modelIndex: ctx.index,
-      cache: ctx.cache,
-      creditTracker: ctx.credit
-    });
-    const size = pool.sync();
-    expect(size).toBe(2);
-    expect(pool.snapshot().map((e) => e.sellerId).sort()).toEqual(["s1", "s2"]);
-  });
-
-  test("sync drops entries whose seller disappeared from the registry index", () => {
-    const ctx = build([{ id: "s1" }, { id: "s2" }]);
-    const pool = new SellerPool({
-      modelIndex: ctx.index,
-      cache: ctx.cache,
-      creditTracker: ctx.credit
-    });
-    pool.sync();
-    expect(pool.size()).toBe(2);
-
-    // Mutate the index so only s1 remains.
-    ctx.index.rebuild([makeSeller({ id: "s1", models: ["gpt-4o"] })], { registryVersion: 2 });
-    const size = pool.sync();
-    expect(size).toBe(1);
-    expect(pool.snapshot().map((e) => e.sellerId)).toEqual(["s1"]);
-  });
-
-  test("pick returns candidates sorted by health score and skips open circuit entries", () => {
-    const ctx = build([{ id: "s1", healthScore: 90 }, { id: "s2", healthScore: 50 }, { id: "s3", healthScore: 70 }]);
-    const pool = new SellerPool({ modelIndex: ctx.index, cache: ctx.cache, creditTracker: ctx.credit });
-    pool.sync();
-
-    const result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(result.candidates.map((c) => c.entry.sellerId)).toEqual(["s1", "s3", "s2"]);
-
-    // Force s1 into the open circuit and verify it is skipped.
-    pool.markOpen("s1", "registry_gone");
-    const filtered = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(filtered.candidates.map((c) => c.entry.sellerId)).toEqual(["s3", "s2"]);
-  });
-
-  test("half_open recycle happens after openStateMs has elapsed", () => {
-    const clock = makeClock();
-    const ctx = build([{ id: "s1" }]);
-    const pool = new SellerPool({
-      modelIndex: ctx.index,
-      cache: ctx.cache,
-      creditTracker: ctx.credit,
-      failureThreshold: 1, // open after the very first failure to keep the test focused
-      openStateMs: 1000,
-      now: () => clock.now
-    });
-    pool.sync();
-    pool.recordFailure("s1", "soft_5xx");
-    expect(pool.snapshot()[0].circuit).toBe("open");
-
-    // Within the open window: still skipped.
-    clock.advance(500);
-    let result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(result.candidates).toEqual([]);
-
-    // After the open window: recycled to half_open and re-included.
-    clock.advance(600);
-    result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(result.candidates.map((c) => c.entry.sellerId)).toEqual(["s1"]);
-    expect(pool.snapshot()[0].circuit).toBe("half_open");
-  });
-
-  test("recycleOpenCircuits refreshes snapshot-based route planning state", () => {
-    const clock = makeClock();
-    const ctx = build([{ id: "s1" }, { id: "s2" }]);
-    const pool = new SellerPool({
-      modelIndex: ctx.index,
-      cache: ctx.cache,
-      creditTracker: ctx.credit,
-      failureThreshold: 1,
-      openStateMs: 1000,
-      now: () => clock.now
-    });
-    pool.sync();
-    pool.recordFailure("s1", "soft_5xx");
-
-    clock.advance(500);
-    expect(pool.recycleOpenCircuits()).toBe(0);
-    expect(pool.snapshot().find((entry) => entry.sellerId === "s1")?.circuit).toBe("open");
-
-    clock.advance(600);
-    expect(pool.recycleOpenCircuits()).toBe(1);
-    expect(pool.snapshot().find((entry) => entry.sellerId === "s1")?.circuit).toBe("half_open");
-  });
-
-  test("recordFailure escalates to open after the configured threshold", () => {
-    const clock = makeClock();
-    const ctx = build([{ id: "s1" }]);
-    const pool = new SellerPool({
-      modelIndex: ctx.index,
-      cache: ctx.cache,
-      creditTracker: ctx.credit,
-      failureThreshold: 3,
-      now: () => clock.now
-    });
-    pool.sync();
-
-    pool.recordFailure("s1", "soft_5xx");
-    expect(pool.snapshot()[0].circuit).toBe("closed");
-    pool.recordFailure("s1", "soft_5xx");
-    expect(pool.snapshot()[0].circuit).toBe("closed");
-    pool.recordFailure("s1", "soft_5xx");
-    expect(pool.snapshot()[0].circuit).toBe("open");
-  });
-
-  test("busy_capacity temporarily blocks selection without opening the circuit", () => {
-    const clock = makeClock();
-    const ctx = build([{ id: "s1", healthScore: 90 }, { id: "s2", healthScore: 50 }]);
-    const pool = new SellerPool({
-      modelIndex: ctx.index,
-      cache: ctx.cache,
-      creditTracker: ctx.credit,
-      failureThreshold: 1,
-      capacityBlockMs: 1000,
-      now: () => clock.now
-    });
-    pool.sync();
-
-    const blocked = pool.recordFailure("s1", "busy_capacity");
-    expect(blocked?.circuit).toBe("closed");
-    expect(blocked?.consecutiveFailures).toBe(0);
-    expect(blocked?.recentFailures).toEqual([]);
-    expect(blocked?.capacityBlockedUntil).toBe(clock.now + 1000);
-
-    let result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(result.candidates.map((c) => c.entry.sellerId)).toEqual(["s2"]);
-
-    clock.advance(1001);
-    result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(result.candidates.map((c) => c.entry.sellerId)).toEqual(["s1", "s2"]);
-
-    pool.recordFailure("s1", "busy_capacity");
-    pool.recordSuccess("s1", 250_000);
-    expect(pool.snapshot().find((entry) => entry.sellerId === "s1")?.capacityBlockedUntil).toBeUndefined();
-  });
-
-  test("sync preserves registry fallback runtime state for sellers still in the registry", () => {
-    const clock = makeClock();
-    const index = new ModelIndex();
-    const sellers = [makeSeller({ id: "s1", models: ["gpt-4o"] })];
-    index.rebuild(sellers, { registryVersion: 1 });
-    const cache = new PrewarmCache();
-    const credit = new CreditTracker();
-    const pool = new SellerPool({
-      modelIndex: index,
-      cache,
-      creditTracker: credit,
-      capacityBlockMs: 1000,
-      now: () => clock.now
-    });
-
-    pool.ensureRegistrySellers(sellers);
-    pool.recordFailure("s1", "busy_capacity");
-    pool.sync();
-
-    expect(pool.snapshot()[0].capacityBlockedUntil).toBe(clock.now + 1000);
-    index.rebuild([], { registryVersion: 2 });
-    pool.sync();
-    expect(pool.snapshot()).toEqual([]);
-  });
-
-  test("recordSuccess closes the circuit and reports to the credit tracker", () => {
-    const clock = makeClock();
-    const ctx = build([{ id: "s1" }]);
-    const pool = new SellerPool({
-      modelIndex: ctx.index,
-      cache: ctx.cache,
-      creditTracker: ctx.credit,
-      failureThreshold: 1, // open after the first failure
-      now: () => clock.now
-    });
-    pool.sync();
-
-    ctx.credit.recordPurchase("s1", 1_000_000, 1_000_000);
-    pool.recordFailure("s1", "soft_5xx");
-    expect(pool.snapshot()[0].circuit).toBe("open");
-
-    clock.advance(31_000); // wait past the open window
-    pool.recordSuccess("s1", 250_000);
-    const entry = pool.snapshot()[0];
-    expect(entry.circuit).toBe("closed");
-    expect(entry.consecutiveFailures).toBe(0);
-    expect(ctx.credit.getEntry("s1")?.currentBalanceMicros).toBe(250_000);
-  });
-
-  test("recordRuntimeMetrics updates speed telemetry without changing credit", () => {
-    const ctx = build([{ id: "s1" }]);
-    const pool = new SellerPool({ modelIndex: ctx.index, cache: ctx.cache, creditTracker: ctx.credit });
-    pool.sync();
-    ctx.credit.recordPurchase("s1", 1_000_000, 250_000);
-
-    const entry = pool.recordRuntimeMetrics("s1", {
-      ttftMs: 123,
-      avgInferenceMs: 456,
-      avgTokensPerSecond: 78.9
-    });
-
-    expect(entry).toMatchObject({
-      sellerId: "s1",
-      ttftMs: 123,
-      avgInferenceMs: 456,
-      avgLatencyMs: 456,
-      avgTokensPerSecond: 78.9
-    });
-    expect(ctx.credit.getEntry("s1")?.currentBalanceMicros).toBe(250_000);
-  });
-
-  test("sync preserves live runtime speed metrics when prewarm has no newer values", () => {
-    const ctx = build([{ id: "s1" }]);
-    const pool = new SellerPool({ modelIndex: ctx.index, cache: ctx.cache, creditTracker: ctx.credit });
-    pool.sync();
-    pool.recordRuntimeMetrics("s1", {
-      ttftMs: 123,
-      avgInferenceMs: 456,
-      avgTokensPerSecond: 78.9
-    }, 2_000_000);
-    ctx.cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [{
-        sellerId: "s1",
-        url: "https://s1.example.com",
-        healthScore: 80,
-        lastSuccessAt: 1_000_000,
-        ttftMs: 1,
-        avgInferenceMs: 2,
-        avgTokensPerSecond: 0
-      }]
-    });
-
-    pool.sync();
-
-    expect(pool.snapshot()[0]).toMatchObject({
-      ttftMs: 123,
-      avgInferenceMs: 456,
-      avgTokensPerSecond: 78.9
-    });
-  });
-
-  test("hard failure kinds (hard_4xx, auth_invalid) immediately open the circuit and transfer leftover", () => {
-    const ctx = build([{ id: "s1" }]);
-    const pool = new SellerPool({ modelIndex: ctx.index, cache: ctx.cache, creditTracker: ctx.credit });
-    pool.sync();
-
-    ctx.credit.recordPurchase("s1", 1_000_000, 500_000);
-    const kinds: FailureKind[] = ["hard_4xx", "auth_invalid"];
-    for (const kind of kinds) {
-      ctx.credit.recordPurchase("s1", 1_000_000, 500_000);
-      const entry = pool.recordFailure("s1", kind, { reason: "test" });
-      expect(entry?.circuit).toBe("open");
-    }
-    const summary = ctx.credit.summary();
-    expect(summary.totalWastedMicros).toBeGreaterThan(0);
-  });
-
-  test("inspect surfaces freshPurchase and autoPurchaseAvailable flags", () => {
-    const ctx = build([{ id: "s1" }]);
-    const pool = new SellerPool({ modelIndex: ctx.index, cache: ctx.cache, creditTracker: ctx.credit });
-    pool.sync();
-
-    ctx.credit.recordPurchase("s1", 1_000_000, 1_000_000);
-    const info = pool.inspect("s1");
-    expect(info.entry?.sellerId).toBe("s1");
-    expect(info.freshPurchase).toBe(true);
-    expect(info.autoPurchaseAvailable).toBe(true);
-  });
-
-  test("markOpen force-opens a circuit without changing other state", () => {
-    const ctx = build([{ id: "s1" }]);
-    const pool = new SellerPool({ modelIndex: ctx.index, cache: ctx.cache, creditTracker: ctx.credit });
-    pool.sync();
-    pool.markOpen("s1", "registry_disappeared");
-    expect(pool.snapshot()[0].circuit).toBe("open");
-  });
-
-  test("pick returns an empty result when the prewarm cache has no entry for the model", () => {
-    const index = new ModelIndex();
-    index.rebuild([makeSeller({ id: "s1", models: ["gpt-4o"] })], { registryVersion: 1 });
-    const cache = new PrewarmCache();
-    const credit = new CreditTracker();
-    const pool = new SellerPool({ modelIndex: index, cache, creditTracker: credit });
-    pool.sync();
-
-    const result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(result.candidates).toEqual([]);
-    // No prewarm has been committed for this model yet, so the pool
-    // surfaces "no_prewarm_candidates" (not "prewarm_cache_empty"); the
-    // distinction matters for the caller deciding whether to schedule a
-    // lazy prewarm.
-    expect(result.reason).toBe("no_prewarm_candidates");
-  });
-
-  test("pick falls back to the registry index when the cache has no entry yet", () => {
-    const index = new ModelIndex();
-    index.rebuild(
-      [makeSeller({ id: "s1", models: ["gpt-4o"] }), makeSeller({ id: "s2", models: ["gpt-4o"] })],
-      { registryVersion: 1 }
-    );
-    const cache = new PrewarmCache();
-    const credit = new CreditTracker();
-    const pool = new SellerPool({ modelIndex: index, cache, creditTracker: credit });
-    pool.sync();
-
-    // No probe has run yet, so pool is empty. pick should report "no candidates" and
-    // also surface the registry-level model resolution so the caller can decide
-    // whether to schedule a lazy prewarm.
-    const result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(result.candidates).toEqual([]);
-    expect(result.resolved.matched).toBe(true);
-    expect(result.resolved.candidates).toHaveLength(2);
-  });
-});

package/tests/seller-route-planner.test.ts

@@ -1,312 +0,0 @@
-import { planSellerRouteSet, type SellerRoutePlannerInput } from "../src/seller-route-planner.js";
-import type { RegistrySeller } from "../src/seller-catalog.js";
-
-function seller(overrides: Partial<RegistrySeller> & { id: string; models?: string[] }): RegistrySeller {
-  return {
-    id: overrides.id,
-    name: overrides.name ?? overrides.id,
-    status: overrides.status,
-    url: overrides.url ?? `https://${overrides.id}.example.com`,
-    supportedProtocols: overrides.supportedProtocols ?? ["chat_completions"],
-    paymentMethods: overrides.paymentMethods ?? ["clawtip"],
-    models: overrides.models ?? ["gpt-5.4"]
-  };
-}
-
-function plan(overrides: Partial<SellerRoutePlannerInput> = {}) {
-  return planSellerRouteSet({
-    modelId: "gpt-5.4",
-    protocol: "chat_completions",
-    paymentMethod: "clawtip",
-    registrySellers: [
-      seller({ id: "s1" }),
-      seller({ id: "s2" }),
-      seller({ id: "s3", supportedProtocols: ["responses"] })
-    ],
-    routing: { mode: "fullAuto", scorer: "balanced" },
-    ...overrides
-  });
-}
-
-describe("seller route planner", () => {
-  test("uses compatible prewarm candidates before registry fallback", () => {
-    const result = plan({
-      prewarmCandidates: [
-        { sellerId: "s2", url: "https://s2.example.com", healthScore: 95, avgLatencyMs: 120, avgTokensPerSecond: 42.5 },
-        { sellerId: "s1", url: "https://s1.example.com", healthScore: 50, avgLatencyMs: 80 },
-        { sellerId: "missing", url: "https://missing.example.com", healthScore: 100, avgLatencyMs: 1 }
-      ],
-      sellerMetrics: [
-        { sellerId: "s1", discountRatio: 0.5 },
-        { sellerId: "s2", discountRatio: 0.01 }
-      ]
-    });
-
-    expect(result.source).toBe("prewarm_cache");
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["s2", "s1"]);
-    expect(result.candidateCount).toBe(2);
-    expect(result.routes[0].metrics).toEqual({
-      healthScore: 95,
-      avgLatencyMs: 120,
-      avgTokensPerSecond: 42.5,
-      discountRatio: 0.01,
-      registryOrder: 1
-    });
-  });
-
-  test("prefers live runtime speed metrics over stale prewarm metrics", () => {
-    const result = plan({
-      routing: { mode: "fullAuto", scorer: "speed" },
-      prewarmCandidates: [
-        { sellerId: "s1", url: "https://s1.example.com", healthScore: 90, avgLatencyMs: 100, avgTokensPerSecond: 1 },
-        { sellerId: "s2", url: "https://s2.example.com", healthScore: 90, avgLatencyMs: 100, avgTokensPerSecond: 80 }
-      ],
-      sellerMetrics: [
-        { sellerId: "s1", ttftMs: 20, avgInferenceMs: 100, avgTokensPerSecond: 120 },
-        { sellerId: "s2", ttftMs: 20, avgInferenceMs: 100, avgTokensPerSecond: 2 }
-      ]
-    });
-
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["s1", "s2"]);
-    expect(result.routes[0].metrics).toMatchObject({
-      ttftMs: 20,
-      avgInferenceMs: 100,
-      avgTokensPerSecond: 120
-    });
-  });
-
-  test("does not hide compatible registry sellers when prewarm cache is incomplete", () => {
-    const result = plan({
-      routing: { mode: "fullAuto", scorer: "discount" },
-      prewarmCandidates: [
-        { sellerId: "s1", url: "https://s1.example.com", healthScore: 95, avgLatencyMs: 30 }
-      ],
-      sellerMetrics: [
-        { sellerId: "s1", discountRatio: 1 },
-        { sellerId: "s2", discountRatio: 0.01 }
-      ]
-    });
-
-    expect(result.source).toBe("prewarm_cache");
-    expect(result.sourceReason).toBe("prewarm_metrics_merged_with_registry");
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["s2", "s1"]);
-    expect(result.diagnostics).toMatchObject({
-      prewarmCandidateCount: 1,
-      prewarmUsableCount: 1,
-      sourceCandidateCount: 2
-    });
-  });
-
-  test("falls back to registry candidates when prewarm has no usable sellers", () => {
-    const result = plan({
-      prewarmCandidates: [
-        { sellerId: "missing", url: "https://missing.example.com", healthScore: 100 },
-        { sellerId: "s3", url: "https://s3.example.com", healthScore: 100 }
-      ]
-    });
-
-    expect(result.source).toBe("registry_fallback");
-    expect(result.sourceReason).toBe("prewarm_no_compatible_candidates");
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["s1", "s2"]);
-    expect(result.diagnostics).toMatchObject({
-      prewarmCandidateCount: 2,
-      prewarmUsableCount: 0,
-      prewarmMissingSellerIds: ["missing"],
-      prewarmBlockedSellerIds: [],
-      prewarmIncompatibleSellerIds: ["s3"]
-    });
-  });
-
-  test("diagnostics explain prewarm fallback caused by blocked warm candidates", () => {
-    const now = 10_000;
-    const result = plan({
-      now,
-      prewarmCandidates: [
-        { sellerId: "s1", url: "https://s1.example.com", healthScore: 100 },
-        { sellerId: "s2", url: "https://s2.example.com", healthScore: 90 }
-      ],
-      sellerMetrics: [
-        { sellerId: "s1", circuit: "open" },
-        { sellerId: "s2", capacityBlockedUntil: now + 1000 }
-      ]
-    });
-
-    expect(result.source).toBe("registry_fallback");
-    expect(result.sourceReason).toBe("prewarm_no_compatible_candidates");
-    expect(result.routes).toEqual([]);
-    expect(result.diagnostics).toMatchObject({
-      prewarmCandidateCount: 2,
-      prewarmUsableCount: 0,
-      prewarmBlockedSellerIds: ["s1", "s2"],
-      blockedOpenCircuitCount: 1,
-      blockedCapacityCount: 1,
-      blockedSellerIds: ["s1", "s2"]
-    });
-  });
-
-  test("filters registry fallback by requested model, protocol, and payment method", () => {
-    const result = plan({
-      registrySellers: [
-        seller({ id: "ok", models: ["gpt-5.4"], supportedProtocols: ["chat_completions"], paymentMethods: ["clawtip"] }),
-        seller({ id: "wrong-model", models: ["MiniMax-M2.7"], supportedProtocols: ["chat_completions"], paymentMethods: ["clawtip"] }),
-        seller({ id: "wrong-protocol", models: ["gpt-5.4"], supportedProtocols: ["responses"], paymentMethods: ["clawtip"] }),
-        seller({ id: "wrong-payment", models: ["gpt-5.4"], supportedProtocols: ["chat_completions"], paymentMethods: ["mock"] })
-      ]
-    });
-
-    expect(result.source).toBe("registry_fallback");
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["ok"]);
-    expect(result.reason).toBe("fullAuto:balanced:routes_1");
-    expect(result.diagnostics).toEqual({
-      registryVisibleCount: 4,
-      prewarmCandidateCount: 0,
-      prewarmUsableCount: 0,
-      prewarmMissingSellerIds: [],
-      prewarmBlockedSellerIds: [],
-      prewarmIncompatibleSellerIds: [],
-      sourceCandidateCount: 1,
-      blockedOpenCircuitCount: 0,
-      blockedCapacityCount: 0,
-      blockedLocalConcurrencyCount: 0,
-      blockedSellerIds: [],
-      incompatibleCount: 3,
-      incompatibleSellerIds: ["wrong-model", "wrong-payment", "wrong-protocol"]
-    });
-  });
-
-  test("only active registry sellers are visible to buyer routing", () => {
-    const result = plan({
-      registrySellers: [
-        seller({ id: "legacy-no-status" }),
-        seller({ id: "active", status: "active" }),
-        seller({ id: "pending", status: "pending" }),
-        seller({ id: "draining", status: "draining" }),
-        seller({ id: "offline", status: "offline" })
-      ]
-    });
-
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["legacy-no-status", "active"]);
-  });
-
-  test("fixed mode fails closed when selected seller is outside compatibility", () => {
-    const result = plan({
-      routing: { mode: "fixed", sellerId: "s3", scorer: "speed" }
-    });
-
-    expect(result.routes).toEqual([]);
-    expect(result.reason).toBe("fixed_seller_not_compatible");
-  });
-
-  test("fixedSet mode does not select outside the configured seller pool", () => {
-    const result = plan({
-      routing: { mode: "fixedSet", sellerIds: ["s1", "s2"], scorer: "speed" },
-      sellerMetrics: [
-        { sellerId: "outside", healthScore: 100, avgLatencyMs: 10 },
-        { sellerId: "s1", healthScore: 40, avgLatencyMs: 20 },
-        { sellerId: "s2", healthScore: 90, avgLatencyMs: 30 }
-      ],
-      registrySellers: [
-        seller({ id: "outside" }),
-        seller({ id: "s1" }),
-        seller({ id: "s2" })
-      ]
-    });
-
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["s2", "s1"]);
-  });
-
-  test("discount scorer uses planner metrics during registry fallback", () => {
-    const result = plan({
-      routing: { mode: "fullAuto", scorer: "discount" },
-      sellerMetrics: [
-        { sellerId: "s1", healthScore: 100, discountRatio: 1 },
-        { sellerId: "s2", healthScore: 30, discountRatio: 0.01 }
-      ]
-    });
-
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["s2", "s1"]);
-  });
-
-  test("messages protocol accepts anthropic_messages registry sellers", () => {
-    const result = plan({
-      modelId: "MiniMax-M2.7",
-      protocol: "messages",
-      registrySellers: [
-        seller({
-          id: "minimax",
-          models: ["MiniMax-M2.7"],
-          supportedProtocols: ["anthropic_messages"],
-          paymentMethods: ["clawtip"]
-        })
-      ]
-    });
-
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["minimax"]);
-  });
-
-  test("open circuit observations are excluded before strategy selection", () => {
-    const result = plan({
-      routing: { mode: "fullAuto", scorer: "speed" },
-      sellerMetrics: [
-        { sellerId: "s1", healthScore: 100, circuit: "open" },
-        { sellerId: "s2", healthScore: 20, circuit: "closed" }
-      ]
-    });
-
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["s2"]);
-    expect(result.diagnostics.blockedOpenCircuitCount).toBe(1);
-    expect(result.diagnostics.blockedSellerIds).toEqual(["s1"]);
-  });
-
-  test("active capacity blocks are excluded before strategy selection", () => {
-    const now = 10_000;
-    const blocked = plan({
-      now,
-      routing: { mode: "fullAuto", scorer: "speed" },
-      sellerMetrics: [
-        { sellerId: "s1", healthScore: 100, avgLatencyMs: 10, capacityBlockedUntil: now + 1000 },
-        { sellerId: "s2", healthScore: 20, avgLatencyMs: 100 }
-      ]
-    });
-
-    expect(blocked.routes.map((route) => route.seller.id)).toEqual(["s2"]);
-    expect(blocked.diagnostics.blockedCapacityCount).toBe(1);
-    expect(blocked.diagnostics.blockedSellerIds).toEqual(["s1"]);
-
-    const expired = plan({
-      now: now + 1001,
-      routing: { mode: "fullAuto", scorer: "speed" },
-      sellerMetrics: [
-        { sellerId: "s1", healthScore: 100, avgLatencyMs: 10, capacityBlockedUntil: now + 1000 },
-        { sellerId: "s2", healthScore: 20, avgLatencyMs: 100 }
-      ]
-    });
-
-    expect(expired.routes.map((route) => route.seller.id)).toEqual(["s1", "s2"]);
-    expect(expired.diagnostics.blockedCapacityCount).toBe(0);
-    expect(expired.diagnostics.blockedSellerIds).toEqual([]);
-  });
-
-  test("local concurrency blocks are excluded before choosing prewarm or registry candidates", () => {
-    const result = plan({
-      prewarmCandidates: [
-        { sellerId: "s1", url: "https://s1.example.com", healthScore: 100 }
-      ],
-      sellerMetrics: [
-        { sellerId: "s1", localConcurrencyActive: 1, localConcurrencyLimit: 1 },
-        { sellerId: "s2", localConcurrencyActive: 0, localConcurrencyLimit: 1 }
-      ]
-    });
-
-    expect(result.source).toBe("registry_fallback");
-    expect(result.sourceReason).toBe("prewarm_no_compatible_candidates");
-    expect(result.routes.map((route) => route.seller.id)).toEqual(["s2"]);
-    expect(result.diagnostics).toMatchObject({
-      prewarmCandidateCount: 1,
-      prewarmUsableCount: 0,
-      prewarmBlockedSellerIds: ["s1"],
-      blockedLocalConcurrencyCount: 1,
-      blockedSellerIds: ["s1"]
-    });
-  });
-});