@hasna/economy 0.4.0 → 0.5.1

package/dist/chunks/index-2hwzmfgv.js

@@ -0,0 +1,3407 @@
+// @bun
+// src/db/observation-schema.ts
+var OBSERVATION_COLUMNS = {
+  usage_snapshots: {
+    provider: "TEXT NOT NULL DEFAULT ''",
+    account_key: "TEXT NOT NULL DEFAULT ''",
+    observed_at: "TEXT",
+    source_timestamp: "TEXT",
+    window_start: "TEXT",
+    window_end: "TEXT",
+    reset_at: "TEXT",
+    window_seconds: "INTEGER",
+    value_kind: "TEXT NOT NULL DEFAULT 'unknown'"
+  },
+  subscriptions: {
+    account_key: "TEXT NOT NULL DEFAULT ''",
+    observed_station: "TEXT",
+    observed_at: "TEXT",
+    fee_basis: "TEXT NOT NULL DEFAULT 'unknown'",
+    included_basis: "TEXT NOT NULL DEFAULT 'unknown'"
+  }
+};
+var SCAN_RECEIPTS_SQL = `CREATE TABLE IF NOT EXISTS scan_receipts (
+  id TEXT PRIMARY KEY, machine_id TEXT NOT NULL, source TEXT NOT NULL,
+  attempted_at TEXT NOT NULL, completed_at TEXT NOT NULL, status TEXT NOT NULL,
+  latest_event_at TEXT, parser_version TEXT NOT NULL, error_code TEXT,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_scan_receipts_machine_source
+  ON scan_receipts(machine_id, source, completed_at);`;
+var OBSERVATION_PG_MIGRATIONS = [
+  ...Object.entries(OBSERVATION_COLUMNS).flatMap(([table, columns]) => Object.entries(columns).map(([column, type]) => `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${column} ${type}`)),
+  SCAN_RECEIPTS_SQL
+];
+
+// src/db/observation-provenance.ts
+import { createHash } from "crypto";
+
+// src/db/ingest-errors.ts
+class IngestError extends Error {
+  status;
+  code;
+  field;
+  expected;
+  constructor(status, code, field, expected) {
+    super(`${field}: ${expected}`);
+    this.status = status;
+    this.code = code;
+    this.field = field;
+    this.expected = expected;
+    this.name = "IngestError";
+  }
+}
+
+// src/db/observation-provenance.ts
+var SCAN_ERROR_CODES = [
+  "SOURCE_MISSING",
+  "SOURCE_UNREADABLE",
+  "SOURCE_INVALID",
+  "LEGACY_AGGREGATE_REQUIRES_MIGRATION",
+  "USAGE_EVENTS_UNAVAILABLE",
+  "USAGE_EVENTS_INCOMPLETE",
+  "PROVIDER_CREDENTIAL_UNAVAILABLE",
+  "PROVIDER_CREDENTIAL_UNREADABLE",
+  "PROVIDER_AUTH_REFUSED",
+  "PROVIDER_REFUSED",
+  "PROVIDER_UNAVAILABLE",
+  "ACCOUNT_IDENTITY_UNAVAILABLE",
+  "SUBSCRIPTION_QUOTA_NOT_APPLICABLE",
+  "TEAM_USAGE_ATTRIBUTION_UNAVAILABLE",
+  "CROSS_APP_LOCAL_READ_REFUSED",
+  "COLLECTION_FAILED"
+];
+var digest = (parts) => createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+function observationId(input) {
+  return digest([input.provider, input.account_key, input.machine_id, input.metric, new Date(input.observed_at).toISOString()]);
+}
+function subscriptionId(input) {
+  return digest([input.provider, input.account_key]);
+}
+function scanReceiptId(input) {
+  return digest([input.machine_id, input.source, new Date(input.attempted_at).toISOString()]);
+}
+var invalid = (path, expected) => {
+  throw new IngestError(400, "INVALID_INGEST", path, expected);
+};
+function required(row, keys, path) {
+  for (const key of keys)
+    if (typeof row[key] !== "string" || !row[key].trim() || row[key].length > 256) {
+      invalid(`${path}.${key}`, "expected nonempty text of at most 256 characters");
+    }
+}
+function validateObservationProvenance(table, row, path) {
+  if (table === "usage_snapshots") {
+    if (!["gauge", "cumulative", "delta", "unknown"].includes(String(row["value_kind"] === undefined ? "unknown" : row["value_kind"])))
+      invalid(`${path}.value_kind`, "expected gauge, cumulative, delta or unknown");
+    const newProvenance = ["provider", "account_key", "observed_at", "source_timestamp", "window_start", "window_end", "reset_at", "window_seconds"].some((k) => row[k] != null && row[k] !== "") || row["value_kind"] != null && row["value_kind"] !== "unknown";
+    if (newProvenance) {
+      required(row, ["provider", "account_key", "machine_id", "observed_at", "metric"], path);
+      if (row["id"] !== observationId(row))
+        invalid(`${path}.id`, "expected SHA-256 identity of provider, account_key, machine_id, metric and observed_at");
+      if (row["date"] !== String(row["observed_at"]).slice(0, 10))
+        invalid(`${path}.date`, "expected the UTC observation date");
+      if (row["window_seconds"] != null && (!Number.isSafeInteger(row["window_seconds"]) || Number(row["window_seconds"]) <= 0))
+        invalid(`${path}.window_seconds`, "expected positive integer seconds or null");
+      if (row["window_start"] && row["window_end"] && Date.parse(String(row["window_start"])) >= Date.parse(String(row["window_end"])))
+        invalid(`${path}.window_end`, "expected a time after window_start");
+    }
+  }
+  if (table === "subscriptions") {
+    for (const key of ["fee_basis", "included_basis"])
+      if (!["unknown", "observed", "configured"].includes(String(row[key] === undefined ? "unknown" : row[key])))
+        invalid(`${path}.${key}`, "expected unknown, observed or configured");
+    const identified = row["account_key"] != null && row["account_key"] !== "" || row["observed_at"] != null;
+    if (identified || ["fee_basis", "included_basis"].some((k) => row[k] != null && row[k] !== "unknown")) {
+      required(row, ["provider", "account_key", "observed_at"], path);
+      if (row["id"] !== subscriptionId(row))
+        invalid(`${path}.id`, "expected SHA-256 identity of provider and account_key");
+      if (row["updated_at"] !== row["observed_at"])
+        invalid(`${path}.updated_at`, "expected the observation timestamp");
+    }
+  }
+  if (table === "scan_receipts") {
+    required(row, ["machine_id", "source", "attempted_at", "completed_at", "parser_version"], path);
+    if (!["success", "unchanged", "missing", "unsupported", "failed"].includes(String(row["status"])))
+      invalid(`${path}.status`, "expected success, unchanged, missing, unsupported or failed");
+    if (row["id"] !== scanReceiptId(row))
+      invalid(`${path}.id`, "expected SHA-256 identity of machine_id, source and attempted_at");
+    if (Date.parse(String(row["completed_at"])) < Date.parse(String(row["attempted_at"])))
+      invalid(`${path}.completed_at`, "expected a time at or after attempted_at");
+    if (row["updated_at"] !== row["completed_at"])
+      invalid(`${path}.updated_at`, "expected completed_at");
+    if (row["error_code"] != null && (typeof row["error_code"] !== "string" || !SCAN_ERROR_CODES.includes(row["error_code"])))
+      invalid(`${path}.error_code`, "expected a supported authored scan error code or null");
+    if (["success", "unchanged"].includes(String(row["status"])) && row["error_code"] != null)
+      invalid(`${path}.error_code`, "expected null for a successful scan");
+  }
+}
+
+// src/db/ingest-validation.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/db/ingest-specs.ts
+var numOr = (v, d = 0) => {
+  if (v == null)
+    return d;
+  const num = Number(v);
+  return Number.isFinite(num) ? num : d;
+};
+var strOr = (v, d = "") => v == null ? d : String(v);
+function ingestSpecs() {
+  return [
+    {
+      table: "requests",
+      pk: ["id"],
+      columns: [
+        "id",
+        "agent",
+        "session_id",
+        "model",
+        "input_tokens",
+        "output_tokens",
+        "cache_read_tokens",
+        "cache_create_tokens",
+        "cache_create_5m_tokens",
+        "cache_create_1h_tokens",
+        "cost_usd",
+        "cost_basis",
+        "duration_ms",
+        "timestamp",
+        "source_request_id",
+        "machine_id",
+        "cost_center_id",
+        "attribution_tag",
+        "account_key",
+        "account_tool",
+        "account_name",
+        "account_email",
+        "account_source",
+        "updated_at",
+        "synced_at"
+      ],
+      map: (r, now) => [
+        strOr(r["id"]),
+        strOr(r["agent"]),
+        strOr(r["session_id"]),
+        strOr(r["model"]),
+        numOr(r["input_tokens"]),
+        numOr(r["output_tokens"]),
+        numOr(r["cache_read_tokens"]),
+        numOr(r["cache_create_tokens"]),
+        numOr(r["cache_create_5m_tokens"] ?? r["cache_create_tokens"]),
+        numOr(r["cache_create_1h_tokens"]),
+        numOr(r["cost_usd"]),
+        strOr(r["cost_basis"], "estimated"),
+        numOr(r["duration_ms"]),
+        strOr(r["timestamp"]),
+        r["source_request_id"] == null ? null : strOr(r["source_request_id"]),
+        strOr(r["machine_id"]),
+        r["cost_center_id"] == null ? null : strOr(r["cost_center_id"]),
+        strOr(r["attribution_tag"]),
+        strOr(r["account_key"]),
+        strOr(r["account_tool"]),
+        strOr(r["account_name"]),
+        strOr(r["account_email"]),
+        strOr(r["account_source"]),
+        strOr(r["updated_at"], now),
+        strOr(r["synced_at"])
+      ]
+    },
+    {
+      table: "sessions",
+      pk: ["id"],
+      columns: [
+        "id",
+        "agent",
+        "project_path",
+        "project_name",
+        "started_at",
+        "ended_at",
+        "total_cost_usd",
+        "total_tokens",
+        "request_count",
+        "machine_id",
+        "cost_center_id",
+        "attribution_tag",
+        "account_key",
+        "account_tool",
+        "account_name",
+        "account_email",
+        "account_source",
+        "updated_at",
+        "synced_at"
+      ],
+      map: (r, now) => [
+        strOr(r["id"]),
+        strOr(r["agent"]),
+        strOr(r["project_path"]),
+        strOr(r["project_name"]),
+        strOr(r["started_at"]),
+        r["ended_at"] == null ? null : strOr(r["ended_at"]),
+        numOr(r["total_cost_usd"]),
+        numOr(r["total_tokens"]),
+        numOr(r["request_count"]),
+        strOr(r["machine_id"]),
+        r["cost_center_id"] == null ? null : strOr(r["cost_center_id"]),
+        strOr(r["attribution_tag"]),
+        strOr(r["account_key"]),
+        strOr(r["account_tool"]),
+        strOr(r["account_name"]),
+        strOr(r["account_email"]),
+        strOr(r["account_source"]),
+        strOr(r["updated_at"], now),
+        strOr(r["synced_at"])
+      ]
+    },
+    {
+      table: "projects",
+      pk: ["id"],
+      columns: ["id", "path", "name", "description", "tags", "created_at"],
+      map: (r) => [
+        strOr(r["id"]),
+        strOr(r["path"]),
+        strOr(r["name"]),
+        r["description"] == null ? null : strOr(r["description"]),
+        typeof r["tags"] === "string" ? r["tags"] : JSON.stringify(r["tags"] ?? []),
+        strOr(r["created_at"])
+      ]
+    },
+    {
+      table: "budgets",
+      pk: ["id"],
+      columns: ["id", "project_path", "agent", "period", "limit_usd", "alert_at_percent", "cost_center_id", "created_at", "updated_at", "metric"],
+      map: (r) => [
+        strOr(r["id"]),
+        r["project_path"] == null ? null : strOr(r["project_path"]),
+        r["agent"] == null ? null : strOr(r["agent"]),
+        strOr(r["period"]),
+        numOr(r["limit_usd"]),
+        numOr(r["alert_at_percent"], 80),
+        r["cost_center_id"] == null ? null : strOr(r["cost_center_id"]),
+        strOr(r["created_at"]),
+        strOr(r["updated_at"]),
+        strOr(r["metric"], "legacy_request_cost_usd")
+      ]
+    },
+    {
+      table: "goals",
+      pk: ["id"],
+      columns: ["id", "period", "project_path", "agent", "limit_usd", "created_at", "updated_at"],
+      map: (r) => [
+        strOr(r["id"]),
+        strOr(r["period"]),
+        r["project_path"] == null ? null : strOr(r["project_path"]),
+        r["agent"] == null ? null : strOr(r["agent"]),
+        numOr(r["limit_usd"]),
+        strOr(r["created_at"]),
+        strOr(r["updated_at"])
+      ]
+    },
+    {
+      table: "billing_daily",
+      pk: ["date", "provider", "description"],
+      columns: ["date", "provider", "description", "cost_usd", "updated_at"],
+      map: (r) => [strOr(r["date"]), strOr(r["provider"]), strOr(r["description"]), numOr(r["cost_usd"]), strOr(r["updated_at"])]
+    },
+    {
+      table: "model_pricing",
+      pk: ["model"],
+      columns: [
+        "model",
+        "input_per_1m",
+        "output_per_1m",
+        "cache_read_per_1m",
+        "cache_write_per_1m",
+        "cache_write_1h_per_1m",
+        "cache_storage_per_1m_hour",
+        "updated_at"
+      ],
+      map: (r) => [
+        strOr(r["model"]),
+        numOr(r["input_per_1m"]),
+        numOr(r["output_per_1m"]),
+        numOr(r["cache_read_per_1m"]),
+        numOr(r["cache_write_per_1m"]),
+        numOr(r["cache_write_1h_per_1m"]),
+        numOr(r["cache_storage_per_1m_hour"]),
+        strOr(r["updated_at"])
+      ]
+    },
+    {
+      table: "subscriptions",
+      pk: ["id"],
+      columns: [
+        "id",
+        "agent",
+        "provider",
+        "plan",
+        "monthly_fee_usd",
+        "included_usage_usd",
+        "billing_cycle_start",
+        "reset_policy",
+        "active",
+        "created_at",
+        "updated_at",
+        "account_key",
+        "observed_station",
+        "observed_at",
+        "fee_basis",
+        "included_basis"
+      ],
+      map: (r) => [
+        strOr(r["id"]),
+        r["agent"] == null ? null : strOr(r["agent"]),
+        strOr(r["provider"]),
+        strOr(r["plan"]),
+        numOr(r["monthly_fee_usd"]),
+        numOr(r["included_usage_usd"]),
+        r["billing_cycle_start"] == null ? null : strOr(r["billing_cycle_start"]),
+        strOr(r["reset_policy"], "unknown"),
+        numOr(r["active"], 1),
+        strOr(r["created_at"]),
+        strOr(r["updated_at"]),
+        strOr(r["account_key"]),
+        r["observed_station"] ?? null,
+        r["observed_at"] ?? null,
+        strOr(r["fee_basis"], "unknown"),
+        strOr(r["included_basis"], "unknown")
+      ]
+    },
+    {
+      table: "usage_snapshots",
+      pk: ["id"],
+      columns: [
+        "id",
+        "agent",
+        "date",
+        "metric",
+        "value",
+        "unit",
+        "machine_id",
+        "updated_at",
+        "provider",
+        "account_key",
+        "observed_at",
+        "source_timestamp",
+        "window_start",
+        "window_end",
+        "reset_at",
+        "window_seconds",
+        "value_kind"
+      ],
+      map: (r, now) => [
+        strOr(r["id"], `${strOr(r["agent"])}-${strOr(r["date"])}-${strOr(r["metric"])}-${strOr(r["machine_id"])}`),
+        strOr(r["agent"]),
+        strOr(r["date"]),
+        strOr(r["metric"]),
+        numOr(r["value"]),
+        strOr(r["unit"]),
+        strOr(r["machine_id"]),
+        strOr(r["updated_at"], now),
+        strOr(r["provider"]),
+        strOr(r["account_key"]),
+        r["observed_at"] ?? null,
+        r["source_timestamp"] ?? null,
+        r["window_start"] ?? null,
+        r["window_end"] ?? null,
+        r["reset_at"] ?? null,
+        r["window_seconds"] ?? null,
+        strOr(r["value_kind"], "unknown")
+      ]
+    },
+    {
+      table: "scan_receipts",
+      pk: ["id"],
+      columns: ["id", "machine_id", "source", "attempted_at", "completed_at", "status", "latest_event_at", "parser_version", "error_code", "updated_at"],
+      map: (r) => [strOr(r["id"]), strOr(r["machine_id"]), strOr(r["source"]), strOr(r["attempted_at"]), strOr(r["completed_at"]), strOr(r["status"]), r["latest_event_at"] ?? null, strOr(r["parser_version"]), r["error_code"] ?? null, strOr(r["updated_at"], strOr(r["completed_at"]))]
+    }
+  ];
+}
+
+// src/lib/agents.ts
+var AGENTS = [
+  "claude",
+  "takumi",
+  "codex",
+  "gemini",
+  "opencode",
+  "cursor",
+  "pi",
+  "hermes"
+];
+function isAgent(value) {
+  return AGENTS.includes(value);
+}
+
+// src/db/ingest-validation.ts
+var MAX_INGEST_ROWS = 1e4;
+var MAX_INGEST_BYTES = 4 * 1024 * 1024;
+var integers = new Set([
+  "input_tokens",
+  "output_tokens",
+  "cache_read_tokens",
+  "cache_create_tokens",
+  "cache_create_5m_tokens",
+  "cache_create_1h_tokens",
+  "duration_ms",
+  "total_tokens",
+  "request_count",
+  "active",
+  "window_seconds"
+]);
+var numeric = new Set([
+  ...integers,
+  "cost_usd",
+  "total_cost_usd",
+  "limit_usd",
+  "alert_at_percent",
+  "input_per_1m",
+  "output_per_1m",
+  "cache_read_per_1m",
+  "cache_write_per_1m",
+  "cache_write_1h_per_1m",
+  "cache_storage_per_1m_hour",
+  "monthly_fee_usd",
+  "included_usage_usd",
+  "value"
+]);
+var required2 = {
+  requests: ["id", "agent", "session_id", "model", "timestamp"],
+  sessions: ["id", "agent", "started_at"],
+  projects: ["id", "path", "name", "created_at"],
+  budgets: ["id", "period"],
+  goals: ["id", "period"],
+  billing_daily: ["date", "provider"],
+  model_pricing: ["model"],
+  subscriptions: ["id", "provider", "plan"],
+  usage_snapshots: ["id", "agent", "date", "metric", "unit"],
+  scan_receipts: ["id", "machine_id", "source", "attempted_at", "completed_at", "status", "parser_version"]
+};
+function stableJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((k) => `${JSON.stringify(k)}:${stableJson(record[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function canonicalIngestBodyHash(body) {
+  return createHash2("sha256").update(stableJson(body)).digest("hex");
+}
+function invalid2(field, expected) {
+  throw new IngestError(400, "INVALID_INGEST", field, expected);
+}
+function plain(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function date(value) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
+}
+function instant(value) {
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value) && date(value.slice(0, 10)) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 19) === value.slice(0, 19);
+}
+function validateIngest(body) {
+  if (!plain(body))
+    invalid2("body", "expected an object of supported table arrays");
+  const specs = ingestSpecs();
+  const allowed = new Set(["schema_version", "idempotency_key", "subscription_mode", "budget_mode", ...specs.map((s) => s.table)]);
+  for (const key of Object.keys(body))
+    if (!allowed.has(key))
+      invalid2("body", "unknown field; expected a supported table, schema_version, subscription_mode, budget_mode or idempotency_key");
+  if (body["subscription_mode"] !== undefined && (typeof body["subscription_mode"] !== "string" || !["quota_observation", "configuration"].includes(body["subscription_mode"]) || !Array.isArray(body["subscriptions"]))) {
+    invalid2("subscription_mode", "expected quota_observation or configuration with a subscriptions array");
+  }
+  if (body["schema_version"] !== undefined && body["schema_version"] !== 1)
+    invalid2("schema_version", "expected 1");
+  if (body["idempotency_key"] !== undefined && (typeof body["idempotency_key"] !== "string" || !/^[A-Za-z0-9._:-]{1,200}$/.test(body["idempotency_key"])))
+    invalid2("idempotency_key", "expected 1\u2013200 letters, digits, dot, underscore, colon or hyphen");
+  const createBudget = body["budget_mode"] !== undefined;
+  if (createBudget) {
+    if (body["budget_mode"] !== "create")
+      invalid2("budget_mode", "expected create");
+    if (body["schema_version"] !== 1)
+      invalid2("schema_version", "budget creation requires 1");
+    if (typeof body["idempotency_key"] !== "string")
+      invalid2("idempotency_key", "budget creation requires a stable caller-owned key");
+    if (Object.keys(body).some((k) => !["schema_version", "idempotency_key", "budget_mode", "budgets"].includes(k)))
+      invalid2("body", "budget creation accepts only schema_version, idempotency_key, budget_mode and budgets");
+    if (!Array.isArray(body["budgets"]) || body["budgets"].length !== 1)
+      invalid2("budgets", "budget creation requires exactly one rule");
+  }
+  let count = 0;
+  let bytes = 0;
+  const groups = [];
+  for (const spec of specs) {
+    const input = body[spec.table];
+    if (input === undefined)
+      continue;
+    if (!Array.isArray(input))
+      invalid2(spec.table, "expected an array");
+    count += input.length;
+    if (count > MAX_INGEST_ROWS)
+      throw new IngestError(413, "INGEST_TOO_LARGE", "body", `maximum ${MAX_INGEST_ROWS} rows; split into bounded commands`);
+    const rows = [];
+    for (let i = 0;i < input.length; i++) {
+      const raw = input[i];
+      const path = `${spec.table}[${i}]`;
+      if (!plain(raw))
+        invalid2(path, "expected a row object");
+      const row = {};
+      for (const key of Object.keys(raw)) {
+        if (!spec.columns.includes(key))
+          invalid2(/^[a-z_]{1,64}$/.test(key) ? `${path}.${key}` : path, "unknown column for this table");
+        const value = raw[key];
+        if (["observed_at", "source_timestamp", "window_start", "window_end", "reset_at", "attempted_at", "completed_at", "latest_event_at"].includes(key) && value === "")
+          invalid2(`${path}.${key}`, "expected an ISO UTC timestamp or null");
+        if (numeric.has(key) && !(key === "window_seconds" && value === null)) {
+          if (typeof value !== "number" || !Number.isFinite(value) || integers.has(key) && !Number.isSafeInteger(value) || value < 0 && !(spec.table === "billing_daily" && key === "cost_usd"))
+            invalid2(`${path}.${key}`, "expected a finite numeric value in the supported range");
+          if (key === "active" && value !== 0 && value !== 1)
+            invalid2(`${path}.active`, "expected 0 or 1");
+        } else if (key === "tags" && Array.isArray(value)) {
+          if (value.length > 100 || value.some((t) => typeof t !== "string" || t.length > 256))
+            invalid2(`${path}.tags`, "expected at most 100 string tags of at most 256 characters");
+        } else if (value !== null && (typeof value !== "string" || value.length > 16384 || value.includes("\x00"))) {
+          invalid2(`${path}.${key}`, "expected text of at most 16384 characters without NUL, or null");
+        }
+        if (typeof value === "string" && (key === "date" || key === "billing_cycle_start") && value !== "" && !date(value))
+          invalid2(`${path}.${key}`, "expected a valid YYYY-MM-DD date");
+        if (typeof value === "string" && (key.endsWith("_at") || ["timestamp", "source_timestamp", "window_start", "window_end"].includes(key)) && value !== "") {
+          if (!instant(value))
+            invalid2(`${path}.${key}`, "expected an ISO UTC timestamp ending in Z");
+          row[key] = new Date(value).toISOString();
+        } else
+          row[key] = value;
+      }
+      for (const key of required2[spec.table] ?? spec.pk) {
+        if (typeof row[key] !== "string" || row[key] === "")
+          invalid2(`${path}.${key}`, "expected nonempty text");
+      }
+      for (const key of spec.pk)
+        if (typeof (row[key] ?? "") !== "string" || String(row[key] ?? "").length > 1024)
+          invalid2(`${path}.${key}`, "expected a primary key of at most 1024 characters");
+      if (spec.table === "budgets" && !["daily", "weekly", "monthly"].includes(String(row["period"])))
+        invalid2(`${path}.period`, "expected daily, weekly or monthly");
+      if (spec.table === "budgets") {
+        if (row["metric"] !== undefined && !["legacy_request_cost_usd", "metered_api_usd"].includes(String(row["metric"])))
+          invalid2(`${path}.metric`, "expected legacy_request_cost_usd or metered_api_usd");
+        if (createBudget) {
+          if (String(row["id"]).trim() === "")
+            invalid2(`${path}.id`, "expected a nonempty caller-owned rule identity");
+          if (row["metric"] !== "metered_api_usd")
+            invalid2(`${path}.metric`, "budget creation requires metered_api_usd");
+          if (typeof row["limit_usd"] !== "number" || row["limit_usd"] <= 0)
+            invalid2(`${path}.limit_usd`, "expected a positive finite USD amount");
+          if (!Number.isInteger(row["alert_at_percent"]) || Number(row["alert_at_percent"]) < 1 || Number(row["alert_at_percent"]) > 100)
+            invalid2(`${path}.alert_at_percent`, "expected an integer from 1 to 100");
+          for (const field of ["created_at", "updated_at"])
+            if (typeof row[field] !== "string" || !instant(row[field]))
+              invalid2(`${path}.${field}`, "expected an explicit ISO UTC timestamp ending in Z; preserve it on retry");
+          for (const field of ["project_path", "cost_center_id"])
+            if (row[field] !== undefined && row[field] !== null && (typeof row[field] !== "string" || row[field].trim() === ""))
+              invalid2(`${path}.${field}`, "expected nonempty text or null for all scopes");
+          if (row["agent"] !== undefined && row["agent"] !== null && (typeof row["agent"] !== "string" || !isAgent(row["agent"])))
+            invalid2(`${path}.agent`, "expected a supported Economy agent or null for all agents");
+        }
+      }
+      if (spec.table === "goals" && !["day", "week", "month", "year"].includes(String(row["period"])))
+        invalid2(`${path}.period`, "expected day, week, month or year");
+      if (spec.table === "scan_receipts" && row["updated_at"] === undefined)
+        row["updated_at"] = row["completed_at"];
+      validateObservationProvenance(spec.table, row, path);
+      bytes += Buffer.byteLength(stableJson(row));
+      if (bytes > MAX_INGEST_BYTES)
+        throw new IngestError(413, "INGEST_TOO_LARGE", "body", `maximum ${MAX_INGEST_BYTES} JSON bytes; split into bounded commands`);
+      rows.push(row);
+    }
+    groups.push({ spec, rows });
+  }
+  if (Buffer.byteLength(stableJson(body)) > MAX_INGEST_BYTES)
+    throw new IngestError(413, "INGEST_TOO_LARGE", "body", `maximum ${MAX_INGEST_BYTES} JSON bytes; split into bounded commands`);
+  return groups;
+}
+
+// src/db/ingest-schema.ts
+var INGEST_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS ingest_session_locks (
+  session_id TEXT PRIMARY KEY
+);
+  CREATE TABLE IF NOT EXISTS ingest_batches (
+    operation_key TEXT PRIMARY KEY,
+    actor_id TEXT NOT NULL,
+    payload_hash TEXT NOT NULL,
+    response_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS ingest_preimages (
+    id TEXT PRIMARY KEY,
+    operation_key TEXT NOT NULL REFERENCES ingest_batches(operation_key),
+    table_name TEXT NOT NULL,
+    entity_key TEXT NOT NULL,
+    record_json TEXT NOT NULL,
+    record_sha256 TEXT NOT NULL,
+    recorded_at TEXT NOT NULL,
+    UNIQUE (operation_key, table_name, entity_key)
+  );
+  CREATE INDEX IF NOT EXISTS idx_ingest_preimages_entity
+    ON ingest_preimages(table_name, entity_key);
+`;
+
+// src/db/legacy-schema.ts
+var LEGACY_LEDGER_SQL = `
+CREATE TABLE IF NOT EXISTS legacy_reconciliations (
+  operation_key TEXT PRIMARY KEY NOT NULL,
+  payload_sha256 TEXT NOT NULL CHECK(length(payload_sha256)=64),
+  plan_sha256 TEXT NOT NULL CHECK(length(plan_sha256)=64),
+  capsule_sha256 TEXT NOT NULL CHECK(length(capsule_sha256)=64),
+  capsule_json TEXT NOT NULL,
+  actor_ref TEXT NOT NULL,
+  authority_ref TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  response_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS legacy_reconciliation_targets (
+  operation_key TEXT NOT NULL REFERENCES legacy_reconciliations(operation_key),
+  request_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  disposition TEXT NOT NULL CHECK(disposition IN ('quarantine_aggregate','mark_billing_unknown')),
+  original_sha256 TEXT NOT NULL CHECK(length(original_sha256)=64),
+  PRIMARY KEY(operation_key,request_id)
+);
+CREATE INDEX IF NOT EXISTS idx_legacy_targets_request ON legacy_reconciliation_targets(request_id);
+CREATE INDEX IF NOT EXISTS idx_legacy_targets_session ON legacy_reconciliation_targets(session_id);
+CREATE TABLE IF NOT EXISTS legacy_rollbacks (
+  operation_key TEXT PRIMARY KEY NOT NULL,
+  apply_key TEXT NOT NULL UNIQUE REFERENCES legacy_reconciliations(operation_key),
+  payload_sha256 TEXT NOT NULL CHECK(length(payload_sha256)=64),
+  actor_ref TEXT NOT NULL,
+  authority_ref TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  response_json TEXT NOT NULL
+);
+`;
+var requestColumns = [
+  "id",
+  "agent",
+  "session_id",
+  "model",
+  "input_tokens",
+  "output_tokens",
+  "cache_read_tokens",
+  "cache_create_tokens",
+  "cache_create_5m_tokens",
+  "cache_create_1h_tokens",
+  "cost_usd",
+  "cost_basis",
+  "duration_ms",
+  "timestamp",
+  "source_request_id",
+  "machine_id",
+  "cost_center_id",
+  "attribution_tag",
+  "account_key",
+  "account_tool",
+  "account_name",
+  "account_email",
+  "account_source",
+  "updated_at",
+  "synced_at"
+];
+var sessionColumns = [
+  "id",
+  "agent",
+  "project_path",
+  "project_name",
+  "started_at",
+  "ended_at",
+  "total_cost_usd",
+  "total_tokens",
+  "request_count",
+  "machine_id",
+  "cost_center_id",
+  "attribution_tag",
+  "account_key",
+  "account_tool",
+  "account_name",
+  "account_email",
+  "account_source",
+  "updated_at",
+  "synced_at"
+];
+var q = (s) => '"' + s + '"';
+var requestProjection = requestColumns.map((column) => column === "cost_basis" ? "CASE WHEN EXISTS (SELECT 1 FROM economy_legacy_active a WHERE a.request_id=r.id AND a.disposition='mark_billing_unknown') THEN 'unknown' ELSE r.cost_basis END AS cost_basis" : "r." + q(column)).join(`,
+`);
+var totals = {
+  total_cost_usd: "COALESCE(SUM(cost_usd),0)",
+  total_tokens: "COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens+cache_create_tokens),0)",
+  request_count: "COUNT(*)"
+};
+var sessionProjection = sessionColumns.map((column) => totals[column] ? `CASE WHEN EXISTS (SELECT 1 FROM economy_legacy_active a WHERE a.session_id=s.id)
+      THEN (SELECT ${totals[column]} FROM economy_effective_requests r WHERE r.session_id=s.id)
+      ELSE s.${q(column)} END AS ${q(column)}` : "s." + q(column)).join(`,
+`);
+var LEGACY_VIEWS_SQL = `
+CREATE VIEW IF NOT EXISTS economy_legacy_active AS
+  SELECT t.* FROM legacy_reconciliation_targets t
+  WHERE NOT EXISTS (SELECT 1 FROM legacy_rollbacks b WHERE b.apply_key=t.operation_key);
+CREATE VIEW IF NOT EXISTS economy_effective_requests AS
+  SELECT ${requestProjection} FROM requests r
+  WHERE NOT EXISTS (SELECT 1 FROM economy_legacy_active a WHERE a.request_id=r.id AND a.disposition='quarantine_aggregate');
+CREATE VIEW IF NOT EXISTS economy_effective_sessions AS
+  SELECT ${sessionProjection} FROM sessions s
+  WHERE NOT EXISTS (SELECT 1 FROM economy_legacy_active a WHERE a.session_id=s.id)
+     OR EXISTS (SELECT 1 FROM economy_effective_requests r WHERE r.session_id=s.id);
+`;
+var immutableTables = ["legacy_reconciliations", "legacy_reconciliation_targets", "legacy_rollbacks"];
+var collision = (table) => table === "legacy_reconciliation_targets" ? "operation_key=NEW.operation_key AND request_id=NEW.request_id" : table === "legacy_rollbacks" ? "operation_key=NEW.operation_key OR apply_key=NEW.apply_key" : "operation_key=NEW.operation_key";
+var LEGACY_SQLITE_SQL = LEGACY_LEDGER_SQL + LEGACY_VIEWS_SQL + immutableTables.map((table) => `
+CREATE TRIGGER IF NOT EXISTS ${table}_no_update BEFORE UPDATE ON ${table}
+  BEGIN SELECT RAISE(ABORT,'legacy reconciliation history is immutable'); END;
+CREATE TRIGGER IF NOT EXISTS ${table}_no_delete BEFORE DELETE ON ${table}
+  BEGIN SELECT RAISE(ABORT,'legacy reconciliation history is immutable'); END;
+CREATE TRIGGER IF NOT EXISTS ${table}_no_replace BEFORE INSERT ON ${table}
+  WHEN EXISTS(SELECT 1 FROM ${table} WHERE ${collision(table)})
+  BEGIN SELECT RAISE(ABORT,'legacy reconciliation history is immutable'); END;
+`).join("") + `
+CREATE TRIGGER IF NOT EXISTS legacy_target_no_overlap BEFORE INSERT ON legacy_reconciliation_targets
+  WHEN EXISTS(SELECT 1 FROM economy_legacy_active a WHERE a.session_id=NEW.session_id AND a.operation_key<>NEW.operation_key)
+    OR EXISTS(SELECT 1 FROM economy_legacy_active a WHERE a.request_id=NEW.request_id)
+  BEGIN SELECT RAISE(ABORT,'legacy reconciliation is already active for this session'); END;
+CREATE TRIGGER IF NOT EXISTS legacy_request_no_insert BEFORE INSERT ON requests
+  WHEN EXISTS(SELECT 1 FROM economy_legacy_active a WHERE a.request_id=NEW.id)
+  BEGIN SELECT RAISE(ABORT,'legacy reconciliation protects this request'); END;
+CREATE TRIGGER IF NOT EXISTS legacy_request_no_update BEFORE UPDATE ON requests
+  WHEN EXISTS(SELECT 1 FROM economy_legacy_active a WHERE a.request_id=NEW.id OR a.request_id=OLD.id)
+  BEGIN SELECT RAISE(ABORT,'legacy reconciliation protects this request'); END;
+CREATE TRIGGER IF NOT EXISTS legacy_request_no_delete BEFORE DELETE ON requests
+  WHEN EXISTS(SELECT 1 FROM economy_legacy_active a WHERE a.request_id=OLD.id)
+  BEGIN SELECT RAISE(ABORT,'legacy reconciliation protects this request'); END;
+`;
+var pgViews = LEGACY_VIEWS_SQL.replace(/CREATE VIEW IF NOT EXISTS (\w+) AS/g, "CREATE VIEW $1 WITH (security_invoker=true) AS");
+var LEGACY_PG_SQL = LEGACY_LEDGER_SQL + pgViews + `
+CREATE FUNCTION economy_legacy_history_immutable() RETURNS trigger LANGUAGE plpgsql AS $body$
+BEGIN
+  RAISE EXCEPTION 'legacy reconciliation history is immutable' USING ERRCODE='23000';
+END
+$body$;
+` + immutableTables.map((table) => `
+CREATE TRIGGER ${table}_immutable BEFORE UPDATE OR DELETE OR TRUNCATE ON ${table}
+  FOR EACH STATEMENT EXECUTE FUNCTION economy_legacy_history_immutable();
+`).join("") + `
+CREATE FUNCTION economy_legacy_request_guard() RETURNS trigger LANGUAGE plpgsql AS $body$
+BEGIN
+  IF TG_OP='TRUNCATE' THEN
+    IF EXISTS(SELECT 1 FROM economy_legacy_active) THEN
+      RAISE EXCEPTION 'legacy reconciliation protects requests' USING ERRCODE='23000';
+    END IF;
+    RETURN NULL;
+  END IF;
+  IF TG_OP IN ('INSERT','UPDATE') THEN
+    IF EXISTS(SELECT 1 FROM economy_legacy_active WHERE request_id=NEW.id) THEN
+      RAISE EXCEPTION 'legacy reconciliation protects this request' USING ERRCODE='23000';
+    END IF;
+  END IF;
+  IF TG_OP IN ('UPDATE','DELETE') THEN
+    IF EXISTS(SELECT 1 FROM economy_legacy_active WHERE request_id=OLD.id) THEN
+      RAISE EXCEPTION 'legacy reconciliation protects this request' USING ERRCODE='23000';
+    END IF;
+  END IF;
+  IF TG_OP='DELETE' THEN RETURN OLD; END IF;
+  RETURN NEW;
+END
+$body$;
+CREATE TRIGGER legacy_request_guard BEFORE INSERT OR UPDATE OR DELETE ON requests
+  FOR EACH ROW EXECUTE FUNCTION economy_legacy_request_guard();
+CREATE TRIGGER legacy_request_no_truncate BEFORE TRUNCATE ON requests
+  FOR EACH STATEMENT EXECUTE FUNCTION economy_legacy_request_guard();
+CREATE FUNCTION economy_legacy_target_guard() RETURNS trigger LANGUAGE plpgsql AS $body$
+BEGIN
+  IF EXISTS(SELECT 1 FROM economy_legacy_active a WHERE a.session_id=NEW.session_id AND a.operation_key<>NEW.operation_key)
+    OR EXISTS(SELECT 1 FROM economy_legacy_active a WHERE a.request_id=NEW.request_id) THEN
+    RAISE EXCEPTION 'legacy reconciliation is already active for this session' USING ERRCODE='23000';
+  END IF;
+  RETURN NEW;
+END
+$body$;
+CREATE TRIGGER legacy_target_no_overlap BEFORE INSERT ON legacy_reconciliation_targets
+  FOR EACH ROW EXECUTE FUNCTION economy_legacy_target_guard();
+`;
+
+// src/db/ingest.ts
+import { createHash as createHash3 } from "crypto";
+var sha = (text) => createHash3("sha256").update(text).digest("hex");
+var quote = (name) => `"${name}"`;
+var predicate = (spec) => spec.pk.map((k) => `${quote(k)} = ?`).join(" AND ");
+var keys = (spec, row) => spec.pk.map((k) => row[k]);
+var conflict = (field, expected) => {
+  throw new IngestError(409, "INGEST_CONFLICT", field, expected);
+};
+var sessionDerived = ["total_cost_usd", "total_tokens", "request_count", "ended_at"];
+var sessionFilled = ["started_at", "account_key", "account_tool", "account_name", "account_email", "account_source", "cost_center_id"];
+function ingestCommand(db, body, rollup, context = {}) {
+  const groups = validateIngest(body);
+  const actor = context.actorId ?? "legacy";
+  if (typeof actor !== "string" || actor.length === 0 || actor.length > 2048)
+    throw new IngestError(400, "INVALID_INGEST", "actorId", "expected a verified actor identifier");
+  const payloadHash = canonicalIngestBodyHash(body);
+  const key = typeof body["idempotency_key"] === "string" ? body["idempotency_key"] : payloadHash;
+  const operation = sha(stableJson([actor, key]));
+  const now = new Date().toISOString();
+  const sessionSpec = ingestSpecs().find((s) => s.table === "sessions");
+  const touched = new Set;
+  for (const { spec, rows } of groups)
+    for (const row of rows) {
+      if (spec.table === "requests")
+        touched.add(String(row["session_id"]));
+      if (spec.table === "sessions")
+        touched.add(String(row["id"]));
+    }
+  return db.transaction(() => {
+    const reservation = db.run(`INSERT INTO ingest_batches(operation_key,actor_id,payload_hash,response_json,created_at)
+      VALUES(?,?,?,?,?) ON CONFLICT(operation_key) DO NOTHING`, operation, actor, payloadHash, "", now);
+    if (reservation.changes === 0) {
+      const previous = db.get("SELECT payload_hash,response_json FROM ingest_batches WHERE operation_key = ?", operation);
+      if (previous?.payload_hash !== payloadHash)
+        conflict("idempotency_key", "key already used for different content; use the original command or a new key");
+      if (!previous.response_json)
+        conflict("idempotency_key", "receipt is not complete; reconcile the original operation");
+      return { ...JSON.parse(previous.response_json), replayed: true };
+    }
+    const result = { ingested: {}, total: 0, stale: 0, unchanged: 0, operation_key: operation, replayed: false };
+    const captured = new Set;
+    function preserve(spec, row) {
+      const entity = stableJson(keys(spec, row));
+      const identity = stableJson([spec.table, entity]);
+      if (captured.has(identity))
+        return;
+      const original = stableJson(row);
+      const digest2 = sha(original);
+      const id = sha(stableJson([operation, spec.table, entity]));
+      db.run(`INSERT INTO ingest_preimages(id,operation_key,table_name,entity_key,record_json,record_sha256,recorded_at)
+        VALUES(?,?,?,?,?,?,?)`, id, operation, spec.table, entity, original, digest2, now);
+      const readback = db.get("SELECT record_json,record_sha256 FROM ingest_preimages WHERE id = ?", id);
+      if (readback?.record_json !== original || readback?.record_sha256 !== digest2 || sha(readback.record_json) !== digest2) {
+        throw new Error("Ingest predecessor readback failed");
+      }
+      captured.add(identity);
+    }
+    function cas(spec, previous, set, args) {
+      const columns = Object.keys(previous);
+      if (columns.some((k) => !/^[a-z][a-z0-9_]*$/.test(k)))
+        throw new Error("Unexpected Economy schema column");
+      const where = columns.map((k) => `${quote(k)} IS NOT DISTINCT FROM ?`).join(" AND ");
+      const updated = db.run(`UPDATE ${quote(spec.table)} SET ${set} WHERE ${where}`, ...args, ...columns.map((k) => previous[k]));
+      if (updated.changes !== 1)
+        conflict(spec.table, "stored row changed concurrently; read current state before retrying");
+    }
+    for (const id of [...touched].sort()) {
+      db.run(`INSERT INTO ingest_session_locks(session_id) VALUES(?)
+        ON CONFLICT(session_id) DO UPDATE SET session_id = excluded.session_id`, id);
+      const previous = db.get("SELECT * FROM sessions WHERE id = ?", id);
+      if (previous) {
+        preserve(sessionSpec, previous);
+        cas(sessionSpec, previous, "id = id", []);
+      }
+    }
+    for (const { spec, rows } of groups) {
+      if (rows.length === 0)
+        continue;
+      const accepted = new Set;
+      for (const raw of rows) {
+        const values = spec.map(raw, "");
+        const row = Object.fromEntries(spec.columns.map((k, i) => [k, values[i]]));
+        const pk = keys(spec, row);
+        const entity = stableJson(pk);
+        if (spec.table === "requests" && db.get("SELECT request_id FROM economy_legacy_active WHERE request_id = ?", row["id"])) {
+          conflict("requests.id", "legacy_reconciliation_protects_request; read its recorded disposition before ingesting");
+        }
+        if (row["agent"] === "hermes") {
+          const sid = spec.table === "sessions" ? String(row["id"]) : String(row["session_id"]);
+          const legacyId = `${sid}-rollup`;
+          if (spec.table === "requests" && row["id"] === legacyId || spec.table === "sessions" && db.get("SELECT id FROM economy_effective_requests WHERE agent='hermes' AND session_id=? AND id=?", sid, legacyId)) {
+            conflict(spec.table, "legacy_aggregate_requires_migration");
+          }
+        }
+        if (spec.table === "requests" && row["agent"] === "codex") {
+          const sessionId = String(row["session_id"]);
+          const legacyId = `${sessionId}-0`;
+          const eventPrefix = `${sessionId}-event-`;
+          const id = String(row["id"]);
+          const mixed = id.startsWith(eventPrefix) ? db.get("SELECT id FROM economy_effective_requests WHERE session_id = ? AND agent = 'codex' AND id = ?", sessionId, legacyId) : id === legacyId ? db.get("SELECT id FROM economy_effective_requests WHERE session_id = ? AND agent = 'codex' AND substr(id,1,?) = ? LIMIT 1", sessionId, eventPrefix.length, eventPrefix) : null;
+          if (mixed)
+            conflict("requests", "legacy_aggregate_requires_migration");
+        }
+        const previous = db.get(`SELECT * FROM ${quote(spec.table)} WHERE ${predicate(spec)}`, ...pk);
+        if (spec.table === "budgets" && body["budget_mode"] === "create" && previous) {
+          conflict("budgets.id", "rule identity already exists; only the original actor and identical command/key can replay creation");
+        }
+        if (!previous) {
+          if (spec.table === "budgets" && row["metric"] === "metered_api_usd" && body["budget_mode"] !== "create") {
+            conflict("budget_mode", "new metered API rules require the explicit create command");
+          }
+          const inserted = db.run(`INSERT INTO ${quote(spec.table)} (${spec.columns.map(quote).join(",")})
+            VALUES (${values.map(() => "?").join(",")}) ON CONFLICT DO NOTHING`, ...values);
+          if (inserted.changes !== 1)
+            conflict(spec.table, "identity or unique key already exists; reconcile before retrying");
+          accepted.add(entity);
+          continue;
+        }
+        if (spec.table === "requests" && previous.session_id !== row["session_id"])
+          conflict("requests.session_id", "an existing request cannot change its session identity");
+        if (spec.table === "sessions" && Number(db.get("SELECT COUNT(*) AS n FROM requests WHERE session_id = ?", row["id"]).n) > 0) {
+          for (const column of sessionDerived)
+            row[column] = previous[column];
+          for (const column of sessionFilled)
+            if (row[column] === "" || row[column] === null)
+              row[column] = previous[column];
+        }
+        if (spec.table === "subscriptions" && (row["account_key"] || previous.account_key)) {
+          if (previous.provider !== row["provider"] || previous.account_key !== row["account_key"])
+            conflict("subscriptions.account_key", "existing subscription identity cannot change");
+          row["created_at"] = previous.created_at;
+          if (body["subscription_mode"] !== "configuration") {
+            for (const column of ["agent", "active", "plan", "billing_cycle_start", "reset_policy"])
+              row[column] = previous[column];
+            for (const [basis, amount] of [["fee_basis", "monthly_fee_usd"], ["included_basis", "included_usage_usd"]]) {
+              if (row[basis] === "unknown" && ["configured", "observed"].includes(String(previous[basis]))) {
+                row[basis] = previous[basis];
+                row[amount] = previous[amount];
+              }
+            }
+          }
+        }
+        const contentColumns = spec.columns.filter((c) => c !== "updated_at" && c !== "synced_at");
+        const equal = contentColumns.every((c) => stableJson(previous[c]) === stableJson(row[c]));
+        if (spec.table === "budgets" && (previous.metric === "metered_api_usd" || row["metric"] === "metered_api_usd")) {
+          if (!spec.columns.every((c) => stableJson(previous[c]) === stableJson(row[c])))
+            conflict("budgets.id", "metered API rules are create-only; an existing rule cannot be edited or converted");
+          result.unchanged++;
+          continue;
+        }
+        if ((spec.table === "scan_receipts" || spec.table === "usage_snapshots" && (row["observed_at"] || previous.observed_at)) && !equal) {
+          conflict(spec.table, "an observation identity is immutable; submit a new observation time for new content");
+        }
+        const priorVersion = typeof previous.updated_at === "string" ? Date.parse(previous.updated_at) : NaN;
+        const nextVersion = typeof row["updated_at"] === "string" ? Date.parse(row["updated_at"]) : NaN;
+        if (Number.isFinite(priorVersion) && Number.isFinite(nextVersion) && nextVersion < priorVersion) {
+          result.stale++;
+          continue;
+        }
+        if (equal && (!Number.isFinite(nextVersion) || Number.isFinite(priorVersion) && nextVersion === priorVersion)) {
+          result.unchanged++;
+          continue;
+        }
+        if (!Number.isFinite(nextVersion) || Number.isFinite(priorVersion) && nextVersion === priorVersion) {
+          conflict(`${spec.table}.updated_at`, "different content requires an explicit newer source version");
+        }
+        preserve(spec, previous);
+        const columns = spec.columns.filter((c) => !spec.pk.includes(c));
+        cas(spec, previous, columns.map((c) => `${quote(c)} = ?`).join(","), columns.map((c) => row[c]));
+        accepted.add(entity);
+      }
+      result.ingested[spec.table] = accepted.size;
+      result.total += accepted.size;
+    }
+    for (const id of [...touched].sort()) {
+      const session = db.get("SELECT * FROM sessions WHERE id = ?", id);
+      if (!session || Number(db.get("SELECT COUNT(*) AS n FROM requests WHERE session_id = ?", id).n) === 0)
+        continue;
+      preserve(sessionSpec, session);
+      rollup(db, id);
+    }
+    db.run("UPDATE ingest_batches SET response_json = ? WHERE operation_key = ?", JSON.stringify(result), operation);
+    return result;
+  });
+}
+
+// src/lib/budget-decimal.ts
+function decimal(value) {
+  if (!Number.isFinite(value) || value < 0)
+    throw new Error("Invalid stored metered budget amount");
+  const [mantissa, exponent = "0"] = String(value).split("e");
+  const [whole, fraction = ""] = mantissa.split(".");
+  return { units: BigInt(whole + fraction), exponent: Number(exponent) - fraction.length };
+}
+function count(value) {
+  if (typeof value === "number" && !Number.isSafeInteger(value) || !/^[1-9][0-9]{0,18}$/.test(String(value))) {
+    throw new Error("Invalid stored metered budget row count");
+  }
+  return BigInt(value);
+}
+function sum(a, b) {
+  const exponent = Math.min(a.exponent, b.exponent);
+  return { units: a.units * 10n ** BigInt(a.exponent - exponent) + b.units * 10n ** BigInt(b.exponent - exponent), exponent };
+}
+function atLeast(a, b) {
+  const exponent = Math.min(a.exponent, b.exponent);
+  return a.units * 10n ** BigInt(a.exponent - exponent) >= b.units * 10n ** BigInt(b.exponent - exponent);
+}
+function meteredBudgetAmounts(groups, limit, threshold) {
+  if (!Number.isFinite(limit) || limit <= 0 || !Number.isInteger(threshold) || threshold < 1 || threshold > 100) {
+    throw new Error("Invalid stored metered budget threshold");
+  }
+  let total = { units: 0n, exponent: 0 };
+  for (const group of groups) {
+    const amount = decimal(group.cost_usd);
+    total = sum(total, { ...amount, units: amount.units * count(group.entries) });
+  }
+  const limitAmount = decimal(limit);
+  const spend = Number(`${total.units}e${total.exponent}`);
+  const percent = spend / limit * 100;
+  if (!Number.isFinite(spend) || !Number.isFinite(percent))
+    throw new Error("Metered budget display amount exceeds supported numeric range");
+  return {
+    current_spend_usd: spend,
+    percent_used: percent,
+    is_over_limit: atLeast(total, limitAmount),
+    is_over_alert: atLeast({ ...total, units: total.units * 100n }, { ...limitAmount, units: limitAmount.units * BigInt(threshold) })
+  };
+}
+
+// src/lib/periods.ts
+function ymd(date2) {
+  return date2.toISOString().substring(0, 10);
+}
+function calendarPeriodBounds(period, now = new Date) {
+  if (!Number.isFinite(now.getTime()))
+    throw new RangeError("Invalid reporting clock");
+  const start = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+  const end = new Date(start);
+  switch (period) {
+    case "today":
+      end.setUTCDate(end.getUTCDate() + 1);
+      break;
+    case "yesterday":
+      start.setUTCDate(start.getUTCDate() - 1);
+      break;
+    case "week":
+      start.setUTCDate(start.getUTCDate() - start.getUTCDay());
+      end.setTime(start.getTime());
+      end.setUTCDate(end.getUTCDate() + 7);
+      break;
+    case "month":
+      start.setUTCDate(1);
+      end.setTime(start.getTime());
+      end.setUTCMonth(end.getUTCMonth() + 1);
+      break;
+    case "year":
+      start.setUTCMonth(0, 1);
+      end.setTime(start.getTime());
+      end.setUTCFullYear(end.getUTCFullYear() + 1);
+      break;
+    case "all":
+      return { time_zone: "UTC", start_date: null, end_date_exclusive: null };
+    default:
+      throw new RangeError("Invalid reporting period");
+  }
+  return { time_zone: "UTC", start_date: ymd(start), end_date_exclusive: ymd(end) };
+}
+function calendarPeriodWhere(period, column, now = new Date) {
+  if (!/^[a-z_][a-z0-9_]*(?:\.[a-z_][a-z0-9_]*)?$/i.test(column)) {
+    throw new TypeError("Invalid reporting column");
+  }
+  const bounds = calendarPeriodBounds(period, now);
+  return bounds.start_date === null ? "1=1" : `${column} >= '${bounds.start_date}' AND ${column} < '${bounds.end_date_exclusive}'`;
+}
+function usageSnapshotFilterForPeriod(period) {
+  const bounds = calendarPeriodBounds(period);
+  if (bounds.start_date === null)
+    return {};
+  if (period === "today" || period === "yesterday")
+    return { date: bounds.start_date };
+  return { since: bounds.start_date, before: bounds.end_date_exclusive };
+}
+function sessionOverlapWhere(period, alias, now = new Date) {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(alias))
+    throw new TypeError("Invalid session alias");
+  const bounds = calendarPeriodBounds(period, now);
+  return bounds.start_date === null ? "1=1" : `${alias}.started_at < '${bounds.end_date_exclusive}' AND (${alias}.ended_at IS NULL OR ${alias}.ended_at >= '${bounds.start_date}')`;
+}
+
+// src/lib/money-display.ts
+function formatReportedUsd(value) {
+  if (value === null || value === undefined || !Number.isFinite(value))
+    return "unavailable";
+  return "$" + value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+function formatSourcedUsd(value, basis) {
+  return formatReportedUsd(basis === "configured" || basis === "observed" ? value : null);
+}
+function formatPlanMoney(plan) {
+  return {
+    fee: formatSourcedUsd(plan.monthly_fee_usd, plan.fee_basis),
+    included: formatSourcedUsd(plan.included_usage_usd, plan.included_basis)
+  };
+}
+
+// src/lib/summary-contract.ts
+function knownZero(row, prices) {
+  if (row.cost_basis === "metered_api")
+    return true;
+  if (!row.model || [row.input_tokens, row.output_tokens, row.cache_read_tokens, row.cache_create_tokens, row.cache_create_1h_tokens].some((value) => typeof value !== "number" || !Number.isSafeInteger(value) || value < 0))
+    return false;
+  try {
+    const result = assessCostFromRows(prices, row.model, row.input_tokens, row.output_tokens, row.cache_read_tokens, Math.max(0, row.cache_create_tokens - row.cache_create_1h_tokens), row.cache_create_1h_tokens);
+    return result.usd === 0;
+  } catch {
+    return false;
+  }
+}
+function hasKnownUsagePrice(row, prices) {
+  return ["metered_api", "subscription_included", "estimated"].includes(row.cost_basis ?? "") && Number.isFinite(row.cost_usd) && row.cost_usd >= 0 && (!(row.zero_cost === 1 || row.cost_usd === 0) || knownZero(row, prices));
+}
+function buildCostSummary(period, period_bounds, groups, sessionOnly, requestSessions, prices) {
+  let metered = 0, estimated = 0, included = 0, unknown = 0, unknownBasis = 0, requestRows = 0, tokens = 0, knownRows = 0;
+  for (const row of groups) {
+    requestRows += row.requests;
+    tokens += row.input_tokens + row.output_tokens + row.cache_read_tokens + row.cache_create_tokens;
+    if (!["metered_api", "subscription_included", "estimated"].includes(row.cost_basis ?? "")) {
+      unknownBasis += row.requests;
+      unknown += row.requests;
+      continue;
+    }
+    if (!hasKnownUsagePrice(row, prices)) {
+      unknown += row.requests;
+      continue;
+    }
+    knownRows += row.requests;
+    if (row.cost_basis === "metered_api")
+      metered += row.cost_usd;
+    else if (row.cost_basis === "subscription_included")
+      included += row.cost_usd;
+    else
+      estimated += row.cost_usd;
+  }
+  const sessionValue = Number.isFinite(sessionOnly.cost_usd) && sessionOnly.cost_usd >= 0 ? sessionOnly.cost_usd : 0;
+  const total = metered + estimated + included + sessionValue;
+  if (!Number.isFinite(total))
+    throw new RangeError("Summary monetary subtotal exceeds the supported range");
+  const empty = requestRows === 0 && sessionOnly.sessions === 0;
+  const complete = !empty && unknown === 0 && sessionOnly.sessions === 0 && Number.isFinite(total);
+  const completeness = empty ? "no_records" : complete ? "complete" : knownRows > 0 || sessionValue > 0 ? "partial" : "unavailable";
+  return {
+    total_usd: Number.isFinite(total) ? total : 0,
+    complete_total_usd: complete ? total : null,
+    basis: "known_usage_value_subtotal",
+    completeness,
+    coverage_scope: "selected_stored_records",
+    source_coverage: "not_established",
+    period_bounds,
+    recorded_metered_api_usd: metered,
+    estimated_usage_value_usd: estimated,
+    subscription_included_value_usd: included,
+    session_only_value_usd: sessionValue,
+    unknown_price_requests: unknown,
+    unknown_basis_requests: unknownBasis,
+    request_rows: requestRows,
+    session_only_sessions: sessionOnly.sessions,
+    sessions: requestSessions + sessionOnly.sessions,
+    requests: requestRows + sessionOnly.requests,
+    tokens: tokens + sessionOnly.tokens,
+    period
+  };
+}
+function requireCurrentCostSummary(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("SUMMARY_REPORT_UNAVAILABLE: Invalid summary response");
+  const s = value;
+  if (s.basis !== "known_usage_value_subtotal" || s.coverage_scope !== "selected_stored_records" || s.source_coverage !== "not_established" || !["complete", "partial", "unavailable", "no_records"].includes(String(s.completeness)))
+    throw new Error("SUMMARY_REPORT_UNAVAILABLE: The service must support summary coverage");
+  for (const key of [
+    "total_usd",
+    "recorded_metered_api_usd",
+    "estimated_usage_value_usd",
+    "subscription_included_value_usd",
+    "session_only_value_usd",
+    "request_rows",
+    "unknown_price_requests",
+    "unknown_basis_requests",
+    "session_only_sessions",
+    "requests",
+    "sessions",
+    "tokens"
+  ]) {
+    if (typeof s[key] !== "number" || !Number.isFinite(s[key]) || Number(s[key]) < 0)
+      throw new Error("SUMMARY_REPORT_UNAVAILABLE: Invalid field " + key);
+  }
+  if (s.complete_total_usd !== null && (typeof s.complete_total_usd !== "number" || !Number.isFinite(s.complete_total_usd) || s.complete_total_usd < 0))
+    throw new Error("SUMMARY_REPORT_UNAVAILABLE: Invalid complete total");
+  if (s.completeness === "complete" !== (s.complete_total_usd !== null) || s.completeness === "complete" && (s.unknown_price_requests !== 0 || s.session_only_sessions !== 0))
+    throw new Error("SUMMARY_REPORT_UNAVAILABLE: Inconsistent completeness");
+  for (const key of ["request_rows", "unknown_price_requests", "unknown_basis_requests", "session_only_sessions", "requests", "sessions", "tokens"]) {
+    if (!Number.isSafeInteger(s[key]))
+      throw new Error("SUMMARY_REPORT_UNAVAILABLE: Invalid count " + key);
+  }
+  if (Number(s.unknown_price_requests) > Number(s.request_rows) || Number(s.unknown_basis_requests) > Number(s.unknown_price_requests))
+    throw new Error("SUMMARY_REPORT_UNAVAILABLE: Invalid request coverage");
+  const subtotal = Number(s.recorded_metered_api_usd) + Number(s.estimated_usage_value_usd) + Number(s.subscription_included_value_usd) + Number(s.session_only_value_usd);
+  if (s.total_usd !== subtotal || s.complete_total_usd !== null && s.complete_total_usd !== subtotal)
+    throw new Error("SUMMARY_REPORT_UNAVAILABLE: Inconsistent subtotal");
+  const empty = s.request_rows === 0 && s.session_only_sessions === 0;
+  if (s.completeness === "no_records" !== empty)
+    throw new Error("SUMMARY_REPORT_UNAVAILABLE: Inconsistent record coverage");
+  const bounds = s.period_bounds;
+  if (bounds?.time_zone !== "UTC" || !(bounds.start_date === null || typeof bounds.start_date === "string") || !(bounds.end_date_exclusive === null || typeof bounds.end_date_exclusive === "string") || bounds.start_date === null !== (bounds.end_date_exclusive === null))
+    throw new Error("SUMMARY_REPORT_UNAVAILABLE: Missing UTC period bounds");
+  return value;
+}
+function formatSummaryValue(value) {
+  try {
+    requireCurrentCostSummary(value);
+  } catch {
+    return "unavailable (summary coverage unsupported)";
+  }
+  if (value.complete_total_usd === null)
+    return `unavailable (known subtotal ${formatReportedUsd(value.total_usd)})`;
+  return `${formatReportedUsd(value.complete_total_usd)} usage value`;
+}
+function formatSummaryCoverage(s) {
+  try {
+    requireCurrentCostSummary(s);
+  } catch {
+    return "Summary coverage unsupported; update the service";
+  }
+  const range = s.period_bounds.start_date ? `${s.period_bounds.start_date} to ${s.period_bounds.end_date_exclusive} exclusive` : "all stored dates";
+  return `${s.completeness}; UTC ${range}; selected stored records only; source coverage unverified; ` + `recorded metered ${formatReportedUsd(s.recorded_metered_api_usd)}, estimated ${formatReportedUsd(s.estimated_usage_value_usd)}, ` + `included value ${formatReportedUsd(s.subscription_included_value_usd)}, unallocated session lifetime value ${formatReportedUsd(s.session_only_value_usd)} (${s.session_only_sessions} overlapping sessions); ` + `${s.unknown_price_requests} unknown-price requests, ${s.unknown_basis_requests} unknown-basis requests`;
+}
+function requireCurrentBillingSummary(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("BILLING_REPORT_UNAVAILABLE: Invalid billing response");
+  const s = value;
+  if (s.basis !== "recorded_provider_rows_subtotal" || s.source_coverage !== "not_established" || s.coverage_scope !== "selected_stored_records" || !["observed", "no_records"].includes(String(s.status)) || s.complete_total_usd !== null)
+    throw new Error("BILLING_REPORT_UNAVAILABLE: The service must support billing coverage");
+  if (typeof s.total_usd !== "number" || !Number.isFinite(s.total_usd) || !Number.isSafeInteger(s.record_count) || Number(s.record_count) < 0 || s.recorded_total_usd !== null && (typeof s.recorded_total_usd !== "number" || !Number.isFinite(s.recorded_total_usd)))
+    throw new Error("BILLING_REPORT_UNAVAILABLE: Invalid monetary coverage");
+  if (s.status === "observed" !== Number(s.record_count) > 0 || s.recorded_total_usd !== null !== (s.status === "observed"))
+    throw new Error("BILLING_REPORT_UNAVAILABLE: Inconsistent record coverage");
+  return value;
+}
+function formatBillingValue(value) {
+  try {
+    const s = requireCurrentBillingSummary(value);
+    return s.recorded_total_usd === null ? "unavailable (no provider rows)" : `${formatReportedUsd(s.recorded_total_usd)} recorded subtotal`;
+  } catch {
+    return "unavailable (billing coverage unsupported)";
+  }
+}
+
+// src/db/database.ts
+import { execFileSync } from "child_process";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { hostname, platform } from "os";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+var PATHS_RESOLVER_KIND_ENV = {
+  config: "HASNA_CONFIG_HOME",
+  data: "HASNA_DATA_HOME",
+  state: "HASNA_STATE_HOME",
+  cache: "HASNA_CACHE_HOME"
+};
+var PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function pathsResolverAssertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
+}
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir();
+  const platform2 = options.platform ?? process.platform;
+  if (platform2 === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin(home, ".cache", "hasna");
+  }
+}
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return pathsResolverResolve("data", options);
+}
+function cacheDir(options) {
+  return pathsResolverResolve("cache", options);
+}
+function normalizeMachineId(value) {
+  const id = value?.trim().toLowerCase().split(".")[0];
+  return id && id.length > 0 ? id : null;
+}
+function macHostMachineId() {
+  if (platform() !== "darwin")
+    return null;
+  for (const key of ["LocalHostName", "ComputerName", "HostName"]) {
+    try {
+      const value = execFileSync("/usr/sbin/scutil", ["--get", key], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1000
+      });
+      const id = normalizeMachineId(value);
+      if (id && id !== "mac" && id !== "localhost")
+        return id;
+    } catch {}
+  }
+  return null;
+}
+function getMachineId() {
+  const envMachine = normalizeMachineId(process.env["HASNA_ECONOMY_MACHINE_ID"]);
+  if (envMachine)
+    return envMachine;
+  const hostMachine = normalizeMachineId(hostname()) ?? "unknown";
+  if (hostMachine === "mac" || hostMachine === "localhost")
+    return macHostMachineId() ?? hostMachine;
+  return hostMachine;
+}
+function getHomeDir() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
+  if (!home)
+    throw new Error("Could not resolve the user home directory");
+  return home;
+}
+function getResolverDataRoot() {
+  return dataDir({
+    app: "economy",
+    home: process.env["HOME"] || process.env["USERPROFILE"] || undefined
+  });
+}
+function getLegacyDataRoot() {
+  return join(getHomeDir(), ".hasna", "economy");
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join(resolved, "economy.db"));
+}
+function getExactDataRoot() {
+  const dir = process.env["HASNA_ECONOMY_HOME"] ?? process.env["ECONOMY_HOME"];
+  if (dir && dir.trim())
+    return dir.trim();
+  return;
+}
+function getDataDir() {
+  const exact = getExactDataRoot();
+  const effective = exact ? resolve(exact) : adoptResolverDataRoot(getResolverDataRoot()) ? resolve(getResolverDataRoot()) : getLegacyDataRoot();
+  const oldDir = join(getHomeDir(), ".economy");
+  if (existsSync(oldDir) && !existsSync(effective)) {
+    mkdirSync(effective, { recursive: true });
+    for (const file of readdirSync(oldDir)) {
+      const oldPath = join(oldDir, file);
+      if (statSync(oldPath).isFile()) {
+        copyFileSync(oldPath, join(effective, file));
+      }
+    }
+  }
+  mkdirSync(effective, { recursive: true });
+  return effective;
+}
+function getDbPath() {
+  if (process.env["HASNA_ECONOMY_DB_PATH"])
+    return process.env["HASNA_ECONOMY_DB_PATH"];
+  if (process.env["ECONOMY_DB"])
+    return process.env["ECONOMY_DB"];
+  return join(getDataDir(), "economy.db");
+}
+function quoteSqlIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function hasColumn(db, table, column) {
+  const columns = db.prepare(`PRAGMA table_info(${quoteSqlIdent(table)})`).all();
+  return columns.some((c) => c.name === column);
+}
+function addColumnIfMissing(db, table, column, definition) {
+  if (hasColumn(db, table, column))
+    return false;
+  try {
+    db.exec(`ALTER TABLE ${quoteSqlIdent(table)} ADD COLUMN ${quoteSqlIdent(column)} ${definition}`);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/duplicate column name/i.test(message))
+      return true;
+    throw error;
+  }
+}
+function initSchema(db) {
+  db.exec(INGEST_SCHEMA_SQL);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS cost_centers (
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL,
+      name TEXT NOT NULL,
+      repo_path TEXT,
+      labels_json TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS requests (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER DEFAULT 0,
+      output_tokens INTEGER DEFAULT 0,
+      cache_read_tokens INTEGER DEFAULT 0,
+      cache_create_tokens INTEGER DEFAULT 0,
+      cache_create_5m_tokens INTEGER DEFAULT 0,
+      cache_create_1h_tokens INTEGER DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      duration_ms INTEGER DEFAULT 0,
+      timestamp TEXT NOT NULL,
+      source_request_id TEXT,
+      machine_id TEXT DEFAULT '',
+      cost_center_id TEXT,
+      account_key TEXT DEFAULT '',
+      account_tool TEXT DEFAULT '',
+      account_name TEXT DEFAULT '',
+      account_email TEXT DEFAULT '',
+      account_source TEXT DEFAULT ''
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      project_path TEXT DEFAULT '',
+      project_name TEXT DEFAULT '',
+      started_at TEXT NOT NULL,
+      ended_at TEXT,
+      total_cost_usd REAL DEFAULT 0,
+      total_tokens INTEGER DEFAULT 0,
+      request_count INTEGER DEFAULT 0,
+      machine_id TEXT DEFAULT '',
+      cost_center_id TEXT,
+      account_key TEXT DEFAULT '',
+      account_tool TEXT DEFAULT '',
+      account_name TEXT DEFAULT '',
+      account_email TEXT DEFAULT '',
+      account_source TEXT DEFAULT ''
+    );
+
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      path TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      tags TEXT DEFAULT '[]',
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS budgets (
+      id TEXT PRIMARY KEY,
+      project_path TEXT,
+      agent TEXT,
+      cost_center_id TEXT,
+      period TEXT NOT NULL,
+      limit_usd REAL NOT NULL,
+      alert_at_percent INTEGER DEFAULT 80,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS goals (
+      id TEXT PRIMARY KEY,
+      period TEXT NOT NULL,
+      project_path TEXT,
+      agent TEXT,
+      limit_usd REAL NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS ingest_state (
+      source TEXT NOT NULL,
+      key TEXT NOT NULL,
+      value TEXT NOT NULL,
+      PRIMARY KEY (source, key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_requests_session ON requests(session_id);
+    CREATE INDEX IF NOT EXISTS idx_requests_timestamp ON requests(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_requests_agent ON requests(agent);
+    CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent);
+    CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_path);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+    CREATE INDEX IF NOT EXISTS idx_cost_centers_kind ON cost_centers(kind);
+
+    CREATE TABLE IF NOT EXISTS model_pricing (
+      model TEXT PRIMARY KEY,
+      input_per_1m REAL NOT NULL DEFAULT 0,
+      output_per_1m REAL NOT NULL DEFAULT 0,
+      cache_read_per_1m REAL NOT NULL DEFAULT 0,
+      cache_write_per_1m REAL NOT NULL DEFAULT 0,
+      cache_write_1h_per_1m REAL NOT NULL DEFAULT 0,
+      cache_storage_per_1m_hour REAL NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      message TEXT NOT NULL,
+      email TEXT,
+      category TEXT DEFAULT 'general',
+      version TEXT,
+      machine_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS billing_daily (
+      date TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      description TEXT DEFAULT '',
+      cost_usd REAL NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (date, provider, description)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_billing_date ON billing_daily(date);
+    CREATE INDEX IF NOT EXISTS idx_billing_provider ON billing_daily(provider);
+
+    CREATE TABLE IF NOT EXISTS subscriptions (
+      id TEXT PRIMARY KEY,
+      agent TEXT,
+      provider TEXT NOT NULL,
+      plan TEXT NOT NULL,
+      monthly_fee_usd REAL NOT NULL DEFAULT 0,
+      included_usage_usd REAL NOT NULL DEFAULT 0,
+      billing_cycle_start TEXT,
+      reset_policy TEXT DEFAULT 'monthly',
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS usage_snapshots (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      date TEXT NOT NULL,
+      metric TEXT NOT NULL,
+      value REAL NOT NULL DEFAULT 0,
+      unit TEXT DEFAULT '',
+      machine_id TEXT DEFAULT '',
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS savings_daily (
+      date TEXT NOT NULL,
+      agent TEXT DEFAULT '',
+      api_equivalent_usd REAL NOT NULL DEFAULT 0,
+      subscription_fee_usd REAL NOT NULL DEFAULT 0,
+      included_consumed_usd REAL NOT NULL DEFAULT 0,
+      on_demand_usd REAL NOT NULL DEFAULT 0,
+      saved_usd REAL NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (date, agent)
+    );
+
+    CREATE TABLE IF NOT EXISTS machines (
+      machine_id TEXT PRIMARY KEY,
+      hostname TEXT NOT NULL,
+      last_seen_at TEXT,
+      last_push_at TEXT,
+      last_pull_at TEXT,
+      economy_version TEXT,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_usage_agent_date ON usage_snapshots(agent, date);
+    CREATE INDEX IF NOT EXISTS idx_savings_date ON savings_daily(date);
+  `);
+  addColumnIfMissing(db, "requests", "machine_id", `TEXT DEFAULT ''`);
+  addColumnIfMissing(db, "sessions", "machine_id", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "cost_centers", "updated_at", `TEXT DEFAULT ''`)) {
+    db.exec(`UPDATE cost_centers SET updated_at = created_at WHERE updated_at = '' OR updated_at IS NULL`);
+  }
+  addColumnIfMissing(db, "requests", "cost_center_id", `TEXT`);
+  addColumnIfMissing(db, "sessions", "cost_center_id", `TEXT`);
+  addColumnIfMissing(db, "budgets", "cost_center_id", `TEXT`);
+  addColumnIfMissing(db, "budgets", "metric", `TEXT NOT NULL DEFAULT 'legacy_request_cost_usd' CHECK (metric IN ('legacy_request_cost_usd', 'metered_api_usd'))`);
+  if (addColumnIfMissing(db, "requests", "cache_create_5m_tokens", "INTEGER DEFAULT 0")) {
+    db.exec(`UPDATE requests SET cache_create_5m_tokens = cache_create_tokens WHERE cache_create_5m_tokens = 0`);
+  }
+  addColumnIfMissing(db, "requests", "cache_create_1h_tokens", "INTEGER DEFAULT 0");
+  addColumnIfMissing(db, "requests", "cost_basis", `TEXT DEFAULT 'estimated'`);
+  addColumnIfMissing(db, "requests", "attribution_tag", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "requests", "updated_at", `TEXT DEFAULT ''`)) {
+    db.exec(`UPDATE requests SET updated_at = timestamp WHERE updated_at = '' OR updated_at IS NULL`);
+  }
+  addColumnIfMissing(db, "requests", "synced_at", `TEXT DEFAULT ''`);
+  for (const column of ["account_key", "account_tool", "account_name", "account_email", "account_source"]) {
+    addColumnIfMissing(db, "requests", column, `TEXT DEFAULT ''`);
+  }
+  addColumnIfMissing(db, "sessions", "attribution_tag", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "sessions", "updated_at", `TEXT DEFAULT ''`)) {
+    db.exec(`UPDATE sessions SET updated_at = started_at WHERE updated_at = '' OR updated_at IS NULL`);
+  }
+  addColumnIfMissing(db, "sessions", "synced_at", `TEXT DEFAULT ''`);
+  for (const column of ["account_key", "account_tool", "account_name", "account_email", "account_source"]) {
+    addColumnIfMissing(db, "sessions", column, `TEXT DEFAULT ''`);
+  }
+  addColumnIfMissing(db, "model_pricing", "cache_write_1h_per_1m", "REAL NOT NULL DEFAULT 0");
+  addColumnIfMissing(db, "model_pricing", "cache_storage_per_1m_hour", "REAL NOT NULL DEFAULT 0");
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_requests_machine ON requests(machine_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_machine ON sessions(machine_id);
+    CREATE INDEX IF NOT EXISTS idx_requests_account ON requests(account_key);
+    CREATE INDEX IF NOT EXISTS idx_sessions_account ON sessions(account_key);
+    CREATE INDEX IF NOT EXISTS idx_requests_cost_center ON requests(cost_center_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_cost_center ON sessions(cost_center_id);
+    CREATE INDEX IF NOT EXISTS idx_budgets_cost_center ON budgets(cost_center_id);
+    CREATE INDEX IF NOT EXISTS idx_cost_centers_kind ON cost_centers(kind);
+  `);
+  for (const [table, columns] of Object.entries(OBSERVATION_COLUMNS)) {
+    for (const [column, type] of Object.entries(columns))
+      addColumnIfMissing(db, table, column, type);
+  }
+  db.exec(SCAN_RECEIPTS_SQL);
+  db.exec(LEGACY_SQLITE_SQL);
+}
+function periodWhere(period, now = new Date) {
+  return calendarPeriodWhere(period, "timestamp", now);
+}
+function sessionPeriodWhere(period) {
+  return calendarPeriodWhere(period, "started_at");
+}
+function requestPeriodWhere(period) {
+  return calendarPeriodWhere(period, "timestamp");
+}
+function upsertCostCenter(db, center) {
+  const updatedAt = center.updated_at ?? center.created_at;
+  db.prepare(`
+    INSERT OR REPLACE INTO cost_centers
+      (id, kind, name, repo_path, labels_json, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(center.id, center.kind, center.name, center.repo_path ?? null, center.labels_json ?? "{}", center.created_at, updatedAt);
+}
+function getCostCenter(db, id) {
+  return db.prepare(`SELECT * FROM cost_centers WHERE id = ?`).get(id);
+}
+function upsertRequest(db, req) {
+  const now = req.updated_at ?? req.timestamp;
+  db.prepare(`
+    INSERT OR REPLACE INTO requests
+      (id, agent, session_id, model, input_tokens, output_tokens,
+       cache_read_tokens, cache_create_tokens, cache_create_5m_tokens,
+       cache_create_1h_tokens, cost_usd, cost_basis, duration_ms, timestamp,
+       source_request_id, machine_id, cost_center_id, attribution_tag, account_key, account_tool,
+       account_name, account_email, account_source, updated_at, synced_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(req.id, req.agent, req.session_id, req.model, req.input_tokens, req.output_tokens, req.cache_read_tokens, req.cache_create_tokens, req.cache_create_5m_tokens ?? req.cache_create_tokens, req.cache_create_1h_tokens ?? 0, req.cost_usd, req.cost_basis ?? "estimated", req.duration_ms, req.timestamp, req.source_request_id, req.machine_id ?? "", req.cost_center_id ?? null, req.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", req.account_key ?? "", req.account_tool ?? "", req.account_name ?? "", req.account_email ?? "", req.account_source ?? "", now, req.synced_at ?? "");
+}
+function upsertSession(db, session) {
+  const now = session.updated_at ?? session.ended_at ?? session.started_at;
+  db.prepare(`
+    INSERT OR REPLACE INTO sessions
+      (id, agent, project_path, project_name, started_at, ended_at,
+       total_cost_usd, total_tokens, request_count, machine_id, attribution_tag,
+       cost_center_id, account_key, account_tool, account_name, account_email, account_source, updated_at, synced_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(session.id, session.agent, session.project_path, session.project_name, session.started_at, session.ended_at ?? null, session.total_cost_usd, session.total_tokens, session.request_count, session.machine_id ?? "", session.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", session.cost_center_id ?? null, session.account_key ?? "", session.account_tool ?? "", session.account_name ?? "", session.account_email ?? "", session.account_source ?? "", now, session.synced_at ?? "");
+}
+function rollupSession(db, sessionId) {
+  db.prepare(`
+    UPDATE sessions SET
+      total_cost_usd = (SELECT COALESCE(SUM(cost_usd), 0) FROM economy_effective_requests WHERE session_id = ?),
+      total_tokens   = (SELECT COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) FROM economy_effective_requests WHERE session_id = ?),
+      request_count  = (SELECT COUNT(*) FROM economy_effective_requests WHERE session_id = ?),
+      ended_at       = (SELECT MAX(timestamp) FROM economy_effective_requests WHERE session_id = ?),
+      started_at     = CASE WHEN started_at = '' OR started_at IS NULL
+                            THEN (SELECT MIN(timestamp) FROM economy_effective_requests WHERE session_id = ?)
+                            ELSE started_at END,
+      account_key    = CASE WHEN account_key = '' OR account_key IS NULL
+                            THEN COALESCE((SELECT account_key FROM economy_effective_requests WHERE session_id = ? AND account_key != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_key END,
+      account_tool   = CASE WHEN account_tool = '' OR account_tool IS NULL
+                            THEN COALESCE((SELECT account_tool FROM economy_effective_requests WHERE session_id = ? AND account_tool != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_tool END,
+      account_name   = CASE WHEN account_name = '' OR account_name IS NULL
+                            THEN COALESCE((SELECT account_name FROM economy_effective_requests WHERE session_id = ? AND account_name != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_name END,
+      account_email  = CASE WHEN account_email = '' OR account_email IS NULL
+                            THEN COALESCE((SELECT account_email FROM economy_effective_requests WHERE session_id = ? AND account_email != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_email END,
+      account_source = CASE WHEN account_source = '' OR account_source IS NULL
+                            THEN COALESCE((SELECT account_source FROM economy_effective_requests WHERE session_id = ? AND account_source != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_source END,
+      cost_center_id = CASE WHEN cost_center_id = '' OR cost_center_id IS NULL
+                            THEN COALESCE((SELECT cost_center_id FROM economy_effective_requests WHERE session_id = ? AND cost_center_id IS NOT NULL AND cost_center_id != '' ORDER BY timestamp DESC LIMIT 1), NULL)
+                            ELSE cost_center_id END
+    WHERE id = ?
+  `).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId);
+}
+function querySessions(db, filter = {}) {
+  const conditions = [];
+  const params = [];
+  if (filter.agent) {
+    conditions.push("agent = ?");
+    params.push(filter.agent);
+  }
+  if (filter.project) {
+    conditions.push("project_path LIKE ?");
+    params.push(`%${filter.project}%`);
+  }
+  if (filter.account) {
+    const q2 = `%${filter.account}%`;
+    conditions.push("(account_key LIKE ? OR account_name LIKE ? OR account_email LIKE ?)");
+    params.push(q2, q2, q2);
+  }
+  if (filter.since) {
+    conditions.push("started_at >= ?");
+    params.push(filter.since);
+  }
+  if (filter.machine) {
+    conditions.push("machine_id = ?");
+    params.push(filter.machine);
+  }
+  if (filter.search) {
+    const q2 = `%${filter.search}%`;
+    conditions.push("(project_name LIKE ? OR agent LIKE ? OR id LIKE ?)");
+    params.push(q2, q2, `${filter.search}%`);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filter.limit ?? 50;
+  const offset = filter.offset ?? 0;
+  return db.prepare(`
+    SELECT * FROM economy_effective_sessions ${where} ORDER BY started_at DESC LIMIT ? OFFSET ?
+  `).all(...params, limit, offset);
+}
+function queryTopSessions(db, n = 10, agent, since) {
+  const conditions = [];
+  const params = [];
+  if (agent) {
+    conditions.push("agent = ?");
+    params.push(agent);
+  }
+  if (since) {
+    conditions.push("started_at >= ?");
+    params.push(since);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  return db.prepare(`SELECT * FROM economy_effective_sessions ${where} ORDER BY total_cost_usd DESC LIMIT ?`).all(...params, n);
+}
+function querySummary(db, period, machine, allMachines = false, agent) {
+  const now = new Date;
+  const rWhere = periodWhere(period, now);
+  const sWhere = sessionOverlapWhere(period, "economy_effective_sessions", now);
+  const machineClause = !allMachines && machine ? " AND machine_id = ?" : "";
+  const agentClause = agent ? " AND agent = ?" : "";
+  const params = [];
+  if (!allMachines && machine)
+    params.push(machine);
+  if (agent)
+    params.push(agent);
+  const groups = db.prepare(`
+    SELECT cost_basis, model, CASE WHEN cost_usd = 0 THEN 1 WHEN cost_usd < 0 THEN 2 ELSE 0 END AS zero_cost,
+      SUM(cost_usd) AS cost_usd, COUNT(*) AS requests,
+      COALESCE(SUM(input_tokens),0) AS input_tokens, COALESCE(SUM(output_tokens),0) AS output_tokens,
+      COALESCE(SUM(cache_read_tokens),0) AS cache_read_tokens, COALESCE(SUM(cache_create_tokens),0) AS cache_create_tokens,
+      COALESCE(SUM(cache_create_1h_tokens),0) AS cache_create_1h_tokens
+    FROM economy_effective_requests WHERE ${rWhere}${machineClause}${agentClause}
+    GROUP BY cost_basis, model, CASE WHEN cost_usd = 0 THEN 1 WHEN cost_usd < 0 THEN 2 ELSE 0 END
+  `).all(...params);
+  const sessionOnly = db.prepare(`
+    SELECT COALESCE(SUM(total_cost_usd),0) AS cost_usd, COALESCE(SUM(total_tokens),0) AS tokens,
+      COALESCE(SUM(request_count),0) AS requests, COUNT(*) AS sessions
+    FROM economy_effective_sessions WHERE ${sWhere}${machineClause}${agentClause}
+      AND NOT EXISTS (SELECT 1 FROM economy_effective_requests r WHERE r.session_id = economy_effective_sessions.id)
+  `).get(...params);
+  const requestSessions = db.prepare(`SELECT COUNT(DISTINCT session_id) AS sessions FROM economy_effective_requests WHERE ${rWhere}${machineClause}${agentClause}`).get(...params);
+  return buildCostSummary(period, calendarPeriodBounds(period, now), groups, sessionOnly, requestSessions.sessions, listModelPricing(db));
+}
+function queryZeroCostTokenizedModels(db, limit = 10) {
+  return db.prepare(`
+    SELECT agent,
+           model,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           MAX(timestamp) as last_seen
+    FROM economy_effective_requests
+    WHERE cost_usd = 0
+      AND (input_tokens > 0 OR output_tokens > 0 OR cache_read_tokens > 0 OR cache_create_tokens > 0)
+    GROUP BY agent, model
+    ORDER BY requests DESC, total_tokens DESC
+    LIMIT ?
+  `).all(limit);
+}
+function queryModelBreakdown(db) {
+  return db.prepare(`
+    SELECT model, agent,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens), 0) as input_tokens,
+           COALESCE(SUM(output_tokens), 0) as output_tokens,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM economy_effective_requests GROUP BY model, agent ORDER BY cost_usd DESC
+  `).all();
+}
+function queryAgentBreakdown(db, period = "all", machine) {
+  const requestWhere = requestPeriodWhere(period);
+  const machineClause = machine ? " AND machine_id = ?" : "";
+  const machineParams = machine ? [machine] : [];
+  const groups = new Map;
+  const requestRows = db.prepare(`
+    SELECT agent,
+           COUNT(DISTINCT session_id) as sessions,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as metered_api_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+           COALESCE(SUM(CASE WHEN COALESCE(cost_basis, 'estimated') = 'estimated' THEN cost_usd ELSE 0 END), 0) as estimated_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
+           COALESCE(SUM(cost_usd), 0) as cost_usd,
+           MAX(timestamp) as last_active
+    FROM economy_effective_requests
+    WHERE ${requestWhere}${machineClause}
+    GROUP BY agent
+    ORDER BY api_equivalent_usd DESC
+  `).all(...machineParams);
+  for (const row of requestRows) {
+    groups.set(row.agent, row);
+  }
+  const sessionWhere = sessionPeriodWhere(period);
+  const sessionOnlyRows = db.prepare(`
+    SELECT agent,
+           COUNT(*) as sessions,
+           COALESCE(SUM(request_count), 0) as requests,
+           COALESCE(SUM(total_tokens), 0) as total_tokens,
+           COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+           MAX(started_at) as last_active
+    FROM economy_effective_sessions
+    WHERE ${sessionWhere}${machineClause}
+      AND id NOT IN (SELECT DISTINCT session_id FROM economy_effective_requests)
+    GROUP BY agent
+  `).all(...machineParams);
+  for (const row of sessionOnlyRows) {
+    const existing = groups.get(row.agent) ?? {
+      agent: row.agent,
+      sessions: 0,
+      requests: 0,
+      total_tokens: 0,
+      api_equivalent_usd: 0,
+      billable_usd: 0,
+      metered_api_usd: 0,
+      subscription_included_usd: 0,
+      estimated_usd: 0,
+      unknown_usd: 0,
+      cost_usd: 0,
+      last_active: ""
+    };
+    existing.sessions += row.sessions;
+    existing.requests += row.requests;
+    existing.total_tokens += row.total_tokens;
+    existing.api_equivalent_usd += row.cost_usd;
+    existing.estimated_usd += row.cost_usd;
+    existing.cost_usd += row.cost_usd;
+    if (!existing.last_active || row.last_active > existing.last_active)
+      existing.last_active = row.last_active;
+    groups.set(row.agent, existing);
+  }
+  return [...groups.values()].sort((a, b) => b.api_equivalent_usd - a.api_equivalent_usd);
+}
+function pathProjectLabel(projectPath) {
+  if (!projectPath)
+    return "";
+  const segments = projectPath.split("/").filter(Boolean);
+  const projectPrefix = /^(open|skill|hook|service|connect|platform|agent|tool|iapp|project|scaffold|capp)-/;
+  for (const seg of segments) {
+    if (projectPrefix.test(seg))
+      return seg;
+  }
+  const generic = new Set([
+    "web",
+    "app",
+    "apps",
+    "packages",
+    "src",
+    "lib",
+    "server",
+    "client",
+    "api",
+    "frontend",
+    "backend",
+    "home",
+    "users",
+    "workspace",
+    "workspaces",
+    "hasna"
+  ]);
+  for (let i = segments.length - 1;i >= 0; i--) {
+    if (!generic.has(segments[i].toLowerCase()))
+      return segments[i];
+  }
+  return null;
+}
+function isRepoLikeLabel(label) {
+  return /^(open|skill|hook|service|connect|platform|agent|tool|iapp|project|scaffold|capp)-/.test(label) || label.includes("-");
+}
+function labelForPath(projectPath, projectName) {
+  const pathLabel = pathProjectLabel(projectPath);
+  if (pathLabel && (!projectName || projectName.trim() === "" || isRepoLikeLabel(pathLabel)))
+    return pathLabel;
+  if (projectName && projectName.trim() !== "")
+    return projectName;
+  if (pathLabel)
+    return pathLabel;
+  return projectPath;
+}
+function groupKeyForPath(projectPath, projectName) {
+  return labelForPath(projectPath, projectName).trim().toLowerCase();
+}
+function laterTimestamp(current, candidate) {
+  if (!candidate)
+    return current;
+  return candidate > current ? candidate : current;
+}
+function queryProjectBreakdownScoped(db, requestWhere, sessionWhere, requestScopeParams = [], sessionScopeParams = [], machine) {
+  const sessionMachineClause = machine ? " AND (machine_id = ? OR id IN (SELECT DISTINCT session_id FROM economy_effective_requests WHERE machine_id = ?))" : "";
+  const requestMachineClause = machine ? " AND machine_id = ?" : "";
+  const sessionMachineParams = machine ? [machine, machine] : [];
+  const requestMachineParams = machine ? [machine] : [];
+  const sessionOnlyMachineClause = machine ? " AND machine_id = ?" : "";
+  const sessionOnlyMachineParams = machine ? [machine] : [];
+  const sessions = db.prepare(`
+    SELECT id, project_path, project_name
+    FROM economy_effective_sessions
+    WHERE (project_path != '' OR project_name != '')${sessionMachineClause}
+  `).all(...sessionMachineParams);
+  const groups = new Map;
+  const groupKeyBySession = new Map;
+  for (const s of sessions) {
+    const label = labelForPath(s.project_path, s.project_name);
+    if (!label)
+      continue;
+    const key = groupKeyForPath(s.project_path, s.project_name);
+    const g = groups.get(key) ?? { label, samplePath: s.project_path, sessions: 0, requests: 0, total_tokens: 0, cost_usd: 0, last_active: "" };
+    if (!g.samplePath)
+      g.samplePath = s.project_path;
+    groups.set(key, g);
+    groupKeyBySession.set(s.id, key);
+  }
+  const groupFor = (sessionId) => {
+    const key = groupKeyBySession.get(sessionId);
+    return key === undefined ? undefined : groups.get(key);
+  };
+  const requestRows = db.prepare(`
+    SELECT session_id,
+           COUNT(*) as requests,
+           COALESCE(SUM(cost_usd), 0) as cost_usd,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           MAX(timestamp) as last_active
+    FROM economy_effective_requests
+    WHERE ${requestWhere}${requestMachineClause}
+    GROUP BY session_id
+  `).all(...requestScopeParams, ...requestMachineParams);
+  for (const row of requestRows) {
+    const g = groupFor(row.session_id);
+    if (!g)
+      continue;
+    g.sessions += 1;
+    g.requests += row.requests;
+    g.cost_usd += row.cost_usd;
+    g.total_tokens += row.total_tokens;
+    g.last_active = laterTimestamp(g.last_active, row.last_active);
+  }
+  const sessionsWithRequests = new Set(db.prepare(`SELECT DISTINCT session_id FROM economy_effective_requests`).all().map((row) => row.session_id));
+  const sessionOnlyRows = db.prepare(`
+    SELECT id,
+           COALESCE(request_count, 0) as request_count,
+           COALESCE(total_tokens, 0) as total_tokens,
+           COALESCE(total_cost_usd, 0) as total_cost_usd,
+           started_at
+    FROM economy_effective_sessions
+    WHERE ${sessionWhere}${sessionOnlyMachineClause}
+  `).all(...sessionScopeParams, ...sessionOnlyMachineParams);
+  for (const row of sessionOnlyRows) {
+    if (sessionsWithRequests.has(row.id))
+      continue;
+    const g = groupFor(row.id);
+    if (!g)
+      continue;
+    g.sessions += 1;
+    g.requests += row.request_count;
+    g.total_tokens += row.total_tokens;
+    g.cost_usd += row.total_cost_usd;
+    g.last_active = laterTimestamp(g.last_active, row.started_at);
+  }
+  const result = [];
+  for (const g of groups.values()) {
+    if (g.sessions === 0)
+      continue;
+    result.push({
+      project_path: g.samplePath,
+      project_name: g.label,
+      sessions: g.sessions,
+      requests: g.requests,
+      total_tokens: g.total_tokens,
+      cost_usd: g.cost_usd,
+      last_active: g.last_active
+    });
+  }
+  result.sort((a, b) => b.cost_usd - a.cost_usd);
+  return result;
+}
+function queryProjectBreakdown(db, period = "all", machine) {
+  return queryProjectBreakdownScoped(db, requestPeriodWhere(period), sessionPeriodWhere(period), [], [], machine);
+}
+function normalizeAccountEmail(email) {
+  return (email ?? "").trim().toLowerCase();
+}
+function accountIdentityKey(agent, accountKey, accountName, accountEmail) {
+  const identityAgent = (agent || "").trim();
+  const normalizedEmail = normalizeAccountEmail(accountEmail);
+  if (identityAgent && normalizedEmail)
+    return `${identityAgent}:${normalizedEmail}`;
+  if (identityAgent && accountName)
+    return `${identityAgent}:${accountName}`;
+  if (accountKey)
+    return accountKey;
+  return identityAgent ? `${identityAgent}:unknown` : "";
+}
+function addAccountBreakdownRow(groups, row, sessionOnly) {
+  const agent = row.agent || row.account_tool;
+  const email = normalizeAccountEmail(row.account_email);
+  const accountName = row.account_name || email || row.account_key;
+  const key = accountIdentityKey(agent, row.account_key, accountName, email);
+  if (!key)
+    return;
+  const group = groups.get(key) ?? {
+    account_key: key,
+    account_tool: agent,
+    account_name: accountName,
+    account_email: email || null,
+    account_source: row.account_source || "unknown",
+    sessionIds: new Set,
+    requests: 0,
+    total_tokens: 0,
+    api_equivalent_usd: 0,
+    metered_api_usd: 0,
+    subscription_included_usd: 0,
+    estimated_usd: 0,
+    unknown_usd: 0,
+    last_active: ""
+  };
+  if (!group.account_email && email)
+    group.account_email = email;
+  if (!group.account_name && accountName)
+    group.account_name = accountName;
+  if ((!group.account_source || group.account_source === "unknown") && row.account_source && row.account_source !== "unknown") {
+    group.account_source = row.account_source;
+  }
+  if (row.session_id)
+    group.sessionIds.add(row.session_id);
+  group.requests += row.requests;
+  group.total_tokens += row.total_tokens;
+  group.api_equivalent_usd += row.cost_usd;
+  if (sessionOnly) {
+    group.estimated_usd += row.cost_usd;
+  } else if (row.cost_basis === "metered_api") {
+    group.metered_api_usd += row.cost_usd;
+  } else if (row.cost_basis === "subscription_included") {
+    group.subscription_included_usd += row.cost_usd;
+  } else if (row.cost_basis === "unknown") {
+    group.unknown_usd += row.cost_usd;
+  } else {
+    group.estimated_usd += row.cost_usd;
+  }
+  if (!group.last_active || row.last_active > group.last_active)
+    group.last_active = row.last_active;
+  groups.set(key, group);
+}
+function queryAccountBreakdown(db, period = "all", machine) {
+  const requestWhere = requestPeriodWhere(period);
+  const sessionWhere = sessionPeriodWhere(period);
+  const requestMachineClause = machine ? " AND r.machine_id = ?" : "";
+  const sessionMachineClause = machine ? " AND s.machine_id = ?" : "";
+  const requestMachineParams = machine ? [machine] : [];
+  const sessionMachineParams = machine ? [machine] : [];
+  const groups = new Map;
+  const requestRows = db.prepare(`
+    SELECT
+      r.session_id as session_id,
+      COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), '') as agent,
+      COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') as account_key,
+      COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') as account_tool,
+      COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') as account_name,
+      COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') as account_email,
+      COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown') as account_source,
+      1 as requests,
+      COALESCE(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens, 0) as total_tokens,
+      COALESCE(r.cost_usd, 0) as cost_usd,
+      COALESCE(NULLIF(r.cost_basis, ''), 'estimated') as cost_basis,
+      r.timestamp as last_active
+    FROM economy_effective_requests r
+    LEFT JOIN economy_effective_sessions s ON s.id = r.session_id
+    WHERE ${requestWhere}${requestMachineClause}
+      AND (
+        COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') != ''
+        OR COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') != ''
+        OR COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') != ''
+        OR COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') != ''
+      )
+  `).all(...requestMachineParams);
+  for (const row of requestRows)
+    addAccountBreakdownRow(groups, row, false);
+  const sessionOnlyRows = db.prepare(`
+    SELECT
+      s.id as session_id,
+      s.agent as agent,
+      s.account_key as account_key,
+      s.account_tool as account_tool,
+      s.account_name as account_name,
+      s.account_email as account_email,
+      COALESCE(NULLIF(s.account_source, ''), 'unknown') as account_source,
+      COALESCE(s.request_count, 0) as requests,
+      COALESCE(s.total_tokens, 0) as total_tokens,
+      COALESCE(s.total_cost_usd, 0) as cost_usd,
+      'estimated' as cost_basis,
+      s.started_at as last_active
+    FROM economy_effective_sessions s
+    WHERE ${sessionWhere}${sessionMachineClause}
+      AND s.id NOT IN (SELECT DISTINCT session_id FROM economy_effective_requests)
+      AND (s.account_key != '' OR s.account_tool != '' OR s.account_name != '' OR s.account_email != '')
+  `).all(...sessionMachineParams);
+  for (const row of sessionOnlyRows)
+    addAccountBreakdownRow(groups, row, true);
+  const result = [...groups.values()].map((group) => ({
+    account_key: group.account_key,
+    account_tool: group.account_tool,
+    account_name: group.account_name,
+    account_email: group.account_email,
+    account_source: group.account_source,
+    sessions: group.sessionIds.size,
+    requests: group.requests,
+    total_tokens: group.total_tokens,
+    api_equivalent_usd: group.api_equivalent_usd,
+    billable_usd: group.metered_api_usd,
+    metered_api_usd: group.metered_api_usd,
+    subscription_included_usd: group.subscription_included_usd,
+    estimated_usd: group.estimated_usd,
+    unknown_usd: group.unknown_usd,
+    cost_usd: group.api_equivalent_usd,
+    last_active: group.last_active
+  }));
+  result.sort((a, b) => b.cost_usd - a.cost_usd);
+  return result;
+}
+function kindFromCostCenterId(id) {
+  const prefix = id.split(":", 1)[0] ?? "";
+  return ["loop", "app", "repo", "service", "team"].includes(prefix) ? prefix : "";
+}
+function addCostCenterBreakdownRow(groups, row, sessionOnly) {
+  if (!row.cost_center_id)
+    return;
+  const derivedKind = row.kind || kindFromCostCenterId(row.cost_center_id) || "service";
+  const group = groups.get(row.cost_center_id) ?? {
+    cost_center_id: row.cost_center_id,
+    kind: derivedKind,
+    name: row.name || row.cost_center_id,
+    repo_path: row.repo_path ?? null,
+    labels_json: row.labels_json || "{}",
+    sessionIds: new Set,
+    requests: 0,
+    total_tokens: 0,
+    api_equivalent_usd: 0,
+    metered_api_usd: 0,
+    subscription_included_usd: 0,
+    estimated_usd: 0,
+    unknown_usd: 0,
+    last_active: ""
+  };
+  group.kind = derivedKind;
+  if (row.name)
+    group.name = row.name;
+  if (row.repo_path && !group.repo_path)
+    group.repo_path = row.repo_path;
+  if (row.labels_json && row.labels_json !== "{}")
+    group.labels_json = row.labels_json;
+  if (row.session_id)
+    group.sessionIds.add(row.session_id);
+  group.requests += row.requests;
+  group.total_tokens += row.total_tokens;
+  group.api_equivalent_usd += row.cost_usd;
+  if (sessionOnly) {
+    group.estimated_usd += row.cost_usd;
+  } else if (row.cost_basis === "metered_api") {
+    group.metered_api_usd += row.cost_usd;
+  } else if (row.cost_basis === "subscription_included") {
+    group.subscription_included_usd += row.cost_usd;
+  } else if (row.cost_basis === "unknown") {
+    group.unknown_usd += row.cost_usd;
+  } else {
+    group.estimated_usd += row.cost_usd;
+  }
+  if (!group.last_active || row.last_active > group.last_active)
+    group.last_active = row.last_active;
+  groups.set(row.cost_center_id, group);
+}
+function queryCostCenterBreakdown(db, period = "all", filter = {}) {
+  const requestWhere = filter.since ? "r.timestamp >= ?" : requestPeriodWhere(period);
+  const sessionWhere = filter.since ? "s.started_at >= ?" : sessionPeriodWhere(period);
+  const requestMachineClause = filter.machine ? " AND r.machine_id = ?" : "";
+  const sessionMachineClause = filter.machine ? " AND s.machine_id = ?" : "";
+  const requestParams = [];
+  const sessionParams = [];
+  if (filter.since) {
+    requestParams.push(filter.since);
+    sessionParams.push(filter.since);
+  }
+  if (filter.machine) {
+    requestParams.push(filter.machine);
+    sessionParams.push(filter.machine);
+  }
+  const groups = new Map;
+  const requestRows = db.prepare(`
+    SELECT
+      COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, '')) as cost_center_id,
+      COALESCE(cc.kind, '') as kind,
+      COALESCE(cc.name, COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, ''))) as name,
+      cc.repo_path as repo_path,
+      COALESCE(cc.labels_json, '{}') as labels_json,
+      r.session_id as session_id,
+      1 as requests,
+      COALESCE(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens, 0) as total_tokens,
+      COALESCE(r.cost_usd, 0) as cost_usd,
+      COALESCE(NULLIF(r.cost_basis, ''), 'estimated') as cost_basis,
+      r.timestamp as last_active
+    FROM economy_effective_requests r
+    LEFT JOIN economy_effective_sessions s ON s.id = r.session_id
+    LEFT JOIN cost_centers cc ON cc.id = COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, ''))
+    WHERE ${requestWhere}${requestMachineClause}
+      AND COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, '')) IS NOT NULL
+      AND COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, '')) != ''
+  `).all(...requestParams);
+  for (const row of requestRows)
+    addCostCenterBreakdownRow(groups, row, false);
+  const sessionOnlyRows = db.prepare(`
+    SELECT
+      s.cost_center_id as cost_center_id,
+      COALESCE(cc.kind, '') as kind,
+      COALESCE(cc.name, s.cost_center_id) as name,
+      cc.repo_path as repo_path,
+      COALESCE(cc.labels_json, '{}') as labels_json,
+      s.id as session_id,
+      COALESCE(s.request_count, 0) as requests,
+      COALESCE(s.total_tokens, 0) as total_tokens,
+      COALESCE(s.total_cost_usd, 0) as cost_usd,
+      'estimated' as cost_basis,
+      s.started_at as last_active
+    FROM economy_effective_sessions s
+    LEFT JOIN cost_centers cc ON cc.id = s.cost_center_id
+    WHERE ${sessionWhere}${sessionMachineClause}
+      AND s.id NOT IN (SELECT DISTINCT session_id FROM economy_effective_requests)
+      AND s.cost_center_id IS NOT NULL
+      AND s.cost_center_id != ''
+  `).all(...sessionParams);
+  for (const row of sessionOnlyRows)
+    addCostCenterBreakdownRow(groups, row, true);
+  const result = [...groups.values()].map((group) => ({
+    cost_center_id: group.cost_center_id,
+    kind: group.kind,
+    name: group.name,
+    repo_path: group.repo_path,
+    labels_json: group.labels_json,
+    sessions: group.sessionIds.size,
+    requests: group.requests,
+    total_tokens: group.total_tokens,
+    api_equivalent_usd: group.api_equivalent_usd,
+    billable_usd: group.metered_api_usd,
+    metered_api_usd: group.metered_api_usd,
+    subscription_included_usd: group.subscription_included_usd,
+    estimated_usd: group.estimated_usd,
+    unknown_usd: group.unknown_usd,
+    cost_usd: group.api_equivalent_usd,
+    last_active: group.last_active
+  }));
+  const filtered = filter.kind ? result.filter((row) => row.kind === filter.kind) : result;
+  filtered.sort((a, b) => b.cost_usd - a.cost_usd);
+  return filtered;
+}
+function queryProjectBreakdownSince(db, since, machine) {
+  return queryProjectBreakdownScoped(db, "timestamp >= ?", "started_at >= ?", [since], [since], machine);
+}
+function queryAgentBreakdownSince(db, since) {
+  return db.prepare(`
+    SELECT agent,
+           COUNT(DISTINCT session_id) as sessions,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+           MAX(timestamp) as last_active
+    FROM economy_effective_requests
+    WHERE timestamp >= ?
+    GROUP BY agent
+    ORDER BY api_equivalent_usd DESC
+  `).all(since);
+}
+function queryModelBreakdownSince(db, since) {
+  return db.prepare(`
+    SELECT model, agent,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens), 0) as input_tokens,
+           COALESCE(SUM(output_tokens), 0) as output_tokens,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM economy_effective_requests WHERE timestamp >= ?
+    GROUP BY model, agent ORDER BY cost_usd DESC
+  `).all(since);
+}
+function queryAccountBreakdownSince(db, since) {
+  return db.prepare(`
+    WITH request_rows AS (
+      SELECT
+        r.session_id as session_id,
+        COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), 'unknown') as account_agent,
+        COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') as raw_account_key,
+        COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') as raw_account_name,
+        LOWER(TRIM(COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), ''))) as raw_account_email,
+        COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown') as account_source,
+        1 as requests,
+        COALESCE(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens, 0) as total_tokens,
+        COALESCE(r.cost_usd, 0) as cost_usd,
+        COALESCE(NULLIF(r.cost_basis, ''), 'estimated') as cost_basis,
+        r.timestamp as last_active
+      FROM economy_effective_requests r
+      LEFT JOIN economy_effective_sessions s ON s.id = r.session_id
+      WHERE r.timestamp >= ?
+        AND (
+          COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') != ''
+        )
+    ),
+    session_only_rows AS (
+      SELECT
+        s.id as session_id,
+        COALESCE(NULLIF(s.agent, ''), NULLIF(s.account_tool, ''), 'unknown') as account_agent,
+        s.account_key as raw_account_key,
+        s.account_name as raw_account_name,
+        LOWER(TRIM(COALESCE(s.account_email, ''))) as raw_account_email,
+        COALESCE(NULLIF(s.account_source, ''), 'unknown') as account_source,
+        COALESCE(s.request_count, 0) as requests,
+        COALESCE(s.total_tokens, 0) as total_tokens,
+        COALESCE(s.total_cost_usd, 0) as cost_usd,
+        'estimated' as cost_basis,
+        s.started_at as last_active
+      FROM economy_effective_sessions s
+      WHERE s.started_at >= ?
+        AND s.id NOT IN (SELECT DISTINCT session_id FROM economy_effective_requests)
+        AND (s.account_key != '' OR s.account_tool != '' OR s.account_name != '' OR s.account_email != '')
+    ),
+    normalized AS (
+      SELECT
+        CASE
+          WHEN raw_account_email != '' THEN account_agent || ':' || raw_account_email
+          WHEN raw_account_name != '' THEN account_agent || ':' || raw_account_name
+          ELSE raw_account_key
+        END as account_key,
+        account_agent as account_tool,
+        raw_account_name as account_name,
+        raw_account_email as account_email,
+        account_source,
+        session_id,
+        requests,
+        total_tokens,
+        cost_usd,
+        cost_basis,
+        last_active
+      FROM request_rows
+      UNION ALL
+      SELECT
+        CASE
+          WHEN raw_account_email != '' THEN account_agent || ':' || raw_account_email
+          WHEN raw_account_name != '' THEN account_agent || ':' || raw_account_name
+          ELSE raw_account_key
+        END as account_key,
+        account_agent as account_tool,
+        raw_account_name as account_name,
+        raw_account_email as account_email,
+        account_source,
+        session_id,
+        requests,
+        total_tokens,
+        cost_usd,
+        cost_basis,
+        last_active
+      FROM session_only_rows
+    )
+    SELECT account_key,
+           account_tool,
+           COALESCE(MAX(NULLIF(account_name, '')), MAX(NULLIF(account_email, '')), account_key) as account_name,
+           NULLIF(account_email, '') as account_email,
+           COALESCE(MAX(NULLIF(account_source, 'unknown')), 'unknown') as account_source,
+           COUNT(DISTINCT session_id) as sessions,
+           COALESCE(SUM(requests), 0) as requests,
+           COALESCE(SUM(total_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as metered_api_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+           COALESCE(SUM(CASE WHEN cost_basis NOT IN ('metered_api', 'subscription_included', 'unknown') THEN cost_usd ELSE 0 END), 0) as estimated_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd,
+           COALESCE(SUM(cost_usd), 0) as cost_usd,
+           MAX(last_active) as last_active
+    FROM normalized
+    WHERE account_key != ''
+    GROUP BY account_key, account_tool, account_email
+    ORDER BY api_equivalent_usd DESC
+  `).all(since, since);
+}
+function queryDailyBreakdown(db, days = 30, machine) {
+  const machineClause = machine ? " AND machine_id = ?" : "";
+  const params = machine ? [`-${days}`, machine] : [`-${days}`];
+  return db.prepare(`
+    SELECT DATE(timestamp) as date, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM economy_effective_requests
+    WHERE timestamp >= DATE('now', ? || ' days')${machineClause}
+    GROUP BY DATE(timestamp), agent
+    ORDER BY date ASC
+  `).all(...params);
+}
+function queryHourlyBreakdown(db, machine, hours) {
+  const clauses = hours == null ? [`DATE(timestamp) = DATE('now')`] : [`DATETIME(timestamp) >= DATETIME('now', ?)`];
+  const params = hours == null ? [] : [`-${hours} hours`];
+  if (machine) {
+    clauses.push("machine_id = ?");
+    params.push(machine);
+  }
+  return db.prepare(`
+    SELECT STRFTIME('%H', timestamp) as hour, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM economy_effective_requests
+    WHERE ${clauses.join(" AND ")}
+    GROUP BY STRFTIME('%H', timestamp), agent
+    ORDER BY hour ASC
+  `).all(...params);
+}
+function upsertProject(db, project) {
+  db.prepare(`
+    INSERT OR REPLACE INTO projects (id, path, name, description, tags, created_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(project.id, project.path, project.name, project.description ?? null, JSON.stringify(project.tags), project.created_at);
+}
+function getProject(db, path) {
+  const row = db.prepare(`SELECT * FROM projects WHERE path = ?`).get(path);
+  if (!row)
+    return null;
+  return { ...row, tags: JSON.parse(row["tags"] ?? "[]") };
+}
+function listProjects(db) {
+  return db.prepare(`SELECT * FROM projects ORDER BY created_at DESC`).all().map((row) => ({ ...row, tags: JSON.parse(row["tags"] ?? "[]") }));
+}
+function deleteProject(db, path) {
+  db.prepare(`DELETE FROM projects WHERE path = ?`).run(path);
+}
+function upsertBudget(db, budget) {
+  if (budget.metric && budget.metric !== "legacy_request_cost_usd")
+    throw new IngestError(409, "INGEST_CONFLICT", "budget.metric", "metered API rules require the explicit ingest create command");
+  const result = db.prepare(`
+    INSERT INTO budgets
+      (id, project_path, agent, cost_center_id, period, limit_usd, alert_at_percent, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET project_path=excluded.project_path, agent=excluded.agent,
+      cost_center_id=excluded.cost_center_id, period=excluded.period, limit_usd=excluded.limit_usd,
+      alert_at_percent=excluded.alert_at_percent, created_at=excluded.created_at, updated_at=excluded.updated_at
+    WHERE budgets.metric='legacy_request_cost_usd'
+  `).run(budget.id, budget.project_path ?? null, budget.agent ?? null, budget.cost_center_id ?? null, budget.period, budget.limit_usd, budget.alert_at_percent, budget.created_at, budget.updated_at);
+  if (result.changes !== 1)
+    throw new IngestError(409, "INGEST_CONFLICT", "budget.id", "existing metered API rules are create-only");
+}
+function listBudgets(db) {
+  return db.prepare(`SELECT * FROM budgets ORDER BY created_at DESC`).all();
+}
+function deleteBudget(db, id) {
+  db.prepare(`DELETE FROM budgets WHERE id = ?`).run(id);
+}
+function getBudgetStatuses(db, now = new Date) {
+  const budgets = listBudgets(db);
+  return budgets.map((b) => {
+    const period = b.period === "daily" ? "today" : b.period === "weekly" ? "week" : "month";
+    let where = calendarPeriodWhere(period, "timestamp", now);
+    if (b.metric === "metered_api_usd")
+      where += ` AND cost_basis = 'metered_api'`;
+    const params = [];
+    if (b.project_path) {
+      where += ` AND session_id IN (SELECT id FROM economy_effective_sessions WHERE project_path = ?)`;
+      params.push(b.project_path);
+    }
+    if (b.agent) {
+      where += ` AND agent = ?`;
+      params.push(b.agent);
+    }
+    if (b.cost_center_id) {
+      where += ` AND COALESCE(NULLIF(cost_center_id, ''), (SELECT NULLIF(s.cost_center_id, '') FROM economy_effective_sessions s WHERE s.id = economy_effective_requests.session_id)) = ?`;
+      params.push(b.cost_center_id);
+    }
+    if (b.metric === "metered_api_usd") {
+      const groups = db.prepare(`SELECT cost_usd,COUNT(*) AS entries FROM economy_effective_requests WHERE ${where} GROUP BY cost_usd`).all(...params);
+      return { ...b, period_bounds: calendarPeriodBounds(period, now), ...meteredBudgetAmounts(groups, b.limit_usd, b.alert_at_percent) };
+    }
+    const row = db.prepare(`SELECT COALESCE(SUM(cost_usd), 0) as spend FROM economy_effective_requests WHERE ${where}`).get(...params);
+    const spend = row.spend;
+    const percent = b.limit_usd > 0 ? spend / b.limit_usd * 100 : 0;
+    return {
+      ...b,
+      period_bounds: calendarPeriodBounds(period, now),
+      current_spend_usd: spend,
+      percent_used: percent,
+      is_over_limit: percent >= 100,
+      is_over_alert: percent >= b.alert_at_percent
+    };
+  });
+}
+function upsertGoal(db, goal) {
+  db.prepare(`
+    INSERT OR REPLACE INTO goals
+      (id, period, project_path, agent, limit_usd, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(goal.id, goal.period, goal.project_path ?? null, goal.agent ?? null, goal.limit_usd, goal.created_at, goal.updated_at);
+}
+function deleteGoal(db, id) {
+  db.prepare(`DELETE FROM goals WHERE id = ?`).run(id);
+}
+function listGoals(db) {
+  return db.prepare(`SELECT * FROM goals ORDER BY created_at DESC`).all();
+}
+function getGoalStatuses(db) {
+  const goals = listGoals(db);
+  return goals.map((g) => {
+    const period = g.period === "day" ? "today" : g.period;
+    let spendQuery = `SELECT COALESCE(SUM(cost_usd), 0) as spend FROM economy_effective_requests WHERE ${calendarPeriodWhere(period, "timestamp")}`;
+    const params = [];
+    if (g.project_path) {
+      spendQuery += ` AND session_id IN (SELECT id FROM economy_effective_sessions WHERE project_path = ?)`;
+      params.push(g.project_path);
+    }
+    if (g.agent) {
+      spendQuery += ` AND agent = ?`;
+      params.push(g.agent);
+    }
+    const row = db.prepare(spendQuery).get(...params);
+    const spend = row.spend;
+    const percent = g.limit_usd > 0 ? spend / g.limit_usd * 100 : 0;
+    return {
+      ...g,
+      current_spend_usd: spend,
+      percent_used: percent,
+      is_on_track: percent < 70,
+      is_at_risk: percent >= 70 && percent <= 100,
+      is_over: percent > 100
+    };
+  });
+}
+function getIngestState(db, source, key) {
+  const row = db.prepare(`SELECT value FROM ingest_state WHERE source = ? AND key = ?`).get(source, key);
+  return row?.value ?? null;
+}
+function loadIngestState(db, source) {
+  const rows = db.prepare(`SELECT key, value FROM ingest_state WHERE source = ?`).all(source);
+  return new Map(rows.map((row) => [row.key, row.value]));
+}
+function setIngestState(db, source, key, value) {
+  db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES (?, ?, ?)`).run(source, key, value);
+}
+function queryRequestsSince(db, since) {
+  return db.prepare(`SELECT * FROM economy_effective_requests WHERE timestamp > ? ORDER BY timestamp ASC`).all(since);
+}
+function insertFeedback(db, record) {
+  db.prepare(`INSERT INTO feedback (message, email, category, version, machine_id) VALUES (?, ?, ?, ?, ?)`).run(record.message, record.email ?? null, record.category ?? "general", record.version ?? null, record.machine_id ?? null);
+}
+function upsertBillingDaily(db, row) {
+  db.prepare(`
+    INSERT OR REPLACE INTO billing_daily (date, provider, description, cost_usd, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(row.date, row.provider, row.description, row.cost_usd, row.updated_at);
+}
+function clearBillingRange(db, provider, fromDate, toDate) {
+  db.prepare(`DELETE FROM billing_daily WHERE provider = ? AND date >= ? AND date <= ?`).run(provider, fromDate, toDate);
+}
+function billingPeriodWhere(period) {
+  return calendarPeriodWhere(period, "date");
+}
+function queryBillingSummary(db, period) {
+  const now = new Date;
+  const rows = db.prepare(`SELECT provider, SUM(cost_usd) AS cost, COUNT(*) AS records FROM billing_daily WHERE ${calendarPeriodWhere(period, "date", now)} GROUP BY provider`).all();
+  const by_provider = {};
+  let total = 0, records = 0;
+  for (const row of rows) {
+    by_provider[row.provider] = row.cost;
+    total += row.cost;
+    records += row.records;
+  }
+  return {
+    total_usd: total,
+    recorded_total_usd: records ? total : null,
+    complete_total_usd: null,
+    by_provider,
+    basis: "recorded_provider_rows_subtotal",
+    status: records ? "observed" : "no_records",
+    record_count: records,
+    coverage_scope: "selected_stored_records",
+    source_coverage: "not_established",
+    period_bounds: calendarPeriodBounds(period, now)
+  };
+}
+function countBillingRecords(db, period) {
+  const row = db.prepare(`SELECT COUNT(*) as c FROM billing_daily WHERE ${billingPeriodWhere(period)}`).get();
+  return row?.c ?? 0;
+}
+function getSessionDetail(db, id) {
+  const session = db.prepare(`SELECT * FROM economy_effective_sessions WHERE id = ? OR id LIKE ?`).get(id, `${id}%`);
+  if (!session)
+    return null;
+  const requests = db.prepare(`SELECT * FROM economy_effective_requests WHERE session_id = ? ORDER BY timestamp ASC`).all(session["id"]);
+  return { session, requests };
+}
+function listMachines(db, period = "all") {
+  const rWhere = requestPeriodWhere(period);
+  const sWhere = sessionPeriodWhere(period);
+  return db.prepare(`
+    WITH request_stats AS (
+      SELECT
+        machine_id,
+        COUNT(DISTINCT session_id) as sessions,
+        COUNT(*) as requests,
+        COALESCE(SUM(cost_usd), 0) as total_cost_usd,
+        MAX(timestamp) as last_active
+      FROM economy_effective_requests
+      WHERE machine_id != ''
+        AND ${rWhere}
+      GROUP BY machine_id
+    ),
+    session_only_stats AS (
+      SELECT
+        machine_id,
+        COUNT(*) as sessions,
+        COALESCE(SUM(request_count), 0) as requests,
+        COALESCE(SUM(total_cost_usd), 0) as total_cost_usd,
+        MAX(started_at) as last_active
+      FROM economy_effective_sessions
+      WHERE machine_id != ''
+        AND ${sWhere}
+        AND id NOT IN (SELECT DISTINCT session_id FROM economy_effective_requests)
+      GROUP BY machine_id
+    ),
+    combined AS (
+      SELECT * FROM request_stats
+      UNION ALL
+      SELECT * FROM session_only_stats
+    )
+    SELECT
+      machine_id,
+      COALESCE(SUM(sessions), 0) as sessions,
+      COALESCE(SUM(requests), 0) as requests,
+      COALESCE(SUM(total_cost_usd), 0) as total_cost_usd,
+      MAX(last_active) as last_active
+    FROM combined
+    GROUP BY machine_id
+    ORDER BY total_cost_usd DESC
+  `).all();
+}
+function upsertModelPricing(db, p) {
+  db.prepare(`
+    INSERT OR REPLACE INTO model_pricing
+      (model, input_per_1m, output_per_1m, cache_read_per_1m, cache_write_per_1m, cache_write_1h_per_1m, cache_storage_per_1m_hour, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(p.model, p.input_per_1m, p.output_per_1m, p.cache_read_per_1m, p.cache_write_per_1m, p.cache_write_1h_per_1m ?? 0, p.cache_storage_per_1m_hour ?? 0, p.updated_at);
+}
+function getModelPricing(db, model) {
+  return db.prepare(`SELECT * FROM model_pricing WHERE model = ?`).get(model);
+}
+function listModelPricing(db) {
+  return db.prepare(`SELECT * FROM model_pricing ORDER BY model ASC`).all();
+}
+function deleteModelPricing(db, model) {
+  db.prepare(`DELETE FROM model_pricing WHERE model = ?`).run(model);
+}
+function seedModelPricing(db, defaults) {
+  const existing = new Set(db.prepare(`SELECT model FROM model_pricing`).all().map((r) => r.model));
+  const now = new Date().toISOString();
+  for (const [model, p] of Object.entries(defaults)) {
+    if (existing.has(model))
+      continue;
+    upsertModelPricing(db, {
+      model,
+      input_per_1m: p.inputPer1M,
+      output_per_1m: p.outputPer1M,
+      cache_read_per_1m: p.cacheReadPer1M,
+      cache_write_per_1m: p.cacheWritePer1M,
+      cache_write_1h_per_1m: p.cacheWrite1hPer1M ?? 0,
+      cache_storage_per_1m_hour: p.cacheStoragePer1MHour ?? 0,
+      updated_at: now
+    });
+  }
+}
+function upsertSubscription(db, sub, mode = "configuration") {
+  if (sub.account_key) {
+    bulkIngest(db, { subscriptions: [sub], subscription_mode: mode });
+    return;
+  }
+  const row = { ...sub };
+  const groups = validateIngest({ subscriptions: [row] });
+  const spec = groups[0].spec;
+  const values = spec.map(groups[0].rows[0], "");
+  const columns = spec.columns;
+  const updates = columns.filter((k) => k !== "id" && k !== "created_at");
+  db.run(`INSERT INTO subscriptions (${columns.join(",")}) VALUES (${columns.map(() => "?").join(",")})
+    ON CONFLICT(id) DO UPDATE SET ${updates.map((k) => `${k}=excluded.${k}`).join(",")}
+    WHERE subscriptions.observed_at IS NULL OR (excluded.observed_at IS NOT NULL AND excluded.observed_at > subscriptions.observed_at)`, ...values);
+}
+function listSubscriptions(db) {
+  return db.prepare(`SELECT * FROM subscriptions ORDER BY provider, plan`).all();
+}
+function deleteSubscription(db, id) {
+  db.prepare(`DELETE FROM subscriptions WHERE id = ?`).run(id);
+}
+function upsertUsageSnapshot(db, snap) {
+  const identified = !!(snap.provider && snap.account_key && snap.observed_at);
+  const id = snap.id ?? (identified ? observationId({ provider: snap.provider, account_key: snap.account_key, machine_id: snap.machine_id, metric: snap.metric, observed_at: snap.observed_at }) : `${snap.agent}-${snap.date}-${snap.metric}-${snap.machine_id}`);
+  const row = { ...snap, id, updated_at: snap.updated_at ?? snap.observed_at ?? new Date().toISOString() };
+  if (identified || db.get("SELECT observed_at FROM usage_snapshots WHERE id = ?", id)?.observed_at) {
+    bulkIngest(db, { usage_snapshots: [row] });
+    return;
+  }
+  const group = validateIngest({ usage_snapshots: [row] })[0];
+  const spec = group.spec;
+  db.run(`INSERT INTO usage_snapshots (${spec.columns.join(",")}) VALUES (${spec.columns.map(() => "?").join(",")})
+    ON CONFLICT(id) DO UPDATE SET ${spec.columns.filter((k) => k !== "id").map((k) => `${k}=excluded.${k}`).join(",")}`, ...spec.map(group.rows[0], ""));
+}
+function upsertScanReceipt(db, receipt) {
+  bulkIngest(db, { scan_receipts: [{ ...receipt, id: receipt.id || scanReceiptId(receipt), updated_at: receipt.completed_at }] });
+}
+function queryScanReceipts(db, options = {}) {
+  const limit = options.limit ?? 100;
+  if (!Number.isInteger(limit) || limit < 1 || limit > 200)
+    throw new Error("scan_receipts.limit: expected an integer from 1 to 200");
+  const where = [], args = [];
+  if (options.machine_id) {
+    where.push("machine_id = ?");
+    args.push(options.machine_id);
+  }
+  if (options.source) {
+    where.push("source = ?");
+    args.push(options.source);
+  }
+  return db.prepare(`SELECT * FROM scan_receipts ${where.length ? "WHERE " + where.join(" AND ") : ""} ORDER BY completed_at DESC, id LIMIT ?`).all(...args, limit);
+}
+function queryUsageSnapshots(db, opts = {}) {
+  const conditions = [];
+  const params = [];
+  if (opts.agent) {
+    conditions.push("agent = ?");
+    params.push(opts.agent);
+  }
+  if (opts.date) {
+    conditions.push("date = ?");
+    params.push(opts.date);
+  }
+  if (opts.since) {
+    conditions.push("date >= ?");
+    params.push(opts.since);
+  }
+  if (opts.before) {
+    conditions.push("date < ?");
+    params.push(opts.before);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  return db.prepare(`SELECT * FROM usage_snapshots ${where} ORDER BY date DESC, agent, metric`).all(...params);
+}
+function listMachineRegistry(db) {
+  return db.prepare(`SELECT * FROM machines ORDER BY last_seen_at DESC`).all();
+}
+function dedupeRequests(db) {
+  const dupes = db.prepare(`
+    SELECT source_request_id, agent, COALESCE(machine_id, '') as machine_id, MIN(id) as keep_id, COUNT(*) as cnt
+    FROM requests
+    WHERE source_request_id != '' AND source_request_id IS NOT NULL
+    GROUP BY source_request_id, agent, COALESCE(machine_id, '')
+    HAVING cnt > 1
+  `).all();
+  let removed = 0;
+  for (const row of dupes) {
+    const result = db.prepare(`
+      DELETE FROM requests
+      WHERE source_request_id = ?
+        AND agent = ?
+        AND COALESCE(machine_id, '') = ?
+        AND id != ?
+    `).run(row.source_request_id, row.agent, row.machine_id, row.keep_id);
+    removed += result.changes;
+  }
+  return removed;
+}
+function bulkIngest(db, body, context = {}) {
+  return ingestCommand(db, body, (adapter, id) => rollupSession(adapter, id), context);
+}
+
+// src/lib/pricing.ts
+var DEFAULT_PRICING = {
+  "claude-opus-4-8": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25, cacheWrite1hPer1M: 10 },
+  "claude-opus-4-7": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25, cacheWrite1hPer1M: 10 },
+  "claude-opus-4-6": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25, cacheWrite1hPer1M: 10 },
+  "claude-opus-4-5": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25, cacheWrite1hPer1M: 10 },
+  "claude-opus-4-1": { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheWritePer1M: 18.75, cacheWrite1hPer1M: 30 },
+  "claude-opus-4": { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheWritePer1M: 18.75, cacheWrite1hPer1M: 30 },
+  "claude-sonnet-4-6": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75, cacheWrite1hPer1M: 6 },
+  "claude-sonnet-4-5": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75, cacheWrite1hPer1M: 6 },
+  "claude-sonnet-4": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75, cacheWrite1hPer1M: 6 },
+  "claude-3-7-sonnet": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75, cacheWrite1hPer1M: 6 },
+  "claude-haiku-4-5": { inputPer1M: 1, outputPer1M: 5, cacheReadPer1M: 0.1, cacheWritePer1M: 1.25, cacheWrite1hPer1M: 2 },
+  "claude-3-5-haiku": { inputPer1M: 0.8, outputPer1M: 4, cacheReadPer1M: 0.08, cacheWritePer1M: 1, cacheWrite1hPer1M: 1.6 },
+  "claude-3-opus": { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheWritePer1M: 18.75, cacheWrite1hPer1M: 30 },
+  "claude-3-haiku": { inputPer1M: 0.25, outputPer1M: 1.25, cacheReadPer1M: 0.03, cacheWritePer1M: 0.3, cacheWrite1hPer1M: 0.5 },
+  "gemini-3.1-pro-preview": { inputPer1M: 2, outputPer1M: 12, cacheReadPer1M: 0.2, cacheWritePer1M: 0, cacheStoragePer1MHour: 4.5 },
+  "gemini-3.1-flash-lite-preview": { inputPer1M: 0.25, outputPer1M: 1.5, cacheReadPer1M: 0.025, cacheWritePer1M: 0, cacheStoragePer1MHour: 1 },
+  "gemini-3.1-flash-lite": { inputPer1M: 0.25, outputPer1M: 1.5, cacheReadPer1M: 0.025, cacheWritePer1M: 0, cacheStoragePer1MHour: 1 },
+  "gemini-3-flash-preview": { inputPer1M: 0.5, outputPer1M: 3, cacheReadPer1M: 0.05, cacheWritePer1M: 0, cacheStoragePer1MHour: 1 },
+  "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0.125, cacheWritePer1M: 0, cacheStoragePer1MHour: 4.5 },
+  "gemini-2.5-flash": { inputPer1M: 0.3, outputPer1M: 2.5, cacheReadPer1M: 0.03, cacheWritePer1M: 0, cacheStoragePer1MHour: 1 },
+  "gemini-2.5-flash-lite": { inputPer1M: 0.1, outputPer1M: 0.4, cacheReadPer1M: 0.01, cacheWritePer1M: 0, cacheStoragePer1MHour: 1 },
+  "gemini-2.0-flash": { inputPer1M: 0.1, outputPer1M: 0.4, cacheReadPer1M: 0.025, cacheWritePer1M: 0, cacheStoragePer1MHour: 1 },
+  "gemini-2.0-flash-lite": { inputPer1M: 0.075, outputPer1M: 0.3, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "google/gemini-3.1-pro-preview": { inputPer1M: 2, outputPer1M: 12, cacheReadPer1M: 0.2, cacheWritePer1M: 0.375 },
+  "google/gemini-3.1-flash-lite-preview": { inputPer1M: 0.25, outputPer1M: 1.5, cacheReadPer1M: 0.025, cacheWritePer1M: 0.08333333333333334 },
+  "google/gemini-3.1-flash-lite": { inputPer1M: 0.25, outputPer1M: 1.5, cacheReadPer1M: 0.025, cacheWritePer1M: 0.08333333333333334 },
+  "google/gemini-3-flash-preview": { inputPer1M: 0.5, outputPer1M: 3, cacheReadPer1M: 0.05, cacheWritePer1M: 0.08333333333333334 },
+  "google/gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0.125, cacheWritePer1M: 0.375 },
+  "google/gemini-2.5-flash": { inputPer1M: 0.3, outputPer1M: 2.5, cacheReadPer1M: 0.03, cacheWritePer1M: 0.08333333333333334 },
+  "google/gemini-2.5-flash-lite": { inputPer1M: 0.1, outputPer1M: 0.4, cacheReadPer1M: 0.01, cacheWritePer1M: 0.08333333333333334 },
+  "gpt-5.5": { inputPer1M: 5, outputPer1M: 30, cacheReadPer1M: 0.5, cacheWritePer1M: 0 },
+  "gpt-5.5-pro": { inputPer1M: 30, outputPer1M: 180, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "gpt-5.4": { inputPer1M: 2.5, outputPer1M: 15, cacheReadPer1M: 0.25, cacheWritePer1M: 0 },
+  "gpt-5.4-pro": { inputPer1M: 30, outputPer1M: 180, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "gpt-5.4-mini": { inputPer1M: 0.75, outputPer1M: 4.5, cacheReadPer1M: 0.075, cacheWritePer1M: 0 },
+  "gpt-5.4-nano": { inputPer1M: 0.2, outputPer1M: 1.25, cacheReadPer1M: 0.02, cacheWritePer1M: 0 },
+  "gpt-5.3-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.175, cacheWritePer1M: 0 },
+  "gpt-5.2-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.175, cacheWritePer1M: 0 },
+  "gpt-5.2-chat-latest": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.175, cacheWritePer1M: 0 },
+  "gpt-5.2": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.175, cacheWritePer1M: 0 },
+  "gpt-5-codex": { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0.125, cacheWritePer1M: 0 },
+  "gpt-5-mini": { inputPer1M: 0.25, outputPer1M: 2, cacheReadPer1M: 0.025, cacheWritePer1M: 0 },
+  "gpt-5": { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0.125, cacheWritePer1M: 0 },
+  "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10, cacheReadPer1M: 1.25, cacheWritePer1M: 0 },
+  "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6, cacheReadPer1M: 0.075, cacheWritePer1M: 0 },
+  o1: { inputPer1M: 15, outputPer1M: 60, cacheReadPer1M: 7.5, cacheWritePer1M: 0 },
+  "o1-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cacheReadPer1M: 0.55, cacheWritePer1M: 0 },
+  o3: { inputPer1M: 2, outputPer1M: 8, cacheReadPer1M: 0.5, cacheWritePer1M: 0 },
+  "o3-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cacheReadPer1M: 0.55, cacheWritePer1M: 0 },
+  "o4-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cacheReadPer1M: 0.275, cacheWritePer1M: 0 },
+  "qwen3.6-plus": { inputPer1M: 0.325, outputPer1M: 1.95, cacheReadPer1M: 0.0325, cacheWritePer1M: 0.40625 },
+  "qwen3.6-flash": { inputPer1M: 0.25, outputPer1M: 1.5, cacheReadPer1M: 0.025, cacheWritePer1M: 0.3125 },
+  "qwen3.6-35b-a3b": { inputPer1M: 0.15, outputPer1M: 1, cacheReadPer1M: 0.05, cacheWritePer1M: 0 },
+  "qwen3.6-max-preview": { inputPer1M: 1.04, outputPer1M: 6.24, cacheReadPer1M: 0.104, cacheWritePer1M: 1.3 },
+  "qwen3.6-27b": { inputPer1M: 0.32, outputPer1M: 3.2, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "qwen/qwen3.6-plus": { inputPer1M: 0.325, outputPer1M: 1.95, cacheReadPer1M: 0.0325, cacheWritePer1M: 0.40625 },
+  "qwen/qwen3.6-flash": { inputPer1M: 0.25, outputPer1M: 1.5, cacheReadPer1M: 0.025, cacheWritePer1M: 0.3125 },
+  "qwen/qwen3.6-35b-a3b": { inputPer1M: 0.15, outputPer1M: 1, cacheReadPer1M: 0.05, cacheWritePer1M: 0 },
+  "qwen/qwen3.6-max-preview": { inputPer1M: 1.04, outputPer1M: 6.24, cacheReadPer1M: 0.104, cacheWritePer1M: 1.3 },
+  "qwen/qwen3.6-27b": { inputPer1M: 0.32, outputPer1M: 3.2, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "minimax-m2.7": { inputPer1M: 0.3, outputPer1M: 1.2, cacheReadPer1M: 0.06, cacheWritePer1M: 0.375 },
+  "minimax-m2.7-highspeed": { inputPer1M: 0.6, outputPer1M: 2.4, cacheReadPer1M: 0.06, cacheWritePer1M: 0.375 },
+  "minimax/minimax-m2.7": { inputPer1M: 0.299, outputPer1M: 1.2, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "minimax-m1": { inputPer1M: 0.4, outputPer1M: 2.2, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "minimax/minimax-m1": { inputPer1M: 0.4, outputPer1M: 2.2, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "grok-4.3": { inputPer1M: 1.25, outputPer1M: 2.5, cacheReadPer1M: 0.2, cacheWritePer1M: 0 },
+  "grok-latest": { inputPer1M: 1.25, outputPer1M: 2.5, cacheReadPer1M: 0.2, cacheWritePer1M: 0 },
+  "grok-4.20": { inputPer1M: 1.25, outputPer1M: 2.5, cacheReadPer1M: 0.2, cacheWritePer1M: 0 },
+  "grok-4-1-fast": { inputPer1M: 0.2, outputPer1M: 0.5, cacheReadPer1M: 0.05, cacheWritePer1M: 0 },
+  "grok-4-fast": { inputPer1M: 0.2, outputPer1M: 0.5, cacheReadPer1M: 0.05, cacheWritePer1M: 0 },
+  "grok-4": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.75, cacheWritePer1M: 0 },
+  "grok-code-fast-1": { inputPer1M: 0.2, outputPer1M: 1.5, cacheReadPer1M: 0.02, cacheWritePer1M: 0 },
+  "grok-code-fast": { inputPer1M: 0.2, outputPer1M: 1.5, cacheReadPer1M: 0.02, cacheWritePer1M: 0 },
+  "grok-3": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.75, cacheWritePer1M: 0 },
+  "grok-3-mini": { inputPer1M: 0.3, outputPer1M: 0.5, cacheReadPer1M: 0.07, cacheWritePer1M: 0 },
+  "glm-5.1": { inputPer1M: 1.4, outputPer1M: 4.4, cacheReadPer1M: 0.26, cacheWritePer1M: 0 },
+  "glm-5": { inputPer1M: 1, outputPer1M: 3.2, cacheReadPer1M: 0.2, cacheWritePer1M: 0 },
+  "z-ai/glm-5.1": { inputPer1M: 1.05, outputPer1M: 3.5, cacheReadPer1M: 0.525, cacheWritePer1M: 0 },
+  "z-ai/glm-5": { inputPer1M: 0.6, outputPer1M: 1.92, cacheReadPer1M: 0.12, cacheWritePer1M: 0 },
+  "kimi-k2.6": { inputPer1M: 0.95, outputPer1M: 4, cacheReadPer1M: 0.16, cacheWritePer1M: 0 },
+  "kimi-k2.5": { inputPer1M: 0.6, outputPer1M: 3, cacheReadPer1M: 0.1, cacheWritePer1M: 0 },
+  "kimi-k2": { inputPer1M: 0.6, outputPer1M: 2.5, cacheReadPer1M: 0.15, cacheWritePer1M: 0 },
+  "moonshotai/kimi-k2.6": { inputPer1M: 0.75, outputPer1M: 3.5, cacheReadPer1M: 0.15, cacheWritePer1M: 0 },
+  "moonshotai/kimi-k2.5": { inputPer1M: 0.44, outputPer1M: 2, cacheReadPer1M: 0.22, cacheWritePer1M: 0 },
+  "moonshotai/kimi-k2": { inputPer1M: 0.57, outputPer1M: 2.3, cacheReadPer1M: 0, cacheWritePer1M: 0 }
+};
+var LEGACY_DEFAULT_PRICING = {
+  "claude-3-5-haiku": { inputPer1M: 1, outputPer1M: 5, cacheReadPer1M: 0.1, cacheWritePer1M: 1.25 },
+  "claude-opus-4": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25 },
+  "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0.31, cacheWritePer1M: 0 },
+  "gemini-2.5-flash": { inputPer1M: 0.15, outputPer1M: 0.6, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "gemini-2.0-flash": { inputPer1M: 0.075, outputPer1M: 0.3, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "gpt-5.3-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+  "gpt-5.2-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+  "gpt-5-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+  "gpt-5-mini": { inputPer1M: 0.3, outputPer1M: 1.2, cacheReadPer1M: 0.075, cacheWritePer1M: 0 },
+  "gpt-5.2": { inputPer1M: 2, outputPer1M: 8, cacheReadPer1M: 0.5, cacheWritePer1M: 0 },
+  "o1-mini": { inputPer1M: 3, outputPer1M: 12, cacheReadPer1M: 1.5, cacheWritePer1M: 0 },
+  "grok-3": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "grok-3-mini": { inputPer1M: 0.3, outputPer1M: 0.5, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "qwen3.6-plus": { inputPer1M: 0.8, outputPer1M: 2, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "minimax-m2.7": { inputPer1M: 0.7, outputPer1M: 0.7, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "minimax-m2.7-highspeed": { inputPer1M: 0.7, outputPer1M: 0.7, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "minimax-m1": { inputPer1M: 0.2, outputPer1M: 1.1, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "glm-5.1": { inputPer1M: 0.7, outputPer1M: 0.7, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "glm-5": { inputPer1M: 0.7, outputPer1M: 0.7, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  "kimi-k2": { inputPer1M: 0.6, outputPer1M: 0.6, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+  o3: { inputPer1M: 10, outputPer1M: 40, cacheReadPer1M: 2.5, cacheWritePer1M: 0 }
+};
+var ADDITIONAL_LEGACY_DEFAULT_PRICING = {
+  "gemini-2.5-pro": [
+    { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0, cacheWritePer1M: 0 }
+  ],
+  "qwen3.6-plus": [
+    { inputPer1M: 0.325, outputPer1M: 1.95, cacheReadPer1M: 0, cacheWritePer1M: 0.40625 },
+    { inputPer1M: 0.325, outputPer1M: 1.95, cacheReadPer1M: 0.05, cacheWritePer1M: 0.40625 }
+  ],
+  "qwen3.6-flash": [
+    { inputPer1M: 0.25, outputPer1M: 1.5, cacheReadPer1M: 0, cacheWritePer1M: 0.3125 }
+  ],
+  "qwen3.6-max-preview": [
+    { inputPer1M: 1.04, outputPer1M: 6.24, cacheReadPer1M: 0, cacheWritePer1M: 1.3 },
+    { inputPer1M: 1.04, outputPer1M: 6.24, cacheReadPer1M: 0.13, cacheWritePer1M: 1.3 }
+  ],
+  "qwen/qwen3.6-plus": [
+    { inputPer1M: 0.325, outputPer1M: 1.95, cacheReadPer1M: 0, cacheWritePer1M: 0.40625 },
+    { inputPer1M: 0.325, outputPer1M: 1.95, cacheReadPer1M: 0.05, cacheWritePer1M: 0.40625 }
+  ],
+  "qwen/qwen3.6-flash": [
+    { inputPer1M: 0.25, outputPer1M: 1.5, cacheReadPer1M: 0, cacheWritePer1M: 0.3125 }
+  ],
+  "qwen/qwen3.6-max-preview": [
+    { inputPer1M: 1.04, outputPer1M: 6.24, cacheReadPer1M: 0, cacheWritePer1M: 1.3 },
+    { inputPer1M: 1.04, outputPer1M: 6.24, cacheReadPer1M: 0.13, cacheWritePer1M: 1.3 }
+  ]
+};
+var REMOVED_DEFAULT_PRICING = {
+  "claude-3-5-sonnet": [
+    { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75, cacheWrite1hPer1M: 6 },
+    { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75, cacheWrite1hPer1M: 0 }
+  ],
+  "claude-3-sonnet": [
+    { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75, cacheWrite1hPer1M: 6 },
+    { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75, cacheWrite1hPer1M: 0 }
+  ],
+  "gemini-3.1-pro": [
+    { inputPer1M: 2, outputPer1M: 12, cacheReadPer1M: 0.2, cacheWritePer1M: 0 },
+    { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0.31, cacheWritePer1M: 0 }
+  ],
+  "gemini-1.5-pro": [
+    { inputPer1M: 1.25, outputPer1M: 5, cacheReadPer1M: 0, cacheWritePer1M: 0 }
+  ],
+  "gemini-1.5-flash": [
+    { inputPer1M: 0.075, outputPer1M: 0.3, cacheReadPer1M: 0, cacheWritePer1M: 0 }
+  ],
+  "gpt-5.3-chat": [
+    { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.175, cacheWritePer1M: 0 },
+    { inputPer1M: 2, outputPer1M: 8, cacheReadPer1M: 0.5, cacheWritePer1M: 0 }
+  ],
+  "qwen3.6": [
+    { inputPer1M: 0.3, outputPer1M: 0.6, cacheReadPer1M: 0, cacheWritePer1M: 0 }
+  ]
+};
+var FREE_PRICING = {
+  inputPer1M: 0,
+  outputPer1M: 0,
+  cacheReadPer1M: 0,
+  cacheWritePer1M: 0,
+  cacheWrite1hPer1M: 0,
+  cacheStoragePer1MHour: 0
+};
+var GEMINI_PROMPT_TIERS = {
+  "gemini-3.1-pro-preview": {
+    threshold: 200000,
+    inputPer1M: 4,
+    outputPer1M: 18,
+    cacheReadPer1M: 0.4
+  },
+  "gemini-2.5-pro": {
+    threshold: 200000,
+    inputPer1M: 2.5,
+    outputPer1M: 15,
+    cacheReadPer1M: 0.25
+  }
+};
+var OPENAI_PROMPT_TIERS = {
+  "gpt-5.5": {
+    threshold: 272000,
+    inputMultiplier: 2,
+    outputMultiplier: 1.5,
+    cacheReadMultiplier: 2
+  },
+  "gpt-5.4-pro": {
+    threshold: 272000,
+    inputMultiplier: 2,
+    outputMultiplier: 1.5,
+    cacheReadMultiplier: 2
+  },
+  "gpt-5.4": {
+    threshold: 272000,
+    inputMultiplier: 2,
+    outputMultiplier: 1.5,
+    cacheReadMultiplier: 2
+  }
+};
+var QWEN_PROMPT_TIERS = {
+  "qwen3.6-plus": {
+    threshold: 256000,
+    inputPer1M: 1.3,
+    outputPer1M: 3.9,
+    cacheReadPer1M: 0.13,
+    cacheWritePer1M: 1.625
+  },
+  "qwen3.6-flash": {
+    threshold: 256000,
+    inputPer1M: 1,
+    outputPer1M: 4,
+    cacheReadPer1M: 0.1,
+    cacheWritePer1M: 1.25
+  },
+  "qwen3.6-max-preview": {
+    threshold: 128000,
+    inputPer1M: 1.6,
+    outputPer1M: 9.6,
+    cacheReadPer1M: 0.16,
+    cacheWritePer1M: 2
+  }
+};
+var MINIMAX_PROMPT_TIERS = {
+  "minimax/minimax-m1": {
+    threshold: Number.POSITIVE_INFINITY
+  },
+  "minimax-m1": {
+    threshold: 200000,
+    inputPer1M: 1.3
+  }
+};
+var XAI_PROMPT_TIERS = {
+  "grok-4.3": {
+    threshold: 200000,
+    inputPer1M: 2.5,
+    outputPer1M: 5,
+    cacheReadPer1M: 0.4
+  },
+  "grok-latest": {
+    threshold: 200000,
+    inputPer1M: 2.5,
+    outputPer1M: 5,
+    cacheReadPer1M: 0.4
+  },
+  "grok-4.20": {
+    threshold: 200000,
+    inputPer1M: 2.5,
+    outputPer1M: 5,
+    cacheReadPer1M: 0.4
+  },
+  "grok-4-1-fast": {
+    threshold: 128000,
+    inputPer1M: 0.4,
+    outputPer1M: 1,
+    cacheReadPer1M: 0
+  },
+  "grok-4-fast": {
+    threshold: 128000,
+    inputPer1M: 0.4,
+    outputPer1M: 1,
+    cacheReadPer1M: 0
+  },
+  "grok-4": {
+    threshold: 128000,
+    inputPer1M: 6,
+    outputPer1M: 30,
+    cacheReadPer1M: 0
+  }
+};
+function normalizeModelName(raw) {
+  return raw.trim().toLowerCase().replace(/^models\//, "").replace(/^[a-z0-9_.-]+\//, "").replace(/:.+$/, "").replace(/-\d{8}$/, "").replace(/-\d{4}-\d{2}-\d{2}$/, "");
+}
+function normalizeModelNamePreservingProvider(raw) {
+  return raw.trim().toLowerCase().replace(/^models\//, "").replace(/:.+$/, "").replace(/-\d{8}$/, "").replace(/-\d{4}-\d{2}-\d{2}$/, "");
+}
+function modelLookupKeys(raw) {
+  const withProvider = normalizeModelNamePreservingProvider(raw);
+  const withoutProvider = normalizeModelName(raw);
+  return withProvider === withoutProvider ? [withoutProvider] : [withProvider, withoutProvider];
+}
+function bestPrefixMatch(normalized, entries) {
+  let best = null;
+  for (const entry of entries) {
+    const [key] = entry;
+    if (normalized !== key && !normalized.startsWith(`${key}-`))
+      continue;
+    if (!best || key.length > best[0].length)
+      best = entry;
+  }
+  return best?.[1] ?? null;
+}
+function bestModelMatch(model, entries) {
+  for (const key of modelLookupKeys(model)) {
+    const match = bestPrefixMatch(key, entries);
+    if (match)
+      return match;
+  }
+  return null;
+}
+function exactModelMatch(model, entries) {
+  for (const key of modelLookupKeys(model)) {
+    const match = entries.find(([entryKey]) => entryKey === key);
+    if (match)
+      return match[1];
+  }
+  return null;
+}
+function ensurePricingSeeded(db) {
+  seedModelPricing(db, DEFAULT_PRICING);
+  repairLegacySeededPricing(db);
+  repairMissingDefaultCacheWrite1h(db);
+  repairMissingDefaultCacheStorage(db);
+  removeDeprecatedDefaultPricing(db);
+}
+function repairLegacySeededPricing(db) {
+  const now = new Date().toISOString();
+  const legacyModels = new Set([
+    ...Object.keys(LEGACY_DEFAULT_PRICING),
+    ...Object.keys(ADDITIONAL_LEGACY_DEFAULT_PRICING)
+  ]);
+  for (const model of legacyModels) {
+    const current = getModelPricing(db, model);
+    const next = DEFAULT_PRICING[model];
+    if (!current || !next)
+      continue;
+    const legacy = LEGACY_DEFAULT_PRICING[model];
+    const legacyRows = [
+      ...legacy ? [legacy] : [],
+      ...ADDITIONAL_LEGACY_DEFAULT_PRICING[model] ?? []
+    ];
+    if (!legacyRows.some((row) => samePricing(current, row)))
+      continue;
+    upsertModelPricing(db, {
+      model,
+      input_per_1m: next.inputPer1M,
+      output_per_1m: next.outputPer1M,
+      cache_read_per_1m: next.cacheReadPer1M,
+      cache_write_per_1m: next.cacheWritePer1M,
+      cache_write_1h_per_1m: next.cacheWrite1hPer1M ?? 0,
+      cache_storage_per_1m_hour: next.cacheStoragePer1MHour ?? 0,
+      updated_at: now
+    });
+  }
+}
+function repairMissingDefaultCacheWrite1h(db) {
+  const now = new Date().toISOString();
+  for (const [model, next] of Object.entries(DEFAULT_PRICING)) {
+    if (!next.cacheWrite1hPer1M)
+      continue;
+    const current = getModelPricing(db, model);
+    if (!current)
+      continue;
+    if ((current.cache_write_1h_per_1m ?? 0) !== 0)
+      continue;
+    if (!sameBasePricing(current, next))
+      continue;
+    upsertModelPricing(db, {
+      model,
+      input_per_1m: current.input_per_1m,
+      output_per_1m: current.output_per_1m,
+      cache_read_per_1m: current.cache_read_per_1m,
+      cache_write_per_1m: current.cache_write_per_1m,
+      cache_write_1h_per_1m: next.cacheWrite1hPer1M,
+      cache_storage_per_1m_hour: current.cache_storage_per_1m_hour ?? next.cacheStoragePer1MHour ?? 0,
+      updated_at: now
+    });
+  }
+}
+function repairMissingDefaultCacheStorage(db) {
+  const now = new Date().toISOString();
+  for (const [model, next] of Object.entries(DEFAULT_PRICING)) {
+    if (!next.cacheStoragePer1MHour)
+      continue;
+    const current = getModelPricing(db, model);
+    if (!current)
+      continue;
+    if ((current.cache_storage_per_1m_hour ?? 0) !== 0)
+      continue;
+    if (!sameBasePricing(current, next))
+      continue;
+    upsertModelPricing(db, {
+      model,
+      input_per_1m: current.input_per_1m,
+      output_per_1m: current.output_per_1m,
+      cache_read_per_1m: current.cache_read_per_1m,
+      cache_write_per_1m: current.cache_write_per_1m,
+      cache_write_1h_per_1m: current.cache_write_1h_per_1m ?? next.cacheWrite1hPer1M ?? 0,
+      cache_storage_per_1m_hour: next.cacheStoragePer1MHour,
+      updated_at: now
+    });
+  }
+}
+function removeDeprecatedDefaultPricing(db) {
+  for (const [model, removedRows] of Object.entries(REMOVED_DEFAULT_PRICING)) {
+    const current = getModelPricing(db, model);
+    if (!current)
+      continue;
+    if (!removedRows.some((row) => samePricing(current, row)))
+      continue;
+    deleteModelPricing(db, model);
+  }
+}
+function sameBasePricing(row, pricing) {
+  return row.input_per_1m === pricing.inputPer1M && row.output_per_1m === pricing.outputPer1M && row.cache_read_per_1m === pricing.cacheReadPer1M && row.cache_write_per_1m === pricing.cacheWritePer1M;
+}
+function samePricing(row, pricing) {
+  return row.input_per_1m === pricing.inputPer1M && row.output_per_1m === pricing.outputPer1M && row.cache_read_per_1m === pricing.cacheReadPer1M && row.cache_write_per_1m === pricing.cacheWritePer1M && (row.cache_write_1h_per_1m ?? 0) === (pricing.cacheWrite1hPer1M ?? 0) && (row.cache_storage_per_1m_hour ?? 0) === (pricing.cacheStoragePer1MHour ?? 0);
+}
+function getPricingFromDb(db, model) {
+  if (isFreeModel(model))
+    return FREE_PRICING;
+  for (const key of modelLookupKeys(model)) {
+    const row = getModelPricing(db, key);
+    if (row)
+      return modelPricingFromDbRow(row);
+  }
+  const allRows = db.prepare(`SELECT * FROM model_pricing`).all();
+  const match = bestModelMatch(model, allRows.map((r) => [r.model, r]));
+  if (!match)
+    return null;
+  return modelPricingFromDbRow(match);
+}
+function modelPricingFromDbRow(row) {
+  const seeded = DEFAULT_PRICING[row.model];
+  const cacheWrite1hPer1M = seeded?.cacheWrite1hPer1M && (row.cache_write_1h_per_1m ?? 0) === 0 && sameBasePricing(row, seeded) ? seeded.cacheWrite1hPer1M : row.cache_write_1h_per_1m ?? 0;
+  return {
+    inputPer1M: row.input_per_1m,
+    outputPer1M: row.output_per_1m,
+    cacheReadPer1M: row.cache_read_per_1m,
+    cacheWritePer1M: row.cache_write_per_1m,
+    cacheWrite1hPer1M,
+    cacheStoragePer1MHour: row.cache_storage_per_1m_hour ?? seeded?.cacheStoragePer1MHour ?? 0
+  };
+}
+function getPricing(model) {
+  if (isFreeModel(model))
+    return FREE_PRICING;
+  return bestModelMatch(model, Object.entries(DEFAULT_PRICING));
+}
+function isFreeModel(model) {
+  return model.trim().toLowerCase().endsWith(":free");
+}
+function computeCost(model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0, cacheWrite1hTokens = 0, cacheStorageTokenHours = 0) {
+  return requirePricedCost(assessResolvedCost(model, null, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours));
+}
+function computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0, cacheWrite1hTokens = 0, cacheStorageTokenHours = 0) {
+  return requirePricedCost(assessCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours));
+}
+
+class UnknownModelPricingError extends Error {
+  code = "MODEL_PRICING_UNAVAILABLE";
+  constructor() {
+    super("MODEL_PRICING_UNAVAILABLE: Pricing unavailable for model; configure its rates before estimating cost");
+    this.name = "UnknownModelPricingError";
+  }
+}
+function requirePricedCost(assessment) {
+  if (assessment.usd === null)
+    throw new UnknownModelPricingError;
+  return assessment.usd;
+}
+function assessCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0, cacheWrite1hTokens = 0, cacheStorageTokenHours = 0) {
+  return assessResolvedCost(model, getPricingFromDb(db, model), inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours);
+}
+function getPricingFromRows(rows, model) {
+  if (isFreeModel(model))
+    return FREE_PRICING;
+  for (const key of modelLookupKeys(model)) {
+    const row = rows.find((r) => r.model === key);
+    if (row)
+      return modelPricingFromDbRow(row);
+  }
+  const match = bestModelMatch(model, rows.map((r) => [r.model, r]));
+  if (!match)
+    return null;
+  return modelPricingFromDbRow(match);
+}
+function estimateCostFromRows(rows, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0, cacheWrite1hTokens = 0, cacheStorageTokenHours = 0) {
+  return requirePricedCost(assessCostFromRows(rows, model, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours));
+}
+function assessCostFromRows(rows, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0, cacheWrite1hTokens = 0, cacheStorageTokenHours = 0) {
+  return assessResolvedCost(model, getPricingFromRows(rows, model), inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours);
+}
+function assessResolvedCost(model, configured, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours) {
+  const counts = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens };
+  for (const [field, value] of Object.entries(counts)) {
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw new RangeError(`${field} must be a nonnegative safe integer`);
+  }
+  if (!Number.isFinite(cacheStorageTokenHours) || cacheStorageTokenHours < 0) {
+    throw new RangeError("cacheStorageTokenHours must be finite and nonnegative");
+  }
+  if (isFreeModel(model))
+    return { usd: 0, pricing: "explicit_free" };
+  const pricing = configured ?? getPricing(model);
+  if (!pricing)
+    return { usd: null, pricing: "missing" };
+  if (Object.values(pricing).some((value) => value !== undefined && (!Number.isFinite(value) || value < 0))) {
+    throw new RangeError("Model pricing rates must be finite and nonnegative");
+  }
+  const usd = computeCostWithPricing(model, pricing, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours);
+  if (!Number.isFinite(usd))
+    throw new RangeError("Cost estimate exceeds the supported numeric range");
+  return { usd, pricing: configured ? "configured" : "catalog" };
+}
+function computeCostWithPricing(model, pricing, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours) {
+  if (isFreeModel(model))
+    return 0;
+  let effective = pricing;
+  const promptTier = bestModelMatch(model, Object.entries(GEMINI_PROMPT_TIERS)) ?? bestModelMatch(model, Object.entries(QWEN_PROMPT_TIERS)) ?? bestModelMatch(model, Object.entries(MINIMAX_PROMPT_TIERS)) ?? bestModelMatch(model, Object.entries(XAI_PROMPT_TIERS)) ?? exactModelMatch(model, Object.entries(OPENAI_PROMPT_TIERS));
+  if (promptTier) {
+    const billablePromptTokens = inputTokens + cacheReadTokens + cacheWriteTokens + cacheWrite1hTokens;
+    if (billablePromptTokens > promptTier.threshold) {
+      effective = {
+        ...pricing,
+        inputPer1M: promptTier.inputPer1M ?? pricing.inputPer1M * (promptTier.inputMultiplier ?? 1),
+        outputPer1M: promptTier.outputPer1M ?? pricing.outputPer1M * (promptTier.outputMultiplier ?? 1),
+        cacheReadPer1M: promptTier.cacheReadPer1M ?? pricing.cacheReadPer1M * (promptTier.cacheReadMultiplier ?? 1),
+        cacheWritePer1M: promptTier.cacheWritePer1M ?? pricing.cacheWritePer1M * (promptTier.cacheWriteMultiplier ?? 1)
+      };
+    }
+  }
+  return (inputTokens * effective.inputPer1M + outputTokens * effective.outputPer1M + cacheReadTokens * effective.cacheReadPer1M + cacheWriteTokens * effective.cacheWritePer1M + cacheWrite1hTokens * (effective.cacheWrite1hPer1M ?? effective.cacheWritePer1M) + cacheStorageTokenHours * (effective.cacheStoragePer1MHour ?? 0)) / 1e6;
+}
+
+export { observationId, subscriptionId, scanReceiptId, AGENTS, MAX_INGEST_ROWS, MAX_INGEST_BYTES, stableJson, canonicalIngestBodyHash, validateIngest, calendarPeriodBounds, calendarPeriodWhere, usageSnapshotFilterForPeriod, sessionOverlapWhere, dataDir, cacheDir, getMachineId, getHomeDir, getResolverDataRoot, getLegacyDataRoot, adoptResolverDataRoot, getExactDataRoot, getDataDir, getDbPath, initSchema, upsertCostCenter, getCostCenter, upsertRequest, upsertSession, rollupSession, querySessions, queryTopSessions, querySummary, queryZeroCostTokenizedModels, queryModelBreakdown, queryAgentBreakdown, queryProjectBreakdown, queryAccountBreakdown, queryCostCenterBreakdown, queryProjectBreakdownSince, queryAgentBreakdownSince, queryModelBreakdownSince, queryAccountBreakdownSince, queryDailyBreakdown, queryHourlyBreakdown, upsertProject, getProject, listProjects, deleteProject, upsertBudget, listBudgets, deleteBudget, getBudgetStatuses, upsertGoal, deleteGoal, listGoals, getGoalStatuses, getIngestState, loadIngestState, setIngestState, queryRequestsSince, insertFeedback, upsertBillingDaily, clearBillingRange, queryBillingSummary, countBillingRecords, getSessionDetail, listMachines, upsertModelPricing, getModelPricing, listModelPricing, deleteModelPricing, seedModelPricing, upsertSubscription, listSubscriptions, deleteSubscription, upsertUsageSnapshot, upsertScanReceipt, queryScanReceipts, queryUsageSnapshots, listMachineRegistry, dedupeRequests, bulkIngest, DEFAULT_PRICING, normalizeModelName, ensurePricingSeeded, getPricingFromDb, getPricing, computeCost, computeCostFromDb, UnknownModelPricingError, assessCostFromDb, getPricingFromRows, estimateCostFromRows, assessCostFromRows, formatReportedUsd, formatPlanMoney, hasKnownUsagePrice, requireCurrentCostSummary, formatSummaryValue, formatSummaryCoverage, requireCurrentBillingSummary, formatBillingValue };