@hasna/economy 0.2.42 → 0.3.0

package/dist/index.js

@@ -14,14 +14,15 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
 
 // src/lib/pricing.ts
 var exports_pricing = {};
 __export(exports_pricing, {
   normalizeModelName: () => normalizeModelName,
+  getPricingFromRows: () => getPricingFromRows,
   getPricingFromDb: () => getPricingFromDb,
   getPricing: () => getPricing,
+  estimateCostFromRows: () => estimateCostFromRows,
   ensurePricingSeeded: () => ensurePricingSeeded,
   computeCostFromDb: () => computeCostFromDb,
   computeCost: () => computeCost,
@@ -212,6 +213,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;
@@ -514,41 +534,9 @@ var init_pricing = __esm(() => {
 
 // src/db/database.ts
 import { SqliteAdapter as Database } from "@hasna/cloud";
-import { execFileSync } from "child_process";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
-import { hostname, platform } from "os";
 import { homedir } from "os";
 import { join } from "path";
-function normalizeMachineId(value) {
-  const id = value?.trim().toLowerCase().split(".")[0];
-  return id && id.length > 0 ? id : null;
-}
-function macHostMachineId() {
-  if (platform() !== "darwin")
-    return null;
-  for (const key of ["LocalHostName", "ComputerName", "HostName"]) {
-    try {
-      const value = execFileSync("/usr/sbin/scutil", ["--get", key], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: 1000
-      });
-      const id = normalizeMachineId(value);
-      if (id && id !== "mac" && id !== "localhost")
-        return id;
-    } catch {}
-  }
-  return null;
-}
-function getMachineId() {
-  const envMachine = normalizeMachineId(process.env["ECONOMY_MACHINE_ID"]);
-  if (envMachine)
-    return envMachine;
-  const hostMachine = normalizeMachineId(hostname()) ?? "unknown";
-  if (hostMachine === "mac" || hostMachine === "localhost")
-    return macHostMachineId() ?? hostMachine;
-  return hostMachine;
-}
 function getDataDir() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
   const newDir = join(home, ".hasna", "economy");
@@ -895,56 +883,6 @@ function requestPeriodWhere(period) {
       return "1=1";
   }
 }
-function upsertRequest(db, req) {
-  const now = req.updated_at ?? new Date().toISOString();
-  db.prepare(`
-    INSERT OR REPLACE INTO requests
-      (id, agent, session_id, model, input_tokens, output_tokens,
-       cache_read_tokens, cache_create_tokens, cache_create_5m_tokens,
-       cache_create_1h_tokens, cost_usd, cost_basis, duration_ms, timestamp,
-       source_request_id, machine_id, attribution_tag, account_key, account_tool,
-       account_name, account_email, account_source, updated_at, synced_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(req.id, req.agent, req.session_id, req.model, req.input_tokens, req.output_tokens, req.cache_read_tokens, req.cache_create_tokens, req.cache_create_5m_tokens ?? req.cache_create_tokens, req.cache_create_1h_tokens ?? 0, req.cost_usd, req.cost_basis ?? "estimated", req.duration_ms, req.timestamp, req.source_request_id, req.machine_id ?? "", req.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", req.account_key ?? "", req.account_tool ?? "", req.account_name ?? "", req.account_email ?? "", req.account_source ?? "", now, req.synced_at ?? "");
-}
-function upsertSession(db, session) {
-  const now = session.updated_at ?? new Date().toISOString();
-  db.prepare(`
-    INSERT OR REPLACE INTO sessions
-      (id, agent, project_path, project_name, started_at, ended_at,
-       total_cost_usd, total_tokens, request_count, machine_id, attribution_tag,
-       account_key, account_tool, account_name, account_email, account_source, updated_at, synced_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(session.id, session.agent, session.project_path, session.project_name, session.started_at, session.ended_at ?? null, session.total_cost_usd, session.total_tokens, session.request_count, session.machine_id ?? "", session.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", session.account_key ?? "", session.account_tool ?? "", session.account_name ?? "", session.account_email ?? "", session.account_source ?? "", now, session.synced_at ?? "");
-}
-function rollupSession(db, sessionId) {
-  db.prepare(`
-    UPDATE sessions SET
-      total_cost_usd = (SELECT COALESCE(SUM(cost_usd), 0) FROM requests WHERE session_id = ?),
-      total_tokens   = (SELECT COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) FROM requests WHERE session_id = ?),
-      request_count  = (SELECT COUNT(*) FROM requests WHERE session_id = ?),
-      ended_at       = (SELECT MAX(timestamp) FROM requests WHERE session_id = ?),
-      started_at     = CASE WHEN started_at = '' OR started_at IS NULL
-                            THEN (SELECT MIN(timestamp) FROM requests WHERE session_id = ?)
-                            ELSE started_at END,
-      account_key    = CASE WHEN account_key = '' OR account_key IS NULL
-                            THEN COALESCE((SELECT account_key FROM requests WHERE session_id = ? AND account_key != '' ORDER BY timestamp DESC LIMIT 1), '')
-                            ELSE account_key END,
-      account_tool   = CASE WHEN account_tool = '' OR account_tool IS NULL
-                            THEN COALESCE((SELECT account_tool FROM requests WHERE session_id = ? AND account_tool != '' ORDER BY timestamp DESC LIMIT 1), '')
-                            ELSE account_tool END,
-      account_name   = CASE WHEN account_name = '' OR account_name IS NULL
-                            THEN COALESCE((SELECT account_name FROM requests WHERE session_id = ? AND account_name != '' ORDER BY timestamp DESC LIMIT 1), '')
-                            ELSE account_name END,
-      account_email  = CASE WHEN account_email = '' OR account_email IS NULL
-                            THEN COALESCE((SELECT account_email FROM requests WHERE session_id = ? AND account_email != '' ORDER BY timestamp DESC LIMIT 1), '')
-                            ELSE account_email END,
-      account_source = CASE WHEN account_source = '' OR account_source IS NULL
-                            THEN COALESCE((SELECT account_source FROM requests WHERE session_id = ? AND account_source != '' ORDER BY timestamp DESC LIMIT 1), '')
-                            ELSE account_source END
-    WHERE id = ?
-  `).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId);
-}
 function querySessions(db, filter = {}) {
   const conditions = [];
   const params = [];
@@ -1033,21 +971,6 @@ function querySummary(db, period, machine, allMachines = false, agent) {
     period
   };
 }
-function queryZeroCostTokenizedModels(db, limit = 10) {
-  return db.prepare(`
-    SELECT agent,
-           model,
-           COUNT(*) as requests,
-           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
-           MAX(timestamp) as last_seen
-    FROM requests
-    WHERE cost_usd = 0
-      AND (input_tokens > 0 OR output_tokens > 0 OR cache_read_tokens > 0 OR cache_create_tokens > 0)
-    GROUP BY agent, model
-    ORDER BY requests DESC, total_tokens DESC
-    LIMIT ?
-  `).all(limit);
-}
 function queryModelBreakdown(db) {
   return db.prepare(`
     SELECT model, agent,
@@ -1385,6 +1308,148 @@ function queryAccountBreakdown(db, period = "all", machine) {
   result.sort((a, b) => b.cost_usd - a.cost_usd);
   return result;
 }
+function queryProjectBreakdownSince(db, since) {
+  return db.prepare(`
+    SELECT project_path, project_name,
+           COUNT(*) as sessions,
+           COALESCE(SUM(total_tokens), 0) as total_tokens,
+           COALESCE(SUM(request_count), 0) as requests,
+           COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+           MAX(started_at) as last_active
+    FROM sessions WHERE started_at >= ?
+    GROUP BY project_path ORDER BY cost_usd DESC
+  `).all(since);
+}
+function queryAgentBreakdownSince(db, since) {
+  return db.prepare(`
+    SELECT agent,
+           COUNT(DISTINCT session_id) as sessions,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+           MAX(timestamp) as last_active
+    FROM requests
+    WHERE timestamp >= ?
+    GROUP BY agent
+    ORDER BY api_equivalent_usd DESC
+  `).all(since);
+}
+function queryModelBreakdownSince(db, since) {
+  return db.prepare(`
+    SELECT model, agent,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens), 0) as input_tokens,
+           COALESCE(SUM(output_tokens), 0) as output_tokens,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM requests WHERE timestamp >= ?
+    GROUP BY model, agent ORDER BY cost_usd DESC
+  `).all(since);
+}
+function queryAccountBreakdownSince(db, since) {
+  return db.prepare(`
+    WITH request_rows AS (
+      SELECT
+        r.session_id as session_id,
+        COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), 'unknown') as account_agent,
+        COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') as raw_account_key,
+        COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') as raw_account_name,
+        LOWER(TRIM(COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), ''))) as raw_account_email,
+        COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown') as account_source,
+        1 as requests,
+        COALESCE(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens, 0) as total_tokens,
+        COALESCE(r.cost_usd, 0) as cost_usd,
+        COALESCE(NULLIF(r.cost_basis, ''), 'estimated') as cost_basis,
+        r.timestamp as last_active
+      FROM requests r
+      LEFT JOIN sessions s ON s.id = r.session_id
+      WHERE r.timestamp >= ?
+        AND (
+          COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') != ''
+        )
+    ),
+    session_only_rows AS (
+      SELECT
+        s.id as session_id,
+        COALESCE(NULLIF(s.agent, ''), NULLIF(s.account_tool, ''), 'unknown') as account_agent,
+        s.account_key as raw_account_key,
+        s.account_name as raw_account_name,
+        LOWER(TRIM(COALESCE(s.account_email, ''))) as raw_account_email,
+        COALESCE(NULLIF(s.account_source, ''), 'unknown') as account_source,
+        COALESCE(s.request_count, 0) as requests,
+        COALESCE(s.total_tokens, 0) as total_tokens,
+        COALESCE(s.total_cost_usd, 0) as cost_usd,
+        'estimated' as cost_basis,
+        s.started_at as last_active
+      FROM sessions s
+      WHERE s.started_at >= ?
+        AND s.id NOT IN (SELECT DISTINCT session_id FROM requests)
+        AND (s.account_key != '' OR s.account_tool != '' OR s.account_name != '' OR s.account_email != '')
+    ),
+    normalized AS (
+      SELECT
+        CASE
+          WHEN raw_account_email != '' THEN account_agent || ':' || raw_account_email
+          WHEN raw_account_name != '' THEN account_agent || ':' || raw_account_name
+          ELSE raw_account_key
+        END as account_key,
+        account_agent as account_tool,
+        raw_account_name as account_name,
+        raw_account_email as account_email,
+        account_source,
+        session_id,
+        requests,
+        total_tokens,
+        cost_usd,
+        cost_basis,
+        last_active
+      FROM request_rows
+      UNION ALL
+      SELECT
+        CASE
+          WHEN raw_account_email != '' THEN account_agent || ':' || raw_account_email
+          WHEN raw_account_name != '' THEN account_agent || ':' || raw_account_name
+          ELSE raw_account_key
+        END as account_key,
+        account_agent as account_tool,
+        raw_account_name as account_name,
+        raw_account_email as account_email,
+        account_source,
+        session_id,
+        requests,
+        total_tokens,
+        cost_usd,
+        cost_basis,
+        last_active
+      FROM session_only_rows
+    )
+    SELECT account_key,
+           account_tool,
+           COALESCE(MAX(NULLIF(account_name, '')), MAX(NULLIF(account_email, '')), account_key) as account_name,
+           NULLIF(account_email, '') as account_email,
+           COALESCE(MAX(NULLIF(account_source, 'unknown')), 'unknown') as account_source,
+           COUNT(DISTINCT session_id) as sessions,
+           COALESCE(SUM(requests), 0) as requests,
+           COALESCE(SUM(total_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as metered_api_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+           COALESCE(SUM(CASE WHEN cost_basis NOT IN ('metered_api', 'subscription_included', 'unknown') THEN cost_usd ELSE 0 END), 0) as estimated_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd,
+           COALESCE(SUM(cost_usd), 0) as cost_usd,
+           MAX(last_active) as last_active
+    FROM normalized
+    WHERE account_key != ''
+    GROUP BY account_key, account_tool, account_email
+    ORDER BY api_equivalent_usd DESC
+  `).all(since, since);
+}
 function queryDailyBreakdown(db, days = 30, machine) {
   const machineClause = machine ? " AND machine_id = ?" : "";
   const params = machine ? [`-${days}`, machine] : [`-${days}`];
@@ -1396,21 +1461,6 @@ function queryDailyBreakdown(db, days = 30, machine) {
     ORDER BY date ASC
   `).all(...params);
 }
-function queryHourlyBreakdown(db, machine, hours) {
-  const clauses = hours == null ? [`DATE(timestamp) = DATE('now')`] : [`DATETIME(timestamp) >= DATETIME('now', ?)`];
-  const params = hours == null ? [] : [`-${hours} hours`];
-  if (machine) {
-    clauses.push("machine_id = ?");
-    params.push(machine);
-  }
-  return db.prepare(`
-    SELECT STRFTIME('%H', timestamp) as hour, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
-    FROM requests
-    WHERE ${clauses.join(" AND ")}
-    GROUP BY STRFTIME('%H', timestamp), agent
-    ORDER BY hour ASC
-  `).all(...params);
-}
 function upsertProject(db, project) {
   db.prepare(`
     INSERT OR REPLACE INTO projects (id, path, name, description, tags, created_at)
@@ -1423,9 +1473,6 @@ function getProject(db, path) {
     return null;
   return { ...row, tags: JSON.parse(row["tags"] ?? "[]") };
 }
-function listProjects(db) {
-  return db.prepare(`SELECT * FROM projects ORDER BY created_at DESC`).all().map((row) => ({ ...row, tags: JSON.parse(row["tags"] ?? "[]") }));
-}
 function deleteProject(db, path) {
   db.prepare(`DELETE FROM projects WHERE path = ?`).run(path);
 }
@@ -1508,25 +1555,9 @@ function getGoalStatuses(db) {
     };
   });
 }
-function getIngestState(db, source, key) {
-  const row = db.prepare(`SELECT value FROM ingest_state WHERE source = ? AND key = ?`).get(source, key);
-  return row?.value ?? null;
-}
-function 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)
-    VALUES (?, ?, ?, ?, ?)
-  `).run(row.date, row.provider, row.description, row.cost_usd, row.updated_at);
-}
-function clearBillingRange(db, provider, fromDate, toDate) {
-  db.prepare(`DELETE FROM billing_daily WHERE provider = ? AND date >= ? AND date <= ?`).run(provider, fromDate, toDate);
-}
 function queryBillingSummary(db, period) {
   const where = period === "today" ? `date = DATE('now')` : period === "yesterday" ? `date = DATE('now', '-1 day')` : period === "week" ? `date >= DATE('now', 'weekday 0', '-7 days')` : period === "month" ? `date >= DATE('now', 'start of month')` : period === "year" ? `date >= DATE('now', 'start of year')` : "1=1";
   const rows = db.prepare(`SELECT provider, SUM(cost_usd) as cost FROM billing_daily WHERE ${where} GROUP BY provider`).all();
@@ -1538,6 +1569,13 @@ function queryBillingSummary(db, period) {
   }
   return { total_usd: total, by_provider };
 }
