tokensniff 0.1.0

package/dist/cli.js

@@ -0,0 +1,2206 @@
+import { execSync, spawn } from 'child_process';
+import fs2 from 'fs';
+import net from 'net';
+import path2 from 'path';
+import os from 'os';
+import http from 'http';
+
+// src/cli/run.ts
+function toValidPort(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed >= 1 && parsed <= 65535 ? parsed : fallback;
+}
+function toBoundedInt(value, fallback, min = 0, max = Number.MAX_SAFE_INTEGER) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  const intVal = Math.floor(parsed);
+  return Math.max(min, Math.min(max, intVal));
+}
+function toNonEmptyString(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : fallback;
+}
+function toSafeBoolean(value, fallback) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lower = value.trim().toLowerCase();
+    if (lower === "true" || lower === "1") return true;
+    if (lower === "false" || lower === "0") return false;
+  }
+  return fallback;
+}
+function normalizeDirectory(targetPath) {
+  const resolved = path2.resolve(targetPath.trim());
+  return path2.normalize(resolved);
+}
+function getGlobalDir() {
+  const home = process.env.USERPROFILE || os.homedir();
+  return path2.join(home, ".tokensniff");
+}
+function getGlobalConfigPath() {
+  return path2.join(getGlobalDir(), "config.json");
+}
+function loadConfig(env = process.env) {
+  const targetConfigFile = env.TOKENSNIFF_CONFIG || getGlobalConfigPath();
+  let fileConfig = {};
+  if (fs2.existsSync(targetConfigFile)) {
+    try {
+      const raw = fs2.readFileSync(targetConfigFile, "utf8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        fileConfig = parsed;
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(`[tokensniff] ignoring corrupt config at ${targetConfigFile}: ${msg}`);
+    }
+  }
+  const resolve = (envKey, configKey, defaultValue) => {
+    return env[envKey] ?? fileConfig[configKey] ?? defaultValue;
+  };
+  const rootDir = getGlobalDir();
+  const defaultStatusDir = path2.join(rootDir, "status");
+  const rawStatusDirs = resolve("TOKENSNIFF_STATUS_DIRS", "statusDirs", [defaultStatusDir]);
+  const parsedDirs = Array.isArray(rawStatusDirs) ? rawStatusDirs.map(String) : String(rawStatusDirs).split(",");
+  const normalizedStatusDirs = parsedDirs.map((d) => d.trim()).filter((d) => d.length > 0).map(normalizeDirectory);
+  const statusDirs = normalizedStatusDirs.length > 0 ? normalizedStatusDirs : [normalizeDirectory(defaultStatusDir)];
+  const isNoColorSet = typeof env.NO_COLOR === "string" && env.NO_COLOR.length > 0;
+  const colorDefault = !isNoColorSet;
+  return {
+    listenPort: toValidPort(resolve("TOKENSNIFF_PORT", "listenPort", 4e3), 4e3),
+    listenHost: toNonEmptyString(
+      resolve("TOKENSNIFF_HOST", "listenHost", "127.0.0.1"),
+      "127.0.0.1"
+    ),
+    upstreamHost: toNonEmptyString(
+      resolve("TOKENSNIFF_UPSTREAM_HOST", "upstreamHost", "localhost"),
+      "localhost"
+    ),
+    upstreamPort: toValidPort(resolve("TOKENSNIFF_UPSTREAM_PORT", "upstreamPort", 8085), 8085),
+    upstreamTimeoutMs: toBoundedInt(
+      resolve("TOKENSNIFF_UPSTREAM_TIMEOUT_MS", "upstreamTimeoutMs", 3e5),
+      3e5,
+      1e3,
+      36e5
+    ),
+    maxBodyBytes: toBoundedInt(
+      resolve("TOKENSNIFF_MAX_BODY_BYTES", "maxBodyBytes", 10 * 1024 * 1024),
+      10485760,
+      1024,
+      100 * 1024 * 1024
+    ),
+    statusDirs,
+    maxSessions: toBoundedInt(resolve("TOKENSNIFF_MAX_SESSIONS", "maxSessions", 50), 50, 1, 1e3),
+    deadSessionMs: toBoundedInt(
+      resolve("TOKENSNIFF_DEAD_SESSION_MS", "deadSessionMs", 72 * 3600 * 1e3),
+      2592e5,
+      3600 * 1e3
+    ),
+    staleAfterS: toBoundedInt(
+      resolve("TOKENSNIFF_STALE_AFTER_S", "staleAfterS", 120),
+      120,
+      5,
+      86400
+    ),
+    labelMaxIn: toBoundedInt(resolve("TOKENSNIFF_LABEL_MAX_IN", "labelMaxIn", 2e3), 2e3, 100),
+    labelMaxOut: toBoundedInt(resolve("TOKENSNIFF_LABEL_MAX_OUT", "labelMaxOut", 60), 60, 1),
+    warnPct: toBoundedInt(resolve("TOKENSNIFF_WARN_PCT", "warnPct", 60), 60, 1, 99),
+    critPct: toBoundedInt(resolve("TOKENSNIFF_CRIT_PCT", "critPct", 80), 80, 2, 100),
+    color: colorDefault && toSafeBoolean(resolve("TOKENSNIFF_COLOR", "color", true), true),
+    upstreamCommand: toNonEmptyString(
+      resolve(
+        "TOKENSNIFF_UPSTREAM_CMD",
+        "upstreamCommand",
+        "npx antigravity-claude-proxy@latest start"
+      ),
+      "npx antigravity-claude-proxy@latest start"
+    ),
+    upstreamStopCommand: String(
+      resolve("TOKENSNIFF_UPSTREAM_STOP_CMD", "upstreamStopCommand", "")
+    ).trim(),
+    harnessCommand: toNonEmptyString(
+      resolve("TOKENSNIFF_HARNESS_CMD", "harnessCommand", "claude"),
+      "claude"
+    )
+  };
+}
+function sanitizeSessionId(id) {
+  const normalized = String(id || "default").trim().slice(0, 64);
+  return /^[A-Za-z0-9_-]+$/.test(normalized) ? normalized : "default";
+}
+function getLocalDateString(d = /* @__PURE__ */ new Date()) {
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function syncSleep(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+  }
+}
+function ensureDir(dir) {
+  try {
+    fs2.mkdirSync(dir, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function atomicWrite(filePath, data, maxRetries = 5) {
+  const dir = path2.dirname(filePath);
+  ensureDir(dir);
+  const tmpPath = path2.join(
+    dir,
+    `.${path2.basename(filePath)}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`
+  );
+  fs2.writeFileSync(tmpPath, data, "utf8");
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      fs2.renameSync(tmpPath, filePath);
+      return;
+    } catch (error) {
+      const err = error;
+      const isLockError = process.platform === "win32" && (err.code === "EPERM" || err.code === "EBUSY" || err.code === "EACCES");
+      if (isLockError && attempt < maxRetries) {
+        syncSleep((attempt + 1) * 10);
+        continue;
+      }
+      try {
+        fs2.unlinkSync(tmpPath);
+      } catch {
+      }
+      throw error;
+    }
+  }
+}
+function atomicAppend(filePath, line, maxRetries = 5) {
+  const dir = path2.dirname(filePath);
+  ensureDir(dir);
+  const payload = line.endsWith("\n") ? line : `${line}
+`;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      fs2.appendFileSync(filePath, payload, { encoding: "utf8", flag: "a" });
+      return;
+    } catch (error) {
+      const err = error;
+      const isLockError = process.platform === "win32" && (err.code === "EPERM" || err.code === "EBUSY" || err.code === "EACCES");
+      if (isLockError && attempt < maxRetries) {
+        syncSleep((attempt + 1) * 10);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+function saveLatest(statusDirs, sessionId, latestPayload) {
+  const safeId = sanitizeSessionId(sessionId);
+  const serialized = JSON.stringify(latestPayload);
+  for (const dir of statusDirs) {
+    try {
+      ensureDir(dir);
+      atomicWrite(path2.join(dir, `latest-${safeId}.json`), serialized);
+      atomicWrite(path2.join(dir, "latest.json"), serialized);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(`[tokensniff] failed saving status in ${dir}: ${msg}`);
+    }
+  }
+}
+function saveTotals(statusDirs, totals, maxSessions) {
+  const sessionKeys = Object.keys(totals);
+  if (sessionKeys.length > maxSessions) {
+    const expiredKeys = sessionKeys.slice(0, sessionKeys.length - maxSessions);
+    for (const key of expiredKeys) {
+      delete totals[key];
+    }
+  }
+  const serialized = JSON.stringify(totals);
+  for (const dir of statusDirs) {
+    try {
+      ensureDir(dir);
+      atomicWrite(path2.join(dir, "totals.json"), serialized);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(`[tokensniff] failed saving totals in ${dir}: ${msg}`);
+    }
+  }
+  return totals;
+}
+function loadTotals(statusDirs) {
+  for (const dir of statusDirs) {
+    const targetFile = path2.join(dir, "totals.json");
+    try {
+      if (fs2.existsSync(targetFile)) {
+        const parsed = JSON.parse(fs2.readFileSync(targetFile, "utf8"));
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          return parsed;
+        }
+      }
+    } catch {
+    }
+  }
+  return {};
+}
+function appendHistory(statusDirs, entry) {
+  const line = JSON.stringify({
+    d: entry.date || getLocalDateString(),
+    ts: Date.now(),
+    s: sanitizeSessionId(entry.sessionId),
+    t: entry.turn || 1,
+    m: entry.model || "unknown",
+    tk: entry.tokens || 0,
+    c: Number(Number(entry.cost || 0).toFixed(6)),
+    cr: entry.cacheRead || 0,
+    th: entry.thinkingTokens || 0
+  });
+  for (const dir of statusDirs) {
+    try {
+      const historyPath = path2.join(dir, "history.ndjson");
+      atomicAppend(historyPath, line);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(`[tokensniff] failed appending history in ${dir}: ${msg}`);
+    }
+  }
+}
+function loadTodaySpend(statusDirs, targetDate = getLocalDateString()) {
+  for (const dir of statusDirs) {
+    const historyPath = path2.join(dir, "history.ndjson");
+    if (!fs2.existsSync(historyPath)) continue;
+    try {
+      const content = fs2.readFileSync(historyPath, "utf8");
+      let totalCost = 0;
+      const lines = content.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const row = JSON.parse(line);
+          if (typeof row === "object" && row !== null && row.d === targetDate && typeof row.c === "number") {
+            totalCost += row.c;
+          }
+        } catch {
+        }
+      }
+      return totalCost;
+    } catch {
+    }
+  }
+  return 0;
+}
+function pruneDeadSessions(statusDirs, ttlMs) {
+  const cutoffTime = Date.now() - ttlMs;
+  for (const dir of statusDirs) {
+    if (!fs2.existsSync(dir)) continue;
+    try {
+      const files = fs2.readdirSync(dir);
+      for (const file of files) {
+        if (!file.startsWith("latest-") || !file.endsWith(".json")) continue;
+        const filePath = path2.join(dir, file);
+        try {
+          const stats = fs2.statSync(filePath);
+          if (stats.mtimeMs < cutoffTime) {
+            fs2.unlinkSync(filePath);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+}
+
+// src/shared/pricing.ts
+var rateCache = /* @__PURE__ */ new Map();
+var catalogPromise = null;
+function normalizeModelName(raw) {
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return "unknown";
+  }
+  const trimmed = raw.trim().toLowerCase();
+  const withoutNamespace = trimmed.replace(/^~?[a-zA-Z0-9_-]+\//, "");
+  return withoutNamespace.replace(/:[a-zA-Z0-9_-]+$/, "").replace(/-(?:tiered|thinking|preview|low|high|latest)$/, "").replace(/-(?:\d{4}-\d{2}-\d{2}|\d{8}|\d{4})$/, "").replace(/\b(\d+)-(\d+)\b/g, "$1.$2");
+}
+function toSafeRate(value, fallback = 0) {
+  if (!value) return fallback;
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+async function syncOpenRouterCatalog() {
+  if (catalogPromise) {
+    return catalogPromise;
+  }
+  catalogPromise = (async () => {
+    try {
+      const response = await fetch("https://openrouter.ai/api/v1/models", {
+        signal: AbortSignal.timeout(5e3),
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        return false;
+      }
+      const json = await response.json();
+      if (!Array.isArray(json?.data)) {
+        return false;
+      }
+      for (const item of json.data) {
+        if (!item?.id || !item.pricing) continue;
+        const promptRate = toSafeRate(item.pricing.prompt);
+        const completionRate = toSafeRate(item.pricing.completion);
+        const cacheReadRate = toSafeRate(
+          item.pricing.input_cache_read,
+          promptRate > 0 ? promptRate * 0.1 : 0
+        );
+        const cacheWriteRate = toSafeRate(item.pricing.input_cache_write, promptRate);
+        const rawWindow = item.context_length;
+        const contextWindow = typeof rawWindow === "number" && Number.isFinite(rawWindow) && rawWindow > 0 ? rawWindow : 128e3;
+        const resolvedRates = {
+          in: promptRate,
+          out: completionRate,
+          cached: cacheReadRate,
+          cacheWrite: cacheWriteRate,
+          window: contextWindow
+        };
+        const fullId = item.id.toLowerCase();
+        const bareSlug = item.id.includes("/") ? item.id.split("/")[1]?.toLowerCase() ?? fullId : fullId;
+        const cleanSlug = normalizeModelName(item.id);
+        rateCache.set(fullId, resolvedRates);
+        rateCache.set(bareSlug, resolvedRates);
+        rateCache.set(cleanSlug, resolvedRates);
+      }
+      return true;
+    } catch {
+      return false;
+    } finally {
+      catalogPromise = null;
+    }
+  })();
+  return catalogPromise;
+}
+async function resolveModelRates(model, overrides = {}) {
+  const clean = normalizeModelName(model);
+  const rawKey = model.trim().toLowerCase();
+  const matchedOverride = overrides[rawKey] ?? overrides[clean];
+  if (matchedOverride) {
+    const existing = rateCache.get(clean) ?? rateCache.get(rawKey);
+    const resolvedOverride = {
+      in: matchedOverride.in ?? existing?.in ?? 0,
+      out: matchedOverride.out ?? existing?.out ?? 0,
+      cached: matchedOverride.cached ?? existing?.cached ?? 0,
+      cacheWrite: matchedOverride.in ?? existing?.cacheWrite ?? 0,
+      window: matchedOverride.window ?? existing?.window ?? 128e3
+    };
+    rateCache.set(clean, resolvedOverride);
+    rateCache.set(rawKey, resolvedOverride);
+    return resolvedOverride;
+  }
+  const cached = rateCache.get(clean) ?? rateCache.get(rawKey);
+  if (cached) {
+    return cached;
+  }
+  await syncOpenRouterCatalog();
+  const postSync = rateCache.get(clean) ?? rateCache.get(rawKey);
+  if (postSync) {
+    return postSync;
+  }
+  const candidateKeys = Array.from(rateCache.keys()).sort((a, b) => b.length - a.length);
+  for (const key of candidateKeys) {
+    if (key.length > 3 && (clean.includes(key) || key.includes(clean))) {
+      const rates = rateCache.get(key);
+      if (rates) {
+        rateCache.set(clean, rates);
+        return rates;
+      }
+    }
+  }
+  const defaultBoundary = {
+    in: 0,
+    out: 0,
+    cached: 0,
+    cacheWrite: 0,
+    window: 128e3
+  };
+  rateCache.set(clean, defaultBoundary);
+  return defaultBoundary;
+}
+function ratesFor(model) {
+  const clean = normalizeModelName(model);
+  const rawKey = model.trim().toLowerCase();
+  const hit = rateCache.get(clean) ?? rateCache.get(rawKey);
+  if (hit) {
+    return hit;
+  }
+  void syncOpenRouterCatalog();
+  return {
+    in: 0,
+    out: 0,
+    cached: 0,
+    cacheWrite: 0,
+    window: 128e3
+  };
+}
+function costFor(rates, usage) {
+  const inputTokens = Math.max(0, usage.input ?? 0);
+  const outputTokens = Math.max(0, usage.output ?? 0);
+  const cacheReadTokens = Math.max(0, usage.cacheRead ?? 0);
+  const cacheCreateTokens = Math.max(0, usage.cacheCreate ?? 0);
+  const cacheWriteRate = rates.cacheWrite > 0 ? rates.cacheWrite : rates.in;
+  const total = inputTokens * rates.in + outputTokens * rates.out + cacheReadTokens * rates.cached + cacheCreateTokens * cacheWriteRate;
+  if (!Number.isFinite(total) || total < 0) {
+    return 0;
+  }
+  return Math.round(total * 1e8) / 1e8;
+}
+
+// src/dashboard/heatmap.ts
+function loadDailyRollup(statusDirs) {
+  const dailyMap = {};
+  for (const dir of statusDirs) {
+    const historyPath = path2.join(dir, "history.ndjson");
+    if (!fs2.existsSync(historyPath)) continue;
+    try {
+      const raw = fs2.readFileSync(historyPath, "utf8");
+      const lines = raw.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const row = JSON.parse(line);
+          if (typeof row !== "object" || row === null) continue;
+          const record = row;
+          const dateStr = record.d;
+          if (typeof dateStr !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+            continue;
+          }
+          if (!dailyMap[dateStr]) {
+            dailyMap[dateStr] = {
+              date: dateStr,
+              tokens: 0,
+              cost: 0,
+              cacheRead: 0,
+              thinkingTokens: 0,
+              turns: 0,
+              models: {},
+              hourlyTurns: new Array(24).fill(0)
+            };
+          }
+          const bucket = dailyMap[dateStr];
+          if (!bucket) continue;
+          bucket.tokens += typeof record.tk === "number" ? record.tk : 0;
+          bucket.cost += typeof record.c === "number" ? record.c : 0;
+          bucket.cacheRead += typeof record.cr === "number" ? record.cr : 0;
+          bucket.thinkingTokens += typeof record.th === "number" ? record.th : 0;
+          bucket.turns += 1;
+          const model = typeof record.m === "string" && record.m ? record.m : "unknown";
+          bucket.models[model] = (bucket.models[model] ?? 0) + 1;
+          if (typeof record.ts === "number") {
+            const hour = new Date(record.ts).getHours();
+            if (hour >= 0 && hour < 24 && bucket.hourlyTurns[hour] !== void 0) {
+              bucket.hourlyTurns[hour] += 1;
+            }
+          }
+        } catch {
+        }
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(`[tokensniff] failed reading history in ${dir}: ${msg}`);
+    }
+  }
+  return dailyMap;
+}
+function importCapturesDirectory(sourceDir, targetStatusDirs) {
+  if (!fs2.existsSync(sourceDir)) {
+    return { imported: 0, skipped: 0 };
+  }
+  const files = fs2.readdirSync(sourceDir);
+  let imported = 0;
+  let skipped = 0;
+  for (const file of files) {
+    if (!file.endsWith(".json") || file.startsWith("session_")) continue;
+    const fullPath = path2.join(sourceDir, file);
+    try {
+      const parsedData = JSON.parse(fs2.readFileSync(fullPath, "utf8"));
+      if (typeof parsedData !== "object" || parsedData === null) {
+        skipped++;
+        continue;
+      }
+      const data = parsedData;
+      const timestamp = data.timestamp || data.reqLog?.timestamp;
+      if (!timestamp) {
+        skipped++;
+        continue;
+      }
+      const dateStr = getLocalDateString(new Date(timestamp));
+      const res = data.response || data.reqLog?.responseHeaders;
+      if (!res) {
+        skipped++;
+        continue;
+      }
+      let rawBody = "";
+      if (typeof data.response?.rawBodyString === "string") {
+        rawBody = data.response.rawBodyString;
+      } else if (typeof data.reqLog?.rawResponseBody === "string") {
+        rawBody = data.reqLog.rawResponseBody;
+      }
+      if (!rawBody) {
+        skipped++;
+        continue;
+      }
+      const parsedBody = JSON.parse(rawBody);
+      if (typeof parsedBody !== "object" || parsedBody === null) {
+        skipped++;
+        continue;
+      }
+      const bodyObj = parsedBody;
+      const usage = bodyObj.usage ?? {};
+      const model = typeof bodyObj.model === "string" ? bodyObj.model : "gemini-3.7-flash-tiered";
+      const rates = ratesFor(model);
+      const inTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+      const outTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+      const cacheRead = typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0;
+      const cacheCreate = typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : 0;
+      if (inTokens === 0 && outTokens === 0) {
+        skipped++;
+        continue;
+      }
+      const turnCost = costFor(rates, {
+        input: inTokens,
+        output: outTokens,
+        cacheRead,
+        cacheCreate
+      });
+      appendHistory(targetStatusDirs, {
+        date: dateStr,
+        sessionId: "imported",
+        turn: 1,
+        model,
+        tokens: inTokens + outTokens + cacheRead,
+        cost: turnCost,
+        cacheRead,
+        thinkingTokens: 0
+      });
+      imported++;
+    } catch {
+      skipped++;
+    }
+  }
+  return { imported, skipped };
+}
+function renderHeatmapHtml(dailyMap, targetYear = (/* @__PURE__ */ new Date()).getFullYear()) {
+  let totalTokens = 0;
+  let totalCost = 0;
+  let totalTurns = 0;
+  let totalCacheRead = 0;
+  for (const bucket of Object.values(dailyMap)) {
+    totalTokens += bucket.tokens;
+    totalCost += bucket.cost;
+    totalTurns += bucket.turns;
+    totalCacheRead += bucket.cacheRead;
+  }
+  const cacheHitPct = totalTokens > 0 ? (totalCacheRead / totalTokens * 100).toFixed(1) : "0.0";
+  const formattedTotalTokens = totalTokens >= 1e9 ? `${(totalTokens / 1e9).toFixed(2)}B` : `${(totalTokens / 1e6).toFixed(2)}M`;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>tokensniff \u2022 ${targetYear} Token Spend Heatmap</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+    :root {
+      --bg-deep: #05070c;
+      --panel-surface: #0a0e17;
+      --panel-border: rgba(255, 255, 255, 0.07);
+      --panel-highlight: rgba(255, 255, 255, 0.12);
+      --text-main: #f8fafc;
+      --text-muted: #64748b;
+      --text-subtle: #475569;
+      --emerald-bright: #34d399;
+      --emerald-vivid: #10b981;
+      --emerald-deep: #047857;
+      --emerald-dark: #064e3b;
+      --tile-size: 16px;
+      --tile-gap: 4.5px;
+      --tile-radius: 3px;
+    }
+
+    body {
+      overflow-x: hidden;
+      background: radial-gradient(circle at 50% -10%, rgba(16, 185, 129, 0.12), transparent 70%),
+                  radial-gradient(circle at 10% 100%, rgba(5, 150, 105, 0.05), transparent 50%),
+                  var(--bg-deep);
+      color: var(--text-main);
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Inter", "Geist", sans-serif;
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      padding: 48px 24px;
+      -webkit-font-smoothing: antialiased;
+      -moz-osx-font-smoothing: grayscale;
+    }
+
+    .container {
+      width: 100%;
+      max-width: 1220px;
+      background: var(--panel-surface);
+      border: 1px solid var(--panel-border);
+      border-radius: 20px;
+      padding: 38px 44px;
+      box-shadow: 0 40px 100px -20px rgba(0, 0, 0, 0.95),
+                  0 0 0 1px rgba(255, 255, 255, 0.03) inset,
+                  0 0 80px rgba(16, 185, 129, 0.04);
+      position: relative;
+      overflow: hidden;
+    }
+
+    .container::before {
+      content: "";
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      height: 1px;
+      background: linear-gradient(90deg, transparent, rgba(52, 211, 153, 0.4), transparent);
+    }
+
+    /* Header Bar */
+    .header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      padding-bottom: 30px;
+      border-bottom: 1px solid rgba(255, 255, 255, 0.06);
+      flex-wrap: wrap;
+      gap: 24px;
+    }
+
+    .title-group {
+      display: flex;
+      align-items: center;
+      gap: 16px;
+    }
+
+    .badge-icon {
+      width: 44px;
+      height: 44px;
+      border-radius: 12px;
+      background: linear-gradient(135deg, rgba(16, 185, 129, 0.25), rgba(4, 120, 87, 0.08));
+      border: 1px solid rgba(52, 211, 153, 0.4);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      color: var(--emerald-bright);
+      font-weight: 800;
+      font-size: 17px;
+      font-family: ui-monospace, "SF Mono", monospace;
+      box-shadow: 0 0 24px rgba(16, 185, 129, 0.2), inset 0 1px 1px rgba(255, 255, 255, 0.2);
+    }
+
+    h1 {
+      font-size: 21px;
+      font-weight: 700;
+      color: #ffffff;
+      letter-spacing: -0.025em;
+      line-height: 1.2;
+    }
+
+    .subtext {
+      font-size: 13px;
+      color: var(--text-muted);
+      margin-top: 4px;
+      font-family: ui-monospace, "SF Mono", monospace;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .status-pulse {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 11px;
+      color: var(--emerald-bright);
+      background: rgba(16, 185, 129, 0.1);
+      border: 1px solid rgba(52, 211, 153, 0.25);
+      border-radius: 20px;
+      padding: 2px 10px;
+      text-transform: uppercase;
+      letter-spacing: 0.06em;
+      font-weight: 600;
+    }
+
+    .status-pulse-dot {
+      width: 6px;
+      height: 6px;
+      border-radius: 50%;
+      background: var(--emerald-bright);
+      box-shadow: 0 0 8px var(--emerald-bright);
+    }
+
+    /* Structured Metric Bays */
+    .summary-metrics {
+      display: flex;
+      gap: 14px;
+      font-family: ui-monospace, "SF Mono", monospace;
+      flex-wrap: wrap;
+    }
+
+    .summary-item {
+      display: flex;
+      flex-direction: column;
+      align-items: flex-end;
+      background: rgba(255, 255, 255, 0.02);
+      border: 1px solid rgba(255, 255, 255, 0.06);
+      border-radius: 12px;
+      padding: 12px 20px;
+      min-width: 125px;
+      box-shadow: inset 0 1px 1px rgba(255, 255, 255, 0.03);
+    }
+
+    .summary-label {
+      font-size: 10px;
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      color: var(--text-muted);
+      font-weight: 600;
+    }
+
+    .summary-val {
+      color: #ffffff;
+      font-size: 18px;
+      font-weight: 700;
+      margin-top: 5px;
+      letter-spacing: -0.02em;
+    }
+
+    .summary-val.emerald {
+      color: var(--emerald-bright);
+      text-shadow: 0 0 20px rgba(52, 211, 153, 0.45);
+    }
+
+    /* Heatmap Layout & Viewport */
+    .heatmap-wrapper {
+      padding-top: 34px;
+      overflow-x: auto;
+      scrollbar-width: thin;
+      scrollbar-color: rgba(255, 255, 255, 0.1) transparent;
+    }
+
+    .heatmap-wrapper::-webkit-scrollbar {
+      height: 6px;
+    }
+    .heatmap-wrapper::-webkit-scrollbar-thumb {
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 3px;
+    }
+
+    .months-row {
+      position: relative;
+      height: 22px;
+      margin-left: 42px;
+      margin-bottom: 10px;
+      font-size: 12px;
+      font-weight: 600;
+      color: var(--text-muted);
+      font-family: ui-monospace, "SF Mono", monospace;
+    }
+
+    .month-label {
+      position: absolute;
+      user-select: none;
+      letter-spacing: -0.01em;
+    }
+
+    .grid-container {
+      display: flex;
+      gap: 12px;
+      align-items: start;
+    }
+
+    .weekday-labels {
+      display: grid;
+      grid-template-rows: repeat(7, var(--tile-size));
+      gap: var(--tile-gap);
+      font-size: 11px;
+      color: var(--text-subtle);
+      font-family: ui-monospace, "SF Mono", monospace;
+      font-weight: 600;
+      user-select: none;
+      line-height: var(--tile-size);
+      text-align: right;
+      padding-right: 6px;
+      width: 34px;
+    }
+
+    .tiles-grid {
+      display: grid;
+      grid-template-rows: repeat(7, var(--tile-size));
+      grid-auto-flow: column;
+      grid-auto-columns: var(--tile-size);
+      gap: var(--tile-gap);
+    }
+
+    .tile {
+      width: var(--tile-size);
+      height: var(--tile-size);
+      border-radius: var(--tile-radius);
+      cursor: pointer;
+      transition: transform 0.16s cubic-bezier(0.16, 1, 0.3, 1), box-shadow 0.16s ease, border-color 0.16s ease;
+      outline: 1px solid transparent;
+      position: relative;
+    }
+
+    .tile:hover {
+      transform: scale(1.38);
+      z-index: 10;
+      outline: 1px solid #ffffff;
+      box-shadow: 0 0 16px rgba(255, 255, 255, 0.65);
+    }
+
+    /* 5-Tier Competitive Millions/Billions Jewel Palette */
+    .tier-0 {
+      background: #0d121c;
+      border: 1px solid rgba(255, 255, 255, 0.04);
+    }
+    .tier-1 {
+      background: #064e3b;
+      border: 1px solid #047857;
+      box-shadow: inset 0 1px 1px rgba(255, 255, 255, 0.1);
+    }
+    .tier-2 {
+      background: #047857;
+      border: 1px solid #10b981;
+      box-shadow: 0 0 8px rgba(4, 120, 87, 0.45), inset 0 1px 1px rgba(255, 255, 255, 0.2);
+    }
+    .tier-3 {
+      background: #10b981;
+      border: 1px solid #34d399;
+      box-shadow: 0 0 14px rgba(16, 185, 129, 0.65), inset 0 1px 1px rgba(255, 255, 255, 0.3);
+    }
+    .tier-4 {
+      background: #34d399;
+      border: 1px solid #a7f3d0;
+      box-shadow: 0 0 20px rgba(52, 211, 153, 0.9), inset 0 0 4px #ffffff;
+    }
+
+    /* Footer Milestone Legend */
+    .footer {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-top: 32px;
+      padding-top: 22px;
+      border-top: 1px solid rgba(255, 255, 255, 0.06);
+      font-size: 12px;
+      color: var(--text-muted);
+      font-family: ui-monospace, "SF Mono", monospace;
+      flex-wrap: wrap;
+      gap: 16px;
+    }
+
+    .legend-container {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+    }
+
+    .legend-label {
+      font-size: 11px;
+      color: var(--text-muted);
+      text-transform: uppercase;
+      letter-spacing: 0.06em;
+      font-weight: 600;
+    }
+
+    .legend {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .legend-tile {
+      width: 15px;
+      height: 15px;
+      border-radius: var(--tile-radius);
+    }
+
+    .legend-bounds {
+      font-size: 11px;
+      color: var(--text-muted);
+    }
+
+    /* Floating Glassmorphic HUD Tooltip */
+    #tooltip {
+      position: fixed;
+      display: none;
+      pointer-events: none;
+      background: rgba(10, 14, 23, 0.97);
+      backdrop-filter: blur(16px);
+      -webkit-backdrop-filter: blur(16px);
+      border: 1px solid rgba(255, 255, 255, 0.12);
+      border-radius: 12px;
+      padding: 14px 18px;
+      font-size: 12px;
+      color: #f1f5f9;
+      box-shadow: 0 20px 40px rgba(0, 0, 0, 0.95), 0 0 30px rgba(16, 185, 129, 0.12);
+      font-family: ui-monospace, "SF Mono", monospace;
+      z-index: 1000;
+      line-height: 1.6;
+      min-width: 220px;
+    }
+
+    .tt-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: 8px;
+      padding-bottom: 6px;
+      border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+    }
+
+    .tt-date {
+      font-weight: 700;
+      color: #ffffff;
+      font-size: 13px;
+    }
+
+    .tt-row {
+      display: flex;
+      justify-content: space-between;
+      margin-top: 3px;
+    }
+
+    .tt-label {
+      color: var(--text-muted);
+    }
+
+    .tt-cost {
+      color: var(--emerald-bright);
+      font-weight: 700;
+    }
+
+    .tt-val {
+      font-weight: 600;
+      color: #ffffff;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <div class="title-group">
+        <div class="badge-icon">TS</div>
+        <div>
+          <h1>tokensniff dashboard</h1>
+          <div class="subtext">
+            <span>Year ${targetYear} Token Telemetry & Spend Ledger</span>
+            <span class="status-pulse"><span class="status-pulse-dot"></span>Online</span>
+          </div>
+        </div>
+      </div>
+      <div class="summary-metrics">
+        <div class="summary-item">
+          <span class="summary-label">Total Spend</span>
+          <span class="summary-val emerald">$${totalCost.toFixed(3)}</span>
+        </div>
+        <div class="summary-item">
+          <span class="summary-label">Total Tokens</span>
+          <span class="summary-val">${formattedTotalTokens}</span>
+        </div>
+        <div class="summary-item">
+          <span class="summary-label">Cache Ratio</span>
+          <span class="summary-val">${cacheHitPct}%</span>
+        </div>
+        <div class="summary-item">
+          <span class="summary-label">Total Turns</span>
+          <span class="summary-val">${totalTurns}</span>
+        </div>
+      </div>
+    </div>
+
+    <div class="heatmap-wrapper">
+      <div id="months-row" class="months-row"></div>
+      <div class="grid-container">
+        <div class="weekday-labels">
+          <span></span>
+          <span>Mon</span>
+          <span></span>
+          <span>Wed</span>
+          <span></span>
+          <span>Fri</span>
+          <span></span>
+        </div>
+        <div id="tiles" class="tiles-grid"></div>
+      </div>
+    </div>
+
+    <div class="footer">
+      <span>Auto-updated live ledger \u2022 port 4000</span>
+      <div class="legend-container">
+        <span class="legend-label">Daily Volume</span>
+        <span class="legend-bounds">0</span>
+        <div class="legend">
+          <div class="legend-tile tier-0" title="0 tokens"></div>
+          <div class="legend-tile tier-1" title="1M - 5M tokens"></div>
+          <div class="legend-tile tier-2" title="5M - 25M tokens"></div>
+          <div class="legend-tile tier-3" title="25M - 100M tokens"></div>
+          <div class="legend-tile tier-4" title="> 100M tokens"></div>
+        </div>
+        <span class="legend-bounds">100M+</span>
+      </div>
+    </div>
+  </div>
+
+  <div id="tooltip"></div>
+
+  <script>
+    const data = ${JSON.stringify(dailyMap)};
+    const year = ${targetYear};
+    const tilesContainer = document.getElementById('tiles');
+    const monthsRow = document.getElementById('months-row');
+    const tooltip = document.getElementById('tooltip');
+
+    const startDate = new Date(year, 0, 1);
+    const startDay = startDate.getDay(); // 0 is Sunday
+
+    // Pad beginning of the year so rows align to Sunday-Saturday
+    for (let p = 0; p < startDay; p++) {
+      const empty = document.createElement('div');
+      empty.style.width = '16px';
+      empty.style.height = '16px';
+      tilesContainer.appendChild(empty);
+    }
+
+    const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
+    const totalDays = isLeapYear ? 366 : 365;
+    const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    let lastMonth = -1;
+
+    function formatHumanTokens(t) {
+      if (!t || t === 0) return '0';
+      if (t >= 1e9) return (t / 1e9).toFixed(2) + 'B';
+      if (t >= 1e6) return (t / 1e6).toFixed(2) + 'M';
+      if (t >= 1e3) return (t / 1e3).toFixed(1) + 'k';
+      return t.toLocaleString();
+    }
+
+    for (let i = 0; i < totalDays; i++) {
+      const cur = new Date(year, 0, 1 + i);
+      const m = cur.getMonth();
+      const yearStr = cur.getFullYear();
+      const monthStr = String(cur.getMonth() + 1).padStart(2, '0');
+      const dayStr = String(cur.getDate()).padStart(2, '0');
+      const dStr = yearStr + '-' + monthStr + '-' + dayStr;
+
+      // Position month labels dynamically along the horizontal week track
+      // 16px tile + 4.5px gap = 20.5px step
+      if (m !== lastMonth) {
+        lastMonth = m;
+        const weekCol = Math.floor((i + startDay) / 7);
+        const span = document.createElement('span');
+        span.className = 'month-label';
+        span.innerText = monthNames[m];
+        span.style.left = (weekCol * 20.5) + 'px';
+        monthsRow.appendChild(span);
+      }
+
+      const record = data[dStr];
+      const tokens = record ? record.tokens : 0;
+      const cost = record ? record.cost : 0;
+      const turns = record ? record.turns : 0;
+      const cacheRead = record ? record.cacheRead : 0;
+
+      // Competitive Millions & Billions Tiers
+      let tier = 'tier-0';
+      if (tokens >= 100000000) tier = 'tier-4';        // > 100M tokens
+      else if (tokens >= 25000000) tier = 'tier-3';   // 25M - 100M tokens
+      else if (tokens >= 5000000) tier = 'tier-2';    // 5M - 25M tokens
+      else if (tokens > 0) tier = 'tier-1';           // 1M - 5M tokens
+
+      const tile = document.createElement('div');
+      tile.className = 'tile ' + tier;
+
+      function positionTooltip(e) {
+        const tipWidth = tooltip.offsetWidth || 240;
+        const tipHeight = tooltip.offsetHeight || 160;
+        let x = e.clientX + 16;
+        let y = e.clientY + 16;
+
+        // If hovering near the right edge of the screen (e.g. December), flip to the left of the cursor
+        if (x + tipWidth > window.innerWidth - 16) {
+          x = e.clientX - tipWidth - 16;
+        }
+
+        // If hovering near the bottom of the screen, flip upward above the cursor
+        if (y + tipHeight > window.innerHeight - 16) {
+          y = e.clientY - tipHeight - 16;
+        }
+
+        tooltip.style.left = Math.max(12, x) + 'px';
+        tooltip.style.top = Math.max(12, y) + 'px';
+      }
+
+      tile.onmouseenter = (e) => {
+        const cachePct = tokens > 0 ? ((cacheRead / tokens) * 100).toFixed(1) : '0.0';
+        tooltip.innerHTML =
+          '<div class="tt-header">' +
+            '<span class="tt-date">' + cur.toLocaleDateString(undefined, { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric' }) + '</span>' +
+            '<span class="tt-cost">$' + cost.toFixed(4) + '</span>' +
+          '</div>' +
+          '<div class="tt-row"><span class="tt-label">Volume</span><span class="tt-val">' + formatHumanTokens(tokens) + '</span></div>' +
+          '<div class="tt-row"><span class="tt-label">Exact Tokens</span><span class="tt-val">' + tokens.toLocaleString() + '</span></div>' +
+          '<div class="tt-row"><span class="tt-label">Cache Leverage</span><span class="tt-val">' + formatHumanTokens(cacheRead) + ' (' + cachePct + '%)</span></div>' +
+          '<div class="tt-row"><span class="tt-label">Turns Logged</span><span class="tt-val">' + turns + '</span></div>';
+        positionTooltip(e);
+        tooltip.style.display = 'block';
+      };
+
+      tile.onmousemove = (e) => {
+        positionTooltip(e);
+      };
+
+      tile.onmouseleave = () => {
+        tooltip.style.display = 'none';
+      };
+
+      tilesContainer.appendChild(tile);
+    }
+  </script>
+</body>
+</html>`;
+}
+
+// src/shared/schema.ts
+var SCHEMA_VERSION = 1;
+function toFiniteNumber(value, fallback = 0) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback;
+}
+function buildLatest(partial) {
+  return {
+    v: SCHEMA_VERSION,
+    session_id: partial.session_id,
+    turn_index: Math.max(1, Math.floor(toFiniteNumber(partial.turn_index, 1))),
+    ts: toFiniteNumber(partial.ts, Date.now()),
+    model: typeof partial.model === "string" && partial.model.length > 0 ? partial.model : "unknown",
+    is_bg: Boolean(partial.is_bg),
+    ctx: Math.max(0, toFiniteNumber(partial.ctx, 0)),
+    window: Math.max(1, toFiniteNumber(partial.window, 1e6)),
+    pct: Math.max(0, Math.min(100, toFiniteNumber(partial.pct, 0))),
+    cache_read: Math.max(0, toFiniteNumber(partial.cache_read, 0)),
+    cache_create: Math.max(0, toFiniteNumber(partial.cache_create, 0)),
+    delta_in: toFiniteNumber(partial.delta_in, 0),
+    in_tokens: Math.max(0, toFiniteNumber(partial.in_tokens, 0)),
+    out_tokens: Math.max(0, toFiniteNumber(partial.out_tokens, 0)),
+    thinking: Boolean(partial.thinking),
+    thinking_tokens: Math.max(0, toFiniteNumber(partial.thinking_tokens, 0)),
+    tool: typeof partial.tool === "string" && partial.tool.length > 0 ? partial.tool : null,
+    tool_tk: Math.max(0, toFiniteNumber(partial.tool_tk, 0)),
+    tools_summary: Array.isArray(partial.tools_summary) ? partial.tools_summary : [],
+    stop_reason: typeof partial.stop_reason === "string" ? partial.stop_reason : "",
+    is_label: Boolean(partial.is_label),
+    label: typeof partial.label === "string" ? partial.label : "",
+    ttft_ms: Math.max(0, toFiniteNumber(partial.ttft_ms, 0)),
+    tps: Math.max(0, toFiniteNumber(partial.tps, 0)),
+    dur_s: Math.max(0, toFiniteNumber(partial.dur_s, 0)),
+    cost_turn: Math.max(0, toFiniteNumber(partial.cost_turn, 0)),
+    cost_session: Math.max(0, toFiniteNumber(partial.cost_session, 0)),
+    cost_today: Math.max(0, toFiniteNumber(partial.cost_today, 0)),
+    error: typeof partial.error === "number" && Number.isFinite(partial.error) ? partial.error : null,
+    status: Math.max(0, toFiniteNumber(partial.status, 0)),
+    quota_pct: typeof partial.quota_pct === "number" && Number.isFinite(partial.quota_pct) ? Math.max(0, Math.min(100, partial.quota_pct)) : null,
+    quota_reset: typeof partial.quota_reset === "string" ? partial.quota_reset : null,
+    tier: typeof partial.tier === "string" ? partial.tier : null
+  };
+}
+function extractCleanLabel(text) {
+  if (typeof text !== "string" || text.length === 0) {
+    return "";
+  }
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{")) {
+    if (trimmed.endsWith("}")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          const record = parsed;
+          if (record.state && record.detail) {
+            return `${String(record.state).trim()}: ${String(record.detail).trim()}`;
+          }
+          const candidate = record.title ?? record.summary ?? record.label ?? record.message ?? record.detail ?? record.state;
+          if (typeof candidate === "string" && candidate.trim().length > 0) {
+            return candidate.trim();
+          }
+        }
+      } catch {
+      }
+    }
+    const stateMatch = trimmed.match(/"state"\s*:\s*"([^"\\]*)(?:"|$)/);
+    const detailMatch = trimmed.match(/"detail"\s*:\s*"([^"\\]*)(?:"|$)/);
+    if (stateMatch?.[1] && detailMatch?.[1]) {
+      return `${stateMatch[1].trim()}: ${detailMatch[1].trim()}`;
+    }
+    const singleMatch = trimmed.match(
+      /"(?:title|summary|label|message|detail|state)"\s*:\s*"([^"\\]*)(?:"|$)/
+    );
+    if (singleMatch?.[1]) {
+      return singleMatch[1].trim();
+    }
+  }
+  return trimmed.replace(/^["']+|["']+$/g, "").trim();
+}
+
+// src/collector/parse.ts
+function parseSafeJson(raw) {
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractFirstInt(pattern, target) {
+  const match = target.match(pattern);
+  if (!match?.[1]) return 0;
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+function groupTools(tools) {
+  if (tools.length === 0) return [];
+  const map = /* @__PURE__ */ new Map();
+  for (const t of tools) {
+    if (!t.name) continue;
+    const existing = map.get(t.name);
+    if (existing) {
+      existing.count += 1;
+      existing.arg_tk += t.argTk;
+    } else {
+      map.set(t.name, {
+        name: t.name,
+        count: 1,
+        arg_tk: t.argTk
+      });
+    }
+  }
+  return Array.from(map.values()).map((v) => ({
+    name: v.name,
+    count: v.count,
+    arg_tk: v.arg_tk
+  }));
+}
+function parseSseStream(fallbackModel, payload) {
+  const input = extractFirstInt(/"input_tokens"\s*:\s*(\d+)/, payload);
+  const cacheReadMatches = Array.from(payload.matchAll(/"cache_read_input_tokens"\s*:\s*(\d+)/g));
+  const cacheRead = cacheReadMatches.length > 0 ? Math.max(
+    ...cacheReadMatches.map((m) => {
+      const val = m[1] ? Number.parseInt(m[1], 10) : 0;
+      return Number.isFinite(val) ? val : 0;
+    })
+  ) : 0;
+  const cacheCreateMatches = Array.from(
+    payload.matchAll(/"cache_creation_input_tokens"\s*:\s*(\d+)/g)
+  );
+  const cacheCreate = cacheCreateMatches.length > 0 ? Math.max(
+    ...cacheCreateMatches.map((m) => {
+      const val = m[1] ? Number.parseInt(m[1], 10) : 0;
+      return Number.isFinite(val) ? val : 0;
+    })
+  ) : 0;
+  const outputMatches = Array.from(payload.matchAll(/"output_tokens"\s*:\s*(\d+)/g));
+  const lastOutputMatch = outputMatches[outputMatches.length - 1];
+  const output = lastOutputMatch?.[1] ? Number.parseInt(lastOutputMatch[1], 10) : 0;
+  const stopMatches = Array.from(payload.matchAll(/"stop_reason"\s*:\s*"([^"]*)"/g));
+  const lastStopMatch = stopMatches[stopMatches.length - 1];
+  const stopReason = lastStopMatch?.[1] ?? "";
+  const toolNames = Array.from(
+    payload.matchAll(/"type"\s*:\s*"tool_use"[^}]*?"name"\s*:\s*"([^"]+)"/g)
+  ).map((m) => m[1] ?? "");
+  const partialChunks = Array.from(
+    payload.matchAll(/"partial_json"\s*:\s*"((?:\\.|[^"\\])*)"/g)
+  ).map((m) => m[1] ?? "");
+  let argChars = 0;
+  try {
+    argChars = partialChunks.join("").replace(/\\./g, "X").length;
+  } catch {
+    argChars = 0;
+  }
+  const estimatedTotalArgTk = Math.max(0, Math.round(argChars / 4));
+  const avgArgTk = toolNames.length > 0 ? Math.max(1, Math.round(estimatedTotalArgTk / toolNames.length)) : 0;
+  const tools = toolNames.map((name) => ({
+    name,
+    argTk: avgArgTk
+  }));
+  let thinkingTokens = extractFirstInt(/"thinking_tokens"\s*:\s*(\d+)/, payload) || extractFirstInt(/"reasoning_tokens"\s*:\s*(\d+)/, payload) || extractFirstInt(/"reasoningTokenCount"\s*:\s*(\d+)/, payload);
+  if (thinkingTokens === 0) {
+    const thinkingDeltas = Array.from(
+      payload.matchAll(/"thinking"\s*:\s*"((?:\\.|[^"\\])*)"/g)
+    ).map((m) => m[1] ?? "");
+    if (thinkingDeltas.length > 0) {
+      const thinkingChars = thinkingDeltas.join("").length;
+      thinkingTokens = Math.max(1, Math.round(thinkingChars / 4));
+    }
+  }
+  const thinking = thinkingTokens > 0 || payload.includes("thinking_delta") || payload.includes('"type":"thinking"') || payload.includes('"thought":true');
+  const kind = tools.length > 0 ? "tool" : thinking ? "thinking" : "text";
+  return {
+    model: fallbackModel,
+    kind,
+    input,
+    output,
+    cacheRead,
+    cacheCreate,
+    tools,
+    toolsSummary: groupTools(tools),
+    thinking,
+    thinkingTokens,
+    stopReason,
+    label: ""
+  };
+}
+function parseJsonPayload(fallbackModel, payload) {
+  const parsed = parseSafeJson(payload);
+  if (!parsed || typeof parsed !== "object") return null;
+  const data = parsed;
+  const usage = data.usage ?? {};
+  const tools = [];
+  let rawText = "";
+  let thinking = false;
+  let thinkingChars = 0;
+  if (Array.isArray(data.content)) {
+    for (const item of data.content) {
+      if (!item) continue;
+      if (item.type === "text" && typeof item.text === "string") {
+        rawText += item.text;
+      } else if (item.type === "tool_use" && typeof item.name === "string") {
+        const argStr = JSON.stringify(item.input ?? {});
+        tools.push({
+          name: item.name,
+          argTk: Math.max(1, Math.round(argStr.length / 4))
+        });
+      } else if (item.type === "thinking") {
+        thinking = true;
+        if (typeof item.thinking === "string") {
+          thinkingChars += item.thinking.length;
+        }
+      }
+    }
+  } else if (typeof data.content === "string") {
+    rawText = data.content;
+  }
+  if (Array.isArray(data.candidates)) {
+    for (const candidate of data.candidates) {
+      const parts = candidate?.content?.parts;
+      if (Array.isArray(parts)) {
+        for (const part of parts) {
+          if (!part) continue;
+          if (typeof part.text === "string") {
+            if (part.thought) {
+              thinking = true;
+              thinkingChars += part.text.length;
+            } else {
+              rawText += part.text;
+            }
+          } else if (part.functionCall?.name) {
+            const argStr = JSON.stringify(part.functionCall.args ?? {});
+            tools.push({
+              name: part.functionCall.name,
+              argTk: Math.max(1, Math.round(argStr.length / 4))
+            });
+          }
+        }
+      }
+    }
+  }
+  let thinkingTokens = usage.thinking_tokens ?? usage.reasoning_tokens ?? data.usageMetadata?.candidatesTokenDetails?.[0]?.reasoningTokenCount ?? 0;
+  if (!thinkingTokens && thinkingChars > 0) {
+    thinkingTokens = Math.max(1, Math.round(thinkingChars / 4));
+  }
+  if (thinkingTokens > 0) {
+    thinking = true;
+  }
+  const input = usage.input_tokens ?? usage.prompt_tokens ?? data.usageMetadata?.promptTokenCount ?? 0;
+  const output = usage.output_tokens ?? usage.completion_tokens ?? data.usageMetadata?.candidatesTokenCount ?? 0;
+  const cacheRead = usage.cache_read_input_tokens ?? data.usageMetadata?.cachedContentTokenCount ?? 0;
+  const cacheCreate = usage.cache_creation_input_tokens ?? 0;
+  const isMicro = input < 2e3 && output < 60 && tools.length === 0 && !thinking;
+  let kind = "text";
+  if (tools.length > 0) {
+    kind = "tool";
+  } else if (thinking) {
+    kind = "thinking";
+  } else if (isMicro) {
+    kind = "label";
+  }
+  const cleanLabel = isMicro ? extractCleanLabel(rawText).slice(0, 120) : "";
+  return {
+    model: data.model || fallbackModel,
+    kind,
+    input,
+    output,
+    cacheRead,
+    cacheCreate,
+    tools,
+    toolsSummary: groupTools(tools),
+    thinking,
+    thinkingTokens,
+    stopReason: data.stop_reason ?? data.candidates?.[0]?.finishReason ?? "end_turn",
+    label: cleanLabel
+  };
+}
+function parseTurn(interaction) {
+  const fallbackResult = {
+    model: "unknown",
+    kind: "unknown",
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheCreate: 0,
+    tools: [],
+    toolsSummary: [],
+    thinking: false,
+    thinkingTokens: 0,
+    stopReason: "",
+    label: ""
+  };
+  try {
+    let resolvedModel = "unknown";
+    const parsedReq = parseSafeJson(interaction.reqBody);
+    if (parsedReq && typeof parsedReq === "object" && "model" in parsedReq && typeof parsedReq.model === "string") {
+      resolvedModel = parsedReq.model;
+    }
+    const resString = interaction.resBody ?? "";
+    const isError = (interaction.statusCode ?? 0) === 429 || (interaction.statusCode ?? 0) >= 500;
+    const isSse = (interaction.contentType ?? "").includes("text/event-stream") || resString.includes("event: message_start");
+    if (isError) {
+      const base = isSse ? parseSseStream(resolvedModel, resString) : parseJsonPayload(resolvedModel, resString) ?? fallbackResult;
+      return { ...base, kind: "error" };
+    }
+    if (isSse) {
+      return parseSseStream(resolvedModel, resString);
+    }
+    return parseJsonPayload(resolvedModel, resString) ?? fallbackResult;
+  } catch {
+    return fallbackResult;
+  }
+}
+function extractSessionId(headers, rawReqBody) {
+  let candidate = "default";
+  if (headers && typeof headers["x-claude-code-session-id"] === "string") {
+    candidate = headers["x-claude-code-session-id"];
+  } else {
+    const parsedBody = parseSafeJson(rawReqBody);
+    if (parsedBody && typeof parsedBody === "object" && "metadata" in parsedBody && typeof parsedBody.metadata === "object" && parsedBody.metadata !== null) {
+      const meta = parsedBody.metadata;
+      if (typeof meta.session_id === "string" && meta.session_id.trim().length > 0) {
+        candidate = meta.session_id;
+      } else if (typeof meta.user_id === "string") {
+        const userMeta = parseSafeJson(meta.user_id);
+        if (userMeta && typeof userMeta === "object" && "session_id" in userMeta && typeof userMeta.session_id === "string") {
+          candidate = userMeta.session_id;
+        }
+      }
+    }
+  }
+  const sanitized = candidate.trim().replace(/[^a-zA-Z0-9_-]/g, "");
+  return sanitized.length > 0 ? sanitized : "default";
+}
+
+// src/collector/index.ts
+var MAX_TRACKED_SESSIONS = 500;
+function setBoundedLRU(map, key, value) {
+  if (!map.has(key) && map.size >= MAX_TRACKED_SESSIONS) {
+    const oldestKey = map.keys().next().value;
+    if (oldestKey !== void 0) {
+      map.delete(oldestKey);
+    }
+  }
+  map.set(key, value);
+}
+function getUpstreamCandidates(host) {
+  if (host === "localhost" || host === "127.0.0.1" || host === "::1") {
+    return ["127.0.0.1", "::1"];
+  }
+  return [host];
+}
+function start(userConfig) {
+  const config = { ...loadConfig(), ...userConfig || {} };
+  for (const dir of config.statusDirs) {
+    ensureDir(dir);
+  }
+  pruneDeadSessions(config.statusDirs, config.deadSessionMs);
+  const contextHistory = /* @__PURE__ */ new Map();
+  const turnIndexBySession = /* @__PURE__ */ new Map();
+  const sessionSpending = loadTotals(config.statusDirs);
+  let activeLocalDate = getLocalDateString();
+  let todayTotalSpend = loadTodaySpend(config.statusDirs, activeLocalDate);
+  const upstreamHosts = getUpstreamCandidates(config.upstreamHost);
+  const server = http.createServer((clientReq, clientRes) => {
+    const reqUrl = clientReq.url || "/";
+    const reqMethod = clientReq.method?.toUpperCase() || "GET";
+    if (reqMethod === "GET" && (reqUrl === "/" || reqUrl === "/dashboard")) {
+      const dailyMap = loadDailyRollup(config.statusDirs);
+      const html = renderHeatmapHtml(dailyMap, (/* @__PURE__ */ new Date()).getFullYear());
+      clientRes.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      clientRes.end(html);
+      return;
+    }
+    if (reqMethod === "GET" && reqUrl === "/api/daily") {
+      const dailyMap = loadDailyRollup(config.statusDirs);
+      clientRes.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+      clientRes.end(JSON.stringify(dailyMap));
+      return;
+    }
+    const startTime = Date.now();
+    const headers = clientReq.headers || {};
+    const isModelExecution = reqUrl.includes("/v1/messages");
+    const isBackgroundAgent = headers["x-app"] === "cli-bg";
+    const contentLength = Number(headers["content-length"]);
+    if (Number.isFinite(contentLength) && contentLength > config.maxBodyBytes) {
+      clientRes.writeHead(413, { "content-type": "text/plain" });
+      clientRes.end("Payload Too Large");
+      return;
+    }
+    let resolvedSessionId = sanitizeSessionId(
+      extractSessionId(headers, "")
+    );
+    const requestChunks = [];
+    let receivedBytes = 0;
+    let isPayloadExceeded = false;
+    let isRequestComplete = false;
+    let proxyClientReq = null;
+    let isResponseCommitted = false;
+    const dispatch502 = (failureReason) => {
+      console.error(
+        `[tokensniff] upstream ${config.upstreamHost}:${config.upstreamPort} unavailable: ${failureReason}`
+      );
+      try {
+        const fallbackStatus = buildLatest({
+          session_id: resolvedSessionId,
+          model: "unknown",
+          ctx: contextHistory.get(resolvedSessionId) ?? 0,
+          error: 502,
+          status: 502,
+          cost_session: sessionSpending[resolvedSessionId] ?? 0,
+          cost_today: todayTotalSpend,
+          is_bg: isBackgroundAgent
+        });
+        saveLatest(config.statusDirs, resolvedSessionId, fallbackStatus);
+      } catch {
+      }
+      if (!clientRes.headersSent) {
+        clientRes.writeHead(502, { "content-type": "text/plain" });
+      }
+      try {
+        clientRes.end("Bad Gateway: Upstream Unreachable");
+      } catch {
+      }
+    };
+    const handleProxyResponse = (proxyRes) => {
+      isResponseCommitted = true;
+      const responseChunks = [];
+      let responseBytes = 0;
+      let isResponseCapped = false;
+      let timeToFirstToken = 0;
+      const contentType = String(proxyRes.headers["content-type"] || "").toLowerCase();
+      const isStreaming = contentType.includes("text/event-stream");
+      clientRes.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+      proxyRes.on("data", (chunk) => {
+        if (isStreaming && timeToFirstToken === 0) {
+          const text = chunk.toString("utf8");
+          if (text.includes("content_block_start") || text.includes("content_block_delta") || text.includes('"delta"')) {
+            timeToFirstToken = Date.now();
+          }
+        }
+        if (!isResponseCapped) {
+          if (responseBytes + chunk.length <= config.maxBodyBytes) {
+            responseChunks.push(chunk);
+            responseBytes += chunk.length;
+          } else {
+            isResponseCapped = true;
+          }
+        }
+        clientRes.write(chunk);
+      });
+      proxyRes.on("aborted", () => {
+        try {
+          clientRes.destroy();
+        } catch {
+        }
+      });
+      proxyRes.on("error", () => {
+        try {
+          if (!clientRes.writableEnded) clientRes.end();
+        } catch {
+        }
+      });
+      proxyRes.on("end", async () => {
+        const endTime = Date.now();
+        try {
+          if (!clientRes.writableEnded) clientRes.end();
+        } catch {
+        }
+        if (!isModelExecution) return;
+        const rawRequestBody = Buffer.concat(requestChunks);
+        try {
+          resolvedSessionId = sanitizeSessionId(
+            extractSessionId(
+              headers,
+              rawRequestBody.toString("utf8")
+            )
+          );
+        } catch {
+        }
+        const rawResponseBody = Buffer.concat(responseChunks);
+        try {
+          const turn = parseTurn({
+            reqBody: rawRequestBody.toString("utf8"),
+            resBody: rawResponseBody.toString("utf8"),
+            contentType: String(proxyRes.headers["content-type"] || ""),
+            statusCode: proxyRes.statusCode || 200
+          });
+          const rates = await resolveModelRates(turn.model);
+          const currentContextTokens = turn.input > turn.cacheRead ? turn.input + turn.cacheCreate : turn.input + turn.cacheRead + turn.cacheCreate;
+          const previousContextTokens = contextHistory.has(resolvedSessionId) ? contextHistory.get(resolvedSessionId) ?? currentContextTokens : currentContextTokens;
+          const durationSeconds = (endTime - startTime) / 1e3;
+          const streamGenerationMs = timeToFirstToken && isStreaming ? endTime - timeToFirstToken : 0;
+          let tokensPerSecond = 0;
+          if (turn.output > 0) {
+            if (isStreaming && streamGenerationMs >= 20) {
+              tokensPerSecond = Math.round(turn.output / streamGenerationMs * 1e3);
+            } else if (endTime > startTime) {
+              const totalTurnMs = Math.max(20, endTime - startTime);
+              tokensPerSecond = Math.round(turn.output / totalTurnMs * 1e3);
+            }
+          }
+          const ttftMs = timeToFirstToken && isStreaming ? timeToFirstToken - startTime : endTime - startTime;
+          const uncachedInput = turn.input > turn.cacheRead ? Math.max(0, turn.input - turn.cacheRead) : turn.input;
+          const turnCostUsd = costFor(rates, {
+            input: uncachedInput,
+            output: turn.output,
+            cacheRead: turn.cacheRead,
+            cacheCreate: turn.cacheCreate
+          });
+          const priorTurns = turnIndexBySession.get(resolvedSessionId) || 0;
+          const currentTurnIndex = priorTurns + 1;
+          setBoundedLRU(turnIndexBySession, resolvedSessionId, currentTurnIndex);
+          const accumulatedSessionCost = (sessionSpending[resolvedSessionId] || 0) + turnCostUsd;
+          sessionSpending[resolvedSessionId] = accumulatedSessionCost;
+          saveTotals(config.statusDirs, sessionSpending, config.maxSessions);
+          const nowLocalDate = getLocalDateString();
+          if (nowLocalDate !== activeLocalDate) {
+            activeLocalDate = nowLocalDate;
+            todayTotalSpend = 0;
+          }
+          todayTotalSpend += turnCostUsd;
+          const isMicroLabel = (turn.kind === "label" || turn.tools.length === 0 && turn.output > 0 && turn.output < config.labelMaxOut) && currentContextTokens < config.labelMaxIn;
+          if (!isMicroLabel) {
+            setBoundedLRU(contextHistory, resolvedSessionId, currentContextTokens);
+          }
+          const displayCtxTokens = isMicroLabel && contextHistory.has(resolvedSessionId) ? contextHistory.get(resolvedSessionId) ?? currentContextTokens : currentContextTokens;
+          const statusSnapshot = buildLatest({
+            session_id: resolvedSessionId,
+            turn_index: currentTurnIndex,
+            model: turn.model,
+            is_bg: isBackgroundAgent,
+            ctx: displayCtxTokens,
+            window: rates.window,
+            pct: Number((displayCtxTokens / rates.window * 100).toFixed(1)),
+            cache_read: turn.cacheRead,
+            cache_create: turn.cacheCreate,
+            delta_in: isMicroLabel ? 0 : currentContextTokens - previousContextTokens,
+            in_tokens: uncachedInput,
+            out_tokens: turn.output,
+            tool: turn.tools[0]?.name ?? null,
+            tool_tk: turn.tools[0]?.argTk ?? 0,
+            tools_summary: turn.toolsSummary,
+            thinking: turn.thinking,
+            thinking_tokens: turn.thinkingTokens,
+            stop_reason: turn.stopReason,
+            is_label: isMicroLabel,
+            label: isMicroLabel ? turn.label : "",
+            ttft_ms: ttftMs,
+            tps: tokensPerSecond,
+            dur_s: Number(durationSeconds.toFixed(1)),
+            cost_turn: turnCostUsd,
+            cost_session: accumulatedSessionCost,
+            cost_today: todayTotalSpend,
+            error: null,
+            status: proxyRes.statusCode || 200
+          });
+          saveLatest(config.statusDirs, resolvedSessionId, statusSnapshot);
+          if (!isMicroLabel && (turn.input > 0 || turn.output > 0)) {
+            appendHistory(config.statusDirs, {
+              date: nowLocalDate,
+              sessionId: resolvedSessionId,
+              turn: currentTurnIndex,
+              model: turn.model,
+              tokens: currentContextTokens + turn.output,
+              cost: turnCostUsd,
+              cacheRead: turn.cacheRead,
+              thinkingTokens: turn.thinkingTokens
+            });
+          }
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          console.error(`[tokensniff] turn parse/record failure: ${msg}`);
+        }
+      });
+    };
+    const tryForwardToHost = (hostIndex) => {
+      if (hostIndex >= upstreamHosts.length) {
+        dispatch502("all loopback candidates exhausted");
+        return;
+      }
+      const hostCandidate = upstreamHosts[hostIndex] ?? "127.0.0.1";
+      const forwardHeaders = { ...headers };
+      forwardHeaders.host = `${hostCandidate}:${config.upstreamPort}`;
+      const proxyRequestOptions = {
+        hostname: hostCandidate,
+        port: config.upstreamPort,
+        path: clientReq.url,
+        method: clientReq.method,
+        headers: forwardHeaders,
+        timeout: config.upstreamTimeoutMs
+      };
+      proxyClientReq = http.request(proxyRequestOptions, (proxyRes) => {
+        handleProxyResponse(proxyRes);
+      });
+      proxyClientReq.on("timeout", () => {
+        try {
+          proxyClientReq?.destroy();
+        } catch {
+        }
+        if (!isResponseCommitted) {
+          tryForwardToHost(hostIndex + 1);
+        }
+      });
+      proxyClientReq.on("error", () => {
+        if (!isResponseCommitted) {
+          tryForwardToHost(hostIndex + 1);
+        }
+      });
+      for (const chunk of requestChunks) {
+        proxyClientReq.write(chunk);
+      }
+      if (isRequestComplete) {
+        proxyClientReq.end();
+      }
+    };
+    clientReq.on("data", (chunk) => {
+      receivedBytes += chunk.length;
+      if (receivedBytes > config.maxBodyBytes) {
+        if (!isPayloadExceeded) {
+          isPayloadExceeded = true;
+          clientRes.writeHead(413, { "content-type": "text/plain" });
+          clientRes.end("Payload Too Large");
+        }
+        return;
+      }
+      requestChunks.push(chunk);
+      if (proxyClientReq) {
+        proxyClientReq.write(chunk);
+      }
+    });
+    clientReq.on("end", () => {
+      isRequestComplete = true;
+      if (proxyClientReq) {
+        proxyClientReq.end();
+      } else if (!isPayloadExceeded) {
+        tryForwardToHost(0);
+      }
+    });
+    clientRes.on("close", () => {
+      if (!clientRes.writableEnded && proxyClientReq) {
+        try {
+          proxyClientReq.destroy();
+        } catch {
+        }
+      }
+    });
+  });
+  server.listen(config.listenPort, config.listenHost, () => {
+    console.log(
+      `[tokensniff] proxy listening on http://${config.listenHost}:${config.listenPort} -> ${config.upstreamHost}:${config.upstreamPort}`
+    );
+  });
+  return server;
+}
+
+// src/cli/run.ts
+function waitForTcp(host, port, timeoutMs = 3e4) {
+  const hosts = host === "localhost" || host === "127.0.0.1" || host === "::1" ? ["127.0.0.1", "::1"] : [host];
+  const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    let hostIndex = 0;
+    const probe = () => {
+      const candidateHost = hosts[hostIndex % hosts.length] ?? "127.0.0.1";
+      hostIndex++;
+      const socket = net.connect(port, candidateHost, () => {
+        socket.destroy();
+        resolve();
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        if (Date.now() - startTime > timeoutMs) {
+          reject(
+            new Error(`Timed out waiting for upstream network availability at ${host}:${port}`)
+          );
+        } else {
+          setTimeout(probe, 250);
+        }
+      });
+    };
+    probe();
+  });
+}
+function isPortActive(host, port) {
+  return new Promise((resolve) => {
+    const socket = net.connect(port, host, () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+function writeInitFile() {
+  const destination = getGlobalConfigPath();
+  if (fs2.existsSync(destination)) {
+    console.log(`[tokensniff] configuration already present: ${destination}`);
+  } else {
+    const template = {
+      upstreamCommand: "npx antigravity-claude-proxy@latest start",
+      upstreamHost: "localhost",
+      upstreamPort: 8085,
+      listenPort: 4e3,
+      harnessCommand: "claude"
+    };
+    fs2.mkdirSync(path2.dirname(destination), { recursive: true });
+    fs2.writeFileSync(destination, JSON.stringify(template, null, 2), "utf8");
+    console.log(`[tokensniff] generated global config: ${destination}`);
+  }
+  printClaudeInstructions();
+  return destination;
+}
+function printClaudeInstructions() {
+  console.log("\n------------------------------------------------------------");
+  console.log("To route Claude Code through tokensniff and enable the HUD,");
+  console.log("add this to your ~/.claude/settings.json file:\n");
+  console.log('  "env": {');
+  console.log('    "ANTHROPIC_BASE_URL": "http://localhost:4000"');
+  console.log("  },");
+  console.log('  "statusLine": {');
+  console.log('    "type": "command",');
+  console.log('    "command": "tokensniff-status",');
+  console.log('    "padding": 0');
+  console.log("  }");
+  console.log("------------------------------------------------------------\n");
+}
+function terminateProcessTree(pid) {
+  if (!pid) return;
+  if (process.platform === "win32") {
+    try {
+      execSync(`taskkill /pid ${pid} /T /F`, { stdio: "ignore" });
+    } catch {
+    }
+  } else {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+}
+function killProcessOnPort(port) {
+  if (!port || !Number.isFinite(port) || port <= 0) return;
+  if (process.platform === "win32") {
+    try {
+      const output = execSync("netstat -ano -p tcp", { encoding: "utf8" });
+      const lines = output.split(/\r?\n/);
+      const portPattern = new RegExp(`:${port}\\s+.*LISTENING\\s+(\\d+)`, "i");
+      const pidsToKill = /* @__PURE__ */ new Set();
+      for (const line of lines) {
+        const match = line.match(portPattern);
+        if (match?.[1]) {
+          const pid = match[1].trim();
+          if (pid && pid !== "0" && pid !== "4" && pid !== String(process.pid)) {
+            pidsToKill.add(pid);
+          }
+        }
+      }
+      for (const pid of pidsToKill) {
+        try {
+          execSync(`taskkill /pid ${pid} /T /F`, { stdio: "ignore" });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  } else {
+    try {
+      execSync(`lsof -ti tcp:${port} | xargs kill -9 2>/dev/null || true`, {
+        stdio: "ignore"
+      });
+    } catch {
+    }
+  }
+}
+function isProcessAlive(pid) {
+  if (!pid || !Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const err = error;
+    return err.code === "EPERM";
+  }
+}
+function getSessionsDir() {
+  return path2.join(getGlobalDir(), "sessions");
+}
+function registerSession(pid = process.pid) {
+  const sessionsDir = getSessionsDir();
+  try {
+    fs2.mkdirSync(sessionsDir, { recursive: true });
+    const sessionFile = path2.join(sessionsDir, `${pid}.json`);
+    fs2.writeFileSync(sessionFile, JSON.stringify({ pid, startedAt: Date.now() }), "utf8");
+  } catch {
+  }
+  let unregistered = false;
+  return () => {
+    if (unregistered) return;
+    unregistered = true;
+    try {
+      const sessionFile = path2.join(sessionsDir, `${pid}.json`);
+      if (fs2.existsSync(sessionFile)) {
+        fs2.unlinkSync(sessionFile);
+      }
+    } catch {
+    }
+  };
+}
+function countActiveSessions(excludePid = process.pid) {
+  const sessionsDir = getSessionsDir();
+  if (!fs2.existsSync(sessionsDir)) return 0;
+  let activeCount = 0;
+  try {
+    const files = fs2.readdirSync(sessionsDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const pidStr = file.replace(".json", "");
+      const pid = Number.parseInt(pidStr, 10);
+      if (!Number.isFinite(pid) || pid <= 0) {
+        try {
+          fs2.unlinkSync(path2.join(sessionsDir, file));
+        } catch {
+        }
+        continue;
+      }
+      if (pid === excludePid) {
+        continue;
+      }
+      if (isProcessAlive(pid)) {
+        activeCount++;
+      } else {
+        try {
+          fs2.unlinkSync(path2.join(sessionsDir, file));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return activeCount;
+}
+async function main(argv = process.argv.slice(2), deps = {}) {
+  const command = argv[0];
+  const config = deps.config || loadConfig();
+  if (command === "init") {
+    writeInitFile();
+    return;
+  }
+  if (command === "dashboard") {
+    const proxyHost2 = config.listenHost === "localhost" ? "127.0.0.1" : config.listenHost;
+    const dashboardUrl = `http://${proxyHost2}:${config.listenPort}/dashboard`;
+    console.log(`[tokensniff] live heatmap dashboard: ${dashboardUrl}`);
+    return;
+  }
+  if (command === "import") {
+    const targetDir = argv[1];
+    if (!targetDir) {
+      console.error(
+        "[tokensniff] Error: directory path required.\nUsage: tokensniff import <path-to-captures-dir>"
+      );
+      return;
+    }
+    const resolvedDir = path2.resolve(process.cwd(), targetDir);
+    console.log(`[tokensniff] importing probe captures from: ${resolvedDir}`);
+    const result = importCapturesDirectory(resolvedDir, config.statusDirs);
+    console.log(
+      `[tokensniff] import complete: ${result.imported} turns recorded, ${result.skipped} non-token files skipped.`
+    );
+    return;
+  }
+  if (command === "--help" || command === "-h") {
+    console.log("Usage: tokensniff [init|dashboard|import] [-- <harness...>]");
+    console.log("  tokensniff                 Run proxy + live dashboard + Claude Code");
+    console.log("  tokensniff init            Generate global config at ~/.tokensniff/config.json");
+    console.log("  tokensniff dashboard       Show live calendar spend heatmap URL");
+    console.log("  tokensniff import [dir]    Import raw probe captures into daily heatmap ledger");
+    console.log(
+      "  tokensniff -- <cmd>        Run with an alternate harness command (e.g. codex)\n"
+    );
+    printClaudeInstructions();
+    return;
+  }
+  const unregisterSession = registerSession(process.pid);
+  const startProxy = deps.startProxy || start;
+  const separatorIndex = argv.indexOf("--");
+  const customHarnessArgs = separatorIndex >= 0 ? argv.slice(separatorIndex + 1) : argv.length > 0 ? argv : String(config.harnessCommand || "claude").split(" ");
+  const [harnessBinary, ...harnessArgs] = customHarnessArgs.filter(Boolean);
+  if (!harnessBinary) {
+    unregisterSession();
+    throw new Error("No executable harness binary resolved. Verify config.harnessCommand.");
+  }
+  const childProcesses = [];
+  let isCleaningUp = false;
+  let didSpawnUpstream = false;
+  let proxyServerInstance = null;
+  const cleanup = (exitCode2) => {
+    if (isCleaningUp) return;
+    isCleaningUp = true;
+    for (const proc of childProcesses) {
+      terminateProcessTree(proc.pid);
+    }
+    unregisterSession();
+    const remainingSessions = countActiveSessions(process.pid);
+    if (remainingSessions > 0) {
+      console.log(
+        `[tokensniff] session detached (${remainingSessions} active session(s) remaining, proxy maintained).`
+      );
+    } else {
+      if (proxyServerInstance) {
+        try {
+          proxyServerInstance.close();
+        } catch {
+        }
+      }
+      if (didSpawnUpstream && config.upstreamCommand) {
+        if (config.upstreamStopCommand) {
+          try {
+            execSync(config.upstreamStopCommand, {
+              stdio: "ignore",
+              env: {
+                ...process.env,
+                PORT: process.env.PORT || String(config.upstreamPort)
+              }
+            });
+          } catch {
+          }
+        } else if (config.upstreamCommand.includes("antigravity-claude-proxy")) {
+          try {
+            execSync("npx antigravity-claude-proxy@latest stop", {
+              stdio: "ignore",
+              env: {
+                ...process.env,
+                PORT: process.env.PORT || String(config.upstreamPort)
+              }
+            });
+          } catch {
+          }
+        }
+        if (config.upstreamPort) {
+          killProcessOnPort(config.upstreamPort);
+        }
+      }
+    }
+    process.exit(exitCode2);
+  };
+  process.once("SIGINT", () => {
+    cleanup(130);
+  });
+  process.once("SIGTERM", () => {
+    cleanup(143);
+  });
+  const proxyHost = config.listenHost === "localhost" ? "127.0.0.1" : config.listenHost;
+  const baseUrl = `http://${proxyHost}:${config.listenPort}`;
+  const isAlreadyRunning = await isPortActive(proxyHost, config.listenPort);
+  if (isAlreadyRunning) {
+    console.log(`[tokensniff] attaching to active tokensniff proxy on port ${config.listenPort}`);
+    console.log(`[tokensniff] live heatmap dashboard available at: ${baseUrl}/dashboard`);
+  } else {
+    const isUpstreamAlreadyActive = await isPortActive(config.upstreamHost, config.upstreamPort);
+    if (isUpstreamAlreadyActive) {
+      console.log(
+        `[tokensniff] upstream proxy already active on ${config.upstreamHost}:${config.upstreamPort}`
+      );
+    } else if (config.upstreamCommand) {
+      console.log(`[tokensniff] initiating upstream command: ${config.upstreamCommand}`);
+      const upstreamProcess = spawn(config.upstreamCommand, {
+        shell: true,
+        stdio: "inherit",
+        detached: process.platform !== "win32",
+        env: {
+          ...process.env,
+          PORT: process.env.PORT || String(config.upstreamPort)
+        }
+      });
+      childProcesses.push(upstreamProcess);
+      didSpawnUpstream = true;
+      upstreamProcess.on("exit", (code) => {
+        if (code !== null && code !== 0 && !isCleaningUp) {
+          console.log(`[tokensniff] upstream daemon exited with code ${code}`);
+        }
+      });
+      try {
+        await waitForTcp(config.upstreamHost, config.upstreamPort, deps.waitMs || 3e4);
+        console.log(
+          `[tokensniff] upstream proxy responsive on ${config.upstreamHost}:${config.upstreamPort}`
+        );
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[tokensniff] upstream proxy failed health check: ${msg}`);
+        console.error(
+          "[tokensniff] continuing pipeline; downstream calls will receive 502 until ready."
+        );
+      }
+    }
+    proxyServerInstance = startProxy(config);
+    if (!proxyServerInstance.listening) {
+      await new Promise((resolve, reject) => {
+        proxyServerInstance?.once("listening", () => resolve());
+        proxyServerInstance?.once("error", (err) => reject(err));
+      });
+    }
+    console.log(`[tokensniff] live heatmap dashboard available at: ${baseUrl}/dashboard`);
+  }
+  console.log(`[tokensniff] launching harness: ${harnessBinary} ${harnessArgs.join(" ")}`.trim());
+  const harnessProcess = spawn(harnessBinary, harnessArgs, {
+    shell: true,
+    stdio: "inherit",
+    env: process.env
+  });
+  childProcesses.push(harnessProcess);
+  const exitCode = await new Promise(
+    (resolve) => harnessProcess.on("close", (code) => resolve(code))
+  );
+  cleanup(exitCode ?? 0);
+}
+
+export { countActiveSessions, getSessionsDir, isPortActive, isProcessAlive, killProcessOnPort, main, printClaudeInstructions, registerSession, terminateProcessTree, waitForTcp, writeInitFile };
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map