claude-setup 1.1.4 → 1.1.5

package/dist/tokens.js

@@ -1,19 +1,75 @@
 /**
  * Token cost tracking — visibility into what every command costs.
  *
- * Zero extra API calls. Token count is computed from content length.
- * Estimates are based on ~4 chars per token approximation.
+ * Two data sources:
+ *   1. Estimates: computed from content length (~4 chars/token)
+ *   2. Real usage: parsed from Claude Code JSONL session transcripts
+ *      stored at ~/.config/claude/projects/ and ~/.claude/projects/
  *
- * Supports all pricing models:
- *   - Opus:   $15/M input
- *   - Sonnet: $3/M input
- *   - Haiku:  $0.25/M input
+ * Pricing engine inspired by ccusage (github.com/syunmoca/ccusage):
+ *   - Per-model pricing with tiered rates (200k token threshold)
+ *   - Cache creation/read tokens tracked separately
+ *   - Per-session, per-project, per-model breakdowns
+ *
+ * Current pricing (per million tokens):
+ *   Opus 4.6:   $15 input / $75 output / $18.75 cache-write / $1.50 cache-read
+ *   Sonnet 4.6: $3 input  / $15 output / $3.75 cache-write  / $0.30 cache-read
+ *   Haiku 4.5:  $0.80 input / $4 output / $1.00 cache-write / $0.08 cache-read
  */
-// Pricing per million input tokens (current as of 2025)
+import { join } from "path";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { homedir } from "os";
+const TIERED_THRESHOLD = 200_000;
+const MODEL_PRICING = {
+    // Opus 4.6
+    "opus": {
+        input: 15e-6, output: 75e-6, cacheWrite: 18.75e-6, cacheRead: 1.5e-6,
+        inputAbove200k: 30e-6, outputAbove200k: 112.5e-6,
+        cacheWriteAbove200k: 37.5e-6, cacheReadAbove200k: 3e-6,
+    },
+    // Sonnet 4.6
+    "sonnet": {
+        input: 3e-6, output: 15e-6, cacheWrite: 3.75e-6, cacheRead: 0.3e-6,
+        inputAbove200k: 6e-6, outputAbove200k: 22.5e-6,
+        cacheWriteAbove200k: 7.5e-6, cacheReadAbove200k: 0.6e-6,
+    },
+    // Haiku 4.5
+    "haiku": {
+        input: 0.8e-6, output: 4e-6, cacheWrite: 1e-6, cacheRead: 0.08e-6,
+    },
+};
+/** Match a model name string to a pricing tier */
+function matchModelPricing(modelName) {
+    const m = modelName.toLowerCase();
+    if (m.includes("opus"))
+        return MODEL_PRICING["opus"];
+    if (m.includes("haiku"))
+        return MODEL_PRICING["haiku"];
+    return MODEL_PRICING["sonnet"]; // default
+}
+/** Calculate tiered cost (like ccusage's calculateTieredCost) */
+function tieredCost(tokens, baseRate, aboveRate, threshold = TIERED_THRESHOLD) {
+    if (tokens <= 0)
+        return 0;
+    if (tokens > threshold && aboveRate !== undefined) {
+        return Math.min(tokens, threshold) * baseRate + Math.max(0, tokens - threshold) * aboveRate;
+    }
+    return tokens * baseRate;
+}
+/** Calculate real cost for a set of token counts using a specific model */
+export function calculateRealCost(inputTokens, outputTokens, cacheCreate, cacheRead, modelName) {
+    const p = matchModelPricing(modelName);
+    return (tieredCost(inputTokens, p.input, p.inputAbove200k) +
+        tieredCost(outputTokens, p.output, p.outputAbove200k) +
+        tieredCost(cacheCreate, p.cacheWrite, p.cacheWriteAbove200k) +
+        tieredCost(cacheRead, p.cacheRead, p.cacheReadAbove200k));
+}
+// ── Legacy estimation (for command file size predictions) ────────────
+// Pricing per million input tokens (for quick estimates)
 const PRICING_PER_M_INPUT = {
     opus: 15.0,
     sonnet: 3.0,
-    haiku: 0.25,
+    haiku: 0.80,
 };
 export function estimateTokens(content) {
     return Math.ceil(content.length / 4);
@@ -25,8 +81,19 @@ export function estimateCost(tokens) {
         haiku: (tokens / 1_000_000) * PRICING_PER_M_INPUT.haiku,
     };
 }
