tokenleak 0.5.0 → 1.0.1

package/README.md

@@ -134,24 +134,24 @@ tokenleak --format json --upload gist
 
 ## All flags
 
-| Flag | Alias | Default | Description |
-|------|-------|---------|-------------|
-| `--format` | `-f` | `terminal` | Output format: `json`, `svg`, `png`, `terminal` |
-| `--theme` | `-t` | `dark` | Colour theme: `dark`, `light` |
-| `--since` | `-s` | | Start date (`YYYY-MM-DD`). Overrides `--days` |
-| `--until` | `-u` | today | End date (`YYYY-MM-DD`) |
-| `--days` | `-d` | `90` | Number of days to look back |
-| `--output` | `-o` | stdout | Output file path. Format is inferred from extension |
-| `--width` | `-w` | `80` | Terminal width for dashboard layout |
-| `--no-color` | | `false` | Strip ANSI escape codes from terminal output |
-| `--no-insights` | | `false` | Hide the insights panel |
-| `--compare` | | | Compare two date ranges. Use `auto` or `YYYY-MM-DD..YYYY-MM-DD` |
-| `--provider` | `-p` | all | Filter to specific provider(s), comma-separated |
-| `--clipboard` | | `false` | Copy output to clipboard after rendering |
-| `--open` | | `false` | Open output file in default app (requires `--output`) |
-| `--upload` | | | Upload output to a service. Supported: `gist` |
-| `--version` | | | Print version number |
-| `--help` | | | Print usage information |
+| Flag            | Alias | Default    | Description                                                     |
+| --------------- | ----- | ---------- | --------------------------------------------------------------- |
+| `--format`      | `-f`  | `terminal` | Output format: `json`, `svg`, `png`, `terminal`                 |
+| `--theme`       | `-t`  | `dark`     | Colour theme: `dark`, `light`                                   |
+| `--since`       | `-s`  |            | Start date (`YYYY-MM-DD`). Overrides `--days`                   |
+| `--until`       | `-u`  | today      | End date (`YYYY-MM-DD`)                                         |
+| `--days`        | `-d`  | `90`       | Number of days to look back                                     |
+| `--output`      | `-o`  | stdout     | Output file path. Format is inferred from extension             |
+| `--width`       | `-w`  | `80`       | Terminal width for dashboard layout                             |
+| `--no-color`    |       | `false`    | Strip ANSI escape codes from terminal output                    |
+| `--no-insights` |       | `false`    | Hide the insights panel                                         |
+| `--compare`     |       |            | Compare two date ranges. Use `auto` or `YYYY-MM-DD..YYYY-MM-DD` |
+| `--provider`    | `-p`  | all        | Filter to specific provider(s), comma-separated                 |
+| `--clipboard`   |       | `false`    | Copy output to clipboard after rendering                        |
+| `--open`        |       | `false`    | Open output file in default app (requires `--output`)           |
+| `--upload`      |       |            | Upload output to a service. Supported: `gist`                   |
+| `--version`     |       |            | Print version number                                            |
+| `--help`        |       |            | Print usage information                                         |
 
 ## Supported providers
 
@@ -159,30 +159,30 @@ tokenleak --format json --upload gist
 
 Reads JSONL conversation logs from the Claude Code projects directory. Each assistant message with a `usage` field is parsed for input/output/cache token counts.
 
-| | |
-|---|---|
-| **Data location** | `~/.claude/projects/*/*.jsonl` |
-| **Override** | Set `CLAUDE_CONFIG_DIR` environment variable |
-| **Provider name** | `claude-code` |
+|                   |                                              |
+| ----------------- | -------------------------------------------- |
+| **Data location** | `~/.claude/projects/*/*.jsonl`               |
+| **Override**      | Set `CLAUDE_CONFIG_DIR` environment variable |
+| **Provider name** | `claude-code`                                |
 
 ### Codex
 
 Reads JSONL session logs from the Codex sessions directory. Parses `response` events for token usage with cumulative delta extraction.
 
-| | |
-|---|---|
-| **Data location** | `~/.codex/sessions/*.jsonl` |
-| **Override** | Set `CODEX_HOME` environment variable |
-| **Provider name** | `codex` |
+|                   |                                       |
+| ----------------- | ------------------------------------- |
+| **Data location** | `~/.codex/sessions/*.jsonl`           |
+| **Override**      | Set `CODEX_HOME` environment variable |
+| **Provider name** | `codex`                               |
 
 ### Open Code
 
 Reads usage data from the Open Code SQLite database. Falls back to legacy JSON session files if no database is found.
 
-| | |
-|---|---|
-| **Data location** | `~/.opencode/sessions.db` (primary) or `~/.opencode/sessions/*.json` (fallback) |
-| **Provider name** | `open-code` |
+|                   |                                                                                                                                                                                        |
+| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Data location** | `~/.local/share/opencode/storage/message/<session>/*.json` (primary), `~/.opencode/opencode.db` or `~/.opencode/sessions.db` (legacy), `~/.opencode/sessions/*.json` (legacy fallback) |
+| **Provider name** | `open-code`                                                                                                                                                                            |
 
 ## Output formats
 
@@ -219,24 +219,30 @@ Structured JSON output containing:
           "cacheReadTokens": 2000,
           "cacheWriteTokens": 500,
           "totalTokens": 22500,
