@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-Q64IR2Z2.js

@@ -0,0 +1,4933 @@
+import {
+  ModelMetadataResolver
+} from "./chunk-YVCMDVBB.js";
+import {
+  CURSOR_KNOWN_MODELS
+} from "./chunk-7HPCIOMA.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  logWarning
+} from "./chunk-ETAD4NKD.js";
+import {
+  sqlite_wrapper_default
+} from "./chunk-XQPEWJPI.js";
+import {
+  wrapWithSandbox
+} from "./chunk-B7YRSULE.js";
+import {
+  TelemetryPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  applySqlitePragmas
+} from "./chunk-HEP3ILP4.js";
+import {
+  ProviderRegistry,
+  refreshInventoryContext,
+  registerProviderRegistryReloadInvalidator,
+  resolveSharedRefreshPaths
+} from "./chunk-QJ6OEH4K.js";
+import {
+  listModelRouteIds
+} from "./chunk-QXBKTJT6.js";
+import {
+  createScopedProviderChildEnv
+} from "./chunk-WGQAXLNA.js";
+import {
+  getBuildProjectRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  debugLog,
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/telemetry/model-invocations-db.ts
+import { randomBytes } from "crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import path5 from "path";
+
+// src/telemetry/cost-precedence.ts
+var NON_METERED_COST_SQL = `(
+  e.computed_cost_cents IS NULL
+  AND (
+    (e.billing_mode IS NOT NULL AND e.billing_mode <> 'metered')
+    OR (
+      e.cost_snapshot IS NOT NULL
+      AND json_valid(e.cost_snapshot)
+      AND json_extract(e.cost_snapshot, '$.billingMode') IS NOT NULL
+      AND json_extract(e.cost_snapshot, '$.billingMode') <> 'metered'
+    )
+  )
+)`;
+var SNAPSHOT_FIRST_COST_CENTS_SQL = `
+  CASE
+    WHEN ${NON_METERED_COST_SQL}
+    THEN NULL
+    WHEN e.cost_snapshot IS NOT NULL AND json_valid(e.cost_snapshot) THEN
+      COALESCE(
+        -- REAL (not INTEGER): snapshot costs carry sub-cent precision; an
+        -- integer cast truncates small invocations (< 1 cent) to zero.
+        CAST(json_extract(e.cost_snapshot, '$.totalCostCents') AS REAL),
+        e.computed_cost_cents
+      )
+    ELSE e.computed_cost_cents
+  END
+`;
+function resolveSnapshotFirstCostCents(input) {
+  const billingMode = input.costSnapshot?.billingMode;
+  if (input.computedCostCents == null && (typeof billingMode === "string" && billingMode !== "metered" || typeof input.billingMode === "string" && input.billingMode !== "metered")) {
+    return null;
+  }
+  const snapshotCost = input.costSnapshot?.totalCostCents;
+  if (typeof snapshotCost === "number" && Number.isFinite(snapshotCost)) {
+    return snapshotCost;
+  }
+  const computedCost = input.computedCostCents;
+  return typeof computedCost === "number" && Number.isFinite(computedCost) ? computedCost : null;
+}
+function finiteNumberOrZero(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function resolveSnapshotFirstCostSnapshot(input) {
+  const totalCostCents = resolveSnapshotFirstCostCents(input);
+  if (totalCostCents === null) {
+    return null;
+  }
+  const snapshot = input.costSnapshot;
+  return {
+    inputCostCents: finiteNumberOrZero(snapshot?.inputCostCents),
+    outputCostCents: finiteNumberOrZero(snapshot?.outputCostCents),
+    cacheCostCents: finiteNumberOrZero(snapshot?.cacheCostCents),
+    toolCostCents: finiteNumberOrZero(snapshot?.toolCostCents),
+    infrastructureCostCents: finiteNumberOrZero(snapshot?.infrastructureCostCents),
+    totalCostCents,
+    currency: typeof snapshot?.currency === "string" && snapshot.currency ? snapshot.currency : "USD"
+  };
+}
+
+// src/telemetry/invocation-cost-enrichment.ts
+import fs3 from "fs";
+import path4 from "path";
+
+// src/core/config/model-registry.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import yaml from "js-yaml";
+import { z } from "zod";
+var BillingModeSchema = z.enum(["metered", "flat_rate", "non_metered"]);
+var CostSchemaZ = z.object({
+  prompt_per_1k: z.number().min(0).optional(),
+  completion_per_1k: z.number().min(0).optional(),
+  cache_read_per_1k: z.number().min(0).optional(),
+  cache_write_per_1k: z.number().min(0).optional(),
+  /** Cache writes held for the longer duration (Anthropic's 1-hour write); absent prices them at `cache_write_per_1k`. */
+  cache_write_1h_per_1k: z.number().min(0).optional(),
+  reasoning_per_1k: z.number().min(0).optional(),
+  tool_per_1k: z.number().min(0).optional(),
+  currency: z.string().min(1).optional(),
+  long_context_pricing: z.record(z.string(), z.unknown()).optional(),
+  /** Per speed-tier rate sets in the same per-1k shape as the standard rates, keyed by tier name. */
+  speed_tiers: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
+  /** Tier a model id selected (e.g. a `-fast` id) and the rate set priced; `applied` is `standard` when the tier had no rates. */
+  routed_speed_tier: z.object({
+    requested: z.string(),
+    applied: z.string(),
+    unpublishedLongContextAboveTokens: z.number().optional()
+  }).optional(),
+  extra_fees: z.record(z.string(), z.number()).optional(),
+  billing_mode: BillingModeSchema.optional(),
+  billing_source: z.string().optional(),
+  pricing_source: z.string().optional(),
+  /** How the rates were reached when not from the model's own row, e.g. `passthrough:<provider>/<model>`. */
+  resolution_route: z.string().optional(),
+  pricing_confidence: z.enum(["high", "medium", "low"]).optional(),
+  flat_rate_per_seat_month: z.number().min(0).optional(),
+  notes: z.string().optional()
+}).superRefine((value, ctx) => {
+  const billingMode = value.billing_mode ?? "metered";
+  if (billingMode === "metered") {
+    if (typeof value.prompt_per_1k !== "number") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Metered billing requires prompt_per_1k",
+        path: ["prompt_per_1k"]
+      });
+    }
+    if (typeof value.completion_per_1k !== "number") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Metered billing requires completion_per_1k",
+        path: ["completion_per_1k"]
+      });
+    }
+  }
+});
+var ModelDefZ = z.object({
+  id: z.string().min(1),
+  display_name: z.string().min(1),
+  capabilities: z.array(z.string()),
+  costSchema: CostSchemaZ.optional()
+});
+var ProviderFrontmatterZ = z.object({
+  id: z.string().min(1),
+  display_name: z.string().min(1),
+  models: z.array(ModelDefZ).min(1, "At least one model is required"),
+  auth_hint: z.string().optional()
+});
+function computeRegistryVersion(registry) {
+  const sortedProviders = [...registry.providers].sort((a, b) => a.providerId.localeCompare(b.providerId)).map((provider) => ({
+    authHint: provider.authHint,
+    displayName: provider.displayName,
+    modelMappings: provider.modelMappings,
+    models: [...provider.models || []].sort((a, b) => a.modelId.localeCompare(b.modelId)).map((model) => ({
+      capabilities: [...model.capabilities].sort(),
+      costSchema: model.costSchema,
+      displayName: model.displayName,
+      modelId: model.modelId,
+      unpricedReason: model.unpricedReason
+    })),
+    providerId: provider.providerId
+  }));
+  const canonical = JSON.stringify(sortJsonValue(sortedProviders));
+  return crypto.createHash("sha256").update(canonical).digest("hex");
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) return value.map(sortJsonValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortJsonValue(child)])
+    );
+  }
+  return value;
+}
+function buildRegistry(providers) {
+  const sorted = [...providers].sort((a, b) => a.providerId.localeCompare(b.providerId));
+  const registry = {
+    providers: sorted,
+    registryVersion: ""
+    // Placeholder, will be computed
+  };
+  const versionData = { ...registry, registryVersion: "" };
+  registry.registryVersion = computeRegistryVersion(versionData);
+  return registry;
+}
+
+// src/cost-tracking/list-price-rates.ts
+var PER_1K_TO_PER_1M = 1e3;
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function metaRecord(row) {
+  return row._meta && typeof row._meta === "object" ? row._meta : {};
+}
+function pricingSourceFromRow(row) {
+  const meta = metaRecord(row);
+  return nonEmptyString(row.pricing_source) ?? nonEmptyString(meta.pricing_source) ?? nonEmptyString(meta.source);
+}
+function billingSourceFromRow(row) {
+  return nonEmptyString(row.billing_source) ?? nonEmptyString(metaRecord(row).billing_source);
+}
+function pricingConfidenceFromRow(row) {
+  const meta = metaRecord(row);
+  const value = row.pricing_confidence ?? meta.pricing_confidence ?? meta.match_confidence;
+  return value === "high" || value === "medium" || value === "low" ? value : void 0;
+}
+function longContextFromRow(value) {
+  if (!value) return void 0;
+  return {
+    thresholdTokens: value.threshold_tokens,
+    inputMultiplier: value.input_multiplier,
+    outputMultiplier: value.output_multiplier,
+    ...value.cache_read_multiplier !== void 0 ? { cacheReadMultiplier: value.cache_read_multiplier } : {},
+    ...value.cache_write_multiplier !== void 0 ? { cacheWriteMultiplier: value.cache_write_multiplier } : {}
+  };
+}
+function rateCardFromPricingRow(row) {
+  const inputPer1m = row.input_per_1m_tokens ?? (row.input_per_1k_tokens === void 0 ? void 0 : row.input_per_1k_tokens * PER_1K_TO_PER_1M);
+  const outputPer1m = row.output_per_1m_tokens ?? (row.output_per_1k_tokens === void 0 ? void 0 : row.output_per_1k_tokens * PER_1K_TO_PER_1M);
+  if (inputPer1m === void 0 || outputPer1m === void 0) return void 0;
+  const longContext = longContextFromRow(row.long_context_pricing);
+  const speedTiers = speedTiersFromRow(row);
+  return {
+    inputPer1m,
+    outputPer1m,
+    ...row.cache_read_per_1m_tokens !== void 0 ? { cacheReadPer1m: row.cache_read_per_1m_tokens } : {},
+    ...row.cache_write_per_1m_tokens !== void 0 ? { cacheWritePer1m: row.cache_write_per_1m_tokens } : {},
+    ...row.cache_write_1h_per_1m_tokens !== void 0 ? { cacheWriteLongPer1m: row.cache_write_1h_per_1m_tokens } : {},
+    ...longContext ? { longContext } : {},
+    ...speedTiers ? { speedTiers } : {}
+  };
+}
+function speedTiersFromRow(row) {
+  const entries = Object.entries(row.speed_tiers ?? {});
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(
+    entries.map(([name, tier]) => {
+      const longContext = longContextFromRow(tier.long_context_pricing);
+      return [
+        name,
+        {
+          inputPer1m: tier.input_per_1m_tokens,
+          outputPer1m: tier.output_per_1m_tokens,
+          ...tier.cache_read_per_1m_tokens !== void 0 ? { cacheReadPer1m: tier.cache_read_per_1m_tokens } : {},
+          ...tier.cache_write_per_1m_tokens !== void 0 ? { cacheWritePer1m: tier.cache_write_per_1m_tokens } : {},
+          ...tier.cache_write_1h_per_1m_tokens !== void 0 ? { cacheWriteLongPer1m: tier.cache_write_1h_per_1m_tokens } : {},
+          ...longContext ? { longContext } : {}
+        }
+      ];
+    })
+  );
+}
+function pricingRowAtSpeedTier(row, tierName) {
+  const tier = row.speed_tiers?.[tierName];
+  if (!tier) return row;
+  const { speed_tiers: _speedTiers, long_context_pricing: _longContext, ...rest } = row;
+  return {
+    ...rest,
+    input_per_1m_tokens: tier.input_per_1m_tokens,
+    output_per_1m_tokens: tier.output_per_1m_tokens,
+    cache_read_per_1m_tokens: tier.cache_read_per_1m_tokens,
+    cache_write_per_1m_tokens: tier.cache_write_per_1m_tokens,
+    cache_write_1h_per_1m_tokens: tier.cache_write_1h_per_1m_tokens,
+    input_per_1k_tokens: void 0,
+    output_per_1k_tokens: void 0,
+    ...tier.long_context_pricing ? { long_context_pricing: tier.long_context_pricing } : {}
+  };
+}
+function numberOrUndefined(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function longContextFromSnapshot(value) {
+  const thresholdTokens = numberOrUndefined(value?.threshold_tokens);
+  if (!value || thresholdTokens === void 0) return void 0;
+  const cacheReadMultiplier = numberOrUndefined(value.cache_read_multiplier);
+  const cacheWriteMultiplier = numberOrUndefined(value.cache_write_multiplier);
+  return {
+    thresholdTokens,
+    inputMultiplier: numberOrUndefined(value.input_multiplier) ?? 1,
+    outputMultiplier: numberOrUndefined(value.output_multiplier) ?? 1,
+    ...cacheReadMultiplier !== void 0 ? { cacheReadMultiplier } : {},
+    ...cacheWriteMultiplier !== void 0 ? { cacheWriteMultiplier } : {}
+  };
+}
+function ratesFromSnapshot(schema) {
+  const cacheRead = numberOrUndefined(schema.cache_read_per_1k);
+  const cacheWrite = numberOrUndefined(schema.cache_write_per_1k);
+  const cacheWriteLong = numberOrUndefined(schema.cache_write_1h_per_1k);
+  const longContext = longContextFromSnapshot(schema.long_context_pricing);
+  return {
+    inputPer1m: (schema.prompt_per_1k ?? 0) * PER_1K_TO_PER_1M,
+    outputPer1m: (schema.completion_per_1k ?? 0) * PER_1K_TO_PER_1M,
+    ...cacheRead !== void 0 ? { cacheReadPer1m: cacheRead * PER_1K_TO_PER_1M } : {},
+    ...cacheWrite !== void 0 ? { cacheWritePer1m: cacheWrite * PER_1K_TO_PER_1M } : {},
+    ...cacheWriteLong !== void 0 ? { cacheWriteLongPer1m: cacheWriteLong * PER_1K_TO_PER_1M } : {},
+    ...longContext ? { longContext } : {}
+  };
+}
+function rateCardFromSnapshotCostSchema(schema) {
+  const tiers = Object.entries(schema.speed_tiers ?? {});
+  return {
+    ...ratesFromSnapshot(schema),
+    ...tiers.length > 0 ? {
+      speedTiers: Object.fromEntries(
+        tiers.map(([name, tier]) => [name, ratesFromSnapshot(tier)])
+      )
+    } : {}
+  };
+}
+function per1kFromRates(rates) {
+  return {
+    prompt_per_1k: rates.inputPer1m / PER_1K_TO_PER_1M,
+    completion_per_1k: rates.outputPer1m / PER_1K_TO_PER_1M,
+    ...rates.cacheReadPer1m !== void 0 ? { cache_read_per_1k: rates.cacheReadPer1m / PER_1K_TO_PER_1M } : {},
+    ...rates.cacheWritePer1m !== void 0 ? { cache_write_per_1k: rates.cacheWritePer1m / PER_1K_TO_PER_1M } : {},
+    ...rates.cacheWriteLongPer1m !== void 0 ? { cache_write_1h_per_1k: rates.cacheWriteLongPer1m / PER_1K_TO_PER_1M } : {}
+  };
+}
+function snapshotCostSchemaFromRow(row) {
+  const card = rateCardFromPricingRow(row);
+  if (!card) return void 0;
+  const speedTiers = Object.entries(row.speed_tiers ?? {}).map(([name, tier]) => [
+    name,
+    {
+      ...per1kFromRates({
+        inputPer1m: tier.input_per_1m_tokens,
+        outputPer1m: tier.output_per_1m_tokens,
+        cacheReadPer1m: tier.cache_read_per_1m_tokens,
+        cacheWritePer1m: tier.cache_write_per_1m_tokens,
+        cacheWriteLongPer1m: tier.cache_write_1h_per_1m_tokens
+      }),
+      ...tier.long_context_pricing ? { long_context_pricing: tier.long_context_pricing } : {}
+    }
+  ]);
+  return {
+    ...per1kFromRates(card),
+    // A row that states per-1k rates keeps them exactly instead of a round trip.
+    ...row.input_per_1m_tokens === void 0 ? { prompt_per_1k: row.input_per_1k_tokens } : {},
+    ...row.output_per_1m_tokens === void 0 ? { completion_per_1k: row.output_per_1k_tokens } : {},
+    ...row.long_context_pricing ? { long_context_pricing: row.long_context_pricing } : {},
+    ...speedTiers.length > 0 ? { speed_tiers: Object.fromEntries(speedTiers) } : {}
+  };
+}
+function rateCardFromModelPricing(pricing) {
+  return {
+    inputPer1m: pricing.inputTokens,
+    outputPer1m: pricing.outputTokens,
+    cacheReadPer1m: pricing.cacheRead,
+    cacheWritePer1m: pricing.cacheWrite,
+    cacheWriteLongPer1m: pricing.cacheWriteLong,
+    longContext: pricing.longContextPricing,
+    speedTiers: pricing.speedTiers
+  };
+}
+
+// src/core/providers/cursor/model-discovery.ts
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync2, statSync, unlinkSync } from "fs";
+import * as fs2 from "fs/promises";
+import { homedir } from "os";
+import * as path3 from "path";
+
+// src/core/providers/cursor/model-cache-path.ts
+import path2 from "path";
+function cursorModelCacheDir(options = {}) {
+  const projectRoot = options.projectRoot ?? getBuildProjectRoot();
+  return path2.join(
+    options.modelCacheDir ?? path2.join(resolveSharedRefreshPaths().storageRoot, "cache", "models"),
+    options.inventoryContext ?? refreshInventoryContext(projectRoot),
+    "providers"
+  );
+}
+
+// src/core/providers/cursor/model-discovery.ts
+var DEFAULT_CACHE_TTL_MS = 60 * 60 * 1e3;
+function getCacheTTL() {
+  const envTTL = process.env.BUILD_CURSOR_CACHE_TTL_MS;
+  if (envTTL) {
+    const parsed = Number.parseInt(envTTL, 10);
+    if (!Number.isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return DEFAULT_CACHE_TTL_MS;
+}
+function getDefaultCacheDir() {
+  return cursorModelCacheDir();
+}
+function getCacheFilePath(cacheDir) {
+  return path3.join(cacheDir, "cursor-models.json");
+}
+function createCursorDiscoveryChildEnv() {
+  const env = createScopedProviderChildEnv("cursor");
+  const apiKey = getCursorApiKeyFromEnv();
+  if (apiKey) {
+    env.CURSOR_API_KEY = apiKey;
+  }
+  return env;
+}
+function getCursorApiKeyFromEnv() {
+  const candidate = process.env.CURSOR_API_KEY?.trim();
+  if (candidate && candidate.length > 0) return candidate;
+  try {
+    const credPath = path3.join(homedir(), ".build", "credentials", "cursor.json");
+    const raw = readFileSync2(credPath, "utf-8");
+    const creds = JSON.parse(raw);
+    const key = (typeof creds.apiKey === "string" ? creds.apiKey : void 0) ?? (typeof creds.api_key === "string" ? creds.api_key : void 0);
+    if (key && key.trim().length > 0) return key.trim();
+  } catch {
+  }
+  return null;
+}
+function inferCursorModelProvider(modelId) {
+  const normalized = modelId.trim().toLowerCase();
+  if (normalized === "auto" || normalized === "cheetah" || normalized === "grok" || normalized.startsWith("grok-") || normalized.startsWith("composer") || normalized.startsWith("cursor-grok-") || normalized.startsWith("cursor-")) {
+    return "cursor";
+  }
+  if (normalized.startsWith("claude") || normalized.startsWith("sonnet") || normalized.startsWith("opus") || normalized.startsWith("haiku")) {
+    return "claude";
+  }
+  if (normalized.startsWith("gpt") || normalized.startsWith("o1") || normalized.startsWith("o3")) {
+    return "codex";
+  }
+  return "unknown";
+}
+function normalizeApiModels(payload) {
+  const candidates = [];
+  const collect = (value) => {
+    if (!value) return;
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed) candidates.push(trimmed);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const entry of value) collect(entry);
+      return;
+    }
+    if (typeof value === "object") {
+      const obj = value;
+      const idCandidate = typeof obj.id === "string" && obj.id || typeof obj.model === "string" && obj.model || typeof obj.slug === "string" && obj.slug || typeof obj.name === "string" && obj.name;
+      if (idCandidate) {
+        candidates.push(idCandidate.trim());
+      }
+    }
+  };
+  if (Array.isArray(payload)) {
+    collect(payload);
+  } else if (payload && typeof payload === "object") {
+    const obj = payload;
+    collect(obj.models);
+    collect(obj.data);
+    collect(obj.results);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  for (const id of candidates) {
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    models.push({
+      id,
+      provider: inferCursorModelProvider(id),
+      isDefault: id === "auto"
+    });
+  }
+  return models;
+}
+function isBareCursorModelIdLine(value) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value)) {
+    return false;
+  }
+  const normalized = value.toLowerCase();
+  return normalized.includes("-") || normalized === "auto" || normalized === "cheetah" || normalized === "grok";
+}
+function parseCursorModelOutput(output) {
+  const trimmed = output.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const fromJson = normalizeApiModels(JSON.parse(trimmed));
+      if (fromJson.length > 0) {
+        return fromJson;
+      }
+    } catch {
+    }
+  }
+  const models = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = output.split("\n");
+  let currentProvider = "unknown";
+  for (const line of lines) {
+    const plainMatch = line.match(/^([a-zA-Z0-9][a-zA-Z0-9._-]*)\s+-\s+(.+)/);
+    if (plainMatch) {
+      const modelId = (plainMatch[1] ?? "").trim();
+      const displayName = (plainMatch[2] ?? "").trim();
+      if (modelId && !seen.has(modelId)) {
+        seen.add(modelId);
+        models.push({
+          id: modelId,
+          provider: inferCursorModelProvider(modelId),
+          displayName: displayName.length > 0 ? displayName : void 0,
+          isDefault: line.includes("(default)"),
+          isLegacy: false
+        });
+      }
+      continue;
+    }
+    const bareId = line.trim();
+    if (isBareCursorModelIdLine(bareId) && !seen.has(bareId)) {
+      seen.add(bareId);
+      models.push({
+        id: bareId,
+        provider: inferCursorModelProvider(bareId),
+        isDefault: bareId === "auto",
+        isLegacy: false
+      });
+      continue;
+    }
+    if (line.includes("### **Claude**")) {
+      currentProvider = "claude";
+      continue;
+    }
+    if (line.includes("### **Codex**")) {
+      currentProvider = "codex";
+      continue;
+    }
+    if (line.includes("### **Cursor**")) {
+      currentProvider = "cursor";
+      continue;
+    }
+    const bulletMatch = line.match(/^[-*]\s+(.+)/);
+    if (bulletMatch) {
+      const content = bulletMatch[1];
+      if (!content) continue;
+      const isDefault = line.includes("(default)");
+      const isLegacy = line.toLowerCase().includes("legacy");
+      const backtickMatches = content.matchAll(/`([^`]+)`/g);
+      for (const match of backtickMatches) {
+        const modelId = match[1]?.trim();
+        if (modelId && modelId.toLowerCase() !== "legacy:" && !seen.has(modelId)) {
+          seen.add(modelId);
+          models.push({
+            id: modelId,
+            provider: currentProvider === "unknown" ? inferCursorModelProvider(modelId) : currentProvider,
+            isDefault,
+            isLegacy
+          });
+        }
+      }
+    }
+  }
+  return models;
+}
+async function executeCursorCLI(cliCommand) {
+  const { command: resolvedCommand, prefixArgs } = cliCommand ?? (await import("./resolve-provider-cli-ZEXVZKET.js")).resolveProviderCliCommand("cursor");
+  try {
+    let version;
+    try {
+      const sandboxed = wrapWithSandbox({
+        workingDir: process.cwd(),
+        command: resolvedCommand,
+        args: [...prefixArgs, "--version"],
+        providerName: "Cursor"
+      });
+      const versionOutput = execFileSync(sandboxed.command, sandboxed.args, {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: createCursorDiscoveryChildEnv()
+      }).trim();
+      version = versionOutput;
+    } catch {
+    }
+    const listingArgSets = [
+      [...prefixArgs, "models"],
+      [...prefixArgs, "--list-models"]
+    ];
+    let lastError;
+    for (const listingArgs of listingArgSets) {
+      try {
+        const sandboxed = wrapWithSandbox({
+          workingDir: process.cwd(),
+          command: resolvedCommand,
+          args: listingArgs,
+          providerName: "Cursor"
+        });
+        const output = execFileSync(sandboxed.command, sandboxed.args, {
+          encoding: "utf-8",
+          timeout: 1e4,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: createCursorDiscoveryChildEnv()
+        });
+        const models = parseCursorModelOutput(output);
+        if (models.length > 0) {
+          return { models, version };
+        }
+        lastError = new Error("No models found in cursor-agent models output");
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
+    }
+    throw lastError ?? new Error("No models found in cursor-agent models output");
+  } catch (error) {
+    throw new Error(
+      `Failed to execute cursor-agent CLI: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCursorApi(apiKey) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 12e3);
+  try {
+    const auth = Buffer.from(`${apiKey}:`, "utf8").toString("base64");
+    const response = await fetch("https://api.cursor.com/v0/models", {
+      method: "GET",
+      headers: {
+        Authorization: `Basic ${auth}`,
+        Accept: "application/json"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${body || response.statusText}`);
+    }
+    const parsed = await response.json();
+    const models = normalizeApiModels(parsed);
+    if (models.length === 0) {
+      throw new Error("No models found in Cursor API response");
+    }
+    return { models };
+  } catch (error) {
+    throw new Error(
+      `Failed to fetch Cursor API models: ${error instanceof Error ? error.message : String(error)}`
+    );
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function readCache(cacheFilePath) {
+  try {
+    const content = await fs2.readFile(cacheFilePath, "utf-8");
+    const cached = JSON.parse(content);
+    if (!cached.models || !Array.isArray(cached.models) || !cached.timestamp) {
+      return null;
+    }
+    const age = Date.now() - cached.timestamp;
+    const ttl = getCacheTTL();
+    if (age > ttl) {
+      return null;
+    }
+    return cached;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cacheFilePath, result) {
+  try {
+    const cacheDir = path3.dirname(cacheFilePath);
+    await fs2.mkdir(cacheDir, { recursive: true });
+    await fs2.writeFile(cacheFilePath, JSON.stringify(result, null, 2), "utf-8");
+  } catch (error) {
+    console.warn(
+      `[Cursor Model Discovery] Failed to write cache: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function discoverCursorModels(options) {
+  const { forceRefresh = false, cacheDir = getDefaultCacheDir(), cliOnly = false } = options || {};
+  const cacheFilePath = getCacheFilePath(cacheDir);
+  if (!forceRefresh) {
+    const cached = await readCache(cacheFilePath);
+    if (cached) {
+      return cached;
+    }
+  }
+  const apiKey = cliOnly ? null : getCursorApiKeyFromEnv();
+  if (apiKey) {
+    try {
+      const { models } = await executeCursorApi(apiKey);
+      const result = {
+        models,
+        source: "api",
+        timestamp: Date.now(),
+        canonicalMappings: buildCanonicalMappings(models)
+      };
+      rememberAuthoritativeDiscovery(cacheFilePath, result);
+      await writeCache(cacheFilePath, result);
+      return result;
+    } catch (error) {
+      console.warn(
+        `[Cursor Model Discovery] API discovery failed, falling back to CLI: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  try {
+    const { models, version } = await executeCursorCLI(options?.cliCommand);
+    const result = {
+      models,
+      source: "cli",
+      timestamp: Date.now(),
+      cliVersion: version,
+      canonicalMappings: buildCanonicalMappings(models)
+    };
+    rememberAuthoritativeDiscovery(cacheFilePath, result);
+    await writeCache(cacheFilePath, result);
+    return result;
+  } catch (error) {
+    console.warn(
+      `[Cursor Model Discovery] CLI execution failed, using fallback: ${error instanceof Error ? error.message : String(error)}`
+    );
+    const result = {
+      models: CURSOR_KNOWN_MODELS,
+      source: "fallback",
+      timestamp: Date.now(),
+      canonicalMappings: buildCanonicalMappings(CURSOR_KNOWN_MODELS)
+    };
+    return result;
+  }
+}
+var cachedSnapshot = null;
+var cachedMappingSnapshot = null;
+function uniqueDiscoveredModelIds(models) {
+  return Array.from(
+    new Set(
+      models.map((model) => model?.id).filter((id) => typeof id === "string" && id.trim().length > 0)
+    )
+  );
+}
+function rememberAuthoritativeDiscovery(cachePath, result) {
+  if (result.source !== "api" && result.source !== "cli") {
+    return;
+  }
+  cachedSnapshot = {
+    cachePath,
+    mtimeMs: Date.now(),
+    modelIds: uniqueDiscoveredModelIds(result.models)
+  };
+  cachedMappingSnapshot = {
+    cachePath,
+    mtimeMs: Date.now(),
+    mappings: { ...result.canonicalMappings ?? {} }
+  };
+}
+function getCachedCursorModelIds(options) {
+  const cacheDir = options?.cacheDir ?? getDefaultCacheDir();
+  const cachePath = getCacheFilePath(cacheDir);
+  const ttl = getCacheTTL();
+  try {
+    const stat = statSync(cachePath);
+    if (Date.now() - stat.mtimeMs > ttl) {
+      if (cachedSnapshot?.cachePath === cachePath) {
+        cachedSnapshot = null;
+      }
+      return [];
+    }
+    if (cachedSnapshot && cachedSnapshot.cachePath === cachePath && cachedSnapshot.mtimeMs === stat.mtimeMs) {
+      return [...cachedSnapshot.modelIds];
+    }
+    const raw = readFileSync2(cachePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const unique = Array.isArray(parsed?.models) ? uniqueDiscoveredModelIds(parsed.models) : [];
+    cachedSnapshot = {
+      cachePath,
+      mtimeMs: stat.mtimeMs,
+      modelIds: unique
+    };
+    return [...unique];
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      if (cachedSnapshot?.cachePath === cachePath) {
+        return [...cachedSnapshot.modelIds];
+      }
+      return [];
+    }
+    if (cachedSnapshot?.cachePath === cachePath) {
+      cachedSnapshot = null;
+    }
+    try {
+      unlinkSync(cachePath);
+    } catch {
+    }
+    logWarning(
+      "cursor-model-discovery",
+      `Ignoring corrupt model cache at ${cachePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return [];
+  }
+}
+var LEGACY_CURSOR_CLAUDE_PATTERN = /^claude-(\d+(?:\.\d+)?)-(\w+?)(?:-([\w-]+))?$/;
+var CURRENT_CURSOR_CLAUDE_PATTERN = /^claude-(opus|sonnet|fable)-(\d+(?:-\d+)*)(?:-([\w-]+))?$/;
+function parseCursorClaudeModelId(modelId) {
+  const current = modelId.match(CURRENT_CURSOR_CLAUDE_PATTERN);
+  if (current) {
+    return {
+      tier: current[1] ?? "",
+      version: (current[2] ?? "").replaceAll("-", "."),
+      suffix: current[3] ?? ""
+    };
+  }
+  const legacy = modelId.match(LEGACY_CURSOR_CLAUDE_PATTERN);
+  if (!legacy) return void 0;
+  return { version: legacy[1] ?? "", tier: legacy[2] ?? "", suffix: legacy[3] ?? "" };
+}
+function buildCanonicalMappings(models) {
+  const mappings = {};
+  const canonicalRankings = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const parsed = parseCursorClaudeModelId(model.id);
+    if (!parsed) continue;
+    const { version, tier, suffix } = parsed;
+    if (suffix.includes("thinking")) continue;
+    const canonical = `${tier}-${version}`;
+    const baseRank = tier === "opus" ? ["high", "", "medium", "low", "xhigh", "max"].indexOf(suffix) : ["medium", "", "low", "high", "xhigh", "max"].indexOf(suffix);
+    const rank = baseRank === -1 ? Number.MAX_SAFE_INTEGER : baseRank;
+    if (suffix === "1m") {
+      const canonical1m = `${tier}-${version}-1m`;
+      if (!mappings[canonical1m]) {
+        mappings[canonical1m] = model.id;
+      }
+    } else {
+      const existingRank = canonicalRankings.get(canonical);
+      if (existingRank === void 0 || rank < existingRank) {
+        mappings[canonical] = model.id;
+        canonicalRankings.set(canonical, rank);
+      }
+    }
+  }
+  return mappings;
+}
+function getCachedCanonicalMappings(options) {
+  const cacheDir = options?.cacheDir ?? getDefaultCacheDir();
+  const cachePath = getCacheFilePath(cacheDir);
+  const ttl = getCacheTTL();
+  try {
+    const stat = statSync(cachePath);
+    if (Date.now() - stat.mtimeMs > ttl) {
+      if (cachedMappingSnapshot?.cachePath === cachePath) cachedMappingSnapshot = null;
+      return {};
+    }
+    if (cachedMappingSnapshot && cachedMappingSnapshot.cachePath === cachePath && cachedMappingSnapshot.mtimeMs === stat.mtimeMs) {
+      return { ...cachedMappingSnapshot.mappings };
+    }
+    const raw = readFileSync2(cachePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const mappings = { ...parsed?.canonicalMappings ?? {} };
+    cachedMappingSnapshot = { cachePath, mtimeMs: stat.mtimeMs, mappings };
+    return { ...mappings };
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      if (cachedMappingSnapshot?.cachePath === cachePath) {
+        return { ...cachedMappingSnapshot.mappings };
+      }
+      return {};
+    }
+    if (cachedMappingSnapshot?.cachePath === cachePath) cachedMappingSnapshot = null;
+    try {
+      unlinkSync(cachePath);
+    } catch {
+    }
+    console.warn(
+      `[cursor-model-discovery] Ignoring corrupt model cache at ${cachePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {};
+  }
+}
+
+// src/core/providers/cursor/config.ts
+var CURSOR_FALLBACK_MODELS = CURSOR_KNOWN_MODELS.map((m) => m.id);
+var GROK_FAST_PRICE_MODELS = {
+  "4.7": "grok-4.7-build-fast"
+};
+
+// src/core/providers/cursor/model-price-target.ts
+var EFFORT_SUFFIX = /-(?:extra-high|xhigh|none|minimal|low|medium|high|max)$/;
+var MAX_SUFFIX_STRIPS = 4;
+var MAKER_ROUTE_PREFIX = { kimi: "moonshotai", glm: "z-ai" };
+function stripVariantSuffixes(modelId) {
+  let base = modelId;
+  let fast = false;
+  for (let i = 0; i < MAX_SUFFIX_STRIPS; i++) {
+    if (base.endsWith("-fast")) {
+      fast = true;
+      base = base.slice(0, -"-fast".length);
+    } else if (base.endsWith("-thinking")) {
+      base = base.slice(0, -"-thinking".length);
+    } else if (EFFORT_SUFFIX.test(base)) {
+      base = base.replace(EFFORT_SUFFIX, "");
+    } else {
+      break;
+    }
+  }
+  return { base, fast };
+}
+function resolveCursorMakerPriceTarget(modelId, hasRow = () => false) {
+  const { base, fast } = stripVariantSuffixes(modelId.toLowerCase());
+  const fastTier = fast ? { speed_tier: "fast" } : {};
+  const cursorFastRow = `${base}-fast`;
+  if (fast && hasRow("cursor", cursorFastRow)) {
+    return { provider: "cursor", model: cursorFastRow };
+  }
+  const grok = /^(?:cursor-)?grok-(\d+\.\d+)$/.exec(base);
+  if (grok) {
+    const version = grok[1];
+    const fastModel = fast && version ? GROK_FAST_PRICE_MODELS[version] : void 0;
+    if (fastModel) return { provider: "grok", model: fastModel };
+    return { provider: "grok", model: `grok-${version}` };
+  }
+  if (/^claude-(?:opus|sonnet|haiku|fable)-\d+(?:-\d+)?$/.test(base)) {
+    return { provider: "claude", model: base, ...fastTier };
+  }
+  const legacyClaude = /^claude-(\d+)(?:\.(\d+))?-(opus|sonnet|haiku)$/.exec(base);
+  if (legacyClaude) {
+    const [, major, minor, family] = legacyClaude;
+    const version = minor === void 0 ? major : `${major}-${minor}`;
+    return { provider: "claude", model: `claude-${family}-${version}`, ...fastTier };
+  }
+  if (/^gpt-\d/.test(base)) {
+    return { provider: "codex", model: base, ...fastTier };
+  }
+  if (/^gemini-/.test(base)) {
+    const preview = `${base}-preview`;
+    if (!hasRow("gemini", base) && hasRow("gemini", preview)) {
+      return {
+        provider: "gemini",
+        model: preview,
+        note: `${base} priced at the preview rate pending GA`
+      };
+    }
+    return { provider: "gemini", model: base };
+  }
+  const makerRoute = /^(kimi|glm)-/.exec(base);
+  if (makerRoute) {
+    const prefix = MAKER_ROUTE_PREFIX[makerRoute[1] ?? ""];
+    return prefix ? { provider: "openrouter", model: `${prefix}/${base}` } : null;
+  }
+  return null;
+}
+
+// src/core/providers/model-update/pricing/passthrough-resolver.ts
+var DEFAULT_CONFIG = {
+  maxDepth: 5,
+  strict: false
+};
+var DEFAULT_CURSOR_MAPPINGS = {
+  // Claude models
+  "sonnet-4.6": { provider: "claude", model: "claude-sonnet-4-6" },
+  "sonnet-4-6": { provider: "claude", model: "claude-sonnet-4-6" },
+  "claude-sonnet-4-6": { provider: "claude", model: "claude-sonnet-4-6" },
+  "sonnet-4.5": { provider: "claude", model: "claude-sonnet-4-5" },
+  "sonnet-4-5": { provider: "claude", model: "claude-sonnet-4-5" },
+  "claude-sonnet-4-5": { provider: "claude", model: "claude-sonnet-4-5" },
+  "opus-4.6": { provider: "claude", model: "claude-opus-4-6" },
+  "opus-4-6": { provider: "claude", model: "claude-opus-4-6" },
+  "claude-opus-4-6": { provider: "claude", model: "claude-opus-4-6" },
+  "haiku-4.5": { provider: "claude", model: "claude-haiku-4-5" },
+  "haiku-4-5": { provider: "claude", model: "claude-haiku-4-5" },
+  "claude-haiku-4-5": { provider: "claude", model: "claude-haiku-4-5" },
+  "claude-haiku-4-5-20251001": { provider: "claude", model: "claude-haiku-4-5" },
+  "opus-4.5": { provider: "claude", model: "claude-opus-4-5" },
+  "opus-4-5": { provider: "claude", model: "claude-opus-4-5" },
+  "claude-opus-4-5": { provider: "claude", model: "claude-opus-4-5" },
+  "claude-3.5-sonnet": { provider: "claude", model: "claude-3-5-sonnet" },
+  "claude-3-5-sonnet": { provider: "claude", model: "claude-3-5-sonnet" },
+  // OpenAI models
+  "gpt-5": { provider: "codex", model: "gpt-5" },
+  "gpt-5-mini": { provider: "codex", model: "gpt-5-mini" },
+  "gpt-4o": { provider: "codex", model: "gpt-4o" },
+  "gpt-4o-mini": { provider: "codex", model: "gpt-4o-mini" },
+  "gpt-4-turbo": { provider: "codex", model: "gpt-4-turbo" },
+  o1: { provider: "codex", model: "o1" },
+  "o1-mini": { provider: "codex", model: "o1-mini" },
+  "o1-pro": { provider: "codex", model: "o1-pro" },
+  o3: { provider: "codex", model: "o3" },
+  "o3-mini": { provider: "codex", model: "o3-mini" },
+  // Gemini models
+  "gemini-2.5-pro": { provider: "gemini", model: "gemini-2.5-pro" },
+  "gemini-2.5-flash": { provider: "gemini", model: "gemini-2.5-flash" },
+  "gemini-2.0-flash": { provider: "gemini", model: "gemini-2.0-flash" },
+  "gemini-1.5-pro": { provider: "gemini", model: "gemini-1.5-pro" },
+  "gemini-1.5-flash": { provider: "gemini", model: "gemini-1.5-flash" }
+};
+var PassthroughResolver = class {
+  config;
+  customMappings = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Register custom pass-through mappings for a provider.
+   */
+  registerMappings(providerId, mappings) {
+    this.customMappings.set(providerId.toLowerCase(), mappings);
+  }
+  /**
+   * Resolve pricing for a model, following pass-through chains.
+   */
+  resolvePricing(providerId, modelId, depth = 0, visited = /* @__PURE__ */ new Set()) {
+    const key = `${providerId}:${modelId}`;
+    if (visited.has(key)) {
+      return {
+        status: "unknown",
+        modelId,
+        reason: `Cycle detected in pass-through chain: ${Array.from(visited).join(" -> ")} -> ${key}`
+      };
+    }
+    if (depth >= this.config.maxDepth) {
+      return {
+        status: "unknown",
+        modelId,
+        reason: `Max pass-through depth (${this.config.maxDepth}) exceeded`
+      };
+    }
+    visited.add(key);
+    const pricing = this.getDirectPricing(providerId, modelId);
+    if (pricing) {
+      return {
+        status: "resolved",
+        provider: providerId,
+        model: modelId,
+        pricing: pricing.pricing,
+        source: pricing.source
+      };
+    }
+    const passthrough = this.getPassthroughTarget(providerId, modelId);
+    if (passthrough) {
+      const upstream = this.resolvePricing(
+        passthrough.provider,
+        passthrough.model,
+        depth + 1,
+        visited
+      );
+      return upstream.status === "resolved" ? { ...upstream, pricing: applyTargetToPricing(upstream.pricing, passthrough) } : upstream;
+    }
+    return {
+      status: "unknown",
+      modelId,
+      reason: `No pricing found for ${providerId}:${modelId}`
+    };
+  }
+  /**
+   * Get pass-through target for a model, if configured. Names the upstream row
+   * without resolving its rates, for callers that read rows from their own
+   * registry snapshot: such a caller passes that registry's `pricing` block so
+   * the lookup neither reads nor clones the live registry per model.
+   * `hasPricingRow` answers which rows exist for the same reason, defaulting to
+   * the live registry.
+   */
+  getPassthroughTarget(providerId, modelId, providerPricing, hasPricingRow = registryHasPricingRow) {
+    const normalizedProvider = providerId.toLowerCase();
+    const normalizedModel = modelId.toLowerCase();
+    const customMap = this.customMappings.get(normalizedProvider);
+    const customTarget = customMap?.[normalizedModel];
+    if (customTarget) {
+      return customTarget;
+    }
+    try {
+      const pricingConfig = providerPricing ?? ProviderRegistry.getProviderConfig(normalizedProvider)?.pricing;
+      if (pricingConfig && "_meta" in pricingConfig) {
+        const meta = pricingConfig._meta;
+        const yamlTarget = meta?.passthrough_map?.[normalizedModel];
+        if (yamlTarget) {
+          return yamlTarget;
+        }
+      }
+      const providerTarget = this.resolveProviderPassthroughTarget(pricingConfig, normalizedModel);
+      if (providerTarget) {
+        return providerTarget;
+      }
+      if (pricingConfig && "passthrough_map" in pricingConfig) {
+        const map = pricingConfig.passthrough_map;
+        const directTarget = map[normalizedModel];
+        if (directTarget) {
+          return directTarget;
+        }
+      }
+    } catch {
+    }
+    if (normalizedProvider === "cursor") {
+      return DEFAULT_CURSOR_MAPPINGS[normalizedModel] ?? resolveCursorMakerPriceTarget(normalizedModel, hasPricingRow);
+    }
+    return null;
+  }
+  /** Provider-level route: the first-class `pricing.passthrough`, else the legacy `_meta` keys. */
+  resolveProviderPassthroughTarget(pricingConfig, normalizedModel) {
+    const meta = pricingConfig?._meta ?? {};
+    const provider = pricingConfig?.passthrough?.provider ?? meta.passthrough_provider;
+    if (!provider) {
+      return null;
+    }
+    return {
+      provider,
+      model: stripConfiguredRoutePrefixes(
+        normalizedModel,
+        pricingConfig?.passthrough?.strip_prefixes ?? meta.passthrough_strip_prefixes
+      )
+    };
+  }
+  /**
+   * Get direct pricing for a model from the shared metadata resolver.
+   */
+  getDirectPricing(providerId, modelId) {
+    try {
+      const resolvedPricing = ModelMetadataResolver.getPricing(providerId, modelId);
+      if (!resolvedPricing) {
+        return null;
+      }
+      const { modelPricing: pricing } = resolvedPricing;
+      const card = rateCardFromPricingRow(pricing);
+      if (!card) {
+        return null;
+      }
+      return {
+        pricing: {
+          input_per_1m_tokens: formatUsdPer1m(card.inputPer1m),
+          output_per_1m_tokens: formatUsdPer1m(card.outputPer1m),
+          cache_read_per_1m_tokens: card.cacheReadPer1m === void 0 ? void 0 : formatUsdPer1m(card.cacheReadPer1m),
+          cache_write_per_1m_tokens: card.cacheWritePer1m === void 0 ? void 0 : formatUsdPer1m(card.cacheWritePer1m),
+          cache_write_1h_per_1m_tokens: card.cacheWriteLongPer1m === void 0 ? void 0 : formatUsdPer1m(card.cacheWriteLongPer1m),
+          long_context_pricing: pricing.long_context_pricing,
+          speed_tiers: pricing.speed_tiers,
+          context_window: pricing.context_window,
+          features: pricing.features,
+          notes: pricing.notes
+        },
+        source: pricingSourceFromRow(pricing) ?? "manual"
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a provider uses pass-through pricing.
+   */
+  isPassthroughProvider(providerId) {
+    const normalizedProvider = providerId.toLowerCase();
+    if (this.customMappings.has(normalizedProvider)) {
+      return true;
+    }
+    try {
+      const providerConfig = ProviderRegistry.getProviderConfig(normalizedProvider);
+      const pricingConfig = providerConfig?.pricing;
+      if (pricingConfig?.passthrough) {
+        return true;
+      }
+      if (pricingConfig && "_meta" in pricingConfig) {
+        const meta = pricingConfig._meta;
+        return meta?.pricing_source === "passthrough";
+      }
+    } catch {
+    }
+    return normalizedProvider === "cursor";
+  }
+  /**
+   * Get all pass-through mappings for a provider.
+   */
+  getMappings(providerId) {
+    const normalizedProvider = providerId.toLowerCase();
+    const mappings = {};
+    const customMap = this.customMappings.get(normalizedProvider);
+    if (customMap) {
+      Object.assign(mappings, customMap);
+    }
+    try {
+      const providerConfig = ProviderRegistry.getProviderConfig(normalizedProvider);
+      const pricingConfig = providerConfig?.pricing;
+      if (pricingConfig && "_meta" in pricingConfig) {
+        const meta = pricingConfig._meta;
+        if (meta?.passthrough_map) {
+          Object.assign(mappings, meta.passthrough_map);
+        }
+      }
+      if (pricingConfig && "passthrough_map" in pricingConfig) {
+        const map = pricingConfig.passthrough_map;
+        Object.assign(mappings, map);
+      }
+    } catch {
+    }
+    if (normalizedProvider === "cursor") {
+      return { ...DEFAULT_CURSOR_MAPPINGS, ...mappings };
+    }
+    return mappings;
+  }
+};
+function registryHasPricingRow(providerId, modelId) {
+  try {
+    return ProviderRegistry.getProviderConfig(providerId)?.pricing?.models?.[modelId] !== void 0;
+  } catch {
+    return false;
+  }
+}
+function stripConfiguredRoutePrefixes(modelId, prefixes) {
+  if (!prefixes || prefixes.length === 0) {
+    return modelId;
+  }
+  const removablePrefixes = new Set(prefixes.map((prefix) => prefix.toLowerCase().trim()));
+  const segments = modelId.split("/").filter(Boolean);
+  while (segments.length > 2 && removablePrefixes.has(segments[0]?.toLowerCase() ?? "")) {
+    segments.shift();
+  }
+  return segments.join("/") || modelId;
+}
+function formatUsdPer1m(value) {
+  const [whole = "0", fraction = ""] = value.toFixed(6).split(".");
+  return `${whole}.${fraction.replace(/0+$/, "").padEnd(2, "0")}`;
+}
+function joinPricingNotes(...notes) {
+  const present = notes.filter((note) => Boolean(note));
+  return present.length > 0 ? present.join(" ") : void 0;
+}
+function applyTargetToPricing(pricing, target) {
+  const noted = target.note ? { ...pricing, notes: joinPricingNotes(pricing.notes, target.note) } : pricing;
+  const tierName = target.speed_tier;
+  if (!tierName) {
+    return noted;
+  }
+  const tier = pricing.speed_tiers?.[tierName];
+  if (!tier) {
+    return {
+      ...noted,
+      routed_speed_tier: { requested: tierName, applied: "standard" },
+      notes: joinPricingNotes(noted.notes, `${tierName} requested, priced at standard.`)
+    };
+  }
+  const unpublishedAbove = tier.long_context_pricing ? void 0 : pricing.long_context_pricing?.threshold_tokens;
+  return {
+    ...noted,
+    input_per_1m_tokens: formatUsdPer1m(tier.input_per_1m_tokens),
+    output_per_1m_tokens: formatUsdPer1m(tier.output_per_1m_tokens),
+    cache_read_per_1m_tokens: tier.cache_read_per_1m_tokens === void 0 ? void 0 : formatUsdPer1m(tier.cache_read_per_1m_tokens),
+    cache_write_per_1m_tokens: tier.cache_write_per_1m_tokens === void 0 ? void 0 : formatUsdPer1m(tier.cache_write_per_1m_tokens),
+    cache_write_1h_per_1m_tokens: tier.cache_write_1h_per_1m_tokens === void 0 ? void 0 : formatUsdPer1m(tier.cache_write_1h_per_1m_tokens),
+    long_context_pricing: tier.long_context_pricing,
+    speed_tiers: void 0,
+    routed_speed_tier: {
+      requested: tierName,
+      applied: tierName,
+      ...unpublishedAbove === void 0 ? {} : { unpublishedLongContextAboveTokens: unpublishedAbove }
+    }
+  };
+}
+var passthroughResolver = new PassthroughResolver();
+function resolvePassthroughPricing(providerId, modelId) {
+  return passthroughResolver.resolvePricing(providerId, modelId);
+}
+
+// src/telemetry/worker.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/cost-tracking/cache-write-duration.ts
+var CACHE_WRITE_LONG_TOKENS_DIMENSION = "cacheWriteLongTokens";
+function clampLongCacheWriteTokens(cacheWriteTokens, longTokens) {
+  if (longTokens === void 0 || !Number.isFinite(longTokens) || longTokens <= 0) return 0;
+  return Math.min(longTokens, Math.max(0, cacheWriteTokens ?? 0));
+}
+function readLongCacheWriteTokens(extraDimensionsJson) {
+  if (!extraDimensionsJson) return void 0;
+  try {
+    const value = JSON.parse(extraDimensionsJson)?.[CACHE_WRITE_LONG_TOKENS_DIMENSION];
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cacheWriteUsd(writeRate, longRate, cacheWriteTokens, longTokens) {
+  const long = clampLongCacheWriteTokens(cacheWriteTokens, longTokens);
+  const effectiveLongRate = longRate ?? writeRate;
+  return (writeRate === void 0 ? 0 : (cacheWriteTokens - long) / 1e6 * writeRate) + (effectiveLongRate === void 0 ? 0 : long / 1e6 * effectiveLongRate);
+}
+
+// src/cost-tracking/usage-granularity.ts
+function usageGranularityFromEventSemantics(eventSemantics) {
+  return eventSemantics === "final" ? "request" : "run_aggregate";
+}
+function longContextContextTokens(usage) {
+  const cacheReadTokens = usage.cacheReadIncludedInInput ? 0 : usage.cacheReadTokens ?? 0;
+  const cacheWriteTokens = usage.cacheWriteIncludedInInput ? 0 : usage.cacheWriteTokens ?? 0;
+  return usage.inputTokens + cacheReadTokens + cacheWriteTokens;
+}
+
+// src/cost-tracking/request-long-context.ts
+var MAX_REQUEST_EVIDENCE = 1e3;
+function boundRequestEvidence(requests, complete = true) {
+  if (requests.length === 0) return void 0;
+  const truncated = requests.length > MAX_REQUEST_EVIDENCE;
+  return {
+    requests: truncated ? requests.slice(0, MAX_REQUEST_EVIDENCE) : requests,
+    complete: complete && !truncated
+  };
+}
+var STATUS_PRECEDENCE = ["applied", "below_threshold", "not_defined"];
+function sumOf(requests, pick) {
+  return requests.reduce((total, request) => total + pick(request), 0);
+}
+function premiumIncrement(rates, usage, request) {
+  const premium = rates.longContext;
+  if (!premium) return { inputUsd: 0, outputUsd: 0, cacheUsd: 0 };
+  const cacheRead = request.cachedInputTokens;
+  const cacheWrite = request.cacheWriteTokens;
+  const cacheWriteLong = clampLongCacheWriteTokens(cacheWrite, request.cacheWriteLongTokens);
+  const uncached = Math.max(0, request.inputTokens - cacheRead - cacheWrite);
+  const inputBilled = uncached + (rates.cacheReadPer1m === void 0 && usage.cacheReadIncludedInInput ? cacheRead : 0);
+  const extra = (multiplier, rate, tokens) => rate === void 0 ? 0 : ((multiplier ?? 1) - 1) * rate * tokens / 1e6;
+  return {
+    inputUsd: extra(premium.inputMultiplier, rates.inputPer1m, inputBilled),
+    outputUsd: extra(premium.outputMultiplier, rates.outputPer1m, request.outputTokens),
+    cacheUsd: extra(premium.cacheReadMultiplier, rates.cacheReadPer1m, cacheRead) + extra(premium.cacheWriteMultiplier, rates.cacheWritePer1m, cacheWrite - cacheWriteLong) + extra(
+      premium.cacheWriteMultiplier,
+      rates.cacheWriteLongPer1m ?? rates.cacheWritePer1m,
+      cacheWriteLong
+    )
+  };
+}
+function assessRequestLongContext(standard, ratesFor, usage, evidence) {
+  const requests = evidence?.requests ?? [];
+  if (!evidence || requests.length === 0) return void 0;
+  const runPrompt = longContextContextTokens(usage);
+  const covered = [
+    [sumOf(requests, (r) => r.inputTokens), runPrompt],
+    [sumOf(requests, (r) => r.outputTokens), usage.outputTokens],
+    [sumOf(requests, (r) => r.cachedInputTokens), usage.cacheReadTokens ?? 0],
+    [sumOf(requests, (r) => r.cacheWriteTokens), usage.cacheWriteTokens ?? 0]
+  ];
+  if (covered.some(([requested, run]) => requested > run)) {
+    return {
+      inputUsd: 0,
+      outputUsd: 0,
+      cacheUsd: 0,
+      status: "not_assessed",
+      incompleteReason: "request usage exceeds the run usage"
+    };
+  }
+  const reasons = [];
+  if (!evidence.complete) reasons.push("request evidence is incomplete");
+  if (covered.some(([requested, run]) => requested < run)) {
+    reasons.push("request evidence covers only part of the run usage");
+  }
+  const total = { inputUsd: 0, outputUsd: 0, cacheUsd: 0 };
+  const statuses = /* @__PURE__ */ new Set();
+  const unpriceableTiers = /* @__PURE__ */ new Set();
+  for (const request of requests) {
+    const { rates, tier, unresolvedTier } = ratesFor(request.speed);
+    if (unresolvedTier && standard.longContext && request.inputTokens > standard.longContext.thresholdTokens) {
+      unpriceableTiers.add(unresolvedTier);
+      continue;
+    }
+    const premium = rates.longContext;
+    if (!premium) {
+      if (rates !== standard && standard.longContext && request.inputTokens > standard.longContext.thresholdTokens) {
+        unpriceableTiers.add(tier);
+      } else {
+        statuses.add("not_defined");
+      }
+      continue;
+    }
+    if (request.inputTokens > premium.thresholdTokens) {
+      statuses.add("applied");
+      const increment = premiumIncrement(rates, usage, request);
+      total.inputUsd += increment.inputUsd;
+      total.outputUsd += increment.outputUsd;
+      total.cacheUsd += increment.cacheUsd;
+    } else {
+      statuses.add("below_threshold");
+    }
+  }
+  if (unpriceableTiers.size > 0) {
+    reasons.push(`no long-context rates for speed tier ${[...unpriceableTiers].sort().join(", ")}`);
+  }
+  return {
+    ...total,
+    status: reasons.length > 0 ? "not_assessed" : STATUS_PRECEDENCE.find((status) => statuses.has(status)) ?? "not_assessed",
+    ...reasons.length > 0 ? { incompleteReason: reasons.join("; ") } : {}
+  };
+}
+
+// src/cost-tracking/list-price.ts
+function listPriceUsageFromRecord(record) {
+  return {
+    inputTokens: record.inputTokens,
+    outputTokens: record.outputTokens,
+    cacheReadTokens: record.cacheReadTokens ?? 0,
+    cacheWriteTokens: record.cacheWriteTokens,
+    cacheWriteLongTokens: record.cacheWriteLongTokens,
+    cacheReadIncludedInInput: record.cacheReadTokensIncludedInInput,
+    granularity: record.granularity,
+    requestEvidence: record.requestEvidence
+  };
+}
+var STANDARD_SPEED_TIER = "standard";
+function normalizeTierName(tier) {
+  const normalized = tier?.trim().toLowerCase();
+  return normalized ? normalized : void 0;
+}
+function selectListPriceRates(card, requestedTier) {
+  const requested = normalizeTierName(requestedTier);
+  if (requested === void 0 || requested === STANDARD_SPEED_TIER) {
+    return {
+      rates: card,
+      speedTier: { ...requested ? { requested } : {}, applied: STANDARD_SPEED_TIER }
+    };
+  }
+  const tierEntry = Object.entries(card.speedTiers ?? {}).find(
+    ([name]) => name.toLowerCase() === requested
+  );
+  return tierEntry ? { rates: tierEntry[1], speedTier: { requested, applied: requested } } : { rates: card, speedTier: { requested, applied: STANDARD_SPEED_TIER } };
+}
+function routedSpeedTier(runRequested, routed) {
+  if (normalizeTierName(runRequested) !== void 0 || !routed) {
+    return { requested: runRequested };
+  }
+  if (routed.applied === STANDARD_SPEED_TIER) {
+    return { requested: routed.requested };
+  }
+  return {
+    reported: { requested: routed.requested, applied: routed.applied },
+    unpublishedAbove: routed.unpublishedLongContextAboveTokens
+  };
+}
+function unpublishedThreshold(card, rates, routedAbove) {
+  return routedAbove ?? (rates === card ? void 0 : card.longContext?.thresholdTokens);
+}
+function priceWithRates(rates, usage, unpublishedAbove) {
+  const cacheReadTokens = usage.cacheReadTokens ?? 0;
+  const cacheWriteTokens = usage.cacheWriteTokens ?? 0;
+  const cacheWriteLongTokens = clampLongCacheWriteTokens(
+    cacheWriteTokens,
+    usage.cacheWriteLongTokens
+  );
+  const longContext = rates.longContext;
+  let longContextPremium;
+  let premium;
+  const standardThreshold = unpublishedAbove;
+  if (usage.granularity !== "request") {
+    const threshold = longContext?.thresholdTokens ?? standardThreshold;
+    longContextPremium = threshold !== void 0 && longContextContextTokens(usage) <= threshold ? "below_threshold" : "not_assessed";
+  } else if (!longContext) {
+    longContextPremium = standardThreshold === void 0 ? "not_defined" : longContextContextTokens(usage) > standardThreshold ? "not_assessed" : "below_threshold";
+  } else if (longContextContextTokens(usage) > longContext.thresholdTokens) {
+    longContextPremium = "applied";
+    premium = longContext;
+  } else {
+    longContextPremium = "below_threshold";
+  }
+  const inputRate = rates.inputPer1m * (premium?.inputMultiplier ?? 1);
+  const outputRate = rates.outputPer1m * (premium?.outputMultiplier ?? 1);
+  const cacheReadRate = rates.cacheReadPer1m === void 0 ? void 0 : rates.cacheReadPer1m * (premium?.cacheReadMultiplier ?? 1);
+  const cacheWriteRate = rates.cacheWritePer1m === void 0 ? void 0 : rates.cacheWritePer1m * (premium?.cacheWriteMultiplier ?? 1);
+  const cacheWriteLongRate = rates.cacheWriteLongPer1m === void 0 ? void 0 : rates.cacheWriteLongPer1m * (premium?.cacheWriteMultiplier ?? 1);
+  const billableInputTokens = usage.cacheReadIncludedInInput && cacheReadRate !== void 0 ? Math.max(0, usage.inputTokens - cacheReadTokens) : usage.inputTokens;
+  return {
+    inputUsd: billableInputTokens / 1e6 * inputRate,
+    outputUsd: usage.outputTokens / 1e6 * outputRate,
+    cacheUsd: (cacheReadRate === void 0 ? 0 : cacheReadTokens / 1e6 * cacheReadRate) + cacheWriteUsd(cacheWriteRate, cacheWriteLongRate, cacheWriteTokens, cacheWriteLongTokens),
+    longContextPremium
+  };
+}
+var PREMIUM_PRECEDENCE = [
+  "applied",
+  "below_threshold",
+  "not_assessed",
+  "not_defined"
+];
+function speedPortionUsage(usage, portion) {
+  return {
+    ...usage,
+    inputTokens: portion.inputTokens,
+    outputTokens: portion.outputTokens,
+    cacheReadTokens: portion.cacheReadTokens ?? 0,
+    cacheWriteTokens: portion.cacheWriteTokens ?? 0,
+    // The run's long-write count describes the whole run, not this portion.
+    cacheWriteLongTokens: portion.cacheWriteLongTokens ?? 0
+  };
+}
+function breakdownMatchesUsage(usage, portions) {
+  const sum = (field) => portions.reduce((total, portion) => total + (portion[field] ?? 0), 0);
+  return sum("inputTokens") === usage.inputTokens && sum("outputTokens") === usage.outputTokens && sum("cacheReadTokens") === (usage.cacheReadTokens ?? 0) && sum("cacheWriteTokens") === (usage.cacheWriteTokens ?? 0);
+}
+function computeSpeedBreakdownPrice(card, usage, requestedTier, breakdown, routedAbove) {
+  const requested = normalizeTierName(requestedTier);
+  const tierEntries = Object.entries(breakdown.tiers).map(([name, portion]) => [normalizeTierName(name), portion]).filter((entry) => entry[0] !== void 0).sort(([a], [b]) => a.localeCompare(b));
+  if (tierEntries.length === 0 && !breakdown.unknown) return void 0;
+  const observed = tierEntries.map(([name]) => name);
+  const portions = [...tierEntries.map(([, portion]) => portion), breakdown.unknown].filter(
+    (portion) => portion !== void 0
+  );
+  const unknownIsStandard = breakdown.unknown !== void 0 && Object.keys(card.speedTiers ?? {}).length === 0;
+  const effectiveTiers = /* @__PURE__ */ new Set([
+    ...observed,
+    ...unknownIsStandard ? [STANDARD_SPEED_TIER] : []
+  ]);
+  const [onlyTier] = effectiveTiers;
+  if (effectiveTiers.size === 1 && onlyTier !== void 0 && (!breakdown.unknown || unknownIsStandard)) {
+    const { rates, speedTier } = selectListPriceRates(card, onlyTier);
+    if (speedTier.applied === onlyTier) {
+      const priced2 = priceWithRates(rates, usage, unpublishedThreshold(card, rates, routedAbove));
+      return {
+        ...priced2,
+        totalUsd: priced2.inputUsd + priced2.outputUsd + priced2.cacheUsd,
+        speedTier: {
+          ...requested ? { requested } : {},
+          applied: onlyTier,
+          observed,
+          assessment: "complete"
+        },
+        complete: true
+      };
+    }
+  }
+  const missingTiers = observed.filter(
+    (name) => selectListPriceRates(card, name).speedTier.applied !== name
+  );
+  const incompleteReason = !breakdownMatchesUsage(usage, portions) ? "speed breakdown does not sum to the run usage" : missingTiers.length > 0 ? `no rates for observed speed tier ${missingTiers.join(", ")}` : void 0;
+  if (incompleteReason !== void 0) {
+    const fallback = computeBaseListPrice(card, usage, requestedTier, void 0, routedAbove);
+    return {
+      ...fallback,
+      speedTier: { ...fallback.speedTier, observed, assessment: "incomplete", incompleteReason }
+    };
+  }
+  const priced = [];
+  const appliedNames = /* @__PURE__ */ new Set();
+  for (const [name, portion] of tierEntries) {
+    const { rates, speedTier } = selectListPriceRates(card, name);
+    appliedNames.add(speedTier.applied);
+    priced.push(
+      priceWithRates(
+        rates,
+        speedPortionUsage(usage, portion),
+        unpublishedThreshold(card, rates, routedAbove)
+      )
+    );
+  }
+  if (breakdown.unknown) {
+    const { rates, speedTier } = selectListPriceRates(card, requested);
+    appliedNames.add(speedTier.applied);
+    priced.push(
+      priceWithRates(
+        rates,
+        speedPortionUsage(usage, breakdown.unknown),
+        unpublishedThreshold(card, rates, routedAbove)
+      )
+    );
+  }
+  const inputUsd = priced.reduce((total, portion) => total + portion.inputUsd, 0);
+  const outputUsd = priced.reduce((total, portion) => total + portion.outputUsd, 0);
+  const cacheUsd = priced.reduce((total, portion) => total + portion.cacheUsd, 0);
+  const longContextPremium = PREMIUM_PRECEDENCE.find(
+    (status) => priced.some((portion) => portion.longContextPremium === status)
+  ) ?? "not_assessed";
+  const unknownSpeed = breakdown.unknown !== void 0;
+  return {
+    inputUsd,
+    outputUsd,
+    cacheUsd,
+    totalUsd: inputUsd + outputUsd + cacheUsd,
+    speedTier: {
+      ...requested ? { requested } : {},
+      applied: appliedNames.size === 1 ? [...appliedNames].join("") : "mixed",
+      observed,
+      assessment: unknownSpeed ? "incomplete" : "complete",
+      ...unknownSpeed ? { incompleteReason: "some responses reported no speed" } : {}
+    },
+    longContextPremium,
+    complete: true
+  };
+}
+function computeBaseListPrice(card, usage, requestedTier, speedBreakdown, routedAbove) {
+  if (speedBreakdown) {
+    const byBreakdown = computeSpeedBreakdownPrice(
+      card,
+      usage,
+      requestedTier,
+      speedBreakdown,
+      routedAbove
+    );
+    if (byBreakdown) return byBreakdown;
+  }
+  const { rates, speedTier } = selectListPriceRates(card, requestedTier);
+  const priced = priceWithRates(rates, usage, unpublishedThreshold(card, rates, routedAbove));
+  const unverified = speedTier.applied !== STANDARD_SPEED_TIER;
+  return {
+    ...priced,
+    totalUsd: priced.inputUsd + priced.outputUsd + priced.cacheUsd,
+    speedTier: unverified ? { ...speedTier, assessment: "incomplete", incompleteReason: "served tier unverified" } : speedTier,
+    complete: true
+  };
+}
+function definesLongContext(card, routedAbove) {
+  return routedAbove !== void 0 || card.longContext !== void 0 || Object.values(card.speedTiers ?? {}).some((tier) => tier.longContext !== void 0);
+}
+function isComplete(speedTier, premium, premiumDefined) {
+  const tierFellBack = speedTier.requested !== void 0 && speedTier.requested !== STANDARD_SPEED_TIER && speedTier.requested !== speedTier.applied && // Evidence of the speed that ran prices the tier it observed, not a fallback.
+  speedTier.assessment !== "complete";
+  const speedUnassessed = speedTier.assessment === "incomplete";
+  return !tierFellBack && !speedUnassessed && !(premium === "not_assessed" && premiumDefined);
+}
+function lowestLongContextThreshold(card, routedAbove) {
+  const thresholds = [card, ...Object.values(card.speedTiers ?? {})].map((rates) => rates.longContext?.thresholdTokens).concat(routedAbove).filter((threshold) => threshold !== void 0);
+  return thresholds.length > 0 ? Math.min(...thresholds) : void 0;
+}
+function computeListPrice(card, usage, requestedTier, options = {}) {
+  const routedTier = routedSpeedTier(requestedTier, options.routed);
+  const effectiveTier = routedTier.requested;
+  const base = computeBaseListPrice(
+    card,
+    usage,
+    effectiveTier,
+    options.speedBreakdown,
+    routedTier.unpublishedAbove
+  );
+  const premiumDefined = definesLongContext(card, routedTier.unpublishedAbove);
+  const finish = (result) => {
+    const speedTier = routedTier.reported ?? result.speedTier;
+    return {
+      ...result,
+      speedTier,
+      complete: isComplete(speedTier, result.longContextPremium, premiumDefined)
+    };
+  };
+  if (usage.granularity === "request") return finish(base);
+  const lowestThreshold = lowestLongContextThreshold(card, routedTier.unpublishedAbove);
+  const runPrompt = longContextContextTokens(usage);
+  const contradicted = (usage.requestEvidence?.requests ?? []).some(
+    (request) => request.inputTokens > runPrompt
+  );
+  if (lowestThreshold !== void 0 && runPrompt <= lowestThreshold && !contradicted) {
+    return finish({ ...base, longContextPremium: "below_threshold" });
+  }
+  const assessed = assessRequestLongContext(
+    card,
+    (speed) => {
+      const { rates, speedTier } = selectListPriceRates(card, speed ?? effectiveTier);
+      const reported = normalizeTierName(speed);
+      return {
+        rates,
+        tier: speedTier.applied,
+        ...reported && reported !== speedTier.applied ? { unresolvedTier: reported } : {}
+      };
+    },
+    usage,
+    usage.requestEvidence
+  );
+  if (!assessed) return finish(base);
+  const routedAbove = routedTier.unpublishedAbove;
+  const crossesUnpublished = routedAbove !== void 0 && (usage.requestEvidence?.requests ?? []).some((request) => request.inputTokens > routedAbove);
+  const premium = crossesUnpublished && assessed.status !== "applied" ? {
+    ...assessed,
+    status: "not_assessed",
+    incompleteReason: [
+      assessed.incompleteReason,
+      "no long-context rates for the routed speed tier"
+    ].filter(Boolean).join("; ")
+  } : assessed;
+  const inputUsd = base.inputUsd + premium.inputUsd;
+  const outputUsd = base.outputUsd + premium.outputUsd;
+  const cacheUsd = base.cacheUsd + premium.cacheUsd;
+  return finish({
+    ...base,
+    inputUsd,
+    outputUsd,
+    cacheUsd,
+    totalUsd: inputUsd + outputUsd + cacheUsd,
+    longContextPremium: premium.status,
+    ...premium.incompleteReason ? { longContextIncompleteReason: premium.incompleteReason } : {}
+  });
+}
+
+// src/telemetry/model-evidence.ts
+var EVIDENCE_FIELDS = ["source", "unverifiedReason", "modelProvider", "observedModelId"];
+var MAX_EVIDENCE_FIELD_LENGTH = 128;
+function cleanField(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 && trimmed.length <= MAX_EVIDENCE_FIELD_LENGTH ? trimmed : void 0;
+}
+function cleanModelEvidence(evidence) {
+  if (!evidence) return void 0;
+  const cleaned = {};
+  for (const field of EVIDENCE_FIELDS) {
+    const value = cleanField(evidence[field]);
+    if (value) cleaned[field] = value;
+  }
+  return Object.keys(cleaned).length > 0 ? cleaned : void 0;
+}
+function modelEvidenceAvailability(evidence) {
+  const cleaned = cleanModelEvidence(evidence);
+  return cleaned ? { modelEvidence: cleaned } : {};
+}
+function readModelEvidence(availabilityJson) {
+  if (!availabilityJson) return void 0;
+  try {
+    const parsed = JSON.parse(availabilityJson);
+    const stored = parsed?.modelEvidence;
+    return stored && typeof stored === "object" ? cleanModelEvidence(stored) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isAmbiguousModelEvidence(evidence) {
+  return evidence?.unverifiedReason?.endsWith("_ambiguous") === true;
+}
+
+// src/telemetry/observed-speed-usage.ts
+function observedSpeedAvailability(breakdown) {
+  return breakdown ? { observedSpeed: breakdown } : {};
+}
+function readSpeedUsage(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const count = (key) => {
+    const value2 = record[key];
+    return typeof value2 === "number" && Number.isFinite(value2) ? value2 : void 0;
+  };
+  const inputTokens = count("inputTokens");
+  const outputTokens = count("outputTokens");
+  if (inputTokens === void 0 || outputTokens === void 0) return void 0;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: count("cacheReadTokens"),
+    cacheWriteTokens: count("cacheWriteTokens"),
+    cacheWriteLongTokens: count("cacheWriteLongTokens")
+  };
+}
+function readObservedSpeedBreakdown(availabilityJson) {
+  if (!availabilityJson) return void 0;
+  try {
+    const parsed = JSON.parse(availabilityJson);
+    const observed = parsed?.observedSpeed;
+    if (typeof observed !== "object" || observed === null) return void 0;
+    const tiers = {};
+    for (const [name, value] of Object.entries(
+      typeof observed.tiers === "object" && observed.tiers !== null ? observed.tiers : {}
+    )) {
+      const usage = readSpeedUsage(value);
+      if (!usage) return void 0;
+      tiers[name] = usage;
+    }
+    const unknown = observed.unknown === void 0 ? void 0 : readSpeedUsage(observed.unknown);
+    if (observed.unknown !== void 0 && !unknown) return void 0;
+    return { tiers, ...unknown ? { unknown } : {} };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/telemetry/request-evidence-usage.ts
+function requestEvidenceAvailability(evidence) {
+  return evidence && evidence.requests.length > 0 ? { requestEvidence: evidence } : {};
+}
+function readRequest(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const count = (key) => {
+    const field = record[key];
+    return typeof field === "number" && Number.isFinite(field) && field >= 0 ? field : void 0;
+  };
+  const inputTokens = count("inputTokens");
+  const cachedInputTokens = count("cachedInputTokens");
+  const cacheWriteTokens = count("cacheWriteTokens");
+  const outputTokens = count("outputTokens");
+  const cacheWriteLongTokens = count("cacheWriteLongTokens");
+  if (inputTokens === void 0 || cachedInputTokens === void 0 || cacheWriteTokens === void 0 || outputTokens === void 0) {
+    return void 0;
+  }
+  return {
+    inputTokens,
+    cachedInputTokens,
+    cacheWriteTokens,
+    ...cacheWriteLongTokens !== void 0 ? { cacheWriteLongTokens } : {},
+    outputTokens,
+    ...typeof record.speed === "string" && record.speed ? { speed: record.speed } : {}
+  };
+}
+function parseRequestEvidence(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const { requests, complete } = value;
+  if (!Array.isArray(requests) || requests.length === 0 || typeof complete !== "boolean") {
+    return void 0;
+  }
+  const parsed = [];
+  for (const entry of requests) {
+    const request = readRequest(entry);
+    if (!request) return void 0;
+    parsed.push(request);
+  }
+  return { requests: parsed, complete };
+}
+function readRequestEvidence(availabilityJson) {
+  if (!availabilityJson) return void 0;
+  try {
+    const parsed = JSON.parse(availabilityJson);
+    return parseRequestEvidence(parsed?.requestEvidence);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/telemetry/requested-service-tier.ts
+function requestedServiceTierAvailability(serviceTier) {
+  const tier = serviceTier?.trim();
+  return tier ? { requested: { serviceTier: tier } } : {};
+}
+function readRequestedServiceTier(availabilityJson) {
+  if (!availabilityJson) return void 0;
+  try {
+    const parsed = JSON.parse(availabilityJson);
+    const tier = parsed?.requested?.serviceTier;
+    return typeof tier === "string" && tier.trim() ? tier.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/telemetry/worker.ts
+function resolveRegistryModelCandidates(provider, modelId) {
+  const trimmed = modelId.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  const candidates = /* @__PURE__ */ new Set([trimmed]);
+  const mappings = provider.modelMappings ?? {};
+  const directMapped = mappings[trimmed];
+  if (directMapped) {
+    candidates.add(directMapped);
+  } else {
+    const lowered = trimmed.toLowerCase();
+    for (const [alias, target] of Object.entries(mappings)) {
+      if (alias.toLowerCase() === lowered && target) {
+        candidates.add(target);
+        break;
+      }
+    }
+  }
+  return Array.from(candidates);
+}
+function roundCostCents(value) {
+  return Math.round(value * 1e6) / 1e6;
+}
+function findRegistryModel(provider, modelId) {
+  const candidates = resolveRegistryModelCandidates(provider, modelId);
+  for (const candidate of candidates) {
+    const model = provider.models.find((entry) => entry.modelId === candidate);
+    if (model) {
+      return { model, resolvedModelId: candidate };
+    }
+  }
+  return null;
+}
+function unverifiedModelSuffix(evidence) {
+  return evidence?.unverifiedReason ? ` (model_unverified: ${evidence.unverifiedReason})` : "";
+}
+function optionalAttributionId(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function hasPricedTokenEvidence(invocation, evidence) {
+  return [
+    evidence?.inputTokens,
+    evidence?.outputTokens,
+    evidence?.cacheReadTokens,
+    evidence?.cacheWriteTokens,
+    invocation.tokensIn,
+    invocation.tokensOut
+  ].some((value) => typeof value === "number");
+}
+function declaresMeteredRates(model) {
+  const schema = model.costSchema;
+  if (!schema) return false;
+  return typeof schema.prompt_per_1k === "number" || typeof schema.completion_per_1k === "number" || typeof schema.cache_read_per_1k === "number" || typeof schema.cache_write_per_1k === "number" || schema.extra_fees !== void 0 || typeof schema.billing_source === "string";
+}
+function findProviderAndModel(registry, providerId, modelId) {
+  const provider = registry.providers.find((p) => p.providerId === providerId);
+  if (!provider) return null;
+  const resolvedModel = findRegistryModel(provider, modelId);
+  if (!resolvedModel) return null;
+  return { provider, ...resolvedModel };
+}
+function collectRegistrySnapshotsForEnrichment(db, preferredRegistryVersion) {
+  const preferred = db.getRegistrySnapshot(preferredRegistryVersion);
+  return preferred ? [preferred] : [];
+}
+var TelemetryWorker = class {
+  constructor(db, options = {}) {
+    this.db = db;
+    this.options = options;
+  }
+  db;
+  options;
+  warn(message) {
+    if (this.options.diagnostics === "silent") return;
+    console.warn(message);
+  }
+  error(message, detail) {
+    if (this.options.diagnostics === "silent") return;
+    console.error(message, detail);
+  }
+  markUnpriced(invocation, reason) {
+    const enrichedAt = Date.now();
+    this.db.insertEnrichedInvocation({
+      id: generateInvocationId(),
+      invocationId: invocation.id,
+      computedCostCents: null,
+      pricingSource: "unavailable",
+      enrichedAt,
+      billingMode: null,
+      usageData: JSON.stringify({
+        inputTokens: invocation.tokensIn ?? 0,
+        outputTokens: invocation.tokensOut ?? 0
+      }),
+      costSnapshot: null,
+      pricingVersion: invocation.registryVersion,
+      taskId: optionalAttributionId(invocation.taskId),
+      competitionId: optionalAttributionId(invocation.competitionId) ?? optionalAttributionId(invocation.taskId),
+      variantId: optionalAttributionId(invocation.variantId)
+    });
+    const identity = JSON.stringify({
+      invocationId: invocation.id,
+      pricingVersion: invocation.registryVersion,
+      methodologyVersion: "api-equivalent-v1",
+      status: "unavailable"
+    });
+    this.db.insertCostEvaluation({
+      evaluationId: createHash2("sha256").update(identity).digest("hex"),
+      invocationId: invocation.id,
+      pricingVersion: invocation.registryVersion,
+      methodologyVersion: "api-equivalent-v1",
+      apiEquivalentCostUsd: null,
+      providerReportedCostUsd: invocation.providerReportedCostUsd ?? null,
+      comparisonDeltaUsd: null,
+      currency: "USD",
+      status: "unavailable",
+      createdAt: enrichedAt
+    });
+    this.warn(reason);
+  }
+  /**
+   * Enrich unenriched invocations with cost data
+   * Returns number of rows enriched
+   */
+  async enrichInvocations(overrides) {
+    const unenriched = this.db.getUnenrichedInvocations(1e3);
+    let enrichedCount = 0;
+    for (const invocation of unenriched) {
+      try {
+        const snapshots = collectRegistrySnapshotsForEnrichment(
+          this.db,
+          invocation.registryVersion
+        );
+        if (snapshots.length === 0) {
+          this.markUnpriced(
+            invocation,
+            `Registry snapshot not found for version ${invocation.registryVersion}`
+          );
+          enrichedCount++;
+          continue;
+        }
+        const reportedModelId = optionalAttributionId(invocation.reportedModelId);
+        const evidence = this.db.getUsageEvidenceForInvocation(invocation.id);
+        const modelEvidence = readModelEvidence(evidence?.availabilityJson);
+        if (isAmbiguousModelEvidence(modelEvidence)) {
+          this.markUnpriced(
+            invocation,
+            `Multiple models used${unverifiedModelSuffix(modelEvidence)}; cost unavailable`
+          );
+          enrichedCount++;
+          continue;
+        }
+        const pricingModelIds = reportedModelId !== null && reportedModelId !== invocation.modelId ? modelEvidence?.source ? [reportedModelId] : [reportedModelId, invocation.modelId] : [invocation.modelId];
+        let resolved = null;
+        let resolvedPricingVersion = null;
+        let providerSeen = false;
+        let unpricedReason;
+        for (const snapshot of snapshots) {
+          const registry = parseJsonWithContext(
+            snapshot.jsonBlob,
+            "Model registry snapshot"
+          );
+          if (registry.providers.some((p) => p.providerId === invocation.providerId)) {
+            providerSeen = true;
+          }
+          unpricedReason = findProviderAndModel(registry, invocation.providerId, invocation.modelId)?.model.unpricedReason;
+          if (unpricedReason) break;
+          for (const pricingModelId of pricingModelIds) {
+            const candidate = findProviderAndModel(registry, invocation.providerId, pricingModelId);
+            if (candidate) {
+              resolved = candidate;
+              resolvedPricingVersion = snapshot.registryVersion;
+              break;
+            }
+          }
+          if (resolved) break;
+        }
+        if (unpricedReason) {
+          this.markUnpriced(invocation, unpricedReason);
+          enrichedCount++;
+          continue;
+        }
+        if (!resolved) {
+          const reason = !providerSeen ? `Provider ${invocation.providerId} not found in registry` : `Model ${pricingModelIds.join(" / ")} not found for provider ${invocation.providerId}`;
+          const unverified = unverifiedModelSuffix(modelEvidence);
+          this.markUnpriced(invocation, `${reason}${unverified}`);
+          enrichedCount++;
+          continue;
+        }
+        const { model, resolvedModelId } = resolved;
+        let pricingSource = model.costSchema?.pricing_source ?? "frontmatter";
+        let pricingConfidence = model.costSchema?.pricing_confidence;
+        let billingSource = model.costSchema?.billing_source;
+        let rateCard = rateCardFromSnapshotCostSchema(model.costSchema ?? {});
+        let extraFees = model.costSchema?.extra_fees ?? {};
+        let billingMode = model.costSchema?.billing_mode ?? "metered";
+        const overrideKey = `${invocation.providerId}:${invocation.modelId}`;
+        const resolvedOverrideKey = `${invocation.providerId}:${resolvedModelId}`;
+        const override = overrides?.[overrideKey] ?? (resolvedOverrideKey !== overrideKey ? overrides?.[resolvedOverrideKey] : void 0);
+        if (override) {
+          pricingSource = `override:${overrides?.[overrideKey] ? overrideKey : resolvedOverrideKey}`;
+          rateCard = {
+            inputPer1m: override.promptPer1k * 1e3,
+            outputPer1m: override.completionPer1k * 1e3,
+            ...rateCard.longContext ? { longContext: rateCard.longContext } : {}
+          };
+          extraFees = override.extraFees ?? {};
+          billingMode = "metered";
+          pricingConfidence = void 0;
+          billingSource = void 0;
+        }
+        if (billingMode === "metered" && !override && !declaresMeteredRates(model)) {
+          this.markUnpriced(
+            invocation,
+            `No pricing schema for ${invocation.providerId}/${resolvedModelId}; cost unavailable${unverifiedModelSuffix(modelEvidence)}`
+          );
+          enrichedCount++;
+          continue;
+        }
+        if (billingMode === "metered" && !hasPricedTokenEvidence(invocation, evidence)) {
+          this.markUnpriced(
+            invocation,
+            `No usage evidence for invocation ${invocation.id}; cost unavailable`
+          );
+          enrichedCount++;
+          continue;
+        }
+        const perModelKeys = evidence?.extraDimensionsJson ? Object.keys(JSON.parse(evidence.extraDimensionsJson)).filter((key) => key.startsWith("modelUsage/")).map((key) => key.split("/")[1]) : [];
+        if (billingMode === "metered" && new Set(perModelKeys).size > 1) {
+          this.markUnpriced(
+            invocation,
+            "Multiple reported models: aggregate usage cannot be priced as one model"
+          );
+          enrichedCount++;
+          continue;
+        }
+        const tokensIn = evidence?.inputTokens ?? invocation.tokensIn ?? 0;
+        const tokensOut = evidence?.outputTokens ?? invocation.tokensOut ?? 0;
+        const cacheReadTokens = evidence?.cacheReadTokens ?? 0;
+        const cacheWriteTokens = evidence?.cacheWriteTokens ?? 0;
+        const cacheWriteLongTokens = readLongCacheWriteTokens(evidence?.extraDimensionsJson);
+        const usageGranularity = usageGranularityFromEventSemantics(evidence?.eventSemantics);
+        const requestedServiceTier = readRequestedServiceTier(evidence?.availabilityJson);
+        const observedSpeed = readObservedSpeedBreakdown(evidence?.availabilityJson);
+        const requestEvidence = readRequestEvidence(evidence?.availabilityJson);
+        const listPrice = computeListPrice(
+          rateCard,
+          {
+            inputTokens: tokensIn,
+            outputTokens: tokensOut,
+            cacheReadTokens,
+            cacheWriteTokens,
+            cacheWriteLongTokens,
+            cacheReadIncludedInInput: evidence?.cacheReadIncludedInInput === true,
+            cacheWriteIncludedInInput: evidence?.cacheWriteIncludedInInput === true,
+            granularity: usageGranularity,
+            requestEvidence
+          },
+          requestedServiceTier,
+          { speedBreakdown: observedSpeed, routed: model.costSchema?.routed_speed_tier }
+        );
+        const extraFeesCents = Object.values(extraFees).reduce(
+          (sum, fee) => sum + (typeof fee === "number" ? fee * 100 : 0),
+          0
+        );
+        let costCents = null;
+        if (billingMode === "metered") {
+          costCents = roundCostCents(listPrice.totalUsd * 100 + extraFeesCents);
+        } else if (!model.costSchema?.pricing_source && !override) {
+          pricingSource = `non_metered:${billingMode}`;
+        }
+        const originalModelId = typeof invocation.requestedModelId === "string" && invocation.requestedModelId.trim().length > 0 ? invocation.requestedModelId : invocation.modelId;
+        const usageData = JSON.stringify({
+          inputTokens: tokensIn,
+          outputTokens: tokensOut,
+          cacheReadTokens,
+          cacheWriteTokens,
+          // Persisted so recalculation prices the long-duration writes the same way.
+          ...cacheWriteLongTokens !== void 0 ? { cacheWriteLongTokens } : {},
+          cacheReadTokensIncludedInInput: evidence?.cacheReadIncludedInInput === true,
+          // Persisted so recalculation prices the record the same way.
+          granularity: usageGranularity,
+          // Persisted so recalculation reprices a fast run at the fast tier.
+          ...requestedServiceTier ? { requestedServiceTier } : {},
+          ...observedSpeed ? { observedSpeed } : {},
+          ...requestEvidence ? { requestEvidence } : {},
+          originalModelId,
+          canonicalModelId: resolvedModelId,
+          // Present only when the provider reported one, so a reader can tell
+          // "priced against what ran" from "priced against what was asked for".
+          ...reportedModelId !== null ? { reportedModelId } : {},
+          ...modelEvidence?.source ? { modelEvidenceSource: modelEvidence.source } : {}
+        });
+        const inputCostCents = billingMode === "metered" ? roundCostCents(listPrice.inputUsd * 100) : 0;
+        const outputCostCents = billingMode === "metered" ? roundCostCents(listPrice.outputUsd * 100) : 0;
+        const costSnapshot = JSON.stringify({
+          inputCostCents,
+          outputCostCents,
+          cacheCostCents: billingMode === "metered" ? roundCostCents(listPrice.cacheUsd * 100) : 0,
+          toolCostCents: 0,
+          infrastructureCostCents: 0,
+          totalCostCents: costCents,
+          currency: "USD",
+          pricingSource,
+          ...pricingConfidence ? { pricingConfidence } : {},
+          billingMode,
+          ...billingSource ? { billingSource } : {},
+          // 'not_assessed' flags a run aggregate priced at flat rates: the
+          // long-context premium may apply to requests inside it, so this cost
+          // can understate the list price.
+          longContextPremium: listPrice.longContextPremium,
+          ...listPrice.longContextIncompleteReason ? { longContextIncompleteReason: listPrice.longContextIncompleteReason } : {},
+          speedTier: listPrice.speedTier,
+          originalModelId,
+          canonicalModelId: resolvedModelId,
+          ...reportedModelId !== null ? { reportedModelId } : {},
+          ...modelEvidence?.source ? { modelEvidenceSource: modelEvidence.source } : {},
+          pricingVersion: resolvedPricingVersion ?? invocation.registryVersion
+        });
+        const taskId = optionalAttributionId(invocation.taskId);
+        const competitionId = optionalAttributionId(invocation.competitionId) ?? taskId;
+        const variantId = optionalAttributionId(invocation.variantId);
+        const enrichedId = generateInvocationId();
+        const enriched = {
+          id: enrichedId,
+          invocationId: invocation.id,
+          computedCostCents: costCents,
+          pricingSource,
+          enrichedAt: Date.now(),
+          billingMode,
+          usageData,
+          costSnapshot,
+          pricingVersion: resolvedPricingVersion ?? invocation.registryVersion,
+          taskId,
+          competitionId,
+          variantId
+        };
+        this.db.insertEnrichedInvocation(enriched);
+        const apiEquivalentCostUsd = costCents === null ? null : costCents / 100;
+        const providerReportedCostUsd = invocation.providerReportedCostUsd ?? null;
+        const evaluationIdentity = JSON.stringify({
+          invocationId: invocation.id,
+          evidenceId: evidence?.evidenceId ?? null,
+          pricingVersion: resolvedPricingVersion ?? invocation.registryVersion,
+          methodologyVersion: "api-equivalent-v1",
+          apiEquivalentCostUsd,
+          providerReportedCostUsd
+        });
+        this.db.insertCostEvaluation({
+          evaluationId: createHash2("sha256").update(evaluationIdentity).digest("hex"),
+          invocationId: invocation.id,
+          evidenceId: evidence?.evidenceId ?? null,
+          pricingVersion: resolvedPricingVersion ?? invocation.registryVersion,
+          methodologyVersion: "api-equivalent-v1",
+          apiEquivalentCostUsd,
+          providerReportedCostUsd,
+          comparisonDeltaUsd: apiEquivalentCostUsd !== null && providerReportedCostUsd !== null ? providerReportedCostUsd - apiEquivalentCostUsd : null,
+          currency: model.costSchema?.currency ?? "USD",
+          // A premium or tier the list price could not assess is partial, not fully priced.
+          status: apiEquivalentCostUsd === null ? "unavailable" : listPrice.complete ? "complete" : "partial",
+          createdAt: Date.now()
+        });
+        enrichedCount++;
+      } catch (error) {
+        this.error(
+          `Failed to enrich invocation ${invocation.id}:`,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+    return enrichedCount;
+  }
+  /**
+   * Aggregate enriched invocations into daily cost buckets.
+   * Returns number of daily aggregate rows upserted.
+   */
+  aggregateDaily() {
+    return this.db.backfillDailyCostAggregations();
+  }
+  /**
+   * Run full enrichment and aggregation cycle
+   */
+  async runCycle(overrides) {
+    const enrichedCount = await this.enrichInvocations(overrides);
+    const dailyAggregatedCount = this.aggregateDaily();
+    return { enrichedCount, dailyAggregatedCount };
+  }
+};
+
+// src/telemetry/invocation-cost-enrichment.ts
+var PENDING_ENRICHMENT_HINT = "Invocations exist in this window but cost enrichment is pending or incomplete.";
+var NO_INVOCATIONS_HINT = "No model invocations recorded in this window.";
+var ZERO_USAGE_HINT = "Invocations were recorded but reported zero token usage; per-token cost is $0.";
+var MISSING_USAGE_HINT = "Invocations were recorded without usage evidence; their cost is unavailable, not $0.";
+var MISSING_PRICING_HINT = "Invocations reported usage but no pricing was available for their model; their cost is unavailable, not $0.";
+function pricingMetadata(pricing) {
+  if (!pricing) return {};
+  const pricingSource = pricingSourceFromRow(pricing);
+  const pricingConfidence = pricingConfidenceFromRow(pricing);
+  const billingSource = billingSourceFromRow(pricing);
+  return {
+    ...pricingSource ? { pricing_source: pricingSource } : {},
+    ...pricingConfidence ? { pricing_confidence: pricingConfidence } : {},
+    ...billingSource ? { billing_source: billingSource } : {}
+  };
+}
+function passthroughPricingRow(parsed, providerId, modelId) {
+  const target = passthroughResolver.getPassthroughTarget(
+    providerId,
+    modelId,
+    parsed.providers[providerId]?.pricing,
+    (provider, model) => parsed.providers[provider]?.pricing?.models?.[model] !== void 0
+  );
+  const upstreamRow = target && parsed.providers[target.provider]?.pricing?.models?.[target.model];
+  if (!target || !upstreamRow) return void 0;
+  const row = target.speed_tier ? pricingRowAtSpeedTier(upstreamRow, target.speed_tier) : upstreamRow;
+  if (!snapshotCostSchemaFromRow(row)) return void 0;
+  const tier = target.speed_tier ? upstreamRow.speed_tiers?.[target.speed_tier] : void 0;
+  const unpublishedAbove = tier?.long_context_pricing ? void 0 : upstreamRow.long_context_pricing?.threshold_tokens;
+  const routedSpeedTier2 = target.speed_tier ? {
+    requested: target.speed_tier,
+    applied: tier ? target.speed_tier : "standard",
+    ...tier && unpublishedAbove !== void 0 ? { unpublishedLongContextAboveTokens: unpublishedAbove } : {}
+  } : void 0;
+  return {
+    row,
+    upstream: `${target.provider}/${target.model}`,
+    ...routedSpeedTier2 ? { routedSpeedTier: routedSpeedTier2 } : {},
+    ...target.note ? { note: target.note } : {}
+  };
+}
+function buildInvocationRegistry(parsed) {
+  const providers = Object.entries(parsed.providers).map(
+    ([providerId, provider]) => ({
+      providerId,
+      displayName: provider.display_name,
+      modelMappings: { ...provider.models.mappings },
+      models: provider.models.available.map((model) => {
+        const declared = provider.pricing?.models?.[model.id];
+        const unpricedReason = declared?.unpriced_reason;
+        const passthrough = declared?.non_metered || declared && snapshotCostSchemaFromRow(declared) ? void 0 : passthroughPricingRow(parsed, providerId, model.id);
+        const pricing = passthrough?.row ?? declared;
+        const per1kRates = pricing ? snapshotCostSchemaFromRow(pricing) : void 0;
+        const metadata = passthrough ? {
+          ...pricingSourceFromRow(passthrough.row) ? { pricing_source: pricingSourceFromRow(passthrough.row) } : {},
+          resolution_route: `passthrough:${passthrough.upstream}`
+        } : pricingMetadata(pricing);
+        return {
+          modelId: model.id,
+          displayName: model.display_name,
+          capabilities: model.capabilities,
+          ...pricing?.non_metered ? {
+            costSchema: {
+              billing_mode: "non_metered",
+              ...metadata,
+              notes: pricing.notes
+            }
+          } : per1kRates ? {
+            costSchema: {
+              ...per1kRates,
+              currency: provider.pricing?.currency ?? "USD",
+              billing_mode: "metered",
+              ...metadata,
+              ...passthrough?.routedSpeedTier ? { routed_speed_tier: passthrough.routedSpeedTier } : {},
+              notes: joinPricingNotes(
+                pricing?.notes,
+                passthrough?.note,
+                passthrough?.routedSpeedTier?.applied === "standard" ? `${passthrough.routedSpeedTier.requested} requested, priced at standard.` : void 0
+              )
+            }
+          } : {},
+          ...unpricedReason ? { unpricedReason } : {}
+        };
+      })
+    })
+  );
+  return buildRegistry(providers);
+}
+function prepareInvocationRegistry() {
+  try {
+    return buildInvocationRegistry(ProviderRegistry.getActiveRegistry());
+  } catch (error) {
+    debugLog(
+      `[Telemetry] Active registry snapshot unavailable: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function captureInvocationRegistryVersion(db, prepared) {
+  try {
+    const registry = prepared === void 0 ? prepareInvocationRegistry() : prepared;
+    if (!registry) return null;
+    db.insertRegistrySnapshot({
+      registryVersion: registry.registryVersion,
+      createdAt: Date.now(),
+      jsonBlob: JSON.stringify(registry)
+    });
+    return registry.registryVersion;
+  } catch {
+    return null;
+  }
+}
+function ensureRegistrySnapshot(db) {
+  return captureInvocationRegistryVersion(db) !== null;
+}
+function ensureRegistrySnapshotForPendingEnrichment(db, options) {
+  const existingSnapshot = db.getLatestRegistrySnapshot();
+  if (options.refreshRegistrySnapshot === false && existingSnapshot) {
+    return true;
+  }
+  return ensureRegistrySnapshot(db);
+}
+async function ensurePendingInvocationCostEnrichment(db, options = {}) {
+  const pendingCount = db.countUnenrichedInvocations();
+  if (pendingCount === 0) {
+    return { enrichedCount: 0, registrySnapshotEnsured: Boolean(db.getLatestRegistrySnapshot()) };
+  }
+  const registrySnapshotEnsured = ensureRegistrySnapshotForPendingEnrichment(db, options);
+  if (!registrySnapshotEnsured) {
+    return { enrichedCount: 0, registrySnapshotEnsured: false };
+  }
+  const worker = new TelemetryWorker(db, { diagnostics: "silent" });
+  const enrichedCount = options.aggregate === false ? await worker.enrichInvocations() : (await worker.runCycle()).enrichedCount;
+  return {
+    enrichedCount,
+    registrySnapshotEnsured: true
+  };
+}
+function resolveUnpricedBreakdown(db, startTimestampMs, unpricedInvocationCount) {
+  if (unpricedInvocationCount === 0) {
+    return {};
+  }
+  const unpricedMissingPricingCount = Math.min(
+    unpricedInvocationCount,
+    db.countUnpricedWithTokenEvidenceSince(startTimestampMs)
+  );
+  return {
+    unpricedCause: unpricedMissingPricingCount > 0 ? "missing_pricing" : "missing_usage",
+    unpricedMissingPricingCount
+  };
+}
+var UNPRICED_CAUSE_HINTS = {
+  missing_pricing: MISSING_PRICING_HINT,
+  missing_usage: MISSING_USAGE_HINT
+};
+function listInvocationProviderIdsSince(db, startTimestampMs) {
+  try {
+    const rows = db.db.prepare("SELECT DISTINCT provider_id FROM model_invocations WHERE timestamp >= ?").all(startTimestampMs);
+    return rows.map((row) => row.provider_id.toLowerCase());
+  } catch {
+    return void 0;
+  }
+}
+function summarizeInvocationCostVisibility(db, startTimestampMs) {
+  const rawInvocationCount = db.countRawInvocationsSince(startTimestampMs);
+  const enrichedInvocationCount = db.countEnrichedInvocationsSince(startTimestampMs);
+  const pendingEnrichmentCount = Math.max(0, rawInvocationCount - enrichedInvocationCount);
+  const unpricedInvocationCount = db.countUnpricedInvocationsSince(startTimestampMs);
+  const unpricedBreakdown = resolveUnpricedBreakdown(db, startTimestampMs, unpricedInvocationCount);
+  const unpricedCause = unpricedBreakdown.unpricedCause;
+  const counts = {
+    rawInvocationCount,
+    enrichedInvocationCount,
+    pendingEnrichmentCount,
+    unpricedInvocationCount,
+    ...unpricedBreakdown
+  };
+  if (rawInvocationCount === 0) {
+    return {
+      ...counts,
+      visibility: "no_invocations",
+      hint: NO_INVOCATIONS_HINT
+    };
+  }
+  if (pendingEnrichmentCount > 0) {
+    return {
+      ...counts,
+      visibility: "pending_enrichment",
+      hint: PENDING_ENRICHMENT_HINT
+    };
+  }
+  const hasTokenUsage = db.hasTokenUsageSince(startTimestampMs);
+  if (!hasTokenUsage) {
+    return {
+      ...counts,
+      visibility: "zero_usage",
+      // A window with no positive usage is a real $0 only when every row was
+      // priced; unpriced rows get the explanation their cause calls for.
+      hint: unpricedCause ? UNPRICED_CAUSE_HINTS[unpricedCause] : ZERO_USAGE_HINT
+    };
+  }
+  return {
+    ...counts,
+    visibility: "enriched",
+    // Fully enriched is not fully priced. A window whose usage was positive
+    // still needs the pricing gap named, or the only thing an operator sees is
+    // a bare count of rows the total left out.
+    ...unpricedCause ? { hint: UNPRICED_CAUSE_HINTS[unpricedCause] } : {}
+  };
+}
+
+// src/telemetry/cost-projection.ts
+function availableCostAmount(amount, unit, source, detail) {
+  return {
+    amount,
+    unit,
+    status: "available",
+    source,
+    ...detail ? { detail } : {}
+  };
+}
+function unavailableCostAmount(unit, source, detail) {
+  return {
+    amount: null,
+    unit,
+    status: "unavailable",
+    source,
+    ...detail ? { detail } : {}
+  };
+}
+function errorCostAmount(unit, source, error, detail) {
+  return {
+    amount: null,
+    unit,
+    status: "error",
+    source,
+    error,
+    ...detail ? { detail } : {}
+  };
+}
+function isAvailableCostAmount(value) {
+  return value.status === "available";
+}
+function costAmountOrNull(value) {
+  return value.status === "available" ? value.amount : null;
+}
+var PENDING_HINT = "Invocations exist in this window but cost enrichment is pending; totals may under-report until enrichment completes.";
+var FAILED_HINT = "Invocations exist in this window but cost enrichment could not run (no pricing snapshot available); showing raw counts only.";
+var RAW_ZERO_USAGE_HINT = "Invocations were recorded but reported zero token usage; per-token cost is $0.";
+var NO_INVOCATIONS_HINT2 = "No model invocations recorded in this window.";
+function mapVisibilityToState(summary, attempt) {
+  switch (summary.visibility) {
+    case "enriched":
+      return "enriched";
+    case "zero_usage":
+      return "raw";
+    case "no_invocations":
+      return "enriched";
+    case "pending_enrichment":
+      if (attempt && attempt.registrySnapshotEnsured === false) {
+        return "failed";
+      }
+      return "pending";
+  }
+}
+function resolveHint(state, summary) {
+  switch (state) {
+    case "pending":
+      return PENDING_HINT;
+    case "failed":
+      return FAILED_HINT;
+    case "raw":
+      return summary.hint ?? RAW_ZERO_USAGE_HINT;
+    case "enriched":
+      if (summary.rawInvocationCount === 0) {
+        return NO_INVOCATIONS_HINT2;
+      }
+      return summary.hint;
+  }
+}
+function projectCostVisibility(db, startTimestampMs, attempt) {
+  const summary = summarizeInvocationCostVisibility(db, startTimestampMs);
+  return fromVisibilitySummary(summary, attempt);
+}
+function fromVisibilitySummary(summary, attempt) {
+  const state = mapVisibilityToState(summary, attempt);
+  const totalsMayUnderReport = state === "pending" || state === "failed" || summary.unpricedInvocationCount > 0;
+  const hint = resolveHint(state, summary);
+  return {
+    rawInvocationCount: summary.rawInvocationCount,
+    enrichedInvocationCount: summary.enrichedInvocationCount,
+    pendingEnrichmentCount: summary.pendingEnrichmentCount,
+    unpricedInvocationCount: summary.unpricedInvocationCount,
+    ...summary.unpricedCause ? { unpricedCause: summary.unpricedCause } : {},
+    ...summary.unpricedMissingPricingCount !== void 0 ? { unpricedMissingPricingCount: summary.unpricedMissingPricingCount } : {},
+    state,
+    visibility: summary.visibility,
+    totalsMayUnderReport,
+    ...hint ? { hint } : {}
+  };
+}
+function formatCostProjectionNotice(projection) {
+  const unpriced = formatUnpricedClause(
+    projection.unpricedInvocationCount,
+    projection.unpricedMissingPricingCount
+  );
+  if (projection.state === "enriched" && projection.rawInvocationCount === 0) {
+    return NO_INVOCATIONS_HINT2;
+  }
+  if (projection.state === "enriched") {
+    return unpriced;
+  }
+  const counts = projection.pendingEnrichmentCount > 0 ? ` (${projection.pendingEnrichmentCount} pending of ${projection.rawInvocationCount} raw)` : projection.rawInvocationCount > 0 ? ` (${projection.rawInvocationCount} raw)` : "";
+  return [`${projection.hint ?? ""}${counts}`.trim(), unpriced].filter(Boolean).join("; ") || void 0;
+}
+function formatUnpricedClause(unpricedInvocationCount, missingPricingCount) {
+  if (unpricedInvocationCount <= 0) {
+    return void 0;
+  }
+  const excluded = "(cost unavailable, excluded from totals)";
+  const missingUsageCount = missingPricingCount === void 0 ? void 0 : unpricedInvocationCount - missingPricingCount;
+  if (missingPricingCount !== void 0 && missingPricingCount > 0 && missingUsageCount) {
+    return `${unpricedInvocationCount} invocations unpriced: ${missingPricingCount} reported usage but no pricing was available; ${missingUsageCount} recorded without usage evidence ${excluded}`;
+  }
+  const noun = unpricedInvocationCount === 1 ? "invocation" : "invocations";
+  const missing = missingPricingCount === void 0 ? "without usage evidence or pricing" : missingPricingCount > 0 ? "reported usage but no pricing was available" : "without usage evidence";
+  return `${unpricedInvocationCount} ${noun} ${missing} ${excluded}`;
+}
+
+// src/telemetry/imported-cost-records.ts
+function loadImportedCostRecords(imported, local, projectSyncId, startMs, endExclusiveMs) {
+  const scope = `r.scope_key = 'production'${projectSyncId ? " AND b.project_sync_id = ?" : ""}`;
+  const projectArgs = projectSyncId ? [projectSyncId] : [];
+  const bounds = [];
+  const boundArgs = [];
+  if (startMs !== void 0) {
+    bounds.push("CAST(json_extract(r.payload_json, '$.timestamp') AS REAL) >= ?");
+    boundArgs.push(startMs);
+  }
+  if (endExclusiveMs !== void 0) {
+    bounds.push("CAST(json_extract(r.payload_json, '$.timestamp') AS REAL) < ?");
+    boundArgs.push(endExclusiveMs);
+  }
+  const invocations = imported.prepare(`
+    WITH latest AS (
+      SELECT MAX(r.rowid) as rowId, MIN(r.rowid) as firstRowId
+        FROM portability_records r
+        JOIN portability_bundles b ON b.bundle_id = r.bundle_id
+       WHERE ${scope} AND r.record_type = 'invocation'
+       GROUP BY json_extract(r.payload_json, '$.invocationId')
+    )
+    SELECT r.record_type as recordType, r.payload_json as payloadJson,
+           json_extract(r.payload_json, '$.invocationId') as invocationId
+      FROM latest JOIN portability_records r ON r.rowid = latest.rowId
+     WHERE 1 = 1 ${bounds.map((bound) => `AND ${bound}`).join(" ")}
+     ORDER BY latest.firstRowId
+  `).all(...projectArgs, ...boundArgs);
+  const selectedIds = [
+    ...new Set(
+      invocations.map((row) => row.invocationId).filter((id) => typeof id === "string")
+    )
+  ];
+  if (selectedIds.length === 0) return [];
+  const localIds = new Set(
+    local.prepare(`
+    SELECT id FROM model_invocations WHERE id IN (SELECT value FROM json_each(?))
+  `).all(JSON.stringify(selectedIds)).map((row) => row.id)
+  );
+  const remoteIds = selectedIds.filter((id) => !localIds.has(id));
+  if (remoteIds.length === 0) return [];
+  const evidence = imported.prepare(`
+    SELECT r.record_type as recordType, r.payload_json as payloadJson
+      FROM portability_records r
+      JOIN portability_bundles b ON b.bundle_id = r.bundle_id
+     WHERE ${scope} AND r.record_type IN ('usage', 'costEvaluation')
+       AND json_extract(r.payload_json, '$.invocationId')
+           IN (SELECT value FROM json_each(?))
+  `).all(...projectArgs, JSON.stringify(remoteIds));
+  return [
+    ...invocations.filter(
+      (row) => typeof row.invocationId === "string" && !localIds.has(row.invocationId)
+    ),
+    ...evidence
+  ];
+}
+
+// src/telemetry/invocation-quality.ts
+var SAFE_SQL_ALIAS = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+function invocationProvenanceClauses(alias) {
+  const prefix = sqlPrefix(alias);
+  return [
+    `${prefix}provider_id <> 'unknown'`,
+    `(${prefix}execution_source IS NULL OR ${prefix}execution_source = 'live')`
+  ];
+}
+function invocationMetricQualityClauses(alias) {
+  const prefix = sqlPrefix(alias);
+  return [
+    `NOT (${prefix}total_time_ms IS NOT NULL AND ${prefix}total_time_ms < 1000 AND ${prefix}tokens_out IS NULL)`,
+    `NOT (
+      ${prefix}tokens_out IS NOT NULL
+      AND ${prefix}tokens_out > 0
+      AND ${prefix}time_first_token_ms IS NOT NULL
+      AND ${prefix}time_last_token_ms IS NOT NULL
+      AND ${prefix}time_last_token_ms > ${prefix}time_first_token_ms
+      AND ((${prefix}tokens_out * 1000.0) / (${prefix}time_last_token_ms - ${prefix}time_first_token_ms)) > 1000
+    )`
+  ];
+}
+function invocationAnalyticsQualityClauses(alias) {
+  return [...invocationProvenanceClauses(alias), ...invocationMetricQualityClauses(alias)];
+}
+function invocationProvenanceWhereSql(alias) {
+  return clausesToAndSql(invocationProvenanceClauses(alias));
+}
+function isInvocationMetricQualityRow(row) {
+  if (row.total_time_ms !== null && row.total_time_ms !== void 0 && row.total_time_ms < 1e3) {
+    if (row.tokens_out === null || row.tokens_out === void 0) return false;
+  }
+  const tokensOut = row.tokens_out;
+  const firstTokenMs = row.time_first_token_ms;
+  const lastTokenMs = row.time_last_token_ms;
+  if (typeof tokensOut === "number" && tokensOut > 0 && typeof firstTokenMs === "number" && typeof lastTokenMs === "number" && lastTokenMs > firstTokenMs) {
+    const decodeTokensPerSecond = tokensOut * 1e3 / (lastTokenMs - firstTokenMs);
+    if (decodeTokensPerSecond > 1e3) return false;
+  }
+  return true;
+}
+function clausesToAndSql(clauses) {
+  if (clauses.length === 0) return "";
+  return clauses.map((clause) => `AND ${clause}`).join("\n");
+}
+function sqlPrefix(alias) {
+  if (alias === void 0) return "";
+  if (!SAFE_SQL_ALIAS.test(alias)) {
+    throw new Error(`Invalid SQL alias: ${alias}`);
+  }
+  return `${alias}.`;
+}
+
+// src/telemetry/model-invocations-db.ts
+var ENRICHED_INVOCATIONS_SOURCE = "enriched_invocations";
+var EXECUTION_COST_COLUMNS = `
+  e.invocation_id,
+  i.timestamp,
+  i.provider_id,
+  i.model_id,
+  e.usage_data,
+  e.cost_snapshot,
+  e.computed_cost_cents,
+  e.billing_mode,
+  e.pricing_version,
+  e.pricing_source,
+  e.task_id,
+  e.competition_id,
+  i.agent_role,
+  e.variant_id
+`;
+function parseExecutionCostUsage(usageData) {
+  return parseJsonWithContext(usageData, "Execution usage data");
+}
+function resolveExecutionCostSnapshot(row) {
+  const costSnapshot = row.cost_snapshot ? parseJsonWithContext(row.cost_snapshot, "Cost snapshot") : null;
+  return resolveSnapshotFirstCostSnapshot({
+    costSnapshot,
+    computedCostCents: row.computed_cost_cents,
+    billingMode: row.billing_mode
+  });
+}
+function projectExecutionCostRecord(row, usage, costSnapshot) {
+  return {
+    executionId: row.invocation_id,
+    timestamp: new Date(row.timestamp),
+    provider: row.provider_id,
+    model: row.model_id,
+    usage,
+    pricingVersion: row.pricing_version || "unknown",
+    pricingSource: row.pricing_source || "xml",
+    costSnapshot,
+    computedCostCents: row.computed_cost_cents ?? void 0,
+    taskId: row.task_id ?? void 0,
+    competitionId: row.competition_id ?? void 0,
+    agentRole: row.agent_role ?? void 0,
+    variantId: row.variant_id ?? void 0
+  };
+}
+function createInvocationAnalyticsViews(db) {
+  const views = [
+    {
+      name: "invocation_metrics_v",
+      ddl: `
+        CREATE VIEW invocation_metrics_v AS
+        WITH ranked_usage AS (
+          SELECT
+            u.*,
+            ROW_NUMBER() OVER (
+              PARTITION BY u.invocation_id
+              ORDER BY
+                CASE u.event_semantics
+                  WHEN 'final' THEN 4
+                  WHEN 'cumulative' THEN 3
+                  WHEN 'logical_run_aggregate' THEN 2
+                  ELSE 1
+                END DESC,
+                u.created_at DESC,
+                u.evidence_id DESC
+            ) AS preference_rank,
+            SUM(
+              CASE WHEN u.event_semantics IN ('final', 'cumulative', 'logical_run_aggregate')
+                THEN 1 ELSE 0 END
+            ) OVER (PARTITION BY u.invocation_id) AS terminal_count
+          FROM usage_evidence u
+        ),
+        usage_reduced AS (
+          SELECT
+            invocation_id,
+            input_tokens,
+            output_tokens,
+            cache_read_tokens,
+            cache_write_tokens,
+            reasoning_tokens,
+            tool_tokens,
+            cache_read_included_in_input,
+            cache_write_included_in_input,
+            provenance AS usage_provenance,
+            event_semantics,
+            availability_json
+          FROM ranked_usage
+          WHERE terminal_count > 0 AND preference_rank = 1
+
+          UNION ALL
+
+          SELECT
+            invocation_id,
+            SUM(input_tokens),
+            SUM(output_tokens),
+            SUM(cache_read_tokens),
+            SUM(cache_write_tokens),
+            SUM(reasoning_tokens),
+            SUM(tool_tokens),
+            MAX(cache_read_included_in_input),
+            MAX(cache_write_included_in_input),
+            'derived',
+            'delta',
+            '{}'
+          FROM ranked_usage
+          WHERE terminal_count = 0
+          GROUP BY invocation_id
+        ),
+        ranked_cost AS (
+          SELECT
+            c.*,
+            ROW_NUMBER() OVER (
+              PARTITION BY c.invocation_id
+              ORDER BY c.created_at DESC, c.evaluation_id DESC
+            ) AS cost_rank
+          FROM cost_evaluations c
+        )
+        SELECT
+          i.id AS invocation_id,
+          i.project_id,
+          i.lab_id,
+          i.lab_run_id,
+          i.run_id,
+          i.task_id,
+          i.competition_id,
+          i.variant_id,
+          i.attempt_id,
+          i.attempt_ordinal,
+          i.agent_role,
+          i.provider_id,
+          i.model_id,
+          i.status,
+          i.error_code,
+          i.timestamp,
+          i.time_request_sent_ms,
+          i.time_first_token_ms,
+          i.time_last_token_ms,
+          i.time_to_first_token_ms,
+          i.total_time_ms,
+          COALESCE(u.input_tokens, i.tokens_in) AS input_tokens,
+          COALESCE(u.output_tokens, i.tokens_out) AS output_tokens,
+          u.cache_read_tokens,
+          u.cache_write_tokens,
+          u.reasoning_tokens,
+          u.tool_tokens,
+          u.cache_read_included_in_input,
+          u.cache_write_included_in_input,
+          u.usage_provenance,
+          u.event_semantics,
+          u.availability_json,
+          COALESCE(c.api_equivalent_cost_usd, i.build_calculated_cost_usd) AS api_equivalent_cost_usd,
+          COALESCE(c.provider_reported_cost_usd, i.provider_reported_cost_usd) AS provider_reported_cost_usd,
+          c.comparison_delta_usd,
+          COALESCE(
+            c.status,
+            CASE WHEN i.build_calculated_cost_usd IS NOT NULL THEN 'complete' ELSE 'unavailable' END
+          ) AS cost_status,
+          c.pricing_version,
+          c.methodology_version
+        FROM model_invocations i
+        LEFT JOIN usage_reduced u ON u.invocation_id = i.id
+        LEFT JOIN ranked_cost c ON c.invocation_id = i.id AND c.cost_rank = 1
+      `
+    },
+    {
+      name: "task_invocation_rollup_v",
+      ddl: `
+        CREATE VIEW task_invocation_rollup_v AS
+        SELECT
+          project_id,
+          lab_id,
+          lab_run_id,
+          run_id,
+          task_id,
+          MAX(timestamp) AS last_invocation_ms,
+          COUNT(*) AS invocation_count,
+          SUM(CASE WHEN input_tokens IS NOT NULL AND output_tokens IS NOT NULL THEN 1 ELSE 0 END)
+            AS usage_reported_count,
+          SUM(
+            CASE WHEN cost_status = 'complete' AND api_equivalent_cost_usd IS NOT NULL
+              THEN 1 ELSE 0 END
+          ) AS priced_count,
+          MIN(time_request_sent_ms) AS provider_started_ms,
+          MAX(time_last_token_ms) AS provider_finished_ms,
+          SUM(total_time_ms) AS provider_sum_ms,
+          SUM(input_tokens) AS input_tokens,
+          SUM(output_tokens) AS output_tokens,
+          SUM(cache_read_tokens) AS cache_read_tokens,
+          SUM(cache_write_tokens) AS cache_write_tokens,
+          SUM(reasoning_tokens) AS reasoning_tokens,
+          SUM(tool_tokens) AS tool_tokens,
+          SUM(api_equivalent_cost_usd) AS api_equivalent_cost_usd,
+          SUM(provider_reported_cost_usd) AS provider_reported_cost_usd
+        FROM invocation_metrics_v
+        GROUP BY project_id, lab_id, lab_run_id, run_id, task_id
+      `
+    }
+  ];
+  const normalizeDdl = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
+  const staleViews = views.filter((view) => {
+    const existing = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'view' AND name = ?").get(view.name);
+    return !existing?.sql || normalizeDdl(existing.sql) !== normalizeDdl(view.ddl);
+  });
+  if (staleViews.length > 0) {
+    try {
+      db.exec("BEGIN IMMEDIATE");
+      for (const view of staleViews) {
+        db.exec(`DROP VIEW IF EXISTS ${view.name}`);
+        db.exec(view.ddl);
+      }
+      db.exec("COMMIT");
+    } catch (error) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {
+      }
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "system",
+          subsystem: "telemetry",
+          executionPhase: "setup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "create_invocation_analytics_views",
+            views: staleViews.map((view) => view.name).join(","),
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }
+      );
+    }
+  }
+  for (const view of views) {
+    try {
+      db.prepare(`SELECT * FROM ${view.name} LIMIT 0`).all();
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "system",
+          subsystem: "telemetry",
+          executionPhase: "setup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "verify_invocation_analytics_view",
+            view: view.name,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }
+      );
+    }
+  }
+}
+var ALLOWED_TABLE_NAMES = [
+  "model_invocations",
+  "registry_snapshots",
+  "enriched_invocations",
+  "usage_evidence",
+  "cost_evaluations",
+  "aggregates_hourly",
+  "cost_aggregations_daily"
+];
+var SAFE_SQL_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+var SAFE_COLUMN_DEFINITION = /^(TEXT|INTEGER|REAL|BLOB|NUMERIC)$/iu;
+function validateTableName(tableName) {
+  if (!ALLOWED_TABLE_NAMES.includes(tableName)) {
+    throw new Error(
+      `Invalid table name: "${tableName}". Only the following tables are allowed: ${ALLOWED_TABLE_NAMES.join(", ")}`
+    );
+  }
+  return tableName;
+}
+function validateSqlIdentifier(value, label) {
+  if (!SAFE_SQL_IDENTIFIER.test(value)) {
+    throw new Error(`Invalid SQL ${label}: ${value}`);
+  }
+  return value;
+}
+function validateColumnDefinition(value) {
+  if (!SAFE_COLUMN_DEFINITION.test(value)) {
+    throw new Error(`Invalid SQL column definition: ${value}`);
+  }
+  return value;
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+function convertRowToCamelCase(row) {
+  if (!row) return null;
+  const result = {};
+  for (const key in row) {
+    result[snakeToCamel(key)] = row[key];
+  }
+  return result;
+}
+function sumNullableEvidence(rows, key) {
+  const values = rows.map((row) => row[key]).filter((value) => typeof value === "number");
+  return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0);
+}
+function reducePortableUsage(rows) {
+  if (!rows || rows.length === 0) return void 0;
+  const final = rows.filter(
+    (row) => ["final", "cumulative", "logical_run_aggregate"].includes(String(row.eventSemantics))
+  ).sort((left, right) => Number(left.createdAt ?? 0) - Number(right.createdAt ?? 0)).at(-1);
+  if (final) return final;
+  const summed = { ...rows.at(-1), eventSemantics: "delta" };
+  for (const key of [
+    "inputTokens",
+    "outputTokens",
+    "cacheReadTokens",
+    "cacheWriteTokens",
+    "reasoningTokens",
+    "toolTokens"
+  ]) {
+    const values = rows.map((row) => row[key]).filter((value) => typeof value === "number");
+    summed[key] = values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0);
+  }
+  return summed;
+}
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function utcDateStartMs(date) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(date);
+  if (!match) {
+    throw new Error(`Invalid date (expected YYYY-MM-DD): ${date}`);
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const ms = Date.UTC(year, month - 1, day);
+  const check = new Date(ms);
+  if (check.getUTCFullYear() !== year || check.getUTCMonth() !== month - 1 || check.getUTCDate() !== day) {
+    throw new Error(`Invalid calendar date: ${date}`);
+  }
+  return ms;
+}
+var compatibleModelIndexByProvider = /* @__PURE__ */ new Map();
+registerProviderRegistryReloadInvalidator(() => {
+  compatibleModelIndexByProvider.clear();
+});
+function addAlternate(index, alternate, modelId) {
+  if (typeof alternate !== "string") return;
+  const trimmed = alternate.trim();
+  if (trimmed.length === 0) return;
+  let owners = index.alternateToModels.get(trimmed);
+  if (!owners) {
+    owners = /* @__PURE__ */ new Set();
+    index.alternateToModels.set(trimmed, owners);
+  }
+  owners.add(modelId);
+}
+function buildCompatibleModelIndex(providerId) {
+  try {
+    const config = ProviderRegistry.getProviderConfig(providerId);
+    const index = {
+      modelIds: /* @__PURE__ */ new Set(),
+      alternateToModels: /* @__PURE__ */ new Map()
+    };
+    for (const model of config.models.available) {
+      index.modelIds.add(model.id);
+      addAlternate(index, model.id, model.id);
+      addAlternate(index, model.full_name, model.id);
+      addAlternate(index, model.canonical_id, model.id);
+      addAlternate(index, model.routing_id, model.id);
+      for (const routeId of listModelRouteIds(model)) addAlternate(index, routeId, model.id);
+    }
+    return index;
+  } catch {
+    return null;
+  }
+}
+function getCompatibleModelIndex(providerId) {
+  const trimmedProvider = providerId.trim();
+  if (trimmedProvider.length === 0) return null;
+  if (compatibleModelIndexByProvider.has(trimmedProvider)) {
+    return compatibleModelIndexByProvider.get(trimmedProvider) ?? null;
+  }
+  const index = buildCompatibleModelIndex(trimmedProvider);
+  compatibleModelIndexByProvider.set(trimmedProvider, index);
+  return index;
+}
+function lookupCompatibleModelId(index, candidate) {
+  if (index.modelIds.has(candidate)) {
+    return candidate;
+  }
+  const owners = index.alternateToModels.get(candidate);
+  if (owners && owners.size === 1) {
+    return owners.values().next().value;
+  }
+  return null;
+}
+function stripOneTrailingContextSelector(modelId) {
+  const match = modelId.match(/^(.*)(\[[^\]]+\])\s*$/u);
+  if (!match || match[1] === void 0 || match[2] === void 0) {
+    return null;
+  }
+  const base = match[1].trim();
+  if (base.length === 0) {
+    return null;
+  }
+  return base;
+}
+function resolveCompatibleInvocationModelId(providerId, modelId) {
+  const trimmedModel = typeof modelId === "string" ? modelId.trim() : "";
+  if (trimmedModel.length === 0) return modelId;
+  const index = getCompatibleModelIndex(providerId);
+  if (!index) return modelId;
+  const direct = lookupCompatibleModelId(index, trimmedModel);
+  if (direct !== null) {
+    return direct;
+  }
+  const baseWithoutSelector = stripOneTrailingContextSelector(trimmedModel);
+  if (baseWithoutSelector !== null && baseWithoutSelector !== trimmedModel) {
+    const fromBase = lookupCompatibleModelId(index, baseWithoutSelector);
+    if (fromBase !== null) {
+      return fromBase;
+    }
+  }
+  return modelId;
+}
+function invocationModelMatchesSameModel(providerId, storedModelId, filterModelId) {
+  if (storedModelId === filterModelId) return true;
+  const storedNorm = resolveCompatibleInvocationModelId(providerId, storedModelId);
+  const filterNorm = resolveCompatibleInvocationModelId(providerId, filterModelId);
+  return storedNorm === filterNorm;
+}
+var ModelInvocationsDB = class {
+  // Exposed for worker access - ideally should add public query methods instead
+  db;
+  // Database instance type (better-sqlite3 or in-memory shim)
+  dbPath;
+  portabilityDbDir;
+  projectSyncId;
+  constructor(dbPath, options = {}) {
+    if (!sqlite_wrapper_default) {
+      throw new Error("Database implementation not available");
+    }
+    this.dbPath = dbPath;
+    this.portabilityDbDir = options.portabilityDbDir;
+    this.projectSyncId = options.projectSyncId;
+    mkdirSync2(path5.dirname(dbPath), { recursive: true });
+    this.db = new sqlite_wrapper_default(dbPath);
+    this.initializeSchema();
+  }
+  /**
+   * Initialize database schema with all required tables
+   */
+  initializeSchema() {
+    applySqlitePragmas(this.db, { foreignKeys: true });
+    this.db.exec(`
+      -- Model invocations table
+      CREATE TABLE IF NOT EXISTS model_invocations (
+        id TEXT PRIMARY KEY,
+        timestamp INTEGER NOT NULL,
+        parent_workflow_id TEXT,
+        provider_id TEXT NOT NULL,
+        model_id TEXT NOT NULL,
+        registry_version TEXT NOT NULL,
+        tokens_in INTEGER,
+        tokens_out INTEGER,
+        time_request_sent_ms INTEGER NOT NULL,
+        time_first_token_ms INTEGER,
+        time_last_token_ms INTEGER,
+        time_to_first_token_ms INTEGER,
+        total_time_ms INTEGER,
+        status TEXT NOT NULL,
+        error_code TEXT,
+        request_size_bytes INTEGER,
+        agent_role TEXT,
+        copilot_subcommand TEXT,
+        execution_source TEXT,
+        requested_model_id TEXT,
+        execution_model_id TEXT,
+        reported_model_id TEXT,
+        backend TEXT,
+        scope TEXT,
+        context_selector TEXT,
+        resolution_source TEXT,
+        task_id TEXT,
+        competition_id TEXT,
+        variant_id TEXT
+        ,run_id TEXT
+        ,attempt_id TEXT
+        ,attempt_ordinal INTEGER
+        ,project_id TEXT
+        ,lab_id TEXT
+        ,lab_run_id TEXT
+        ,provider_reported_cost_usd REAL
+        ,build_calculated_cost_usd REAL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_model_invocations_timestamp
+        ON model_invocations(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_model_invocations_provider_model
+        ON model_invocations(provider_id, model_id);
+      CREATE INDEX IF NOT EXISTS idx_model_invocations_registry_version
+        ON model_invocations(registry_version);
+      CREATE INDEX IF NOT EXISTS idx_model_invocations_agent_role
+        ON model_invocations(agent_role);
+      -- Partial index for speed/latency analytics, which filter on
+      -- status='success' (+ optional timestamp/provider/model) and order by
+      -- timestamp. A PARTIAL index keyed only to successful rows is used
+      -- instead of the full composite (status, timestamp, provider_id,
+      -- model_id) deliberately: the full composite would add per-INSERT write
+      -- cost on the hot invocation-write path for every row, whereas success
+      -- rows are the only ones these read paths target. Validate that the
+      -- speed query actually uses this index with EXPLAIN QUERY PLAN. Created
+      -- idempotently like the other indexes above (no SCHEMA_VERSION bump).
+      CREATE INDEX IF NOT EXISTS idx_model_invocations_success_speed
+        ON model_invocations(timestamp DESC, provider_id, model_id)
+        WHERE status = 'success';
+
+      -- Registry snapshots table
+      CREATE TABLE IF NOT EXISTS registry_snapshots (
+        registry_version TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        json_blob TEXT NOT NULL
+      );
+
+      -- Enriched invocations table (hybrid storage: tokens + cost snapshot)
+      CREATE TABLE IF NOT EXISTS enriched_invocations (
+        id TEXT PRIMARY KEY,
+        invocation_id TEXT NOT NULL UNIQUE,
+        computed_cost_cents INTEGER,
+        pricing_source TEXT NOT NULL,
+        enriched_at INTEGER NOT NULL,
+        billing_mode TEXT,
+
+        -- Hybrid Storage: Raw usage data (JSON) - immutable source of truth
+        usage_data TEXT,
+
+        -- Hybrid Storage: Cost snapshot (JSON) - historical accuracy
+        cost_snapshot TEXT,
+
+        -- Hybrid Storage: Pricing metadata for recalculation
+        pricing_version TEXT,
+
+        -- Hybrid Storage: Context for cost attribution
+        task_id TEXT,
+        competition_id TEXT,
+        variant_id TEXT,
+
+        FOREIGN KEY (invocation_id) REFERENCES model_invocations(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_enriched_invocations_invocation_id
+        ON enriched_invocations(invocation_id);
+      CREATE INDEX IF NOT EXISTS idx_enriched_invocations_task_id
+        ON enriched_invocations(task_id);
+      CREATE INDEX IF NOT EXISTS idx_enriched_invocations_competition_id
+        ON enriched_invocations(competition_id);
+
+      CREATE TABLE IF NOT EXISTS usage_evidence (
+        evidence_id TEXT PRIMARY KEY,
+        invocation_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        attempt_id TEXT NOT NULL,
+        event_semantics TEXT NOT NULL,
+        provenance TEXT NOT NULL,
+        input_tokens INTEGER,
+        output_tokens INTEGER,
+        cache_read_tokens INTEGER,
+        cache_write_tokens INTEGER,
+        reasoning_tokens INTEGER,
+        tool_tokens INTEGER,
+        cache_read_included_in_input INTEGER,
+        cache_write_included_in_input INTEGER,
+        extra_dimensions_json TEXT,
+        availability_json TEXT NOT NULL,
+        parser_version TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY (invocation_id) REFERENCES model_invocations(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_usage_evidence_invocation
+        ON usage_evidence(invocation_id);
+      CREATE INDEX IF NOT EXISTS idx_usage_evidence_run
+        ON usage_evidence(run_id, attempt_id);
+
+      CREATE TABLE IF NOT EXISTS cost_evaluations (
+        evaluation_id TEXT PRIMARY KEY,
+        invocation_id TEXT NOT NULL,
+        evidence_id TEXT,
+        pricing_version TEXT,
+        methodology_version TEXT NOT NULL,
+        api_equivalent_cost_usd REAL,
+        provider_reported_cost_usd REAL,
+        comparison_delta_usd REAL,
+        currency TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY (invocation_id) REFERENCES model_invocations(id),
+        FOREIGN KEY (evidence_id) REFERENCES usage_evidence(evidence_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_cost_evaluations_invocation
+        ON cost_evaluations(invocation_id, created_at);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_cost_evaluations_methodology
+        ON cost_evaluations(invocation_id, methodology_version, pricing_version);
+
+      -- Hourly aggregates table: retained schema only; nothing writes or reads it
+      CREATE TABLE IF NOT EXISTS aggregates_hourly (
+        bucket_start INTEGER NOT NULL,
+        provider_id TEXT NOT NULL,
+        model_id TEXT NOT NULL,
+        total_invocations INTEGER NOT NULL,
+        total_tokens_in INTEGER NOT NULL,
+        total_tokens_out INTEGER NOT NULL,
+        avg_cost_cents REAL NOT NULL,
+        p95_latency_ms INTEGER NOT NULL,
+        error_rate REAL NOT NULL,
+        PRIMARY KEY (bucket_start, provider_id, model_id)
+      );
+
+      -- Daily cost aggregates table (queried by getDailyCostAggregations)
+      CREATE TABLE IF NOT EXISTS cost_aggregations_daily (
+        date TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        execution_count INTEGER NOT NULL DEFAULT 0,
+        total_cost_usd REAL NOT NULL DEFAULT 0,
+        total_input_tokens INTEGER NOT NULL DEFAULT 0,
+        total_output_tokens INTEGER NOT NULL DEFAULT 0,
+        avg_cost_per_execution REAL NOT NULL DEFAULT 0,
+        PRIMARY KEY (date, provider, model)
+      );
+      CREATE INDEX IF NOT EXISTS idx_cost_aggregations_daily_date
+        ON cost_aggregations_daily(date);
+    `);
+    this.ensureColumn("model_invocations", "copilot_subcommand", "TEXT");
+    this.ensureColumn("model_invocations", "execution_source", "TEXT");
+    this.ensureColumn("model_invocations", "requested_model_id", "TEXT");
+    this.ensureColumn("model_invocations", "execution_model_id", "TEXT");
+    this.ensureColumn("model_invocations", "reported_model_id", "TEXT");
+    this.ensureColumn("model_invocations", "backend", "TEXT");
+    this.ensureColumn("model_invocations", "scope", "TEXT");
+    this.ensureColumn("model_invocations", "context_selector", "TEXT");
+    this.ensureColumn("model_invocations", "resolution_source", "TEXT");
+    this.ensureColumn("model_invocations", "task_id", "TEXT");
+    this.ensureColumn("model_invocations", "competition_id", "TEXT");
+    this.ensureColumn("model_invocations", "variant_id", "TEXT");
+    this.ensureColumn("model_invocations", "run_id", "TEXT");
+    this.ensureColumn("model_invocations", "attempt_id", "TEXT");
+    this.ensureColumn("model_invocations", "attempt_ordinal", "INTEGER");
+    this.ensureColumn("model_invocations", "project_id", "TEXT");
+    this.ensureColumn("model_invocations", "lab_id", "TEXT");
+    this.ensureColumn("model_invocations", "lab_run_id", "TEXT");
+    this.ensureColumn("model_invocations", "provider_reported_cost_usd", "REAL");
+    this.ensureColumn("model_invocations", "build_calculated_cost_usd", "REAL");
+    this.ensureColumn("enriched_invocations", "billing_mode", "TEXT");
+    this.ensureColumn("enriched_invocations", "usage_data", "TEXT");
+    this.ensureColumn("enriched_invocations", "cost_snapshot", "TEXT");
+    this.ensureColumn("enriched_invocations", "pricing_version", "TEXT");
+    this.ensureColumn("enriched_invocations", "task_id", "TEXT");
+    this.ensureColumn("enriched_invocations", "competition_id", "TEXT");
+    this.ensureColumn("enriched_invocations", "variant_id", "TEXT");
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_model_invocations_task_time
+        ON model_invocations(task_id, timestamp);
+      CREATE INDEX IF NOT EXISTS idx_model_invocations_run
+        ON model_invocations(run_id);
+      CREATE INDEX IF NOT EXISTS idx_model_invocations_project_time
+        ON model_invocations(project_id, timestamp);
+    `);
+    createInvocationAnalyticsViews(this.db);
+  }
+  /**
+   * Ensures a column exists in a table, adding it if necessary.
+   * Security: Table name is validated against whitelist to prevent SQL injection (CWE-89).
+   * Column name and definition are parameterized through prepared statements where possible.
+   *
+   * @param table - The table name (must be in ALLOWED_TABLE_NAMES)
+   * @param column - The column name to ensure exists
+   * @param definition - The SQL column definition (e.g., 'TEXT', 'INTEGER NOT NULL')
+   * @throws {Error} If the table name is not in the whitelist
+   */
+  ensureColumn(table, column, definition) {
+    const validatedTable = validateTableName(table);
+    const validatedColumn = validateSqlIdentifier(column, "column name");
+    const validatedDefinition = validateColumnDefinition(definition);
+    try {
+      const infoStmt = this.db.prepare(`PRAGMA table_info(${validatedTable})`);
+      const columns = infoStmt.all() ?? [];
+      const hasColumn = columns.some((col) => col.name === validatedColumn);
+      if (!hasColumn) {
+        this.db.exec(
+          `ALTER TABLE ${validatedTable} ADD COLUMN ${validatedColumn} ${validatedDefinition}`
+        );
+      }
+    } catch (error) {
+      if (!error || !(error instanceof Error) || !error.message.includes("Invalid table name")) {
+        emitWarning(
+          "WS-003",
+          {
+            taskId: "system",
+            subsystem: "telemetry",
+            executionPhase: "setup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              operation: "ensure_column",
+              table,
+              column,
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }
+        );
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Insert a model invocation record
+   */
+  insertInvocation(invocation) {
+    const stmt = this.db.prepare(`
+      INSERT INTO model_invocations (
+        id, timestamp, parent_workflow_id, provider_id, model_id,
+        registry_version, tokens_in, tokens_out, time_request_sent_ms,
+        time_first_token_ms, time_last_token_ms, time_to_first_token_ms,
+        total_time_ms, status, error_code, request_size_bytes, agent_role,
+        copilot_subcommand, execution_source,
+        requested_model_id, execution_model_id, reported_model_id,
+        backend, scope, context_selector, resolution_source,
+        task_id, competition_id, variant_id, run_id, attempt_id, attempt_ordinal,
+        project_id, lab_id, lab_run_id, provider_reported_cost_usd, build_calculated_cost_usd
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      invocation.id,
+      invocation.timestamp,
+      invocation.parentWorkflowId ?? null,
+      invocation.providerId,
+      invocation.modelId,
+      invocation.registryVersion,
+      invocation.tokensIn ?? null,
+      invocation.tokensOut ?? null,
+      invocation.timeRequestSentMs,
+      invocation.timeFirstTokenMs ?? null,
+      invocation.timeLastTokenMs ?? null,
+      invocation.timeToFirstTokenMs ?? null,
+      invocation.totalTimeMs ?? null,
+      invocation.status,
+      invocation.errorCode ?? null,
+      invocation.requestSizeBytes ?? null,
+      invocation.agentRole ?? null,
+      invocation.copilotSubcommand ?? null,
+      invocation.executionSource ?? null,
+      invocation.requestedModelId ?? null,
+      invocation.executionModelId ?? null,
+      invocation.reportedModelId ?? null,
+      invocation.backend ?? null,
+      invocation.scope ?? null,
+      invocation.contextSelector ?? null,
+      invocation.resolutionSource ?? null,
+      invocation.taskId ?? null,
+      invocation.competitionId ?? invocation.taskId ?? null,
+      invocation.variantId ?? null,
+      invocation.runId ?? null,
+      invocation.attemptId ?? invocation.id,
+      invocation.attemptOrdinal ?? 1,
+      invocation.projectId ?? null,
+      invocation.labId ?? null,
+      invocation.labRunId ?? null,
+      invocation.providerReportedCostUsd ?? null,
+      invocation.buildCalculatedCostUsd ?? null
+    );
+  }
+  insertUsageEvidence(evidence) {
+    this.db.prepare(
+      `INSERT OR IGNORE INTO usage_evidence (
+          evidence_id, invocation_id, run_id, attempt_id, event_semantics, provenance,
+          input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+          reasoning_tokens, tool_tokens, cache_read_included_in_input,
+          cache_write_included_in_input, extra_dimensions_json, availability_json,
+          parser_version, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      evidence.evidenceId,
+      evidence.invocationId,
+      evidence.runId,
+      evidence.attemptId,
+      evidence.eventSemantics,
+      evidence.provenance,
+      evidence.inputTokens ?? null,
+      evidence.outputTokens ?? null,
+      evidence.cacheReadTokens ?? null,
+      evidence.cacheWriteTokens ?? null,
+      evidence.reasoningTokens ?? null,
+      evidence.toolTokens ?? null,
+      evidence.cacheReadIncludedInInput == null ? null : evidence.cacheReadIncludedInInput ? 1 : 0,
+      evidence.cacheWriteIncludedInInput == null ? null : evidence.cacheWriteIncludedInInput ? 1 : 0,
+      evidence.extraDimensionsJson ?? null,
+      evidence.availabilityJson,
+      evidence.parserVersion,
+      evidence.createdAt
+    );
+  }
+  getUsageEvidenceForInvocation(invocationId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM usage_evidence
+          WHERE invocation_id = ?
+          ORDER BY created_at ASC, evidence_id ASC`
+    ).all(invocationId);
+    const evidence = [];
+    for (const row of rows) {
+      const converted = convertRowToCamelCase(row);
+      if (!converted) continue;
+      evidence.push({
+        ...converted,
+        cacheReadIncludedInInput: row.cache_read_included_in_input === null ? null : Number(row.cache_read_included_in_input) !== 0,
+        cacheWriteIncludedInInput: row.cache_write_included_in_input === null ? null : Number(row.cache_write_included_in_input) !== 0
+      });
+    }
+    if (evidence.length === 0) return null;
+    const final = evidence.filter(
+      (row) => ["final", "cumulative", "logical_run_aggregate"].includes(row.eventSemantics)
+    ).at(-1);
+    if (final) return final;
+    const base = evidence.at(-1);
+    return {
+      ...base,
+      inputTokens: sumNullableEvidence(evidence, "inputTokens"),
+      outputTokens: sumNullableEvidence(evidence, "outputTokens"),
+      cacheReadTokens: sumNullableEvidence(evidence, "cacheReadTokens"),
+      cacheWriteTokens: sumNullableEvidence(evidence, "cacheWriteTokens"),
+      reasoningTokens: sumNullableEvidence(evidence, "reasoningTokens"),
+      toolTokens: sumNullableEvidence(evidence, "toolTokens"),
+      eventSemantics: "delta"
+    };
+  }
+  insertCostEvaluation(evaluation) {
+    this.db.prepare(
+      `INSERT OR IGNORE INTO cost_evaluations (
+          evaluation_id, invocation_id, evidence_id, pricing_version, methodology_version,
+          api_equivalent_cost_usd, provider_reported_cost_usd, comparison_delta_usd,
+          currency, status, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      evaluation.evaluationId,
+      evaluation.invocationId,
+      evaluation.evidenceId ?? null,
+      evaluation.pricingVersion ?? null,
+      evaluation.methodologyVersion,
+      evaluation.apiEquivalentCostUsd ?? null,
+      evaluation.providerReportedCostUsd ?? null,
+      evaluation.comparisonDeltaUsd ?? null,
+      evaluation.currency,
+      evaluation.status,
+      evaluation.createdAt
+    );
+  }
+  /**
+   * Get a model invocation by ID
+   */
+  getInvocation(id) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM model_invocations WHERE id = ?
+    `);
+    const row = stmt.get(id);
+    return row ? convertRowToCamelCase(row) : null;
+  }
+  /**
+   * Return the most recent live invocations used by performance reporting.
+   *
+   * The invocation database is the canonical execution-attempt store. Results
+   * are returned oldest-first within the requested recent window so callers can
+   * calculate throughput and render CSV chronologically.
+   */
+  getPerformanceInvocations(options) {
+    const limit = Math.max(1, Math.trunc(options.limit));
+    const filters = [];
+    const params = [];
+    filters.push(...invocationProvenanceClauses("i"));
+    if (options.providerId) {
+      filters.push("i.provider_id = ?");
+      params.push(options.providerId);
+    }
+    if (options.variantId) {
+      filters.push("i.variant_id = ?");
+      params.push(options.variantId);
+    }
+    const where = filters.length > 0 ? `WHERE ${filters.join("\nAND ")}` : "";
+    const rows = this.db.prepare(
+      `SELECT i.*
+         FROM model_invocations i
+         ${where}
+         ORDER BY i.timestamp DESC, i.id DESC
+         LIMIT ?`
+    ).all(...params, limit);
+    return rows.reverse().map(
+      (row) => convertRowToCamelCase(row)
+    ).filter((row) => row !== null);
+  }
+  /**
+   * Insert a registry snapshot
+   */
+  insertRegistrySnapshot(snapshot) {
+    const stmt = this.db.prepare(`
+      INSERT OR IGNORE INTO registry_snapshots (registry_version, created_at, json_blob)
+      VALUES (?, ?, ?)
+    `);
+    stmt.run(snapshot.registryVersion, snapshot.createdAt, snapshot.jsonBlob);
+  }
+  /**
+   * Get the most recently persisted registry snapshot, if any.
+   */
+  getLatestRegistrySnapshot() {
+    const snapshots = this.getRegistrySnapshots(1);
+    return snapshots[0] ?? null;
+  }
+  /**
+   * List registry snapshots newest-first.
+   *
+   * Used by enrichment when an invocation's stamped registry_version is a
+   * placeholder / stale id: prefer the exact version when present, then walk
+   * other persisted snapshots so known providers still price.
+   */
+  getRegistrySnapshots(limit) {
+    const boundedLimit = typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : void 0;
+    const stmt = this.db.prepare(
+      boundedLimit !== void 0 ? `
+      SELECT * FROM registry_snapshots
+      ORDER BY created_at DESC
+      LIMIT ?
+    ` : `
+      SELECT * FROM registry_snapshots
+      ORDER BY created_at DESC
+    `
+    );
+    const rows = (boundedLimit !== void 0 ? stmt.all(boundedLimit) : stmt.all()) ?? [];
+    return rows.map(
+      (row) => convertRowToCamelCase(row)
+    ).filter((snapshot) => snapshot !== null);
+  }
+  /**
+   * Get the most recently persisted registry version, if any.
+   */
+  getLatestRegistryVersion() {
+    return this.getLatestRegistrySnapshot()?.registryVersion ?? null;
+  }
+  /**
+   * Get a registry snapshot by version
+   */
+  getRegistrySnapshot(registryVersion) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM registry_snapshots WHERE registry_version = ?
+    `);
+    const row = stmt.get(registryVersion);
+    return row ? convertRowToCamelCase(row) : null;
+  }
+  /**
+   * Insert an enriched invocation record
+   */
+  insertEnrichedInvocation(enriched) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO enriched_invocations (
+        id, invocation_id, computed_cost_cents, pricing_source, enriched_at, billing_mode,
+        usage_data, cost_snapshot, pricing_version, task_id, competition_id, variant_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      enriched.id,
+      enriched.invocationId,
+      enriched.computedCostCents ?? null,
+      enriched.pricingSource,
+      enriched.enrichedAt,
+      enriched.billingMode ?? null,
+      enriched.usageData ?? null,
+      enriched.costSnapshot ?? null,
+      enriched.pricingVersion ?? null,
+      enriched.taskId ?? null,
+      enriched.competitionId ?? null,
+      enriched.variantId ?? null
+    );
+  }
+  /**
+   * Execute related telemetry writes atomically when the SQLite driver supports it.
+   */
+  transaction(operation) {
+    if (!this.db.transaction) {
+      return operation();
+    }
+    return this.db.transaction(operation)();
+  }
+  /**
+   * Get unenriched invocations
+   */
+  getUnenrichedInvocations(limit = 100) {
+    const stmt = this.db.prepare(`
+      SELECT i.* FROM model_invocations i
+      LEFT JOIN enriched_invocations e ON i.id = e.invocation_id
+      WHERE e.id IS NULL
+      ORDER BY i.timestamp ASC
+      LIMIT ?
+    `);
+    const rows = stmt.all(limit) ?? [];
+    return rows.map(
+      (row) => convertRowToCamelCase(row)
+    ).filter((x) => x !== null);
+  }
+  /**
+   * Get cost breakdown by agent role for swarm executions
+   * Returns per-role cost totals (snapshot-first cost precedence, non-metered
+   * rows excluded) plus how many of the role's invocations were priced.
+   */
+  getRoleCostBreakdown(startTimestamp, endTimestamp) {
+    let query = `
+      SELECT
+        i.agent_role as agent_role,
+        COUNT(*) as total_invocations,
+        COALESCE(SUM(i.tokens_in), 0) as total_tokens_in,
+        COALESCE(SUM(i.tokens_out), 0) as total_tokens_out,
+        COALESCE(SUM((${SNAPSHOT_FIRST_COST_CENTS_SQL})), 0) as total_cost_cents,
+        SUM(CASE WHEN (${SNAPSHOT_FIRST_COST_CENTS_SQL}) IS NOT NULL THEN 1 ELSE 0 END) as priced_invocations
+      FROM model_invocations i
+      LEFT JOIN enriched_invocations e ON i.id = e.invocation_id
+      WHERE i.agent_role IS NOT NULL
+    `;
+    const params = [];
+    if (startTimestamp !== void 0) {
+      query += " AND i.timestamp >= ?";
+      params.push(startTimestamp);
+    }
+    if (endTimestamp !== void 0) {
+      query += " AND i.timestamp <= ?";
+      params.push(endTimestamp);
+    }
+    query += `
+      GROUP BY i.agent_role
+      ORDER BY total_cost_cents DESC, agent_role ASC
+    `;
+    const stmt = this.db.prepare(query);
+    const rows = params.length > 0 ? stmt.all(...params) : stmt.all();
+    return (rows ?? []).map(
+      (row) => convertRowToCamelCase(row)
+    ).filter(
+      (x) => x !== null
+    );
+  }
+  /**
+   * Return TTFT and token-throughput statistics grouped by provider/model.
+   *
+   * Only streaming invocations (status='success', time_to_first_token_ms IS NOT NULL)
+   * are included. Rows with total_time_ms <= 0 or null tokens_out are excluded from
+   * the tokens/sec calculation to avoid divide-by-zero and noise.
+   *
+   * Percentiles are computed in JS from a sorted slice, so they are exact for the
+   * dataset (not approximations). Safe to call on an empty or partially-populated DB.
+   *
+   * @param limit - Max provider/model groups to return, ordered by invocation count desc.
+   */
+  getTtftReport(limit = 20, options = {}) {
+    return this.getTtftReportResult(limit, options).rows;
+  }
+  /** Return TTFT rows with explicit supplementary-query availability. */
+  getTtftReportResult(limit = 20, options = {}) {
+    let rows;
+    try {
+      const filters = ["time_to_first_token_ms IS NOT NULL", "status = 'success'"];
+      const params = [];
+      if (!options.includeRaw) {
+        filters.push(...invocationAnalyticsQualityClauses());
+      }
+      if (options.providerId) {
+        filters.push("provider_id = ?");
+        params.push(options.providerId);
+      }
+      if (options.variantId) {
+        filters.push("variant_id = ?");
+        params.push(options.variantId);
+      }
+      const stmt = this.db.prepare(`
+        SELECT
+          provider_id,
+          model_id,
+          time_to_first_token_ms,
+          tokens_out,
+          total_time_ms
+        FROM model_invocations
+        WHERE ${filters.join("\nAND ")}
+        ORDER BY provider_id, model_id, time_to_first_token_ms ASC
+      `);
+      rows = stmt.all(...params);
+    } catch (error) {
+      return {
+        status: "unavailable",
+        rows: [],
+        unavailableReason: error instanceof Error ? error.message : String(error)
+      };
+    }
+    if (rows.length === 0) return { status: "available", rows: [] };
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const compatibleModelId = resolveCompatibleInvocationModelId(row.provider_id, row.model_id);
+      const key = `${row.provider_id}\0${compatibleModelId}`;
+      let group = groups.get(key);
+      if (!group) {
+        group = { providerId: row.provider_id, modelId: compatibleModelId, rows: [] };
+        groups.set(key, group);
+      }
+      group.rows.push(row);
+    }
+    const result = [];
+    for (const group of groups.values()) {
+      const groupRows = group.rows;
+      const ttfts = groupRows.map((r) => r.time_to_first_token_ms).sort((a, b) => a - b);
+      const n = ttfts.length;
+      if (n === 0) continue;
+      const p50 = ttfts[Math.min(Math.floor(n * 0.5), n - 1)] ?? null;
+      const p95 = ttfts[Math.min(Math.floor(n * 0.95), n - 1)] ?? null;
+      const avgTtft = Math.round(ttfts.reduce((s, v) => s + v, 0) / n);
+      const tokensSecs = groupRows.filter(
+        (r) => r.total_time_ms !== null && r.total_time_ms > 0 && r.tokens_out !== null && r.tokens_out > 0
+      ).map((r) => r.tokens_out * 1e3 / r.total_time_ms);
+      const avgTokensPerSec = tokensSecs.length > 0 ? Math.round(tokensSecs.reduce((s, v) => s + v, 0) / tokensSecs.length * 100) / 100 : null;
+      result.push({
+        providerId: group.providerId,
+        modelId: group.modelId,
+        streamingInvocations: n,
+        p50TtftMs: p50,
+        p95TtftMs: p95,
+        avgTtftMs: avgTtft,
+        avgTokensPerSec
+      });
+    }
+    result.sort((a, b) => b.streamingInvocations - a.streamingInvocations);
+    return { status: "available", rows: result.slice(0, limit) };
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Backfill daily cost aggregates from model_invocations (optional enrichment).
+   * Idempotent via INSERT OR REPLACE; safe to call before reads or in worker cycles.
+   *
+   * Source universe is every matching model_invocations row; enrichment is optional
+   * via LEFT JOIN. Numeric cost totals are stored only for fully priced groups;
+   * incomplete groups store 0 cost so partial known-member sums are never
+   * persisted as totals. Coverage status for reads is derived by
+   * {@link getDailyCostAggregations}.
+   *
+   * @returns Number of aggregate rows upserted, or 0 on failure (worker-compatible).
+   */
+  backfillDailyCostAggregations(startDate, endDate) {
+    const result = this.tryBackfillDailyCostAggregations(startDate, endDate);
+    return result.ok ? result.changes : 0;
+  }
+  /**
+   * Internal backfill with explicit success/failure (does not launder errors to "0 changes").
+   */
+  tryBackfillDailyCostAggregations(startDate, endDate) {
+    const params = [];
+    let whereClause = "WHERE 1=1";
+    if (startDate) {
+      whereClause += " AND i.timestamp >= ?";
+      params.push(utcDateStartMs(startDate));
+    }
+    if (endDate) {
+      whereClause += " AND i.timestamp < ?";
+      params.push(utcDateStartMs(endDate) + DAY_MS);
+    }
+    try {
+      const stmt = this.db.prepare(`
+        INSERT OR REPLACE INTO cost_aggregations_daily (
+          date,
+          provider,
+          model,
+          execution_count,
+          total_cost_usd,
+          total_input_tokens,
+          total_output_tokens,
+          avg_cost_per_execution
+        )
+        SELECT
+          date(i.timestamp / 1000, 'unixepoch') as date,
+          i.provider_id as provider,
+          i.model_id as model,
+          COUNT(*) as execution_count,
+          CASE
+            WHEN COUNT(*) > 0
+              AND COUNT(*) = SUM(
+                CASE WHEN (${SNAPSHOT_FIRST_COST_CENTS_SQL}) IS NOT NULL THEN 1 ELSE 0 END
+              )
+            THEN COALESCE(SUM((${SNAPSHOT_FIRST_COST_CENTS_SQL})), 0) / 100.0
+            ELSE 0
+          END as total_cost_usd,
+          COALESCE(SUM(i.tokens_in), 0) as total_input_tokens,
+          COALESCE(SUM(i.tokens_out), 0) as total_output_tokens,
+          CASE
+            WHEN COUNT(*) > 0
+              AND COUNT(*) = SUM(
+                CASE WHEN (${SNAPSHOT_FIRST_COST_CENTS_SQL}) IS NOT NULL THEN 1 ELSE 0 END
+              )
+            THEN COALESCE(SUM((${SNAPSHOT_FIRST_COST_CENTS_SQL})), 0) / 100.0 / COUNT(*)
+            ELSE 0
+          END as avg_cost_per_execution
+        FROM model_invocations i
+        LEFT JOIN enriched_invocations e ON e.invocation_id = i.id
+        ${whereClause}
+        GROUP BY date, provider, model
+      `);
+      const result = params.length > 0 ? stmt.run(...params) : stmt.run();
+      return { ok: true, changes: result.changes ?? 0 };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "system",
+          subsystem: "telemetry",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "backfill_daily_cost_aggregations",
+            error: message,
+            startDate,
+            endDate
+          }
+        }
+      );
+      return { ok: false, error: message };
+    }
+  }
+  /**
+   * Get daily cost aggregations for a specified date range.
+   *
+   * Status-bearing: numeric totals/averages exist only when every included
+   * invocation has authoritative snapshot-first cost evidence. Mixed or
+   * all-unpriced evidence is `incomplete` (counts retained, costs null).
+   * Query/backfill failure is `error` (no totals). Empty complete means no data.
+   *
+   * Source universe is every matching model_invocations row (optional enrichment
+   * via LEFT JOIN). Live and legacy tables are composed at the storage-native
+   * date+provider+model key first: live replaces only its exact native key;
+   * legacy-only native keys remain. Only then are merged native rows aggregated
+   * to the requested date/provider/model grouping. A group total is numeric only
+   * when every constituent native row is complete (no partial subtotals).
+   * Ordering is preserved (date DESC, then provider/model ASC when grouped).
+   */
+  getDailyCostAggregations(startDate, endDate, groupBy) {
+    const backfill = this.tryBackfillDailyCostAggregations(startDate, endDate);
+    if (!backfill.ok) {
+      return {
+        status: "error",
+        rows: [],
+        executionCount: 0,
+        pricedCount: 0,
+        error: backfill.error,
+        detail: "backfill_daily_cost_aggregations failed"
+      };
+    }
+    try {
+      const liveNative = this.queryLiveDailyCostCoverage(startDate, endDate);
+      const importedNative = this.queryImportedDailyCostCoverage(startDate, endDate);
+      const combinedLiveNative = this.combineLiveCoverage(liveNative, importedNative);
+      const legacyNative = this.queryPreseededDailyCostAggregationsNative(startDate, endDate);
+      if (combinedLiveNative.length === 0) {
+        const rows2 = this.aggregateNativeDailyCostRows(legacyNative, groupBy);
+        return this.buildDailyCostResultFromRows(rows2);
+      }
+      if (legacyNative.length === 0) {
+        const rows2 = this.aggregateNativeDailyCostRows(
+          this.buildDailyCostRowsFromLive(combinedLiveNative),
+          groupBy
+        );
+        return this.buildDailyCostResultFromRows(rows2);
+      }
+      const mergedNative = this.mergeLiveAndLegacyAtNativeKey(combinedLiveNative, legacyNative);
+      const rows = this.aggregateNativeDailyCostRows(mergedNative, groupBy);
+      return this.buildDailyCostResultFromRows(rows);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "system",
+          subsystem: "telemetry",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "query_daily_cost_aggregations",
+            error: message,
+            startDate,
+            endDate
+          }
+        }
+      );
+      return {
+        status: "error",
+        rows: [],
+        executionCount: 0,
+        pricedCount: 0,
+        error: message,
+        detail: "query_daily_cost_aggregations failed"
+      };
+    }
+  }
+  queryImportedDailyCostCoverage(startDate, endDate) {
+    if (this.portabilityDbDir && !this.projectSyncId) {
+      return [];
+    }
+    const portabilityPath = [
+      this.portabilityDbDir ? path5.join(this.portabilityDbDir, "portability.db") : void 0,
+      path5.join(path5.dirname(this.dbPath), "db", "portability.db"),
+      path5.join(path5.dirname(this.dbPath), "portability.db")
+    ].find((candidate) => Boolean(candidate && existsSync2(candidate)));
+    if (!portabilityPath) return [];
+    const imported = new sqlite_wrapper_default(portabilityPath);
+    try {
+      applySqlitePragmas(imported, { foreignKeys: true });
+      const rows = loadImportedCostRecords(
+        imported,
+        this.db,
+        this.projectSyncId,
+        startDate ? utcDateStartMs(startDate) : void 0,
+        endDate ? utcDateStartMs(endDate) + DAY_MS : void 0
+      );
+      const invocations = /* @__PURE__ */ new Map();
+      const usage = /* @__PURE__ */ new Map();
+      const evaluations = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const payload = parseJsonWithContext(
+          row.payloadJson,
+          "portable cost payload"
+        );
+        const invocationId = typeof payload.invocationId === "string" ? payload.invocationId : void 0;
+        if (!invocationId) continue;
+        if (row.recordType === "invocation") invocations.set(invocationId, payload);
+        if (row.recordType === "usage") {
+          const current = usage.get(invocationId) ?? [];
+          current.push(payload);
+          usage.set(invocationId, current);
+        }
+        if (row.recordType === "costEvaluation") {
+          const current = evaluations.get(invocationId);
+          if (!current || Number(payload.createdAt ?? 0) >= Number(current.createdAt ?? 0)) {
+            evaluations.set(invocationId, payload);
+          }
+        }
+      }
+      const native = /* @__PURE__ */ new Map();
+      for (const [invocationId, invocation] of invocations) {
+        const timestamp = Number(invocation.timestamp);
+        if (!Number.isFinite(timestamp)) continue;
+        const date = new Date(timestamp).toISOString().slice(0, 10);
+        if (startDate && date < startDate || endDate && date > endDate) continue;
+        const provider = String(invocation.provider ?? "unknown");
+        const model = String(invocation.model ?? "unknown");
+        const key = `${date}\0${provider}\0${model}`;
+        const usagePayload = reducePortableUsage(usage.get(invocationId));
+        const evaluation = evaluations.get(invocationId);
+        const apiCost = typeof evaluation?.apiEquivalentCostUsd === "number" ? evaluation.apiEquivalentCostUsd : typeof invocation.inlineApiEquivalentCostUsd === "number" ? invocation.inlineApiEquivalentCostUsd : null;
+        const inputTokens = typeof usagePayload?.inputTokens === "number" ? usagePayload.inputTokens : typeof invocation.inlineTokensIn === "number" ? invocation.inlineTokensIn : 0;
+        const outputTokens = typeof usagePayload?.outputTokens === "number" ? usagePayload.outputTokens : typeof invocation.inlineTokensOut === "number" ? invocation.inlineTokensOut : 0;
+        const existing = native.get(key) ?? {
+          date,
+          provider,
+          model,
+          execution_count: 0,
+          priced_count: 0,
+          total_cost_cents: 0,
+          total_input_tokens: 0,
+          total_output_tokens: 0
+        };
+        existing.execution_count += 1;
+        existing.total_input_tokens += inputTokens;
+        existing.total_output_tokens += outputTokens;
+        if (apiCost !== null) {
+          existing.priced_count += 1;
+          if (existing.total_cost_cents !== null) {
+            existing.total_cost_cents += apiCost * 100;
+          }
+        } else {
+          existing.total_cost_cents = null;
+        }
+        native.set(key, existing);
+      }
+      return [...native.values()];
+    } finally {
+      imported.close();
+    }
+  }
+  combineLiveCoverage(local, imported) {
+    const combined = /* @__PURE__ */ new Map();
+    for (const row of [...local, ...imported]) {
+      const key = `${row.date}\0${row.provider}\0${row.model}`;
+      const current = combined.get(key);
+      if (!current) {
+        combined.set(key, { ...row });
+        continue;
+      }
+      current.execution_count += row.execution_count;
+      current.priced_count += row.priced_count;
+      current.total_input_tokens += row.total_input_tokens;
+      current.total_output_tokens += row.total_output_tokens;
+      current.total_cost_cents = current.total_cost_cents === null || row.total_cost_cents === null ? null : current.total_cost_cents + row.total_cost_cents;
+    }
+    return [...combined.values()];
+  }
+  /**
+   * Storage-native merge identity: date + provider + model.
+   */
+  nativeDailyCostKey(row) {
+    return `${row.date}\0${row.provider ?? ""}\0${row.model ?? ""}`;
+  }
+  /**
+   * Stable key for daily aggregation under the requested grouping.
+   */
+  dailyCostAggregationKey(row, groupBy) {
+    if (groupBy === "provider") {
+      return `${row.date}\0${row.provider ?? ""}`;
+    }
+    if (groupBy === "model") {
+      return `${row.date}\0${row.model ?? ""}`;
+    }
+    return row.date;
+  }
+  /**
+   * Ordering: date DESC, then provider/model ASC when grouped (matches SQL ORDER BY).
+   * At native resolution, order by date DESC, provider ASC, model ASC.
+   */
+  compareDailyCostAggregationRows(a, b, groupBy) {
+    if (a.date !== b.date) {
+      return a.date < b.date ? 1 : -1;
+    }
+    if (groupBy === "provider" || groupBy === "native") {
+      const ap = a.provider ?? "";
+      const bp = b.provider ?? "";
+      if (ap !== bp) {
+        return ap < bp ? -1 : 1;
+      }
+    }
+    if (groupBy === "model" || groupBy === "native") {
+      const am = a.model ?? "";
+      const bm = b.model ?? "";
+      if (am !== bm) {
+        return am < bm ? -1 : 1;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Live coverage at native date+provider+model resolution.
+   * Source universe: model_invocations; enrichment optional via LEFT JOIN.
+   */
+  queryLiveDailyCostCoverage(startDate, endDate) {
+    const params = [];
+    let whereClause = "WHERE 1=1";
+    if (startDate) {
+      whereClause += " AND i.timestamp >= ?";
+      params.push(utcDateStartMs(startDate));
+    }
+    if (endDate) {
+      whereClause += " AND i.timestamp < ?";
+      params.push(utcDateStartMs(endDate) + DAY_MS);
+    }
+    const query = `
+      SELECT
+        date(i.timestamp / 1000, 'unixepoch') as date,
+        i.provider_id as provider,
+        i.model_id as model,
+        COUNT(*) as execution_count,
+        SUM(CASE WHEN (${SNAPSHOT_FIRST_COST_CENTS_SQL}) IS NOT NULL THEN 1 ELSE 0 END) as priced_count,
+        SUM(CASE WHEN ${NON_METERED_COST_SQL} THEN 1 ELSE 0 END) as non_metered_count,
+        SUM((${SNAPSHOT_FIRST_COST_CENTS_SQL})) as total_cost_cents,
+        COALESCE(SUM(i.tokens_in), 0) as total_input_tokens,
+        COALESCE(SUM(i.tokens_out), 0) as total_output_tokens
+      FROM model_invocations i
+      LEFT JOIN enriched_invocations e ON e.invocation_id = i.id
+      ${whereClause}
+      GROUP BY date, i.provider_id, i.model_id
+      ORDER BY date DESC, provider ASC, model ASC
+    `;
+    const stmt = this.db.prepare(query);
+    const rows = params.length > 0 ? stmt.all(...params) : stmt.all();
+    return rows.map((row) => this.normalizeLiveDailyCostCoverageRow(row));
+  }
+  normalizeLiveDailyCostCoverageRow(row) {
+    if (row === null || typeof row !== "object") {
+      return {
+        date: "",
+        provider: "",
+        model: "",
+        execution_count: 0,
+        priced_count: 0,
+        total_cost_cents: null,
+        total_input_tokens: 0,
+        total_output_tokens: 0
+      };
+    }
+    const dateValue = Reflect.get(row, "date");
+    const providerValue = Reflect.get(row, "provider");
+    const modelValue = Reflect.get(row, "model");
+    const totalCostCentsValue = Reflect.get(row, "total_cost_cents");
+    const totalCostCents = totalCostCentsValue == null ? null : Number(totalCostCentsValue);
+    return {
+      date: typeof dateValue === "string" ? dateValue : String(dateValue ?? ""),
+      provider: typeof providerValue === "string" ? providerValue : String(providerValue ?? ""),
+      model: typeof modelValue === "string" ? modelValue : String(modelValue ?? ""),
+      execution_count: Number(Reflect.get(row, "execution_count")) || 0,
+      priced_count: Number(Reflect.get(row, "priced_count")) || 0,
+      non_metered_count: Number(Reflect.get(row, "non_metered_count")) || 0,
+      total_cost_cents: totalCostCents === null || Number.isNaN(totalCostCents) ? null : totalCostCents,
+      total_input_tokens: Number(Reflect.get(row, "total_input_tokens")) || 0,
+      total_output_tokens: Number(Reflect.get(row, "total_output_tokens")) || 0
+    };
+  }
+  buildDailyCostRowsFromLive(live) {
+    return live.map((row) => {
+      const execCount = Number(row.execution_count) || 0;
+      const priced = Number(row.priced_count) || 0;
+      const rowComplete = execCount > 0 && priced + (row.non_metered_count ?? 0) === execCount;
+      const totalCost = rowComplete ? (Number(row.total_cost_cents) || 0) / 100 : null;
+      const avgCostPerExecution = rowComplete && execCount > 0 && totalCost !== null ? totalCost / execCount : null;
+      return {
+        date: row.date,
+        provider: row.provider,
+        model: row.model,
+        executionCount: execCount,
+        pricedCount: priced,
+        totalTokensIn: Number(row.total_input_tokens) || 0,
+        totalTokensOut: Number(row.total_output_tokens) || 0,
+        totalCost,
+        avgCostPerExecution,
+        status: rowComplete ? "complete" : "incomplete"
+      };
+    });
+  }
+  buildDailyCostResultFromRows(rows) {
+    let executionCount = 0;
+    let pricedCount = 0;
+    let anyIncomplete = false;
+    for (const row of rows) {
+      executionCount += row.executionCount;
+      pricedCount += row.pricedCount;
+      if (row.status === "incomplete") {
+        anyIncomplete = true;
+      }
+    }
+    return {
+      status: anyIncomplete ? "incomplete" : "complete",
+      rows,
+      executionCount,
+      pricedCount,
+      ...anyIncomplete ? { detail: `incomplete cost evidence (${pricedCount}/${executionCount} priced)` } : {}
+    };
+  }
+  /**
+   * Compose live and legacy rows at storage-native date+provider+model keys.
+   * Live is authoritative for its exact native key only; legacy-only keys remain.
+   */
+  mergeLiveAndLegacyAtNativeKey(live, legacyRows) {
+    const liveRows = this.buildDailyCostRowsFromLive(live);
+    const liveKeys = new Set(liveRows.map((row) => this.nativeDailyCostKey(row)));
+    const legacyOnly = legacyRows.filter((row) => !liveKeys.has(this.nativeDailyCostKey(row)));
+    return [...liveRows, ...legacyOnly];
+  }
+  /**
+   * Aggregate storage-native rows to the requested date/provider/model grouping.
+   * A group total/average is numeric only when every constituent native row is
+   * complete; partial subtotals are never exposed.
+   */
+  aggregateNativeDailyCostRows(nativeRows, groupBy) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of nativeRows) {
+      const key = this.dailyCostAggregationKey(row, groupBy);
+      let group = groups.get(key);
+      if (!group) {
+        group = {
+          date: row.date,
+          ...groupBy === "provider" ? { provider: row.provider } : {},
+          ...groupBy === "model" ? { model: row.model } : {},
+          members: []
+        };
+        groups.set(key, group);
+      }
+      group.members.push(row);
+    }
+    const aggregated = [];
+    for (const group of groups.values()) {
+      let executionCount = 0;
+      let pricedCount = 0;
+      let totalTokensIn = 0;
+      let totalTokensOut = 0;
+      let allComplete = true;
+      let totalCostSum = 0;
+      for (const member of group.members) {
+        executionCount += member.executionCount;
+        pricedCount += member.pricedCount;
+        totalTokensIn += member.totalTokensIn;
+        totalTokensOut += member.totalTokensOut;
+        if (member.status !== "complete" || member.totalCost === null) {
+          allComplete = false;
+        } else {
+          totalCostSum += member.totalCost;
+        }
+      }
+      const complete = allComplete && executionCount > 0;
+      const totalCost = complete ? totalCostSum : null;
+      const avgCostPerExecution = complete && executionCount > 0 && totalCost !== null ? totalCost / executionCount : null;
+      aggregated.push({
+        date: group.date,
+        provider: group.provider,
+        model: group.model,
+        executionCount,
+        pricedCount,
+        totalTokensIn,
+        totalTokensOut,
+        totalCost,
+        avgCostPerExecution,
+        status: complete ? "complete" : "incomplete"
+      });
+    }
+    return aggregated.sort((a, b) => this.compareDailyCostAggregationRows(a, b, groupBy));
+  }
+  /**
+   * Pre-seeded cost_aggregations_daily fixtures at storage-native resolution
+   * (date, provider, model). Treated as complete; pricedCount equals
+   * executionCount. Callers that also have live coverage must merge at the
+   * native key so live remains authoritative for exact collisions only.
+   */
+  queryPreseededDailyCostAggregationsNative(startDate, endDate) {
+    const params = [];
+    let whereClause = " WHERE 1=1";
+    if (startDate) {
+      whereClause += " AND date >= ?";
+      params.push(startDate);
+    }
+    if (endDate) {
+      whereClause += " AND date <= ?";
+      params.push(endDate);
+    }
+    const query = `
+      SELECT
+        date,
+        provider,
+        model,
+        execution_count,
+        total_cost_usd,
+        total_input_tokens,
+        total_output_tokens,
+        avg_cost_per_execution
+      FROM cost_aggregations_daily
+      ${whereClause}
+      ORDER BY date DESC, provider ASC, model ASC
+    `;
+    const stmt = this.db.prepare(query);
+    const rawRows = params.length > 0 ? stmt.all(...params) : stmt.all();
+    return rawRows.map((raw) => this.normalizePreseededDailyCostAggregateRow(raw));
+  }
+  normalizePreseededDailyCostAggregateRow(raw) {
+    if (raw === null || typeof raw !== "object") {
+      return {
+        date: "",
+        executionCount: 0,
+        pricedCount: 0,
+        totalTokensIn: 0,
+        totalTokensOut: 0,
+        totalCost: 0,
+        avgCostPerExecution: 0,
+        status: "complete"
+      };
+    }
+    const dateValue = Reflect.get(raw, "date");
+    const providerValue = Reflect.get(raw, "provider");
+    const modelValue = Reflect.get(raw, "model");
+    const avgValue = Reflect.get(raw, "avg_cost_per_execution");
+    const execCount = Number(Reflect.get(raw, "execution_count")) || 0;
+    const totalCost = Number(Reflect.get(raw, "total_cost_usd")) || 0;
+    const avgFromRow = avgValue === null || avgValue === void 0 ? null : Number(avgValue);
+    const avgCostPerExecution = avgFromRow !== null && !Number.isNaN(avgFromRow) ? avgFromRow : execCount > 0 ? totalCost / execCount : 0;
+    const provider = typeof providerValue === "string" ? providerValue : void 0;
+    const model = typeof modelValue === "string" ? modelValue : void 0;
+    return {
+      date: typeof dateValue === "string" ? dateValue : String(dateValue ?? ""),
+      ...provider !== void 0 ? { provider } : {},
+      ...model !== void 0 ? { model } : {},
+      executionCount: execCount,
+      pricedCount: execCount,
+      totalTokensIn: Number(Reflect.get(raw, "total_input_tokens")) || 0,
+      totalTokensOut: Number(Reflect.get(raw, "total_output_tokens")) || 0,
+      totalCost,
+      avgCostPerExecution,
+      status: "complete"
+    };
+  }
+  /**
+   * Determine if telemetry contains non-metered billing records
+   */
+  hasNonMeteredBilling() {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT 1 FROM enriched_invocations
+        WHERE billing_mode IS NOT NULL AND billing_mode != 'metered'
+        LIMIT 1
+      `);
+      const row = stmt.get();
+      return Boolean(row);
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "system",
+          subsystem: "telemetry",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "query_non_metered_billing",
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }
+      );
+      return false;
+    }
+  }
+  // ============================================================================
+  // HYBRID STORAGE: Cost Tracking with Tokens + Snapshot
+  // ============================================================================
+  /**
+   * Record an execution cost with hybrid storage (tokens + cost snapshot)
+   * Stores both raw usage data (immutable) and cost snapshot (historical accuracy)
+   */
+  recordExecutionCost(record) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO enriched_invocations (
+        id,
+        invocation_id,
+        computed_cost_cents,
+        pricing_source,
+        enriched_at,
+        billing_mode,
+        usage_data,
+        cost_snapshot,
+        pricing_version,
+        task_id,
+        competition_id,
+        variant_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const enrichedId = `enrich_${Date.now()}_${randomBytes(8).toString("hex")}`;
+    const enrichedAt = record.timestamp.getTime();
+    stmt.run(
+      enrichedId,
+      record.executionId,
+      record.costSnapshot.totalCostCents,
+      record.pricingSource,
+      enrichedAt,
+      "metered",
+      // Default to metered for new records
+      JSON.stringify(record.usage),
+      JSON.stringify(record.costSnapshot),
+      record.pricingVersion,
+      record.taskId ?? null,
+      record.competitionId ?? null,
+      record.variantId ?? null
+    );
+  }
+  /**
+   * Get execution cost record by execution ID
+   * Reconstructs full ExecutionCostRecord from hybrid storage
+   */
+  getExecutionCost(executionId) {
+    const stmt = this.db.prepare(`
+      SELECT ${EXECUTION_COST_COLUMNS}
+      FROM enriched_invocations e
+      JOIN model_invocations i ON e.invocation_id = i.id
+      WHERE e.invocation_id = ?
+    `);
+    const row = stmt.get(executionId);
+    if (!row) {
+      return null;
+    }
+    const usage = row.usage_data ? parseExecutionCostUsage(row.usage_data) : null;
+    const resolvedCostSnapshot = resolveExecutionCostSnapshot(row);
+    if (!usage || !resolvedCostSnapshot) {
+      return null;
+    }
+    return projectExecutionCostRecord(row, usage, resolvedCostSnapshot);
+  }
+  /**
+   * Recalculate cost for an execution using current pricing
+   * Requires calculator function to be passed in to avoid circular dependency
+   *
+   * @param executionId - Execution ID to recalculate
+   * @param calculateCost - Cost calculation function (provider, model, usage) => cost in cents
+   * @returns New cost in cents, or null if execution not found or missing usage data
+   */
+  recalculateCost(executionId, calculateCost) {
+    const record = this.getExecutionCost(executionId);
+    if (!record) {
+      return null;
+    }
+    try {
+      const newCostCents = calculateCost(record.provider, record.model, record.usage);
+      return newCostCents;
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "system",
+          subsystem: "telemetry",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "recalculate_cost",
+            executionId,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }
+      );
+      return null;
+    }
+  }
+  /**
+   * Get all execution costs for a task
+   */
+  getTaskExecutionCosts(taskId) {
+    const stmt = this.db.prepare(`
+      SELECT ${EXECUTION_COST_COLUMNS}
+      FROM enriched_invocations e
+      JOIN model_invocations i ON e.invocation_id = i.id
+      WHERE e.task_id = ?
+      ORDER BY i.timestamp ASC
+    `);
+    const rows = stmt.all(taskId);
+    const mappedRecords = rows.map((row) => {
+      const usage = row.usage_data ? parseExecutionCostUsage(row.usage_data) : null;
+      const resolvedCostSnapshot = resolveExecutionCostSnapshot(row);
+      if (!usage || !resolvedCostSnapshot) {
+        return null;
+      }
+      return projectExecutionCostRecord(row, usage, resolvedCostSnapshot);
+    });
+    return mappedRecords.filter((record) => record !== null);
+  }
+  /**
+   * Get all execution costs for a competition
+   */
+  getCompetitionExecutionCosts(competitionId) {
+    const stmt = this.db.prepare(`
+      SELECT ${EXECUTION_COST_COLUMNS}
+      FROM enriched_invocations e
+      JOIN model_invocations i ON e.invocation_id = i.id
+      WHERE e.competition_id = ?
+      ORDER BY i.timestamp ASC
+    `);
+    const rows = stmt.all(competitionId);
+    const mappedRecords = rows.map((row) => {
+      const usage = row.usage_data ? parseExecutionCostUsage(row.usage_data) : null;
+      const resolvedCostSnapshot = resolveExecutionCostSnapshot(row);
+      if (!usage || !resolvedCostSnapshot) {
+        return null;
+      }
+      return projectExecutionCostRecord(row, usage, resolvedCostSnapshot);
+    });
+    return mappedRecords.filter((record) => record !== null);
+  }
+  /**
+   * Count invocations that have not yet been enriched with cost data.
+   */
+  countUnenrichedInvocations() {
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count
+      FROM model_invocations i
+      LEFT JOIN enriched_invocations e ON i.id = e.invocation_id
+      WHERE e.id IS NULL
+    `);
+    const row = stmt.get();
+    return row?.count ?? 0;
+  }
+  /**
+   * Count enriched invocations since a given timestamp.
+   */
+  countEnrichedInvocationsSince(startTimestampMs) {
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count
+      FROM enriched_invocations e
+      JOIN model_invocations i ON e.invocation_id = i.id
+      WHERE i.timestamp >= ?
+    `);
+    const row = stmt.get(startTimestampMs);
+    return row?.count ?? 0;
+  }
+  /**
+   * Count enriched invocations in the window whose per-token cost is
+   * unavailable (no usage evidence, no registry snapshot, or no pricing for the
+   * model). Enrichment leaves `computed_cost_cents` NULL with a NULL billing
+   * mode for those rows, so cost readbacks can report how many invocations a
+   * total does not account for instead of implying a complete $0.
+   *
+   * Seat-licensed (non-metered) rows also carry a NULL cost but are excluded:
+   * their absence from per-token totals is by design, not missing evidence.
+   */
+  countUnpricedInvocationsSince(startTimestampMs) {
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count
+      FROM enriched_invocations e
+      JOIN model_invocations i ON e.invocation_id = i.id
+      WHERE i.timestamp >= ?
+        AND e.computed_cost_cents IS NULL
+        AND (e.billing_mode IS NULL OR e.billing_mode = 'metered')
+    `);
+    const row = stmt.get(startTimestampMs);
+    return row?.count ?? 0;
+  }
+  /**
+   * Whether any invocation in the window reported non-zero token usage in a
+   * dimension the cost formula prices.
+   *
+   * Cache reads and writes are billed usage, and providers report them only in
+   * `usage_evidence` — the raw columns stay 0. Reading the raw columns alone
+   * called a cache-only window "zero usage" and then described its real,
+   * positive cost as $0.
+   */
+  hasTokenUsageSince(startTimestampMs) {
+    const stmt = this.db.prepare(`
+      SELECT 1
+      FROM model_invocations i
+      LEFT JOIN usage_evidence u ON u.invocation_id = i.id
+      WHERE i.timestamp >= ?
+        AND (
+          COALESCE(i.tokens_in, 0) > 0
+          OR COALESCE(i.tokens_out, 0) > 0
+          OR COALESCE(u.input_tokens, 0) > 0
+          OR COALESCE(u.output_tokens, 0) > 0
+          OR COALESCE(u.cache_read_tokens, 0) > 0
+          OR COALESCE(u.cache_write_tokens, 0) > 0
+        )
+      LIMIT 1
+    `);
+    return Boolean(stmt.get(startTimestampMs));
+  }
+  /**
+   * How many unpriced invocations in the window did record token counts.
+   *
+   * An explicit 0 counts as recorded: such a row is unpriced because pricing
+   * could not be resolved (no snapshot, provider, model, or rates), not because
+   * usage was never reported, and cost output explains the two differently. A
+   * count rather than a flag so a window holding both kinds reports each.
+   */
+  countUnpricedWithTokenEvidenceSince(startTimestampMs) {
+    const stmt = this.db.prepare(`
+      SELECT COUNT(DISTINCT i.id) as count
+      FROM enriched_invocations e
+      JOIN model_invocations i ON e.invocation_id = i.id
+      LEFT JOIN usage_evidence u ON u.invocation_id = i.id
+      WHERE i.timestamp >= ?
+        AND e.computed_cost_cents IS NULL
+        AND (e.billing_mode IS NULL OR e.billing_mode = 'metered')
+        AND (
+          i.tokens_in IS NOT NULL
+          OR i.tokens_out IS NOT NULL
+          OR u.input_tokens IS NOT NULL
+          OR u.output_tokens IS NOT NULL
+          OR u.cache_read_tokens IS NOT NULL
+          OR u.cache_write_tokens IS NOT NULL
+        )
+    `);
+    const row = stmt.get(startTimestampMs);
+    return row?.count ?? 0;
+  }
+  /**
+   * Count raw model invocations since a given timestamp (before cost enrichment).
+   */
+  countRawInvocationsSince(startTimestampMs) {
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count
+      FROM model_invocations
+      WHERE timestamp >= ?
+    `);
+    const row = stmt.get(startTimestampMs);
+    return row?.count ?? 0;
+  }
+  /**
+   * Get execution costs since a given timestamp
+   */
+  getExecutionCostsSince(startTimestampMs) {
+    const stmt = this.db.prepare(`
+      SELECT ${EXECUTION_COST_COLUMNS},
+        i.tokens_in,
+        i.tokens_out
+      FROM enriched_invocations e
+      JOIN model_invocations i ON e.invocation_id = i.id
+      WHERE i.timestamp >= ?
+      ORDER BY i.timestamp ASC
+    `);
+    const rows = stmt.all(startTimestampMs);
+    const mappedRecords = rows.map((row) => {
+      const usage = row.usage_data ? parseExecutionCostUsage(row.usage_data) : {
+        inputTokens: row.tokens_in ?? 0,
+        outputTokens: row.tokens_out ?? 0
+      };
+      const resolvedCostSnapshot = resolveExecutionCostSnapshot(row);
+      if (!resolvedCostSnapshot) {
+        return null;
+      }
+      return projectExecutionCostRecord(row, usage, resolvedCostSnapshot);
+    });
+    return mappedRecords.filter((record) => record !== null);
+  }
+  /**
+   * Get total cost for a task from cost snapshots.
+   *
+   * Returns a status-bearing amount in cents (as stored on enriched rows).
+   * Known zero is valid only when priced rows exist and sum to 0.
+   * Empty match set, all-null evidence, and query failures do not collapse to bare 0.
+   */
+  getTaskTotalCost(taskId) {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT
+          ${SNAPSHOT_FIRST_COST_CENTS_SQL} AS cost_cents
+        FROM enriched_invocations e
+        WHERE e.task_id = ?
+      `);
+      const rows = stmt.all(taskId);
+      if (rows.length === 0) {
+        return unavailableCostAmount(
+          "cents",
+          ENRICHED_INVOCATIONS_SOURCE,
+          `no enriched cost rows for task=${taskId}`
+        );
+      }
+      let totalCents = 0;
+      let pricedCount = 0;
+      for (const row of rows) {
+        if (row.cost_cents === null || row.cost_cents === void 0) {
+          continue;
+        }
+        if (!Number.isFinite(row.cost_cents)) {
+          return unavailableCostAmount(
+            "cents",
+            ENRICHED_INVOCATIONS_SOURCE,
+            `non-finite cost evidence for task=${taskId}`
+          );
+        }
+        pricedCount += 1;
+        totalCents += row.cost_cents;
+      }
+      if (pricedCount === 0) {
+        return unavailableCostAmount(
+          "cents",
+          ENRICHED_INVOCATIONS_SOURCE,
+          `null or missing cost evidence for task=${taskId}`
+        );
+      }
+      if (pricedCount < rows.length) {
+        return unavailableCostAmount(
+          "cents",
+          ENRICHED_INVOCATIONS_SOURCE,
+          `partial cost evidence for task=${taskId} (${pricedCount}/${rows.length} priced)`
+        );
+      }
+      return availableCostAmount(totalCents, "cents", ENRICHED_INVOCATIONS_SOURCE);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return errorCostAmount(
+        "cents",
+        ENRICHED_INVOCATIONS_SOURCE,
+        message,
+        `query failure for task=${taskId}`
+      );
+    }
+  }
+  /**
+   * Get cost breakdown by provider for a competition.
+   *
+   * Status-bearing (C11): empty match set, null/partial evidence, and query
+   * failures never collapse to an empty map or bare numeric zero. Known zero is
+   * returned only when priced rows exist and sum to 0. Zero-valued providers are
+   * retained rather than omitted.
+   */
+  getCompetitionCostBreakdown(competitionId) {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT
+          i.provider_id,
+          SUM(${SNAPSHOT_FIRST_COST_CENTS_SQL}) as total_cost_cents,
+          COUNT(*) as row_count,
+          SUM(CASE WHEN ${SNAPSHOT_FIRST_COST_CENTS_SQL} IS NOT NULL THEN 1 ELSE 0 END) as priced_count
+        FROM enriched_invocations e
+        JOIN model_invocations i ON e.invocation_id = i.id
+        WHERE e.competition_id = ?
+        GROUP BY i.provider_id
+      `);
+      const rows = stmt.all(competitionId);
+      if (rows.length === 0) {
+        const total2 = unavailableCostAmount(
+          "cents",
+          ENRICHED_INVOCATIONS_SOURCE,
+          `no enriched cost rows for competition=${competitionId}`
+        );
+        return {
+          status: "unavailable",
+          byProvider: {},
+          total: total2,
+          source: ENRICHED_INVOCATIONS_SOURCE,
+          detail: total2.detail
+        };
+      }
+      const byProvider = {};
+      let allAvailable = true;
+      let totalCents = 0;
+      const partialDetails = [];
+      for (const row of rows) {
+        const rowCount = row.row_count ?? 0;
+        const pricedCount = row.priced_count ?? 0;
+        const totalCostCents = row.total_cost_cents;
+        if (rowCount === 0) {
+          byProvider[row.provider_id] = unavailableCostAmount(
+            "cents",
+            ENRICHED_INVOCATIONS_SOURCE,
+            `no rows for provider=${row.provider_id} competition=${competitionId}`
+          );
+          allAvailable = false;
+          continue;
+        }
+        if (pricedCount === 0 || totalCostCents === null || totalCostCents === void 0) {
+          byProvider[row.provider_id] = unavailableCostAmount(
+            "cents",
+            ENRICHED_INVOCATIONS_SOURCE,
+            `null or missing cost evidence for provider=${row.provider_id} competition=${competitionId}`
+          );
+          allAvailable = false;
+          partialDetails.push(`${row.provider_id}:null`);
+          continue;
+        }
+        if (pricedCount < rowCount) {
+          byProvider[row.provider_id] = unavailableCostAmount(
+            "cents",
+            ENRICHED_INVOCATIONS_SOURCE,
+            `partial cost evidence for provider=${row.provider_id} competition=${competitionId} (${pricedCount}/${rowCount} priced)`
+          );
+          allAvailable = false;
+          partialDetails.push(`${row.provider_id}:${pricedCount}/${rowCount}`);
+          continue;
+        }
+        byProvider[row.provider_id] = availableCostAmount(
+          totalCostCents,
+          "cents",
+          ENRICHED_INVOCATIONS_SOURCE
+        );
+        totalCents += totalCostCents;
+      }
+      if (!allAvailable) {
+        const detail = partialDetails.length > 0 ? `partial or null cost evidence for competition=${competitionId} (${partialDetails.join(", ")})` : `incomplete cost evidence for competition=${competitionId}`;
+        const total2 = unavailableCostAmount("cents", ENRICHED_INVOCATIONS_SOURCE, detail);
+        return {
+          status: "unavailable",
+          byProvider,
+          total: total2,
+          source: ENRICHED_INVOCATIONS_SOURCE,
+          detail
+        };
+      }
+      const total = availableCostAmount(totalCents, "cents", ENRICHED_INVOCATIONS_SOURCE);
+      return {
+        status: "available",
+        byProvider,
+        total,
+        source: ENRICHED_INVOCATIONS_SOURCE
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const total = errorCostAmount(
+        "cents",
+        ENRICHED_INVOCATIONS_SOURCE,
+        message,
+        `query failure for competition=${competitionId}`
+      );
+      return {
+        status: "error",
+        byProvider: {},
+        total,
+        source: ENRICHED_INVOCATIONS_SOURCE,
+        error: message,
+        detail: total.detail
+      };
+    }
+  }
+};
+function generateInvocationId() {
+  return `inv_${Date.now()}_${randomBytes(8).toString("hex")}`;
+}
+function resolveInvocationsDbPath(buildDir) {
+  const dbDir = TelemetryPathResolver.getInstance().resolveDbDir(buildDir);
+  const telemetryDir = path5.basename(dbDir) === "db" ? path5.dirname(dbDir) : dbDir;
+  return path5.join(telemetryDir, "invocations.db");
+}
+
+export {
+  NON_METERED_COST_SQL,
+  SNAPSHOT_FIRST_COST_CENTS_SQL,
+  pricingSourceFromRow,
+  billingSourceFromRow,
+  pricingConfidenceFromRow,
+  longContextFromRow,
+  rateCardFromPricingRow,
+  speedTiersFromRow,
+  rateCardFromModelPricing,
+  cursorModelCacheDir,
+  discoverCursorModels,
+  getCachedCursorModelIds,
+  buildCanonicalMappings,
+  getCachedCanonicalMappings,
+  CURSOR_FALLBACK_MODELS,
+  PassthroughResolver,
+  resolvePassthroughPricing,
+  CACHE_WRITE_LONG_TOKENS_DIMENSION,
+  boundRequestEvidence,
+  listPriceUsageFromRecord,
+  computeListPrice,
+  modelEvidenceAvailability,
+  invocationProvenanceClauses,
+  invocationAnalyticsQualityClauses,
+  invocationProvenanceWhereSql,
+  isInvocationMetricQualityRow,
+  createInvocationAnalyticsViews,
+  resolveCompatibleInvocationModelId,
+  invocationModelMatchesSameModel,
+  ModelInvocationsDB,
+  generateInvocationId,
+  resolveInvocationsDbPath,
+  observedSpeedAvailability,
+  requestEvidenceAvailability,
+  requestedServiceTierAvailability,
+  prepareInvocationRegistry,
+  captureInvocationRegistryVersion,
+  ensurePendingInvocationCostEnrichment,
+  listInvocationProviderIdsSince,
+  summarizeInvocationCostVisibility,
+  availableCostAmount,
+  unavailableCostAmount,
+  errorCostAmount,
+  isAvailableCostAmount,
+  costAmountOrNull,
+  projectCostVisibility,
+  fromVisibilitySummary,
+  formatCostProjectionNotice
+};
+//# sourceMappingURL=chunk-Q64IR2Z2.js.map