@tokz/cli 0.2.3 → 0.2.5

package/dist/{Root-6SZ5FQDN.js → Root-TUEV5MJB.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  findMcpServers
+} from "./chunk-65BQE6TI.js";
 import {
   addUsage,
   buildReport,
@@ -6,9 +9,10 @@ import {
   cacheSavings,
   compact,
   costUsd,
+  dayKey,
   duration,
   emptyUsage,
-  findMcpServers,
+  groupDaily,
   parseTranscript,
   pct,
   pct1,
@@ -16,19 +20,19 @@ import {
   sanitizeProjectPath,
   shortModel,
   usd
-} from "./chunk-JAZOB7NC.js";
+} from "./chunk-Z5W5QH2Z.js";
 
 // src/ui/Root.tsx
 import { useEffect as useEffect2, useState as useState6 } from "react";
 import { Box as Box10, Text as Text11, useApp as useApp2 } from "ink";
 
 // src/agents/index.ts
-import { access as access4 } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
+import { access as access15 } from "fs/promises";
+import { homedir as homedir16 } from "os";
+import { join as join16 } from "path";
 
-// src/agents/claude.ts
-import { access } from "fs/promises";
+// src/agents/antigravity.ts
+import { access, readFile as readFile2, readdir } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 
@@ -47,6 +51,24 @@ function baseName(p) {
   const parts = p.replace(/\\/g, "/").split("/").filter(Boolean);
   return parts.at(-1) ?? p;
 }
+var UNKNOWN_PROJECT = "(unknown project)";
+function groupSessionsByCwd(agentId, sessions) {
+  const byCwd = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    if (Object.keys(s.usageByModel).length === 0) continue;
+    const key = s.cwd ?? UNKNOWN_PROJECT;
+    (byCwd.get(key) ?? byCwd.set(key, []).get(key)).push(s);
+  }
+  return [...byCwd].map(([cwd, group]) => ({
+    id: `${agentId}:${cwd}`,
+    name: cwd,
+    label: cwd === UNKNOWN_PROJECT ? cwd : baseName(cwd),
+    realPath: cwd === UNKNOWN_PROJECT ? void 0 : cwd,
+    report: buildReport(group, []),
+    sessions: group,
+    serverList: []
+  })).sort((a, b) => b.report.totalCostUsd - a.report.totalCostUsd);
+}
 var DAY_MS = 864e5;
 function aggregate(projects) {
   const usageByModel = {};
@@ -175,14 +197,167 @@ async function loadProjects(home = homedir(), onProgress) {
   return out;
 }
 
+// src/agents/antigravity.ts
+var ESTIMATED_CHARS_PER_TOKEN = 4;
+var INPUT_SHARE = 0.85;
+function antigravityRoot(home) {
+  return join2(home ?? homedir2(), ".gemini", "antigravity-cli");
+}
+function modelIdFromDisplayName(name) {
+  const bare = name.replace(/\s*\(.*\)\s*$/, "").trim();
+  const slug = bare.toLowerCase().replace(/\s+/g, "-");
+  return slug.startsWith("claude") ? slug.replace(/\./g, "-") : slug;
+}
+var MODEL_NAME_RX = /(Gemini|Claude|GPT)[- ][0-9][0-9A-Za-z. ]{0,25}(\((Low|Medium|High|Max|Thinking)\))?/;
+function scanConversation(buf) {
+  const text = buf.toString("latin1");
+  const turnsByModel = {};
+  const anchor = /used_claude_conservative/g;
+  let m;
+  while (m = anchor.exec(text)) {
+    const window = text.slice(m.index + 24, m.index + 250);
+    const name = window.match(MODEL_NAME_RX);
+    const key = name ? modelIdFromDisplayName(name[0]) : "";
+    turnsByModel[key] = (turnsByModel[key] ?? 0) + 1;
+  }
+  let textChars = 0;
+  let start = -1;
+  for (let i = 0; i <= buf.length; i++) {
+    const c = i < buf.length ? buf[i] : 0;
+    const printable = c >= 32 && c < 127;
+    if (printable && start < 0) start = i;
+    if (!printable && start >= 0) {
+      if (i - start >= 20) textChars += i - start;
+      start = -1;
+    }
+  }
+  return { turnsByModel, textChars };
+}
+async function readHistory(root) {
+  try {
+    const raw = await readFile2(join2(root, "history.jsonl"), "utf8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        out.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function loadAntigravityProjects(home, onProgress) {
+  const root = antigravityRoot(home);
+  const convDir = join2(root, "conversations");
+  let dbFiles;
+  try {
+    dbFiles = (await readdir(convDir)).filter((f) => f.endsWith(".db"));
+  } catch {
+    return [];
+  }
+  if (dbFiles.length === 0) return [];
+  const history = await readHistory(root);
+  const byConversation = /* @__PURE__ */ new Map();
+  for (const e of history) {
+    if (!e.conversationId || !e.timestamp) continue;
+    const c = byConversation.get(e.conversationId) ?? {};
+    c.workspace ??= e.workspace;
+    if (!c.firstTs || e.timestamp < c.firstTs) c.firstTs = e.timestamp;
+    if (!c.lastTs || e.timestamp > c.lastTs) c.lastTs = e.timestamp;
+    byConversation.set(e.conversationId, c);
+  }
+  const sessions = [];
+  let parsed = 0;
+  for (const file of dbFiles) {
+    onProgress?.({ parsed, total: dbFiles.length, currentProject: "Antigravity conversations" });
+    let scan;
+    try {
+      scan = scanConversation(await readFile2(join2(convDir, file)));
+    } catch {
+      parsed += 1;
+      continue;
+    }
+    parsed += 1;
+    onProgress?.({ parsed, total: dbFiles.length, currentProject: "Antigravity conversations" });
+    const named = Object.entries(scan.turnsByModel).filter(([k]) => k !== "");
+    named.sort((a, b) => b[1] - a[1]);
+    const fallback = named[0]?.[0] ?? "antigravity-unknown";
+    const turnsByModel = {};
+    for (const [model, turns] of Object.entries(scan.turnsByModel)) {
+      const key = model === "" ? fallback : model;
+      turnsByModel[key] = (turnsByModel[key] ?? 0) + turns;
+    }
+    const totalTurns = Object.values(turnsByModel).reduce((s, n) => s + n, 0);
+    if (totalTurns === 0) continue;
+    const conversationId = file.replace(/\.db$/, "");
+    const meta = byConversation.get(conversationId);
+    const firstTs = meta?.firstTs ? new Date(meta.firstTs).toISOString() : void 0;
+    const lastTs = meta?.lastTs ? new Date(meta.lastTs).toISOString() : void 0;
+    const day = (lastTs ?? firstTs)?.slice(0, 10);
+    const estTokens = Math.round(scan.textChars / ESTIMATED_CHARS_PER_TOKEN);
+    const stats = {
+      file: conversationId,
+      cwd: meta?.workspace,
+      firstTs,
+      lastTs,
+      usageByModel: {},
+      toolCalls: {},
+      toolCostUsd: {},
+      dailyUsage: {}
+    };
+    for (const [model, turns] of Object.entries(turnsByModel)) {
+      const share = turns / totalTurns;
+      const u = stats.usageByModel[model] ??= emptyUsage();
+      u.inputTokens += Math.round(estTokens * share * INPUT_SHARE);
+      u.outputTokens += Math.round(estTokens * share * (1 - INPUT_SHARE));
+      u.turns += turns;
+      if (day) {
+        const d = (stats.dailyUsage[day] ??= {})[model] ??= emptyUsage();
+        d.inputTokens += u.inputTokens;
+        d.outputTokens += u.outputTokens;
+        d.turns += turns;
+      }
+    }
+    sessions.push(stats);
+  }
+  return groupSessionsByCwd("antigravity", sessions);
+}
+var antigravityAdapter = {
+  id: "antigravity",
+  name: "Antigravity",
+  supported: true,
+  estimated: true,
+  estimateNote: "no token counts on disk \u2014 tokens/costs estimated from conversation size",
+  async detect(home) {
+    try {
+      await access(join2(antigravityRoot(home), "conversations"));
+      return true;
+    } catch {
+      try {
+        await access(join2(home ?? homedir2(), ".gemini", "antigravity", "conversations"));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  },
+  loadProjects: loadAntigravityProjects
+};
+
 // src/agents/claude.ts
+import { access as access2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 var claudeAdapter = {
   id: "claude",
   name: "Claude Code",
   supported: true,
-  async detect(home = homedir2()) {
+  async detect(home = homedir3()) {
     try {
-      await access(join2(home, ".claude", "projects"));
+      await access2(join3(home, ".claude", "projects"));
       return true;
     } catch {
       return false;
@@ -191,13 +366,178 @@ var claudeAdapter = {
   loadProjects: (home, onProgress) => loadProjects(home, onProgress)
 };
 
+// src/agents/codebuff.ts
+import { access as access3, stat } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+import { glob as glob2 } from "tinyglobby";
+
+// src/agents/usage.ts
+import { readFile as readFile3 } from "fs/promises";
+async function readJson(file) {
+  try {
+    return JSON.parse(await readFile3(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function readJsonl(file) {
+  let raw;
+  try {
+    raw = await readFile3(file, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function sessionFromRecords(file, cwd, records) {
+  const stats = { file, cwd, usageByModel: {}, toolCalls: {}, toolCostUsd: {}, dailyUsage: {} };
+  for (const r of records) {
+    if (r.input + r.output + r.cacheRead + r.cacheWrite === 0) continue;
+    if (r.ts) {
+      if (!stats.firstTs || r.ts < stats.firstTs) stats.firstTs = r.ts;
+      if (!stats.lastTs || r.ts > stats.lastTs) stats.lastTs = r.ts;
+    }
+    const accs = [stats.usageByModel[r.model] ??= emptyUsage()];
+    if (r.ts) {
+      const day = stats.dailyUsage[r.ts.slice(0, 10)] ??= {};
+      accs.push(day[r.model] ??= emptyUsage());
+    }
+    for (const u of accs) {
+      u.inputTokens += r.input;
+      u.outputTokens += r.output;
+      u.cacheReadTokens += r.cacheRead;
+      u.cacheCreationTokens += r.cacheWrite;
+      u.turns += 1;
+    }
+  }
+  return stats;
+}
+function pickNum(obj, keys) {
+  if (!obj || typeof obj !== "object") return 0;
+  const rec = obj;
+  for (const k of keys) {
+    const v = rec[k];
+    const n = typeof v === "string" ? Number(v) : typeof v === "number" ? v : NaN;
+    if (Number.isFinite(n)) return Math.max(0, Math.trunc(n));
+  }
+  return 0;
+}
+function str(obj, key) {
+  if (!obj || typeof obj !== "object") return void 0;
+  const v = obj[key];
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function toIso(value) {
+  if (typeof value === "string") {
+    const t = Date.parse(value);
+    return Number.isFinite(t) ? new Date(t).toISOString() : void 0;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    let ms = Number(value);
+    if (!Number.isFinite(ms) || ms <= 0) return void 0;
+    if (ms < 1e12) ms *= 1e3;
+    return new Date(ms).toISOString();
+  }
+  return void 0;
+}
+function deepFind(node, keys, depth = 6) {
+  if (!node || typeof node !== "object" || depth < 0) return void 0;
+  const rec = node;
+  if (!Array.isArray(node) && keys.some((k) => k in rec)) return rec;
+  for (const v of Object.values(rec)) {
+    const hit = deepFind(v, keys, depth - 1);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+
+// src/agents/codebuff.ts
+var CHANNELS = ["manicode", "manicode-dev", "manicode-staging"];
+function codebuffRoots(home) {
+  const env = process.env.CODEBUFF_DATA_DIR;
+  if (env) return env.split(",").map((s) => s.trim()).filter(Boolean);
+  const h = home ?? homedir4();
+  return CHANNELS.map((c) => join4(h, ".config", c));
+}
+function isAssistant(msg) {
+  const role = str(msg, "variant") ?? str(msg, "role");
+  return role === "ai" || role === "agent" || role === "assistant";
+}
+async function parseFile(file) {
+  const arr = await readJson(file);
+  if (!Array.isArray(arr)) return sessionFromRecords(file, void 0, []);
+  let fileTs;
+  try {
+    fileTs = (await stat(file)).mtime.toISOString();
+  } catch {
+  }
+  const records = [];
+  for (const msg of arr) {
+    if (!isAssistant(msg)) continue;
+    const meta = msg.metadata;
+    const usage = meta?.usage;
+    if (!usage) continue;
+    records.push({
+      model: str(meta, "model") ?? "codebuff-unknown",
+      ts: str(msg, "timestamp") ?? fileTs,
+      input: pickNum(usage, ["inputTokens", "input_tokens"]),
+      output: pickNum(usage, ["outputTokens", "output_tokens"]),
+      cacheRead: pickNum(usage, ["cacheReadInputTokens", "cache_read_input_tokens", "cachedTokens"]),
+      cacheWrite: pickNum(usage, ["cacheCreationInputTokens", "cache_creation_input_tokens"])
+    });
+  }
+  return sessionFromRecords(file, void 0, records);
+}
+async function loadCodebuffProjects(home, onProgress) {
+  const files = [];
+  for (const root of codebuffRoots(home)) {
+    files.push(
+      ...await glob2(["**/chat-messages.json"], { cwd: root, absolute: true }).catch(() => [])
+    );
+  }
+  const sessions = [];
+  let parsed = 0;
+  for (const f of files) {
+    onProgress?.({ parsed, total: files.length, currentProject: "Codebuff chats" });
+    sessions.push(await parseFile(f));
+    parsed += 1;
+    onProgress?.({ parsed, total: files.length, currentProject: "Codebuff chats" });
+  }
+  return groupSessionsByCwd("codebuff", sessions);
+}
+var codebuffAdapter = {
+  id: "codebuff",
+  name: "Codebuff",
+  supported: true,
+  async detect(home) {
+    for (const root of codebuffRoots(home)) {
+      try {
+        await access3(root);
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  },
+  loadProjects: loadCodebuffProjects
+};
+
 // src/agents/codex.ts
 import { createReadStream } from "fs";
-import { access as access2 } from "fs/promises";
+import { access as access4 } from "fs/promises";
 import { createInterface } from "readline";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
-import { glob as glob2 } from "tinyglobby";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+import { glob as glob3 } from "tinyglobby";
 import { z } from "zod";
 var TokenTotals = z.object({
   input_tokens: z.number().catch(0).default(0),
@@ -220,8 +560,8 @@ var Line = z.object({
   }).passthrough().optional()
 });
 function codexHome(home) {
-  if (home) return join3(home, ".codex");
-  return process.env.CODEX_HOME ?? join3(homedir3(), ".codex");
+  if (home) return join5(home, ".codex");
+  return process.env.CODEX_HOME ?? join5(homedir5(), ".codex");
 }
 var DEFAULT_MODEL = "gpt-5";
 async function parseCodexRollout(file) {
@@ -240,19 +580,19 @@ async function parseCodexRollout(file) {
     }
     const parsed = Line.safeParse(obj);
     if (!parsed.success) continue;
-    const { timestamp, type, payload } = parsed.data;
-    if (!stats.cwd) stats.cwd = payload?.cwd ?? parsed.data.cwd;
-    if (payload?.model) model = payload.model;
+    const { timestamp, type, payload: payload2 } = parsed.data;
+    if (!stats.cwd) stats.cwd = payload2?.cwd ?? parsed.data.cwd;
+    if (payload2?.model) model = payload2.model;
     if (timestamp) {
       if (!stats.firstTs) stats.firstTs = timestamp;
       stats.lastTs = timestamp;
     }
-    const toolName = payload?.type === "function_call" || payload?.type === "custom_tool_call" ? payload.name : payload?.type === "local_shell_call" ? "shell" : type === "function_call" ? parsed.data.name : void 0;
+    const toolName = payload2?.type === "function_call" || payload2?.type === "custom_tool_call" ? payload2.name : payload2?.type === "local_shell_call" ? "shell" : type === "function_call" ? parsed.data.name : void 0;
     if (toolName) {
       stats.toolCalls[toolName] = (stats.toolCalls[toolName] ?? 0) + 1;
       turnTools.push(toolName);
     }
-    const totals = payload?.type === "token_count" ? payload.info?.total_token_usage : void 0;
+    const totals = payload2?.type === "token_count" ? payload2.info?.total_token_usage : void 0;
     if (!totals) continue;
     const cur = {
       input: totals.input_tokens,
@@ -298,38 +638,20 @@ async function parseCodexRollout(file) {
 }
 async function loadCodexProjects(home, onProgress) {
   const root = codexHome(home);
-  const files = await glob2(["sessions/**/*.jsonl", "archived_sessions/**/*.jsonl"], {
+  const files = await glob3(["sessions/**/*.jsonl", "archived_sessions/**/*.jsonl"], {
     cwd: root,
     absolute: true
   }).catch(() => []);
   if (files.length === 0) return [];
-  const byCwd = /* @__PURE__ */ new Map();
+  const sessions = [];
   let parsed = 0;
   for (const f of files) {
     onProgress?.({ parsed, total: files.length, currentProject: "Codex sessions" });
-    const s = await parseCodexRollout(f);
+    sessions.push(await parseCodexRollout(f));
     parsed += 1;
     onProgress?.({ parsed, total: files.length, currentProject: "Codex sessions" });
-    if (Object.keys(s.usageByModel).length === 0) continue;
-    const key = s.cwd ?? "(unknown project)";
-    const list = byCwd.get(key) ?? [];
-    list.push(s);
-    byCwd.set(key, list);
   }
-  const out = [];
-  for (const [cwd, sessions] of byCwd) {
-    out.push({
-      id: `codex:${cwd}`,
-      name: cwd,
-      label: cwd === "(unknown project)" ? cwd : baseName(cwd),
-      realPath: cwd,
-      report: buildReport(sessions, []),
-      sessions,
-      serverList: []
-    });
-  }
-  out.sort((a, b) => b.report.totalCostUsd - a.report.totalCostUsd);
-  return out;
+  return groupSessionsByCwd("codex", sessions);
 }
 var codexAdapter = {
   id: "codex",
@@ -337,7 +659,7 @@ var codexAdapter = {
   supported: true,
   async detect(home) {
     try {
-      await access2(join3(codexHome(home), "sessions"));
+      await access4(join5(codexHome(home), "sessions"));
       return true;
     } catch {
       return false;
@@ -346,11 +668,602 @@ var codexAdapter = {
   loadProjects: loadCodexProjects
 };
 
+// src/agents/droid.ts
+import { access as access5, stat as stat2 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { basename as basename2, join as join6 } from "path";
+import { glob as glob4 } from "tinyglobby";
+function droidRoot(home) {
+  return process.env.DROID_SESSIONS_DIR ?? join6(home ?? homedir6(), ".factory", "sessions");
+}
+async function parseFile2(file) {
+  const settings = await readJson(file);
+  const usage = settings?.tokenUsage;
+  if (!usage) return sessionFromRecords(file, void 0, []);
+  let ts = str(settings, "updatedAt") ?? str(settings, "createdAt");
+  if (!ts) {
+    try {
+      ts = (await stat2(file)).mtime.toISOString();
+    } catch {
+    }
+  }
+  return sessionFromRecords(file, void 0, [
+    {
+      model: str(settings, "model") ?? "droid-unknown",
+      ts,
+      input: pickNum(usage, ["inputTokens"]),
+      output: pickNum(usage, ["outputTokens"]) + pickNum(usage, ["thinkingTokens"]),
+      cacheRead: pickNum(usage, ["cacheReadTokens"]),
+      cacheWrite: pickNum(usage, ["cacheCreationTokens"])
+    }
+  ]);
+}
+async function loadDroidProjects(home, onProgress) {
+  const files = (await glob4(["**/*.settings.json"], { cwd: droidRoot(home), absolute: true }).catch(() => [])).filter((f) => basename2(f).endsWith(".settings.json"));
+  const sessions = [];
+  let parsed = 0;
+  for (const f of files) {
+    onProgress?.({ parsed, total: files.length, currentProject: "Droid sessions" });
+    sessions.push(await parseFile2(f));
+    parsed += 1;
+    onProgress?.({ parsed, total: files.length, currentProject: "Droid sessions" });
+  }
+  return groupSessionsByCwd("droid", sessions);
+}
+var droidAdapter = {
+  id: "droid",
+  name: "Droid (Factory)",
+  supported: true,
+  async detect(home) {
+    try {
+      await access5(droidRoot(home));
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  loadProjects: loadDroidProjects
+};
+
+// src/agents/gemini.ts
+import { access as access6 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
+import { glob as glob5 } from "tinyglobby";
+function geminiRoot(home) {
+  return process.env.GEMINI_DATA_DIR ?? join7(home ?? homedir7(), ".gemini", "tmp");
+}
+var IN = ["input", "prompt", "input_tokens", "prompt_tokens"];
+var OUT = ["output", "candidates", "output_tokens", "candidates_tokens"];
+function recordFrom(node, model, ts) {
+  const tokens = node.tokens;
+  if (!tokens) return void 0;
+  const reasoning = pickNum(tokens, ["thoughts", "reasoning", "thoughts_tokens", "reasoning_tokens"]);
+  return {
+    model: str(node, "model") ?? model ?? "gemini-unknown",
+    ts: str(node, "timestamp") ?? ts,
+    input: pickNum(tokens, IN),
+    output: pickNum(tokens, OUT) + reasoning,
+    cacheRead: pickNum(tokens, ["cached", "cached_tokens"]),
+    cacheWrite: 0
+  };
+}
+async function parseFile3(file) {
+  const records = [];
+  const push = (r) => r && records.push(r);
+  if (file.endsWith(".jsonl")) {
+    for (const line of await readJsonl(file)) push(recordFrom(line, str(line, "model"), void 0));
+  } else {
+    const doc = await readJson(file);
+    const model = str(doc, "model");
+    const messages = doc?.messages;
+    if (Array.isArray(messages)) for (const m of messages) push(recordFrom(m, model, void 0));
+    push(recordFrom(doc, model, void 0));
+  }
+  return sessionFromRecords(file, void 0, records);
+}
+async function loadGeminiProjects(home, onProgress) {
+  const files = await glob5(["**/*.json", "**/*.jsonl"], { cwd: geminiRoot(home), absolute: true }).catch(
+    () => []
+  );
+  const sessions = [];
+  let parsed = 0;
+  for (const f of files) {
+    onProgress?.({ parsed, total: files.length, currentProject: "Gemini logs" });
+    sessions.push(await parseFile3(f));
+    parsed += 1;
+    onProgress?.({ parsed, total: files.length, currentProject: "Gemini logs" });
+  }
+  return groupSessionsByCwd("gemini", sessions);
+}
+var geminiAdapter = {
+  id: "gemini",
+  name: "Gemini CLI",
+  supported: true,
+  async detect(home) {
+    try {
+      await access6(geminiRoot(home));
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  loadProjects: loadGeminiProjects
+};
+
+// src/agents/goose.ts
+import { access as access7 } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
+
+// src/sqlite.ts
+import { readFile as readFile4 } from "fs/promises";
+function u8(b, o) {
+  return b[o];
+}
+function u16(b, o) {
+  return b[o] << 8 | b[o + 1];
+}
+function u32(b, o) {
+  return b[o] * 16777216 + (b[o + 1] << 16) + (b[o + 2] << 8) + b[o + 3];
+}
+function varint(b, o) {
+  let result = 0n;
+  for (let i = 0; i < 8; i++) {
+    const byte = b[o + i];
+    result = result << 7n | BigInt(byte & 127);
+    if ((byte & 128) === 0) return [result, i + 1];
+  }
+  result = result << 8n | BigInt(b[o + 8]);
+  return [result, 9];
+}
+function page(db, n) {
+  const start = (n - 1) * db.pageSize;
+  return db.buf.subarray(start, start + db.pageSize);
+}
+function payload(db, p, cellContentOffset, payloadLen) {
+  const U = db.usable;
+  const X = U - 35;
+  if (payloadLen <= X) return p.subarray(cellContentOffset, cellContentOffset + payloadLen);
+  const M = Math.floor((U - 12) * 32 / 255) - 23;
+  const K = M + (payloadLen - M) % (U - 4);
+  const local = K <= X ? K : M;
+  const parts = [p.subarray(cellContentOffset, cellContentOffset + local)];
+  let next = u32(p, cellContentOffset + local);
+  let remaining = payloadLen - local;
+  while (next !== 0 && remaining > 0) {
+    const ov = page(db, next);
+    next = u32(ov, 0);
+    const take = Math.min(remaining, U - 4);
+    parts.push(ov.subarray(4, 4 + take));
+    remaining -= take;
+  }
+  return Buffer.concat(parts);
+}
+function decodeRecord(rec, rowid) {
+  const [headerLen, hlBytes] = varint(rec, 0);
+  const serials = [];
+  let o = hlBytes;
+  while (o < Number(headerLen)) {
+    const [s, n] = varint(rec, o);
+    serials.push(s);
+    o += n;
+  }
+  const values = [];
+  let body = Number(headerLen);
+  for (const st of serials) {
+    const t = Number(st);
+    if (t === 0) {
+      values.push(rowid);
+    } else if (t >= 1 && t <= 6) {
+      const len = t <= 4 ? t : t === 5 ? 6 : 8;
+      let v = 0n;
+      for (let i = 0; i < len; i++) v = v << 8n | BigInt(rec[body + i]);
+      const bits = BigInt(len * 8);
+      if (v >> bits - 1n) v -= 1n << bits;
+      values.push(v >= -9007199254740991n && v <= 9007199254740991n ? Number(v) : v);
+      body += len;
+    } else if (t === 7) {
+      values.push(rec.readDoubleBE(body));
+      body += 8;
+    } else if (t === 8) {
+      values.push(0);
+    } else if (t === 9) {
+      values.push(1);
+    } else if (t >= 12 && t % 2 === 0) {
+      const len = (t - 12) / 2;
+      values.push(Uint8Array.from(rec.subarray(body, body + len)));
+      body += len;
+    } else if (t >= 13) {
+      const len = (t - 13) / 2;
+      values.push(rec.toString("utf8", body, body + len));
+      body += len;
+    } else {
+      values.push(null);
+    }
+  }
+  return values;
+}
+function walkTable(db, rootPage, out) {
+  const p = page(db, rootPage);
+  const headerOffset = rootPage === 1 ? 100 : 0;
+  const type = u8(p, headerOffset);
+  const cellCount = u16(p, headerOffset + 3);
+  const interior = type === 5;
+  const cellPtrBase = headerOffset + (interior ? 12 : 8);
+  for (let i = 0; i < cellCount; i++) {
+    const cellOffset = u16(p, cellPtrBase + i * 2);
+    if (interior) {
+      const child = u32(p, cellOffset);
+      walkTable(db, child, out);
+    } else if (type === 13) {
+      const [plen, n1] = varint(p, cellOffset);
+      const [rowid, n2] = varint(p, cellOffset + n1);
+      const rec = payload(db, p, cellOffset + n1 + n2, Number(plen));
+      out.push([rowid, decodeRecord(rec, rowid)]);
+    }
+  }
+  if (interior) {
+    const rightMost = u32(p, headerOffset + 8);
+    if (rightMost) walkTable(db, rightMost, out);
+  }
+}
+function columnNames(sql) {
+  const open = sql.indexOf("(");
+  const close = sql.lastIndexOf(")");
+  if (open < 0 || close < 0) return [];
+  const body = sql.slice(open + 1, close);
+  const cols = [];
+  let depth = 0;
+  let cur = "";
+  const parts = [];
+  for (const ch of body) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  if (cur.trim()) parts.push(cur);
+  const CONSTRAINTS = /* @__PURE__ */ new Set(["primary", "unique", "check", "foreign", "constraint"]);
+  for (const part of parts) {
+    const token = part.trim().replace(/^["'`\[]|["'`\]]$/g, "");
+    const name = token.split(/[\s(]/)[0].replace(/["'`\[\]]/g, "");
+    if (name && !CONSTRAINTS.has(name.toLowerCase())) cols.push(name);
+  }
+  return cols;
+}
+async function readTable(file, table) {
+  let buf;
+  try {
+    buf = await readFile4(file);
+  } catch {
+    return [];
+  }
+  if (buf.length < 100 || buf.toString("latin1", 0, 16) !== "SQLite format 3\0") return [];
+  let pageSize = u16(buf, 16);
+  if (pageSize === 1) pageSize = 65536;
+  const reserved = u8(buf, 20);
+  const db = { buf, pageSize, usable: pageSize - reserved };
+  const master = [];
+  walkTable(db, 1, master);
+  let rootPage = 0;
+  let createSql = "";
+  for (const [, cols] of master) {
+    if (cols[0] === "table" && cols[1] === table) {
+      rootPage = Number(cols[3]);
+      createSql = typeof cols[4] === "string" ? cols[4] : "";
+      break;
+    }
+  }
+  if (!rootPage) return [];
+  const names = columnNames(createSql);
+  const rows = [];
+  walkTable(db, rootPage, rows);
+  return rows.map(([rowid, values]) => {
+    const row = {};
+    names.forEach((name, i) => row[name] = values[i] ?? null);
+    row.rowid ??= rowid <= 9007199254740991n ? Number(rowid) : rowid;
+    return row;
+  });
+}
+
+// src/agents/goose.ts
+var GOOSE_DB_CANDIDATES = [
+  [".local", "share", "goose", "sessions", "sessions.db"],
+  ["Library", "Application Support", "goose", "sessions", "sessions.db"],
+  [".local", "share", "Block", "goose", "sessions", "sessions.db"]
+];
+function gooseDbCandidates(home) {
+  const root = process.env.GOOSE_PATH_ROOT;
+  if (root) return [join8(root, "data", "sessions", "sessions.db")];
+  const h = home ?? homedir8();
+  return GOOSE_DB_CANDIDATES.map((parts) => join8(h, ...parts));
+}
+async function loadGooseProjects(home, onProgress) {
+  const records = [];
+  for (const db of gooseDbCandidates(home)) {
+    const rows = await readTable(db, "sessions").catch(() => []);
+    for (const row of rows) {
+      onProgress?.({ parsed: records.length, total: rows.length, currentProject: "Goose sessions" });
+      const input = pickNum(row, ["accumulated_input_tokens"]) || pickNum(row, ["input_tokens"]);
+      const output = pickNum(row, ["accumulated_output_tokens"]) || pickNum(row, ["output_tokens"]);
+      const total = pickNum(row, ["accumulated_total_tokens"]) || pickNum(row, ["total_tokens"]);
+      const reasoning = Math.max(0, total - input - output);
+      let model = "goose-unknown";
+      try {
+        model = JSON.parse(String(row.model_config_json ?? "{}")).model_name || model;
+      } catch {
+      }
+      records.push({
+        model,
+        ts: toIso(row.created_at),
+        input,
+        output: output + reasoning,
+        cacheRead: 0,
+        cacheWrite: 0
+      });
+    }
+  }
+  const session = sessionFromRecords("goose", void 0, records);
+  return groupSessionsByCwd("goose", [session]);
+}
+var gooseAdapter = {
+  id: "goose",
+  name: "Goose",
+  supported: true,
+  async detect(home) {
+    for (const db of gooseDbCandidates(home)) {
+      try {
+        await access7(db);
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  },
+  loadProjects: loadGooseProjects
+};
+
+// src/agents/hermes.ts
+import { access as access8 } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
+function hermesDb(home) {
+  const env = process.env.HERMES_HOME;
+  const root = env ? env.split(",")[0].trim() : join9(home ?? homedir9(), ".hermes");
+  return join9(root, "state.db");
+}
+async function loadHermesProjects(home, onProgress) {
+  const rows = await readTable(hermesDb(home), "sessions").catch(() => []);
+  const records = [];
+  for (const row of rows) {
+    onProgress?.({ parsed: records.length, total: rows.length, currentProject: "Hermes sessions" });
+    records.push({
+      model: str(row, "model") ?? "hermes-unknown",
+      ts: toIso(row.started_at),
+      input: pickNum(row, ["input_tokens"]),
+      output: pickNum(row, ["output_tokens"]) + pickNum(row, ["reasoning_tokens"]),
+      cacheRead: pickNum(row, ["cache_read_tokens"]),
+      cacheWrite: pickNum(row, ["cache_write_tokens"])
+    });
+  }
+  const session = sessionFromRecords("hermes", void 0, records);
+  return groupSessionsByCwd("hermes", [session]);
+}
+var hermesAdapter = {
+  id: "hermes",
+  name: "Hermes",
+  supported: true,
+  async detect(home) {
+    try {
+      await access8(hermesDb(home));
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  loadProjects: loadHermesProjects
+};
+
+// src/agents/kilo.ts
+import { access as access9 } from "fs/promises";
+import { homedir as homedir10 } from "os";
+import { join as join10 } from "path";
+function kiloDir(home) {
+  return process.env.KILO_DATA_DIR ?? join10(home ?? homedir10(), ".local", "share", "kilo");
+}
+async function loadKiloProjects(home, onProgress) {
+  const db = join10(kiloDir(home), "kilo.db");
+  let rows;
+  try {
+    rows = await readTable(db, "message");
+  } catch {
+    return [];
+  }
+  const bySession = /* @__PURE__ */ new Map();
+  let parsed = 0;
+  for (const row of rows) {
+    onProgress?.({ parsed, total: rows.length, currentProject: "Kilo messages" });
+    parsed += 1;
+    if (typeof row.data !== "string") continue;
+    let m;
+    try {
+      m = JSON.parse(row.data);
+    } catch {
+      continue;
+    }
+    if (m.role !== "assistant" || !m.tokens) continue;
+    const session = m.sessionID ?? String(row.session_id ?? "kilo");
+    const list = bySession.get(session) ?? [];
+    list.push({
+      model: m.modelID ?? "kilo-unknown",
+      ts: m.time?.created ? new Date(m.time.created).toISOString() : void 0,
+      input: m.tokens.input ?? 0,
+      output: (m.tokens.output ?? 0) + (m.tokens.reasoning ?? 0),
+      cacheRead: m.tokens.cache?.read ?? 0,
+      cacheWrite: m.tokens.cache?.write ?? 0
+    });
+    bySession.set(session, list);
+  }
+  const sessions = [];
+  for (const [id, records] of bySession) sessions.push(sessionFromRecords(id, void 0, records));
+  return groupSessionsByCwd("kilo", sessions);
+}
+var kiloAdapter = {
+  id: "kilo",
+  name: "Kilo",
+  supported: true,
+  async detect(home) {
+    try {
+      await access9(join10(kiloDir(home), "kilo.db"));
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  loadProjects: loadKiloProjects
+};
+
+// src/agents/kimi.ts
+import { access as access10 } from "fs/promises";
+import { homedir as homedir11 } from "os";
+import { join as join11 } from "path";
+import { glob as glob6 } from "tinyglobby";
+var KIMI_DIRS = [".kimi", ".kimi-code"];
+var USAGE_KEYS = ["inputOther", "input_other", "inputCacheRead", "input_cache_read"];
+function kimiRoots(home) {
+  const env = process.env.KIMI_DATA_DIR;
+  if (env) return env.split(",").map((s) => s.trim()).filter(Boolean);
+  const h = home ?? homedir11();
+  return KIMI_DIRS.map((d) => join11(h, d));
+}
+async function parseFile4(file) {
+  const records = [];
+  for (const line of await readJsonl(file)) {
+    const usage = deepFind(line, USAGE_KEYS);
+    if (!usage) continue;
+    records.push({
+      model: str(line, "model") ?? "kimi-unknown",
+      ts: str(line, "timestamp"),
+      input: pickNum(usage, ["inputOther", "input_other"]),
+      output: pickNum(usage, ["output"]),
+      cacheRead: pickNum(usage, ["inputCacheRead", "input_cache_read"]),
+      cacheWrite: pickNum(usage, ["inputCacheCreation", "input_cache_creation"])
+    });
+  }
+  return sessionFromRecords(file, void 0, records);
+}
+async function loadKimiProjects(home, onProgress) {
+  const files = [];
+  for (const root of kimiRoots(home)) {
+    files.push(
+      ...await glob6(["sessions/**/wire.jsonl"], { cwd: root, absolute: true }).catch(() => [])
+    );
+  }
+  const sessions = [];
+  let parsed = 0;
+  for (const f of files) {
+    onProgress?.({ parsed, total: files.length, currentProject: "Kimi sessions" });
+    sessions.push(await parseFile4(f));
+    parsed += 1;
+    onProgress?.({ parsed, total: files.length, currentProject: "Kimi sessions" });
+  }
+  return groupSessionsByCwd("kimi", sessions);
+}
+var kimiAdapter = {
+  id: "kimi",
+  name: "Kimi CLI",
+  supported: true,
+  async detect(home) {
+    for (const root of kimiRoots(home)) {
+      try {
+        await access10(join11(root, "sessions"));
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  },
+  loadProjects: loadKimiProjects
+};
+
+// src/agents/openclaw.ts
+import { access as access11 } from "fs/promises";
+import { homedir as homedir12 } from "os";
+import { join as join12 } from "path";
+import { glob as glob7 } from "tinyglobby";
+var OPENCLAW_DIRS = [".openclaw", ".clawdbot", ".moltbot", ".moldbot"];
+function openclawRoots(home) {
+  const env = process.env.OPENCLAW_DIR;
+  if (env) return env.split(",").map((s) => s.trim()).filter(Boolean);
+  const h = home ?? homedir12();
+  return OPENCLAW_DIRS.map((d) => join12(h, d));
+}
+function modelFrom(obj) {
+  return str(obj, "modelId") ?? str(obj, "model");
+}
+async function parseFile5(file) {
+  const records = [];
+  let currentModel;
+  for (const line of await readJsonl(file)) {
+    const l = line;
+    if (l.type === "model_change" || l.type === "model-snapshot") {
+      currentModel = modelFrom(l.data) ?? modelFrom(l) ?? currentModel;
+      continue;
+    }
+    const usage = l.message?.usage;
+    if (!usage) continue;
+    const model = modelFrom(l.message) ?? currentModel ?? "openclaw-unknown";
+    records.push({
+      model,
+      ts: str(l.message, "timestamp") ?? str(l, "timestamp"),
+      input: pickNum(usage, ["input"]),
+      output: pickNum(usage, ["output"]),
+      cacheRead: pickNum(usage, ["cacheRead"]),
+      cacheWrite: pickNum(usage, ["cacheWrite"])
+    });
+  }
+  return sessionFromRecords(file, void 0, records);
+}
+async function loadOpenclawProjects(home, onProgress) {
+  const files = [];
+  for (const root of openclawRoots(home)) {
+    files.push(...await glob7(["**/*.jsonl", "**/*.jsonl.*"], { cwd: root, absolute: true }).catch(() => []));
+  }
+  const sessions = [];
+  let parsed = 0;
+  for (const f of files) {
+    onProgress?.({ parsed, total: files.length, currentProject: "OpenClaw sessions" });
+    sessions.push(await parseFile5(f));
+    parsed += 1;
+    onProgress?.({ parsed, total: files.length, currentProject: "OpenClaw sessions" });
+  }
+  return groupSessionsByCwd("openclaw", sessions);
+}
+var openclawAdapter = {
+  id: "openclaw",
+  name: "OpenClaw",
+  supported: true,
+  async detect(home) {
+    for (const root of openclawRoots(home)) {
+      try {
+        await access11(root);
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  },
+  loadProjects: loadOpenclawProjects
+};
+
 // src/agents/opencode.ts
-import { access as access3, readFile as readFile2 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
-import { glob as glob3 } from "tinyglobby";
+import { access as access12, readFile as readFile5 } from "fs/promises";
+import { homedir as homedir13 } from "os";
+import { join as join13 } from "path";
+import { glob as glob8 } from "tinyglobby";
 import { z as z2 } from "zod";
 var Message = z2.object({
   sessionID: z2.string(),
@@ -373,34 +1286,34 @@ var Session = z2.object({
 });
 var Project = z2.object({ id: z2.string(), worktree: z2.string().optional() });
 function opencodeRoot(home) {
-  if (home) return join4(home, ".local", "share", "opencode");
-  return process.env.OPENCODE_DATA_DIR ?? join4(homedir4(), ".local", "share", "opencode");
+  if (home) return join13(home, ".local", "share", "opencode");
+  return process.env.OPENCODE_DATA_DIR ?? join13(homedir13(), ".local", "share", "opencode");
 }
-async function readJson(file) {
+async function readJson2(file) {
   try {
-    return JSON.parse(await readFile2(file, "utf8"));
+    return JSON.parse(await readFile5(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 async function loadOpencodeProjects(home, onProgress) {
   const root = opencodeRoot(home);
-  const storage = join4(root, "storage");
-  const messageFiles = await glob3(["message/*/*.json"], { cwd: storage, absolute: true }).catch(
+  const storage = join13(root, "storage");
+  const messageFiles = await glob8(["message/*/*.json"], { cwd: storage, absolute: true }).catch(
     () => []
   );
   if (messageFiles.length === 0) return [];
   const sessionDir = /* @__PURE__ */ new Map();
   const projectWorktree = /* @__PURE__ */ new Map();
-  for (const f of await glob3(["project/*.json"], { cwd: storage, absolute: true }).catch(() => [])) {
-    const p = Project.safeParse(await readJson(f));
+  for (const f of await glob8(["project/*.json"], { cwd: storage, absolute: true }).catch(() => [])) {
+    const p = Project.safeParse(await readJson2(f));
     if (p.success && p.data.worktree) projectWorktree.set(p.data.id, p.data.worktree);
   }
-  const sessionFiles = await glob3(["session/**/*.json"], { cwd: storage, absolute: true }).catch(
+  const sessionFiles = await glob8(["session/**/*.json"], { cwd: storage, absolute: true }).catch(
     () => []
   );
   for (const f of sessionFiles) {
-    const s = Session.safeParse(await readJson(f));
+    const s = Session.safeParse(await readJson2(f));
     if (!s.success) continue;
     const dir = s.data.directory ?? (s.data.projectID ? projectWorktree.get(s.data.projectID) : void 0);
     if (dir) sessionDir.set(s.data.id, dir);
@@ -409,7 +1322,7 @@ async function loadOpencodeProjects(home, onProgress) {
   let parsed = 0;
   for (const f of messageFiles) {
     onProgress?.({ parsed, total: messageFiles.length, currentProject: "OpenCode messages" });
-    const m = Message.safeParse(await readJson(f));
+    const m = Message.safeParse(await readJson2(f));
     parsed += 1;
     onProgress?.({ parsed, total: messageFiles.length, currentProject: "OpenCode messages" });
     if (!m.success || m.data.role !== "assistant" || !m.data.tokens) continue;
@@ -442,28 +1355,7 @@ async function loadOpencodeProjects(home, onProgress) {
       u.turns += 1;
     }
   }
-  const byDir = /* @__PURE__ */ new Map();
-  for (const s of bySession.values()) {
-    if (Object.keys(s.usageByModel).length === 0) continue;
-    const key = s.cwd ?? "(unknown project)";
-    const list = byDir.get(key) ?? [];
-    list.push(s);
-    byDir.set(key, list);
-  }
-  const out = [];
-  for (const [dir, sessions] of byDir) {
-    out.push({
-      id: `opencode:${dir}`,
-      name: dir,
-      label: dir === "(unknown project)" ? dir : baseName(dir),
-      realPath: dir,
-      report: buildReport(sessions, []),
-      sessions,
-      serverList: []
-    });
-  }
-  out.sort((a, b) => b.report.totalCostUsd - a.report.totalCostUsd);
-  return out;
+  return groupSessionsByCwd("opencode", [...bySession.values()]);
 }
 var opencodeAdapter = {
   id: "opencode",
@@ -471,7 +1363,7 @@ var opencodeAdapter = {
   supported: true,
   async detect(home) {
     try {
-      await access3(join4(opencodeRoot(home), "storage", "message"));
+      await access12(join13(opencodeRoot(home), "storage", "message"));
       return true;
     } catch {
       return false;
@@ -480,19 +1372,130 @@ var opencodeAdapter = {
   loadProjects: loadOpencodeProjects
 };
 
+// src/agents/pi.ts
+import { access as access13 } from "fs/promises";
+import { homedir as homedir14 } from "os";
+import { join as join14 } from "path";
+import { glob as glob9 } from "tinyglobby";
+function piRoot(home) {
+  return process.env.PI_AGENT_DIR ?? join14(home ?? homedir14(), ".pi", "agent", "sessions");
+}
+async function parseFile6(file) {
+  const records = [];
+  for (const line of await readJsonl(file)) {
+    const msg = line.message;
+    const usage = msg?.usage;
+    if (!usage) continue;
+    records.push({
+      model: str(msg, "model") ?? "pi-unknown",
+      ts: str(line, "timestamp"),
+      input: pickNum(usage, ["input"]),
+      output: pickNum(usage, ["output"]),
+      cacheRead: pickNum(usage, ["cacheRead"]),
+      cacheWrite: pickNum(usage, ["cacheWrite"])
+    });
+  }
+  return sessionFromRecords(file, void 0, records);
+}
+async function loadPiProjects(home, onProgress) {
+  const files = await glob9(["**/*.jsonl"], { cwd: piRoot(home), absolute: true }).catch(() => []);
+  const sessions = [];
+  let parsed = 0;
+  for (const f of files) {
+    onProgress?.({ parsed, total: files.length, currentProject: "pi sessions" });
+    sessions.push(await parseFile6(f));
+    parsed += 1;
+    onProgress?.({ parsed, total: files.length, currentProject: "pi sessions" });
+  }
+  return groupSessionsByCwd("pi", sessions);
+}
+var piAdapter = {
+  id: "pi",
+  name: "pi-agent",
+  supported: true,
+  async detect(home) {
+    try {
+      await access13(piRoot(home));
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  loadProjects: loadPiProjects
+};
+
+// src/agents/qwen.ts
+import { access as access14 } from "fs/promises";
+import { homedir as homedir15 } from "os";
+import { join as join15 } from "path";
+import { glob as glob10 } from "tinyglobby";
+function qwenRoot(home) {
+  return process.env.QWEN_DATA_DIR ?? join15(home ?? homedir15(), ".qwen");
+}
+async function parseFile7(file) {
+  const records = [];
+  for (const line of await readJsonl(file)) {
+    const meta = line.usageMetadata;
+    if (!meta) continue;
+    const prompt = pickNum(meta, ["promptTokenCount"]);
+    const cached = pickNum(meta, ["cachedContentTokenCount"]);
+    const reasoning = pickNum(meta, ["thoughtsTokenCount"]);
+    records.push({
+      model: str(line, "model") ?? "qwen-unknown",
+      ts: str(line, "timestamp"),
+      input: Math.max(0, prompt - cached),
+      output: pickNum(meta, ["candidatesTokenCount"]) + reasoning,
+      cacheRead: cached,
+      cacheWrite: 0
+    });
+  }
+  return sessionFromRecords(file, void 0, records);
+}
+async function loadQwenProjects(home, onProgress) {
+  const files = await glob10(["projects/**/*.jsonl"], { cwd: qwenRoot(home), absolute: true }).catch(
+    () => []
+  );
+  const sessions = [];
+  let parsed = 0;
+  for (const f of files) {
+    onProgress?.({ parsed, total: files.length, currentProject: "Qwen sessions" });
+    sessions.push(await parseFile7(f));
+    parsed += 1;
+    onProgress?.({ parsed, total: files.length, currentProject: "Qwen sessions" });
+  }
+  return groupSessionsByCwd("qwen", sessions);
+}
+var qwenAdapter = {
+  id: "qwen",
+  name: "Qwen Code",
+  supported: true,
+  async detect(home) {
+    try {
+      await access14(join15(qwenRoot(home), "projects"));
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  loadProjects: loadQwenProjects
+};
+
 // src/agents/index.ts
-function detectOnly(id, name, ...pathParts) {
+function detectOnly(id, name, reason, ...pathCandidates) {
   return {
     id,
     name,
     supported: false,
-    async detect(home = homedir5()) {
-      try {
-        await access4(join5(home, ...pathParts));
-        return true;
-      } catch {
-        return false;
+    unsupportedReason: reason,
+    async detect(home = homedir16()) {
+      for (const parts of pathCandidates) {
+        try {
+          await access15(join16(home, ...parts));
+          return true;
+        } catch {
+        }
       }
+      return false;
     },
     loadProjects: async () => []
   };
@@ -501,8 +1504,23 @@ var ADAPTERS = [
   claudeAdapter,
   codexAdapter,
   opencodeAdapter,
-  detectOnly("gemini", "Gemini CLI", ".gemini", "tmp"),
-  detectOnly("cursor", "Cursor CLI", ".cursor", "chats")
+  geminiAdapter,
+  qwenAdapter,
+  droidAdapter,
+  codebuffAdapter,
+  openclawAdapter,
+  kimiAdapter,
+  kiloAdapter,
+  gooseAdapter,
+  hermesAdapter,
+  piAdapter,
+  antigravityAdapter,
+  // Detected but not parsed: Copilot uses OpenTelemetry spans, Amp a usage
+  // ledger (formats not wired yet). Cursor is intentionally absent — it stores
+  // no token counts on disk (usage is server-side, reachable only with auth),
+  // which is out of scope for an offline tool.
+  detectOnly("copilot", "GitHub Copilot CLI", "usage is OpenTelemetry spans \u2014 parsing not wired yet", [".copilot", "otel"]),
+  detectOnly("amp", "Amp", "usage-ledger thread format \u2014 parsing not wired yet", [".local", "share", "amp"])
 ];
 async function loadAllAgents(home, onProgress) {
   const out = [];
@@ -529,7 +1547,7 @@ var TIMEFRAMES = [
   { id: "7d", label: "Last 7 days" },
   { id: "30d", label: "Last 30 days" }
 ];
-var isoDay = (offsetDays, now) => new Date(now - offsetDays * 864e5).toISOString().slice(0, 10);
+var isoDay = (offsetDays, now) => dayKey(now - offsetDays * 864e5);
 function timeframeLabel(id) {
   return TIMEFRAMES.find((t) => t.id === id)?.label ?? id;
 }
@@ -589,11 +1607,15 @@ var ART = [
   "   \u2588\u2588    \u2588\u2588    \u2588\u2588 \u2588\u2588  \u2588\u2588   \u2588\u2588     ",
   "   \u2588\u2588     \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588\u2588 "
 ];
-function Banner({ subtitle }) {
+function bannerHeight(mode) {
+  return mode === "full" ? 7 : mode === "tiny" ? 3 : 0;
+}
+function Banner({ subtitle, mode }) {
   const { cols, rows } = useTerminalSize();
-  const tiny = cols < 40 || rows < 18;
+  const resolved = mode ?? (cols < 40 || rows < 18 ? "tiny" : "full");
+  if (resolved === "none") return null;
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
-    tiny ? /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u2590 TOKZ \u258C" }) : ART.map((line, i) => /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: line }, i)),
+    resolved === "tiny" ? /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u2590 TOKZ \u258C" }) : ART.map((line, i) => /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: line }, i)),
     subtitle ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: subtitle }) : null
   ] });
 }
@@ -619,15 +1641,28 @@ function modelColor(modelId) {
   return "white";
 }
 
+// src/ui/viewport.ts
+function windowOffset(cursor, count, height) {
+  if (count <= height) return 0;
+  const centered = cursor - Math.floor(height / 2);
+  return Math.max(0, Math.min(centered, count - height));
+}
+
 // src/ui/AgentPicker.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function status(a) {
   if (a.projects.length > 0) {
     const cost = a.projects.reduce((s, p) => s + p.report.totalCostUsd, 0);
     const sessions = a.projects.reduce((s, p) => s + p.report.sessionCount, 0);
-    return { text: `${a.projects.length} projects \xB7 ${sessions} sessions \xB7 ${usd(cost)}` };
+    const est = a.adapter.estimated ? `~` : "";
+    const tail = a.adapter.estimated ? " \xB7 estimated" : "";
+    return { text: `${a.projects.length} projects \xB7 ${sessions} sessions \xB7 ${est}${usd(cost)}${tail}` };
   }
-  if (a.detected && !a.adapter.supported) return { text: "detected \xB7 parsing not supported yet", color: theme.warn };
+  if (a.detected && !a.adapter.supported)
+    return {
+      text: `detected \xB7 ${a.adapter.unsupportedReason ?? "parsing not supported yet"}`,
+      color: theme.warn
+    };
   if (a.detected) return { text: "detected \xB7 no usage data", dim: true };
   return { text: "not detected", dim: true };
 }
@@ -638,33 +1673,43 @@ function AgentPicker({
   const selectable = agents.map((a, i) => ({ a, i })).filter(({ a }) => a.projects.length > 0).map(({ i }) => i);
   const [cursor, setCursor] = useState2(0);
   const clamped = Math.min(cursor, Math.max(0, selectable.length - 1));
+  const { cols, rows } = useTerminalSize();
   useInput((_input, key) => {
     if (key.upArrow) setCursor(() => Math.max(0, clamped - 1));
     if (key.downArrow) setCursor(() => Math.min(selectable.length - 1, clamped + 1));
     if (key.return && selectable[clamped] !== void 0) onSelect(selectable[clamped]);
   });
   const nameW = Math.max(...agents.map((a) => a.adapter.name.length)) + 2;
+  const FIXED_CHROME = 9;
+  const LIST_MIN = 3;
+  const forcedTiny = cols < 40;
+  const bannerBudget = rows - FIXED_CHROME - LIST_MIN;
+  const bannerMode = !forcedTiny && bannerBudget >= 7 ? "full" : bannerBudget >= 3 ? "tiny" : "none";
+  const visibleRows = Math.max(1, rows - FIXED_CHROME - bannerHeight(bannerMode));
+  const selectedDisplayIdx = selectable[clamped] ?? 0;
+  const offset = windowOffset(selectedDisplayIdx, agents.length, visibleRows);
+  const visible = agents.slice(offset, offset + visibleRows);
+  const hiddenBelow = agents.length - offset - visible.length;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsx2(Banner, { subtitle: "where your agents' tokens and dollars go \xB7 100% offline" }),
+    /* @__PURE__ */ jsx2(Banner, { subtitle: "where your agents' tokens and dollars actually go", mode: bannerMode }),
     /* @__PURE__ */ jsx2(Text2, { bold: true, color: theme.accent, children: "Pick an agent" }),
     /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, marginTop: 1, children: [
-      agents.map((a, i) => {
+      visible.map((a, vi) => {
+        const i = offset + vi;
         const st = status(a);
         const selected = selectable[clamped] === i;
         const selectableRow = a.projects.length > 0;
         return /* @__PURE__ */ jsxs2(Text2, { bold: selected, children: [
           /* @__PURE__ */ jsx2(Text2, { color: selected ? theme.accent : void 0, children: selected ? "\u25B8 " : "  " }),
-          /* @__PURE__ */ jsx2(
-            Text2,
-            {
-              color: selected ? theme.accent : selectableRow ? void 0 : void 0,
-              dimColor: !selectableRow,
-              children: a.adapter.name.padEnd(nameW)
-            }
-          ),
+          /* @__PURE__ */ jsx2(Text2, { color: selected ? theme.accent : void 0, dimColor: !selectableRow, children: a.adapter.name.padEnd(nameW) }),
           /* @__PURE__ */ jsx2(Text2, { color: st.color, dimColor: st.dim, children: st.text })
         ] }, a.adapter.id);
       }),
+      agents.length > visibleRows ? /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        offset > 0 ? `\u2191 ${offset} above` : "",
+        offset > 0 && hiddenBelow > 0 ? " \xB7 " : "",
+        hiddenBelow > 0 ? `\u2193 ${hiddenBelow} below` : ""
+      ] }) : null,
       selectable.length === 0 ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "no agent usage data found on this machine" }) : null
     ] })
   ] });
@@ -740,7 +1785,7 @@ function Menu({
     /* @__PURE__ */ jsx5(
       Banner,
       {
-        subtitle: `${agentName ? `${agentName} \xB7 ` : ""}where your agent's tokens and dollars go \xB7 100% offline`
+        subtitle: `${agentName ? `${agentName} \xB7 ` : ""}where your agent's tokens and dollars go`
       }
     ),
     /* @__PURE__ */ jsx5(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx5(
@@ -891,12 +1936,13 @@ function ProjectList({
   const fixed = COST_W + (showSess ? SESS_W : 0) + (showWhen ? WHEN_W : 0) + (showBar ? BAR_W + 2 : 0);
   const nameW = Math.max(10, Math.min(42, avail - fixed - 2));
   const barW = showBar ? Math.min(BAR_W + Math.max(0, avail - fixed - 2 - nameW), 30) : 0;
-  const visibleRows = Math.max(4, Math.min(20, rows - 10));
+  const CHROME_ROWS = 11;
+  const visibleRows = Math.max(3, rows - CHROME_ROWS);
   const clip = (s) => s.length > nameW ? s.slice(0, nameW - 1) + "\u2026" : s;
   const total = projects.reduce((s, p) => s + p.report.totalCostUsd, 0);
   const max = Math.max(0, ...projects.map((p) => p.report.totalCostUsd));
   const projCursor = clamped - (pinnedShown ? 1 : 0);
-  const offset = Math.max(0, Math.min(projCursor - Math.floor(visibleRows / 2), filtered.length - visibleRows));
+  const offset = windowOffset(Math.max(0, projCursor), filtered.length, visibleRows);
   const visible = filtered.slice(offset, offset + visibleRows);
   const line = (label, sess, when, cost, share, selected) => (selected ? "\u25B8 " : "  ") + clip(label).padEnd(nameW) + (showSess ? sess.padStart(SESS_W) : "") + (showWhen ? when.padStart(WHEN_W) : "") + cost.padStart(COST_W) + (showBar ? "  " + share : "");
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, children: [
@@ -1188,24 +2234,33 @@ function Sessions({ r, cols }) {
     ] }) : null
   ] });
 }
-function Activity({ r, chartW, cols }) {
-  const days = lastDays(r, 21).filter((d, i, all) => d.costUsd > 0 || i >= all.length - 14);
+function Activity({
+  r,
+  chartW,
+  cols,
+  grouping
+}) {
+  if (r.daily.length === 0) return /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "no dated activity" });
   const wide = cols >= 66;
-  const rows = days.slice(-16).map((d) => ({
-    label: `${d.date} ${relativeDate(d.date) === "today" ? "\u25C2" : " "}`,
+  const source = grouping === "day" ? lastDays(r, 21).filter((d, i, all) => d.costUsd > 0 || i >= all.length - 14) : groupDaily(r.daily, grouping);
+  const rows = source.slice(-16).map((d) => ({
+    label: grouping === "day" ? `${d.date} ${relativeDate(d.date) === "today" ? "\u25C2" : " "}` : grouping === "week" ? `wk ${d.date}` : d.date,
     value: d.costUsd,
     display: d.costUsd > 0 ? wide ? `${usd(d.costUsd)} \xB7 ${compact(d.turns)} turns` : usd(d.costUsd) : "\u2014"
   }));
-  if (r.daily.length === 0) return /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "no dated activity" });
   const avg = r.totalCostUsd / Math.max(1, r.daily.length);
   return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx8(BarChart, { rows, width: chartW }),
     /* @__PURE__ */ jsx8(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text8, { dimColor: true, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: theme.accent, children: "g" }),
+      " group: ",
+      grouping,
+      " \xB7 ",
       r.daily.length,
-      " active days \xB7 avg ",
-      usd(avg),
-      "/active day \xB7 projected",
+      " active days \xB7 avg",
       " ",
+      usd(avg),
+      "/active day \xB7 projected ",
       usd(r.monthlyProjectionUsd),
       "/mo"
     ] }) })
@@ -1217,12 +2272,15 @@ function Dashboard({
   timeframe
 }) {
   const [tab, setTab] = useState4(initialTab);
+  const [grouping, setGrouping] = useState4("day");
   const { cols } = useTerminalSize();
   useInput3((input, key) => {
     const n = Number.parseInt(input, 10);
     if (n >= 1 && n <= TABS.length) setTab(n - 1);
     if (key.rightArrow) setTab((t) => (t + 1) % TABS.length);
     if (key.leftArrow) setTab((t) => (t + TABS.length - 1) % TABS.length);
+    if (input === "g")
+      setGrouping((g) => g === "day" ? "week" : g === "week" ? "month" : "day");
   });
   const r = project.report;
   const span = r.spanStart && r.spanEnd ? `${r.spanStart} \u2192 ${r.spanEnd}` : `${r.spanDays}d`;
@@ -1255,7 +2313,7 @@ function Dashboard({
       tab === 2 ? /* @__PURE__ */ jsx8(Tools, { r, chartW, cols }) : null,
       tab === 3 ? /* @__PURE__ */ jsx8(Servers, { r, cols }) : null,
       tab === 4 ? /* @__PURE__ */ jsx8(Sessions, { r, cols }) : null,
-      tab === 5 ? /* @__PURE__ */ jsx8(Activity, { r, chartW, cols }) : null
+      tab === 5 ? /* @__PURE__ */ jsx8(Activity, { r, chartW, cols, grouping }) : null
     ] })
   ] });
 }
@@ -1270,6 +2328,7 @@ var KEYS = [
   ["/", "filter project list (esc clears)"],
   ["s", "cycle project sort: cost \xB7 recent \xB7 name"],
   ["t", "cycle timeframe: all \xB7 today \xB7 yesterday \xB7 7d \xB7 30d"],
+  ["g", "Activity tab: group by day \xB7 week \xB7 month"],
   ["esc", "go back"],
   ["?", "toggle this help"],
   ["q", "quit"]
@@ -1339,7 +2398,8 @@ function App({
     [activeProjects, timeframe]
   );
   const totals = useMemo2(() => aggregate(scoped), [scoped]);
-  const agentName = agentList[agentIdx]?.adapter.name ?? "";
+  const activeAdapter = agentList[agentIdx]?.adapter;
+  const agentName = activeAdapter ? activeAdapter.name + (activeAdapter.estimated ? " (estimated)" : "") : "";
   useInput4((input, key) => {
     if (help) {
       setHelp(false);
@@ -1472,7 +2532,7 @@ function Root() {
   }, [empty, exit]);
   if (!agents) {
     return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", paddingX: 1, children: [
-      /* @__PURE__ */ jsx11(Banner, { subtitle: "where your agents' tokens and dollars go \xB7 100% offline" }),
+      /* @__PURE__ */ jsx11(Banner, { subtitle: "where your agents' tokens and dollars go" }),
       /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
         /* @__PURE__ */ jsxs10(Text11, { children: [
           /* @__PURE__ */ jsx11(Text11, { color: theme.accent, children: SPINNER[frame % SPINNER.length] }),