@hasna/economy 0.2.21 → 0.2.23

package/dist/server/index.js

@@ -583,7 +583,12 @@ function initSchema(db) {
       duration_ms INTEGER DEFAULT 0,
       timestamp TEXT NOT NULL,
       source_request_id TEXT,
-      machine_id TEXT DEFAULT ''
+      machine_id TEXT DEFAULT '',
+      account_key TEXT DEFAULT '',
+      account_tool TEXT DEFAULT '',
+      account_name TEXT DEFAULT '',
+      account_email TEXT DEFAULT '',
+      account_source TEXT DEFAULT ''
     );
 
     CREATE TABLE IF NOT EXISTS sessions (
@@ -596,7 +601,12 @@ function initSchema(db) {
       total_cost_usd REAL DEFAULT 0,
       total_tokens INTEGER DEFAULT 0,
       request_count INTEGER DEFAULT 0,
-      machine_id TEXT DEFAULT ''
+      machine_id TEXT DEFAULT '',
+      account_key TEXT DEFAULT '',
+      account_tool TEXT DEFAULT '',
+      account_name TEXT DEFAULT '',
+      account_email TEXT DEFAULT '',
+      account_source TEXT DEFAULT ''
     );
 
     CREATE TABLE IF NOT EXISTS projects (
@@ -751,6 +761,11 @@ function initSchema(db) {
   if (!cols.some((c) => c.name === "synced_at")) {
     db.exec(`ALTER TABLE requests ADD COLUMN synced_at TEXT DEFAULT ''`);
   }
+  for (const column of ["account_key", "account_tool", "account_name", "account_email", "account_source"]) {
+    if (!cols.some((c) => c.name === column)) {
+      db.exec(`ALTER TABLE requests ADD COLUMN ${column} TEXT DEFAULT ''`);
+    }
+  }
   const sessionCols = db.prepare(`PRAGMA table_info(sessions)`).all();
   if (!sessionCols.some((c) => c.name === "attribution_tag")) {
     db.exec(`ALTER TABLE sessions ADD COLUMN attribution_tag TEXT DEFAULT ''`);
@@ -762,6 +777,11 @@ function initSchema(db) {
   if (!sessionCols.some((c) => c.name === "synced_at")) {
     db.exec(`ALTER TABLE sessions ADD COLUMN synced_at TEXT DEFAULT ''`);
   }
+  for (const column of ["account_key", "account_tool", "account_name", "account_email", "account_source"]) {
+    if (!sessionCols.some((c) => c.name === column)) {
+      db.exec(`ALTER TABLE sessions ADD COLUMN ${column} TEXT DEFAULT ''`);
+    }
+  }
   const pricingCols = db.prepare(`PRAGMA table_info(model_pricing)`).all();
   if (!pricingCols.some((c) => c.name === "cache_write_1h_per_1m")) {
     db.exec(`ALTER TABLE model_pricing ADD COLUMN cache_write_1h_per_1m REAL NOT NULL DEFAULT 0`);
@@ -772,6 +792,8 @@ function initSchema(db) {
   db.exec(`
     CREATE INDEX IF NOT EXISTS idx_requests_machine ON requests(machine_id);
     CREATE INDEX IF NOT EXISTS idx_sessions_machine ON sessions(machine_id);
+    CREATE INDEX IF NOT EXISTS idx_requests_account ON requests(account_key);
+    CREATE INDEX IF NOT EXISTS idx_sessions_account ON sessions(account_key);
   `);
 }
 function periodWhere(period) {
@@ -806,6 +828,22 @@ function sessionPeriodWhere(period) {
       return "1=1";
   }
 }
+function requestPeriodWhere(period) {
+  switch (period) {
+    case "today":
+      return `DATE(timestamp) = DATE('now')`;
+    case "yesterday":
+      return `DATE(timestamp) = DATE('now', '-1 day')`;
+    case "week":
+      return `timestamp >= DATE('now', 'weekday 0', '-7 days')`;
+    case "month":
+      return `timestamp >= DATE('now', 'start of month')`;
+    case "year":
+      return `timestamp >= DATE('now', 'start of year')`;
+    case "all":
+      return "1=1";
+  }
+}
 function upsertRequest(db, req) {
   const now = req.updated_at ?? new Date().toISOString();
   db.prepare(`
@@ -813,18 +851,20 @@ function upsertRequest(db, req) {
       (id, agent, session_id, model, input_tokens, output_tokens,
        cache_read_tokens, cache_create_tokens, cache_create_5m_tokens,
        cache_create_1h_tokens, cost_usd, cost_basis, duration_ms, timestamp,
-       source_request_id, machine_id, attribution_tag, updated_at, synced_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(req.id, req.agent, req.session_id, req.model, req.input_tokens, req.output_tokens, req.cache_read_tokens, req.cache_create_tokens, req.cache_create_5m_tokens ?? req.cache_create_tokens, req.cache_create_1h_tokens ?? 0, req.cost_usd, req.cost_basis ?? "estimated", req.duration_ms, req.timestamp, req.source_request_id, req.machine_id ?? "", req.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", now, req.synced_at ?? "");
+       source_request_id, machine_id, attribution_tag, account_key, account_tool,
+       account_name, account_email, account_source, updated_at, synced_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(req.id, req.agent, req.session_id, req.model, req.input_tokens, req.output_tokens, req.cache_read_tokens, req.cache_create_tokens, req.cache_create_5m_tokens ?? req.cache_create_tokens, req.cache_create_1h_tokens ?? 0, req.cost_usd, req.cost_basis ?? "estimated", req.duration_ms, req.timestamp, req.source_request_id, req.machine_id ?? "", req.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", req.account_key ?? "", req.account_tool ?? "", req.account_name ?? "", req.account_email ?? "", req.account_source ?? "", now, req.synced_at ?? "");
 }
 function upsertSession(db, session) {
   const now = session.updated_at ?? new Date().toISOString();
   db.prepare(`
     INSERT OR REPLACE INTO sessions
       (id, agent, project_path, project_name, started_at, ended_at,
-       total_cost_usd, total_tokens, request_count, machine_id, attribution_tag, updated_at, synced_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(session.id, session.agent, session.project_path, session.project_name, session.started_at, session.ended_at ?? null, session.total_cost_usd, session.total_tokens, session.request_count, session.machine_id ?? "", session.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", now, session.synced_at ?? "");
+       total_cost_usd, total_tokens, request_count, machine_id, attribution_tag,
+       account_key, account_tool, account_name, account_email, account_source, updated_at, synced_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(session.id, session.agent, session.project_path, session.project_name, session.started_at, session.ended_at ?? null, session.total_cost_usd, session.total_tokens, session.request_count, session.machine_id ?? "", session.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", session.account_key ?? "", session.account_tool ?? "", session.account_name ?? "", session.account_email ?? "", session.account_source ?? "", now, session.synced_at ?? "");
 }
 function rollupSession(db, sessionId) {
   db.prepare(`
@@ -835,9 +875,24 @@ function rollupSession(db, sessionId) {
       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
+                            ELSE started_at END,
+      account_key    = CASE WHEN account_key = '' OR account_key IS NULL
+                            THEN COALESCE((SELECT account_key FROM requests WHERE session_id = ? AND account_key != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_key END,
+      account_tool   = CASE WHEN account_tool = '' OR account_tool IS NULL
+                            THEN COALESCE((SELECT account_tool FROM requests WHERE session_id = ? AND account_tool != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_tool END,
+      account_name   = CASE WHEN account_name = '' OR account_name IS NULL
+                            THEN COALESCE((SELECT account_name FROM requests WHERE session_id = ? AND account_name != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_name END,
+      account_email  = CASE WHEN account_email = '' OR account_email IS NULL
+                            THEN COALESCE((SELECT account_email FROM requests WHERE session_id = ? AND account_email != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_email END,
+      account_source = CASE WHEN account_source = '' OR account_source IS NULL
+                            THEN COALESCE((SELECT account_source FROM requests WHERE session_id = ? AND account_source != '' ORDER BY timestamp DESC LIMIT 1), '')
+                            ELSE account_source END
     WHERE id = ?
-  `).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId);
+  `).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId);
 }
 function querySessions(db, filter = {}) {
   const conditions = [];
@@ -850,6 +905,11 @@ function querySessions(db, filter = {}) {
     conditions.push("project_path LIKE ?");
     params.push(`%${filter.project}%`);
   }
+  if (filter.account) {
+    const q = `%${filter.account}%`;
+    conditions.push("(account_key LIKE ? OR account_name LIKE ? OR account_email LIKE ?)");
+    params.push(q, q, q);
+  }
   if (filter.since) {
     conditions.push("started_at >= ?");
     params.push(filter.since);
@@ -914,6 +974,70 @@ function queryModelBreakdown(db) {
     FROM requests GROUP BY model, agent ORDER BY cost_usd DESC
   `).all();
 }
+function queryAgentBreakdown(db, period = "all") {
+  const requestWhere = requestPeriodWhere(period);
+  const groups = new Map;
+  const requestRows = db.prepare(`
+    SELECT agent,
+           COUNT(DISTINCT session_id) as sessions,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as metered_api_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+           COALESCE(SUM(CASE WHEN COALESCE(cost_basis, 'estimated') = 'estimated' THEN cost_usd ELSE 0 END), 0) as estimated_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
+           COALESCE(SUM(cost_usd), 0) as cost_usd,
+           MAX(timestamp) as last_active
+    FROM requests
+    WHERE ${requestWhere}
+    GROUP BY agent
+    ORDER BY api_equivalent_usd DESC
+  `).all();
+  for (const row of requestRows) {
+    groups.set(row.agent, row);
+  }
+  const sessionWhere = sessionPeriodWhere(period);
+  const sessionOnlyRows = db.prepare(`
+    SELECT agent,
+           COUNT(*) as sessions,
+           COALESCE(SUM(request_count), 0) as requests,
+           COALESCE(SUM(total_tokens), 0) as total_tokens,
+           COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+           MAX(started_at) as last_active
+    FROM sessions
+    WHERE ${sessionWhere}
+      AND id NOT IN (SELECT DISTINCT session_id FROM requests)
+    GROUP BY agent
+  `).all();
+  for (const row of sessionOnlyRows) {
+    const existing = groups.get(row.agent) ?? {
+      agent: row.agent,
+      sessions: 0,
+      requests: 0,
+      total_tokens: 0,
+      api_equivalent_usd: 0,
+      billable_usd: 0,
+      metered_api_usd: 0,
+      subscription_included_usd: 0,
+      estimated_usd: 0,
+      unknown_usd: 0,
+      cost_usd: 0,
+      last_active: ""
+    };
+    existing.sessions += row.sessions;
+    existing.requests += row.requests;
+    existing.total_tokens += row.total_tokens;
+    existing.api_equivalent_usd += row.cost_usd;
+    existing.estimated_usd += row.cost_usd;
+    existing.cost_usd += row.cost_usd;
+    if (!existing.last_active || row.last_active > existing.last_active)
+      existing.last_active = row.last_active;
+    groups.set(row.agent, existing);
+  }
+  return [...groups.values()].sort((a, b) => b.api_equivalent_usd - a.api_equivalent_usd);
+}
 function labelForPath(projectPath, projectName) {
   if (projectName && projectName.trim() !== "")
     return projectName;
@@ -932,11 +1056,13 @@ function labelForPath(projectPath, projectName) {
   }
   return segments[segments.length - 1] ?? projectPath;
 }
-function queryProjectBreakdown(db) {
+function queryProjectBreakdown(db, period = "all") {
+  const where = sessionPeriodWhere(period);
   const sessions = db.prepare(`
     SELECT id, project_path, project_name, total_cost_usd, started_at
     FROM sessions
-    WHERE project_path != '' OR project_name != ''
+    WHERE ${where}
+      AND (project_path != '' OR project_name != '')
   `).all();
   const groups = new Map;
   for (const s of sessions) {
@@ -975,6 +1101,87 @@ function queryProjectBreakdown(db) {
   result.sort((a, b) => b.cost_usd - a.cost_usd);
   return result;
 }
+function queryAccountBreakdown(db, period = "all") {
+  const sWhere = sessionPeriodWhere(period);
+  const sessions = db.prepare(`
+    SELECT id, account_key, account_tool, account_name, account_email, account_source,
+           total_cost_usd, total_tokens, request_count, started_at
+    FROM sessions
+    WHERE ${sWhere}
+      AND (account_key != '' OR account_tool != '' OR account_name != '' OR account_email != '')
+  `).all();
+  const groups = new Map;
+  for (const session of sessions) {
+    const key = session.account_key || `${session.account_tool}:${session.account_name}`;
+    if (!key || key === ":")
+      continue;
+    const group = groups.get(key) ?? {
+      sessionIds: [],
+      account_tool: session.account_tool,
+      account_name: session.account_name,
+      account_email: session.account_email || null,
+      account_source: session.account_source || "unknown",
+      totalCost: 0,
+      totalTokens: 0,
+      requests: 0,
+      lastActive: ""
+    };
+    group.sessionIds.push(session.id);
+    group.totalCost += session.total_cost_usd || 0;
+    group.totalTokens += session.total_tokens || 0;
+    group.requests += session.request_count || 0;
+    if (!group.lastActive || session.started_at > group.lastActive)
+      group.lastActive = session.started_at;
+    groups.set(key, group);
+  }
+  const result = [];
+  for (const [key, group] of groups.entries()) {
+    const placeholders = group.sessionIds.map(() => "?").join(",");
+    const reqStats = placeholders ? db.prepare(`
+          SELECT
+            COUNT(*) as requests,
+            COALESCE(SUM(cost_usd), 0) as cost_usd,
+            COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+            COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as metered_api_usd,
+            COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+            COALESCE(SUM(CASE WHEN COALESCE(cost_basis, 'estimated') = 'estimated' THEN cost_usd ELSE 0 END), 0) as estimated_usd,
+            COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd
+          FROM requests WHERE session_id IN (${placeholders})
+        `).get(...group.sessionIds) : {
+      requests: 0,
+      cost_usd: 0,
+      total_tokens: 0,
+      metered_api_usd: 0,
+      subscription_included_usd: 0,
+      estimated_usd: 0,
+      unknown_usd: 0
+    };
+    const hasRequestCosts = reqStats.requests > 0;
+    const apiEquivalentUsd = hasRequestCosts ? reqStats.cost_usd : group.totalCost;
+    const estimatedUsd = hasRequestCosts ? reqStats.estimated_usd : group.totalCost;
+    const billableUsd = reqStats.metered_api_usd;
+    result.push({
+      account_key: key,
+      account_tool: group.account_tool,
+      account_name: group.account_name,
+      account_email: group.account_email,
+      account_source: group.account_source,
+      sessions: group.sessionIds.length,
+      requests: reqStats.requests || group.requests,
+      total_tokens: reqStats.total_tokens || group.totalTokens,
+      api_equivalent_usd: apiEquivalentUsd,
+      billable_usd: billableUsd,
+      metered_api_usd: reqStats.metered_api_usd,
+      subscription_included_usd: reqStats.subscription_included_usd,
+      estimated_usd: estimatedUsd,
+      unknown_usd: reqStats.unknown_usd,
+      cost_usd: apiEquivalentUsd,
+      last_active: group.lastActive
+    });
+  }
+  result.sort((a, b) => b.cost_usd - a.cost_usd);
+  return result;
+}
 function queryDailyBreakdown(db, days = 30) {
   return db.prepare(`
     SELECT DATE(timestamp) as date, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
@@ -1157,6 +1364,12 @@ function upsertSubscription(db, sub) {
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(sub.id, sub.agent, sub.provider, sub.plan, sub.monthly_fee_usd, sub.included_usage_usd, sub.billing_cycle_start, sub.reset_policy, sub.active, sub.created_at, sub.updated_at);
 }
+function listSubscriptions(db) {
+  return db.prepare(`SELECT * FROM subscriptions ORDER BY provider, plan`).all();
+}
+function deleteSubscription(db, id) {
+  db.prepare(`DELETE FROM subscriptions WHERE id = ?`).run(id);
+}
 function upsertUsageSnapshot(db, snap) {
   const now = snap.updated_at ?? new Date().toISOString();
   const id = snap.id ?? `${snap.agent}-${snap.date}-${snap.metric}-${snap.machine_id}`;
@@ -1228,7 +1441,12 @@ var init_pg_migrations = __esm(() => {
     duration_ms INTEGER DEFAULT 0,
     timestamp TEXT NOT NULL,
     source_request_id TEXT,
-    machine_id TEXT DEFAULT ''
+    machine_id TEXT DEFAULT '',
+    account_key TEXT DEFAULT '',
+    account_tool TEXT DEFAULT '',
+    account_name TEXT DEFAULT '',
+    account_email TEXT DEFAULT '',
+    account_source TEXT DEFAULT ''
   )`,
     `CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
@@ -1240,7 +1458,12 @@ var init_pg_migrations = __esm(() => {
     total_cost_usd REAL DEFAULT 0,
     total_tokens INTEGER DEFAULT 0,
     request_count INTEGER DEFAULT 0,
-    machine_id TEXT DEFAULT ''
+    machine_id TEXT DEFAULT '',
+    account_key TEXT DEFAULT '',
+    account_tool TEXT DEFAULT '',
+    account_name TEXT DEFAULT '',
+    account_email TEXT DEFAULT '',
+    account_source TEXT DEFAULT ''
   )`,
     `CREATE TABLE IF NOT EXISTS projects (
     id TEXT PRIMARY KEY,
@@ -1361,13 +1584,25 @@ var init_pg_migrations = __esm(() => {
   )`,
     `ALTER TABLE requests ADD COLUMN IF NOT EXISTS cost_basis TEXT DEFAULT 'estimated'`,
     `ALTER TABLE requests ADD COLUMN IF NOT EXISTS attribution_tag TEXT DEFAULT ''`,
+    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_key TEXT DEFAULT ''`,
+    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_tool TEXT DEFAULT ''`,
+    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_name TEXT DEFAULT ''`,
+    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_email TEXT DEFAULT ''`,
+    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_source TEXT DEFAULT ''`,
     `ALTER TABLE requests ADD COLUMN IF NOT EXISTS updated_at TEXT DEFAULT ''`,
     `ALTER TABLE requests ADD COLUMN IF NOT EXISTS synced_at TEXT DEFAULT ''`,
     `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS attribution_tag TEXT DEFAULT ''`,
+    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_key TEXT DEFAULT ''`,
+    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_tool TEXT DEFAULT ''`,
+    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_name TEXT DEFAULT ''`,
+    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_email TEXT DEFAULT ''`,
+    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_source TEXT DEFAULT ''`,
     `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS updated_at TEXT DEFAULT ''`,
     `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS synced_at TEXT DEFAULT ''`,
     `CREATE INDEX IF NOT EXISTS idx_usage_agent_date ON usage_snapshots(agent, date)`,
-    `CREATE INDEX IF NOT EXISTS idx_savings_date ON savings_daily(date)`
+    `CREATE INDEX IF NOT EXISTS idx_savings_date ON savings_daily(date)`,
+    `CREATE INDEX IF NOT EXISTS idx_requests_account ON requests(account_key)`,
+    `CREATE INDEX IF NOT EXISTS idx_sessions_account ON sessions(account_key)`
   ];
 });
 
@@ -1378,7 +1613,7 @@ __export(exports_billing, {
   syncGeminiBilling: () => syncGeminiBilling,
   syncAnthropicBilling: () => syncAnthropicBilling
 });
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 function getAnthropicAdminKey() {
   return process.env["HASNAXYZ_ANTHROPIC_LIVE_ADMIN_API_KEY"] ?? process.env["ANTHROPIC_ADMIN_API_KEY"] ?? null;
 }
@@ -1572,7 +1807,7 @@ async function syncGeminiBilling(db, opts = {}) {
   const start = opts.fromDate ? new Date(opts.fromDate) : new Date(end.getTime() - days * 24 * 3600000);
   const fromDateStr = toISODate(start);
   const toDateStr = toISODate(end);
-  const rows = parseBillingRows(readFileSync10(exportPath, "utf-8"));
+  const rows = parseBillingRows(readFileSync9(exportPath, "utf-8"));
   clearBillingRange(db, "gemini", fromDateStr, toDateStr);
   const updatedAt = new Date().toISOString();
   let totalUsd = 0;
@@ -1634,7 +1869,7 @@ var init_open_projects = __esm(() => {
 });
 
 // src/lib/config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync10, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname, join as join9 } from "path";
 function getConfigPath() {
   return process.env["HASNA_ECONOMY_CONFIG_PATH"] ?? join9(getDataDir(), "config.json");
@@ -1643,7 +1878,7 @@ function loadConfig() {
   try {
     const configPath = getConfigPath();
     if (existsSync10(configPath)) {
-      const raw = readFileSync11(configPath, "utf-8");
+      const raw = readFileSync10(configPath, "utf-8");
       return { ...DEFAULTS, ...JSON.parse(raw) };
     }
   } catch {}
@@ -1809,7 +2044,6 @@ function periodWhere2(period, column) {
 }
 function prorateMonthlyFee(monthlyFee, period) {
   const now = new Date;
-  const dayOfMonth = now.getDate();
   const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
   switch (period) {
     case "today":
@@ -1891,6 +2125,131 @@ function defaultCostBasisForAgent(agent) {
   return "estimated";
 }
 
+// src/lib/accounts.ts
+var AGENT_ACCOUNT_TOOLS = {
+  claude: ["claude"],
+  takumi: ["takumi", "claude"],
+  codex: ["codex"],
+  gemini: ["gemini"],
+  opencode: ["opencode"],
+  cursor: ["cursor"],
+  pi: ["pi"],
+  hermes: ["hermes"]
+};
+function accountKey(tool, name) {
+  return `${tool}:${name}`;
+}
+function normalizeDir(value) {
+  return value.replace(/\/+$/, "");
+}
+function fromProfile(profile, source) {
+  return {
+    account_key: accountKey(profile.tool, profile.name),
+    account_tool: profile.tool,
+    account_name: profile.name,
+    ...profile.email ? { account_email: profile.email } : {},
+    account_source: source
+  };
+}
+function fromOverride(raw, agent) {
+  const value = raw.trim();
+  if (!value)
+    return null;
+  const candidateTool = AGENT_ACCOUNT_TOOLS[agent][0] ?? agent;
+  const [tool, name] = value.includes(":") ? value.split(":", 2) : [candidateTool, value];
+  if (!tool || !name)
+    return null;
+  return {
+    account_key: accountKey(tool, name),
+    account_tool: tool,
+    account_name: name,
+    account_source: "override"
+  };
+}
+function envOverride(agent, env) {
+  const agentPrefix = agent.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  const raw = env[`ECONOMY_${agentPrefix}_ACCOUNT_KEY`] ?? env[`ECONOMY_${agentPrefix}_ACCOUNT`] ?? env["ECONOMY_ACCOUNT_KEY"] ?? env["ECONOMY_ACCOUNT"];
+  if (raw)
+    return fromOverride(raw, agent);
+  const tool = env[`ECONOMY_${agentPrefix}_ACCOUNT_TOOL`] ?? env["ECONOMY_ACCOUNT_TOOL"];
+  const name = env[`ECONOMY_${agentPrefix}_ACCOUNT_NAME`] ?? env["ECONOMY_ACCOUNT_NAME"];
+  if (!tool || !name)
+    return null;
+  return {
+    account_key: accountKey(tool, name),
+    account_tool: tool,
+    account_name: name,
+    account_email: env[`ECONOMY_${agentPrefix}_ACCOUNT_EMAIL`] ?? env["ECONOMY_ACCOUNT_EMAIL"],
+    account_source: "override"
+  };
+}
+function knownToolIds(api) {
+  try {
+    return new Set(api.listTools().map((tool) => tool.id));
+  } catch {
+    return new Set;
+  }
+}
+function profileForEnvDir(api, tool, env) {
+  const configuredDir = env[tool.envVar];
+  if (!configuredDir)
+    return null;
+  const normalized = normalizeDir(configuredDir);
+  try {
+    return api.listProfiles(tool.id).find((profile) => normalizeDir(profile.dir) === normalized) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function resolveAccountForAgent(agent, env = process.env) {
+  const override = envOverride(agent, env);
+  if (override)
+    return override;
+  let api;
+  try {
+    api = await import("@hasna/accounts");
+  } catch {
+    return null;
+  }
+  const toolIds = knownToolIds(api);
+  for (const toolId of AGENT_ACCOUNT_TOOLS[agent]) {
+    if (!toolIds.has(toolId))
+      continue;
+    let tool;
+    try {
+      tool = api.getTool(toolId);
+    } catch {
+      continue;
+    }
+    const envProfile = profileForEnvDir(api, tool, env);
+    if (envProfile)
+      return fromProfile(envProfile, "env");
+    try {
+      const applied = api.appliedProfile(toolId);
+      if (applied)
+        return fromProfile(applied, "applied");
+    } catch {}
+    try {
+      const current = api.currentProfile(toolId);
+      if (current)
+        return fromProfile(current, "current");
+    } catch {}
+  }
+  return null;
+}
+function withAccount(record, account) {
+  if (!account)
+    return record;
+  return {
+    ...record,
+    account_key: account.account_key,
+    account_tool: account.account_tool,
+    account_name: account.account_name,
+    account_email: account.account_email ?? "",
+    account_source: account.account_source
+  };
+}
+
 // src/ingest/claude.ts
 function autoDetectProject(cwd, projects) {
   return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
@@ -1932,6 +2291,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
   let totalRequests = 0;
   const touchedSessions = new Set;
   const registeredProjects = db.prepare(`SELECT path, name FROM projects ORDER BY LENGTH(path) DESC`).all();
+  const account = await resolveAccountForAgent(agentName);
   const projectDirs = readdirSync2(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
   for (const projectDirEntry of projectDirs) {
     const projectDirPath = join2(projectsDir, projectDirEntry.name);
@@ -1995,7 +2355,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
         }
         const sourceRequestId = entry.requestId ?? entry.request_id ?? entry.message.id ?? entry.uuid ?? `${sessionId}-${timestamp}`;
         const reqId = `${agentName}-${sourceRequestId}`;
-        upsertRequest(db, {
+        upsertRequest(db, withAccount({
           id: reqId,
           agent: agentName,
           session_id: sessionId,
@@ -2012,7 +2372,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
           timestamp,
           source_request_id: sourceRequestId,
           machine_id: machineId
-        });
+        }, account));
         if (!touchedSessions.has(sessionId)) {
           const existing = db.prepare(`SELECT id FROM sessions WHERE id = ?`).get(sessionId);
           if (!existing) {
@@ -2030,7 +2390,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
               request_count: 0,
               machine_id: machineId
             };
-            upsertSession(db, session);
+            upsertSession(db, withAccount(session, account));
           }
           touchedSessions.add(sessionId);
         }
@@ -2076,7 +2436,7 @@ import { join as join3, basename as basename2 } from "path";
 import { Database as BunDatabase } from "bun:sqlite";
 var DEFAULT_CODEX_DB_PATH = join3(homedir3(), ".codex", "state_5.sqlite");
 var DEFAULT_CODEX_CONFIG_PATH = join3(homedir3(), ".codex", "config.toml");
-var CODEX_INGEST_VERSION = "rollout-token-dedupe-v2";
+var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
 function codexDbPath() {
   return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
 }
@@ -2109,8 +2469,9 @@ function buildThreadQuery(codexDb) {
 function readTokenEvents(rolloutPath) {
   if (!rolloutPath || !existsSync3(rolloutPath))
     return [];
-  const events = [];
-  const seen = new Set;
+  const fallbackUsages = new Map;
+  let fallbackTimestamp;
+  let aggregate = null;
   for (const line of readFileSync2(rolloutPath, "utf-8").split(`
 `)) {
     if (!line.trim())
@@ -2127,20 +2488,48 @@ function readTokenEvents(rolloutPath) {
     if (!payload || payload["type"] !== "token_count")
       continue;
     const info = payload["info"];
+    const timestamp = entry["timestamp"];
+    const entryTimestamp = typeof timestamp === "string" ? timestamp : undefined;
+    const totalUsage = info?.["total_token_usage"];
+    if (totalUsage && tokenTotal(totalUsage) > 0) {
+      aggregate = { usage: totalUsage, timestamp: entryTimestamp };
+      continue;
+    }
     const usage = info?.["last_token_usage"];
     if (!usage)
       continue;
-    const total = usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
-    if (total <= 0)
+    if (tokenTotal(usage) <= 0)
       continue;
     const key = JSON.stringify(usage);
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    const timestamp = entry["timestamp"];
-    events.push({ usage, timestamp: typeof timestamp === "string" ? timestamp : undefined });
+    if (!fallbackUsages.has(key))
+      fallbackUsages.set(key, usage);
+    fallbackTimestamp = entryTimestamp ?? fallbackTimestamp;
   }
-  return events;
+  if (aggregate)
+    return [aggregate];
+  if (fallbackUsages.size === 0)
+    return [];
+  return [{ usage: sumTokenUsages([...fallbackUsages.values()]), timestamp: fallbackTimestamp }];
+}
+function tokenTotal(usage) {
+  return usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
+}
+function sumTokenUsages(usages) {
+  const result = {
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0
+  };
+  for (const usage of usages) {
+    result.input_tokens = (result.input_tokens ?? 0) + (usage.input_tokens ?? 0);
+    result.cached_input_tokens = (result.cached_input_tokens ?? 0) + (usage.cached_input_tokens ?? 0);
+    result.output_tokens = (result.output_tokens ?? 0) + (usage.output_tokens ?? 0);
+    result.reasoning_output_tokens = (result.reasoning_output_tokens ?? 0) + (usage.reasoning_output_tokens ?? 0);
+    result.total_tokens = (result.total_tokens ?? 0) + tokenTotal(usage);
+  }
+  return result;
 }
 function fallbackEvents(totalTokens) {
   const inputTokens = Math.floor(totalTokens * 0.6);
@@ -2164,6 +2553,7 @@ async function ingestCodex(db, verbose = false) {
   let codexDb = null;
   let ingested = 0;
   let requests = 0;
+  const account = await resolveAccountForAgent("codex");
   try {
     codexDb = new BunDatabase(dbPath, { readonly: true });
     const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
@@ -2178,7 +2568,7 @@ async function ingestCodex(db, verbose = false) {
       const sessionId = `codex-${thread.id}`;
       const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
       const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
-      upsertSession(db, {
+      upsertSession(db, withAccount({
         id: sessionId,
         agent: "codex",
         project_path: projectPath,
@@ -2189,9 +2579,10 @@ async function ingestCodex(db, verbose = false) {
         total_tokens: 0,
         request_count: 0,
         machine_id: machineId
-      });
+      }, account));
       const events = readTokenEvents(thread.rollout_path);
       const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
+      const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
       db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
       tokenEvents.forEach((event, index) => {
         const usage = event.usage;
@@ -2202,7 +2593,7 @@ async function ingestCodex(db, verbose = false) {
         const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
         const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
         const requestId = `${sessionId}-${index}`;
-        upsertRequest(db, {
+        upsertRequest(db, withAccount({
           id: requestId,
           agent: "codex",
           session_id: sessionId,
@@ -2217,14 +2608,14 @@ async function ingestCodex(db, verbose = false) {
           timestamp,
           source_request_id: requestId,
           machine_id: machineId
-        });
+        }, account));
         requests++;
       });
       rollupSession(db, sessionId);
       setIngestState(db, "codex", thread.id, stateValue);
       ingested++;
       if (verbose)
-        console.log(`Codex session ${thread.id}: ${thread.tokens_used} tokens on ${model}`);
+        console.log(`Codex session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
     }
   } finally {
     codexDb?.close();
@@ -2291,6 +2682,7 @@ async function ingestGemini(db, verbose) {
   let totalSessions = 0;
   let totalRequests = 0;
   const touchedSessions = new Set;
+  const account = await resolveAccountForAgent("gemini");
   const projectDirs = listProjectDirs(tmpDir, historyDir);
   for (const projectDir of projectDirs) {
     const chatsDir = join4(projectDir, "chats");
@@ -2339,7 +2731,7 @@ async function ingestGemini(db, verbose) {
           request_count: 0,
           machine_id: machineId
         };
-        upsertSession(db, session);
+        upsertSession(db, withAccount(session, account));
         totalSessions++;
       }
       touchedSessions.add(sessionId);
@@ -2363,7 +2755,7 @@ async function ingestGemini(db, verbose) {
         const costUsd = numberField(message.costUsd, message.cost_usd) || computedCost;
         const timestamp = message.timestamp ?? chatData.lastUpdated ?? startTime;
         const requestId = `gemini-${sessionId}-${message.id ?? index}`;
-        upsertRequest(db, {
+        upsertRequest(db, withAccount({
           id: requestId,
           agent: "gemini",
           session_id: sessionId,
@@ -2378,7 +2770,7 @@ async function ingestGemini(db, verbose) {
           timestamp,
           source_request_id: message.id ?? requestId,
           machine_id: machineId
-        });
+        }, account));
         totalRequests++;
       }
       setIngestState(db, "gemini", stateKey, fileMtime);
@@ -2427,6 +2819,7 @@ async function ingestOpenCode(db, verbose = false) {
   const touched = new Set;
   const machineId = getMachineId();
   const now = new Date().toISOString();
+  const account = await resolveAccountForAgent("opencode");
   for (const file of files) {
     const mtime = statSync4(file).mtimeMs;
     const stateKey = file;
@@ -2456,7 +2849,7 @@ async function ingestOpenCode(db, verbose = false) {
     const sourceId = file.replace(OPENCODE_STORAGE, "");
     const reqId = `opencode-${sourceId}`;
     const costUsd = usage.cost ?? computeCostFromDb(db, model, input, output, cacheRead, cacheWrite, 0);
-    upsertRequest(db, {
+    upsertRequest(db, withAccount({
       id: reqId,
       agent: "opencode",
       session_id: sessionId,
@@ -2472,10 +2865,10 @@ async function ingestOpenCode(db, verbose = false) {
       source_request_id: sourceId,
       machine_id: machineId,
       updated_at: now
-    });
+    }, account));
     requests++;
     if (!touched.has(sessionId)) {
-      upsertSession(db, {
+      upsertSession(db, withAccount({
         id: sessionId,
         agent: "opencode",
         project_path: "",
@@ -2487,7 +2880,7 @@ async function ingestOpenCode(db, verbose = false) {
         request_count: 0,
         machine_id: machineId,
         updated_at: now
-      });
+      }, account));
       touched.add(sessionId);
     }
     setIngestState(db, "opencode", stateKey, String(mtime));
@@ -2534,6 +2927,7 @@ async function ingestCursor(db, verbose = false) {
   const machineId = getMachineId();
   const now = new Date().toISOString();
   let snapshots = 0;
+  const account = await resolveAccountForAgent("cursor");
   const usage = await cursorFetch("/api/usage", token);
   if (usage?.premiumRequests != null && usage.maxPremiumRequests) {
     upsertUsageSnapshot(db, {
@@ -2581,7 +2975,7 @@ async function ingestCursor(db, verbose = false) {
   }
   const sessionId = `cursor-${today}-${machineId}`;
   if (onDemand + included > 0) {
-    upsertSession(db, {
+    upsertSession(db, withAccount({
       id: sessionId,
       agent: "cursor",
       project_path: "",
@@ -2593,8 +2987,8 @@ async function ingestCursor(db, verbose = false) {
       request_count: 1,
       machine_id: machineId,
       updated_at: now
-    });
-    upsertRequest(db, {
+    }, account));
+    upsertRequest(db, withAccount({
       id: `cursor-${today}-${machineId}-usage`,
       agent: "cursor",
       session_id: sessionId,
@@ -2610,7 +3004,7 @@ async function ingestCursor(db, verbose = false) {
       source_request_id: today,
       machine_id: machineId,
       updated_at: now
-    });
+    }, account));
     rollupSession(db, sessionId);
   }
   setIngestState(db, "cursor", `sync-${today}`, now);
@@ -2643,6 +3037,7 @@ async function ingestPi(db, verbose = false) {
   const touched = new Set;
   const machineId = getMachineId();
   const now = new Date().toISOString();
+  const account = await resolveAccountForAgent("pi");
   for (const file of files) {
     const mtime = statSync5(file).mtimeMs;
     const prev = getIngestState(db, "pi", file);
@@ -2668,7 +3063,7 @@ async function ingestPi(db, verbose = false) {
       const model = turn.model ?? turn.provider ?? "unknown";
       const timestamp = turn.timestamp ?? new Date(statSync5(file).mtime).toISOString();
       const reqId = `pi-${sessionId}-${i}`;
-      upsertRequest(db, {
+      upsertRequest(db, withAccount({
         id: reqId,
         agent: "pi",
         session_id: sessionId,
@@ -2684,11 +3079,11 @@ async function ingestPi(db, verbose = false) {
         source_request_id: `${sessionId}-${i}`,
         machine_id: machineId,
         updated_at: now
-      });
+      }, account));
       requests++;
     }
     if (turns.length > 0) {
-      upsertSession(db, {
+      upsertSession(db, withAccount({
         id: sessionId,
         agent: "pi",
         project_path: "",
@@ -2700,7 +3095,7 @@ async function ingestPi(db, verbose = false) {
         request_count: 0,
         machine_id: machineId,
         updated_at: now
-      });
+      }, account));
       touched.add(sessionId);
     }
     setIngestState(db, "pi", file, String(mtime));
@@ -2748,13 +3143,14 @@ async function ingestHermes(db, verbose = false) {
   const machineId = getMachineId();
   const now = new Date().toISOString();
   let requests = 0;
+  const account = await resolveAccountForAgent("hermes");
   for (const row of rows) {
     const sessionId = `hermes-${row.id}`;
     const startedAt = new Date(row.started_at * 1000).toISOString();
     const endedAt = row.ended_at ? new Date(row.ended_at * 1000).toISOString() : null;
     const cost = row.actual_cost_usd ?? row.estimated_cost_usd ?? 0;
     const tokens = row.input_tokens + row.output_tokens + row.cache_read_tokens + row.cache_write_tokens + row.reasoning_tokens;
-    upsertSession(db, {
+    upsertSession(db, withAccount({
       id: sessionId,
       agent: "hermes",
       project_path: row.source ?? "",
@@ -2766,9 +3162,9 @@ async function ingestHermes(db, verbose = false) {
       request_count: 1,
       machine_id: machineId,
       updated_at: now
-    });
+    }, account));
     const reqId = `hermes-${row.id}-rollup`;
-    upsertRequest(db, {
+    upsertRequest(db, withAccount({
       id: reqId,
       agent: "hermes",
       session_id: sessionId,
@@ -2784,7 +3180,7 @@ async function ingestHermes(db, verbose = false) {
       source_request_id: row.id,
       machine_id: machineId,
       updated_at: now
-    });
+    }, account));
     requests++;
     rollupSession(db, sessionId);
     if (verbose)
@@ -2804,7 +3200,7 @@ function statSyncSafe(path) {
 
 // src/ingest/claude-quota.ts
 init_database();
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
 
 // src/lib/paths.ts
 import { homedir as homedir8 } from "os";
@@ -2842,7 +3238,7 @@ function readClaudeToken() {
   if (!existsSync8(CREDENTIALS_PATH))
     return null;
   try {
-    const creds = JSON.parse(readFileSync7(CREDENTIALS_PATH, "utf-8"));
+    const creds = JSON.parse(readFileSync6(CREDENTIALS_PATH, "utf-8"));
     const oauth = creds.claudeAiOauth;
     if (!oauth?.accessToken)
       return null;
@@ -2978,7 +3374,7 @@ async function ingestClaudeQuota(db, verbose = false) {
 
 // src/ingest/codex-quota.ts
 init_database();
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 var WHAM_USAGE_URL = process.env["CODEX_USAGE_URL"] ?? "https://chatgpt.com/backend-api/wham/usage";
 function readCodexAuth() {
   const fromEnv = process.env["CODEX_OAUTH_TOKEN"];
@@ -2988,7 +3384,7 @@ function readCodexAuth() {
   if (!existsSync9(authPath))
     return null;
   try {
-    const auth = JSON.parse(readFileSync8(authPath, "utf-8"));
+    const auth = JSON.parse(readFileSync7(authPath, "utf-8"));
     const token = auth.tokens?.access_token;
     if (!token)
       return null;
@@ -3122,12 +3518,12 @@ init_database();
 init_database();
 
 // src/lib/package-metadata.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 var cachedMetadata = null;
 function getPackageMetadata() {
   if (cachedMetadata)
     return cachedMetadata;
-  const raw = readFileSync9(new URL("../../package.json", import.meta.url), "utf8");
+  const raw = readFileSync8(new URL("../../package.json", import.meta.url), "utf8");
   const parsed = JSON.parse(raw);
   cachedMetadata = {
     name: parsed.name ?? "@hasna/economy",
@@ -3179,44 +3575,27 @@ async function runCloudMigrations(cloud) {
     await cloud.run(sql);
   }
 }
-function isCloudIncrementalEnabled() {
-  return process.env["ECONOMY_CLOUD_INCREMENTAL"] === "1" || process.env["ECONOMY_CLOUD_INCREMENTAL"] === "true";
-}
 async function cloudPush(opts) {
-  const { syncPush, incrementalSyncPush, ensureSyncMetaTable, SqliteAdapter } = await import("@hasna/cloud");
+  const { syncPush, SqliteAdapter } = await import("@hasna/cloud");
   const cloud = await getCloudPg();
   const local = new SqliteAdapter(getDbPath());
   await runCloudMigrations(cloud);
   const tables = opts?.tables ?? [...CLOUD_TABLES];
-  let rows = 0;
-  if (isCloudIncrementalEnabled()) {
-    ensureSyncMetaTable(local);
-    const results = incrementalSyncPush(local, cloud, tables, { conflictColumn: "updated_at" });
-    rows = results.reduce((s, r) => s + r.synced_rows, 0);
-  } else {
-    const results = await syncPush(local, cloud, { tables, conflictColumn: "updated_at" });
-    rows = results.reduce((s, r) => s + r.rowsWritten, 0);
-  }
+  const results = await syncPush(local, cloud, { tables, conflictColumn: "updated_at" });
+  const rows = results.reduce((s, r) => s + r.rowsWritten, 0);
   touchMachineRegistry(local, "push");
   local.close();
   await cloud.close();
   return { rows, machine: getMachineId() };
 }
 async function cloudPull(opts) {
-  const { syncPull, incrementalSyncPull, ensureSyncMetaTable, SqliteAdapter } = await import("@hasna/cloud");
+  const { syncPull, SqliteAdapter } = await import("@hasna/cloud");
   const cloud = await getCloudPg();
   const local = new SqliteAdapter(getDbPath());
   await runCloudMigrations(cloud);
   const tables = opts?.tables ?? [...CLOUD_TABLES];
-  let rows = 0;
-  if (isCloudIncrementalEnabled()) {
-    ensureSyncMetaTable(local);
-    const results = incrementalSyncPull(cloud, local, tables, { conflictColumn: "updated_at" });
-    rows = results.reduce((s, r) => s + r.synced_rows, 0);
-  } else {
-    const results = await syncPull(cloud, local, { tables, conflictColumn: "updated_at" });
-    rows = results.reduce((s, r) => s + r.rowsWritten, 0);
-  }
+  const results = await syncPull(cloud, local, { tables, conflictColumn: "updated_at" });
+  const rows = results.reduce((s, r) => s + r.rowsWritten, 0);
   touchMachineRegistry(local, "pull");
   local.close();
   await cloud.close();
@@ -3526,6 +3905,7 @@ function createHandler(db) {
       const project = url.searchParams.get("project") ?? undefined;
       const search = url.searchParams.get("search") ?? undefined;
       const machine = url.searchParams.get("machine") ?? undefined;
+      const account = url.searchParams.get("account") ?? undefined;
       const limit = Number(url.searchParams.get("limit") ?? 50);
       const offset = Number(url.searchParams.get("offset") ?? 0);
       const since = url.searchParams.get("since") ?? undefined;
@@ -3536,6 +3916,7 @@ function createHandler(db) {
         project,
         search,
         machine,
+        account,
         limit,
         offset,
         since
@@ -3586,11 +3967,23 @@ function createHandler(db) {
       return ok(results);
     }
     if (path === "/api/projects" && method === "GET") {
-      return ok(queryProjectBreakdown(db));
+      const period = url.searchParams.get("period") ?? "all";
+      return ok(queryProjectBreakdown(db, period));
+    }
+    if (path === "/api/accounts" && method === "GET") {
+      const period = url.searchParams.get("period") ?? "all";
+      return ok(queryAccountBreakdown(db, period));
     }
     if (path === "/api/breakdown" && method === "GET") {
       const by = url.searchParams.get("by") ?? "model";
-      return ok(by === "project" ? queryProjectBreakdown(db) : queryModelBreakdown(db));
+      const period = url.searchParams.get("period") ?? "all";
+      if (by === "project")
+        return ok(queryProjectBreakdown(db, period));
+      if (by === "agent")
+        return ok(queryAgentBreakdown(db, period));
+      if (by === "account")
+        return ok(queryAccountBreakdown(db, period));
+      return ok(queryModelBreakdown(db));
     }
     if (path === "/api/budgets" && method === "GET") {
       return ok(getBudgetStatuses(db));
@@ -3725,6 +4118,50 @@ function createHandler(db) {
       const agent = url.searchParams.get("agent") ?? undefined;
       return ok(querySavingsSummary(db, period, agent && isAgent(agent) ? agent : undefined));
     }
+    if (path === "/api/subscriptions" && method === "GET") {
+      return ok(listSubscriptions(db));
+    }
+    if (path === "/api/subscriptions" && method === "POST") {
+      const body = await jsonBody(req);
+      if (!body)
+        return err("invalid JSON body");
+      const provider = optionalString(body["provider"])?.trim();
+      const plan = optionalString(body["plan"])?.trim();
+      if (!provider)
+        return err("provider is required");
+      if (!plan)
+        return err("plan is required");
+      const monthlyFee = finiteNumber(body["monthly_fee_usd"] ?? body["fee_usd"] ?? 0);
+      const includedUsage = finiteNumber(body["included_usage_usd"] ?? 0);
+      if (monthlyFee == null || monthlyFee < 0)
+        return err("monthly_fee_usd must be a non-negative number");
+      if (includedUsage == null || includedUsage < 0)
+        return err("included_usage_usd must be a non-negative number");
+      const agent = optionalAgent(body["agent"]);
+      if (agent === undefined)
+        return err(AGENT_ERROR);
+      const now = new Date().toISOString();
+      const subscription = {
+        id: optionalString(body["id"])?.trim() || randomUUID(),
+        agent,
+        provider,
+        plan,
+        monthly_fee_usd: monthlyFee,
+        included_usage_usd: includedUsage,
+        billing_cycle_start: optionalString(body["billing_cycle_start"]),
+        reset_policy: optionalString(body["reset_policy"]) ?? "monthly",
+        active: body["active"] === false || body["active"] === 0 ? 0 : 1,
+        created_at: optionalString(body["created_at"]) ?? now,
+        updated_at: now
+      };
+      upsertSubscription(db, subscription);
+      return ok(subscription);
+    }
+    const subscriptionMatch = path.match(/^\/api\/subscriptions\/(.+)$/);
+    if (subscriptionMatch && method === "DELETE") {
+      deleteSubscription(db, decodeURIComponent(subscriptionMatch[1]));
+      return ok({ ok: true });
+    }
     const sessionRequestsMatch = path.match(/^\/api\/sessions\/([^/]+)\/requests$/);
     if (sessionRequestsMatch && method === "GET") {
       const sessionId = decodeURIComponent(sessionRequestsMatch[1]);