cchubber 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cchubber",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "What you spent. Why you spent it. Is that normal. — Claude Code usage diagnosis with beautiful HTML reports.",
   "type": "module",
   "bin": {

package/src/analyzers/model-routing.js

@@ -0,0 +1,72 @@
+/**
+ * Model Routing Analysis
+ * Detects model usage patterns and estimates savings from better routing.
+ */
+export function analyzeModelRouting(costAnalysis, jsonlEntries) {
+  const modelCosts = costAnalysis.modelCosts || {};
+  const totalCost = Object.values(modelCosts).reduce((s, c) => s + c, 0);
+
+  if (totalCost < 0.01) return { available: false };
+
+  // Classify models into tiers
+  const tiers = { opus: 0, sonnet: 0, haiku: 0, other: 0 };
+  const tierCosts = { opus: 0, sonnet: 0, haiku: 0, other: 0 };
+
+  for (const [name, cost] of Object.entries(modelCosts)) {
+    const lower = name.toLowerCase();
+    if (lower.includes('opus')) { tiers.opus++; tierCosts.opus += cost; }
+    else if (lower.includes('sonnet')) { tiers.sonnet++; tierCosts.sonnet += cost; }
+    else if (lower.includes('haiku')) { tiers.haiku++; tierCosts.haiku += cost; }
+    else { tiers.other++; tierCosts.other += cost; }
+  }
+
+  const opusPct = totalCost > 0 ? Math.round((tierCosts.opus / totalCost) * 100) : 0;
+  const sonnetPct = totalCost > 0 ? Math.round((tierCosts.sonnet / totalCost) * 100) : 0;
+  const haikuPct = totalCost > 0 ? Math.round((tierCosts.haiku / totalCost) * 100) : 0;
+
+  // Estimate savings: assume 40% of Opus work could be done by Sonnet at 60% cost
+  // Conservative estimate — Sonnet handles file reads, simple edits, search well
+  const opusCost = tierCosts.opus;
+  const routableToSonnet = opusCost * 0.4; // 40% of Opus work is routable
+  const sonnetEquivalentCost = routableToSonnet * 0.6; // Sonnet is ~60% of Opus cost
+  const estimatedSavings = routableToSonnet - sonnetEquivalentCost;
+
+  // Detect subagent usage from JSONL (subagent messages often use different models)
+  let subagentMessages = 0;
+  let mainMessages = 0;
+  if (jsonlEntries && jsonlEntries.length > 0) {
+    for (const entry of jsonlEntries) {
+      const model = (entry.model || '').toLowerCase();
+      // Subagents typically use sonnet/haiku, main thread uses opus
+      if (model.includes('sonnet') || model.includes('haiku')) {
+        subagentMessages++;
+      } else {
+        mainMessages++;
+      }
+    }
+  }
+
+  const subagentPct = (subagentMessages + mainMessages) > 0
+    ? Math.round((subagentMessages / (subagentMessages + mainMessages)) * 100)
+    : 0;
+
+  // Model diversity score (0-100): higher = better routing
+  const modelCount = Object.keys(modelCosts).length;
+  let diversityScore = 0;
+  if (modelCount >= 3 && opusPct < 80) diversityScore = 90;
+  else if (modelCount >= 2 && opusPct < 90) diversityScore = 60;
+  else if (opusPct > 95) diversityScore = 20;
+  else diversityScore = 40;
+
+  return {
+    available: true,
+    opusPct,
+    sonnetPct,
+    haikuPct,
+    estimatedSavings: Math.round(estimatedSavings),
+    subagentPct,
+    diversityScore,
+    tierCosts,
+    totalCost,
+  };
+}

package/src/analyzers/recommendations.js

@@ -1,128 +1,141 @@
-export function generateRecommendations(costAnalysis, cacheHealth, claudeMdStack, anomalies, inflection) {
+/**
+ * Recommendations Engine
+ * Generates actionable recommendations informed by community data (March 2026 crisis).
+ * Every recommendation maps to a real pattern reported by users on GitHub/Twitter/Reddit.
+ */
+export function generateRecommendations(costAnalysis, cacheHealth, claudeMdStack, anomalies, inflection, sessionIntel, modelRouting) {
   const recs = [];
 
-  // 0. Inflection point — most important signal, goes first
+  // 0. Inflection point — most important signal
   if (inflection && inflection.direction === 'worsened' && inflection.multiplier >= 2) {
     recs.push({
       severity: 'critical',
-      title: `Efficiency dropped ${inflection.multiplier}x on ${inflection.date}`,
+      title: `Cache efficiency dropped ${inflection.multiplier}x on ${inflection.date}`,
       detail: inflection.summary,
-      action: 'This date likely correlates with a Claude Code update or cache regression. Check your CC version history. v2.1.89 had a known cache bug — v2.1.90 includes a fix.',
+      action: 'Run: claude update. Versions 2.1.69-2.1.89 had a cache sentinel bug that dropped read rates from 95% to 4-17%. Fixed in v2.1.90.',
     });
   } else if (inflection && inflection.direction === 'improved' && inflection.multiplier >= 2) {
     recs.push({
       severity: 'positive',
       title: `Efficiency improved ${inflection.multiplier}x on ${inflection.date}`,
       detail: inflection.summary,
-      action: 'Something changed for the better on this date. Likely a version update or workflow change.',
+      action: 'Your cache efficiency improved here. Likely a version update or workflow change that stuck.',
     });
   }
 
-  // 1. CLAUDE.md size
+  // 1. CLAUDE.md bloat — community-reported 10-20x cost multiplier
   if (claudeMdStack.totalTokensEstimate > 8000) {
+    const dailyCost = claudeMdStack.costPerMessage?.dailyCached200;
     recs.push({
-      severity: 'warning',
-      title: 'Large CLAUDE.md stack',
-      detail: `Your CLAUDE.md files total ~${claudeMdStack.totalTokensEstimate.toLocaleString()} tokens (${(claudeMdStack.totalBytes / 1024).toFixed(1)} KB). This is re-read on every message. At 200 messages/day, this costs ~$${claudeMdStack.costPerMessage.dailyCached200.toFixed(2)}/day cached, or $${claudeMdStack.costPerMessage.dailyUncached200.toFixed(2)}/day if cache breaks.`,
-      action: 'Review your CLAUDE.md for sections that could be moved to project-level files loaded on demand.',
+      severity: claudeMdStack.totalTokensEstimate > 15000 ? 'critical' : 'warning',
+      title: `CLAUDE.md is ${Math.round(claudeMdStack.totalTokensEstimate / 1000)}K tokens`,
+      detail: `Re-read on every turn. Community best practice: keep under 200 lines (~4K tokens). Yours costs ~$${dailyCost ? dailyCost.toFixed(2) : '?'}/day at 200 messages. Each cache break re-reads at 12.5x the cached price.`,
+      action: 'Move rarely-used rules to project-level files. Use skills/hooks instead of inline instructions. Every 1K tokens removed saves ~$0.50/day.',
     });
   }
 
-  // 2. Cache break frequency
+  // 2. Version check — the #1 fix reported by community
+  if (cacheHealth.efficiencyRatio > 1500 || (inflection && inflection.direction === 'worsened')) {
+    recs.push({
+      severity: 'critical',
+      title: 'Update Claude Code to v2.1.90+',
+      detail: 'Versions 2.1.69-2.1.89 had three cache bugs: sentinel replacement error, --resume cache miss, and nested CLAUDE.md re-injection. Community-verified: usage dropped from 80-100% to 5-7% of Max quota after updating.',
+      action: 'Run: claude update. If already on latest, start a fresh session — the fix only applies to new sessions.',
+    });
+  }
+
+  // 3. Cache break analysis
   if (cacheHealth.totalCacheBreaks > 10) {
     const topReason = cacheHealth.reasonsRanked[0];
     recs.push({
       severity: cacheHealth.totalCacheBreaks > 50 ? 'critical' : 'warning',
-      title: `${cacheHealth.totalCacheBreaks} cache breaks detected`,
-      detail: `Each cache break forces a full context re-read at write prices (12.5x cache read cost). Top cause: "${topReason?.reason}" (${topReason?.count} times, ${topReason?.percentage}%).`,
+      title: `${cacheHealth.totalCacheBreaks} cache invalidations`,
+      detail: `Each break forces a full prompt re-read at write prices (12.5x cache read cost). ${topReason ? `Top cause: "${topReason.reason}" (${topReason.count}x, ${topReason.percentage}%).` : ''}`,
       action: topReason?.reason === 'Tool schemas changed'
-        ? 'Reduce MCP tool connections. Each tool add/remove invalidates the cache.'
+        ? 'Reduce MCP server connections. Each tool schema change breaks the cache prefix. Disconnect tools you\'re not actively using.'
         : topReason?.reason === 'System prompt changed'
-        ? 'Avoid editing CLAUDE.md mid-session. Make changes between sessions.'
-        : topReason?.reason === 'TTL expiry'
-        ? 'Keep sessions active. Cache expires after 5 minutes of inactivity.'
-        : 'Review cache break logs in ~/.claude/tmp/cache-break-*.diff for details.',
+        ? 'Stop editing CLAUDE.md mid-session. Batch rule changes between sessions.'
+        : 'Review ~/.claude/tmp/cache-break-*.diff for exact invalidation causes.',
     });
   }
 
-  // 3. High cache:output ratio
+  // 4. High cache:output ratio
   if (cacheHealth.efficiencyRatio > 2000) {
     recs.push({
       severity: 'critical',
-      title: `Cache efficiency ratio: ${cacheHealth.efficiencyRatio.toLocaleString()}:1`,
-      detail: `For every 1 token of output, ${cacheHealth.efficiencyRatio.toLocaleString()} tokens are read from cache. Healthy range is 300-800:1. This could indicate the known Claude Code cache bug (March 2026).`,
-      action: 'Check your Claude Code version. Versions around 2.1.85-2.1.90 have known cache regression bugs. Consider pinning to an earlier version.',
+      title: `Cache ratio ${cacheHealth.efficiencyRatio.toLocaleString()}:1 — abnormally high`,
+      detail: `Healthy range: 300-800:1. You\'re at ${cacheHealth.efficiencyRatio.toLocaleString()}:1 — every output token costs ${cacheHealth.efficiencyRatio.toLocaleString()} cache read tokens. This pattern matches the March 2026 cache bug reported by thousands of users.`,
+      action: 'Immediate fix: update to v2.1.90+. If already updated, avoid --resume flag and start fresh sessions per task.',
     });
   } else if (cacheHealth.efficiencyRatio > 1000) {
     recs.push({
       severity: 'warning',
-      title: `Elevated cache ratio: ${cacheHealth.efficiencyRatio.toLocaleString()}:1`,
-      detail: 'Above average but not critical. Could be large codebase exploration or heavy file reading.',
-      action: 'Use /compact more frequently in long sessions. Start fresh sessions for new tasks.',
+      title: `Cache ratio ${cacheHealth.efficiencyRatio.toLocaleString()}:1 — elevated`,
+      detail: 'Not critical, but above the 300-800 healthy range. Common causes: large codebase exploration, many file reads without /compact, or stale sessions.',
+      action: 'Use /compact every 30-40 tool calls. Start fresh sessions for each distinct task.',
     });
   }
 
-  // 4. Cost anomalies
-  if (anomalies.hasAnomalies) {
-    const spikes = anomalies.anomalies.filter(a => a.type === 'spike');
-    if (spikes.length > 0) {
-      const worst = spikes[0];
-      recs.push({
-        severity: worst.severity,
-        title: `${spikes.length} cost spike${spikes.length > 1 ? 's' : ''} detected`,
-        detail: `Worst: $${worst.cost.toFixed(2)} on ${worst.date} (${worst.zScore > 0 ? '+' : ''}${worst.deviation.toFixed(2)} from average of $${worst.avgCost.toFixed(2)}).${worst.cacheRatioAnomaly ? ' Cache ratio was also anomalous — likely cache bug impact.' : ''}`,
-        action: 'Compare session activity on spike days. Look for long sessions without /compact, or sessions where many MCP tools were connected.',
-      });
-    }
-  }
+  // 5. Opus dominance — community tip: Sonnet handles 60%+ of tasks at 1/5 cost
+  const modelCosts = costAnalysis.modelCosts || {};
+  const totalModelCost = Object.values(modelCosts).reduce((s, c) => s + c, 0);
+  const opusCost = Object.entries(modelCosts).filter(([n]) => n.toLowerCase().includes('opus')).reduce((s, [, c]) => s + c, 0);
+  const opusPct = totalModelCost > 0 ? Math.round((opusCost / totalModelCost) * 100) : 0;
 
-  // 5. Cost trend
-  if (anomalies.trend === 'rising_fast') {
+  if (opusPct > 85) {
+    const savings = modelRouting?.estimatedSavings || Math.round(opusCost * 0.16);
     recs.push({
-      severity: 'critical',
-      title: 'Costs rising rapidly',
-      detail: 'Your recent 7-day average is significantly higher than your historical average.',
-      action: 'This may be related to the March 2026 Claude Code cache bug. Check Anthropic status for updates.',
+      severity: 'warning',
+      title: `${opusPct}% of spend is Opus`,
+      detail: `Opus costs 5x more than Sonnet per token. Sonnet 4.6 handles file reads, search, simple edits, and subagent work at the same quality. Community tip: switching routine tasks to Sonnet dropped quota usage by 60-80%.`,
+      action: `Set model: "sonnet" on subagent/Task calls. Estimated savings: ~$${savings.toLocaleString()}. Reserve Opus for complex reasoning only.`,
     });
   }
 
-  // 6. Opus dominance
-  const modelCosts = costAnalysis.modelCosts || {};
-  const totalModelCost = Object.values(modelCosts).reduce((s, c) => s + c, 0);
-  const opusCost = Object.entries(modelCosts)
-    .filter(([name]) => name.includes('opus'))
-    .reduce((s, [, c]) => s + c, 0);
-  const opusPercentage = totalModelCost > 0 ? (opusCost / totalModelCost) * 100 : 0;
-
-  if (opusPercentage > 90) {
+  // 6. Session length — community-reported: sessions >60 min degrade heavily
+  if (sessionIntel?.available && sessionIntel.longSessionPct > 30) {
     recs.push({
-      severity: 'info',
-      title: `${Math.round(opusPercentage)}% of costs from Opus`,
-      detail: 'Opus is the most expensive model. Subagents and simple tasks could use Sonnet or Haiku.',
-      action: 'Set model: "sonnet" or "haiku" on Task tool calls for search, documentation lookup, and log analysis.',
+      severity: 'warning',
+      title: `${sessionIntel.longSessionPct}% of sessions exceed 60 minutes`,
+      detail: `Long sessions accumulate context that degrades cache efficiency and response quality. Your median: ${sessionIntel.medianDuration}min, p90: ${sessionIntel.p90Duration}min, longest: ${sessionIntel.maxDuration}min.`,
+      action: 'One task, one session. Use /compact for exploration, fresh session for each bug fix or feature. The cost of starting fresh is less than the cost of a bloated context.',
     });
   }
 
-  // 7. Session depth — long sessions without compact
-  const sessions = costAnalysis.sessions || {};
-  if (sessions.avgDurationMinutes > 60) {
+  // 7. Peak hour overlap — community-reported: 5am-11am PT has throttled limits
+  if (sessionIntel?.available && sessionIntel.peakOverlapPct > 40) {
     recs.push({
-      severity: 'warning',
-      title: `Average session: ${Math.round(sessions.avgDurationMinutes)} minutes`,
-      detail: `Long sessions accumulate context that degrades both performance and cache efficiency. Sessions over 60 minutes often benefit from /compact.`,
-      action: 'Use /compact every 30-40 tool calls or when switching tasks. Start fresh sessions for new work.',
+      severity: 'info',
+      title: `${sessionIntel.peakOverlapPct}% of your work hits throttled hours`,
+      detail: 'Anthropic reduces 5-hour session limits during weekday peak hours (5am-11am PT / 12pm-6pm UTC). ~7% of users hit limits they wouldn\'t otherwise.',
+      action: 'Shift token-heavy work (refactors, test generation, codebase exploration) to off-peak hours. Session limits are unchanged — only the 5-hour window shrinks.',
     });
   }
 
-  // 8. Caching savings acknowledgment
-  if (cacheHealth.savings.fromCaching > 100) {
+  // 8. Cost anomalies
+  if (anomalies.hasAnomalies) {
+    const spikes = anomalies.anomalies.filter(a => a.type === 'spike');
+    if (spikes.length > 0) {
+      const worst = spikes[0];
+      recs.push({
+        severity: worst.severity,
+        title: `${spikes.length} cost spike${spikes.length > 1 ? 's' : ''} — worst: $${worst.cost.toFixed(0)} on ${worst.date}`,
+        detail: `+$${worst.deviation.toFixed(0)} above your $${worst.avgCost.toFixed(0)} daily average.${worst.cacheRatioAnomaly ? ' Cache ratio was also anomalous — strongly suggests cache bug.' : ''} GitHub #38029 documents a bug where a single session generated 652K phantom output tokens ($342).`,
+        action: 'Monitor the first 1-2 messages of each session. If a single message burns 3-5% of your quota, restart immediately.',
+      });
+    }
+  }
+
+  // 9. Positive: cache savings
+  if (cacheHealth.savings?.fromCaching > 100) {
     recs.push({
       severity: 'positive',
-      title: `Caching saved you ~$${cacheHealth.savings.fromCaching.toLocaleString()}`,
-      detail: 'Without prompt caching, your bill would be significantly higher. The cache system is working — the question is whether it breaks too often.',
-      action: 'No action needed. Keep sessions alive to maximize cache hits.',
+      title: `Cache saved you ~$${cacheHealth.savings.fromCaching.toLocaleString()}`,
+      detail: 'Without prompt caching, standard input pricing would have applied to all cache reads. The system is working — optimization is about reducing breaks.',
+      action: 'Keep sessions alive to maximize hits. Avoid mid-session CLAUDE.md edits and MCP tool changes.',
     });
   }
 
-  return recs;
+  // Cap at 5 most impactful recommendations
+  return recs.slice(0, 5);
 }

package/src/analyzers/session-intelligence.js

@@ -0,0 +1,114 @@
+/**
+ * Session Intelligence
+ * Analyzes session patterns: length, tool density, compact usage, productivity.
+ */
+export function analyzeSessionIntelligence(sessionMeta, jsonlEntries) {
+  if (!sessionMeta || sessionMeta.length === 0) {
+    return { available: false };
+  }
+
+  const sessions = sessionMeta.filter(s => s.durationMinutes > 0);
+  if (sessions.length === 0) return { available: false };
+
+  // Basic session stats
+  const durations = sessions.map(s => s.durationMinutes);
+  const totalMinutes = durations.reduce((s, d) => s + d, 0);
+  const avgDuration = totalMinutes / sessions.length;
+  const maxDuration = Math.max(...durations);
+  const longestSession = sessions.find(s => s.durationMinutes === maxDuration);
+
+  // Sort by duration for percentile calc
+  const sorted = [...durations].sort((a, b) => a - b);
+  const p50 = sorted[Math.floor(sorted.length * 0.5)];
+  const p90 = sorted[Math.floor(sorted.length * 0.9)];
+
+  // Long sessions (>60 min) — likely need /compact
+  const longSessions = sessions.filter(s => s.durationMinutes > 60);
+  const longSessionPct = sessions.length > 0 ? Math.round((longSessions.length / sessions.length) * 100) : 0;
+
+  // Tool call density per session
+  const toolDensities = sessions.map(s => {
+    const totalTools = Object.values(s.toolCounts || {}).reduce((sum, c) => sum + c, 0);
+    return { sessionId: s.sessionId, tools: totalTools, minutes: s.durationMinutes, density: s.durationMinutes > 0 ? (totalTools / s.durationMinutes).toFixed(1) : 0 };
+  });
+
+  const avgToolsPerSession = toolDensities.reduce((s, t) => s + t.tools, 0) / sessions.length;
+
+  // Most used tools across all sessions
+  const toolTotals = {};
+  for (const s of sessions) {
+    for (const [tool, count] of Object.entries(s.toolCounts || {})) {
+      toolTotals[tool] = (toolTotals[tool] || 0) + count;
+    }
+  }
+  const topTools = Object.entries(toolTotals)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 8)
+    .map(([name, count]) => ({ name, count }));
+
+  // Lines of code per session hour (productivity proxy)
+  const totalLines = sessions.reduce((s, x) => s + x.linesAdded + x.linesRemoved, 0);
+  const totalHours = totalMinutes / 60;
+  const linesPerHour = totalHours > 0 ? Math.round(totalLines / totalHours) : 0;
+
+  // Messages per session
+  const totalMessages = sessions.reduce((s, x) => s + x.userMessageCount + x.assistantMessageCount, 0);
+  const avgMessagesPerSession = Math.round(totalMessages / sessions.length);
+
+  // Time-of-day distribution (from JSONL timestamps)
+  const hourDistribution = new Array(24).fill(0);
+  if (jsonlEntries && jsonlEntries.length > 0) {
+    for (const entry of jsonlEntries) {
+      if (!entry.timestamp) continue;
+      try {
+        const d = new Date(entry.timestamp);
+        if (!isNaN(d.getTime())) {
+          hourDistribution[d.getHours()]++;
+        }
+      } catch { /* skip */ }
+    }
+  }
+
+  // Peak hours (top 3)
+  const peakHours = hourDistribution
+    .map((count, hour) => ({ hour, count }))
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 3)
+    .map(h => ({ hour: h.hour, label: formatHour(h.hour), count: h.count }));
+
+  // Off-peak overlap check (5am-11am PT = 12pm-6pm UTC, roughly)
+  const offPeakStart = 12; // UTC
+  const offPeakEnd = 18;
+  const peakOverlapMessages = hourDistribution
+    .slice(offPeakStart, offPeakEnd + 1)
+    .reduce((s, c) => s + c, 0);
+  const totalHourMessages = hourDistribution.reduce((s, c) => s + c, 0);
+  const peakOverlapPct = totalHourMessages > 0 ? Math.round((peakOverlapMessages / totalHourMessages) * 100) : 0;
+
+  return {
+    available: true,
+    totalSessions: sessions.length,
+    totalMinutes,
+    avgDuration: Math.round(avgDuration),
+    medianDuration: p50,
+    p90Duration: p90,
+    maxDuration,
+    longestSessionProject: longestSession?.projectPath,
+    longSessions: longSessions.length,
+    longSessionPct,
+    avgToolsPerSession: Math.round(avgToolsPerSession),
+    topTools,
+    linesPerHour,
+    avgMessagesPerSession,
+    peakHours,
+    peakOverlapPct,
+    hourDistribution,
+  };
+}
+
+function formatHour(h) {
+  if (h === 0) return '12am';
+  if (h < 12) return h + 'am';
+  if (h === 12) return '12pm';
+  return (h - 12) + 'pm';
+}

package/src/cli/index.js

@@ -16,6 +16,8 @@ import { analyzeCacheHealth } from '../analyzers/cache-health.js';
 import { detectAnomalies } from '../analyzers/anomaly-detector.js';
 import { generateRecommendations } from '../analyzers/recommendations.js';
 import { detectInflectionPoints } from '../analyzers/inflection-detector.js';
+import { analyzeSessionIntelligence } from '../analyzers/session-intelligence.js';
+import { analyzeModelRouting } from '../analyzers/model-routing.js';
 import { renderHTML } from '../renderers/html-report.js';
 import { renderTerminal } from '../renderers/terminal-summary.js';
 
@@ -115,21 +117,24 @@ async function main() {
   const cacheHealth = analyzeCacheHealth(statsCache, cacheBreaks, allTimeDays, dailyFromJSONL);
   const anomalies = detectAnomalies(costAnalysis);
   const inflection = detectInflectionPoints(dailyFromJSONL);
-  const recommendations = generateRecommendations(costAnalysis, cacheHealth, claudeMdStack, anomalies, inflection);
-
-  if (inflection) {
-    console.log(`  ✓ Inflection point: ${inflection.summary}`);
-  }
+  const sessionIntel = analyzeSessionIntelligence(sessionMeta, jsonlEntries);
+  const modelRouting = analyzeModelRouting(costAnalysis, jsonlEntries);
+  const recommendations = generateRecommendations(costAnalysis, cacheHealth, claudeMdStack, anomalies, inflection, sessionIntel, modelRouting);
 
+  if (inflection) console.log(`  ✓ Inflection: ${inflection.summary}`);
+  if (sessionIntel.available) console.log(`  ✓ ${sessionIntel.totalSessions} sessions analyzed (${sessionIntel.avgDuration} min avg)`);
+  if (modelRouting.available) console.log(`  ✓ Model routing: ${modelRouting.opusPct}% Opus, ${modelRouting.sonnetPct}% Sonnet`);
   console.log(`  ✓ ${projectBreakdown.length} projects detected`);
 
   const report = {
     generatedAt: new Date().toISOString(),
-    periodDays: flags.days, // Default view in HTML
+    periodDays: flags.days,
     costAnalysis,
     cacheHealth,
     anomalies,
     inflection,
+    sessionIntel,
+    modelRouting,
     projectBreakdown,
     claudeMdStack,
     oauthUsage,

package/src/readers/claude-md.js

@@ -6,15 +6,41 @@ export function readClaudeMdStack(claudeDir) {
   const home = homedir();
   const stack = [];
 
-  // Global CLAUDE.md
+  // Global CLAUDE.md — detailed section analysis
   const globalPath = join(home, '.claude', 'CLAUDE.md');
+  let globalSections = [];
   if (existsSync(globalPath)) {
     const stat = statSync(globalPath);
+    const content = readFileSync(globalPath, 'utf-8');
+    const lines = content.split('\n');
+    const lineCount = lines.length;
+
+    // Parse sections (## headings)
+    let currentSection = { name: 'Header', lines: 0, bytes: 0 };
+    const sections = [];
+    for (const line of lines) {
+      if (line.match(/^##\s+/)) {
+        if (currentSection.lines > 0) sections.push(currentSection);
+        currentSection = { name: line.replace(/^#+\s*/, '').trim(), lines: 0, bytes: 0 };
+      }
+      currentSection.lines++;
+      currentSection.bytes += Buffer.byteLength(line + '\n', 'utf-8');
+    }
+    if (currentSection.lines > 0) sections.push(currentSection);
+
+    // Add token estimates and sort by size
+    globalSections = sections
+      .map(s => ({ ...s, tokens: Math.round(s.bytes / 4) }))
+      .sort((a, b) => b.bytes - a.bytes);
+
     stack.push({
       level: 'global',
       path: globalPath,
       bytes: stat.size,
       tokensEstimate: Math.round(stat.size / 4),
+      lineCount,
+      sectionCount: sections.length,
+      sections: globalSections,
     });
   }
 
@@ -54,6 +80,7 @@ export function readClaudeMdStack(claudeDir) {
 
   return {
     files: stack,
+    globalSections,
     totalBytes,
     totalTokensEstimate,
     settingsBytes: settingsSize,