claude-roi 0.6.0 → 0.7.0

package/CLAUDE.md

@@ -0,0 +1,119 @@
+# CLAUDE.md — Codelens-AI
+
+## Project Overview
+
+**Codelens AI** (`claude-roi` on npm) is a CLI tool that measures ROI from AI coding agents by correlating Claude Code token usage with git commit output. It parses Claude Code session files, analyzes git history, and serves an interactive dashboard at `http://localhost:3457`.
+
+**Version:** 0.6.0
+**License:** MIT
+**npm package:** `claude-roi`
+
+## Tech Stack
+
+- **Runtime:** Node.js >= 18, ES modules (`"type": "module"`)
+- **Backend:** Express.js 5.0.0
+- **CLI:** Commander.js 13.0.0
+- **Frontend:** Single-file HTML (`src/dashboard.html`) with vanilla JS + Chart.js 4.4.7
+- **Testing:** Playwright (E2E)
+- **Styling:** Inline CSS with CSS variables, glassmorphism design, dark/light theme
+
+## Project Structure
+
+```
+src/
+├── index.js           # CLI entry point & orchestration (Commander)
+├── claude-parser.js   # Parses JSONL session files from ~/.claude/projects/
+├── git-analyzer.js    # Git log analysis, branch detection, diff stats
+├── correlator.js      # Matches sessions to commits via file overlap + time window
+├── metrics.js         # ROI calculations, grades, insights, heatmap, survival rate
+├── server.js          # Express REST API routes
+├── cache.js           # Smart caching with stale file detection
+├── dashboard.html     # Single-file SPA dashboard (3000+ lines)
+└── agents/            # Agent integration stubs (claude/, cursor/)
+
+tests/
+└── dashboard.spec.js  # Playwright E2E tests
+
+.github/workflows/
+├── ci.yml             # CI: syntax check, Node 18/20/22 matrix
+└── release.yml        # npm publish on version tag push
+```
+
+## Data Flow
+
+```
+Claude Sessions (JSONL) → claude-parser.js → [Cache] → git-analyzer.js
+→ correlator.js → metrics.js → server.js (REST API) → dashboard.html
+```
+
+## Key API Routes (server.js)
+
+- `GET /` — dashboard HTML
+- `GET /api/all` — full payload
+- `GET /api/summary` — hero stats + insights
+- `GET /api/timeline` — daily cost/output chart data
+- `GET /api/sessions` — paginated sessions with sorting
+- `GET /api/models` — model breakdown
+- `GET /api/heatmap` — productivity heatmap
+- `GET /api/tools` — tool usage breakdown
+- `GET /api/survival` — line survival stats
+- `GET /api/tokens` — detailed token analytics
+- `POST /api/refresh` — force re-parse
+
+## CLI Usage
+
+```bash
+npx claude-roi                  # defaults: 30 days, port 3457
+npx claude-roi --days 90        # custom lookback
+npx claude-roi --port 8080      # custom port
+npx claude-roi --no-open        # don't auto-open browser
+npx claude-roi --json           # dump raw JSON to stdout
+npx claude-roi --project X      # filter by project name
+npx claude-roi --refresh        # force full re-parse
+```
+
+## Development Commands
+
+```bash
+npm install                     # install dependencies
+npm test                        # run Playwright E2E tests (needs fixtures)
+node src/index.js               # run locally
+node --check src/*.js           # syntax validation
+```
+
+## Key Design Decisions
+
+- **Single-file dashboard** — no build step, served directly by Express
+- **Zero-config** — auto-discovers `~/.claude/projects/`
+- **Smart caching** — incremental parsing, only re-processes changed JSONL files (`~/.cache/agent-analytics/`)
+- **File-first correlation** — sessions matched to commits by file overlap, 2-hour temporal buffer
+- **Privacy-first** — all data stays local, no telemetry
+- **Version-aware pricing** — token costs reflect Anthropic's pricing tiers per model
+
+## Coding Conventions
+
+- ES module imports (`import`/`export`)
+- No build tooling or transpilation
+- Inline styles and scripts in dashboard.html (no external CSS/JS bundles)
+- Express 5 (path params, async error handling)
+- Functions and variables use camelCase
+- Constants defined at module top
+
+## Available Skills
+
+Use these skills when working on this project:
+
+- **`/simplify`** — Review changed code for reuse, quality, and efficiency, then fix issues found. Use after writing or modifying code.
+- **`/frontend-design`** — Create distinctive, production-grade frontend interfaces. Use when modifying `dashboard.html` or building new UI components.
+- **`/claude-developer-platform`** — Build apps with the Claude API or Anthropic SDK. Use when working on agent integrations in `src/agents/`.
+- **`/find-skills`** — Discover and install new agent skills for extended capabilities.
+- **`/keybindings-help`** — Configure keyboard shortcuts for Claude Code.
+
+## Important Notes
+
+- The dashboard is a single 3000+ line HTML file — changes should maintain the inline architecture
+- Cache is stored at `~/.cache/agent-analytics/parsed-sessions.json`
+- Session JSONL files are at `~/.claude/projects/`
+- Token pricing is hardcoded in `claude-parser.js` — update when Anthropic changes pricing
+- Playwright tests require Claude session fixtures to run (run locally, not in CI)
+- CI runs syntax checks only; E2E tests are local-only

