@hasna/economy 0.2.28 → 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,
@@ -1020,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,
@@ -1037,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);
   }
@@ -1053,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,
@@ -1133,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);
@@ -1166,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,
@@ -1177,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;
@@ -1196,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(`
@@ -2359,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
   };
 }
@@ -2382,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"
   };
 }
@@ -2398,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"
   };
 }
@@ -4541,8 +4619,9 @@ 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),
+        summary: querySummary(db, period, machine),
         machines: listMachines(db, period),
         registry: listMachineRegistry(db),
         current_machine: getMachineId()
@@ -4550,7 +4629,12 @@ function createHandler(db) {
     }
     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");
@@ -4620,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") {
@@ -6245,6 +6332,8 @@ var TOP_LEVEL = [
   "doctor",
   "init",
   "estimate",
+  "accounts",
+  "breakdown",
   "fleet",
   "merge-db",
   "todos",
@@ -7015,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) {
@@ -7274,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,
@@ -7318,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({