@hasna/economy 0.2.5 → 0.2.6

package/dist/cli/index.js

@@ -0,0 +1,2235 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+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,
+  getPricingFromDb: () => getPricingFromDb,
+  getPricing: () => getPricing,
+  ensurePricingSeeded: () => ensurePricingSeeded,
+  computeCostFromDb: () => computeCostFromDb,
+  computeCost: () => computeCost,
+  DEFAULT_PRICING: () => DEFAULT_PRICING
+});
+function normalizeModelName(raw) {
+  return raw.replace(/-\d{8}$/, "").replace(/-\d{4}-\d{2}-\d{2}$/, "").toLowerCase();
+}
+function ensurePricingSeeded(db) {
+  seedModelPricing(db, DEFAULT_PRICING);
+}
+function getPricingFromDb(db, model) {
+  const normalized = normalizeModelName(model);
+  const row = getModelPricing(db, normalized);
+  if (row) {
+    return {
+      inputPer1M: row.input_per_1m,
+      outputPer1M: row.output_per_1m,
+      cacheReadPer1M: row.cache_read_per_1m,
+      cacheWritePer1M: row.cache_write_per_1m
+    };
+  }
+  const allRows = db.prepare(`SELECT * FROM model_pricing`).all();
+  for (const r of allRows) {
+    if (normalized.startsWith(r.model)) {
+      return { inputPer1M: r.input_per_1m, outputPer1M: r.output_per_1m, cacheReadPer1M: r.cache_read_per_1m, cacheWritePer1M: r.cache_write_per_1m };
+    }
+  }
+  return null;
+}
+function getPricing(model) {
+  const normalized = normalizeModelName(model);
+  if (DEFAULT_PRICING[normalized])
+    return DEFAULT_PRICING[normalized] ?? null;
+  for (const key of Object.keys(DEFAULT_PRICING)) {
+    if (normalized.startsWith(key))
+      return DEFAULT_PRICING[key] ?? null;
+  }
+  return null;
+}
+function computeCost(model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
+  const pricing = getPricing(model);
+  if (!pricing)
+    return 0;
+  return (inputTokens * pricing.inputPer1M + outputTokens * pricing.outputPer1M + cacheReadTokens * pricing.cacheReadPer1M + cacheWriteTokens * pricing.cacheWritePer1M) / 1e6;
+}
+function computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
+  const pricing = getPricingFromDb(db, model) ?? getPricing(model);
+  if (!pricing)
+    return 0;
+  return (inputTokens * pricing.inputPer1M + outputTokens * pricing.outputPer1M + cacheReadTokens * pricing.cacheReadPer1M + cacheWriteTokens * pricing.cacheWritePer1M) / 1e6;
+}
+var DEFAULT_PRICING;
+var init_pricing = __esm(() => {
+  init_database();
+  DEFAULT_PRICING = {
+    "claude-opus-4-6": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25 },
+    "claude-opus-4-5": { inputPer1M: 5, outputPer1M: 25, cacheReadPer1M: 0.5, cacheWritePer1M: 6.25 },
+    "claude-sonnet-4-6": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+    "claude-sonnet-4-5": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+    "claude-haiku-4-5": { inputPer1M: 1, outputPer1M: 5, cacheReadPer1M: 0.1, cacheWritePer1M: 1.25 },
+    "claude-3-5-sonnet": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+    "claude-3-5-haiku": { inputPer1M: 1, outputPer1M: 5, cacheReadPer1M: 0.1, cacheWritePer1M: 1.25 },
+    "claude-3-opus": { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheWritePer1M: 18.75 },
+    "claude-3-sonnet": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+    "claude-3-haiku": { inputPer1M: 0.25, outputPer1M: 1.25, cacheReadPer1M: 0.03, cacheWritePer1M: 0.3 },
+    "gemini-2.0-flash": { inputPer1M: 0.075, outputPer1M: 0.3, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+    "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+    "gemini-1.5-pro": { inputPer1M: 1.25, outputPer1M: 5, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+    "gemini-1.5-flash": { inputPer1M: 0.075, outputPer1M: 0.3, cacheReadPer1M: 0, cacheWritePer1M: 0 },
+    "gpt-5.3-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+    "gpt-5.2-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+    "gpt-5-codex": { inputPer1M: 1.75, outputPer1M: 14, cacheReadPer1M: 0.44, cacheWritePer1M: 0 },
+    "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10, cacheReadPer1M: 1.25, cacheWritePer1M: 0 },
+    "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6, cacheReadPer1M: 0.075, cacheWritePer1M: 0 },
+    o1: { inputPer1M: 15, outputPer1M: 60, cacheReadPer1M: 7.5, cacheWritePer1M: 0 },
+    "o1-mini": { inputPer1M: 3, outputPer1M: 12, cacheReadPer1M: 1.5, cacheWritePer1M: 0 },
+    o3: { inputPer1M: 10, outputPer1M: 40, cacheReadPer1M: 2.5, cacheWritePer1M: 0 },
+    "o3-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cacheReadPer1M: 0.55, cacheWritePer1M: 0 },
+    "o4-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cacheReadPer1M: 0.275, cacheWritePer1M: 0 }
+  };
+});
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getDbPath() {
+  return process.env["ECONOMY_DB"] ?? join(homedir(), ".economy", "economy.db");
+}
+function openDatabase(dbPath, skipSeed = false) {
+  const path = dbPath ?? getDbPath();
+  if (path !== ":memory:") {
+    const dir = path.substring(0, path.lastIndexOf("/"));
+    if (dir && !existsSync(dir))
+      mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  initSchema(db);
+  if (!skipSeed) {
+    Promise.resolve().then(() => (init_pricing(), exports_pricing)).then(({ ensurePricingSeeded: ensurePricingSeeded2 }) => ensurePricingSeeded2(db)).catch(() => {});
+  }
+  return db;
+}
+function initSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS requests (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER DEFAULT 0,
+      output_tokens INTEGER DEFAULT 0,
+      cache_read_tokens INTEGER DEFAULT 0,
+      cache_create_tokens INTEGER DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      duration_ms INTEGER DEFAULT 0,
+      timestamp TEXT NOT NULL,
+      source_request_id TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      project_path TEXT DEFAULT '',
+      project_name TEXT DEFAULT '',
+      started_at TEXT NOT NULL,
+      ended_at TEXT,
+      total_cost_usd REAL DEFAULT 0,
+      total_tokens INTEGER DEFAULT 0,
+      request_count INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      path TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      tags TEXT DEFAULT '[]',
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS budgets (
+      id TEXT PRIMARY KEY,
+      project_path TEXT,
+      agent TEXT,
+      period TEXT NOT NULL,
+      limit_usd REAL NOT NULL,
+      alert_at_percent INTEGER DEFAULT 80,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS goals (
+      id TEXT PRIMARY KEY,
+      period TEXT NOT NULL,
+      project_path TEXT,
+      agent TEXT,
+      limit_usd REAL NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS ingest_state (
+      source TEXT NOT NULL,
+      key TEXT NOT NULL,
+      value TEXT NOT NULL,
+      PRIMARY KEY (source, key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_requests_session ON requests(session_id);
+    CREATE INDEX IF NOT EXISTS idx_requests_timestamp ON requests(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_requests_agent ON requests(agent);
+    CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent);
+    CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_path);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+
+    CREATE TABLE IF NOT EXISTS model_pricing (
+      model TEXT PRIMARY KEY,
+      input_per_1m REAL NOT NULL DEFAULT 0,
+      output_per_1m REAL NOT NULL DEFAULT 0,
+      cache_read_per_1m REAL NOT NULL DEFAULT 0,
+      cache_write_per_1m REAL NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL
+    );
+  `);
+}
+function periodWhere(period) {
+  switch (period) {
+    case "today":
+      return `DATE(timestamp) = DATE('now')`;
+    case "week":
+      return `timestamp >= DATE('now', '-7 days')`;
+    case "month":
+      return `timestamp >= DATE('now', '-30 days')`;
+    case "year":
+      return `timestamp >= DATE('now', '-365 days')`;
+    case "all":
+      return "1=1";
+  }
+}
+function sessionPeriodWhere(period) {
+  switch (period) {
+    case "today":
+      return `DATE(started_at) = DATE('now')`;
+    case "week":
+      return `started_at >= DATE('now', '-7 days')`;
+    case "month":
+      return `started_at >= DATE('now', '-30 days')`;
+    case "year":
+      return `started_at >= DATE('now', '-365 days')`;
+    case "all":
+      return "1=1";
+  }
+}
+function upsertRequest(db, req) {
+  db.prepare(`
+    INSERT OR REPLACE INTO requests
+      (id, agent, session_id, model, input_tokens, output_tokens,
+       cache_read_tokens, cache_create_tokens, cost_usd, duration_ms,
+       timestamp, source_request_id)
+    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.cost_usd, req.duration_ms, req.timestamp, req.source_request_id);
+}
+function upsertSession(db, session) {
+  db.prepare(`
+    INSERT OR REPLACE INTO sessions
+      (id, agent, project_path, project_name, started_at, ended_at,
+       total_cost_usd, total_tokens, request_count)
+    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);
+}
+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
+    WHERE id = ?
+  `).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId);
+}
+function querySessions(db, filter = {}) {
+  const conditions = [];
+  const params = [];
+  if (filter.agent) {
+    conditions.push("agent = ?");
+    params.push(filter.agent);
+  }
+  if (filter.project) {
+    conditions.push("project_path LIKE ?");
+    params.push(`%${filter.project}%`);
+  }
+  if (filter.since) {
+    conditions.push("started_at >= ?");
+    params.push(filter.since);
+  }
+  if (filter.search) {
+    const q = `%${filter.search}%`;
+    conditions.push("(project_name LIKE ? OR agent LIKE ? OR id LIKE ?)");
+    params.push(q, q, `${filter.search}%`);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filter.limit ?? 50;
+  const offset = filter.offset ?? 0;
+  return db.prepare(`
+    SELECT * FROM sessions ${where} ORDER BY started_at DESC LIMIT ? OFFSET ?
+  `).all(...params, limit, offset);
+}
+function queryTopSessions(db, n = 10, agent) {
+  if (agent) {
+    return db.prepare(`SELECT * FROM sessions WHERE agent = ? ORDER BY total_cost_usd DESC LIMIT ?`).all(agent, n);
+  }
+  return db.prepare(`SELECT * FROM sessions ORDER BY total_cost_usd DESC LIMIT ?`).all(n);
+}
+function querySummary(db, period) {
+  const rWhere = periodWhere(period);
+  const sWhere = sessionPeriodWhere(period);
+  const r = db.prepare(`
+    SELECT COALESCE(SUM(cost_usd), 0) as total_usd,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as tokens
+    FROM requests WHERE ${rWhere}
+  `).get();
+  const codexTotals = db.prepare(`
+    SELECT COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+           COALESCE(SUM(total_tokens), 0) as tokens,
+           COUNT(*) as sessions
+    FROM sessions
+    WHERE ${sWhere}
+    AND id NOT IN (SELECT DISTINCT session_id FROM requests)
+  `).get();
+  const sessionCount = db.prepare(`SELECT COUNT(*) as sessions FROM sessions WHERE ${sWhere}`).get();
+  return {
+    total_usd: r.total_usd + codexTotals.cost_usd,
+    requests: r.requests,
+    tokens: r.tokens + codexTotals.tokens,
+    sessions: sessionCount.sessions,
+    period
+  };
+}
+function queryModelBreakdown(db) {
+  return db.prepare(`
+    SELECT model, agent,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens), 0) as input_tokens,
+           COALESCE(SUM(output_tokens), 0) as output_tokens,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM requests GROUP BY model, agent ORDER BY cost_usd DESC
+  `).all();
+}
+function queryProjectBreakdown(db) {
+  return db.prepare(`
+    SELECT
+      s.project_path,
+      COALESCE(p.name, s.project_name) as project_name,
+      COUNT(DISTINCT s.id) as sessions,
+      COUNT(r.id) as requests,
+      COALESCE(SUM(r.cost_usd), COALESCE(SUM(s.total_cost_usd), 0)) as cost_usd,
+      COALESCE(SUM(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens), 0) as total_tokens,
+      MAX(s.started_at) as last_active
+    FROM sessions s
+    LEFT JOIN projects p ON p.path = s.project_path OR p.name = s.project_name
+    LEFT JOIN requests r ON r.session_id = s.id
+    WHERE s.project_path != '' OR s.project_name != ''
+    GROUP BY s.project_path
+    ORDER BY cost_usd DESC
+  `).all();
+}
+function queryDailyBreakdown(db, days = 30) {
+  return db.prepare(`
+    SELECT DATE(timestamp) as date, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM requests
+    WHERE timestamp >= DATE('now', ? || ' days')
+    GROUP BY DATE(timestamp), agent
+    ORDER BY date ASC
+  `).all(`-${days}`);
+}
+function upsertProject(db, project) {
+  db.prepare(`
+    INSERT OR REPLACE INTO projects (id, path, name, description, tags, created_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(project.id, project.path, project.name, project.description ?? null, JSON.stringify(project.tags), project.created_at);
+}
+function getProject(db, path) {
+  const row = db.prepare(`SELECT * FROM projects WHERE path = ?`).get(path);
+  if (!row)
+    return null;
+  return { ...row, tags: JSON.parse(row["tags"] ?? "[]") };
+}
+function listProjects(db) {
+  return db.prepare(`SELECT * FROM projects ORDER BY created_at DESC`).all().map((row) => ({ ...row, tags: JSON.parse(row["tags"] ?? "[]") }));
+}
+function deleteProject(db, path) {
+  db.prepare(`DELETE FROM projects WHERE path = ?`).run(path);
+}
+function upsertBudget(db, budget) {
+  db.prepare(`
+    INSERT OR REPLACE INTO budgets
+      (id, project_path, agent, period, limit_usd, alert_at_percent, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(budget.id, budget.project_path ?? null, budget.agent ?? null, budget.period, budget.limit_usd, budget.alert_at_percent, budget.created_at, budget.updated_at);
+}
+function listBudgets(db) {
+  return db.prepare(`SELECT * FROM budgets ORDER BY created_at DESC`).all();
+}
+function deleteBudget(db, id) {
+  db.prepare(`DELETE FROM budgets WHERE id = ?`).run(id);
+}
+function getBudgetStatuses(db) {
+  const budgets = listBudgets(db);
+  return budgets.map((b) => {
+    const periodStart = b.period === "daily" ? "DATE('now')" : b.period === "weekly" ? "DATE('now', '-7 days')" : "DATE('now', '-30 days')";
+    let spendQuery = `SELECT COALESCE(SUM(cost_usd), 0) as spend FROM requests WHERE timestamp >= ${periodStart}`;
+    const params = [];
+    if (b.project_path) {
+      spendQuery += ` AND session_id IN (SELECT id FROM sessions WHERE project_path = ?)`;
+      params.push(b.project_path);
+    }
+    if (b.agent) {
+      spendQuery += ` AND agent = ?`;
+      params.push(b.agent);
+    }
+    const row = db.prepare(spendQuery).get(...params);
+    const spend = row.spend;
+    const percent = b.limit_usd > 0 ? spend / b.limit_usd * 100 : 0;
+    return {
+      ...b,
+      current_spend_usd: spend,
+      percent_used: percent,
+      is_over_limit: percent >= 100,
+      is_over_alert: percent >= b.alert_at_percent
+    };
+  });
+}
+function upsertGoal(db, goal) {
+  db.prepare(`
+    INSERT OR REPLACE INTO goals
+      (id, period, project_path, agent, limit_usd, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(goal.id, goal.period, goal.project_path ?? null, goal.agent ?? null, goal.limit_usd, goal.created_at, goal.updated_at);
+}
+function deleteGoal(db, id) {
+  db.prepare(`DELETE FROM goals WHERE id = ?`).run(id);
+}
+function listGoals(db) {
+  return db.prepare(`SELECT * FROM goals ORDER BY created_at DESC`).all();
+}
+function getGoalStatuses(db) {
+  const goals = listGoals(db);
+  return goals.map((g) => {
+    const periodStart = g.period === "day" ? "DATE('now')" : g.period === "week" ? "DATE('now', '-7 days')" : g.period === "month" ? "DATE('now', '-30 days')" : "DATE('now', '-365 days')";
+    let spendQuery = `SELECT COALESCE(SUM(cost_usd), 0) as spend FROM requests WHERE timestamp >= ${periodStart}`;
+    const params = [];
+    if (g.project_path) {
+      spendQuery += ` AND session_id IN (SELECT id FROM sessions WHERE project_path = ?)`;
+      params.push(g.project_path);
+    }
+    if (g.agent) {
+      spendQuery += ` AND agent = ?`;
+      params.push(g.agent);
+    }
+    const row = db.prepare(spendQuery).get(...params);
+    const spend = row.spend;
+    const percent = g.limit_usd > 0 ? spend / g.limit_usd * 100 : 0;
+    return {
+      ...g,
+      current_spend_usd: spend,
+      percent_used: percent,
+      is_on_track: percent < 70,
+      is_at_risk: percent >= 70 && percent <= 100,
+      is_over: percent > 100
+    };
+  });
+}
+function getIngestState(db, source, key) {
+  const row = db.prepare(`SELECT value FROM ingest_state WHERE source = ? AND key = ?`).get(source, key);
+  return row?.value ?? null;
+}
+function 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 upsertModelPricing(db, p) {
+  db.prepare(`
+    INSERT OR REPLACE INTO model_pricing
+      (model, input_per_1m, output_per_1m, cache_read_per_1m, cache_write_per_1m, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(p.model, p.input_per_1m, p.output_per_1m, p.cache_read_per_1m, p.cache_write_per_1m, p.updated_at);
+}
+function getModelPricing(db, model) {
+  return db.prepare(`SELECT * FROM model_pricing WHERE model = ?`).get(model);
+}
+function listModelPricing(db) {
+  return db.prepare(`SELECT * FROM model_pricing ORDER BY model ASC`).all();
+}
+function deleteModelPricing(db, model) {
+  db.prepare(`DELETE FROM model_pricing WHERE model = ?`).run(model);
+}
+function seedModelPricing(db, defaults) {
+  const existing = db.prepare(`SELECT COUNT(*) as count FROM model_pricing`).get();
+  if (existing.count > 0)
+    return;
+  const now = new Date().toISOString();
+  for (const [model, p] of Object.entries(defaults)) {
+    upsertModelPricing(db, {
+      model,
+      input_per_1m: p.inputPer1M,
+      output_per_1m: p.outputPer1M,
+      cache_read_per_1m: p.cacheReadPer1M,
+      cache_write_per_1m: p.cacheWritePer1M,
+      updated_at: now
+    });
+  }
+}
+var init_database = () => {};
+
+// src/ingest/claude.ts
+import { readdirSync, readFileSync, existsSync as existsSync2, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, basename } from "path";
+function autoDetectProject(cwd, projects) {
+  return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
+}
+function dirNameToPath(dirName) {
+  return dirName.replace(/^-/, "/").replace(/-/g, "/").replace(/\/\//g, "/-");
+}
+function collectJsonlFiles(projectDir) {
+  const files = [];
+  function walk(dir) {
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory())
+          walk(join2(dir, entry.name));
+        else if (entry.name.endsWith(".jsonl"))
+          files.push(join2(dir, entry.name));
+      }
+    } catch {}
+  }
+  walk(projectDir);
+  return files;
+}
+async function ingestClaude(db, verbose = false, _telemetryDir) {
+  if (!existsSync2(PROJECTS_DIR)) {
+    if (verbose)
+      console.log("Claude projects dir not found:", PROJECTS_DIR);
+    return { files: 0, requests: 0, sessions: 0 };
+  }
+  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 projectDirs = readdirSync(PROJECTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const projectDirEntry of projectDirs) {
+    const projectDirPath = join2(PROJECTS_DIR, projectDirEntry.name);
+    const projectPath = dirNameToPath(projectDirEntry.name);
+    const jsonlFiles = collectJsonlFiles(projectDirPath);
+    for (const filePath of jsonlFiles) {
+      const stateKey = filePath.replace(PROJECTS_DIR, "");
+      let fileMtime = "0";
+      try {
+        fileMtime = statSync(filePath).mtimeMs.toString();
+      } catch {
+        continue;
+      }
+      const processed = getIngestState(db, "claude", stateKey);
+      if (processed === fileMtime)
+        continue;
+      let lines;
+      try {
+        lines = readFileSync(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 cacheWriteTokens = usage.cache_creation_input_tokens ?? 0;
+        const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+        const timestamp = entry.timestamp ?? new Date().toISOString();
+        if (inputTokens + outputTokens + cacheWriteTokens === 0)
+          continue;
+        const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens);
+        const reqId = `claude-${sessionId}-${timestamp}`;
+        upsertRequest(db, {
+          id: reqId,
+          agent: "claude",
+          session_id: sessionId,
+          model,
+          input_tokens: inputTokens,
+          output_tokens: outputTokens,
+          cache_read_tokens: cacheReadTokens,
+          cache_create_tokens: cacheWriteTokens,
+          cost_usd: costUsd,
+          duration_ms: 0,
+          timestamp,
+          source_request_id: reqId
+        });
+        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: "claude",
+              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
+            };
+            upsertSession(db, session);
+          }
+          touchedSessions.add(sessionId);
+        }
+        totalRequests++;
+      }
+      setIngestState(db, "claude", stateKey, fileMtime);
+      totalFiles++;
+    }
+  }
+  for (const sessionId of touchedSessions) {
+    rollupSession(db, sessionId);
+  }
+  return { files: totalFiles, requests: totalRequests, sessions: touchedSessions.size };
+}
+var PROJECTS_DIR;
+var init_claude = __esm(() => {
+  init_database();
+  init_pricing();
+  PROJECTS_DIR = join2(homedir2(), ".claude", "projects");
+});
+
+// src/ingest/codex.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3, basename as basename2 } from "path";
+import { Database as Database2 } from "bun:sqlite";
+async function ingestCodex(db, verbose = false) {
+  if (!existsSync3(CODEX_DB_PATH)) {
+    if (verbose)
+      console.log("Codex DB not found:", CODEX_DB_PATH);
+    return { sessions: 0 };
+  }
+  let codexDb = null;
+  let ingested = 0;
+  try {
+    codexDb = new Database2(CODEX_DB_PATH, { readonly: true });
+    const threads = codexDb.prepare(`SELECT id, cwd, created_at, updated_at, tokens_used, title FROM threads WHERE tokens_used > 0`).all();
+    for (const thread of threads) {
+      const stateKey = thread.id;
+      const processed = getIngestState(db, "codex", stateKey);
+      if (processed === "done")
+        continue;
+      const costUsd = 0;
+      const projectPath = thread.cwd ?? "";
+      const projectName = projectPath ? basename2(projectPath) : "unknown";
+      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, {
+        id: `codex-${thread.id}`,
+        agent: "codex",
+        project_path: projectPath,
+        project_name: projectName,
+        started_at: startedAt,
+        ended_at: endedAt,
+        total_cost_usd: costUsd,
+        total_tokens: thread.tokens_used,
+        request_count: 1
+      });
+      setIngestState(db, "codex", stateKey, "done");
+      ingested++;
+      if (verbose)
+        console.log(`Codex session ${thread.id}: ${thread.tokens_used} tokens \u2192 $${costUsd.toFixed(4)}`);
+    }
+  } finally {
+    codexDb?.close();
+  }
+  return { sessions: ingested };
+}
+var CODEX_DB_PATH, CODEX_CONFIG_PATH;
+var init_codex = __esm(() => {
+  init_database();
+  CODEX_DB_PATH = join3(homedir3(), ".codex", "state_5.sqlite");
+  CODEX_CONFIG_PATH = join3(homedir3(), ".codex", "config.toml");
+});
+
+// src/lib/config.ts
+var exports_config = {};
+__export(exports_config, {
+  setConfigValue: () => setConfigValue,
+  saveConfig: () => saveConfig,
+  loadConfig: () => loadConfig,
+  getConfigValue: () => getConfigValue
+});
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+function loadConfig() {
+  try {
+    if (existsSync5(CONFIG_PATH)) {
+      const raw = readFileSync4(CONFIG_PATH, "utf-8");
+      return { ...DEFAULTS, ...JSON.parse(raw) };
+    }
+  } catch {}
+  return { ...DEFAULTS };
+}
+function saveConfig(config) {
+  const dir = CONFIG_PATH.substring(0, CONFIG_PATH.lastIndexOf("/"));
+  if (!existsSync5(dir))
+    mkdirSync2(dir, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+}
+function getConfigValue(key) {
+  const config = loadConfig();
+  return config[key] ?? null;
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  let parsed = value;
+  if (value === "true")
+    parsed = true;
+  else if (value === "false")
+    parsed = false;
+  else if (value === "null")
+    parsed = null;
+  else if (!isNaN(Number(value)))
+    parsed = Number(value);
+  else if (value.startsWith("[")) {
+    try {
+      parsed = JSON.parse(value);
+    } catch {}
+  }
+  config[key] = parsed;
+  saveConfig(config);
+}
+var CONFIG_PATH, DEFAULTS;
+var init_config = __esm(() => {
+  CONFIG_PATH = join5(homedir5(), ".economy", "config.json");
+  DEFAULTS = {
+    port: 3456,
+    "default-period": "today",
+    "auto-sync": true,
+    "sync-interval": 30,
+    "alert-thresholds": [5, 10, 25, 50, 100],
+    "webhook-url": null
+  };
+});
+
+// src/lib/webhooks.ts
+var exports_webhooks = {};
+__export(exports_webhooks, {
+  checkAndFireWebhooks: () => checkAndFireWebhooks
+});
+async function checkAndFireWebhooks(db) {
+  const config = loadConfig();
+  const url = config["webhook-url"];
+  if (!url)
+    return;
+  const statuses = getBudgetStatuses(db);
+  for (const b of statuses) {
+    if (!b.is_over_alert)
+      continue;
+    const key = `webhook-budget-${b.id}-${b.period}`;
+    const lastFired = getIngestState(db, "webhook", key);
+    const pctBucket = Math.floor(b.percent_used / 10) * 10;
+    if (lastFired === String(pctBucket))
+      continue;
+    await fireWebhook(url, {
+      event: "budget_alert",
+      budget_id: b.id,
+      project: b.project_path ?? "global",
+      period: b.period,
+      spend: b.current_spend_usd,
+      limit: b.limit_usd,
+      percent: Math.round(b.percent_used * 10) / 10
+    });
+    setIngestState(db, "webhook", key, String(pctBucket));
+  }
+}
+async function fireWebhook(url, payload) {
+  try {
+    await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(5000)
+    });
+  } catch {}
+}
+var init_webhooks = __esm(() => {
+  init_config();
+  init_database();
+});
+
+// src/cli/commands/watch.ts
+var exports_watch = {};
+__export(exports_watch, {
+  watchCosts: () => watchCosts
+});
+import chalk from "chalk";
+function fmt(usd) {
+  return chalk.green(`$${usd.toFixed(4)}`);
+}
+function notify(title, body) {
+  try {
+    const { execSync } = __require("child_process");
+    execSync(`osascript -e 'display notification "${body.replace(/'/g, "")}" with title "${title.replace(/'/g, "")}"'`, { stdio: "ignore" });
+  } catch {}
+}
+function renderHeader(todayUsd, weekUsd) {
+  process.stdout.write("\x1B[H\x1B[2J");
+  console.log(chalk.bold.cyan("  economy watch") + chalk.dim(" \u2014 live cost stream"));
+  console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(`  Today:  ${fmt(todayUsd)}   Week: ${fmt(weekUsd)}`);
+  console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk.dim("  [agent]  cost     model                  tokens   project"));
+  console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+}
+async function watchCosts(opts) {
+  const db = openDatabase();
+  let lastCheck = new Date(Date.now() - opts.interval * 1000).toISOString();
+  const lines = [];
+  const MAX_LINES = 20;
+  let sessionCumulativeCost = 0;
+  let notifyThresholdFired = 0;
+  const initialSummaryToday = querySummary(db, "today");
+  const initialSummaryWeek = querySummary(db, "week");
+  renderHeader(initialSummaryToday.total_usd, initialSummaryWeek.total_usd);
+  console.log(chalk.dim(`
+  Polling every ${opts.interval}s \u2014 Ctrl+C to exit
+`));
+  async function poll() {
+    const now = new Date().toISOString();
+    await ingestClaude(db);
+    await ingestCodex(db);
+    const newRequests = queryRequestsSince(db, lastCheck);
+    lastCheck = now;
+    for (const req of newRequests) {
+      if (opts.agent && req.agent !== opts.agent)
+        continue;
+      const agentLabel = req.agent === "claude" ? chalk.blue("[claude]") : chalk.yellow("[codex] ");
+      const tokens = req.input_tokens + req.output_tokens;
+      const tokStr = tokens >= 1000 ? `${(tokens / 1000).toFixed(1)}k` : String(tokens);
+      const line = `  ${agentLabel}  ${fmt(req.cost_usd).padEnd(14)}${req.model.substring(0, 24).padEnd(26)}${tokStr.padEnd(10)}${req.session_id.substring(0, 12)}`;
+      lines.push(line);
+      if (lines.length > MAX_LINES)
+        lines.shift();
+      if (req.cost_usd > 1) {
+        notify("economy: high cost", `$${req.cost_usd.toFixed(2)} on ${req.model}`);
+      }
+      if (opts.notify && opts.notify > 0) {
+        sessionCumulativeCost += req.cost_usd;
+        const crossedThresholds = Math.floor(sessionCumulativeCost / opts.notify);
+        if (crossedThresholds > notifyThresholdFired) {
+          notifyThresholdFired = crossedThresholds;
+          const { execSync } = __require("child_process");
+          try {
+            execSync(`osascript -e 'display notification "Economy: $${sessionCumulativeCost.toFixed(2)} spent this session" with title "Cost Alert"'`);
+          } catch {}
+        }
+      }
+    }
+    const today = querySummary(db, "today");
+    const week = querySummary(db, "week");
+    renderHeader(today.total_usd, week.total_usd);
+    for (const line of lines)
+      console.log(line);
+    if (lines.length === 0)
+      console.log(chalk.dim("  Waiting for new requests..."));
+    console.log(chalk.dim(`
+  Last updated: ${new Date().toLocaleTimeString()} \u2014 polling every ${opts.interval}s \u2014 Ctrl+C to exit`));
+  }
+  await poll();
+  const timer = setInterval(poll, opts.interval * 1000);
+  process.on("SIGINT", () => {
+    clearInterval(timer);
+    console.log(chalk.dim(`
+
+  Stopped watching.`));
+    process.exit(0);
+  });
+  await new Promise(() => {});
+}
+var init_watch = __esm(() => {
+  init_database();
+  init_claude();
+  init_codex();
+});
+
+// src/server/serve.ts
+var exports_serve = {};
+__export(exports_serve, {
+  startServer: () => startServer,
+  createHandler: () => createHandler
+});
+import { randomUUID } from "crypto";
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...CORS }
+  });
+}
+function ok(data, meta) {
+  return json({ data, meta: meta ?? {} });
+}
+function err(message, status = 400) {
+  return json({ error: message }, status);
+}
+function applyFields(obj, fields) {
+  if (!fields || fields.length === 0)
+    return obj;
+  return Object.fromEntries(fields.map((f) => [f, obj[f] ?? null]));
+}
+function createHandler(db) {
+  return async function handler(req) {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const method = req.method;
+    if (method === "OPTIONS")
+      return new Response(null, { status: 204, headers: CORS });
+    if (path === "/health")
+      return ok({ status: "ok", ts: new Date().toISOString() });
+    if (path === "/api/summary" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "today";
+      return ok(querySummary(db, period));
+    }
+    if (path === "/api/daily" && method === "GET") {
+      const days = Number(url.searchParams.get("days") ?? 30);
+      return ok(queryDailyBreakdown(db, days));
+    }
+    if (path === "/api/sessions" && method === "GET") {
+      const agent = url.searchParams.get("agent");
+      const project = url.searchParams.get("project") ?? undefined;
+      const limit = Number(url.searchParams.get("limit") ?? 50);
+      const offset = Number(url.searchParams.get("offset") ?? 0);
+      const since = url.searchParams.get("since") ?? undefined;
+      const fieldsParam = url.searchParams.get("fields");
+      const fields = fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
+      const sessions = querySessions(db, { agent: agent ?? undefined, project, limit, offset, since });
+      return ok(fields ? sessions.map((s) => applyFields(s, fields)) : sessions, { limit, offset });
+    }
+    if (path === "/api/top" && method === "GET") {
+      const n = Number(url.searchParams.get("n") ?? 10);
+      const agent = url.searchParams.get("agent") ?? undefined;
+      return ok(queryTopSessions(db, n, agent));
+    }
+    if (path === "/api/models" && method === "GET") {
+      return ok(queryModelBreakdown(db));
+    }
+    if (path === "/api/projects" && method === "GET") {
+      return ok(queryProjectBreakdown(db));
+    }
+    if (path === "/api/breakdown" && method === "GET") {
+      const by = url.searchParams.get("by") ?? "model";
+      return ok(by === "project" ? queryProjectBreakdown(db) : queryModelBreakdown(db));
+    }
+    if (path === "/api/budgets" && method === "GET") {
+      return ok(getBudgetStatuses(db));
+    }
+    if (path === "/api/budgets" && method === "POST") {
+      const body = await req.json();
+      const now = new Date().toISOString();
+      upsertBudget(db, {
+        id: randomUUID(),
+        project_path: body["project_path"] ?? null,
+        agent: body["agent"] ?? null,
+        period: body["period"] ?? "monthly",
+        limit_usd: Number(body["limit_usd"]),
+        alert_at_percent: Number(body["alert_at_percent"] ?? 80),
+        created_at: now,
+        updated_at: now
+      });
+      return ok({ ok: true });
+    }
+    const budgetMatch = path.match(/^\/api\/budgets\/(.+)$/);
+    if (budgetMatch && method === "DELETE") {
+      deleteBudget(db, budgetMatch[1]);
+      return ok({ ok: true });
+    }
+    if (path === "/api/project-registry" && method === "GET") {
+      return ok(listProjects(db));
+    }
+    if (path === "/api/project-registry" && method === "POST") {
+      const body = await req.json();
+      const { basename: basename3 } = await import("path");
+      const projPath = body["path"];
+      upsertProject(db, {
+        id: randomUUID(),
+        path: projPath,
+        name: body["name"] ?? basename3(projPath),
+        description: body["description"] ?? null,
+        tags: body["tags"] ?? [],
+        created_at: new Date().toISOString()
+      });
+      return ok({ ok: true });
+    }
+    const projMatch = path.match(/^\/api\/project-registry\/(.+)$/);
+    if (projMatch && method === "DELETE") {
+      deleteProject(db, decodeURIComponent(projMatch[1]));
+      return ok({ ok: true });
+    }
+    if (path === "/api/pricing" && method === "GET") {
+      return ok(listModelPricing(db));
+    }
+    if (path === "/api/pricing" && method === "POST") {
+      const body = await req.json();
+      upsertModelPricing(db, {
+        model: body["model"],
+        input_per_1m: Number(body["input_per_1m"]),
+        output_per_1m: Number(body["output_per_1m"]),
+        cache_read_per_1m: Number(body["cache_read_per_1m"] ?? 0),
+        cache_write_per_1m: Number(body["cache_write_per_1m"] ?? 0),
+        updated_at: new Date().toISOString()
+      });
+      return ok({ ok: true });
+    }
+    const pricingMatch = path.match(/^\/api\/pricing\/(.+)$/);
+    if (pricingMatch && method === "DELETE") {
+      deleteModelPricing(db, decodeURIComponent(pricingMatch[1]));
+      return ok({ ok: true });
+    }
+    if (path === "/api/sync" && method === "POST") {
+      const body = await req.json().catch(() => ({}));
+      const sources = body["sources"] ?? "all";
+      const results = {};
+      if (sources === "all" || sources === "claude")
+        results["claude"] = await ingestClaude(db);
+      if (sources === "all" || sources === "codex")
+        results["codex"] = await ingestCodex(db);
+      return ok(results);
+    }
+    const sessionRequestsMatch = path.match(/^\/api\/sessions\/([^/]+)\/requests$/);
+    if (sessionRequestsMatch && method === "GET") {
+      const sessionId = sessionRequestsMatch[1];
+      const session = db.prepare(`SELECT * FROM sessions WHERE id = ? OR id LIKE ?`).get(sessionId, `${sessionId}%`);
+      if (!session)
+        return err("Session not found", 404);
+      const requests = db.prepare(`SELECT * FROM requests WHERE session_id = ? ORDER BY timestamp ASC`).all(session["id"]);
+      return ok(requests, { session_id: session["id"], count: requests.length });
+    }
+    if (path === "/api/goals" && method === "GET") {
+      return ok(getGoalStatuses(db));
+    }
+    if (path === "/api/goals" && method === "POST") {
+      const body = await req.json();
+      const now = new Date().toISOString();
+      upsertGoal(db, {
+        id: randomUUID(),
+        period: body["period"] ?? "month",
+        project_path: body["project_path"] ?? null,
+        agent: body["agent"] ?? null,
+        limit_usd: Number(body["limit_usd"]),
+        created_at: now,
+        updated_at: now
+      });
+      return ok({ ok: true });
+    }
+    const goalMatch = path.match(/^\/api\/goals\/(.+)$/);
+    if (goalMatch && method === "DELETE") {
+      deleteGoal(db, goalMatch[1]);
+      return ok({ ok: true });
+    }
+    return err("Not found", 404);
+  };
+}
+function startServer(port = 3456) {
+  const db = openDatabase();
+  ensurePricingSeeded(db);
+  const apiHandler = createHandler(db);
+  const dashboardDir = new URL("../../dashboard/dist", import.meta.url).pathname;
+  Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname.startsWith("/api") || url.pathname === "/health") {
+        return apiHandler(req);
+      }
+      try {
+        const { existsSync: existsSync6 } = await import("fs");
+        if (existsSync6(dashboardDir)) {
+          let filePath = url.pathname === "/" ? "/index.html" : url.pathname;
+          const fullPath = dashboardDir + filePath;
+          if (existsSync6(fullPath)) {
+            return new Response(Bun.file(fullPath));
+          }
+          const indexPath = dashboardDir + "/index.html";
+          if (existsSync6(indexPath)) {
+            return new Response(Bun.file(indexPath));
+          }
+        }
+      } catch {}
+      return apiHandler(req);
+    }
+  });
+  console.log(`economy-serve listening on http://localhost:${port}`);
+}
+var CORS;
+var init_serve = __esm(() => {
+  init_database();
+  init_claude();
+  init_codex();
+  init_pricing();
+  CORS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type"
+  };
+});
+
+// src/cli/commands/menubar.ts
+var exports_menubar = {};
+__export(exports_menubar, {
+  menubarUninstall: () => menubarUninstall,
+  menubarStop: () => menubarStop,
+  menubarStart: () => menubarStart,
+  menubarInstall: () => menubarInstall
+});
+import chalk2 from "chalk";
+import { execSync } from "child_process";
+import { existsSync as existsSync6, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir, arch } from "os";
+import { join as join6 } from "path";
+function getArch() {
+  return arch() === "arm64" ? "arm64" : "x86_64";
+}
+function isInstalled() {
+  return existsSync6(APP_PATH);
+}
+function isRunning() {
+  try {
+    const result = execSync(`pgrep -x EconomyBar`, { stdio: "pipe" }).toString().trim();
+    return result.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function menubarInstall(opts) {
+  if (isInstalled() && !opts.force) {
+    console.log(chalk2.yellow("Economy Bar is already installed. Use --force to reinstall."));
+    console.log(chalk2.dim(`  Location: ${APP_PATH}`));
+    return;
+  }
+  const cpuArch = getArch();
+  console.log(chalk2.cyan(`\u2192 Detecting architecture: ${cpuArch}`));
+  console.log(chalk2.cyan("\u2192 Fetching latest release info..."));
+  let assetUrl;
+  try {
+    const res = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`, {
+      headers: { Accept: "application/vnd.github+json", "User-Agent": "economy-cli" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok)
+      throw new Error(`GitHub API error: ${res.status}`);
+    const release = await res.json();
+    const assetName = `economy-bar-${cpuArch}.zip`;
+    const asset = release.assets.find((a) => a.name === assetName);
+    if (!asset)
+      throw new Error(`No asset found for ${assetName}. Check releases at https://github.com/${REPO}/releases`);
+    assetUrl = asset.browser_download_url;
+  } catch (e) {
+    console.error(chalk2.red(`\u2717 Failed to fetch release info: ${e instanceof Error ? e.message : String(e)}`));
+    process.exit(1);
+  }
+  const zipPath = join6(tmpdir(), `economy-bar-${cpuArch}.zip`);
+  const extractDir = join6(tmpdir(), "economy-bar-extracted");
+  console.log(chalk2.cyan(`\u2192 Downloading ${assetUrl}...`));
+  try {
+    const res = await fetch(assetUrl, { signal: AbortSignal.timeout(60000) });
+    if (!res.ok)
+      throw new Error(`Download failed: ${res.status}`);
+    const buffer = await res.arrayBuffer();
+    writeFileSync2(zipPath, Buffer.from(buffer));
+    console.log(chalk2.green(`\u2713 Downloaded (${(buffer.byteLength / 1024 / 1024).toFixed(1)} MB)`));
+  } catch (e) {
+    console.error(chalk2.red(`\u2717 Download failed: ${e instanceof Error ? e.message : String(e)}`));
+    process.exit(1);
+  }
+  console.log(chalk2.cyan("\u2192 Installing to /Applications..."));
+  try {
+    execSync(`rm -rf "${extractDir}" && mkdir -p "${extractDir}"`, { stdio: "ignore" });
+    execSync(`unzip -q "${zipPath}" -d "${extractDir}"`, { stdio: "ignore" });
+    if (isInstalled())
+      execSync(`rm -rf "${APP_PATH}"`, { stdio: "ignore" });
+    execSync(`cp -R "${extractDir}/Economy Bar.app" /Applications/`, { stdio: "ignore" });
+    execSync(`xattr -rd com.apple.quarantine "${APP_PATH}" 2>/dev/null || true`, { stdio: "ignore" });
+    execSync(`rm -rf "${zipPath}" "${extractDir}"`, { stdio: "ignore" });
+    console.log(chalk2.green(`\u2713 Installed to ${APP_PATH}`));
+  } catch (e) {
+    console.error(chalk2.red(`\u2717 Install failed: ${e instanceof Error ? e.message : String(e)}`));
+    process.exit(1);
+  }
+  console.log(chalk2.cyan("\u2192 Launching Economy Bar..."));
+  try {
+    execSync(`open "${APP_PATH}"`, { stdio: "ignore" });
+    console.log(chalk2.bold.green(`
+\u2713 Economy Bar is running in your menu bar!`));
+    console.log(chalk2.dim("  Make sure economy serve is running: economy serve"));
+  } catch (e) {
+    console.log(chalk2.yellow("\u26A0 Installed but could not auto-launch. Open from /Applications manually."));
+  }
+}
+function menubarUninstall() {
+  if (!isInstalled()) {
+    console.log(chalk2.yellow("Economy Bar is not installed."));
+    return;
+  }
+  if (isRunning()) {
+    try {
+      execSync(`osascript -e 'quit app "Economy Bar"'`, { stdio: "ignore" });
+      execSync(`sleep 1`, { stdio: "ignore" });
+    } catch {}
+  }
+  execSync(`rm -rf "${APP_PATH}"`, { stdio: "ignore" });
+  console.log(chalk2.green("\u2713 Economy Bar uninstalled"));
+}
+function menubarStart() {
+  if (!isInstalled()) {
+    console.error(chalk2.red("Economy Bar is not installed. Run: economy menubar install"));
+    process.exit(1);
+  }
+  execSync(`open "${APP_PATH}"`, { stdio: "ignore" });
+  console.log(chalk2.green("\u2713 Economy Bar launched"));
+}
+function menubarStop() {
+  if (!isRunning()) {
+    console.log(chalk2.yellow("Economy Bar is not running."));
+    return;
+  }
+  try {
+    execSync(`osascript -e 'quit app "Economy Bar"'`, { stdio: "ignore" });
+    console.log(chalk2.green("\u2713 Economy Bar stopped"));
+  } catch {
+    console.log(chalk2.yellow("Could not quit Economy Bar gracefully"));
+  }
+}
+var APP_PATH = "/Applications/Economy Bar.app", REPO = "hasna/open-economy";
+var init_menubar = () => {};
+
+// src/cli/index.ts
+init_database();
+init_claude();
+init_codex();
+import { Command } from "commander";
+import chalk3 from "chalk";
+
+// src/ingest/gemini.ts
+init_database();
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+var GEMINI_TMP_DIR = join4(homedir4(), ".gemini", "tmp");
+async function ingestGemini(db, verbose) {
+  if (!existsSync4(GEMINI_TMP_DIR)) {
+    if (verbose)
+      console.log("Gemini tmp dir not found:", GEMINI_TMP_DIR);
+    return { sessions: 0 };
+  }
+  let totalSessions = 0;
+  const touchedSessions = new Set;
+  let projectHashDirs = [];
+  try {
+    projectHashDirs = readdirSync2(GEMINI_TMP_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && /^[0-9a-f]{64}$/.test(d.name)).map((d) => join4(GEMINI_TMP_DIR, d.name));
+  } catch {
+    return { sessions: 0 };
+  }
+  for (const projectDir of projectHashDirs) {
+    const chatsDir = join4(projectDir, "chats");
+    if (!existsSync4(chatsDir))
+      continue;
+    let chatFiles = [];
+    try {
+      chatFiles = readdirSync2(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join4(chatsDir, f));
+    } catch {
+      continue;
+    }
+    for (const filePath of chatFiles) {
+      const stateKey = filePath.replace(homedir4(), "~");
+      let fileMtime = "0";
+      try {
+        fileMtime = statSync2(filePath).mtimeMs.toString();
+      } catch {
+        continue;
+      }
+      const processed = getIngestState(db, "gemini", stateKey);
+      if (processed === fileMtime)
+        continue;
+      let chatData;
+      try {
+        chatData = JSON.parse(readFileSync3(filePath, "utf-8"));
+      } catch {
+        continue;
+      }
+      const sessionId = chatData.sessionId;
+      if (!sessionId)
+        continue;
+      const startTime = chatData.startTime ?? new Date().toISOString();
+      const existing = db.prepare(`SELECT id FROM sessions WHERE id = ?`).get(sessionId);
+      if (!existing) {
+        const session = {
+          id: sessionId,
+          agent: "gemini",
+          project_path: "",
+          project_name: "",
+          started_at: startTime,
+          ended_at: chatData.lastUpdated ?? null,
+          total_cost_usd: 0,
+          total_tokens: 0,
+          request_count: 0
+        };
+        upsertSession(db, session);
+        touchedSessions.add(sessionId);
+        totalSessions++;
+      }
+      setIngestState(db, "gemini", stateKey, fileMtime);
+    }
+  }
+  for (const sessionId of touchedSessions) {
+    rollupSession(db, sessionId);
+  }
+  return { sessions: totalSessions };
+}
+
+// src/cli/index.ts
+init_pricing();
+import { randomUUID as randomUUID2 } from "crypto";
+import { execSync as execSync2 } from "child_process";
+var program = new Command;
+program.name("economy").description("AI coding cost tracker \u2014 Claude Code, Codex, and Gemini").version("0.2.2");
+async function autoSync() {
+  const db = openDatabase();
+  ensurePricingSeeded(db);
+  await ingestClaude(db);
+  await ingestCodex(db);
+  await ingestGemini(db);
+}
+function sparkline(values) {
+  const chars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  if (values.length === 0)
+    return "";
+  const max = Math.max(...values);
+  if (max === 0)
+    return chars[0].repeat(values.length);
+  return values.map((v) => chars[Math.min(Math.round(v / max * 7), 7)]).join("");
+}
+function fmt2(usd) {
+  let formatted;
+  if (usd >= 0.01) {
+    formatted = "$" + usd.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+  } else if (usd >= 0.0001) {
+    const cents = usd * 100;
+    formatted = cents.toFixed(2).replace(/\.?0+$/, "") + "\xA2";
+  } else if (usd > 0) {
+    formatted = "<0.01\xA2";
+  } else {
+    formatted = "$0.00";
+  }
+  return chalk3.green(formatted);
+}
+function fmtTokens(n) {
+  if (n >= 1e9)
+    return `${(n / 1e9).toFixed(1)}B`;
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)}k`;
+  return n.toLocaleString("en-US");
+}
+function fmtCount(n) {
+  return n.toLocaleString("en-US");
+}
+function printTable(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").replace(/\x1b\[[0-9;]*m/g, "").length)));
+  const sep = widths.map((w) => "\u2500".repeat(w + 2)).join("\u253C");
+  const header = headers.map((h, i) => ` ${h.padEnd(widths[i] ?? 0)} `).join("\u2502");
+  console.log(`\u250C${sep.replace(/\u253C/g, "\u252C")}\u2510`);
+  console.log(`\u2502${header}\u2502`);
+  console.log(`\u251C${sep}\u2524`);
+  for (const row of rows) {
+    const line = row.map((cell, i) => {
+      const plain = cell.replace(/\x1b\[[0-9;]*m/g, "");
+      return ` ${cell}${" ".repeat(Math.max(0, (widths[i] ?? 0) - plain.length))} `;
+    }).join("\u2502");
+    console.log(`\u2502${line}\u2502`);
+  }
+  console.log(`\u2514${sep.replace(/\u253C/g, "\u2534")}\u2518`);
+}
+function parseSinceDate(since) {
+  const relMatch = since.match(/^(\d+)d$/);
+  if (relMatch) {
+    const days = parseInt(relMatch[1], 10);
+    const d = new Date;
+    d.setDate(d.getDate() - days);
+    return d.toISOString().substring(0, 10);
+  }
+  return since;
+}
+function printSummary(label, period) {
+  const db = openDatabase();
+  ensurePricingSeeded(db);
+  const s = querySummary(db, period);
+  console.log();
+  console.log(chalk3.bold.cyan(`  ${label}`));
+  console.log();
+  printTable(["Metric", "Value"], [
+    ["Total cost", fmt2(s.total_usd)],
+    ["Sessions", chalk3.yellow(fmtCount(s.sessions))],
+    ["Requests", chalk3.yellow(fmtCount(s.requests))],
+    ["Tokens", chalk3.yellow(fmtTokens(s.tokens))]
+  ]);
+  console.log();
+}
+program.action(async () => {
+  await autoSync();
+  const db = openDatabase();
+  const t = querySummary(db, "today");
+  const w = querySummary(db, "week");
+  const m = querySummary(db, "month");
+  const projects = queryProjectBreakdown(db).slice(0, 3);
+  const daily = queryDailyBreakdown(db, 14).reduce((acc, d) => {
+    acc[d.date] = (acc[d.date] ?? 0) + d.cost_usd;
+    return acc;
+  }, {});
+  const dailyValues = Object.values(daily);
+  console.log();
+  console.log(chalk3.bold.cyan("  Economy"));
+  console.log();
+  printTable(["Period", "Cost", "Sessions", "Requests", "Tokens"], [
+    ["Today", fmt2(t.total_usd), fmtCount(t.sessions), fmtCount(t.requests), fmtTokens(t.tokens)],
+    ["This Week", fmt2(w.total_usd), fmtCount(w.sessions), fmtCount(w.requests), fmtTokens(w.tokens)],
+    ["This Month", fmt2(m.total_usd), fmtCount(m.sessions), fmtCount(m.requests), fmtTokens(m.tokens)]
+  ]);
+  if (dailyValues.length > 0) {
+    console.log(`
+  ${chalk3.dim("14-day trend:")} ${sparkline(dailyValues)}`);
+  }
+  if (projects.length > 0) {
+    console.log(`
+  ${chalk3.dim("Top projects:")}`);
+    for (const p of projects) {
+      console.log(`    ${chalk3.white(p.project_name.padEnd(25))} ${fmt2(p.cost_usd)}`);
+    }
+  }
+  console.log();
+});
+program.command("sync").description("Ingest cost data from Claude Code, Codex, and Gemini").option("--claude", "Only ingest Claude Code telemetry").option("--codex", "Only ingest Codex sessions").option("--gemini", "Only ingest Gemini CLI sessions").option("-v, --verbose", "Verbose output").option("--force", "Force re-process all files (ignore mtime cache)").action(async (opts) => {
+  const db = openDatabase();
+  ensurePricingSeeded(db);
+  if (opts.force) {
+    db.exec(`DELETE FROM ingest_state WHERE source = 'claude'`);
+    if (opts.verbose)
+      console.log(chalk3.dim("Cleared ingest cache"));
+  }
+  const anySpecific = opts.claude || opts.codex || opts.gemini;
+  const doClaude = opts.claude || !anySpecific;
+  const doCodex = opts.codex || !anySpecific;
+  const doGemini = opts.gemini || !anySpecific;
+  if (doClaude) {
+    process.stdout.write(chalk3.cyan("\u2192 Ingesting Claude Code telemetry... "));
+    const r = await ingestClaude(db, opts.verbose);
+    console.log(chalk3.green(`\u2713 ${r.files} files, ${r.requests} requests, ${r.sessions} sessions`));
+  }
+  if (doCodex) {
+    process.stdout.write(chalk3.cyan("\u2192 Ingesting Codex sessions... "));
+    const r = await ingestCodex(db, opts.verbose);
+    console.log(chalk3.green(`\u2713 ${r.sessions} sessions`));
+  }
+  if (doGemini) {
+    process.stdout.write(chalk3.cyan("\u2192 Ingesting Gemini CLI sessions... "));
+    const r = await ingestGemini(db, opts.verbose);
+    console.log(chalk3.green(`\u2713 ${r.sessions} sessions`));
+  }
+  try {
+    const { checkAndFireWebhooks: checkAndFireWebhooks2 } = await Promise.resolve().then(() => (init_webhooks(), exports_webhooks));
+    await checkAndFireWebhooks2(db);
+  } catch {}
+  console.log(chalk3.bold.green(`
+\u2713 Sync complete`));
+});
+program.command("today").description("Cost summary for today").action(async () => {
+  await autoSync();
+  printSummary("Today", "today");
+});
+program.command("week").description("Cost summary for this week").action(async () => {
+  await autoSync();
+  printSummary("This Week", "week");
+});
+program.command("month").description("Cost summary for this month").action(async () => {
+  await autoSync();
+  printSummary("This Month", "month");
+});
+program.command("sessions").description("List coding sessions with costs").option("--agent <agent>", "Filter by agent (claude|codex)").option("--project <path>", "Filter by project path").option("--limit <n>", "Number of sessions", "20").option("--format <fmt>", "Output format: table|compact|csv|json", "table").option("--since <date>", "Filter sessions since date or relative (e.g. 2026-03-01, 7d, 30d)").option("--search <query>", "Search by project name, session id prefix, or agent").action(async (opts) => {
+  await autoSync();
+  const db = openDatabase();
+  const sinceDate = opts.since ? parseSinceDate(opts.since) : undefined;
+  let sessions = querySessions(db, {
+    agent: opts.agent,
+    project: opts.project,
+    limit: Number(opts.limit ?? 20),
+    since: sinceDate,
+    search: opts.search
+  });
+  if (sessions.length === 0) {
+    console.log(chalk3.yellow("No sessions found."));
+    return;
+  }
+  const f = opts.format ?? "table";
+  if (f === "compact") {
+    for (const s of sessions)
+      process.stdout.write(`${s.id.slice(0, 8)} ${s.agent} ${fmt2(s.total_cost_usd)} ${fmtTokens(s.total_tokens)} ${s.project_name || "\u2014"}
+`);
+    return;
+  }
+  if (f === "json") {
+    console.log(JSON.stringify(sessions, null, 2));
+    return;
+  }
+  if (f === "csv") {
+    console.log("id,agent,project_name,total_cost_usd,total_tokens,request_count,started_at");
+    for (const s of sessions)
+      console.log(`${s.id},${s.agent},"${s.project_name}",${s.total_cost_usd},${s.total_tokens},${s.request_count},${s.started_at}`);
+    return;
+  }
+  console.log();
+  printTable(["Session ID", "Agent", "Project", "Cost", "Tokens", "Requests", "Started"], sessions.map((s) => [
+    chalk3.dim(s.id.substring(0, 12)),
+    s.agent === "claude" ? chalk3.blue("claude") : chalk3.yellow("codex"),
+    chalk3.white(s.project_name || chalk3.dim("unknown")),
+    fmt2(s.total_cost_usd),
+    chalk3.cyan(fmtTokens(s.total_tokens)),
+    fmtCount(s.request_count),
+    chalk3.dim(s.started_at.substring(0, 16))
+  ]));
+  console.log();
+});
+program.command("top").description("Most expensive sessions").option("-n <n>", "Number of sessions", "10").option("--agent <agent>", "Filter by agent").option("--since <date>", "Filter sessions since date or relative (e.g. 2026-03-01, 7d, 30d)").action((opts) => {
+  const db = openDatabase();
+  const sinceDate = opts.since ? parseSinceDate(opts.since) : undefined;
+  let sessions = queryTopSessions(db, Number(opts.n ?? 10), opts.agent);
+  if (sinceDate)
+    sessions = sessions.filter((s) => s.started_at >= sinceDate);
+  if (sessions.length === 0) {
+    console.log(chalk3.yellow("No sessions found. Run `economy sync` first."));
+    return;
+  }
+  console.log();
+  printTable(["#", "Project", "Agent", "Cost", "Tokens", "Started"], sessions.map((s, i) => [
+    chalk3.dim(String(i + 1)),
+    chalk3.white(s.project_name || chalk3.dim("unknown")),
+    s.agent === "claude" ? chalk3.blue("claude") : chalk3.yellow("codex"),
+    fmt2(s.total_cost_usd),
+    chalk3.cyan(fmtTokens(s.total_tokens)),
+    chalk3.dim(s.started_at.substring(0, 16))
+  ]));
+  console.log();
+});
+program.command("breakdown").description("Cost breakdown by model, agent, or project").option("--by <dimension>", "Dimension: model|agent|project", "model").option("--since <date>", "Filter since date or relative (e.g. 2026-03-01, 7d, 30d)").action((opts) => {
+  const db = openDatabase();
+  const sinceDate = opts.since ? parseSinceDate(opts.since) : undefined;
+  console.log();
+  if (opts.by === "project") {
+    const rows = sinceDate ? 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(sinceDate) : queryProjectBreakdown(db);
+    printTable(["Project", "Sessions", "Requests", "Tokens", "Cost"], rows.map((r) => [
+      chalk3.white(r.project_name || chalk3.dim("unknown")),
+      String(r.sessions),
+      String(r.requests),
+      chalk3.cyan(fmtTokens(r.total_tokens)),
+      fmt2(r.cost_usd)
+    ]));
+  } else {
+    const rows = sinceDate ? 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(sinceDate) : queryModelBreakdown(db);
+    printTable(["Model", "Agent", "Requests", "Tokens", "Cost"], rows.map((r) => [
+      chalk3.white(r.model),
+      r.agent === "claude" ? chalk3.blue("claude") : chalk3.yellow("codex"),
+      String(r.requests),
+      chalk3.cyan(fmtTokens(r.total_tokens)),
+      fmt2(r.cost_usd)
+    ]));
+  }
+  console.log();
+});
+program.command("watch").description("Live stream of incoming costs").option("--interval <seconds>", "Poll interval in seconds", "10").option("--agent <agent>", "Filter by agent").option("--notify <amount>", "Fire macOS notification when cumulative cost crosses this USD threshold").action(async (opts) => {
+  const { watchCosts: watchCosts2 } = await Promise.resolve().then(() => (init_watch(), exports_watch));
+  await watchCosts2({ interval: Number(opts.interval ?? 10), agent: opts.agent, notify: opts.notify ? Number(opts.notify) : undefined });
+});
+var budgetCmd = program.command("budget").description("Manage spending budgets");
+budgetCmd.command("set").description("Set a budget").option("--project <path>", "Project path (omit for global)").option("--period <period>", "Period: daily|weekly|monthly", "monthly").option("--limit <usd>", "Budget limit in USD").option("--alert <percent>", "Alert threshold %", "80").option("--agent <agent>", "Limit to agent (claude|codex)").action((opts) => {
+  if (!opts.limit) {
+    console.error(chalk3.red("--limit is required"));
+    process.exit(1);
+  }
+  const db = openDatabase();
+  const now = new Date().toISOString();
+  upsertBudget(db, {
+    id: randomUUID2(),
+    project_path: opts.project ?? null,
+    agent: opts.agent ?? null,
+    period: opts.period ?? "monthly",
+    limit_usd: Number(opts.limit),
+    alert_at_percent: Number(opts.alert ?? 80),
+    created_at: now,
+    updated_at: now
+  });
+  console.log(chalk3.green(`\u2713 Budget set: ${opts.project ?? "global"} \u2014 ${opts.period} $${opts.limit}`));
+});
+budgetCmd.command("list").description("List all budgets").action(() => {
+  const db = openDatabase();
+  const statuses = getBudgetStatuses(db);
+  if (statuses.length === 0) {
+    console.log(chalk3.yellow("No budgets set."));
+    return;
+  }
+  console.log();
+  printTable(["Scope", "Period", "Limit", "Spent", "Used%", "Status"], statuses.map((b) => {
+    const pct = b.percent_used.toFixed(1);
+    const status = b.is_over_limit ? chalk3.red("OVER") : b.is_over_alert ? chalk3.yellow("ALERT") : chalk3.green("OK");
+    const pctColor = b.is_over_limit ? chalk3.red(pct + "%") : b.is_over_alert ? chalk3.yellow(pct + "%") : chalk3.green(pct + "%");
+    return [
+      chalk3.white(b.project_path ?? "global"),
+      b.period,
+      fmt2(b.limit_usd),
+      fmt2(b.current_spend_usd),
+      pctColor,
+      status
+    ];
+  }));
+  console.log();
+});
+budgetCmd.command("remove <id>").description("Remove a budget by ID").action((id) => {
+  const db = openDatabase();
+  deleteBudget(db, id);
+  console.log(chalk3.green(`\u2713 Budget removed`));
+});
+var projectCmd = program.command("project").description("Manage tracked projects");
+projectCmd.command("add <path>").description("Add a project").option("--name <name>", "Human-readable name").action((path, opts) => {
+  const db = openDatabase();
+  const { basename: basename3 } = __require("path");
+  upsertProject(db, {
+    id: randomUUID2(),
+    path,
+    name: opts.name ?? basename3(path),
+    description: null,
+    tags: [],
+    created_at: new Date().toISOString()
+  });
+  console.log(chalk3.green(`\u2713 Project added: ${path}`));
+});
+projectCmd.command("list").description("List all projects with costs").action(() => {
+  const db = openDatabase();
+  const projects = queryProjectBreakdown(db);
+  if (projects.length === 0) {
+    console.log(chalk3.yellow("No projects tracked yet."));
+    return;
+  }
+  console.log();
+  printTable(["Project", "Path", "Sessions", "Cost", "Last Active"], projects.map((p) => [
+    chalk3.white(p.project_name || chalk3.dim("unknown")),
+    chalk3.dim(p.project_path.substring(0, 40)),
+    String(p.sessions),
+    fmt2(p.cost_usd),
+    chalk3.dim(p.last_active?.substring(0, 16) ?? "\u2014")
+  ]));
+  console.log();
+});
+projectCmd.command("remove <path>").description("Remove a project (keeps historical data)").action((path) => {
+  const db = openDatabase();
+  deleteProject(db, path);
+  console.log(chalk3.green(`\u2713 Project removed`));
+});
+projectCmd.command("rename <path> <name>").description("Rename a project").action((path, name) => {
+  const db = openDatabase();
+  const existing = getProject(db, path);
+  if (!existing) {
+    console.error(chalk3.red("Project not found"));
+    process.exit(1);
+  }
+  upsertProject(db, { ...existing, name });
+  console.log(chalk3.green(`\u2713 Renamed to: ${name}`));
+});
+projectCmd.command("show <nameOrPath>").description("Detailed project breakdown with sparkline").action(async (nameOrPath) => {
+  await autoSync();
+  const db = openDatabase();
+  const sessions = db.prepare(`SELECT * FROM sessions WHERE project_name LIKE ? OR project_path LIKE ? ORDER BY started_at DESC`).all(`%${nameOrPath}%`, `%${nameOrPath}%`);
+  if (sessions.length === 0) {
+    console.log(chalk3.yellow(`No sessions found for: ${nameOrPath}`));
+    return;
+  }
+  const projectName = sessions[0]["project_name"] || nameOrPath;
+  const projectPath = sessions[0]["project_path"] || "";
+  const totalCost = sessions.reduce((s, r) => s + r["total_cost_usd"], 0);
+  const totalTokens = sessions.reduce((s, r) => s + r["total_tokens"], 0);
+  const daily = db.prepare(`
+      SELECT DATE(r.timestamp) as d, SUM(r.cost_usd) as cost
+      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 d ORDER BY d ASC
+    `).all(`%${nameOrPath}%`, `%${nameOrPath}%`);
+  const dailyValues = daily.map((d) => d.cost);
+  const models = db.prepare(`
+      SELECT r.model, COUNT(*) as reqs, SUM(r.cost_usd) as cost
+      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 DESC LIMIT 5
+    `).all(`%${nameOrPath}%`, `%${nameOrPath}%`);
+  console.log();
+  console.log(chalk3.bold.cyan(`  ${projectName}`));
+  console.log(chalk3.dim(`  ${projectPath}`));
+  console.log();
+  printTable(["Metric", "Value"], [
+    ["Total cost", fmt2(totalCost)],
+    ["Sessions", fmtCount(sessions.length)],
+    ["Total tokens", fmtTokens(totalTokens)]
+  ]);
+  if (dailyValues.length > 0) {
+    console.log(`
+  ${chalk3.dim("14-day trend:")} ${sparkline(dailyValues)}`);
+  }
+  if (models.length > 0) {
+    console.log(`
+  ${chalk3.dim("Model breakdown:")}`);
+    for (const m of models) {
+      console.log(`    ${chalk3.white(m.model.padEnd(30))} ${fmt2(m.cost)} (${fmtCount(m.reqs)} reqs)`);
+    }
+  }
+  const topSessions = sessions.sort((a, b) => b["total_cost_usd"] - a["total_cost_usd"]).slice(0, 5);
+  if (topSessions.length > 0) {
+    console.log(`
+  ${chalk3.dim("Top sessions:")}`);
+    for (const s of topSessions) {
+      console.log(`    ${chalk3.dim(s["id"].substring(0, 12))}  ${fmt2(s["total_cost_usd"])}  ${chalk3.dim(String(s["started_at"]).substring(0, 16))}`);
+    }
+  }
+  console.log();
+});
+var configCmd = program.command("config").description("Manage economy configuration");
+configCmd.command("set <key> <value>").description("Set a config value").action(async (_key, _value) => {
+  const { setConfigValue: setConfigValue2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+  setConfigValue2(_key, _value);
+  console.log(chalk3.green(`\u2713 ${_key} = ${_value}`));
+});
+configCmd.command("get <key>").description("Get a config value").action(async (key) => {
+  const { getConfigValue: getConfigValue2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+  console.log(getConfigValue2(key) ?? chalk3.dim("(not set)"));
+});
+configCmd.command("webhook-test").description("Send a test payload to the configured webhook URL").action(async () => {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+  const config = loadConfig2();
+  const url = config["webhook-url"];
+  if (!url) {
+    console.log(chalk3.yellow("No webhook-url configured. Run: economy config set webhook-url <url>"));
+    return;
+  }
+  const payload = {
+    event: "test",
+    message: "Economy webhook test",
+    timestamp: new Date().toISOString()
+  };
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(5000)
+    });
+    const text = await res.text().catch(() => "");
+    if (res.ok) {
+      console.log(chalk3.green(`\u2713 Webhook responded: HTTP ${res.status}`));
+      if (text)
+        console.log(chalk3.dim(text.slice(0, 200)));
+    } else {
+      console.log(chalk3.red(`\u2717 Webhook failed: HTTP ${res.status}`));
+      if (text)
+        console.log(chalk3.dim(text.slice(0, 200)));
+    }
+  } catch (e) {
+    console.log(chalk3.red(`\u2717 Request failed: ${e instanceof Error ? e.message : String(e)}`));
+  }
+});
+configCmd.action(async () => {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+  const config = loadConfig2();
+  console.log();
+  printTable(["Key", "Value"], Object.entries(config).map(([k, v]) => [k, String(v)]));
+  console.log();
+});
+var pricingCmd = program.command("pricing").description("Manage model pricing rates");
+pricingCmd.command("list").description("List all model prices").action(() => {
+  const db = openDatabase();
+  ensurePricingSeeded(db);
+  const rows = listModelPricing(db);
+  console.log();
+  printTable(["Model", "Input/1M", "Output/1M", "CacheR/1M", "CacheW/1M", "Out/1k"], rows.map((r) => [
+    chalk3.white(r.model),
+    fmt2(r.input_per_1m),
+    fmt2(r.output_per_1m),
+    fmt2(r.cache_read_per_1m),
+    fmt2(r.cache_write_per_1m),
+    chalk3.dim(fmt2(r.output_per_1m / 1000))
+  ]));
+  console.log();
+});
+pricingCmd.command("set <model>").description("Set pricing for a model").option("--input <usd>", "Input price per 1M tokens").option("--output <usd>", "Output price per 1M tokens").option("--cache-read <usd>", "Cache read price per 1M tokens", "0").option("--cache-write <usd>", "Cache write price per 1M tokens", "0").action((model, opts) => {
+  if (!opts.input || !opts.output) {
+    console.error(chalk3.red("--input and --output are required"));
+    process.exit(1);
+  }
+  const db = openDatabase();
+  ensurePricingSeeded(db);
+  upsertModelPricing(db, {
+    model,
+    input_per_1m: Number(opts.input),
+    output_per_1m: Number(opts.output),
+    cache_read_per_1m: Number(opts.cacheRead ?? 0),
+    cache_write_per_1m: Number(opts.cacheWrite ?? 0),
+    updated_at: new Date().toISOString()
+  });
+  console.log(chalk3.green(`\u2713 Pricing updated for ${model}`));
+});
+pricingCmd.command("remove <model>").description("Remove pricing for a model").action((model) => {
+  const db = openDatabase();
+  deleteModelPricing(db, model);
+  console.log(chalk3.green(`\u2713 Pricing removed for ${model}`));
+});
+program.command("serve").description("Start the REST API server").option("-p, --port <port>", "Port", "3456").action(async (opts) => {
+  const port = Number(opts.port ?? 3456);
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_serve(), exports_serve));
+  startServer2(port);
+});
+program.command("dashboard").description("Open the web dashboard (auto-starts server if not running)").option("-p, --port <port>", "Server port", "3456").action(async (opts) => {
+  const port = Number(opts.port ?? 3456);
+  const url = `http://localhost:${port}`;
+  let serverRunning = false;
+  try {
+    const res = await fetch(`${url}/health`, { signal: AbortSignal.timeout(500) });
+    serverRunning = res.ok;
+  } catch {}
+  if (!serverRunning) {
+    console.log(chalk3.cyan(`\u2192 Starting economy server on port ${port}...`));
+    const { spawn } = await import("child_process");
+    const { resolve, dirname } = await import("path");
+    const serveScript = resolve(dirname(process.argv[1]), "..", "server", "index.js");
+    const child = spawn(process.execPath, [serveScript], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, ECONOMY_PORT: String(port) }
+    });
+    child.unref();
+    let attempts = 0;
+    while (attempts < 20) {
+      await new Promise((r) => setTimeout(r, 250));
+      try {
+        const res = await fetch(`${url}/health`, { signal: AbortSignal.timeout(300) });
+        if (res.ok) {
+          serverRunning = true;
+          break;
+        }
+      } catch {}
+      attempts++;
+    }
+    if (serverRunning) {
+      console.log(chalk3.green(`\u2713 Server started`));
+    } else {
+      console.log(chalk3.yellow(`\u26A0 Server didn't respond \u2014 open ${url} manually after running \`economy serve\``));
+    }
+  }
+  console.log(chalk3.cyan(`Opening ${url}`));
+  try {
+    execSync2(`open ${url}`);
+  } catch {
+    console.log(chalk3.yellow(`Open your browser at ${url}`));
+  }
+});
+program.command("mcp").description("Show MCP server install commands").option("--claude", "Install into Claude Code").option("--codex", "Install into Codex").option("--all", "Install into all agents").action(async (opts) => {
+  const doAll = opts.all || !opts.claude && !opts.codex;
+  if (opts.claude || doAll) {
+    console.log(chalk3.bold.cyan(`
+Claude Code:`));
+    console.log(chalk3.white("  claude mcp add --transport stdio --scope user economy -- economy-mcp"));
+  }
+  if (opts.codex || doAll) {
+    console.log(chalk3.bold.yellow(`
+Codex (~/.codex/config.toml):`));
+    console.log(chalk3.white(`  [mcp_servers.economy]
+  command = "economy-mcp"
+  args = []`));
+  }
+  console.log();
+});
+program.command("session <id>").description("Show detailed breakdown of a single session").action(async (id) => {
+  await autoSync();
+  const db = openDatabase();
+  const session = db.prepare(`SELECT * FROM sessions WHERE id = ? OR id LIKE ?`).get(id, `%${id}%`);
+  if (!session) {
+    console.log(chalk3.red(`Session not found: ${id}`));
+    process.exit(1);
+  }
+  const requests = db.prepare(`SELECT * FROM requests WHERE session_id = ? ORDER BY timestamp ASC`).all(session["id"]);
+  console.log();
+  console.log(chalk3.bold.cyan(`  Session: ${session["id"].substring(0, 16)}...`));
+  console.log();
+  printTable(["Field", "Value"], [
+    ["Agent", String(session["agent"])],
+    ["Project", String(session["project_name"] || session["project_path"] || "\u2014")],
+    ["Started", String(session["started_at"]).substring(0, 19)],
+    ["Ended", session["ended_at"] ? String(session["ended_at"]).substring(0, 19) : "\u2014"],
+    ["Total cost", fmt2(session["total_cost_usd"])],
+    ["Total tokens", fmtTokens(session["total_tokens"])],
+    ["Requests", fmtCount(session["request_count"])]
+  ]);
+  if (requests.length > 0) {
+    console.log(chalk3.dim(`
+  Requests (${requests.length}):
+`));
+    printTable(["Time", "Model", "Input", "Output", "Cache R", "Cache W", "Cost"], requests.slice(0, 50).map((r) => [
+      chalk3.dim(String(r["timestamp"]).substring(11, 19)),
+      chalk3.white(String(r["model"]).substring(0, 22)),
+      fmtTokens(r["input_tokens"]),
+      fmtTokens(r["output_tokens"]),
+      fmtTokens(r["cache_read_tokens"]),
+      fmtTokens(r["cache_create_tokens"]),
+      fmt2(r["cost_usd"])
+    ]));
+    if (requests.length > 50)
+      console.log(chalk3.dim(`  ... and ${requests.length - 50} more requests`));
+  }
+  console.log();
+});
+program.command("export").description("Export data as CSV").option("--type <type>", "Data type: sessions or requests", "sessions").option("--period <period>", "Period: today|week|month|all", "month").option("--output <file>", "Output file path (default: stdout)").action(async (opts) => {
+  await autoSync();
+  const db = openDatabase();
+  let csv;
+  if (opts.type === "requests") {
+    const where = opts.period === "today" ? `DATE(timestamp) = DATE('now')` : opts.period === "week" ? `timestamp >= DATE('now', '-7 days')` : opts.period === "all" ? "1=1" : `timestamp >= DATE('now', '-30 days')`;
+    const rows = db.prepare(`SELECT * FROM requests WHERE ${where} ORDER BY timestamp ASC`).all();
+    csv = `id,agent,session_id,model,input_tokens,output_tokens,cache_read_tokens,cache_create_tokens,cost_usd,duration_ms,timestamp
+`;
+    for (const r of rows) {
+      csv += `${r["id"]},${r["agent"]},${r["session_id"]},${r["model"]},${r["input_tokens"]},${r["output_tokens"]},${r["cache_read_tokens"]},${r["cache_create_tokens"]},${r["cost_usd"]},${r["duration_ms"]},${r["timestamp"]}
+`;
+    }
+  } else {
+    const where = opts.period === "today" ? `DATE(started_at) = DATE('now')` : opts.period === "week" ? `started_at >= DATE('now', '-7 days')` : opts.period === "all" ? "1=1" : `started_at >= DATE('now', '-30 days')`;
+    const rows = db.prepare(`SELECT * FROM sessions WHERE ${where} ORDER BY started_at DESC`).all();
+    csv = `id,agent,project_path,project_name,started_at,ended_at,total_cost_usd,total_tokens,request_count
+`;
+    for (const r of rows) {
+      csv += `${r["id"]},${r["agent"]},"${r["project_path"]}","${r["project_name"]}",${r["started_at"]},${r["ended_at"] ?? ""},${r["total_cost_usd"]},${r["total_tokens"]},${r["request_count"]}
+`;
+    }
+  }
+  if (opts.output) {
+    const { writeFileSync: writeFileSync3 } = await import("fs");
+    writeFileSync3(opts.output, csv);
+    console.log(chalk3.green(`\u2713 Exported to ${opts.output}`));
+  } else {
+    process.stdout.write(csv);
+  }
+});
+program.command("compare <period1> <period2>").description("Compare two periods (today/yesterday/week/lastweek/month/lastmonth)").action(async (p1, p2) => {
+  await autoSync();
+  const db = openDatabase();
+  function dateRange(period) {
+    const now = new Date;
+    const today = now.toISOString().substring(0, 10);
+    switch (period) {
+      case "today":
+        return [today, today];
+      case "yesterday": {
+        const d = new Date(now);
+        d.setDate(d.getDate() - 1);
+        const s = d.toISOString().substring(0, 10);
+        return [s, s];
+      }
+      case "week": {
+        const d = new Date(now);
+        d.setDate(d.getDate() - 7);
+        return [d.toISOString().substring(0, 10), today];
+      }
+      case "lastweek": {
+        const d1 = new Date(now);
+        d1.setDate(d1.getDate() - 14);
+        const d2 = new Date(now);
+        d2.setDate(d2.getDate() - 7);
+        return [d1.toISOString().substring(0, 10), d2.toISOString().substring(0, 10)];
+      }
+      case "month": {
+        const d = new Date(now);
+        d.setDate(d.getDate() - 30);
+        return [d.toISOString().substring(0, 10), today];
+      }
+      case "lastmonth": {
+        const d1 = new Date(now);
+        d1.setDate(d1.getDate() - 60);
+        const d2 = new Date(now);
+        d2.setDate(d2.getDate() - 30);
+        return [d1.toISOString().substring(0, 10), d2.toISOString().substring(0, 10)];
+      }
+      default:
+        return [today, today];
+    }
+  }
+  function queryRange(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 { ...r, sessions: s.sessions };
+  }
+  const [f1, t1] = dateRange(p1);
+  const [f2, t2] = dateRange(p2);
+  const a = queryRange(f1, t1);
+  const b = queryRange(f2, t2);
+  function delta(v1, v2) {
+    const d = v1 - v2;
+    const pct = v2 > 0 ? (d / v2 * 100).toFixed(1) : "\u2014";
+    const sign = d >= 0 ? "+" : "";
+    const color = d > 0 ? chalk3.red : d < 0 ? chalk3.green : chalk3.dim;
+    return color(`${sign}${pct}%`);
+  }
+  console.log();
+  console.log(chalk3.bold.cyan(`  ${p1} vs ${p2}`));
+  console.log();
+  printTable(["Metric", p1, p2, "Change"], [
+    ["Cost", fmt2(a.cost), fmt2(b.cost), delta(a.cost, b.cost)],
+    ["Sessions", fmtCount(a.sessions), fmtCount(b.sessions), delta(a.sessions, b.sessions)],
+    ["Requests", fmtCount(a.requests), fmtCount(b.requests), delta(a.requests, b.requests)],
+    ["Tokens", fmtTokens(a.tokens), fmtTokens(b.tokens), delta(a.tokens, b.tokens)]
+  ]);
+  console.log();
+});
+program.command("forecast").description("Project end-of-month cost based on current burn rate").action(async () => {
+  await autoSync();
+  const db = openDatabase();
+  const 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 last7Projected = last7DailyAvg * daysInMonth;
+  const dailyCosts = db.prepare(`SELECT DATE(timestamp) as d, SUM(cost_usd) as cost FROM requests WHERE DATE(timestamp) >= ? GROUP BY d ORDER BY cost ASC`).all(monthStart);
+  const cheapest = dailyCosts[0];
+  const mostExpensive = dailyCosts[dailyCosts.length - 1];
+  console.log();
+  console.log(chalk3.bold.cyan(`  Forecast (${dayOfMonth} of ${daysInMonth} days)`));
+  console.log();
+  printTable(["Metric", "Value"], [
+    ["Spent so far", fmt2(monthSoFar.cost)],
+    ["Daily average", fmt2(dailyAvg)],
+    [chalk3.bold("Projected total"), chalk3.bold(fmt2(projected).replace(chalk3.green(""), ""))],
+    ["Last 7-day rate", `${fmt2(last7DailyAvg)}/day \u2192 ${fmt2(last7Projected)}`],
+    ["Cheapest day", cheapest ? `${fmt2(cheapest.cost)} (${cheapest.d})` : "\u2014"],
+    ["Most expensive", mostExpensive ? `${fmt2(mostExpensive.cost)} (${mostExpensive.d})` : "\u2014"]
+  ]);
+  console.log();
+});
+program.command("efficiency").description("Show output/input token ratio per model").action(async () => {
+  await autoSync();
+  const db = openDatabase();
+  const models = db.prepare(`
+      SELECT model, SUM(input_tokens) as input, SUM(output_tokens) as output,
+             SUM(cache_read_tokens) as cache_read, SUM(cache_create_tokens) as cache_write,
+             COUNT(*) as requests, SUM(cost_usd) as cost
+      FROM requests GROUP BY model ORDER BY cost DESC
+    `).all();
+  console.log();
+  console.log(chalk3.bold.cyan("  Token Efficiency"));
+  console.log();
+  printTable(["Model", "Output/Input", "Cache Hit%", "Cost/1k Output", "Requests"], models.map((m) => {
+    const ratio = m.input > 0 ? (m.output / m.input).toFixed(2) : "\u2014";
+    const totalInput = m.input + m.cache_read + m.cache_write;
+    const cacheHit = totalInput > 0 ? (m.cache_read / totalInput * 100).toFixed(1) + "%" : "\u2014";
+    const costPer1kOutput = m.output > 0 ? fmt2(m.cost / m.output * 1000) : "\u2014";
+    return [chalk3.white(m.model), ratio, cacheHit, costPer1kOutput, fmtCount(m.requests)];
+  }));
+  console.log();
+});
+var menubarCmd = program.command("menubar").description("Manage the Economy Bar macOS menubar app");
+menubarCmd.command("install").description("Download and install Economy Bar from GitHub Releases").option("--force", "Overwrite existing installation").action(async (opts) => {
+  const { menubarInstall: menubarInstall2 } = await Promise.resolve().then(() => (init_menubar(), exports_menubar));
+  await menubarInstall2(opts);
+});
+menubarCmd.command("uninstall").description("Quit and remove Economy Bar from /Applications").action(async () => {
+  const { menubarUninstall: menubarUninstall2 } = await Promise.resolve().then(() => (init_menubar(), exports_menubar));
+  menubarUninstall2();
+});
+menubarCmd.command("start").description("Launch Economy Bar").action(async () => {
+  const { menubarStart: menubarStart2 } = await Promise.resolve().then(() => (init_menubar(), exports_menubar));
+  menubarStart2();
+});
+menubarCmd.command("stop").description("Quit Economy Bar").action(async () => {
+  const { menubarStop: menubarStop2 } = await Promise.resolve().then(() => (init_menubar(), exports_menubar));
+  menubarStop2();
+});
+var goalCmd = program.command("goal").description("Manage spending goals");
+goalCmd.command("set").description("Set a spending goal").option("--period <period>", "Period: day|week|month|year", "month").option("--limit <usd>", "Goal limit in USD").option("--project <path>", "Scope to project path").option("--agent <agent>", "Scope to agent").action((opts) => {
+  if (!opts.limit) {
+    console.error(chalk3.red("--limit is required"));
+    process.exit(1);
+  }
+  const db = openDatabase();
+  const now = new Date().toISOString();
+  upsertGoal(db, {
+    id: randomUUID2(),
+    period: opts.period ?? "month",
+    project_path: opts.project ?? null,
+    agent: opts.agent ?? null,
+    limit_usd: Number(opts.limit),
+    created_at: now,
+    updated_at: now
+  });
+  console.log(chalk3.green(`\u2713 Goal set: ${opts.period ?? "month"} $${opts.limit}${opts.project ? ` (${opts.project})` : ""}`));
+});
+goalCmd.command("list").description("List all goals with progress").action(() => {
+  const db = openDatabase();
+  const statuses = getGoalStatuses(db);
+  if (statuses.length === 0) {
+    console.log(chalk3.yellow("No goals set."));
+    return;
+  }
+  console.log();
+  printTable(["Period", "Scope", "Limit", "Spent", "Used%", "Status"], statuses.map((g) => {
+    const pct = g.percent_used.toFixed(1);
+    const scope = g.project_path ?? g.agent ?? "global";
+    const status = g.is_over ? chalk3.red("OVER") : g.is_at_risk ? chalk3.yellow("AT RISK") : chalk3.green("ON TRACK");
+    const pctColor = g.is_over ? chalk3.red(pct + "%") : g.is_at_risk ? chalk3.yellow(pct + "%") : chalk3.green(pct + "%");
+    return [
+      g.period,
+      chalk3.white(scope),
+      fmt2(g.limit_usd),
+      fmt2(g.current_spend_usd),
+      pctColor,
+      status
+    ];
+  }));
+  console.log();
+});
+goalCmd.command("remove <id>").description("Remove a goal").action((id) => {
+  const db = openDatabase();
+  deleteGoal(db, id);
+  console.log(chalk3.green(`\u2713 Goal removed`));
+});
+goalCmd.command("status").description("Quick goal progress summary").action(() => {
+  const db = openDatabase();
+  const statuses = getGoalStatuses(db);
+  if (statuses.length === 0) {
+    console.log(chalk3.yellow("No goals set."));
+    return;
+  }
+  console.log();
+  for (const g of statuses) {
+    const scope = g.project_path ?? g.agent ?? "global";
+    const pct = Math.min(g.percent_used, 100);
+    const barFilled = Math.round(pct / 10);
+    const barEmpty = 10 - barFilled;
+    const bar = "\u2588".repeat(barFilled) + "\u2591".repeat(barEmpty);
+    const statusStr = g.is_over ? chalk3.red("\u2717 OVER") : g.is_at_risk ? chalk3.yellow("\u26A0 AT RISK") : chalk3.green("\u2713 ON TRACK");
+    const label = `${g.period} (${scope})`.padEnd(20);
+    console.log(`  ${label}  ${bar}  ${fmt2(g.current_spend_usd)} / ${fmt2(g.limit_usd)}  (${g.percent_used.toFixed(0)}%)  ${statusStr}`);
+  }
+  console.log();
+});
+program.command("remove <type> <id>").alias("rm").description("Remove a record. Type: budget | project | goal | pricing").action((type, id) => {
+  const db = openDatabase();
+  try {
+    switch (type.toLowerCase()) {
+      case "budget":
+        deleteBudget(db, id);
+        console.log(chalk3.green(`\u2713 Budget ${id} removed`));
+        break;
+      case "project":
+        deleteProject(db, id);
+        console.log(chalk3.green(`\u2713 Project ${id} removed`));
+        break;
+      case "goal":
+        deleteGoal(db, id);
+        console.log(chalk3.green(`\u2713 Goal ${id} removed`));
+        break;
+      case "pricing":
+        deleteModelPricing(db, id);
+        console.log(chalk3.green(`\u2713 Pricing entry ${id} removed`));
+        break;
+      default:
+        console.error(chalk3.red(`Unknown type: ${type}. Use: budget | project | goal | pricing`));
+        process.exit(1);
+    }
+  } catch (e) {
+    console.error(chalk3.red(`Failed: ${e instanceof Error ? e.message : String(e)}`));
+    process.exit(1);
+  }
+});
+program.parse();