package/README.md

@@ -79,6 +79,11 @@ This parses your `~/.claude/projects/` session data, analyzes your git repos, an
 | **Model Comparison**  | Efficiency breakdown across Opus, Sonnet, and Haiku             |
 | **Branch Awareness**  | What % of AI commits landed on production                       |
 | **Peak Hours**        | Hour-of-day x day-of-week productivity heatmap                  |
+| **Autonomy Score**    | Composite A-F grade measuring how independently the agent works |
+| **Autopilot Ratio**   | Assistant messages per user prompt (higher = more autonomous)   |
+| **Self-Heal Score**   | % of bash calls that are test/lint commands (self-verification) |
+| **Toolbelt Coverage** | % of available tools used per session (workflow breadth)        |
+| **Commit Velocity**   | Tool calls per commit (lower = more efficient)                  |
 
 ## CLI Options
 
@@ -90,6 +95,7 @@ claude-roi --no-open              # don't auto-open browser
 claude-roi --json                 # dump all metrics as JSON to stdout
 claude-roi --project techops      # filter to a specific project
 claude-roi --refresh              # force full re-parse (ignore cache)
+claude-roi --autonomy             # print autonomy score to terminal and exit
 ```
 
 ## Dashboard
@@ -102,7 +108,8 @@ The dashboard includes:
 - **Model comparison** — cost breakdown by Claude model
 - **Session length analysis** — which session sizes have the best ROI
 - **Productivity heatmap** — GitHub-style grid showing when you're most productive
-- **Sessions table** — sortable, expandable table with per-session metrics and matched commits
+- **Agent Autonomy** — autonomy score badge, autopilot ratio, self-heal score, toolbelt coverage, commit velocity, and top verification commands
+- **Sessions table** — sortable, expandable table with per-session metrics, matched commits, and autopilot ratio
 
 ## How It Works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-roi",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Correlate Claude Code token usage with git output to measure AI coding agent ROI",
   "type": "module",
   "bin": {

package/skills-lock.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "skills": {
+    "frontend-design": {
+      "source": "anthropics/skills",
+      "sourceType": "github",
+      "computedHash": "063a0e6448123cd359ad0044cc46b0e490cc7964d45ef4bb9fd842bd2ffbca67"
+    }
+  }
+}

package/src/cache.js

@@ -4,7 +4,7 @@ import os from 'node:os';
 
 const CACHE_DIR = path.join(os.homedir(), '.cache', 'agent-analytics');
 const CACHE_FILE = path.join(CACHE_DIR, 'parsed-sessions.json');
-const CACHE_VERSION = 1;
+const CACHE_VERSION = 2;
 
 export function loadCache() {
   if (!existsSync(CACHE_FILE)) {

package/src/claude-parser.js

@@ -96,6 +96,43 @@ function toRelativePath(absolutePath, repoPath) {
   return absolutePath.split('/').pop();
 }
 
+// Commands that are clearly NOT verification even if they contain matching keywords
+const NON_VERIFICATION_PATTERNS = [
+  /^\s*node\s+-e\b/,        // inline JS eval
+  /^\s*find\s+/,            // file search
+  /^\s*cat\s+/,             // file display
+  /^\s*echo\s+/,            // printing
+  /^\s*ls\b/,               // listing
+  /^\s*rm\s+/,              // file deletion
+];
+
+// Patterns that identify test/lint/typecheck commands (for autonomy self-heal score)
+const VERIFICATION_PATTERNS = [
+  /\bnpm\s+(test|run\s+(test|lint|check|typecheck))\b/,
+  /\b(pnpm|yarn|bun)\s+(run\s+)?(test|lint|check|typecheck)\b/,
+  /\b(jest|vitest|mocha|ava)\b/,
+  /\b(pytest|python\s+-m\s+(pytest|unittest))\b/,
+  /\b(go\s+test|cargo\s+(test|clippy))\b/,
+  /\b(eslint|biome|prettier\b.*--check)/,
+  /\btsc(\s+--noEmit|\s+-p)\b/,
+  /\b(mypy|ruff|flake8|pylint|rubocop)\b/,
+  /\bnode\s+--check\b/,
+  /\bmake\s+(test|check|lint)\b/,
+];
+
+function isVerificationCommand(command) {
+  if (!command || typeof command !== 'string') return false;
+  // Strip cd/path and env var prefixes to get the core command
+  const core = command
+    .replace(/^(?:cd\s+\S+\s*&&\s*)+/g, '')
+    .replace(/^(?:cd\s+\S+\s*;\s*)+/g, '')
+    .replace(/^(?:\w+=\S+\s+)+/g, '')
+    .trim();
+  // Exclude commands that are clearly not verification
+  if (NON_VERIFICATION_PATTERNS.some(p => p.test(core))) return false;
+  return VERIFICATION_PATTERNS.some(p => p.test(core));
+}
+
 function extractToolUse(session, msg) {
   const content = msg.content;
   if (!Array.isArray(content)) return;
@@ -108,6 +145,17 @@ function extractToolUse(session, msg) {
     // Count tool calls
     session.toolCalls[toolName] = (session.toolCalls[toolName] || 0) + 1;
 
+    // Track Bash commands for autonomy self-heal scoring
+    if (toolName === 'Bash') {
+      const command = block.input?.command || block.input?.content;
+      if (command) {
+        session.totalBashCalls++;
+        const isVerif = isVerificationCommand(command);
+        if (isVerif) session.verificationBashCalls++;
+        session.bashCommands.push({ command: command.slice(0, 200), isVerification: isVerif });
+      }
+    }
+
     // Track files written/read
     const filePath = block.input?.file_path;
     if (!filePath) continue;
@@ -145,6 +193,9 @@ function createEmptySession(sessionId) {
     filesRead: [],
     userMessageCount: 0,
     assistantMessageCount: 0,
+    bashCommands: [],
+    totalBashCalls: 0,
+    verificationBashCalls: 0,
   };
 }
 
@@ -380,6 +431,11 @@ function mergeSubagentIntoSession(parent, sub) {
     parent.toolCalls[tool] = (parent.toolCalls[tool] || 0) + count;
   }
 
+  // Merge bash command tracking
+  parent.totalBashCalls += sub.totalBashCalls;
+  parent.verificationBashCalls += sub.verificationBashCalls;
+  parent.bashCommands.push(...sub.bashCommands);
+
   // Merge files
   for (const f of sub.filesWritten) {
     if (!parent.filesWritten.includes(f)) parent.filesWritten.push(f);

package/src/dashboard.html

@@ -1517,6 +1517,254 @@
     .share-toast.visible {
       opacity: 1;
     }
+
+    /* ── Autonomy Section ───────────────────────── */
+    @property --auto-deg {
+      syntax: '<angle>';
+      initial-value: 0deg;
+      inherits: false;
+    }
+    .autonomy-section { margin-bottom: 48px; }
+    .autonomy-section h2 {
+      font-family: var(--font-display);
+      font-size: 1rem;
+      font-weight: 700;
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      color: var(--text-secondary);
+      margin-bottom: 24px;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    .autonomy-layout {
+      display: grid;
+      grid-template-columns: 220px 1fr;
+      gap: 24px;
+      align-items: stretch;
+    }
+    @media (max-width: 768px) {
+      .autonomy-layout { grid-template-columns: 1fr; }
+      .autonomy-score-hub { justify-self: center; max-width: 240px; }
+    }
+
+    /* Score hub — the big badge */
+    .autonomy-score-hub {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 12px;
+      padding: 28px 20px;
+      background: linear-gradient(145deg, var(--glass-bg-from), var(--glass-bg-to));
+      backdrop-filter: blur(16px);
+      border: 1px solid var(--glass-border);
+      border-radius: var(--radius);
+      position: relative;
+      overflow: hidden;
+    }
+    .autonomy-score-hub::before {
+      content: '';
+      position: absolute;
+      inset: 0;
+      background: radial-gradient(circle at 50% 20%, var(--auto-glow, rgba(34, 211, 168, 0.08)), transparent 70%);
+      pointer-events: none;
+    }
+    .autonomy-ring {
+      width: 130px;
+      height: 130px;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      position: relative;
+      flex-shrink: 0;
+    }
+    .autonomy-ring::before {
+      content: '';
+      position: absolute;
+      inset: 0;
+      border-radius: 50%;
+      padding: 5px;
+      background: conic-gradient(var(--auto-color) 0deg, var(--auto-color) var(--auto-deg, 0deg), var(--bg-hover) var(--auto-deg, 0deg));
+      -webkit-mask: linear-gradient(#fff 0 0) content-box, linear-gradient(#fff 0 0);
+      -webkit-mask-composite: xor;
+      mask-composite: exclude;
+      animation: autoRingReveal 1.5s cubic-bezier(0.25, 0.46, 0.45, 0.94) forwards;
+    }
+    @keyframes autoRingReveal {
+      from { --auto-deg: 0deg; }
+    }
+    .autonomy-ring .auto-grade {
+      font-family: var(--font-display);
+      font-size: 3rem;
+      font-weight: 800;
+      line-height: 1;
+    }
+    .autonomy-score-label {
+      font-family: var(--font-display);
+      font-size: 0.75rem;
+      color: var(--text-muted);
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      text-align: center;
+    }
+    .autonomy-score-num {
+      font-family: var(--font-display);
+      font-size: 1.1rem;
+      font-weight: 700;
+      color: var(--text-primary);
+    }
+
+    /* Metric cards grid */
+    .autonomy-cards {
+      display: grid;
+      grid-template-columns: repeat(2, 1fr);
+      gap: 16px;
+    }
+    @media (max-width: 520px) {
+      .autonomy-cards { grid-template-columns: 1fr; }
+    }
+    .auto-metric {
+      background: linear-gradient(145deg, var(--glass-bg-from), var(--glass-bg-to));
+      backdrop-filter: blur(16px);
+      border: 1px solid var(--glass-border);
+      border-radius: var(--radius);
+      padding: 20px;
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+      transition: border-color 0.2s, box-shadow 0.2s;
+    }
+    .auto-metric:hover {
+      border-color: var(--glass-border-hover);
+      box-shadow: 0 4px 20px var(--shadow-card);
+    }
+    .auto-metric .metric-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .auto-metric .metric-name {
+      font-family: var(--font-display);
+      font-size: 0.7rem;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--text-muted);
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+    .auto-metric .metric-value {
+      font-family: var(--font-display);
+      font-size: 1.6rem;
+      font-weight: 800;
+      line-height: 1;
+    }
+    .auto-metric .metric-bar {
+      height: 6px;
+      background: var(--overlay-medium);
+      border-radius: 3px;
+      overflow: hidden;
+    }
+    .auto-metric .metric-bar .fill {
+      height: 100%;
+      border-radius: 3px;
+      transition: width 1s cubic-bezier(0.25, 0.46, 0.45, 0.94);
+    }
+    .auto-metric .metric-sub {
+      font-size: 0.75rem;
+      color: var(--text-muted);
+    }
+
+    /* Breakdown bar */
+    .autonomy-breakdown {
+      margin-top: 20px;
+      grid-column: 1 / -1;
+    }
+    .autonomy-breakdown .breakdown-label {
+      font-family: var(--font-display);
+      font-size: 0.7rem;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--text-muted);
+      margin-bottom: 8px;
+    }
+    .breakdown-bar {
+      display: flex;
+      height: 10px;
+      border-radius: 5px;
+      overflow: hidden;
+      background: var(--overlay-medium);
+    }
+    .breakdown-bar .seg {
+      height: 100%;
+      transition: width 0.8s ease;
+    }
+    .breakdown-legend {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 12px;
+      margin-top: 8px;
+      font-size: 0.7rem;
+      color: var(--text-secondary);
+    }
+    .breakdown-legend span {
+      display: flex;
+      align-items: center;
+      gap: 5px;
+    }
+    .breakdown-legend .ldot {
+      width: 6px;
+      height: 6px;
+      border-radius: 50%;
+      display: inline-block;
+    }
+
+    /* Top commands */
+    .auto-commands {
+      margin-top: 16px;
+      grid-column: 1 / -1;
+      background: linear-gradient(145deg, var(--glass-bg-from), var(--glass-bg-to));
+      border: 1px solid var(--glass-border);
+      border-radius: var(--radius);
+      padding: 16px 20px;
+    }
+    .auto-commands .cmd-title {
+      font-family: var(--font-display);
+      font-size: 0.7rem;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--text-muted);
+      margin-bottom: 10px;
+    }
+    .auto-commands .cmd-list {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+    .auto-commands .cmd-tag {
+      font-family: var(--font-display);
+      font-size: 0.72rem;
+      padding: 4px 10px;
+      border-radius: 4px;
+      background: var(--overlay-strong);
+      color: var(--text-secondary);
+      border: 1px solid var(--overlay-intense);
+    }
+    .auto-commands .cmd-tag .cmd-count {
+      color: var(--accent-green);
+      font-weight: 600;
+      margin-left: 4px;
+    }
+
+    /* Autopilot badge in sessions table */
+    .autopilot-badge {
+      font-family: var(--font-display);
+      font-size: 0.75rem;
+      font-weight: 600;
+      color: var(--accent-cyan);
+    }
   </style>
 </head>
 <body>
@@ -1803,6 +2051,7 @@ function render() {
         <div id="heatmap-container"></div>
       </div>
     </div>
+    <div class="scroll-reveal">${renderAutonomySection(d.autonomyMetrics)}</div>
     <div class="scroll-reveal">${renderCacheEfficiency(t)}</div>
     <div class="scroll-reveal">${renderSurvival(d.lineSurvival)}</div>
     <div class="scroll-reveal">${renderSessionsTable(d.sessions)}</div>
@@ -2093,6 +2342,105 @@ function renderTokenFunFacts(facts) {
   </div>`;
 }
 
