chekk 0.2.2 → 0.2.4

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.2')
+  .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')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chekk",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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/detect.js

@@ -9,7 +9,7 @@ export function detectTools() {
   const home = homedir();
   const results = [];
 
-  // Claude Code: ~/.claude/projects/
+  // ── Claude Code: ~/.claude/projects/ ──
   const claudeProjectsDir = join(home, '.claude', 'projects');
   if (existsSync(claudeProjectsDir)) {
     const projects = readdirSync(claudeProjectsDir).filter(f => {
@@ -29,11 +29,10 @@ export function detectTools() {
 
       if (jsonlFiles.length > 0) {
         totalSessions += jsonlFiles.length;
-        // Rough line count for display
         for (const file of jsonlFiles) {
           try {
             const stat = statSync(join(projectDir, file));
-            totalLines += Math.floor(stat.size / 500); // rough estimate
+            totalLines += Math.floor(stat.size / 500);
           } catch {}
         }
         projectDetails.push({
@@ -55,39 +54,92 @@ export function detectTools() {
     }
   }
 
-  // Cursor: ~/Library/Application Support/Cursor/User/workspaceStorage/
+  // ── Cursor: workspaceStorage with state.vscdb files ──
   const cursorPaths = [
     join(home, 'Library', 'Application Support', 'Cursor', 'User', 'workspaceStorage'),  // macOS
     join(home, '.config', 'Cursor', 'User', 'workspaceStorage'),  // Linux
     join(home, 'AppData', 'Roaming', 'Cursor', 'User', 'workspaceStorage'),  // Windows
   ];
+
   for (const cursorPath of cursorPaths) {
     if (existsSync(cursorPath)) {
-      results.push({
-        tool: 'Cursor',
-        sessions: 0,
-        projects: [],
-        estimatedPrompts: 0,
-        basePath: cursorPath,
-        status: 'detected_not_supported',
-        message: 'Cursor support coming in V2',
-      });
+      // Count workspaces that have state.vscdb
+      let workspaceCount = 0;
+      const projectDetails = [];
+
+      try {
+        const dirs = readdirSync(cursorPath).filter(f => {
+          try { return statSync(join(cursorPath, f)).isDirectory(); } catch { return false; }
+        });
+
+        for (const dir of dirs) {
+          const dbPath = join(cursorPath, dir, 'state.vscdb');
+          if (existsSync(dbPath)) {
+            workspaceCount++;
+            projectDetails.push({
+              name: dir.slice(0, 8),
+              sessions: 1,
+              path: join(cursorPath, dir),
+            });
+          }
+        }
+      } catch {}
+
+      if (workspaceCount > 0) {
+        results.push({
+          tool: 'Cursor',
+          sessions: workspaceCount,
+          projects: projectDetails,
+          estimatedPrompts: 0,
+          basePath: cursorPath,
+        });
+      }
       break;
     }
   }
 
-  // Codex: ~/.codex/
+  // ── Codex: ~/.codex/sessions/ ──
   const codexPath = join(home, '.codex');
-  if (existsSync(codexPath)) {
-    results.push({
-      tool: 'Codex',
-      sessions: 0,
-      projects: [],
-      estimatedPrompts: 0,
-      basePath: codexPath,
-      status: 'detected_not_supported',
-      message: 'Codex support coming in V2',
-    });
+  const codexSessionsPath = join(codexPath, 'sessions');
+  if (existsSync(codexSessionsPath)) {
+    // Count JSONL session files recursively
+    let totalSessions = 0;
+    const projectDetails = [];
+
+    function countFiles(dir) {
+      try {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+          const full = join(dir, entry);
+          try {
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+              countFiles(full);
+            } else if (entry.endsWith('.jsonl')) {
+              totalSessions++;
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+
+    countFiles(codexSessionsPath);
+
+    if (totalSessions > 0) {
+      projectDetails.push({
+        name: 'codex',
+        sessions: totalSessions,
+        path: codexSessionsPath,
+      });
+
+      results.push({
+        tool: 'Codex',
+        sessions: totalSessions,
+        projects: projectDetails,
+        estimatedPrompts: 0,
+        basePath: codexPath,
+      });
+    }
   }
 
   return results;

package/src/display.js

@@ -42,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) {
@@ -68,7 +90,7 @@ export function displayHeader() {
   console.log();
   const lines = [
     '',
-    `   ${bold.white('chekk')}${dim(' v0.2.2')}`,
+    `   ${bold.white('chekk')}${dim(' v0.2.4')}`,
     `   ${dim('the engineering capability score')}`,
     '',
   ];
@@ -84,17 +106,12 @@ export function displayScan(tools) {
   console.log(dim('  Scanning local AI tools...\n'));
 
   for (const tool of tools) {
-    if (tool.status === 'detected_not_supported') {
-      console.log(`  ${dim('\u25CB')} ${dim(tool.tool)}${dim('         detected \u2014 V2')}`);
-    } else {
-      const sessions = numberFormat(tool.sessions);
-      const projects = tool.projects.length;
-      const exchanges = numberFormat(tool.estimatedPrompts);
-      console.log(
-        `  ${cyan('\u2726')} ${bold.white(tool.tool)}    ` +
-        dim(`${sessions} sessions  \u00B7  ${projects} projects`)
-      );
-    }
+    const sessions = numberFormat(tool.sessions);
+    const projects = tool.projects.length;
+    console.log(
+      `  ${cyan('\u2726')} ${bold.white(tool.tool)}    ` +
+      dim(`${sessions} sessions  \u00B7  ${projects} projects`)
+    );
   }
   console.log();
 }
@@ -186,27 +203,60 @@ 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) {
+    if (!prompt) return;
+    const s = snippet(prompt, 70);
+    if (shownSnippets.has(s)) return;
+    shownSnippets.add(s);
+    displaySnippet(prompt);
+  }
+
   if (prose && prose.sections) {
-    // Use DeepSeek-generated prose
+    // 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'),
+    };
+
     for (const section of prose.sections) {
       console.log(`  ${section.emoji} ${bold(section.title.toUpperCase())}`);
       const lines = section.description.split('\n').filter(l => l.trim());
       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);
       console.log();
     }
   } else {
-    // Fallback: data-driven bullet points
-    displayDataNarratives(metrics);
+    // Fallback: data-driven bullet points with inline snippets
+    displayDataNarrativesWithTracker(metrics, shownSnippets);
   }
 }
 
-function displayDataNarratives(metrics) {
+function displayDataNarrativesWithTracker(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 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')}`);
@@ -214,6 +264,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
@@ -222,6 +273,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
@@ -230,6 +282,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
@@ -237,9 +290,11 @@ 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();
 }
 
+
 // ══════════════════════════════════════════════
 // EASTER EGGS
 // ══════════════════════════════════════════════
@@ -364,7 +419,7 @@ export function displayVerbose(metrics, sessions) {
 
 export function displayOffline(result, metrics) {
   displayScore(result, null);
-  displayDataNarratives(metrics);
+  displayDataNarrativesWithTracker(metrics, new Set());
   displayEasterEggs(result, metrics);
   console.log(dim('  Run without --offline for personalized AI-generated insights\n'));
   displayEnding(result);

package/src/index.js

@@ -1,6 +1,8 @@
 import chalk from 'chalk';
 import { detectTools } from './detect.js';
 import { parseAllProjects } from './parsers/claude-code.js';
+import { parseAllWorkspaces } from './parsers/cursor.js';
+import { parseAllSessions as parseCodexSessions } from './parsers/codex.js';
 import { computeDecomposition } from './metrics/decomposition.js';
 import { computeDebugCycles } from './metrics/debug-cycles.js';
 import { computeAILeverage } from './metrics/ai-leverage.js';
@@ -26,18 +28,7 @@ export async function run(options = {}) {
 
   if (tools.length === 0) {
     console.log(chalk.dim('  No AI coding tools detected.'));
-    console.log(chalk.dim('  Chekk currently supports Claude Code.'));
-    console.log(chalk.dim('  Cursor and Codex coming in V2.\n'));
-    process.exit(1);
-  }
-
-  const supported = tools.filter(t => t.status !== 'detected_not_supported');
-  if (supported.length === 0) {
-    console.log(chalk.dim('  No supported tools found.\n'));
-    for (const t of tools) {
-      console.log(chalk.dim(`  ${t.tool} \u2014 ${t.message}`));
-    }
-    console.log();
+    console.log(chalk.dim('  Chekk supports Claude Code, Cursor, and Codex.\n'));
     process.exit(1);
   }
 
@@ -45,9 +36,13 @@ export async function run(options = {}) {
 
   // ── Step 2: Parse sessions ──
   let allSessions = [];
-  for (const tool of supported) {
+  for (const tool of tools) {
     if (tool.tool === 'Claude Code') {
       allSessions.push(...parseAllProjects(tool.basePath));
+    } else if (tool.tool === 'Cursor') {
+      allSessions.push(...parseAllWorkspaces(tool.basePath));
+    } else if (tool.tool === 'Codex') {
+      allSessions.push(...parseCodexSessions(tool.basePath));
     }
   }
 
@@ -90,7 +85,7 @@ export async function run(options = {}) {
     totalExchanges,
     projectCount: projects.length,
     dateRange: dateRangeFull,
-    tools: supported.map(t => t.tool),
+    tools: tools.map(t => t.tool),
   };
 
   // ── JSON output ──

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/parsers/codex.js

@@ -0,0 +1,188 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Parse OpenAI Codex CLI session files into normalized format.
+ *
+ * Codex stores sessions under:
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+ *
+ * Each JSONL line follows the OpenAI message format:
+ *   { "role": "user"|"assistant"|"system", "content": "..." | [...], "timestamp": "..." }
+ *
+ * Tool calls appear as content blocks with type "function_call" or "tool_use".
+ * We normalize into the same session format as Claude Code.
+ */
+
+function parseJsonlLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+function extractText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter(block => block.type === 'text' || block.type === 'output_text')
+    .map(block => block.text || block.content || '')
+    .join('\n');
+}
+
+function extractToolCalls(content) {
+  if (!Array.isArray(content)) return [];
+  return content
+    .filter(block =>
+      block.type === 'function_call' ||
+      block.type === 'tool_use' ||
+      block.type === 'tool_call'
+    )
+    .map(block => ({
+      tool: block.name || block.function?.name || 'unknown',
+      input: block.arguments || block.input || {},
+    }));
+}
+
+/**
+ * Parse a single Codex rollout JSONL file.
+ */
+function parseSessionFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, 'utf-8');
+  } catch {
+    return [];
+  }
+
+  const lines = raw.split('\n').filter(l => l.trim());
+  const exchanges = [];
+  let current = null;
+
+  for (const line of lines) {
+    const entry = parseJsonlLine(line);
+    if (!entry) continue;
+
+    const role = entry.role;
+    if (!role) continue;
+
+    // Skip system messages
+    if (role === 'system') continue;
+
+    // Skip tool result messages
+    if (role === 'tool' || role === 'function') continue;
+
+    const text = extractText(entry.content);
+    const tools = role === 'assistant' ? extractToolCalls(entry.content) : [];
+    const timestamp = entry.timestamp || entry.created_at || null;
+
+    if (role === 'user') {
+      if (!text.trim()) continue;
+      if (current) exchanges.push(current);
+      current = {
+        userPrompt: text,
+        userTimestamp: timestamp,
+        assistantResponses: [],
+        toolCalls: [],
+        thinkingContent: [],
+      };
+    } else if (role === 'assistant' && current) {
+      if (text) current.assistantResponses.push(text);
+      current.toolCalls.push(...tools);
+
+      // Codex may include reasoning/thinking
+      if (entry.reasoning || entry.thinking) {
+        current.thinkingContent.push(entry.reasoning || entry.thinking);
+      }
+    }
+  }
+
+  if (current) exchanges.push(current);
+  return exchanges;
+}
+
+/**
+ * Recursively find all rollout-*.jsonl files under sessions dir.
+ */
+function findSessionFiles(dir) {
+  const files = [];
+  if (!existsSync(dir)) return files;
+
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          files.push(...findSessionFiles(fullPath));
+        } else if (entry.endsWith('.jsonl')) {
+          files.push(fullPath);
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    // Ignore permission errors
+  }
+
+  return files;
+}
+
+/**
+ * Extract project name from session file path or content.
+ * Codex sessions are in ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+ * Try to get the working directory from the session content.
+ */
+function extractProjectName(filePath, exchanges) {
+  // Try to extract from the file path date structure
+  const parts = filePath.split('/');
+  const dateIdx = parts.findIndex(p => p === 'sessions');
+  if (dateIdx >= 0 && parts.length > dateIdx + 3) {
+    return `codex/${parts[dateIdx + 1]}/${parts[dateIdx + 2]}/${parts[dateIdx + 3]}`;
+  }
+  return 'codex';
+}
+
+/**
+ * Parse all Codex sessions from ~/.codex/sessions.
+ */
+export function parseAllSessions(basePath) {
+  const sessionsDir = join(basePath, 'sessions');
+  if (!existsSync(sessionsDir)) return [];
+
+  const sessionFiles = findSessionFiles(sessionsDir);
+  const allSessions = [];
+
+  for (const filePath of sessionFiles) {
+    const exchanges = parseSessionFile(filePath);
+    if (exchanges.length === 0) continue;
+
+    const timestamps = exchanges
+      .map(e => e.userTimestamp)
+      .filter(Boolean)
+      .map(t => typeof t === 'number' ? t * 1000 : new Date(t).getTime())
+      .filter(t => !isNaN(t))
+      .sort();
+
+    const fileName = filePath.split('/').pop();
+
+    allSessions.push({
+      id: fileName.replace('.jsonl', ''),
+      file: fileName,
+      project: extractProjectName(filePath, exchanges),
+      exchanges,
+      turnCount: exchanges.length * 2,
+      exchangeCount: exchanges.length,
+      startTime: timestamps[0] ? new Date(timestamps[0]).toISOString() : null,
+      endTime: timestamps.length > 0 ? new Date(timestamps[timestamps.length - 1]).toISOString() : null,
+      durationMinutes: timestamps.length >= 2
+        ? Math.round((timestamps[timestamps.length - 1] - timestamps[0]) / 60000)
+        : 0,
+    });
+  }
+
+  return allSessions;
+}

package/src/parsers/cursor.js

@@ -0,0 +1,281 @@
+import { existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+/**
+ * Parse Cursor chat history from SQLite state.vscdb files.
+ *
+ * Cursor stores chats in SQLite databases under:
+ *   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/state.vscdb
+ *
+ * Two storage formats exist:
+ *   - Legacy: key = 'workbench.panel.aichat.view.aichat.chatdata' → JSON with tabs/bubbles
+ *   - Current: key like 'composerData:%' in table cursorDiskKV → JSON with conversation data
+ *     Bubble text stored separately under 'bubbleId:<composerId>:<bubbleId>'
+ *
+ * We normalize into the same session format as Claude Code.
+ */
+
+function querySqlite(dbPath, query) {
+  try {
+    const result = execSync(
+      `sqlite3 -json "${dbPath}" "${query.replace(/"/g, '\\"')}"`,
+      { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+    return JSON.parse(result || '[]');
+  } catch {
+    return [];
+  }
+}
+
+function querySqliteRaw(dbPath, query) {
+  try {
+    return execSync(
+      `sqlite3 "${dbPath}" "${query.replace(/"/g, '\\"')}"`,
+      { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Try to detect which table the DB uses (ItemTable vs cursorDiskKV).
+ */
+function detectTable(dbPath) {
+  const tables = querySqliteRaw(dbPath, ".tables");
+  if (tables.includes('cursorDiskKV')) return 'cursorDiskKV';
+  if (tables.includes('ItemTable')) return 'ItemTable';
+  return null;
+}
+
+/**
+ * Parse legacy aichat format (tabs with bubbles inline).
+ */
+function parseLegacyChat(dbPath, table) {
+  const raw = querySqliteRaw(
+    dbPath,
+    `SELECT value FROM ${table} WHERE key = 'workbench.panel.aichat.view.aichat.chatdata';`
+  );
+  if (!raw) return [];
+
+  try {
+    const data = JSON.parse(raw);
+    if (!data.tabs || !Array.isArray(data.tabs)) return [];
+
+    const sessions = [];
+    for (const tab of data.tabs) {
+      if (!tab.bubbles || !Array.isArray(tab.bubbles)) continue;
+
+      const exchanges = [];
+      let current = null;
+
+      for (const bubble of tab.bubbles) {
+        const text = bubble.text || '';
+        if (!text.trim()) continue;
+
+        // type 1 = user, type 2 = assistant
+        if (bubble.type === 1) {
+          if (current) exchanges.push(current);
+          current = {
+            userPrompt: text,
+            userTimestamp: bubble.createdAt || null,
+            assistantResponses: [],
+            toolCalls: [],
+            thinkingContent: [],
+          };
+        } else if (bubble.type === 2 && current) {
+          current.assistantResponses.push(text);
+          // Extract tool info if available
+          if (bubble.toolFormerData && Array.isArray(bubble.toolFormerData)) {
+            for (const tool of bubble.toolFormerData) {
+              current.toolCalls.push({ tool: tool.toolName || 'unknown', input: {} });
+            }
+          }
+        }
+      }
+      if (current) exchanges.push(current);
+      if (exchanges.length === 0) continue;
+
+      const timestamps = exchanges
+        .map(e => e.userTimestamp)
+        .filter(Boolean)
+        .map(t => new Date(t).getTime())
+        .sort();
+
+      sessions.push({
+        id: tab.tabId || `cursor-${sessions.length}`,
+        file: 'state.vscdb',
+        exchanges,
+        turnCount: exchanges.length * 2,
+        exchangeCount: exchanges.length,
+        startTime: timestamps[0] ? new Date(timestamps[0]).toISOString() : null,
+        endTime: timestamps.length > 0 ? new Date(timestamps[timestamps.length - 1]).toISOString() : null,
+        durationMinutes: timestamps.length >= 2
+          ? Math.round((timestamps[timestamps.length - 1] - timestamps[0]) / 60000)
+          : 0,
+      });
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Parse composer format (cursorDiskKV with separate bubble keys).
+ */
+function parseComposerChat(dbPath) {
+  // Get all composer conversation metadata
+  const composerRows = querySqlite(
+    dbPath,
+    `SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%';`
+  );
+
+  if (!composerRows.length) return [];
+
+  const sessions = [];
+
+  for (const row of composerRows) {
+    try {
+      const composerData = JSON.parse(row.value || '{}');
+      const composerId = composerData.composerId || row.key.replace('composerData:', '');
+      const headers = composerData.fullConversationHeadersOnly || [];
+
+      if (headers.length === 0) continue;
+
+      const exchanges = [];
+      let current = null;
+
+      for (const header of headers) {
+        const bubbleKey = `bubbleId:${composerId}:${header.bubbleId}`;
+        const bubbleRaw = querySqliteRaw(
+          dbPath,
+          `SELECT value FROM cursorDiskKV WHERE key = '${bubbleKey}';`
+        );
+
+        if (!bubbleRaw) continue;
+
+        let bubbleData;
+        try {
+          bubbleData = JSON.parse(bubbleRaw);
+        } catch {
+          continue;
+        }
+
+        const text = bubbleData.text || '';
+        if (!text.trim()) continue;
+
+        // type 1 = user, type 2 = assistant
+        if (header.type === 1) {
+          if (current) exchanges.push(current);
+          current = {
+            userPrompt: text,
+            userTimestamp: bubbleData.createdAt || bubbleData.timingInfo?.startedAt || null,
+            assistantResponses: [],
+            toolCalls: [],
+            thinkingContent: [],
+          };
+        } else if (header.type === 2 && current) {
+          current.assistantResponses.push(text);
+          if (bubbleData.toolFormerData && Array.isArray(bubbleData.toolFormerData)) {
+            for (const tool of bubbleData.toolFormerData) {
+              current.toolCalls.push({ tool: tool.toolName || String(tool.tool || 'unknown'), input: {} });
+            }
+          }
+        }
+      }
+      if (current) exchanges.push(current);
+      if (exchanges.length === 0) continue;
+
+      const timestamps = exchanges
+        .map(e => e.userTimestamp)
+        .filter(Boolean)
+        .map(t => typeof t === 'number' ? t : new Date(t).getTime())
+        .sort();
+
+      sessions.push({
+        id: composerId,
+        file: 'state.vscdb',
+        exchanges,
+        turnCount: exchanges.length * 2,
+        exchangeCount: exchanges.length,
+        startTime: timestamps[0] ? new Date(timestamps[0]).toISOString() : null,
+        endTime: timestamps.length > 0 ? new Date(timestamps[timestamps.length - 1]).toISOString() : null,
+        durationMinutes: timestamps.length >= 2
+          ? Math.round((timestamps[timestamps.length - 1] - timestamps[0]) / 60000)
+          : 0,
+      });
+    } catch {
+      continue;
+    }
+  }
+
+  return sessions;
+}
+
+/**
+ * Get workspace name from workspace.json.
+ */
+function getWorkspaceName(workspaceDir) {
+  const wsFile = join(workspaceDir, 'workspace.json');
+  if (!existsSync(wsFile)) return workspaceDir.split('/').pop();
+  try {
+    const data = JSON.parse(execSync(`cat "${wsFile}"`, { encoding: 'utf-8' }));
+    // workspace.json has a "folder" field with the project path
+    const folder = data.folder || data.workspace || '';
+    // Extract meaningful project name from path
+    const decoded = decodeURIComponent(folder.replace('file://', ''));
+    const parts = decoded.split('/').filter(Boolean);
+    return parts.slice(-2).join('/') || workspaceDir.split('/').pop();
+  } catch {
+    return workspaceDir.split('/').pop();
+  }
+}
+
+/**
+ * Parse all Cursor workspaces from workspaceStorage.
+ */
+export function parseAllWorkspaces(basePath) {
+  if (!existsSync(basePath)) return [];
+
+  const allSessions = [];
+  let dirs;
+  try {
+    dirs = readdirSync(basePath).filter(f => {
+      try { return statSync(join(basePath, f)).isDirectory(); } catch { return false; }
+    });
+  } catch {
+    return [];
+  }
+
+  for (const dir of dirs) {
+    const workspaceDir = join(basePath, dir);
+    const dbPath = join(workspaceDir, 'state.vscdb');
+    if (!existsSync(dbPath)) continue;
+
+    const projectName = getWorkspaceName(workspaceDir);
+    const table = detectTable(dbPath);
+    if (!table) continue;
+
+    let sessions = [];
+
+    // Try composer format first (newer)
+    if (table === 'cursorDiskKV') {
+      sessions = parseComposerChat(dbPath);
+      // Also try legacy key in same table
+      if (sessions.length === 0) {
+        sessions = parseLegacyChat(dbPath, table);
+      }
+    } else {
+      sessions = parseLegacyChat(dbPath, table);
+    }
+
+    for (const session of sessions) {
+      session.project = projectName;
+      allSessions.push(session);
+    }
+  }
+
+  return allSessions;
+}

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: {