tktuner 0.2.0

package/dist/cli.js

@@ -0,0 +1,2608 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// package.json
+var package_default = {
+  name: "tktuner",
+  version: "0.2.0",
+  description: "Local-first token usage analytics and cost optimization for Claude Code power users. Stop paying Fable prices for Haiku work.",
+  license: "MIT",
+  type: "module",
+  bin: {
+    tktuner: "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsx src/cli/index.ts",
+    test: "vitest run",
+    "test:watch": "vitest",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "pnpm test && pnpm build"
+  },
+  keywords: [
+    "claude-code",
+    "claude",
+    "tokens",
+    "usage",
+    "analytics",
+    "cost",
+    "cli"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/tktuner/tktuner.git"
+  },
+  dependencies: {
+    "better-sqlite3": "^12.2.0",
+    commander: "^14.0.0",
+    picocolors: "^1.1.1"
+  },
+  devDependencies: {
+    "@tktuner/core": "workspace:*",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^24.0.0",
+    tsup: "^8.5.0",
+    tsx: "^4.20.0",
+    typescript: "^5.6.3",
+    vitest: "^3.2.0"
+  }
+};
+
+// src/lib/version.ts
+var CLI_VERSION = package_default.version;
+
+// src/cli/login.ts
+import { spawn } from "child_process";
+import { hostname, userInfo } from "os";
+import pc from "picocolors";
+
+// src/lib/api-client.ts
+import { gzipSync } from "zlib";
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+async function apiRequest(method, apiUrl, path, opts = {}) {
+  const headers = { accept: "application/json" };
+  if (opts.token) headers.authorization = `Bearer ${opts.token}`;
+  let body;
+  if (opts.body !== void 0) {
+    headers["content-type"] = "application/json";
+    const raw = JSON.stringify(opts.body);
+    if (opts.gzip) {
+      headers["content-encoding"] = "gzip";
+      body = gzipSync(Buffer.from(raw, "utf8"));
+    } else {
+      body = raw;
+    }
+  }
+  const res = await fetch(`${apiUrl.replace(/\/$/, "")}${path}`, { method, headers, body });
+  let json = {};
+  try {
+    json = await res.json();
+  } catch {
+  }
+  return { status: res.status, json };
+}
+async function apiCall(method, apiUrl, path, opts = {}) {
+  const { status, json } = await apiRequest(method, apiUrl, path, opts);
+  if (status >= 200 && status < 300) return json;
+  const err = json.error ?? {};
+  throw new ApiError(status, err.code ?? "UNKNOWN", err.message ?? `HTTP ${status}`);
+}
+
+// src/lib/credentials.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function dataDir() {
+  const xdg = process.env.XDG_DATA_HOME;
+  const base = xdg && xdg.trim() !== "" ? xdg : join(homedir(), ".local", "share");
+  return join(base, "tktuner");
+}
+
+// src/lib/credentials.ts
+function credentialsPath() {
+  return join2(dataDir(), "credentials.json");
+}
+function readCredentials() {
+  try {
+    const raw = readFileSync(credentialsPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.apiUrl || !parsed.deviceToken || !parsed.deviceId) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeCredentials(creds) {
+  mkdirSync(dataDir(), { recursive: true });
+  const path = credentialsPath();
+  writeFileSync(path, `${JSON.stringify(creds, null, 2)}
+`, { mode: 384 });
+  chmodSync(path, 384);
+}
+function deleteCredentials() {
+  if (existsSync(credentialsPath())) rmSync(credentialsPath());
+}
+
+// src/cli/login.ts
+var DEFAULT_API_URL = "https://tktuner.com";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function openBrowser(url) {
+  const candidates = process.platform === "darwin" ? [["open", url]] : process.platform === "win32" ? [["cmd", "/c", "start", "", url]] : [
+    ["wslview", url],
+    ["xdg-open", url]
+  ];
+  for (const [cmd, ...args] of candidates) {
+    try {
+      const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+      child.on("error", () => {
+      });
+      child.unref();
+      return;
+    } catch {
+    }
+  }
+}
+async function login(opts) {
+  const existing = readCredentials();
+  if (existing) {
+    console.log(
+      `Already logged in (device ${pc.bold(existing.deviceName)} \u2192 ${existing.apiUrl}).
+Run ${pc.bold("tktuner logout")} first to switch accounts.`
+    );
+    return;
+  }
+  const apiUrl = opts.api ?? DEFAULT_API_URL;
+  const deviceName = `${userInfo().username}@${hostname()}`.slice(0, 80);
+  const start = await apiCall("POST", apiUrl, "/v1/device/code", {
+    body: { deviceName, cliVersion: CLI_VERSION }
+  });
+  const deviceCode = start.device_code;
+  const userCode = start.user_code;
+  const verifyUrl = start.verification_uri_complete ?? start.verification_uri;
+  let intervalMs = (start.interval ?? 5) * 1e3;
+  const deadline = Date.now() + (start.expires_in ?? 900) * 1e3;
+  console.log(`
+Open ${pc.bold(pc.cyan(verifyUrl))}`);
+  console.log(`and confirm this code: ${pc.bold(userCode)}
+`);
+  openBrowser(verifyUrl);
+  process.stdout.write("Waiting for approval");
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    process.stdout.write(".");
+    const { status, json } = await apiRequest("POST", apiUrl, "/v1/device/token", {
+      body: { device_code: deviceCode }
+    });
+    if (status === 200) {
+      writeCredentials({
+        apiUrl,
+        deviceToken: json.device_token,
+        deviceId: json.device_id,
+        deviceName
+      });
+      console.log(`
+
+${pc.green("Logged in.")} Device ${pc.bold(deviceName)} is connected.`);
+      console.log(`Run ${pc.bold("tktuner sync")} to upload your usage metadata.`);
+      return;
+    }
+    if (status === 202) continue;
+    const code = (json.error ?? {}).code;
+    if (code === "SLOW_DOWN") {
+      intervalMs += 2e3;
+      continue;
+    }
+    const message = (json.error ?? {}).message ?? `HTTP ${status}`;
+    console.error(`
+${pc.red("Login failed:")} ${message}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.error(`
+${pc.red("Login timed out.")} Run tktuner login again.`);
+  process.exitCode = 1;
+}
+
+// src/cli/logout.ts
+import pc2 from "picocolors";
+async function logout() {
+  const creds = readCredentials();
+  if (!creds) {
+    console.log("Not logged in.");
+    return;
+  }
+  try {
+    await apiCall("POST", creds.apiUrl, "/v1/device/revoke-self", { token: creds.deviceToken });
+  } catch {
+  }
+  deleteCredentials();
+  console.log(`${pc2.green("Logged out.")} Device ${pc2.bold(creds.deviceName)} was disconnected.`);
+}
+
+// ../core/src/analysis/waste.ts
+function isPremiumModel(model) {
+  return model.startsWith("claude-opus") || model.startsWith("claude-fable") || model.startsWith("claude-mythos");
+}
+var IDEAL_MODEL_BY_PHASE = {
+  exploration: "claude-haiku-4-5",
+  execution: "claude-sonnet-4-5"
+};
+function rootSessionId(turn) {
+  return turn.parentSessionId ?? turn.sessionId;
+}
+function computeWaste(classified, prices) {
+  const report2 = {
+    totalCostUsd: 0,
+    totalWasteUsd: 0,
+    wasteByPhase: { exploration: 0, execution: 0 },
+    fastModeExtraUsd: 0,
+    unpricedTurns: 0,
+    unpricedModels: [],
+    matrix: /* @__PURE__ */ new Map(),
+    perSession: /* @__PURE__ */ new Map(),
+    perProject: /* @__PURE__ */ new Map()
+  };
+  const unpricedModels = /* @__PURE__ */ new Set();
+  for (const { turn, phaseSmoothed } of classified) {
+    const cost = prices.turnCostUsd(turn);
+    if (cost === null) {
+      report2.unpricedTurns++;
+      unpricedModels.add(turn.model);
+      continue;
+    }
+    report2.totalCostUsd += cost;
+    if (turn.speed === "fast") {
+      const standard = prices.costAtModel(turn.model, turn);
+      if (standard !== null) report2.fastModeExtraUsd += Math.max(0, cost - standard);
+    }
+    let wasteUsd = 0;
+    const idealModel = IDEAL_MODEL_BY_PHASE[phaseSmoothed];
+    if (idealModel && isPremiumModel(turn.model)) {
+      const idealCost = prices.costAtModel(idealModel, turn);
+      if (idealCost !== null) {
+        wasteUsd = Math.max(0, cost - idealCost);
+        report2.totalWasteUsd += wasteUsd;
+        if (phaseSmoothed === "exploration") report2.wasteByPhase.exploration += wasteUsd;
+        if (phaseSmoothed === "execution") report2.wasteByPhase.execution += wasteUsd;
+      }
+    }
+    let phaseMap = report2.matrix.get(turn.model);
+    if (!phaseMap) {
+      phaseMap = /* @__PURE__ */ new Map();
+      report2.matrix.set(turn.model, phaseMap);
+    }
+    let cell = phaseMap.get(phaseSmoothed);
+    if (!cell) {
+      cell = { turns: 0, costUsd: 0, wasteUsd: 0, tokens: 0 };
+      phaseMap.set(phaseSmoothed, cell);
+    }
+    cell.turns++;
+    cell.costUsd += cost;
+    cell.wasteUsd += wasteUsd;
+    cell.tokens += turn.usage.input + turn.usage.output + turn.usage.cacheRead + turn.usage.cacheWrite;
+    const sid = rootSessionId(turn);
+    let sess = report2.perSession.get(sid);
+    if (!sess) {
+      sess = {
+        sessionId: sid,
+        project: "",
+        slug: void 0,
+        firstTs: Infinity,
+        lastTs: 0,
+        turns: 0,
+        costUsd: 0,
+        wasteUsd: 0,
+        wasteExplorationUsd: 0,
+        wasteExecutionUsd: 0,
+        premiumTurns: 0,
+        models: /* @__PURE__ */ new Set()
+      };
+      report2.perSession.set(sid, sess);
+    }
+    sess.turns++;
+    sess.costUsd += cost;
+    sess.wasteUsd += wasteUsd;
+    if (phaseSmoothed === "exploration") sess.wasteExplorationUsd += wasteUsd;
+    if (phaseSmoothed === "execution") sess.wasteExecutionUsd += wasteUsd;
+    if (isPremiumModel(turn.model)) sess.premiumTurns++;
+    sess.models.add(turn.model);
+    if (turn.timestamp > 0) {
+      sess.firstTs = Math.min(sess.firstTs, turn.timestamp);
+      sess.lastTs = Math.max(sess.lastTs, turn.timestamp);
+    }
+    if (!sess.project && turn.projectPath) sess.project = turn.projectPath;
+    if (!sess.slug && !turn.isSidechain && turn.slug) sess.slug = turn.slug;
+    const project = turn.projectPath || "(unknown)";
+    let proj = report2.perProject.get(project);
+    if (!proj) {
+      proj = { costUsd: 0, wasteUsd: 0, turns: 0 };
+      report2.perProject.set(project, proj);
+    }
+    proj.costUsd += cost;
+    proj.wasteUsd += wasteUsd;
+    proj.turns++;
+  }
+  report2.unpricedModels = [...unpricedModels].sort();
+  return report2;
+}
+
+// ../core/src/analysis/cache.ts
+function cacheStats(turns) {
+  const s = { turns: 0, input: 0, cacheRead: 0, cacheWrite: 0, hitRate: null };
+  for (const t of turns) {
+    s.turns++;
+    s.input += t.usage.input;
+    s.cacheRead += t.usage.cacheRead;
+    s.cacheWrite += t.usage.cacheWrite;
+  }
+  const denom = s.input + s.cacheRead + s.cacheWrite;
+  s.hitRate = denom > 0 ? s.cacheRead / denom : null;
+  return s;
+}
+function cacheByProject(turns) {
+  return groupStats(turns, (t) => t.projectPath || "(unknown)");
+}
+function cacheBySession(turns) {
+  return groupStats(turns, rootSessionId);
+}
+function groupStats(turns, key) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    const k = key(t);
+    const list = groups.get(k);
+    if (list) list.push(t);
+    else groups.set(k, [t]);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [k, list] of groups) out.set(k, cacheStats(list));
+  return out;
+}
+function summarizeCompactions(events) {
+  const out = { total: 0, bySession: /* @__PURE__ */ new Map(), tokensCompacted: 0 };
+  for (const e of events) {
+    if (e.kind !== "compact_boundary") continue;
+    out.total++;
+    out.bySession.set(e.sessionId, (out.bySession.get(e.sessionId) ?? 0) + 1);
+    const pre = typeof e.data.preTokens === "number" ? e.data.preTokens : 0;
+    const post = typeof e.data.postTokens === "number" ? e.data.postTokens : 0;
+    if (pre > post) out.tokensCompacted += pre - post;
+  }
+  return out;
+}
+
+// ../core/src/analysis/classify.ts
+var WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "NotebookEdit",
+  "Bash",
+  "MultiEdit",
+  "mcp__ide__executeCode"
+]);
+var READ_TOOLS = /* @__PURE__ */ new Set([
+  "Read",
+  "Grep",
+  "Glob",
+  "LS",
+  "WebFetch",
+  "WebSearch",
+  "ToolSearch",
+  "TaskOutput",
+  "BashOutput",
+  "NotebookRead",
+  "Monitor"
+]);
+var DELEGATION_TOOLS = /* @__PURE__ */ new Set(["Agent", "Workflow", "Task"]);
+var PLANNING_TOOLS = /* @__PURE__ */ new Set(["ExitPlanMode", "EnterPlanMode", "exit_plan_mode"]);
+var THINKING_PLANNING_MIN_CHARS = 1500;
+var SMOOTHING_WINDOW = 5;
+function buildPlanSpans(events) {
+  const bySession = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.kind !== "plan_mode" && e.kind !== "plan_mode_exit") continue;
+    if (e.timestamp === void 0) continue;
+    const list = bySession.get(e.sessionId);
+    if (list) list.push(e);
+    else bySession.set(e.sessionId, [e]);
+  }
+  const spans = /* @__PURE__ */ new Map();
+  for (const [sessionId, list] of bySession) {
+    list.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+    const out = [];
+    let openStart;
+    for (const e of list) {
+      if (e.kind === "plan_mode") {
+        openStart ??= e.timestamp;
+      } else if (openStart !== void 0) {
+        out.push({ start: openStart, end: e.timestamp ?? openStart });
+        openStart = void 0;
+      }
+    }
+    if (openStart !== void 0) out.push({ start: openStart, end: Infinity });
+    spans.set(sessionId, out);
+  }
+  return spans;
+}
+function rawPhase(turn, inPlanSpan) {
+  if (inPlanSpan || turn.tools.some((t) => PLANNING_TOOLS.has(t))) return "planning";
+  if (turn.tools.some((t) => DELEGATION_TOOLS.has(t))) return "delegation";
+  if (turn.tools.some((t) => WRITE_TOOLS.has(t))) return "execution";
+  if (turn.tools.some((t) => READ_TOOLS.has(t))) return "exploration";
+  if (turn.numToolUses === 0 && turn.thinkingChars >= THINKING_PLANNING_MIN_CHARS) {
+    return "planning";
+  }
+  return "chat";
+}
+function classifyTurns(turns, events) {
+  const spans = buildPlanSpans(events);
+  const bySession = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    const list = bySession.get(t.sessionId);
+    if (list) list.push(t);
+    else bySession.set(t.sessionId, [t]);
+  }
+  const out = [];
+  for (const [sessionId, sessionTurns] of bySession) {
+    sessionTurns.sort((a, b) => a.timestamp - b.timestamp || (a.uuid < b.uuid ? -1 : 1));
+    const sessionSpans = spans.get(sessionId) ?? [];
+    const raw = sessionTurns.map(
+      (t) => rawPhase(
+        t,
+        sessionSpans.some((s) => t.timestamp >= s.start && t.timestamp <= s.end)
+      )
+    );
+    const smoothed = smoothPhases(raw);
+    for (let i = 0; i < sessionTurns.length; i++) {
+      out.push({
+        turn: sessionTurns[i],
+        phase: raw[i],
+        phaseSmoothed: smoothed[i]
+      });
+    }
+  }
+  return out;
+}
+function smoothPhases(raw) {
+  const half = Math.floor(SMOOTHING_WINDOW / 2);
+  return raw.map((phase, i) => {
+    const counts = /* @__PURE__ */ new Map();
+    const lo = Math.max(0, i - half);
+    const hi = Math.min(raw.length - 1, i + half);
+    for (let j = lo; j <= hi; j++) {
+      const p = raw[j];
+      counts.set(p, (counts.get(p) ?? 0) + 1);
+    }
+    let maxN = 0;
+    for (const n of counts.values()) maxN = Math.max(maxN, n);
+    const winners = [...counts.entries()].filter(([, n]) => n === maxN).map(([p]) => p);
+    return winners.length === 1 ? winners[0] : phase;
+  });
+}
+
+// ../core/src/analysis/quota.ts
+var WINDOW_MS = 5 * 60 * 60 * 1e3;
+function build5hWindows(turns, prices) {
+  const sorted = turns.filter((t) => t.timestamp > 0).sort((a, b) => a.timestamp - b.timestamp);
+  const windows = [];
+  let current;
+  for (const t of sorted) {
+    if (!current || t.timestamp >= current.end) {
+      current = {
+        start: t.timestamp,
+        end: t.timestamp + WINDOW_MS,
+        turns: 0,
+        totalTokens: 0,
+        outputTokens: 0,
+        costUsd: 0,
+        unpricedTurns: 0
+      };
+      windows.push(current);
+    }
+    current.turns++;
+    current.totalTokens += t.usage.input + t.usage.output + t.usage.cacheRead + t.usage.cacheWrite;
+    current.outputTokens += t.usage.output;
+    const cost = prices.turnCostUsd(t);
+    if (cost === null) current.unpricedTurns++;
+    else current.costUsd += cost;
+  }
+  return windows;
+}
+function weeklyRollup(turns, prices) {
+  const byWeek = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    if (t.timestamp <= 0) continue;
+    const weekKey = isoWeekKey(t.timestamp);
+    let bucket = byWeek.get(weekKey);
+    if (!bucket) {
+      bucket = { weekKey, start: t.timestamp, turns: 0, totalTokens: 0, costUsd: 0 };
+      byWeek.set(weekKey, bucket);
+    }
+    bucket.start = Math.min(bucket.start, t.timestamp);
+    bucket.turns++;
+    bucket.totalTokens += t.usage.input + t.usage.output + t.usage.cacheRead + t.usage.cacheWrite;
+    const cost = prices.turnCostUsd(t);
+    if (cost !== null) bucket.costUsd += cost;
+  }
+  return [...byWeek.values()].sort((a, b) => a.start - b.start);
+}
+function isoWeekKey(ts) {
+  const d = new Date(ts);
+  const thursday = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  const weekday = (thursday.getDay() + 6) % 7;
+  thursday.setDate(thursday.getDate() - weekday + 3);
+  const year = thursday.getFullYear();
+  const jan4 = new Date(year, 0, 4);
+  const week1Monday = new Date(year, 0, 4 - (jan4.getDay() + 6) % 7);
+  const week = Math.round((thursday.getTime() - week1Monday.getTime()) / (7 * 864e5)) + 1;
+  return `${year}-W${String(week).padStart(2, "0")}`;
+}
+
+// ../core/src/merge.ts
+function mergeTurnLines(lines) {
+  const groups = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const line of lines) {
+    const key = line.messageId ?? line.uuid;
+    const group = groups.get(key);
+    if (group) group.push(line);
+    else {
+      groups.set(key, [line]);
+      order.push(key);
+    }
+  }
+  return order.map((key) => {
+    const group = groups.get(key);
+    const first = group[0];
+    if (group.length === 1) return first;
+    const timestamps = group.map((l) => l.timestamp).filter((t) => t > 0);
+    return {
+      ...first,
+      usage: {
+        input: Math.max(...group.map((l) => l.usage.input)),
+        output: Math.max(...group.map((l) => l.usage.output)),
+        cacheRead: Math.max(...group.map((l) => l.usage.cacheRead)),
+        cacheWrite: Math.max(...group.map((l) => l.usage.cacheWrite)),
+        cacheWrite5m: Math.max(...group.map((l) => l.usage.cacheWrite5m)),
+        cacheWrite1h: Math.max(...group.map((l) => l.usage.cacheWrite1h))
+      },
+      tools: group.flatMap((l) => l.tools),
+      numToolUses: group.reduce((n, l) => n + l.numToolUses, 0),
+      thinkingChars: group.reduce((n, l) => n + l.thinkingChars, 0),
+      textChars: group.reduce((n, l) => n + l.textChars, 0),
+      timestamp: timestamps.length > 0 ? Math.min(...timestamps) : first.timestamp,
+      stopReason: [...group].reverse().find((l) => l.stopReason)?.stopReason,
+      speed: group.find((l) => l.speed)?.speed,
+      inferenceGeo: group.find((l) => l.inferenceGeo)?.inferenceGeo
+    };
+  });
+}
+
+// ../core/src/pricing/prices.json
+var prices_default = {
+  version: "2026-07-12",
+  source: "https://platform.claude.com/docs/en/about-claude/pricing",
+  currency: "USD",
+  per_mtok: {
+    "claude-fable-5": {
+      input: 10,
+      output: 50,
+      cache_read: 1,
+      cache_write_5m: 12.5,
+      cache_write_1h: 20
+    },
+    "claude-mythos-5": {
+      input: 10,
+      output: 50,
+      cache_read: 1,
+      cache_write_5m: 12.5,
+      cache_write_1h: 20
+    },
+    "claude-opus-4-8": {
+      input: 5,
+      output: 25,
+      cache_read: 0.5,
+      cache_write_5m: 6.25,
+      cache_write_1h: 10,
+      fast_input: 10,
+      fast_output: 50
+    },
+    "claude-opus-4-7": {
+      input: 5,
+      output: 25,
+      cache_read: 0.5,
+      cache_write_5m: 6.25,
+      cache_write_1h: 10,
+      fast_input: 30,
+      fast_output: 150
+    },
+    "claude-opus-4-6": {
+      input: 5,
+      output: 25,
+      cache_read: 0.5,
+      cache_write_5m: 6.25,
+      cache_write_1h: 10
+    },
+    "claude-opus-4-5": {
+      input: 5,
+      output: 25,
+      cache_read: 0.5,
+      cache_write_5m: 6.25,
+      cache_write_1h: 10
+    },
+    "claude-opus-4-1": {
+      input: 15,
+      output: 75,
+      cache_read: 1.5,
+      cache_write_5m: 18.75,
+      cache_write_1h: 30
+    },
+    "claude-opus-4": {
+      input: 15,
+      output: 75,
+      cache_read: 1.5,
+      cache_write_5m: 18.75,
+      cache_write_1h: 30
+    },
+    "claude-sonnet-5": [
+      {
+        until: "2026-09-01",
+        input: 2,
+        output: 10,
+        cache_read: 0.2,
+        cache_write_5m: 2.5,
+        cache_write_1h: 4
+      },
+      {
+        from: "2026-09-01",
+        input: 3,
+        output: 15,
+        cache_read: 0.3,
+        cache_write_5m: 3.75,
+        cache_write_1h: 6
+      }
+    ],
+    "claude-sonnet-4-6": {
+      input: 3,
+      output: 15,
+      cache_read: 0.3,
+      cache_write_5m: 3.75,
+      cache_write_1h: 6
+    },
+    "claude-sonnet-4-5": {
+      input: 3,
+      output: 15,
+      cache_read: 0.3,
+      cache_write_5m: 3.75,
+      cache_write_1h: 6
+    },
+    "claude-sonnet-4": {
+      input: 3,
+      output: 15,
+      cache_read: 0.3,
+      cache_write_5m: 3.75,
+      cache_write_1h: 6
+    },
+    "claude-3-7-sonnet": {
+      input: 3,
+      output: 15,
+      cache_read: 0.3,
+      cache_write_5m: 3.75,
+      cache_write_1h: 6
+    },
+    "claude-3-5-sonnet": {
+      input: 3,
+      output: 15,
+      cache_read: 0.3,
+      cache_write_5m: 3.75,
+      cache_write_1h: 6
+    },
+    "claude-haiku-4-5": {
+      input: 1,
+      output: 5,
+      cache_read: 0.1,
+      cache_write_5m: 1.25,
+      cache_write_1h: 2
+    },
+    "claude-haiku-3-5": {
+      input: 0.8,
+      output: 4,
+      cache_read: 0.08,
+      cache_write_5m: 1,
+      cache_write_1h: 1.6
+    },
+    "claude-3-5-haiku": {
+      input: 0.8,
+      output: 4,
+      cache_read: 0.08,
+      cache_write_5m: 1,
+      cache_write_1h: 1.6
+    },
+    "claude-3-haiku": {
+      input: 0.25,
+      output: 1.25,
+      cache_read: 0.03,
+      cache_write_5m: 0.3,
+      cache_write_1h: 0.5
+    },
+    "claude-3-opus": {
+      input: 15,
+      output: 75,
+      cache_read: 1.5,
+      cache_write_5m: 18.75,
+      cache_write_1h: 30
+    }
+  }
+};
+
+// ../core/src/pricing/pricing.ts
+var US_GEO_MULTIPLIER = 1.1;
+var PriceTable = class _PriceTable {
+  constructor(file) {
+    this.file = file;
+    this.keysByLength = Object.keys(file.per_mtok).sort((a, b) => b.length - a.length);
+  }
+  file;
+  keysByLength;
+  static bundled() {
+    return new _PriceTable(prices_default);
+  }
+  /** Bundled table with a user's partial table merged on top (per-model override). */
+  static withOverrideData(raw) {
+    const base = prices_default;
+    return new _PriceTable({
+      ...base,
+      ...raw,
+      per_mtok: { ...base.per_mtok, ...raw.per_mtok ?? {} }
+    });
+  }
+  get version() {
+    return this.file.version;
+  }
+  /**
+   * Model id -> price entry via exact match, then longest-prefix match (covers
+   * date-stamped ids like claude-haiku-4-5-20251001). Null when unknown.
+   */
+  resolve(model, ctx = {}) {
+    const entry = this.file.per_mtok[model] ?? this.prefixMatch(model);
+    if (!entry) return null;
+    const variant = pickVariant(entry, ctx.ts);
+    if (!variant || variant.input == null || variant.output == null) return null;
+    let price;
+    if (ctx.speed === "fast" && variant.fast_input != null && variant.fast_output != null) {
+      price = {
+        input: variant.fast_input,
+        output: variant.fast_output,
+        cacheRead: variant.fast_input * 0.1,
+        cacheWrite5m: variant.fast_input * 1.25,
+        cacheWrite1h: variant.fast_input * 2
+      };
+    } else {
+      price = {
+        input: variant.input,
+        output: variant.output,
+        cacheRead: variant.cache_read ?? variant.input * 0.1,
+        cacheWrite5m: variant.cache_write_5m ?? variant.input * 1.25,
+        cacheWrite1h: variant.cache_write_1h ?? variant.input * 2
+      };
+    }
+    if (ctx.inferenceGeo === "us") {
+      price = {
+        input: price.input * US_GEO_MULTIPLIER,
+        output: price.output * US_GEO_MULTIPLIER,
+        cacheRead: price.cacheRead * US_GEO_MULTIPLIER,
+        cacheWrite5m: price.cacheWrite5m * US_GEO_MULTIPLIER,
+        cacheWrite1h: price.cacheWrite1h * US_GEO_MULTIPLIER
+      };
+    }
+    return price;
+  }
+  /** Cost of one turn in USD. 0 for zero-usage turns; null when unpriceable. */
+  turnCostUsd(turn) {
+    return this.costAtModel(turn.model, turn, { keepSpeed: true });
+  }
+  /**
+   * Cost of a turn's token counts billed as `model` — used for the "what if
+   * this ran on the ideal model" comparison. Keeps the turn's inference geo
+   * (switching model would not change it) but assumes standard speed unless
+   * `keepSpeed` is set.
+   */
+  costAtModel(model, turn, opts = {}) {
+    const u = turn.usage;
+    if (u.input + u.output + u.cacheRead + u.cacheWrite === 0) return 0;
+    const price = this.resolve(model, {
+      ts: turn.timestamp > 0 ? turn.timestamp : void 0,
+      speed: opts.keepSpeed ? turn.speed : void 0,
+      inferenceGeo: turn.inferenceGeo
+    });
+    if (!price) return null;
+    let write5m = u.cacheWrite5m;
+    let write1h = u.cacheWrite1h;
+    if (write5m + write1h !== u.cacheWrite) {
+      write5m = u.cacheWrite;
+      write1h = 0;
+    }
+    return (u.input * price.input + u.output * price.output + u.cacheRead * price.cacheRead + write5m * price.cacheWrite5m + write1h * price.cacheWrite1h) / 1e6;
+  }
+  prefixMatch(model) {
+    for (const key of this.keysByLength) {
+      if (model.startsWith(key)) return this.file.per_mtok[key];
+    }
+    return void 0;
+  }
+};
+function pickVariant(entry, ts) {
+  if (!Array.isArray(entry)) return entry;
+  if (entry.length === 0) return void 0;
+  const at = ts ?? Date.now();
+  for (const v of entry) {
+    const from = v.from ? Date.parse(v.from) : -Infinity;
+    const until = v.until ? Date.parse(v.until) : Infinity;
+    if (at >= from && at < until) return v;
+  }
+  return entry[entry.length - 1];
+}
+
+// ../core/src/report/format.ts
+function fmtUsd(n) {
+  if (n === null || n === void 0) return "n/a";
+  if (n === 0) return "$0.00";
+  if (n > 0 && n < 0.01) return "<$0.01";
+  return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function fmtTokens(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+  if (n < 1e9) return `${(n / 1e6).toFixed(1)}M`;
+  return `${(n / 1e9).toFixed(2)}B`;
+}
+function fmtPct(x) {
+  if (x === null || x === void 0) return "\u2014";
+  return `${Math.round(x * 100)}%`;
+}
+function fmtDate(ts) {
+  if (!Number.isFinite(ts) || ts <= 0) return "\u2014";
+  const d = new Date(ts);
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${d.getFullYear()}-${mm}-${dd}`;
+}
+function fmtDateTime(ts) {
+  if (!Number.isFinite(ts) || ts <= 0) return "\u2014";
+  const d = new Date(ts);
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mi = String(d.getMinutes()).padStart(2, "0");
+  return `${mm}-${dd} ${hh}:${mi}`;
+}
+function fmtTime(ts) {
+  if (!Number.isFinite(ts) || ts <= 0) return "\u2014";
+  const d = new Date(ts);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}
+function shortId(id) {
+  return id.length > 8 ? id.slice(0, 8) : id;
+}
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+function basename(p) {
+  if (!p) return "\u2014";
+  const parts = p.split("/").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : p;
+}
+function prettyModel(model) {
+  return model.replace(/^claude-/, "").replace(/-\d{8}$/, "");
+}
+
+// ../core/src/types.ts
+var PHASES = ["exploration", "planning", "execution", "delegation", "chat"];
+
+// ../core/src/report/model.ts
+var WASTE_EPSILON = 5e-3;
+var QUOTA_NOTE = "Estimated reconstruction of Anthropic's rolling 5h usage windows \u2014 not official quota accounting.";
+var WASTE_ASSUMPTION = "Waste assumes the cheaper model would consume the same token counts; actual savings vary.";
+function buildReport(turns, events, prices, range) {
+  const sessionIds = new Set(turns.map((t) => t.sessionId));
+  const relevantEvents = events.filter((e) => sessionIds.has(e.sessionId));
+  const classified = classifyTurns(turns, events);
+  const waste = computeWaste(classified, prices);
+  const rootSessions = /* @__PURE__ */ new Set();
+  const projects = /* @__PURE__ */ new Set();
+  const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  let subagentTurns = 0;
+  let minTs = Infinity;
+  let maxTs = 0;
+  for (const t of turns) {
+    rootSessions.add(rootSessionId(t));
+    if (t.projectPath) projects.add(t.projectPath);
+    tokens.input += t.usage.input;
+    tokens.output += t.usage.output;
+    tokens.cacheRead += t.usage.cacheRead;
+    tokens.cacheWrite += t.usage.cacheWrite;
+    if (t.isSidechain) subagentTurns++;
+    if (t.timestamp > 0) {
+      minTs = Math.min(minTs, t.timestamp);
+      maxTs = Math.max(maxTs, t.timestamp);
+    }
+  }
+  const totalTokens = tokens.input + tokens.output + tokens.cacheRead + tokens.cacheWrite;
+  const byModelMap = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    const u = t.usage;
+    if (u.input + u.output + u.cacheRead + u.cacheWrite === 0) continue;
+    let agg = byModelMap.get(t.model);
+    if (!agg) {
+      agg = {
+        turns: 0,
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        costUsd: 0,
+        unpriced: false
+      };
+      byModelMap.set(t.model, agg);
+    }
+    agg.turns++;
+    agg.input += u.input;
+    agg.output += u.output;
+    agg.cacheRead += u.cacheRead;
+    agg.cacheWrite += u.cacheWrite;
+    const cost = prices.turnCostUsd(t);
+    if (cost === null) agg.unpriced = true;
+    else agg.costUsd += cost;
+  }
+  const byModel = [...byModelMap.entries()].map(([model, a]) => ({
+    model,
+    turns: a.turns,
+    input: a.input,
+    output: a.output,
+    cacheRead: a.cacheRead,
+    cacheWrite: a.cacheWrite,
+    costUsd: a.unpriced ? null : a.costUsd,
+    costShare: !a.unpriced && waste.totalCostUsd > 0 ? a.costUsd / waste.totalCostUsd : null
+  })).sort((a, b) => (b.costUsd ?? 0) - (a.costUsd ?? 0) || b.turns - a.turns);
+  const phaseMatrix = [...waste.matrix.entries()].map(([model, phases]) => {
+    const row = {};
+    let total = 0;
+    for (const phase of PHASES) {
+      const cell = phases.get(phase);
+      row[phase] = {
+        turns: cell?.turns ?? 0,
+        costUsd: cell?.costUsd ?? 0,
+        wasteUsd: cell?.wasteUsd ?? 0
+      };
+      total += row[phase].costUsd;
+    }
+    return { model, phases: row, total };
+  }).sort((a, b) => b.total - a.total).map(({ model, phases }) => ({ model, phases }));
+  const overallCache = cacheStats(turns);
+  const cacheProjects = [...cacheByProject(turns).entries()].map(([project, s]) => ({
+    // basename keeps the model identical whether projectPath is the real cwd
+    // (local CLI) or the hashed id/name pair (synced server data).
+    project: basename(project),
+    turns: s.turns,
+    hitRate: s.hitRate,
+    cacheRead: s.cacheRead,
+    cacheWrite: s.cacheWrite
+  })).filter((p) => p.turns >= 10).sort((a, b) => (a.hitRate ?? 1) - (b.hitRate ?? 1)).slice(0, 8);
+  const compactions = summarizeCompactions(relevantEvents);
+  const cachePerSession = cacheBySession(turns);
+  const topSessions = [...waste.perSession.values()].sort((a, b) => b.wasteUsd - a.wasteUsd || b.costUsd - a.costUsd).slice(0, 5).map((s) => ({
+    sessionId: s.sessionId,
+    label: s.slug ?? shortId(s.sessionId),
+    project: basename(s.project),
+    date: fmtDate(s.firstTs === Infinity ? 0 : s.firstTs),
+    turns: s.turns,
+    costUsd: s.costUsd,
+    wasteUsd: s.wasteUsd,
+    antiPattern: dominantAntiPattern(s, cachePerSession.get(s.sessionId)?.hitRate ?? null)
+  }));
+  const agentTypeById = /* @__PURE__ */ new Map();
+  for (const e of relevantEvents) {
+    if (e.kind !== "agent_result") continue;
+    const id = typeof e.data.agentId === "string" ? e.data.agentId : void 0;
+    const type = typeof e.data.agentType === "string" ? e.data.agentType : void 0;
+    if (id && type) agentTypeById.set(id, type);
+  }
+  const children = /* @__PURE__ */ new Map();
+  for (const { turn } of classified) {
+    if (!turn.agentId) continue;
+    let child = children.get(turn.agentId);
+    if (!child) {
+      child = { costUsd: 0, premiumModel: null };
+      children.set(turn.agentId, child);
+    }
+    const cost = prices.turnCostUsd(turn);
+    if (cost !== null) child.costUsd += cost;
+    if (!child.premiumModel && isPremiumModel(turn.model)) child.premiumModel = turn.model;
+  }
+  const leakGroups = /* @__PURE__ */ new Map();
+  for (const [agentId, child] of children) {
+    if (!child.premiumModel) continue;
+    const agentType = agentTypeById.get(agentId) ?? "subagent";
+    const key = `${agentType}\0${child.premiumModel}`;
+    let g = leakGroups.get(key);
+    if (!g) {
+      g = { agentType, model: child.premiumModel, runs: 0, costUsd: 0 };
+      leakGroups.set(key, g);
+    }
+    g.runs++;
+    g.costUsd += child.costUsd;
+  }
+  const subagentLeaks = [...leakGroups.values()].sort((a, b) => b.costUsd - a.costUsd);
+  const windows = build5hWindows(turns, prices);
+  const last7dStart = maxTs > 0 ? maxTs - 7 * 864e5 : 0;
+  const last7d = windows.filter((w) => w.start >= last7dStart).map((w) => ({
+    start: fmtDateTime(w.start),
+    startTs: w.start,
+    turns: w.turns,
+    totalTokens: w.totalTokens,
+    costUsd: w.costUsd
+  }));
+  const weekly = weeklyRollup(turns, prices).map((w) => ({
+    week: w.weekKey,
+    turns: w.turns,
+    totalTokens: w.totalTokens,
+    costUsd: w.costUsd
+  }));
+  const spanDays = Math.max(1, (maxTs - (minTs === Infinity ? maxTs : minTs)) / 864e5);
+  const monthly = (x) => x / spanDays * 30;
+  const recommendations = [];
+  if (monthly(waste.wasteByPhase.exploration) >= 1) {
+    recommendations.push(
+      `Delegate exploration to a Haiku-pinned subagent (frontmatter: model: haiku, effort: low) \u2014 roughly ${fmtUsd(monthly(waste.wasteByPhase.exploration))}/month of premium-model exploration to reclaim.`
+    );
+  }
+  if (monthly(waste.wasteByPhase.execution) >= 1) {
+    recommendations.push(
+      `Run edit/build-heavy work on Sonnet (settings "model": "opusplan", or a sonnet implementer subagent) \u2014 roughly ${fmtUsd(monthly(waste.wasteByPhase.execution))}/month spent running premium models in execution.`
+    );
+  }
+  const leakRuns = subagentLeaks.reduce((n, l) => n + l.runs, 0);
+  if (leakRuns > 0) {
+    recommendations.push(
+      `${leakRuns} subagent run(s) executed on a premium model \u2014 pin model: (haiku/sonnet) in .claude/agents/*.md frontmatter so delegation actually saves money.`
+    );
+  }
+  if (overallCache.hitRate !== null && overallCache.hitRate < 0.7) {
+    recommendations.push(
+      `Cache hit rate is ${fmtPct(overallCache.hitRate)} \u2014 cold starts repay your context at full price. Prefer resuming sessions (claude --continue) over starting fresh ones.`
+    );
+  }
+  if (monthly(waste.fastModeExtraUsd) >= 1) {
+    recommendations.push(
+      `Fast mode premium added ${fmtUsd(waste.fastModeExtraUsd)} in this window \u2014 reserve /fast for latency-critical work.`
+    );
+  }
+  if (compactions.total >= 5) {
+    recommendations.push(
+      `${compactions.total} context compaction(s) re-summarized ~${fmtTokens(compactions.tokensCompacted)} tokens \u2014 split long sessions or push exploration into subagents to keep the main context lean.`
+    );
+  }
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    priceTableVersion: prices.version,
+    range: {
+      days: range.days,
+      since: minTs === Infinity ? null : new Date(minTs).toISOString(),
+      until: new Date(maxTs > 0 ? maxTs : Date.now()).toISOString(),
+      project: range.project
+    },
+    overview: {
+      sessions: rootSessions.size,
+      turns: turns.length,
+      subagentTurns,
+      projects: projects.size,
+      totalTokens,
+      tokens,
+      totalCostUsd: waste.totalCostUsd,
+      unpricedTurns: waste.unpricedTurns,
+      unpricedModels: waste.unpricedModels
+    },
+    byModel,
+    phaseMatrix,
+    waste: {
+      totalUsd: waste.totalWasteUsd,
+      explorationUsd: waste.wasteByPhase.exploration,
+      executionUsd: waste.wasteByPhase.execution,
+      pctOfSpend: waste.totalCostUsd > 0 ? waste.totalWasteUsd / waste.totalCostUsd : null,
+      fastModeExtraUsd: waste.fastModeExtraUsd,
+      assumption: WASTE_ASSUMPTION
+    },
+    cache: {
+      overall: {
+        hitRate: overallCache.hitRate,
+        input: overallCache.input,
+        cacheRead: overallCache.cacheRead,
+        cacheWrite: overallCache.cacheWrite
+      },
+      byProject: cacheProjects,
+      compactions: {
+        total: compactions.total,
+        tokensCompacted: compactions.tokensCompacted,
+        sessionsAffected: compactions.bySession.size
+      }
+    },
+    topSessions,
+    subagentLeaks,
+    quota: { windowHours: WINDOW_MS / 36e5, last7d, weekly, note: QUOTA_NOTE },
+    recommendations
+  };
+}
+function dominantAntiPattern(s, hitRate) {
+  const parts = [];
+  if (s.wasteExplorationUsd > WASTE_EPSILON && s.wasteExplorationUsd >= s.wasteExecutionUsd) {
+    parts.push(`premium model on exploration (${fmtUsd(s.wasteExplorationUsd)})`);
+  } else if (s.wasteExecutionUsd > WASTE_EPSILON) {
+    parts.push(`premium model on execution (${fmtUsd(s.wasteExecutionUsd)})`);
+  }
+  if (parts.length === 0 && hitRate !== null && hitRate < 0.5 && s.turns >= 20) {
+    parts.push(`low cache reuse (${fmtPct(hitRate)} hit rate)`);
+  }
+  return parts.length > 0 ? parts[0] : "\u2014";
+}
+
+// ../core/src/sync.ts
+var SYNC_MAX_TURNS_PER_BATCH = 2e3;
+var SYNC_MAX_EVENTS_PER_BATCH = 5e3;
+
+// src/cli/report.ts
+import pc4 from "picocolors";
+
+// src/lib/prices-io.ts
+import { readFileSync as readFileSync2 } from "fs";
+function loadPriceTable(overridePath) {
+  if (!overridePath) return PriceTable.bundled();
+  const raw = JSON.parse(readFileSync2(overridePath, "utf8"));
+  return PriceTable.withOverrideData(raw);
+}
+
+// src/render/colors.ts
+import pc3 from "picocolors";
+var c = pc3;
+function setColors(enabled) {
+  c = pc3.createColors(enabled);
+}
+
+// src/render/table.ts
+var MAX_CELL_WIDTH = 44;
+function renderTable(cols, rows, indent = "  ") {
+  const plain = (cell) => typeof cell === "string" ? cell : cell.text;
+  const widths = cols.map((col, i) => {
+    let w = col.header.length;
+    for (const row of rows) {
+      const cell = row[i];
+      if (cell !== void 0) w = Math.max(w, Math.min(plain(cell).length, MAX_CELL_WIDTH));
+    }
+    return w;
+  });
+  const renderRow = (cells, painter) => {
+    const parts = cols.map((col, i) => {
+      const cell = cells[i] ?? "";
+      let text = plain(cell);
+      if (text.length > MAX_CELL_WIDTH) text = `${text.slice(0, MAX_CELL_WIDTH - 1)}\u2026`;
+      const w = widths[i] ?? 0;
+      const padded = col.align === "right" ? text.padStart(w) : text.padEnd(w);
+      const paint = typeof cell === "object" ? cell.paint : void 0;
+      const chosen = paint ?? painter;
+      return chosen ? chosen(padded) : padded;
+    });
+    return indent + parts.join("  ");
+  };
+  const lines = [];
+  lines.push(renderRow(cols.map((c2) => c2.header)));
+  lines.push(indent + widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500"));
+  for (const row of rows) lines.push(renderRow(row));
+  return lines.join("\n");
+}
+
+// src/render/terminal.ts
+function renderReport(m) {
+  const out = [];
+  const rangeLabel = m.range.days === null ? "all history" : `last ${m.range.days} days`;
+  const span = `${m.range.since ? fmtDate(Date.parse(m.range.since)) : "\u2014"} \u2192 ${fmtDate(Date.parse(m.range.until))}`;
+  const filter = m.range.project ? ` \xB7 project ~ "${m.range.project}"` : "";
+  out.push(`${c.bold("TkTuner report")} \u2014 ${rangeLabel} (${span})${filter}`);
+  const o = m.overview;
+  const lines = [];
+  lines.push(
+    `Sessions ${c.bold(String(o.sessions))} \xB7 assistant turns ${c.bold(o.turns.toLocaleString("en-US"))}` + (o.subagentTurns > 0 ? ` (${o.subagentTurns.toLocaleString("en-US")} in subagents)` : "") + ` \xB7 projects ${c.bold(String(o.projects))}`
+  );
+  lines.push(
+    `Est. cost (API-equivalent): ${c.bold(c.green(fmtUsd(o.totalCostUsd)))}   tokens: ${c.bold(fmtTokens(o.totalTokens))} \u2014 in ${fmtTokens(o.tokens.input)} \xB7 out ${fmtTokens(o.tokens.output)} \xB7 cache read ${fmtTokens(o.tokens.cacheRead)} \xB7 cache write ${fmtTokens(o.tokens.cacheWrite)}`
+  );
+  if (o.unpricedTurns > 0) {
+    lines.push(
+      c.yellow(
+        `${o.unpricedTurns} turn(s) on unpriced model(s) excluded from cost: ${o.unpricedModels.join(", ")} \u2014 update prices.json or use --prices`
+      )
+    );
+  }
+  out.push(`${header("Overview")}
+${lines.join("\n")}`);
+  out.push(
+    `${header("By model")}
+${renderTable(
+      [
+        { header: "Model" },
+        { header: "Turns", align: "right" },
+        { header: "Input", align: "right" },
+        { header: "Output", align: "right" },
+        { header: "Cache read", align: "right" },
+        { header: "Cache write", align: "right" },
+        { header: "Est. cost", align: "right" },
+        { header: "%", align: "right" }
+      ],
+      m.byModel.map((r) => [
+        prettyModel(r.model),
+        String(r.turns),
+        fmtTokens(r.input),
+        fmtTokens(r.output),
+        fmtTokens(r.cacheRead),
+        fmtTokens(r.cacheWrite),
+        { text: fmtUsd(r.costUsd), paint: r.costUsd === null ? c.yellow : void 0 },
+        fmtPct(r.costShare)
+      ])
+    )}`
+  );
+  const matrixRows = m.phaseMatrix.map((row) => {
+    const cells = [prettyModel(row.model)];
+    for (const phase of PHASES) {
+      const cell = row.phases[phase];
+      if (cell.turns === 0) cells.push({ text: "\xB7", paint: c.dim });
+      else if (cell.wasteUsd > WASTE_EPSILON) {
+        cells.push({ text: fmtUsd(cell.costUsd), paint: c.red });
+      } else cells.push(fmtUsd(cell.costUsd));
+    }
+    return cells;
+  });
+  const wasteLines = [];
+  wasteLines.push(
+    `${c.bold(c.red("\u26A0 waste"))} (premium model on cheap work): ${c.bold(c.red(fmtUsd(m.waste.totalUsd)))}` + (m.waste.pctOfSpend !== null ? ` = ${c.bold(fmtPct(m.waste.pctOfSpend))} of spend` : "")
+  );
+  wasteLines.push(
+    `  exploration on premium: ${fmtUsd(m.waste.explorationUsd)} \xB7 execution on premium: ${fmtUsd(m.waste.executionUsd)}` + (m.waste.fastModeExtraUsd > WASTE_EPSILON ? ` \xB7 fast-mode premium: ${fmtUsd(m.waste.fastModeExtraUsd)}` : "")
+  );
+  out.push(
+    `${header("Cost by phase \xD7 model")}
+${renderTable(
+      [{ header: "Model" }, ...PHASES.map((p) => ({ header: cap(p), align: "right" }))],
+      matrixRows
+    )}
+
+${wasteLines.join("\n")}`
+  );
+  const ch = m.cache;
+  const cacheLines = [
+    `Overall hit rate: ${paintHitRate(ch.overall.hitRate)} (read ${fmtTokens(ch.overall.cacheRead)} \xB7 write ${fmtTokens(ch.overall.cacheWrite)} \xB7 uncached input ${fmtTokens(ch.overall.input)})`
+  ];
+  if (ch.compactions.total > 0) {
+    cacheLines.push(
+      `Compactions: ${ch.compactions.total} across ${ch.compactions.sessionsAffected} session(s) \xB7 ~${fmtTokens(ch.compactions.tokensCompacted)} tokens re-summarized`
+    );
+  }
+  const cacheTable = ch.byProject.length > 0 ? `
+${renderTable(
+    [
+      { header: "Project (worst hit rate first)" },
+      { header: "Turns", align: "right" },
+      { header: "Hit rate", align: "right" },
+      { header: "Read", align: "right" },
+      { header: "Write", align: "right" }
+    ],
+    ch.byProject.map((p) => [
+      basename(p.project),
+      String(p.turns),
+      {
+        text: fmtPct(p.hitRate),
+        paint: p.hitRate !== null && p.hitRate < 0.6 ? c.yellow : void 0
+      },
+      fmtTokens(p.cacheRead),
+      fmtTokens(p.cacheWrite)
+    ])
+  )}` : "";
+  out.push(`${header("Cache health")}
+${cacheLines.join("\n")}${cacheTable}`);
+  if (m.topSessions.length > 0) {
+    out.push(
+      `${header("Top 5 most wasteful sessions")}
+${renderTable(
+        [
+          { header: "#", align: "right" },
+          { header: "Session" },
+          { header: "Project" },
+          { header: "Date" },
+          { header: "Turns", align: "right" },
+          { header: "Cost", align: "right" },
+          { header: "Waste", align: "right" },
+          { header: "Dominant anti-pattern" }
+        ],
+        m.topSessions.map((s, i) => [
+          String(i + 1),
+          s.label,
+          s.project,
+          s.date,
+          String(s.turns),
+          fmtUsd(s.costUsd),
+          { text: fmtUsd(s.wasteUsd), paint: s.wasteUsd > WASTE_EPSILON ? c.red : void 0 },
+          s.antiPattern
+        ])
+      )}
+${c.dim(`  drill down: tktuner report --debug-session <session>`)}`
+    );
+  }
+  if (m.subagentLeaks.length > 0) {
+    out.push(
+      `${header("Subagent leaks (premium model in delegated runs)")}
+${renderTable(
+        [
+          { header: "Agent type" },
+          { header: "Model" },
+          { header: "Runs", align: "right" },
+          { header: "Est. cost", align: "right" }
+        ],
+        m.subagentLeaks.map((l) => [
+          l.agentType,
+          prettyModel(l.model),
+          String(l.runs),
+          { text: fmtUsd(l.costUsd), paint: c.red }
+        ])
+      )}
+${c.dim("  fix: pin model: haiku|sonnet in the agent frontmatter (.claude/agents/*.md)")}`
+    );
+  } else {
+    out.push(`${header("Subagent leaks")}
+${c.green("No subagent runs on premium models.")}`);
+  }
+  const maxWindowCost = Math.max(...m.quota.last7d.map((w) => w.costUsd), 0);
+  const quotaParts = [];
+  if (m.quota.last7d.length > 0) {
+    quotaParts.push(
+      renderTable(
+        [
+          { header: `5h window start (last 7d)` },
+          { header: "Turns", align: "right" },
+          { header: "Tokens", align: "right" },
+          { header: "Cost-equivalent", align: "right" },
+          { header: "" }
+        ],
+        m.quota.last7d.map((w) => [
+          w.start,
+          String(w.turns),
+          fmtTokens(w.totalTokens),
+          fmtUsd(w.costUsd),
+          { text: bar(w.costUsd, maxWindowCost, 14), paint: c.cyan }
+        ])
+      )
+    );
+  }
+  const maxWeekCost = Math.max(...m.quota.weekly.map((w) => w.costUsd), 0);
+  if (m.quota.weekly.length > 0) {
+    quotaParts.push(
+      renderTable(
+        [
+          { header: "Week" },
+          { header: "Turns", align: "right" },
+          { header: "Tokens", align: "right" },
+          { header: "Cost-equivalent", align: "right" },
+          { header: "" }
+        ],
+        m.quota.weekly.map((w) => [
+          w.week,
+          String(w.turns),
+          fmtTokens(w.totalTokens),
+          fmtUsd(w.costUsd),
+          { text: bar(w.costUsd, maxWeekCost, 14), paint: c.magenta }
+        ])
+      )
+    );
+  }
+  quotaParts.push(c.dim(`  ${m.quota.note}`));
+  out.push(`${header("Quota pressure")}
+${quotaParts.join("\n\n")}`);
+  if (m.recommendations.length > 0) {
+    out.push(
+      `${header("Recommendations")}
+${m.recommendations.map((r, i) => `  ${c.green(`${i + 1}.`)} ${r}`).join("\n")}`
+    );
+  }
+  out.push(
+    c.dim(
+      [
+        m.waste.assumption,
+        `Prices v${m.priceTableVersion} (platform.claude.com) \u2014 override with --prices <file>.`
+      ].join("\n")
+    )
+  );
+  return `
+${out.join("\n\n")}
+`;
+}
+function renderDebugSession(turns, events, prices, idPrefix) {
+  const match = turns.filter(
+    (t) => t.sessionId.startsWith(idPrefix) || rootSessionId(t).startsWith(idPrefix) || t.slug?.startsWith(idPrefix)
+  );
+  if (match.length === 0) {
+    return c.yellow(`No turns found for session prefix "${idPrefix}".`);
+  }
+  const classified = classifyTurns(match, events).sort(
+    (a, b) => a.turn.timestamp - b.turn.timestamp
+  );
+  const first = classified[0];
+  const totalCost = classified.reduce((acc, ct) => acc + (prices.turnCostUsd(ct.turn) ?? 0), 0);
+  const sessions = new Set(match.map((t) => t.sessionId));
+  const head = `${c.bold("Session debug")} \u2014 ${idPrefix} (${sessions.size} session file(s), ${match.length} turns)
+project ${first.turn.projectPath || "\u2014"} \xB7 ${fmtDate(first.turn.timestamp)} \xB7 est. cost ${c.bold(fmtUsd(totalCost))}`;
+  const table = renderTable(
+    [
+      { header: "Time" },
+      { header: "Model" },
+      { header: "Raw", align: "left" },
+      { header: "Smoothed", align: "left" },
+      { header: "Think", align: "right" },
+      { header: "Out", align: "right" },
+      { header: "Cost", align: "right" },
+      { header: "Tools" }
+    ],
+    classified.map((ct) => [
+      fmtTime(ct.turn.timestamp),
+      prettyModel(ct.turn.model),
+      ct.phase,
+      ct.phase === ct.phaseSmoothed ? ct.phaseSmoothed : { text: ct.phaseSmoothed, paint: c.yellow },
+      fmtTokens(ct.turn.thinkingChars),
+      fmtTokens(ct.turn.usage.output),
+      fmtUsd(prices.turnCostUsd(ct.turn)),
+      truncate(ct.turn.tools.join(","), 40) || c.dim("\u2014")
+    ])
+  );
+  const sessionEvents = events.filter((e) => sessions.has(e.sessionId) && e.kind !== "turn_duration" && e.timestamp).sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0)).map((e) => `  ${fmtTime(e.timestamp ?? 0)}  ${e.kind}`).join("\n");
+  return `
+${head}
+
+${table}${sessionEvents ? `
+
+${c.bold("Events")}
+${sessionEvents}` : ""}
+`;
+}
+function header(title) {
+  const line = "\u2501".repeat(Math.max(4, 62 - title.length));
+  return c.bold(c.cyan(`\u2501\u2501 ${title} ${line.slice(0, Math.max(2, 58 - title.length))}`));
+}
+function cap(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function paintHitRate(rate) {
+  const text = fmtPct(rate);
+  if (rate === null) return text;
+  if (rate >= 0.8) return c.green(c.bold(text));
+  if (rate >= 0.6) return c.yellow(c.bold(text));
+  return c.red(c.bold(text));
+}
+function bar(value, max, width) {
+  if (max <= 0 || value <= 0) return "";
+  return "\u2588".repeat(Math.max(1, Math.round(value / max * width)));
+}
+
+// src/store/db.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+import Database from "better-sqlite3";
+
+// src/store/schema.ts
+var SCHEMA_VERSION = 1;
+var DDL = `
+CREATE TABLE IF NOT EXISTS files (
+  path TEXT PRIMARY KEY,
+  mtime_ms INTEGER NOT NULL,
+  size INTEGER NOT NULL,
+  byte_offset INTEGER NOT NULL DEFAULT 0,
+  kind TEXT NOT NULL,
+  session_id TEXT,
+  agent_id TEXT,
+  parent_session_id TEXT,
+  last_scanned_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS turns (
+  uuid TEXT PRIMARY KEY,
+  message_id TEXT,
+  request_id TEXT,
+  session_id TEXT NOT NULL,
+  agent_id TEXT,
+  parent_session_id TEXT,
+  is_sidechain INTEGER NOT NULL DEFAULT 0,
+  ts INTEGER NOT NULL DEFAULT 0,
+  model TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_5m_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_1h_tokens INTEGER NOT NULL DEFAULT 0,
+  tools TEXT NOT NULL DEFAULT '[]',
+  num_tool_uses INTEGER NOT NULL DEFAULT 0,
+  thinking_chars INTEGER NOT NULL DEFAULT 0,
+  text_chars INTEGER NOT NULL DEFAULT 0,
+  stop_reason TEXT,
+  cwd TEXT,
+  slug TEXT,
+  git_branch TEXT,
+  version TEXT,
+  speed TEXT,
+  inference_geo TEXT,
+  file_path TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_turns_session ON turns(session_id);
+CREATE INDEX IF NOT EXISTS idx_turns_ts ON turns(ts);
+CREATE INDEX IF NOT EXISTS idx_turns_file ON turns(file_path);
+CREATE INDEX IF NOT EXISTS idx_turns_msg ON turns(message_id);
+
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  ts INTEGER,
+  kind TEXT NOT NULL,
+  data TEXT NOT NULL DEFAULT '{}',
+  file_path TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id, ts);
+CREATE INDEX IF NOT EXISTS idx_events_file ON events(file_path);
+
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+`;
+
+// src/store/db.ts
+function defaultDbPath() {
+  return join3(dataDir(), "tktuner.db");
+}
+function openDb(path) {
+  const dbPath = path ?? defaultDbPath();
+  mkdirSync2(dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  migrate(db);
+  return db;
+}
+function migrate(db) {
+  rebuildIfPreRelease(db);
+  db.exec(DDL);
+  const row = db.prepare(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
+  const current = row ? Number(row.value) : 0;
+  if (current > SCHEMA_VERSION) {
+    throw new Error(
+      `Database schema v${current} is newer than this tktuner build supports (v${SCHEMA_VERSION}). Upgrade tktuner.`
+    );
+  }
+  db.prepare(
+    `INSERT INTO meta (key, value) VALUES ('schema_version', ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(String(SCHEMA_VERSION));
+}
+function rebuildIfPreRelease(db) {
+  const table = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'turns'`).get();
+  if (!table) return;
+  const cols = db.prepare(`PRAGMA table_info(turns)`).all();
+  if (cols.some((c2) => c2.name === "message_id")) return;
+  db.exec(`DROP TABLE IF EXISTS turns; DROP TABLE IF EXISTS events; DROP TABLE IF EXISTS files;`);
+}
+
+// src/store/queries.ts
+var Store = class {
+  constructor(db) {
+    this.db = db;
+    this.stmtGetFile = db.prepare(
+      `SELECT path, mtime_ms AS mtimeMs, size, byte_offset AS byteOffset, kind
+       FROM files WHERE path = ?`
+    );
+    this.stmtUpsertFile = db.prepare(
+      `INSERT INTO files (path, mtime_ms, size, byte_offset, kind, session_id, agent_id, parent_session_id, last_scanned_at)
+       VALUES (@path, @mtimeMs, @size, @byteOffset, @kind, @sessionId, @agentId, @parentSessionId, @scannedAt)
+       ON CONFLICT(path) DO UPDATE SET
+         mtime_ms = excluded.mtime_ms,
+         size = excluded.size,
+         byte_offset = excluded.byte_offset,
+         last_scanned_at = excluded.last_scanned_at`
+    );
+    this.stmtInsertTurn = db.prepare(
+      `INSERT OR IGNORE INTO turns (
+         uuid, message_id, request_id, session_id, agent_id, parent_session_id, is_sidechain, ts, model,
+         input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+         cache_5m_tokens, cache_1h_tokens, tools, num_tool_uses, thinking_chars,
+         text_chars, stop_reason, cwd, slug, git_branch, version, speed, inference_geo, file_path
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    this.stmtInsertEvent = db.prepare(
+      `INSERT INTO events (session_id, ts, kind, data, file_path) VALUES (?, ?, ?, ?, ?)`
+    );
+    this.txIngest = db.transaction((file, batch) => {
+      let newTurns = 0;
+      for (const t of batch.turns) {
+        const info = this.stmtInsertTurn.run(
+          t.uuid,
+          t.messageId ?? null,
+          t.requestId ?? null,
+          t.sessionId,
+          t.agentId ?? null,
+          t.parentSessionId ?? null,
+          t.isSidechain ? 1 : 0,
+          t.timestamp,
+          t.model,
+          t.usage.input,
+          t.usage.output,
+          t.usage.cacheWrite,
+          t.usage.cacheRead,
+          t.usage.cacheWrite5m,
+          t.usage.cacheWrite1h,
+          JSON.stringify(t.tools),
+          t.numToolUses,
+          t.thinkingChars,
+          t.textChars,
+          t.stopReason ?? null,
+          t.projectPath || null,
+          t.slug ?? null,
+          t.gitBranch ?? null,
+          t.cliVersion ?? null,
+          t.speed ?? null,
+          t.inferenceGeo ?? null,
+          t.filePath
+        );
+        newTurns += info.changes;
+      }
+      for (const e of batch.events) {
+        this.stmtInsertEvent.run(
+          e.sessionId,
+          e.timestamp ?? null,
+          e.kind,
+          JSON.stringify(e.data),
+          e.filePath
+        );
+      }
+      this.stmtUpsertFile.run({
+        path: file.path,
+        mtimeMs: file.mtimeMs,
+        size: file.sizeBytes,
+        byteOffset: batch.bytesConsumed,
+        kind: file.kind,
+        sessionId: file.sessionId ?? null,
+        agentId: file.agentId ?? null,
+        parentSessionId: file.parentSessionId ?? null,
+        scannedAt: Date.now()
+      });
+      return { newTurns, newEvents: batch.events.length };
+    });
+  }
+  db;
+  stmtGetFile;
+  stmtUpsertFile;
+  stmtInsertTurn;
+  stmtInsertEvent;
+  txIngest;
+  getFileState(path) {
+    return this.stmtGetFile.get(path);
+  }
+  /** Remove everything ingested from one file so it can be reparsed cleanly. */
+  deleteFileData(path) {
+    this.db.prepare(`DELETE FROM turns WHERE file_path = ?`).run(path);
+    this.db.prepare(`DELETE FROM events WHERE file_path = ?`).run(path);
+    this.db.prepare(`DELETE FROM files WHERE path = ?`).run(path);
+  }
+  ingestBatch(file, batch) {
+    return this.txIngest(file, batch);
+  }
+  /** Merge unknown line-type counts into the persistent parser-evolution log. */
+  bumpUnknownTypes(counts) {
+    if (Object.keys(counts).length === 0) return;
+    const merged = { ...this.getUnknownTypes() };
+    for (const [k, v] of Object.entries(counts)) merged[k] = (merged[k] ?? 0) + v;
+    this.setMeta("unknown_line_types", JSON.stringify(merged));
+  }
+  getUnknownTypes() {
+    const raw = this.getMeta("unknown_line_types");
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  getMeta(key) {
+    const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(key);
+    return row?.value;
+  }
+  setMeta(key, value) {
+    this.db.prepare(
+      `INSERT INTO meta (key, value) VALUES (?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(key, value);
+  }
+  /** Real (merged) turn count — content-block lines collapse by message_id. */
+  countTurns() {
+    const row = this.db.prepare(`SELECT COUNT(DISTINCT COALESCE(message_id, uuid)) AS n FROM turns`).get();
+    return row.n;
+  }
+  /**
+   * Loads billable turns. Raw rows are one-per-content-block (Claude Code
+   * splits an API response across JSONL lines, repeating the same usage), so
+   * rows sharing a message_id are merged here into a single TurnEvent.
+   *
+   * The project filter matches the project NAME (basename of cwd), case-
+   * insensitive — the same semantics as the dashboard, which only ever sees
+   * hashed ids + names. Full-path matching would also catch unrelated
+   * directories that merely contain the string.
+   */
+  loadTurns(filter = {}) {
+    const clauses = [];
+    const params = [];
+    if (filter.sinceTs !== void 0) {
+      clauses.push(`ts >= ?`);
+      params.push(filter.sinceTs);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    let rows = this.db.prepare(`SELECT * FROM turns ${where} ORDER BY ts ASC, uuid ASC`).all(...params);
+    if (filter.projectLike) {
+      const needle = filter.projectLike.toLowerCase();
+      rows = rows.filter(
+        (r) => basename(r.cwd ?? "").toLowerCase().includes(needle)
+      );
+    }
+    return mergeTurnLines(rows.map(rowToTurn));
+  }
+  /** Distinct turnKeys touched by raw lines after `rowid` + the new watermark. */
+  newTurnKeysSince(rowid) {
+    const rows = this.db.prepare(`SELECT rowid AS rid, COALESCE(message_id, uuid) AS k FROM turns WHERE rowid > ?`).all(rowid);
+    const keys = /* @__PURE__ */ new Set();
+    let maxRowid = rowid;
+    for (const r of rows) {
+      keys.add(r.k);
+      if (r.rid > maxRowid) maxRowid = r.rid;
+    }
+    return { keys: [...keys], maxRowid };
+  }
+  /**
+   * Loads and merges the ENTIRE line group of each turnKey (late-arriving
+   * content blocks re-push the whole merged turn — the server upsert
+   * overwrites). Each merged turn carries its group's max rowid so the sync
+   * watermark can advance per confirmed batch.
+   */
+  loadTurnGroups(keys) {
+    if (keys.length === 0) return [];
+    const lines = [];
+    const maxRowidByKey = /* @__PURE__ */ new Map();
+    for (let i = 0; i < keys.length; i += 500) {
+      const chunk = keys.slice(i, i + 500);
+      const placeholders = chunk.map(() => "?").join(",");
+      const rows = this.db.prepare(
+        `SELECT rowid AS rid, * FROM turns
+            WHERE COALESCE(message_id, uuid) IN (${placeholders})
+            ORDER BY ts ASC, uuid ASC`
+      ).all(...chunk);
+      for (const r of rows) {
+        const key = r.message_id ?? r.uuid;
+        const prev = maxRowidByKey.get(key) ?? 0;
+        if (r.rid > prev) maxRowidByKey.set(key, r.rid);
+        lines.push(rowToTurn(r));
+      }
+    }
+    return mergeTurnLines(lines).map((turn) => ({
+      turn,
+      maxRowid: maxRowidByKey.get(turn.messageId ?? turn.uuid) ?? 0
+    })).sort((a, b) => a.maxRowid - b.maxRowid);
+  }
+  /** Raw events after `id`, oldest first (insert-only; id is the watermark). */
+  eventsSince(id) {
+    const rows = this.db.prepare(
+      `SELECT id, session_id, ts, kind, data, file_path FROM events WHERE id > ? ORDER BY id ASC`
+    ).all(id);
+    return rows.map((r) => {
+      let data = {};
+      try {
+        data = JSON.parse(r.data);
+      } catch {
+      }
+      return {
+        id: r.id,
+        event: {
+          kind: r.kind,
+          sessionId: r.session_id,
+          timestamp: r.ts ?? void 0,
+          filePath: r.file_path,
+          data
+        }
+      };
+    });
+  }
+  loadEvents() {
+    const rows = this.db.prepare(`SELECT session_id, ts, kind, data, file_path FROM events ORDER BY ts ASC`).all();
+    return rows.map((r) => {
+      let data = {};
+      try {
+        data = JSON.parse(r.data);
+      } catch {
+      }
+      return {
+        kind: r.kind,
+        sessionId: r.session_id,
+        timestamp: r.ts ?? void 0,
+        filePath: r.file_path,
+        data
+      };
+    });
+  }
+};
+function rowToTurn(r) {
+  let tools = [];
+  try {
+    const parsed = JSON.parse(r.tools);
+    if (Array.isArray(parsed)) tools = parsed.filter((x) => typeof x === "string");
+  } catch {
+  }
+  return {
+    agent: "claude-code",
+    uuid: r.uuid,
+    messageId: r.message_id ?? void 0,
+    requestId: r.request_id ?? void 0,
+    sessionId: r.session_id,
+    parentSessionId: r.parent_session_id ?? void 0,
+    agentId: r.agent_id ?? void 0,
+    isSidechain: r.is_sidechain === 1,
+    projectPath: r.cwd ?? "",
+    slug: r.slug ?? void 0,
+    timestamp: r.ts,
+    model: r.model,
+    usage: {
+      input: r.input_tokens,
+      output: r.output_tokens,
+      cacheRead: r.cache_read_tokens,
+      cacheWrite: r.cache_creation_tokens,
+      cacheWrite5m: r.cache_5m_tokens,
+      cacheWrite1h: r.cache_1h_tokens
+    },
+    tools,
+    numToolUses: r.num_tool_uses,
+    thinkingChars: r.thinking_chars,
+    textChars: r.text_chars,
+    stopReason: r.stop_reason ?? void 0,
+    gitBranch: r.git_branch ?? void 0,
+    cliVersion: r.version ?? void 0,
+    speed: r.speed ?? void 0,
+    inferenceGeo: r.inference_geo ?? void 0,
+    filePath: r.file_path
+  };
+}
+
+// src/cli/report.ts
+async function report(opts) {
+  if (opts.color === false || opts.json) setColors(false);
+  const days = opts.all ? null : Number(opts.days);
+  if (days !== null && (!Number.isFinite(days) || days <= 0)) {
+    console.error(pc4.red(`Invalid --days value: ${opts.days}`));
+    process.exitCode = 1;
+    return;
+  }
+  const db = openDb(opts.db);
+  try {
+    const store = new Store(db);
+    if (store.countTurns() === 0) {
+      console.log(`No data yet \u2014 run ${pc4.bold("tktuner scan")} first.`);
+      return;
+    }
+    let prices;
+    try {
+      prices = loadPriceTable(opts.prices);
+    } catch (err) {
+      console.error(pc4.red(`Could not load price override ${opts.prices}: ${String(err)}`));
+      process.exitCode = 1;
+      return;
+    }
+    const sinceTs = days === null ? void 0 : Date.now() - days * 864e5;
+    const turns = store.loadTurns({ sinceTs, projectLike: opts.project });
+    if (turns.length === 0) {
+      console.log(
+        `No turns in the selected window${opts.project ? ` for project filter "${opts.project}"` : ""}. Try --all or a larger --days.`
+      );
+      return;
+    }
+    const events = store.loadEvents();
+    if (opts.debugSession) {
+      console.log(renderDebugSession(turns, events, prices, opts.debugSession));
+      return;
+    }
+    const model = buildReport(turns, events, prices, {
+      days,
+      project: opts.project ?? null
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(model, null, 2));
+    } else {
+      console.log(renderReport(model));
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// src/cli/scan.ts
+import pc5 from "picocolors";
+
+// src/adapters/claude-code/discover.ts
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4, relative, sep } from "path";
+var SESSION_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
+var AGENT_RE = /^agent-([0-9a-z_-]+)\.jsonl$/i;
+var SKIP_DIRS = /* @__PURE__ */ new Set(["memory", "tool-results"]);
+function detectClaudeRoot(override) {
+  const root = override ?? join4(homedir2(), ".claude", "projects");
+  return existsSync2(root) ? { found: true, rootDirs: [root] } : { found: false, rootDirs: [] };
+}
+function listLogFiles(rootDirs) {
+  const out = [];
+  for (const root of rootDirs) {
+    let entries;
+    try {
+      entries = readdirSync(root, { recursive: true, withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      if (!ent.isFile() || !ent.name.endsWith(".jsonl")) continue;
+      if (ent.name === "journal.jsonl") continue;
+      const dirent = ent;
+      const parent = dirent.parentPath ?? dirent.path ?? root;
+      const full = join4(parent, ent.name);
+      const segs = relative(root, full).split(sep);
+      if (segs.some((s) => SKIP_DIRS.has(s))) continue;
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      const base = { path: full, sizeBytes: st.size, mtimeMs: Math.trunc(st.mtimeMs) };
+      const agentMatch = AGENT_RE.exec(ent.name);
+      const subIdx = segs.indexOf("subagents");
+      if (agentMatch && subIdx > 0) {
+        out.push({
+          ...base,
+          kind: "subagent",
+          agentId: agentMatch[1],
+          parentSessionId: segs[subIdx - 1]
+        });
+      } else if (segs.length === 2 && SESSION_RE.test(ent.name)) {
+        out.push({ ...base, kind: "session", sessionId: ent.name.slice(0, -".jsonl".length) });
+      } else {
+        out.push({ ...base, kind: "other" });
+      }
+    }
+  }
+  out.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return out;
+}
+
+// src/adapters/claude-code/jsonl.ts
+import { createReadStream } from "fs";
+var NL = 10;
+var CR = 13;
+async function* iterateJsonlLines(path, fromOffset = 0) {
+  const stream = createReadStream(path, { start: fromOffset });
+  let pending = [];
+  let pendingBytes = 0;
+  let offset = fromOffset;
+  for await (const chunk of stream) {
+    let start = 0;
+    while (start < chunk.length) {
+      const idx = chunk.indexOf(NL, start);
+      if (idx === -1) {
+        pending.push(chunk.subarray(start));
+        pendingBytes += chunk.length - start;
+        break;
+      }
+      const slice = chunk.subarray(start, idx);
+      const lineBuf = pending.length > 0 ? Buffer.concat([...pending, slice]) : slice;
+      pending = [];
+      pendingBytes = 0;
+      offset += lineBuf.length + 1;
+      yield { text: lineText(lineBuf), endOffset: offset, terminated: true };
+      start = idx + 1;
+    }
+  }
+  if (pendingBytes > 0) {
+    const lineBuf = Buffer.concat(pending);
+    yield { text: lineText(lineBuf), endOffset: offset + lineBuf.length, terminated: false };
+  }
+}
+function lineText(buf) {
+  const end = buf.length > 0 && buf[buf.length - 1] === CR ? buf.length - 1 : buf.length;
+  return buf.toString("utf8", 0, end);
+}
+
+// src/adapters/claude-code/parse.ts
+var SIDECAR_TYPES = /* @__PURE__ */ new Set([
+  "ai-title",
+  "mode",
+  "permission-mode",
+  "last-prompt",
+  "agent-name",
+  "file-history-snapshot",
+  "queue-operation",
+  "queued-command",
+  "started",
+  "result",
+  "frame-link",
+  "summary"
+]);
+function parseLine(raw, file) {
+  const text = raw.trim();
+  if (text === "") return {};
+  let obj;
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { parseError: true };
+    }
+    obj = parsed;
+  } catch {
+    return { parseError: true };
+  }
+  const type = obj.type;
+  if (typeof type !== "string") return { parseError: true };
+  switch (type) {
+    case "assistant":
+      return assistantToTurn(obj, file);
+    case "user":
+      return userToEvent(obj, file);
+    case "system":
+      return systemToEvent(obj, file);
+    case "attachment":
+      return attachmentToEvent(obj, file);
+    default:
+      return SIDECAR_TYPES.has(type) ? {} : { unknownType: type };
+  }
+}
+function assistantToTurn(obj, file) {
+  const uuid = str(obj.uuid);
+  const msg = obj.message;
+  if (!uuid || typeof msg !== "object" || msg === null) return { parseError: true };
+  const message = msg;
+  const usage = asRecord(message.usage);
+  const cacheCreation = asRecord(usage.cache_creation);
+  const write5m = num(cacheCreation.ephemeral_5m_input_tokens);
+  const write1h = num(cacheCreation.ephemeral_1h_input_tokens);
+  const cacheWrite = usage.cache_creation_input_tokens !== void 0 ? num(usage.cache_creation_input_tokens) : write5m + write1h;
+  const tools = [];
+  let thinkingChars = 0;
+  let textChars = 0;
+  const content = Array.isArray(message.content) ? message.content : [];
+  for (const rawBlock of content) {
+    if (typeof rawBlock !== "object" || rawBlock === null) continue;
+    const block = rawBlock;
+    if (block.type === "tool_use") {
+      const name = str(block.name);
+      if (name) tools.push(name);
+    } else if (block.type === "thinking") {
+      thinkingChars += typeof block.thinking === "string" ? block.thinking.length : 0;
+    } else if (block.type === "text") {
+      textChars += typeof block.text === "string" ? block.text.length : 0;
+    }
+  }
+  const turn = {
+    agent: "claude-code",
+    uuid,
+    messageId: str(message.id),
+    requestId: str(obj.requestId),
+    sessionId: str(obj.sessionId) ?? file.sessionId ?? "unknown",
+    parentSessionId: file.parentSessionId,
+    agentId: str(obj.agentId) ?? file.agentId,
+    isSidechain: obj.isSidechain === true,
+    projectPath: str(obj.cwd) ?? "",
+    slug: str(obj.slug),
+    timestamp: parseTs(obj.timestamp) ?? 0,
+    model: str(message.model) ?? "unknown",
+    usage: {
+      input: num(usage.input_tokens),
+      output: num(usage.output_tokens),
+      cacheRead: num(usage.cache_read_input_tokens),
+      cacheWrite,
+      cacheWrite5m: write5m,
+      cacheWrite1h: write1h
+    },
+    tools,
+    numToolUses: tools.length,
+    thinkingChars,
+    textChars,
+    stopReason: str(message.stop_reason),
+    gitBranch: str(obj.gitBranch),
+    cliVersion: str(obj.version),
+    speed: str(usage.speed),
+    inferenceGeo: str(usage.inference_geo),
+    filePath: file.path
+  };
+  return { turn };
+}
+function userToEvent(obj, file) {
+  const tur = obj.toolUseResult;
+  if (typeof tur !== "object" || tur === null || Array.isArray(tur)) return {};
+  const r = tur;
+  const agentId = str(r.agentId);
+  const looksLikeAgentResult = agentId !== void 0 && ("resolvedModel" in r || "agentType" in r || "totalTokens" in r);
+  if (!looksLikeAgentResult) return {};
+  return {
+    event: {
+      kind: "agent_result",
+      sessionId: str(obj.sessionId) ?? file.sessionId ?? "unknown",
+      timestamp: parseTs(obj.timestamp),
+      filePath: file.path,
+      data: compact({
+        agentId,
+        agentType: str(r.agentType),
+        resolvedModel: str(r.resolvedModel),
+        status: str(r.status),
+        totalDurationMs: numOrU(r.totalDurationMs),
+        totalTokens: numOrU(r.totalTokens),
+        totalToolUseCount: numOrU(r.totalToolUseCount)
+      })
+    }
+  };
+}
+function systemToEvent(obj, file) {
+  const subtype = str(obj.subtype);
+  const sessionId = str(obj.sessionId) ?? file.sessionId ?? "unknown";
+  const timestamp = parseTs(obj.timestamp);
+  if (subtype === "compact_boundary") {
+    const meta = asRecord(obj.compactMetadata);
+    return {
+      event: {
+        kind: "compact_boundary",
+        sessionId,
+        timestamp,
+        filePath: file.path,
+        data: compact({
+          trigger: str(meta.trigger),
+          preTokens: numOrU(meta.preTokens),
+          postTokens: numOrU(meta.postTokens),
+          cumulativeDroppedTokens: numOrU(meta.cumulativeDroppedTokens),
+          durationMs: numOrU(meta.durationMs)
+        })
+      }
+    };
+  }
+  if (subtype === "turn_duration") {
+    return {
+      event: {
+        kind: "turn_duration",
+        sessionId,
+        timestamp,
+        filePath: file.path,
+        data: compact({
+          durationMs: numOrU(obj.durationMs),
+          messageCount: numOrU(obj.messageCount)
+        })
+      }
+    };
+  }
+  return {};
+}
+function attachmentToEvent(obj, file) {
+  const att = asRecord(obj.attachment);
+  const attType = str(att.type);
+  if (attType !== "plan_mode" && attType !== "plan_mode_reentry" && attType !== "plan_mode_exit") {
+    return {};
+  }
+  return {
+    event: {
+      kind: attType === "plan_mode_exit" ? "plan_mode_exit" : "plan_mode",
+      sessionId: str(obj.sessionId) ?? file.sessionId ?? "unknown",
+      timestamp: parseTs(obj.timestamp),
+      filePath: file.path,
+      data: {}
+    }
+  };
+}
+function str(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function numOrU(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function parseTs(v) {
+  if (typeof v !== "string") return void 0;
+  const ts = Date.parse(v);
+  return Number.isFinite(ts) ? ts : void 0;
+}
+function asRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function compact(data) {
+  const out = {};
+  for (const [k, v] of Object.entries(data)) if (v !== void 0) out[k] = v;
+  return out;
+}
+
+// src/adapters/claude-code/adapter.ts
+var BATCH_LINES = 2e3;
+var ClaudeCodeAdapter = class {
+  kind = "claude-code";
+  detect(rootOverride) {
+    return detectClaudeRoot(rootOverride);
+  }
+  listLogFiles(rootDirs) {
+    return listLogFiles(rootDirs);
+  }
+  async *parseFile(file, fromOffset) {
+    let batch = emptyBatch(fromOffset);
+    for await (const line of iterateJsonlLines(file.path, fromOffset)) {
+      const outcome = parseLine(line.text, file);
+      batch.linesParsed++;
+      if (line.terminated) {
+        batch.bytesConsumed = line.endOffset;
+        if (outcome.turn) batch.turns.push(outcome.turn);
+        if (outcome.event) batch.events.push(outcome.event);
+        if (outcome.unknownType) {
+          batch.unknownTypes[outcome.unknownType] = (batch.unknownTypes[outcome.unknownType] ?? 0) + 1;
+        }
+        if (outcome.parseError) batch.parseErrors++;
+      } else {
+        if (outcome.turn) batch.turns.push(outcome.turn);
+      }
+      if (batch.linesParsed >= BATCH_LINES) {
+        yield batch;
+        batch = emptyBatch(batch.bytesConsumed);
+      }
+    }
+    yield batch;
+  }
+};
+function emptyBatch(offset) {
+  return {
+    turns: [],
+    events: [],
+    bytesConsumed: offset,
+    linesParsed: 0,
+    parseErrors: 0,
+    unknownTypes: {}
+  };
+}
+
+// src/cli/scan.ts
+async function scan(opts) {
+  const adapter = new ClaudeCodeAdapter();
+  const det = adapter.detect(opts.claudeDir);
+  if (!det.found) {
+    console.error(
+      pc5.red(
+        `No Claude Code data found at ${opts.claudeDir ?? "~/.claude/projects"}. Use --claude-dir to point at your Claude projects directory.`
+      )
+    );
+    process.exitCode = 1;
+    return null;
+  }
+  const t0 = performance.now();
+  const db = openDb(opts.db);
+  const store = new Store(db);
+  const result = {
+    files: 0,
+    skipped: 0,
+    newTurns: 0,
+    newEvents: 0,
+    parseErrors: 0,
+    unknownTypes: {},
+    seconds: 0
+  };
+  try {
+    const files = adapter.listLogFiles(det.rootDirs);
+    for (const file of files) {
+      const state = store.getFileState(file.path);
+      let fromOffset = 0;
+      if (opts.full) {
+        store.deleteFileData(file.path);
+      } else if (state) {
+        if (state.mtimeMs === file.mtimeMs && state.size === file.sizeBytes) {
+          result.skipped++;
+          continue;
+        }
+        if (file.sizeBytes >= state.byteOffset) {
+          fromOffset = state.byteOffset;
+        } else {
+          store.deleteFileData(file.path);
+        }
+      }
+      for await (const batch of adapter.parseFile(file, fromOffset)) {
+        const ingested = store.ingestBatch(file, batch);
+        result.newTurns += ingested.newTurns;
+        result.newEvents += ingested.newEvents;
+        result.parseErrors += batch.parseErrors;
+        for (const [k, v] of Object.entries(batch.unknownTypes)) {
+          result.unknownTypes[k] = (result.unknownTypes[k] ?? 0) + v;
+        }
+      }
+      result.files++;
+      if (opts.verbose) console.log(pc5.dim(`  ${file.kind.padEnd(8)} ${file.path}`));
+    }
+    store.bumpUnknownTypes(result.unknownTypes);
+  } finally {
+    db.close();
+  }
+  result.seconds = (performance.now() - t0) / 1e3;
+  if (!opts.silent) {
+    console.log(
+      `${pc5.bold("scan complete")} \u2014 ${result.files} file(s) parsed, ${result.skipped} unchanged, ${pc5.green(String(result.newTurns))} new assistant line(s), ${result.newEvents} event(s) in ${result.seconds.toFixed(1)}s`
+    );
+    if (result.parseErrors > 0) {
+      console.log(pc5.yellow(`  ${result.parseErrors} unparseable line(s) skipped`));
+    }
+    const unknown = Object.entries(result.unknownTypes);
+    if (unknown.length > 0) {
+      const summary = unknown.map(([k, v]) => `${k}\xD7${v}`).join(", ");
+      console.log(
+        pc5.yellow(`  unknown line type(s) skipped (parser may need an update): ${summary}`)
+      );
+    }
+  }
+  return result;
+}
+
+// src/cli/sync.ts
+import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5 } from "path";
+import pc6 from "picocolors";
+
+// src/lib/privacy.ts
+import { createHash } from "crypto";
+function projectIdOf(cwd) {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function projectNameOf(cwd) {
+  return cwd ? basename(cwd).slice(0, 120) : "unknown";
+}
+function toSyncTurn(t) {
+  return {
+    turnKey: t.messageId ?? t.uuid,
+    uuid: t.uuid,
+    messageId: t.messageId,
+    requestId: t.requestId,
+    sessionId: t.sessionId,
+    agentId: t.agentId,
+    parentSessionId: t.parentSessionId,
+    isSidechain: t.isSidechain,
+    projectId: projectIdOf(t.projectPath),
+    projectName: projectNameOf(t.projectPath),
+    slug: t.slug?.slice(0, 120),
+    ts: t.timestamp,
+    model: t.model.slice(0, 120),
+    usage: t.usage,
+    tools: t.tools.slice(0, 500).map((name) => name.slice(0, 100)),
+    numToolUses: t.numToolUses,
+    thinkingChars: t.thinkingChars,
+    textChars: t.textChars,
+    stopReason: t.stopReason?.slice(0, 60),
+    version: t.cliVersion?.slice(0, 40),
+    speed: t.speed?.slice(0, 20),
+    inferenceGeo: t.inferenceGeo?.slice(0, 20)
+  };
+}
+function toSyncEvent(id, e) {
+  return {
+    localEventId: id,
+    sessionId: e.sessionId,
+    ts: e.timestamp,
+    kind: e.kind,
+    data: e.data
+    // already whitelisted at parse time — never prompt/content
+  };
+}
+
+// src/cli/sync.ts
+function logFailure(err) {
+  try {
+    mkdirSync3(dataDir(), { recursive: true });
+    const line = `${(/* @__PURE__ */ new Date()).toISOString()} sync failed: ${err instanceof Error ? err.message : String(err)}
+`;
+    appendFileSync(join5(dataDir(), "sync.log"), line);
+  } catch {
+  }
+}
+async function sync(opts) {
+  const say = (msg) => {
+    if (!opts.quiet) console.log(msg);
+  };
+  try {
+    const creds = readCredentials();
+    if (!creds) {
+      if (opts.quiet) return null;
+      console.log(`Not logged in. Run ${pc6.bold("tktuner login")} first.`);
+      process.exitCode = 1;
+      return null;
+    }
+    const apiUrl = opts.api ?? creds.apiUrl;
+    if (!opts.noScan) {
+      await scan({ db: opts.db, claudeDir: opts.claudeDir, silent: opts.quiet });
+    }
+    const db = openDb(opts.db);
+    try {
+      const store = new Store(db);
+      const boundDevice = store.getMeta("sync_device_id");
+      const boundApi = store.getMeta("sync_api_url");
+      if (opts.full || boundDevice !== creds.deviceId || boundApi !== apiUrl) {
+        store.setMeta("sync_last_turn_rowid", "0");
+        store.setMeta("sync_last_event_id", "0");
+        store.setMeta("sync_device_id", creds.deviceId);
+        store.setMeta("sync_api_url", apiUrl);
+      }
+      const turnWm = Number(store.getMeta("sync_last_turn_rowid") ?? "0");
+      const eventWm = Number(store.getMeta("sync_last_event_id") ?? "0");
+      const { keys } = store.newTurnKeysSince(turnWm);
+      const groups = store.loadTurnGroups(keys);
+      const pendingEvents = store.eventsSince(eventWm);
+      if (opts.dryRun) {
+        say(
+          `${pc6.bold("dry run")} \u2014 would push ${pc6.green(String(groups.length))} turn(s) and ${pendingEvents.length} event(s) to ${apiUrl}`
+        );
+        for (const g of groups.slice(0, 2)) {
+          say(pc6.dim(JSON.stringify(toSyncTurn(g.turn), null, 2)));
+        }
+        return { turnsPushed: 0, eventsPushed: 0, batches: 0 };
+      }
+      if (groups.length === 0 && pendingEvents.length === 0) {
+        say(`${pc6.bold("sync")} \u2014 already up to date (${apiUrl})`);
+        return { turnsPushed: 0, eventsPushed: 0, batches: 0 };
+      }
+      const t0 = performance.now();
+      let turnCursor = 0;
+      let eventCursor = 0;
+      let turnsPushed = 0;
+      let eventsPushed = 0;
+      let batches = 0;
+      while (turnCursor < groups.length || eventCursor < pendingEvents.length) {
+        const turnBatch = groups.slice(turnCursor, turnCursor + SYNC_MAX_TURNS_PER_BATCH);
+        const eventBatch = pendingEvents.slice(
+          eventCursor,
+          eventCursor + SYNC_MAX_EVENTS_PER_BATCH
+        );
+        const eventWires = eventBatch.map((e) => toSyncEvent(e.id, e.event));
+        await apiCall("POST", apiUrl, "/v1/sync", {
+          token: creds.deviceToken,
+          gzip: true,
+          body: {
+            turns: turnBatch.map((g) => toSyncTurn(g.turn)),
+            events: eventWires,
+            cliVersion: CLI_VERSION
+          }
+        });
+        if (turnBatch.length > 0) {
+          const maxRowid = turnBatch[turnBatch.length - 1]?.maxRowid ?? turnWm;
+          store.setMeta("sync_last_turn_rowid", String(maxRowid));
+        }
+        if (eventBatch.length > 0) {
+          const maxId = eventBatch[eventBatch.length - 1]?.id ?? eventWm;
+          store.setMeta("sync_last_event_id", String(maxId));
+        }
+        turnCursor += turnBatch.length;
+        eventCursor += eventBatch.length;
+        turnsPushed += turnBatch.length;
+        eventsPushed += eventWires.length;
+        batches++;
+      }
+      const seconds = ((performance.now() - t0) / 1e3).toFixed(1);
+      say(
+        `${pc6.bold("sync complete")} \u2014 ${pc6.green(String(turnsPushed))} turn(s), ${eventsPushed} event(s) in ${batches} batch(es), ${seconds}s \u2192 ${apiUrl}`
+      );
+      return { turnsPushed, eventsPushed, batches };
+    } finally {
+      db.close();
+    }
+  } catch (err) {
+    if (opts.quiet) {
+      logFailure(err);
+      return null;
+    }
+    console.error(pc6.red(err instanceof Error ? err.message : String(err)));
+    process.exitCode = 1;
+    return null;
+  }
+}
+
+// src/cli/whoami.ts
+import pc7 from "picocolors";
+async function whoami(opts) {
+  const creds = readCredentials();
+  if (!creds) {
+    console.log(`Not logged in. Run ${pc7.bold("tktuner login")}.`);
+    return;
+  }
+  try {
+    const status = await apiCall("GET", creds.apiUrl, "/v1/sync/status", {
+      token: creds.deviceToken
+    });
+    console.log(`${pc7.bold(String(status.email))} \xB7 device ${creds.deviceName} \u2192 ${creds.apiUrl}`);
+    console.log(
+      `server: ${pc7.bold(String(status.serverTurnCount))} turns \xB7 last sync ${status.lastSyncedAt ? String(status.lastSyncedAt) : "never"}`
+    );
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 401) {
+      console.error(pc7.red(`Device token was revoked. Run ${pc7.bold("tktuner login")} again.`));
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
+  }
+  const db = openDb(opts.db);
+  try {
+    const store = new Store(db);
+    const wm = store.getMeta("sync_last_turn_rowid") ?? "0";
+    console.log(`local: ${store.countTurns()} turns \xB7 sync watermark @ row ${wm}`);
+  } finally {
+    db.close();
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("tktuner").description(
+  "Local-first token usage analytics for Claude Code power users.\nScans ~/.claude/projects session logs and shows where you waste tokens and quota."
+).version(CLI_VERSION);
+program.command("scan").description("Incrementally parse Claude Code session logs into the local database").option("--claude-dir <path>", "Claude projects directory (default: ~/.claude/projects)").option("--db <path>", "database file (default: ~/.local/share/tktuner/tktuner.db)").option("--full", "ignore incremental state and reparse every file").option("--verbose", "print each file as it is parsed").action(async (opts) => {
+  await scan(opts);
+});
+program.command("report").description("Analyze scanned data: cost by model/phase, waste, cache health, quota pressure").option("--days <n>", "analysis window in days", "30").option("--all", "analyze the entire history").option("--project <filter>", "only sessions whose project name contains this substring").option("--json", "machine-readable JSON output").option("--no-color", "disable colors").option("--db <path>", "database file (default: ~/.local/share/tktuner/tktuner.db)").option("--prices <path>", "JSON file overriding the bundled model price table").option("--debug-session <id>", "per-turn phase breakdown for one session (id or slug prefix)").action(async (opts) => {
+  await report(opts);
+});
+program.command("login").description("Connect this machine to your tktuner.com account (device flow)").option("--api <url>", "API base URL (default: https://tktuner.com)").action(async (opts) => {
+  await login(opts);
+});
+program.command("logout").description("Disconnect this machine and delete local credentials").action(async () => {
+  await logout();
+});
+program.command("whoami").description("Show the connected account, device and sync state").option("--db <path>", "database file (default: ~/.local/share/tktuner/tktuner.db)").action(async (opts) => {
+  await whoami(opts);
+});
+program.command("sync").description("Scan locally, then upload new usage metadata (never content) to your dashboard").option("--quiet", "no output, always exit 0 (for the SessionEnd hook)").option("--full", "re-push the entire local database (idempotent server-side)").option("--dry-run", "show what would be uploaded without sending anything").option("--no-scan", "skip the local scan step").option("--db <path>", "database file (default: ~/.local/share/tktuner/tktuner.db)").option("--claude-dir <path>", "Claude projects directory (default: ~/.claude/projects)").option("--api <url>", "override the API base URL from credentials").action(async (opts) => {
+  await sync({ ...opts, noScan: opts.scan === false });
+});
+var hook = program.command("hook").description("Manage the opt-in Claude Code SessionEnd hook (auto-sync when a session ends)");
+hook.command("install").description("Add the SessionEnd hook to ~/.claude/settings.json (merge-safe, backed up)").option("--yes", "skip the confirmation prompt").action(async (opts) => {
+  const { hookInstall } = await import("./hook-QKTYBOHD.js");
+  await hookInstall(opts);
+});
+hook.command("uninstall").description("Remove only tktuner's hook entry, leaving everything else untouched").action(async () => {
+  const { hookUninstall } = await import("./hook-QKTYBOHD.js");
+  await hookUninstall();
+});
+hook.command("status").description("Show whether the auto-sync hook is installed").action(async () => {
+  const { hookStatus } = await import("./hook-QKTYBOHD.js");
+  hookStatus();
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map