+function renderAutonomySection(am) {
+  if (!am) return '';
+  const g = am.overall.grade;
+  const s = am.overall.score;
+  const gradeColor = GRADE_VAR[g] || GRADE_VAR.F;
+  const gradeBg = GRADE_BG_VAR[g] || GRADE_BG_VAR.F;
+  const deg = Math.round((s / 100) * 360);
+
+  // Glow color map
+  const glowMap = { A: 'rgba(34,211,168,0.08)', B: 'rgba(59,130,246,0.08)', C: 'rgba(245,158,11,0.08)', D: 'rgba(240,136,62,0.08)', F: 'rgba(239,68,68,0.08)' };
+
+  // Velocity bar: lower is better, cap at 100 steps
+  const velPct = am.commitVelocity !== null ? Math.max(0, 100 - am.commitVelocity) : 0;
+  const velLabel = am.commitVelocity !== null
+    ? (am.commitVelocity <= 20 ? 'Blazing' : am.commitVelocity <= 50 ? 'Solid' : 'Heavy')
+    : 'N/A';
+
+  // Breakdown percentages (out of total weight = 100)
+  const bd = am.breakdown;
+  const bTotal = (bd.autopilotScore * 0.25 + bd.selfHealWeighted * 0.30 + bd.toolbeltWeighted * 0.20 + bd.velocityScore * 0.25) || 1;
+  const bAuto = Math.round((bd.autopilotScore * 0.25 / bTotal) * 100);
+  const bHeal = Math.round((bd.selfHealWeighted * 0.30 / bTotal) * 100);
+  const bTool = Math.round((bd.toolbeltWeighted * 0.20 / bTotal) * 100);
+  const bVel = 100 - bAuto - bHeal - bTool;
+
+  return `<div class="autonomy-section">
+    <h2>Agent Autonomy <i class="info-tip" data-tip="How independently your AI agent works. Measures autopilot ratio (actions per prompt), self-healing (test/lint usage), tool diversity, and commit efficiency.">i</i></h2>
+    <div class="autonomy-layout">
+      <div class="autonomy-score-hub" style="--auto-glow: ${glowMap[g] || glowMap.F};">
+        <div class="autonomy-ring" style="--auto-color: ${gradeColor}; --auto-deg: ${deg}deg;">
+          <div class="auto-grade" style="color: ${gradeColor};">${g}</div>
+        </div>
+        <div class="autonomy-score-num">${s} / 100</div>
+        <div class="autonomy-score-label">Autonomy Score</div>
+      </div>
+      <div>
+        <div class="autonomy-cards">
+          <div class="auto-metric">
+            <div class="metric-header">
+              <span class="metric-name">Autopilot Ratio <i class="info-tip" data-tip="Agent responses per user message. Higher means the agent does more per prompt. 5x = max score.">i</i></span>
+            </div>
+            <div class="metric-value" style="color: var(--accent-cyan);">${am.autopilotRatio}x</div>
+            <div class="metric-bar"><div class="fill" style="width: ${Math.min(am.autopilotRatio / 5 * 100, 100)}%; background: var(--accent-cyan);"></div></div>
+            <div class="metric-sub">${am.autopilotRatio >= 4 ? 'High autonomy' : am.autopilotRatio >= 2 ? 'Moderate' : 'Low — agent needs more prompts'}</div>
+          </div>
+          <div class="auto-metric">
+            <div class="metric-header">
+              <span class="metric-name">Self-Heal Score <i class="info-tip" data-tip="Percentage of Bash commands that are tests, lints, or type checks. Higher means the agent verifies its own work.">i</i></span>
+            </div>
+            <div class="metric-value" style="color: var(--accent-green);">${am.selfHealScore}%</div>
+            <div class="metric-bar"><div class="fill" style="width: ${am.selfHealScore}%; background: var(--accent-green);"></div></div>
+            <div class="metric-sub">${am.totalVerificationCalls} of ${am.totalBashCalls} bash calls were tests/lints</div>
+          </div>
+          <div class="auto-metric">
+            <div class="metric-header">
+              <span class="metric-name">Toolbelt Coverage <i class="info-tip" data-tip="Percentage of available tools (Read, Write, Edit, Bash, Grep, Glob, etc.) the agent uses per session. Higher diversity suggests more complete autonomous workflow.">i</i></span>
+            </div>
+            <div class="metric-value" style="color: var(--accent-purple);">${am.toolbeltCoverage}%</div>
+            <div class="metric-bar"><div class="fill" style="width: ${am.toolbeltCoverage}%; background: var(--accent-purple);"></div></div>
+            <div class="metric-sub">${am.toolbeltCoverage >= 70 ? 'Full toolbelt utilization' : am.toolbeltCoverage >= 40 ? 'Moderate diversity' : 'Narrow tool usage'}</div>
+          </div>
+          <div class="auto-metric">
+            <div class="metric-header">
+              <span class="metric-name">Commit Velocity <i class="info-tip" data-tip="Average tool calls needed per commit. Lower = more efficient agent. Under 20 is blazing fast.">i</i></span>
+            </div>
+            <div class="metric-value" style="color: var(--accent-blue);">${am.commitVelocity !== null ? am.commitVelocity : '—'}<span style="font-size:0.7rem;font-weight:500;color:var(--text-muted);margin-left:4px;">${am.commitVelocity !== null ? 'steps/commit' : ''}</span></div>
+            <div class="metric-bar"><div class="fill" style="width: ${velPct}%; background: var(--accent-blue);"></div></div>
+            <div class="metric-sub">${velLabel}</div>
+          </div>
+        </div>
+        <div class="autonomy-breakdown">
+          <div class="breakdown-label">Score Composition</div>
+          <div class="breakdown-bar">
+            <div class="seg" style="width: ${bAuto}%; background: var(--accent-cyan);" title="Autopilot ${bd.autopilotScore}"></div>
+            <div class="seg" style="width: ${bHeal}%; background: var(--accent-green);" title="Self-Heal ${bd.selfHealWeighted}"></div>
+            <div class="seg" style="width: ${bTool}%; background: var(--accent-purple);" title="Toolbelt ${bd.toolbeltWeighted}"></div>
+            <div class="seg" style="width: ${bVel}%; background: var(--accent-blue);" title="Velocity ${bd.velocityScore}"></div>
+          </div>
+          <div class="breakdown-legend">
+            <span><span class="ldot" style="background: var(--accent-cyan);"></span>Autopilot 25%</span>
+            <span><span class="ldot" style="background: var(--accent-green);"></span>Self-Heal 30%</span>
+            <span><span class="ldot" style="background: var(--accent-purple);"></span>Toolbelt 20%</span>
+            <span><span class="ldot" style="background: var(--accent-blue);"></span>Velocity 25%</span>
+          </div>
+        </div>
+        ${am.topVerificationCommands.length > 0 ? `
+        <div class="auto-commands">
+          <div class="cmd-title">Top Verification Commands</div>
+          <div class="cmd-list">
+            ${am.topVerificationCommands.slice(0, 6).map(c =>
+              `<span class="cmd-tag">${c.command}<span class="cmd-count">&times;${c.count}</span></span>`
+            ).join('')}
+          </div>
+        </div>` : ''}
+      </div>
+    </div>
+  </div>`;
+}
+
 function renderCacheEfficiency(t) {
   const hitRate = t.cacheHitRate;
   const accentColor = hitRate >= 60 ? 'var(--accent-blue)' : hitRate >= 30 ? 'var(--accent-orange)' : 'var(--accent-red)';
@@ -2142,6 +2490,7 @@ function renderSessionsTable(sessions) {
             <th onclick="sortTable('projectName')" class="${sortCol === 'projectName' ? 'sorted' : ''}">Project${thArrow('projectName')}</th>
             <th onclick="sortTable('model')" class="${sortCol === 'model' ? 'sorted' : ''}">Model${thArrow('model')} <i class="info-tip" data-tip="Primary model used in the session. Models marked (sub) are subagents spawned for background tasks like code search and exploration.">i</i></th>
             <th onclick="sortTable('msgCount')" class="${sortCol === 'msgCount' ? 'sorted' : ''}">Msgs${thArrow('msgCount')} <i class="info-tip" data-tip="Total messages in the session (your messages + Claude's responses).">i</i></th>
+            <th onclick="sortTable('autopilotRatio')" class="${sortCol === 'autopilotRatio' ? 'sorted' : ''}">Autopilot${thArrow('autopilotRatio')} <i class="info-tip" data-tip="Agent responses per user message. Higher = more autonomous. 5x is excellent.">i</i></th>
             <th onclick="sortTable('cost.totalCost')" class="${sortCol === 'cost.totalCost' ? 'sorted' : ''}">Cost${thArrow('cost.totalCost')} <i class="info-tip" data-tip="Estimated cost based on token usage and Anthropic's pricing. Calculated from input, output, cache read (90% discount), and cache write (25% premium) tokens.">i</i></th>
             <th onclick="sortTable('commitCount')" class="${sortCol === 'commitCount' ? 'sorted' : ''}">Commits${thArrow('commitCount')} <i class="info-tip" data-tip="Git commits that touch files Claude edited in this session. Falls back to time-window for chat-only sessions.">i</i></th>
             <th onclick="sortTable('linesAdded')" class="${sortCol === 'linesAdded' ? 'sorted' : ''}">Lines${thArrow('linesAdded')} <i class="info-tip" data-tip="Lines added / lines deleted in matched commits.">i</i></th>
@@ -2168,13 +2517,14 @@ function renderSessionsTable(sessions) {
                 <td>${s.projectName || '—'}</td>
                 <td>${modelDisplay}</td>
                 <td>${s.userMessageCount + s.assistantMessageCount}</td>
+                <td><span class="autopilot-badge">${s.autopilotRatio > 0 ? s.autopilotRatio + 'x' : '—'}</span></td>
                 <td>$${s.cost.totalCost.toFixed(2)}</td>
                 <td>${s.commitCount}</td>
                 <td><span style="color:var(--accent-green)">+${s.linesAdded.toLocaleString()}</span> / <span style="color:var(--accent-red)">-${s.linesDeleted.toLocaleString()}</span></td>
                 <td><span class="grade-badge" style="background:${gradeBg};color:${gradeColor};">${s.grade}</span></td>
               </tr>
               <tr class="expand-row" id="expand-${idx}">
-                <td colspan="8">
+                <td colspan="9">
                   <div class="expand-content">
                     ${s.commits.length > 0 ? s.commits.map(c => `
                       <div class="commit-item">
@@ -2556,7 +2906,7 @@ function bindEvents() {
     });
 
     // Animate bar fills
-    document.querySelectorAll('.survival-bar .fill, .waste-bar .fill').forEach(el => {
+    document.querySelectorAll('.survival-bar .fill, .waste-bar .fill, .metric-bar .fill').forEach(el => {
       const targetWidth = el.style.width;
       el.style.width = '0%';
       requestAnimationFrame(() => {

package/src/index.js

@@ -90,7 +90,8 @@ async function main() {
     .option('--no-open', 'do not auto-open browser')
     .option('--json', 'output raw JSON to stdout instead of starting server')
     .option('--project <name>', 'filter to specific project')
-    .option('--refresh', 'force full re-parse, ignore cache');
+    .option('--refresh', 'force full re-parse, ignore cache')
+    .option('--autonomy', 'print autonomy metrics table to stdout and exit');
 
   program.parse();
   const opts = program.opts();
@@ -115,6 +116,28 @@ async function main() {
     process.exit(0);
   }
 
+  if (opts.autonomy) {
+    const am = payload.autonomyMetrics;
+    const GRADE_COLOR = { A: '\x1b[32m', B: '\x1b[36m', C: '\x1b[33m', D: '\x1b[33m', F: '\x1b[31m' };
+    const gc = GRADE_COLOR[am.overall.grade] || '\x1b[0m';
+    const line = '\u2500'.repeat(35);
+    console.log('');
+    console.log(`  ${gc}Autonomy Score: ${am.overall.grade}\x1b[0m (${am.overall.score}/100)`);
+    console.log(`  ${line}`);
+    console.log(`  Autopilot Ratio     ${am.autopilotRatio}x`);
+    console.log(`  Self-Heal Score     ${am.selfHealScore}%`);
+    console.log(`  Toolbelt Coverage   ${am.toolbeltCoverage}%`);
+    console.log(`  Commit Velocity     ${am.commitVelocity !== null ? am.commitVelocity + ' steps/commit' : 'N/A'}`);
+    console.log(`  ${line}`);
+    if (am.topVerificationCommands.length > 0) {
+      const top3 = am.topVerificationCommands.slice(0, 3)
+        .map(c => `${c.command} (${c.count})`).join(', ');
+      console.log(`  Top Tests: ${top3}`);
+    }
+    console.log('');
+    process.exit(0);
+  }
+
   // Start server — pass a rebuild function so /api/refresh can re-run the pipeline
   const rebuild = () => buildPayload(claudeDir, days, opts.project, true);
   const app = createServer(payload, rebuild);

package/src/metrics.js

@@ -149,6 +149,110 @@ function computeLineSurvival(commitsByRepo) {
   return { totalAdded, totalChurned, surviving, survivalRate };
 }
 
+// ---- Autonomy metrics ----
+const KNOWN_TOOLS = [
+  'Bash', 'Read', 'Write', 'Edit', 'MultiEdit', 'Glob', 'Grep', 'LS',
+  'WebFetch', 'WebSearch', 'NotebookEdit', 'NotebookRead', 'TodoWrite', 'Agent',
+];
+const TOTAL_AVAILABLE_TOOLS = KNOWN_TOOLS.length; // 14
+
+function computeAutonomyGrade(score) {
+  if (score >= 80) return 'A';
+  if (score >= 60) return 'B';
+  if (score >= 40) return 'C';
+  if (score >= 20) return 'D';
+  return 'F';
+}
+
+function computeAutonomyMetrics(correlatedSessions) {
+  const perSession = correlatedSessions.map(s => {
+    const autopilotRatio = s.userMessageCount > 0
+      ? Math.round((s.assistantMessageCount / s.userMessageCount) * 100) / 100
+      : 0;
+
+    const selfHealScore = s.totalBashCalls > 0
+      ? Math.round((s.verificationBashCalls / s.totalBashCalls) * 100)
+      : 0;
+
+    const uniqueTools = Object.keys(s.toolCalls).length;
+    const toolbeltCoverage = Math.round((uniqueTools / TOTAL_AVAILABLE_TOOLS) * 100);
+
+    const totalToolCalls = Object.values(s.toolCalls).reduce((sum, c) => sum + c, 0);
+    const commitVelocity = s.commitCount > 0 ? Math.round(totalToolCalls / s.commitCount) : null;
+
+    return { sessionId: s.sessionId, autopilotRatio, selfHealScore, toolbeltCoverage, commitVelocity };
+  });
+
+  // Aggregates
+  const totalUser = correlatedSessions.reduce((s, c) => s + c.userMessageCount, 0);
+  const totalAssistant = correlatedSessions.reduce((s, c) => s + c.assistantMessageCount, 0);
+  const autopilotRatio = totalUser > 0
+    ? Math.round((totalAssistant / totalUser) * 100) / 100
+    : 0;
+
+  const totalBash = correlatedSessions.reduce((s, c) => s + (c.totalBashCalls || 0), 0);
+  const totalVerif = correlatedSessions.reduce((s, c) => s + (c.verificationBashCalls || 0), 0);
+  const selfHealScore = totalBash > 0 ? Math.round((totalVerif / totalBash) * 100) : 0;
+
+  const toolbeltCoverage = perSession.length > 0
+    ? Math.round(perSession.reduce((s, a) => s + a.toolbeltCoverage, 0) / perSession.length)
+    : 0;
+
+  const withCommits = perSession.filter(a => a.commitVelocity !== null);
+  const commitVelocity = withCommits.length > 0
+    ? Math.round(withCommits.reduce((s, a) => s + a.commitVelocity, 0) / withCommits.length)
+    : null;
+
+  // Composite score (0-100): clamp and weight each component
+  const autopilotScore = Math.round(Math.min(autopilotRatio / 5, 1) * 100);
+  const selfHealWeighted = selfHealScore;
+  const toolbeltWeighted = toolbeltCoverage;
+  const velocityScore = commitVelocity !== null
+    ? Math.round(Math.max(0, Math.min(1, 1 - (commitVelocity / 100))) * 100)
+    : 50; // neutral when no commits
+
+  const overallScore = Math.round(
+    autopilotScore * 0.25 +
+    selfHealWeighted * 0.30 +
+    toolbeltWeighted * 0.20 +
+    velocityScore * 0.25
+  );
+
+  // Top verification commands — extract the actual test/lint command, stripping cd/path prefixes
+  const verifCounts = {};
+  for (const s of correlatedSessions) {
+    for (const bc of (s.bashCommands || [])) {
+      if (bc.isVerification) {
+        // Strip "cd /path && ", "cd /path;", and "VAR=val " prefixes to get the real command
+        const stripped = bc.command
+          .replace(/^(?:cd\s+\S+\s*&&\s*)+/g, '')
+          .replace(/^(?:cd\s+\S+\s*;\s*)+/g, '')
+          .replace(/^(?:\w+=\S+\s+)+/g, '')
+          .trim();
+        const key = stripped.split(' ').slice(0, 3).join(' ') || bc.command.split(' ').slice(0, 3).join(' ');
+        verifCounts[key] = (verifCounts[key] || 0) + 1;
+      }
+    }
+  }
+  const topVerificationCommands = Object.entries(verifCounts)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([command, count]) => ({ command, count }));
+
+  return {
+    overall: { score: overallScore, grade: computeAutonomyGrade(overallScore) },
+    autopilotRatio,
+    selfHealScore,
+    toolbeltCoverage,
+    commitVelocity,
+    totalBashCalls: totalBash,
+    totalVerificationCalls: totalVerif,
+    topVerificationCommands,
+    perSession,
+    breakdown: { autopilotScore, selfHealWeighted, toolbeltWeighted, velocityScore },
+  };
+}
+
 function computeEfficiencyGrade(costPerCommit, survivalRate) {
   // Grade based on cost per commit (more meaningful than raw token count)
   if (costPerCommit <= 2 && survivalRate >= 90) return 'A';
@@ -165,7 +269,7 @@ function computeSessionGrade(session) {
   return computeEfficiencyGrade(costPerCommit, 80);
 }
 
-function generateInsights(summary, correlatedSessions, modelBreakdown, sessionBuckets, tokenAnalytics) {
+function generateInsights(summary, correlatedSessions, modelBreakdown, sessionBuckets, tokenAnalytics, autonomyMetrics) {
   const insights = [];
 
   // Orphaned session rate
@@ -350,6 +454,34 @@ function generateInsights(summary, correlatedSessions, modelBreakdown, sessionBu
     }
   }
 
+  // ---- Autonomy insights ----
+  if (autonomyMetrics) {
+    const am = autonomyMetrics;
+    if (am.autopilotRatio >= 4) {
+      insights.push({
+        type: 'success',
+        text: `Your agent averaged ${am.autopilotRatio}x autopilot — it handled ${Math.round(am.autopilotRatio)} actions per prompt.`,
+      });
+    }
+    if (am.totalBashCalls > 5 && am.selfHealScore < 10) {
+      insights.push({
+        type: 'warning',
+        text: `Your agent ran ${am.totalBashCalls} bash commands but only ${am.selfHealScore}% were tests or lints — low self-healing.`,
+      });
+    } else if (am.selfHealScore >= 40) {
+      insights.push({
+        type: 'success',
+        text: `${am.selfHealScore}% of bash commands were tests/lints — your agent self-heals well.`,
+      });
+    }
+    if (am.toolbeltCoverage < 30 && correlatedSessions.length >= 3) {
+      insights.push({
+        type: 'tip',
+        text: `Your agent only used ${Math.round(am.toolbeltCoverage * TOTAL_AVAILABLE_TOOLS / 100)} of ${TOTAL_AVAILABLE_TOOLS} available tools — low toolbelt coverage.`,
+      });
+    }
+  }
+
   return insights;
 }
 
@@ -516,12 +648,6 @@ export function computeMetrics(correlatedSessions, organicCommits, commitsByRepo
     mainBranchPct: p.commits > 0 ? Math.round((p.commitsOnMain / p.commits) * 100) : 0,
   }));
 
-  // Add grades to sessions
-  const sessionsWithGrades = correlatedSessions.map(s => ({
-    ...s,
-    grade: computeSessionGrade(s),
-  }));
-
   // ---- Cost breakdown by time period ----
   const now = new Date();
   const todayStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
@@ -567,7 +693,24 @@ export function computeMetrics(correlatedSessions, organicCommits, commitsByRepo
   // ---- Token analytics ----
   const tokenAnalytics = computeTokenAnalytics(correlatedSessions, lineSurvival, totalCommits, totalLinesAdded, modelBreakdown);
 
-  const insights = generateInsights(summary, correlatedSessions, modelBreakdown, sessionBuckets, tokenAnalytics);
+  // ---- Autonomy metrics ----
+  const autonomyMetrics = computeAutonomyMetrics(correlatedSessions);
+
+  // Add grades + autonomy to sessions
+  const autonomyBySession = new Map(autonomyMetrics.perSession.map(a => [a.sessionId, a]));
+  const sessionsWithGrades = correlatedSessions.map(s => {
+    const a = autonomyBySession.get(s.sessionId);
+    return {
+      ...s,
+      grade: computeSessionGrade(s),
+      autopilotRatio: a?.autopilotRatio ?? 0,
+      selfHealScore: a?.selfHealScore ?? 0,
+      toolbeltCoverage: a?.toolbeltCoverage ?? 0,
+      commitVelocity: a?.commitVelocity ?? null,
+    };
+  });
+
+  const insights = generateInsights(summary, correlatedSessions, modelBreakdown, sessionBuckets, tokenAnalytics, autonomyMetrics);
 
   return {
     meta: {
@@ -585,6 +728,7 @@ export function computeMetrics(correlatedSessions, organicCommits, commitsByRepo
     },
     summary,
     tokenAnalytics,
+    autonomyMetrics,
     insights,
     daily,
     projects,

package/src/server.js

@@ -134,5 +134,10 @@ export function createServer(initialPayload, rebuildFn) {
     res.json(payload.tokenAnalytics);
   });
 
+  // Autonomy metrics
+  app.get('/api/autonomy', (req, res) => {
+    res.json(payload.autonomyMetrics);
+  });
+
   return app;
 }