@hasna/economy 0.2.42 → 0.3.0

package/dist/server/index.js

@@ -21,8 +21,10 @@ var __require = import.meta.require;
 var exports_pricing = {};
 __export(exports_pricing, {
   normalizeModelName: () => normalizeModelName,
+  getPricingFromRows: () => getPricingFromRows,
   getPricingFromDb: () => getPricingFromDb,
   getPricing: () => getPricing,
+  estimateCostFromRows: () => estimateCostFromRows,
   ensurePricingSeeded: () => ensurePricingSeeded,
   computeCostFromDb: () => computeCostFromDb,
   computeCost: () => computeCost,
@@ -213,6 +215,25 @@ function computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens
     return 0;
   return computeCostWithPricing(model, pricing, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours);
 }
+function getPricingFromRows(rows, model) {
+  if (isFreeModel(model))
+    return FREE_PRICING;
+  for (const key of modelLookupKeys(model)) {
+    const row = rows.find((r) => r.model === key);
+    if (row)
+      return modelPricingFromDbRow(row);
+  }
+  const match = bestModelMatch(model, rows.map((r) => [r.model, r]));
+  if (!match)
+    return null;
+  return modelPricingFromDbRow(match);
+}
+function estimateCostFromRows(rows, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0, cacheWrite1hTokens = 0, cacheStorageTokenHours = 0) {
+  const pricing = getPricingFromRows(rows, model) ?? getPricing(model);
+  if (!pricing)
+    return 0;
+  return computeCostWithPricing(model, pricing, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours);
+}
 function computeCostWithPricing(model, pricing, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours) {
   if (isFreeModel(model))
     return 0;
@@ -1495,6 +1516,9 @@ function getIngestState(db, source, key) {
 function setIngestState(db, source, key, value) {
   db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES (?, ?, ?)`).run(source, key, value);
 }
+function queryRequestsSince(db, since) {
+  return db.prepare(`SELECT * FROM requests WHERE timestamp > ? ORDER BY timestamp ASC`).all(since);
+}
 function upsertBillingDaily(db, row) {
   db.prepare(`
     INSERT OR REPLACE INTO billing_daily (date, provider, description, cost_usd, updated_at)
@@ -1657,13 +1681,374 @@ function dedupeRequests(db) {
   }
   return removed;
 }
+function ingestSpecs() {
+  return [
+    {
+      table: "requests",
+      pk: ["id"],
+      columns: [
+        "id",
+        "agent",
+        "session_id",
+        "model",
+        "input_tokens",
+        "output_tokens",
+        "cache_read_tokens",
+        "cache_create_tokens",
+        "cache_create_5m_tokens",
+        "cache_create_1h_tokens",
+        "cost_usd",
+        "cost_basis",
+        "duration_ms",
+        "timestamp",
+        "source_request_id",
+        "machine_id",
+        "attribution_tag",
+        "account_key",
+        "account_tool",
+        "account_name",
+        "account_email",
+        "account_source",
+        "updated_at",
+        "synced_at"
+      ],
+      map: (r, now) => [
+        strOr(r["id"]),
+        strOr(r["agent"]),
+        strOr(r["session_id"]),
+        strOr(r["model"]),
+        numOr(r["input_tokens"]),
+        numOr(r["output_tokens"]),
+        numOr(r["cache_read_tokens"]),
+        numOr(r["cache_create_tokens"]),
+        numOr(r["cache_create_5m_tokens"] ?? r["cache_create_tokens"]),
+        numOr(r["cache_create_1h_tokens"]),
+        numOr(r["cost_usd"]),
+        strOr(r["cost_basis"], "estimated"),
+        numOr(r["duration_ms"]),
+        strOr(r["timestamp"]),
+        r["source_request_id"] == null ? null : strOr(r["source_request_id"]),
+        strOr(r["machine_id"]),
+        strOr(r["attribution_tag"]),
+        strOr(r["account_key"]),
+        strOr(r["account_tool"]),
+        strOr(r["account_name"]),
+        strOr(r["account_email"]),
+        strOr(r["account_source"]),
+        strOr(r["updated_at"], now),
+        strOr(r["synced_at"])
+      ]
+    },
+    {
+      table: "sessions",
+      pk: ["id"],
+      columns: [
+        "id",
+        "agent",
+        "project_path",
+        "project_name",
+        "started_at",
+        "ended_at",
+        "total_cost_usd",
+        "total_tokens",
+        "request_count",
+        "machine_id",
+        "attribution_tag",
+        "account_key",
+        "account_tool",
+        "account_name",
+        "account_email",
+        "account_source",
+        "updated_at",
+        "synced_at"
+      ],
+      map: (r, now) => [
+        strOr(r["id"]),
+        strOr(r["agent"]),
+        strOr(r["project_path"]),
+        strOr(r["project_name"]),
+        strOr(r["started_at"]),
+        r["ended_at"] == null ? null : strOr(r["ended_at"]),
+        numOr(r["total_cost_usd"]),
+        numOr(r["total_tokens"]),
+        numOr(r["request_count"]),
+        strOr(r["machine_id"]),
+        strOr(r["attribution_tag"]),
+        strOr(r["account_key"]),
+        strOr(r["account_tool"]),
+        strOr(r["account_name"]),
+        strOr(r["account_email"]),
+        strOr(r["account_source"]),
+        strOr(r["updated_at"], now),
+        strOr(r["synced_at"])
+      ]
+    },
+    {
+      table: "projects",
+      pk: ["id"],
+      columns: ["id", "path", "name", "description", "tags", "created_at"],
+      map: (r) => [
+        strOr(r["id"]),
+        strOr(r["path"]),
+        strOr(r["name"]),
+        r["description"] == null ? null : strOr(r["description"]),
+        typeof r["tags"] === "string" ? r["tags"] : JSON.stringify(r["tags"] ?? []),
+        strOr(r["created_at"])
+      ]
+    },
+    {
+      table: "budgets",
+      pk: ["id"],
+      columns: ["id", "project_path", "agent", "period", "limit_usd", "alert_at_percent", "created_at", "updated_at"],
+      map: (r) => [
+        strOr(r["id"]),
+        r["project_path"] == null ? null : strOr(r["project_path"]),
+        r["agent"] == null ? null : strOr(r["agent"]),
+        strOr(r["period"]),
+        numOr(r["limit_usd"]),
+        numOr(r["alert_at_percent"]),
+        strOr(r["created_at"]),
+        strOr(r["updated_at"])
+      ]
+    },
+    {
+      table: "goals",
+      pk: ["id"],
+      columns: ["id", "period", "project_path", "agent", "limit_usd", "created_at", "updated_at"],
+      map: (r) => [
+        strOr(r["id"]),
+        strOr(r["period"]),
+        r["project_path"] == null ? null : strOr(r["project_path"]),
+        r["agent"] == null ? null : strOr(r["agent"]),
+        numOr(r["limit_usd"]),
+        strOr(r["created_at"]),
+        strOr(r["updated_at"])
+      ]
+    },
+    {
+      table: "billing_daily",
+      pk: ["date", "provider", "description"],
+      columns: ["date", "provider", "description", "cost_usd", "updated_at"],
+      map: (r) => [strOr(r["date"]), strOr(r["provider"]), strOr(r["description"]), numOr(r["cost_usd"]), strOr(r["updated_at"])]
+    },
+    {
+      table: "model_pricing",
+      pk: ["model"],
+      columns: [
+        "model",
+        "input_per_1m",
+        "output_per_1m",
+        "cache_read_per_1m",
+        "cache_write_per_1m",
+        "cache_write_1h_per_1m",
+        "cache_storage_per_1m_hour",
+        "updated_at"
+      ],
+      map: (r) => [
+        strOr(r["model"]),
+        numOr(r["input_per_1m"]),
+        numOr(r["output_per_1m"]),
+        numOr(r["cache_read_per_1m"]),
+        numOr(r["cache_write_per_1m"]),
+        numOr(r["cache_write_1h_per_1m"]),
+        numOr(r["cache_storage_per_1m_hour"]),
+        strOr(r["updated_at"])
+      ]
+    },
+    {
+      table: "subscriptions",
+      pk: ["id"],
+      columns: [
+        "id",
+        "agent",
+        "provider",
+        "plan",
+        "monthly_fee_usd",
+        "included_usage_usd",
+        "billing_cycle_start",
+        "reset_policy",
+        "active",
+        "created_at",
+        "updated_at"
+      ],
+      map: (r) => [
+        strOr(r["id"]),
+        r["agent"] == null ? null : strOr(r["agent"]),
+        strOr(r["provider"]),
+        strOr(r["plan"]),
+        numOr(r["monthly_fee_usd"]),
+        numOr(r["included_usage_usd"]),
+        r["billing_cycle_start"] == null ? null : strOr(r["billing_cycle_start"]),
+        strOr(r["reset_policy"], "monthly"),
+        numOr(r["active"], 1),
+        strOr(r["created_at"]),
+        strOr(r["updated_at"])
+      ]
+    },
+    {
+      table: "usage_snapshots",
+      pk: ["id"],
+      columns: ["id", "agent", "date", "metric", "value", "unit", "machine_id", "updated_at"],
+      map: (r, now) => [
+        strOr(r["id"], `${strOr(r["agent"])}-${strOr(r["date"])}-${strOr(r["metric"])}-${strOr(r["machine_id"])}`),
+        strOr(r["agent"]),
+        strOr(r["date"]),
+        strOr(r["metric"]),
+        numOr(r["value"]),
+        strOr(r["unit"]),
+        strOr(r["machine_id"]),
+        strOr(r["updated_at"], now)
+      ]
+    }
+  ];
+}
+function bulkIngest(db, body) {
+  const now = new Date().toISOString();
+  const ingested = {};
+  for (const spec of ingestSpecs()) {
+    const raw = body[spec.table];
+    if (!Array.isArray(raw) || raw.length === 0)
+      continue;
+    const cols = spec.columns;
+    const pkIdx = spec.pk.map((k) => cols.indexOf(k));
+    const deduped = new Map;
+    for (const row of raw) {
+      const values = spec.map(row, now);
+      const key = pkIdx.map((i) => String(values[i])).join("\x00");
+      deduped.set(key, values);
+    }
+    const rows = [...deduped.values()];
+    const updateCols = cols.filter((c) => !spec.pk.includes(c));
+    const conflictAction = updateCols.length ? `DO UPDATE SET ${updateCols.map((c) => `"${c}" = excluded."${c}"`).join(", ")}` : "DO NOTHING";
+    const colList = cols.map((c) => `"${c}"`).join(", ");
+    const conflict = spec.pk.map((c) => `"${c}"`).join(", ");
+    const chunkRows = Math.max(1, Math.floor(20000 / cols.length));
+    const rowPlaceholder = `(${cols.map(() => "?").join(", ")})`;
+    for (let i = 0;i < rows.length; i += chunkRows) {
+      const chunk = rows.slice(i, i + chunkRows);
+      const valuesSql = chunk.map(() => rowPlaceholder).join(", ");
+      const sql = `INSERT INTO ${spec.table} (${colList}) VALUES ${valuesSql} ON CONFLICT (${conflict}) ${conflictAction}`;
+      const params = [];
+      for (const values of chunk)
+        params.push(...values);
+      db.prepare(sql).run(...params);
+    }
+    ingested[spec.table] = rows.length;
+  }
+  const total = Object.values(ingested).reduce((a, b) => a + b, 0);
+  return { ingested, total };
+}
+var numOr = (v, d = 0) => {
+  if (v == null)
+    return d;
+  const num = Number(v);
+  return Number.isFinite(num) ? num : d;
+}, strOr = (v, d = "") => v == null ? d : String(v);
 var init_database = () => {};
 
+// src/db/sync-pg.ts
+import { Worker, MessageChannel, receiveMessageOnPort } from "worker_threads";
+import { fileURLToPath } from "url";
+import { dirname, join as join9 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { translateSql, translateParams } from "@hasna/cloud";
+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 candidates = [
+    join9(here, "pg-sync-worker.ts"),
+    join9(here, "pg-sync-worker.js"),
+    join9(here, "..", "db", "pg-sync-worker.js")
+  ];
+  for (const candidate of candidates)
+    if (existsSync10(candidate))
+      return candidate;
+  return candidates[0];
+}
+
+class SyncPgAdapter {
+  worker;
+  port;
+  counter = 0;
+  constructor(dsn) {
+    const workerPath = resolveWorkerPath();
+    this.worker = new Worker(workerPath, { workerData: { dsn } });
+    this.worker.on("error", (err) => console.error(JSON.stringify({ evt: "pg_worker_error", message: err.message })));
+    const channel = new MessageChannel;
+    this.port = channel.port1;
+    this.worker.postMessage({ type: "init", port: channel.port2 }, [channel.port2]);
+  }
+  query(sql, params) {
+    const pgSql = translateSqliteDates(translateSql(sql, "pg"));
+    const pgParams = translateParams(params);
+    const id = ++this.counter;
+    const signal = new SharedArrayBuffer(4);
+    const sig = new Int32Array(signal);
+    Atomics.store(sig, 0, 0);
+    this.worker.postMessage({ id, sql: pgSql, params: pgParams, signal });
+    Atomics.wait(sig, 0, 0);
+    let received = receiveMessageOnPort(this.port);
+    for (let attempt = 0;!received && attempt < 1e6; attempt++)
+      received = receiveMessageOnPort(this.port);
+    if (!received)
+      throw new Error("SyncPgAdapter: no reply from worker");
+    const reply = received.message;
+    if (!reply.ok)
+      throw new Error(reply.error);
+    return { rows: reply.rows, rowCount: reply.rowCount };
+  }
+  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) {
+    const self = this;
+    return {
+      run: (...params) => self.run(sql, ...params),
+      get: (...params) => self.get(sql, ...params),
+      all: (...params) => self.all(sql, ...params),
+      finalize: () => {}
+    };
+  }
+  transaction(fn) {
+    return fn();
+  }
+  close() {
+    this.worker.terminate();
+  }
+}
+var init_sync_pg = () => {};
+
 // src/db/pg-migrations.ts
-var exports_pg_migrations = {};
-__export(exports_pg_migrations, {
-  PG_MIGRATIONS: () => PG_MIGRATIONS
-});
 var PG_MIGRATIONS;
 var init_pg_migrations = __esm(() => {
   PG_MIGRATIONS = [
@@ -1843,10 +2228,103 @@ var init_pg_migrations = __esm(() => {
     `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_sessions_account ON sessions(account_key)`,
+    `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`
   ];
 });
 
+// src/db/cloud.ts
+var exports_cloud = {};
+__export(exports_cloud, {
+  resolveSigningSecret: () => resolveSigningSecret,
+  openCloudDatabase: () => openCloudDatabase,
+  isCloudMode: () => isCloudMode,
+  getCloudDatabaseUrl: () => getCloudDatabaseUrl,
+  createCloudPool: () => createCloudPool,
+  cloudMigrations: () => cloudMigrations,
+  authClientFromPool: () => authClientFromPool
+});
+import pg from "pg";
+function getCloudDatabaseUrl() {
+  return process.env["HASNA_ECONOMY_DATABASE_URL"]?.trim() || process.env["ECONOMY_DATABASE_URL"]?.trim() || process.env["DATABASE_URL"]?.trim() || undefined;
+}
+function isCloudMode() {
+  const mode = process.env["HASNA_ECONOMY_STORAGE_MODE"]?.trim().toLowerCase();
+  if (mode === "cloud")
+    return true;
+  if (mode === "local")
+    return false;
+  return Boolean(getCloudDatabaseUrl());
+}
+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 openCloudDatabase(dsn = getCloudDatabaseUrl()) {
+  if (!dsn) {
+    throw new Error("economy cloud mode requires a Postgres DSN: set HASNA_ECONOMY_DATABASE_URL (or ECONOMY_DATABASE_URL / DATABASE_URL)");
+  }
+  return new SyncPgAdapter(dsn);
+}
+function createCloudPool(dsn = getCloudDatabaseUrl()) {
+  if (!dsn)
+    throw new Error("economy cloud mode requires a Postgres DSN (HASNA_ECONOMY_DATABASE_URL)");
+  const ssl = dsn.includes("sslmode=require") || dsn.includes("ssl=true") ? { rejectUnauthorized: false } : undefined;
+  const pool = new pg.Pool({ connectionString: dsn, ssl, max: Number(process.env["ECONOMY_PG_POOL_MAX"] ?? "5"), connectionTimeoutMillis: 1e4 });
+  pool.on("error", (err) => {
+    console.error(JSON.stringify({ evt: "pg_pool_error", message: err.message }));
+  });
+  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);
+    }
+  };
+}
+function cloudMigrations() {
+  return PG_MIGRATIONS;
+}
+var init_cloud = __esm(() => {
+  init_sync_pg();
+  init_pg_migrations();
+});
+
 // src/ingest/billing.ts
 var exports_billing = {};
 __export(exports_billing, {
@@ -2143,15 +2621,15 @@ var init_open_projects = __esm(() => {
 });
 
 // src/lib/config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname, join as join9 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, join as join10 } from "path";
 function getConfigPath() {
-  return process.env["HASNA_ECONOMY_CONFIG_PATH"] ?? join9(getDataDir(), "config.json");
+  return process.env["HASNA_ECONOMY_CONFIG_PATH"] ?? join10(getDataDir(), "config.json");
 }
 function loadConfig() {
   try {
     const configPath = getConfigPath();
-    if (existsSync10(configPath)) {
+    if (existsSync11(configPath)) {
       const raw = readFileSync10(configPath, "utf-8");
       return { ...DEFAULTS, ...JSON.parse(raw) };
     }
@@ -3904,157 +4382,10 @@ async function ingestCodexQuota(db, verbose = false) {
 
 // src/lib/sync-all.ts
 init_database();
-
-// src/lib/cloud-sync.ts
-init_database();
-
-// src/lib/package-metadata.ts
-import { readFileSync as readFileSync8 } from "fs";
-var cachedMetadata = null;
-function getPackageMetadata() {
-  if (cachedMetadata)
-    return cachedMetadata;
-  const raw = readFileSync8(new URL("../../package.json", import.meta.url), "utf8");
-  const parsed = JSON.parse(raw);
-  cachedMetadata = {
-    name: parsed.name ?? "@hasna/economy",
-    version: parsed.version ?? "0.0.0"
-  };
-  return cachedMetadata;
-}
-var packageMetadata = getPackageMetadata();
-
-// src/lib/cloud-sync.ts
-var CLOUD_TABLES = [
-  "requests",
-  "sessions",
-  "projects",
-  "budgets",
-  "goals",
-  "model_pricing",
-  "billing_daily",
-  "subscriptions",
-  "usage_snapshots",
-  "savings_daily",
-  "machines",
-  "ingest_state"
-];
-function getCloudDatabaseUrl() {
-  return process.env["ECONOMY_CLOUD_DATABASE_URL"] ?? process.env["HASNA_ECONOMY_CLOUD_DATABASE_URL"] ?? null;
-}
-function isCloudAutoEnabled() {
-  return process.env["ECONOMY_CLOUD_AUTO"] === "1" || process.env["ECONOMY_CLOUD_AUTO"] === "true";
-}
-function getCloudPullIntervalMinutes() {
-  const raw = process.env["ECONOMY_CLOUD_PULL_INTERVAL"];
-  if (!raw)
-    return 15;
-  const n = Number(raw);
-  return Number.isFinite(n) && n > 0 ? n : 15;
-}
-async function getCloudPg() {
-  const url = getCloudDatabaseUrl();
-  if (!url) {
-    throw new Error("Missing ECONOMY_CLOUD_DATABASE_URL (or HASNA_ECONOMY_CLOUD_DATABASE_URL)");
-  }
-  const { PgAdapterAsync } = await import("@hasna/cloud");
-  return new PgAdapterAsync(url);
-}
-async function runCloudMigrations(cloud) {
-  const { PG_MIGRATIONS: PG_MIGRATIONS2 } = await Promise.resolve().then(() => (init_pg_migrations(), exports_pg_migrations));
-  for (const sql of PG_MIGRATIONS2) {
-    await cloud.run(sql);
-  }
-}
-async function cloudPush(opts) {
-  const { syncPush, SqliteAdapter } = await import("@hasna/cloud");
-  const cloud = await getCloudPg();
-  const local = new SqliteAdapter(getDbPath());
-  await runCloudMigrations(cloud);
-  const tables = opts?.tables ?? [...CLOUD_TABLES];
-  const results = await syncPush(local, cloud, { tables, conflictColumn: "updated_at" });
-  const rows = results.reduce((s, r) => s + r.rowsWritten, 0);
-  touchMachineRegistry(local, "push");
-  local.close();
-  await cloud.close();
-  return { rows, machine: getMachineId() };
-}
-async function cloudPull(opts) {
-  const { syncPull, SqliteAdapter } = await import("@hasna/cloud");
-  const cloud = await getCloudPg();
-  const local = new SqliteAdapter(getDbPath());
-  await runCloudMigrations(cloud);
-  const tables = opts?.tables ?? [...CLOUD_TABLES];
-  const results = await syncPull(cloud, local, { tables, conflictColumn: "updated_at" });
-  const rows = results.reduce((s, r) => s + r.rowsWritten, 0);
-  touchMachineRegistry(local, "pull");
-  local.close();
-  await cloud.close();
-  setLastCloudPull();
-  return { rows, machine: getMachineId() };
-}
-function setLastCloudPull(at = new Date().toISOString()) {
-  const db = openDatabase();
-  db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES ('cloud', 'last_pull_at', ?)`).run(at);
-}
-function getLastCloudPull() {
-  const db = openDatabase();
-  const row = db.prepare(`SELECT value FROM ingest_state WHERE source = 'cloud' AND key = 'last_pull_at'`).get();
-  return row?.value ?? null;
-}
-function shouldPullFromCloud() {
-  if (!getCloudDatabaseUrl())
-    return false;
-  const last = getLastCloudPull();
-  if (!last)
-    return true;
-  const ageMs = Date.now() - new Date(last).getTime();
-  return ageMs > getCloudPullIntervalMinutes() * 60000;
-}
-async function maybePullFromCloud() {
-  if (!shouldPullFromCloud())
-    return false;
-  try {
-    await cloudPull();
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function maybePushAfterIngest() {
-  if (!isCloudAutoEnabled() || !getCloudDatabaseUrl())
-    return false;
-  try {
-    await cloudPush();
-    return true;
-  } catch {
-    return false;
-  }
-}
-function touchMachineRegistry(db, direction) {
-  const now = new Date().toISOString();
-  const machine = getMachineId();
-  db.prepare(`
-    INSERT INTO machines (machine_id, hostname, last_seen_at, last_push_at, last_pull_at, economy_version, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(machine_id) DO UPDATE SET
-      hostname = excluded.hostname,
-      last_seen_at = excluded.last_seen_at,
-      last_push_at = CASE WHEN ? = 'push' THEN excluded.last_push_at ELSE machines.last_push_at END,
-      last_pull_at = CASE WHEN ? = 'pull' THEN excluded.last_pull_at ELSE machines.last_pull_at END,
-      economy_version = excluded.economy_version,
-      updated_at = excluded.updated_at
-  `).run(machine, machine, now, direction === "push" ? now : null, direction === "pull" ? now : null, packageMetadata.version, now, direction, direction);
-}
-
-// src/lib/sync-all.ts
 async function syncAll(db, opts = {}) {
   const anySpecific = Boolean(opts.claude || opts.takumi || opts.codex || opts.gemini || opts.opencode || opts.cursor || opts.pi || opts.hermes);
   const all = !anySpecific;
-  const useCloud = opts.cloud !== false;
-  if (useCloud)
-    await maybePullFromCloud();
-  const result = { deduped: 0, cloudPulled: false, cloudPushed: false };
+  const result = { deduped: 0 };
   if (all || opts.claude) {
     result.claude = await ingestClaude(db, opts.verbose);
     result.claudeQuota = await ingestClaudeQuota(db, opts.verbose);
@@ -4077,158 +4408,2505 @@ async function syncAll(db, opts = {}) {
     result.hermes = await ingestHermes(db, opts.verbose);
   if (opts.dedupe !== false)
     result.deduped = dedupeRequests(db);
-  if (useCloud)
-    result.cloudPushed = await maybePushAfterIngest();
   return result;
 }
 
-// src/lib/periods.ts
-function ymd(date) {
-  return date.toISOString().substring(0, 10);
-}
-function usageSnapshotFilterForPeriod(period) {
-  const now = new Date;
-  switch (period) {
-    case "today":
-      return { date: ymd(now) };
-    case "yesterday": {
-      const yesterday = new Date(now);
-      yesterday.setUTCDate(yesterday.getUTCDate() - 1);
-      return { date: ymd(yesterday) };
-    }
-    case "week": {
-      const weekAgo = new Date(now);
-      weekAgo.setUTCDate(weekAgo.getUTCDate() - 7);
-      return { since: ymd(weekAgo) };
-    }
-    case "month":
-      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))) };
-    case "year":
-      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), 0, 1))) };
-    case "all":
-      return {};
-  }
-}
-
-// src/lib/billing-diff.ts
+// src/lib/brief.ts
 init_database();
-var PROVIDER_TO_AGENT = {
-  anthropic: "claude",
-  openai: "codex",
-  gemini: "gemini",
-  google: "gemini"
+var ZERO_REQUEST_TOTALS = {
+  sessions: 0,
+  request_sessions: 0,
+  requests: 0,
+  input_tokens: 0,
+  output_tokens: 0,
+  cache_read_tokens: 0,
+  cache_create_tokens: 0,
+  cache_create_5m_tokens: 0,
+  cache_create_1h_tokens: 0,
+  total_tokens: 0,
+  cost_usd: 0,
+  last_active: null
 };
-function queryBillingDiff(db, period, thresholdPct = 15) {
-  const estimated = querySummary(db, period, undefined, true);
-  const actual = queryBillingSummary(db, period);
-  const delta = estimated.total_usd - actual.total_usd;
-  const deltaPct = actual.total_usd > 0 ? delta / actual.total_usd * 100 : 0;
-  const agentRows = db.prepare(`
-    SELECT agent, COALESCE(SUM(cost_usd), 0) as estimated_usd
-    FROM requests
-    WHERE ${periodWhere3(period, "timestamp")}
-    GROUP BY agent
-  `).all();
-  const by_agent = agentRows.map((row) => {
-    const provider = Object.entries(PROVIDER_TO_AGENT).find(([, a]) => a === row.agent)?.[0];
-    const actualUsd = provider ? actual.by_provider[provider] ?? 0 : 0;
-    const rowDelta = row.estimated_usd - actualUsd;
-    const rowPct = actualUsd > 0 ? rowDelta / actualUsd * 100 : 0;
-    return {
-      agent: row.agent,
-      estimated_usd: row.estimated_usd,
-      actual_usd: actualUsd,
-      delta_usd: rowDelta,
-      delta_pct: rowPct
-    };
-  }).sort((a, b) => Math.abs(b.delta_usd) - Math.abs(a.delta_usd));
-  return {
-    period,
-    estimated_usd: estimated.total_usd,
-    actual_usd: actual.total_usd,
-    delta_usd: delta,
-    delta_pct: deltaPct,
-    threshold_pct: thresholdPct,
-    is_alert: Math.abs(deltaPct) > thresholdPct,
-    by_agent,
-    by_provider: actual.by_provider
-  };
+var ZERO_SESSION_TOTALS = {
+  sessions: 0,
+  requests: 0,
+  total_tokens: 0,
+  cost_usd: 0,
+  last_active: null
+};
+function formatAge(timestamp, now) {
+  if (!timestamp)
+    return "never";
+  const t = new Date(timestamp).getTime();
+  if (!Number.isFinite(t))
+    return "unknown";
+  const ageMs = Math.max(0, now.getTime() - t);
+  const minutes = Math.floor(ageMs / 60000);
+  if (minutes < 1)
+    return "<1m";
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48)
+    return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+function machineFilter(machine) {
+  if (!machine || machine === "all")
+    return;
+  return machine;
 }
-function periodWhere3(period, column) {
-  switch (period) {
-    case "today":
-      return `DATE(${column}) = DATE('now')`;
-    case "yesterday":
-      return `DATE(${column}) = DATE('now', '-1 day')`;
-    case "week":
-      return `${column} >= DATE('now', 'weekday 0', '-7 days')`;
-    case "month":
-      return `${column} >= DATE('now', 'start of month')`;
-    case "year":
-      return `${column} >= DATE('now', 'start of year')`;
-    case "all":
-      return "1=1";
-  }
+function requestPeriodWhere2(period) {
+  if (period === "today")
+    return `DATE(timestamp) = DATE('now')`;
+  return `timestamp >= DATE('now', 'weekday 0', '-7 days')`;
 }
-
-// src/server/serve.ts
-init_database();
-
-// src/lib/serve-auth.ts
-function getServeApiToken() {
-  return process.env["ECONOMY_API_TOKEN"] ?? process.env["HASNA_ECONOMY_API_TOKEN"];
+function sessionPeriodWhere2(period) {
+  if (period === "today")
+    return `DATE(started_at) = DATE('now')`;
+  return `started_at >= DATE('now', 'weekday 0', '-7 days')`;
 }
-function getServeBindHost() {
-  const explicit = process.env["ECONOMY_BIND"] ?? process.env["ECONOMY_HOST"];
-  if (explicit)
-    return explicit;
-  return getServeApiToken() ? "127.0.0.1" : "0.0.0.0";
+function baseRequestTotals(row) {
+  return {
+    ...ZERO_REQUEST_TOTALS,
+    ...row,
+    sessions: Number(row?.request_sessions ?? row?.sessions ?? 0),
+    request_sessions: Number(row?.request_sessions ?? row?.sessions ?? 0),
+    requests: Number(row?.requests ?? 0),
+    input_tokens: Number(row?.input_tokens ?? 0),
+    output_tokens: Number(row?.output_tokens ?? 0),
+    cache_read_tokens: Number(row?.cache_read_tokens ?? 0),
+    cache_create_tokens: Number(row?.cache_create_tokens ?? 0),
+    cache_create_5m_tokens: Number(row?.cache_create_5m_tokens ?? 0),
+    cache_create_1h_tokens: Number(row?.cache_create_1h_tokens ?? 0),
+    total_tokens: Number(row?.total_tokens ?? 0),
+    cost_usd: Number(row?.cost_usd ?? 0),
+    last_active: row?.last_active ?? null
+  };
 }
-function isAuthorizedRequest(req, path) {
-  const token = getServeApiToken();
-  if (!token)
-    return true;
-  if (path === "/health")
-    return true;
-  const auth = req.headers.get("Authorization");
-  if (auth === `Bearer ${token}`)
-    return true;
-  if (req.headers.get("X-Economy-Token") === token)
-    return true;
-  return false;
+function baseSessionTotals(row) {
+  return {
+    sessions: Number(row?.sessions ?? 0),
+    requests: Number(row?.requests ?? 0),
+    total_tokens: Number(row?.total_tokens ?? 0),
+    cost_usd: Number(row?.cost_usd ?? 0),
+    last_active: row?.last_active ?? null
+  };
 }
-
-// src/server/serve.ts
-import { randomUUID } from "crypto";
-import { existsSync as existsSync11 } from "fs";
-import { resolve, sep } from "path";
-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];
-var DEFAULT_DASHBOARD_DIR = new URL("../../dashboard/dist", import.meta.url).pathname;
-function json(data, status = 200) {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json", ...CORS }
-  });
+function latestTimestamp(...values) {
+  return values.filter(Boolean).sort().at(-1) ?? null;
 }
-function ok(data, meta) {
-  return json({ data, meta: meta ?? {} });
+function combineTotals(requests, sessions) {
+  return {
+    sessions: requests.request_sessions + sessions.sessions,
+    requests: requests.requests + sessions.requests,
+    input_tokens: requests.input_tokens,
+    output_tokens: requests.output_tokens,
+    cache_read_tokens: requests.cache_read_tokens,
+    cache_create_tokens: requests.cache_create_tokens,
+    cache_create_5m_tokens: requests.cache_create_5m_tokens,
+    cache_create_1h_tokens: requests.cache_create_1h_tokens,
+    total_tokens: requests.total_tokens + sessions.total_tokens,
+    cost_usd: requests.cost_usd + sessions.cost_usd,
+    last_active: latestTimestamp(requests.last_active, sessions.last_active)
+  };
 }
-function err(message, status = 400) {
-  return json({ error: message }, status);
+function emptyTotals() {
+  return combineTotals(ZERO_REQUEST_TOTALS, ZERO_SESSION_TOTALS);
 }
-function normalizeBudgetPeriod(value) {
-  switch (value) {
-    case "day":
-    case "daily":
-      return "daily";
-    case "week":
-    case "weekly":
+function requestTotalsSql(where, machine) {
+  const params = [];
+  let machineClause = "";
+  if (machine) {
+    machineClause = " AND machine_id = ?";
+    params.push(machine);
+  }
+  return {
+    sql: `
+      SELECT
+        COUNT(DISTINCT session_id) as request_sessions,
+        COUNT(*) as requests,
+        COALESCE(SUM(input_tokens), 0) as input_tokens,
+        COALESCE(SUM(output_tokens), 0) as output_tokens,
+        COALESCE(SUM(cache_read_tokens), 0) as cache_read_tokens,
+        COALESCE(SUM(cache_create_tokens), 0) as cache_create_tokens,
+        COALESCE(SUM(COALESCE(cache_create_5m_tokens, cache_create_tokens)), 0) as cache_create_5m_tokens,
+        COALESCE(SUM(COALESCE(cache_create_1h_tokens, 0)), 0) as cache_create_1h_tokens,
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+        COALESCE(SUM(cost_usd), 0) as cost_usd,
+        MAX(timestamp) as last_active
+      FROM requests
+      WHERE ${where}${machineClause}
+    `,
+    params
+  };
+}
+function sessionOnlyTotalsSql(where, machine) {
+  const params = [];
+  let machineClause = "";
+  if (machine) {
+    machineClause = " AND machine_id = ?";
+    params.push(machine);
+  }
+  return {
+    sql: `
+      SELECT
+        COUNT(*) as sessions,
+        COALESCE(SUM(request_count), 0) as requests,
+        COALESCE(SUM(total_tokens), 0) as total_tokens,
+        COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+        MAX(started_at) as last_active
+      FROM sessions
+      WHERE ${where}${machineClause}
+        AND NOT EXISTS (SELECT 1 FROM requests r WHERE r.session_id = sessions.id)
+    `,
+    params
+  };
+}
+function queryRequestTotals(db, where, params, machine) {
+  const q = requestTotalsSql(where, machine);
+  return baseRequestTotals(db.prepare(q.sql).get(...params, ...q.params));
+}
+function querySessionOnlyTotals(db, where, params, machine) {
+  const q = sessionOnlyTotalsSql(where, machine);
+  return baseSessionTotals(db.prepare(q.sql).get(...params, ...q.params));
+}
+function queryPeriodTotals(db, period, machine) {
+  const summary = querySummary(db, period, machine);
+  const requests = queryRequestTotals(db, requestPeriodWhere2(period), [], machine);
+  const sessions = querySessionOnlyTotals(db, sessionPeriodWhere2(period), [], machine);
+  const totals = combineTotals(requests, sessions);
+  return {
+    ...totals,
+    sessions: summary.sessions,
+    requests: summary.requests,
+    total_tokens: summary.tokens,
+    cost_usd: summary.total_usd
+  };
+}
+function querySinceTotals(db, since, machine) {
+  const requests = queryRequestTotals(db, "timestamp >= ?", [since], machine);
+  const sessions = querySessionOnlyTotals(db, "started_at >= ?", [since], machine);
+  return combineTotals(requests, sessions);
+}
+function parseSinceDate(input, now) {
+  const value = input.trim();
+  const match = value.match(/^(\d+(?:\.\d+)?)(m|h|d|w)$/i);
+  if (match) {
+    const amount = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const multiplier = unit === "m" ? 60000 : unit === "h" ? 60 * 60000 : unit === "d" ? 24 * 60 * 60000 : 7 * 24 * 60 * 60000;
+    return {
+      timestamp: new Date(now.getTime() - amount * multiplier).toISOString(),
+      label: value
+    };
+  }
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error("--since must be a duration like 24h, 7d, 30m, 2w, or an ISO date");
+  }
+  return { timestamp: parsed.toISOString(), label: value };
+}
+function queryMachineSinceRows(db, since, machine) {
+  const knownMachines = new Set;
+  for (const m of listMachines(db, "all")) {
+    if (m.machine_id)
+      knownMachines.add(m.machine_id);
+  }
+  for (const m of listMachineRegistry(db)) {
+    if (m.machine_id)
+      knownMachines.add(m.machine_id);
+  }
+  if (machine)
+    knownMachines.add(machine);
+  const requestMachineClause = machine ? " AND machine_id = ?" : "";
+  const requestRows = db.prepare(`
+    SELECT
+      machine_id,
+      COUNT(DISTINCT session_id) as request_sessions,
+      COUNT(*) as requests,
+      COALESCE(SUM(input_tokens), 0) as input_tokens,
+      COALESCE(SUM(output_tokens), 0) as output_tokens,
+      COALESCE(SUM(cache_read_tokens), 0) as cache_read_tokens,
+      COALESCE(SUM(cache_create_tokens), 0) as cache_create_tokens,
+      COALESCE(SUM(COALESCE(cache_create_5m_tokens, cache_create_tokens)), 0) as cache_create_5m_tokens,
+      COALESCE(SUM(COALESCE(cache_create_1h_tokens, 0)), 0) as cache_create_1h_tokens,
+      COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+      COALESCE(SUM(cost_usd), 0) as cost_usd,
+      MAX(timestamp) as last_active
+    FROM requests
+    WHERE timestamp >= ?
+      AND machine_id != ''
+      ${requestMachineClause}
+    GROUP BY machine_id
+  `).all(...machine ? [since, machine] : [since]);
+  const sessionMachineClause = machine ? " AND machine_id = ?" : "";
+  const sessionRows = db.prepare(`
+    SELECT
+      machine_id,
+      COUNT(*) as sessions,
+      COALESCE(SUM(request_count), 0) as requests,
+      COALESCE(SUM(total_tokens), 0) as total_tokens,
+      COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+      MAX(started_at) as last_active
+    FROM sessions
+    WHERE started_at >= ?
+      AND machine_id != ''
+      ${sessionMachineClause}
+      AND NOT EXISTS (SELECT 1 FROM requests r WHERE r.session_id = sessions.id)
+    GROUP BY machine_id
+  `).all(...machine ? [since, machine] : [since]);
+  const groups = new Map;
+  for (const row of requestRows) {
+    knownMachines.add(row.machine_id);
+    groups.set(row.machine_id, combineTotals(baseRequestTotals(row), ZERO_SESSION_TOTALS));
+  }
+  for (const row of sessionRows) {
+    knownMachines.add(row.machine_id);
+    const current = groups.get(row.machine_id) ?? emptyTotals();
+    const sessions = baseSessionTotals(row);
+    groups.set(row.machine_id, {
+      ...current,
+      sessions: current.sessions + sessions.sessions,
+      requests: current.requests + sessions.requests,
+      total_tokens: current.total_tokens + sessions.total_tokens,
+      cost_usd: current.cost_usd + sessions.cost_usd,
+      last_active: latestTimestamp(current.last_active, sessions.last_active)
+    });
+  }
+  const lastData = queryMachineLastData(db, machine);
+  const rows = [...knownMachines].filter((m) => !machine || m === machine).map((machineId) => {
+    const totals = groups.get(machineId) ?? emptyTotals();
+    const lastDataAt = lastData.get(machineId) ?? totals.last_active;
+    return {
+      machine_id: machineId,
+      ...totals,
+      last_data_at: lastDataAt,
+      last_data_age: ""
+    };
+  });
+  return rows.sort((a, b) => b.cost_usd - a.cost_usd || a.machine_id.localeCompare(b.machine_id));
+}
+function queryMachineLastData(db, machine) {
+  const filter = machine ? " AND machine_id = ?" : "";
+  const requestRows = db.prepare(`
+    SELECT machine_id, MAX(timestamp) as last_at
+    FROM requests
+    WHERE machine_id != ''${filter}
+    GROUP BY machine_id
+  `).all(...machine ? [machine] : []);
+  const sessionRows = db.prepare(`
+    SELECT machine_id, MAX(started_at) as last_at
+    FROM sessions
+    WHERE machine_id != ''${filter}
+    GROUP BY machine_id
+  `).all(...machine ? [machine] : []);
+  const result = new Map;
+  for (const row of [...requestRows, ...sessionRows]) {
+    result.set(row.machine_id, latestTimestamp(result.get(row.machine_id), row.last_at));
+  }
+  return result;
+}
+function queryAgentSinceRows(db, since, machine) {
+  const requestMachineClause = machine ? " AND machine_id = ?" : "";
+  const sessionMachineClause = machine ? " AND machine_id = ?" : "";
+  const rows = db.prepare(`
+    WITH request_rows AS (
+      SELECT
+        agent,
+        session_id,
+        1 as requests,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_create_tokens,
+        COALESCE(cache_create_5m_tokens, cache_create_tokens) as cache_create_5m_tokens,
+        COALESCE(cache_create_1h_tokens, 0) as cache_create_1h_tokens,
+        input_tokens + output_tokens + cache_read_tokens + cache_create_tokens as total_tokens,
+        cost_usd,
+        timestamp as last_active
+      FROM requests
+      WHERE timestamp >= ?${requestMachineClause}
+    ),
+    session_only_rows AS (
+      SELECT
+        agent,
+        id as session_id,
+        COALESCE(request_count, 0) as requests,
+        0 as input_tokens,
+        0 as output_tokens,
+        0 as cache_read_tokens,
+        0 as cache_create_tokens,
+        0 as cache_create_5m_tokens,
+        0 as cache_create_1h_tokens,
+        COALESCE(total_tokens, 0) as total_tokens,
+        COALESCE(total_cost_usd, 0) as cost_usd,
+        started_at as last_active
+      FROM sessions
+      WHERE started_at >= ?${sessionMachineClause}
+        AND NOT EXISTS (SELECT 1 FROM requests r WHERE r.session_id = sessions.id)
+    ),
+    combined AS (
+      SELECT * FROM request_rows
+      UNION ALL
+      SELECT * FROM session_only_rows
+    )
+    SELECT
+      agent,
+      COUNT(DISTINCT session_id) as sessions,
+      COALESCE(SUM(requests), 0) as requests,
+      COALESCE(SUM(input_tokens), 0) as input_tokens,
+      COALESCE(SUM(output_tokens), 0) as output_tokens,
+      COALESCE(SUM(cache_read_tokens), 0) as cache_read_tokens,
+      COALESCE(SUM(cache_create_tokens), 0) as cache_create_tokens,
+      COALESCE(SUM(cache_create_5m_tokens), 0) as cache_create_5m_tokens,
+      COALESCE(SUM(cache_create_1h_tokens), 0) as cache_create_1h_tokens,
+      COALESCE(SUM(total_tokens), 0) as total_tokens,
+      COALESCE(SUM(cost_usd), 0) as cost_usd,
+      MAX(last_active) as last_active
+    FROM combined
+    GROUP BY agent
+    ORDER BY cost_usd DESC
+  `).all(...machine ? [since, machine, since, machine] : [since, since]);
+  if (rows.length > 0)
+    return rows;
+  return queryAgentBreakdown(db, "all", machine).filter((row) => row.last_active >= since).map(agentBreakdownToBriefRow);
+}
+function agentBreakdownToBriefRow(row) {
+  return {
+    agent: row.agent,
+    sessions: row.sessions,
+    requests: row.requests,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_create_tokens: 0,
+    cache_create_5m_tokens: 0,
+    cache_create_1h_tokens: 0,
+    total_tokens: row.total_tokens,
+    cost_usd: row.cost_usd,
+    last_active: row.last_active
+  };
+}
+function normalizeAccountEmail2(email) {
+  return email.trim().toLowerCase();
+}
+function accountKey2(row) {
+  const agent = row.agent || row.account_tool || "unknown";
+  const email = normalizeAccountEmail2(row.account_email);
+  if (email)
+    return `${agent}:${email}`;
+  if (row.account_name)
+    return `${agent}:${row.account_name}`;
+  return row.account_key || `${agent}:unknown`;
+}
+function addAccountRow(groups, row) {
+  if (!row.account_key && !row.account_tool && !row.account_name && !row.account_email)
+    return;
+  const key = accountKey2(row);
+  const email = normalizeAccountEmail2(row.account_email);
+  const current = groups.get(key) ?? {
+    account_key: key,
+    account_tool: row.agent || row.account_tool || "unknown",
+    account_name: row.account_name || email || row.account_key || "unknown",
+    account_email: email || null,
+    account_source: row.account_source || "unknown",
+    sessions: 0,
+    requests: 0,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_create_tokens: 0,
+    cache_create_5m_tokens: 0,
+    cache_create_1h_tokens: 0,
+    total_tokens: 0,
+    cost_usd: 0,
+    last_active: null
+  };
+  current.sessions += Number(row.sessions ?? 0);
+  if (!current.account_email && email)
+    current.account_email = email;
+  if ((!current.account_name || current.account_name === "unknown") && (row.account_name || email)) {
+    current.account_name = row.account_name || email;
+  }
+  if ((!current.account_source || current.account_source === "unknown") && row.account_source && row.account_source !== "unknown") {
+    current.account_source = row.account_source;
+  }
+  current.requests += Number(row.requests ?? 0);
+  current.input_tokens += Number(row.input_tokens ?? 0);
+  current.output_tokens += Number(row.output_tokens ?? 0);
+  current.cache_read_tokens += Number(row.cache_read_tokens ?? 0);
+  current.cache_create_tokens += Number(row.cache_create_tokens ?? 0);
+  current.cache_create_5m_tokens += Number(row.cache_create_5m_tokens ?? 0);
+  current.cache_create_1h_tokens += Number(row.cache_create_1h_tokens ?? 0);
+  current.total_tokens += Number(row.total_tokens ?? 0);
+  current.cost_usd += Number(row.cost_usd ?? 0);
+  current.last_active = latestTimestamp(current.last_active, row.last_active);
+  groups.set(key, current);
+}
+function queryAccountSinceRows(db, since, machine) {
+  const requestMachineClause = machine ? " AND r.machine_id = ?" : "";
+  const sessionMachineClause = machine ? " AND s.machine_id = ?" : "";
+  const requestRows = db.prepare(`
+    SELECT
+      COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), '') as agent,
+      COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') as account_key,
+      COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') as account_tool,
+      COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') as account_name,
+      COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') as account_email,
+      COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown') as account_source,
+      COUNT(DISTINCT r.session_id) as sessions,
+      COUNT(*) as requests,
+      COALESCE(SUM(r.input_tokens), 0) as input_tokens,
+      COALESCE(SUM(r.output_tokens), 0) as output_tokens,
+      COALESCE(SUM(r.cache_read_tokens), 0) as cache_read_tokens,
+      COALESCE(SUM(r.cache_create_tokens), 0) as cache_create_tokens,
+      COALESCE(SUM(COALESCE(r.cache_create_5m_tokens, r.cache_create_tokens, 0)), 0) as cache_create_5m_tokens,
+      COALESCE(SUM(COALESCE(r.cache_create_1h_tokens, 0)), 0) as cache_create_1h_tokens,
+      COALESCE(SUM(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens), 0) as total_tokens,
+      COALESCE(SUM(r.cost_usd), 0) as cost_usd,
+      MAX(r.timestamp) as last_active
+    FROM requests r
+    LEFT JOIN sessions s ON s.id = r.session_id
+    WHERE r.timestamp >= ?${requestMachineClause}
+    GROUP BY
+      COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), ''),
+      COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), ''),
+      COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), ''),
+      COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), ''),
+      COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), ''),
+      COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown')
+  `).all(...machine ? [since, machine] : [since]);
+  const sessionRows = db.prepare(`
+    SELECT
+      s.agent as agent,
+      s.account_key as account_key,
+      s.account_tool as account_tool,
+      s.account_name as account_name,
+      COALESCE(s.account_email, '') as account_email,
+      COALESCE(NULLIF(s.account_source, ''), 'unknown') as account_source,
+      COUNT(DISTINCT s.id) as sessions,
+      COALESCE(SUM(s.request_count), 0) as requests,
+      0 as input_tokens,
+      0 as output_tokens,
+      0 as cache_read_tokens,
+      0 as cache_create_tokens,
+      0 as cache_create_5m_tokens,
+      0 as cache_create_1h_tokens,
+      COALESCE(SUM(s.total_tokens), 0) as total_tokens,
+      COALESCE(SUM(s.total_cost_usd), 0) as cost_usd,
+      MAX(s.started_at) as last_active
+    FROM sessions s
+    WHERE s.started_at >= ?${sessionMachineClause}
+      AND NOT EXISTS (SELECT 1 FROM requests r WHERE r.session_id = s.id)
+    GROUP BY
+      s.agent,
+      s.account_key,
+      s.account_tool,
+      s.account_name,
+      COALESCE(s.account_email, ''),
+      COALESCE(NULLIF(s.account_source, ''), 'unknown')
+  `).all(...machine ? [since, machine] : [since]);
+  const groups = new Map;
+  for (const row of requestRows)
+    addAccountRow(groups, row);
+  for (const row of sessionRows)
+    addAccountRow(groups, row);
+  const rows = [...groups.values()];
+  rows.sort((a, b) => b.cost_usd - a.cost_usd || a.account_key.localeCompare(b.account_key));
+  if (rows.length > 0)
+    return rows;
+  return queryAccountBreakdown(db, "all", machine).filter((row) => row.last_active >= since).map(accountBreakdownToBriefRow);
+}
+function accountBreakdownToBriefRow(row) {
+  return {
+    account_key: row.account_key,
+    account_tool: row.account_tool,
+    account_name: row.account_name,
+    account_email: row.account_email,
+    account_source: row.account_source,
+    sessions: row.sessions,
+    requests: row.requests,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_create_tokens: 0,
+    cache_create_5m_tokens: 0,
+    cache_create_1h_tokens: 0,
+    total_tokens: row.total_tokens,
+    cost_usd: row.cost_usd,
+    last_active: row.last_active
+  };
+}
+function queryFreshness(db, now, machine, localSync) {
+  const requestFilter = machine ? " AND machine_id = ?" : "";
+  const requestRows = db.prepare(`
+    SELECT machine_id, MAX(timestamp) as max_request_at
+    FROM requests
+    WHERE machine_id != ''${requestFilter}
+    GROUP BY machine_id
+  `).all(...machine ? [machine] : []);
+  const registryRows = listMachineRegistry(db).filter((row) => !machine || row.machine_id === machine);
+  const machines = new Map;
+  for (const row of requestRows) {
+    machines.set(row.machine_id, {
+      machine_id: row.machine_id,
+      max_request_at: row.max_request_at,
+      request_age: formatAge(row.max_request_at, now),
+      last_merge_sync_at: null,
+      merge_sync_age: "never"
+    });
+  }
+  for (const row of registryRows) {
+    const current = machines.get(row.machine_id) ?? {
+      machine_id: row.machine_id,
+      max_request_at: null,
+      request_age: "never",
+      last_merge_sync_at: null,
+      merge_sync_age: "never"
+    };
+    const syncAt = latestTimestamp(row.last_pull_at, row.last_push_at, row.updated_at);
+    current.last_merge_sync_at = syncAt;
+    current.merge_sync_age = formatAge(syncAt, now);
+    machines.set(row.machine_id, current);
+  }
+  if (localSync && (!machine || machine === localSync.machineId)) {
+    const current = machines.get(localSync.machineId) ?? {
+      machine_id: localSync.machineId,
+      max_request_at: null,
+      request_age: "never",
+      last_merge_sync_at: null,
+      merge_sync_age: "never"
+    };
+    current.last_merge_sync_at = latestTimestamp(current.last_merge_sync_at, localSync.syncedAt);
+    current.merge_sync_age = formatAge(current.last_merge_sync_at, now);
+    machines.set(localSync.machineId, current);
+  }
+  const rows = [...machines.values()].sort((a, b) => a.machine_id.localeCompare(b.machine_id));
+  return {
+    machines: rows,
+    max_request_line: rows.length ? rows.map((row) => `${row.machine_id} ${row.max_request_at ?? "never"} (${row.request_age})`).join("; ") : "none",
+    merge_sync_line: rows.length ? rows.map((row) => `${row.machine_id} ${row.last_merge_sync_at ?? "never"} (${row.merge_sync_age})`).join("; ") : "none"
+  };
+}
+function buildBrief(db, opts = {}) {
+  const now = opts.now ?? new Date;
+  const machine = machineFilter(opts.machine);
+  const sinceInput = opts.since ?? "24h";
+  const since = parseSinceDate(sinceInput, now);
+  const summaries = [
+    {
+      label: "Today",
+      period: "today",
+      ...queryPeriodTotals(db, "today", machine)
+    },
+    {
+      label: "Week",
+      period: "week",
+      ...queryPeriodTotals(db, "week", machine)
+    },
+    {
+      label: `Since ${since.label}`,
+      period: "since",
+      since: since.timestamp,
+      ...querySinceTotals(db, since.timestamp, machine)
+    }
+  ];
+  const machines = queryMachineSinceRows(db, since.timestamp, machine);
+  for (const row of machines) {
+    row.last_data_age = formatAge(row.last_data_at, now);
+  }
+  return {
+    generated_at: now.toISOString(),
+    machine: machine ?? "all",
+    since: {
+      input: sinceInput,
+      timestamp: since.timestamp,
+      label: since.label
+    },
+    summaries,
+    machines,
+    agents: queryAgentSinceRows(db, since.timestamp, machine),
+    accounts: queryAccountSinceRows(db, since.timestamp, machine),
+    freshness: queryFreshness(db, now, machine, opts.currentMachineId && opts.localSyncAt ? { machineId: opts.currentMachineId, syncedAt: opts.localSyncAt.toISOString() } : undefined)
+  };
+}
+
+// src/lib/analytics.ts
+function queryProjectDetail(db, nameOrPath) {
+  const like = `%${nameOrPath}%`;
+  const sessions = db.prepare(`SELECT id, project_name, project_path, total_cost_usd, total_tokens, started_at
+     FROM sessions
+     WHERE project_name LIKE ? OR project_path LIKE ?
+     ORDER BY started_at DESC`).all(like, like);
+  if (sessions.length === 0)
+    return null;
+  const first = sessions[0];
+  const totalCost = sessions.reduce((s, r) => s + (r.total_cost_usd ?? 0), 0);
+  const totalTokens = sessions.reduce((s, r) => s + (r.total_tokens ?? 0), 0);
+  const daily = db.prepare(`SELECT DATE(r.timestamp) as date, COALESCE(SUM(r.cost_usd), 0) as cost_usd
+     FROM requests r JOIN sessions s ON r.session_id = s.id
+     WHERE (s.project_name LIKE ? OR s.project_path LIKE ?)
+       AND r.timestamp >= DATE('now', '-14 days')
+     GROUP BY date ORDER BY date ASC`).all(like, like);
+  const models = db.prepare(`SELECT r.model as model, COUNT(*) as requests, COALESCE(SUM(r.cost_usd), 0) as cost_usd
+     FROM requests r JOIN sessions s ON r.session_id = s.id
+     WHERE s.project_name LIKE ? OR s.project_path LIKE ?
+     GROUP BY r.model ORDER BY cost_usd DESC LIMIT 5`).all(like, like);
+  const top_sessions = [...sessions].sort((a, b) => (b.total_cost_usd ?? 0) - (a.total_cost_usd ?? 0)).slice(0, 5).map((s) => ({ id: s.id, total_cost_usd: s.total_cost_usd ?? 0, started_at: s.started_at }));
+  return {
+    project_name: first.project_name || nameOrPath,
+    project_path: first.project_path || "",
+    total_cost_usd: totalCost,
+    total_tokens: totalTokens,
+    sessions: sessions.length,
+    daily,
+    models,
+    top_sessions
+  };
+}
+function exportDateWhere(column, period) {
+  switch (period) {
+    case "today":
+      return `DATE(${column}) = DATE('now')`;
+    case "week":
+      return `${column} >= DATE('now', '-7 days')`;
+    case "all":
+      return "1=1";
+    default:
+      return `${column} >= DATE('now', '-30 days')`;
+  }
+}
+function queryExportRows(db, type, period) {
+  if (type === "requests") {
+    const where2 = exportDateWhere("timestamp", period);
+    return db.prepare(`SELECT * FROM requests WHERE ${where2} ORDER BY timestamp ASC`).all();
+  }
+  const where = exportDateWhere("started_at", period);
+  return db.prepare(`SELECT * FROM sessions WHERE ${where} ORDER BY started_at DESC`).all();
+}
+function queryRangeStats(db, from, to) {
+  const r = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost, COUNT(*) as requests,
+            COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens+cache_create_tokens),0) as tokens
+     FROM requests WHERE DATE(timestamp) BETWEEN ? AND ?`).get(from, to);
+  const s = db.prepare(`SELECT COUNT(*) as sessions FROM sessions WHERE DATE(started_at) BETWEEN ? AND ?`).get(from, to);
+  return { cost: r.cost, requests: r.requests, tokens: r.tokens, sessions: s.sessions };
+}
+function queryForecast(db, now = new Date) {
+  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+  const dayOfMonth = now.getDate();
+  const monthStart = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-01`;
+  const monthSoFar = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM requests WHERE DATE(timestamp) >= ?`).get(monthStart);
+  const dailyAvg = dayOfMonth > 0 ? monthSoFar.cost / dayOfMonth : 0;
+  const projected = dailyAvg * daysInMonth;
+  const sevenDaysAgo = new Date(now);
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+  const last7 = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM requests WHERE DATE(timestamp) >= ?`).get(sevenDaysAgo.toISOString().substring(0, 10));
+  const last7DailyAvg = last7.cost / 7;
+  const dailyCosts = db.prepare(`SELECT DATE(timestamp) as date, COALESCE(SUM(cost_usd),0) as cost_usd
+     FROM requests WHERE DATE(timestamp) >= ? GROUP BY date ORDER BY cost_usd ASC`).all(monthStart);
+  return {
+    day_of_month: dayOfMonth,
+    days_in_month: daysInMonth,
+    spent_so_far_usd: monthSoFar.cost,
+    daily_avg_usd: dailyAvg,
+    projected_usd: projected,
+    last7_daily_avg_usd: last7DailyAvg,
+    last7_projected_usd: last7DailyAvg * daysInMonth,
+    cheapest_day: dailyCosts[0] ?? null,
+    most_expensive_day: dailyCosts[dailyCosts.length - 1] ?? null
+  };
+}
+function queryModelEfficiency(db) {
+  return db.prepare(`SELECT model,
+            COALESCE(SUM(input_tokens),0) as input,
+            COALESCE(SUM(output_tokens),0) as output,
+            COALESCE(SUM(cache_read_tokens),0) as cache_read,
+            COALESCE(SUM(cache_create_tokens),0) as cache_write,
+            COUNT(*) as requests,
+            COALESCE(SUM(cost_usd),0) as cost
+     FROM requests GROUP BY model ORDER BY cost DESC`).all();
+}
+
+// src/server/serve.ts
+init_database();
+
+// src/lib/periods.ts
+function ymd(date) {
+  return date.toISOString().substring(0, 10);
+}
+function usageSnapshotFilterForPeriod(period) {
+  const now = new Date;
+  switch (period) {
+    case "today":
+      return { date: ymd(now) };
+    case "yesterday": {
+      const yesterday = new Date(now);
+      yesterday.setUTCDate(yesterday.getUTCDate() - 1);
+      return { date: ymd(yesterday) };
+    }
+    case "week": {
+      const weekAgo = new Date(now);
+      weekAgo.setUTCDate(weekAgo.getUTCDate() - 7);
+      return { since: ymd(weekAgo) };
+    }
+    case "month":
+      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))) };
+    case "year":
+      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), 0, 1))) };
+    case "all":
+      return {};
+  }
+}
+
+// src/lib/billing-diff.ts
+init_database();
+var PROVIDER_TO_AGENT = {
+  anthropic: "claude",
+  openai: "codex",
+  gemini: "gemini",
+  google: "gemini"
+};
+function queryBillingDiff(db, period, thresholdPct = 15) {
+  const estimated = querySummary(db, period, undefined, true);
+  const actual = queryBillingSummary(db, period);
+  const delta = estimated.total_usd - actual.total_usd;
+  const deltaPct = actual.total_usd > 0 ? delta / actual.total_usd * 100 : 0;
+  const agentRows = db.prepare(`
+    SELECT agent, COALESCE(SUM(cost_usd), 0) as estimated_usd
+    FROM requests
+    WHERE ${periodWhere3(period, "timestamp")}
+    GROUP BY agent
+  `).all();
+  const by_agent = agentRows.map((row) => {
+    const provider = Object.entries(PROVIDER_TO_AGENT).find(([, a]) => a === row.agent)?.[0];
+    const actualUsd = provider ? actual.by_provider[provider] ?? 0 : 0;
+    const rowDelta = row.estimated_usd - actualUsd;
+    const rowPct = actualUsd > 0 ? rowDelta / actualUsd * 100 : 0;
+    return {
+      agent: row.agent,
+      estimated_usd: row.estimated_usd,
+      actual_usd: actualUsd,
+      delta_usd: rowDelta,
+      delta_pct: rowPct
+    };
+  }).sort((a, b) => Math.abs(b.delta_usd) - Math.abs(a.delta_usd));
+  return {
+    period,
+    estimated_usd: estimated.total_usd,
+    actual_usd: actual.total_usd,
+    delta_usd: delta,
+    delta_pct: deltaPct,
+    threshold_pct: thresholdPct,
+    is_alert: Math.abs(deltaPct) > thresholdPct,
+    by_agent,
+    by_provider: actual.by_provider
+  };
+}
+function periodWhere3(period, column) {
+  switch (period) {
+    case "today":
+      return `DATE(${column}) = DATE('now')`;
+    case "yesterday":
+      return `DATE(${column}) = DATE('now', '-1 day')`;
+    case "week":
+      return `${column} >= DATE('now', 'weekday 0', '-7 days')`;
+    case "month":
+      return `${column} >= DATE('now', 'start of month')`;
+    case "year":
+      return `${column} >= DATE('now', 'start of year')`;
+    case "all":
+      return "1=1";
+  }
+}
+
+// src/server/serve.ts
+init_database();
+
+// src/lib/serve-auth.ts
+function getServeApiToken() {
+  return process.env["ECONOMY_API_TOKEN"] ?? process.env["HASNA_ECONOMY_API_TOKEN"];
+}
+function getServeBindHost() {
+  const explicit = process.env["ECONOMY_BIND"] ?? process.env["ECONOMY_HOST"];
+  if (explicit)
+    return explicit;
+  return getServeApiToken() ? "127.0.0.1" : "0.0.0.0";
+}
+function isAuthorizedRequest(req, path) {
+  const token = getServeApiToken();
+  if (!token)
+    return true;
+  if (path === "/health")
+    return true;
+  const auth = req.headers.get("Authorization");
+  if (auth === `Bearer ${token}`)
+    return true;
+  if (req.headers.get("X-Economy-Token") === token)
+    return true;
+  return false;
+}
+
+// src/server/serve.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync12 } from "fs";
+import { resolve, sep } from "path";
+
+// src/lib/package-metadata.ts
+import { readFileSync as readFileSync8 } from "fs";
+var cachedMetadata = null;
+function getPackageMetadata() {
+  if (cachedMetadata)
+    return cachedMetadata;
+  const raw = readFileSync8(new URL("../../package.json", import.meta.url), "utf8");
+  const parsed = JSON.parse(raw);
+  cachedMetadata = {
+    name: parsed.name ?? "@hasna/economy",
+    version: parsed.version ?? "0.0.0"
+  };
+  return cachedMetadata;
+}
+var packageMetadata = getPackageMetadata();
+
+// src/server/serve.ts
+init_cloud();
+import { verifyApiKey, ApiKeyStore } from "@hasna/contracts/auth";
+
+// src/openapi.ts
+var openApiSpec = {
+  openapi: "3.0.3",
+  info: {
+    title: "@hasna/economy self-hosted API",
+    version: "0.0.0",
+    description: "AI coding cost tracker \u2014 self-hosted control plane. Cloud mode is PURE REMOTE per Amendment A1: the serve process reads/writes the shared RDS Postgres 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."
+  },
+  servers: [
+    {
+      url: "https://economy.hasna.xyz",
+      description: "prod"
+    },
+    {
+      url: "http://localhost:3456",
+      description: "local"
+    }
+  ],
+  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"
+        ]
+      },
+      Foundation: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string"
+          },
+          version: {
+            type: "string"
+          },
+          mode: {
+            type: "string"
+          },
+          service: {
+            type: "string"
+          }
+        },
+        required: [
+          "status",
+          "version",
+          "mode"
+        ]
+      },
+      Error: {
+        type: "object",
+        properties: {
+          error: {
+            type: "string"
+          },
+          message: {
+            type: "string"
+          }
+        },
+        required: [
+          "error"
+        ]
+      },
+      MutationOk: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          }
+        }
+      },
+      CostSummary: {
+        type: "object",
+        properties: {
+          total_cost_usd: {
+            type: "number"
+          },
+          total_tokens: {
+            type: "number"
+          },
+          request_count: {
+            type: "number"
+          },
+          session_count: {
+            type: "number"
+          },
+          period: {
+            type: "string"
+          }
+        },
+        additionalProperties: true
+      },
+      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"
+          }
+        },
+        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",
+        additionalProperties: true
+      },
+      CreateSubscriptionInput: {
+        type: "object",
+        properties: {
+          provider: {
+            type: "string"
+          },
+          plan: {
+            type: "string"
+          },
+          monthly_fee_usd: {
+            type: "number"
+          },
+          included_usage_usd: {
+            type: "number"
+          },
+          agent: {
+            type: "string",
+            nullable: true
+          }
+        },
+        required: [
+          "provider",
+          "plan"
+        ]
+      },
+      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",
+        additionalProperties: true
+      }
+    }
+  },
+  paths: {
+    "/health": {
+      get: {
+        operationId: "health",
+        summary: "Liveness probe",
+        security: [],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foundation"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/ready": {
+      get: {
+        operationId: "ready",
+        summary: "Readiness probe (storage reachable + migrated)",
+        security: [],
+        responses: {
+          "200": {
+            description: "ready",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foundation"
+                }
+              }
+            }
+          },
+          "503": {
+            description: "not ready",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foundation"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/version": {
+      get: {
+        operationId: "version",
+        summary: "Version probe",
+        security: [],
+        responses: {
+          "200": {
+            description: "version",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foundation"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/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: "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: "Billing vs tracked diff",
+        parameters: [
+          {
+            name: "period",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "threshold",
+            in: "query",
+            schema: {
+              type: "number"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/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: "Bulk-import local rows into the cloud DB (merge by primary key, idempotent)",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  requests: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  },
+                  sessions: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  },
+                  projects: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  },
+                  budgets: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  },
+                  goals: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  },
+                  billing_daily: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  },
+                  model_pricing: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  },
+                  subscriptions: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  },
+                  usage_snapshots: {
+                    type: "array",
+                    items: {
+                      type: "object"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "ok",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Envelope"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/server/serve.ts
+function openApiDocument() {
+  const spec = openApiSpec;
+  return { ...spec, info: { ...spec["info"], version: packageMetadata.version } };
+}
+function serveMode() {
+  return isCloudMode() ? "self_hosted" : "local";
+}
+function foundationEnvelope(status, extra = {}) {
+  return { status, version: packageMetadata.version, mode: serveMode(), service: "economy", ...extra };
+}
+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 APP = "economy";
+var ECONOMY_WRITE_SCOPE = `${APP}:write`;
+var AGENT_ERROR = `agent must be one of: ${AGENTS.join(", ")}`;
+var SYNC_SOURCES = ["all", ...AGENTS];
+var DEFAULT_DASHBOARD_DIR = new URL("../../dashboard/dist", import.meta.url).pathname;
+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":
@@ -4252,6 +6930,11 @@ function optionalAgent(value) {
     return null;
   return typeof value === "string" && AGENTS.includes(value) ? value : undefined;
 }
+function requiredScopesForRequest(method, path) {
+  if (method === "POST" && path === "/api/ingest")
+    return [ECONOMY_WRITE_SCOPE];
+  return;
+}
 function stringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
@@ -4267,19 +6950,20 @@ function dashboardPath(root, pathname) {
   const filePath = resolve(rootPath, relativePath);
   return filePath === rootPath || filePath.startsWith(rootPath + sep) ? filePath : null;
 }
+var FOUNDATION_PATHS = new Set(["/health", "/healthz", "/ready", "/readyz", "/version", "/openapi.json"]);
 function createServerFetch(apiHandler, dashboardDir = DEFAULT_DASHBOARD_DIR) {
   return async function fetch2(req) {
     const url = new URL(req.url);
-    if (url.pathname.startsWith("/api") || url.pathname === "/health") {
+    if (url.pathname.startsWith("/api") || url.pathname.startsWith("/v1") || FOUNDATION_PATHS.has(url.pathname)) {
       return apiHandler(req);
     }
-    if (existsSync11(dashboardDir)) {
+    if (existsSync12(dashboardDir)) {
       const filePath = dashboardPath(dashboardDir, url.pathname);
-      if (filePath && existsSync11(filePath)) {
+      if (filePath && existsSync12(filePath)) {
         return new Response(Bun.file(filePath));
       }
       const indexPath = dashboardPath(dashboardDir, "/");
-      if (indexPath && existsSync11(indexPath)) {
+      if (indexPath && existsSync12(indexPath)) {
         return new Response(Bun.file(indexPath));
       }
     }
@@ -4291,15 +6975,38 @@ function applyFields(obj, fields) {
     return obj;
   return Object.fromEntries(fields.map((f) => [f, obj[f] ?? null]));
 }
-function createHandler(db) {
+function createHandler(db, options = {}) {
   return async function handler(req) {
     const url = new URL(req.url);
-    const path = url.pathname;
+    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: CORS });
-    if (!isAuthorizedRequest(req, path))
+    if (method === "GET" && (rawPath === "/health" || rawPath === "/healthz")) {
+      return json(foundationEnvelope("ok"));
+    }
+    if (method === "GET" && (rawPath === "/version" || rawPath === "/v1/version")) {
+      return json(foundationEnvelope("ok"));
+    }
+    if (method === "GET" && (rawPath === "/ready" || rawPath === "/readyz")) {
+      const result = options.readyCheck ? await options.readyCheck() : { ready: true };
+      return json(foundationEnvelope(result.ready ? "ready" : "not_ready", result.detail ? { detail: result.detail } : {}), result.ready ? 200 : 503);
+    }
+    if (method === "GET" && rawPath === "/openapi.json") {
+      return json(openApiDocument());
+    }
+    if (options.authenticator) {
+      const decision = await options.authenticator.authenticate(req.headers, {
+        method,
+        path: rawPath,
+        requiredScopes: requiredScopesForRequest(method, path)
+      });
+      if (!decision.ok)
+        return json({ error: decision.reason ?? "unauthorized", message: decision.message }, decision.status || 401);
+    } else if (!isAuthorizedRequest(req, path)) {
       return err("Unauthorized", 401);
+    }
     if (path === "/health")
       return ok({ status: "ok", ts: new Date().toISOString() });
     if (path === "/api/summary" && method === "GET") {
@@ -4546,15 +7253,22 @@ function createHandler(db) {
       } catch {}
       return ok(results);
     }
+    if (path === "/api/ingest" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      return ok(bulkIngest(db, body));
+    }
     if (path === "/api/usage" && method === "GET") {
       const period = url.searchParams.get("period") ?? "month";
-      const agent = url.searchParams.get("agent") ?? undefined;
+      const agentParam = url.searchParams.get("agent") ?? undefined;
+      const agent = agentParam && isAgent(agentParam) ? agentParam : undefined;
       return ok({
         snapshots: queryUsageSnapshots(db, {
-          agent: agent && isAgent(agent) ? agent : undefined,
+          agent,
           ...usageSnapshotFilterForPeriod(period)
         }),
-        summary: querySummary(db, period, undefined, true)
+        summary: querySummary(db, period, undefined, true, agent)
       });
     }
     if (path === "/api/savings" && method === "GET") {
@@ -4562,6 +7276,47 @@ function createHandler(db) {
       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 (e) {
+        return err(e instanceof Error ? e.message : String(e));
+      }
+    }
+    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));
     }
@@ -4652,27 +7407,68 @@ function createHandler(db) {
     return err("Not found", 404);
   };
 }
+function isLocalHost(host) {
+  return ["127.0.0.1", "localhost", "::1"].includes(host);
+}
 function startServer(port = 3456, options = {}) {
-  const db = options.db ?? openDatabase();
-  ensurePricingSeeded(db);
-  const apiHandler = createHandler(db);
-  const hostname2 = options.hostname ?? getServeBindHost();
+  const cloud = options.db ? false : isCloudMode();
+  const hostname2 = options.hostname ?? (cloud ? process.env["ECONOMY_HOST"] ?? "0.0.0.0" : getServeBindHost());
+  const log = options.log ?? console.log;
+  const handlerOptions = {};
+  let db;
+  if (cloud) {
+    db = openCloudDatabase();
+    const pool = createCloudPool();
+    const signingSecret = resolveSigningSecret();
+    if (signingSecret) {
+      const keys = new ApiKeyStore(authClientFromPool(pool));
+      keys.ensureSchema().catch((e) => log(`api_keys ensureSchema: ${e instanceof Error ? e.message : String(e)}`));
+      handlerOptions.authenticator = verifyApiKey({
+        app: APP,
+        signingSecret,
+        isRevoked: keys.statusChecker(),
+        audit: (event) => log(JSON.stringify({ evt: "api_auth", outcome: event.outcome, kid: event.kid, reason: event.reason, path: event.path, status: event.status }))
+      });
+    } else if (!isLocalHost(hostname2)) {
+      throw new Error("economy-serve on a non-local host requires an API signing secret (HASNA_ECONOMY_API_SIGNING_KEY / API_KEY_SIGNING_SECRET)");
+    }
+    handlerOptions.readyCheck = async () => {
+      try {
+        const res = await pool.query("SELECT to_regclass($1) AS reg", ["public.requests"]);
+        if (!res.rows[0]?.reg)
+          return { ready: false, detail: "pending_migrations:requests" };
+        return { ready: true };
+      } catch (error) {
+        return { ready: false, detail: error instanceof Error ? error.message : "storage_unreachable" };
+      }
+    };
+  } else {
+    db = options.db ?? openDatabase();
+    ensurePricingSeeded(db);
+  }
+  const apiHandler = createHandler(db, handlerOptions);
   const server = Bun.serve({
     port,
     hostname: hostname2,
     fetch: createServerFetch(apiHandler, options.dashboardDir)
   });
   const address = `http://${hostname2 === "0.0.0.0" ? "localhost" : hostname2}:${server.port}`;
