kerf-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1704 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/watch.ts
+import React2 from "react";
+import { render } from "ink";
+
+// src/core/parser.ts
+import { readFileSync, statSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join as join2, basename } from "node:path";
+import dayjs from "dayjs";
+import { watch } from "chokidar";
+
+// src/core/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_CONFIG = {
+  defaultModel: "sonnet",
+  budgetWarningThreshold: 80,
+  budgetBlockThreshold: 100,
+  pollingInterval: 2e3,
+  dataDir: join(homedir(), ".kerf"),
+  enableHooks: true
+};
+var CONTEXT_WINDOW_SIZE = 2e5;
+var SYSTEM_PROMPT_TOKENS = 14328;
+var BUILT_IN_TOOLS_TOKENS = 15e3;
+var AUTOCOMPACT_BUFFER_TOKENS = 33e3;
+var MCP_TOKENS_PER_TOOL = 600;
+var BILLING_WINDOW_HOURS = 5;
+var CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
+var CLAUDE_SETTINGS_GLOBAL = join(homedir(), ".claude", "settings.json");
+var KERF_DB_PATH = join(homedir(), ".kerf", "kerf.db");
+var KERF_SESSION_LOG = join(homedir(), ".kerf", "session-log.jsonl");
+
+// src/core/parser.ts
+function extractUsage(raw) {
+  return raw.message?.usage ?? raw.usage ?? raw.delta?.usage ?? null;
+}
+function extractMessageId(raw) {
+  return raw.message?.id ?? null;
+}
+function extractModel(raw) {
+  return raw.message?.model ?? null;
+}
+function extractTimestamp(raw) {
+  return raw.timestamp ?? dayjs().toISOString();
+}
+function parseJsonlLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function parseJsonlContent(content, sessionId) {
+  const lines = content.split("\n");
+  const messageMap = /* @__PURE__ */ new Map();
+  let anonymousCounter = 0;
+  for (const line of lines) {
+    const raw = parseJsonlLine(line);
+    if (!raw) continue;
+    const usage = extractUsage(raw);
+    if (!usage) continue;
+    const id = extractMessageId(raw) ?? `anon_${anonymousCounter++}`;
+    const model = extractModel(raw) ?? "unknown";
+    const timestamp = extractTimestamp(raw);
+    const existing = messageMap.get(id);
+    const parsedUsage = {
+      input_tokens: usage.input_tokens ?? existing?.usage.input_tokens ?? 0,
+      output_tokens: usage.output_tokens ?? existing?.usage.output_tokens ?? 0,
+      cache_creation_input_tokens: usage.cache_creation_input_tokens ?? existing?.usage.cache_creation_input_tokens ?? 0,
+      cache_read_input_tokens: usage.cache_read_input_tokens ?? existing?.usage.cache_read_input_tokens ?? 0
+    };
+    messageMap.set(id, {
+      id,
+      model: model !== "unknown" ? model : existing?.model ?? "unknown",
+      timestamp,
+      usage: parsedUsage,
+      totalCostUsd: raw.total_cost_usd ?? existing?.totalCostUsd ?? null
+    });
+  }
+  return Array.from(messageMap.values());
+}
+function parseSessionFile(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  const sessionId = basename(filePath, ".jsonl");
+  const messages = parseJsonlContent(content, sessionId);
+  const totals = messages.reduce(
+    (acc, msg) => ({
+      input: acc.input + msg.usage.input_tokens,
+      output: acc.output + msg.usage.output_tokens,
+      cacheRead: acc.cacheRead + msg.usage.cache_read_input_tokens,
+      cacheCreation: acc.cacheCreation + msg.usage.cache_creation_input_tokens,
+      cost: acc.cost + (msg.totalCostUsd ?? 0)
+    }),
+    { input: 0, output: 0, cacheRead: 0, cacheCreation: 0, cost: 0 }
+  );
+  const timestamps = messages.map((m) => m.timestamp).sort();
+  return {
+    sessionId,
+    filePath,
+    messages,
+    totalInputTokens: totals.input,
+    totalOutputTokens: totals.output,
+    totalCacheReadTokens: totals.cacheRead,
+    totalCacheCreationTokens: totals.cacheCreation,
+    totalCostUsd: totals.cost,
+    startTime: timestamps[0] ?? "",
+    endTime: timestamps[timestamps.length - 1] ?? "",
+    messageCount: messages.length
+  };
+}
+async function findJsonlFiles(baseDir) {
+  const dir = baseDir ?? CLAUDE_PROJECTS_DIR;
+  const files = [];
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join2(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.name.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+async function getActiveSessions(baseDir) {
+  const files = await findJsonlFiles(baseDir);
+  const cutoff = dayjs().subtract(BILLING_WINDOW_HOURS, "hour");
+  const activeSessions = [];
+  for (const filePath of files) {
+    try {
+      const stat = statSync(filePath);
+      const lastModified = dayjs(stat.mtime);
+      if (lastModified.isAfter(cutoff)) {
+        const content = readFileSync(filePath, "utf-8");
+        const sessionId = basename(filePath, ".jsonl");
+        const messages = parseJsonlContent(content, sessionId);
+        if (messages.length === 0) continue;
+        const timestamps = messages.map((m) => m.timestamp).sort();
+        activeSessions.push({
+          sessionId,
+          filePath,
+          messages,
+          startTime: timestamps[0] ?? "",
+          endTime: timestamps[timestamps.length - 1] ?? "",
+          lastModified: stat.mtime
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return activeSessions.sort(
+    (a, b) => b.lastModified.getTime() - a.lastModified.getTime()
+  );
+}
+
+// src/cli/ui/Dashboard.tsx
+import { useState, useEffect } from "react";
+import { Box as Box3, Text as Text3, useInput, useApp } from "ink";
+
+// src/cli/ui/CostMeter.tsx
+import { Box, Text } from "ink";
+
+// src/core/costCalculator.ts
+import dayjs2 from "dayjs";
+import isoWeek from "dayjs/plugin/isoWeek.js";
+dayjs2.extend(isoWeek);
+var MODEL_PRICING = {
+  "claude-sonnet-4-20250514": {
+    input: 3,
+    output: 15,
+    cacheRead: 0.3,
+    cacheCreation: 3.75
+  },
+  "claude-opus-4-20250514": {
+    input: 15,
+    output: 75,
+    cacheRead: 1.5,
+    cacheCreation: 18.75
+  },
+  "claude-haiku-4-20250514": {
+    input: 0.8,
+    output: 4,
+    cacheRead: 0.08,
+    cacheCreation: 1
+  }
+};
+var MODEL_ALIASES = {
+  sonnet: "claude-sonnet-4-20250514",
+  opus: "claude-opus-4-20250514",
+  haiku: "claude-haiku-4-20250514"
+};
+function resolveModelPricing(model) {
+  const resolved = MODEL_ALIASES[model] ?? model;
+  if (MODEL_PRICING[resolved]) return MODEL_PRICING[resolved];
+  const match = Object.keys(MODEL_PRICING).find((k) => resolved.startsWith(k) || k.startsWith(resolved));
+  if (match) return MODEL_PRICING[match];
+  return MODEL_PRICING["claude-sonnet-4-20250514"];
+}
+function calculateMessageCost(msg) {
+  if (msg.totalCostUsd !== null && msg.totalCostUsd > 0) {
+    return {
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreationCost: 0,
+      totalCost: msg.totalCostUsd
+    };
+  }
+  const pricing = resolveModelPricing(msg.model);
+  const MILLION = 1e6;
+  const inputCost = msg.usage.input_tokens * pricing.input / MILLION;
+  const outputCost = msg.usage.output_tokens * pricing.output / MILLION;
+  const cacheReadCost = msg.usage.cache_read_input_tokens * pricing.cacheRead / MILLION;
+  const cacheCreationCost = msg.usage.cache_creation_input_tokens * pricing.cacheCreation / MILLION;
+  return {
+    inputCost,
+    outputCost,
+    cacheReadCost,
+    cacheCreationCost,
+    totalCost: inputCost + outputCost + cacheReadCost + cacheCreationCost
+  };
+}
+function calculateCostVelocity(messages) {
+  if (messages.length < 2) {
+    return { dollarsPerMinute: 0, tokensPerMinute: 0, projectedWindowCost: 0, minutesRemaining: 0 };
+  }
+  const recent = messages.slice(-10);
+  const firstTime = dayjs2(recent[0].timestamp);
+  const lastTime = dayjs2(recent[recent.length - 1].timestamp);
+  const durationMinutes = lastTime.diff(firstTime, "minute", true);
+  if (durationMinutes <= 0) {
+    return { dollarsPerMinute: 0, tokensPerMinute: 0, projectedWindowCost: 0, minutesRemaining: 0 };
+  }
+  let totalCost = 0;
+  let totalTokens = 0;
+  for (const msg of recent) {
+    totalCost += calculateMessageCost(msg).totalCost;
+    totalTokens += msg.usage.input_tokens + msg.usage.output_tokens;
+  }
+  const dollarsPerMinute = totalCost / durationMinutes;
+  const tokensPerMinute = totalTokens / durationMinutes;
+  const windowMinutes = BILLING_WINDOW_HOURS * 60;
+  const projectedWindowCost = dollarsPerMinute * windowMinutes;
+  const windowStart = dayjs2().subtract(BILLING_WINDOW_HOURS, "hour");
+  const elapsed = dayjs2().diff(windowStart, "minute", true);
+  const minutesRemaining = Math.max(0, windowMinutes - elapsed);
+  return { dollarsPerMinute, tokensPerMinute, projectedWindowCost, minutesRemaining };
+}
+function aggregateCosts(messages, period) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const key = getPeriodKey(msg.timestamp, period);
+    const group = groups.get(key) ?? { messages: [], sessions: /* @__PURE__ */ new Set() };
+    group.messages.push(msg);
+    group.sessions.add(msg.id.split("_")[0] ?? msg.id);
+    groups.set(key, group);
+  }
+  return Array.from(groups.entries()).map(([key, group]) => {
+    let totalCost = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    for (const msg of group.messages) {
+      totalCost += calculateMessageCost(msg).totalCost;
+      totalInput += msg.usage.input_tokens;
+      totalOutput += msg.usage.output_tokens;
+    }
+    return {
+      period: key,
+      periodLabel: formatPeriodLabel(key, period),
+      totalCost,
+      totalInputTokens: totalInput,
+      totalOutputTokens: totalOutput,
+      messageCount: group.messages.length,
+      sessionCount: group.sessions.size
+    };
+  });
+}
+function getPeriodKey(timestamp, period) {
+  const d = dayjs2(timestamp);
+  switch (period) {
+    case "hour":
+      return d.format("YYYY-MM-DD-HH");
+    case "day":
+      return d.format("YYYY-MM-DD");
+    case "billing_window":
+      const hour = d.hour();
+      const windowStart = Math.floor(hour / BILLING_WINDOW_HOURS) * BILLING_WINDOW_HOURS;
+      return `${d.format("YYYY-MM-DD")}-W${windowStart}`;
+    case "week":
+      return `${d.isoWeekYear()}-W${String(d.isoWeek()).padStart(2, "0")}`;
+    case "month":
+      return d.format("YYYY-MM");
+    case "session":
+    default:
+      return timestamp;
+  }
+}
+function formatPeriodLabel(key, period) {
+  switch (period) {
+    case "hour":
+      return dayjs2(key, "YYYY-MM-DD-HH").format("MMM D, h A");
+    case "day":
+      return dayjs2(key).format("ddd, MMM D");
+    case "week":
+      return `Week ${key.split("-W")[1]}`;
+    case "month":
+      return dayjs2(key).format("MMMM YYYY");
+    default:
+      return key;
+  }
+}
+function formatCost(cost) {
+  return `$${cost.toFixed(2)}`;
+}
+function formatTokens(tokens) {
+  if (tokens >= 1e6) return `${(tokens / 1e6).toFixed(1)}M`;
+  if (tokens >= 1e3) return `${(tokens / 1e3).toFixed(1)}K`;
+  return String(tokens);
+}
+
+// src/cli/ui/CostMeter.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function CostMeter({ spent, windowBudget, burnRate, minutesRemaining, model }) {
+  const pct = windowBudget > 0 ? spent / windowBudget * 100 : 0;
+  const color = pct < 50 ? "green" : pct < 80 ? "yellow" : "red";
+  const hours = Math.floor(minutesRemaining / 60);
+  const mins = Math.round(minutesRemaining % 60);
+  const timeStr = hours > 0 ? `${hours}h ${mins}m` : `${mins}m`;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color, children: ">> " }),
+    /* @__PURE__ */ jsx(Text, { bold: true, children: formatCost(spent) }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      " / ~",
+      formatCost(windowBudget),
+      " window"
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: " | " }),
+    /* @__PURE__ */ jsxs(Text, { color, children: [
+      formatCost(burnRate),
+      "/min"
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: " | " }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "~",
+      timeStr,
+      " remaining"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      " [",
+      model,
+      "]"
+    ] })
+  ] }) });
+}
+
+// src/cli/ui/ContextBar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ContextBar({ used, total, overhead }) {
+  const barWidth = 30;
+  const usedPct = total > 0 ? used / total * 100 : 0;
+  const filledCount = Math.round(usedPct / 100 * barWidth);
+  const emptyCount = barWidth - filledCount;
+  const color = usedPct < 50 ? "green" : usedPct < 80 ? "yellow" : "red";
+  const filled = "\u2588".repeat(filledCount);
+  const empty = "\u2591".repeat(emptyCount);
+  const formatK = (n) => `${Math.round(n / 1e3)}K`;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { children: "[" }),
+      /* @__PURE__ */ jsx2(Text2, { color, children: filled }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: empty }),
+      /* @__PURE__ */ jsx2(Text2, { children: "]" }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        " ",
+        usedPct.toFixed(0),
+        "%"
+      ] }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        " | ",
+        formatK(used),
+        " / ",
+        formatK(total),
+        " tokens"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "  ",
+      "system(",
+      formatK(overhead.systemPrompt),
+      ") + tools(",
+      formatK(overhead.builtInTools),
+      ") + mcp(",
+      formatK(overhead.mcpTools),
+      ") + claude.md(",
+      formatK(overhead.claudeMd),
+      ")"
+    ] })
+  ] });
+}
+
+// src/core/tokenCounter.ts
+import { readFileSync as readFileSync2, existsSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+function estimateTokens(text) {
+  return Math.ceil(text.length / 3.5);
+}
+function countFileTokens(filePath) {
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    return estimateTokens(content);
+  } catch {
+    return 0;
+  }
+}
+function parseClaudeMdSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentTitle = "Preamble";
+  let currentContent = [];
+  let currentLineStart = 1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      if (currentContent.length > 0 || currentTitle !== "Preamble") {
+        const sectionContent = currentContent.join("\n");
+        sections.push({
+          title: currentTitle,
+          content: sectionContent,
+          tokens: estimateTokens(sectionContent),
+          lineStart: currentLineStart,
+          lineEnd: i
+        });
+      }
+      currentTitle = line.replace(/^##\s*/, "");
+      currentContent = [];
+      currentLineStart = i + 1;
+    } else {
+      currentContent.push(line);
+    }
+  }
+  if (currentContent.length > 0) {
+    const sectionContent = currentContent.join("\n");
+    sections.push({
+      title: currentTitle,
+      content: sectionContent,
+      tokens: estimateTokens(sectionContent),
+      lineStart: currentLineStart,
+      lineEnd: lines.length
+    });
+  }
+  return sections;
+}
+function analyzeClaudeMd(filePath) {
+  const paths = filePath ? [filePath] : [
+    join3(process.cwd(), "CLAUDE.md"),
+    join3(process.cwd(), ".claude", "CLAUDE.md")
+  ];
+  for (const p of paths) {
+    if (existsSync(p)) {
+      const content = readFileSync2(p, "utf-8");
+      const sections = parseClaudeMdSections(content);
+      const totalTokens = sections.reduce((sum, s) => sum + s.tokens, 0);
+      const heavySections = sections.filter((s) => s.tokens > 500);
+      return { totalTokens, sections, heavySections };
+    }
+  }
+  return { totalTokens: 0, sections: [], heavySections: [] };
+}
+function analyzeMcpServers() {
+  const servers = [];
+  const paths = [
+    join3(process.cwd(), ".mcp.json"),
+    join3(homedir2(), ".claude.json")
+  ];
+  for (const configPath of paths) {
+    if (!existsSync(configPath)) continue;
+    try {
+      const raw = JSON.parse(readFileSync2(configPath, "utf-8"));
+      const mcpServers = raw.mcpServers ?? raw.mcp_servers ?? {};
+      for (const [name, config] of Object.entries(mcpServers)) {
+        const cfg = config;
+        const tools = Array.isArray(cfg.tools) ? cfg.tools : [];
+        const toolCount = tools.length || 5;
+        const estimatedTokens = toolCount * MCP_TOKENS_PER_TOOL;
+        servers.push({
+          name,
+          toolCount,
+          estimatedTokens,
+          isHeavy: toolCount > 10
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return servers;
+}
+function estimateContextOverhead(claudeMdPath) {
+  const claudeMd = analyzeClaudeMd(claudeMdPath);
+  const mcpServers = analyzeMcpServers();
+  const mcpToolTokens = mcpServers.reduce((sum, s) => sum + s.estimatedTokens, 0);
+  const totalOverhead = SYSTEM_PROMPT_TOKENS + BUILT_IN_TOOLS_TOKENS + mcpToolTokens + claudeMd.totalTokens + AUTOCOMPACT_BUFFER_TOKENS;
+  const effectiveWindow = CONTEXT_WINDOW_SIZE - totalOverhead;
+  const percentUsable = effectiveWindow / CONTEXT_WINDOW_SIZE * 100;
+  return {
+    systemPrompt: SYSTEM_PROMPT_TOKENS,
+    builtInTools: BUILT_IN_TOOLS_TOKENS,
+    claudeMd: claudeMd.totalTokens,
+    mcpTools: mcpToolTokens,
+    autocompactBuffer: AUTOCOMPACT_BUFFER_TOKENS,
+    totalOverhead,
+    effectiveWindow,
+    percentUsable
+  };
+}
+
+// src/cli/ui/Dashboard.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Dashboard({ sessionFilePath, interval }) {
+  const { exit } = useApp();
+  const [session, setSession] = useState(null);
+  const [overhead, setOverhead] = useState(estimateContextOverhead());
+  const [showBudget, setShowBudget] = useState(false);
+  useEffect(() => {
+    function refresh() {
+      try {
+        const parsed = parseSessionFile(sessionFilePath);
+        setSession(parsed);
+        setOverhead(estimateContextOverhead());
+      } catch {
+      }
+    }
+    refresh();
+    const timer = setInterval(refresh, interval);
+    return () => clearInterval(timer);
+  }, [sessionFilePath, interval]);
+  useInput((input) => {
+    if (input === "q") exit();
+    if (input === "b") setShowBudget((prev) => !prev);
+  });
+  if (!session || session.messages.length === 0) {
+    return /* @__PURE__ */ jsx3(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Waiting for session data..." }) });
+  }
+  const totalCost = session.messages.reduce(
+    (sum, msg) => sum + calculateMessageCost(msg).totalCost,
+    0
+  );
+  const velocity = calculateCostVelocity(session.messages);
+  const model = session.messages[session.messages.length - 1]?.model ?? "unknown";
+  const windowBudget = velocity.projectedWindowCost || totalCost * 3;
+  const totalInput = session.totalInputTokens + session.totalCacheReadTokens;
+  const usedTokens = totalInput + session.totalOutputTokens;
+  const recentMessages = session.messages.slice(-8);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box3, { borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: "kerf watch" }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        " | session: ",
+        session.sessionId.slice(0, 8),
+        "..."
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        " | ",
+        session.messageCount,
+        " messages"
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " (q=quit, b=budget)" })
+    ] }),
+    /* @__PURE__ */ jsx3(
+      CostMeter,
+      {
+        spent: totalCost,
+        windowBudget,
+        burnRate: velocity.dollarsPerMinute,
+        minutesRemaining: velocity.minutesRemaining,
+        model
+      }
+    ),
+    /* @__PURE__ */ jsx3(ContextBar, { used: usedTokens, total: CONTEXT_WINDOW_SIZE, overhead }),
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Recent Messages:" }),
+      recentMessages.map((msg, i) => {
+        const cost = calculateMessageCost(msg);
+        return /* @__PURE__ */ jsxs3(Text3, { children: [
+          /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: msg.timestamp.slice(11, 19) }),
+          /* @__PURE__ */ jsxs3(Text3, { children: [
+            " ",
+            formatTokens(msg.usage.input_tokens + msg.usage.output_tokens),
+            " tok"
+          ] }),
+          /* @__PURE__ */ jsxs3(Text3, { color: "yellow", children: [
+            " ",
+            formatCost(cost.totalCost)
+          ] })
+        ] }, i);
+      })
+    ] })
+  ] });
+}
+
+// src/cli/commands/watch.ts
+function registerWatchCommand(program2) {
+  program2.command("watch").description("Real-time cost dashboard (default)").option("-s, --session <id>", "Watch a specific session").option("-p, --project <path>", "Watch sessions for a specific project").option("-i, --interval <ms>", "Polling interval in ms", "2000").option("--no-color", "Disable colors").action(async (opts) => {
+    const interval = parseInt(opts.interval, 10);
+    let sessionFilePath;
+    if (opts.session) {
+      const sessions = await getActiveSessions(opts.project);
+      const found = sessions.find((s) => s.sessionId.startsWith(opts.session));
+      sessionFilePath = found?.filePath;
+    } else {
+      const sessions = await getActiveSessions(opts.project);
+      sessionFilePath = sessions[0]?.filePath;
+    }
+    if (!sessionFilePath) {
+      console.log(
+        "No active Claude Code session found. Start Claude Code and run 'kerf watch' again."
+      );
+      process.exit(0);
+    }
+    const { waitUntilExit } = render(
+      React2.createElement(Dashboard, { sessionFilePath, interval })
+    );
+    await waitUntilExit();
+  });
+}
+
+// src/cli/commands/estimate.ts
+import React3 from "react";
+import { render as render2 } from "ink";
+import { glob as glob2 } from "glob";
+
+// src/core/estimator.ts
+import { glob } from "glob";
+var COMPLEXITY_PROFILES = {
+  simple: { turns: { low: 2, expected: 3, high: 5 }, outputTokensPerTurn: 1e3 },
+  medium: { turns: { low: 5, expected: 10, high: 15 }, outputTokensPerTurn: 2e3 },
+  complex: { turns: { low: 15, expected: 25, high: 40 }, outputTokensPerTurn: 2500 }
+};
+var SIMPLE_KEYWORDS = ["typo", "rename", "fix typo", "update version", "change name", "remove unused", "delete"];
+var COMPLEX_KEYWORDS = ["refactor", "rewrite", "new module", "implement", "build", "create", "migrate", "redesign", "overhaul", "architecture"];
+function detectComplexity(taskDescription) {
+  const lower = taskDescription.toLowerCase();
+  if (SIMPLE_KEYWORDS.some((k) => lower.includes(k))) return "simple";
+  if (COMPLEX_KEYWORDS.some((k) => lower.includes(k))) return "complex";
+  return "medium";
+}
+async function estimateTaskCost(taskDescription, options = {}) {
+  const model = options.model ?? "sonnet";
+  const cwd = options.cwd ?? process.cwd();
+  const pricing = resolveModelPricing(model);
+  const MILLION = 1e6;
+  const overhead = estimateContextOverhead();
+  let fileTokens = 0;
+  let fileList = options.files ?? [];
+  if (fileList.length === 0) {
+    try {
+      const { execSync } = await import("node:child_process");
+      const output = execSync("git diff --name-only HEAD 2>/dev/null || git ls-files -m 2>/dev/null", {
+        cwd,
+        encoding: "utf-8"
+      });
+      fileList = output.split("\n").filter(Boolean).map((f) => `${cwd}/${f}`);
+    } catch {
+    }
+  }
+  for (const filePattern of fileList) {
+    const matched = await glob(filePattern, { cwd, absolute: true });
+    for (const f of matched) {
+      fileTokens += countFileTokens(f);
+    }
+  }
+  const complexity = detectComplexity(taskDescription);
+  const profile = COMPLEXITY_PROFILES[complexity];
+  const contextPerTurn = overhead.totalOverhead + fileTokens;
+  const CACHE_HIT_RATE = 0.9;
+  function estimateCostForTurns(turns) {
+    let totalCost = 0;
+    for (let turn = 1; turn <= turns; turn++) {
+      const conversationGrowth = (turn - 1) * profile.outputTokensPerTurn;
+      const inputTokens = contextPerTurn + conversationGrowth;
+      let effectiveInputCost;
+      if (turn <= 2) {
+        effectiveInputCost = inputTokens * pricing.input / MILLION;
+      } else {
+        const cachedTokens = inputTokens * CACHE_HIT_RATE;
+        const uncachedTokens = inputTokens * (1 - CACHE_HIT_RATE);
+        effectiveInputCost = cachedTokens * pricing.cacheRead / MILLION + uncachedTokens * pricing.input / MILLION;
+      }
+      const outputCost = profile.outputTokensPerTurn * pricing.output / MILLION;
+      totalCost += effectiveInputCost + outputCost;
+    }
+    return totalCost;
+  }
+  const lowCost = estimateCostForTurns(profile.turns.low);
+  const expectedCost = estimateCostForTurns(profile.turns.expected);
+  const highCost = estimateCostForTurns(profile.turns.high);
+  const expectedInputTokens = contextPerTurn * profile.turns.expected;
+  const expectedOutputTokens = profile.outputTokensPerTurn * profile.turns.expected;
+  const expectedCachedTokens = expectedInputTokens * CACHE_HIT_RATE;
+  const windowMinutes = BILLING_WINDOW_HOURS * 60;
+  const percentOfWindow = expectedCost / (expectedCost * 3) * 100;
+  const recommendations = [];
+  if (model !== "sonnet") {
+    const sonnetPricing = resolveModelPricing("sonnet");
+    const sonnetCost = estimateCostForTurns(profile.turns.expected);
+    const ratio = pricing.output / resolveModelPricing("sonnet").output;
+    if (ratio > 2) {
+      recommendations.push(
+        `Consider Sonnet to save ~${formatCost(expectedCost - expectedCost / ratio)} (${ratio.toFixed(0)}x cheaper)`
+      );
+    }
+  }
+  if (model === "sonnet") {
+    const opusPricing = resolveModelPricing("opus");
+    const ratio = opusPricing.output / pricing.output;
+    recommendations.push(`Using Opus would cost ~${formatCost(expectedCost * ratio)} (${ratio.toFixed(0)}x more)`);
+  }
+  if (overhead.percentUsable < 60) {
+    recommendations.push(`High ghost token overhead (${(100 - overhead.percentUsable).toFixed(0)}%). Run 'kerf audit' to optimize.`);
+  }
+  if (fileTokens > 5e4) {
+    recommendations.push(`Large file context (${(fileTokens / 1e3).toFixed(0)}K tokens). Consider narrowing scope.`);
+  }
+  return {
+    model,
+    estimatedTurns: profile.turns,
+    estimatedTokens: {
+      input: Math.round(expectedInputTokens),
+      output: Math.round(expectedOutputTokens),
+      cached: Math.round(expectedCachedTokens)
+    },
+    estimatedCost: {
+      low: formatCost(lowCost),
+      expected: formatCost(expectedCost),
+      high: formatCost(highCost)
+    },
+    contextOverhead: overhead.totalOverhead,
+    fileTokens,
+    percentOfWindow: Math.round(percentOfWindow),
+    recommendations
+  };
+}
+
+// src/cli/ui/EstimateCard.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function EstimateCard({ task, estimate }) {
+  const formatK = (n) => `${(n / 1e3).toFixed(1)}K`;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "cyan", children: [
+      "kerf estimate: '",
+      task,
+      "'"
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      "Model: ",
+      /* @__PURE__ */ jsx4(Text4, { bold: true, children: estimate.model })
+    ] }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      "Estimated turns: ",
+      estimate.estimatedTurns.low,
+      "-",
+      estimate.estimatedTurns.high,
+      " (expected:",
+      " ",
+      estimate.estimatedTurns.expected,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      "Files: ",
+      formatK(estimate.fileTokens),
+      " tokens"
+    ] }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      "Context overhead: ",
+      formatK(estimate.contextOverhead),
+      " tokens (ghost tokens)"
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Estimated Cost:" }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      "  ",
+      "Low:      ",
+      /* @__PURE__ */ jsx4(Text4, { color: "green", children: estimate.estimatedCost.low })
+    ] }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      "  ",
+      "Expected: ",
+      /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: estimate.estimatedCost.expected })
+    ] }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      "  ",
+      "High:     ",
+      /* @__PURE__ */ jsx4(Text4, { color: "red", children: estimate.estimatedCost.high })
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      "Window Usage: ~",
+      estimate.percentOfWindow,
+      "% of 5-hour window"
+    ] }),
+    estimate.recommendations.map((rec, i) => /* @__PURE__ */ jsxs4(Text4, { color: "cyan", children: [
+      "  -> ",
+      rec
+    ] }, i))
+  ] });
+}
+
+// src/cli/commands/estimate.ts
+function registerEstimateCommand(program2) {
+  program2.command("estimate <task>").description("Pre-flight cost estimation").option("-m, --model <model>", "Model to estimate for", "sonnet").option("-f, --files <glob>", "Specific files that will be touched").option("--compare", "Show Sonnet vs Opus vs Haiku comparison").option("--json", "Output as JSON").action(async (task, opts) => {
+    const files = [];
+    if (opts.files) {
+      const matched = await glob2(opts.files, { absolute: true });
+      files.push(...matched);
+    }
+    if (opts.compare) {
+      const models = ["sonnet", "opus", "haiku"];
+      for (const model of models) {
+        const estimate2 = await estimateTaskCost(task, { model, files, cwd: process.cwd() });
+        if (opts.json) {
+          console.log(JSON.stringify(estimate2, null, 2));
+        } else {
+          const { waitUntilExit: waitUntilExit2 } = render2(
+            React3.createElement(EstimateCard, { task, estimate: estimate2 })
+          );
+          await waitUntilExit2();
+        }
+      }
+      return;
+    }
+    const estimate = await estimateTaskCost(task, {
+      model: opts.model,
+      files,
+      cwd: process.cwd()
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(estimate, null, 2));
+      return;
+    }
+    const { waitUntilExit } = render2(
+      React3.createElement(EstimateCard, { task, estimate })
+    );
+    await waitUntilExit();
+  });
+}
+
+// src/cli/commands/budget.ts
+import chalk from "chalk";
+
+// src/core/budgetManager.ts
+import dayjs3 from "dayjs";
+import isoWeek2 from "dayjs/plugin/isoWeek.js";
+import { basename as basename2 } from "node:path";
+
+// src/db/schema.ts
+import Database from "better-sqlite3";
+import { mkdirSync, existsSync as existsSync2 } from "node:fs";
+import { dirname } from "node:path";
+function initDatabase(dbPath) {
+  const path = dbPath ?? KERF_DB_PATH;
+  const dir = dirname(path);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  createTables(db);
+  return db;
+}
+function createTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL UNIQUE,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS budgets (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      amount_usd REAL NOT NULL,
+      period TEXT NOT NULL CHECK (period IN ('daily', 'weekly', 'monthly')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(project_id, period)
+    );
+
+    CREATE TABLE IF NOT EXISTS usage_snapshots (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      session_id TEXT NOT NULL,
+      tokens_in INTEGER NOT NULL DEFAULT 0,
+      tokens_out INTEGER NOT NULL DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      timestamp TEXT NOT NULL,
+      UNIQUE(project_id, session_id, timestamp)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_usage_project_time
+      ON usage_snapshots(project_id, timestamp);
+  `);
+}
+
+// src/db/migrations.ts
+var migrations = [
+  {
+    version: 1,
+    description: "Initial schema",
+    up(_db) {
+    }
+  }
+];
+function runMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  const applied = new Set(
+    db.prepare("SELECT version FROM schema_migrations").all().map((row) => row.version)
+  );
+  for (const migration of migrations) {
+    if (!applied.has(migration.version)) {
+      migration.up(db);
+      db.prepare("INSERT INTO schema_migrations (version) VALUES (?)").run(migration.version);
+    }
+  }
+}
+
+// src/core/budgetManager.ts
+dayjs3.extend(isoWeek2);
+var BudgetManager = class {
+  db;
+  constructor(dbPath) {
+    this.db = initDatabase(dbPath);
+    runMigrations(this.db);
+  }
+  getOrCreateProject(projectPath) {
+    const name = basename2(projectPath) || projectPath;
+    const existing = this.db.prepare("SELECT id FROM projects WHERE path = ?").get(projectPath);
+    if (existing) return existing.id;
+    const result = this.db.prepare("INSERT INTO projects (name, path) VALUES (?, ?)").run(name, projectPath);
+    return Number(result.lastInsertRowid);
+  }
+  setBudget(projectPath, amount, period) {
+    const projectId = this.getOrCreateProject(projectPath);
+    this.db.prepare(
+      `INSERT INTO budgets (project_id, amount_usd, period)
+         VALUES (?, ?, ?)
+         ON CONFLICT(project_id, period)
+         DO UPDATE SET amount_usd = excluded.amount_usd`
+    ).run(projectId, amount, period);
+  }
+  getBudget(projectPath) {
+    const project = this.db.prepare("SELECT id FROM projects WHERE path = ?").get(projectPath);
+    if (!project) return null;
+    const budget = this.db.prepare("SELECT amount_usd, period FROM budgets WHERE project_id = ? ORDER BY created_at DESC LIMIT 1").get(project.id);
+    if (!budget) return null;
+    return { amount: budget.amount_usd, period: budget.period };
+  }
+  recordUsage(projectPath, sessionId, tokensIn, tokensOut, costUsd, timestamp) {
+    const projectId = this.getOrCreateProject(projectPath);
+    this.db.prepare(
+      `INSERT OR IGNORE INTO usage_snapshots (project_id, session_id, tokens_in, tokens_out, cost_usd, timestamp)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(projectId, sessionId, tokensIn, tokensOut, costUsd, timestamp);
+  }
+  getUsage(projectPath, period) {
+    const project = this.db.prepare("SELECT id FROM projects WHERE path = ?").get(projectPath);
+    if (!project) return 0;
+    const start = getPeriodStart(period);
+    const result = this.db.prepare(
+      `SELECT COALESCE(SUM(cost_usd), 0) as total
+         FROM usage_snapshots
+         WHERE project_id = ? AND timestamp >= ?`
+    ).get(project.id, start.toISOString());
+    return result.total;
+  }
+  checkBudget(projectPath) {
+    const budgetConfig = this.getBudget(projectPath);
+    if (!budgetConfig) return null;
+    const spent = this.getUsage(projectPath, budgetConfig.period);
+    const remaining = Math.max(0, budgetConfig.amount - spent);
+    const percentUsed = budgetConfig.amount > 0 ? spent / budgetConfig.amount * 100 : 0;
+    const periodStart = getPeriodStart(budgetConfig.period);
+    const periodEnd = getPeriodEnd(budgetConfig.period);
+    return {
+      budget: budgetConfig.amount,
+      spent,
+      remaining,
+      percentUsed,
+      isOverBudget: spent > budgetConfig.amount,
+      period: budgetConfig.period,
+      periodStart: periodStart.toISOString(),
+      periodEnd: periodEnd.toISOString()
+    };
+  }
+  listProjects() {
+    const rows = this.db.prepare(
+      `SELECT p.name, p.path, b.amount_usd, b.period
+         FROM projects p
+         LEFT JOIN budgets b ON b.project_id = p.id
+         ORDER BY p.name`
+    ).all();
+    return rows.map((row) => ({
+      name: row.name,
+      path: row.path,
+      budget: row.amount_usd,
+      period: row.period,
+      spent: row.period ? this.getUsage(row.path, row.period) : 0
+    }));
+  }
+  removeBudget(projectPath) {
+    const project = this.db.prepare("SELECT id FROM projects WHERE path = ?").get(projectPath);
+    if (!project) return false;
+    const result = this.db.prepare("DELETE FROM budgets WHERE project_id = ?").run(project.id);
+    return result.changes > 0;
+  }
+  close() {
+    this.db.close();
+  }
+};
+function getPeriodStart(period) {
+  switch (period) {
+    case "daily":
+      return dayjs3().startOf("day");
+    case "weekly":
+      return dayjs3().startOf("isoWeek");
+    case "monthly":
+      return dayjs3().startOf("month");
+  }
+}
+function getPeriodEnd(period) {
+  switch (period) {
+    case "daily":
+      return dayjs3().endOf("day");
+    case "weekly":
+      return dayjs3().endOf("isoWeek");
+    case "monthly":
+      return dayjs3().endOf("month");
+  }
+}
+
+// src/cli/commands/budget.ts
+function registerBudgetCommand(program2) {
+  const budget = program2.command("budget").description("Per-project budget management");
+  budget.command("set <amount>").description("Set budget for current project").option("-p, --period <period>", "Budget period (daily|weekly|monthly)", "weekly").option("--project <path>", "Project path").action((amount, opts) => {
+    const manager = new BudgetManager();
+    const projectPath = opts.project || process.cwd();
+    const amountNum = parseFloat(amount);
+    if (isNaN(amountNum) || amountNum <= 0) {
+      console.log(chalk.red("Budget amount must be a positive number."));
+      process.exit(1);
+    }
+    manager.setBudget(projectPath, amountNum, opts.period);
+    console.log(
+      chalk.green(`Budget set: ${formatCost(amountNum)}/${opts.period} for ${projectPath}`)
+    );
+    manager.close();
+  });
+  budget.command("show").description("Show current project budget").option("--project <path>", "Project path").option("--json", "Output as JSON").action((opts) => {
+    const manager = new BudgetManager();
+    const projectPath = opts.project || process.cwd();
+    const status = manager.checkBudget(projectPath);
+    if (!status) {
+      console.log("No budget set for this project. Use 'kerf budget set <amount>' to set one.");
+      manager.close();
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(status, null, 2));
+      manager.close();
+      return;
+    }
+    const pct = status.percentUsed;
+    const barWidth = 20;
+    const filled = Math.round(Math.min(pct, 100) / 100 * barWidth);
+    const empty = barWidth - filled;
+    const color = pct < 50 ? "green" : pct < 80 ? "yellow" : "red";
+    const barColor = color === "green" ? chalk.green : color === "yellow" ? chalk.yellow : chalk.red;
+    console.log(chalk.bold.cyan("\n  kerf budget\n"));
+    console.log(`  Period:  ${status.period} (${status.periodStart.slice(0, 10)} to ${status.periodEnd.slice(0, 10)})`);
+    console.log(`  Budget:  ${formatCost(status.budget)}`);
+    console.log(`  Spent:   ${barColor(formatCost(status.spent))}`);
+    console.log(`  ${barColor("[" + "\u2588".repeat(filled) + "\u2591".repeat(empty) + "]")} ${pct.toFixed(1)}%`);
+    if (status.isOverBudget) {
+      console.log(chalk.red.bold(`
+  OVER BUDGET by ${formatCost(status.spent - status.budget)}`));
+    }
+    console.log();
+    manager.close();
+  });
+  budget.command("list").description("List all project budgets").action(() => {
+    const manager = new BudgetManager();
+    const projects = manager.listProjects();
+    if (projects.length === 0) {
+      console.log("No projects with budgets. Use 'kerf budget set <amount>' to set one.");
+      manager.close();
+      return;
+    }
+    console.log(chalk.bold.cyan("\n  kerf budget list\n"));
+    for (const p of projects) {
+      const budgetStr = p.budget ? `${formatCost(p.budget)}/${p.period}` : "no budget";
+      const spentStr = p.spent > 0 ? ` (spent: ${formatCost(p.spent)})` : "";
+      console.log(`  ${chalk.bold(p.name)} \u2014 ${budgetStr}${spentStr}`);
+      console.log(chalk.dim(`    ${p.path}`));
+    }
+    console.log();
+    manager.close();
+  });
+  budget.command("remove").description("Remove budget for current project").option("--project <path>", "Project path").action((opts) => {
+    const manager = new BudgetManager();
+    const projectPath = opts.project || process.cwd();
+    const removed = manager.removeBudget(projectPath);
+    if (removed) {
+      console.log(chalk.green("Budget removed."));
+    } else {
+      console.log("No budget found for this project.");
+    }
+    manager.close();
+  });
+}
+
+// src/cli/commands/audit.ts
+import chalk2 from "chalk";
+
+// src/audit/ghostTokens.ts
+function calculateGrade(percentUsable) {
+  if (percentUsable >= 70) return "A";
+  if (percentUsable >= 50) return "B";
+  if (percentUsable >= 30) return "C";
+  return "D";
+}
+function analyzeGhostTokens(claudeMdPath) {
+  const overhead = estimateContextOverhead(claudeMdPath);
+  const mcpServers = analyzeMcpServers();
+  const grade = calculateGrade(overhead.percentUsable);
+  const breakdown = [
+    { label: "System prompt", tokens: overhead.systemPrompt, percent: overhead.systemPrompt / CONTEXT_WINDOW_SIZE * 100 },
+    { label: "Built-in tools", tokens: overhead.builtInTools, percent: overhead.builtInTools / CONTEXT_WINDOW_SIZE * 100 },
+    { label: `MCP tools (${mcpServers.length} srv)`, tokens: overhead.mcpTools, percent: overhead.mcpTools / CONTEXT_WINDOW_SIZE * 100 },
+    { label: "CLAUDE.md", tokens: overhead.claudeMd, percent: overhead.claudeMd / CONTEXT_WINDOW_SIZE * 100 },
+    { label: "Autocompact buffer", tokens: overhead.autocompactBuffer, percent: overhead.autocompactBuffer / CONTEXT_WINDOW_SIZE * 100 }
+  ];
+  return {
+    grade,
+    overhead,
+    mcpServers,
+    percentUsable: overhead.percentUsable,
+    breakdown
+  };
+}
+
+// src/audit/claudeMdLinter.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+var CRITICAL_RULE_PATTERN = /\b(NEVER|ALWAYS|MUST|IMPORTANT|CRITICAL)\b/i;
+var SKILL_CANDIDATES = /\b(review|deploy|release|migration|template|boilerplate|scaffold)\b/i;
+var LINE_LIMIT = 200;
+function getAttentionZone(position, total) {
+  const pct = total > 0 ? position / total : 0;
+  if (pct <= 0.3) return "high-start";
+  if (pct >= 0.7) return "high-end";
+  return "low-middle";
+}
+function lintClaudeMd(filePath) {
+  const paths = filePath ? [filePath] : [
+    join4(process.cwd(), "CLAUDE.md"),
+    join4(process.cwd(), ".claude", "CLAUDE.md")
+  ];
+  let resolvedPath = null;
+  for (const p of paths) {
+    if (existsSync3(p)) {
+      resolvedPath = p;
+      break;
+    }
+  }
+  if (!resolvedPath) return null;
+  const content = readFileSync3(resolvedPath, "utf-8");
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  const rawSections = parseClaudeMdSections(content);
+  const totalTokens = rawSections.reduce((sum, s) => sum + s.tokens, 0);
+  let criticalRulesInDeadZone = 0;
+  const sectionsToSkill = [];
+  const sections = rawSections.map((s) => {
+    const midpoint = (s.lineStart + s.lineEnd) / 2;
+    const attentionZone = getAttentionZone(midpoint, totalLines);
+    const hasCriticalRules = CRITICAL_RULE_PATTERN.test(s.content);
+    if (hasCriticalRules && attentionZone === "low-middle") {
+      criticalRulesInDeadZone++;
+    }
+    if (SKILL_CANDIDATES.test(s.title) || SKILL_CANDIDATES.test(s.content)) {
+      sectionsToSkill.push(s.title);
+    }
+    return {
+      title: s.title,
+      content: s.content,
+      tokens: s.tokens,
+      lineStart: s.lineStart,
+      lineEnd: s.lineEnd,
+      hasCriticalRules,
+      attentionZone
+    };
+  });
+  const critical = sections.filter((s) => s.hasCriticalRules);
+  const normal = sections.filter((s) => !s.hasCriticalRules && s.tokens <= 500);
+  const heavy = sections.filter((s) => !s.hasCriticalRules && s.tokens > 500);
+  const suggestedReorder = [...critical, ...normal, ...heavy].map((s) => s.title);
+  return {
+    totalLines,
+    totalTokens,
+    sections,
+    criticalRulesInDeadZone,
+    isOverLineLimit: totalLines > LINE_LIMIT,
+    suggestedReorder
+  };
+}
+
+// src/audit/mcpAnalyzer.ts
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+var CLI_ALTERNATIVES = {
+  playwright: "Consider using the built-in Bash tool with playwright CLI instead",
+  puppeteer: "Consider using the built-in Bash tool with puppeteer scripts",
+  filesystem: "Claude Code has built-in file tools (Read, Write, Edit, Glob, Grep)",
+  github: "Consider using 'gh' CLI via Bash tool instead",
+  slack: "Consider using 'slack' CLI or curl for API calls"
+};
+function analyzeMcp() {
+  const servers = [];
+  const configPaths = [
+    join5(process.cwd(), ".mcp.json"),
+    join5(homedir3(), ".claude.json")
+  ];
+  for (const configPath of configPaths) {
+    if (!existsSync4(configPath)) continue;
+    try {
+      const raw = JSON.parse(readFileSync4(configPath, "utf-8"));
+      const mcpServers = raw.mcpServers ?? raw.mcp_servers ?? {};
+      for (const [name, config] of Object.entries(mcpServers)) {
+        const cfg = config;
+        const tools = Array.isArray(cfg.tools) ? cfg.tools : [];
+        const toolCount = tools.length || 5;
+        const estimatedTokens = toolCount * MCP_TOKENS_PER_TOOL;
+        servers.push({
+          name,
+          toolCount,
+          estimatedTokens,
+          isHeavy: toolCount > 10
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  const totalTools = servers.reduce((sum, s) => sum + s.toolCount, 0);
+  const totalTokens = servers.reduce((sum, s) => sum + s.estimatedTokens, 0);
+  const heavyServers = servers.filter((s) => s.isHeavy);
+  let hasToolSearch = false;
+  const settingsPaths = [
+    join5(process.cwd(), ".claude", "settings.json"),
+    join5(homedir3(), ".claude", "settings.json")
+  ];
+  for (const sp of settingsPaths) {
+    if (!existsSync4(sp)) continue;
+    try {
+      const settings = JSON.parse(readFileSync4(sp, "utf-8"));
+      if (settings.enableToolSearch || settings.tool_search) {
+        hasToolSearch = true;
+        break;
+      }
+    } catch {
+      continue;
+    }
+  }
+  const effectiveTokens = hasToolSearch ? Math.round(totalTokens * 0.15) : totalTokens;
+  const recommendations = [];
+  for (const server of heavyServers) {
+    recommendations.push(
+      `'${server.name}' has ${server.toolCount} tools (${server.estimatedTokens.toLocaleString()} tokens). Consider enabling Tool Search to reduce overhead by ~85%.`
+    );
+  }
+  for (const server of servers) {
+    const alt = CLI_ALTERNATIVES[server.name.toLowerCase()];
+    if (alt) {
+      recommendations.push(`${server.name}: ${alt}`);
+    }
+  }
+  return {
+    servers,
+    totalTools,
+    totalTokens,
+    heavyServers,
+    hasToolSearch,
+    effectiveTokens,
+    recommendations
+  };
+}
+
+// src/audit/recommendations.ts
+function runFullAudit(claudeMdPath) {
+  const ghostReport = analyzeGhostTokens(claudeMdPath);
+  const claudeMdAnalysis = lintClaudeMd(claudeMdPath);
+  const mcpAnalysis = analyzeMcp();
+  const recommendations = [];
+  if (claudeMdAnalysis) {
+    if (claudeMdAnalysis.criticalRulesInDeadZone > 0) {
+      recommendations.push({
+        priority: "high",
+        impact: "improved rule adherence",
+        action: `Reorder CLAUDE.md \u2014 ${claudeMdAnalysis.criticalRulesInDeadZone} critical rule(s) in the low-attention dead zone (30-70% position). Move them to the top or bottom.`,
+        category: "claude-md"
+      });
+    }
+    if (claudeMdAnalysis.isOverLineLimit) {
+      recommendations.push({
+        priority: "high",
+        impact: `${claudeMdAnalysis.totalLines - 200} lines over limit`,
+        action: `CLAUDE.md is ${claudeMdAnalysis.totalLines} lines (limit: 200). Trim or move sections to skills.`,
+        category: "claude-md"
+      });
+    }
+    const heavySections = claudeMdAnalysis.sections.filter((s) => s.tokens > 500);
+    for (const section of heavySections) {
+      recommendations.push({
+        priority: "medium",
+        impact: `-${section.tokens} tokens/session`,
+        action: `Move '${section.title}' section to a skill (${section.tokens} tokens \u2014 heavy section)`,
+        category: "claude-md"
+      });
+    }
+  }
+  for (const server of mcpAnalysis.heavyServers) {
+    recommendations.push({
+      priority: "medium",
+      impact: `-${server.estimatedTokens.toLocaleString()} tokens/session`,
+      action: `MCP server '${server.name}' has ${server.toolCount} tools. Consider disabling if unused or enabling Tool Search.`,
+      category: "mcp"
+    });
+  }
+  if (!mcpAnalysis.hasToolSearch && mcpAnalysis.totalTools > 10) {
+    recommendations.push({
+      priority: "high",
+      impact: `~${Math.round(mcpAnalysis.totalTokens * 0.85).toLocaleString()} tokens saved`,
+      action: "Enable Tool Search (deferred tool loading) to reduce MCP overhead by ~85%.",
+      category: "mcp"
+    });
+  }
+  for (const rec of mcpAnalysis.recommendations) {
+    if (rec.includes("CLI")) {
+      recommendations.push({
+        priority: "low",
+        impact: "reduced token overhead",
+        action: rec,
+        category: "mcp"
+      });
+    }
+  }
+  if (ghostReport.percentUsable < 50) {
+    recommendations.push({
+      priority: "high",
+      impact: `only ${ghostReport.percentUsable.toFixed(0)}% usable`,
+      action: `Context window health is poor (grade ${ghostReport.grade}). Total overhead: ${ghostReport.overhead.totalOverhead.toLocaleString()} tokens.`,
+      category: "ghost-tokens"
+    });
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  recommendations.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return {
+    grade: ghostReport.grade,
+    contextOverhead: ghostReport.overhead,
+    claudeMdAnalysis,
+    mcpServers: ghostReport.mcpServers,
+    recommendations
+  };
+}
+
+// src/cli/commands/audit.ts
+function registerAuditCommand(program2) {
+  program2.command("audit").description("Ghost token & CLAUDE.md audit").option("--fix", "Auto-apply safe fixes").option("--claude-md-only", "Only audit CLAUDE.md").option("--mcp-only", "Only audit MCP servers").option("--json", "Output as JSON").action((opts) => {
+    const result = runFullAudit();
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const gradeColor = result.grade === "A" ? chalk2.green : result.grade === "B" ? chalk2.yellow : chalk2.red;
+    console.log(chalk2.bold.cyan("\n  kerf audit report\n"));
+    console.log(
+      `  Context Window Health: ${gradeColor.bold(result.grade)} (${result.contextOverhead.percentUsable.toFixed(0)}% usable)
+`
+    );
+    if (!opts.mcpOnly) {
+      console.log(chalk2.bold("  Ghost Token Breakdown:"));
+      const oh = result.contextOverhead;
+      const fmt = (label, tokens) => {
+        const pct = (tokens / CONTEXT_WINDOW_SIZE * 100).toFixed(1);
+        return `    ${label.padEnd(22)} ${tokens.toLocaleString().padStart(6)} tokens (${pct}%)`;
+      };
+      console.log(fmt("System prompt:", oh.systemPrompt));
+      console.log(fmt("Built-in tools:", oh.builtInTools));
+      console.log(fmt(`MCP tools (${result.mcpServers.length} srv):`, oh.mcpTools));
+      console.log(fmt("CLAUDE.md:", oh.claudeMd));
+      console.log(fmt("Autocompact buffer:", oh.autocompactBuffer));
+      console.log("    " + "-".repeat(40));
+      console.log(fmt("Total overhead:", oh.totalOverhead));
+      console.log(
+        `    ${"Effective window:".padEnd(22)} ${oh.effectiveWindow.toLocaleString().padStart(6)} tokens (${oh.percentUsable.toFixed(1)}%)
+`
+      );
+    }
+    if (!opts.mcpOnly && result.claudeMdAnalysis) {
+      const cma = result.claudeMdAnalysis;
+      console.log(chalk2.bold("  CLAUDE.md Analysis:"));
+      console.log(
+        `    Lines: ${cma.totalLines}${cma.isOverLineLimit ? chalk2.yellow(" (over 200 limit)") : ""}`
+      );
+      console.log(`    Tokens: ${cma.totalTokens.toLocaleString()}`);
+      console.log(
+        `    Critical rules in dead zone: ${cma.criticalRulesInDeadZone > 0 ? chalk2.red(String(cma.criticalRulesInDeadZone)) : "0"}`
+      );
+      console.log();
+    }
+    if (result.recommendations.length > 0) {
+      console.log(chalk2.bold("  Recommendations:"));
+      result.recommendations.forEach((rec, i) => {
+        const priorityColor = rec.priority === "high" ? chalk2.red : rec.priority === "medium" ? chalk2.yellow : chalk2.dim;
+        console.log(
+          `    ${i + 1}. ${priorityColor(`[${rec.priority.toUpperCase()}]`)} ${rec.action}`
+        );
+        console.log(chalk2.dim(`       Impact: ${rec.impact}`));
+      });
+    }
+    console.log();
+    if (opts.fix) {
+      console.log(chalk2.yellow("  --fix: Auto-fix is not yet implemented. Coming in v0.2.0.\n"));
+    }
+  });
+}
+
+// src/cli/commands/report.ts
+import chalk3 from "chalk";
+import dayjs4 from "dayjs";
+function registerReportCommand(program2) {
+  program2.command("report").description("Historical cost reports").option("--period <period>", "Time period (today|week|month|all)", "today").option("-p, --project <path>", "Filter to specific project").option("--model", "Show per-model breakdown").option("--sessions", "Show per-session breakdown").option("--csv", "Export as CSV").option("--json", "Export as JSON").action(async (opts) => {
+    const files = await findJsonlFiles(opts.project);
+    if (files.length === 0) {
+      console.log("No session data found. Start using Claude Code to generate data.");
+      return;
+    }
+    const now = dayjs4();
+    let cutoff;
+    switch (opts.period) {
+      case "today":
+        cutoff = now.startOf("day");
+        break;
+      case "week":
+        cutoff = now.subtract(7, "day");
+        break;
+      case "month":
+        cutoff = now.subtract(30, "day");
+        break;
+      case "all":
+        cutoff = dayjs4("2000-01-01");
+        break;
+      default:
+        cutoff = now.startOf("day");
+    }
+    const allMessages = [];
+    const sessionSummaries = [];
+    for (const file of files) {
+      try {
+        const session = parseSessionFile(file);
+        const filteredMessages = session.messages.filter(
+          (m) => dayjs4(m.timestamp).isAfter(cutoff)
+        );
+        if (filteredMessages.length === 0) continue;
+        allMessages.push(...filteredMessages);
+        const sessionCost = filteredMessages.reduce(
+          (sum, m) => sum + calculateMessageCost(m).totalCost,
+          0
+        );
+        sessionSummaries.push({
+          id: session.sessionId,
+          model: filteredMessages[0]?.model ?? "unknown",
+          cost: sessionCost,
+          messages: filteredMessages.length
+        });
+      } catch {
+        continue;
+      }
+    }
+    if (allMessages.length === 0) {
+      console.log(`No data found for period: ${opts.period}`);
+      return;
+    }
+    let totalCost = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCacheRead = 0;
+    for (const msg of allMessages) {
+      totalCost += calculateMessageCost(msg).totalCost;
+      totalInput += msg.usage.input_tokens;
+      totalOutput += msg.usage.output_tokens;
+      totalCacheRead += msg.usage.cache_read_input_tokens;
+    }
+    const totalCacheable = totalInput + totalCacheRead;
+    const cacheHitRate = totalCacheable > 0 ? totalCacheRead / totalCacheable * 100 : 0;
+    if (opts.json) {
+      console.log(
+        JSON.stringify(
+          {
+            period: opts.period,
+            totalCost,
+            totalInput,
+            totalOutput,
+            cacheHitRate,
+            sessions: sessionSummaries
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (opts.csv) {
+      console.log("session_id,model,cost_usd,messages");
+      for (const s of sessionSummaries) {
+        console.log(`${s.id},${s.model},${s.cost.toFixed(4)},${s.messages}`);
+      }
+      return;
+    }
+    const periodLabel = opts.period === "today" ? now.format("ddd, MMM D, YYYY") : opts.period;
+    console.log(chalk3.bold.cyan(`
+  kerf report -- ${periodLabel}
+`));
+    console.log(`  Total Cost:       ${chalk3.bold(formatCost(totalCost))}`);
+    console.log(`  Total Tokens:     ${formatTokens(totalInput)} in / ${formatTokens(totalOutput)} out`);
+    console.log(`  Cache Hit Rate:   ${cacheHitRate.toFixed(1)}%`);
+    console.log(`  Sessions:         ${sessionSummaries.length}`);
+    console.log();
+    if (opts.model || opts.sessions) {
+      const byModel = /* @__PURE__ */ new Map();
+      for (const s of sessionSummaries) {
+        const existing = byModel.get(s.model) ?? { cost: 0, sessions: 0 };
+        existing.cost += s.cost;
+        existing.sessions++;
+        byModel.set(s.model, existing);
+      }
+      console.log(chalk3.bold("  Model Breakdown:"));
+      for (const [model, data] of byModel) {
+        const pct = totalCost > 0 ? (data.cost / totalCost * 100).toFixed(1) : "0";
+        const shortModel = model.replace("claude-", "").replace(/-20\d{6}$/, "");
+        console.log(
+          `    ${shortModel}: ${formatCost(data.cost)} (${pct}%) -- ${data.sessions} session(s)`
+        );
+      }
+      console.log();
+    }
+    if (opts.sessions) {
+      console.log(chalk3.bold("  Session Breakdown:"));
+      for (const s of sessionSummaries.sort((a, b) => b.cost - a.cost)) {
+        console.log(`    ${s.id.slice(0, 12)}  ${formatCost(s.cost)}  ${s.messages} msgs  [${s.model}]`);
+      }
+      console.log();
+    }
+    const hourly = aggregateCosts(allMessages, "hour");
+    if (hourly.length > 1) {
+      console.log(chalk3.bold("  Hourly:"));
+      const maxCost = Math.max(...hourly.map((h) => h.totalCost));
+      for (const h of hourly.slice(-8)) {
+        const barLen = maxCost > 0 ? Math.round(h.totalCost / maxCost * 12) : 0;
+        const bar = "\u2588".repeat(barLen) + "\u2591".repeat(12 - barLen);
+        console.log(`    ${h.periodLabel.padEnd(14)} ${bar} ${formatCost(h.totalCost)}`);
+      }
+      console.log();
+    }
+  });
+}
+
+// src/cli/commands/init.ts
+import chalk4 from "chalk";
+import { mkdirSync as mkdirSync2, existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync, copyFileSync } from "node:fs";
+import { join as join6, dirname as dirname2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+function registerInitCommand(program2) {
+  program2.command("init").description("Set up kerf for the current project").option("--global", "Install hooks globally").option("--hooks-only", "Only install hooks").option("--no-hooks", "Skip hook installation").option("--force", "Skip confirmation prompts").action(async (opts) => {
+    console.log(chalk4.bold.cyan("\n  Welcome to kerf!\n"));
+    console.log("  Setting up cost intelligence for Claude Code...\n");
+    const kerfDir = join6(homedir4(), ".kerf");
+    if (!existsSync5(kerfDir)) {
+      mkdirSync2(kerfDir, { recursive: true });
+      console.log(chalk4.green("  Created ~/.kerf/"));
+    }
+    if (!opts.hooksOnly) {
+      try {
+        const db = initDatabase();
+        runMigrations(db);
+        db.close();
+        console.log(chalk4.green("  Created ~/.kerf/kerf.db"));
+      } catch (err) {
+        console.log(chalk4.red(`  Failed to create database: ${err}`));
+      }
+    }
+    try {
+      const { execSync } = await import("node:child_process");
+      try {
+        execSync("which rtk", { stdio: "ignore" });
+        console.log(chalk4.green("  Detected RTK (command compression) -- compatible!"));
+      } catch {
+      }
+      try {
+        execSync("which ccusage", { stdio: "ignore" });
+        console.log(chalk4.green("  Detected ccusage -- will import historical data"));
+      } catch {
+      }
+    } catch {
+    }
+    if (opts.hooks !== false) {
+      const settingsPath = opts.global ? join6(homedir4(), ".claude", "settings.json") : join6(process.cwd(), ".claude", "settings.json");
+      console.log("\n  Install hooks? These enable:");
+      console.log("    - Real-time token tracking (Notification hook)");
+      console.log("    - Budget enforcement (Stop hook)");
+      console.log(`
+  Hooks will be added to ${opts.global ? "~/.claude" : ".claude"}/settings.json`);
+      try {
+        installHooks(settingsPath);
+        console.log(chalk4.green("\n  Hooks installed"));
+      } catch (err) {
+        console.log(chalk4.yellow(`
+  Skipped hook installation: ${err}`));
+      }
+    }
+    console.log(chalk4.bold("\n  Recommended settings for your setup:"));
+    console.log(chalk4.dim("  Add to .claude/settings.json or ~/.claude/settings.json:"));
+    console.log(chalk4.dim(JSON.stringify({
+      env: {
+        MAX_THINKING_TOKENS: "10000",
+        CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "50"
+      }
+    }, null, 4).split("\n").map((l) => "    " + l).join("\n")));
+    console.log(chalk4.bold.cyan("\n  Run 'kerf watch' to start the live dashboard!\n"));
+  });
+}
+function installHooks(settingsPath) {
+  const dir = dirname2(settingsPath);
+  if (!existsSync5(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  let settings = {};
+  if (existsSync5(settingsPath)) {
+    const backupPath = settingsPath + ".bak";
+    copyFileSync(settingsPath, backupPath);
+    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
+  }
+  const hooks = settings.hooks ?? {};
+  if (!hooks.Notification) {
+    hooks.Notification = [];
+  }
+  if (!hooks.Stop) {
+    hooks.Stop = [];
+  }
+  settings.hooks = hooks;
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("kerf").version("0.1.0").description("Cost intelligence for Claude Code. Know before you spend.");
+registerWatchCommand(program);
+registerEstimateCommand(program);
+registerBudgetCommand(program);
+registerAuditCommand(program);
+registerReportCommand(program);
+registerInitCommand(program);
+program.action(async () => {
+  await program.commands.find((c) => c.name() === "watch")?.parseAsync([], { from: "user" });
+});
+program.parse();
+//# sourceMappingURL=index.js.map