-          "cost": 0.0825
-        }
+          "cost": 0.0825,
+        },
         // ...
       ],
       "models": [
-        { "model": "claude-sonnet-4", "inputTokens": 10000, "outputTokens": 3000, "totalTokens": 13000, "cost": 0.075 }
+        {
+          "model": "claude-sonnet-4",
+          "inputTokens": 10000,
+          "outputTokens": 3000,
+          "totalTokens": 13000,
+          "cost": 0.075,
+        },
       ],
       "totalTokens": 22500,
-      "totalCost": 0.0825
-    }
+      "totalCost": 0.0825,
+    },
   ],
   "aggregated": {
     "currentStreak": 12,
     "longestStreak": 45,
     "totalTokens": 1500000,
-    "totalCost": 52.50,
+    "totalCost": 52.5,
     // ... rolling windows, peaks, averages, day-of-week, top models
-  }
+  },
 }
 ```
 
@@ -274,14 +280,14 @@ All fields are optional. Only include the ones you want to override.
 
 ## Environment variables
 
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `TOKENLEAK_FORMAT` | `terminal` | Default output format |
-| `TOKENLEAK_THEME` | `dark` | Default colour theme |
-| `TOKENLEAK_DAYS` | `90` | Default lookback period in days |
+| Variable                           | Default            | Description                                             |
+| ---------------------------------- | ------------------ | ------------------------------------------------------- |
+| `TOKENLEAK_FORMAT`                 | `terminal`         | Default output format                                   |
+| `TOKENLEAK_THEME`                  | `dark`             | Default colour theme                                    |
+| `TOKENLEAK_DAYS`                   | `90`               | Default lookback period in days                         |
 | `TOKENLEAK_MAX_JSONL_RECORD_BYTES` | `10485760` (10 MB) | Max size of a single JSONL record before it is rejected |
-| `CLAUDE_CONFIG_DIR` | `~/.claude` | Claude Code configuration directory |
-| `CODEX_HOME` | `~/.codex` | Codex home directory |
+| `CLAUDE_CONFIG_DIR`                | `~/.claude`        | Claude Code configuration directory                     |
+| `CODEX_HOME`                       | `~/.codex`         | Codex home directory                                    |
 
 ## What Tokenleak tracks
 
@@ -309,13 +315,13 @@ It then computes:
 
 Tokenleak includes pricing for these model families:
 
-| Family | Models |
-|--------|--------|
-| Claude 3 | `claude-3-haiku`, `claude-3-sonnet`, `claude-3-opus` |
-| Claude 3.5 | `claude-3.5-haiku`, `claude-3.5-sonnet` |
-| Claude 4 | `claude-sonnet-4`, `claude-opus-4` |
-| GPT-4o | `gpt-4o`, `gpt-4o-mini` |
-| o-series | `o1`, `o1-mini`, `o3`, `o3-mini`, `o4-mini` |
+| Family     | Models                                               |
+| ---------- | ---------------------------------------------------- |
+| Claude 3   | `claude-3-haiku`, `claude-3-sonnet`, `claude-3-opus` |
+| Claude 3.5 | `claude-3.5-haiku`, `claude-3.5-sonnet`              |
+| Claude 4   | `claude-sonnet-4`, `claude-opus-4`                   |
+| GPT-4o     | `gpt-4o`, `gpt-4o-mini`                              |
+| o-series   | `o1`, `o1-mini`, `o3`, `o3-mini`, `o4-mini`          |
 
 Model names with date suffixes (e.g. `claude-sonnet-4-20250514`) are automatically normalised. Unknown models show `$0.00` cost but tokens are still tracked.
 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "tokenleak",
-  "version": "0.5.0",
+  "version": "1.0.1",
   "description": "Visualise your AI coding-assistant token usage across providers — heatmaps, dashboards, and shareable cards.",
   "type": "module",
   "bin": {
-    "tokenleak": "./tokenleak.js"
+    "tokenleak": "tokenleak"
   },
   "files": [
-    "tokenleak.js"
+    "tokenleak"
   ],
   "dependencies": {
     "sharp": "^0.34.0"
@@ -28,7 +28,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/ya-nsh/tokenleak.git"
+    "url": "git+https://github.com/ya-nsh/tokenleak.git"
   },
   "license": "MIT",
   "author": "ya-nsh"

package/{tokenleak.js → tokenleak}

@@ -580,7 +580,7 @@ function topModels(daily, limit = DEFAULT_LIMIT) {
       model,
       tokens,
       cost,
-      percentage: grandTotal > 0 ? tokens / grandTotal : 0
+      percentage: grandTotal > 0 ? tokens / grandTotal * 100 : 0
     });
   }
   entries.sort((a, b) => b.tokens - a.tokens);
@@ -663,6 +663,26 @@ function computeTotalDays(daily) {
   return Math.round((last - first) / ONE_DAY_MS) + 1;
 }
 // packages/core/dist/aggregation/merge.js
+function mergeModelArrays(existing, incoming) {
+  const map = new Map;
+  for (const m of existing) {
+    map.set(m.model, { ...m });
+  }
+  for (const m of incoming) {
+    const prev = map.get(m.model);
+    if (prev) {
+      prev.inputTokens += m.inputTokens;
+      prev.outputTokens += m.outputTokens;
+      prev.cacheReadTokens += m.cacheReadTokens;
+      prev.cacheWriteTokens += m.cacheWriteTokens;
+      prev.totalTokens += m.totalTokens;
+      prev.cost += m.cost;
+    } else {
+      map.set(m.model, { ...m });
+    }
+  }
+  return [...map.values()];
+}
 function mergeProviderData(providers) {
   const dateMap = new Map;
   for (const provider of providers) {
@@ -675,7 +695,7 @@ function mergeProviderData(providers) {
         existing.cacheWriteTokens += entry.cacheWriteTokens;
         existing.totalTokens += entry.totalTokens;
         existing.cost += entry.cost;
-        existing.models = [...existing.models, ...entry.models];
+        existing.models = mergeModelArrays(existing.models, entry.models);
       } else {
         dateMap.set(entry.date, {
           date: entry.date,
@@ -736,7 +756,7 @@ function computePreviousPeriod(current) {
   };
 }
 // packages/core/dist/index.js
-var VERSION = "0.5.0";
+var VERSION = "1.0.1";
 
 // packages/registry/dist/models/normalizer.js
 var DATE_SUFFIX_PATTERN = /-\d{8}$/;
@@ -830,6 +850,54 @@ var MODEL_PRICING = {
     cacheRead: 0.075,
     cacheWrite: 0.15
   },
+  "gpt-5": {
+    input: 1.25,
+    output: 10,
+    cacheRead: 0.125,
+    cacheWrite: 1.25
+  },
+  "gpt-5.1": {
+    input: 1.25,
+    output: 10,
+    cacheRead: 0.125,
+    cacheWrite: 1.25
+  },
+  "gpt-5.2": {
+    input: 1.75,
+    output: 14,
+    cacheRead: 0.175,
+    cacheWrite: 1.75
+  },
+  "gpt-5.4": {
+    input: 2.5,
+    output: 15,
+    cacheRead: 0.25,
+    cacheWrite: 2.5
+  },
+  "gpt-5-codex": {
+    input: 1.25,
+    output: 10,
+    cacheRead: 0.125,
+    cacheWrite: 1.25
+  },
+  "gpt-5.1-codex": {
+    input: 1.25,
+    output: 10,
+    cacheRead: 0.125,
+    cacheWrite: 1.25
+  },
+  "gpt-5.1-codex-max": {
+    input: 1.25,
+    output: 10,
+    cacheRead: 0.125,
+    cacheWrite: 1.25
+  },
+  "gpt-5.2-codex": {
+    input: 1.75,
+    output: 14,
+    cacheRead: 0.175,
+    cacheWrite: 1.75
+  },
   o1: {
     input: 15,
     output: 60,
@@ -963,12 +1031,19 @@ function isInRange(date, range) {
 }
 
 // packages/registry/dist/providers/claude-code.js
-var DEFAULT_BASE_DIR = join(homedir(), ".claude", "projects");
+var DEFAULT_CONFIG_DIR = join(homedir(), ".claude");
 var CLAUDE_CODE_COLORS = {
   primary: "#ff6b35",
   secondary: "#ffa366",
   gradient: ["#ff6b35", "#ffa366"]
 };
+function resolveBaseDir(baseDir) {
+  if (baseDir) {
+    return baseDir;
+  }
+  const configDir = process.env["CLAUDE_CONFIG_DIR"];
+  return join(configDir && configDir.length > 0 ? configDir : DEFAULT_CONFIG_DIR, "projects");
+}
 function collectJsonlFiles(dir) {
   const results = [];
   if (!existsSync(dir)) {
@@ -1016,6 +1091,10 @@ function extractUsage(record) {
   const outputTokens = typeof u["output_tokens"] === "number" ? u["output_tokens"] : 0;
   const cacheReadTokens = typeof u["cache_read_input_tokens"] === "number" ? u["cache_read_input_tokens"] : 0;
   const cacheWriteTokens = typeof u["cache_creation_input_tokens"] === "number" ? u["cache_creation_input_tokens"] : 0;
+  const totalTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+  if (totalTokens === 0) {
+    return null;
+  }
   const date = timestamp.slice(0, 10);
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
     return null;
@@ -1026,7 +1105,8 @@ function extractUsage(record) {
     inputTokens,
     outputTokens,
     cacheReadTokens,
-    cacheWriteTokens
+    cacheWriteTokens,
+    messageId: typeof msg["id"] === "string" ? msg["id"] : undefined
   };
 }
 function buildDailyUsage(records) {
@@ -1089,7 +1169,7 @@ class ClaudeCodeProvider {
   colors = CLAUDE_CODE_COLORS;
   baseDir;
   constructor(baseDir) {
-    this.baseDir = baseDir ?? DEFAULT_BASE_DIR;
+    this.baseDir = resolveBaseDir(baseDir);
   }
   async isAvailable() {
     try {
@@ -1102,16 +1182,23 @@ class ClaudeCodeProvider {
     const files = collectJsonlFiles(this.baseDir);
     const allRecords = [];
     for (const file of files) {
+      const latestRecordsByMessageId = new Map;
+      const anonymousRecords = [];
       try {
         for await (const record of splitJsonlRecords(file)) {
           const usage = extractUsage(record);
           if (usage !== null && isInRange(usage.date, range)) {
-            allRecords.push(usage);
+            if (usage.messageId) {
+              latestRecordsByMessageId.set(usage.messageId, usage);
+            } else {
+              anonymousRecords.push(usage);
+            }
           }
         }
       } catch {
         continue;
       }
+      allRecords.push(...latestRecordsByMessageId.values(), ...anonymousRecords);
     }
     const daily = buildDailyUsage(allRecords);
     const totalTokens = daily.reduce((sum, d) => sum + d.totalTokens, 0);
@@ -1127,7 +1214,7 @@ class ClaudeCodeProvider {
   }
 }
 // packages/registry/dist/providers/codex.js
-import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 var CODEX_COLORS = {
@@ -1135,7 +1222,7 @@ var CODEX_COLORS = {
   secondary: "#4ade80",
   gradient: ["#10a37f", "#4ade80"]
 };
-var DEFAULT_SESSIONS_DIR = join2(homedir2(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = join2(process.env["CODEX_HOME"] ?? join2(homedir2(), ".codex"), "sessions");
 function parseResponseEvent(record) {
   if (typeof record !== "object" || record === null || !("type" in record)) {
     return null;
@@ -1170,6 +1257,159 @@ function extractDate(timestamp) {
   const match = /^(\d{4}-\d{2}-\d{2})/.exec(timestamp);
   return match ? match[1] : null;
 }
+function collectJsonlFiles2(dir) {
+  if (!existsSync2(dir)) {
+    return [];
+  }
+  const files = [];
+  for (const entry of readdirSync2(dir)) {
+    const fullPath = join2(dir, entry);
+    const stats = statSync2(fullPath);
+    if (stats.isDirectory()) {
+      files.push(...collectJsonlFiles2(fullPath));
+    } else if (entry.endsWith(".jsonl")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function inferModelFromContext(record) {
+  if (typeof record !== "object" || record === null) {
+    return null;
+  }
+  const obj = record;
+  if (obj["type"] !== "session_meta" && obj["type"] !== "turn_context") {
+    return null;
+  }
+  const payload = obj["payload"];
+  if (typeof payload !== "object" || payload === null) {
+    return null;
+  }
+  const meta = payload;
+  const directModelKeys = ["model", "model_name", "model_slug"];
+  for (const key of directModelKeys) {
+    if (typeof meta[key] === "string" && meta[key].trim()) {
+      return meta[key].trim();
+    }
+  }
+  const instructions = meta["base_instructions"];
+  if (typeof instructions === "object" && instructions !== null) {
+    const text = instructions["text"];
+    if (typeof text === "string") {
+      const match = /based on ([A-Za-z0-9.-]+)/i.exec(text);
+      if (match?.[1]) {
+        return match[1].toLowerCase();
+      }
+    }
+  }
+  return null;
+}
+function parseTokenCountUsage(record, context) {
+  if (typeof record !== "object" || record === null) {
+    return null;
+  }
+  const obj = record;
+  if (obj["type"] !== "event_msg") {
+    return null;
+  }
+  const timestamp = obj["timestamp"];
+  const payload = obj["payload"];
+  if (typeof timestamp !== "string" || typeof payload !== "object" || payload === null) {
+    return null;
+  }
+  const eventPayload = payload;
+  if (eventPayload["type"] !== "token_count") {
+    return null;
+  }
+  const info = eventPayload["info"];
+  if (typeof info !== "object" || info === null) {
+    return null;
+  }
+  const usageInfo = info;
+  const lastUsage = usageInfo["last_token_usage"];
+  const totalUsage = usageInfo["total_token_usage"];
+  const date = extractDate(timestamp);
+  if (!date) {
+    return null;
+  }
+  const parseUsage = (usage2) => {
+    if (typeof usage2 !== "object" || usage2 === null) {
+      return null;
+    }
+    const usageObj = usage2;
+    const inputTokens2 = usageObj["input_tokens"];
+    const outputTokens = usageObj["output_tokens"];
+    const cachedInputTokens = usageObj["cached_input_tokens"];
+    if (typeof inputTokens2 !== "number" || typeof outputTokens !== "number") {
+      return null;
+    }
+    return {
+      inputTokens: inputTokens2,
+      outputTokens,
+      cachedInputTokens: typeof cachedInputTokens === "number" ? cachedInputTokens : 0
+    };
+  };
+  let usage = parseUsage(lastUsage);
+  if (!usage) {
+    const cumulative = parseUsage(totalUsage);
+    if (!cumulative) {
+      return null;
+    }
+    const previous = context.previousTotals ?? {
+      inputTokens: 0,
+      outputTokens: 0,
+      cachedInputTokens: 0
+    };
+    usage = {
+      inputTokens: Math.max(0, cumulative.inputTokens - previous.inputTokens),
+      outputTokens: Math.max(0, cumulative.outputTokens - previous.outputTokens),
+      cachedInputTokens: Math.max(0, cumulative.cachedInputTokens - previous.cachedInputTokens)
+    };
+    context.previousTotals = cumulative;
+  } else if (parseUsage(totalUsage)) {
+    context.previousTotals = parseUsage(totalUsage);
+  }
+  const cacheReadTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
+  const inputTokens = Math.max(0, usage.inputTokens - cacheReadTokens);
+  return {
+    date,
+    model: context.model,
+    inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens: 0
+  };
+}
+function parseUsageRecord(record, context) {
+  const inferredModel = inferModelFromContext(record);
+  if (inferredModel) {
+    if (context.model !== inferredModel) {
+      context.model = inferredModel;
+      context.previousTotals = null;
+    }
+    return null;
+  }
+  const tokenCountUsage = parseTokenCountUsage(record, context);
+  if (tokenCountUsage) {
+    return tokenCountUsage;
+  }
+  const legacyEvent = parseResponseEvent(record);
+  if (!legacyEvent) {
+    return null;
+  }
+  const date = extractDate(legacyEvent.timestamp);
+  if (!date) {
+    return null;
+  }
+  return {
+    date,
+    model: compactModelDateSuffix(legacyEvent.model),
+    inputTokens: legacyEvent.usage.input_tokens,
+    outputTokens: legacyEvent.usage.output_tokens,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  };
+}
 
 class CodexProvider {
   name = "codex";
@@ -1188,34 +1428,31 @@ class CodexProvider {
   }
   async load(range) {
     const dailyMap = new Map;
-    let files;
-    try {
-      files = readdirSync2(this.sessionsDir).filter((f) => f.endsWith(".jsonl"));
-    } catch {
-      files = [];
-    }
+    const files = collectJsonlFiles2(this.sessionsDir);
     for (const file of files) {
-      const filePath = join2(this.sessionsDir, file);
+      const context = {
+        model: "gpt-5",
+        previousTotals: null
+      };
       try {
-        for await (const record of splitJsonlRecords(filePath)) {
-          const event = parseResponseEvent(record);
-          if (!event) {
+        for await (const record of splitJsonlRecords(file)) {
+          const usage = parseUsageRecord(record, context);
+          if (!usage) {
             continue;
           }
-          const date = extractDate(event.timestamp);
-          if (!date || !isInRange(date, range)) {
+          if (!isInRange(usage.date, range)) {
             continue;
           }
-          const normalizedModel = normalizeModelName(compactModelDateSuffix(event.model));
-          const inputTokens = event.usage.input_tokens;
-          const outputTokens = event.usage.output_tokens;
-          const cacheReadTokens = 0;
-          const cacheWriteTokens = 0;
+          const normalizedModel = normalizeModelName(compactModelDateSuffix(usage.model));
+          const inputTokens = usage.inputTokens;
+          const outputTokens = usage.outputTokens;
+          const cacheReadTokens = usage.cacheReadTokens;
+          const cacheWriteTokens = usage.cacheWriteTokens;
           const cost = estimateCost(normalizedModel, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens);
-          if (!dailyMap.has(date)) {
-            dailyMap.set(date, new Map);
+          if (!dailyMap.has(usage.date)) {
+            dailyMap.set(usage.date, new Map);
           }
-          const modelMap = dailyMap.get(date);
+          const modelMap = dailyMap.get(usage.date);
           if (!modelMap.has(normalizedModel)) {
             modelMap.set(normalizedModel, {
               model: normalizedModel,
@@ -1282,15 +1519,41 @@ var COLORS = {
   secondary: "#a78bfa",
   gradient: ["#6366f1", "#a78bfa"]
 };
+var CURRENT_DEFAULT_BASE_DIR = join3(homedir3(), ".local", "share", "opencode");
+var LEGACY_DEFAULT_BASE_DIR = join3(homedir3(), ".opencode");
+var CONFIG_DEFAULT_BASE_DIR = join3(homedir3(), ".config", "opencode");
+function resolveBaseDir2(baseDir) {
+  if (baseDir) {
+    return baseDir;
+  }
+  for (const candidate of [
+    CURRENT_DEFAULT_BASE_DIR,
+    LEGACY_DEFAULT_BASE_DIR,
+    CONFIG_DEFAULT_BASE_DIR
+  ]) {
+    if (existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  return CURRENT_DEFAULT_BASE_DIR;
+}
 function extractDate2(createdAt) {
-  if (typeof createdAt === "number") {
-    return new Date(createdAt * 1000).toISOString().slice(0, 10);
+  const timestamp = typeof createdAt === "number" ? createdAt : Number.isNaN(Number(createdAt)) ? Date.parse(createdAt) : Number(createdAt);
+  if (!Number.isFinite(timestamp)) {
+    return null;
+  }
+  const millis = Math.abs(timestamp) >= 1000000000000 ? timestamp : timestamp * 1000;
+  const date = new Date(millis);
+  if (Number.isNaN(date.getTime())) {
+    return null;
   }
-  const asNum = Number(createdAt);
-  if (!Number.isNaN(asNum) && String(asNum) === String(createdAt).trim()) {
-    return new Date(asNum * 1000).toISOString().slice(0, 10);
+  return date.toISOString().slice(0, 10);
+}
+function getRecordCost(record) {
+  if (typeof record.explicitCost === "number" && Number.isFinite(record.explicitCost)) {
+    return record.explicitCost;
   }
-  return new Date(createdAt).toISOString().slice(0, 10);
+  return estimateCost(record.model, record.inputTokens, record.outputTokens, record.cacheReadTokens, record.cacheWriteTokens);
 }
 function buildProviderData(records) {
   const byDate = new Map;
@@ -1302,50 +1565,44 @@ function buildProviderData(records) {
     }
     const normalized = normalizeModelName(record.model);
     const existing = dateMap.get(normalized);
+    const recordCost = getRecordCost(record);
     if (existing) {
       existing.inputTokens += record.inputTokens;
       existing.outputTokens += record.outputTokens;
+      existing.cacheReadTokens += record.cacheReadTokens;
+      existing.cacheWriteTokens += record.cacheWriteTokens;
+      existing.totalTokens += record.inputTokens + record.outputTokens + record.cacheReadTokens + record.cacheWriteTokens;
+      existing.cost += recordCost;
     } else {
       dateMap.set(normalized, {
+        model: normalized,
         inputTokens: record.inputTokens,
-        outputTokens: record.outputTokens
+        outputTokens: record.outputTokens,
+        cacheReadTokens: record.cacheReadTokens,
+        cacheWriteTokens: record.cacheWriteTokens,
+        totalTokens: record.inputTokens + record.outputTokens + record.cacheReadTokens + record.cacheWriteTokens,
+        cost: recordCost
       });
     }
   }
   let totalTokens = 0;
   let totalCost = 0;
   const daily = [...byDate.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, modelMap]) => {
-    const models = [];
-    let dayInput = 0;
-    let dayOutput = 0;
-    let dayCost = 0;
-    for (const [model, usage] of modelMap) {
-      const cost = estimateCost(model, usage.inputTokens, usage.outputTokens, 0, 0);
-      const cacheReadTokens = 0;
-      const cacheWriteTokens = 0;
-      const modelTotal = usage.inputTokens + usage.outputTokens + cacheReadTokens + cacheWriteTokens;
-      models.push({
-        model,
-        inputTokens: usage.inputTokens,
-        outputTokens: usage.outputTokens,
-        cacheReadTokens,
-        cacheWriteTokens,
-        totalTokens: modelTotal,
-        cost
-      });
-      dayInput += usage.inputTokens;
-      dayOutput += usage.outputTokens;
-      dayCost += cost;
-    }
-    const dayTotal = dayInput + dayOutput;
+    const models = [...modelMap.values()];
+    const inputTokens = models.reduce((sum, model) => sum + model.inputTokens, 0);
+    const outputTokens = models.reduce((sum, model) => sum + model.outputTokens, 0);
+    const cacheReadTokens = models.reduce((sum, model) => sum + model.cacheReadTokens, 0);
+    const cacheWriteTokens = models.reduce((sum, model) => sum + model.cacheWriteTokens, 0);
+    const dayTotal = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+    const dayCost = models.reduce((sum, model) => sum + model.cost, 0);
     totalTokens += dayTotal;
     totalCost += dayCost;
     return {
       date,
-      inputTokens: dayInput,
-      outputTokens: dayOutput,
-      cacheReadTokens: 0,
-      cacheWriteTokens: 0,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
       totalTokens: dayTotal,
       cost: dayCost,
       models
@@ -1361,52 +1618,131 @@ function buildProviderData(records) {
   };
 }
 function loadFromSqlite(dbPath, range) {
-  const db = new Database(dbPath, { readonly: true });
+  let db;
   try {
+    db = new Database(dbPath, { readonly: true });
+  } catch {
+    return [];
+  }
+  try {
+    const tables = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='messages'").all();
+    if (tables.length === 0) {
+      return [];
+    }
     const rows = db.query("SELECT model, input_tokens, output_tokens, created_at FROM messages WHERE role = 'assistant'").all();
     const records = [];
     for (const row of rows) {
       const date = extractDate2(row.created_at);
-      if (isInRange(date, range)) {
+      if (date && isInRange(date, range)) {
         records.push({
           date,
           model: row.model,
           inputTokens: row.input_tokens,
-          outputTokens: row.output_tokens
+          outputTokens: row.output_tokens,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0
         });
       }
     }
     return records;
+  } catch {
+    return [];
   } finally {
     db.close();
   }
 }
-function loadFromJson(sessionsDir, range) {
-  const files = readdirSync3(sessionsDir).filter((f) => f.endsWith(".json"));
+function loadFromLegacyJson(sessionsDir, range) {
+  const files = readdirSync3(sessionsDir).filter((file) => file.endsWith(".json"));
   const records = [];
   for (const file of files) {
-    const content = readFileSync(join3(sessionsDir, file), "utf-8");
-    const session = JSON.parse(content);
-    if (!Array.isArray(session.messages)) {
-      continue;
-    }
-    for (const msg of session.messages) {
-      if (msg.role !== "assistant" || !msg.usage) {
+    try {
+      const content = readFileSync(join3(sessionsDir, file), "utf-8");
+      const session = JSON.parse(content);
+      if (!Array.isArray(session.messages)) {
         continue;
       }
-      const date = extractDate2(msg.created_at);
-      if (isInRange(date, range)) {
-        records.push({
-          date,
-          model: msg.model,
-          inputTokens: msg.usage.input_tokens,
-          outputTokens: msg.usage.output_tokens
-        });
+      for (const msg of session.messages) {
+        if (msg.role !== "assistant" || !msg.usage) {
+          continue;
+        }
+        const date = extractDate2(msg.created_at);
+        if (date && isInRange(date, range)) {
+          records.push({
+            date,
+            model: msg.model,
+            inputTokens: msg.usage.input_tokens,
+            outputTokens: msg.usage.output_tokens,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0
+          });
+        }
       }
+    } catch {
+      continue;
     }
   }
   return records;
 }
+function loadFromCurrentStorage(baseDir, range) {
+  const messagesRoot = join3(baseDir, "storage", "message");
+  if (!existsSync3(messagesRoot)) {
+    return [];
+  }
+  const recordsById = new Map;
+  const recordsWithoutId = [];
+  for (const sessionDir of readdirSync3(messagesRoot)) {
+    const sessionPath = join3(messagesRoot, sessionDir);
+    let messageFiles;
+    try {
+      messageFiles = readdirSync3(sessionPath).filter((file) => file.endsWith(".json"));
+    } catch {
+      continue;
+    }
+    for (const file of messageFiles) {
+      try {
+        const content = readFileSync(join3(sessionPath, file), "utf-8");
+        const message = JSON.parse(content);
+        if (message.role !== "assistant") {
+          continue;
+        }
+        const model = message.modelID;
+        const createdAt = message.time?.created;
+        if (typeof model !== "string" || typeof createdAt !== "string" && typeof createdAt !== "number") {
+          continue;
+        }
+        const date = extractDate2(createdAt);
+        if (!date || !isInRange(date, range)) {
+          continue;
+        }
+        const inputTokens = typeof message.tokens?.input === "number" ? message.tokens.input : 0;
+        const outputTokens = typeof message.tokens?.output === "number" ? message.tokens.output : 0;
+        const cacheReadTokens = typeof message.tokens?.cache?.read === "number" ? message.tokens.cache.read : 0;
+        const cacheWriteTokens = typeof message.tokens?.cache?.write === "number" ? message.tokens.cache.write : 0;
+        const record = {
+          date,
+          model,
+          inputTokens,
+          outputTokens,
+          cacheReadTokens,
+          cacheWriteTokens,
+          explicitCost: typeof message.cost === "number" ? message.cost : undefined
+        };
+        const totalTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+        if (totalTokens === 0 && !(typeof record.explicitCost === "number" && record.explicitCost > 0)) {
+          continue;
+        }
+        if (typeof message.id === "string" && message.id.length > 0) {
+          recordsById.set(message.id, record);
+        } else {
+          recordsWithoutId.push(record);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return [...recordsById.values(), ...recordsWithoutId];
+}
 
 class OpenCodeProvider {
   name = PROVIDER_NAME;
@@ -1414,30 +1750,37 @@ class OpenCodeProvider {
   colors = COLORS;
   baseDir;
   constructor(baseDir) {
-    this.baseDir = baseDir ?? join3(homedir3(), ".opencode");
+    this.baseDir = resolveBaseDir2(baseDir);
   }
   async isAvailable() {
     try {
       if (!existsSync3(this.baseDir)) {
         return false;
       }
-      const hasDb = existsSync3(join3(this.baseDir, "sessions.db"));
-      const hasSessionsDir = existsSync3(join3(this.baseDir, "sessions"));
-      return hasDb || hasSessionsDir;
+      const hasCurrentStorage = existsSync3(join3(this.baseDir, "storage", "message"));
+      const hasLegacyDb = existsSync3(join3(this.baseDir, "opencode.db")) || existsSync3(join3(this.baseDir, "sessions.db"));
+      const hasLegacySessionsDir = existsSync3(join3(this.baseDir, "sessions"));
+      return hasCurrentStorage || hasLegacyDb || hasLegacySessionsDir;
     } catch {
       return false;
     }
   }
   async load(range) {
-    const dbPath = join3(this.baseDir, "sessions.db");
+    const currentMessagesRoot = join3(this.baseDir, "storage", "message");
+    if (existsSync3(currentMessagesRoot)) {
+      const currentRecords = loadFromCurrentStorage(this.baseDir, range);
+      return buildProviderData(currentRecords);
+    }
+    const opencodeDbPath = join3(this.baseDir, "opencode.db");
+    const sessionsDbPath = join3(this.baseDir, "sessions.db");
     const sessionsDir = join3(this.baseDir, "sessions");
-    let records;
-    if (existsSync3(dbPath)) {
-      records = loadFromSqlite(dbPath, range);
+    let records = [];
+    if (existsSync3(opencodeDbPath)) {
+      records = loadFromSqlite(opencodeDbPath, range);
+    } else if (existsSync3(sessionsDbPath)) {
+      records = loadFromSqlite(sessionsDbPath, range);
     } else if (existsSync3(sessionsDir)) {
-      records = loadFromJson(sessionsDir, range);
-    } else {
-      records = [];
+      records = loadFromLegacyJson(sessionsDir, range);
     }
     return buildProviderData(records);
   }
@@ -1984,7 +2327,6 @@ function renderTerminalCardSvg(output, options) {
   const contentWidth = cardWidth - pad * 2;
   let y = 0;
   const sections = [];
-  sections.push(`<defs><style>@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600;700&amp;display=swap');</style></defs>`);
   sections.push(`<rect width="${cardWidth}" height="__CARD_HEIGHT__" rx="12" fill="${escapeXml(theme.bg)}" stroke="${escapeXml(theme.border)}" stroke-width="1"/>`);
   sections.push(`<clipPath id="titlebar-clip"><rect width="${cardWidth}" height="${TITLEBAR_HEIGHT}" rx="12"/></clipPath>`);
   sections.push(`<rect width="${cardWidth}" height="${TITLEBAR_HEIGHT}" fill="${escapeXml(theme.bg)}" clip-path="url(#titlebar-clip)"/>`);
