chekk 0.3.0 → 0.4.1

package/src/display.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { BENCHMARKS, DIM_RANGES } from './insights.js';
 
 // ── Color palette ──
 const gold = chalk.hex('#FFD700');
@@ -7,6 +8,8 @@ const blue = chalk.hex('#3B82F6');
 const green = chalk.hex('#22C55E');
 const cyan = chalk.hex('#06B6D4');
 const orange = chalk.hex('#F97316');
+const red = chalk.hex('#EF4444');
+const yellow = chalk.hex('#EAB308');
 const dim = chalk.dim;
 const bold = chalk.bold;
 const white = chalk.white;
@@ -22,9 +25,9 @@ function tierColor(tier) {
 function scoreColor(score) {
   if (score >= 85) return green;
   if (score >= 70) return cyan;
-  if (score >= 55) return chalk.hex('#EAB308');
+  if (score >= 55) return yellow;
   if (score >= 40) return orange;
-  return chalk.hex('#EF4444');
+  return red;
 }
 
 function progressBar(score, width = 18) {
@@ -45,23 +48,22 @@ function pad(str, len) {
 
 // ── 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';
+  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 >= 50) return yellow;
   if (score >= 35) return orange;
-  return chalk.hex('#EF4444');
+  return red;
 }
 
 // ── Snippet helpers ──
-// Longer snippets with context labels instead of truncated decorations
 
 function cleanPrompt(prompt, maxLen = 120) {
   if (!prompt) return null;
@@ -78,15 +80,37 @@ function displayLabeledSnippet(label, prompt, maxLen = 120) {
   console.log(`  ${dim('\u21B3')} ${dim(label + ':')} ${dim.italic('\u201C' + s + '\u201D')}`);
 }
 
+// Cross-dimension filters: reject prompts that clearly belong to another dimension
+const architecturalRe = /\b(architect|design|refactor|redesign|restructure|system design|data model|schema|api design|infrastructure|migration|strategy)\b/i;
+const debugRe = /\b(error|bug|broken|crash|fail|exception|traceback|stack trace|doesn'?t work|not working|TypeError|SyntaxError|ImportError|ReferenceError|500|502|503|404|CORS)\b/i;
+const planningRe = /\b(plan|breakdown|break down|think through|help me think|pros and cons|how should|code review|audit)\b/i;
+
+// For each dimension, prompts matching these patterns are *excluded* as evidence
+const dimensionExclusions = {
+  'specific_report': [architecturalRe, planningRe],
+  'quick_fix': [architecturalRe, planningRe],
+  'architectural': [debugRe],
+  'planning': [debugRe],
+  'exploratory': [debugRe],
+  'decomposition': [],
+  'followup': [],
+  'context_setting': [],
+  'refinement': [],
+};
+
 function pickExample(examples, type) {
   if (!examples || !examples.length) return null;
-  const match = examples.find(e => e.type === type);
-  return match ? match.prompt : null;
+  const exclusions = dimensionExclusions[type] || [];
+  // Prefer a match that doesn't trigger exclusion patterns
+  const candidates = examples.filter(e => e.type === type);
+  if (candidates.length === 0) return null;
+  const clean = candidates.find(e => !exclusions.some(re => re.test(e.prompt)));
+  return (clean || candidates[0]).prompt;
 }
 
 // ── Box drawing ──
 
-function box(lines, width = 43) {
+function box(lines, width = 47) {
   const out = [];
   out.push(dim('  \u250C' + '\u2500'.repeat(width) + '\u2510'));
   for (const line of lines) {
@@ -98,33 +122,44 @@ function box(lines, width = 43) {
   return out;
 }
 
-function doubleRule(width = 47) {
+function doubleRule(width = 53) {
   return dim('  ' + '\u2550'.repeat(width));
 }
 
+function wrapText(text, maxWidth = 49) {
+  const words = text.split(' ');
+  const lines = [];
+  let current = '';
+  for (const word of words) {
+    if (current.length + word.length + 1 > maxWidth) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = current ? current + ' ' + word : word;
+    }
+  }
+  if (current) lines.push(current);
+  return lines;
+}
+
 // ══════════════════════════════════════════════
-// HEADER
+// HEADER — Scanning + progress
 // ══════════════════════════════════════════════
 
 export function displayHeader() {
   console.log();
   const lines = [
     '',
-    `   ${bold.white('chekk')}${dim(' v0.3.0')}`,
-    `   ${dim('the engineering capability score')}`,
+    `   ${bold.white('chekk')}${dim(' v0.4.1')}`,
+    `   ${dim('engineering capability profile')}`,
     '',
   ];
   for (const l of box(lines, 45)) console.log(l);
   console.log();
 }
 
-// ══════════════════════════════════════════════
-// SCAN RESULTS
-// ══════════════════════════════════════════════
-
 export function displayScan(tools) {
   console.log(dim('  Scanning local AI tools...\n'));
-
   for (const tool of tools) {
     const sessions = numberFormat(tool.sessions);
     const projects = tool.projects.length;
@@ -136,10 +171,6 @@ export function displayScan(tools) {
   console.log();
 }
 
-// ══════════════════════════════════════════════
-// ANALYSIS PROGRESS BAR
-// ══════════════════════════════════════════════
-
 export function displayAnalysisStart(dateRange) {
   console.log(`  ${dim('Analyzing')} ${white(dateRange)}${dim('...\n')}`);
 }
@@ -148,7 +179,6 @@ export async function displayProgressBar(durationMs = 2000) {
   const width = 40;
   const steps = 40;
   const stepTime = durationMs / steps;
-
   for (let i = 0; i <= steps; i++) {
     const filled = i;
     const empty = width - filled;
@@ -159,108 +189,199 @@ export async function displayProgressBar(durationMs = 2000) {
   }
   console.log();
   console.log();
-  console.log(`  ${green('\u2713')} ${dim('Score generated.')}`);
+  console.log(`  ${green('\u2713')} ${dim('Profile generated.')}`);
   console.log();
 }
 
 // ══════════════════════════════════════════════
-// MAIN SCORE DISPLAY
+// PROFILE HEADER — Official document feel
 // ══════════════════════════════════════════════
 
-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);
+function displayProfileHeader(result, extra = {}) {
+  const { sessionStats } = extra;
+  const now = new Date();
+  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+  const dateStr = `${months[now.getMonth()]} ${now.getDate()}, ${now.getFullYear()}`;
 
-  // Big score block
   console.log(doubleRule());
   console.log();
-  console.log(dim('  YOUR CHEKK SCORE'));
+  console.log(`  ${bold.white('ENGINEERING CAPABILITY PROFILE')}`);
+  console.log();
+  if (sessionStats) {
+    console.log(`  ${dim(`Generated ${dateStr} | chekk v0.4.1`)}`);
+    console.log(`  ${dim(`Analysis: ${sessionStats.totalSessions} sessions \u00B7 ${sessionStats.tools.length} tool${sessionStats.tools.length > 1 ? 's' : ''} \u00B7 ${numberFormat(sessionStats.totalExchanges)} exchanges`)}`);
+    if (sessionStats.dateRangeShort) {
+      console.log(`  ${dim(`Period: ${sessionStats.dateRangeShort}`)}`);
+    }
+  }
+  console.log();
+  console.log(doubleRule());
+}
+
+// ══════════════════════════════════════════════
+// SUMMARY BLOCK
+// ══════════════════════════════════════════════
+
+function displaySummary(result, extra = {}) {
+  const { overall, scores, archetype, tier, tierBadge, tierPercentile } = result;
+  const { scoreDelta, perToolScores, insights, sessionStats } = extra;
+  const tc = tierColor(tier);
+
+  // Find strongest and weakest
+  const dims = [
+    { label: 'Thinking', score: scores.decomposition },
+    { label: 'Debugging', score: scores.debugCycles },
+    { label: 'AI Leverage', score: scores.aiLeverage },
+    { label: 'Workflow', score: scores.sessionStructure },
+  ];
+  dims.sort((a, b) => b.score - a.score);
+  const strongest = dims[0];
+  const weakest = dims[dims.length - 1];
+
   console.log();
+  console.log(dim('  SUMMARY'));
 
-  // Score + delta
+  const badge = tierBadge || '';
+  const toolsList = sessionStats ? sessionStats.tools.join(' \u00B7 ') : '';
+  const sessionCount = sessionStats ? `${sessionStats.totalSessions} across ${sessionStats.projectCount} projects` : '';
+  const period = sessionStats?.dateRangeShort || '';
+
+  // Delta string
   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')}`;
+    if (scoreDelta > 0) deltaStr = `  ${green('\u2191 +' + scoreDelta)}`;
+    else if (scoreDelta < 0) deltaStr = `  ${orange('\u2193 ' + scoreDelta)}`;
   }
-  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}`);
+
+  const summaryLines = [
+    '',
+    `  ${dim('Score')}          ${scoreColor(overall).bold(String(overall))}${deltaStr}`,
+    `  ${dim('Tier')}           ${tc(tier)} ${badge} ${dim('\u2014')} ${dim(tierPercentile)}`,
+    `  ${dim('Archetype')}      ${bold.white(archetype.name)}`,
+  ];
+  if (toolsList) summaryLines.push(`  ${dim('Tools')}          ${dim(toolsList)}`);
+  if (sessionCount) summaryLines.push(`  ${dim('Sessions')}       ${dim(sessionCount)}`);
+  if (period) summaryLines.push(`  ${dim('Period')}         ${dim(period)}`);
+  summaryLines.push(`  ${dim('Strongest')}      ${dim(strongest.label + ' (' + dimTierLabel(strongest.score) + ')')}`);
+  summaryLines.push(`  ${dim('Growth Area')}    ${dim(weakest.label + ' (' + dimTierLabel(weakest.score) + ')')}`);
+  summaryLines.push('');
+
+  for (const l of box(summaryLines, 53)) console.log(l);
   console.log();
-  console.log(`  ${dim('Archetype:')} ${bold.white(archetype.name)}`);
+}
+
+// ══════════════════════════════════════════════
+// ARCHETYPE DEFINITION
+// ══════════════════════════════════════════════
 
-  if (prose && prose.tagline) {
-    console.log(`  ${dim('"' + prose.tagline + '"')}`);
+function displayArchetype(result) {
+  const { archetype } = result;
+  console.log(`  ${bold.white(archetype.name)}`);
+  console.log();
+  if (archetype.description) {
+    const lines = wrapText(archetype.description, 51);
+    for (const line of lines) {
+      console.log(`  ${dim(line)}`);
+    }
+  }
+  if (archetype.distribution) {
+    console.log();
+    console.log(`  ${dim('Distribution: ' + archetype.distribution + ' of scored engineers')}`);
   }
   console.log();
+}
 
-  // ── Score weights (transparency) ──
-  console.log(`  ${dim('Score = Thinking (25%) + Debugging (25%) + AI Leverage (30%) + Workflow (20%)')}`);
-  console.log();
-  console.log(doubleRule());
+// ══════════════════════════════════════════════
+// DIMENSIONS — with ranges and qualitative labels
+// ══════════════════════════════════════════════
+
+function displayDimensions(result) {
+  const { scores } = result;
+  console.log(dim('  DIMENSIONS'));
   console.log();
 
-  // Dimensions box with qualitative labels
-  console.log(dim('  DIMENSIONS\n'));
+  // Score weight transparency
+  console.log(`  ${dim('Weights: Thinking 25% | Debugging 25% | AI Leverage 30% | Workflow 20%')}`);
+  console.log();
 
-  function dimLine(label, score) {
+  function dimLine(label, key, 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 ? ' ' : '';
     const tierLabel = dimTierLabel(score);
-    const tierStr = dimTierColor(score)(tierLabel);
-    return `  ${labelStr}${labelPad}${progressBar(score)} ${scorePad}${bold(scoreStr)}  ${dim('\u2500\u2500')} ${tierStr} `;
+    const tierStr = dimTierColor(score)(pad(tierLabel, 11));
+    const range = DIM_RANGES[key];
+    const rangeStr = dim(`range: ${range.min}-${range.max} | you: ${score}`);
+    return [
+      `  ${labelStr}${labelPad}${progressBar(score)}  ${tierStr}`,
+      `  ${' '.repeat(15)}${rangeStr}`,
+    ];
   }
 
-  const dimLines = [
-    '',
-    dimLine('Thinking', scores.decomposition),
-    dimLine('Debugging', scores.debugCycles),
-    dimLine('AI Leverage', scores.aiLeverage),
-    dimLine('Workflow', scores.sessionStructure),
-    '',
-  ];
-  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')}`);
-      }
+  const allLines = [''];
+  allLines.push(...dimLine('Thinking', 'decomposition', scores.decomposition));
+  allLines.push('');
+  allLines.push(...dimLine('Debugging', 'debugCycles', scores.debugCycles));
+  allLines.push('');
+  allLines.push(...dimLine('AI Leverage', 'aiLeverage', scores.aiLeverage));
+  allLines.push('');
+  allLines.push(...dimLine('Workflow', 'sessionStructure', scores.sessionStructure));
+  allLines.push('');
+
+  for (const l of box(allLines, 53)) console.log(l);
+  console.log();
+}
+
+// ══════════════════════════════════════════════
+// CROSS-PLATFORM
+// ══════════════════════════════════════════════
+
+function displayCrossPlatform(perToolScores) {
+  if (!perToolScores || Object.keys(perToolScores).length <= 1) return;
+
+  console.log(dim('  CROSS-PLATFORM\n'));
+  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;
+  });
+  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' : 'active';
+      console.log(`  ${pad(bold(tool), 18)} ${bold(String(data.score))} ${progressBar(data.score)}  ${dim(label)}`);
+    } else {
+      console.log(`  ${pad(bold(tool), 18)} ${dim('--')} ${dim('\u2591'.repeat(18))}  ${dim('limited data')}`);
     }
+  }
+  console.log();
+}
+
+// ══════════════════════════════════════════════
+// PROJECT ANALYSIS
+// ══════════════════════════════════════════════
+
+function displayProjects(insights) {
+  const projects = insights?.projectComplexity;
+  if (!projects || projects.length === 0) return;
+
+  console.log(dim('  PROJECT ANALYSIS\n'));
+  for (const p of projects) {
+    const compColor = p.complexity === 'HIGH' ? green : p.complexity === 'MEDIUM' ? yellow : dim;
+    const signals = p.signals.length > 0 ? p.signals.join(' \u00B7 ') : '';
+    console.log(`  ${pad(bold(p.name), 32)} Complexity: ${compColor(p.complexity)}`);
+    if (signals) {
+      console.log(`  ${dim(signals)}`);
+    }
+    console.log(`  ${dim(`${p.sessions} sessions \u00B7 ${numberFormat(p.exchanges)} exchanges \u00B7 ${p.daysActive} days active`)}`);
     console.log();
   }
 }
 
 // ══════════════════════════════════════════════
