chekk 0.2.3 → 0.2.5

package/bin/chekk.js

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

package/package.json

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

@@ -90,7 +90,7 @@ export function displayHeader() {
   console.log();
   const lines = [
     '',
-    `   ${bold.white('chekk')}${dim(' v0.2.3')}`,
+    `   ${bold.white('chekk')}${dim(' v0.2.5')}`,
     `   ${dim('the engineering capability score')}`,
     '',
   ];
@@ -106,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();
 }
@@ -208,25 +203,44 @@ 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();
     }
-    // Show prompt evidence after AI prose
-    displayPromptEvidence(metrics);
   } else {
     // Fallback: data-driven bullet points with inline snippets
-    displayDataNarratives(metrics);
+    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;
@@ -236,8 +250,6 @@ function displayDataNarratives(metrics) {
   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);
@@ -282,49 +294,6 @@ function displayDataNarratives(metrics) {
   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();
-}
 
 // ══════════════════════════════════════════════
 // EASTER EGGS
@@ -450,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/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;
+}