@tokz/cli 0.2.3 → 0.2.4

package/README.md

@@ -4,9 +4,14 @@ Audit where your coding agents' context windows — and API dollars — actually
 
 Supports multiple agentic coders: **Claude Code** (`~/.claude/projects`),
 **OpenAI Codex CLI** (`~/.codex/sessions` rollout files, cumulative
-token-count deltas), and **OpenCode** (`~/.local/share/opencode/storage`).
-Gemini CLI and Cursor CLI are detected and listed; their session formats
-aren't parsed yet. The TUI opens with an agent picker — choose which agent's
+token-count deltas), **OpenCode** (`~/.local/share/opencode/storage`), and
+**Antigravity CLI** (`~/.gemini/antigravity-cli`). Antigravity stores no
+token counts on disk, so its numbers are *estimates*: per-model turn counts
+are read from the conversation databases' generation-metadata records,
+projects and dates from `history.jsonl`, and tokens are derived from
+conversation content size (~4 chars/token) — the UI labels it "estimated"
+everywhere. Cursor CLI is detected and listed with the reason it can't be
+parsed yet. The TUI opens with an agent picker — choose which agent's
 analytics to explore; everything downstream (projects, dashboards,
 timeframes) is scoped to it.
 
@@ -14,11 +19,55 @@ timeframes) is scoped to it.
 npx @tokz/cli             # interactive TUI: browse projects, drill into charts
 npx @tokz/cli audit       # static report for the current project
 npx @tokz/cli audit --all # static report across every project on this machine
