@uxcontinuum/ccaudit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matt Turley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# ccaudit
+
+A diagnostic for your Claude Code setup. Run it, get graded across five dimensions, find the specific fixes.
+
+```bash
+npx @uxcontinuum/ccaudit
+```
+
+Reads `~/.claude/` locally. Zero dependencies. Nothing leaves your machine.
+
+## What you get
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  CCAUDIT  your Claude Code report card
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  OVERALL GRADE   D+   (67/100)
+
+  Hook coverage                     B-   ████████████████░░░░
+    1 PreToolUse, 1 PostToolUse, 0 UserPromptSubmit hook(s).
+
+  Project hygiene (human)            F   ████████░░░░░░░░░░░░
+    0% of your human sessions are titled. Avg prompt: 2350 chars.
+    → Title your sessions. Untitled sessions are unsearchable history.
+
+  Tool balance (human)               F   ███████████░░░░░░░░░
+    Bash 73%, Edit+Write 10%, Read 10%, Grep+Glob 2%, Agent/Task 0%.
+    → You are running things, not editing things. Use Edit/Write more.
+
+  Prompt tells                       C   ███████████████░░░░░
+    You said "just" 10243 times across 19199 prompts (53%).
+    → The word "just" telegraphs that you think the task is simple. It is not.
+
+  Pipeline ops (agent sessions)      B   █████████████████░░░
+    3253 agent-spawned sessions, 26.93M output tokens.
+```
+
+## What it checks
+
+| Dimension | Source |
+|-----------|--------|
+| Hook coverage | `~/.claude/settings.json` (PreToolUse, PostToolUse, UserPromptSubmit hook counts) |
+| Project hygiene | session titles, average prompt length, untitled rate (human sessions only) |
+| Tool balance | distribution across Bash, Edit/Write, Read, Grep/Glob, Agent/Task (human sessions only) |
+| Prompt tells | "just" frequency, "please" frequency, total prompt count |
+| Pipeline ops | agent-spawned session stats: count, token spend, hook coverage relative to volume |
+
+It separates human-driven sessions from agent-spawned worktrees (UUID and ULID-suffix dirs in your projects folder). Your operator-grade and your pipeline-grade get scored independently against different rubrics.
+
+## Install
+
+```bash
+# Run once without installing
+npx @uxcontinuum/ccaudit
+
+# Or globally
+npm i -g @uxcontinuum/ccaudit
+ccaudit
+```
+
+Requires Node 14+. No other dependencies.
+
+## Options
+
+```bash
+ccaudit                 # full report, last 30 days of activity
+ccaudit --days 7        # just last week
+ccaudit --days 365      # full year
+ccaudit --no-color      # plain text for copying
+```
+
+## How it grades
+
+Each dimension produces a 0-100 score and a letter grade (A+ through F). The overall grade is the mean of the dimension scores. The rubric weights:
+
+- Hook coverage is hard-floored at 35 if you have zero hooks. Anything could happen overnight.
+- Project hygiene scales linearly with titled-session percentage and penalizes both ultra-terse (<80 chars) and wall-of-text (>1500 chars) average prompts.
+- Tool balance penalizes Bash dominance above 65% and rewards healthy editing (10-55% Edit+Write).
+- Prompt tells subtract for high "just" frequency. "Just" telegraphs that you think the task is simple. It usually is not.
+- Pipeline ops rewards low tokens-per-session and penalizes running an agent pipeline without runtime hooks.
+
+The grade is opinionated, not objective. Read it as a diagnostic, not a judgment.
+
+## Why this exists
+
+There is no public benchmark for "is my Claude Code setup any good." People burn weeks reading other people's CLAUDE.md files trying to figure out what they're doing wrong. This tool answers that question in 30 seconds.
+
+If the audit flags two or more dimensions, the fix is usually a few days of work, not a rebuild. [Continuum](https://continuum.build) runs structured 2-week sprints for setups that need them.
+
+## Privacy
+
+Reads `~/.claude/` on your machine. Outputs to stdout. Makes no network calls. No telemetry, no analytics, no opt-in submission (yet).
+
+---
+
+Built by [Matt Turley](https://uxcontinuum.com) / [Continuum](https://continuum.build).

package/index.js

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+'use strict';
+
+// ccaudit: diagnostic for your Claude Code setup.
+// Reads ~/.claude/ locally. Nothing leaves your machine.
+// One-line install: npx @uxcontinuum/ccaudit
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ── COLOR + LAYOUT ────────────────────────────────────────────────────────────
+const C = {
+  bold: '\x1b[1m', dim: '\x1b[2m', reset: '\x1b[0m',
+  green: '\x1b[92m', yellow: '\x1b[93m', red: '\x1b[91m',
+  cyan: '\x1b[96m', white: '\x1b[97m', magenta: '\x1b[95m',
+};
+const hasFlag = (f) => process.argv.includes(f);
+if (hasFlag('--no-color')) { for (const k in C) C[k] = ''; }
+const getArg = (f, d) => {
+  const i = process.argv.indexOf(f);
+  return i > -1 && process.argv[i+1] ? process.argv[i+1] : d;
+};
+const pr = (s = '') => process.stdout.write(s + '\n');
+
+// ── CLAUDE DIR DISCOVERY (root-aware) ─────────────────────────────────────────
+function findClaudeDirs() {
+  const candidates = [path.join(os.homedir(), '.claude')];
+  if (os.homedir() === '/root') {
+    try {
+      for (const u of fs.readdirSync('/home')) {
+        candidates.push(`/home/${u}/.claude`);
+      }
+    } catch (_) {}
+  }
+  const dirs = [];
+  for (const c of candidates) {
+    try { if (fs.statSync(c).isDirectory()) dirs.push(c); } catch (_) {}
+  }
+  return dirs.length ? dirs : [candidates[0]];
+}
+const CLAUDE_DIRS = findClaudeDirs();
+
+// ── SESSION TYPE CLASSIFIER ───────────────────────────────────────────────────
+// Agent-spawned worktrees end with a 32-char hex hash (your orchestrator's
+// pattern). Named project dirs are human.
+// Agent worktrees use either UUIDv4 names (orchestrator-spawned) or ULID-style
+// hex suffixes appended to a path. Human dirs are word-segmented.
+const UUID_RE     = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+const HEX_TAIL_RE = /-[0-9a-f]{20,}$/;
+function isAgentProjectDir(name) {
+  if (UUID_RE.test(name)) return true;
+  if (HEX_TAIL_RE.test(name)) return true;
+  return false;
+}
+
+// ── FILE SCAN ─────────────────────────────────────────────────────────────────
+function findJsonl(dir, cutoffMs, out = []) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return out; }
+  for (const e of entries) {
+    if (e.name === 'subagents') continue;
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) { findJsonl(full, cutoffMs, out); continue; }
+    if (!e.name.endsWith('.jsonl')) continue;
+    try { if (fs.statSync(full).mtimeMs >= cutoffMs) out.push(full); } catch (_) {}
+  }
+  return out;
+}
+
+// ── SESSION PARSE ─────────────────────────────────────────────────────────────
+function projDirName(filePath) {
+  const parts = filePath.split(path.sep);
+  const idx   = parts.lastIndexOf('projects');
+  return idx >= 0 && idx + 1 < parts.length ? parts[idx + 1] : '';
+}
+
+function parseSession(filePath, cutoffMs) {
+  let lines;
+  try { lines = fs.readFileSync(filePath, 'utf8').split('\n'); } catch (_) { return null; }
+
+  const userPrompts = [];
+  const toolCalls   = [];
+  const timestamps  = [];
+  let title = null;
+  let outputTokens = 0;
+  let inputTokens  = 0;
+
+  for (const raw of lines) {
+    if (!raw) continue;
+    let msg;
+    try { msg = JSON.parse(raw); } catch (_) { continue; }
+
+    if (msg.type === 'custom-title') { title = msg.title || ''; continue; }
+    if (msg.type !== 'user' && msg.type !== 'assistant') continue;
+
+    if (msg.timestamp) {
+      const t = Date.parse(msg.timestamp);
+      if (!isNaN(t) && t >= cutoffMs) timestamps.push(t);
+    }
+
+    if (msg.type === 'user') {
+      const c = msg.message?.content;
+      if (Array.isArray(c)) {
+        for (const b of c) if (b?.type === 'text' && b.text?.trim()) userPrompts.push(b.text.trim());
+      } else if (typeof c === 'string' && c.trim()) {
+        userPrompts.push(c.trim());
+      }
+    }
+
+    if (msg.type === 'assistant') {
+      const c = msg.message?.content;
+      if (Array.isArray(c)) {
+        for (const b of c) if (b?.type === 'tool_use') toolCalls.push(b.name || 'unknown');
+      }
+      const u = msg.message?.usage;
+      if (u) {
+        outputTokens += u.output_tokens || 0;
+        inputTokens  += u.input_tokens || 0;
+      }
+    }
+  }
+
+  if (!timestamps.length) return null;
+
+  const projDir = projDirName(filePath);
+  return {
+    projDir,
+    isAgent: isAgentProjectDir(projDir),
+    title: title || '',
+    userPrompts,
+    toolCalls,
+    timestamps,
+    outputTokens,
+    inputTokens,
+  };
+}
+
+// ── SETTINGS / HOOK AUDIT ─────────────────────────────────────────────────────
+function inspectClaudeDir(claudeDir) {
+  const out = {
+    claudeDir,
+    hasSettings: false,
+    settingsValid: false,
+    preToolUseHooks: 0,
+    postToolUseHooks: 0,
+    userPromptSubmitHooks: 0,
+    hookFiles: [],
+    hasClaudeMd: false,
+    claudeMdBytes: 0,
+    skillCount: 0,
+  };
+
+  const settingsPath = path.join(claudeDir, 'settings.json');
+  try {
+    if (fs.statSync(settingsPath).isFile()) {
+      out.hasSettings = true;
+      try {
+        const s = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        out.settingsValid = true;
+        const hooks = s.hooks || {};
+        const count = (entries) => (entries || []).reduce((n, e) => n + (e.hooks || []).length, 0);
+        out.preToolUseHooks       = count(hooks.PreToolUse);
+        out.postToolUseHooks      = count(hooks.PostToolUse);
+        out.userPromptSubmitHooks = count(hooks.UserPromptSubmit);
+      } catch (_) {}
+    }
+  } catch (_) {}
+
+  try {
+    const hooksDir = path.join(claudeDir, 'hooks');
+    if (fs.statSync(hooksDir).isDirectory()) {
+      for (const f of fs.readdirSync(hooksDir)) {
+        if (!f.startsWith('.')) out.hookFiles.push(f);
+      }
+    }
+  } catch (_) {}
+
+  for (const md of ['CLAUDE.md', 'CLAUDE-personal.md']) {
+    try {
+      const p = path.join(claudeDir, md);
+      const st = fs.statSync(p);
+      if (st.isFile()) {
+        out.hasClaudeMd = true;
+        out.claudeMdBytes += st.size;
+      }
+    } catch (_) {}
+  }
+
+  try {
+    const skillsDir = path.join(claudeDir, 'skills');
+    if (fs.statSync(skillsDir).isDirectory()) {
+      out.skillCount = fs.readdirSync(skillsDir).filter(d => {
+        try { return fs.statSync(path.join(skillsDir, d)).isDirectory(); } catch (_) { return false; }
+      }).length;
+    }
+  } catch (_) {}
+
+  return out;
+}
+
+// ── AGGREGATE ─────────────────────────────────────────────────────────────────
+function aggregate(sessions) {
+  const human = sessions.filter(s => !s.isAgent);
+  const agent = sessions.filter(s => s.isAgent);
+
+  const bucket = (subset) => {
+    if (!subset.length) return null;
+    const prompts = subset.flatMap(s => s.userPrompts);
+    const tools = subset.flatMap(s => s.toolCalls);
+    const titled = subset.filter(s => s.title).length;
+
+    const toolCounts = {};
+    for (const t of tools) toolCounts[t] = (toolCounts[t] || 0) + 1;
+    const totalTools = tools.length || 1;
+    const pct = (k) => Math.round(100 * (toolCounts[k] || 0) / totalTools);
+
+    const totalChars = prompts.reduce((n, p) => n + p.length, 0);
+    const avgPromptLen = prompts.length ? Math.round(totalChars / prompts.length) : 0;
+
+    const justCount = prompts.reduce((n, p) => n + (p.toLowerCase().match(/\bjust\b/g)?.length || 0), 0);
+    const pleaseCount = prompts.reduce((n, p) => n + (p.toLowerCase().match(/\bplease\b/g)?.length || 0), 0);
+
+    const outputTokens = subset.reduce((n, s) => n + s.outputTokens, 0);
+    const inputTokens  = subset.reduce((n, s) => n + s.inputTokens, 0);
+
+    return {
+      sessions: subset.length,
+      prompts: prompts.length,
+      titledPct: Math.round(100 * titled / subset.length),
+      avgPromptLen,
+      justCount,
+      pleaseCount,
+      bashPct: pct('Bash'),
+      editPct: pct('Edit') + pct('Write'),
+      readPct: pct('Read'),
+      grepPct: pct('Grep') + pct('Glob'),
+      agentPct: pct('Agent') + pct('Task'),
+      outputTokens,
+      inputTokens,
+      totalTools: tools.length,
+    };
+  };
+
+  return { human: bucket(human), agent: bucket(agent), totalSessions: sessions.length };
+}
+
+// ── GRADING ───────────────────────────────────────────────────────────────────
+const LETTERS = ['F','D-','D','D+','C-','C','C+','B-','B','B+','A-','A','A+'];
+function letterFor(score /* 0..100 */) {
+  if (score >= 97) return 'A+';
+  if (score >= 93) return 'A';
+  if (score >= 90) return 'A-';
+  if (score >= 87) return 'B+';
+  if (score >= 83) return 'B';
+  if (score >= 80) return 'B-';
+  if (score >= 77) return 'C+';
+  if (score >= 73) return 'C';
+  if (score >= 70) return 'C-';
+  if (score >= 67) return 'D+';
+  if (score >= 63) return 'D';
+  if (score >= 60) return 'D-';
+  return 'F';
+}
+function colorForLetter(L) {
+  if (L.startsWith('A')) return C.green;
+  if (L.startsWith('B')) return C.cyan;
+  if (L.startsWith('C')) return C.yellow;
+  return C.red;
+}
+
+function grade(stats, setup) {
+  const dims = [];
+  const human = stats.human || {};
+  const agent = stats.agent || {};
+
+  // 1. Hook coverage. Lives at the setup layer, applies to everyone.
+  const hookSignals = setup.preToolUseHooks + setup.postToolUseHooks + setup.userPromptSubmitHooks;
+  let hookScore;
+  if (hookSignals === 0) hookScore = 35;
+  else if (hookSignals === 1) hookScore = 65;
+  else if (hookSignals === 2) hookScore = 82;
+  else hookScore = Math.min(100, 88 + hookSignals * 2);
+  dims.push({
+    name: 'Hook coverage',
+    score: hookScore,
+    detail: hookSignals === 0
+      ? 'No PreToolUse, PostToolUse, or UserPromptSubmit hooks installed. Anything could happen overnight.'
+      : `${setup.preToolUseHooks} PreToolUse, ${setup.postToolUseHooks} PostToolUse, ${setup.userPromptSubmitHooks} UserPromptSubmit hook(s) installed.`,
+    fix: hookSignals === 0
+      ? 'Install claude-loop-sentinel for runaway-loop protection: npm i @uxcontinuum/claude-loop-sentinel'
+      : null,
+  });
+
+  // 2. Project hygiene (human sessions only).
+  if (human.sessions) {
+    let hScore = 50;
+    hScore += Math.round(human.titledPct * 0.5); // titled sessions help up to +50
+    if (human.avgPromptLen > 0 && human.avgPromptLen < 80) hScore -= 10; // too terse
+    if (human.avgPromptLen > 1500) hScore -= 8; // walls of text
+    hScore = Math.max(0, Math.min(100, hScore));
+    dims.push({
+      name: 'Project hygiene (human)',
+      score: hScore,
+      detail: `${human.titledPct}% of your human sessions are titled. Avg prompt: ${human.avgPromptLen} chars.`,
+      fix: human.titledPct < 30
+        ? 'Title your sessions. Untitled sessions are unsearchable history.'
+        : null,
+    });
+  }
+
+  // 3. Tool balance (human sessions only).
+  if (human.sessions && human.totalTools > 0) {
+    let bScore = 75;
+    if (human.bashPct > 65) bScore -= 18; // bash hammer
+    if (human.readPct + human.grepPct + human.editPct < 15) bScore -= 12;
+    if (human.editPct > 10 && human.editPct < 55) bScore += 8; // healthy editing
+    if (human.agentPct > 2) bScore += 7; // delegates work
+    bScore = Math.max(0, Math.min(100, bScore));
+    dims.push({
+      name: 'Tool balance (human)',
+      score: bScore,
+      detail: `Bash ${human.bashPct}%, Edit+Write ${human.editPct}%, Read ${human.readPct}%, Grep+Glob ${human.grepPct}%, Agent/Task ${human.agentPct}%.`,
+      fix: human.bashPct > 65
+        ? 'You are running things, not editing things. Use Edit/Write more.'
+        : null,
+    });
+  }
+
+  // 4. Prompt tells (the "just"/"please" tax).
+  if (human.sessions && human.prompts > 0) {
+    const justRate = human.justCount / human.prompts;
+    let pScore = 85;
+    if (justRate > 0.5) pScore -= 12;
+    if (justRate > 1.0) pScore -= 15;
+    if (human.pleaseCount / human.prompts > 0.3) pScore -= 6;
+    pScore = Math.max(0, Math.min(100, pScore));
+    dims.push({
+      name: 'Prompt tells',
+      score: pScore,
+      detail: `You said "just" ${human.justCount} times across ${human.prompts} prompts (${(justRate * 100).toFixed(0)}%).`,
+      fix: justRate > 0.5
+        ? 'The word "just" telegraphs that you think the task is simple. It is not. Strip it.'
+        : null,
+    });
+  }
+
+  // 5. Agent pipeline grade (only if agent sessions exist).
+  if (agent.sessions) {
+    let aScore = 75;
+    if (agent.sessions > 50) aScore += 8;
+    if (agent.outputTokens > 0 && agent.sessions > 0) {
+      const tokensPerSession = agent.outputTokens / agent.sessions;
+      if (tokensPerSession < 5000) aScore += 5; // efficient
+      if (tokensPerSession > 50000) aScore -= 8; // bloated
+    }
+    if (hookSignals === 0) aScore -= 12; // running pipeline with no safety net is reckless
+    aScore = Math.max(0, Math.min(100, aScore));
+    dims.push({
+      name: 'Pipeline ops (agent sessions)',
+      score: aScore,
+      detail: `${agent.sessions} agent-spawned sessions, ${(agent.outputTokens / 1e6).toFixed(2)}M output tokens.`,
+      fix: hookSignals === 0 ? 'Your pipeline has no runtime hooks. Install claude-loop-sentinel before the next overnight run.' : null,
+    });
+  }
+
+  const overall = Math.round(dims.reduce((s, d) => s + d.score, 0) / dims.length);
+  return { overall, letter: letterFor(overall), dims };
+}
+
+// ── OUTPUT ────────────────────────────────────────────────────────────────────
+function renderCard(stats, setup, graded) {
+  const bar = (n) => {
+    const filled = Math.round(n / 5);
+    return '█'.repeat(filled) + '░'.repeat(20 - filled);
+  };
+
+  pr();
+  pr(`  ${C.bold}${C.white}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+  pr(`  ${C.bold}${C.white}  CCAUDIT${C.reset}${C.dim}  your Claude Code report card${C.reset}`);
+  pr(`  ${C.bold}${C.white}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+  pr();
+
+  const L = graded.letter;
+  const lc = colorForLetter(L);
+  pr(`  ${C.bold}OVERALL GRADE   ${lc}${C.bold}${L}${C.reset}   ${C.dim}(${graded.overall}/100)${C.reset}`);
+  pr();
+
+  for (const d of graded.dims) {
+    const dL = letterFor(d.score);
+    const dc = colorForLetter(dL);
+    pr(`  ${C.bold}${d.name.padEnd(34)}${C.reset}${dc}${C.bold}${dL.padStart(3)}${C.reset}   ${C.dim}${bar(d.score)}${C.reset}`);
+    pr(`    ${C.dim}${d.detail}${C.reset}`);
+    if (d.fix) pr(`    ${C.yellow}→ ${d.fix}${C.reset}`);
+    pr();
+  }
+
+  pr(`  ${C.dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+  pr(`  ${C.bold}YOUR DATA${C.reset}`);
+  if (stats.human) {
+    pr(`    ${C.dim}Human sessions:${C.reset}  ${stats.human.sessions} sessions, ${stats.human.prompts} prompts, ${(stats.human.outputTokens / 1e6).toFixed(2)}M output tokens`);
+  }
+  if (stats.agent) {
+    pr(`    ${C.dim}Agent sessions:${C.reset}  ${stats.agent.sessions} sessions, ${(stats.agent.outputTokens / 1e6).toFixed(2)}M output tokens`);
+  }
+  pr(`    ${C.dim}Hooks installed:${C.reset} ${setup.preToolUseHooks + setup.postToolUseHooks + setup.userPromptSubmitHooks} (${setup.hookFiles.length} hook file(s) in ~/.claude/hooks/)`);
+  pr(`    ${C.dim}CLAUDE.md:${C.reset}       ${setup.hasClaudeMd ? `${setup.claudeMdBytes} bytes` : 'not found'}`);
+  pr(`    ${C.dim}Skills installed:${C.reset} ${setup.skillCount}`);
+
+  pr();
+  pr(`  ${C.dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+  pr(`  ${C.dim}Run it on your own machine: ${C.reset}${C.bold}npx @uxcontinuum/ccaudit${C.reset}`);
+  pr(`  ${C.dim}Source + fixes:${C.reset}             github.com/turleydesigns/claude-audit`);
+
+  const failingDims = graded.dims.filter(d => d.score < 75).length;
+  if (failingDims >= 2) {
+    pr();
+    pr(`  ${C.bold}${C.yellow}${failingDims} dimensions flagged. The Continuum Sprint fixes setups like this in 2 weeks.${C.reset}`);
+    pr(`  ${C.dim}continuum.build${C.reset}`);
+  }
+  pr();
+}
+
+// ── MAIN ──────────────────────────────────────────────────────────────────────
+const days     = parseInt(getArg('--days', '30'), 10);
+const cutoffMs = Date.now() - days * 86400000;
+
+const projectsDirs = CLAUDE_DIRS.map(d => path.join(d, 'projects'))
+  .filter(d => { try { return fs.statSync(d).isDirectory(); } catch (_) { return false; } });
+
+const files = projectsDirs.flatMap(d => findJsonl(d, cutoffMs));
+const sessions = files.map(f => parseSession(f, cutoffMs)).filter(Boolean);
+
+if (!sessions.length) {
+  pr(`No Claude Code sessions found in the last ${days} days.`);
+  pr(`Looked in: ${projectsDirs.join(', ') || CLAUDE_DIRS.join(', ')}`);
+  process.exit(0);
+}
+
+const stats  = aggregate(sessions);
+const setup  = inspectClaudeDir(CLAUDE_DIRS[0]);
+const graded = grade(stats, setup);
+
+renderCard(stats, setup, graded);

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@uxcontinuum/ccaudit",
+  "version": "1.0.0",
+  "description": "A diagnostic for your Claude Code setup. Reads ~/.claude/ locally, grades you across hook coverage, project hygiene, tool balance, prompt tells, and pipeline ops. Zero install: npx @uxcontinuum/ccaudit",
+  "main": "index.js",
+  "bin": {
+    "ccaudit": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "ai",
+    "developer-tools",
+    "audit",
+    "diagnostic",
+    "report-card",
+    "cli"
+  ],
+  "author": "Matt Turley <mt@turleydesigns.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/turleydesigns/claude-audit"
+  },
+  "homepage": "https://github.com/turleydesigns/claude-audit#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}