-// DIMENSION NARRATIVES (data-driven, punchy)
+// DIMENSION NARRATIVES — Clinical, benchmarked
 // ══════════════════════════════════════════════
 
 export function displayNarratives(metrics, prose) {
@@ -275,10 +396,10 @@ export function displayNarratives(metrics, prose) {
 
   if (prose && prose.sections) {
     const sectionSnippetMap = {
-      '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') },
+      'thinking': { label: 'Evidence', prompt: pickExample(metrics.decomposition.examples, 'decomposition') },
+      'debugging': { label: 'Evidence', prompt: pickExample(metrics.debugCycles.examples, 'specific_report') || pickExample(metrics.debugCycles.examples, 'quick_fix') },
+      'ai leverage': { label: 'Evidence', prompt: pickExample(metrics.aiLeverage.examples, 'architectural') || pickExample(metrics.aiLeverage.examples, 'planning') },
+      'workflow': { label: 'Evidence', prompt: pickExample(metrics.sessionStructure.examples, 'context_setting') || pickExample(metrics.sessionStructure.examples, 'refinement') },
     };
 
     for (const section of prose.sections) {
@@ -293,21 +414,17 @@ export function displayNarratives(metrics, prose) {
       console.log();
     }
   } else {
-    displayDataNarrativesWithTracker(metrics, shownSnippets);
+    displayDataNarratives(metrics, shownSnippets);
   }
 }
 
