@poetic-ai/poetic 1.42.0

package/dist/chunk-GKN3HMN4.js

@@ -0,0 +1,2809 @@
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  sqlite_wrapper_default
+} from "./chunk-45FPSA3B.js";
+import {
+  applySqlitePragmas
+} from "./chunk-QGJDMEOV.js";
+import {
+  ProviderRegistry,
+  ProviderRegistryConfigSchema,
+  registerProviderRegistryReloadInvalidator
+} from "./chunk-AT4TNPWW.js";
+import {
+  getPackageRoot
+} from "./chunk-XZE4XARH.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/telemetry/model-invocations-db.ts
+import { randomBytes } from "crypto";
+import path3 from "path";
+
+// src/telemetry/cost-precedence.ts
+var SNAPSHOT_FIRST_COST_CENTS_SQL = `
+  CASE
+    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 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 fs2 from "fs";
+import path2 from "path";
+import yaml2 from "js-yaml";
+
+// 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(),
+  extra_fees: z.record(z.string(), z.number()).optional(),
+  billing_mode: BillingModeSchema.optional(),
+  billing_source: z.string().optional(),
+  pricing_source: 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()
+});
+var IGNORED_PROVIDER_FILES = /* @__PURE__ */ new Set(["valid-provider.md", "minimal-provider.md"]);
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!match) {
+    throw new Error("Invalid frontmatter: must start with --- and have --- separator");
+  }
+  const [, yamlStr, markdown] = match;
+  const data = yaml.load(yamlStr);
+  return { data, content: markdown || "" };
+}
+function loadProviderFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const { data } = parseFrontmatter(content);
+  const normalized = normalizeProviderFrontmatter(data, filePath);
+  const frontmatter = ProviderFrontmatterZ.parse(normalized);
+  return {
+    providerId: frontmatter.id,
+    displayName: frontmatter.display_name,
+    models: frontmatter.models.map((m) => ({
+      modelId: m.id,
+      displayName: m.display_name,
+      capabilities: m.capabilities,
+      costSchema: m.costSchema
+    })),
+    authHint: frontmatter.auth_hint
+  };
+}
+function computeRegistryVersion(registry) {
+  const sortedProviders = [...registry.providers].sort((a, b) => a.providerId.localeCompare(b.providerId)).map((provider) => ({
+    authHint: provider.authHint,
+    displayName: provider.displayName,
+    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
+    })),
+    providerId: provider.providerId
+  }));
+  const canonical = JSON.stringify(sortedProviders);
+  return crypto.createHash("sha256").update(canonical).digest("hex");
+}
+function loadProviderDirectory(providerDir) {
+  if (!fs.existsSync(providerDir)) {
+    throw new Error(`Providers directory not found: ${providerDir}`);
+  }
+  const providerMap = /* @__PURE__ */ new Map();
+  const files = fs.readdirSync(providerDir).filter((f) => f.endsWith(".md") && !IGNORED_PROVIDER_FILES.has(f));
+  if (files.length === 0) {
+    throw new Error(`No provider manifests found in ${providerDir}`);
+  }
+  for (const file of files) {
+    try {
+      const provider = loadProviderFile(path.join(providerDir, file));
+      providerMap.set(provider.providerId, provider);
+    } catch (error) {
+      throw new Error(
+        `Failed to load provider ${file}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return Array.from(providerMap.values());
+}
+function normalizeProviderFrontmatter(data, filePath) {
+  const providerId = getFirstString(data, ["id", "provider_id"]);
+  if (!providerId) {
+    throw new Error(`Provider manifest ${filePath} is missing required id/provider_id field`);
+  }
+  const displayName = getFirstString(data, ["display_name", "name"]) ?? providerId;
+  const authHint = getFirstString(data, ["auth_hint", "auth", "authHint"]);
+  const rawModels = Array.isArray(data.models) ? data.models : [];
+  const models = rawModels.map((model, index) => normalizeModel(model, filePath, index));
+  return {
+    id: providerId,
+    display_name: displayName,
+    auth_hint: authHint,
+    models
+  };
+}
+function normalizeModel(model, filePath, index) {
+  if (!model || typeof model !== "object") {
+    throw new Error(`Model entry at index ${index} in ${filePath} must be an object`);
+  }
+  const id = getFirstString(model, ["id", "model_id"]);
+  if (!id) {
+    throw new Error(
+      `Model entry at index ${index} in ${filePath} is missing required id/model_id field`
+    );
+  }
+  const displayName = getFirstString(model, ["display_name", "name"]) ?? id;
+  const capabilitiesRaw = Array.isArray(model.capabilities) ? model.capabilities : [];
+  const capabilities = capabilitiesRaw.map((capability) => String(capability));
+  const costSchema = normalizeCostSchema(
+    model.costSchema,
+    model.cost
+  );
+  return {
+    id,
+    display_name: displayName,
+    capabilities,
+    costSchema
+  };
+}
+function normalizeCostSchema(costSchema, legacyCost) {
+  const normalized = {};
+  if (costSchema && typeof costSchema === "object") {
+    const prompt = parseCurrency(
+      costSchema.prompt_per_1k ?? costSchema.promptPer1k
+    );
+    const completion = parseCurrency(
+      costSchema.completion_per_1k ?? costSchema.completionPer1k
+    );
+    const extraFees = parseExtraFees(
+      costSchema.extra_fees ?? costSchema.extraFees
+    );
+    const billingMode = parseBillingMode(
+      costSchema.billing_mode ?? costSchema.billingMode ?? costSchema.pricing_mode
+    );
+    const flatRate = parseCurrency(
+      costSchema.flat_rate_per_seat_month ?? costSchema.flat_rate ?? costSchema.seat_price
+    );
+    const billingSource = parseOptionalString(
+      costSchema.billing_source ?? costSchema.billingSource
+    );
+    const pricingSource = parseOptionalString(
+      costSchema.pricing_source ?? costSchema.pricingSource
+    );
+    const pricingConfidence = parsePricingConfidence(
+      costSchema.pricing_confidence ?? costSchema.pricingConfidence
+    );
+    const notes = parseOptionalString(
+      costSchema.notes ?? costSchema.description
+    );
+    if (prompt !== void 0) {
+      normalized.prompt_per_1k = prompt;
+    }
+    if (completion !== void 0) {
+      normalized.completion_per_1k = completion;
+    }
+    if (extraFees) {
+      normalized.extra_fees = extraFees;
+    }
+    if (billingMode) {
+      normalized.billing_mode = billingMode;
+    }
+    if (flatRate !== void 0) {
+      normalized.flat_rate_per_seat_month = flatRate;
+    }
+    if (billingSource) {
+      normalized.billing_source = billingSource;
+    }
+    if (pricingSource) {
+      normalized.pricing_source = pricingSource;
+    }
+    if (pricingConfidence) {
+      normalized.pricing_confidence = pricingConfidence;
+    }
+    if (notes) {
+      normalized.notes = notes;
+    }
+  }
+  if (legacyCost && typeof legacyCost === "object") {
+    const prompt = parseCurrency(
+      legacyCost.prompt_per_1k_tokens ?? legacyCost.prompt_per_1k ?? legacyCost.promptPer1k
+    );
+    const completion = parseCurrency(
+      legacyCost.completion_per_1k_tokens ?? legacyCost.completion_per_1k ?? legacyCost.completionPer1k
+    );
+    const extraFees = {};
+    const cacheRead = parseCurrency(
+      legacyCost.cache_read_per_1k_tokens ?? legacyCost.cache_read_per_1k
+    );
+    const cacheWrite = parseCurrency(
+      legacyCost.cache_write_per_1k_tokens ?? legacyCost.cache_write_per_1k
+    );
+    if (cacheRead !== void 0) {
+      extraFees.cacheReadPer1k = cacheRead;
+    }
+    if (cacheWrite !== void 0) {
+      extraFees.cacheWritePer1k = cacheWrite;
+    }
+    if (prompt !== void 0 && normalized.prompt_per_1k === void 0) {
+      normalized.prompt_per_1k = prompt;
+    }
+    if (completion !== void 0 && normalized.completion_per_1k === void 0) {
+      normalized.completion_per_1k = completion;
+    }
+    const normalizedExtraFees = Object.keys(extraFees).length > 0 ? extraFees : void 0;
+    if (normalizedExtraFees && !normalized.extra_fees) {
+      normalized.extra_fees = normalizedExtraFees;
+    }
+  }
+  if (Object.keys(normalized).length === 0) {
+    return void 0;
+  }
+  if (!normalized.billing_mode) {
+    normalized.billing_mode = "metered";
+  }
+  if (normalized.billing_mode === "metered" && (typeof normalized.prompt_per_1k !== "number" || typeof normalized.completion_per_1k !== "number")) {
+    return void 0;
+  }
+  return normalized;
+}
+function parseCurrency(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function parseExtraFees(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const entries = {};
+  for (const [key, raw] of Object.entries(value)) {
+    const parsed = parseCurrency(raw);
+    if (parsed !== void 0) {
+      entries[key] = parsed;
+    }
+  }
+  return Object.keys(entries).length > 0 ? entries : void 0;
+}
+function parseBillingMode(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  if (["flat", "flat_rate", "flat-rate", "seat", "seat_licensed"].includes(normalized)) {
+    return "flat_rate";
+  }
+  if (["non_metered", "non-metered", "unmetered", "license"].includes(normalized)) {
+    return "non_metered";
+  }
+  if (["metered", "per_token", "per-token"].includes(normalized)) {
+    return "metered";
+  }
+  return void 0;
+}
+function parsePricingConfidence(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "high" || normalized === "medium" || normalized === "low") {
+    return normalized;
+  }
+  return void 0;
+}
+function parseOptionalString(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  return void 0;
+}
+function getFirstString(source, keys) {
+  if (!source || typeof source !== "object") {
+    return void 0;
+  }
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.trim() !== "") {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+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;
+}
+function saveRegistry(registry, filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const tempPath = path.join(dir, `${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}`);
+  fs.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
+  fs.renameSync(tempPath, filePath);
+}
+function loadRegistry(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  return parseJsonWithContext(content, `model registry: ${filePath}`);
+}
+
+// src/telemetry/worker.ts
+function resolveRegistryModelCandidates(providerId, modelId) {
+  const trimmed = modelId.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  const candidates = /* @__PURE__ */ new Set([trimmed]);
+  let mappings = {};
+  try {
+    mappings = ProviderRegistry.getMappings(providerId);
+  } catch {
+    mappings = {};
+  }
+  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.providerId, modelId);
+  for (const candidate of candidates) {
+    const model = provider.models.find((entry) => entry.modelId === candidate);
+    if (model) {
+      return { model, resolvedModelId: candidate };
+    }
+  }
+  return null;
+}
+function optionalAttributionId(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+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 ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const preferred = db.getRegistrySnapshot(preferredRegistryVersion);
+  if (preferred) {
+    ordered.push(preferred);
+    seen.add(preferred.registryVersion);
+  }
+  for (const snapshot of db.getRegistrySnapshots()) {
+    if (seen.has(snapshot.registryVersion)) continue;
+    ordered.push(snapshot);
+    seen.add(snapshot.registryVersion);
+  }
+  return ordered;
+}
+var TelemetryWorker = class _TelemetryWorker {
+  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);
+  }
+  static interpolatePercentile(sortedValues, percentile) {
+    if (sortedValues.length === 0) {
+      return 0;
+    }
+    const clampedPercentile = Math.min(1, Math.max(0, percentile));
+    const rank = (sortedValues.length - 1) * clampedPercentile;
+    const lowerIndex = Math.floor(rank);
+    const upperIndex = Math.ceil(rank);
+    const lower = sortedValues[lowerIndex] ?? 0;
+    const upper = sortedValues[upperIndex] ?? lower;
+    if (lowerIndex === upperIndex) {
+      return lower;
+    }
+    const weight = rank - lowerIndex;
+    return lower + (upper - lower) * weight;
+  }
+  /**
+   * 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.warn(`Registry snapshot not found for version ${invocation.registryVersion}`);
+          continue;
+        }
+        let resolved = null;
+        let providerSeen = false;
+        for (const snapshot of snapshots) {
+          const registry = parseJsonWithContext(
+            snapshot.jsonBlob,
+            "Model registry snapshot"
+          );
+          if (registry.providers.some((p) => p.providerId === invocation.providerId)) {
+            providerSeen = true;
+          }
+          const candidate = findProviderAndModel(
+            registry,
+            invocation.providerId,
+            invocation.modelId
+          );
+          if (candidate) {
+            resolved = candidate;
+            break;
+          }
+        }
+        if (!resolved) {
+          if (!providerSeen) {
+            this.warn(`Provider ${invocation.providerId} not found in registry`);
+          } else {
+            this.warn(
+              `Model ${invocation.modelId} not found for provider ${invocation.providerId}`
+            );
+          }
+          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 promptPer1k = model.costSchema?.prompt_per_1k ?? 0;
+        let completionPer1k = model.costSchema?.completion_per_1k ?? 0;
+        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}`;
+          promptPer1k = override.promptPer1k;
+          completionPer1k = override.completionPer1k;
+          extraFees = override.extraFees ?? {};
+          billingMode = "metered";
+          pricingConfidence = void 0;
+          billingSource = void 0;
+        }
+        const tokensIn = invocation.tokensIn ?? 0;
+        const tokensOut = invocation.tokensOut ?? 0;
+        let costCents = null;
+        if (billingMode === "metered") {
+          costCents = roundCostCents(
+            tokensIn / 1e3 * promptPer1k * 100 + tokensOut / 1e3 * completionPer1k * 100 + Object.values(extraFees).reduce(
+              (sum, fee) => sum + (typeof fee === "number" ? fee * 100 : 0),
+              0
+            )
+          );
+        } 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,
+          originalModelId,
+          canonicalModelId: resolvedModelId
+        });
+        const inputCostCents = billingMode === "metered" ? roundCostCents(tokensIn / 1e3 * promptPer1k * 100) : 0;
+        const outputCostCents = billingMode === "metered" ? roundCostCents(tokensOut / 1e3 * completionPer1k * 100) : 0;
+        const costSnapshot = JSON.stringify({
+          inputCostCents,
+          outputCostCents,
+          cacheCostCents: 0,
+          toolCostCents: 0,
+          infrastructureCostCents: 0,
+          totalCostCents: costCents ?? 0,
+          currency: "USD",
+          pricingSource,
+          ...pricingConfidence ? { pricingConfidence } : {},
+          billingMode,
+          ...billingSource ? { billingSource } : {},
+          originalModelId,
+          canonicalModelId: resolvedModelId,
+          pricingVersion: 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: invocation.registryVersion,
+          taskId,
+          competitionId,
+          variantId
+        };
+        this.db.insertEnrichedInvocation(enriched);
+        enrichedCount++;
+      } catch (error) {
+        this.error(
+          `Failed to enrich invocation ${invocation.id}:`,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+    return enrichedCount;
+  }
+  /**
+   * Aggregate enriched invocations into hourly buckets
+   * Returns number of aggregates updated
+   */
+  aggregateHourly() {
+    const rows = this.db.db.prepare(
+      `
+      SELECT
+        i.provider_id AS provider_id,
+        i.model_id AS model_id,
+        CAST(i.timestamp / 3600000 AS INTEGER) * 3600000 AS bucket_start,
+        i.tokens_in AS tokens_in,
+        i.tokens_out AS tokens_out,
+        i.total_time_ms AS total_time_ms,
+        i.status AS status,
+        e.billing_mode AS billing_mode,
+        e.computed_cost_cents AS computed_cost_cents
+      FROM model_invocations i
+      LEFT JOIN enriched_invocations e ON i.id = e.invocation_id
+    `
+    ).all();
+    const buckets = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = `${row.provider_id}\0${row.model_id}\0${row.bucket_start}`;
+      let acc = buckets.get(key);
+      if (!acc) {
+        acc = {
+          providerId: row.provider_id,
+          modelId: row.model_id,
+          bucketStart: row.bucket_start,
+          totalInvocations: 0,
+          totalTokensIn: 0,
+          totalTokensOut: 0,
+          errorCount: 0,
+          timings: [],
+          costSum: 0,
+          costCount: 0
+        };
+        buckets.set(key, acc);
+      }
+      acc.totalInvocations += 1;
+      if (typeof row.tokens_in === "number") {
+        acc.totalTokensIn += row.tokens_in;
+      }
+      if (typeof row.tokens_out === "number") {
+        acc.totalTokensOut += row.tokens_out;
+      }
+      if (row.status !== "success") {
+        acc.errorCount += 1;
+      }
+      if (typeof row.total_time_ms === "number" && Number.isFinite(row.total_time_ms)) {
+        acc.timings.push(row.total_time_ms);
+      }
+      const billingQualifies = row.billing_mode === null || row.billing_mode === "metered";
+      if (billingQualifies && typeof row.computed_cost_cents === "number") {
+        acc.costSum += row.computed_cost_cents;
+        acc.costCount += 1;
+      }
+    }
+    let aggregatedCount = 0;
+    for (const acc of buckets.values()) {
+      const sortedTimings = acc.timings.slice().sort((a, b) => a - b);
+      const p95LatencyMs = _TelemetryWorker.interpolatePercentile(sortedTimings, 0.95);
+      const avgCostCents = acc.costCount > 0 ? acc.costSum / acc.costCount : 0;
+      const errorRate = acc.errorCount * 100 / acc.totalInvocations;
+      const aggregate = {
+        bucketStart: acc.bucketStart,
+        providerId: acc.providerId,
+        modelId: acc.modelId,
+        totalInvocations: acc.totalInvocations,
+        totalTokensIn: acc.totalTokensIn,
+        totalTokensOut: acc.totalTokensOut,
+        avgCostCents,
+        p95LatencyMs,
+        errorRate
+      };
+      this.db.upsertHourlyAggregate(aggregate);
+      aggregatedCount++;
+    }
+    return aggregatedCount;
+  }
+  /**
+   * 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 aggregatedCount = this.aggregateHourly();
+    const dailyAggregatedCount = this.aggregateDaily();
+    return { enrichedCount, aggregatedCount, 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.";
+function resolveProvidersDirectory(cwd = process.cwd()) {
+  const packageRoot = getPackageRoot();
+  const artifactsDir = path2.join(cwd, ".poetic", "providers");
+  if (fs2.existsSync(path2.join(artifactsDir, "registry.json"))) {
+    return artifactsDir;
+  }
+  const candidates = [
+    path2.join(cwd, "providers"),
+    path2.join(cwd, ".poetic", "config"),
+    path2.join(packageRoot, ".poetic", "providers"),
+    path2.join(packageRoot, "providers"),
+    path2.join(packageRoot, ".poetic", "config")
+  ];
+  for (const candidate of candidates) {
+    if (!fs2.existsSync(candidate)) continue;
+    if (fs2.existsSync(path2.join(candidate, "registry.json")) || fs2.existsSync(path2.join(candidate, "providers.yaml")) || fs2.readdirSync(candidate, { withFileTypes: true }).some((entry) => entry.name.endsWith(".md"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function per1kCost(modelPricing, input) {
+  if (!modelPricing) return void 0;
+  const per1k = input ? modelPricing.input_per_1k_tokens : modelPricing.output_per_1k_tokens;
+  if (typeof per1k === "number") return per1k;
+  const per1m = input ? modelPricing.input_per_1m_tokens : modelPricing.output_per_1m_tokens;
+  return typeof per1m === "number" ? per1m / 1e3 : void 0;
+}
+function stringMeta(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function confidenceMeta(value) {
+  const raw = stringMeta(value)?.toLowerCase();
+  return raw === "high" || raw === "medium" || raw === "low" ? raw : void 0;
+}
+function pricingMetadata(pricing) {
+  const meta = pricing?._meta && typeof pricing._meta === "object" ? pricing._meta : {};
+  return {
+    ...stringMeta(meta.pricing_source) ? { pricing_source: stringMeta(meta.pricing_source) } : {},
+    ...confidenceMeta(meta.pricing_confidence) ? { pricing_confidence: confidenceMeta(meta.pricing_confidence) } : {},
+    ...stringMeta(meta.billing_source) ? { billing_source: stringMeta(meta.billing_source) } : {}
+  };
+}
+function buildRegistryFromProvidersYaml(filePath) {
+  const parsed = ProviderRegistryConfigSchema.parse(yaml2.load(fs2.readFileSync(filePath, "utf-8")));
+  const providers = Object.entries(parsed.providers).map(
+    ([providerId, provider]) => ({
+      providerId,
+      displayName: provider.display_name,
+      models: provider.models.available.map((model) => {
+        const pricing = provider.pricing?.models?.[model.id];
+        const inputPer1k = per1kCost(pricing, true);
+        const outputPer1k = per1kCost(pricing, false);
+        const metadata = 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
+            }
+          } : inputPer1k !== void 0 || outputPer1k !== void 0 ? {
+            costSchema: {
+              prompt_per_1k: inputPer1k ?? 0,
+              completion_per_1k: outputPer1k ?? 0,
+              billing_mode: "metered",
+              ...metadata,
+              notes: pricing?.notes
+            }
+          } : {}
+        };
+      })
+    })
+  );
+  return buildRegistry(providers);
+}
+function loadBundledRegistry(providersDir) {
+  const registryJsonPath = path2.join(providersDir, "registry.json");
+  if (fs2.existsSync(registryJsonPath)) {
+    return loadRegistry(registryJsonPath);
+  }
+  const providersYamlPath = path2.join(providersDir, "providers.yaml");
+  if (fs2.existsSync(providersYamlPath)) {
+    return buildRegistryFromProvidersYaml(providersYamlPath);
+  }
+  return buildRegistry(loadProviderDirectory(providersDir));
+}
+function ensureRegistrySnapshot(db) {
+  const providersDir = resolveProvidersDirectory();
+  const existingSnapshot = db.getLatestRegistrySnapshot();
+  if (!providersDir) {
+    return Boolean(existingSnapshot);
+  }
+  try {
+    const registry = loadBundledRegistry(providersDir);
+    db.insertRegistrySnapshot({
+      registryVersion: registry.registryVersion,
+      createdAt: Date.now(),
+      jsonBlob: JSON.stringify(registry)
+    });
+    return true;
+  } catch {
+    return Boolean(existingSnapshot);
+  }
+}
+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 summarizeInvocationCostVisibility(db, startTimestampMs) {
+  const rawInvocationCount = db.countRawInvocationsSince(startTimestampMs);
+  const enrichedInvocationCount = db.countEnrichedInvocationsSince(startTimestampMs);
+  const pendingEnrichmentCount = Math.max(0, rawInvocationCount - enrichedInvocationCount);
+  if (rawInvocationCount === 0) {
+    return {
+      rawInvocationCount,
+      enrichedInvocationCount,
+      pendingEnrichmentCount,
+      visibility: "no_invocations",
+      hint: NO_INVOCATIONS_HINT
+    };
+  }
+  if (pendingEnrichmentCount > 0) {
+    return {
+      rawInvocationCount,
+      enrichedInvocationCount,
+      pendingEnrichmentCount,
+      visibility: "pending_enrichment",
+      hint: PENDING_ENRICHMENT_HINT
+    };
+  }
+  const hasTokenUsage = db.hasTokenUsageSince(startTimestampMs);
+  if (!hasTokenUsage) {
+    return {
+      rawInvocationCount,
+      enrichedInvocationCount,
+      pendingEnrichmentCount,
+      visibility: "zero_usage",
+      hint: ZERO_USAGE_HINT
+    };
+  }
+  return {
+    rawInvocationCount,
+    enrichedInvocationCount,
+    pendingEnrichmentCount,
+    visibility: "enriched"
+  };
+}
+function resolveInvocationRegistryVersion(db) {
+  return db.getLatestRegistryVersion() ?? "v1";
+}
+
+// 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.visibility === "zero_usage" ? RAW_ZERO_USAGE_HINT : summary.hint;
+    case "enriched":
+      return summary.rawInvocationCount === 0 ? NO_INVOCATIONS_HINT2 : void 0;
+  }
+}
+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";
+  const hint = resolveHint(state, summary);
+  return {
+    rawInvocationCount: summary.rawInvocationCount,
+    enrichedInvocationCount: summary.enrichedInvocationCount,
+    pendingEnrichmentCount: summary.pendingEnrichmentCount,
+    state,
+    visibility: summary.visibility,
+    totalsMayUnderReport,
+    ...hint ? { hint } : {}
+  };
+}
+function formatCostProjectionNotice(projection) {
+  if (projection.state === "enriched" && projection.rawInvocationCount === 0) {
+    return NO_INVOCATIONS_HINT2;
+  }
+  if (projection.state === "enriched") {
+    return void 0;
+  }
+  const counts = projection.pendingEnrichmentCount > 0 ? ` (${projection.pendingEnrichmentCount} pending of ${projection.rawInvocationCount} raw)` : projection.rawInvocationCount > 0 ? ` (${projection.rawInvocationCount} raw)` : "";
+  return `${projection.hint ?? ""}${counts}`.trim() || void 0;
+}
+
+// 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 invocationAnalyticsQualityWhereSql(alias) {
+  return clausesToAndSql(invocationAnalyticsQualityClauses(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 ALLOWED_TABLE_NAMES = [
+  "model_invocations",
+  "registry_snapshots",
+  "enriched_invocations",
+  "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;
+}
+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);
+      const bedrock = model.bedrock;
+      if (bedrock) {
+        addAlternate(index, bedrock.base_model_id, model.id);
+        addAlternate(index, bedrock.global, model.id);
+        addAlternate(index, bedrock.us, model.id);
+        addAlternate(index, bedrock.eu, model.id);
+        addAlternate(index, bedrock.jp, model.id);
+        addAlternate(index, bedrock.apac, 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;
+  constructor(dbPath) {
+    if (!sqlite_wrapper_default) {
+      throw new Error("Database implementation not available");
+    }
+    this.dbPath = dbPath;
+    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
+      );
+
+      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);
+
+      -- Hourly aggregates table
+      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("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");
+  }
+  /**
+   * 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
+      ) 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
+    );
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Insert a registry snapshot
+   */
+  insertRegistrySnapshot(snapshot) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE 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);
+  }
+  /**
+   * Upsert hourly aggregate
+   */
+  upsertHourlyAggregate(aggregate) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO aggregates_hourly (
+        bucket_start, provider_id, model_id, total_invocations,
+        total_tokens_in, total_tokens_out, avg_cost_cents,
+        p95_latency_ms, error_rate
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      aggregate.bucketStart,
+      aggregate.providerId,
+      aggregate.modelId,
+      aggregate.totalInvocations,
+      aggregate.totalTokensIn,
+      aggregate.totalTokensOut,
+      aggregate.avgCostCents,
+      aggregate.p95LatencyMs,
+      aggregate.errorRate
+    );
+  }
+  /**
+   * Get hourly aggregates for a time range
+   */
+  getHourlyAggregates(providerId, modelId, startBucket, endBucket) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM aggregates_hourly
+      WHERE provider_id = ? AND model_id = ?
+        AND bucket_start >= ? AND bucket_start <= ?
+      ORDER BY bucket_start ASC
+    `);
+    const rows = stmt.all(providerId, modelId, startBucket, endBucket) ?? [];
+    return rows.map(
+      (row) => convertRowToCamelCase(row)
+    ).filter((x) => x !== null);
+  }
+  /**
+   * Get cost breakdown by agent role for swarm executions
+   * Returns aggregated cost metrics grouped by agent role
+   */
+  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(AVG(CASE WHEN e.billing_mode IS NULL OR e.billing_mode = 'metered' THEN e.computed_cost_cents END), 0) as avg_cost_cents
+      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 avg_cost_cents DESC
+    `;
+    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 = {}) {
+    let rows;
+    try {
+      const stmt = this.db.prepare(`
+        SELECT
+          provider_id,
+          model_id,
+          time_to_first_token_ms,
+          tokens_out,
+          total_time_ms
+        FROM model_invocations
+	        WHERE time_to_first_token_ms IS NOT NULL
+	          AND status = 'success'
+          ${options.includeRaw ? "" : invocationAnalyticsQualityWhereSql()}
+        ORDER BY provider_id, model_id, time_to_first_token_ms ASC
+      `);
+      rows = stmt.all();
+    } catch {
+      return [];
+    }
+    if (rows.length === 0) return [];
+    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 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 legacyNative = this.queryPreseededDailyCostAggregationsNative(startDate, endDate);
+      if (liveNative.length === 0) {
+        const rows2 = this.aggregateNativeDailyCostRows(legacyNative, groupBy);
+        return this.buildDailyCostResultFromRows(rows2);
+      }
+      if (legacyNative.length === 0) {
+        const rows2 = this.aggregateNativeDailyCostRows(
+          this.buildDailyCostRowsFromLive(liveNative),
+          groupBy
+        );
+        return this.buildDailyCostResultFromRows(rows2);
+      }
+      const mergedNative = this.mergeLiveAndLegacyAtNativeKey(liveNative, 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"
+      };
+    }
+  }
+  /**
+   * 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((${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 || totalCostCentsValue === void 0 ? 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,
+      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 === 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
+        e.invocation_id,
+        i.timestamp,
+        i.provider_id,
+        i.model_id,
+        e.usage_data,
+        e.cost_snapshot,
+        e.computed_cost_cents,
+        e.pricing_version,
+        e.pricing_source,
+        e.task_id,
+        e.competition_id,
+        i.agent_role,
+        e.variant_id
+      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 ? parseJsonWithContext(row.usage_data, "Execution usage data") : null;
+    const costSnapshot = row.cost_snapshot ? parseJsonWithContext(row.cost_snapshot, "Cost snapshot") : null;
+    const resolvedCostSnapshot = resolveSnapshotFirstCostSnapshot({
+      costSnapshot,
+      computedCostCents: row.computed_cost_cents
+    });
+    if (!usage || !resolvedCostSnapshot) {
+      return null;
+    }
+    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: resolvedCostSnapshot,
+      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
+    };
+  }
+  /**
+   * 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
+        e.invocation_id,
+        i.timestamp,
+        i.provider_id,
+        i.model_id,
+        e.usage_data,
+        e.cost_snapshot,
+        e.computed_cost_cents,
+        e.pricing_version,
+        e.pricing_source,
+        e.task_id,
+        e.competition_id,
+        i.agent_role,
+        e.variant_id
+      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 ? parseJsonWithContext(row.usage_data, "Execution usage data") : null;
+      const costSnapshot = row.cost_snapshot ? parseJsonWithContext(row.cost_snapshot, "Cost snapshot") : null;
+      const resolvedCostSnapshot = resolveSnapshotFirstCostSnapshot({
+        costSnapshot,
+        computedCostCents: row.computed_cost_cents
+      });
+      if (!usage || !resolvedCostSnapshot) {
+        return null;
+      }
+      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: resolvedCostSnapshot,
+        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
+      };
+    });
+    return mappedRecords.filter((record) => record !== null);
+  }
+  /**
+   * Get all execution costs for a competition
+   */
+  getCompetitionExecutionCosts(competitionId) {
+    const stmt = this.db.prepare(`
+      SELECT
+        e.invocation_id,
+        i.timestamp,
+        i.provider_id,
+        i.model_id,
+        e.usage_data,
+        e.cost_snapshot,
+        e.computed_cost_cents,
+        e.pricing_version,
+        e.pricing_source,
+        e.task_id,
+        e.competition_id,
+        i.agent_role,
+        e.variant_id
+      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 ? parseJsonWithContext(row.usage_data, "Execution usage data") : null;
+      const costSnapshot = row.cost_snapshot ? parseJsonWithContext(row.cost_snapshot, "Cost snapshot") : null;
+      const resolvedCostSnapshot = resolveSnapshotFirstCostSnapshot({
+        costSnapshot,
+        computedCostCents: row.computed_cost_cents
+      });
+      if (!usage || !resolvedCostSnapshot) {
+        return null;
+      }
+      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: resolvedCostSnapshot,
+        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
+      };
+    });
+    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;
+  }
+  /**
+   * Whether any invocation in the window reported non-zero token usage.
+   */
+  hasTokenUsageSince(startTimestampMs) {
+    const stmt = this.db.prepare(`
+      SELECT 1
+      FROM model_invocations
+      WHERE timestamp >= ?
+        AND (
+          COALESCE(tokens_in, 0) > 0
+          OR COALESCE(tokens_out, 0) > 0
+        )
+      LIMIT 1
+    `);
+    return Boolean(stmt.get(startTimestampMs));
+  }
+  /**
+   * 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
+        e.invocation_id,
+        i.timestamp,
+        i.provider_id,
+        i.model_id,
+        i.tokens_in,
+        i.tokens_out,
+        e.usage_data,
+        e.cost_snapshot,
+        e.computed_cost_cents,
+        e.pricing_version,
+        e.pricing_source,
+        e.task_id,
+        e.competition_id,
+        i.agent_role,
+        e.variant_id
+      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 ? parseJsonWithContext(row.usage_data, "Execution usage data") : {
+        inputTokens: row.tokens_in ?? 0,
+        outputTokens: row.tokens_out ?? 0
+      };
+      const costSnapshot = row.cost_snapshot ? parseJsonWithContext(row.cost_snapshot, "Cost snapshot") : null;
+      const resolvedCostSnapshot = resolveSnapshotFirstCostSnapshot({
+        costSnapshot,
+        computedCostCents: row.computed_cost_cents
+      });
+      if (!resolvedCostSnapshot) {
+        return null;
+      }
+      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: resolvedCostSnapshot,
+        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
+      };
+    });
+    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(poeticDir) {
+  return path3.join(poeticDir, "telemetry", "invocations.db");
+}
+
+export {
+  loadProviderDirectory,
+  buildRegistry,
+  saveRegistry,
+  SNAPSHOT_FIRST_COST_CENTS_SQL,
+  ensurePendingInvocationCostEnrichment,
+  summarizeInvocationCostVisibility,
+  resolveInvocationRegistryVersion,
+  availableCostAmount,
+  unavailableCostAmount,
+  errorCostAmount,
+  isAvailableCostAmount,
+  costAmountOrNull,
+  projectCostVisibility,
+  fromVisibilitySummary,
+  formatCostProjectionNotice,
+  invocationAnalyticsQualityClauses,
+  invocationProvenanceWhereSql,
+  isInvocationMetricQualityRow,
+  resolveCompatibleInvocationModelId,
+  invocationModelMatchesSameModel,
+  ModelInvocationsDB,
+  generateInvocationId,
+  resolveInvocationsDbPath
+};
+//# sourceMappingURL=chunk-GKN3HMN4.js.map