chekk 0.2.4 → 0.3.0

package/bin/chekk.js

@@ -1,20 +1,62 @@
 #!/usr/bin/env node
 
+import { execSync, spawn } from 'child_process';
 import { Command } from 'commander';
 import { run } from '../src/index.js';
 
-const program = new Command();
-
-program
-  .name('chekk')
-  .description('The engineering capability score. See how you prompt.')
-  .version('0.2.4')
-  .option('--offline', 'Skip AI prose generation, show data-driven output')
-  .option('--verbose', 'Show detailed per-project and per-metric breakdowns')
-  .option('--json', 'Output raw metrics as JSON')
-  .option('--no-upload', 'Skip the claim prompt')
-  .action(async (options) => {
-    await run(options);
-  });
-
-program.parse();
+const LOCAL_VERSION = '0.3.0';
+
+// ── Auto-update check ──
+// If running from a cached npx install, check if there's a newer version
+// and re-exec with @latest to ensure users always get the freshest build.
+async function checkForUpdate() {
+  try {
+    const latest = execSync('npm view chekk version 2>/dev/null', {
+      encoding: 'utf-8',
+      timeout: 3000,
+    }).trim();
+
+    if (latest && latest !== LOCAL_VERSION && isNewer(latest, LOCAL_VERSION)) {
+      // Re-run with the latest version
+      const args = process.argv.slice(2);
+      const child = spawn('npx', ['--yes', `chekk@${latest}`, ...args], {
+        stdio: 'inherit',
+        shell: true,
+      });
+      child.on('exit', (code) => process.exit(code || 0));
+      return true; // signal that we're handing off
+    }
+  } catch {
+    // Network down or timeout — just run the local version
+  }
+  return false;
+}
+
+function isNewer(remote, local) {
+  const r = remote.split('.').map(Number);
+  const l = local.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((r[i] || 0) > (l[i] || 0)) return true;
+    if ((r[i] || 0) < (l[i] || 0)) return false;
+  }
+  return false;
+}
+
+const handedOff = await checkForUpdate();
+if (!handedOff) {
+  const program = new Command();
+
+  program
+    .name('chekk')
+    .description('The engineering capability score. See how you prompt.')
+    .version(LOCAL_VERSION)
+    .option('--offline', 'Skip AI prose generation, show data-driven output')
+    .option('--verbose', 'Show detailed per-project and per-metric breakdowns')
+    .option('--json', 'Output raw metrics as JSON')
+    .option('--no-upload', 'Skip the claim prompt')
+    .action(async (options) => {
+      await run(options);
+    });
+
+  program.parse();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chekk",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "See how you prompt. Chekk analyzes your AI coding workflow and tells you what kind of engineer you are.",
   "bin": {
     "chekk": "./bin/chekk.js"

package/src/display.js

@@ -6,6 +6,7 @@ const purple = chalk.hex('#A855F7');
 const blue = chalk.hex('#3B82F6');
 const green = chalk.hex('#22C55E');
 const cyan = chalk.hex('#06B6D4');
+const orange = chalk.hex('#F97316');
 const dim = chalk.dim;
 const bold = chalk.bold;
 const white = chalk.white;
@@ -22,7 +23,7 @@ function scoreColor(score) {
   if (score >= 85) return green;
   if (score >= 70) return cyan;
   if (score >= 55) return chalk.hex('#EAB308');
-  if (score >= 40) return chalk.hex('#F97316');
+  if (score >= 40) return orange;
   return chalk.hex('#EF4444');
 }
 
@@ -42,9 +43,28 @@ function pad(str, len) {
   return str + ' '.repeat(Math.max(0, len - visible.length));
 }
 
-function snippet(prompt, maxLen = 70) {
+// ── Qualitative tier labels for dimensions ──
+function dimTierLabel(score) {
+  if (score >= 80) return 'exceptional';
+  if (score >= 65) return 'strong';
+  if (score >= 50) return 'solid';
+  if (score >= 35) return 'developing';
+  return 'needs work';
+}
+
+function dimTierColor(score) {
+  if (score >= 80) return green;
+  if (score >= 65) return cyan;
+  if (score >= 50) return chalk.hex('#EAB308');
+  if (score >= 35) return orange;
+  return chalk.hex('#EF4444');
+}
+
+// ── Snippet helpers ──
+// Longer snippets with context labels instead of truncated decorations
+
+function cleanPrompt(prompt, maxLen = 120) {
   if (!prompt) return null;
-  // Clean up whitespace / newlines
   let clean = prompt.replace(/\s+/g, ' ').trim();
   if (clean.length > maxLen) {
     clean = clean.slice(0, maxLen - 1) + '\u2026';
@@ -52,10 +72,10 @@ function snippet(prompt, maxLen = 70) {
   return clean;
 }
 
-function displaySnippet(prompt, maxLen = 70) {
-  const s = snippet(prompt, maxLen);
+function displayLabeledSnippet(label, prompt, maxLen = 120) {
+  const s = cleanPrompt(prompt, maxLen);
   if (!s) return;
-  console.log(`  ${dim('\u201C')}${dim.italic(s)}${dim('\u201D')}`);
+  console.log(`  ${dim('\u21B3')} ${dim(label + ':')} ${dim.italic('\u201C' + s + '\u201D')}`);
 }
 
 function pickExample(examples, type) {
@@ -90,7 +110,7 @@ export function displayHeader() {
   console.log();
   const lines = [
     '',
-    `   ${bold.white('chekk')}${dim(' v0.2.4')}`,
+    `   ${bold.white('chekk')}${dim(' v0.3.0')}`,
     `   ${dim('the engineering capability score')}`,
     '',
   ];
@@ -147,8 +167,9 @@ export async function displayProgressBar(durationMs = 2000) {
 // MAIN SCORE DISPLAY
 // ══════════════════════════════════════════════
 
-export function displayScore(result, prose) {
+export function displayScore(result, prose, extra = {}) {
   const { overall, scores, archetype, tier, tierBadge, tierPercentile } = result;
+  const { scoreDelta, perToolScores } = extra;
   const tc = tierColor(tier);
   const sc = scoreColor(overall);
 
@@ -157,10 +178,19 @@ export function displayScore(result, prose) {
   console.log();
   console.log(dim('  YOUR CHEKK SCORE'));
   console.log();
+
+  // Score + delta
+  let deltaStr = '';
+  if (scoreDelta !== null && scoreDelta !== undefined) {
+    if (scoreDelta > 0) deltaStr = `  ${green('\u2191 +' + scoreDelta + ' since last scan')}`;
+    else if (scoreDelta < 0) deltaStr = `  ${orange('\u2193 ' + scoreDelta + ' since last scan')}`;
+    else deltaStr = `  ${dim('\u2192 same as last scan')}`;
+  }
   console.log(`                    ${sc.bold(String(overall))}`);
   const badgeStr = tierBadge ? ` ${tierBadge}` : '';
   const pctStr = tierPercentile ? `  ${dim(tierPercentile)}` : '';
   console.log(`               ${tc('\u2500\u2500 ' + tier + ' \u2500\u2500')}${badgeStr}${pctStr}`);
+  if (deltaStr) console.log(`               ${deltaStr}`);
   console.log();
   console.log(`  ${dim('Archetype:')} ${bold.white(archetype.name)}`);
 
@@ -168,22 +198,25 @@ export function displayScore(result, prose) {
     console.log(`  ${dim('"' + prose.tagline + '"')}`);
   }
   console.log();
+
+  // ── Score weights (transparency) ──
+  console.log(`  ${dim('Score = Thinking (25%) + Debugging (25%) + AI Leverage (30%) + Workflow (20%)')}`);
+  console.log();
   console.log(doubleRule());
   console.log();
 
-  // Dimensions box
+  // Dimensions box with qualitative labels
   console.log(dim('  DIMENSIONS\n'));
 
-  // Build dimension lines with fixed-width layout
-  // Format: "  Label          ██████████████░░░░  XX "
-  // Visible: 2 + 15 + 18 + 2 + 3 + 1 = ~41 chars
   function dimLine(label, score) {
     const labelStr = bold(label);
     const labelVisible = label.length;
     const labelPad = ' '.repeat(Math.max(0, 15 - labelVisible));
     const scoreStr = String(score);
     const scorePad = score < 10 ? '  ' : score < 100 ? ' ' : '';
-    return `  ${labelStr}${labelPad}${progressBar(score)} ${scorePad}${bold(scoreStr)} `;
+    const tierLabel = dimTierLabel(score);
+    const tierStr = dimTierColor(score)(tierLabel);
+    return `  ${labelStr}${labelPad}${progressBar(score)} ${scorePad}${bold(scoreStr)}  ${dim('\u2500\u2500')} ${tierStr} `;
   }
 
   const dimLines = [
@@ -194,8 +227,36 @@ export function displayScore(result, prose) {
     dimLine('Workflow', scores.sessionStructure),
     '',
   ];
-  for (const l of box(dimLines, 45)) console.log(l);
+  for (const l of box(dimLines, 53)) console.log(l);
   console.log();
+
+  // ── Cross-platform breakdown ──
+  if (perToolScores && Object.keys(perToolScores).length > 1) {
+    console.log(dim('  CROSS-PLATFORM\n'));
+    // Sort by score descending, null scores last
+    const sorted = Object.entries(perToolScores).sort((a, b) => {
+      if (a[1].score === null) return 1;
+      if (b[1].score === null) return -1;
+      return b[1].score - a[1].score;
+    });
+    // Find primary (most sessions)
+    const maxSessions = Math.max(...sorted.map(([, v]) => v.sessions));
+
+    for (const [tool, data] of sorted) {
+      if (data.score !== null) {
+        const isPrimary = data.sessions === maxSessions;
+        const label = isPrimary ? 'primary tool' : data.sessions < 5 ? 'limited usage' : (data.label || 'active');
+        const barWidth = 18;
+        const filled = Math.round((data.score / 100) * barWidth);
+        const empty = barWidth - filled;
+        const bar = scoreColor(data.score)('\u2588'.repeat(filled)) + dim('\u2591'.repeat(empty));
+        console.log(`  ${pad(bold(tool), 18)} ${bold(String(data.score))} ${bar}  ${dim(label)}`);
+      } else {
+        console.log(`  ${pad(bold(tool), 18)} ${dim('--')} ${dim('\u2591'.repeat(18))}  ${dim('limited data')}`);
+      }
+    }
+    console.log();
+  }
 }
 
 // ══════════════════════════════════════════════
@@ -203,23 +264,21 @@ export function displayScore(result, prose) {
 // ══════════════════════════════════════════════
 
 export function displayNarratives(metrics, prose) {
-  // Track shown snippets globally to avoid duplicates across sections
   const shownSnippets = new Set();
-  function showUniqueSnippet(prompt) {
+  function showLabeledSnippet(label, prompt) {
     if (!prompt) return;
-    const s = snippet(prompt, 70);
+    const s = cleanPrompt(prompt, 120);
     if (shownSnippets.has(s)) return;
     shownSnippets.add(s);
-    displaySnippet(prompt);
+    displayLabeledSnippet(label, prompt);
   }
 
   if (prose && prose.sections) {
-    // Use DeepSeek-generated prose with inline prompt snippets per section
     const sectionSnippetMap = {
-      'thinking': pickExample(metrics.decomposition.examples, 'decomposition'),
-      'debugging': pickExample(metrics.debugCycles.examples, 'specific_report') || pickExample(metrics.debugCycles.examples, 'quick_fix'),
-      'ai leverage': pickExample(metrics.aiLeverage.examples, 'architectural') || pickExample(metrics.aiLeverage.examples, 'planning'),
-      'workflow': pickExample(metrics.sessionStructure.examples, 'context_setting') || pickExample(metrics.sessionStructure.examples, 'refinement'),
+      'thinking': { label: 'Best decomposition prompt', prompt: pickExample(metrics.decomposition.examples, 'decomposition') },
+      'debugging': { label: 'Best debug prompt', prompt: pickExample(metrics.debugCycles.examples, 'specific_report') || pickExample(metrics.debugCycles.examples, 'quick_fix') },
+      'ai leverage': { label: 'Best leverage prompt', prompt: pickExample(metrics.aiLeverage.examples, 'architectural') || pickExample(metrics.aiLeverage.examples, 'planning') },
+      'workflow': { label: 'Best workflow prompt', prompt: pickExample(metrics.sessionStructure.examples, 'context_setting') || pickExample(metrics.sessionStructure.examples, 'refinement') },
     };
 
     for (const section of prose.sections) {
@@ -228,14 +287,12 @@ export function displayNarratives(metrics, prose) {
       for (const line of lines) {
         console.log(`  ${dim(line.trim())}`);
       }
-      // Show relevant prompt snippet under this section
       const titleLower = section.title.toLowerCase();
-      const matchedSnippet = sectionSnippetMap[titleLower];
-      if (matchedSnippet) showUniqueSnippet(matchedSnippet);
+      const matched = sectionSnippetMap[titleLower];
+      if (matched && matched.prompt) showLabeledSnippet(matched.label, matched.prompt);
       console.log();
     }
   } else {
-    // Fallback: data-driven bullet points with inline snippets
     displayDataNarrativesWithTracker(metrics, shownSnippets);
   }
 }
@@ -250,12 +307,12 @@ function displayDataNarrativesWithTracker(metrics, shownSnippets) {
   const aiEx = metrics.aiLeverage.examples || [];
   const ssEx = metrics.sessionStructure.examples || [];
 
-  function showUniqueSnippet(prompt) {
+  function showLabeledSnippet(label, prompt) {
     if (!prompt) return;
-    const s = snippet(prompt, 70);
+    const s = cleanPrompt(prompt, 120);
     if (shownSnippets.has(s)) return;
     shownSnippets.add(s);
-    displaySnippet(prompt);
+    displayLabeledSnippet(label, prompt);
   }
 
   // Thinking
@@ -264,16 +321,16 @@ function displayDataNarrativesWithTracker(metrics, shownSnippets) {
   console.log(`  ${dim(exchPerSession > 20 ? `${exchPerSession} avg exchanges/session \u2014 marathon builder` : exchPerSession > 8 ? `${exchPerSession} avg exchanges/session \u2014 iterative` : `${exchPerSession} avg exchanges/session \u2014 concise`)}`);
   console.log(`  ${dim(d.avgPromptLength > 500 ? `${numberFormat(d.avgPromptLength)} char avg prompt \u2014 thinks out loud` : `${d.avgPromptLength} char avg prompt \u2014 concise communicator`)}`);
   console.log(`  ${dim(d.multiStepSessions > d.singleShotSessions * 2 ? 'Multi-step decomposition over single-shot' : 'Mix of multi-step and single-shot sessions')}`);
-  showUniqueSnippet(pickExample(dEx, 'decomposition'));
+  showLabeledSnippet('Best decomposition prompt', pickExample(dEx, 'decomposition'));
   console.log();
 
   // Debugging
   console.log(`  ${bold('\u26A1 DEBUGGING')}`);
   const turns = db.avgTurnsToResolve;
   console.log(`  ${dim(turns <= 2 ? `${turns} turns to resolve \u2014 surgical` : turns <= 4 ? `${turns} turns to resolve \u2014 efficient` : `${turns} turns to resolve \u2014 iterative`)}`);
-  console.log(`  ${dim(`${db.specificReportRatio}% specific error reports`)}`);
-  console.log(`  ${dim(db.longLoops === 0 ? 'Zero extended debug loops detected' : `${db.longLoops} extended debug loops`)}`);
-  showUniqueSnippet(pickExample(dbEx, 'specific_report') || pickExample(dbEx, 'quick_fix'));
+  console.log(`  ${dim(`${db.specificReportRatio}% specific error reports \u2014 ${db.specificReportRatio >= 80 ? 'precise' : db.specificReportRatio >= 50 ? 'decent' : 'vague'}`)}`);
+  console.log(`  ${dim(db.longLoops === 0 ? 'Zero long loops \u2014 efficient debugger' : `${db.longLoops} extended debug loops`)}`);
+  showLabeledSnippet('Best debug prompt', pickExample(dbEx, 'specific_report') || pickExample(dbEx, 'quick_fix'));
   console.log();
 
   // AI Leverage
@@ -282,7 +339,7 @@ function displayDataNarrativesWithTracker(metrics, shownSnippets) {
   const codingRatio = ai.toolDiversity.coding > ai.toolDiversity.research ? 'Coding-heavy' : 'Research-heavy';
   console.log(`  ${dim(`${codingRatio} over ${ai.toolDiversity.coding > ai.toolDiversity.research ? 'research' : 'coding'}-heavy`)}`);
   console.log(`  ${dim(`${ai.architecturalPrompts} architectural, ${ai.planningPrompts} planning, ${ai.exploratoryPrompts} exploratory`)}`);
-  showUniqueSnippet(pickExample(aiEx, 'architectural') || pickExample(aiEx, 'planning'));
+  showLabeledSnippet('Best leverage prompt', pickExample(aiEx, 'architectural') || pickExample(aiEx, 'planning'));
   console.log();
 
   // Workflow
@@ -290,7 +347,43 @@ function displayDataNarrativesWithTracker(metrics, shownSnippets) {
   console.log(`  ${dim(`${ss.contextSetRatio}% context-setting rate \u2014 ${ss.contextSetRatio > 50 ? 'deliberate' : ss.contextSetRatio > 25 ? 'moderate' : 'low'}`)}`);
   console.log(`  ${dim(`${ss.reviewEndRatio}% sessions end with review`)}`);
   console.log(`  ${dim(`${ss.refinementRatio}% refinement rate \u2014 ${ss.refinementRatio > 20 ? 'critical eye' : 'accepts readily'}`)}`);
-  showUniqueSnippet(pickExample(ssEx, 'context_setting') || pickExample(ssEx, 'refinement'));
+  showLabeledSnippet('Best workflow prompt', pickExample(ssEx, 'context_setting') || pickExample(ssEx, 'refinement'));
+  console.log();
+}
+
+
+// ══════════════════════════════════════════════
+// COACHING RECOMMENDATION
+// ══════════════════════════════════════════════
+
+function displayCoaching(result, metrics) {
+  const { scores } = result;
+  // Find the weakest dimension
+  const dims = [
+    { key: 'decomposition', label: 'Thinking', score: scores.decomposition },
+    { key: 'debugCycles', label: 'Debugging', score: scores.debugCycles },
+    { key: 'aiLeverage', label: 'AI Leverage', score: scores.aiLeverage },
+    { key: 'sessionStructure', label: 'Workflow', score: scores.sessionStructure },
+  ];
+  dims.sort((a, b) => a.score - b.score);
+  const weakest = dims[0];
+
+  // Only show coaching if the weakest is actually dragging things down
+  if (weakest.score >= 70) return;
+
+  const tips = {
+    decomposition: 'Break complex tasks into subtasks before prompting.\nEngineers who decompose problems score 15+ points higher.',
+    debugCycles: 'Include specific error messages and stack traces in debug prompts.\nPrecise reports resolve 2x faster than "it\'s broken, fix it."',
+    aiLeverage: 'Use AI for architecture and planning, not just code generation.\nAsk "what\'s the best approach" before "write the code."',
+    sessionStructure: 'Set context at the start of each session and review at the end.\nEngineers who do this score 12 points higher on average.',
+  };
+
+  console.log(`  ${bold('\uD83D\uDCA1 TO LEVEL UP')}`);
+  console.log(`  ${dim(`Your ${weakest.label} score (${weakest.score}) is your biggest opportunity.`)}`);
+  const tipLines = tips[weakest.key].split('\n');
+  for (const line of tipLines) {
+    console.log(`  ${dim(line)}`);
+  }
   console.log();
 }
 
@@ -335,8 +428,15 @@ export function displayEnding(result) {
 
   console.log(doubleRule());
   console.log();
-  console.log(`  ${dim('\u2192 Claim your profile:')}  ${cyan.underline('chekk.dev/claim')}`);
-  console.log(`  ${dim('\u2192 Leaderboard:')}         ${cyan.underline('chekk.dev/leaderboard')}`);
+
+  // Value-driven claim CTA
+  console.log(`  ${dim('\u2192 Claim your profile to:')}`);
+  console.log(`  ${dim('  \u00B7 See how you compare across 10K+ engineers')}`);
+  console.log(`  ${dim('  \u00B7 Get matched with roles at top startups')}`);
+  console.log(`  ${dim('  \u00B7 Track your score over time')}`);
+  console.log(`  ${cyan.underline('  chekk.dev/claim')}`);
+  console.log();
+  console.log(`  ${dim('\u2192 Leaderboard:')}  ${cyan.underline('chekk.dev/leaderboard')}`);
   console.log();
 
   // Copy-paste share line
@@ -351,7 +451,7 @@ export function displayEnding(result) {
 }
 
 // ══════════════════════════════════════════════
-// VERBOSE: DETAILED BREAKDOWN
+// VERBOSE: DETAILED BREAKDOWN (with interpretation)
 // ══════════════════════════════════════════════
 
 export function displayVerbose(metrics, sessions) {
@@ -375,40 +475,57 @@ export function displayVerbose(metrics, sessions) {
   }
   console.log();
 
-  // Full metric details
+  // Decomposition details with interpretation
+  const d = metrics.decomposition.details;
   console.log(bold('  DECOMPOSITION DETAILS'));
-  for (const [k, v] of Object.entries(metrics.decomposition.details)) {
-    console.log(`  ${dim(pad(k, 30))} ${dim(String(v) + (typeof v === 'number' && k.includes('Ratio') ? '%' : ''))}`);
-  }
+  console.log(`  ${dim(pad('totalSessions', 30))} ${dim(String(d.totalSessions))}`);
+  console.log(`  ${dim(pad('multiStepSessions', 30))} ${dim(String(d.multiStepSessions))}  ${dim(d.multiStepSessions > d.totalSessions * 0.5 ? '\u2014 strong iterative work' : '\u2014 room for more iteration')}`);
+  console.log(`  ${dim(pad('singleShotSessions', 30))} ${dim(String(d.singleShotSessions))}  ${dim(d.singleShotSessions < d.totalSessions * 0.3 ? '\u2014 good, not over-relying on one-shots' : '\u2014 consider breaking tasks down more')}`);
+  console.log(`  ${dim(pad('avgExchangesPerSession', 30))} ${dim(String(d.avgExchangesPerSession))}  ${dim(d.avgExchangesPerSession > 12 ? '\u2014 deep sessions' : d.avgExchangesPerSession > 5 ? '\u2014 moderate depth' : '\u2014 shallow sessions')}`);
+  console.log(`  ${dim(pad('avgPromptLength', 30))} ${dim(String(d.avgPromptLength) + ' chars')}  ${dim(d.avgPromptLength > 300 ? '\u2014 detailed communicator' : d.avgPromptLength > 100 ? '\u2014 moderate detail' : '\u2014 terse')}`);
+  console.log(`  ${dim(pad('longPromptRatio', 30))} ${dim(d.longPromptRatio + '%')}`);
+  console.log(`  ${dim(pad('contextualFollowupRatio', 30))} ${dim(d.contextualFollowupRatio + '%')}  ${dim(d.contextualFollowupRatio > 20 ? '\u2014 builds on previous context well' : '\u2014 could reference prior context more')}`);
   console.log();
 
+  // Debug cycle details
+  const db = metrics.debugCycles.details;
   console.log(bold('  DEBUG CYCLE DETAILS'));
-  for (const [k, v] of Object.entries(metrics.debugCycles.details)) {
-    console.log(`  ${dim(pad(k, 30))} ${dim(String(v))}`);
-  }
+  console.log(`  ${dim(pad('totalDebugSequences', 30))} ${dim(String(db.totalDebugSequences))}`);
+  console.log(`  ${dim(pad('avgTurnsToResolve', 30))} ${dim(String(db.avgTurnsToResolve))}  ${dim(db.avgTurnsToResolve <= 2 ? '\u2014 surgical precision' : db.avgTurnsToResolve <= 4 ? '\u2014 efficient' : '\u2014 could be tighter')}`);
+  console.log(`  ${dim(pad('quickFixes', 30))} ${dim(String(db.quickFixes))}  ${dim(db.quickFixes > db.totalDebugSequences * 0.5 ? '\u2014 most issues resolved fast' : '')}`);
+  console.log(`  ${dim(pad('longLoops', 30))} ${dim(String(db.longLoops))}  ${dim(db.longLoops === 0 ? '\u2014 zero spirals' : '\u2014 some extended debugging')}`);
+  console.log(`  ${dim(pad('specificReportRatio', 30))} ${dim(db.specificReportRatio + '%')}  ${dim(db.specificReportRatio >= 80 ? '\u2014 precise error reporting' : '\u2014 include more stack traces/line numbers')}`);
+  console.log(`  ${dim(pad('vagueReports', 30))} ${dim(String(db.vagueReports))}  ${dim(db.vagueReports === 0 ? '\u2014 never vague' : `\u2014 ${db.vagueReports} vague reports`)}`);
   console.log();
 
+  // AI Leverage details
+  const ai = metrics.aiLeverage.details;
   console.log(bold('  AI LEVERAGE DETAILS'));
-  for (const [k, v] of Object.entries(metrics.aiLeverage.details)) {
-    if (typeof v === 'object') {
-      for (const [k2, v2] of Object.entries(v)) {
-        console.log(`  ${dim(pad(`  ${k}.${k2}`, 30))} ${dim(String(v2))}`);
-      }
-    } else {
-      console.log(`  ${dim(pad(k, 30))} ${dim(String(v))}`);
-    }
-  }
+  console.log(`  ${dim(pad('totalPrompts', 30))} ${dim(numberFormat(ai.totalPrompts))}`);
+  console.log(`  ${dim(pad('architecturalPrompts', 30))} ${dim(String(ai.architecturalPrompts))} ${dim(`(${Math.round(ai.architecturalPrompts / ai.totalPrompts * 100)}%)`)}  ${dim(ai.architecturalPrompts > ai.totalPrompts * 0.1 ? '\u2014 strategic usage' : '\u2014 could use AI for more design work')}`);
+  console.log(`  ${dim(pad('planningPrompts', 30))} ${dim(String(ai.planningPrompts))} ${dim(`(${Math.round(ai.planningPrompts / ai.totalPrompts * 100)}%)`)}`);
+  console.log(`  ${dim(pad('exploratoryPrompts', 30))} ${dim(String(ai.exploratoryPrompts))} ${dim(`(${Math.round(ai.exploratoryPrompts / ai.totalPrompts * 100)}%)`)}`);
+  console.log(`  ${dim(pad('boilerplatePrompts', 30))} ${dim(String(ai.boilerplatePrompts))} ${dim(`(${Math.round(ai.boilerplatePrompts / ai.totalPrompts * 100)}%)`)}  ${dim(ai.boilerplatePrompts < ai.totalPrompts * 0.05 ? '\u2014 very low, minimal repetitive work' : '\u2014 some boilerplate delegation')}`);
+  console.log(`  ${dim(pad('testingPrompts', 30))} ${dim(String(ai.testingPrompts))} ${dim(`(${Math.round(ai.testingPrompts / ai.totalPrompts * 100)}%)`)}`);
+  console.log(`  ${dim(pad('highLevelRatio', 30))} ${dim(ai.highLevelRatio + '%')}  ${dim(ai.highLevelRatio > 30 ? '\u2014 strong strategic AI usage' : '\u2014 room to leverage AI for higher-level work')}`);
+  console.log(`  ${dim(pad('toolDiversity.research', 30))} ${dim(String(ai.toolDiversity.research))}`);
+  console.log(`  ${dim(pad('toolDiversity.coding', 30))} ${dim(String(ai.toolDiversity.coding))}`);
   console.log();
 
+  // Session structure details
+  const ss = metrics.sessionStructure.details;
   console.log(bold('  SESSION STRUCTURE DETAILS'));
-  for (const [k, v] of Object.entries(metrics.sessionStructure.details)) {
-    if (typeof v === 'object') {
-      for (const [k2, v2] of Object.entries(v)) {
-        console.log(`  ${dim(pad(`  ${k}.${k2}`, 30))} ${dim(String(v2))}`);
-      }
-    } else {
-      console.log(`  ${dim(pad(k, 30))} ${dim(String(v) + (typeof v === 'number' && k.includes('Ratio') ? '%' : ''))}`);
-    }
+  console.log(`  ${dim(pad('contextSetRatio', 30))} ${dim(ss.contextSetRatio + '%')}  ${dim(ss.contextSetRatio > 50 ? '\u2014 deliberate context-setting' : '\u2014 try explaining goals upfront')}`);
+  console.log(`  ${dim(pad('planBeforeCodeRatio', 30))} ${dim(ss.planBeforeCodeRatio + '%')}  ${dim(ss.planBeforeCodeRatio > 20 ? '\u2014 plans before coding' : '\u2014 consider planning before diving in')}`);
+  console.log(`  ${dim(pad('reviewEndRatio', 30))} ${dim(ss.reviewEndRatio + '%')}  ${dim(ss.reviewEndRatio > 30 ? '\u2014 reviews work before shipping' : '\u2014 add review steps before finishing')}`);
+  console.log(`  ${dim(pad('refinementRatio', 30))} ${dim(ss.refinementRatio + '%')}  ${dim(ss.refinementRatio > 20 ? '\u2014 critically evaluates output' : '\u2014 push back on AI output more')}`);
+  console.log(`  ${dim(pad('avgFirstPromptLength', 30))} ${dim(ss.avgFirstPromptLength + ' chars')}  ${dim(ss.avgFirstPromptLength > 200 ? '\u2014 thorough session openers' : '\u2014 try longer context-setting openers')}`);
+  if (ss.durationDistribution) {
+    const dur = ss.durationDistribution;
+    console.log(`  ${dim(pad('duration.focused (10-45m)', 30))} ${dim(String(dur.focused))}  ${dim('\u2014 sweet spot sessions')}`);
+    console.log(`  ${dim(pad('duration.short (<5m)', 30))} ${dim(String(dur.short))}`);
+    console.log(`  ${dim(pad('duration.medium (5-60m)', 30))} ${dim(String(dur.medium))}`);
+    console.log(`  ${dim(pad('duration.long (>60m)', 30))} ${dim(String(dur.long))}`);
   }
   console.log();
 }
@@ -417,9 +534,10 @@ export function displayVerbose(metrics, sessions) {
 // OFFLINE DISPLAY (no API)
 // ══════════════════════════════════════════════
 
-export function displayOffline(result, metrics) {
-  displayScore(result, null);
+export function displayOffline(result, metrics, extra = {}) {
+  displayScore(result, null, extra);
   displayDataNarrativesWithTracker(metrics, new Set());
+  displayCoaching(result, metrics);
   displayEasterEggs(result, metrics);
   console.log(dim('  Run without --offline for personalized AI-generated insights\n'));
   displayEnding(result);
@@ -429,9 +547,10 @@ export function displayOffline(result, metrics) {
 // FULL ONLINE DISPLAY
 // ══════════════════════════════════════════════
 
-export function displayFull(result, metrics, prose) {
-  displayScore(result, prose);
+export function displayFull(result, metrics, prose, extra = {}) {
+  displayScore(result, prose, extra);
   displayNarratives(metrics, prose);
+  displayCoaching(result, metrics);
   displayEasterEggs(result, metrics);
   displayEnding(result);
 }

package/src/index.js

@@ -1,4 +1,7 @@
 import chalk from 'chalk';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
 import { detectTools } from './detect.js';
 import { parseAllProjects } from './parsers/claude-code.js';
 import { parseAllWorkspaces } from './parsers/cursor.js';
@@ -19,6 +22,52 @@ import {
 } from './display.js';
 import { generateProse, askVerbose, askClaim, uploadAndClaim } from './upload.js';
 
+// ── Score history ──
+const HISTORY_DIR = join(homedir(), '.chekk');
+const HISTORY_FILE = join(HISTORY_DIR, 'history.json');
+
+function loadHistory() {
+  try {
+    if (existsSync(HISTORY_FILE)) {
+      return JSON.parse(readFileSync(HISTORY_FILE, 'utf-8'));
+    }
+  } catch {}
+  return { scans: [] };
+}
+
+function saveHistory(history) {
+  try {
+    if (!existsSync(HISTORY_DIR)) mkdirSync(HISTORY_DIR, { recursive: true });
+    writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+  } catch {}
+}
+
+function computePerToolScores(allSessions) {
+  const toolSessions = {};
+  for (const s of allSessions) {
+    const t = s.sourceTool || 'Unknown';
+    if (!toolSessions[t]) toolSessions[t] = [];
+    toolSessions[t].push(s);
+  }
+
+  const perTool = {};
+  for (const [tool, sessions] of Object.entries(toolSessions)) {
+    if (sessions.length < 2) {
+      perTool[tool] = { sessions: sessions.length, score: null, label: 'limited data' };
+      continue;
+    }
+    const m = {
+      decomposition: computeDecomposition(sessions),
+      debugCycles: computeDebugCycles(sessions),
+      aiLeverage: computeAILeverage(sessions),
+      sessionStructure: computeSessionStructure(sessions),
+    };
+    const r = computeOverallScore(m);
+    perTool[tool] = { sessions: sessions.length, score: r.overall, label: null };
+  }
+  return perTool;
+}
+
 export async function run(options = {}) {
   // ── Header ──
   displayHeader();
@@ -34,16 +83,21 @@ export async function run(options = {}) {
 
   displayScan(tools);
 
-  // ── Step 2: Parse sessions ──
+  // ── Step 2: Parse sessions (tag each with sourceTool) ──
   let allSessions = [];
   for (const tool of tools) {
+    let parsed = [];
     if (tool.tool === 'Claude Code') {
-      allSessions.push(...parseAllProjects(tool.basePath));
+      parsed = parseAllProjects(tool.basePath);
     } else if (tool.tool === 'Cursor') {
-      allSessions.push(...parseAllWorkspaces(tool.basePath));
+      parsed = parseAllWorkspaces(tool.basePath);
     } else if (tool.tool === 'Codex') {
-      allSessions.push(...parseCodexSessions(tool.basePath));
+      parsed = parseCodexSessions(tool.basePath);
+    }
+    for (const s of parsed) {
+      s.sourceTool = tool.tool;
     }
+    allSessions.push(...parsed);
   }
 
   if (allSessions.length === 0) {
@@ -80,6 +134,25 @@ export async function run(options = {}) {
 
   const result = computeOverallScore(metrics);
 
+  // ── Cross-platform scores ──
+  const perToolScores = tools.length > 1 ? computePerToolScores(allSessions) : null;
+
+  // ── Score delta (compare to last scan) ──
+  const history = loadHistory();
+  const lastScan = history.scans.length > 0 ? history.scans[history.scans.length - 1] : null;
+  const scoreDelta = lastScan ? result.overall - lastScan.overall : null;
+
+  // Save current scan
+  history.scans.push({
+    overall: result.overall,
+    tier: result.tier,
+    archetype: result.archetype.name,
+    date: new Date().toISOString(),
+  });
+  // Keep last 20 scans
+  if (history.scans.length > 20) history.scans = history.scans.slice(-20);
+  saveHistory(history);
+
   const sessionStats = {
     totalSessions: allSessions.length,
     totalExchanges,
@@ -90,13 +163,11 @@ export async function run(options = {}) {
 
   // ── JSON output ──
   if (options.json) {
-    console.log(JSON.stringify({ metrics, result, sessionStats }, null, 2));
+    console.log(JSON.stringify({ metrics, result, sessionStats, perToolScores, scoreDelta }, null, 2));
     return;
   }
 
   // ── Step 4: Progress bar + API call in parallel ──
-  // Run prose generation alongside the progress bar so score appears
-  // immediately when the bar hits 100% — no lag.
   let prose = null;
   if (!options.offline) {
     const [, proseResult] = await Promise.all([
@@ -110,13 +181,12 @@ export async function run(options = {}) {
 
   // ── Step 5: Display results ──
   if (options.offline) {
-    displayOffline(result, metrics);
+    displayOffline(result, metrics, { scoreDelta, perToolScores });
   } else {
-    displayFull(result, metrics, prose);
+    displayFull(result, metrics, prose, { scoreDelta, perToolScores });
   }
 
   // ── Step 6: Verbose prompt (interactive) ──
-  // If --verbose flag was passed, show immediately. Otherwise prompt.
   if (options.verbose) {
     displayVerbose(metrics, allSessions);
   } else {