@hasna/economy 0.2.27 → 0.2.29

package/dist/cli/index.js

@@ -534,6 +534,7 @@ __export(exports_database, {
   queryRequestsSince: () => queryRequestsSince,
   queryProjectBreakdown: () => queryProjectBreakdown,
   queryModelBreakdown: () => queryModelBreakdown,
+  queryHourlyBreakdown: () => queryHourlyBreakdown,
   queryDailyBreakdown: () => queryDailyBreakdown,
   queryBillingSummary: () => queryBillingSummary,
   queryAgentBreakdown: () => queryAgentBreakdown,
@@ -615,6 +616,26 @@ function openDatabase(dbPath, skipSeed = false) {
   }
   return db;
 }
+function quoteSqlIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function hasColumn(db, table, column) {
+  const columns = db.prepare(`PRAGMA table_info(${quoteSqlIdent(table)})`).all();
+  return columns.some((c) => c.name === column);
+}
+function addColumnIfMissing(db, table, column, definition) {
+  if (hasColumn(db, table, column))
+    return false;
+  try {
+    db.exec(`ALTER TABLE ${quoteSqlIdent(table)} ADD COLUMN ${quoteSqlIdent(column)} ${definition}`);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/duplicate column name/i.test(message))
+      return true;
+    throw error;
+  }
+}
 function initSchema(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS requests (
@@ -785,59 +806,31 @@ function initSchema(db) {
     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);
   `);
-  const cols = db.prepare(`PRAGMA table_info(requests)`).all();
-  if (!cols.some((c) => c.name === "machine_id")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN machine_id TEXT DEFAULT ''`);
-    db.exec(`ALTER TABLE sessions ADD COLUMN machine_id TEXT DEFAULT ''`);
-  }
-  if (!cols.some((c) => c.name === "cache_create_5m_tokens")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN cache_create_5m_tokens INTEGER DEFAULT 0`);
+  addColumnIfMissing(db, "requests", "machine_id", `TEXT DEFAULT ''`);
+  addColumnIfMissing(db, "sessions", "machine_id", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "requests", "cache_create_5m_tokens", "INTEGER DEFAULT 0")) {
     db.exec(`UPDATE requests SET cache_create_5m_tokens = cache_create_tokens WHERE cache_create_5m_tokens = 0`);
   }
-  if (!cols.some((c) => c.name === "cache_create_1h_tokens")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN cache_create_1h_tokens INTEGER DEFAULT 0`);
-  }
-  if (!cols.some((c) => c.name === "cost_basis")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN cost_basis TEXT DEFAULT 'estimated'`);
-  }
-  if (!cols.some((c) => c.name === "attribution_tag")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN attribution_tag TEXT DEFAULT ''`);
-  }
-  if (!cols.some((c) => c.name === "updated_at")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN updated_at TEXT DEFAULT ''`);
+  addColumnIfMissing(db, "requests", "cache_create_1h_tokens", "INTEGER DEFAULT 0");
+  addColumnIfMissing(db, "requests", "cost_basis", `TEXT DEFAULT 'estimated'`);
+  addColumnIfMissing(db, "requests", "attribution_tag", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "requests", "updated_at", `TEXT DEFAULT ''`)) {
     db.exec(`UPDATE requests SET updated_at = timestamp WHERE updated_at = '' OR updated_at IS NULL`);
   }
-  if (!cols.some((c) => c.name === "synced_at")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN synced_at TEXT DEFAULT ''`);
-  }
+  addColumnIfMissing(db, "requests", "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 ''`);
-    }
+    addColumnIfMissing(db, "requests", 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 ''`);
-  }
-  if (!sessionCols.some((c) => c.name === "updated_at")) {
-    db.exec(`ALTER TABLE sessions ADD COLUMN updated_at TEXT DEFAULT ''`);
+  addColumnIfMissing(db, "sessions", "attribution_tag", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "sessions", "updated_at", `TEXT DEFAULT ''`)) {
     db.exec(`UPDATE sessions SET updated_at = started_at WHERE updated_at = '' OR updated_at IS NULL`);
   }
-  if (!sessionCols.some((c) => c.name === "synced_at")) {
-    db.exec(`ALTER TABLE sessions ADD COLUMN synced_at TEXT DEFAULT ''`);
-  }
+  addColumnIfMissing(db, "sessions", "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`);
-  }
-  if (!pricingCols.some((c) => c.name === "cache_storage_per_1m_hour")) {
-    db.exec(`ALTER TABLE model_pricing ADD COLUMN cache_storage_per_1m_hour REAL NOT NULL DEFAULT 0`);
+    addColumnIfMissing(db, "sessions", column, `TEXT DEFAULT ''`);
   }