+npx @tokz/cli blocks      # Claude usage by rolling 5-hour billing window
 
 npm i -g @tokz/cli        # installs the `tokz` command
 tokz                      # then just: tokz
 ```
 
+## Blocks (5-hour billing windows)
+
+`tokz blocks` groups Claude usage into the rolling 5-hour windows Claude's
+usage limits operate on: one row per block with models, total tokens, and
+cost, plus burn rate (tok/min and $/hr), projected tokens/cost by block end,
+and time remaining for the active block. `--active` shows only the current
+block, `--recent` the last 3 days, `--token-limit N` (or `max` — your
+biggest past block) adds ⚠️/🚨 warnings, `--session-length H` changes the
+window, `--json` for raw output.
+
+## Statusline for Claude Code
+
+`tokz statusline` renders one compact line for Claude Code's status bar —
+model, session cost, today's total, active block cost with time left, burn
+rate, and context usage with percentage. One command wires it up:
+
+```bash
+tokz statusline enable    # writes the hook into ~/.claude/settings.json
+tokz statusline disable   # removes it (only if it's tokz's)
+```
+
+`enable` preserves everything else in your settings file (and refuses to
+touch one it can't parse); it's equivalent to:
+
+```json
+{
+  "statusLine": { "type": "command", "command": "npx -y @tokz/cli statusline" }
+}
+```
+
+It reads only transcripts touched in the last few hours and never fetches
+pricing from the network on this path, so it stays fast.
+
+## Dates, ranges, and timezones
+
+- `tokz audit --since 2026-07-01 --until 2026-07-15` — any inclusive date
+  range (also accepts `YYYYMMDD`); `--days N` still works.
+- `tokz audit --weekly` / `--monthly` — appends an activity table rolled up
+  by ISO week (keyed by its Monday) or calendar month. In the TUI the
+  Activity tab cycles day · week · month with `g`.
+- `tokz --timezone local audit …` — group days in your system timezone, or
+  any IANA zone (`--timezone Asia/Amman`); default is UTC.
+
 ## Interactive TUI
 
 Bare `tokz` launches a full-screen terminal UI (Ink) with a live parse

package/dist/{Root-6SZ5FQDN.js → Root-WEIYEE6M.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 access5 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join6 } 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";
 
@@ -175,14 +179,187 @@ 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);
+  }
+  const byDir = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const key = s.cwd ?? "(unknown project)";
+    const list = byDir.get(key) ?? [];
+    list.push(s);
+    byDir.set(key, list);
+  }
+  const out = [];
+  for (const [dir, list] of byDir) {
+    out.push({
+      id: `antigravity:${dir}`,
+      name: dir,
+      label: dir === "(unknown project)" ? dir : baseName(dir),
+      realPath: dir,
+      report: buildReport(list, []),
+      sessions: list,
+      serverList: []
+    });
+  }
+  out.sort((a, b) => b.report.totalCostUsd - a.report.totalCostUsd);
+  return out;
+}
+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;
@@ -193,10 +370,10 @@ var claudeAdapter = {
 
 // src/agents/codex.ts
 import { createReadStream } from "fs";
-import { access as access2 } from "fs/promises";
+import { access as access3 } from "fs/promises";
 import { createInterface } from "readline";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 import { glob as glob2 } from "tinyglobby";
 import { z } from "zod";
 var TokenTotals = z.object({
@@ -220,8 +397,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 join4(home, ".codex");
+  return process.env.CODEX_HOME ?? join4(homedir4(), ".codex");
 }
 var DEFAULT_MODEL = "gpt-5";
 async function parseCodexRollout(file) {
@@ -337,7 +514,7 @@ var codexAdapter = {
   supported: true,
   async detect(home) {
     try {
-      await access2(join3(codexHome(home), "sessions"));
+      await access3(join4(codexHome(home), "sessions"));
       return true;
     } catch {
       return false;
@@ -347,9 +524,9 @@ var codexAdapter = {
 };
 
 // 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 { access as access4, readFile as readFile3 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
 import { glob as glob3 } from "tinyglobby";
 import { z as z2 } from "zod";
 var Message = z2.object({
@@ -373,19 +550,19 @@ 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 join5(home, ".local", "share", "opencode");
+  return process.env.OPENCODE_DATA_DIR ?? join5(homedir5(), ".local", "share", "opencode");
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await readFile2(file, "utf8"));
+    return JSON.parse(await readFile3(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 async function loadOpencodeProjects(home, onProgress) {
   const root = opencodeRoot(home);
-  const storage = join4(root, "storage");
+  const storage = join5(root, "storage");
   const messageFiles = await glob3(["message/*/*.json"], { cwd: storage, absolute: true }).catch(
     () => []
   );
@@ -471,7 +648,7 @@ var opencodeAdapter = {
   supported: true,
   async detect(home) {
     try {
-      await access3(join4(opencodeRoot(home), "storage", "message"));
+      await access4(join5(opencodeRoot(home), "storage", "message"));
       return true;
     } catch {
       return false;
@@ -481,14 +658,15 @@ var opencodeAdapter = {
 };
 
 // src/agents/index.ts
-function detectOnly(id, name, ...pathParts) {
+function detectOnly(id, name, reason, ...pathParts) {
   return {
     id,
     name,
     supported: false,
-    async detect(home = homedir5()) {
+    unsupportedReason: reason,
+    async detect(home = homedir6()) {
       try {
-        await access4(join5(home, ...pathParts));
+        await access5(join6(home, ...pathParts));
         return true;
       } catch {
         return false;
@@ -501,8 +679,8 @@ var ADAPTERS = [
   claudeAdapter,
   codexAdapter,
   opencodeAdapter,
-  detectOnly("gemini", "Gemini CLI", ".gemini", "tmp"),
-  detectOnly("cursor", "Cursor CLI", ".cursor", "chats")
+  antigravityAdapter,
+  detectOnly("cursor", "Cursor CLI", "sessions live in SQLite; parsing not supported yet", ".cursor", "chats")
 ];
 async function loadAllAgents(home, onProgress) {
   const out = [];
@@ -529,7 +707,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;
 }
@@ -625,9 +803,15 @@ 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 };
 }
@@ -1188,24 +1372,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 +1410,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 +1451,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 +1466,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 +1536,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);

package/dist/chunk-65BQE6TI.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+// src/mcp.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+async function readJson(file) {
+  try {
+    return JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function serverNames(obj) {
+  if (obj && typeof obj === "object" && !Array.isArray(obj)) return Object.keys(obj);
+  return [];
+}
+async function findMcpServers(projectPath, home = homedir()) {
+  const out = /* @__PURE__ */ new Map();
+  const add = (names, source) => {
+    for (const name of names) if (!out.has(name)) out.set(name, { name, source });
+  };
+  const projectFile = join(projectPath, ".mcp.json");
+  const projectCfg = await readJson(projectFile);
+  add(serverNames(projectCfg?.mcpServers), projectFile);
+  const globalFile = join(home, ".claude.json");
+  const globalCfg = await readJson(globalFile);
+  add(serverNames(globalCfg?.mcpServers), globalFile);
+  const projects = globalCfg?.projects;
+  if (projects && typeof projects === "object") {
+    const entry = projects[projectPath];
+    add(serverNames(entry?.mcpServers), `${globalFile} (project entry)`);
+  }
+  return [...out.values()];
+}
+
+export {
+  findMcpServers
+};

package/dist/chunk-6Y6MKFHZ.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import {
+  addUsage,
+  compact,
+  costUsd,
+  emptyUsage,
+  shortModel,
+  usd
+} from "./chunk-Z5W5QH2Z.js";
+
+// src/blocks.ts
+var BLOCK_LENGTH_MS = 5 * 60 * 60 * 1e3;
+var HOUR_MS = 60 * 60 * 1e3;
+function finalize(b) {
+  for (const [model, u] of Object.entries(b.usageByModel)) {
+    b.totalTokens += u.inputTokens + u.cacheReadTokens + u.cacheCreationTokens + u.outputTokens;
+    b.costUsd += costUsd(u, model).total;
+  }
+  return b;
+}
+function buildBlocks(events, opts) {
+  const len = opts?.sessionLengthMs ?? BLOCK_LENGTH_MS;
+  const now = opts?.now ?? Date.now();
+  const sorted = [...events].sort((a, b) => a.ts - b.ts);
+  const blocks = [];
+  let cur;
+  for (const e of sorted) {
+    if (!cur || e.ts >= cur.end) {
+      if (cur) blocks.push(finalize(cur));
+      const start = Math.floor(e.ts / HOUR_MS) * HOUR_MS;
+      cur = {
+        start,
+        end: start + len,
+        firstTs: e.ts,
+        lastTs: e.ts,
+        usageByModel: {},
+        totalTokens: 0,
+        costUsd: 0,
+        active: false
+      };
+    }
+    cur.lastTs = Math.max(cur.lastTs, e.ts);
+    addUsage(cur.usageByModel[e.model] ??= emptyUsage(), e.usage);
+  }
+  if (cur) {
+    cur.active = now < cur.end;
+    blocks.push(finalize(cur));
+  }
+  return blocks;
+}
+function burnRate(b, now = Date.now()) {
+  if (!b.active) return void 0;
+  const elapsed = Math.max(6e4, now - b.firstTs);
+  const remainingMs = Math.max(0, b.end - now);
+  const tokensPerMinute = b.totalTokens / (elapsed / 6e4);
+  const costPerHour = b.costUsd / (elapsed / HOUR_MS);
+  return {
+    tokensPerMinute,
+    costPerHour,
+    projectedTokens: Math.round(b.totalTokens + tokensPerMinute * (remainingMs / 6e4)),
+    projectedCostUsd: b.costUsd + costPerHour * (remainingMs / HOUR_MS),
+    remainingMs
+  };
+}
+function maxBlockTokens(blocks) {
+  return blocks.filter((b) => !b.active).reduce((m, b) => Math.max(m, b.totalTokens), 0);
+}
+
+// src/blocksReport.ts
+import Table from "cli-table3";
+import pc from "picocolors";
+function fmtMs(ms) {
+  const mins = Math.round(ms / 6e4);
+  if (mins < 1) return "<1m";
+  if (mins < 60) return `${mins}m`;
+  const h = Math.floor(mins / 60);
+  const m = mins % 60;
+  return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+function fmtStart(ms) {
+  const d = new Date(ms);
+  return `${d.toISOString().slice(0, 10)} ${d.toISOString().slice(11, 16)} UTC`;
+}
+function renderBlocksReport(blocks, opts) {
+  if (blocks.length === 0) return "No Claude Code activity found.";
+  const now = opts?.now ?? Date.now();
+  const limit = opts?.tokenLimit === "max" ? maxBlockTokens(blocks) : opts?.tokenLimit;
+  const parts = [];
+  parts.push(
+    pc.bold(`tokz blocks \u2014 ${blocks.length} \xD7 5-hour billing windows`) + pc.dim("  (Claude usage limits reset per rolling 5h block)")
+  );
+  const table = new Table({ head: ["Block start", "Status", "Models", "Tokens", "Cost"] });
+  for (const b of blocks) {
+    const models = [...new Set(Object.keys(b.usageByModel).map(shortModel))].join(", ");
+    const status = b.active ? pc.green(`ACTIVE \xB7 ${fmtMs(b.end - now)} left`) : pc.dim(`done \xB7 ${fmtMs(b.lastTs - b.firstTs)}`);
+    const tokens = limit && b.totalTokens > limit ? pc.red(`${compact(b.totalTokens)} \u{1F6A8}`) : limit && b.totalTokens > limit * 0.8 ? pc.yellow(`${compact(b.totalTokens)} \u26A0\uFE0F`) : compact(b.totalTokens);
+    table.push([fmtStart(b.start), status, models, tokens, usd(b.costUsd)]);
+  }
+  parts.push(table.toString());
+  const active = blocks.find((b) => b.active);
+  const rate = active ? burnRate(active, now) : void 0;
+  if (active && rate) {
+    const lines = [
+      pc.bold("Active block") + ` \u2014 started ${fmtStart(active.start)}, ${pc.green(fmtMs(rate.remainingMs))} remaining`,
+      `  burn rate   ${compact(Math.round(rate.tokensPerMinute))} tok/min \xB7 ${usd(rate.costPerHour)}/hr`,
+      `  projected   ${compact(rate.projectedTokens)} tokens \xB7 ${usd(rate.projectedCostUsd)} by block end`
+    ];
+    if (limit) {
+      const over = rate.projectedTokens > limit;
+      const nearing = !over && active.totalTokens > limit * 0.8;
+      lines.push(
+        `  limit       ${compact(limit)} tokens \u2014 ` + (over ? pc.red(`\u{1F6A8} projected to exceed (${compact(rate.projectedTokens)})`) : nearing ? pc.yellow(`\u26A0\uFE0F ${Math.round(active.totalTokens / limit * 100)}% used`) : pc.green(`${Math.round(active.totalTokens / limit * 100)}% used`))
+      );
+    }
+    parts.push(lines.join("\n"));
+  }
+  return parts.join("\n\n");
+}
+
+export {
+  buildBlocks,
+  burnRate,
+  fmtMs,
+  renderBlocksReport
+};

package/dist/{chunk-JAZOB7NC.js → chunk-Z5W5QH2Z.js}

@@ -12,6 +12,11 @@ var PRICES = {
   "claude-sonnet-4-6": { inputPerMTok: 3, outputPerMTok: 15 },
   "claude-haiku-4-5": { inputPerMTok: 1, outputPerMTok: 5 },
   // OpenAI (no cache-write charge; cached input 0.1x)
+  "gpt-5.6-sol": { inputPerMTok: 5, outputPerMTok: 30, cacheWriteMult: 0 },
+  "gpt-5.6-terra": { inputPerMTok: 2.5, outputPerMTok: 15, cacheWriteMult: 0 },
+  "gpt-5.6-luna": { inputPerMTok: 1, outputPerMTok: 6, cacheWriteMult: 0 },
+  "gpt-5.5-pro": { inputPerMTok: 30, outputPerMTok: 180, cacheWriteMult: 0, cacheReadMult: 1 },
+  "gpt-5.5": { inputPerMTok: 5, outputPerMTok: 30, cacheWriteMult: 0 },
   "gpt-5-codex": { inputPerMTok: 1.25, outputPerMTok: 10, cacheWriteMult: 0 },
   "gpt-5-mini": { inputPerMTok: 0.25, outputPerMTok: 2, cacheWriteMult: 0 },
   "gpt-5-nano": { inputPerMTok: 0.05, outputPerMTok: 0.4, cacheWriteMult: 0 },
@@ -22,6 +27,8 @@ var PRICES = {
   "o4-mini": { inputPerMTok: 1.1, outputPerMTok: 4.4, cacheWriteMult: 0, cacheReadMult: 0.25 },
   o3: { inputPerMTok: 2, outputPerMTok: 8, cacheWriteMult: 0, cacheReadMult: 0.25 },
   // Google
+  "gemini-3.1-pro": { inputPerMTok: 2, outputPerMTok: 12, cacheWriteMult: 0 },
+  "gemini-3.5-flash": { inputPerMTok: 1.5, outputPerMTok: 9, cacheWriteMult: 0 },
   "gemini-2.5-pro": { inputPerMTok: 1.25, outputPerMTok: 10, cacheWriteMult: 0 },
   "gemini-2.5-flash": { inputPerMTok: 0.3, outputPerMTok: 2.5, cacheWriteMult: 0 }
 };
@@ -29,17 +36,29 @@ var DEFAULT_CACHE_READ_MULT = 0.1;
 var DEFAULT_CACHE_WRITE_MULT = 1.25;
 var CLAUDE_FALLBACK = PRICES["claude-opus-4-8"];
 var UNKNOWN = { inputPerMTok: 0, outputPerMTok: 0 };
-function resolvePrice(modelId) {
+var livePrices = {};
+var resolveCache = /* @__PURE__ */ new Map();
+function setLivePrices(prices) {
+  livePrices = prices;
+  resolveCache.clear();
+}
+function longestPrefix(modelId, table) {
   let best;
   let bestLen = -1;
-  for (const [prefix, price] of Object.entries(PRICES)) {
+  for (const [prefix, price] of Object.entries(table)) {
     if (modelId.startsWith(prefix) && prefix.length > bestLen) {
       best = price;
       bestLen = prefix.length;
     }
   }
-  if (best) return best;
-  return modelId.startsWith("claude") ? CLAUDE_FALLBACK : UNKNOWN;
+  return best;
+}
+function resolvePrice(modelId) {
+  const hit = resolveCache.get(modelId);
+  if (hit) return hit;
+  const price = livePrices[modelId] ?? longestPrefix(modelId, PRICES) ?? longestPrefix(modelId, livePrices) ?? (modelId.startsWith("claude") ? CLAUDE_FALLBACK : UNKNOWN);
+  resolveCache.set(modelId, price);
+  return price;
 }
 function emptyUsage() {
   return { inputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, outputTokens: 0, turns: 0 };
@@ -53,7 +72,8 @@ function costUsd(usage, modelId) {
   const cacheRead = usage.cacheReadTokens / 1e6 * p.inputPerMTok * readMult;
   const write1h = Math.min(usage.cacheCreation1hTokens ?? 0, usage.cacheCreationTokens);
   const write5m = usage.cacheCreationTokens - write1h;
-  const cacheWrite = write5m / 1e6 * p.inputPerMTok * writeMult + write1h / 1e6 * p.inputPerMTok * (p.cacheWriteMult ?? CACHE_WRITE_1H_MULT);
+  const write1hMult = p.cacheWrite1hMult ?? (p.cacheWriteMult === 0 ? 0 : CACHE_WRITE_1H_MULT);
+  const cacheWrite = write5m / 1e6 * p.inputPerMTok * writeMult + write1h / 1e6 * p.inputPerMTok * write1hMult;
   const output = usage.outputTokens / 1e6 * p.outputPerMTok;
   return { input, cacheRead, cacheWrite, output, total: input + cacheRead + cacheWrite + output };
 }
@@ -220,6 +240,85 @@ function buildReport(sessions, servers, range) {
   };
 }
 
+// src/format.ts
+var usd = (n) => `$${n.toFixed(2)}`;
+var tok = (n) => n.toLocaleString("en-US");
+function compact(n) {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+var pct = (fraction) => `${Math.round(fraction * 100)}%`;
+var pct1 = (fraction) => `${(fraction * 100).toFixed(1)}%`;
+var shortModel = (id) => id.replace(/^claude-/, "").replace(/-\d{8}$/, "");
+function duration(startIso, endIso) {
+  if (!startIso || !endIso) return "\u2014";
+  const mins = Math.round((Date.parse(endIso) - Date.parse(startIso)) / 6e4);
+  if (mins < 1) return "<1m";
+  if (mins < 60) return `${mins}m`;
+  const h = Math.floor(mins / 60);
+  const m = mins % 60;
+  return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+function relativeDate(iso, now = Date.now()) {
+  if (!iso) return "\u2014";
+  const date = iso.slice(0, 10);
+  const days = Math.floor((now - Date.parse(date)) / 864e5);
+  if (days <= 0) return "today";
+  if (days === 1) return "yesterday";
+  if (days < 30) return `${days}d ago`;
+  return date;
+}
+
+// src/dates.ts
+var zone;
+var formatter;
+function setTimezone(tz) {
+  zone = tz === "utc" || tz === void 0 ? void 0 : tz;
+  formatter = zone ? new Intl.DateTimeFormat("en-CA", {
+    timeZone: zone === "local" ? void 0 : zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }) : void 0;
+}
+function dayKey(ts) {
+  if (!formatter) return typeof ts === "string" ? ts.slice(0, 10) : new Date(ts).toISOString().slice(0, 10);
+  return formatter.format(typeof ts === "string" ? new Date(ts) : ts);
+}
+function weekKey(day) {
+  const d = /* @__PURE__ */ new Date(`${day}T00:00:00Z`);
+  const dow = (d.getUTCDay() + 6) % 7;
+  d.setUTCDate(d.getUTCDate() - dow);
+  return d.toISOString().slice(0, 10);
+}
+function monthKey(day) {
+  return day.slice(0, 7);
+}
+function groupDaily(daily, unit) {
+  if (unit === "day") return daily;
+  const keyOf = unit === "week" ? weekKey : monthKey;
+  const out = /* @__PURE__ */ new Map();
+  for (const d of daily) {
+    const key = keyOf(d.date);
+    const acc = out.get(key) ?? { date: key, costUsd: 0, inputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, outputTokens: 0, turns: 0 };
+    acc.costUsd += d.costUsd;
+    acc.inputTokens += d.inputTokens;
+    acc.cacheReadTokens += d.cacheReadTokens;
+    acc.cacheCreationTokens += d.cacheCreationTokens;
+    acc.outputTokens += d.outputTokens;
+    acc.turns += d.turns;
+    out.set(key, acc);
+  }
+  return [...out.values()].sort((a, b) => a.date < b.date ? -1 : 1);
+}
+function parseDateArg(raw) {
+  if (!raw) return void 0;
+  const m = /^(\d{4})-?(\d{2})-?(\d{2})$/.exec(raw.trim());
+  return m ? `${m[1]}-${m[2]}-${m[3]}` : void 0;
+}
+
 // src/discover.ts
 import { homedir } from "os";
 import { join } from "path";
@@ -235,40 +334,6 @@ async function findTranscripts(projectPath, home = homedir()) {
   return glob(["**/*.jsonl"], { cwd, absolute: true }).catch(() => []);
 }
 
-// src/mcp.ts
-import { readFile } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-async function readJson(file) {
-  try {
-    return JSON.parse(await readFile(file, "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function serverNames(obj) {
-  if (obj && typeof obj === "object" && !Array.isArray(obj)) return Object.keys(obj);
-  return [];
-}
-async function findMcpServers(projectPath, home = homedir2()) {
-  const out = /* @__PURE__ */ new Map();
-  const add = (names, source) => {
-    for (const name of names) if (!out.has(name)) out.set(name, { name, source });
-  };
-  const projectFile = join2(projectPath, ".mcp.json");
-  const projectCfg = await readJson(projectFile);
-  add(serverNames(projectCfg?.mcpServers), projectFile);
-  const globalFile = join2(home, ".claude.json");
-  const globalCfg = await readJson(globalFile);
-  add(serverNames(globalCfg?.mcpServers), globalFile);
-  const projects = globalCfg?.projects;
-  if (projects && typeof projects === "object") {
-    const entry = projects[projectPath];
-    add(serverNames(entry?.mcpServers), `${globalFile} (project entry)`);
-  }
-  return [...out.values()];
-}
-
 // src/transcript.ts
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
@@ -293,7 +358,7 @@ var AssistantLine = z.object({
     content: z.array(z.object({ type: z.string(), id: z.string().optional(), name: z.string().optional() }).passthrough()).optional()
   })
 });
-async function parseTranscript(file, seenMessages = /* @__PURE__ */ new Map(), seenToolIds = /* @__PURE__ */ new Set()) {
+async function parseTranscript(file, seenMessages = /* @__PURE__ */ new Map(), seenToolIds = /* @__PURE__ */ new Set(), events) {
   const stats = { file, usageByModel: {}, toolCalls: {}, toolCostUsd: {}, dailyUsage: {} };
   const rl = createInterface({ input: createReadStream(file, "utf8"), crlfDelay: Infinity });
   for await (const line of rl) {
@@ -345,8 +410,9 @@ async function parseTranscript(file, seenMessages = /* @__PURE__ */ new Map(), s
       if (hasDelta) {
         const accs = [stats.usageByModel[model] ??= emptyUsage()];
         if (timestamp) {
-          const day = stats.dailyUsage[timestamp.slice(0, 10)] ??= {};
+          const day = stats.dailyUsage[dayKey(timestamp)] ??= {};
           accs.push(day[model] ??= emptyUsage());
+          events?.push({ ts: Date.parse(timestamp), model, usage: delta });
         }
         for (const acc of accs) {
           acc.inputTokens += delta.inputTokens;
@@ -379,47 +445,14 @@ async function parseTranscript(file, seenMessages = /* @__PURE__ */ new Map(), s
   return stats;
 }
 
-// src/format.ts
-var usd = (n) => `$${n.toFixed(2)}`;
-var tok = (n) => n.toLocaleString("en-US");
-function compact(n) {
-  if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
-  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
-  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
-  return String(n);
-}
-var pct = (fraction) => `${Math.round(fraction * 100)}%`;
-var pct1 = (fraction) => `${(fraction * 100).toFixed(1)}%`;
-var shortModel = (id) => id.replace(/^claude-/, "").replace(/-\d{8}$/, "");
-function duration(startIso, endIso) {
-  if (!startIso || !endIso) return "\u2014";
-  const mins = Math.round((Date.parse(endIso) - Date.parse(startIso)) / 6e4);
-  if (mins < 1) return "<1m";
-  if (mins < 60) return `${mins}m`;
-  const h = Math.floor(mins / 60);
-  const m = mins % 60;
-  return m > 0 ? `${h}h ${m}m` : `${h}h`;
-}
-function relativeDate(iso, now = Date.now()) {
-  if (!iso) return "\u2014";
-  const date = iso.slice(0, 10);
-  const days = Math.floor((now - Date.parse(date)) / 864e5);
-  if (days <= 0) return "today";
-  if (days === 1) return "yesterday";
-  if (days < 30) return `${days}d ago`;
-  return date;
-}
-
 export {
+  setLivePrices,
   emptyUsage,
   costUsd,
   addUsage,
   cacheSavings,
   cacheHitRate,
   buildReport,
-  sanitizeProjectPath,
-  findTranscripts,
-  findMcpServers,
   usd,
   tok,
   compact,
@@ -428,5 +461,11 @@ export {
   shortModel,
   duration,
   relativeDate,
+  setTimezone,
+  dayKey,
+  groupDaily,
+  parseDateArg,
+  sanitizeProjectPath,
+  findTranscripts,
   parseTranscript
 };

package/dist/cli.js

@@ -1,21 +1,107 @@
 #!/usr/bin/env node
+import {
+  buildBlocks,
+  renderBlocksReport
+} from "./chunk-6Y6MKFHZ.js";
+import {
+  findMcpServers
+} from "./chunk-65BQE6TI.js";
 import {
   buildReport,
-  findMcpServers,
   findTranscripts,
+  groupDaily,
+  parseDateArg,
   parseTranscript,
   pct1,
+  setLivePrices,
+  setTimezone,
   tok,
   usd
-} from "./chunk-JAZOB7NC.js";
+} from "./chunk-Z5W5QH2Z.js";
 
 // src/cli.ts
 import { createRequire } from "module";
 import { Command } from "commander";
 
+// src/livePricing.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var LITELLM_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3500;
+function mapLitellmPrices(raw) {
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (!value || typeof value !== "object") continue;
+    const e = value;
+    const inCost = e.input_cost_per_token;
+    const outCost = e.output_cost_per_token;
+    if (typeof inCost !== "number" || typeof outCost !== "number" || inCost <= 0) continue;
+    const name = key.includes("/") ? key.slice(key.lastIndexOf("/") + 1) : key;
+    if (key.includes("/") && out[name]) continue;
+    const p = { inputPerMTok: inCost * 1e6, outputPerMTok: outCost * 1e6 };
+    if (typeof e.cache_read_input_token_cost === "number")
+      p.cacheReadMult = e.cache_read_input_token_cost / inCost;
+    if (typeof e.cache_creation_input_token_cost === "number")
+      p.cacheWriteMult = e.cache_creation_input_token_cost / inCost;
+    else if (!name.startsWith("claude"))
+      p.cacheWriteMult = 0;
+    if (typeof e.cache_creation_input_token_cost_above_1hr === "number")
+      p.cacheWrite1hMult = e.cache_creation_input_token_cost_above_1hr / inCost;
+    out[name] = p;
+  }
+  return out;
+}
+async function initPricing(opts) {
+  const dir = opts?.cacheDir ?? join(homedir(), ".tokz");
+  const file = join(dir, "litellm-prices.json");
+  let cached;
+  try {
+    cached = JSON.parse(await readFile(file, "utf8"));
+  } catch {
+  }
+  const fresh = cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS;
+  if (cached && (fresh || opts?.offline)) {
+    setLivePrices(cached.prices);
+    return "cached";
+  }
+  if (opts?.offline) return "static";
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(LITELLM_URL, { signal: ctrl.signal });
+    clearTimeout(timer);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const prices = mapLitellmPrices(await res.json());
+    setLivePrices(prices);
+    try {
+      await mkdir(dir, { recursive: true });
+      await writeFile(file, JSON.stringify({ fetchedAt: Date.now(), prices }));
+    } catch {
+    }
+    return "live";
+  } catch {
+    if (cached) {
+      setLivePrices(cached.prices);
+      return "cached";
+    }
+    return "static";
+  }
+}
+
 // src/report.ts
 import Table from "cli-table3";
 import pc from "picocolors";
+function renderActivity(rows, unit) {
+  const head = unit === "week" ? "Week of" : "Month";
+  const table = new Table({ head: [head, "Cost", "Input", "Cache read", "Cache write", "Output", "Turns"] });
+  for (const d of rows) {
+    table.push([d.date, usd(d.costUsd), tok(d.inputTokens), tok(d.cacheReadTokens), tok(d.cacheCreationTokens), tok(d.outputTokens), String(d.turns)]);
+  }
+  return `${pc.bold(`Activity by ${unit}`)}
+${table.toString()}`;
+}
 function renderReport(report) {
   const parts = [];
   const span = report.spanStart && report.spanEnd ? `${report.spanStart} \u2192 ${report.spanEnd}` : `${report.spanDays} days`;
@@ -62,47 +148,108 @@ function renderReport(report) {
 // src/cli.ts
 var { version } = createRequire(import.meta.url)("../package.json");
 var program = new Command();
-program.name("tokz").description("Audit where your coding agent's context window and API dollars go.").version(version);
-program.command("audit").argument("[project]", "project path (default: current directory)").option("--all", "scan all projects under ~/.claude/projects").option("--json", "output raw JSON report").option("--days <n>", "only include the last N days of activity").action(async (project, opts) => {
+program.name("tokz").description("Audit where your coding agent's context window and API dollars go.").option("--offline", "don't fetch live pricing; use cached/built-in rates").option("--timezone <zone>", 'group days in this timezone: "utc" (default), "local", or an IANA name').version(version);
+function applyGlobals() {
+  const opts = program.opts();
+  setTimezone(opts.timezone);
+  return { offline: opts.offline };
+}
+async function parseAll(projectPath, events) {
+  const transcripts = await findTranscripts(projectPath);
+  const seenMessageIds = /* @__PURE__ */ new Map();
+  const seenToolIds = /* @__PURE__ */ new Set();
+  const sessions = await Promise.all(
+    transcripts.map((f) => parseTranscript(f, seenMessageIds, seenToolIds, events))
+  );
+  return { transcripts, sessions };
+}
+program.command("audit").argument("[project]", "project path (default: current directory)").option("--all", "scan all projects under ~/.claude/projects").option("--json", "output raw JSON report").option("--days <n>", "only include the last N days of activity").option("--since <date>", "start date, YYYY-MM-DD or YYYYMMDD (inclusive)").option("--until <date>", "end date, YYYY-MM-DD or YYYYMMDD (inclusive)").option("--weekly", "append activity grouped by week").option("--monthly", "append activity grouped by month").action(async (project, opts) => {
+  const globals = applyGlobals();
   const projectPath = project ?? process.cwd();
-  const transcripts = await findTranscripts(opts.all ? void 0 : projectPath);
+  const [{ transcripts, sessions }] = await Promise.all([
+    parseAll(opts.all ? void 0 : projectPath),
+    initPricing(globals)
+  ]);
   if (transcripts.length === 0) {
     console.error(`No Claude Code transcripts found for ${opts.all ? "any project" : projectPath}.`);
     process.exitCode = 1;
     return;
   }
-  const seenMessageIds = /* @__PURE__ */ new Map();
-  const seenToolIds = /* @__PURE__ */ new Set();
-  const sessions = await Promise.all(
-    transcripts.map((f) => parseTranscript(f, seenMessageIds, seenToolIds))
-  );
   const servers = opts.all ? [] : await findMcpServers(projectPath);
   const days = opts.days ? Number.parseInt(opts.days, 10) : void 0;
   const isoDay = (offset) => new Date(Date.now() - offset * 864e5).toISOString().slice(0, 10);
-  const range = days && days > 0 ? { from: isoDay(days - 1), to: isoDay(0) } : void 0;
+  const since = parseDateArg(opts.since);
+  const until = parseDateArg(opts.until);
+  let range;
+  if (since || until) range = { from: since ?? "0000-01-01", to: until ?? "9999-12-31" };
+  else if (days && days > 0) range = { from: isoDay(days - 1), to: isoDay(0) };
   const report = buildReport(sessions, servers, range);
-  console.log(opts.json ? JSON.stringify(report, null, 2) : renderReport(report));
+  if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  const parts = [renderReport(report)];
+  const grouping = opts.monthly ? "month" : opts.weekly ? "week" : void 0;
+  if (grouping) parts.push(renderActivity(groupDaily(report.daily, grouping), grouping));
+  console.log(parts.join("\n\n"));
+});
+program.command("blocks").description("Claude usage grouped into rolling 5-hour billing windows").option("--json", "output raw JSON").option("--active", "show only the currently active block").option("--recent", "only blocks from the last 3 days").option("--token-limit <n>", 'warn near this many tokens per block ("max" = highest past block)').option("--session-length <hours>", "block length in hours (default 5)").action(async (opts) => {
+  const globals = applyGlobals();
+  const events = [];
+  await Promise.all([parseAll(void 0, events), initPricing(globals)]);
+  const hours = opts.sessionLength ? Number.parseFloat(opts.sessionLength) : 5;
+  let blocks = buildBlocks(events, { sessionLengthMs: hours * 36e5 });
+  if (opts.recent) blocks = blocks.filter((b) => b.lastTs >= Date.now() - 3 * 864e5);
+  if (opts.active) blocks = blocks.filter((b) => b.active);
+  const tokenLimit = opts.tokenLimit === "max" ? "max" : opts.tokenLimit ? Number.parseInt(opts.tokenLimit, 10) : void 0;
+  if (opts.json) {
+    console.log(JSON.stringify(blocks, null, 2));
+    return;
+  }
+  console.log(renderBlocksReport(blocks, { tokenLimit }));
+});
+program.command("statusline").description("compact usage line for Claude Code's statusLine hook (reads hook JSON on stdin)").argument("[action]", '"enable" writes the hook into ~/.claude/settings.json, "disable" removes it').action(async (action) => {
+  const globals = applyGlobals();
+  const sl = await import("./statusline-A36XPBG6.js");
+  if (action === "enable" || action === "disable") {
+    try {
+      console.log(action === "enable" ? await sl.enableStatusline() : await sl.disableStatusline());
+    } catch (err) {
+      console.error(`Could not update settings: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (action !== void 0) {
+    console.error(`Unknown action "${action}" \u2014 use "enable" or "disable".`);
+    process.exitCode = 1;
+    return;
+  }
+  await initPricing({ ...globals, offline: true });
+  let input = {};
+  try {
+    input = JSON.parse(await sl.readStdin());
+  } catch {
+  }
+  console.log(await sl.statusline(input));
 });
 program.action(async () => {
+  const globals = applyGlobals();
+  await initPricing(globals);
   if (!process.stdout.isTTY) {
-    const transcripts = await findTranscripts(void 0);
+    const { transcripts, sessions } = await parseAll(void 0);
     if (transcripts.length === 0) {
       console.error("No Claude Code transcripts found.");
       process.exitCode = 1;
       return;
     }
-    const seenMessageIds = /* @__PURE__ */ new Map();
-    const seenToolIds = /* @__PURE__ */ new Set();
-    const sessions = await Promise.all(
-      transcripts.map((f) => parseTranscript(f, seenMessageIds, seenToolIds))
-    );
     console.log(renderReport(buildReport(sessions, [])));
     return;
   }
   const [{ render }, React, { Root }, { Fullscreen }] = await Promise.all([
     import("ink"),
     import("react"),
-    import("./Root-6SZ5FQDN.js"),
+    import("./Root-WEIYEE6M.js"),
     import("./Fullscreen-GK2ZYXHV.js")
   ]);
   render(React.createElement(Fullscreen, null, React.createElement(Root)));

package/dist/statusline-A36XPBG6.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import {
+  buildBlocks,
+  burnRate,
+  fmtMs
+} from "./chunk-6Y6MKFHZ.js";
+import {
+  compact,
+  costUsd,
+  dayKey,
+  findTranscripts,
+  parseTranscript,
+  shortModel,
+  usd
+} from "./chunk-Z5W5QH2Z.js";
+
+// src/statusline.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import pc from "picocolors";
+var CONTEXT_WINDOW = 2e5;
+var LOOKBACK_MS = 6 * 60 * 60 * 1e3;
+async function lastContextTokens(transcriptPath) {
+  try {
+    const lines = (await readFile(transcriptPath, "utf8")).split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"usage"')) continue;
+      try {
+        const j = JSON.parse(lines[i]);
+        const u = j?.message?.usage;
+        if (u && typeof u.input_tokens === "number") {
+          return u.input_tokens + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function statusline(input, now = Date.now(), home) {
+  const files = await findTranscripts(void 0, home);
+  const recent = [];
+  await Promise.all(
+    files.map(async (f) => {
+      try {
+        if ((await stat(f)).mtimeMs >= now - Math.max(LOOKBACK_MS, msSinceMidnight(now) + 6e4))
+          recent.push(f);
+      } catch {
+      }
+    })
+  );
+  const seen = /* @__PURE__ */ new Map();
+  const seenTools = /* @__PURE__ */ new Set();
+  const events = [];
+  const sessions = await Promise.all(recent.map((f) => parseTranscript(f, seen, seenTools, events)));
+  const today = dayKey(now);
+  let todayCost = 0;
+  let sessionCost = input.cost?.total_cost_usd;
+  for (const s of sessions) {
+    for (const [model2, u] of Object.entries(s.dailyUsage[today] ?? {})) todayCost += costUsd(u, model2).total;
+    if (sessionCost === void 0 && input.transcript_path && s.file === input.transcript_path) {
+      sessionCost = Object.entries(s.usageByModel).reduce((sum, [m, u]) => sum + costUsd(u, m).total, 0);
+    }
+  }
+  const blocks = buildBlocks(events, { now });
+  const active = blocks.find((b) => b.active);
+  const rate = active ? burnRate(active, now) : void 0;
+  const model = input.model?.display_name ?? shortModel(input.model?.id ?? "?");
+  const parts = [`\u{1F916} ${model}`];
+  const costs = [
+    sessionCost !== void 0 ? `${usd(sessionCost)} session` : void 0,
+    `${usd(todayCost)} today`,
+    active ? `${usd(active.costUsd)} block (${fmtMs(active.end - now)} left)` : void 0
+  ].filter(Boolean);
+  parts.push(`\u{1F4B0} ${costs.join(" / ")}`);
+  if (rate) parts.push(`\u{1F525} ${usd(rate.costPerHour)}/hr`);
+  const ctx = input.transcript_path ? await lastContextTokens(input.transcript_path) : void 0;
+  if (ctx !== void 0) {
+    const p = Math.round(ctx / CONTEXT_WINDOW * 100);
+    const colored = p >= 80 ? pc.red(`${p}%`) : p >= 50 ? pc.yellow(`${p}%`) : pc.green(`${p}%`);
+    parts.push(`\u{1F9E0} ${compact(ctx)} (${colored})`);
+  }
+  return parts.join(pc.dim(" | "));
+}
+function msSinceMidnight(now) {
+  const day = dayKey(now);
+  const midnight = Date.parse(`${day}T00:00:00Z`);
+  const diff = now - midnight;
+  return Math.min(Math.max(diff, 0), 36 * 60 * 60 * 1e3);
+}
+async function readStdin() {
+  let data = "";
+  for await (const chunk of process.stdin) data += chunk;
+  return data;
+}
+var STATUSLINE_COMMAND = "npx -y @tokz/cli statusline";
+function settingsPath(home = homedir()) {
+  return join(home, ".claude", "settings.json");
+}
+async function readSettings(file) {
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch {
+    return {};
+  }
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error(`${file} is not a JSON object`);
+  return parsed;
+}
+async function enableStatusline(home) {
+  const file = settingsPath(home);
+  const settings = await readSettings(file);
+  const prev = settings.statusLine;
+  if (prev?.command === STATUSLINE_COMMAND) return `Already enabled in ${file}.`;
+  settings.statusLine = { type: "command", command: STATUSLINE_COMMAND };
+  await mkdir(join(file, ".."), { recursive: true });
+  await writeFile(file, `${JSON.stringify(settings, null, 2)}
+`);
+  const note = prev?.command ? ` (replaced previous statusLine: ${prev.command})` : "";
+  return `Statusline enabled \u2014 Claude Code will run "${STATUSLINE_COMMAND}".${note}
+Restart Claude Code (or start a new session) to see it.`;
+}
+async function disableStatusline(home) {
+  const file = settingsPath(home);
+  const settings = await readSettings(file);
+  const prev = settings.statusLine;
+  if (!prev) return `No statusLine configured in ${file}; nothing to do.`;
+  if (prev.command !== void 0 && !prev.command.includes("tokz") && !prev.command.includes("@tokz/cli"))
+    return `statusLine in ${file} is "${prev.command}" \u2014 not tokz, leaving it alone.`;
+  delete settings.statusLine;
+  await writeFile(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return `Statusline disabled \u2014 removed from ${file}.`;
+}
+export {
+  STATUSLINE_COMMAND,
+  disableStatusline,
+  enableStatusline,
+  readStdin,
+  statusline
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokz/cli",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Audit where your coding agent's context window and API dollars go.",
   "type": "module",
   "license": "MIT",