+function fmtVal(v) {
+    if (v === 0)
+        return "$0.000000";
+    if (v < 0.000001)
+        return `$${v.toFixed(8)}`;
+    if (v < 0.0001)
+        return `$${v.toFixed(6)}`;
+    if (v < 0.01)
+        return `$${v.toFixed(5)}`;
+    return `$${v.toFixed(4)}`;
+}
 export function formatCost(cost) {
-    return `Opus $${cost.opus.toFixed(4)} | Sonnet $${cost.sonnet.toFixed(4)} | Haiku $${cost.haiku.toFixed(4)}`;
+    return `Opus ${fmtVal(cost.opus)} | Sonnet ${fmtVal(cost.sonnet)} | Haiku ${fmtVal(cost.haiku)}`;
 }
 /**
  * Build a detailed token estimate with per-section breakdown.
@@ -104,6 +171,472 @@ export function generateHints(runs, currentTokens, budget) {
     }
     return hints;
 }
+export function readRealTokenUsage(cwd) {
+    const p = join(cwd, ".claude", "token-usage.json");
+    if (!existsSync(p))
+        return [];
+    try {
+        return JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Find Claude data directories — works on every OS.
+ * Checks (in order):
+ *   1. CLAUDE_CONFIG_DIR env var (comma-separated, custom override)
+ *   2. XDG_CONFIG_HOME/claude  (Linux/macOS new default)
+ *   3. ~/.config/claude        (Linux/macOS fallback)
+ *   4. ~/Library/Application Support/claude  (macOS alternate)
+ *   5. %APPDATA%/claude        (Windows alternate)
+ *   6. ~/.claude               (old default, all platforms)
+ */
+function getClaudeDataDirs() {
+    const dirs = [];
+    const seen = new Set();
+    const home = homedir();
+    function tryAdd(dir) {
+        const resolved = join(dir); // normalize
+        if (seen.has(resolved))
+            return;
+        seen.add(resolved);
+        if (existsSync(join(resolved, "projects")))
+            dirs.push(resolved);
+    }
+    // 1. Custom env var
+    const envDirs = process.env.CLAUDE_CONFIG_DIR;
+    if (envDirs) {
+        for (const d of envDirs.split(",").map(s => s.trim()).filter(Boolean)) {
+            tryAdd(d);
+        }
+    }
+    // 2. XDG config
+    const xdgConfig = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+    tryAdd(join(xdgConfig, "claude"));
+    // 3. macOS Application Support
+    tryAdd(join(home, "Library", "Application Support", "claude"));
+    // 4. Windows APPDATA
+    if (process.env.APPDATA)
+        tryAdd(join(process.env.APPDATA, "claude"));
+    // 5. Old default
+    tryAdd(join(home, ".claude"));
+    return dirs;
+}
+/** Parse a single JSONL line into usage data */
+function parseJsonlLine(line) {
+    try {
+        const obj = JSON.parse(line);
+        const msg = obj?.message;
+        if (!msg?.usage)
+            return null;
+        const u = msg.usage;
+        // Skip synthetic/zero-usage entries (e.g. <synthetic> model with all-zero counts)
+        if ((u.input_tokens ?? 0) === 0 && (u.output_tokens ?? 0) === 0 &&
+            (u.cache_creation_input_tokens ?? 0) === 0 && (u.cache_read_input_tokens ?? 0) === 0)
+            return null;
+        return {
+            model: msg.model ?? "unknown",
+            inputTokens: u.input_tokens ?? 0,
+            outputTokens: u.output_tokens ?? 0,
+            cacheCreate: u.cache_creation_input_tokens ?? 0,
+            cacheRead: u.cache_read_input_tokens ?? 0,
+            costUSD: obj.costUSD,
+            timestamp: obj.timestamp,
+            messageId: msg.id,
+            requestId: obj.requestId,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Extract a human-readable project name from a CWD path */
+function extractProjectName(cwd) {
+    const parts = cwd.replace(/[\\/]/g, "/").split("/").filter(Boolean);
+    return parts[parts.length - 1] ?? cwd;
+}
+/** Aggregate entries by model (like ccusage's aggregateByModel) */
+function aggregateByModel(entries) {
+    const agg = new Map();
+    for (const e of entries) {
+        const existing = agg.get(e.model) ?? { inputTokens: 0, outputTokens: 0, cacheCreateTokens: 0, cacheReadTokens: 0, cost: 0 };
+        existing.inputTokens += e.inputTokens;
+        existing.outputTokens += e.outputTokens;
+        existing.cacheCreateTokens += e.cacheCreate;
+        existing.cacheReadTokens += e.cacheRead;
+        existing.cost += e.cost;
+        agg.set(e.model, existing);
+    }
+    return [...agg.entries()].map(([model, stats]) => ({
+        model,
+        ...stats,
+        totalTokens: stats.inputTokens + stats.outputTokens + stats.cacheCreateTokens + stats.cacheReadTokens,
+    }));
+}
+/**
+ * Read all JSONL session files for a given project directory.
+ * Scans Claude's data directories for matching project paths.
+ * Returns per-session summaries with per-model breakdowns.
+ */
+export function readProjectSessions(projectCwd) {
+    const claudeDirs = getClaudeDataDirs();
+    if (claudeDirs.length === 0)
+        return [];
+    const sessions = [];
+    const seen = new Set(); // dedup by messageId:requestId
+    for (const claudeDir of claudeDirs) {
+        const projectsDir = join(claudeDir, "projects");
+        if (!existsSync(projectsDir))
+            continue;
+        // Encode the CWD the way Claude Code does, then exact-match against project dirs.
+        // This is the only reliable cross-platform approach — decoding is lossy when
+        // folder names contain hyphens (e.g. "Claude-code-documentation").
+        //   Windows: C:\Users\ok\Desktop\my-app  →  C--Users-ok-Desktop-my-app
+        //   Unix:    /Users/ok/dev/my-app         →  -Users-ok-dev-my-app
+        const encodedCwd = projectCwd
+            .replace(/\\/g, "/") // normalize backslashes to forward slashes
+            .replace(/:\//g, "--") // drive letter: C:/ → C--
+            .replace(/\//g, "-"); // remaining slashes → dashes
+        let targetDir = null;
+        try {
+            for (const entry of readdirSync(projectsDir)) {
+                // Case-insensitive compare handles Windows where CWDs may differ in case
+                if (entry.toLowerCase() === encodedCwd.toLowerCase()) {
+                    targetDir = join(projectsDir, entry);
+                    break;
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+        if (!targetDir || !existsSync(targetDir))
+            continue;
+        // Read all .jsonl files in this project dir
+        try {
+            const files = readdirSync(targetDir).filter(f => f.endsWith(".jsonl"));
+            for (const file of files) {
+                const filePath = join(targetDir, file);
+                const sessionId = file.replace(".jsonl", "");
+                let content;
+                try {
+                    content = readFileSync(filePath, "utf8");
+                }
+                catch {
+                    continue;
+                }
+                const entries = [];
+                let latestTimestamp = "";
+                // Helper to process lines from any JSONL source into entries
+                const processLines = (text) => {
+                    for (const line of text.split("\n")) {
+                        if (!line.trim())
+                            continue;
+                        const parsed = parseJsonlLine(line);
+                        if (!parsed)
+                            continue;
+                        // Dedup by messageId:requestId
+                        if (parsed.messageId && parsed.requestId) {
+                            const key = `${parsed.messageId}:${parsed.requestId}`;
+                            if (seen.has(key))
+                                continue;
+                            seen.add(key);
+                        }
+                        const cost = parsed.costUSD ?? calculateRealCost(parsed.inputTokens, parsed.outputTokens, parsed.cacheCreate, parsed.cacheRead, parsed.model);
+                        entries.push({
+                            model: parsed.model,
+                            inputTokens: parsed.inputTokens,
+                            outputTokens: parsed.outputTokens,
+                            cacheCreate: parsed.cacheCreate,
+                            cacheRead: parsed.cacheRead,
+                            cost,
+                        });
+                        if (parsed.timestamp && parsed.timestamp > latestTimestamp) {
+                            latestTimestamp = parsed.timestamp;
+                        }
+                    }
+                };
+                // Read main session JSONL
+                processLines(content);
+                // Also read subagent JSONL files (stored in <sessionId>/subagents/*.jsonl)
+                // These track token usage from Agent tool calls (subagents use separate API sessions)
+                const subagentDir = join(targetDir, sessionId, "subagents");
+                if (existsSync(subagentDir)) {
+                    try {
+                        const subFiles = readdirSync(subagentDir).filter(f => f.endsWith(".jsonl"));
+                        for (const sf of subFiles) {
+                            try {
+                                const subContent = readFileSync(join(subagentDir, sf), "utf8");
+                                processLines(subContent);
+                            }
+                            catch { /* skip unreadable subagent file */ }
+                        }
+                    }
+                    catch { /* skip if subagents dir unreadable */ }
+                }
+                if (entries.length === 0)
+                    continue;
+                const models = aggregateByModel(entries);
+                const totals = entries.reduce((acc, e) => ({
+                    inputTokens: acc.inputTokens + e.inputTokens,
+                    outputTokens: acc.outputTokens + e.outputTokens,
+                    cacheCreate: acc.cacheCreate + e.cacheCreate,
+                    cacheRead: acc.cacheRead + e.cacheRead,
+                    cost: acc.cost + e.cost,
+                }), { inputTokens: 0, outputTokens: 0, cacheCreate: 0, cacheRead: 0, cost: 0 });
+                sessions.push({
+                    sessionId,
+                    project: extractProjectName(projectCwd),
+                    timestamp: latestTimestamp,
+                    models,
+                    inputTokens: totals.inputTokens,
+                    outputTokens: totals.outputTokens,
+                    cacheCreateTokens: totals.cacheCreate,
+                    cacheReadTokens: totals.cacheRead,
+                    totalTokens: totals.inputTokens + totals.outputTokens + totals.cacheCreate + totals.cacheRead,
+                    totalCost: totals.cost,
+                });
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Sort by timestamp descending
+    sessions.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return sessions;
+}
+/**
+ * Aggregate all sessions for a project into a single summary.
+ */
+export function getProjectUsageSummary(projectCwd) {
+    const sessions = readProjectSessions(projectCwd);
+    if (sessions.length === 0)
+        return null;
+    // Merge all model breakdowns across sessions
+    const allEntries = [];
+    for (const s of sessions) {
+        for (const m of s.models) {
+            allEntries.push({
+                model: m.model,
+                inputTokens: m.inputTokens,
+                outputTokens: m.outputTokens,
+                cacheCreate: m.cacheCreateTokens,
+                cacheRead: m.cacheReadTokens,
+                cost: m.cost,
+            });
+        }
+    }
+    const models = aggregateByModel(allEntries);
+    const totals = sessions.reduce((acc, s) => ({
+        inputTokens: acc.inputTokens + s.inputTokens,
+        outputTokens: acc.outputTokens + s.outputTokens,
+        cacheCreate: acc.cacheCreate + s.cacheCreateTokens,
+        cacheRead: acc.cacheRead + s.cacheReadTokens,
+        cost: acc.cost + s.totalCost,
+    }), { inputTokens: 0, outputTokens: 0, cacheCreate: 0, cacheRead: 0, cost: 0 });
+    return {
+        project: sessions[0].project,
+        sessions: sessions.length,
+        models,
+        inputTokens: totals.inputTokens,
+        outputTokens: totals.outputTokens,
+        cacheCreateTokens: totals.cacheCreate,
+        cacheReadTokens: totals.cacheRead,
+        totalTokens: totals.inputTokens + totals.outputTokens + totals.cacheCreate + totals.cacheRead,
+        totalCost: totals.cost,
+    };
+}
+export function getTokenHookScript() {
+    return `#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+// Tiered pricing: tokens above 200k threshold are charged at a higher rate
+const THRESHOLD = 200000;
+function tieredCost(tokens, baseRate, aboveRate) {
+  if (tokens <= 0) return 0;
+  if (tokens > THRESHOLD && aboveRate) {
+    return Math.min(tokens, THRESHOLD) * baseRate + Math.max(0, tokens - THRESHOLD) * aboveRate;
+  }
+  return tokens * baseRate;
+}
+
+// Model pricing per token (ccusage-style, supports tiered pricing)
+const PRICING = {
+  opus:   { input: 15e-6, output: 75e-6, cacheWrite: 18.75e-6, cacheRead: 1.5e-6,
+            inputAbove200k: 30e-6, outputAbove200k: 112.5e-6, cacheWriteAbove200k: 37.5e-6, cacheReadAbove200k: 3e-6 },
+  sonnet: { input: 3e-6, output: 15e-6, cacheWrite: 3.75e-6, cacheRead: 0.3e-6,
+            inputAbove200k: 6e-6, outputAbove200k: 22.5e-6, cacheWriteAbove200k: 7.5e-6, cacheReadAbove200k: 0.6e-6 },
+  haiku:  { input: 0.8e-6, output: 4e-6, cacheWrite: 1e-6, cacheRead: 0.08e-6 },
+};
+
+function getPricing(modelName) {
+  const m = modelName.toLowerCase();
+  if (m.includes('opus')) return PRICING.opus;
+  if (m.includes('haiku')) return PRICING.haiku;
+  return PRICING.sonnet;
+}
+
+let input = '';
+process.stdin.on('data', (d) => { input += d; });
+process.stdin.on('end', () => {
+  try {
+    const event = JSON.parse(input);
+    const transcriptPath = event.transcript_path;
+    const sessionId = event.session_id || 'unknown';
+
+    if (!transcriptPath || !fs.existsSync(transcriptPath)) process.exit(0);
+
+    // Per-model aggregation (like ccusage's aggregateByModel)
+    const models = {};
+    const seen = new Set();
+
+    function processLines(text) {
+      for (const line of text.split('\\n')) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          const msg = obj.message;
+          if (!msg || !msg.usage) continue;
+          const u = msg.usage;
+          // Skip zero-usage entries (e.g. <synthetic>)
+          if (!u.input_tokens && !u.output_tokens && !u.cache_creation_input_tokens && !u.cache_read_input_tokens) continue;
+          // Dedup by messageId:requestId
+          const dedup = (msg.id || '') + ':' + (obj.requestId || '');
+          if (dedup !== ':' && seen.has(dedup)) continue;
+          if (dedup !== ':') seen.add(dedup);
+          const model = msg.model || 'unknown';
+          if (!models[model]) models[model] = { inputTokens: 0, outputTokens: 0, cacheCreate: 0, cacheRead: 0 };
+          models[model].inputTokens  += u.input_tokens || 0;
+          models[model].outputTokens += u.output_tokens || 0;
+          models[model].cacheCreate  += u.cache_creation_input_tokens || 0;
+          models[model].cacheRead    += u.cache_read_input_tokens || 0;
+        } catch {}
+      }
+    }
+
+    // Read main session transcript
+    processLines(fs.readFileSync(transcriptPath, 'utf8'));
+
+    // Also read subagent JSONL files — subagents use separate API sessions
+    // stored at <transcriptPath without .jsonl>/subagents/*.jsonl
+    const sessionDir = transcriptPath.replace(/\\.jsonl$/, '');
+    const subagentDir = path.join(sessionDir, 'subagents');
+    if (fs.existsSync(subagentDir)) {
+      try {
+        const subFiles = fs.readdirSync(subagentDir).filter(f => f.endsWith('.jsonl'));
+        for (const sf of subFiles) {
+          try { processLines(fs.readFileSync(path.join(subagentDir, sf), 'utf8')); } catch {}
+        }
+      } catch {}
+    }
+
+    // Calculate cost per model with tiered pricing
+    let totalCost = 0;
+    let totalInput = 0, totalOutput = 0, totalCacheCreate = 0, totalCacheRead = 0;
+    const modelBreakdowns = [];
+    let primaryModel = 'unknown';
+    let maxTokens = 0;
+
+    for (const [model, t] of Object.entries(models)) {
+      const p = getPricing(model);
+      const cost = tieredCost(t.inputTokens, p.input, p.inputAbove200k)
+                 + tieredCost(t.outputTokens, p.output, p.outputAbove200k)
+                 + tieredCost(t.cacheCreate, p.cacheWrite, p.cacheWriteAbove200k)
+                 + tieredCost(t.cacheRead, p.cacheRead, p.cacheReadAbove200k);
+      totalCost += cost;
+      totalInput += t.inputTokens;
+      totalOutput += t.outputTokens;
+      totalCacheCreate += t.cacheCreate;
+      totalCacheRead += t.cacheRead;
+      const total = t.inputTokens + t.outputTokens + t.cacheCreate + t.cacheRead;
+      if (total > maxTokens) { maxTokens = total; primaryModel = model; }
+      modelBreakdowns.push({ model, ...t, cost, totalTokens: total });
+    }
+
+    const record = {
+      sessionId,
+      timestamp: new Date().toISOString(),
+      model: primaryModel,
+      inputTokens: totalInput,
+      outputTokens: totalOutput,
+      cacheCreate: totalCacheCreate,
+      cacheRead: totalCacheRead,
+      cost: totalCost,
+      modelBreakdowns
+    };
+
+    const usageFile = path.join(process.cwd(), '.claude', 'token-usage.json');
+    let records = [];
+    try { records = JSON.parse(fs.readFileSync(usageFile, 'utf8')); } catch {}
+    const idx = records.findIndex(r => r.sessionId === sessionId);
+    if (idx >= 0) { records[idx] = record; } else { records.push(record); }
+    if (records.length > 100) records = records.slice(-100);
+    const dir = path.dirname(usageFile);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(usageFile, JSON.stringify(records, null, 2));
+  } catch { process.exit(0); }
+});
+`;
+}
+/**
+ * Format a real-cost summary. Prefers JSONL transcript data (ccusage-style),
+ * falls back to Stop hook data if no JSONL sessions found.
+ * Returns null if no real data is available from either source.
+ */
+export function formatRealCostSummary(cwd) {
+    // Try JSONL transcripts first (most accurate — per-model, cache-aware)
+    const projectSummary = getProjectUsageSummary(cwd);
+    if (projectSummary && projectSummary.totalTokens > 0) {
+        const lines = [];
+        lines.push(`  Real usage (${projectSummary.sessions} session${projectSummary.sessions > 1 ? "s" : ""}, from JSONL transcripts):`);
+        lines.push(`    Total cost   : $${projectSummary.totalCost.toFixed(6)}`);
+        lines.push(`    Input tokens : ${projectSummary.inputTokens.toLocaleString()}`);
+        lines.push(`    Output tokens: ${projectSummary.outputTokens.toLocaleString()}`);
+        if (projectSummary.cacheCreateTokens > 0 || projectSummary.cacheReadTokens > 0) {
+            lines.push(`    Cache write  : ${projectSummary.cacheCreateTokens.toLocaleString()}`);
+            lines.push(`    Cache read   : ${projectSummary.cacheReadTokens.toLocaleString()}`);
+        }
+        if (projectSummary.models.length > 0) {
+            lines.push(`    Per model:`);
+            for (const m of projectSummary.models.sort((a, b) => b.cost - a.cost)) {
+                const shortName = m.model.replace(/^claude-/, "").replace(/-\d{8}$/, "");
+                lines.push(`      ${shortName.padEnd(14)} ${m.totalTokens.toLocaleString().padStart(12)} tokens  $${m.cost.toFixed(6)}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // Fallback: Stop hook data
+    const records = readRealTokenUsage(cwd);
+    if (records.length === 0)
+        return null;
+    let totalCost = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCacheCreate = 0;
+    let totalCacheRead = 0;
+    for (const r of records) {
+        totalCost += r.cost;
+        totalInput += r.inputTokens;
+        totalOutput += r.outputTokens;
+        totalCacheCreate += r.cacheCreate;
+        totalCacheRead += r.cacheRead;
+    }
+    const last = records[records.length - 1];
+    const lastDate = new Date(last.timestamp).toLocaleString();
+    const lines = [];
+    lines.push(`  Real usage (${records.length} session${records.length > 1 ? "s" : ""} tracked):`);
+    lines.push(`    Total cost   : $${totalCost.toFixed(6)}`);
+    lines.push(`    Input tokens : ${totalInput.toLocaleString()}`);
+    lines.push(`    Output tokens: ${totalOutput.toLocaleString()}`);
+    if (totalCacheCreate > 0 || totalCacheRead > 0) {
+        lines.push(`    Cache write  : ${totalCacheCreate.toLocaleString()}`);
+        lines.push(`    Cache read   : ${totalCacheRead.toLocaleString()}`);
+    }
+    lines.push(`    Last session : ${lastDate} (${last.model})`);
+    return lines.join("\n");
+}
 /**
  * Compute cumulative stats for status dashboard.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-setup",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Setup layer for Claude Code — reads your project, writes command files, Claude Code does the rest",
   "type": "module",
   "bin": {

package/templates/init-empty.md

@@ -3,22 +3,64 @@
 
 This is a new project with no source files yet.
 
-Before setting up anything, ask the developer these three questions in ONE message:
+## Step 1 — Idea discovery
 
-1. What are you building? (describe the product in one sentence — not the tech)
-2. Do you have a preferred language or runtime? (completely fine if not)
-3. Are there external services you know you'll use? (fine to say "not sure yet")
+Start a conversation with the developer. Ask ONE focused question to understand what they're building.
+Keep it short and conversational. Offer at most 3 answer choices where helpful.
 
-Wait for their reply. Then immediately set up the full Claude Code environment.
+**Ask this first:**
+
+> What are you building? (Pick the closest match or describe in a few words)
+> 1. A web app or SaaS product
+> 2. A CLI tool or developer utility
+> 3. Something else — tell me in one sentence
+
+Wait for their answer. Then ask ONE follow-up question if needed to clarify the core purpose.
+Ask a maximum of 3 questions total in this step. Stop after you understand the product.
+
+---
+
+## Step 2 — Tech stack
+
+Once you understand the idea, ask:
+
+> Do you already have a tech stack in mind?
+> - **Yes** → ask them to describe it briefly, then suggest complementary tools
+> - **No** → based on their idea, suggest the most appropriate stack:
+>   - Web app → Next.js/React + TypeScript (or Python/FastAPI if data-heavy)
+>   - CLI tool → Node.js/TypeScript or Go
+>   - API service → Node.js/Express or Python/FastAPI
+>   - Mobile → React Native or Flutter
+>   Present 2-3 options max and let them choose.
+
+Confirm their final stack choice before moving on.
+
+---
+
+## Step 3 — Services
+
+Based on the stack and idea, ask:
+
+> Which of these services will you need? (select any that apply)
+
+Suggest only services relevant to their specific idea:
+- **Database** — if they need persistent data (PostgreSQL, MongoDB, Redis)
+- **Auth** — if they need user accounts
+- **Payments** — if they're monetizing (Stripe)
+- **Storage** — if they handle files/media
+- **Email/notifications** — if they need to reach users
+- **External API** — if they named a specific third-party service
+
+Let them specify their own services, then suggest 1-2 additional ones that complement their stack.
 
 ---
 
-## After they reply
+## After collecting all answers
 
 Use exactly what they said. Do not invent requirements they did not mention.
 
 **CLAUDE.md**
-Write it for the product they described. Reference their exact words.
+Write it for the product they described. Reference their exact words and chosen stack.
 If they gave no language: write a language-agnostic CLAUDE.md about the product itself.
 
 **.mcp.json**

package/templates/remove.md

@@ -47,8 +47,12 @@ Before removing anything, scan these locations directly:
 - Remove the entire matcher entry if removing all hooks for that matcher
 
 ### Skills
-- Delete the skill directory: `.claude/skills/<name>/` (entire directory including SKILL.md)
-- Or delete the flat skill file: `.claude/skills/<name>.md`
+- Delete the skill directory using the appropriate shell command:
+  - macOS/Linux: run `rm -rf .claude/skills/<name>/`
+  - Windows: run `rmdir /s /q ".claude\skills\<name>"`
+- Verify deletion succeeded: confirm `.claude/skills/<name>/` no longer exists on disk
+- Remove the skill reference from CLAUDE.md
+- Remove from SKILLS_LIST in CLAUDE.md if referenced there
 
 ### Plugins
 - Suggest: `/plugin uninstall <name>@<marketplace>`