@hasna/economy 0.4.0 → 0.5.1

package/dist/chunks/serve-2knem98x.js

@@ -0,0 +1,4655 @@
+// @bun
+import {
+  getServeBindHost,
+  isAuthorizedRequest
+} from "./index-w3bvv0ns.js";
+import {
+  syncAll
+} from "./index-xsah93s2.js";
+import {
+  buildBrief,
+  packageMetadata,
+  queryBillingDiff,
+  queryExportRows,
+  queryForecast,
+  queryModelEfficiency,
+  queryProjectDetail,
+  queryRangeStats,
+  querySavingsSummary
+} from "./index-d480p2wh.js";
+import {
+  AGENTS,
+  INGEST_SCHEMA_SQL,
+  IngestError,
+  LEGACY_PG_SQL,
+  OBSERVATION_PG_MIGRATIONS,
+  bulkIngest,
+  deleteBudget,
+  deleteGoal,
+  deleteModelPricing,
+  deleteProject,
+  deleteSubscription,
+  ensurePricingSeeded,
+  getBudgetStatuses,
+  getGoalStatuses,
+  getMachineId,
+  insertFeedback,
+  isAgent,
+  listMachineRegistry,
+  listMachines,
+  listModelPricing,
+  listProjects,
+  listSubscriptions,
+  queryAccountBreakdown,
+  queryAccountBreakdownSince,
+  queryAgentBreakdown,
+  queryAgentBreakdownSince,
+  queryBillingSummary,
+  queryCostCenterBreakdown,
+  queryDailyBreakdown,
+  queryHourlyBreakdown,
+  queryModelBreakdown,
+  queryModelBreakdownSince,
+  queryProjectBreakdown,
+  queryProjectBreakdownSince,
+  queryRequestsSince,
+  queryScanReceipts,
+  querySessions,
+  querySummary,
+  queryTopSessions,
+  queryUsageSnapshots,
+  reconcileIngestReceipt,
+  subscriptionId,
+  upsertBudget,
+  upsertGoal,
+  upsertModelPricing,
+  upsertProject,
+  upsertSubscription,
+  usageSnapshotFilterForPeriod
+} from "./index-ez9thsr7.js";
+import {
+  __require
+} from "./index-p35cyhc4.js";
+
+// src/db/cloud.ts
+import pg2 from "pg";
+
+// src/db/sync-pg.ts
+import { Worker, MessageChannel, receiveMessageOnPort } from "worker_threads";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+
+// src/db/dialect.ts
+function translateSql(sql, dialect) {
+  if (dialect === "sqlite")
+    return sql;
+  return sqliteToPostgres(sql);
+}
+function translateParams(params) {
+  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
+  return flat.map((p) => p === undefined ? null : p);
+}
+function sqliteToPostgres(sql) {
+  let out = sql;
+  let paramIdx = 0;
+  out = out.replace(/\?/g, () => `$${++paramIdx}`);
+  out = out.replace(/datetime\s*\(\s*'now'\s*\)/gi, "NOW()");
+  out = out.replace(/datetime\s*\(\s*'now'\s*,\s*'(-?\d+)\s+(minutes?|hours?|days?|seconds?)'\s*\)/gi, (_match, amount, unit) => {
+    const n = parseInt(amount, 10);
+    const absN = Math.abs(n);
+    const normalizedUnit = unit.toLowerCase().replace(/s$/, "");
+    const plural = absN === 1 ? normalizedUnit : `${normalizedUnit}s`;
+    return n < 0 ? `NOW() - INTERVAL '${absN} ${plural}'` : `NOW() + INTERVAL '${absN} ${plural}'`;
+  });
+  out = out.replace(/lower\s*\(\s*hex\s*\(\s*randomblob\s*\(\s*\d+\s*\)\s*\)\s*\)/gi, "gen_random_uuid()::text");
+  out = out.replace(/GROUP_CONCAT\s*\(/gi, "STRING_AGG(");
+  out = out.replace(/json_extract\s*\(\s*(\w+)\s*,\s*'\$\.(\w+)'\s*\)/gi, (_match, col, key) => `${col}->>'${key}'`);
+  out = out.replace(/\bAUTOINCREMENT\b/gi, "GENERATED ALWAYS AS IDENTITY");
+  out = out.replace(/(?<![I])LIKE/gi, "ILIKE");
+  out = out.replace(/\bIFNULL\s*\(/gi, "COALESCE(");
+  out = out.replace(/INSERT\s+OR\s+REPLACE\s+INTO\s+"?(\w+)"?\s*\(([^)]+)\)\s*VALUES/gi, (_match, table, colList) => `INSERT INTO "${table}" (${colList}) VALUES`);
+  out = out.replace(/INSERT\s+OR\s+REPLACE\s+INTO/gi, "INSERT INTO");
+  if (/INSERT\s+OR\s+IGNORE\s+INTO/i.test(out)) {
+    out = out.replace(/INSERT\s+OR\s+IGNORE\s+INTO/gi, "INSERT INTO");
+    out = out.replace(/;?\s*$/, " ON CONFLICT DO NOTHING");
+  }
+  return out;
+}
+
+// src/db/pg-protocol.ts
+function pgNow() {
+  return performance.timeOrigin + performance.now();
+}
+
+// src/db/sync-pg.ts
+function translateSqliteDates(sql) {
+  let s = sql;
+  const isoDate = (expr) => `to_char(${expr}, 'YYYY-MM-DD')`;
+  s = s.replace(/DATE\('now',\s*'weekday 0',\s*'-7 days'\)/gi, isoDate("(date_trunc('week', now() + interval '1 day') - interval '1 day')"));
+  s = s.replace(/DATE\('now',\s*'start of month'\)/gi, isoDate("date_trunc('month', now())"));
+  s = s.replace(/DATE\('now',\s*'start of year'\)/gi, isoDate("date_trunc('year', now())"));
+  s = s.replace(/DATE\('now',\s*'(-?\d+)\s*days?'\)/gi, (_m, n) => isoDate(`now() + interval '${n} days'`));
+  s = s.replace(/DATE\('now',\s*(\$\d+)\s*\|\|\s*' days'\)/gi, (_m, p) => isoDate(`now() + ((${p}) || ' days')::interval`));
+  s = s.replace(/DATETIME\('now',\s*(\$\d+)\)/gi, (_m, p) => `(now() + (${p})::interval)`);
+  s = s.replace(/DATETIME\('now',\s*'([^']+)'\)/gi, (_m, lit) => `(now() + interval '${lit}')`);
+  const strftimeMap = { "%H": "HH24", "%Y": "YYYY", "%m": "MM", "%d": "DD", "%M": "MI", "%S": "SS" };
+  s = s.replace(/STRFTIME\('([^']+)',\s*([A-Za-z_][A-Za-z0-9_]*)\)/gi, (_m, fmt, col) => {
+    const pgFmt = Object.entries(strftimeMap).reduce((acc, [k, v]) => acc.split(k).join(v), fmt);
+    return `to_char(CAST("${col}" AS timestamptz), '${pgFmt}')`;
+  });
+  s = s.replace(/\bDATE\('now'\)/gi, isoDate("now()"));
+  s = s.replace(/\bDATETIME\('now'\)/gi, "now()");
+  s = s.replace(/\bDATETIME\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/gi, (_m, col) => `CAST("${col}" AS timestamptz)`);
+  s = s.replace(/\bDATE\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/gi, (_m, col) => `substr("${col}", 1, 10)`);
+  return s;
+}
+function resolveWorkerPath() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const selfExt = fileURLToPath(import.meta.url).endsWith(".js") ? "js" : "ts";
+  const otherExt = selfExt === "js" ? "ts" : "js";
+  const candidates = [
+    join(here, `pg-sync-worker.${selfExt}`),
+    join(here, `pg-sync-worker.${otherExt}`),
+    join(here, "..", "db", "pg-sync-worker.js")
+  ];
+  for (const candidate of candidates)
+    if (existsSync(candidate))
+      return candidate;
+  return candidates[0];
+}
+function boundedTimeout(value, fallback) {
+  const timeout = value ?? fallback;
+  if (!Number.isInteger(timeout) || timeout < 1 || timeout > 120000) {
+    throw new Error("PostgreSQL timeout must be an integer between 1 and 120000 milliseconds");
+  }
+  return timeout;
+}
+
+class SyncPgAdapter {
+  worker;
+  port;
+  lifecycle = new Int32Array(new SharedArrayBuffer(4));
+  sleeper = new Int32Array(new SharedArrayBuffer(4));
+  queryTimeoutMs;
+  transactionTimeoutMs;
+  counter = 0;
+  transactionId = null;
+  transactionDeadline = Infinity;
+  depth = 0;
+  closed = false;
+  constructor(dsn, options = {}) {
+    this.queryTimeoutMs = boundedTimeout(options.queryTimeoutMs, 30000);
+    this.transactionTimeoutMs = boundedTimeout(options.transactionTimeoutMs, 30000);
+    this.worker = new Worker(resolveWorkerPath(), { workerData: {
+      dsn,
+      lifecycle: this.lifecycle.buffer,
+      queryTimeoutMs: this.queryTimeoutMs,
+      transactionTimeoutMs: this.transactionTimeoutMs
+    } });
+    this.worker.on("error", () => {
+      this.abandon();
+    });
+    this.worker.on("exit", () => {
+      this.closed = true;
+    });
+    const channel = new MessageChannel;
+    this.port = channel.port1;
+    this.worker.postMessage({ type: "init", port: channel.port2 }, [channel.port2]);
+  }
+  abandon() {
+    this.closed = true;
+    Atomics.store(this.lifecycle, 0, 1);
+    this.worker.terminate();
+    this.port.close();
+  }
+  request(operation, sql, params = []) {
+    if (this.closed || Atomics.load(this.lifecycle, 0) !== 0) {
+      if (!this.closed)
+        this.abandon();
+      throw new Error("PostgreSQL adapter is closed; reconcile any uncertain write before creating a new adapter");
+    }
+    const deadline = Math.min(pgNow() + this.queryTimeoutMs, this.transactionDeadline);
+    const id = ++this.counter;
+    const signal = new Int32Array(new SharedArrayBuffer(4));
+    if (deadline <= pgNow()) {
+      this.abandon();
+      throw new Error("PostgreSQL transaction deadline exceeded; transaction abandoned");
+    }
+    try {
+      this.worker.postMessage({
+        id,
+        operation,
+        sql,
+        params,
+        deadline,
+        transactionId: this.transactionId,
+        depth: this.depth,
+        signal: signal.buffer
+      });
+      for (;; ) {
+        if (pgNow() >= deadline)
+          break;
+        const received = receiveMessageOnPort(this.port);
+        if (received) {
+          const reply = received.message;
+          if (reply.id !== id)
+            continue;
+          if (pgNow() >= deadline)
+            break;
+          if (!reply.ok) {
+            if (reply.fatal)
+              this.abandon();
+            const error = new Error(reply.error);
+            error.code = reply.code;
+            throw error;
+          }
+          return { rows: reply.rows, rowCount: reply.rowCount };
+        }
+        const remaining = deadline - pgNow();
+        if (remaining <= 0)
+          break;
+        if (Atomics.load(signal, 0) === 0)
+          Atomics.wait(signal, 0, 0, Math.min(remaining, 10));
+        else
+          Atomics.wait(this.sleeper, 0, 0, Math.min(remaining, 1));
+      }
+    } catch (error) {
+      if (error instanceof Error && "code" in error)
+        throw error;
+      this.abandon();
+      throw new Error("PostgreSQL worker unavailable; write outcome may be unknown");
+    }
+    this.abandon();
+    throw new Error("PostgreSQL operation deadline exceeded; write outcome may be unknown");
+  }
+  query(sql, params) {
+    return this.request("query", translateSqliteDates(translateSql(sql, "pg")), translateParams(params));
+  }
+  run(sql, ...params) {
+    const result = this.query(sql, params);
+    return { changes: result.rowCount, lastInsertRowid: result.rows[0]?.["id"] ?? 0 };
+  }
+  get(sql, ...params) {
+    return this.query(sql, params).rows[0] ?? null;
+  }
+  all(sql, ...params) {
+    return this.query(sql, params).rows;
+  }
+  exec(sql) {
+    this.query(sql, []);
+  }
+  prepare(sql) {
+    return {
+      run: (...params) => this.run(sql, ...params),
+      get: (...params) => this.get(sql, ...params),
+      all: (...params) => this.all(sql, ...params),
+      finalize: () => {}
+    };
+  }
+  transaction(fn) {
+    const outer = this.depth === 0;
+    if (outer) {
+      this.transactionId = ++this.counter;
+      this.transactionDeadline = pgNow() + this.transactionTimeoutMs;
+    }
+    this.depth++;
+    let started = false;
+    try {
+      this.request(outer ? "begin" : "savepoint");
+      started = true;
+      const result = fn();
+      if (result && typeof result.then === "function") {
+        this.abandon();
+        Promise.resolve(result).catch(() => {});
+        throw new Error("PostgreSQL transaction callback must be synchronous");
+      }
+      this.request(outer ? "commit" : "release");
+      return result;
+    } catch (error) {
+      if (started && !this.closed) {
+        try {
+          this.request(outer ? "rollback" : "rollbackTo");
+        } catch {
+          this.abandon();
+        }
+      }
+      throw error;
+    } finally {
+      this.depth--;
+      if (outer) {
+        this.transactionId = null;
+        this.transactionDeadline = Infinity;
+      }
+    }
+  }
+  close() {
+    this.abandon();
+  }
+}
+
+// src/db/pg-connection.ts
+import pg from "pg";
+import { checkServerIdentity } from "tls";
+function resolvePgConnection(dsn) {
+  try {
+    const client = new pg.Client({ connectionString: dsn });
+    const resolved = client.connectionParameters;
+    const ssl = resolved.ssl;
+    const host = resolved.host.replace(/^\[|\]$/g, "");
+    const tls = ssl ? {
+      ...typeof ssl === "object" ? ssl : {},
+      rejectUnauthorized: true,
+      checkServerIdentity: (_servername, cert) => checkServerIdentity(host, cert)
+    } : false;
+    return { ...resolved, password: resolved.password, ssl: tls };
+  } catch {
+    throw new Error("PostgreSQL connection configuration is invalid or its TLS files are unreadable");
+  }
+}
+
+// src/db/pg-migrations.ts
+var PG_MIGRATIONS = [
+  `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_requests_machine ON requests(machine_id)`,
+  `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_sessions_machine ON sessions(machine_id)`,
+  `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
+  )`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS cache_create_5m_tokens INTEGER DEFAULT 0`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS cache_create_1h_tokens INTEGER DEFAULT 0`,
+  `ALTER TABLE model_pricing ADD COLUMN IF NOT EXISTS cache_write_1h_per_1m REAL NOT NULL DEFAULT 0`,
+  `ALTER TABLE model_pricing ADD COLUMN IF NOT EXISTS cache_storage_per_1m_hour REAL NOT NULL DEFAULT 0`,
+  `CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    message TEXT NOT NULL,
+    email TEXT,
+    category TEXT DEFAULT 'general',
+    version TEXT,
+    machine_id TEXT,
+    created_at TEXT NOT NULL DEFAULT NOW()::text
+  )`,
+  `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
+  )`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS cost_basis TEXT DEFAULT 'estimated'`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS attribution_tag TEXT DEFAULT ''`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_key TEXT DEFAULT ''`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_tool TEXT DEFAULT ''`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_name TEXT DEFAULT ''`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_email TEXT DEFAULT ''`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_source TEXT DEFAULT ''`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS updated_at TEXT DEFAULT ''`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS synced_at TEXT DEFAULT ''`,
+  `ALTER TABLE requests ADD COLUMN IF NOT EXISTS cost_center_id TEXT`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS attribution_tag TEXT DEFAULT ''`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_key TEXT DEFAULT ''`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_tool TEXT DEFAULT ''`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_name TEXT DEFAULT ''`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_email TEXT DEFAULT ''`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_source TEXT DEFAULT ''`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS updated_at TEXT DEFAULT ''`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS synced_at TEXT DEFAULT ''`,
+  `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS cost_center_id TEXT`,
+  `ALTER TABLE budgets ADD COLUMN IF NOT EXISTS cost_center_id TEXT`,
+  `ALTER TABLE cost_centers ADD COLUMN IF NOT EXISTS updated_at TEXT DEFAULT ''`,
+  `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)`,
+  `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)`,
+  `ALTER TABLE requests ALTER COLUMN input_tokens TYPE BIGINT`,
+  `ALTER TABLE requests ALTER COLUMN output_tokens TYPE BIGINT`,
+  `ALTER TABLE requests ALTER COLUMN cache_read_tokens TYPE BIGINT`,
+  `ALTER TABLE requests ALTER COLUMN cache_create_tokens TYPE BIGINT`,
+  `ALTER TABLE requests ALTER COLUMN cache_create_5m_tokens TYPE BIGINT`,
+  `ALTER TABLE requests ALTER COLUMN cache_create_1h_tokens TYPE BIGINT`,
+  `ALTER TABLE requests ALTER COLUMN duration_ms TYPE BIGINT`,
+  `ALTER TABLE sessions ALTER COLUMN total_tokens TYPE BIGINT`,
+  `ALTER TABLE sessions ALTER COLUMN request_count TYPE BIGINT`,
+  `ALTER TABLE requests ALTER COLUMN cost_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE sessions ALTER COLUMN total_cost_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE budgets ALTER COLUMN limit_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE goals ALTER COLUMN limit_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE model_pricing ALTER COLUMN input_per_1m TYPE DOUBLE PRECISION`,
+  `ALTER TABLE model_pricing ALTER COLUMN output_per_1m TYPE DOUBLE PRECISION`,
+  `ALTER TABLE model_pricing ALTER COLUMN cache_read_per_1m TYPE DOUBLE PRECISION`,
+  `ALTER TABLE model_pricing ALTER COLUMN cache_write_per_1m TYPE DOUBLE PRECISION`,
+  `ALTER TABLE model_pricing ALTER COLUMN cache_write_1h_per_1m TYPE DOUBLE PRECISION`,
+  `ALTER TABLE model_pricing ALTER COLUMN cache_storage_per_1m_hour TYPE DOUBLE PRECISION`,
+  `ALTER TABLE billing_daily ALTER COLUMN cost_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE subscriptions ALTER COLUMN monthly_fee_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE subscriptions ALTER COLUMN included_usage_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE usage_snapshots ALTER COLUMN value TYPE DOUBLE PRECISION`,
+  `ALTER TABLE savings_daily ALTER COLUMN api_equivalent_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE savings_daily ALTER COLUMN subscription_fee_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE savings_daily ALTER COLUMN included_consumed_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE savings_daily ALTER COLUMN on_demand_usd TYPE DOUBLE PRECISION`,
+  `ALTER TABLE savings_daily ALTER COLUMN saved_usd TYPE DOUBLE PRECISION`,
+  INGEST_SCHEMA_SQL,
+  ...OBSERVATION_PG_MIGRATIONS,
+  `ALTER TABLE budgets ADD COLUMN IF NOT EXISTS metric TEXT NOT NULL DEFAULT 'legacy_request_cost_usd'
+    CHECK (metric IN ('legacy_request_cost_usd', 'metered_api_usd'))`,
+  LEGACY_PG_SQL
+];
+
+// src/db/cloud.ts
+function getCloudDatabaseUrl(env = process.env) {
+  return env["HASNA_ECONOMY_DATABASE_URL"]?.trim() || env["ECONOMY_DATABASE_URL"]?.trim() || env["DATABASE_URL"]?.trim() || undefined;
+}
+function resolveEconomyServerBackend(env = process.env) {
+  return getCloudDatabaseUrl(env) ? "postgresql" : "sqlite";
+}
+function isPostgresBackend(env = process.env) {
+  return resolveEconomyServerBackend(env) === "postgresql";
+}
+function resolveSigningSecret() {
+  return process.env["HASNA_ECONOMY_API_SIGNING_KEY"]?.trim() || process.env["HASNA_API_SIGNING_KEY"]?.trim() || process.env["API_KEY_SIGNING_SECRET"]?.trim() || undefined;
+}
+function createCloudPool(dsn = getCloudDatabaseUrl(), options = {}) {
+  if (!dsn)
+    throw new Error("economy cloud mode requires a Postgres DSN (HASNA_ECONOMY_DATABASE_URL)");
+  const pool = new pg2.Pool({ ...resolvePgConnection(dsn), max: Number(process.env["ECONOMY_PG_POOL_MAX"] ?? "5"), connectionTimeoutMillis: 1e4, ...options });
+  pool.on("error", () => {
+    console.error(JSON.stringify({ evt: "pg_pool_error" }));
+  });
+  return pool;
+}
+function authClientFromPool(pool) {
+  return {
+    async many(sql, params = []) {
+      const res = await pool.query(sql, params);
+      return res.rows;
+    },
+    async get(sql, params = []) {
+      const res = await pool.query(sql, params);
+      return res.rows[0] ?? null;
+    },
+    async execute(sql, params = []) {
+      await pool.query(sql, params);
+    }
+  };
+}
+
+// src/server/serve.ts
+import { verifyApiKey, ApiKeyStore } from "@hasna/contracts/auth";
+
+// src/openapi.ts
+var openApiSpec = {
+  openapi: "3.0.3",
+  info: {
+    title: "@hasna/economy API",
+    version: "0.0.0",
+    description: "AI coding cost tracker \u2014 deployed economy control plane. The server data backend is sqlite | postgresql, selected by the presence of a database URL; with postgresql the serve process reads AND writes PostgreSQL directly with API-key auth via @hasna/contracts. All /v1 routes require a valid `economy:*` scoped API key (x-api-key or Authorization: Bearer). The foundation probes /health, /ready, /version are open. Explicitly configured human access additionally accepts short-lived Economy identity tokens with current session/grant checks and a fixed report-store tenant/principal binding."
+  },
+  servers: [
+    {
+      url: "http://localhost:3456",
+      description: "local default; set your own URL when deploying"
+    }
+  ],
+  security: [
+    {
+      apiKey: []
+    },
+    {
+      bearer: []
+    }
+  ],
+  components: {
+    securitySchemes: {
+      apiKey: {
+        type: "apiKey",
+        in: "header",
+        name: "x-api-key"
+      },
+      bearer: {
+        type: "http",
+        scheme: "bearer"
+      }
+    },
+    schemas: {
+      Envelope: {
+        type: "object",
+        properties: {
+          data: {},
+          meta: {
+            type: "object",
+            additionalProperties: true
+          }
+        },
+        required: [
+          "data"
+        ]
+      },
+      Health: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            enum: [
+              "ok",
+              "degraded",
+              "unavailable"
+            ]
+          },
+          version: {
+            type: "string"
+          },
+          backend: {
+            type: "string",
+            enum: [
+              "sqlite",
+              "postgresql"
+            ]
+          }
+        },
+        required: [
+          "status",
+          "version",
+          "backend"
+        ],
+        additionalProperties: false
+      },
+      Ready: {
+        type: "object",
+        properties: {
+          ready: {
+            type: "boolean"
+          },
+          reason: {
+            type: "string"
+          }
+        },
+        required: [
+          "ready"
+        ],
+        additionalProperties: false
+      },
+      Version: {
+        type: "object",
+        properties: {
+          version: {
+            type: "string"
+          }
+        },
+        required: [
+          "version"
+        ],
+        additionalProperties: false
+      },
+      Error: {
+        type: "object",
+        properties: {
+          error: {
+            type: "string"
+          },
+          message: {
+            type: "string"
+          }
+        },
+        required: [
+          "error"
+        ]
+      },
+      MutationOk: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          }
+        }
+      },
+      CostSummary: {
+        type: "object",
+        properties: {
+          total_usd: {
+            type: "number",
+            minimum: 0,
+            description: "Compatibility subtotal of known stored usage values, including separately reported session-only values. Not a paid bill."
+          },
+          complete_total_usd: {
+            type: "number",
+            nullable: true,
+            minimum: 0
+          },
+          basis: {
+            type: "string",
+            enum: [
+              "known_usage_value_subtotal"
+            ]
+          },
+          completeness: {
+            type: "string",
+            enum: [
+              "complete",
+              "partial",
+              "unavailable",
+              "no_records"
+            ]
+          },
+          coverage_scope: {
+            type: "string",
+            enum: [
+              "selected_stored_records"
+            ]
+          },
+          source_coverage: {
+            type: "string",
+            enum: [
+              "not_established"
+            ]
+          },
+          period_bounds: {
+            $ref: "#/components/schemas/CalendarPeriodBounds"
+          },
+          period: {
+            type: "string",
+            enum: [
+              "today",
+              "yesterday",
+              "week",
+              "month",
+              "year",
+              "all"
+            ]
+          },
+          recorded_metered_api_usd: {
+            type: "number",
+            minimum: 0
+          },
+          estimated_usage_value_usd: {
+            type: "number",
+            minimum: 0
+          },
+          subscription_included_value_usd: {
+            type: "number",
+            minimum: 0
+          },
+          session_only_value_usd: {
+            type: "number",
+            minimum: 0
+          },
+          request_rows: {
+            type: "integer",
+            minimum: 0
+          },
+          unknown_price_requests: {
+            type: "integer",
+            minimum: 0
+          },
+          unknown_basis_requests: {
+            type: "integer",
+            minimum: 0
+          },
+          session_only_sessions: {
+            type: "integer",
+            minimum: 0
+          },
+          sessions: {
+            type: "integer",
+            minimum: 0
+          },
+          requests: {
+            type: "integer",
+            minimum: 0
+          },
+          tokens: {
+            type: "integer",
+            minimum: 0
+          }
+        },
+        required: [
+          "total_usd",
+          "complete_total_usd",
+          "basis",
+          "completeness",
+          "coverage_scope",
+          "source_coverage",
+          "period_bounds",
+          "period",
+          "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",
+          "sessions",
+          "requests",
+          "tokens"
+        ],
+        description: "Complete applies only to selected stored records. Unknown prices or session-only records make complete_total_usd null. Source coverage is never established by this aggregate."
+      },
+      Session: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string"
+          },
+          agent: {
+            type: "string"
+          },
+          project_path: {
+            type: "string"
+          },
+          project_name: {
+            type: "string"
+          },
+          started_at: {
+            type: "string"
+          },
+          ended_at: {
+            type: "string",
+            nullable: true
+          },
+          total_cost_usd: {
+            type: "number"
+          },
+          total_tokens: {
+            type: "number"
+          },
+          request_count: {
+            type: "number"
+          }
+        },
+        additionalProperties: true
+      },
+      ModelBreakdown: {
+        type: "object",
+        additionalProperties: true
+      },
+      ProjectBreakdown: {
+        type: "object",
+        additionalProperties: true
+      },
+      AgentBreakdown: {
+        type: "object",
+        additionalProperties: true
+      },
+      AccountBreakdown: {
+        type: "object",
+        additionalProperties: true
+      },
+      DailyPoint: {
+        type: "object",
+        additionalProperties: true
+      },
+      BudgetStatus: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string"
+          },
+          limit_usd: {
+            type: "number"
+          },
+          period: {
+            type: "string"
+          },
+          spent_usd: {
+            type: "number"
+          },
+          metric: {
+            type: "string",
+            enum: [
+              "legacy_request_cost_usd",
+              "metered_api_usd"
+            ]
+          },
+          current_spend_usd: {
+            type: "number"
+          },
+          percent_used: {
+            type: "number"
+          },
+          is_over_limit: {
+            type: "boolean"
+          },
+          is_over_alert: {
+            type: "boolean"
+          },
+          period_bounds: {
+            type: "object",
+            required: [
+              "time_zone",
+              "start_date",
+              "end_date_exclusive"
+            ],
+            properties: {
+              time_zone: {
+                type: "string",
+                enum: [
+                  "UTC"
+                ]
+              },
+              start_date: {
+                type: "string",
+                format: "date"
+              },
+              end_date_exclusive: {
+                type: "string",
+                format: "date"
+              }
+            }
+          }
+        },
+        additionalProperties: true
+      },
+      CreateBudgetInput: {
+        type: "object",
+        properties: {
+          limit_usd: {
+            type: "number"
+          },
+          alert_at_percent: {
+            type: "number"
+          },
+          period: {
+            type: "string",
+            enum: [
+              "daily",
+              "weekly",
+              "monthly",
+              "day",
+              "week",
+              "month"
+            ]
+          },
+          project_path: {
+            type: "string",
+            nullable: true
+          },
+          agent: {
+            type: "string",
+            nullable: true
+          }
+        },
+        required: [
+          "limit_usd"
+        ]
+      },
+      GoalStatus: {
+        type: "object",
+        additionalProperties: true
+      },
+      CreateGoalInput: {
+        type: "object",
+        properties: {
+          period: {
+            type: "string",
+            enum: [
+              "day",
+              "week",
+              "month",
+              "year"
+            ]
+          },
+          limit_usd: {
+            type: "number"
+          },
+          project_path: {
+            type: "string",
+            nullable: true
+          },
+          agent: {
+            type: "string",
+            nullable: true
+          }
+        },
+        required: [
+          "limit_usd"
+        ]
+      },
+      ModelPricing: {
+        type: "object",
+        additionalProperties: true
+      },
+      CreatePricingInput: {
+        type: "object",
+        properties: {
+          model: {
+            type: "string"
+          },
+          input_per_1m: {
+            type: "number"
+          },
+          output_per_1m: {
+            type: "number"
+          }
+        },
+        required: [
+          "model",
+          "input_per_1m",
+          "output_per_1m"
+        ]
+      },
+      Subscription: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string"
+          },
+          provider: {
+            type: "string"
+          },
+          plan: {
+            type: "string"
+          },
+          agent: {
+            type: "string",
+            nullable: true
+          },
+          account_key: {
+            type: "string"
+          },
+          monthly_fee_usd: {
+            type: "number",
+            minimum: 0
+          },
+          included_usage_usd: {
+            type: "number",
+            minimum: 0
+          },
+          fee_basis: {
+            type: "string",
+            enum: [
+              "unknown",
+              "observed",
+              "configured"
+            ]
+          },
+          included_basis: {
+            type: "string",
+            enum: [
+              "unknown",
+              "observed",
+              "configured"
+            ]
+          },
+          observed_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          observed_station: {
+            type: "string",
+            nullable: true
+          },
+          billing_cycle_start: {
+            type: "string",
+            format: "date",
+            nullable: true
+          },
+          reset_policy: {
+            type: "string"
+          },
+          active: {
+            type: "integer",
+            enum: [
+              0,
+              1
+            ]
+          },
+          created_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          updated_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          }
+        },
+        description: "Account identity is SHA-256 of JSON [provider, account_key]. Legacy numeric amounts remain stored but unknown basis is not a verified fee or free plan."
+      },
+      CreateSubscriptionInput: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string"
+          },
+          provider: {
+            type: "string"
+          },
+          plan: {
+            type: "string"
+          },
+          agent: {
+            type: "string",
+            nullable: true
+          },
+          account_key: {
+            type: "string"
+          },
+          monthly_fee_usd: {
+            type: "number",
+            minimum: 0
+          },
+          included_usage_usd: {
+            type: "number",
+            minimum: 0
+          },
+          fee_basis: {
+            type: "string",
+            enum: [
+              "unknown",
+              "observed",
+              "configured"
+            ]
+          },
+          included_basis: {
+            type: "string",
+            enum: [
+              "unknown",
+              "observed",
+              "configured"
+            ]
+          },
+          observed_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          observed_station: {
+            type: "string",
+            nullable: true
+          },
+          billing_cycle_start: {
+            type: "string",
+            format: "date",
+            nullable: true
+          },
+          reset_policy: {
+            type: "string"
+          },
+          active: {
+            type: "integer",
+            enum: [
+              0,
+              1
+            ]
+          },
+          created_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          updated_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          }
+        },
+        required: [
+          "provider",
+          "plan"
+        ],
+        description: "Known monetary basis requires account_key and observed_at; server supplies observed_at when account_key is provided. Omitted basis is unknown. The CLI/SDK configure explicit amounts with configured basis and require account_key. Null numeric amounts are refused."
+      },
+      Project: {
+        type: "object",
+        additionalProperties: true
+      },
+      CreateProjectInput: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string"
+          },
+          name: {
+            type: "string"
+          },
+          description: {
+            type: "string"
+          },
+          tags: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        required: [
+          "path"
+        ]
+      },
+      MachineInfo: {
+        type: "object",
+        additionalProperties: true
+      },
+      BillingSummary: {
+        type: "object",
+        properties: {
+          total_usd: {
+            type: "number",
+            description: "Compatibility subtotal of selected imported provider rows, including recorded credits."
+          },
+          recorded_total_usd: {
+            type: "number",
+            nullable: true
+          },
+          complete_total_usd: {
+            type: "number",
+            nullable: true,
+            enum: [
+              null
+            ]
+          },
+          basis: {
+            type: "string",
+            enum: [
+              "recorded_provider_rows_subtotal"
+            ]
+          },
+          status: {
+            type: "string",
+            enum: [
+              "observed",
+              "no_records"
+            ]
+          },
+          coverage_scope: {
+            type: "string",
+            enum: [
+              "selected_stored_records"
+            ]
+          },
+          source_coverage: {
+            type: "string",
+            enum: [
+              "not_established"
+            ]
+          },
+          period_bounds: {
+            $ref: "#/components/schemas/CalendarPeriodBounds"
+          },
+          record_count: {
+            type: "integer",
+            minimum: 0
+          },
+          by_provider: {
+            type: "object",
+            additionalProperties: {
+              type: "number"
+            }
+          }
+        },
+        required: [
+          "total_usd",
+          "recorded_total_usd",
+          "complete_total_usd",
+          "basis",
+          "status",
+          "coverage_scope",
+          "source_coverage",
+          "period_bounds",
+          "record_count",
+          "by_provider"
+        ],
+        description: "Recorded provider-row subtotal only. Empty records produce null recorded_total_usd; an actual observed zero remains zero. Complete account/invoice/source coverage is unverified."
+      },
+      UsageSnapshot: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string"
+          },
+          agent: {
+            type: "string"
+          },
+          date: {
+            type: "string",
+            format: "date"
+          },
+          metric: {
+            type: "string"
+          },
+          value: {
+            type: "number",
+            minimum: 0
+          },
+          unit: {
+            type: "string"
+          },
+          machine_id: {
+            type: "string"
+          },
+          updated_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          provider: {
+            type: "string"
+          },
+          account_key: {
+            type: "string"
+          },
+          observed_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          source_timestamp: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          window_start: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          window_end: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          reset_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          window_seconds: {
+            type: "integer",
+            minimum: 1,
+            nullable: true
+          },
+          value_kind: {
+            type: "string",
+            enum: [
+              "gauge",
+              "cumulative",
+              "delta",
+              "unknown"
+            ]
+          }
+        },
+        description: "Immutable identified observation: provider/account/station/metric/observed_at. Measurements retain their source units and actual window; a cumulative value is not a request or delta."
+      },
+      ScanReceipt: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string"
+          },
+          machine_id: {
+            type: "string"
+          },
+          source: {
+            type: "string"
+          },
+          attempted_at: {
+            type: "string",
+            format: "date-time"
+          },
+          completed_at: {
+            type: "string",
+            format: "date-time"
+          },
+          status: {
+            type: "string",
+            enum: [
+              "success",
+              "unchanged",
+              "missing",
+              "unsupported",
+              "failed"
+            ]
+          },
+          latest_event_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          parser_version: {
+            type: "string"
+          },
+          error_code: {
+            type: "string",
+            nullable: true
+          },
+          updated_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          }
+        },
+        required: [
+          "id",
+          "machine_id",
+          "source",
+          "attempted_at",
+          "completed_at",
+          "status",
+          "parser_version"
+        ],
+        description: "Collection attempt and source-event freshness are separate. Error codes are a fixed authored allowlist, never raw provider responses."
+      },
+      IngestReceipt: {
+        type: "object",
+        required: [
+          "ingested",
+          "total",
+          "stale",
+          "unchanged",
+          "operation_key",
+          "replayed"
+        ],
+        properties: {
+          ingested: {
+            type: "object",
+            additionalProperties: {
+              type: "integer",
+              minimum: 0
+            }
+          },
+          total: {
+            type: "integer",
+            minimum: 0
+          },
+          stale: {
+            type: "integer",
+            minimum: 0
+          },
+          unchanged: {
+            type: "integer",
+            minimum: 0
+          },
+          operation_key: {
+            type: "string",
+            pattern: "^[a-f0-9]{64}$"
+          },
+          replayed: {
+            type: "boolean"
+          }
+        }
+      },
+      IngestReconciliation: {
+        type: "object",
+        required: [
+          "status",
+          "body_hash"
+        ],
+        properties: {
+          status: {
+            type: "string",
+            enum: [
+              "committed",
+              "absent"
+            ]
+          },
+          body_hash: {
+            type: "string",
+            pattern: "^[a-f0-9]{64}$"
+          },
+          receipt: {
+            $ref: "#/components/schemas/IngestReceipt"
+          }
+        },
+        description: "Read-only lookup bound to the current signed principal and exact canonical body hash. Absent does not rule out a later commit and does not authorize automatic replay."
+      },
+      CalendarPeriodBounds: {
+        type: "object",
+        properties: {
+          time_zone: {
+            type: "string",
+            enum: [
+              "UTC"
+            ]
+          },
+          start_date: {
+            type: "string",
+            format: "date",
+            nullable: true
+          },
+          end_date_exclusive: {
+            type: "string",
+            format: "date",
+            nullable: true
+          }
+        },
+        required: [
+          "time_zone",
+          "start_date",
+          "end_date_exclusive"
+        ],
+        description: "UTC calendar half-open dates. Null bounds mean all stored dates; weeks begin Sunday."
+      },
+      BillingDiffSummary: {
+        type: "object",
+        properties: {
+          period: {
+            type: "string",
+            enum: [
+              "today",
+              "yesterday",
+              "week",
+              "month",
+              "year",
+              "all"
+            ]
+          },
+          basis: {
+            type: "string",
+            enum: [
+              "unmatched_subtotals"
+            ]
+          },
+          estimated_usd: {
+            type: "number",
+            description: "Compatibility alias of usage_summary.total_usd; known stored usage-value subtotal."
+          },
+          actual_usd: {
+            type: "number",
+            description: "Compatibility alias of billing_summary.total_usd; recorded provider-row subtotal, not verified full billed cost."
+          },
+          usage_summary: {
+            $ref: "#/components/schemas/CostSummary"
+          },
+          billing_summary: {
+            $ref: "#/components/schemas/BillingSummary"
+          },
+          delta_usd: {
+            type: "number",
+            nullable: true,
+            enum: [
+              null
+            ]
+          },
+          delta_pct: {
+            type: "number",
+            nullable: true,
+            enum: [
+              null
+            ]
+          },
+          threshold_pct: {
+            type: "number",
+            minimum: 0
+          },
+          is_alert: {
+            type: "boolean",
+            nullable: true,
+            enum: [
+              null
+            ]
+          },
+          comparable: {
+            type: "boolean",
+            enum: [
+              false
+            ]
+          },
+          incomparable_reason: {
+            type: "string",
+            enum: [
+              "no_billing_records",
+              "account_window_source_unverified"
+            ]
+          },
+          by_provider: {
+            type: "object",
+            additionalProperties: {
+              type: "number"
+            }
+          },
+          by_agent: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                agent: {
+                  type: "string"
+                },
+                basis: {
+                  type: "string",
+                  enum: [
+                    "stored_request_rows_subtotal"
+                  ]
+                },
+                estimated_usd: {
+                  type: "number"
+                },
+                actual_usd: {
+                  type: "number",
+                  nullable: true,
+                  enum: [
+                    null
+                  ]
+                },
+                delta_usd: {
+                  type: "number",
+                  nullable: true,
+                  enum: [
+                    null
+                  ]
+                },
+                delta_pct: {
+                  type: "number",
+                  nullable: true,
+                  enum: [
+                    null
+                  ]
+                }
+              },
+              required: [
+                "agent",
+                "basis",
+                "estimated_usd",
+                "actual_usd",
+                "delta_usd",
+                "delta_pct"
+              ]
+            }
+          }
+        },
+        required: [
+          "period",
+          "basis",
+          "estimated_usd",
+          "actual_usd",
+          "usage_summary",
+          "billing_summary",
+          "delta_usd",
+          "delta_pct",
+          "threshold_pct",
+          "is_alert",
+          "comparable",
+          "incomparable_reason",
+          "by_provider",
+          "by_agent"
+        ],
+        description: "Unmatched subtotals are not a measured difference. Account, billing-window and source correspondence are unverified; deltas and alert state remain null."
+      },
+      CreateApiBudgetRule: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "id",
+          "period",
+          "metric",
+          "limit_usd",
+          "alert_at_percent",
+          "created_at",
+          "updated_at"
+        ],
+        properties: {
+          id: {
+            type: "string",
+            minLength: 1,
+            maxLength: 1024
+          },
+          period: {
+            type: "string",
+            enum: [
+              "daily",
+              "weekly",
+              "monthly"
+            ]
+          },
+          metric: {
+            type: "string",
+            enum: [
+              "metered_api_usd"
+            ]
+          },
+          limit_usd: {
+            type: "number",
+            exclusiveMinimum: true,
+            minimum: 0
+          },
+          alert_at_percent: {
+            type: "integer",
+            minimum: 1,
+            maximum: 100
+          },
+          project_path: {
+            type: "string",
+            nullable: true,
+            minLength: 1,
+            maxLength: 16384
+          },
+          cost_center_id: {
+            type: "string",
+            nullable: true,
+            minLength: 1,
+            maxLength: 16384
+          },
+          agent: {
+            type: "string",
+            nullable: true,
+            enum: [
+              "claude",
+              "takumi",
+              "codex",
+              "gemini",
+              "opencode",
+              "cursor",
+              "pi",
+              "hermes",
+              null
+            ]
+          },
+          created_at: {
+            type: "string",
+            format: "date-time",
+            description: "Explicit UTC Z timestamp; preserve exact body on retry."
+          },
+          updated_at: {
+            type: "string",
+            format: "date-time",
+            description: "Explicit UTC Z timestamp; preserve exact body on retry."
+          }
+        }
+      },
+      CreateApiBudgetCommand: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "schema_version",
+          "idempotency_key",
+          "budget_mode",
+          "budgets"
+        ],
+        properties: {
+          schema_version: {
+            type: "integer",
+            enum: [
+              1
+            ]
+          },
+          idempotency_key: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200,
+            pattern: "^[A-Za-z0-9._:-]+$"
+          },
+          budget_mode: {
+            type: "string",
+            enum: [
+              "create"
+            ]
+          },
+          budgets: {
+            type: "array",
+            minItems: 1,
+            maxItems: 1,
+            items: {
+              $ref: "#/components/schemas/CreateApiBudgetRule"
+            }
+          }
+        }
+      }
+    }
+  },
+  paths: {
+    "/health": {
+      get: {
+        operationId: "health",
+        summary: "Liveness probe",
+        security: [],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Health"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/ready": {
+      get: {
+        operationId: "ready",
+        summary: "Readiness probe (storage reachable + migrated)",
+        security: [],
+        responses: {
+          "200": {
+            description: "ready",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Ready"
+                }
+              }
+            }
+          },
+          "503": {
+            description: "not ready",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Ready"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/version": {
+      get: {
+        operationId: "version",
+        summary: "Version probe",
+        security: [],
+        responses: {
+          "200": {
+            description: "version",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Version"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/summary": {
+      get: {
+        operationId: "getSummary",
+        summary: "Cost summary for a period",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "machine",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/CostSummary"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/sessions": {
+      get: {
+        operationId: "listSessions",
+        summary: "List sessions",
+        parameters: [
+          {
+            name: "agent",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "project",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "search",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "machine",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "account",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "limit",
+            in: "query",
+            schema: {
+              type: "integer"
+            }
+          },
+          {
+            name: "offset",
+            in: "query",
+            schema: {
+              type: "integer"
+            }
+          },
+          {
+            name: "since",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "fields",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/Session"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/sessions/{id}/requests": {
+      get: {
+        operationId: "getSessionRequests",
+        summary: "Requests for a session",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          },
+          "404": {
+            description: "not found",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/top": {
+      get: {
+        operationId: "topSessions",
+        summary: "Top sessions by cost",
+        parameters: [
+          {
+            name: "n",
+            in: "query",
+            schema: {
+              type: "integer"
+            }
+          },
+          {
+            name: "agent",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "since",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/Session"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/models": {
+      get: {
+        operationId: "modelBreakdown",
+        summary: "Cost by model",
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/ModelBreakdown"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/projects": {
+      get: {
+        operationId: "projectBreakdown",
+        summary: "Cost by project",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "machine",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/ProjectBreakdown"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/accounts": {
+      get: {
+        operationId: "accountBreakdown",
+        summary: "Cost by account",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "machine",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/AccountBreakdown"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/breakdown": {
+      get: {
+        operationId: "breakdown",
+        summary: "Cost breakdown by dimension",
+        parameters: [
+          {
+            name: "by",
+            in: "query",
+            schema: {
+              type: "string",
+              enum: [
+                "model",
+                "project",
+                "agent",
+                "account"
+              ]
+            }
+          },
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "since",
+            in: "query",
+            description: "ISO timestamp lower bound; takes precedence over period",
+            schema: {
+              type: "string",
+              format: "date-time"
+            }
+          },
+          {
+            name: "machine",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/daily": {
+      get: {
+        operationId: "daily",
+        summary: "Daily cost points",
+        parameters: [
+          {
+            name: "days",
+            in: "query",
+            schema: {
+              type: "integer"
+            }
+          },
+          {
+            name: "machine",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/DailyPoint"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/hourly": {
+      get: {
+        operationId: "hourly",
+        summary: "Hourly cost points",
+        parameters: [
+          {
+            name: "hours",
+            in: "query",
+            schema: {
+              type: "integer"
+            }
+          },
+          {
+            name: "machine",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/machines": {
+      get: {
+        operationId: "listMachines",
+        summary: "Known machines",
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/MachineInfo"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/fleet": {
+      get: {
+        operationId: "fleet",
+        summary: "Fleet summary",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "machine",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/billing": {
+      get: {
+        operationId: "billing",
+        summary: "Provider billing summary",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/BillingSummary"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/billing/diff": {
+      get: {
+        operationId: "billingDiff",
+        summary: "Read unmatched usage-value and provider-row subtotals with an explicit unavailable comparison",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "threshold",
+            in: "query",
+            schema: {
+              type: "number"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/BillingDiffSummary"
+                    }
+                  },
+                  required: [
+                    "data"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/usage": {
+      get: {
+        operationId: "usage",
+        summary: "Usage snapshots + summary",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "agent",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/savings": {
+      get: {
+        operationId: "savings",
+        summary: "Savings summary",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "agent",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/budgets": {
+      get: {
+        operationId: "listBudgets",
+        summary: "List budgets",
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/BudgetStatus"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "createBudget",
+        summary: "Create a budget",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/CreateBudgetInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "created",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/BudgetStatus"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/budgets/{id}": {
+      delete: {
+        operationId: "deleteBudget",
+        summary: "Delete a budget",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/MutationOk"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/goals": {
+      get: {
+        operationId: "listGoals",
+        summary: "List goals",
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/GoalStatus"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "createGoal",
+        summary: "Create a goal",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/CreateGoalInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "created",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/GoalStatus"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/goals/{id}": {
+      delete: {
+        operationId: "deleteGoal",
+        summary: "Delete a goal",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/MutationOk"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/pricing": {
+      get: {
+        operationId: "listPricing",
+        summary: "List model pricing",
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/ModelPricing"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "upsertPricing",
+        summary: "Upsert model pricing",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/CreatePricingInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/ModelPricing"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/pricing/{model}": {
+      delete: {
+        operationId: "deletePricing",
+        summary: "Delete model pricing",
+        parameters: [
+          {
+            name: "model",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/MutationOk"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/subscriptions": {
+      get: {
+        operationId: "listSubscriptions",
+        summary: "List subscriptions",
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/Subscription"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "upsertSubscription",
+        summary: "Upsert a subscription",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/CreateSubscriptionInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/Subscription"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/subscriptions/{id}": {
+      delete: {
+        operationId: "deleteSubscription",
+        summary: "Delete a subscription",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/MutationOk"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/project-registry": {
+      get: {
+        operationId: "listProjectRegistry",
+        summary: "List registered projects",
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/Project"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "upsertProject",
+        summary: "Register a project",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/CreateProjectInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/MutationOk"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/project-registry/{id}": {
+      delete: {
+        operationId: "deleteProject",
+        summary: "Delete a registered project",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/MutationOk"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/sync": {
+      post: {
+        operationId: "sync",
+        summary: "Trigger an ingest sync",
+        requestBody: {
+          required: false,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  sources: {
+                    type: "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/ingest": {
+      post: {
+        operationId: "ingest",
+        summary: "Atomically ingest a bounded, versioned observation batch",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  requests: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    },
+                    maxItems: 1e4
+                  },
+                  sessions: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    },
+                    maxItems: 1e4
+                  },
+                  projects: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    },
+                    maxItems: 1e4
+                  },
+                  budgets: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    },
+                    maxItems: 1e4
+                  },
+                  goals: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    },
+                    maxItems: 1e4
+                  },
+                  billing_daily: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    },
+                    maxItems: 1e4
+                  },
+                  model_pricing: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    },
+                    maxItems: 1e4
+                  },
+                  subscriptions: {
+                    type: "array",
+                    items: {
+                      $ref: "#/components/schemas/Subscription"
+                    },
+                    maxItems: 1e4
+                  },
+                  usage_snapshots: {
+                    type: "array",
+                    items: {
+                      $ref: "#/components/schemas/UsageSnapshot"
+                    },
+                    maxItems: 1e4
+                  },
+                  schema_version: {
+                    type: "integer",
+                    enum: [
+                      1
+                    ],
+                    description: "Optional format version; current value is 1."
+                  },
+                  idempotency_key: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 200,
+                    pattern: "^[A-Za-z0-9._:-]+$",
+                    description: "Stable caller-owned key for the exact body. After uncertainty use GET /v1/ingest/receipts with the canonical body hash; do not automatically replay."
+                  },
+                  scan_receipts: {
+                    type: "array",
+                    items: {
+                      $ref: "#/components/schemas/ScanReceipt"
+                    },
+                    maxItems: 1e4
+                  },
+                  subscription_mode: {
+                    type: "string",
+                    enum: [
+                      "quota_observation",
+                      "configuration"
+                    ],
+                    default: "quota_observation",
+                    description: "With subscriptions only. Quota observations preserve existing assignment, activation, plan label and cycle settings. Explicit configuration permits changing those fields under the current write authority."
+                  },
+                  budget_mode: {
+                    type: "string",
+                    enum: [
+                      "create"
+                    ],
+                    description: "Opt-in new metered API rule creation. Requires schema_version=1, stable idempotency_key, exactly one budgets row matching CreateApiBudgetRule and no other tables. Existing IDs conflict; preserve complete command/body on uncertainty and use the existing receipt GET. Does not dispatch notifications."
+                  }
+                },
+                additionalProperties: false
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Committed or exact replayed receipt.",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "data"
+                  ],
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/IngestReceipt"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            description: "INVALID_INGEST: invalid field or row; no writes.",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "error"
+                  ],
+                  properties: {
+                    error: {
+                      type: "string"
+                    },
+                    code: {
+                      type: "string"
+                    },
+                    field: {
+                      type: "string"
+                    },
+                    expected: {
+                      type: "string"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "409": {
+            description: "INGEST_CONFLICT: changed key content, concurrent row change, or missing/conflicting source version; no writes for this command.",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "error"
+                  ],
+                  properties: {
+                    error: {
+                      type: "string"
+                    },
+                    code: {
+                      type: "string"
+                    },
+                    field: {
+                      type: "string"
+                    },
+                    expected: {
+                      type: "string"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "413": {
+            description: "INGEST_TOO_LARGE: split into bounded commands; no writes.",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "error"
+                  ],
+                  properties: {
+                    error: {
+                      type: "string"
+                    },
+                    code: {
+                      type: "string"
+                    },
+                    field: {
+                      type: "string"
+                    },
+                    expected: {
+                      type: "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        description: "Maximum 10000 rows total and 4194304 JSON bytes. All rows and rollups commit with one actor-bound receipt. A repeated exact key/content returns that receipt with replayed=true; different content under the same key is 409. Older source versions are skipped; conflicting same-version or unversioned replacements are 409. Missing key derives from exact content for compatibility. Source times use ISO UTC (Z). No automatic retry after an uncertain response. Legacy Codex aggregate and event rows for one session cannot coexist; migrate preserved historical data separately."
+      }
+    },
+    "/v1/ingest/receipts": {
+      get: {
+        operationId: "reconcileIngestReceipt",
+        summary: "Read the exact current-principal ingestion receipt without replay",
+        parameters: [
+          {
+            name: "idempotency_key",
+            in: "query",
+            required: true,
+            schema: {
+              type: "string",
+              pattern: "^[A-Za-z0-9._:-]{1,200}$"
+            }
+          },
+          {
+            name: "body_hash",
+            in: "query",
+            required: true,
+            schema: {
+              type: "string",
+              pattern: "^[a-f0-9]{64}$"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "data"
+                  ],
+                  properties: {
+                    data: {
+                      $ref: "#/components/schemas/IngestReconciliation"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            description: "Invalid query shape; exactly one key and hash are required."
+          },
+          "401": {
+            description: "Current principal is missing or invalid."
+          },
+          "409": {
+            description: "The key exists for this principal with different content."
+          }
+        }
+      }
+    },
+    "/v1/scan-receipts": {
+      get: {
+        operationId: "listScanReceipts",
+        summary: "Bounded latest collection attempts; not a complete fleet coverage claim",
+        parameters: [
+          {
+            name: "machine_id",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "source",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "limit",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 1,
+              maximum: 200,
+              default: 100
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "data"
+                  ],
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/ScanReceipt"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            description: "Invalid limit; expected an integer from 1 to 200."
+          }
+        }
+      }
+    },
+    "/v1/auth/session": {
+      get: {
+        operationId: "humanSession",
+        summary: "Read the authenticated human and effective store-bound scopes",
+        security: [
+          {
+            bearer: []
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Current human session; Cache-Control: no-store",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "data",
+                    "meta"
+                  ],
+                  properties: {
+                    data: {
+                      type: "object",
+                      required: [
+                        "subject",
+                        "tenant_id",
+                        "scopes",
+                        "session_id",
+                        "expires_at"
+                      ],
+                      properties: {
+                        subject: {
+                          type: "string"
+                        },
+                        tenant_id: {
+                          type: "string"
+                        },
+                        scopes: {
+                          type: "array",
+                          items: {
+                            type: "string",
+                            enum: [
+                              "economy:read",
+                              "economy:write"
+                            ]
+                          }
+                        },
+                        session_id: {
+                          type: "string"
+                        },
+                        expires_at: {
+                          type: "integer",
+                          description: "Expiry in epoch seconds"
+                        }
+                      }
+                    },
+                    meta: {
+                      type: "object"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            description: "Invalid or expired human token"
+          },
+          "403": {
+            description: "Human, tenant, principal or current grant denied"
+          },
+          "503": {
+            description: "Human binding missing or identity authority unavailable"
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/server/service-dispatcher.ts
+import { fork } from "child_process";
+import { randomUUID } from "crypto";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/server/service-protocol.ts
+var routes = [
+  ["summary", "GET", "/api/summary"],
+  ["machines", "GET", "/api/machines"],
+  ["fleet", "GET", "/api/fleet"],
+  ["daily", "GET", "/api/daily"],
+  ["hourly", "GET", "/api/hourly"],
+  ["sessions", "GET", "/api/sessions"],
+  ["top", "GET", "/api/top"],
+  ["models", "GET", "/api/models"],
+  ["billing", "GET", "/api/billing"],
+  ["billingDiff", "GET", "/api/billing/diff"],
+  ["billingSync", "POST", "/api/billing/sync"],
+  ["projects", "GET", "/api/projects"],
+  ["accounts", "GET", "/api/accounts"],
+  ["breakdown", "GET", "/api/breakdown"],
+  ["budgets", "GET", "/api/budgets"],
+  ["budgetSave", "POST", "/api/budgets"],
+  ["projectRegistry", "GET", "/api/project-registry"],
+  ["projectSave", "POST", "/api/project-registry"],
+  ["pricing", "GET", "/api/pricing"],
+  ["pricingSave", "POST", "/api/pricing"],
+  ["sync", "POST", "/api/sync"],
+  ["ingest", "POST", "/api/ingest"],
+  ["ingestReceipt", "GET", "/api/ingest/receipts"],
+  ["scanReceipts", "GET", "/api/scan-receipts"],
+  ["usage", "GET", "/api/usage"],
+  ["savings", "GET", "/api/savings"],
+  ["brief", "GET", "/api/brief"],
+  ["projectDetail", "GET", "/api/projects/detail"],
+  ["export", "GET", "/api/export"],
+  ["compare", "GET", "/api/compare"],
+  ["forecast", "GET", "/api/forecast"],
+  ["efficiency", "GET", "/api/efficiency"],
+  ["requests", "GET", "/api/requests"],
+  ["subscriptions", "GET", "/api/subscriptions"],
+  ["subscriptionSave", "POST", "/api/subscriptions"],
+  ["goals", "GET", "/api/goals"],
+  ["goalSave", "POST", "/api/goals"],
+  ["feedback", "POST", "/api/feedback"]
+];
+var dynamicRoutes = [
+  ["budgetDelete", "DELETE", /^\/api\/budgets\/(.+)$/],
+  ["projectDelete", "DELETE", /^\/api\/project-registry\/(.+)$/],
+  ["pricingDelete", "DELETE", /^\/api\/pricing\/(.+)$/],
+  ["subscriptionDelete", "DELETE", /^\/api\/subscriptions\/(.+)$/],
+  ["goalDelete", "DELETE", /^\/api\/goals\/(.+)$/],
+  ["sessionRequests", "GET", /^\/api\/sessions\/([^/]+)\/requests$/]
+];
+function serviceRoute(method, path) {
+  return routes.find((route) => route[1] === method && route[2] === path)?.[0] ?? dynamicRoutes.find((route) => route[1] === method && route[2].test(path))?.[0];
+}
+function validOperation(operation) {
+  return !!operation && typeof operation.path === "string" && typeof operation.method === "string" && typeof operation.route === "string" && serviceRoute(operation.method, operation.path) === operation.route && operation.path.length <= 8192 && operation.search?.length <= 8192 && typeof operation.search === "string" && (operation.search === "" || operation.search.startsWith("?")) && typeof operation.actorId === "string" && operation.actorId.length <= 1024 && (operation.body === null || typeof operation.body === "string");
+}
+
+// src/server/service-dispatcher.ts
+var DEFAULT_SERVICE_LIMITS = {
+  workers: 2,
+  maxQueue: 32,
+  deadlineMs: 30000,
+  maxInputBytes: 4 * 1024 * 1024,
+  maxResultBytes: 8 * 1024 * 1024,
+  maxQueuedBytes: 16 * 1024 * 1024
+};
+function serviceLimits(env = process.env) {
+  const limits = { ...DEFAULT_SERVICE_LIMITS };
+  for (const [field, name, max] of [
+    ["workers", "ECONOMY_SERVICE_WORKERS", 8],
+    ["maxQueue", "ECONOMY_SERVICE_MAX_QUEUE", 256],
+    ["deadlineMs", "ECONOMY_SERVICE_DEADLINE_MS", 120000],
+    ["maxInputBytes", "ECONOMY_SERVICE_MAX_INPUT_BYTES", 16 * 1024 * 1024],
+    ["maxResultBytes", "ECONOMY_SERVICE_MAX_RESULT_BYTES", 32 * 1024 * 1024],
+    ["maxQueuedBytes", "ECONOMY_SERVICE_MAX_QUEUED_BYTES", 64 * 1024 * 1024]
+  ]) {
+    if (env[name] === undefined)
+      continue;
+    const value = Number(env[name]);
+    if (!Number.isSafeInteger(value) || value < 1 || value > max)
+      throw new Error(`Invalid ${name}`);
+    limits[field] = value;
+  }
+  return limits;
+}
+
+class ServiceUnavailable extends Error {
+  code;
+  status;
+  operationId;
+  outcome;
+  constructor(code, status, operationId, outcome) {
+    super("Economy operation could not return a confirmed result");
+    this.code = code;
+    this.status = status;
+    this.operationId = operationId;
+    this.outcome = outcome;
+  }
+}
+
+class AsyncServiceDispatcher {
+  backend;
+  limits;
+  queue = [];
+  active = new Set;
+  generation = 0;
+  queuedBytes = 0;
+  stopped = false;
+  constructor(backend, limits = serviceLimits()) {
+    this.backend = backend;
+    this.limits = limits;
+  }
+  dispatch(operation, signal, beforeStart) {
+    const id = randomUUID();
+    if (!validOperation(operation))
+      return Promise.reject(new ServiceUnavailable("invalid_operation", 400, id, "not_started"));
+    const bodyBytes = operation.body === null ? 0 : Buffer.byteLength(operation.body);
+    const bytes = bodyBytes + Buffer.byteLength(JSON.stringify({ ...operation, body: null }));
+    if (bodyBytes > this.limits.maxInputBytes)
+      return Promise.reject(new ServiceUnavailable("input_too_large", 413, id, "not_started"));
+    if (this.stopped)
+      return Promise.reject(new ServiceUnavailable("service_stopping", 503, id, "not_started"));
+    if (signal?.aborted)
+      return Promise.reject(new ServiceUnavailable("request_cancelled", 499, id, "not_started"));
+    if (this.active.size >= this.limits.workers && (this.queue.length >= this.limits.maxQueue || this.queuedBytes + bytes > this.limits.maxQueuedBytes)) {
+      return Promise.reject(new ServiceUnavailable("service_busy", 503, id, "not_started"));
+    }
+    return new Promise((resolve, reject) => {
+      const job = {
+        id,
+        generation: ++this.generation,
+        operation,
+        bytes,
+        deadline: performance.now() + this.limits.deadlineMs,
+        done: false,
+        resolve,
+        reject,
+        signal,
+        beforeStart,
+        cancel: () => {},
+        timer: undefined
+      };
+      job.cancel = () => this.fail(job, "request_cancelled", 499);
+      signal?.addEventListener("abort", job.cancel, { once: true });
+      job.timer = setTimeout(() => this.fail(job, "operation_timeout", 504), this.limits.deadlineMs);
+      this.queue.push(job);
+      this.queuedBytes += bytes;
+      this.pump();
+    });
+  }
+  settle(job) {
+    if (job.done)
+      return false;
+    job.done = true;
+    clearTimeout(job.timer);
+    job.signal?.removeEventListener("abort", job.cancel);
+    const index = this.queue.indexOf(job);
+    if (index !== -1) {
+      this.queue.splice(index, 1);
+      this.queuedBytes -= job.bytes;
+    }
+    return true;
+  }
+  fail(job, code, status) {
+    if (!this.settle(job))
+      return;
+    job.reject(new ServiceUnavailable(code, status, job.id, job.child ? "unknown" : "not_started"));
+    if (job.child && job.child.exitCode === null && job.child.signalCode === null)
+      job.child.kill("SIGKILL");
+    this.pump();
+  }
+  pump() {
+    while (!this.stopped && this.active.size < this.limits.workers && this.queue.length) {
+      const job = this.queue.shift();
+      this.queuedBytes -= job.bytes;
+      if (job.done)
+        continue;
+      if (performance.now() >= job.deadline) {
+        this.fail(job, "operation_timeout", 504);
+        continue;
+      }
+      this.start(job);
+    }
+  }
+  start(job) {
+    this.active.add(job);
+    if (!job.beforeStart) {
+      this.launch(job);
+      return;
+    }
+    (async () => {
+      try {
+        await job.beforeStart();
+        if (!job.done && !this.stopped && performance.now() < job.deadline) {
+          this.launch(job);
+          return;
+        }
+        this.fail(job, "operation_timeout", 504);
+      } catch (error) {
+        this.fail(job, error instanceof ServiceUnavailable ? error.code : "authentication_unavailable", error instanceof ServiceUnavailable ? error.status : 503);
+      }
+      this.active.delete(job);
+      this.pump();
+    })();
+  }
+  launch(job) {
+    const self = fileURLToPath2(import.meta.url);
+    const workerPath = join2(dirname2(self), `service-worker.${self.endsWith(".js") ? "js" : "ts"}`);
+    const env = { ...process.env, ECONOMY_PG_POOL_MAX: "1" };
+    for (const key of ["HASNA_ECONOMY_API_SIGNING_KEY", "HASNA_API_SIGNING_KEY", "API_KEY_SIGNING_SECRET", "NODE_OPTIONS", "BUN_OPTIONS"])
+      delete env[key];
+    try {
+      const child = fork(workerPath, [], { execPath: process.execPath, env, stdio: ["ignore", "ignore", "ignore", "ipc"], serialization: "json" });
+      job.child = child;
+      child.on("message", (input) => {
+        if (job.done || !this.active.has(job))
+          return;
+        const reply = input;
+        if (reply?.version !== 1 || reply.id !== job.id || reply.generation !== job.generation) {
+          this.fail(job, "worker_protocol_error", 502);
+          return;
+        }
+        if (performance.now() >= job.deadline) {
+          this.fail(job, "operation_timeout", 504);
+          return;
+        }
+        if (!reply.ok) {
+          this.fail(job, reply.code === "result_too_large" ? "result_too_large" : "operation_failed", 502);
+          return;
+        }
+        if (!reply.result || !Number.isInteger(reply.result.status) || reply.result.status < 100 || reply.result.status > 599 || typeof reply.result.body !== "string" || Buffer.byteLength(reply.result.body) > this.limits.maxResultBytes) {
+          this.fail(job, "worker_protocol_error", 502);
+          return;
+        }
+        if (this.settle(job)) {
+          job.resolve(reply.result);
+          child.kill("SIGKILL");
+        }
+      });
+      child.on("error", () => {
+        this.fail(job, "worker_unavailable", 503);
+        if (!child.pid) {
+          this.active.delete(job);
+          this.pump();
+        }
+      });
+      child.once("exit", () => {
+        if (!job.done)
+          this.fail(job, "worker_exited", 502);
+        this.active.delete(job);
+        this.pump();
+      });
+      child.send({
+        version: 1,
+        id: job.id,
+        generation: job.generation,
+        operation: job.operation,
+        backend: this.backend,
+        queryTimeoutMs: Math.max(1, Math.floor(job.deadline - performance.now())),
+        maxResultBytes: this.limits.maxResultBytes
+      }, (error) => {
+        if (error)
+          this.fail(job, "worker_unavailable", 503);
+      });
+    } catch {
+      this.fail(job, "worker_unavailable", 503);
+      this.active.delete(job);
+      this.pump();
+    }
+  }
+  state() {
+    return { active: this.active.size, queued: this.queue.length, queuedBytes: this.queuedBytes, stopped: this.stopped };
+  }
+  async close() {
+    this.stopped = true;
+    for (const job of [...this.queue, ...this.active])
+      this.fail(job, "service_stopping", 503);
+    await Promise.all([...this.active].map((job) => new Promise((resolve, reject) => {
+      if (!job.child || job.child.exitCode !== null || job.child.signalCode !== null) {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => reject(new Error("Economy worker shutdown timed out")), 2000);
+      job.child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    })));
+  }
+}
+
+// src/server/service-operations.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var CORS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Economy-Token"
+};
+var AGENT_ERROR = `agent must be one of: ${AGENTS.join(", ")}`;
+var SYNC_SOURCES = ["all", ...AGENTS, "loops"];
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...CORS }
+  });
+}
+function ok(data, meta) {
+  return json({ data, meta: meta ?? {} });
+}
+function err(message, status = 400) {
+  return json({ error: message }, status);
+}
+function normalizeBudgetPeriod(value) {
+  switch (value) {
+    case "day":
+    case "daily":
+      return "daily";
+    case "week":
+    case "weekly":
+      return "weekly";
+    case "month":
+    case "monthly":
+    default:
+      return "monthly";
+  }
+}
+function finiteNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+async function jsonBody(req) {
+  const body = await req.json().catch(() => null);
+  return body && typeof body === "object" && !Array.isArray(body) ? body : null;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : null;
+}
+function optionalAgent(value) {
+  if (value == null || value === "")
+    return null;
+  return typeof value === "string" && AGENTS.includes(value) ? value : undefined;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function applyFields(obj, fields) {
+  if (!fields || fields.length === 0)
+    return obj;
+  return Object.fromEntries(fields.map((f) => [f, obj[f] ?? null]));
+}
+function createDataHandler(db, actorId) {
+  return async function handler(req) {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const method = req.method;
+    if (path === "/api/summary" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "today";
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok(querySummary(db, period, machine));
+    }
+    if (path === "/api/machines" && method === "GET") {
+      return ok(listMachines(db), { current_machine: getMachineId() });
+    }
+    if (path === "/api/fleet" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "month";
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok({
+        summary: querySummary(db, period, machine),
+        machines: listMachines(db, period),
+        registry: listMachineRegistry(db),
+        current_machine: getMachineId()
+      });
+    }
+    if (path === "/api/daily" && method === "GET") {
+      const days = Number(url.searchParams.get("days") ?? 30);
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok(queryDailyBreakdown(db, days, machine));
+    }
+    if (path === "/api/hourly" && method === "GET") {
+      const machine = url.searchParams.get("machine") ?? undefined;
+      const rawHours = url.searchParams.get("hours");
+      let hours;
+      if (rawHours != null) {
+        const parsedHours = Number(rawHours);
+        if (!Number.isInteger(parsedHours) || parsedHours < 1 || parsedHours > 48) {
+          return err("hours must be between 1 and 48");
+        }
+        hours = parsedHours;
+      }
+      return ok(queryHourlyBreakdown(db, machine, hours));
+    }
+    if (path === "/api/sessions" && method === "GET") {
+      const agent = url.searchParams.get("agent");
+      const project = url.searchParams.get("project") ?? undefined;
+      const search = url.searchParams.get("search") ?? undefined;
+      const machine = url.searchParams.get("machine") ?? undefined;
+      const account = url.searchParams.get("account") ?? undefined;
+      const limit = Number(url.searchParams.get("limit") ?? 50);
+      const offset = Number(url.searchParams.get("offset") ?? 0);
+      const since = url.searchParams.get("since") ?? undefined;
+      const fieldsParam = url.searchParams.get("fields");
+      const fields = fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
+      const sessions = querySessions(db, {
+        agent: agent ?? undefined,
+        project,
+        search,
+        machine,
+        account,
+        limit,
+        offset,
+        since
+      });
+      return ok(fields ? sessions.map((s) => applyFields(s, fields)) : sessions, { limit, offset });
+    }
+    if (path === "/api/top" && method === "GET") {
+      const n = Number(url.searchParams.get("n") ?? 10);
+      const agent = url.searchParams.get("agent") ?? undefined;
+      const since = url.searchParams.get("since") ?? undefined;
+      return ok(queryTopSessions(db, n, agent, since));
+    }
+    if (path === "/api/models" && method === "GET") {
+      return ok(queryModelBreakdown(db));
+    }
+    if (path === "/api/billing" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "month";
+      return ok(queryBillingSummary(db, period));
+    }
+    if (path === "/api/billing/diff" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "month";
+      const threshold = Number(url.searchParams.get("threshold") ?? 15);
+      return ok(queryBillingDiff(db, period, Number.isFinite(threshold) ? threshold : 15));
+    }
+    if (path === "/api/billing/sync" && method === "POST") {
+      const body = await jsonBody(req) ?? {};
+      const days = Number(body["days"] ?? 31);
+      if (!Number.isFinite(days) || days <= 0 || days > 366)
+        return err("days must be between 1 and 366");
+      const providers = Array.isArray(body["providers"]) ? body["providers"] : ["anthropic", "openai", "gemini"];
+      const allowedProviders = new Set(["anthropic", "openai", "gemini"]);
+      if (providers.some((provider) => !allowedProviders.has(provider)))
+        return err("invalid billing provider");
+      const results = {};
+      const { syncAnthropicBilling, syncOpenAIBilling, syncGeminiBilling } = await import("./billing-bkpxy4kv.js");
+      async function capture(provider, fn) {
+        try {
+          results[provider] = await fn();
+        } catch (error) {
+          const missingConfig = [
+            "Missing Anthropic admin key (HASNAXYZ_ANTHROPIC_LIVE_ADMIN_API_KEY)",
+            "Missing OpenAI admin key (HASNAXYZ_OPENAI_LIVE_ADMIN_API_KEY)"
+          ];
+          const safeMessage = error instanceof Error && missingConfig.includes(error.message) ? error.message : "billing_sync_failed";
+          results[provider] = { error: safeMessage };
+        }
+      }
+      if (providers.includes("anthropic"))
+        await capture("anthropic", () => syncAnthropicBilling(db, { days }));
+      if (providers.includes("openai"))
+        await capture("openai", () => syncOpenAIBilling(db, { days }));
+      if (providers.includes("gemini"))
+        await capture("gemini", () => syncGeminiBilling(db, { days }));
+      return ok(results);
+    }
+    if (path === "/api/projects" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "all";
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok(queryProjectBreakdown(db, period, machine));
+    }
+    if (path === "/api/accounts" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "all";
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok(queryAccountBreakdown(db, period, machine));
+    }
+    if (path === "/api/breakdown" && method === "GET") {
+      const by = url.searchParams.get("by") ?? "model";
+      const period = url.searchParams.get("period") ?? "all";
+      const since = url.searchParams.get("since") ?? undefined;
+      const machine = url.searchParams.get("machine") ?? undefined;
+      if (by === "project")
+        return ok(since ? queryProjectBreakdownSince(db, since, machine) : queryProjectBreakdown(db, period, machine));
+      if (by === "agent")
+        return ok(since ? queryAgentBreakdownSince(db, since) : queryAgentBreakdown(db, period, machine));
+      if (by === "account")
+        return ok(since ? queryAccountBreakdownSince(db, since) : queryAccountBreakdown(db, period, machine));
+      if (by === "cost-center")
+        return ok(queryCostCenterBreakdown(db, period, { machine, since }));
+      if (["loop", "app", "repo", "service", "team"].includes(by))
+        return ok(queryCostCenterBreakdown(db, period, { kind: by, machine, since }));
+      return ok(since ? queryModelBreakdownSince(db, since) : queryModelBreakdown(db));
+    }
+    if (path === "/api/budgets" && method === "GET") {
+      return ok(getBudgetStatuses(db));
+    }
+    if (path === "/api/budgets" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      const limitUsd = finiteNumber(body["limit_usd"]);
+      const alertAtPercent = finiteNumber(body["alert_at_percent"] ?? 80);
+      if (limitUsd == null || limitUsd <= 0)
+        return err("limit_usd must be a positive number");
+      if (alertAtPercent == null || alertAtPercent <= 0 || alertAtPercent > 100)
+        return err("alert_at_percent must be between 1 and 100");
+      const agent = optionalAgent(body["agent"]);
+      if (agent === undefined)
+        return err(AGENT_ERROR);
+      const now = new Date().toISOString();
+      const budget = {
+        id: randomUUID2(),
+        project_path: body["project_path"] ?? null,
+        agent,
+        cost_center_id: optionalString(body["cost_center_id"]) ?? null,
+        period: normalizeBudgetPeriod(body["period"]),
+        limit_usd: limitUsd,
+        alert_at_percent: alertAtPercent,
+        created_at: now,
+        updated_at: now
+      };
+      upsertBudget(db, budget);
+      return ok(getBudgetStatuses(db).find((b) => b.id === budget.id) ?? budget);
+    }
+    const budgetMatch = path.match(/^\/api\/budgets\/(.+)$/);
+    if (budgetMatch && method === "DELETE") {
+      deleteBudget(db, decodeURIComponent(budgetMatch[1]));
+      return ok({ ok: true });
+    }
+    if (path === "/api/project-registry" && method === "GET") {
+      return ok(listProjects(db));
+    }
+    if (path === "/api/project-registry" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      const { basename } = await import("path");
+      const projPath = optionalString(body["path"])?.trim();
+      if (!projPath)
+        return err("path is required");
+      upsertProject(db, {
+        id: randomUUID2(),
+        path: projPath,
+        name: optionalString(body["name"]) ?? basename(projPath),
+        description: optionalString(body["description"]),
+        tags: stringArray(body["tags"]),
+        created_at: new Date().toISOString()
+      });
+      return ok({ ok: true });
+    }
+    const projMatch = path.match(/^\/api\/project-registry\/(.+)$/);
+    if (projMatch && method === "DELETE") {
+      deleteProject(db, decodeURIComponent(projMatch[1]));
+      return ok({ ok: true });
+    }
+    if (path === "/api/pricing" && method === "GET") {
+      return ok(listModelPricing(db));
+    }
+    if (path === "/api/pricing" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      const model = String(body["model"] ?? "").trim();
+      if (!model)
+        return err("model is required");
+      const input = finiteNumber(body["input_per_1m"]);
+      const output = finiteNumber(body["output_per_1m"]);
+      const cacheRead = finiteNumber(body["cache_read_per_1m"] ?? 0);
+      const cacheWrite = finiteNumber(body["cache_write_per_1m"] ?? 0);
+      const cacheWrite1h = finiteNumber(body["cache_write_1h_per_1m"] ?? 0);
+      const cacheStorage = finiteNumber(body["cache_storage_per_1m_hour"] ?? 0);
+      if ([input, output, cacheRead, cacheWrite, cacheWrite1h, cacheStorage].some((v) => v == null || v < 0)) {
+        return err("pricing values must be non-negative numbers");
+      }
+      const pricing = {
+        model,
+        input_per_1m: input,
+        output_per_1m: output,
+        cache_read_per_1m: cacheRead,
+        cache_write_per_1m: cacheWrite,
+        cache_write_1h_per_1m: cacheWrite1h,
+        cache_storage_per_1m_hour: cacheStorage,
+        updated_at: new Date().toISOString()
+      };
+      upsertModelPricing(db, pricing);
+      return ok(pricing);
+    }
+    const pricingMatch = path.match(/^\/api\/pricing\/(.+)$/);
+    if (pricingMatch && method === "DELETE") {
+      deleteModelPricing(db, decodeURIComponent(pricingMatch[1]));
+      return ok({ ok: true });
+    }
+    if (path === "/api/sync" && method === "POST") {
+      const body = await jsonBody(req) ?? {};
+      const sources = body["sources"] ?? "all";
+      if (!SYNC_SOURCES.includes(sources))
+        return err("invalid sync source");
+      const results = {};
+      if (sources === "all") {
+        try {
+          const { syncOpenProjectsRegistry } = await import("./open-projects-6z4pq6mx.js");
+          results["projects"] = await syncOpenProjectsRegistry(db);
+        } catch {}
+      }
+      const selected = sources === "all" ? {} : { [sources]: true };
+      const syncResult = await syncAll(db, selected);
+      Object.assign(results, syncResult);
+      try {
+        const { checkAndFireWebhooks } = await import("./webhooks-k4fh2t9c.js");
+        await checkAndFireWebhooks(db);
+      } catch {}
+      return ok(results);
+    }
+    if (path === "/api/ingest/receipts" && method === "GET") {
+      const params = url.searchParams;
+      if (params.getAll("idempotency_key").length !== 1 || params.getAll("body_hash").length !== 1 || [...params.keys()].some((k) => !["idempotency_key", "body_hash"].includes(k))) {
+        throw new IngestError(400, "INVALID_INGEST", "query", "expected exactly one idempotency_key and one body_hash");
+      }
+      return ok(reconcileIngestReceipt(db, params.get("idempotency_key"), params.get("body_hash"), { actorId }));
+    }
+    if (path === "/api/scan-receipts" && method === "GET") {
+      const limit = Number(url.searchParams.get("limit") ?? 100);
+      if (!Number.isInteger(limit) || limit < 1 || limit > 200)
+        return err("limit must be an integer from 1 to 200");
+      return ok(queryScanReceipts(db, { machine_id: url.searchParams.get("machine_id") ?? undefined, source: url.searchParams.get("source") ?? undefined, limit }));
+    }
+    if (path === "/api/ingest" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      const result = bulkIngest(db, body, { actorId });
+      try {
+        const { checkAndFireWebhooks } = await import("./webhooks-k4fh2t9c.js");
+        if (body["budget_mode"] !== "create")
+          await checkAndFireWebhooks(db);
+      } catch {}
+      return ok(result);
+    }
+    if (path === "/api/usage" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "month";
+      const agentParam = url.searchParams.get("agent") ?? undefined;
+      const agent = agentParam && isAgent(agentParam) ? agentParam : undefined;
+      return ok({
+        snapshots: queryUsageSnapshots(db, {
+          agent,
+          ...usageSnapshotFilterForPeriod(period)
+        }),
+        summary: querySummary(db, period, undefined, true, agent)
+      });
+    }
+    if (path === "/api/savings" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "month";
+      const agent = url.searchParams.get("agent") ?? undefined;
+      return ok(querySavingsSummary(db, period, agent && isAgent(agent) ? agent : undefined));
+    }
+    if (path === "/api/brief" && method === "GET") {
+      const since = url.searchParams.get("since") ?? undefined;
+      const machine = url.searchParams.get("machine") ?? undefined;
+      try {
+        return ok(buildBrief(db, { since, machine }));
+      } catch (error) {
+        const invalidSince = "--since must be a duration like 24h, 7d, 30m, 2w, or an ISO date";
+        if (error instanceof Error && error.message === invalidSince)
+          return err(invalidSince);
+        return err("brief_unavailable", 503);
+      }
+    }
+    if (path === "/api/projects/detail" && method === "GET") {
+      const q = url.searchParams.get("q")?.trim();
+      if (!q)
+        return err("q is required");
+      return ok(queryProjectDetail(db, q));
+    }
+    if (path === "/api/export" && method === "GET") {
+      const type = url.searchParams.get("type") ?? "sessions";
+      if (type !== "sessions" && type !== "requests")
+        return err("type must be sessions or requests");
+      const period = url.searchParams.get("period") ?? "month";
+      return ok(queryExportRows(db, type, period));
+    }
+    if (path === "/api/compare" && method === "GET") {
+      const from = url.searchParams.get("from")?.trim();
+      const to = url.searchParams.get("to")?.trim();
+      if (!from || !to)
+        return err("from and to are required (YYYY-MM-DD)");
+      return ok(queryRangeStats(db, from, to));
+    }
+    if (path === "/api/forecast" && method === "GET") {
+      return ok(queryForecast(db));
+    }
+    if (path === "/api/efficiency" && method === "GET") {
+      return ok(queryModelEfficiency(db));
+    }
+    if (path === "/api/requests" && method === "GET") {
+      const since = url.searchParams.get("since")?.trim();
+      if (!since)
+        return err("since is required (ISO timestamp)");
+      return ok(queryRequestsSince(db, since));
+    }
+    if (path === "/api/subscriptions" && method === "GET") {
+      return ok(listSubscriptions(db));
+    }
+    if (path === "/api/subscriptions" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      const provider = optionalString(body["provider"])?.trim();
+      const plan = optionalString(body["plan"])?.trim();
+      if (!provider)
+        return err("provider is required");
+      if (!plan)
+        return err("plan is required");
+      for (const field of ["account_key", "observed_station", "observed_at"]) {
+        const value = body[field];
+        if (value !== undefined && !(field !== "account_key" && value === null) && (typeof value !== "string" || !value.trim() || value.length > 256))
+          return err(`${field} must be nonempty text of at most 256 characters${field !== "account_key" ? " or null" : ""}`);
+      }
+      for (const field of ["fee_basis", "included_basis"]) {
+        if (body[field] !== undefined && !["unknown", "observed", "configured"].includes(String(body[field])))
+          return err(`${field} must be unknown, observed or configured`);
+      }
+      if (body["monthly_fee_usd"] === null || body["fee_usd"] === null)
+        return err("monthly_fee_usd must be a non-negative number; use fee_basis unknown for an unknown amount");
+      if (body["included_usage_usd"] === null)
+        return err("included_usage_usd must be a non-negative number; use included_basis unknown for an unknown amount");
+      const monthlyFee = body["monthly_fee_usd"] ?? body["fee_usd"] ?? 0;
+      const includedUsage = body["included_usage_usd"] ?? 0;
+      if (typeof monthlyFee !== "number" || !Number.isFinite(monthlyFee) || monthlyFee < 0)
+        return err("monthly_fee_usd must be a non-negative number");
+      if (typeof includedUsage !== "number" || !Number.isFinite(includedUsage) || includedUsage < 0)
+        return err("included_usage_usd must be a non-negative number");
+      const agent = optionalAgent(body["agent"]);
+      if (agent === undefined)
+        return err(AGENT_ERROR);
+      const now = new Date().toISOString();
+      const accountKey = optionalString(body["account_key"]) ?? "";
+      const observedAt = optionalString(body["observed_at"]) ?? (accountKey ? now : null);
+      const subscription = {
+        id: optionalString(body["id"])?.trim() || (accountKey ? subscriptionId({ provider, account_key: accountKey }) : randomUUID2()),
+        agent,
+        provider,
+        plan,
+        monthly_fee_usd: monthlyFee,
+        included_usage_usd: includedUsage,
+        billing_cycle_start: optionalString(body["billing_cycle_start"]),
+        reset_policy: optionalString(body["reset_policy"]) ?? "unknown",
+        account_key: accountKey,
+        observed_station: optionalString(body["observed_station"]),
+        observed_at: observedAt,
+        fee_basis: body["fee_basis"] ?? "unknown",
+        included_basis: body["included_basis"] ?? "unknown",
+        active: body["active"] === false || body["active"] === 0 ? 0 : 1,
+        created_at: optionalString(body["created_at"]) ?? now,
+        updated_at: observedAt ?? now
+      };
+      upsertSubscription(db, subscription);
+      return ok(db.get("SELECT * FROM subscriptions WHERE id = ?", subscription.id));
+    }
+    const subscriptionMatch = path.match(/^\/api\/subscriptions\/(.+)$/);
+    if (subscriptionMatch && method === "DELETE") {
+      deleteSubscription(db, decodeURIComponent(subscriptionMatch[1]));
+      return ok({ ok: true });
+    }
+    const sessionRequestsMatch = path.match(/^\/api\/sessions\/([^/]+)\/requests$/);
+    if (sessionRequestsMatch && method === "GET") {
+      const sessionId = decodeURIComponent(sessionRequestsMatch[1]);
+      const session = db.prepare(`SELECT * FROM economy_effective_sessions WHERE id = ? OR id LIKE ?`).get(sessionId, `${sessionId}%`);
+      if (!session)
+        return err("Session not found", 404);
+      const requests = db.prepare(`SELECT * FROM economy_effective_requests WHERE session_id = ? ORDER BY timestamp ASC`).all(session["id"]);
+      return ok(requests, { session_id: session["id"], count: requests.length });
+    }
+    if (path === "/api/goals" && method === "GET") {
+      return ok(getGoalStatuses(db));
+    }
+    if (path === "/api/goals" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      const period = body["period"] ?? "month";
+      if (!["day", "week", "month", "year"].includes(String(period)))
+        return err("period must be day, week, month, or year");
+      const limitUsd = finiteNumber(body["limit_usd"]);
+      if (limitUsd == null || limitUsd <= 0)
+        return err("limit_usd must be a positive number");
+      const agent = optionalAgent(body["agent"]);
+      if (agent === undefined)
+        return err(AGENT_ERROR);
+      const now = new Date().toISOString();
+      const goal = {
+        id: randomUUID2(),
+        period,
+        project_path: optionalString(body["project_path"]),
+        agent,
+        limit_usd: limitUsd,
+        created_at: now,
+        updated_at: now
+      };
+      upsertGoal(db, goal);
+      return ok(getGoalStatuses(db).find((g) => g.id === goal.id) ?? goal);
+    }
+    const goalMatch = path.match(/^\/api\/goals\/(.+)$/);
+    if (goalMatch && method === "DELETE") {
+      deleteGoal(db, decodeURIComponent(goalMatch[1]));
+      return ok({ ok: true });
+    }
+    if (path === "/api/feedback" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      const message = optionalString(body["message"])?.trim();
+      if (!message)
+        return err("message is required");
+      const email = optionalString(body["email"])?.trim() || null;
+      const rawCategory = optionalString(body["category"])?.trim() || "general";
+      if (!["bug", "feature", "general"].includes(rawCategory))
+        return err("category must be bug, feature, or general");
+      insertFeedback(db, {
+        message,
+        email,
+        category: rawCategory,
+        version: packageMetadata.version,
+        machine_id: getMachineId()
+      });
+      return ok({ ok: true });
+    }
+    return err("Not found", 404);
+  };
+}
+async function executeServiceOperation(db, operation) {
+  const request = new Request(`http://economy.invalid${operation.path}${operation.search}`, {
+    method: operation.method,
+    ...operation.body === null ? {} : { body: operation.body, headers: { "Content-Type": "application/json" } }
+  });
+  try {
+    const response = await createDataHandler(db, operation.actorId)(request);
+    return { status: response.status, body: await response.text() };
+  } catch (error) {
+    if (error instanceof IngestError)
+      return {
+        status: error.status,
+        body: JSON.stringify({ error: error.message, code: error.code, field: error.field, expected: error.expected })
+      };
+    throw error;
+  }
+}
+
+// src/server/service-admission.ts
+class ServiceAdmission {
+  capacity;
+  deadlineMs;
+  active = 0;
+  constructor(capacity, deadlineMs) {
+    this.capacity = capacity;
+    this.deadlineMs = deadlineMs;
+  }
+  async run(work) {
+    if (this.active >= this.capacity)
+      throw new Error("Economy authority is busy");
+    this.active++;
+    let timer;
+    try {
+      const operation = Promise.resolve().then(work).finally(() => {
+        this.active--;
+      });
+      return await Promise.race([
+        operation,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Economy authority timed out")), this.deadlineMs);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+// src/server/human-auth.ts
+var AUTHORITY = "https://api.hasna.com/identities/v1/auth/economy-authority";
+var identifier = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,255}$/.test(value);
+function parseHumanAuthBinding(raw) {
+  if (raw === undefined || raw === "")
+    return;
+  try {
+    const v = JSON.parse(raw);
+    if (!v || typeof v !== "object" || Array.isArray(v))
+      throw Error();
+    const b = v;
+    if (Object.keys(v).some((k) => !["tenantId", "principals", "authorityUrl"].includes(k)) || !identifier(b.tenantId) || !Array.isArray(b.principals) || !b.principals.length || b.principals.length > 100)
+      throw Error();
+    const seen = new Set;
+    for (const p of b.principals) {
+      if (!p || Object.keys(p).some((k) => !["subject", "scopes"].includes(k)) || !identifier(p.subject) || seen.has(p.subject) || !Array.isArray(p.scopes) || !p.scopes.length || p.scopes.length > 2 || p.scopes.some((s) => s !== "economy:read" && s !== "economy:write"))
+        throw Error();
+      seen.add(p.subject);
+    }
+    const url = new URL(b.authorityUrl ?? AUTHORITY);
+    if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash || url.pathname !== "/identities/v1/auth/economy-authority" && url.pathname !== "/v1/auth/economy-authority")
+      throw Error();
+    return { tenantId: b.tenantId, principals: b.principals.map((p) => ({ subject: p.subject, scopes: [...p.scopes] })), authorityUrl: url.href };
+  } catch {
+    throw new Error("Invalid ECONOMY_HUMAN_AUTH_BINDING; explicit tenant, principals and HTTPS authority are required");
+  }
+}
+function withHumanAuthentication(agent, binding, options = {}) {
+  const config = binding ? parseHumanAuthBinding(JSON.stringify(binding)) : undefined;
+  const fetcher = options.fetch ?? fetch;
+  const now = options.now ?? Date.now;
+  return { async authenticate(headers, context) {
+    const bearer = headers.get("authorization")?.match(/^Bearer ([^\s]+)$/i)?.[1];
+    if (headers.has("x-api-key") || !bearer || bearer.startsWith("hasna_"))
+      return agent.authenticate(headers, context);
+    if (bearer.length > 8192 || bearer.split(".").length !== 3)
+      return { ok: false, status: 401, reason: "invalid_human_token" };
+    if (!config)
+      return { ok: false, status: 503, reason: "human_auth_not_configured" };
+    const controller = new AbortController;
+    let timer;
+    try {
+      const operation = async () => {
+        const response = await fetcher(config.authorityUrl, { method: "GET", headers: { authorization: `Bearer ${bearer}`, accept: "application/json" }, redirect: "error", signal: controller.signal });
+        if (response.status === 401 || response.status === 403) {
+          response.body?.cancel().catch(() => {});
+          return { ok: false, status: response.status, reason: "human_authority_denied" };
+        }
+        if (!response.ok || !response.body) {
+          response.body?.cancel().catch(() => {});
+          throw Error();
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+          for (;; ) {
+            const { value, done } = await reader.read();
+            if (done)
+              break;
+            size += value.byteLength;
+            if (size > 16384)
+              throw Error();
+            chunks.push(value);
+          }
+        } finally {
+          reader.cancel().catch(() => {});
+        }
+        const data = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        if (data.active !== true || data.issuer !== "identities" || data.audience !== "economy" || data.tenant_id !== config.tenantId || !identifier(data.subject) || !identifier(data.session_id) || !identifier(data.token_id) || !Number.isSafeInteger(data.expires_at) || data.expires_at * 1000 <= now() || data.expires_at * 1000 > now() + 300000 || !Array.isArray(data.scopes) || data.scopes.some((s) => s !== "economy:read" && s !== "economy:write"))
+          return { ok: false, status: 403, reason: "human_binding_denied" };
+        const allowed = config.principals.find((p) => p.subject === data.subject);
+        if (!allowed)
+          return { ok: false, status: 403, reason: "human_binding_denied" };
+        const scopes = allowed.scopes.filter((s) => data.scopes.includes(s));
+        const required = context?.requiredScopes ?? ["economy:read"];
+        if (!scopes.length || !required.every((s) => scopes.includes(s)))
+          return { ok: false, status: 403, reason: "insufficient_scope" };
+        return { ok: true, status: 200, principal: { tid: config.tenantId, kid: `human:${data.subject}`, kind: "human", subject: data.subject, scopes, sessionId: data.session_id, expiresAt: data.expires_at } };
+      };
+      return await Promise.race([operation(), new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          controller.abort();
+          reject(Error());
+        }, 3000);
+      })]);
+    } catch {
+      return { ok: false, status: 503, reason: "human_authority_unavailable" };
+    } finally {
+      clearTimeout(timer);
+      controller.abort();
+    }
+  } };
+}
+
+// src/server/serve.ts
+function openApiDocument() {
+  const spec = openApiSpec;
+  return { ...spec, info: { ...spec["info"], version: packageMetadata.version } };
+}
+var CORS2 = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Economy-Token"
+};
+function json2(data, status = 200) {
+  return new Response(JSON.stringify(data), { status, headers: { "Content-Type": "application/json", ...CORS2 } });
+}
+function requiredScopesForRequest(method, path) {
+  if (method === "GET" && path === "/api/auth/session")
+    return [];
+  if (method === "GET" && path === "/api/ingest/receipts")
+    return ["economy:write"];
+  if (["POST", "PUT", "PATCH", "DELETE"].includes(method))
+    return ["economy:write"];
+  return;
+}
+async function boundedBody(req, limits) {
+  if (!req.body)
+    return null;
+  const reader = req.body.getReader();
+  const chunks = [];
+  let size = 0;
+  let timer;
+  try {
+    const read = async () => {
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          return Buffer.concat(chunks).toString("utf8");
+        size += value.byteLength;
+        if (size > limits.maxInputBytes)
+          throw new ServiceUnavailable("input_too_large", 413, "", "not_started");
+        chunks.push(value);
+      }
+    };
+    return await Promise.race([read(), new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new ServiceUnavailable("input_timeout", 408, "", "not_started")), limits.deadlineMs);
+    })]);
+  } finally {
+    clearTimeout(timer);
+    reader.cancel().catch(() => {});
+  }
+}
+function createHandler(target, options = {}) {
+  const limits = options.limits ?? serviceLimits();
+  const dispatcher = "dispatch" in target ? target : {
+    dispatch: async (operation, _signal, beforeStart) => {
+      await beforeStart?.();
+      return executeServiceOperation(target, operation);
+    }
+  };
+  const authority = new ServiceAdmission(32, Math.min(5000, limits.deadlineMs));
+  let readingBodies = 0;
+  return async function handler(req) {
+    const url = new URL(req.url);
+    const rawPath = url.pathname;
+    const path = rawPath.startsWith("/v1/") ? "/api" + rawPath.slice(3) : rawPath === "/v1" ? "/api" : rawPath;
+    const method = req.method;
+    if (method === "OPTIONS")
+      return new Response(null, { status: 204, headers: CORS2 });
+    if (method === "GET" && (rawPath === "/health" || rawPath === "/healthz")) {
+      return json2({ status: "ok", version: packageMetadata.version, backend: resolveEconomyServerBackend() });
+    }
+    if (method === "GET" && (rawPath === "/version" || rawPath === "/v1/version"))
+      return json2({ version: packageMetadata.version });
+    if (method === "GET" && (rawPath === "/ready" || rawPath === "/readyz")) {
+      try {
+        const result = options.readyCheck ? await authority.run(options.readyCheck) : { ready: true };
+        return json2(result.detail ? { ready: result.ready, reason: result.detail } : { ready: result.ready }, result.ready ? 200 : 503);
+      } catch {
+        return json2({ ready: false, reason: "storage_unreachable" }, 503);
+      }
+    }
+    if (method === "GET" && rawPath === "/openapi.json")
+      return json2(openApiDocument());
+    let actorId = "legacy";
+    let human = false;
+    let beforeStart;
+    if (options.authenticator) {
+      const headers = new Headers(req.headers);
+      const authenticate = () => authority.run(() => options.authenticator.authenticate(headers, {
+        method,
+        path: rawPath,
+        requiredScopes: requiredScopesForRequest(method, path)
+      }));
+      const actor = (decision2) => {
+        const principal = decision2.principal;
+        return principal && (principal.tid === null || typeof principal.tid === "string") && typeof principal.kid === "string" && principal.kid.length > 0 ? JSON.stringify([principal.tid, principal.kid]) : undefined;
+      };
+      let decision;
+      try {
+        decision = await authenticate();
+      } catch {
+        return json2({ error: "authentication_unavailable" }, 503);
+      }
+      if (!decision.ok)
+        return json2({ error: decision.reason ?? "unauthorized", message: decision.message }, decision.status || 401);
+      human = decision.principal?.kind === "human";
+      if (method === "GET" && path === "/api/auth/session") {
+        const p = decision.principal;
+        if (p?.kind !== "human")
+          return json2({ error: "human_principal_required" }, 403);
+        const response = json2({ data: { subject: p.subject, tenant_id: p.tid, scopes: p.scopes, session_id: p.sessionId, expires_at: p.expiresAt }, meta: {} });
+        response.headers.set("Cache-Control", "no-store");
+        return response;
+      }
+      const binding = actor(decision);
+      if (binding !== undefined)
+        actorId = binding;
+      else if (method === "POST" && path === "/api/ingest" || path === "/api/ingest/receipts")
+        return json2({ error: "authenticated_principal_required" }, 503);
+      beforeStart = async () => {
+        const fresh = await authenticate();
+        if (!fresh.ok)
+          throw new ServiceUnavailable(fresh.reason ?? "unauthorized", fresh.status || 401, "", "not_started");
+        if (actor(fresh) !== binding)
+          throw new ServiceUnavailable("principal_changed", 403, "", "not_started");
+      };
+    } else {
+      if (path === "/api/ingest/receipts")
+        return json2({ error: "authenticated_principal_required" }, 401);
+      if (!isAuthorizedRequest(req, path))
+        return json2({ error: "Unauthorized" }, 401);
+      beforeStart = async () => {
+        if (!isAuthorizedRequest(req, path))
+          throw new ServiceUnavailable("unauthorized", 401, "", "not_started");
+      };
+    }
+    if (path === "/health")
+      return json2({ data: { status: "ok", ts: new Date().toISOString() }, meta: {} });
+    const route = serviceRoute(method, path);
+    if (!route)
+      return json2({ error: "Not found" }, 404);
+    if (path.length + url.search.length > 8192)
+      return json2({ error: "input_too_large" }, 413);
+    try {
+      let body = null;
+      if (req.body) {
+        if (readingBodies >= limits.workers + limits.maxQueue)
+          return json2({ error: "service_busy", outcome: "not_started" }, 503);
+        readingBodies++;
+        try {
+          body = await boundedBody(req, limits);
+        } finally {
+          readingBodies--;
+        }
+      }
+      const result = await dispatcher.dispatch({ route, method, path, search: url.search, body, actorId }, req.signal, beforeStart);
+      return new Response(result.body, { status: result.status, headers: { "Content-Type": "application/json", ...CORS2, ...human ? { "Cache-Control": "no-store" } : {} } });
+    } catch (error) {
+      if (error instanceof ServiceUnavailable)
+        return json2({ error: error.code, operation_id: error.operationId || undefined, outcome: error.outcome }, error.status);
+      return json2({ error: "operation_failed", outcome: "unknown" }, 503);
+    }
+  };
+}
+function isLocalHost(host) {
+  return ["127.0.0.1", "localhost", "::1"].includes(host);
+}
+function startServer(port = 3456, options = {}) {
+  const cloud = options.db ? false : isPostgresBackend();
+  const hostname = options.hostname ?? (cloud ? process.env["ECONOMY_HOST"] ?? "0.0.0.0" : getServeBindHost());
+  const log = options.log ?? console.log;
+  const limits = serviceLimits();
+  const handlerOptions = { limits };
+  let pool;
+  let dispatcher;
+  if (cloud) {
+    const signingSecret = resolveSigningSecret();
+    if (!signingSecret && !isLocalHost(hostname))
+      throw new Error("economy-serve on a non-local host requires an API signing secret (HASNA_ECONOMY_API_SIGNING_KEY / API_KEY_SIGNING_SECRET)");
+    const max = Number(process.env["ECONOMY_PG_POOL_MAX"] ?? "5");
+    if (!Number.isSafeInteger(max) || max < 1 || max > 32)
+      throw new Error("Invalid ECONOMY_PG_POOL_MAX");
+    const timeout = Math.min(5000, limits.deadlineMs);
+    pool = createCloudPool(undefined, { max, connectionTimeoutMillis: timeout, query_timeout: timeout, statement_timeout: timeout });
+    const authPool = pool;
+    if (signingSecret) {
+      const keys = new ApiKeyStore(authClientFromPool(authPool));
+      keys.ensureSchema().catch(() => log("api_keys ensureSchema failed"));
+      handlerOptions.authenticator = withHumanAuthentication(verifyApiKey({
+        app: "economy",
+        signingSecret,
+        keyStatus: keys.keyStatus,
+        audit: (event) => log(JSON.stringify({ evt: "api_auth", outcome: event.outcome, kid: event.kid, reason: event.reason, path: event.path, status: event.status }))
+      }), parseHumanAuthBinding(process.env["ECONOMY_HUMAN_AUTH_BINDING"]));
+    }
+    handlerOptions.readyCheck = async () => {
+      try {
+        const res = await authPool.query("SELECT to_regclass($1) AS reg", ["public.requests"]);
+        return res.rows[0]?.reg ? { ready: true } : { ready: false, detail: "pending_migrations:requests" };
+      } catch {
+        return { ready: false, detail: "storage_unreachable" };
+      }
+    };
+    dispatcher = new AsyncServiceDispatcher({ kind: "postgresql", dsn: getCloudDatabaseUrl() }, limits);
+  } else if (!options.db) {
+    dispatcher = new AsyncServiceDispatcher({ kind: "sqlite" }, limits);
+  } else {
+    ensurePricingSeeded(options.db);
+  }
+  const apiHandler = createHandler(dispatcher ?? options.db, handlerOptions);
+  let server;
+  try {
+    server = Bun.serve({ port, hostname, fetch: apiHandler, maxRequestBodySize: limits.maxInputBytes });
+  } catch (error) {
+    dispatcher?.close();
+    pool?.end();
+    throw error;
+  }
+  const stop = server.stop.bind(server);
+  let stopping;
+  server.stop = (closeActiveConnections) => {
+    if (closeActiveConnections) {
+      stop(true);
+      dispatcher?.close().catch(() => {});
+    }
+    if (!stopping) {
+      let timer;
+      const drain = (async () => {
+        await stop(closeActiveConnections);
+        await dispatcher?.close();
+        await pool?.end();
+      })();
+      stopping = Promise.race([drain, new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          stop(true);
+          dispatcher?.close().catch(() => {});
+          reject(new Error("Economy server shutdown timed out"));
+        }, limits.deadlineMs + 5000);
+      })]).finally(() => clearTimeout(timer));
+    }
+    return stopping;
+  };
+  const address = `http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${server.port}`;
+  log(`economy-serve listening on ${address}`);
+  return server;
+}
+export {
+  startServer,
+  openApiDocument,
+  createHandler
+};