-function displayDataNarrativesWithTracker(metrics, shownSnippets) {
+function displayDataNarratives(metrics, shownSnippets) {
   const d = metrics.decomposition.details;
   const db = metrics.debugCycles.details;
   const ai = metrics.aiLeverage.details;
   const ss = metrics.sessionStructure.details;
-  const dEx = metrics.decomposition.examples || [];
-  const dbEx = metrics.debugCycles.examples || [];
-  const aiEx = metrics.aiLeverage.examples || [];
-  const ssEx = metrics.sessionStructure.examples || [];
 
-  function showLabeledSnippet(label, prompt) {
+  function showSnippet(label, prompt) {
     if (!prompt) return;
     const s = cleanPrompt(prompt, 120);
     if (shownSnippets.has(s)) return;
@@ -315,128 +432,180 @@ function displayDataNarrativesWithTracker(metrics, shownSnippets) {
     displayLabeledSnippet(label, prompt);
   }
 
-  // Thinking
+  // Thinking — clinical
   console.log(`  ${bold('\uD83E\uDDE0 THINKING')}`);
-  const exchPerSession = d.avgExchangesPerSession;
-  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')}`);
-  showLabeledSnippet('Best decomposition prompt', pickExample(dEx, 'decomposition'));
+  console.log(`  ${dim(`Avg session depth: ${d.avgExchangesPerSession} exchanges (benchmark: ${BENCHMARKS.avgExchangesPerSession})`)}`);
+  console.log(`  ${dim(`Avg prompt length: ${numberFormat(d.avgPromptLength)} chars (benchmark: ${BENCHMARKS.avgPromptLength})`)}`);
+  console.log(`  ${dim(`Multi-step ratio: ${d.multiStepSessions}/${d.totalSessions} sessions (${Math.round(d.multiStepSessions / Math.max(1, d.totalSessions) * 100)}%)`)}`);
+  showSnippet('Evidence', pickExample(metrics.decomposition.examples, 'decomposition'));
   console.log();
 
-  // Debugging
+  // Debugging — clinical
   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 \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(`  ${dim(`Avg resolution: ${db.avgTurnsToResolve} turns (benchmark: ${BENCHMARKS.avgTurnsToResolve})`)}`);
+  console.log(`  ${dim(`Specific reports: ${db.specificReportRatio}% (benchmark: ${BENCHMARKS.specificReportRatio}%)`)}`);
+  console.log(`  ${dim(`Extended loops: ${db.longLoops} | Quick fixes: ${db.quickFixes}/${db.totalDebugSequences}`)}`);
+  showSnippet('Evidence', pickExample(metrics.debugCycles.examples, 'specific_report') || pickExample(metrics.debugCycles.examples, 'quick_fix'));
   console.log();
 
-  // AI Leverage
+  // AI Leverage — clinical
   console.log(`  ${bold('\uD83D\uDD27 AI LEVERAGE')}`);
-  console.log(`  ${dim(`${ai.highLevelRatio}% architecture prompts \u2014 ${ai.highLevelRatio > 25 ? 'high-level partner usage' : 'room to leverage AI more strategically'}`)}`);
-  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`)}`);
-  showLabeledSnippet('Best leverage prompt', pickExample(aiEx, 'architectural') || pickExample(aiEx, 'planning'));
+  console.log(`  ${dim(`High-level ratio: ${ai.highLevelRatio}% (benchmark: ${BENCHMARKS.highLevelRatio}%)`)}`);
+  console.log(`  ${dim(`Breakdown: ${ai.architecturalPrompts} architectural \u00B7 ${ai.planningPrompts} planning \u00B7 ${ai.exploratoryPrompts} exploratory`)}`);
+  console.log(`  ${dim(`Boilerplate: ${ai.boilerplatePrompts} (${Math.round(ai.boilerplatePrompts / Math.max(1, ai.totalPrompts) * 100)}%) \u00B7 Testing: ${ai.testingPrompts}`)}`);
+  showSnippet('Evidence', pickExample(metrics.aiLeverage.examples, 'architectural') || pickExample(metrics.aiLeverage.examples, 'planning'));
   console.log();
 
-  // Workflow
+  // Workflow — clinical
   console.log(`  ${bold('\uD83D\uDCD0 WORKFLOW')}`);
-  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'}`)}`);
-  showLabeledSnippet('Best workflow prompt', pickExample(ssEx, 'context_setting') || pickExample(ssEx, 'refinement'));
+  console.log(`  ${dim(`Context-setting: ${ss.contextSetRatio}% (benchmark: ${BENCHMARKS.contextSetRatio}%)`)}`);
+  console.log(`  ${dim(`Review at end: ${ss.reviewEndRatio}% (benchmark: ${BENCHMARKS.reviewEndRatio}%)`)}`);
+  console.log(`  ${dim(`Refinement rate: ${ss.refinementRatio}% (benchmark: ${BENCHMARKS.refinementRatio}%)`)}`);
+  showSnippet('Evidence', pickExample(metrics.sessionStructure.examples, 'context_setting') || pickExample(metrics.sessionStructure.examples, 'refinement'));
   console.log();
 }
 
-
 // ══════════════════════════════════════════════
-// COACHING RECOMMENDATION
+// SIGNATURES — What makes you distinctive
 // ══════════════════════════════════════════════
 
-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)}`);
+function displaySignatures(insights) {
+  const sigs = insights?.signatures;
+  if (!sigs || sigs.length === 0) return;
+
+  console.log(dim('  YOUR SIGNATURES\n'));
+  for (const sig of sigs) {
+    console.log(`  ${cyan('\u2726')} ${bold(sig.name)}`);
+    const lines = wrapText(sig.detail, 49);
+    for (const line of lines) {
+      console.log(`    ${dim(line)}`);
+    }
+    console.log();
   }
-  console.log();
 }
 
-
 // ══════════════════════════════════════════════
-// EASTER EGGS
+// WATCH POINTS — Areas to improve
 // ══════════════════════════════════════════════
 
-export function displayEasterEggs(result, metrics) {
-  const { overall } = result;
-  const db = metrics.debugCycles.details;
-
-  const eggs = [];
+function displayWatchPoints(insights) {
+  const wps = insights?.watchPoints;
+  if (!wps || wps.length === 0) return;
 
-  if (overall >= 90) {
-    eggs.push('Top-tier. Companies should be applying to you.');
+  console.log(dim('  WATCH POINTS\n'));
+  for (const wp of wps) {
+    console.log(`  ${orange('\u26A0')} ${bold(wp.name)}`);
+    const lines = wrapText(wp.detail, 49);
+    for (const line of lines) {
+      console.log(`    ${dim(line)}`);
+    }
+    console.log();
   }
+}
+
+// ══════════════════════════════════════════════
+// TRAJECTORY — Weekly evolution
+// ══════════════════════════════════════════════
 
-  if (db.longLoops === 0 && db.totalDebugSequences > 10) {
-    eggs.push('Zero debug spirals. Either you\'re exceptional or your AI is.');
+function displayTrajectory(insights) {
+  const traj = insights?.trajectory;
+  if (!traj) return;
+
+  console.log(dim('  YOUR TRAJECTORY\n'));
+  for (let i = 0; i < traj.weeks.length; i++) {
+    const w = traj.weeks[i];
+    const prev = i > 0 ? traj.weeks[i - 1] : null;
+    const arrow = prev ? (w.score > prev.score ? green(' \u2191') : w.score < prev.score ? orange(' \u2193') : dim(' \u2192')) : '';
+    const tierLabel = dimTierLabel(w.score);
+    console.log(`  ${dim(pad(w.label, 16))} Score: ${scoreColor(w.score).bold(String(w.score))}  ${dimTierColor(w.score)(tierLabel)}${arrow}`);
   }
+  console.log();
+  const velColor = traj.velocityLabel === 'FAST' ? green : traj.velocityLabel === 'STEADY' ? cyan : traj.velocityLabel === 'STABLE' ? yellow : orange;
+  console.log(`  ${dim('Learning velocity:')} ${velColor(traj.velocityLabel)} ${dim('\u2014 ' + traj.velocityDetail)}`);
+  console.log();
+}
 
-  if (db.vagueReports === 0 && db.totalDebugSequences > 20) {
-    eggs.push('Never once said "it\'s broken, fix it." Respect.');
+// ══════════════════════════════════════════════
+// ASSESSMENT — Narrative paragraph
+// ══════════════════════════════════════════════
+
+function displayAssessment(insights) {
+  const assessment = insights?.assessment;
+  if (!assessment) return;
+
+  console.log(dim('  ASSESSMENT\n'));
+  const lines = wrapText(assessment, 51);
+  for (const line of lines) {
+    console.log(`  ${dim(line)}`);
   }
+  console.log();
+}
 
-  if (eggs.length > 0) {
-    for (const egg of eggs) {
-      console.log(`  ${dim('\u2727')} ${dim.italic(egg)}`);
-    }
+// ══════════════════════════════════════════════
+// CONFIDENCE INDICATOR
+// ══════════════════════════════════════════════
+
+function displayConfidence(insights, sessionStats) {
+  const conf = insights?.confidence;
+  if (!conf) return;
+
+  const barWidth = 18;
+  const filled = Math.round((conf.score / 100) * barWidth);
+  const empty = barWidth - filled;
+  const confColor = conf.level === 'HIGH' ? green : conf.level === 'MODERATE' ? yellow : orange;
+  const bar = confColor('\u2588'.repeat(filled)) + dim('\u2591'.repeat(empty));
+
+  console.log(`  ${dim('Profile confidence:')} ${bar}  ${confColor(conf.level)}`);
+  if (sessionStats) {
+    console.log(`  ${dim(`Based on ${sessionStats.totalSessions} sessions across ${sessionStats.tools.length} tool${sessionStats.tools.length > 1 ? 's' : ''}.`)}`);
+  }
+  console.log();
+  if (conf.level !== 'HIGH') {
+    console.log(`  ${dim('Confidence increases with more sessions and tool')}`);
+    console.log(`  ${dim('diversity. Run again in 30 days for updated assessment.')}`);
     console.log();
   }
 }
 
 // ══════════════════════════════════════════════
-// VIRAL ENDING
+// METHODOLOGY FOOTER
 // ══════════════════════════════════════════════
 
-export function displayEnding(result) {
+function displayMethodology() {
+  console.log(doubleRule());
+  console.log();
+  console.log(`  ${dim('METHODOLOGY')}`);
+  console.log(`  ${dim('Scores derived from structural analysis of prompt')}`);
+  console.log(`  ${dim('patterns, debug sequences, and session architecture')}`);
+  console.log(`  ${dim('across detected AI coding tools. Tier placement based')}`);
+  console.log(`  ${dim('on distribution of scored engineers. No prompt content')}`);
+  console.log(`  ${dim('is stored or transmitted. Learn more: chekk.dev/methodology')}`);
+  console.log();
+}
+
+// ══════════════════════════════════════════════
+// NEXT STEPS — Credential issuance
+// ══════════════════════════════════════════════
+
+function displayNextSteps(result) {
   const { overall, archetype, tier, tierBadge } = result;
   const tc = tierColor(tier);
 
   console.log(doubleRule());
   console.log();
-
-  // 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(`  ${bold.white('NEXT STEPS')}`);
+  console.log();
+  console.log(`  ${dim('\u2192 Claim your verified profile')}`);
+  console.log(`    ${dim('Link your GitHub and LinkedIn to create your')}`);
+  console.log(`    ${dim('portable engineering credential.')}`);
+  console.log(`    ${cyan.underline('chekk.dev/claim')}`);
+  console.log();
+  console.log(`  ${dim('\u2192 View industry benchmarks')}`);
+  console.log(`    ${dim('See how you compare across scored engineers.')}`);
+  console.log(`    ${cyan.underline('chekk.dev/benchmarks')}`);
   console.log();
-  console.log(`  ${dim('\u2192 Leaderboard:')}  ${cyan.underline('chekk.dev/leaderboard')}`);
+  console.log(`  ${dim('\u2192 Export this report')}`);
+  console.log(`    ${dim('npx chekk --json')}`);
   console.log();
 
   // Copy-paste share line
@@ -446,12 +615,12 @@ export function displayEnding(result) {
   console.log(`  ${dim('\u2191 Copy this to share')}`);
   console.log();
   console.log(doubleRule());
-  console.log(`  ${dim('chekk.dev \u2014 the engineering capability score')}`);
+  console.log(`  ${dim('chekk.dev \u2014 engineering capability profiles')}`);
   console.log();
 }
 
 // ══════════════════════════════════════════════
-// VERBOSE: DETAILED BREAKDOWN (with interpretation)
+// VERBOSE: DETAILED BREAKDOWN
 // ══════════════════════════════════════════════
 
 export function displayVerbose(metrics, sessions) {
@@ -475,72 +644,77 @@ export function displayVerbose(metrics, sessions) {
   }
   console.log();
 
-  // Decomposition details with interpretation
+  // Decomposition
   const d = metrics.decomposition.details;
-  console.log(bold('  DECOMPOSITION DETAILS'));
-  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(bold('  DECOMPOSITION'));
+  console.log(`  ${dim(pad('Avg session depth', 30))} ${dim(String(d.avgExchangesPerSession))}  ${dim(`(benchmark: ${BENCHMARKS.avgExchangesPerSession})`)}`);
+  console.log(`  ${dim(pad('Avg prompt length', 30))} ${dim(d.avgPromptLength + ' chars')}  ${dim(`(benchmark: ${BENCHMARKS.avgPromptLength})`)}`);
+  console.log(`  ${dim(pad('Multi-step sessions', 30))} ${dim(String(d.multiStepSessions) + '/' + d.totalSessions)}  ${dim(d.multiStepSessions > d.totalSessions * 0.5 ? '\u2014 strong' : '\u2014 room to grow')}`);
+  console.log(`  ${dim(pad('Single-shot sessions', 30))} ${dim(String(d.singleShotSessions))}`);
+  console.log(`  ${dim(pad('Contextual followups', 30))} ${dim(d.contextualFollowupRatio + '%')}  ${dim(d.contextualFollowupRatio > 20 ? '\u2014 builds on context well' : '\u2014 could reference prior work more')}`);
   console.log();
 
-  // Debug cycle details
+  // Debug
   const db = metrics.debugCycles.details;
-  console.log(bold('  DEBUG CYCLE DETAILS'));
-  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(bold('  DEBUG CYCLES'));
+  console.log(`  ${dim(pad('Total sequences', 30))} ${dim(String(db.totalDebugSequences))}`);
+  console.log(`  ${dim(pad('Avg turns to resolve', 30))} ${dim(String(db.avgTurnsToResolve))}  ${dim(`(benchmark: ${BENCHMARKS.avgTurnsToResolve})`)}`);
+  console.log(`  ${dim(pad('Quick fixes (\u22642 turns)', 30))} ${dim(String(db.quickFixes))}`);
+  console.log(`  ${dim(pad('Extended loops (>5 turns)', 30))} ${dim(String(db.longLoops))}  ${dim(db.longLoops === 0 ? '\u2014 zero spirals' : '')}`);
+  console.log(`  ${dim(pad('Specific report ratio', 30))} ${dim(db.specificReportRatio + '%')}  ${dim(`(benchmark: ${BENCHMARKS.specificReportRatio}%)`)}`);
+  console.log(`  ${dim(pad('Vague reports', 30))} ${dim(String(db.vagueReports))}  ${dim(db.vagueReports === 0 ? '\u2014 never vague' : '')}`);
   console.log();
 
-  // AI Leverage details
+  // AI Leverage
   const ai = metrics.aiLeverage.details;
-  console.log(bold('  AI LEVERAGE DETAILS'));
-  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
+  console.log(bold('  AI LEVERAGE'));
+  console.log(`  ${dim(pad('Total prompts', 30))} ${dim(numberFormat(ai.totalPrompts))}`);
+  console.log(`  ${dim(pad('Architectural', 30))} ${dim(String(ai.architecturalPrompts))} ${dim(`(${Math.round(ai.architecturalPrompts / Math.max(1, ai.totalPrompts) * 100)}%)`)}`);
+  console.log(`  ${dim(pad('Planning', 30))} ${dim(String(ai.planningPrompts))} ${dim(`(${Math.round(ai.planningPrompts / Math.max(1, ai.totalPrompts) * 100)}%)`)}`);
+  console.log(`  ${dim(pad('Exploratory', 30))} ${dim(String(ai.exploratoryPrompts))} ${dim(`(${Math.round(ai.exploratoryPrompts / Math.max(1, ai.totalPrompts) * 100)}%)`)}`);
+  console.log(`  ${dim(pad('Boilerplate', 30))} ${dim(String(ai.boilerplatePrompts))} ${dim(`(${Math.round(ai.boilerplatePrompts / Math.max(1, ai.totalPrompts) * 100)}%)`)}  ${dim(ai.boilerplatePrompts < ai.totalPrompts * 0.05 ? '\u2014 minimal' : '')}`);
+  console.log(`  ${dim(pad('Testing', 30))} ${dim(String(ai.testingPrompts))}`);
+  console.log(`  ${dim(pad('High-level ratio', 30))} ${dim(ai.highLevelRatio + '%')}  ${dim(`(benchmark: ${BENCHMARKS.highLevelRatio}%)`)}`);
+  console.log();
+
+  // Session structure
   const ss = metrics.sessionStructure.details;
-  console.log(bold('  SESSION STRUCTURE DETAILS'));
-  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')}`);
+  console.log(bold('  SESSION STRUCTURE'));
+  console.log(`  ${dim(pad('Context-setting', 30))} ${dim(ss.contextSetRatio + '%')}  ${dim(`(benchmark: ${BENCHMARKS.contextSetRatio}%)`)}`);
+  console.log(`  ${dim(pad('Plan before code', 30))} ${dim(ss.planBeforeCodeRatio + '%')}`);
+  console.log(`  ${dim(pad('Review at end', 30))} ${dim(ss.reviewEndRatio + '%')}  ${dim(`(benchmark: ${BENCHMARKS.reviewEndRatio}%)`)}`);
+  console.log(`  ${dim(pad('Refinement rate', 30))} ${dim(ss.refinementRatio + '%')}  ${dim(`(benchmark: ${BENCHMARKS.refinementRatio}%)`)}`);
+  console.log(`  ${dim(pad('Avg first prompt', 30))} ${dim(ss.avgFirstPromptLength + ' chars')}`);
   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(`  ${dim(pad('Focused sessions (10-45m)', 30))} ${dim(String(dur.focused))}`);