@@ -2088,7 +2430,7 @@ function renderTerminalCardSvg(output, options) {
   const svg = sections.join(`
 `).replace("__CARD_HEIGHT__", String(cardHeight));
   return [
-    `<svg xmlns="http://www.w3.org/2000/svg" width="${cardWidth}" height="${cardHeight}" viewBox="0 0 ${cardWidth} ${cardHeight}">`,
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${cardWidth}" height="${cardHeight}" viewBox="0 0 ${cardWidth} ${cardHeight}" shape-rendering="geometricPrecision" text-rendering="geometricPrecision">`,
     svg,
     "</svg>"
   ].join(`
@@ -2097,12 +2439,17 @@ function renderTerminalCardSvg(output, options) {
 
 // packages/renderers/dist/png/png-renderer.js
 import sharp from "sharp";
+var PNG_DENSITY = 288;
 
 class PngRenderer {
   format = "png";
   async render(output, options) {
     const svgString = renderTerminalCardSvg(output, options);
-    const pngBuffer = await sharp(Buffer.from(svgString)).png().toBuffer();
+    const pngBuffer = await sharp(Buffer.from(svgString), {
+      density: PNG_DENSITY
+    }).png({
+      compressionLevel: 9
+    }).toBuffer();
     return pngBuffer;
   }
 }
@@ -2271,6 +2618,9 @@ function formatCost2(cost) {
 function formatPercent(rate) {
   return `${(rate * 100).toFixed(1)}%`;
 }
+function formatSharePercent(percentage) {
+  return `${percentage.toFixed(0)}%`;
+}
 function divider(width) {
   return BOX_H.repeat(width);
 }
@@ -2337,7 +2687,7 @@ function renderDayOfWeek(stats, width, noColor2) {
 function renderTopModels(stats, width, noColor2) {
   const lines = [];
   for (const model of stats.topModels.slice(0, 5)) {
-    const pct = formatPercent(model.percentage);
+    const pct = formatSharePercent(model.percentage);
     const tokens = formatTokens(model.tokens);
     const line = `  ${colorize(model.model, "yellow", noColor2)}  ${tokens}  ${pct}`;
     lines.push(line.length > width ? line.slice(0, width) : line);
@@ -3063,8 +3413,21 @@ function inferFormatFromPath(filePath) {
       return null;
   }
 }
+var DATE_FORMAT = /^\d{4}-\d{2}-\d{2}$/;
+function isValidDate(dateStr) {
+  if (!DATE_FORMAT.test(dateStr))
+    return false;
+  const d = new Date(dateStr + "T00:00:00Z");
+  return !Number.isNaN(d.getTime()) && d.toISOString().slice(0, 10) === dateStr;
+}
 function computeDateRange(args) {
   const until = args.until ?? new Date().toISOString().slice(0, 10);
+  if (args.until && !isValidDate(args.until)) {
+    throw new TokenleakError(`Invalid --until date: "${args.until}". Use YYYY-MM-DD format.`);
+  }
+  if (args.since && !isValidDate(args.since)) {
+    throw new TokenleakError(`Invalid --since date: "${args.since}". Use YYYY-MM-DD format.`);
+  }
   let since;
   if (args.since) {
     since = args.since;
@@ -3074,6 +3437,9 @@ function computeDateRange(args) {
     d.setDate(d.getDate() - daysBack);
     since = d.toISOString().slice(0, 10);
   }
+  if (since > until) {
+    throw new TokenleakError(`--since (${since}) must not be after --until (${until}).`);
+  }
   return { since, until };
 }
 function resolveConfig(cliArgs) {
@@ -3230,6 +3596,10 @@ async function run(cliArgs) {
     throw new TokenleakError("No provider data found");
   }
   if (config.compare) {
+    if (config.format !== "json" && config.format !== "terminal") {
+      process.stderr.write(`Warning: --compare only supports JSON output. Ignoring --format ${config.format}.
+`);
+    }
     const compareOutput = await runCompare(config.compare, dateRange, registry, available);
     const rendered2 = JSON.stringify(compareOutput, null, 2);
     if (config.output) {
@@ -3261,6 +3631,19 @@ async function run(cliArgs) {
     aggregated: stats
   };
   if (config.liveServer) {
+    const ignoredFlags = [];
+    if (config.output)
+      ignoredFlags.push("--output");
+    if (config.clipboard)
+      ignoredFlags.push("--clipboard");
+    if (config.open)
+      ignoredFlags.push("--open");
+    if (config.upload)
+      ignoredFlags.push("--upload");
+    if (ignoredFlags.length > 0) {
+      process.stderr.write(`Warning: ${ignoredFlags.join(", ")} ignored in --live-server mode.
+`);
+    }
     const renderOptions2 = {
       format: config.format,
       theme: config.theme,