@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/injector-pkb-v2-silenced.test.ts

@@ -1,23 +1,26 @@
 /**
  * v2 read-side cutover behavior for the PKB-derived default injectors.
  *
- * When `isMemoryV2ReadActive(getConfig())` is true:
+ * When `getConfig().memory.v2.enabled` is true:
  *   - `pkb-context` silences itself (concept pages own retrieval).
  *   - `pkb-reminder` still fires (its body is generic recall/remember
  *     guidance) but skips the PKB-search hints — those name PKB paths.
  *   - `now-md` fires unchanged (workspace state, independent of PKB).
  *
- * Mocks `isMemoryV2ReadActive` at the module level so each test can flip the
- * effective gate state without standing up a full feature-flag + config
- * stack. Mocks the PKB hybrid search so the reminder-with-hints branch can
- * resolve deterministically when called.
+ * Mocks `getConfig` at the module level so each test can flip the effective
+ * gate state without standing up a full config stack. Mocks the PKB hybrid
+ * search so the reminder-with-hints branch can resolve deterministically
+ * when called.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let v2Active = false;
 
-mock.module("../memory/context-search/sources/memory-v2.js", () => ({
-  isMemoryV2ReadActive: () => v2Active,
+const realLoader = await import("../config/loader.js");
+
+mock.module("../config/loader.js", () => ({
+  ...realLoader,
+  getConfig: () => ({ memory: { v2: { enabled: v2Active } } }),
 }));
 
 mock.module("../memory/pkb/pkb-search.js", () => ({

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -14,7 +14,7 @@
 
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mock setup (must be before any imports from the project) ──────────────
 
@@ -115,6 +115,7 @@ describe("inline-command skill_load permissions", () => {
   beforeEach(() => {
     clearRiskCache();
     _clearGlobalCacheForTesting();
+    _setOverridesForTesting({});
     mockIpcResponse("get_global_thresholds", {
       interactive: "low",
       autonomous: "medium",
@@ -133,6 +134,10 @@ describe("inline-command skill_load permissions", () => {
     }
   });
 
+  afterEach(() => {
+    _setOverridesForTesting({});
+  });
+
   // ── Default behavior ─────────────────────────────────────────────────
 
   describe("default behavior", () => {

package/src/__tests__/install-skill-routing.test.ts

@@ -180,7 +180,7 @@ describe("installSkill routing", () => {
       "vercel-labs",
       "agent-skills",
       "react-best-practices",
-      true, // overwrite
+      true, // overwrite — handler default is true for HTTP API back-compat; CLI passes explicit false
       undefined, // ref
       undefined, // contactId
     );
@@ -221,7 +221,7 @@ describe("installSkill routing", () => {
       "owner",
       "repo",
       "my-skill",
-      true,
+      true, // overwrite — handler default is true for HTTP API back-compat; CLI passes explicit false
       undefined, // ref
       undefined, // contactId
     );

package/src/__tests__/lifecycle-memory-v2-seed.test.ts

@@ -1,17 +1,17 @@
 /**
- * Tests for the memory-v2 skill seed gate invoked from the daemon startup
- * path (`assistant/src/daemon/memory-v2-startup.ts`).
+ * Tests for the memory-v2 skill seed gate and the v2 concept-page schema
+ * rebuild gate, both invoked from the daemon startup path
+ * (`assistant/src/daemon/memory-v2-startup.ts`).
  *
- * The gate is exercised in isolation rather than mounting the full lifecycle
- * import graph. Coverage matrix from PR 8 acceptance criteria:
- *   - Case 1: feature flag on + `config.memory.v2.enabled` on → seed runs.
- *   - Case 2: feature flag off → seed does not run.
- *   - Case 3: `config.memory.v2.enabled` off (flag on) → seed does not run.
- *   - Case 4: `seedV2SkillEntries` rejects → gate does not throw and the
- *     warning is logged.
+ * The gates are exercised in isolation rather than mounting the full
+ * lifecycle import graph. Coverage matrix:
+ *   - Skill seed (`maybeSeedMemoryV2Skills`): config gating, rejection
+ *     swallowing.
+ *   - Schema rebuild (`maybeRebuildMemoryV2Concepts`): config gating,
+ *     drift-triggered reembed enqueue, empty-after-create reembed enqueue,
+ *     no enqueue when collection is healthy, error swallowing.
  *
- * The seed call itself is fire-and-forget (`void` + `.catch`); the gate must
- * never block startup or surface an exception.
+ * Both gates must never block startup or surface an exception.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -22,31 +22,38 @@ import type { AssistantConfig } from "../config/schema.js";
 // ---------------------------------------------------------------------------
 
 interface TestState {
-  flagOverrides: Record<string, boolean>;
   seedCallCount: number;
   seedShouldReject: Error | null;
   warnCalls: Array<{ obj: unknown; msg: unknown }>;
+  infoCalls: Array<{ obj: unknown; msg: unknown }>;
+  // Rebuild-gate mocks (drive maybeRebuildMemoryV2Concepts).
+  ensureCollectionCallCount: number;
+  ensureCollectionResult: { migrated: boolean };
+  ensureCollectionThrows: Error | null;
+  countResult: number;
+  listPagesResult: string[];
+  enqueueCalls: Array<{ type: string; payload: Record<string, unknown> }>;
+  clearSentinelCallCount: number;
 }
 
 const state: TestState = {
-  flagOverrides: {},
   seedCallCount: 0,
   seedShouldReject: null,
   warnCalls: [],
+  infoCalls: [],
+  ensureCollectionCallCount: 0,
+  ensureCollectionResult: { migrated: false },
+  ensureCollectionThrows: null,
+  countResult: 0,
+  listPagesResult: [],
+  enqueueCalls: [],
+  clearSentinelCallCount: 0,
 };
 
 // ---------------------------------------------------------------------------
 // Mocks — installed before the module under test is loaded.
 // ---------------------------------------------------------------------------
 
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string, _config: unknown): boolean => {
-    const explicit = state.flagOverrides[key];
-    if (typeof explicit === "boolean") return explicit;
-    return true; // undeclared flags default to enabled
-  },
-}));
-
 mock.module("../memory/v2/skill-store.js", () => ({
   seedV2SkillEntries: async (): Promise<void> => {
     state.seedCallCount += 1;
@@ -54,18 +61,59 @@ mock.module("../memory/v2/skill-store.js", () => ({
   },
 }));
 
+mock.module("../memory/v2/qdrant.js", () => ({
+  ensureConceptPageCollection: async (): Promise<{ migrated: boolean }> => {
+    state.ensureCollectionCallCount += 1;
+    if (state.ensureCollectionThrows) throw state.ensureCollectionThrows;
+    return state.ensureCollectionResult;
+  },
+  countConceptPagePoints: async (): Promise<number> => state.countResult,
+  clearReembedSentinel: async (): Promise<void> => {
+    state.clearSentinelCallCount += 1;
+  },
+  // The rebuild gate does not call this, but the seed gate's fire-and-forget
+  // chain imports it; provide a no-op so the dynamic import resolves.
+  dropLegacySkillsCollection: async (): Promise<void> => {},
+}));
+
+mock.module("../memory/v2/page-store.js", () => ({
+  hasConceptPages: async (): Promise<boolean> =>
+    state.listPagesResult.length > 0,
+}));
+
+mock.module("../memory/jobs-store.js", () => ({
+  enqueueMemoryJob: (
+    type: string,
+    payload: Record<string, unknown>,
+  ): string => {
+    state.enqueueCalls.push({ type, payload });
+    return "test-job-id";
+  },
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspaceDir: () => "/tmp/test-workspace",
+  // qdrant.ts (mocked away in this file) reads `getDataDir` for the reembed
+  // sentinel path; bun mocks share the same module record across files, so
+  // include it here too so a peer test importing `getDataDir` doesn't see
+  // `undefined` after this mock evaluates.
+  getDataDir: () => "/tmp/test-workspace/data",
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     warn: (obj: unknown, msg: unknown) => {
       state.warnCalls.push({ obj, msg });
     },
-    info: () => {},
+    info: (obj: unknown, msg: unknown) => {
+      state.infoCalls.push({ obj, msg });
+    },
     error: () => {},
     debug: () => {},
   }),
 }));
 
-const { maybeSeedMemoryV2Skills } =
+const { maybeSeedMemoryV2Skills, maybeRebuildMemoryV2Concepts } =
   await import("../daemon/memory-v2-startup.js");
 
 // ---------------------------------------------------------------------------
@@ -99,65 +147,38 @@ async function flushMicrotasks(): Promise<void> {
 // Tests
 // ---------------------------------------------------------------------------
 
+function resetState(): void {
+  state.seedCallCount = 0;
+  state.seedShouldReject = null;
+  state.warnCalls = [];
+  state.infoCalls = [];
+  state.ensureCollectionCallCount = 0;
+  state.ensureCollectionResult = { migrated: false };
+  state.ensureCollectionThrows = null;
+  state.countResult = 0;
+  state.listPagesResult = [];
+  state.enqueueCalls = [];
+  state.clearSentinelCallCount = 0;
+}
+
 describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
-  beforeEach(() => {
-    state.flagOverrides = {};
-    state.seedCallCount = 0;
-    state.seedShouldReject = null;
-    state.warnCalls = [];
-  });
+  beforeEach(resetState);
 
-  test("invokes seedV2SkillEntries when flag and config are both enabled", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
+  test("invokes seedV2SkillEntries when memory.v2.enabled is true", async () => {
     maybeSeedMemoryV2Skills(makeConfig(true));
     await flushMicrotasks();
     expect(state.seedCallCount).toBe(1);
     expect(state.warnCalls).toHaveLength(0);
   });
 
-  test("does not invoke seedV2SkillEntries when feature flag is off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": false };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-    expect(state.warnCalls).toHaveLength(0);
-  });
-
-  test("does not invoke seedV2SkillEntries when config.memory.v2.enabled is off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
+  test("does not invoke seedV2SkillEntries when memory.v2.enabled is false", async () => {
     maybeSeedMemoryV2Skills(makeConfig(false));
     await flushMicrotasks();
     expect(state.seedCallCount).toBe(0);
     expect(state.warnCalls).toHaveLength(0);
   });
 
-  test("does not invoke seedV2SkillEntries when both gates are off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": false };
-    maybeSeedMemoryV2Skills(makeConfig(false));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-    expect(state.warnCalls).toHaveLength(0);
-  });
-
-  test("re-invocation seeds after flag flips on (deferred-init race recovery)", async () => {
-    // Models the lifecycle-startup race: the synchronous seed call evaluates
-    // the flag while the gateway IPC override fetch is still in flight, falls
-    // through to the registry default (`false`), and skips. Once
-    // `initFeatureFlagOverrides()` resolves, the chained `.then` re-invokes
-    // the seed with the now-populated cache and the flag flips to `true`.
-    state.flagOverrides = { "memory-v2-enabled": false };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-
-    state.flagOverrides = { "memory-v2-enabled": true };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(1);
-  });
-
   test("swallows seedV2SkillEntries rejections and logs a warning", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
     state.seedShouldReject = new Error("seed failed");
 
     // The gate must not throw — startup must not block on this.
@@ -172,3 +193,84 @@ describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
     expect(msg).toBe("Failed to seed v2 skill entries");
   });
 });
+
+describe("maybeRebuildMemoryV2Concepts (daemon startup gate)", () => {
+  beforeEach(resetState);
+
+  test("does nothing when memory.v2.enabled is false", async () => {
+    await maybeRebuildMemoryV2Concepts(makeConfig(false));
+
+    expect(state.ensureCollectionCallCount).toBe(0);
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("enqueues memory_v2_reembed when the collection was migrated", async () => {
+    state.ensureCollectionResult = { migrated: true };
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.ensureCollectionCallCount).toBe(1);
+    expect(state.enqueueCalls).toEqual([
+      { type: "memory_v2_reembed", payload: {} },
+    ]);
+    // After the reembed is queued, the on-disk sentinel that the qdrant
+    // ensure-path may have written is cleared so it does not re-trigger on
+    // the next startup.
+    expect(state.clearSentinelCallCount).toBe(1);
+    // Migrated path skips the count probe — drift detection is the trigger.
+    // (The mock's countConceptPagePoints would silently return 0 either way,
+    // but keeping the path conditional keeps the lifecycle hook predictable.)
+  });
+
+  test("enqueues reembed when the collection is empty but pages exist on disk (crash-mid-rebuild recovery)", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 0;
+    state.listPagesResult = ["people/alice", "topics/zsh"];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([
+      { type: "memory_v2_reembed", payload: {} },
+    ]);
+  });
+
+  test("does not enqueue when the collection is healthy and populated", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 1185;
+    state.listPagesResult = ["people/alice"];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("does not enqueue when the collection is empty AND no pages exist on disk (fresh workspace)", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 0;
+    state.listPagesResult = [];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("swallows ensureConceptPageCollection failures and logs a warning", async () => {
+    state.ensureCollectionThrows = new Error("Qdrant unreachable");
+
+    // Must not throw — startup never blocks on this gate.
+    let thrown: unknown = null;
+    try {
+      await maybeRebuildMemoryV2Concepts(makeConfig(true));
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeNull();
+
+    expect(state.enqueueCalls).toEqual([]);
+    expect(state.warnCalls.length).toBeGreaterThan(0);
+    const lastWarn = state.warnCalls[state.warnCalls.length - 1];
+    expect((lastWarn.obj as { err: Error }).err.message).toBe(
+      "Qdrant unreachable",
+    );
+  });
+});

package/src/__tests__/llm-callsite-catalog.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import { getLLMCallSiteLabel } from "../config/llm-callsite-catalog.js";
 import { CALL_SITE_CATALOG } from "../config/schemas/call-site-catalog.js";
-import { LLMCallSiteEnum } from "../config/schemas/llm.js";
+import { LLMCallSiteEnum, LLMSchema } from "../config/schemas/llm.js";
 
 describe("LLM call-site catalog", () => {
   test("resolves every backend call-site enum value from the catalog", () => {
@@ -31,4 +31,23 @@ describe("LLM call-site catalog", () => {
   test("returns the raw ID for unknown call sites", () => {
     expect(getLLMCallSiteLabel("unknownCallSite")).toBe("unknownCallSite");
   });
+
+  test("registers the memoryRouter call site under the memory domain", () => {
+    expect(LLMCallSiteEnum.options).toContain("memoryRouter");
+
+    const entry = CALL_SITE_CATALOG.find(({ id }) => id === "memoryRouter");
+    expect(entry).toBeDefined();
+    expect(entry?.domain).toBe("memory");
+    expect(entry?.displayName).toBe("Memory Router");
+    expect(entry?.description).toBe(
+      "Selects which concept pages to inject for the next agent turn by routing over a cached page index.",
+    );
+  });
+
+  test("memoryRouter is addressable as a call-site override key in LLMSchema", () => {
+    const parsed = LLMSchema.parse({
+      callSites: { memoryRouter: { model: "claude-sonnet-4-6" } },
+    });
+    expect(parsed.callSites.memoryRouter?.model).toBe("claude-sonnet-4-6");
+  });
 });

package/src/__tests__/llm-catalog-parity.test.ts

@@ -2,7 +2,9 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
+import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
 import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
+import { resolvePricing, resolvePricingForUsage } from "../util/pricing.js";
 
 /**
  * Parity guard: daemon LLM provider catalog vs client LLM catalog JSON.
@@ -50,6 +52,13 @@ interface ClientCatalogModel {
     outputPer1mTokens: number;
     cacheWritePer1mTokens?: number;
     cacheReadPer1mTokens?: number;
+    tiers?: Array<{
+      inputTokenThreshold: number;
+      inputPer1mTokens: number;
+      outputPer1mTokens: number;
+      cacheReadPer1mTokens?: number;
+      cacheWritePer1mTokens?: number;
+    }>;
   };
 }
 
@@ -62,6 +71,7 @@ interface ClientCatalogEntry {
   envVar?: string;
   apiKeyPlaceholder?: string;
   credentialsGuide?: ClientCatalogCredentialsGuide;
+  supportsManagedAuth?: boolean;
   defaultModel: string;
   models: ClientCatalogModel[];
 }
@@ -114,6 +124,9 @@ describe("LLM catalog parity: daemon vs client", () => {
       expect(clientEntry.setupHint).toBe(daemonEntry.setupHint);
       expect(clientEntry.envVar).toBe(daemonEntry.envVar);
       expect(clientEntry.apiKeyPlaceholder).toBe(daemonEntry.apiKeyPlaceholder);
+      expect(clientEntry.supportsManagedAuth).toBe(
+        daemonEntry.supportsManagedAuth,
+      );
       expect(clientEntry.credentialsGuide).toEqual(
         daemonEntry.credentialsGuide,
       );
@@ -121,6 +134,19 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
+  test("supportsManagedAuth mirrors MANAGED_PROVIDER_META", () => {
+    // The catalog field is derived from MANAGED_PROVIDER_META at build
+    // time. This test guards against future hand-edits to model-catalog.ts
+    // that would let the two drift. Adding a provider to MANAGED_PROVIDER_META
+    // must auto-propagate; flipping `managed: true` to `false` (or vice
+    // versa) must propagate too.
+    for (const entry of PROVIDER_CATALOG) {
+      const expectedSupportsManagedAuth =
+        MANAGED_PROVIDER_META[entry.id]?.managed === true;
+      expect(entry.supportsManagedAuth).toBe(expectedSupportsManagedAuth);
+    }
+  });
+
   test("each provider's model count matches the daemon catalog", () => {
     const json = loadClientCatalog();
 
@@ -248,6 +274,126 @@ describe("LLM catalog parity: daemon vs client", () => {
     });
   });
 
+  // -----------------------------------------------------------------------
+  // pricing.ts ↔ model-catalog.ts parity
+  //
+  // `assistant/src/util/pricing.ts` reads pricing from `PROVIDER_CATALOG`
+  // (catalog-first) with a legacy fallback table for models we still bill
+  // for but no longer advertise. These tests probe `resolvePricing` /
+  // `resolvePricingForUsage` for every priced catalog model so any drift
+  // between the catalog row and the resolver's output (including cache
+  // discounts and long-context tier rates) fails CI.
+  // -----------------------------------------------------------------------
+
+  test("each priced catalog model has matching base rates in pricing.ts", () => {
+    // 100k tokens stays below every long-context tier threshold in the
+    // catalog (smallest threshold is 200k), so resolvePricing returns the
+    // base rate uncontaminated by tier selection.
+    const PROBE_TOKENS = 100_000;
+    const TOKENS_PER_MILLION = 1_000_000;
+
+    for (const provider of PROVIDER_CATALOG) {
+      for (const model of provider.models) {
+        if (!model.pricing) continue;
+
+        const inputResult = resolvePricing(
+          provider.id,
+          model.id,
+          PROBE_TOKENS,
+          0,
+        );
+        expect(
+          inputResult.pricingStatus,
+          `${provider.id}/${model.id} unpriced in pricing.ts`,
+        ).toBe("priced");
+        const inputRate =
+          (inputResult.estimatedCostUsd ?? 0) *
+          (TOKENS_PER_MILLION / PROBE_TOKENS);
+        expect(
+          inputRate,
+          `${provider.id}/${model.id} input rate drift`,
+        ).toBeCloseTo(model.pricing.inputPer1mTokens, 6);
+
+        const outputResult = resolvePricing(
+          provider.id,
+          model.id,
+          0,
+          PROBE_TOKENS,
+        );
+        const outputRate =
+          (outputResult.estimatedCostUsd ?? 0) *
+          (TOKENS_PER_MILLION / PROBE_TOKENS);
+        expect(
+          outputRate,
+          `${provider.id}/${model.id} output rate drift`,
+        ).toBeCloseTo(model.pricing.outputPer1mTokens, 6);
+      }
+    }
+  });
+
+  test("each priced catalog model has matching cache-read rate in pricing.ts", () => {
+    const PROBE_TOKENS = 100_000;
+    const TOKENS_PER_MILLION = 1_000_000;
+
+    for (const provider of PROVIDER_CATALOG) {
+      for (const model of provider.models) {
+        const cacheReadCatalogRate = model.pricing?.cacheReadPer1mTokens;
+        if (cacheReadCatalogRate === undefined) continue;
+
+        const result = resolvePricingForUsage(provider.id, model.id, {
+          directInputTokens: 0,
+          outputTokens: 0,
+          cacheCreationInputTokens: 0,
+          cacheReadInputTokens: PROBE_TOKENS,
+          anthropicCacheCreation: null,
+        });
+        expect(
+          result.pricingStatus,
+          `${provider.id}/${model.id} unpriced in pricing.ts`,
+        ).toBe("priced");
+        const cacheReadResolvedRate =
+          (result.estimatedCostUsd ?? 0) * (TOKENS_PER_MILLION / PROBE_TOKENS);
+        expect(
+          cacheReadResolvedRate,
+          `${provider.id}/${model.id} cache-read rate drift`,
+        ).toBeCloseTo(cacheReadCatalogRate, 6);
+      }
+    }
+  });
+
+  test("each priced catalog tier resolves at its tier rate", () => {
+    const TOKENS_PER_MILLION = 1_000_000;
+
+    for (const provider of PROVIDER_CATALOG) {
+      for (const model of provider.models) {
+        const tiers = model.pricing?.tiers;
+        if (!tiers || tiers.length === 0) continue;
+
+        for (const tier of tiers) {
+          const probeTokens = tier.inputTokenThreshold + 1_000;
+          const result = resolvePricingForUsage(provider.id, model.id, {
+            directInputTokens: probeTokens,
+            outputTokens: 0,
+            cacheCreationInputTokens: 0,
+            cacheReadInputTokens: 0,
+            anthropicCacheCreation: null,
+          });
+          expect(
+            result.pricingStatus,
+            `${provider.id}/${model.id} unpriced at tier ${tier.inputTokenThreshold}`,
+          ).toBe("priced");
+          const resolvedRate =
+            (result.estimatedCostUsd ?? 0) *
+            (TOKENS_PER_MILLION / probeTokens);
+          expect(
+            resolvedRate,
+            `${provider.id}/${model.id} input rate drift at tier ${tier.inputTokenThreshold}`,
+          ).toBeCloseTo(tier.inputPer1mTokens, 6);
+        }
+      }
+    }
+  });
+
   test("Gemini 2.5 Pro catalog context matches provider limits", () => {
     const gemini = PROVIDER_CATALOG.find((entry) => entry.id === "gemini");
     expect(