chekk 0.2.1 → 0.2.3

package/bin/chekk.js

@@ -8,7 +8,7 @@ const program = new Command();
 program
   .name('chekk')
   .description('The engineering capability score. See how you prompt.')
-  .version('0.2.1')
+  .version('0.2.3')
   .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')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chekk",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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

@@ -12,7 +12,8 @@ const white = chalk.white;
 
 function tierColor(tier) {
   if (tier === 'LEGENDARY') return gold;
-  if (tier === 'RARE') return purple;
+  if (tier === 'ULTRA RARE') return purple;
+  if (tier === 'RARE') return cyan;
   if (tier === 'UNCOMMON') return blue;
   return dim;
 }
@@ -41,6 +42,28 @@ function pad(str, len) {
   return str + ' '.repeat(Math.max(0, len - visible.length));
 }
 
+function snippet(prompt, maxLen = 70) {
+  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';
+  }
+  return clean;
+}
+
+function displaySnippet(prompt, maxLen = 70) {
+  const s = snippet(prompt, maxLen);
+  if (!s) return;
+  console.log(`  ${dim('\u201C')}${dim.italic(s)}${dim('\u201D')}`);
+}
+
+function pickExample(examples, type) {
+  if (!examples || !examples.length) return null;
+  const match = examples.find(e => e.type === type);
+  return match ? match.prompt : null;
+}
+
 // ── Box drawing ──
 
 function box(lines, width = 43) {
@@ -67,7 +90,7 @@ export function displayHeader() {
   console.log();
   const lines = [
     '',
-    `   ${bold.white('chekk')}${dim(' v0.2.1')}`,
+    `   ${bold.white('chekk')}${dim(' v0.2.3')}`,
     `   ${dim('the engineering capability score')}`,
     '',
   ];
@@ -130,7 +153,7 @@ export async function displayProgressBar(durationMs = 2000) {
 // ══════════════════════════════════════════════
 
 export function displayScore(result, prose) {
-  const { overall, scores, archetype, tier } = result;
+  const { overall, scores, archetype, tier, tierBadge, tierPercentile } = result;
   const tc = tierColor(tier);
   const sc = scoreColor(overall);
 
@@ -140,7 +163,9 @@ export function displayScore(result, prose) {
   console.log(dim('  YOUR CHEKK SCORE'));
   console.log();
   console.log(`                    ${sc.bold(String(overall))}`);
-  console.log(`               ${tc('\u2500\u2500 ' + tier + ' \u2500\u2500')}`);
+  const badgeStr = tierBadge ? ` ${tierBadge}` : '';
+  const pctStr = tierPercentile ? `  ${dim(tierPercentile)}` : '';
+  console.log(`               ${tc('\u2500\u2500 ' + tier + ' \u2500\u2500')}${badgeStr}${pctStr}`);
   console.log();
   console.log(`  ${dim('Archetype:')} ${bold.white(archetype.name)}`);
 
@@ -193,8 +218,10 @@ export function displayNarratives(metrics, prose) {
       }
       console.log();
     }
+    // Show prompt evidence after AI prose
+    displayPromptEvidence(metrics);
   } else {
-    // Fallback: data-driven bullet points
+    // Fallback: data-driven bullet points with inline snippets
     displayDataNarratives(metrics);
   }
 }
@@ -204,6 +231,20 @@ function displayDataNarratives(metrics) {
   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 || [];
+
+  // Track shown snippets to avoid duplicates
+  const shownSnippets = new Set();
+  function showUniqueSnippet(prompt) {
+    if (!prompt) return;
+    const s = snippet(prompt, 70);
+    if (shownSnippets.has(s)) return;
+    shownSnippets.add(s);
+    displaySnippet(prompt);
+  }
 
   // Thinking
   console.log(`  ${bold('\uD83E\uDDE0 THINKING')}`);
@@ -211,6 +252,7 @@ function displayDataNarratives(metrics) {
   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'));
   console.log();
 
   // Debugging
@@ -219,6 +261,7 @@ function displayDataNarratives(metrics) {
   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();
 
   // AI Leverage
@@ -227,6 +270,7 @@ function displayDataNarratives(metrics) {
   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'));
   console.log();
 
   // Workflow
@@ -234,6 +278,51 @@ function displayDataNarratives(metrics) {
   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'));
+  console.log();
+}
+
+// ── Prompt evidence block (shown after AI prose) ──
+
+function displayPromptEvidence(metrics) {
+  const allExamples = [
+    ...(metrics.decomposition.examples || []),
+    ...(metrics.debugCycles.examples || []),
+    ...(metrics.aiLeverage.examples || []),
+    ...(metrics.sessionStructure.examples || []),
+  ];
+
+  if (allExamples.length === 0) return;
+
+  // Pick up to 3 best examples to show as evidence, deduplicated
+  const candidates = [];
+  const arch = pickExample(metrics.aiLeverage.examples, 'architectural');
+  const decomp = pickExample(metrics.decomposition.examples, 'decomposition');
+  const debug = pickExample(metrics.debugCycles.examples, 'specific_report');
+  const ctx = pickExample(metrics.sessionStructure.examples, 'context_setting');
+
+  if (arch) candidates.push({ label: 'Architecture', prompt: arch });
+  if (decomp) candidates.push({ label: 'Thinking', prompt: decomp });
+  if (debug) candidates.push({ label: 'Debugging', prompt: debug });
+  if (ctx) candidates.push({ label: 'Context', prompt: ctx });
+
+  // Deduplicate by snippet text
+  const picks = [];
+  const seen = new Set();
+  for (const c of candidates) {
+    const s = snippet(c.prompt, 65);
+    if (!seen.has(s)) {
+      seen.add(s);
+      picks.push(c);
+    }
+  }
+
+  if (picks.length === 0) return;
+
+  console.log(dim('  YOUR PROMPTS\n'));
+  for (const pick of picks.slice(0, 3)) {
+    console.log(`  ${dim(pick.label + ':')} ${dim('\u201C')}${dim.italic(snippet(pick.prompt, 65))}${dim('\u201D')}`);
+  }
   console.log();
 }
 
@@ -272,7 +361,7 @@ export function displayEasterEggs(result, metrics) {
 // ══════════════════════════════════════════════
 
 export function displayEnding(result) {
-  const { overall, archetype, tier } = result;
+  const { overall, archetype, tier, tierBadge } = result;
   const tc = tierColor(tier);
 
   console.log(doubleRule());
@@ -282,7 +371,8 @@ export function displayEnding(result) {
   console.log();
 
   // Copy-paste share line
-  const shareLine = `${overall} \u2014 ${tier} \u2014 ${archetype.name}`;
+  const badge = tierBadge ? ` ${tierBadge}` : '';
+  const shareLine = `${overall} \u2014 ${tier}${badge} \u2014 ${archetype.name}`;
   console.log(`  ${dim('"')}${tc(shareLine)}${dim('"')}`);
   console.log(`  ${dim('\u2191 Copy this to share')}`);
   console.log();
@@ -362,8 +452,7 @@ export function displayOffline(result, metrics) {
   displayScore(result, null);
   displayDataNarratives(metrics);
   displayEasterEggs(result, metrics);
-  console.log(dim('  Run without --offline for personalized AI-generated insights'));
-  console.log(dim('  Run with --verbose for full per-project and metric breakdown\n'));
+  console.log(dim('  Run without --offline for personalized AI-generated insights\n'));
   displayEnding(result);
 }
 
@@ -375,7 +464,6 @@ export function displayFull(result, metrics, prose) {
   displayScore(result, prose);
   displayNarratives(metrics, prose);
   displayEasterEggs(result, metrics);
-  console.log(dim('  Run with --verbose for full per-project and metric breakdown\n'));
   displayEnding(result);
 }
 

package/src/index.js

@@ -15,7 +15,7 @@ import {
   displayOffline,
   displayVerbose,
 } from './display.js';
-import { generateProse, askClaim, uploadAndClaim } from './upload.js';
+import { generateProse, askVerbose, askClaim, uploadAndClaim } from './upload.js';
 
 export async function run(options = {}) {
   // ── Header ──
@@ -93,35 +93,52 @@ export async function run(options = {}) {
     tools: supported.map(t => t.tool),
   };
 
-  // Progress bar animation
-  await displayProgressBar(1500);
-
   // ── JSON output ──
   if (options.json) {
     console.log(JSON.stringify({ metrics, result, sessionStats }, null, 2));
     return;
   }
 
-  // ── Step 4: Display results ──
+  // ── 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([
+      displayProgressBar(1500),
+      generateProse(metrics, result, sessionStats).catch(() => null),
+    ]);
+    prose = proseResult;
+  } else {
+    await displayProgressBar(1500);
+  }
+
+  // ── Step 5: Display results ──
   if (options.offline) {
     displayOffline(result, metrics);
   } else {
-    // Generate prose from API
-    let prose = null;
-    try {
-      prose = await generateProse(metrics, result, sessionStats);
-    } catch {
-      // Silently fall back to data-driven display
-    }
     displayFull(result, metrics, prose);
   }
 
-  // ── Verbose breakdown ──
+  // ── Step 6: Verbose prompt (interactive) ──
+  // If --verbose flag was passed, show immediately. Otherwise prompt.
   if (options.verbose) {
     displayVerbose(metrics, allSessions);
+  } else {
+    try {
+      const wantsVerbose = await askVerbose();
+      if (wantsVerbose) {
+        console.log();
+        displayVerbose(metrics, allSessions);
+      } else {
+        console.log();
+      }
+    } catch {
+      console.log();
+    }
   }
 
-  // ── Step 5: Claim prompt ──
+  // ── Step 7: Claim prompt ──
   if (options.upload !== false) {
     try {
       const wantsClaim = await askClaim();

package/src/metrics/ai-leverage.js

@@ -37,15 +37,32 @@ export function computeAILeverage(sessions) {
   let complexPrompts = 0; // > 200 chars with multiple sentences
   let trivialPrompts = 0; // < 50 chars, simple commands
 
+  // Capture representative examples
+  let bestArchPrompt = null; // best architectural prompt
+  let bestPlanPrompt = null; // best planning prompt
+  let bestExplorePrompt = null; // best exploratory prompt
+  let bestArchLen = 0;
+  let bestPlanLen = 0;
+  let bestExploreLen = 0;
+
   for (const session of sessions) {
     for (const exchange of session.exchanges) {
       const prompt = exchange.userPrompt || '';
       totalPrompts++;
 
       // Categorize prompt type
-      if (architecturalPatterns.test(prompt)) architecturalPrompts++;
-      if (planningPatterns.test(prompt)) planningPrompts++;
-      if (exploratoryPatterns.test(prompt)) exploratoryPrompts++;
+      if (architecturalPatterns.test(prompt)) {
+        architecturalPrompts++;
+        if (prompt.length > bestArchLen) { bestArchLen = prompt.length; bestArchPrompt = prompt; }
+      }
+      if (planningPatterns.test(prompt)) {
+        planningPrompts++;
+        if (prompt.length > bestPlanLen) { bestPlanLen = prompt.length; bestPlanPrompt = prompt; }
+      }
+      if (exploratoryPatterns.test(prompt)) {
+        exploratoryPrompts++;
+        if (prompt.length > bestExploreLen) { bestExploreLen = prompt.length; bestExplorePrompt = prompt; }
+      }
       if (boilerplatePatterns.test(prompt)) boilerplatePrompts++;
       if (testingPatterns.test(prompt)) testingPrompts++;
 
@@ -103,6 +120,12 @@ export function computeAILeverage(sessions) {
     50 * 0  // baseline filler
   );
 
+  // Build examples — pick the best one available
+  const examples = [];
+  if (bestArchPrompt) examples.push({ type: 'architectural', prompt: bestArchPrompt });
+  if (bestPlanPrompt) examples.push({ type: 'planning', prompt: bestPlanPrompt });
+  if (bestExplorePrompt) examples.push({ type: 'exploratory', prompt: bestExplorePrompt });
+
   return {
     score: Math.max(0, Math.min(100, score)),
     details: {
@@ -120,5 +143,6 @@ export function computeAILeverage(sessions) {
         coding: codingToolUses,
       },
     },
+    examples,
   };
 }

package/src/metrics/debug-cycles.js

@@ -26,10 +26,16 @@ export function computeDebugCycles(sessions) {
   let quickFixes = 0; // resolved in 1-2 turns
   let longLoops = 0; // > 5 turns to resolve
 
+  // Capture representative examples
+  let bestSpecificReport = null; // best specific error report
+  let bestQuickFix = null; // prompt that led to quick resolution
+  let bestSpecificLen = 0;
+
   for (const session of sessions) {
     const { exchanges } = session;
     let inDebugMode = false;
     let debugTurnCount = 0;
+    let debugStartPrompt = null;
 
     for (let i = 0; i < exchanges.length; i++) {
       const prompt = exchanges[i].userPrompt || '';
@@ -39,6 +45,7 @@ export function computeDebugCycles(sessions) {
           // Starting a new debug sequence
           inDebugMode = true;
           debugTurnCount = 1;
+          debugStartPrompt = prompt;
           totalDebugSequences++;
         } else {
           debugTurnCount++;
@@ -50,21 +57,31 @@ export function computeDebugCycles(sessions) {
         }
         if (specificDebugPatterns.test(prompt) || prompt.length > 200) {
           specificReports++;
+          // Track best specific report
+          if (prompt.length > bestSpecificLen) {
+            bestSpecificLen = prompt.length;
+            bestSpecificReport = prompt;
+          }
         }
       } else if (inDebugMode) {
         // Check if this exchange resolves the debug
         if (resolutionPatterns.test(prompt)) {
           totalTurnsToResolve += debugTurnCount;
-          if (debugTurnCount <= 2) quickFixes++;
+          if (debugTurnCount <= 2) {
+            quickFixes++;
+            if (!bestQuickFix) bestQuickFix = debugStartPrompt;
+          }
           if (debugTurnCount > 5) longLoops++;
           inDebugMode = false;
           debugTurnCount = 0;
+          debugStartPrompt = null;
         } else {
           // Moved on without explicit resolution
           totalTurnsToResolve += debugTurnCount;
           unresolvedSequences++;
           inDebugMode = false;
           debugTurnCount = 0;
+          debugStartPrompt = null;
         }
       }
     }
@@ -109,6 +126,11 @@ export function computeDebugCycles(sessions) {
     (100 - longLoopPenalty) * 0.15
   );
 
+  // Build examples array
+  const examples = [];
+  if (bestSpecificReport) examples.push({ type: 'specific_report', prompt: bestSpecificReport });
+  if (bestQuickFix) examples.push({ type: 'quick_fix', prompt: bestQuickFix });
+
   return {
     score: Math.max(0, Math.min(100, score)),
     details: {
@@ -120,5 +142,6 @@ export function computeDebugCycles(sessions) {
       vagueReports,
       specificReports,
     },
+    examples,
   };
 }

package/src/metrics/decomposition.js

@@ -26,6 +26,11 @@ export function computeDecomposition(sessions) {
   const followupPatterns = /^(now |next |then |also |and |ok |okay |great |good |perfect |after that|building on|following up|continuing)/i;
   const refinementPatterns = /^(actually |wait |hmm |instead |change |modify |update |tweak |adjust |fix |but )/i;
 
+  // Capture representative prompt examples
+  // Keep top 3 candidates and pick the 2nd-longest to avoid overlap with other metrics
+  const decompCandidates = [];
+  let bestFollowupPrompt = null;
+
   for (const session of sessions) {
     const { exchanges } = session;
     totalExchanges += exchanges.length;
@@ -45,10 +50,19 @@ export function computeDecomposition(sessions) {
       if (len > 500) longPromptCount++;
       if (len < 100) shortPromptCount++;
 
+      // Track decomposition examples (multi-sentence prompts showing task breakdown)
+      if (len > 150 && len < 2000) {
+        decompCandidates.push(prompt);
+      }
+
       // Check for contextual followups (not the first prompt in a session)
       if (i > 0) {
         if (followupPatterns.test(prompt) || refinementPatterns.test(prompt)) {
           contextualFollowups++;
+          // Capture best followup example
+          if (!bestFollowupPrompt || prompt.length > bestFollowupPrompt.length) {
+            bestFollowupPrompt = prompt;
+          }
         }
       }
     }
@@ -83,6 +97,16 @@ export function computeDecomposition(sessions) {
     depthScore * 0.2
   );
 
+  // Build examples array — pick a mid-length prompt to avoid overlap with other metrics
+  const examples = [];
+  if (decompCandidates.length > 0) {
+    decompCandidates.sort((a, b) => b.length - a.length);
+    // Pick ~median length to avoid the longest (which will also match ai-leverage)
+    const pickIdx = Math.min(Math.floor(decompCandidates.length / 3), decompCandidates.length - 1);
+    examples.push({ type: 'decomposition', prompt: decompCandidates[pickIdx] });
+  }
+  if (bestFollowupPrompt) examples.push({ type: 'followup', prompt: bestFollowupPrompt });
+
   return {
     score: Math.max(0, Math.min(100, score)),
     details: {
@@ -94,5 +118,6 @@ export function computeDecomposition(sessions) {
       longPromptRatio: promptCount > 0 ? Math.round(longPromptCount / promptCount * 100) : 0,
       contextualFollowupRatio: promptCount > 0 ? Math.round(followupRatio * 100) : 0,
     },
+    examples,
   };
 }

package/src/metrics/session-structure.js

@@ -34,6 +34,11 @@ export function computeSessionStructure(sessions) {
   // First prompt length distribution (longer first prompts = more context setting)
   let firstPromptTotalLength = 0;
 
+  // Capture representative examples
+  let bestContextPrompt = null; // best context-setting opener
+  let bestRefinementPrompt = null; // best refinement/critical feedback
+  let bestContextLen = 0;
+
   for (const session of sessions) {
     const { exchanges, durationMinutes } = session;
     if (exchanges.length === 0) continue;
@@ -46,6 +51,11 @@ export function computeSessionStructure(sessions) {
 
     if (contextSettingPatterns.test(firstPrompt) || firstPrompt.length > 200) {
       contextSetSessions++;
+      // Track best context-setting prompt
+      if (firstPrompt.length > bestContextLen) {
+        bestContextLen = firstPrompt.length;
+        bestContextPrompt = firstPrompt;
+      }
     }
 
     if (planningStartPatterns.test(firstPrompt)) {
@@ -66,6 +76,10 @@ export function computeSessionStructure(sessions) {
       const prompt = exchanges[i].userPrompt || '';
       if (refinementPatterns.test(prompt)) {
         refinementCount++;
+        // Track best refinement example
+        if (!bestRefinementPrompt || prompt.length > bestRefinementPrompt.length) {
+          bestRefinementPrompt = prompt;
+        }
       }
     }
 
@@ -115,6 +129,11 @@ export function computeSessionStructure(sessions) {
     firstPromptScore * 0.15
   );
 
+  // Build examples array
+  const examples = [];
+  if (bestContextPrompt) examples.push({ type: 'context_setting', prompt: bestContextPrompt });
+  if (bestRefinementPrompt) examples.push({ type: 'refinement', prompt: bestRefinementPrompt });
+
   return {
     score: Math.max(0, Math.min(100, score)),
     details: {
@@ -130,5 +149,6 @@ export function computeSessionStructure(sessions) {
         focused: focusedSessions,
       },
     },
+    examples,
   };
 }

package/src/scorer.js

@@ -1,79 +1,162 @@
 /**
  * Combine individual metric scores into composite scores and assign archetype.
+ *
+ * Archetypes and tiers are consistent with the GitHub analysis system.
+ * 15 archetypes across 5 tiers, mapped from repo-based signals to
+ * prompt-behavior signals measured by the CLI.
  */
 
+// ── Tier thresholds (match GitHub analysis) ──
+
+const TIERS = [
+  { name: 'LEGENDARY',  min: 85, badge: '🌟🌟🌟', percentile: 'Top 1%' },
+  { name: 'ULTRA RARE', min: 73, badge: '🌟🌟',   percentile: 'Top 5%' },
+  { name: 'RARE',       min: 60, badge: '⭐',      percentile: 'Top 15%' },
+  { name: 'UNCOMMON',   min: 47, badge: '◆',       percentile: 'Top 30%' },
+  { name: 'COMMON',     min: 0,  badge: '●',       percentile: 'Top 50%' },
+];
+
+// ── Archetype definitions ──
+// Each archetype has a match function based on the 4 CLI dimension scores:
+//   decomposition (thinking), debugCycles (debugging),
+//   aiLeverage (AI leverage), sessionStructure (workflow)
+//
+// Tier-restricted: archetypes only match within their allowed tier range.
+
 const ARCHETYPES = [
+  // ── LEGENDARY (85+) ──
   {
-    id: 'THE_ARCHITECT',
-    name: 'THE ARCHITECT',
-    // High decomposition + high planning + high leverage
-    match: (s) => s.decomposition >= 70 && s.sessionStructure >= 65 && s.aiLeverage >= 65,
+    id: 'THE_10X_ENGINEER',
+    name: 'THE 10X ENGINEER',
+    tierRange: ['LEGENDARY'],
+    match: (s) => true, // If you hit LEGENDARY, you're a 10x
     priority: 1,
   },
+
+  // ── ULTRA RARE (73-84) ──
   {
-    id: 'THE_SURGEON',
-    name: 'THE SURGEON',
-    // High debug efficiency + high leverage + good structure
-    match: (s) => s.debugCycles >= 75 && s.aiLeverage >= 60,
+    id: 'THE_ARCHITECT',
+    name: 'THE ARCHITECT',
+    tierRange: ['ULTRA RARE'],
+    // High decomposition + structured workflow + strong leverage
+    match: (s) => s.decomposition >= 70 && s.sessionStructure >= 65,
     priority: 2,
   },
+  {
+    id: 'THE_PROFESSOR',
+    name: 'THE PROFESSOR',
+    tierRange: ['ULTRA RARE'],
+    // Exceptional at explaining: high decomposition, detailed prompts, strong context-setting
+    match: (s) => s.decomposition >= 65 && s.sessionStructure >= 70,
+    priority: 3,
+  },
+
+  // ── RARE (60-72) ──
+  {
+    id: 'THE_SPECIALIST',
+    name: 'THE SPECIALIST',
+    tierRange: ['RARE'],
+    // Deep focused work: high debug efficiency + high leverage in specific domain
+    match: (s) => s.debugCycles >= 70 && s.aiLeverage >= 65,
+    priority: 4,
+  },
+  {
+    id: 'THE_SYSTEMS_THINKER',
+    name: 'THE SYSTEMS THINKER',
+    tierRange: ['RARE'],
+    // Strong decomposition + structured approach to complex problems
+    match: (s) => s.decomposition >= 65 && s.sessionStructure >= 60,
+    priority: 5,
+  },
+  {
+    id: 'THE_MAINTAINER',
+    name: 'THE MAINTAINER',
+    tierRange: ['RARE'],
+    // Reliable workflow + solid debugging: keeps things running
+    match: (s) => s.sessionStructure >= 60 && s.debugCycles >= 60,
+    priority: 6,
+  },
+
+  // ── UNCOMMON (47-59) ──
+  {
+    id: 'THE_CRAFTSPERSON',
+    name: 'THE CRAFTSPERSON',
+    tierRange: ['UNCOMMON'],
+    // Quality obsession: high debug precision + structured sessions
+    match: (s) => s.debugCycles >= 60 && s.sessionStructure >= 55,
+    priority: 7,
+  },
   {
     id: 'THE_BUILDER',
     name: 'THE BUILDER',
-    // High overall scores, well-rounded
+    tierRange: ['UNCOMMON'],
+    // Well-rounded: decent across all dimensions
     match: (s) => {
-      const avg = (s.decomposition + s.debugCycles + s.aiLeverage + s.sessionStructure) / 4;
-      return avg >= 65 && Math.min(s.decomposition, s.debugCycles, s.aiLeverage, s.sessionStructure) >= 55;
+      const min = Math.min(s.decomposition, s.debugCycles, s.aiLeverage, s.sessionStructure);
+      return min >= 45;
     },
-    priority: 3,
+    priority: 8,
+  },
+  {
+    id: 'THE_CONTRIBUTOR',
+    name: 'THE CONTRIBUTOR',
+    tierRange: ['UNCOMMON'],
+    // Strong AI leverage + decent decomposition: collaborates well with AI
+    match: (s) => s.aiLeverage >= 55 && s.decomposition >= 50,
+    priority: 9,
+  },
+  {
+    id: 'THE_HIDDEN_GEM',
+    name: 'THE HIDDEN GEM',
+    tierRange: ['UNCOMMON'],
+    // Strong skills but unstructured: high debug or leverage but low structure
+    match: (s) => (s.debugCycles >= 55 || s.aiLeverage >= 55) && s.sessionStructure < 50,
+    priority: 10,
   },
   {
     id: 'THE_EXPLORER',
     name: 'THE EXPLORER',
-    // High leverage + high decomposition, loves research
-    match: (s) => s.aiLeverage >= 70 && s.decomposition >= 60,
-    priority: 4,
+    tierRange: ['UNCOMMON'],
+    // High leverage + curiosity-driven: research-heavy prompting
+    match: (s) => s.aiLeverage >= 50,
+    priority: 11,
   },
+
+  // ── COMMON (0-46) ──
   {
-    id: 'THE_SPEEDRUNNER',
-    name: 'THE SPEEDRUNNER',
-    // Quick debug cycles, less structured but efficient
-    match: (s) => s.debugCycles >= 70 && s.sessionStructure < 60,
-    priority: 5,
+    id: 'THE_TINKERER',
+    name: 'THE TINKERER',
+    tierRange: ['COMMON'],
+    // Practical problem-solving: decent debug + some leverage
+    match: (s) => s.debugCycles >= 40 && s.aiLeverage >= 35,
+    priority: 12,
   },
   {
-    id: 'THE_APPRENTICE',
-    name: 'THE APPRENTICE',
-    // Learning patterns - lower scores but shows growth potential
-    match: (s) => {
-      const avg = (s.decomposition + s.debugCycles + s.aiLeverage + s.sessionStructure) / 4;
-      return avg >= 40 && avg < 65;
-    },
-    priority: 6,
+    id: 'THE_GRINDER',
+    name: 'THE GRINDER',
+    tierRange: ['COMMON'],
+    // High volume, iterative: lots of exchanges, keeps going
+    match: (s) => s.decomposition >= 35,
+    priority: 13,
   },
   {
-    id: 'THE_MAVERICK',
-    name: 'THE MAVERICK',
-    // Unstructured but somehow gets things done - low structure, decent other scores
-    match: (s) => s.sessionStructure < 50 && (s.decomposition >= 55 || s.aiLeverage >= 55),
-    priority: 7,
+    id: 'THE_HOBBYIST',
+    name: 'THE HOBBYIST',
+    tierRange: ['COMMON'],
+    // Active but early: some leverage or debugging skill
+    match: (s) => s.aiLeverage >= 30 || s.debugCycles >= 30,
+    priority: 14,
   },
   {
-    id: 'THE_NEWCOMER',
-    name: 'THE NEWCOMER',
-    // Default fallback
+    id: 'THE_APPRENTICE',
+    name: 'THE APPRENTICE',
+    tierRange: ['COMMON'],
+    // Default fallback for COMMON tier
     match: () => true,
     priority: 99,
   },
 ];
 
-const TIERS = [
-  { name: 'LEGENDARY', min: 90 },
-  { name: 'RARE', min: 75 },
-  { name: 'UNCOMMON', min: 55 },
-  { name: 'COMMON', min: 0 },
-];
-
 export function computeOverallScore(metrics) {
   const scores = {
     decomposition: metrics.decomposition.score,
@@ -90,13 +173,18 @@ export function computeOverallScore(metrics) {
     scores.sessionStructure * 0.2
   );
 
-  // Assign archetype
-  const sortedArchetypes = [...ARCHETYPES].sort((a, b) => a.priority - b.priority);
-  const archetype = sortedArchetypes.find(a => a.match(scores)) || ARCHETYPES[ARCHETYPES.length - 1];
-
-  // Assign tier
+  // Assign tier first
   const tier = TIERS.find(t => overall >= t.min) || TIERS[TIERS.length - 1];
 
+  // Assign archetype within tier
+  const tierArchetypes = ARCHETYPES
+    .filter(a => a.tierRange.includes(tier.name))
+    .sort((a, b) => a.priority - b.priority);
+
+  const archetype = tierArchetypes.find(a => a.match(scores))
+    || tierArchetypes[tierArchetypes.length - 1]
+    || { id: 'THE_APPRENTICE', name: 'THE APPRENTICE' };
+
   return {
     overall,
     scores,
@@ -105,5 +193,7 @@ export function computeOverallScore(metrics) {
       name: archetype.name,
     },
     tier: tier.name,
+    tierBadge: tier.badge,
+    tierPercentile: tier.percentile,
   };
 }

package/src/upload.js

@@ -5,24 +5,38 @@ const API_BASE = 'https://chekk-production.up.railway.app/api/v1';
 /**
  * Call the Chekk API to generate personalized prose from metrics.
  */
+function truncateExamples(examples, maxLen = 120) {
+  if (!examples || !examples.length) return [];
+  return examples.map(e => ({
+    type: e.type,
+    prompt: e.prompt && e.prompt.length > maxLen
+      ? e.prompt.replace(/\s+/g, ' ').trim().slice(0, maxLen) + '...'
+      : (e.prompt || '').replace(/\s+/g, ' ').trim(),
+  }));
+}
+
 export async function generateProse(metrics, result, sessionStats) {
   const payload = {
     metrics: {
       decomposition: {
         score: metrics.decomposition.score,
         details: metrics.decomposition.details,
+        examples: truncateExamples(metrics.decomposition.examples),
       },
       debugCycles: {
         score: metrics.debugCycles.score,
         details: metrics.debugCycles.details,
+        examples: truncateExamples(metrics.debugCycles.examples),
       },
       aiLeverage: {
         score: metrics.aiLeverage.score,
         details: metrics.aiLeverage.details,
+        examples: truncateExamples(metrics.aiLeverage.examples),
       },
       sessionStructure: {
         score: metrics.sessionStructure.score,
         details: metrics.sessionStructure.details,
+        examples: truncateExamples(metrics.sessionStructure.examples),
       },
     },
     result: {
@@ -47,6 +61,23 @@ export async function generateProse(metrics, result, sessionStats) {
   return response.json();
 }
 
+/**
+ * Ask user if they want to see detailed breakdown.
+ */
+export function askVerbose() {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question('   See detailed breakdown? (y/n) ', (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+}
+
 /**
  * Ask user if they want to claim their profile.
  */