+function getSessionDetail(db, id) {
+  const session = db.prepare(`SELECT * FROM sessions WHERE id = ? OR id LIKE ?`).get(id, `${id}%`);
+  if (!session)
+    return null;
+  const requests = db.prepare(`SELECT * FROM requests WHERE session_id = ? ORDER BY timestamp ASC`).all(session["id"]);
+  return { session, requests };
+}
 function listMachines(db, period = "all") {
   const rWhere = requestPeriodWhere(period);
   const sWhere = sessionPeriodWhere(period);
@@ -1630,14 +1668,6 @@ function listSubscriptions(db) {
 function deleteSubscription(db, id) {
   db.prepare(`DELETE FROM subscriptions WHERE id = ?`).run(id);
 }
-function upsertUsageSnapshot(db, snap) {
-  const now = snap.updated_at ?? new Date().toISOString();
-  const id = snap.id ?? `${snap.agent}-${snap.date}-${snap.metric}-${snap.machine_id}`;
-  db.prepare(`
-    INSERT OR REPLACE INTO usage_snapshots (id, agent, date, metric, value, unit, machine_id, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(id, snap.agent, snap.date, snap.metric, snap.value, snap.unit, snap.machine_id, now);
-}
 function queryUsageSnapshots(db, opts = {}) {
   const conditions = [];
   const params = [];
@@ -1659,27 +1689,6 @@ function queryUsageSnapshots(db, opts = {}) {
 function listMachineRegistry(db) {
   return db.prepare(`SELECT * FROM machines ORDER BY last_seen_at DESC`).all();
 }
-function dedupeRequests(db) {
-  const dupes = db.prepare(`
-    SELECT source_request_id, agent, COALESCE(machine_id, '') as machine_id, MIN(id) as keep_id, COUNT(*) as cnt
-    FROM requests
-    WHERE source_request_id != '' AND source_request_id IS NOT NULL
-    GROUP BY source_request_id, agent, COALESCE(machine_id, '')
-    HAVING cnt > 1
-  `).all();
-  let removed = 0;
-  for (const row of dupes) {
-    const result = db.prepare(`
-      DELETE FROM requests
-      WHERE source_request_id = ?
-        AND agent = ?
-        AND COALESCE(machine_id, '') = ?
-        AND id != ?
-    `).run(row.source_request_id, row.agent, row.machine_id, row.keep_id);
-    removed += result.changes;
-  }
-  return removed;
-}
 var init_database = () => {};
 
 // src/lib/agents.ts
@@ -1702,1542 +1711,1775 @@ var COST_BASIS = [
 function isAgent(value) {
   return AGENTS.includes(value);
 }
-// src/index.ts
+// src/lib/store/index.ts
 init_database();
 init_pricing();
+import { randomUUID } from "crypto";
 
-// src/lib/gatherer.ts
-init_database();
-var SYSTEM_PROMPT = "You are a cost-aware AI assistant that tracks API usage, identifies expensive patterns, and helps optimize spending.";
-function hasCostData(summary) {
-  return summary.total_usd > 0 || summary.sessions > 0 || summary.requests > 0 || summary.tokens > 0;
-}
-var gatherTrainingData = async (options = {}) => {
-  const limit = options.limit ?? 500;
-  const examples = [];
-  try {
-    const db = openDatabase();
-    const periods = ["today", "week", "month", "all"];
-    for (const period of periods) {
-      try {
-        const s = querySummary(db, period);
-        if (!hasCostData(s))
-          continue;
-        examples.push({
-          messages: [
-            { role: "system", content: SYSTEM_PROMPT },
-            { role: "user", content: `What did I spend on AI ${period === "all" ? "in total" : period}?` },
-            {
-              role: "assistant",
-              content: `${period === "all" ? "Total" : period.charAt(0).toUpperCase() + period.slice(1)} AI spending: $${s.total_usd.toFixed(4)} across ${s.sessions} session(s), ${s.requests} request(s), ${s.tokens.toLocaleString()} tokens.`
-            }
-          ]
-        });
-      } catch {}
-    }
-    const sessions = querySessions(db, {
-      limit: Math.min(Math.floor(limit / 4), 50),
-      since: options.since?.toISOString().substring(0, 10)
-    });
-    for (const s of sessions) {
-      examples.push({
-        messages: [
-          { role: "system", content: SYSTEM_PROMPT },
-          {
-            role: "user",
-            content: `How much did the session "${s.id.substring(0, 12)}" cost?`
-          },
-          {
-            role: "assistant",
-            content: `Session ${s.id.substring(0, 12)} (${s.agent}, project: ${s.project_name || "unknown"}): $${s.total_cost_usd.toFixed(4)}, ${s.total_tokens.toLocaleString()} tokens, ${s.request_count} requests. Started: ${s.started_at.substring(0, 16)}.`
-          }
-        ]
-      });
-      examples.push({
-        messages: [
-          { role: "system", content: SYSTEM_PROMPT },
-          {
-            role: "user",
-            content: `What was the token usage for session ${s.id.substring(0, 12)}?`
-          },
-          {
-            role: "assistant",
-            content: `Session ${s.id.substring(0, 12)} used ${s.total_tokens.toLocaleString()} tokens across ${s.request_count} requests on project "${s.project_name || "unknown"}" (${s.agent}).`
-          }
-        ]
-      });
-      if (examples.length >= limit)
-        break;
-    }
-    const modelBreakdown = queryModelBreakdown(db);
-    if (modelBreakdown.length > 0) {
-      const topModels = modelBreakdown.slice(0, 5);
-      examples.push({
-        messages: [
-          { role: "system", content: SYSTEM_PROMPT },
-          { role: "user", content: "Which AI models have I spent the most on?" },
-          {
-            role: "assistant",
-            content: `Model cost breakdown (top ${topModels.length}):
-${topModels.map((m) => `- ${m.model} (${m.agent}): $${m.cost_usd.toFixed(4)}, ${m.requests} requests, ${m.total_tokens.toLocaleString()} tokens`).join(`
-`)}`
-          }
-        ]
-      });
-      for (const m of topModels) {
-        examples.push({
-          messages: [
-            { role: "system", content: SYSTEM_PROMPT },
-            { role: "user", content: `How much have I spent on ${m.model}?` },
-            {
-              role: "assistant",
-              content: `${m.model} (${m.agent}): $${m.cost_usd.toFixed(4)} total across ${m.requests.toLocaleString()} requests and ${m.total_tokens.toLocaleString()} tokens.`
-            }
-          ]
-        });
-      }
-    }
-    const projectBreakdown = queryProjectBreakdown(db);
-    if (projectBreakdown.length > 0) {
-      const topProjects = projectBreakdown.slice(0, 5);
-      examples.push({
-        messages: [
-          { role: "system", content: SYSTEM_PROMPT },
-          { role: "user", content: "Which projects are costing the most?" },
-          {
-            role: "assistant",
-            content: `Project cost breakdown (top ${topProjects.length}):
-${topProjects.map((p) => `- ${p.project_name || "unknown"}: $${p.cost_usd.toFixed(4)}, ${p.sessions} sessions`).join(`
-`)}`
-          }
-        ]
-      });
-      for (const p of topProjects.slice(0, 3)) {
-        examples.push({
-          messages: [
-            { role: "system", content: SYSTEM_PROMPT },
-            { role: "user", content: `What is the AI spend for project "${p.project_name}"?` },
-            {
-              role: "assistant",
-              content: `Project "${p.project_name}": $${p.cost_usd.toFixed(4)} across ${p.sessions} session(s) and ${p.requests.toLocaleString()} requests. Last active: ${p.last_active?.substring(0, 10) ?? "unknown"}.`
-            }
-          ]
-        });
-      }
-    }
-    try {
-      const budgets = getBudgetStatuses(db);
-      if (budgets.length > 0) {
-        examples.push({
-          messages: [
-            { role: "system", content: SYSTEM_PROMPT },
-            { role: "user", content: "How am I tracking against my AI spending budgets?" },
-            {
-              role: "assistant",
-              content: `Budget status:
-${budgets.map((b) => `- ${b.project_path ?? "global"} (${b.period}): $${b.current_spend_usd.toFixed(4)} / $${b.limit_usd.toFixed(2)} (${b.percent_used.toFixed(1)}%) \u2014 ${b.is_over_limit ? "OVER LIMIT" : b.is_over_alert ? "ALERT" : "OK"}`).join(`
-`)}`
-            }
-          ]
-        });
-      }
-    } catch {}
-    try {
-      const goals = getGoalStatuses(db);
-      if (goals.length > 0) {
-        examples.push({
-          messages: [
-            { role: "system", content: SYSTEM_PROMPT },
-            { role: "user", content: "Am I on track with my AI cost reduction goals?" },
-            {
-              role: "assistant",
-              content: `Goal progress:
-${goals.map((g) => `- ${g.period} goal (${g.project_path ?? g.agent ?? "global"}): $${g.current_spend_usd.toFixed(4)} / $${g.limit_usd.toFixed(2)} (${g.percent_used.toFixed(1)}%) \u2014 ${g.is_over ? "OVER" : g.is_at_risk ? "AT RISK" : "ON TRACK"}`).join(`
-`)}`
-            }
-          ]
-        });
-      }
-    } catch {}
-    const weekSummary = querySummary(db, "week");
-    const monthSummary = querySummary(db, "month");
-    if (weekSummary.total_usd > 0) {
-      const projectedMonthly = weekSummary.total_usd / 7 * 30;
-      examples.push({
-        messages: [
-          { role: "system", content: SYSTEM_PROMPT },
-          { role: "user", content: "Based on my usage, what will I spend this month?" },
-          {
-            role: "assistant",
-            content: `Based on your last 7 days ($${weekSummary.total_usd.toFixed(4)}), projected monthly spend is approximately $${projectedMonthly.toFixed(2)}. Current month-to-date: $${monthSummary.total_usd.toFixed(4)}.`
-          }
-        ]
-      });
-    }
-    if (modelBreakdown.length > 1) {
-      const expensive = modelBreakdown[0];
-      const cheaper = modelBreakdown[modelBreakdown.length - 1];
-      examples.push({
-        messages: [
-          { role: "system", content: SYSTEM_PROMPT },
-          { role: "user", content: "How can I reduce my AI API costs?" },
-          {
-            role: "assistant",
-            content: `Your most expensive model is ${expensive.model} at $${expensive.cost_usd.toFixed(4)}. Consider switching some workloads to ${cheaper.model} ($${cheaper.cost_usd.toFixed(4)}) for cost savings. Cache frequently repeated prompts to reduce cache-miss costs.`
-          }
-        ]
-      });
-    }
-  } catch {}
-  const finalExamples = examples.slice(0, limit);
-  return { source: "economy", examples: finalExamples, count: finalExamples.length };
-};
-// src/lib/model-config.ts
-init_database();
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname, join as join2 } from "path";
-var DEFAULT_MODEL = "gpt-4o-mini";
-function getModelConfigPath() {
-  return process.env["HASNA_ECONOMY_CONFIG_PATH"] ?? join2(getDataDir(), "config.json");
-}
-function loadConfig() {
-  try {
-    const configPath = getModelConfigPath();
-    if (existsSync2(configPath)) {
-      return JSON.parse(readFileSync(configPath, "utf-8"));
-    }
-  } catch {}
-  return {};
-}
-function saveConfig(config) {
-  const configPath = getModelConfigPath();
-  const dir = dirname(configPath);
-  if (!existsSync2(dir))
-    mkdirSync2(dir, { recursive: true });
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + `
-`);
-}
-function getActiveModel() {
-  return loadConfig().activeModel ?? DEFAULT_MODEL;
-}
-function setActiveModel(id) {
-  const config = loadConfig();
-  config.activeModel = id;
-  saveConfig(config);
-}
-function clearActiveModel() {
-  const config = loadConfig();
-  delete config.activeModel;
-  saveConfig(config);
-}
-// src/lib/open-projects.ts
-init_database();
-async function syncOpenProjectsRegistry(db, listActiveProjects) {
-  let listProjects2 = listActiveProjects;
-  if (!listProjects2) {
-    const projectsApi = await import("@hasna/projects");
-    listProjects2 = projectsApi.listProjects;
-  }
-  const projects = listProjects2({ status: "active", limit: 5000 });
-  let imported = 0;
-  let skipped = 0;
-  for (const project of projects) {
-    if (!project.path) {
-      skipped++;
-      continue;
-    }
-    upsertProject(db, {
-      id: project.id,
-      path: project.path,
-      name: project.name,
-      description: project.description,
-      tags: project.tags ?? [],
-      created_at: project.created_at
-    });
-    imported++;
+// src/lib/savings.ts
+function periodWhere2(period, column) {
+  switch (period) {
+    case "today":
+      return `DATE(${column}) = DATE('now')`;
+    case "yesterday":
+      return `DATE(${column}) = DATE('now', '-1 day')`;
+    case "week":
+      return `${column} >= DATE('now', 'weekday 0', '-7 days')`;
+    case "month":
+      return `${column} >= DATE('now', 'start of month')`;
+    case "year":
+      return `${column} >= DATE('now', 'start of year')`;
+    case "all":
+      return "1=1";
   }
-  return { imported, skipped };
-}
-// src/lib/peer-sync.ts
-init_database();
-import { Database as BunDatabase } from "bun:sqlite";
-import { existsSync as existsSync3 } from "fs";
-
-// src/lib/package-metadata.ts
-import { readFileSync as readFileSync2 } from "fs";
-var cachedMetadata = null;
-function getPackageMetadata() {
-  if (cachedMetadata)
-    return cachedMetadata;
-  const raw = readFileSync2(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/peer-sync.ts
-var GENERIC_PEER_TABLES = [
-  "usage_snapshots",
-  "subscriptions",
-  "billing_daily",
-  "savings_daily",
-  "budgets",
-  "goals",
-  "model_pricing",
-  "machines"
-];
-function quoteIdent(identifier) {
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-function tableExists(db, table) {
-  const row = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(table);
-  return Boolean(row);
 }
-function tableColumns(db, table) {
-  if (!tableExists(db, table))
-    return [];
-  return db.prepare(`PRAGMA table_info(${quoteIdent(table)})`).all();
-}
-function commonColumns(source, target, table) {
-  const sourceCols = new Set(tableColumns(source, table).map((c) => c.name));
-  return tableColumns(target, table).map((c) => c.name).filter((c) => sourceCols.has(c));
-}
-function primaryKeyColumns(db, table) {
-  return tableColumns(db, table).filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk).map((c) => c.name);
-}
-function selectRows(source, table, columns) {
-  if (columns.length === 0)
-    return [];
-  const select = columns.map(quoteIdent).join(", ");
-  return source.prepare(`SELECT ${select} FROM ${quoteIdent(table)}`).all();
+function prorateMonthlyFee(monthlyFee, period) {
+  const now = new Date;
+  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+  switch (period) {
+    case "today":
+    case "yesterday":
+      return monthlyFee / daysInMonth;
+    case "week":
+      return monthlyFee / daysInMonth * 7;
+    case "month":
+      return monthlyFee;
+    case "year":
+      return monthlyFee * 12;
+    case "all":
+      return monthlyFee;
+  }
 }
-function rowByKey(target, table, keyColumns, row) {
-  if (keyColumns.length === 0)
-    return null;
-  if (keyColumns.some((c) => row[c] == null))
-    return null;
-  const where = keyColumns.map((c) => `${quoteIdent(c)} = ?`).join(" AND ");
-  return target.prepare(`SELECT * FROM ${quoteIdent(table)} WHERE ${where}`).get(...keyColumns.map((c) => row[c]));
+function proratedIncludedConsumed(includedUsage, includedCap, period) {
+  const cap = prorateMonthlyFee(includedCap, period);
+  return cap > 0 ? Math.min(includedUsage, cap) : includedUsage;
 }
-function hasId(target, table, id) {
-  return target.prepare(`SELECT id, machine_id FROM ${quoteIdent(table)} WHERE id = ?`).get(id);
+function computeSavedUsd(apiEquivalent, onDemand, subscriptionFee) {
+  return Math.max(0, apiEquivalent - onDemand - subscriptionFee);
 }
-function shouldReplace(source, existing) {
-  if (!existing)
-    return true;
-  const sourceUpdated = source["updated_at"];
-  const existingUpdated = existing["updated_at"];
-  if (typeof sourceUpdated === "string" && typeof existingUpdated === "string" && existingUpdated !== "") {
-    return sourceUpdated >= existingUpdated;
-  }
-  return true;
-}
-function normalizeRow(row, columns, sourceMachine, now) {
-  const next = { ...row };
-  if (columns.includes("machine_id") && (!next["machine_id"] || next["machine_id"] === "")) {
-    next["machine_id"] = sourceMachine;
-  }
-  if (columns.includes("updated_at") && (!next["updated_at"] || next["updated_at"] === "")) {
-    next["updated_at"] = next["timestamp"] ?? next["started_at"] ?? next["created_at"] ?? now;
-  }
-  if (columns.includes("synced_at") && next["synced_at"] == null)
-    next["synced_at"] = "";
-  if (columns.includes("attribution_tag") && next["attribution_tag"] == null)
-    next["attribution_tag"] = "";
-  return next;
-}
-function insertOrReplace(target, table, columns, row) {
-  const colSql = columns.map(quoteIdent).join(", ");
-  const placeholders = columns.map(() => "?").join(", ");
-  target.prepare(`
-    INSERT OR REPLACE INTO ${quoteIdent(table)} (${colSql})
-    VALUES (${placeholders})
-  `).run(...columns.map((c) => row[c] ?? null));
-}
-function collisionId(target, table, machine, originalId) {
-  const base = `${machine || "peer"}:${originalId}`;
-  const baseRow = hasId(target, table, base);
-  if (!baseRow || String(baseRow["machine_id"] ?? "") === machine)
-    return base;
-  for (let i = 2;; i++) {
-    const candidate = `${base}:${i}`;
-    const row = hasId(target, table, candidate);
-    if (!row || String(row["machine_id"] ?? "") === machine)
-      return candidate;
-  }
-}
-function mergeIdentityTable(target, source, table, sourceMachine, now, sessionIdMap) {
-  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
-  const columns = commonColumns(source, target, table);
-  const rows = selectRows(source, table, columns);
-  const idMap = new Map;
-  for (const raw of rows) {
-    const row = normalizeRow(raw, columns, sourceMachine, now);
-    const originalId = String(row["id"] ?? "");
-    if (!originalId) {
-      stats.skipped++;
-      continue;
-    }
-    const machine = String(row["machine_id"] ?? "");
-    const directExisting = hasId(target, table, originalId);
-    if (directExisting && String(directExisting["machine_id"] ?? "") !== machine) {
-      row["id"] = collisionId(target, table, machine, originalId);
-      stats.collisions++;
-    }
-    if (table === "requests" && sessionIdMap) {
-      const originalSessionId = String(row["session_id"] ?? "");
-      row["session_id"] = sessionIdMap.get(originalSessionId) ?? originalSessionId;
-    }
-    const existing = hasId(target, table, String(row["id"]));
-    idMap.set(originalId, String(row["id"]));
-    if (existing && !shouldReplace(row, existing)) {
-      stats.skipped++;
-      continue;
-    }
-    insertOrReplace(target, table, columns, row);
-    if (existing)
-      stats.updated++;
-    else
-      stats.inserted++;
-  }
-  return { stats, idMap };
-}
-function mergeProjects(target, source) {
-  const table = "projects";
-  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
-  const columns = commonColumns(source, target, table);
-  const rows = selectRows(source, table, columns);
-  for (const raw of rows) {
-    const row = { ...raw };
-    const path = String(row["path"] ?? "");
-    const id = String(row["id"] ?? "");
-    if (!path || !id) {
-      stats.skipped++;
-      continue;
-    }
-    const existingByPath = target.prepare(`SELECT * FROM projects WHERE path = ?`).get(path);
-    if (existingByPath) {
-      row["id"] = existingByPath["id"] ?? id;
-      insertOrReplace(target, table, columns, row);
-      stats.updated++;
-      continue;
-    }
-    const existingById = target.prepare(`SELECT * FROM projects WHERE id = ?`).get(id);
-    if (existingById && String(existingById["path"] ?? "") !== path) {
-      row["id"] = `peer:${id}`;
-      stats.collisions++;
-      while (target.prepare(`SELECT id FROM projects WHERE id = ?`).get(row["id"])) {
-        row["id"] = `peer:${String(row["id"])}`;
-      }
+function querySavingsSummary(db, period, agent) {
+  const where = periodWhere2(period, "timestamp");
+  const agentClause = agent ? " AND agent = ?" : "";
+  const params = agent ? [agent] : [];
+  const apiRow = db.prepare(`
+    SELECT COALESCE(SUM(cost_usd), 0) as total
+    FROM requests
+    WHERE ${where}${agentClause}
+      AND COALESCE(cost_basis, 'estimated') IN ('metered_api', 'estimated', 'unknown')
+  `).get(...params);
+  const includedRow = db.prepare(`
+    SELECT COALESCE(SUM(cost_usd), 0) as total
+    FROM requests
+    WHERE ${where}${agentClause}
+      AND cost_basis = 'subscription_included'
+  `).get(...params);
+  const subWhere = periodWhere2(period, "date");
+  const onDemandRow = db.prepare(`
+    SELECT COALESCE(SUM(value), 0) as total
+    FROM usage_snapshots
+    WHERE ${subWhere}${agent ? " AND agent = ?" : ""}
+      AND metric = 'on_demand_usd'
+  `).get(...params);
+  const subs = db.prepare(`
+    SELECT
+      COALESCE(SUM(monthly_fee_usd), 0) as fee,
+      COALESCE(SUM(included_usage_usd), 0) as included
+    FROM subscriptions
+    WHERE active = 1${agent ? " AND (agent = ? OR agent IS NULL)" : ""}
+  `).get(...agent ? [agent] : []);
+  const subscriptionFee = prorateMonthlyFee(subs.fee, period);
+  const apiEquivalent = apiRow.total + includedRow.total;
+  const includedConsumed = proratedIncludedConsumed(includedRow.total, subs.included, period);
+  const onDemand = onDemandRow.total;
+  const saved = computeSavedUsd(apiEquivalent, onDemand, subscriptionFee);
+  const byAgent = {};
+  if (!agent) {
+    const onDemandByAgent = new Map;
+    for (const row of db.prepare(`
+      SELECT agent, COALESCE(SUM(value), 0) as total
+      FROM usage_snapshots
+      WHERE ${subWhere}
+        AND metric = 'on_demand_usd'
+      GROUP BY agent
+    `).all()) {
+      onDemandByAgent.set(row.agent, row.total);
     }
-    insertOrReplace(target, table, columns, row);
-    stats.inserted++;
-  }
-  return stats;
-}
-function mergeGenericTable(target, source, table, sourceMachine, now) {
-  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
-  const columns = commonColumns(source, target, table);
-  const keyColumns = primaryKeyColumns(target, table).filter((c) => columns.includes(c));
-  const rows = selectRows(source, table, columns);
-  for (const raw of rows) {
-    const row = normalizeRow(raw, columns, sourceMachine, now);
-    const existing = rowByKey(target, table, keyColumns, row);
-    if (existing && !shouldReplace(row, existing)) {
-      stats.skipped++;
-      continue;
+    const subscriptionByAgent = new Map;
+    for (const row of db.prepare(`
+      SELECT agent,
+             COALESCE(SUM(monthly_fee_usd), 0) as fee,
+             COALESCE(SUM(included_usage_usd), 0) as included
+      FROM subscriptions
+      WHERE active = 1 AND agent IS NOT NULL
+      GROUP BY agent
+    `).all()) {
+      subscriptionByAgent.set(row.agent, row);
     }
-    insertOrReplace(target, table, columns, row);
-    if (existing)
-      stats.updated++;
-    else
-      stats.inserted++;
-  }
-  return stats;
-}
-function detectSourceMachine(source, fallback) {
-  if (fallback && fallback.trim())
-    return fallback.trim();
-  const counts = new Map;
-  for (const table of ["sessions", "requests", "usage_snapshots"]) {
-    if (!tableExists(source, table))
-      continue;
-    const rows = source.prepare(`
-      SELECT machine_id, COUNT(*) as cnt
-      FROM ${quoteIdent(table)}
-      WHERE machine_id != '' AND machine_id IS NOT NULL
-      GROUP BY machine_id
+    const globalSubs = db.prepare(`
+      SELECT
+        COALESCE(SUM(monthly_fee_usd), 0) as fee,
+        COALESCE(SUM(included_usage_usd), 0) as included
+      FROM subscriptions
+      WHERE active = 1 AND agent IS NULL
+    `).get();
+    const rows = db.prepare(`
+      SELECT agent,
+             COALESCE(SUM(cost_usd), 0) as api_eq,
+             COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as included
+      FROM requests WHERE ${where}
+      GROUP BY agent
     `).all();
-    for (const row of rows) {
-      counts.set(row.machine_id, (counts.get(row.machine_id) ?? 0) + row.cnt);
-    }
-  }
-  let best = "";
-  let bestCount = -1;
-  for (const [machine, count] of counts.entries()) {
-    if (count > bestCount) {
-      best = machine;
-      bestCount = count;
-    }
-  }
-  return best || "peer";
-}
-function ensureMachineRegistry(target, machine, now) {
-  if (!machine)
-    return;
-  target.prepare(`
-    INSERT INTO machines (machine_id, hostname, last_seen_at, last_push_at, last_pull_at, economy_version, updated_at)
-    VALUES (?, ?, ?, NULL, ?, ?, ?)
-    ON CONFLICT(machine_id) DO UPDATE SET
-      hostname = COALESCE(NULLIF(machines.hostname, ''), excluded.hostname),
-      last_seen_at = CASE
-        WHEN machines.last_seen_at IS NULL OR machines.last_seen_at < excluded.last_seen_at THEN excluded.last_seen_at
-        ELSE machines.last_seen_at
-      END,
-      last_pull_at = excluded.last_pull_at,
-      economy_version = excluded.economy_version,
-      updated_at = excluded.updated_at
-  `).run(machine, machine, now, now, packageMetadata.version, now);
-}
-function openSourceDatabase(path) {
-  try {
-    return new BunDatabase(path, { readonly: true });
-  } catch {
-    return new BunDatabase(path);
-  }
-}
-function mergePeerDatabase(target, sourcePath, opts = {}) {
-  if (!existsSync3(sourcePath))
-    throw new Error(`source database does not exist: ${sourcePath}`);
-  const source = openSourceDatabase(sourcePath);
-  const now = opts.now ?? new Date().toISOString();
-  const sourceMachine = detectSourceMachine(source, opts.sourceMachine);
-  const tables = [];
-  try {
-    target.exec("PRAGMA foreign_keys = OFF");
-    target.exec("BEGIN IMMEDIATE");
-    try {
-      tables.push(mergeProjects(target, source));
-      const sessionMerge = mergeIdentityTable(target, source, "sessions", sourceMachine, now);
-      tables.push(sessionMerge.stats);
-      tables.push(mergeIdentityTable(target, source, "requests", sourceMachine, now, sessionMerge.idMap).stats);
-      for (const table of GENERIC_PEER_TABLES) {
-        tables.push(mergeGenericTable(target, source, table, sourceMachine, now));
-      }
-      ensureMachineRegistry(target, sourceMachine, now);
-      target.exec("COMMIT");
-    } catch (err) {
-      target.exec("ROLLBACK");
-      throw err;
-    } finally {
-      target.exec("PRAGMA foreign_keys = ON");
+    const totalAgentApiEq = rows.reduce((sum, row) => sum + row.api_eq, 0);
+    for (const row of db.prepare(`
+      SELECT agent,
+             COALESCE(SUM(cost_usd), 0) as api_eq,
+             COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as included
+      FROM requests WHERE ${where}
+      GROUP BY agent
+    `).all()) {
+      const agentSubs = subscriptionByAgent.get(row.agent) ?? { fee: 0, included: 0 };
+      const globalShare = totalAgentApiEq > 0 ? row.api_eq / totalAgentApiEq : 0;
+      const agentFee = prorateMonthlyFee(agentSubs.fee + globalSubs.fee * globalShare, period);
+      const agentIncludedCap = agentSubs.included + globalSubs.included * globalShare;
+      const agentIncludedConsumed = proratedIncludedConsumed(row.included, agentIncludedCap, period);
+      const agentOnDemand = onDemandByAgent.get(row.agent) ?? 0;
+      byAgent[row.agent] = {
+        api_equivalent_usd: row.api_eq,
+        subscription_fee_usd: agentFee,
+        included_consumed_usd: agentIncludedConsumed,
+        on_demand_usd: agentOnDemand,
+        saved_usd: computeSavedUsd(row.api_eq, agentOnDemand, agentFee)
+      };
     }
-  } finally {
-    source.close();
   }
-  const deduped = dedupeRequests(target);
-  const rowsWritten = tables.reduce((sum, table) => sum + table.inserted + table.updated, 0);
-  const collisions = tables.reduce((sum, table) => sum + table.collisions, 0);
   return {
-    source_path: sourcePath,
-    source_machine: sourceMachine,
-    rows_written: rowsWritten,
-    collisions,
-    deduped,
-    tables: tables.filter((t) => t.inserted || t.updated || t.skipped || t.collisions)
+    period,
+    api_equivalent_usd: apiEquivalent,
+    subscription_fee_usd: subscriptionFee,
+    included_consumed_usd: includedConsumed,
+    on_demand_usd: onDemand,
+    saved_usd: saved,
+    by_agent: byAgent
   };
 }
-// src/lib/fleet-sync.ts
+
+// src/lib/billing-diff.ts
 init_database();
-import { spawnSync } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, renameSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3, resolve } from "path";
-import { homedir as homedir2 } from "os";
-import { Database as Database2 } from "bun:sqlite";
-var DEFAULT_TIMEOUT_MS = 120000;
-var DEFAULT_MACHINES = ["spark02", "apple03"];
-function runEconomyFleetSync(options = {}) {
-  const generatedAt = (options.now ?? new Date).toISOString();
-  const timeoutMs = normalizePositiveInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS);
-  const runner = options.runner ?? spawnCommand;
-  const dryRun = Boolean(options.dryRun);
-  const machines = ((options.machines?.length) ? options.machines : DEFAULT_MACHINES).filter(Boolean);
-  const cacheDir = resolve(options.cacheDir ?? join3(homedir2(), ".hasna", "economy", "fleet-sync-cache"));
-  const remoteSnapshotDir = options.remoteSnapshotDir ?? "$HOME/.hasna/economy/fleet-sync-snapshots";
-  const localSync = options.localSync !== false;
-  const remoteSync = options.remoteSync !== false;
-  const local = {
-    status: dryRun ? "dry_run" : localSync ? "skipped" : "skipped",
-    db_path: getDbPath()
-  };
-  if (localSync) {
-    if (dryRun) {
-      local.status = "dry_run";
-    } else {
-      local.sync = runner("economy", ["sync"], { timeoutMs });
-      local.status = local.sync.code === 0 ? "synced" : "failed";
-    }
-  }
-  const remote = machines.map((machine) => syncMachine(machine, {
-    generatedAt,
-    timeoutMs,
-    runner,
-    dryRun,
-    remoteSync,
-    cacheDir,
-    remoteSnapshotDir
-  }));
+var PROVIDER_TO_AGENT = {
+  anthropic: "claude",
+  openai: "codex",
+  gemini: "gemini",
+  google: "gemini"
+};
+function queryBillingDiff(db, period, thresholdPct = 15) {
+  const estimated = querySummary(db, period, undefined, true);
+  const actual = queryBillingSummary(db, period);
+  const delta = estimated.total_usd - actual.total_usd;
+  const deltaPct = actual.total_usd > 0 ? delta / actual.total_usd * 100 : 0;
+  const agentRows = db.prepare(`
+    SELECT agent, COALESCE(SUM(cost_usd), 0) as estimated_usd
+    FROM requests
+    WHERE ${periodWhere3(period, "timestamp")}
+    GROUP BY agent
+  `).all();
+  const by_agent = agentRows.map((row) => {
+    const provider = Object.entries(PROVIDER_TO_AGENT).find(([, a]) => a === row.agent)?.[0];
+    const actualUsd = provider ? actual.by_provider[provider] ?? 0 : 0;
+    const rowDelta = row.estimated_usd - actualUsd;
+    const rowPct = actualUsd > 0 ? rowDelta / actualUsd * 100 : 0;
+    return {
+      agent: row.agent,
+      estimated_usd: row.estimated_usd,
+      actual_usd: actualUsd,
+      delta_usd: rowDelta,
+      delta_pct: rowPct
+    };
+  }).sort((a, b) => Math.abs(b.delta_usd) - Math.abs(a.delta_usd));
   return {
-    schema: "open-economy.fleet-sync.v1",
-    generated_at: generatedAt,
-    dry_run: dryRun,
-    local,
-    remote,
-    summary: {
-      machines: remote.length,
-      merged: remote.filter((row) => row.status === "merged").length,
-      failed: remote.filter((row) => row.status === "failed").length,
-      dry_run: remote.filter((row) => row.status === "dry_run").length + (dryRun ? 1 : 0)
-    }
+    period,
+    estimated_usd: estimated.total_usd,
+    actual_usd: actual.total_usd,
+    delta_usd: delta,
+    delta_pct: deltaPct,
+    threshold_pct: thresholdPct,
+    is_alert: Math.abs(deltaPct) > thresholdPct,
+    by_agent,
+    by_provider: actual.by_provider
   };
 }
-function syncMachine(machine, context) {
-  const safeMachine = machine.replace(/[^A-Za-z0-9_.-]/g, "_");
-  const stamp = context.generatedAt.replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const snapshotName = `${safeMachine}-${stamp}.economy.db`;
-  const remoteSnapshotPath = `${context.remoteSnapshotDir.replace(/\/$/, "")}/${snapshotName}`;
-  const tmpLocal = join3(context.cacheDir, `${snapshotName}.tmp`);
-  const verifiedLocal = join3(context.cacheDir, snapshotName);
-  if (context.dryRun) {
-    return { machine, status: "dry_run", remote_snapshot_path: remoteSnapshotPath };
-  }
-  mkdirSync3(context.cacheDir, { recursive: true });
-  rmSync(tmpLocal, { force: true });
-  const result = {
-    machine,
-    status: "failed",
-    remote_snapshot_path: remoteSnapshotPath
-  };
-  if (context.remoteSync) {
-    result.remote_sync = context.runner("ssh", [machine, "economy sync"], { timeoutMs: context.timeoutMs });
-    if (result.remote_sync.code !== 0) {
-      result.error = "remote economy sync failed";
-      return result;
-    }
+function periodWhere3(period, column) {
+  switch (period) {
+    case "today":
+      return `DATE(${column}) = DATE('now')`;
+    case "yesterday":
+      return `DATE(${column}) = DATE('now', '-1 day')`;
+    case "week":
+      return `${column} >= DATE('now', 'weekday 0', '-7 days')`;
+    case "month":
+      return `${column} >= DATE('now', 'start of month')`;
+    case "year":
+      return `${column} >= DATE('now', 'start of year')`;
+    case "all":
+      return "1=1";
   }
-  result.remote_snapshot = context.runner("ssh", [machine, remoteSnapshotCommand(context.remoteSnapshotDir, snapshotName)], { timeoutMs: context.timeoutMs });
-  if (result.remote_snapshot.code !== 0) {
-    result.error = "remote snapshot failed";
-    return result;
-  }
-  const emittedPath = result.remote_snapshot.stdout.trim().split(/\r?\n/).at(-1)?.trim() || remoteSnapshotPath;
-  if (!isSafeRemoteSnapshotPath(emittedPath, context.remoteSnapshotDir)) {
-    result.error = `remote snapshot path refused: ${emittedPath}`;
-    return result;
-  }
-  result.remote_snapshot_path = emittedPath;
-  result.pull = context.runner("scp", [`${machine}:${emittedPath}`, tmpLocal], { timeoutMs: context.timeoutMs });
-  context.runner("ssh", [machine, `rm -f ${shellQuote(emittedPath)}`], { timeoutMs: context.timeoutMs });
-  if (result.pull.code !== 0) {
-    result.error = "snapshot pull failed; no cached DB merged";
-    rmSync(tmpLocal, { force: true });
-    return result;
-  }
-  const integrity = verifySqliteIntegrity(tmpLocal);
-  result.local_integrity = integrity;
-  if (!integrity.ok) {
-    result.error = "pulled snapshot failed local integrity check";
-    rmSync(tmpLocal, { force: true });
-    return result;
-  }
-  renameSync(tmpLocal, verifiedLocal);
-  const db = openDatabase();
-  result.merge = mergePeerDatabase(db, verifiedLocal, { sourceMachine: machine });
-  result.status = "merged";
-  return result;
 }
-function remoteSnapshotCommand(remoteDir, filename) {
-  const dirExpr = remoteDir.startsWith("$HOME/") ? `"${remoteDir.replace(/"/g, "\\\"")}"` : shellQuote(remoteDir);
-  const safeFilename = filename.replace(/[^A-Za-z0-9_.-]/g, "_");
-  return [
-    "set -euo pipefail",
-    'db="${HASNA_ECONOMY_DB_PATH:-${ECONOMY_DB:-$HOME/.hasna/economy/economy.db}}"',
-    `snapshot_dir=${dirExpr}`,
-    `out="$snapshot_dir/${safeFilename}"`,
-    'test -f "$db"',
-    'mkdir -p "$snapshot_dir"',
-    'rm -f "$out"',
-    `sqlite3 "$db" "VACUUM INTO '$out'"`,
-    'test "$(sqlite3 "$out" "PRAGMA integrity_check;")" = "ok"',
-    'printf "%s\\n" "$out"'
-  ].join("; ");
-}
-function isSafeRemoteSnapshotPath(path, remoteSnapshotDir = "$HOME/.hasna/economy/fleet-sync-snapshots") {
-  if (!path || path.includes("\x00") || path.includes(`
-`) || path.includes("\r"))
-    return false;
-  if (!path.endsWith(".db"))
-    return false;
-  if (path.includes(".."))
-    return false;
-  const prefix = remoteSnapshotDir.replace(/\/$/, "");
-  return path.startsWith(`${prefix}/`) || path.startsWith("$HOME/.hasna/economy/fleet-sync-snapshots/") || path.includes("/.hasna/economy/fleet-sync-snapshots/");
-}
-function verifySqliteIntegrity(path) {
-  if (!existsSync4(path))
-    return { ok: false, detail: "file does not exist" };
-  let db;
-  try {
-    db = new Database2(path, { readonly: true });
-    const row = db.query("PRAGMA integrity_check").get();
-    const detail = Object.values(row ?? {})[0] ?? "";
-    return { ok: detail.toLowerCase() === "ok", detail: detail || "no integrity result" };
-  } catch (error) {
-    return { ok: false, detail: error instanceof Error ? error.message : String(error) };
-  } finally {
-    db?.close();
-  }
-}
-function writeFleetSyncReport(reportDir, result) {
-  mkdirSync3(reportDir, { recursive: true });
-  const path = join3(resolve(reportDir), `${result.generated_at.replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z")}.json`);
-  writeFileSync2(path, `${JSON.stringify(result, null, 2)}
-`);
-  return path;
-}
-function spawnCommand(command, args, options) {
-  const result = spawnSync(command, args, {
-    encoding: "utf8",
-    timeout: options.timeoutMs,
-    maxBuffer: 1024 * 1024,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  return {
-    code: result.status,
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? "",
-    ...result.error ? { error: result.error.message } : {}
-  };
-}
-function shellQuote(value) {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function normalizePositiveInteger(value, fallback) {
-  if (value == null || !Number.isFinite(value) || value < 1)
-    return fallback;
-  return Math.floor(value);
-}
-// src/ingest/claude.ts
-init_database();
-init_pricing();
-import { readdirSync as readdirSync2, readFileSync as readFileSync3, existsSync as existsSync5, statSync as statSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4, basename } from "path";
 
-// src/lib/savings.ts
-function defaultCostBasisForAgent(agent) {
-  if (agent === "claude")
-    return "metered_api";
-  if (agent === "cursor")
-    return "subscription_included";
-  return "estimated";
+// src/lib/periods.ts
+function ymd(date) {
+  return date.toISOString().substring(0, 10);
+}
+function usageSnapshotFilterForPeriod(period) {
+  const now = new Date;
+  switch (period) {
+    case "today":
+      return { date: ymd(now) };
+    case "yesterday": {
+      const yesterday = new Date(now);
+      yesterday.setUTCDate(yesterday.getUTCDate() - 1);
+      return { date: ymd(yesterday) };
+    }
+    case "week": {
+      const weekAgo = new Date(now);
+      weekAgo.setUTCDate(weekAgo.getUTCDate() - 7);
+      return { since: ymd(weekAgo) };
+    }
+    case "month":
+      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))) };
+    case "year":
+      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), 0, 1))) };
+    case "all":
+      return {};
+  }
 }
 