-  const log = options.log ?? console.log;
   log(`economy-serve listening on ${address}`);
   return server;
 }
 
 // src/server/index.ts
 function printHelp() {
-  console.log(`Usage: economy-serve [options]
+  console.log(`Usage: economy-serve [command] [options]
 
 REST API server for ${packageMetadata.name}
+Foundation probes: GET /health, /ready, /version -> { status, version, mode }
+Versioned API: /v1/* (API-key auth via @hasna/contracts in cloud mode)
+
+Commands:
+  (default)          start the HTTP server
+  migrate            apply the cloud Postgres schema + api_keys, then exit
+  version            print { status, version, mode }
 
 Options:
   -p, --port <port>  Port to bind (default: ECONOMY_PORT or 3456)
@@ -4698,18 +7494,46 @@ function parsePort(raw, label) {
   }
   return value;
 }
+async function runMigrate() {
+  const { getCloudDatabaseUrl: getCloudDatabaseUrl2, createCloudPool: createCloudPool2, authClientFromPool: authClientFromPool2, cloudMigrations: cloudMigrations2 } = await Promise.resolve().then(() => (init_cloud(), exports_cloud));
+  const { applyPgMigrations } = await import("@hasna/cloud");
+  const { ApiKeyStore: ApiKeyStore2 } = await import("@hasna/contracts/auth");
+  const dsn = getCloudDatabaseUrl2();
+  if (!dsn)
+    throw new Error("migrate requires a Postgres DSN: set HASNA_ECONOMY_DATABASE_URL (or ECONOMY_DATABASE_URL / DATABASE_URL)");
+  const result = await applyPgMigrations(dsn, cloudMigrations2(), "economy");
+  const pool = createCloudPool2(dsn);
+  try {
+    await new ApiKeyStore2(authClientFromPool2(pool)).ensureSchema();
+  } finally {
+    await pool.end().catch(() => {});
+  }
+  console.log(JSON.stringify({ evt: "migrate", service: result.service, applied: result.applied, alreadyApplied: result.alreadyApplied, errors: result.errors, api_keys: "ensured" }));
+  if (result.errors.length)
+    process.exit(1);
+}
 var args = process.argv.slice(2);
-if (args.includes("--help") || args.includes("-h")) {
-  printHelp();
+var sub = args[0];
+if (sub === "version") {
+  console.log(JSON.stringify({ status: "ok", version: packageMetadata.version, mode: process.env["HASNA_ECONOMY_STORAGE_MODE"] === "cloud" ? "self_hosted" : "local" }));
   process.exit(0);
 }
-if (args.includes("--version") || args.includes("-V")) {
+if (sub === "migrate") {
+  runMigrate().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+} else if (args.includes("--help") || args.includes("-h")) {
+  printHelp();
+  process.exit(0);
+} else if (args.includes("--version") || args.includes("-V")) {
   console.log(packageMetadata.version);
   process.exit(0);
-}
-try {
-  startServer(resolvePort(args));
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
+} else {
+  try {
+    startServer(resolvePort(args));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
 }