@hasna/economy 0.2.43 → 0.3.1

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,125 +2228,51 @@ 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/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/cloud.ts
 var exports_cloud = {};
 __export(exports_cloud, {
   resolveSigningSecret: () => resolveSigningSecret,
   openCloudDatabase: () => openCloudDatabase,
   isCloudMode: () => isCloudMode,
-  getCloudDatabaseUrl: () => getCloudDatabaseUrl2,
+  getCloudDatabaseUrl: () => getCloudDatabaseUrl,
   createCloudPool: () => createCloudPool,
   cloudMigrations: () => cloudMigrations,
   authClientFromPool: () => authClientFromPool
 });
 import pg from "pg";
-function getCloudDatabaseUrl2() {
+function getCloudDatabaseUrl() {
   return process.env["HASNA_ECONOMY_DATABASE_URL"]?.trim() || process.env["ECONOMY_DATABASE_URL"]?.trim() || process.env["DATABASE_URL"]?.trim() || undefined;
 }
 function isCloudMode() {
@@ -1970,18 +2281,18 @@ function isCloudMode() {
     return true;
   if (mode === "local")
     return false;
-  return Boolean(getCloudDatabaseUrl2());
+  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 = getCloudDatabaseUrl2()) {
+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 = getCloudDatabaseUrl2()) {
+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;
@@ -4071,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);
@@ -4244,11 +4408,729 @@ 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/brief.ts
+init_database();
+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
+};
+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 requestPeriodWhere2(period) {
+  if (period === "today")
+    return `DATE(timestamp) = DATE('now')`;
+  return `timestamp >= DATE('now', 'weekday 0', '-7 days')`;
+}
+function sessionPeriodWhere2(period) {
+  if (period === "today")
+    return `DATE(started_at) = DATE('now')`;
+  return `started_at >= DATE('now', 'weekday 0', '-7 days')`;
+}
+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 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
+  };
+}
+function latestTimestamp(...values) {
+  return values.filter(Boolean).sort().at(-1) ?? null;
+}
+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 emptyTotals() {
+  return combineTotals(ZERO_REQUEST_TOTALS, ZERO_SESSION_TOTALS);
+}
+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);
@@ -4369,6 +5251,24 @@ function isAuthorizedRequest(req, path) {
 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";
 
@@ -4380,85 +5280,1590 @@ var openApiSpec = {
     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: [] }],
+  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" }
+      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 }
+      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" } } } } } } },
+    "/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" } } } } } } } }
+      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/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" } } } } } } } }
+      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/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" } } } } } } } }
+      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/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" } } } } } } } }
+      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/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" } } } } } }
+      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/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/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"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
   }
 };
 
@@ -4478,6 +6883,8 @@ var CORS = {
   "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;
@@ -4523,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") : [];
 }
@@ -4585,7 +6997,11 @@ function createHandler(db, options = {}) {
       return json(openApiDocument());
     }
     if (options.authenticator) {
-      const decision = await options.authenticator.authenticate(req.headers, { method, path: rawPath });
+      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)) {
@@ -4837,15 +7253,22 @@ function createHandler(db, options = {}) {
       } 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") {
@@ -4853,6 +7276,47 @@ function createHandler(db, options = {}) {
       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));
     }
@@ -4943,7 +7407,6 @@ function createHandler(db, options = {}) {
     return err("Not found", 404);
   };
 }
-var APP = "economy";
 function isLocalHost(host) {
   return ["127.0.0.1", "localhost", "::1"].includes(host);
 }
@@ -5032,10 +7495,10 @@ function parsePort(raw, label) {
   return value;
 }
 async function runMigrate() {
-  const { getCloudDatabaseUrl: getCloudDatabaseUrl3, createCloudPool: createCloudPool2, authClientFromPool: authClientFromPool2, cloudMigrations: cloudMigrations2 } = await Promise.resolve().then(() => (init_cloud(), exports_cloud));
+  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 = getCloudDatabaseUrl3();
+  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");