-// src/lib/accounts.ts
-var AGENT_ACCOUNT_TOOLS = {
-  claude: ["claude"],
-  takumi: ["takumi", "claude"],
-  codex: ["codex"],
-  gemini: ["gemini"],
-  opencode: ["opencode"],
-  cursor: ["cursor"],
-  pi: ["pi"],
-  hermes: ["hermes"]
+// 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
 };
-function normalizeEmail(email) {
-  return (email ?? "").trim().toLowerCase();
+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 accountKey(tool, name, email) {
-  const normalizedEmail = normalizeEmail(email);
-  return `${tool}:${normalizedEmail || name}`;
+function requestPeriodWhere2(period) {
+  if (period === "today")
+    return `DATE(timestamp) = DATE('now')`;
+  return `timestamp >= DATE('now', 'weekday 0', '-7 days')`;
 }
-function normalizeDir(value) {
-  return value.replace(/\/+$/, "");
+function sessionPeriodWhere2(period) {
+  if (period === "today")
+    return `DATE(started_at) = DATE('now')`;
+  return `started_at >= DATE('now', 'weekday 0', '-7 days')`;
 }
-function fromProfile(profile, source) {
+function baseRequestTotals(row) {
   return {
-    account_key: accountKey(profile.tool, profile.name, profile.email),
-    account_tool: profile.tool,
-    account_name: profile.name,
-    ...profile.email ? { account_email: normalizeEmail(profile.email) } : {},
-    account_source: source
+    ...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 fromOverride(raw, agent) {
-  const value = raw.trim();
-  if (!value)
-    return null;
-  const candidateTool = AGENT_ACCOUNT_TOOLS[agent][0] ?? agent;
-  const [tool, name] = value.includes(":") ? value.split(":", 2) : [candidateTool, value];
-  if (!tool || !name)
-    return null;
-  const email = name.includes("@") ? normalizeEmail(name) : undefined;
+function baseSessionTotals(row) {
   return {
-    account_key: accountKey(tool, name, email),
-    account_tool: tool,
-    account_name: name,
-    ...email ? { account_email: email } : {},
-    account_source: "override"
+    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 envOverride(agent, env) {
-  const agentPrefix = agent.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  const raw = env[`ECONOMY_${agentPrefix}_ACCOUNT_KEY`] ?? env[`ECONOMY_${agentPrefix}_ACCOUNT`] ?? env["ECONOMY_ACCOUNT_KEY"] ?? env["ECONOMY_ACCOUNT"];
-  if (raw)
-    return fromOverride(raw, agent);
-  const tool = env[`ECONOMY_${agentPrefix}_ACCOUNT_TOOL`] ?? env["ECONOMY_ACCOUNT_TOOL"];
-  const name = env[`ECONOMY_${agentPrefix}_ACCOUNT_NAME`] ?? env["ECONOMY_ACCOUNT_NAME"];
-  if (!tool || !name)
-    return null;
-  const email = normalizeEmail(env[`ECONOMY_${agentPrefix}_ACCOUNT_EMAIL`] ?? env["ECONOMY_ACCOUNT_EMAIL"]);
+function latestTimestamp(...values) {
+  return values.filter(Boolean).sort().at(-1) ?? null;
+}
+function combineTotals(requests, sessions) {
   return {
-    account_key: accountKey(tool, name, email),
-    account_tool: tool,
-    account_name: name,
-    ...email ? { account_email: email } : {},
-    account_source: "override"
+    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 knownToolIds(api) {
-  try {
-    return new Set(api.listTools().map((tool) => tool.id));
-  } catch {
-    return new Set;
-  }
+function emptyTotals() {
+  return combineTotals(ZERO_REQUEST_TOTALS, ZERO_SESSION_TOTALS);
 }
-function profileForEnvDir(api, tool, env) {
-  const configuredDir = env[tool.envVar];
-  if (!configuredDir)
-    return null;
-  const normalized = normalizeDir(configuredDir);
-  try {
-    return api.listProfiles(tool.id).find((profile) => normalizeDir(profile.dir) === normalized) ?? null;
-  } catch {
-    return null;
+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
+  };
 }
-async function resolveAccountForAgent(agent, env = process.env) {
-  const override = envOverride(agent, env);
-  if (override)
-    return override;
-  let api;
-  try {
-    api = await import("@hasna/accounts");
-  } catch {
-    return null;
-  }
-  const toolIds = knownToolIds(api);
-  for (const toolId of AGENT_ACCOUNT_TOOLS[agent]) {
-    if (!toolIds.has(toolId))
-      continue;
-    let tool;
-    try {
-      tool = api.getTool(toolId);
-    } catch {
-      continue;
-    }
-    const envProfile = profileForEnvDir(api, tool, env);
-    if (envProfile)
-      return fromProfile(envProfile, "env");
-    try {
-      const applied = api.appliedProfile(toolId);
-      if (applied)
-        return fromProfile(applied, "applied");
-    } catch {}
-    try {
-      const current = api.currentProfile(toolId);
-      if (current)
-        return fromProfile(current, "current");
-    } catch {}
+function sessionOnlyTotalsSql(where, machine) {
+  const params = [];
+  let machineClause = "";
+  if (machine) {
+    machineClause = " AND machine_id = ?";
+    params.push(machine);
   }
-  return null;
+  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 withAccount(record, account) {
-  if (!account)
-    return record;
+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 {
-    ...record,
-    account_key: account.account_key,
-    account_tool: account.account_tool,
-    account_name: account.account_name,
-    account_email: account.account_email ?? "",
-    account_source: account.account_source
+    ...totals,
+    sessions: summary.sessions,
+    requests: summary.requests,
+    total_tokens: summary.tokens,
+    cost_usd: summary.total_usd
   };
 }
-
-// src/ingest/claude.ts
-function autoDetectProject(cwd, projects) {
-  return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
-}
-var CLAUDE_PROJECTS_DIR = join4(homedir3(), ".claude", "projects");
-var TAKUMI_PROJECTS_DIR = join4(homedir3(), ".takumi", "projects");
-function dirNameToPath(dirName) {
-  return dirName.replace(/^-/, "/").replace(/-/g, "/").replace(/\/\//g, "/-");
-}
-function collectJsonlFiles(projectDir) {
-  const files = [];
-  function walk(dir) {
-    try {
-      for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-        if (entry.isDirectory())
-          walk(join4(dir, entry.name));
-        else if (entry.name.endsWith(".jsonl"))
-          files.push(join4(dir, entry.name));
-      }
-    } catch {}
-  }
-  walk(projectDir);
-  return files;
-}
-async function ingestClaude(db, verbose = false, projectsDir = CLAUDE_PROJECTS_DIR) {
-  return ingestJsonlProjects(db, projectsDir, "claude", verbose);
-}
-async function ingestTakumi(db, verbose = false, projectsDir = TAKUMI_PROJECTS_DIR) {
-  return ingestJsonlProjects(db, projectsDir, "takumi", verbose);
-}
-async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false) {
-  if (!existsSync5(projectsDir)) {
-    if (verbose)
-      console.log(`${agentName} projects dir not found:`, projectsDir);
-    return { files: 0, requests: 0, sessions: 0 };
-  }
-  const machineId = getMachineId();
-  let totalFiles = 0;
-  let totalRequests = 0;
-  const touchedSessions = new Set;
-  const registeredProjects = db.prepare(`SELECT path, name FROM projects ORDER BY LENGTH(path) DESC`).all();
-  const account = await resolveAccountForAgent(agentName);
-  const projectDirs = readdirSync2(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
-  for (const projectDirEntry of projectDirs) {
-    const projectDirPath = join4(projectsDir, projectDirEntry.name);
-    const projectPath = dirNameToPath(projectDirEntry.name);
-    const jsonlFiles = collectJsonlFiles(projectDirPath);
-    for (const filePath of jsonlFiles) {
-      const stateKey = filePath.replace(projectsDir, "");
-      let fileMtime = "0";
-      try {
-        fileMtime = statSync2(filePath).mtimeMs.toString();
-      } catch {
-        continue;
-      }
-      const processed = getIngestState(db, agentName, stateKey);
-      if (processed === fileMtime)
-        continue;
-      let lines;
-      try {
-        lines = readFileSync3(filePath, "utf-8").split(`
-`).filter((l) => l.trim());
-      } catch {
-        continue;
-      }
-      const fileBasename = basename(filePath, ".jsonl");
-      const isUuid = /^[0-9a-f-]{36}$/.test(fileBasename);
-      let sessionId = isUuid ? fileBasename : fileBasename.replace(/^agent-/, "");
-      let sessionCwd = projectPath;
-      for (const line of lines) {
-        let entry;
-        try {
-          entry = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        if (entry.sessionId)
-          sessionId = entry.sessionId;
-        if (entry.cwd)
-          sessionCwd = entry.cwd;
-        if (entry.message?.role !== "assistant")
-          continue;
-        const usage = entry.message.usage;
-        if (!usage)
-          continue;
-        const model = entry.message.model;
-        if (!model)
-          continue;
-        const inputTokens = usage.input_tokens ?? 0;
-        const outputTokens = usage.output_tokens ?? 0;
-        const cacheWrite5mTokens = usage.cache_creation?.ephemeral_5m_input_tokens ?? usage.cache_creation_input_tokens ?? 0;
-        const cacheWrite1hTokens = usage.cache_creation?.ephemeral_1h_input_tokens ?? 0;
-        const cacheWriteTokens = cacheWrite5mTokens + cacheWrite1hTokens;
-        const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
-        const timestamp = entry.timestamp ?? new Date().toISOString();
-        if (inputTokens + outputTokens + cacheWriteTokens + cacheReadTokens === 0)
-          continue;
-        let costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, cacheWrite5mTokens, cacheWrite1hTokens);
-        costUsd = applyClaudeModifiers(costUsd, model, usage, entry);
-        const serverToolUse = usage.server_tool_use;
-        if (serverToolUse?.web_search_requests) {
-          costUsd += serverToolUse.web_search_requests * 0.01;
-        }
-        const sourceRequestId = entry.requestId ?? entry.request_id ?? entry.message.id ?? entry.uuid ?? `${sessionId}-${timestamp}`;
-        const reqId = `${agentName}-${sourceRequestId}`;
-        upsertRequest(db, withAccount({
-          id: reqId,
-          agent: agentName,
-          session_id: sessionId,
-          model,
-          input_tokens: inputTokens,
-          output_tokens: outputTokens,
-          cache_read_tokens: cacheReadTokens,
-          cache_create_tokens: cacheWriteTokens,
-          cache_create_5m_tokens: cacheWrite5mTokens,
-          cache_create_1h_tokens: cacheWrite1hTokens,
-          cost_usd: costUsd,
-          cost_basis: defaultCostBasisForAgent(agentName),
-          duration_ms: 0,
-          timestamp,
-          source_request_id: sourceRequestId,
-          machine_id: machineId
-        }, account));
-        if (!touchedSessions.has(sessionId)) {
-          const existing = db.prepare(`SELECT id FROM sessions WHERE id = ?`).get(sessionId);
-          if (!existing) {
-            const effectiveCwd = sessionCwd || projectPath;
-            const detectedProject = autoDetectProject(effectiveCwd, registeredProjects);
-            const session = {
-              id: sessionId,
-              agent: agentName,
-              project_path: detectedProject ? detectedProject.path : effectiveCwd,
-              project_name: detectedProject ? detectedProject.name : "",
-              started_at: timestamp,
-              ended_at: null,
-              total_cost_usd: 0,
-              total_tokens: 0,
-              request_count: 0,
-              machine_id: machineId
-            };
-            upsertSession(db, withAccount(session, account));
-          }
-          touchedSessions.add(sessionId);
-        }
-        totalRequests++;
-      }
-      setIngestState(db, agentName, stateKey, fileMtime);
-      totalFiles++;
-    }
+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
+    };
   }
-  for (const sessionId of touchedSessions) {
-    rollupSession(db, sessionId);
+  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 { files: totalFiles, requests: totalRequests, sessions: touchedSessions.size };
+  return { timestamp: parsed.toISOString(), label: value };
 }
-function applyClaudeModifiers(costUsd, model, usage, entry) {
-  let multiplier = 1;
-  const speed = usage.speed ?? entry.message?.speed ?? entry.speed;
-  if (speed === "fast" && model.includes("opus-4-6")) {
-    multiplier *= 6;
+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);
   }
-  const inferenceGeo = usage.inference_geo ?? entry.message?.inference_geo ?? entry.inference_geo;
-  if (inferenceGeo && ["us", "us-only", "us_only"].includes(inferenceGeo) && supportsClaudeDataResidencyPricing(model)) {
-    multiplier *= 1.1;
+  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)
+    });
   }
-  return costUsd * multiplier;
+  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 supportsClaudeDataResidencyPricing(model) {
-  const normalized = normalizeModelName(model);
-  const match = normalized.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:-(\d+))?(?:-|$)/);
-  if (!match)
-    return false;
-  const major = Number(match[2]);
-  const minor = match[3] ? Number(match[3]) : 0;
-  return major > 4 || major === 4 && minor >= 6;
+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;
 }
-// src/ingest/codex.ts
-init_database();
-init_pricing();
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5, basename as basename2 } from "path";
-import { Database as BunDatabase2 } from "bun:sqlite";
-var DEFAULT_CODEX_DB_PATH = join5(homedir4(), ".codex", "state_5.sqlite");
-var DEFAULT_CODEX_CONFIG_PATH = join5(homedir4(), ".codex", "config.toml");
-var DEFAULT_CODEWITH_DB_PATH = join5(homedir4(), ".codewith", "state_5.sqlite");
-var DEFAULT_CODEWITH_CONFIG_PATH = join5(homedir4(), ".codewith", "config.toml");
-var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
-function codexDbPath() {
-  return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
-}
-function codexConfigPath() {
-  return process.env["HASNA_ECONOMY_CODEX_CONFIG_PATH"] ?? DEFAULT_CODEX_CONFIG_PATH;
-}
-function codewithDbPath() {
-  return process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"] ?? DEFAULT_CODEWITH_DB_PATH;
-}
-function codewithConfigPath() {
-  return process.env["HASNA_ECONOMY_CODEWITH_CONFIG_PATH"] ?? DEFAULT_CODEWITH_CONFIG_PATH;
-}
-function codexSources() {
-  const explicitCodexPath = process.env["HASNA_ECONOMY_CODEX_DB_PATH"];
-  const explicitCodewithPath = process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"];
-  const sources = [{
-    label: "Codex",
-    dbPath: codexDbPath(),
-    configPath: codexConfigPath(),
-    sessionPrefix: "codex",
-    stateSource: "codex"
-  }];
-  if (!explicitCodexPath || explicitCodewithPath) {
-    sources.push({
-      label: "Codewith",
-      dbPath: codewithDbPath(),
-      configPath: codewithConfigPath(),
-      sessionPrefix: "codex-codewith",
-      stateSource: "codex-codewith"
+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 accountKey(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 = accountKey(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"
     });
   }
-  const seen = new Set;
-  return sources.filter((source) => {
-    if (seen.has(source.dbPath))
-      return false;
-    seen.add(source.dbPath);
-    return true;
-  });
+  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 readCodexModel(configPath = codexConfigPath()) {
-  if (!existsSync6(configPath))
-    return "gpt-5-codex";
-  try {
-    const content = readFileSync4(configPath, "utf-8");
-    const match = content.match(/^model\s*=\s*"([^"]+)"/m);
-    return match?.[1] ?? "gpt-5-codex";
-  } catch {
-    return "gpt-5-codex";
-  }
-}
-function buildThreadQuery(codexDb) {
-  const cols = new Set(codexDb.prepare(`PRAGMA table_info(threads)`).all().map((c) => c.name));
-  const modelSelect = cols.has("model") ? "model" : "NULL AS model";
-  const rolloutSelect = cols.has("rollout_path") ? "rollout_path" : "NULL AS rollout_path";
-  const providerSelect = cols.has("model_provider") ? "model_provider" : "NULL AS model_provider";
-  return `
-    SELECT id, ${rolloutSelect}, cwd, created_at, updated_at, tokens_used, title,
-           ${providerSelect}, ${modelSelect}
-    FROM threads WHERE tokens_used > 0
-  `;
-}
-function openCodexDb(dbPath, verbose) {
-  let lastError;
-  for (const readonly of [true, false]) {
-    let codexDb = null;
-    try {
-      codexDb = readonly ? new BunDatabase2(dbPath, { readonly: true }) : new BunDatabase2(dbPath);
-      codexDb.prepare("PRAGMA schema_version").get();
-      return codexDb;
-    } catch (error) {
-      lastError = error;
-      codexDb?.close();
+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);
   }
-  if (verbose) {
-    const message = lastError instanceof Error ? lastError.message : String(lastError);
-    console.log("Codex DB unreadable:", dbPath, message);
+  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/lib/contracts-client/mode.ts
+var DEPRECATED_STORAGE_MODE_ALIASES = ["remote", "hybrid", "self_hosted"];
+function normalizeStorageMode(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  if (normalized === "local")
+    return { mode: "local", deprecatedAlias: null };
+  if (normalized === "cloud")
+    return { mode: "cloud", deprecatedAlias: null };
+  if (DEPRECATED_STORAGE_MODE_ALIASES.includes(normalized)) {
+    return { mode: "cloud", deprecatedAlias: normalized };
+  }
+  throw new Error(`Unknown storage mode: ${value}. Use local or cloud.`);
+}
+function envToken(name) {
+  return name.toUpperCase().replace(/-/g, "_");
+}
+
+// src/lib/contracts-client/transport.ts
+function defaultCloudBaseUrl(name) {
+  return `https://${name}.hasna.xyz`;
+}
+function clientTransportEnvKeys(name) {
+  const token = envToken(name);
+  return {
+    modeKeys: [
+      `HASNA_${token}_STORAGE_MODE`,
+      `HASNA_${token}_MODE`,
+      `${token}_STORAGE_MODE`,
+      `${token}_MODE`
+    ],
+    apiUrlKeys: [`HASNA_${token}_API_URL`, `${token}_API_URL`],
+    apiKeyKeys: [`HASNA_${token}_API_KEY`, `${token}_API_KEY`]
+  };
+}
+function firstEnv(env, keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value)
+      return { key, value };
   }
   return null;
 }
-function readTokenEvents(rolloutPath) {
-  if (!rolloutPath || !existsSync6(rolloutPath))
-    return [];
-  const fallbackUsages = new Map;
-  let fallbackTimestamp;
-  let aggregate = null;
-  for (const line of readFileSync4(rolloutPath, "utf-8").split(`
-`)) {
-    if (!line.trim())
-      continue;
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (!entry || typeof entry !== "object")
-      continue;
-    const payload = entry["payload"];
-    if (!payload || payload["type"] !== "token_count")
-      continue;
-    const info = payload["info"];
-    const timestamp = entry["timestamp"];
-    const entryTimestamp = typeof timestamp === "string" ? timestamp : undefined;
-    const totalUsage = info?.["total_token_usage"];
-    if (totalUsage && tokenTotal(totalUsage) > 0) {
-      aggregate = { usage: totalUsage, timestamp: entryTimestamp };
-      continue;
+function toV1BaseUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("API URL must use http or https.");
+  }
+  let path = url.pathname.replace(/\/+$/, "");
+  if (path.endsWith("/v1"))
+    path = path.slice(0, -"/v1".length);
+  url.pathname = `${path}/v1`;
+  url.search = "";
+  url.hash = "";
+  return url.toString().replace(/\/+$/, "");
+}
+function resolveClientTransport(name, env = process.env) {
+  const keys = clientTransportEnvKeys(name);
+  const modeHit = firstEnv(env, keys.modeKeys);
+  const urlHit = firstEnv(env, keys.apiUrlKeys);
+  const keyHit = firstEnv(env, keys.apiKeyKeys);
+  let mode = "local";
+  let deprecatedAlias = null;
+  let modeSource = "default";
+  const warnings = [];
+  if (modeHit) {
+    const normalized = normalizeStorageMode(modeHit.value);
+    mode = normalized.mode;
+    deprecatedAlias = normalized.deprecatedAlias;
+    modeSource = modeHit.key;
+    if (deprecatedAlias) {
+      warnings.push(`Deprecated mode '${deprecatedAlias}' from ${modeHit.key} is treated as 'cloud'. Prefer ${keys.modeKeys[0]}=cloud.`);
     }
-    const usage = info?.["last_token_usage"];
-    if (!usage)
-      continue;
-    if (tokenTotal(usage) <= 0)
-      continue;
-    const key = JSON.stringify(usage);
-    if (!fallbackUsages.has(key))
-      fallbackUsages.set(key, usage);
-    fallbackTimestamp = entryTimestamp ?? fallbackTimestamp;
-  }
-  if (aggregate)
-    return [aggregate];
-  if (fallbackUsages.size === 0)
-    return [];
-  return [{ usage: sumTokenUsages([...fallbackUsages.values()]), timestamp: fallbackTimestamp }];
-}
-function tokenTotal(usage) {
-  return usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
-}
-function sumTokenUsages(usages) {
-  const result = {
-    input_tokens: 0,
-    cached_input_tokens: 0,
-    output_tokens: 0,
-    reasoning_output_tokens: 0,
-    total_tokens: 0
-  };
-  for (const usage of usages) {
-    result.input_tokens = (result.input_tokens ?? 0) + (usage.input_tokens ?? 0);
-    result.cached_input_tokens = (result.cached_input_tokens ?? 0) + (usage.cached_input_tokens ?? 0);
-    result.output_tokens = (result.output_tokens ?? 0) + (usage.output_tokens ?? 0);
-    result.reasoning_output_tokens = (result.reasoning_output_tokens ?? 0) + (usage.reasoning_output_tokens ?? 0);
-    result.total_tokens = (result.total_tokens ?? 0) + tokenTotal(usage);
+  } else if (urlHit && keyHit) {
+    mode = "cloud";
+    modeSource = `${urlHit.key}+${keyHit.key}`;
   }
-  return result;
+  if (mode === "local") {
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: Boolean(keyHit),
+      apiKeySource: keyHit ? keyHit.key : null,
+      misconfigured: false,
+      warning: warnings.length > 0 ? warnings.join(" ") : null
+    };
+  }
+  if (!keyHit) {
+    warnings.push(`${modeSource}=cloud but no API key is set (${keys.apiKeyKeys[0]}). Refusing to route to cloud; using local store. Set ${keys.apiKeyKeys[0]} to enable the cloud client.`);
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: false,
+      apiKeySource: null,
+      misconfigured: true,
+      warning: warnings.join(" ")
+    };
+  }
+  const rawUrl = urlHit?.value ?? defaultCloudBaseUrl(name);
+  const apiUrlSource = urlHit ? urlHit.key : "default";
+  let baseUrl;
+  try {
+    baseUrl = toV1BaseUrl(rawUrl);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warnings.push(`Invalid API URL from ${apiUrlSource}: ${message}. Using local store.`);
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: true,
+      apiKeySource: keyHit.key,
+      misconfigured: true,
+      warning: warnings.join(" ")
+    };
+  }
+  return {
+    transport: "cloud-http",
+    mode,
+    deprecatedAlias,
+    modeSource,
+    baseUrl,
+    apiUrlSource,
+    apiKeyPresent: true,
+    apiKeySource: keyHit.key,
+    misconfigured: false,
+    warning: warnings.length > 0 ? warnings.join(" ") : null
+  };
 }
-function fallbackEvents(totalTokens) {
-  const inputTokens = Math.floor(totalTokens * 0.6);
-  return [{
-    usage: {
-      input_tokens: inputTokens,
-      cached_input_tokens: 0,
-      output_tokens: totalTokens - inputTokens,
-      total_tokens: totalTokens
+
+class HasnaHttpError extends Error {
+  status;
+  method;
+  path;
+  body;
+  constructor(method, path, status, body) {
+    super(`Hasna cloud request failed: ${method} ${path} -> ${status}`);
+    this.name = "HasnaHttpError";
+    this.status = status;
+    this.method = method;
+    this.path = path;
+    this.body = body;
+  }
+}
+var DEFAULT_RETRY_STATUSES = [408, 425, 429, 500, 502, 503, 504];
+var IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+function appendQuery(path, query) {
+  if (!query)
+    return path;
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams;
+  if (!(query instanceof URLSearchParams)) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value === null || value === undefined)
+        continue;
+      if (Array.isArray(value)) {
+        for (const v of value)
+          params.append(key, String(v));
+      } else {
+        params.append(key, String(value));
+      }
     }
-  }];
-}
-async function ingestCodex(db, verbose = false) {
-  const machineId = getMachineId();
-  let ingested = 0;
-  let requests = 0;
-  const account = await resolveAccountForAgent("codex");
-  for (const source of codexSources()) {
-    if (!existsSync6(source.dbPath)) {
-      if (verbose)
-        console.log(`${source.label} DB not found:`, source.dbPath);
-      continue;
+  }
+  const qs = params.toString();
+  if (!qs)
+    return path;
+  return `${path}${path.includes("?") ? "&" : "?"}${qs}`;
+}
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function createHasnaHttpTransport(options) {
+  const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
+  const base = options.baseUrl.replace(/\/+$/, "");
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const sleep = options.sleepImpl ?? defaultSleep;
+  const defaultRetry = options.retry;
+  function resolveRetry(callRetry) {
+    const chosen = callRetry !== undefined ? callRetry : defaultRetry;
+    if (chosen === false)
+      return null;
+    const r = chosen ?? {};
+    return {
+      retries: r.retries ?? 2,
+      baseDelayMs: r.baseDelayMs ?? 200,
+      maxDelayMs: r.maxDelayMs ?? 2000,
+      retryStatuses: r.retryStatuses ?? [...DEFAULT_RETRY_STATUSES]
+    };
+  }
+  async function once(method, rel, url, body, opts) {
+    const headers = {
+      "x-api-key": options.apiKey,
+      Authorization: `Bearer ${options.apiKey}`,
+      Accept: "application/json",
+      ...options.headers ?? {},
+      ...opts.headers ?? {}
+    };
+    if (opts.idempotencyKey)
+      headers["Idempotency-Key"] = opts.idempotencyKey;
+    const init = { method, headers };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
     }
-    let codexDb = null;
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    if (opts.signal) {
+      if (opts.signal.aborted)
+        controller.abort();
+      else
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? timeoutMs);
+    init.signal = controller.signal;
+    let response;
     try {
-      codexDb = openCodexDb(source.dbPath, verbose);
-      if (!codexDb)
-        continue;
-      const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
-      for (const thread of threads) {
-        const model = thread.model ?? readCodexModel(source.configPath);
-        const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
-        const processed = getIngestState(db, source.stateSource, thread.id);
-        if (processed === stateValue)
-          continue;
-        const projectPath = thread.cwd ?? "";
-        const projectName = projectPath ? basename2(projectPath) : "unknown";
-        const sessionId = `${source.sessionPrefix}-${thread.id}`;
-        const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
-        const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
-        upsertSession(db, withAccount({
-          id: sessionId,
-          agent: "codex",
-          project_path: projectPath,
-          project_name: projectName,
-          started_at: startedAt,
-          ended_at: endedAt,
-          total_cost_usd: 0,
-          total_tokens: 0,
-          request_count: 0,
-          machine_id: machineId
-        }, account));
-        const events = readTokenEvents(thread.rollout_path);
-        const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
-        const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
-        db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
-        tokenEvents.forEach((event, index) => {
-          const usage = event.usage;
-          const inputTotal = usage.input_tokens ?? 0;
-          const cacheReadTokens = usage.cached_input_tokens ?? 0;
-          const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
-          const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
-          const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
-          const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
-          const requestId = `${sessionId}-${index}`;
-          upsertRequest(db, withAccount({
-            id: requestId,
-            agent: "codex",
-            session_id: sessionId,
-            model,
-            input_tokens: inputTokens,
-            output_tokens: outputTokens,
-            cache_read_tokens: cacheReadTokens,
-            cache_create_tokens: 0,
-            cost_usd: costUsd,
-            cost_basis: defaultCostBasisForAgent("codex"),
-            duration_ms: 0,
-            timestamp,
-            source_request_id: requestId,
-            machine_id: machineId
-          }, account));
-          requests++;
-        });
-        rollupSession(db, sessionId);
-        setIngestState(db, source.stateSource, thread.id, stateValue);
-        ingested++;
-        if (verbose)
-          console.log(`${source.label} session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
-      }
+      response = await fetchImpl(url, init);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (opts.signal?.aborted)
+        return { ok: false, retryable: false, error: err };
+      return { ok: false, retryable: true, error: err };
     } finally {
-      codexDb?.close();
+      clearTimeout(timer);
+      if (opts.signal)
+        opts.signal.removeEventListener("abort", onAbort);
+    }
+    const text = await response.text();
+    let parsed = undefined;
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!response.ok) {
+      const retry = resolveRetry(opts.retry);
+      const retryable = retry ? retry.retryStatuses.includes(response.status) : false;
+      return { ok: false, retryable, error: new HasnaHttpError(method, rel, response.status, parsed) };
     }
+    return { ok: true, value: parsed };
+  }
+  async function request(method, path, body, opts = {}) {
+    const upper = method.toUpperCase();
+    const rel = appendQuery(path.startsWith("/") ? path : `/${path}`, opts.query);
+    const url = `${base}${rel}`;
+    const retry = resolveRetry(opts.retry);
+    const methodRetryable = IDEMPOTENT_METHODS.has(upper) || Boolean(opts.idempotencyKey);
+    const maxAttempts = retry && methodRetryable ? retry.retries + 1 : 1;
+    let last = null;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      const result = await once(upper, rel, url, body, opts);
+      if (result.ok)
+        return result.value;
+      last = result;
+      const canRetry = retry !== null && methodRetryable && result.retryable && attempt < maxAttempts;
+      if (!canRetry)
+        break;
+      const backoff = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** (attempt - 1));
+      const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
+      await sleep(backoff + jitter);
+    }
+    throw last.error;
   }
-  return { sessions: ingested, requests };
+  return {
+    baseUrl: base,
+    request,
+    get: (path, opts) => request("GET", path, undefined, opts),
+    post: (path, body, opts) => request("POST", path, body, opts),
+    put: (path, body, opts) => request("PUT", path, body, opts),
+    patch: (path, body, opts) => request("PATCH", path, body, opts),
+    del: (path, body, opts) => request("DELETE", path, body, opts)
+  };
 }
-// src/ingest/gemini.ts
-init_database();
-init_pricing();
-import { readdirSync as readdirSync3, readFileSync as readFileSync5, existsSync as existsSync7, statSync as statSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6, basename as basename3 } from "path";
-var DEFAULT_GEMINI_TMP_DIR = join6(homedir5(), ".gemini", "tmp");
-var DEFAULT_GEMINI_HISTORY_DIR = join6(homedir5(), ".gemini", "history");
-function geminiTmpDir() {
-  return process.env["HASNA_ECONOMY_GEMINI_TMP_DIR"] ?? DEFAULT_GEMINI_TMP_DIR;
-}
-function geminiHistoryDir() {
-  return process.env["HASNA_ECONOMY_GEMINI_HISTORY_DIR"] ?? DEFAULT_GEMINI_HISTORY_DIR;
-}
-function numberField(...values) {
-  for (const value of values) {
-    if (typeof value === "number" && Number.isFinite(value))
-      return value;
-  }
-  return 0;
-}
-function listProjectDirs(...roots) {
-  const dirs = new Set;
-  for (const root of roots) {
-    if (!existsSync7(root))
-      continue;
-    try {
-      for (const entry of readdirSync3(root, { withFileTypes: true })) {
-        if (entry.isDirectory())
-          dirs.add(join6(root, entry.name));
-      }
-    } catch {}
+function createClientTransport(name, env = process.env, overrides) {
+  const resolution = resolveClientTransport(name, env);
+  if (resolution.misconfigured) {
+    throw new Error(resolution.warning ?? `Client for '${name}' is misconfigured for cloud mode.`);
   }
-  return [...dirs];
+  if (resolution.transport === "local" || !resolution.baseUrl) {
+    return { transport: "local", client: null, resolution };
+  }
+  const keys = clientTransportEnvKeys(name);
+  const apiKey = firstEnv(env, keys.apiKeyKeys)?.value;
+  if (!apiKey) {
+    throw new Error(`Client for '${name}' resolved to cloud-http without an API key.`);
+  }
+  return {
+    transport: "cloud-http",
+    client: createHasnaHttpTransport({
+      name,
+      baseUrl: resolution.baseUrl,
+      apiKey,
+      ...overrides?.fetchImpl ? { fetchImpl: overrides.fetchImpl } : {},
+      ...overrides?.headers ? { headers: overrides.headers } : {},
+      ...overrides?.timeoutMs ? { timeoutMs: overrides.timeoutMs } : {},
+      ...overrides?.retry !== undefined ? { retry: overrides.retry } : {},
+      ...overrides?.sleepImpl ? { sleepImpl: overrides.sleepImpl } : {}
+    }),
+    resolution
+  };
 }
-function projectRoot(projectDir, chatData) {
-  if (chatData.projectPath)
-    return chatData.projectPath;
-  if (chatData.project_path)
-    return chatData.project_path;
-  const rootFile = join6(projectDir, ".project_root");
-  try {
-    if (existsSync7(rootFile))
-      return readFileSync5(rootFile, "utf-8").trim();
-  } catch {}
-  return "";
-}
-async function ingestGemini(db, verbose) {
-  const tmpDir = geminiTmpDir();
-  const historyDir = geminiHistoryDir();
-  if (!existsSync7(tmpDir) && !existsSync7(historyDir)) {
-    if (verbose)
-      console.log("Gemini tmp/history dirs not found:", tmpDir, historyDir);
-    return { sessions: 0, requests: 0 };
-  }
-  const machineId = getMachineId();
-  let totalSessions = 0;
-  let totalRequests = 0;
-  const touchedSessions = new Set;
-  const account = await resolveAccountForAgent("gemini");
-  const projectDirs = listProjectDirs(tmpDir, historyDir);
-  for (const projectDir of projectDirs) {
-    const chatsDir = join6(projectDir, "chats");
-    if (!existsSync7(chatsDir))
-      continue;
-    let chatFiles = [];
-    try {
-      chatFiles = readdirSync3(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join6(chatsDir, f));
-    } catch {
-      continue;
+
+// src/lib/contracts-client/storage.ts
+function resourcePath(resource) {
+  const trimmed = resource.replace(/^\/+|\/+$/g, "");
+  if (!trimmed)
+    throw new Error("resource must be a non-empty path segment");
+  return `/${trimmed}`;
+}
+function entityPath(resource, id) {
+  if (id === undefined || id === null || `${id}`.length === 0) {
+    throw new Error("id must be a non-empty string");
+  }
+  return `${resourcePath(resource)}/${encodeURIComponent(String(id))}`;
+}
+function newIdempotencyKey() {
+  const g = globalThis;
+  if (g.crypto?.randomUUID)
+    return g.crypto.randomUUID();
+  return `idmp_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+function extractItems(raw) {
+  if (Array.isArray(raw))
+    return raw;
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["items", "data", "results", "rows", "records"]) {
+      if (Array.isArray(obj[key]))
+        return obj[key];
+    }
+  }
+  return [];
+}
+function extractTotal(raw) {
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["total", "count", "totalCount", "total_count"]) {
+      if (typeof obj[key] === "number")
+        return obj[key];
     }
-    for (const filePath of chatFiles) {
-      const stateKey = filePath.replace(homedir5(), "~");
-      let fileMtime = "0";
+  }
+  return null;
+}
+function extractCursor(raw) {
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["cursor", "nextCursor", "next_cursor", "next"]) {
+      if (typeof obj[key] === "string")
+        return obj[key];
+    }
+  }
+  return null;
+}
+function createHasnaStorageClient(name, transport) {
+  return {
+    name,
+    baseUrl: transport.baseUrl,
+    transport,
+    async list(resource, options = {}) {
+      const raw = await transport.get(resourcePath(resource), options);
+      return {
+        items: extractItems(raw),
+        total: extractTotal(raw),
+        cursor: extractCursor(raw),
+        raw
+      };
+    },
+    async get(resource, id, options = {}) {
       try {
-        fileMtime = statSync3(filePath).mtimeMs.toString();
-      } catch {
-        continue;
+        return await transport.get(entityPath(resource, id), options);
+      } catch (error) {
+        if (error instanceof HasnaHttpError && error.status === 404)
+          return null;
+        throw error;
       }
-      const processed = getIngestState(db, "gemini", stateKey);
-      if (processed === fileMtime)
-        continue;
-      let chatData;
+    },
+    async create(resource, body, options = {}) {
+      const { idempotencyKey, ...rest } = options;
+      return transport.post(resourcePath(resource), body, {
+        ...rest,
+        idempotencyKey: idempotencyKey ?? newIdempotencyKey()
+      });
+    },
+    async update(resource, id, patch, options = {}) {
+      const { method = "PATCH", idempotencyKey, ...rest } = options;
+      const call = method === "PUT" ? transport.put : transport.patch;
+      return call(entityPath(resource, id), patch, { ...rest, ...idempotencyKey ? { idempotencyKey } : {} });
+    },
+    async delete(resource, id, options = {}) {
       try {
-        chatData = JSON.parse(readFileSync5(filePath, "utf-8"));
-      } catch {
-        continue;
-      }
-      const sessionId = chatData.sessionId ?? chatData.id ?? basename3(filePath, ".json");
-      if (!sessionId)
-        continue;
-      const startTime = chatData.startTime ?? new Date().toISOString();
-      const projectPath = projectRoot(projectDir, chatData);
-      const projectName = projectPath ? basename3(projectPath) : "";
-      const existing = db.prepare(`SELECT id FROM sessions WHERE id = ?`).get(sessionId);
-      if (!existing) {
-        const session = {
-          id: sessionId,
-          agent: "gemini",
-          project_path: projectPath,
-          project_name: projectName,
-          started_at: startTime,
-          ended_at: chatData.lastUpdated ?? null,
-          total_cost_usd: 0,
-          total_tokens: 0,
-          request_count: 0,
-          machine_id: machineId
-        };
-        upsertSession(db, withAccount(session, account));
-        totalSessions++;
-      }
-      touchedSessions.add(sessionId);
-      for (const [index, message] of (chatData.messages ?? []).entries()) {
-        const usage = message.usage ?? message.usageMetadata ?? message.response?.usageMetadata;
-        if (!usage)
-          continue;
-        const model = message.model ?? message.response?.modelVersion ?? message.response?.model ?? chatData.model;
-        if (!model)
-          continue;
-        const toolUsePromptTokens = numberField(usage.toolUsePromptTokenCount, usage.tool_use_prompt_token_count);
-        const inputTotal = numberField(usage.inputTokens, usage.input_tokens, usage.promptTokenCount, usage.prompt_token_count) + toolUsePromptTokens;
-        const cacheReadTokens = numberField(usage.cachedInputTokens, usage.cache_read_tokens, usage.cachedContentTokenCount, usage.cached_content_token_count);
-        const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
-        const thoughtsTokens = numberField(usage.thoughtsTokenCount, usage.thoughts_token_count);
-        const outputTokens = numberField(usage.outputTokens, usage.output_tokens, usage.candidatesTokenCount, usage.candidates_token_count) + thoughtsTokens;
-        const totalTokens = numberField(usage.totalTokens, usage.total_tokens, usage.totalTokenCount, usage.total_token_count);
-        if (inputTokens + outputTokens + cacheReadTokens + totalTokens === 0)
-          continue;
-        const computedCost = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
-        const costUsd = numberField(message.costUsd, message.cost_usd) || computedCost;
-        const timestamp = message.timestamp ?? chatData.lastUpdated ?? startTime;
-        const requestId = `gemini-${sessionId}-${message.id ?? index}`;
-        upsertRequest(db, withAccount({
-          id: requestId,
-          agent: "gemini",
-          session_id: sessionId,
-          model,
-          input_tokens: inputTokens,
-          output_tokens: outputTokens,
-          cache_read_tokens: cacheReadTokens,
-          cache_create_tokens: 0,
-          cost_usd: costUsd,
-          cost_basis: defaultCostBasisForAgent("gemini"),
-          duration_ms: 0,
-          timestamp,
-          source_request_id: message.id ?? requestId,
-          machine_id: machineId
-        }, account));
-        totalRequests++;
+        await transport.del(entityPath(resource, id), undefined, options);
+      } catch (error) {
+        if (error instanceof HasnaHttpError && error.status === 404)
+          return;
+        throw error;
       }
-      setIngestState(db, "gemini", stateKey, fileMtime);
     }
+  };
+}
+function resolveStorageClient(name, env = process.env, overrides) {
+  const wired = createClientTransport(name, env, overrides);
+  if (wired.transport === "cloud-http") {
+    return { transport: "cloud-http", client: createHasnaStorageClient(name, wired.client) };
   }
-  for (const sessionId of touchedSessions) {
-    rollupSession(db, sessionId);
+  return { transport: "local", client: null };
+}
+
+// src/lib/cloud-storage.ts
+var ECONOMY_APP = "economy";
+var cache;
+function resolveEconomyCloudStorage(env = process.env, overrides) {
+  const resolved = resolveStorageClient(ECONOMY_APP, env, overrides);
+  return resolved.transport === "cloud-http" ? { active: true, client: resolved.client } : { active: false, client: null };
+}
+function economyCloudStorage(env = process.env) {
+  if (cache === undefined)
+    cache = resolveEconomyCloudStorage(env);
+  return cache;
+}
+function cleanQuery(query) {
+  if (!query)
+    return;
+  const out = {};
+  for (const [k, v] of Object.entries(query)) {
+    if (v !== undefined && v !== null && v !== "")
+      out[k] = v;
   }
-  return { sessions: totalSessions, requests: totalRequests };
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+async function cloudListItems(storage, resource, query) {
+  const cleaned = cleanQuery(query);
+  const res = await storage.client.list(resource, cleaned ? { query: cleaned } : {});
+  return res.items;
+}
+async function cloudObject(storage, path, query) {
+  const cleaned = cleanQuery(query);
+  const raw = await storage.client.transport.get(path, cleaned ? { query: cleaned } : {});
+  if (raw && typeof raw === "object" && "data" in raw) {
+    return raw.data;
+  }
+  return raw;
+}
+
+// src/lib/store/index.ts
+class LocalStore {
+  transport = "local";
+  _db;
+  db() {
+    if (!this._db) {
+      this._db = openDatabase();
+      ensurePricingSeeded(this._db);
+    }
+    return this._db;
+  }
+  async summary(period, machine) {
+    return querySummary(this.db(), period, machine);
+  }
+  async sessions(filter) {
+    return querySessions(this.db(), filter);
+  }
+  async topSessions(n, agent, since) {
+    return queryTopSessions(this.db(), n, agent, since);
+  }
+  async sessionDetail(id) {
+    return getSessionDetail(this.db(), id);
+  }
+  async modelBreakdown(query = {}) {
+    return query.since ? queryModelBreakdownSince(this.db(), query.since) : queryModelBreakdown(this.db());
+  }
+  async agentBreakdown(query = {}) {
+    return query.since ? queryAgentBreakdownSince(this.db(), query.since) : queryAgentBreakdown(this.db(), query.period ?? "all", query.machine);
+  }
+  async projectBreakdown(query = {}) {
+    return query.since ? queryProjectBreakdownSince(this.db(), query.since) : queryProjectBreakdown(this.db(), query.period ?? "all", query.machine);
+  }
+  async accountBreakdown(query = {}) {
+    return query.since ? queryAccountBreakdownSince(this.db(), query.since) : queryAccountBreakdown(this.db(), query.period ?? "all", query.machine);
+  }
+  async accounts(period) {
+    return queryAccountBreakdown(this.db(), period);
+  }
+  async daily(days, machine) {
+    return queryDailyBreakdown(this.db(), days, machine);
+  }
+  async machines() {
+    return listMachines(this.db());
+  }
+  async fleet(period) {
+    return {
+      summary: querySummary(this.db(), period, undefined, true),
+      machines: listMachines(this.db(), period),
+      registry: listMachineRegistry(this.db())
+    };
+  }
+  async billingSummary(period) {
+    return queryBillingSummary(this.db(), period);
+  }
+  async billingDiff(period) {
+    return queryBillingDiff(this.db(), period);
+  }
+  async usage(period, agent) {
+    const snapshots = queryUsageSnapshots(this.db(), { agent, ...usageSnapshotFilterForPeriod(period) });
+    const summary = querySummary(this.db(), period, undefined, true, agent);
+    return { snapshots, summary };
+  }
+  async savings(period, agent) {
+    return querySavingsSummary(this.db(), period, agent);
+  }
+  async listBudgets() {
+    return getBudgetStatuses(this.db());
+  }
+  async listGoals() {
+    return getGoalStatuses(this.db());
+  }
+  async listPricing() {
+    return listModelPricing(this.db());
+  }
+  async listSubscriptions() {
+    return listSubscriptions(this.db());
+  }
+  async listProjects() {
+    return queryProjectBreakdown(this.db());
+  }
+  async brief(query = {}) {
+    return buildBrief(this.db(), {
+      since: query.since,
+      machine: query.machine,
+      currentMachineId: query.currentMachineId,
+      localSyncAt: query.localSyncAt
+    });
+  }
+  async projectDetail(nameOrPath) {
+    return queryProjectDetail(this.db(), nameOrPath);
+  }
+  async exportRows(type, period) {
+    return queryExportRows(this.db(), type, period);
+  }
+  async rangeStats(from, to) {
+    return queryRangeStats(this.db(), from, to);
+  }
+  async forecast() {
+    return queryForecast(this.db());
+  }
+  async efficiency() {
+    return queryModelEfficiency(this.db());
+  }
+  async recentRequests(since) {
+    return queryRequestsSince(this.db(), since);
+  }
+  async estimate(input) {
+    return estimateCostFromRows(listModelPricing(this.db()), input.model, input.inputTokens, input.outputTokens, input.cacheReadTokens ?? 0, input.cacheWriteTokens ?? 0, input.cacheWrite1hTokens ?? 0, input.cacheStorageTokenHours ?? 0);
+  }
+  async setBudget(input) {
+    const now = new Date().toISOString();
+    const budget = { id: randomUUID(), ...input, created_at: now, updated_at: now };
+    upsertBudget(this.db(), budget);
+    return budget.id;
+  }
+  async removeBudget(id) {
+    deleteBudget(this.db(), id);
+  }
+  async setGoal(input) {
+    const now = new Date().toISOString();
+    upsertGoal(this.db(), { id: randomUUID(), ...input, created_at: now, updated_at: now });
+  }
+  async removeGoal(id) {
+    deleteGoal(this.db(), id);
+  }
+  async setPricing(input) {
+    upsertModelPricing(this.db(), { ...input, updated_at: new Date().toISOString() });
+  }
+  async removePricing(model) {
+    deleteModelPricing(this.db(), model);
+  }
+  async setSubscription(input) {
+    const now = new Date().toISOString();
+    const row = {
+      id: input.id ?? randomUUID(),
+      provider: input.provider,
+      plan: input.plan,
+      agent: input.agent,
+      monthly_fee_usd: input.monthly_fee_usd,
+      included_usage_usd: input.included_usage_usd,
+      billing_cycle_start: input.billing_cycle_start,
+      reset_policy: input.reset_policy,
+      active: input.active,
+      created_at: now,
+      updated_at: now
+    };
+    upsertSubscription(this.db(), row);
+    return row;
+  }
+  async removeSubscription(id) {
+    deleteSubscription(this.db(), id);
+  }
+  async addProject(path, name) {
+    upsertProject(this.db(), {
+      id: randomUUID(),
+      path,
+      name,
+      description: null,
+      tags: [],
+      created_at: new Date().toISOString()
+    });
+  }
+  async renameProject(path, name) {
+    const existing = getProject(this.db(), path);
+    if (!existing)
+      throw new Error("Project not found");
+    upsertProject(this.db(), { ...existing, name });
+  }
+  async removeProject(path) {
+    deleteProject(this.db(), path);
+  }
+}
+function q(params) {
+  const out = {};
+  for (const [k, v] of Object.entries(params))
+    if (v !== undefined && v !== null && v !== "")
+      out[k] = v;
+  return out;
+}
+
+class ApiStore {
+  cloud;
+  transport = "cloud-http";
+  constructor(cloud) {
+    this.cloud = cloud;
+  }
+  async summary(period, machine) {
+    return cloudObject(this.cloud, "/summary", q({ period, machine }));
+  }
+  async sessions(filter) {
+    return cloudListItems(this.cloud, "sessions", q({ ...filter }));
+  }
+  async topSessions(n, agent, since) {
+    return cloudListItems(this.cloud, "top", q({ n, agent, since }));
+  }
+  async sessionDetail(id) {
+    const matches = await cloudListItems(this.cloud, "sessions", q({ search: id, limit: 1 }));
+    const session = matches[0];
+    if (!session)
+      return null;
+    const requests = await cloudObject(this.cloud, `/sessions/${encodeURIComponent(String(session["id"]))}/requests`);
+    return { session, requests: requests ?? [] };
+  }
+  async modelBreakdown(query = {}) {
+    return cloudListItems(this.cloud, "breakdown", q({ by: "model", period: query.period, since: query.since }));
+  }
+  async agentBreakdown(query = {}) {
+    return cloudListItems(this.cloud, "breakdown", q({ by: "agent", period: query.period, since: query.since }));
+  }
+  async projectBreakdown(query = {}) {
+    return cloudListItems(this.cloud, "breakdown", q({ by: "project", period: query.period, since: query.since }));
+  }
+  async accountBreakdown(query = {}) {
+    return cloudListItems(this.cloud, "breakdown", q({ by: "account", period: query.period, since: query.since }));
+  }
+  async accounts(period) {
+    return cloudListItems(this.cloud, "accounts", q({ period }));
+  }
+  async daily(days, machine) {
+    return cloudListItems(this.cloud, "daily", q({ days, machine }));
+  }
+  async machines() {
+    return cloudListItems(this.cloud, "machines");
+  }
+  async fleet(period) {
+    const data = await cloudObject(this.cloud, "/fleet", q({ period }));
+    return {
+      summary: data.summary,
+      machines: data.machines ?? [],
+      registry: data.registry ?? []
+    };
+  }
+  async billingSummary(period) {
+    return cloudObject(this.cloud, "/billing", q({ period }));
+  }
+  async billingDiff(period) {
+    return cloudObject(this.cloud, "/billing/diff", q({ period }));
+  }
+  async usage(period, agent) {
+    return cloudObject(this.cloud, "/usage", q({ period, agent }));
+  }
+  async savings(period, agent) {
+    return cloudObject(this.cloud, "/savings", q({ period, agent }));
+  }
+  async listBudgets() {
+    return cloudListItems(this.cloud, "budgets");
+  }
+  async listGoals() {
+    return cloudListItems(this.cloud, "goals");
+  }
+  async listPricing() {
+    return cloudListItems(this.cloud, "pricing");
+  }
+  async listSubscriptions() {
+    return cloudListItems(this.cloud, "subscriptions");
+  }
+  async listProjects() {
+    return cloudListItems(this.cloud, "projects");
+  }
+  async brief(query = {}) {
+    return cloudObject(this.cloud, "/brief", q({ since: query.since, machine: query.machine }));
+  }
+  async projectDetail(nameOrPath) {
+    return cloudObject(this.cloud, "/projects/detail", q({ q: nameOrPath }));
+  }
+  async exportRows(type, period) {
+    return cloudListItems(this.cloud, "export", q({ type, period }));
+  }
+  async rangeStats(from, to) {
+    return cloudObject(this.cloud, "/compare", q({ from, to }));
+  }
+  async forecast() {
+    return cloudObject(this.cloud, "/forecast");
+  }
+  async efficiency() {
+    return cloudListItems(this.cloud, "efficiency");
+  }
+  async recentRequests(since) {
+    return cloudListItems(this.cloud, "requests", q({ since }));
+  }
+  async estimate(input) {
+    const rows = await this.listPricing();
+    return estimateCostFromRows(rows, input.model, input.inputTokens, input.outputTokens, input.cacheReadTokens ?? 0, input.cacheWriteTokens ?? 0, input.cacheWrite1hTokens ?? 0, input.cacheStorageTokenHours ?? 0);
+  }
+  async setBudget(input) {
+    const created = await this.cloud.client.create("budgets", {
+      project_path: input.project_path,
+      ...input.agent ? { agent: input.agent } : {},
+      period: input.period,
+      limit_usd: input.limit_usd,
+      alert_at_percent: input.alert_at_percent
+    });
+    return created?.id ?? "";
+  }
+  async removeBudget(id) {
+    await this.cloud.client.delete("budgets", id);
+  }
+  async setGoal(input) {
+    await this.cloud.client.create("goals", {
+      period: input.period,
+      project_path: input.project_path,
+      ...input.agent ? { agent: input.agent } : {},
+      limit_usd: input.limit_usd
+    });
+  }
+  async removeGoal(id) {
+    await this.cloud.client.delete("goals", id);
+  }
+  async setPricing(input) {
+    await this.cloud.client.create("pricing", { ...input, updated_at: new Date().toISOString() });
+  }
+  async removePricing(model) {
+    await this.cloud.client.delete("pricing", model);
+  }
+  async setSubscription(input) {
+    const now = new Date().toISOString();
+    const row = {
+      id: input.id ?? randomUUID(),
+      provider: input.provider,
+      plan: input.plan,
+      agent: input.agent,
+      monthly_fee_usd: input.monthly_fee_usd,
+      included_usage_usd: input.included_usage_usd,
+      billing_cycle_start: input.billing_cycle_start,
+      reset_policy: input.reset_policy,
+      active: input.active,
+      created_at: now,
+      updated_at: now
+    };
+    await this.cloud.client.create("subscriptions", row);
+    return row;
+  }
+  async removeSubscription(id) {
+    await this.cloud.client.delete("subscriptions", id);
+  }
+  async addProject(path, name) {
+    await this.cloud.client.create("project-registry", { path, name, description: null, tags: [] });
+  }
+  async renameProject(path, name) {
+    await this.cloud.client.delete("project-registry", path);
+    await this.cloud.client.create("project-registry", { path, name, description: null, tags: [] });
+  }
+  async removeProject(path) {
+    await this.cloud.client.delete("project-registry", path);
+  }
+}
+function getStore(env = process.env) {
+  const cloud = economyCloudStorage(env);
+  return cloud.active ? new ApiStore(cloud) : new LocalStore;
+}
+function isCloudStore(env = process.env) {
+  return economyCloudStorage(env).active;
 }
 export {
-  writeFleetSyncReport,
-  verifySqliteIntegrity,
-  upsertUsageSnapshot,
-  upsertSubscription,
-  upsertSession,
-  upsertRequest,
-  upsertProject,
-  upsertModelPricing,
-  upsertGoal,
-  upsertBudget,
-  upsertBillingDaily,
-  syncOpenProjectsRegistry,
-  setIngestState,
-  setActiveModel,
-  seedModelPricing,
-  runEconomyFleetSync,
-  rollupSession,
-  readCodexModel,
-  queryZeroCostTokenizedModels,
-  queryUsageSnapshots,
-  queryTopSessions,
-  querySummary,
-  querySessions,
-  queryRequestsSince,
-  queryProjectBreakdown,
-  queryModelBreakdown,
-  queryHourlyBreakdown,
-  queryDailyBreakdown,
-  queryBillingSummary,
-  queryAgentBreakdown,
-  queryAccountBreakdown,
-  openDatabase,
-  normalizeModelName,
-  mergePeerDatabase,
-  listSubscriptions,
-  listProjects,
-  listModelPricing,
-  listMachines,
-  listMachineRegistry,
-  listGoals,
-  listBudgets,
-  isSafeRemoteSnapshotPath,
+  isCloudStore,
   isAgent,
-  ingestTakumi,
-  ingestJsonlProjects,
-  ingestGemini,
-  ingestCodex,
-  ingestClaude,
-  getProject,
-  getPricingFromDb,
-  getPricing,
-  getModelPricing,
-  getMachineId,
-  getIngestState,
-  getGoalStatuses,
-  getDbPath,
-  getDataDir,
-  getBudgetStatuses,
-  getActiveModel,
-  gatherTrainingData,
-  ensurePricingSeeded,
-  deleteSubscription,
-  deleteProject,
-  deleteModelPricing,
-  deleteGoal,
-  deleteBudget,
-  dedupeRequests,
-  computeCostFromDb,
-  computeCost,
-  clearBillingRange,
-  clearActiveModel,
-  DEFAULT_PRICING,
-  DEFAULT_MODEL,
+  getStore,
+  LocalStore,
   COST_BASIS,
+  ApiStore,
   AGENTS
 };