+  addColumnIfMissing(db, "model_pricing", "cache_write_1h_per_1m", "REAL NOT NULL DEFAULT 0");
+  addColumnIfMissing(db, "model_pricing", "cache_storage_per_1m_hour", "REAL NOT NULL DEFAULT 0");
   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);
@@ -998,17 +991,22 @@ function querySummary(db, period, machine, allMachines = false) {
   const codexTotals = db.prepare(`
     SELECT COALESCE(SUM(total_cost_usd), 0) as cost_usd,
            COALESCE(SUM(total_tokens), 0) as tokens,
+           COALESCE(SUM(request_count), 0) as requests,
            COUNT(*) as sessions
     FROM sessions
     WHERE ${sWhere}${machineClause}
     AND id NOT IN (SELECT DISTINCT session_id FROM requests)
   `).get();
-  const sessionCount = db.prepare(`SELECT COUNT(*) as sessions FROM sessions WHERE ${sWhere}${machineClause}`).get();
+  const requestSessionCount = db.prepare(`
+    SELECT COUNT(DISTINCT session_id) as sessions
+    FROM requests
+    WHERE ${rWhere}${machineClause}
+  `).get();
   return {
     total_usd: r.total_usd + codexTotals.cost_usd,
-    requests: r.requests,
+    requests: r.requests + codexTotals.requests,
     tokens: r.tokens + codexTotals.tokens,
-    sessions: sessionCount.sessions,
+    sessions: requestSessionCount.sessions + codexTotals.sessions,
     period
   };
 }