+    console.log(`  ${dim(pad('Short (<5m)', 30))} ${dim(String(dur.short))}`);
+    console.log(`  ${dim(pad('Medium (5-60m)', 30))} ${dim(String(dur.medium))}`);
+    console.log(`  ${dim(pad('Long (>60m)', 30))} ${dim(String(dur.long))}`);
   }
   console.log();
 }
 
 // ══════════════════════════════════════════════
-// OFFLINE DISPLAY (no API)
+// OFFLINE DISPLAY
 // ══════════════════════════════════════════════
 
 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);
+  displayProfileHeader(result, extra);
+  displaySummary(result, extra);
+  displayArchetype(result);
+  displayDimensions(result);
+  displayCrossPlatform(extra.perToolScores);
+  displayDataNarratives(metrics, new Set());
+  displayProjects(extra.insights);
+  displaySignatures(extra.insights);
+  displayWatchPoints(extra.insights);
+  displayTrajectory(extra.insights);
+  displayAssessment(extra.insights);
+  displayConfidence(extra.insights, extra.sessionStats);
+  displayMethodology();
+  console.log(dim('  Run without --offline for AI-generated narrative insights\n'));
+  displayNextSteps(result);
 }
 
 // ══════════════════════════════════════════════
@@ -548,11 +722,20 @@ export function displayOffline(result, metrics, extra = {}) {
 // ══════════════════════════════════════════════
 
 export function displayFull(result, metrics, prose, extra = {}) {
-  displayScore(result, prose, extra);
+  displayProfileHeader(result, extra);
+  displaySummary(result, extra);
+  displayArchetype(result);
+  displayDimensions(result);
+  displayCrossPlatform(extra.perToolScores);
   displayNarratives(metrics, prose);
-  displayCoaching(result, metrics);
-  displayEasterEggs(result, metrics);
-  displayEnding(result);
+  displayProjects(extra.insights);
+  displaySignatures(extra.insights);
+  displayWatchPoints(extra.insights);
+  displayTrajectory(extra.insights);
+  displayAssessment(extra.insights);
+  displayConfidence(extra.insights, extra.sessionStats);
+  displayMethodology();
+  displayNextSteps(result);
 }
 
 // ── Utility ──