@hasna/economy 0.2.21 → 0.2.23

package/dist/index.js

@@ -582,7 +582,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 (
@@ -595,7 +600,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 (
@@ -750,6 +760,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 ''`);
@@ -761,6 +776,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`);
@@ -771,6 +791,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) {
@@ -805,6 +827,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(`
@@ -812,18 +850,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(`
@@ -834,9 +874,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 = [];
@@ -849,6 +904,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);
@@ -913,6 +973,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;
@@ -931,11 +1055,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) {
@@ -974,6 +1100,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
@@ -1511,6 +1718,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 + "/"));
@@ -1552,6 +1884,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 = join3(projectsDir, projectDirEntry.name);
@@ -1615,7 +1948,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,
@@ -1632,7 +1965,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) {
@@ -1650,7 +1983,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);
         }
@@ -1695,7 +2028,7 @@ import { join as join4, basename as basename2 } from "path";
 import { Database as BunDatabase } from "bun:sqlite";
 var DEFAULT_CODEX_DB_PATH = join4(homedir3(), ".codex", "state_5.sqlite");
 var DEFAULT_CODEX_CONFIG_PATH = join4(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;
 }
@@ -1728,8 +2061,9 @@ function buildThreadQuery(codexDb) {
 function readTokenEvents(rolloutPath) {
   if (!rolloutPath || !existsSync4(rolloutPath))
     return [];
-  const events = [];
-  const seen = new Set;
+  const fallbackUsages = new Map;
+  let fallbackTimestamp;
+  let aggregate = null;
   for (const line of readFileSync3(rolloutPath, "utf-8").split(`
 `)) {
     if (!line.trim())
@@ -1746,20 +2080,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);
@@ -1783,6 +2145,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();
@@ -1797,7 +2160,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,
@@ -1808,9 +2171,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;
@@ -1821,7 +2185,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,
@@ -1836,14 +2200,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();
@@ -1909,6 +2273,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 = join5(projectDir, "chats");
@@ -1957,7 +2322,7 @@ async function ingestGemini(db, verbose) {
           request_count: 0,
           machine_id: machineId
         };
-        upsertSession(db, session);
+        upsertSession(db, withAccount(session, account));
         totalSessions++;
       }
       touchedSessions.add(sessionId);
@@ -1981,7 +2346,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,
@@ -1996,7 +2361,7 @@ async function ingestGemini(db, verbose) {
           timestamp,
           source_request_id: message.id ?? requestId,
           machine_id: machineId
-        });
+        }, account));
         totalRequests++;
       }
       setIngestState(db, "gemini", stateKey, fileMtime);
@@ -2032,6 +2397,8 @@ export {
   queryModelBreakdown,
   queryDailyBreakdown,
   queryBillingSummary,
+  queryAgentBreakdown,
+  queryAccountBreakdown,
   openDatabase,
   normalizeModelName,
   listSubscriptions,

package/dist/ingest/claude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/ingest/claude.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAW7D,OAAO,KAAK,EAAkB,KAAK,EAAE,MAAM,mBAAmB,CAAA;AA+D9D,wBAAsB,YAAY,CAChC,EAAE,EAAE,QAAQ,EACZ,OAAO,UAAQ,EACf,WAAW,SAAsB,GAChC,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAEhE;AAED,wBAAsB,YAAY,CAChC,EAAE,EAAE,QAAQ,EACZ,OAAO,UAAQ,EACf,WAAW,SAAsB,GAChC,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAEhE;AAED,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,KAAK,EAChB,OAAO,UAAQ,GACd,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAwIhE"}
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/ingest/claude.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAY7D,OAAO,KAAK,EAAkB,KAAK,EAAE,MAAM,mBAAmB,CAAA;AA+D9D,wBAAsB,YAAY,CAChC,EAAE,EAAE,QAAQ,EACZ,OAAO,UAAQ,EACf,WAAW,SAAsB,GAChC,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAEhE;AAED,wBAAsB,YAAY,CAChC,EAAE,EAAE,QAAQ,EACZ,OAAO,UAAQ,EACf,WAAW,SAAsB,GAChC,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAEhE;AAED,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,KAAK,EAChB,OAAO,UAAQ,GACd,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAyIhE"}

package/dist/ingest/codex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/ingest/codex.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AA4C7D,iBAAS,cAAc,IAAI,MAAM,CAUhC;AAsDD,wBAAsB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA0FhH;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/ingest/codex.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AA6C7D,iBAAS,cAAc,IAAI,MAAM,CAUhC;AAoFD,wBAAsB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA4FhH;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/ingest/cursor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/ingest/cursor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAsC7D,wBAAsB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAoGlH"}
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/ingest/cursor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAsC7D,wBAAsB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAqGlH"}