@@ -1023,8 +1021,10 @@ function queryModelBreakdown(db) {
     FROM requests GROUP BY model, agent ORDER BY cost_usd DESC
   `).all();
 }
-function queryAgentBreakdown(db, period = "all") {
+function queryAgentBreakdown(db, period = "all", machine) {
   const requestWhere = requestPeriodWhere(period);
+  const machineClause = machine ? " AND machine_id = ?" : "";
+  const machineParams = machine ? [machine] : [];
   const groups = new Map;
   const requestRows = db.prepare(`
     SELECT agent,
@@ -1040,10 +1040,10 @@ function queryAgentBreakdown(db, period = "all") {
            COALESCE(SUM(cost_usd), 0) as cost_usd,
            MAX(timestamp) as last_active
     FROM requests
-    WHERE ${requestWhere}
+    WHERE ${requestWhere}${machineClause}
     GROUP BY agent
     ORDER BY api_equivalent_usd DESC
-  `).all();
+  `).all(...machineParams);
   for (const row of requestRows) {
     groups.set(row.agent, row);
   }
@@ -1056,10 +1056,10 @@ function queryAgentBreakdown(db, period = "all") {
            COALESCE(SUM(total_cost_usd), 0) as cost_usd,
            MAX(started_at) as last_active
     FROM sessions
-    WHERE ${sessionWhere}
+    WHERE ${sessionWhere}${machineClause}
       AND id NOT IN (SELECT DISTINCT session_id FROM requests)
     GROUP BY agent
-  `).all();
+  `).all(...machineParams);
   for (const row of sessionOnlyRows) {
     const existing = groups.get(row.agent) ?? {
       agent: row.agent,
@@ -1136,14 +1136,20 @@ function labelForPath(projectPath, projectName) {
 function groupKeyForPath(projectPath, projectName) {
   return labelForPath(projectPath, projectName).trim().toLowerCase();
 }
-function queryProjectBreakdown(db, period = "all") {
+function queryProjectBreakdown(db, period = "all", machine) {
   const requestWhere = requestPeriodWhere(period);
   const sessionWhere = sessionPeriodWhere(period);
+  const sessionMachineClause = machine ? " AND (machine_id = ? OR id IN (SELECT DISTINCT session_id FROM requests WHERE machine_id = ?))" : "";
+  const requestMachineClause = machine ? " AND machine_id = ?" : "";
+  const sessionMachineParams = machine ? [machine, machine] : [];
+  const requestMachineParams = machine ? [machine] : [];
+  const sessionOnlyMachineClause = machine ? " AND machine_id = ?" : "";
+  const sessionOnlyMachineParams = machine ? [machine] : [];
   const sessions = db.prepare(`
     SELECT id, project_path, project_name, total_cost_usd, started_at
     FROM sessions
-    WHERE project_path != '' OR project_name != ''
-  `).all();
+    WHERE (project_path != '' OR project_name != '')${sessionMachineClause}
+  `).all(...sessionMachineParams);
   const groups = new Map;
   for (const s of sessions) {
     const label = labelForPath(s.project_path, s.project_name);
@@ -1169,7 +1175,8 @@ function queryProjectBreakdown(db, period = "all") {
           FROM requests
           WHERE session_id IN (${placeholders})
             AND ${requestWhere}
-        `).get(...g.sessionIds) : { sessions: 0, requests: 0, cost_usd: 0, total_tokens: 0, last_active: null };
+            ${requestMachineClause}
+        `).get(...g.sessionIds, ...requestMachineParams) : { sessions: 0, requests: 0, cost_usd: 0, total_tokens: 0, last_active: null };
     const sessionOnlyStats = placeholders.length ? db.prepare(`
           SELECT
             COUNT(*) as sessions,
@@ -1180,8 +1187,9 @@ function queryProjectBreakdown(db, period = "all") {
           FROM sessions
           WHERE id IN (${placeholders})
             AND ${sessionWhere}
+            ${sessionOnlyMachineClause}
             AND id NOT IN (SELECT DISTINCT session_id FROM requests)
-        `).get(...g.sessionIds) : { sessions: 0, requests: 0, total_tokens: 0, cost_usd: 0, last_active: null };
+        `).get(...g.sessionIds, ...sessionOnlyMachineParams) : { sessions: 0, requests: 0, total_tokens: 0, cost_usd: 0, last_active: null };
     const totalSessions = reqStats.sessions + sessionOnlyStats.sessions;
     if (totalSessions === 0)
       continue;
@@ -1199,107 +1207,167 @@ function queryProjectBreakdown(db, period = "all") {
   result.sort((a, b) => b.cost_usd - a.cost_usd);
   return result;
 }
-function queryAccountBreakdown(db, period = "all") {
+function normalizeAccountEmail(email) {
+  return (email ?? "").trim().toLowerCase();
+}
+function accountIdentityKey(agent, accountKey, accountName, accountEmail) {
+  const identityAgent = (agent || "").trim();
+  const normalizedEmail = normalizeAccountEmail(accountEmail);
+  if (identityAgent && normalizedEmail)
+    return `${identityAgent}:${normalizedEmail}`;
+  if (identityAgent && accountName)
+    return `${identityAgent}:${accountName}`;
+  if (accountKey)
+    return accountKey;
+  return identityAgent ? `${identityAgent}:unknown` : "";
+}
+function addAccountBreakdownRow(groups, row, sessionOnly) {
+  const agent = row.agent || row.account_tool;
+  const email = normalizeAccountEmail(row.account_email);
+  const accountName = row.account_name || email || row.account_key;
+  const key = accountIdentityKey(agent, row.account_key, accountName, email);
+  if (!key)
+    return;
+  const group = groups.get(key) ?? {
+    account_key: key,
+    account_tool: agent,
+    account_name: accountName,
+    account_email: email || null,
+    account_source: row.account_source || "unknown",
+    sessionIds: new Set,
+    requests: 0,
+    total_tokens: 0,
+    api_equivalent_usd: 0,
+    metered_api_usd: 0,
+    subscription_included_usd: 0,
+    estimated_usd: 0,
+    unknown_usd: 0,
+    last_active: ""
+  };
+  if (!group.account_email && email)
+    group.account_email = email;
+  if (!group.account_name && accountName)
+    group.account_name = accountName;
+  if ((!group.account_source || group.account_source === "unknown") && row.account_source && row.account_source !== "unknown") {
+    group.account_source = row.account_source;
+  }
+  if (row.session_id)
+    group.sessionIds.add(row.session_id);
+  group.requests += row.requests;
+  group.total_tokens += row.total_tokens;
+  group.api_equivalent_usd += row.cost_usd;
+  if (sessionOnly) {
+    group.estimated_usd += row.cost_usd;
+  } else if (row.cost_basis === "metered_api") {
+    group.metered_api_usd += row.cost_usd;
+  } else if (row.cost_basis === "subscription_included") {
+    group.subscription_included_usd += row.cost_usd;
+  } else if (row.cost_basis === "unknown") {
+    group.unknown_usd += row.cost_usd;
+  } else {
+    group.estimated_usd += row.cost_usd;
+  }
+  if (!group.last_active || row.last_active > group.last_active)
+    group.last_active = row.last_active;
+  groups.set(key, group);
+}
+function queryAccountBreakdown(db, period = "all", machine) {
   const requestWhere = requestPeriodWhere(period);
   const sessionWhere = 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 account_key != '' OR account_tool != '' OR account_name != '' OR account_email != ''
-  `).all();
+  const requestMachineClause = machine ? " AND r.machine_id = ?" : "";
+  const sessionMachineClause = machine ? " AND s.machine_id = ?" : "";
+  const requestMachineParams = machine ? [machine] : [];
+  const sessionMachineParams = machine ? [machine] : [];
   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"
-    };
-    group.sessionIds.push(session.id);
-    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(DISTINCT session_id) as sessions,
-            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,
-            MAX(timestamp) as last_active
-          FROM requests
-          WHERE session_id IN (${placeholders})
-            AND ${requestWhere}
-        `).get(...group.sessionIds) : {
-      sessions: 0,
-      requests: 0,
-      cost_usd: 0,
-      total_tokens: 0,
-      metered_api_usd: 0,
-      subscription_included_usd: 0,
-      estimated_usd: 0,
-      unknown_usd: 0,
-      last_active: null
-    };
-    const sessionOnlyStats = placeholders ? db.prepare(`
-          SELECT
-            COUNT(*) as sessions,
-            COALESCE(SUM(request_count), 0) as requests,
-            COALESCE(SUM(total_tokens), 0) as total_tokens,
-            COALESCE(SUM(total_cost_usd), 0) as cost_usd,
-            MAX(started_at) as last_active
-          FROM sessions
-          WHERE id IN (${placeholders})
-            AND ${sessionWhere}
-            AND id NOT IN (SELECT DISTINCT session_id FROM requests)
-        `).get(...group.sessionIds) : { sessions: 0, requests: 0, total_tokens: 0, cost_usd: 0, last_active: null };
-    const sessionsTotal = reqStats.sessions + sessionOnlyStats.sessions;
-    if (sessionsTotal === 0)
-      continue;
-    const apiEquivalentUsd = reqStats.cost_usd + sessionOnlyStats.cost_usd;
-    const estimatedUsd = reqStats.estimated_usd + sessionOnlyStats.cost_usd;
-    const billableUsd = reqStats.metered_api_usd;
-    const lastActive = [reqStats.last_active, sessionOnlyStats.last_active].filter(Boolean).sort().at(-1) ?? "";
-    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: sessionsTotal,
-      requests: reqStats.requests + sessionOnlyStats.requests,
-      total_tokens: reqStats.total_tokens + sessionOnlyStats.total_tokens,
-      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: lastActive
-    });
-  }
+  const requestRows = db.prepare(`
+    SELECT
+      r.session_id as session_id,
+      COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), '') as agent,
+      COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') as account_key,
+      COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') as account_tool,
+      COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') as account_name,
+      COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') as account_email,
+      COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown') as account_source,
+      1 as requests,
+      COALESCE(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens, 0) as total_tokens,
+      COALESCE(r.cost_usd, 0) as cost_usd,
+      COALESCE(NULLIF(r.cost_basis, ''), 'estimated') as cost_basis,
+      r.timestamp as last_active
+    FROM requests r
+    LEFT JOIN sessions s ON s.id = r.session_id
+    WHERE ${requestWhere}${requestMachineClause}
+      AND (
+        COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') != ''
+        OR COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') != ''
+        OR COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') != ''
+        OR COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') != ''
+      )
+  `).all(...requestMachineParams);
+  for (const row of requestRows)
+    addAccountBreakdownRow(groups, row, false);
+  const sessionOnlyRows = db.prepare(`
+    SELECT
+      s.id as session_id,
+      s.agent as agent,
+      s.account_key as account_key,
+      s.account_tool as account_tool,
+      s.account_name as account_name,
+      s.account_email as account_email,
+      COALESCE(NULLIF(s.account_source, ''), 'unknown') as account_source,
+      COALESCE(s.request_count, 0) as requests,
+      COALESCE(s.total_tokens, 0) as total_tokens,
+      COALESCE(s.total_cost_usd, 0) as cost_usd,
+      'estimated' as cost_basis,
+      s.started_at as last_active
+    FROM sessions s
+    WHERE ${sessionWhere}${sessionMachineClause}
+      AND s.id NOT IN (SELECT DISTINCT session_id FROM requests)
+      AND (s.account_key != '' OR s.account_tool != '' OR s.account_name != '' OR s.account_email != '')
+  `).all(...sessionMachineParams);
+  for (const row of sessionOnlyRows)
+    addAccountBreakdownRow(groups, row, true);
+  const result = [...groups.values()].map((group) => ({
+    account_key: group.account_key,
+    account_tool: group.account_tool,
+    account_name: group.account_name,
+    account_email: group.account_email,
+    account_source: group.account_source,
+    sessions: group.sessionIds.size,
+    requests: group.requests,
+    total_tokens: group.total_tokens,
+    api_equivalent_usd: group.api_equivalent_usd,
+    billable_usd: group.metered_api_usd,
+    metered_api_usd: group.metered_api_usd,
+    subscription_included_usd: group.subscription_included_usd,
+    estimated_usd: group.estimated_usd,
+    unknown_usd: group.unknown_usd,
+    cost_usd: group.api_equivalent_usd,
+    last_active: group.last_active
+  }));
   result.sort((a, b) => b.cost_usd - a.cost_usd);
   return result;
 }
-function queryDailyBreakdown(db, days = 30) {
+function queryDailyBreakdown(db, days = 30, machine) {
+  const machineClause = machine ? " AND machine_id = ?" : "";
+  const params = machine ? [`-${days}`, machine] : [`-${days}`];
   return db.prepare(`
     SELECT DATE(timestamp) as date, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
     FROM requests
-    WHERE timestamp >= DATE('now', ? || ' days')
+    WHERE timestamp >= DATE('now', ? || ' days')${machineClause}
     GROUP BY DATE(timestamp), agent
     ORDER BY date ASC
-  `).all(`-${days}`);
+  `).all(...params);
+}
+function queryHourlyBreakdown(db, machine) {
+  const machineClause = machine ? " AND machine_id = ?" : "";
+  const params = machine ? [machine] : [];
+  return db.prepare(`
+    SELECT STRFTIME('%H', timestamp) as hour, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM requests
+    WHERE DATE(timestamp) = DATE('now')${machineClause}
+    GROUP BY STRFTIME('%H', timestamp), agent
+    ORDER BY hour ASC
+  `).all(...params);
 }
 function upsertProject(db, project) {
   db.prepare(`
@@ -1428,17 +1496,48 @@ function queryBillingSummary(db, period) {
   }
   return { total_usd: total, by_provider };
 }
-function listMachines(db) {
+function listMachines(db, period = "all") {
+  const rWhere = requestPeriodWhere(period);
+  const sWhere = sessionPeriodWhere(period);
   return db.prepare(`
+    WITH request_stats AS (
+      SELECT
+        machine_id,
+        COUNT(DISTINCT session_id) as sessions,
+        COUNT(*) as requests,
+        COALESCE(SUM(cost_usd), 0) as total_cost_usd,
+        MAX(timestamp) as last_active
+      FROM requests
+      WHERE machine_id != ''
+        AND ${rWhere}
+      GROUP BY machine_id
+    ),
+    session_only_stats AS (
+      SELECT
+        machine_id,
+        COUNT(*) as sessions,
+        COALESCE(SUM(request_count), 0) as requests,
+        COALESCE(SUM(total_cost_usd), 0) as total_cost_usd,
+        MAX(started_at) as last_active
+      FROM sessions
+      WHERE machine_id != ''
+        AND ${sWhere}
+        AND id NOT IN (SELECT DISTINCT session_id FROM requests)
+      GROUP BY machine_id
+    ),
+    combined AS (
+      SELECT * FROM request_stats
+      UNION ALL
+      SELECT * FROM session_only_stats
+    )
     SELECT
-      s.machine_id,
-      COUNT(DISTINCT s.id) as sessions,
-      COALESCE((SELECT COUNT(*) FROM requests r WHERE r.machine_id = s.machine_id), 0) as requests,
-      COALESCE(SUM(s.total_cost_usd), 0) as total_cost_usd,
-      MAX(s.started_at) as last_active
-    FROM sessions s
-    WHERE s.machine_id != ''
-    GROUP BY s.machine_id
+      machine_id,
+      COALESCE(SUM(sessions), 0) as sessions,
+      COALESCE(SUM(requests), 0) as requests,
+      COALESCE(SUM(total_cost_usd), 0) as total_cost_usd,
+      MAX(last_active) as last_active
+    FROM combined
+    GROUP BY machine_id
     ORDER BY total_cost_usd DESC
   `).all();
 }
@@ -2331,18 +2430,22 @@ function agentPaths() {
 var init_paths = () => {};
 
 // src/lib/accounts.ts
-function accountKey(tool, name) {
-  return `${tool}:${name}`;
+function normalizeEmail(email) {
+  return (email ?? "").trim().toLowerCase();
+}
+function accountKey(tool, name, email) {
+  const normalizedEmail = normalizeEmail(email);
+  return `${tool}:${normalizedEmail || name}`;
 }
 function normalizeDir(value) {
   return value.replace(/\/+$/, "");
 }
 function fromProfile(profile, source) {
   return {
-    account_key: accountKey(profile.tool, profile.name),
+    account_key: accountKey(profile.tool, profile.name, profile.email),
     account_tool: profile.tool,
     account_name: profile.name,
-    ...profile.email ? { account_email: profile.email } : {},
+    ...profile.email ? { account_email: normalizeEmail(profile.email) } : {},
     account_source: source
   };
 }
@@ -2354,10 +2457,12 @@ function fromOverride(raw, agent) {
   const [tool, name] = value.includes(":") ? value.split(":", 2) : [candidateTool, value];
   if (!tool || !name)
     return null;
+  const email = name.includes("@") ? normalizeEmail(name) : undefined;
   return {
-    account_key: accountKey(tool, name),
+    account_key: accountKey(tool, name, email),
     account_tool: tool,
     account_name: name,
+    ...email ? { account_email: email } : {},
     account_source: "override"
   };
 }
@@ -2370,11 +2475,12 @@ function envOverride(agent, env) {
   const name = env[`ECONOMY_${agentPrefix}_ACCOUNT_NAME`] ?? env["ECONOMY_ACCOUNT_NAME"];
   if (!tool || !name)
     return null;
+  const email = normalizeEmail(env[`ECONOMY_${agentPrefix}_ACCOUNT_EMAIL`] ?? env["ECONOMY_ACCOUNT_EMAIL"]);
   return {
-    account_key: accountKey(tool, name),
+    account_key: accountKey(tool, name, email),
     account_tool: tool,
     account_name: name,
-    account_email: env[`ECONOMY_${agentPrefix}_ACCOUNT_EMAIL`] ?? env["ECONOMY_ACCOUNT_EMAIL"],
+    ...email ? { account_email: email } : {},
     account_source: "override"
   };
 }
@@ -4513,16 +4619,22 @@ function createHandler(db) {
     }
     if (path === "/api/fleet" && method === "GET") {
       const period = url.searchParams.get("period") ?? "month";
+      const machine = url.searchParams.get("machine") ?? undefined;
       return ok({
-        summary: querySummary(db, period, undefined, true),
-        machines: listMachines(db),
+        summary: querySummary(db, period, machine),
+        machines: listMachines(db, period),
         registry: listMachineRegistry(db),
         current_machine: getMachineId()
       });
     }
     if (path === "/api/daily" && method === "GET") {
       const days = Number(url.searchParams.get("days") ?? 30);
-      return ok(queryDailyBreakdown(db, days));
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok(queryDailyBreakdown(db, days, machine));
+    }
+    if (path === "/api/hourly" && method === "GET") {
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok(queryHourlyBreakdown(db, machine));
     }
     if (path === "/api/sessions" && method === "GET") {
       const agent = url.searchParams.get("agent");
@@ -4592,21 +4704,24 @@ function createHandler(db) {
     }
     if (path === "/api/projects" && method === "GET") {
       const period = url.searchParams.get("period") ?? "all";
-      return ok(queryProjectBreakdown(db, period));
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok(queryProjectBreakdown(db, period, machine));
     }
     if (path === "/api/accounts" && method === "GET") {
       const period = url.searchParams.get("period") ?? "all";
-      return ok(queryAccountBreakdown(db, period));
+      const machine = url.searchParams.get("machine") ?? undefined;
+      return ok(queryAccountBreakdown(db, period, machine));
     }
     if (path === "/api/breakdown" && method === "GET") {
       const by = url.searchParams.get("by") ?? "model";
       const period = url.searchParams.get("period") ?? "all";
+      const machine = url.searchParams.get("machine") ?? undefined;
       if (by === "project")
-        return ok(queryProjectBreakdown(db, period));
+        return ok(queryProjectBreakdown(db, period, machine));
       if (by === "agent")
-        return ok(queryAgentBreakdown(db, period));
+        return ok(queryAgentBreakdown(db, period, machine));
       if (by === "account")
-        return ok(queryAccountBreakdown(db, period));
+        return ok(queryAccountBreakdown(db, period, machine));
       return ok(queryModelBreakdown(db));
     }
     if (path === "/api/budgets" && method === "GET") {
@@ -6217,6 +6332,8 @@ var TOP_LEVEL = [
   "doctor",
   "init",
   "estimate",
+  "accounts",
+  "breakdown",
   "fleet",
   "merge-db",
   "todos",
@@ -6548,7 +6665,7 @@ function registerFleetCommands(program) {
     const db = openDatabase();
     const period = parsePeriod(opts.period, "today");
     const summary = querySummary(db, period, undefined, true);
-    const machines = listMachines(db);
+    const machines = listMachines(db, period);
     const registry = listMachineRegistry(db);
     if (opts.json) {
       console.log(JSON.stringify({ period, summary, machines, registry }, null, 2));
@@ -6987,6 +7104,22 @@ function printTable(headers, rows) {
   }
   console.log(`\u2514${sep2.replace(/\u253C/g, "\u2534")}\u2518`);
 }
+function accountDisplayName(row) {
+  return row.account_email || row.account_name || row.account_key || "unknown";
+}
+function printAccountBreakdown(rows) {
+  printTable(["Account", "Agent", "Source", "Sessions", "Requests", "Tokens", "API Eq", "Billable", "Included"], rows.map((r) => [
+    chalk7.white(accountDisplayName(r)),
+    fmtAgent(r.account_tool),
+    chalk7.dim(r.account_source || "unknown"),
+    String(r.sessions),
+    String(r.requests),
+    chalk7.cyan(fmtTokens(r.total_tokens)),
+    fmt4(r.api_equivalent_usd),
+    fmt4(r.billable_usd),
+    fmt4(r.subscription_included_usd)
+  ]));
+}
 function parseSinceDate(since) {
   const relMatch = since.match(/^(\d+)d$/);
   if (relMatch) {
@@ -7246,29 +7379,106 @@ program.command("breakdown").description("Cost breakdown by model, agent, projec
     ]));
   } else if (opts.by === "account") {
     const rows = sinceDate ? db.prepare(`
-          SELECT account_key, account_tool, account_name, account_email, account_source,
+          WITH request_rows AS (
+            SELECT
+              r.session_id as session_id,
+              COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), 'unknown') as account_agent,
+              COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') as raw_account_key,
+              COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') as raw_account_name,
+              LOWER(TRIM(COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), ''))) as raw_account_email,
+              COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown') as account_source,
+              1 as requests,
+              COALESCE(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens, 0) as total_tokens,
+              COALESCE(r.cost_usd, 0) as cost_usd,
+              COALESCE(NULLIF(r.cost_basis, ''), 'estimated') as cost_basis,
+              r.timestamp as last_active
+            FROM requests r
+            LEFT JOIN sessions s ON s.id = r.session_id
+            WHERE r.timestamp >= ?
+              AND (
+                COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') != ''
+                OR COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') != ''
+                OR COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') != ''
+                OR COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') != ''
+              )
+          ),
+          session_only_rows AS (
+            SELECT
+              s.id as session_id,
+              COALESCE(NULLIF(s.agent, ''), NULLIF(s.account_tool, ''), 'unknown') as account_agent,
+              s.account_key as raw_account_key,
+              s.account_name as raw_account_name,
+              LOWER(TRIM(COALESCE(s.account_email, ''))) as raw_account_email,
+              COALESCE(NULLIF(s.account_source, ''), 'unknown') as account_source,
+              COALESCE(s.request_count, 0) as requests,
+              COALESCE(s.total_tokens, 0) as total_tokens,
+              COALESCE(s.total_cost_usd, 0) as cost_usd,
+              'estimated' as cost_basis,
+              s.started_at as last_active
+            FROM sessions s
+            WHERE s.started_at >= ?
+              AND s.id NOT IN (SELECT DISTINCT session_id FROM requests)
+              AND (s.account_key != '' OR s.account_tool != '' OR s.account_name != '' OR s.account_email != '')
+          ),
+          normalized AS (
+            SELECT
+              CASE
+                WHEN raw_account_email != '' THEN account_agent || ':' || raw_account_email
+                WHEN raw_account_name != '' THEN account_agent || ':' || raw_account_name
+                ELSE raw_account_key
+              END as account_key,
+              account_agent as account_tool,
+              raw_account_name as account_name,
+              raw_account_email as account_email,
+              account_source,
+              session_id,
+              requests,
+              total_tokens,
+              cost_usd,
+              cost_basis,
+              last_active
+            FROM request_rows
+            UNION ALL
+            SELECT
+              CASE
+                WHEN raw_account_email != '' THEN account_agent || ':' || raw_account_email
+                WHEN raw_account_name != '' THEN account_agent || ':' || raw_account_name
+                ELSE raw_account_key
+              END as account_key,
+              account_agent as account_tool,
+              raw_account_name as account_name,
+              raw_account_email as account_email,
+              account_source,
+              session_id,
+              requests,
+              total_tokens,
+              cost_usd,
+              cost_basis,
+              last_active
+            FROM session_only_rows
+          )
+          SELECT account_key,
+                 account_tool,
+                 COALESCE(MAX(NULLIF(account_name, '')), MAX(NULLIF(account_email, '')), account_key) as account_name,
+                 NULLIF(account_email, '') as account_email,
+                 COALESCE(MAX(NULLIF(account_source, 'unknown')), 'unknown') as account_source,
                  COUNT(DISTINCT session_id) as sessions,
-                 COUNT(*) as requests,
-                 COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+                 COALESCE(SUM(requests), 0) as requests,
+                 COALESCE(SUM(total_tokens), 0) as total_tokens,
                  COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+                 COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
                  COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as metered_api_usd,
                  COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
-                 MAX(timestamp) as last_active
-          FROM requests
-          WHERE timestamp >= ?
-            AND (account_key != '' OR account_tool != '' OR account_name != '' OR account_email != '')
-          GROUP BY account_key, account_tool, account_name, account_email, account_source
+                 COALESCE(SUM(CASE WHEN cost_basis NOT IN ('metered_api', 'subscription_included', 'unknown') THEN cost_usd ELSE 0 END), 0) as estimated_usd,
+                 COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd,
+                 COALESCE(SUM(cost_usd), 0) as cost_usd,
+                 MAX(last_active) as last_active
+          FROM normalized
+          WHERE account_key != ''
+          GROUP BY account_key, account_tool, account_email
           ORDER BY api_equivalent_usd DESC
-        `).all(sinceDate) : queryAccountBreakdown(db);
-    printTable(["Account", "Sessions", "Requests", "Tokens", "API Eq", "Billable", "Included"], rows.map((r) => [
-      chalk7.white(r.account_key || r.account_name || chalk7.dim("unknown")),
-      String(r.sessions),
-      String(r.requests),
-      chalk7.cyan(fmtTokens(r.total_tokens)),
-      fmt4(r.api_equivalent_usd),
-      fmt4("billable_usd" in r ? Number(r.billable_usd) : r.metered_api_usd),
-      fmt4(r.subscription_included_usd)
-    ]));
+        `).all(sinceDate, sinceDate) : queryAccountBreakdown(db);
+    printAccountBreakdown(rows);
   } else {
     const rows = sinceDate ? db.prepare(`
           SELECT model, agent,
@@ -7290,6 +7500,24 @@ program.command("breakdown").description("Cost breakdown by model, agent, projec
   }
   console.log();
 });
+var ACCOUNT_PERIODS = ["today", "week", "month", "year", "all"];
+program.command("accounts [period]").description("List account usage by email address and coding agent").option("--json", "Output JSON").action((periodArg, opts) => {
+  const period = requireCliChoice(periodArg, "period", ACCOUNT_PERIODS);
+  const rows = queryAccountBreakdown(openDatabase(), period);
+  if (opts.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(chalk7.yellow("No account-attributed sessions yet. Run `economy sync` first."));
+    return;
+  }
+  console.log();
+  console.log(chalk7.bold.cyan(`  Accounts \u2014 ${period}`));
+  console.log();
+  printAccountBreakdown(rows);
+  console.log();
+});
 program.command("watch").description("Live stream of incoming costs").option("--interval <seconds>", "Poll interval in seconds", "10").option("--daemon", "Watch agent data directories and sync on change").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({