chekk 0.5.5 → 1.0.0

package/src/metrics/ai-leverage.js

@@ -1,186 +0,0 @@
-/**
- * AI Leverage
- *
- * Measures whether the engineer uses AI for high-level design and architecture
- * or mostly for boilerplate and simple tasks.
- *
- * Signals:
- * - Architectural/design prompts vs boilerplate/CRUD prompts
- * - Complexity of requested tasks
- * - Usage of AI for planning, design review, code review
- * - Diversity of tool usage (not just "write code" but also explore, analyze, test)
- */
-
-// ── Evidence quality filter ──
-const noisePatterns = /^This session is being continued|^\[?[0-9T:.Z-]{20,}|^\S+@\S+.*[%$#>]|^\s*\$\s|^\s*>\s/;
-function isGoodEvidence(prompt) {
-  if (!prompt || prompt.length < 40 || prompt.length > 600) return false;
-  if (noisePatterns.test(prompt)) return false;
-  const alpha = prompt.replace(/[^a-zA-Z]/g, '').length;
-  if (alpha / prompt.length < 0.4) return false;
-  return true;
-}
-
-const architecturalPatterns = /\b(architect|design|refactor|redesign|restructure|system design|data model|schema|api design|interface|abstract|pattern|trade-?off|scalab|approach|strategy|migration|infrastructure)\b/i;
-const planningPatterns = /\b(plan|breakdown|break down|think through|help me think|what('?s| is) the best (way|approach)|how should (i|we)|pros and cons|options for|compare|evaluate|review my|code review|audit)\b/i;
-const exploratoryPatterns = /\b(explain|understand|how does|what does|why does|walk me through|investigate|diagnose|analyze|explore|deep dive|look into)\b/i;
-const boilerplatePatterns = /\b(add a (button|field|column|route|endpoint|page|component)|create a (form|modal|table|list|card)|simple (function|class|component)|CRUD|boilerplate|scaffold|template|generate (a |the )?(basic|simple))\b/i;
-const testingPatterns = /\b(test|spec|unit test|integration test|e2e|coverage|assert|expect|mock|fixture)\b/i;
-
-const highLeverageTools = ['Task', 'WebSearch', 'WebFetch', 'Grep', 'Glob', 'Read'];
-const codingTools = ['Write', 'Edit', 'Bash', 'NotebookEdit'];
-
-export function computeAILeverage(sessions) {
-  if (sessions.length === 0) return { score: 50, details: {} };
-
-  let totalPrompts = 0;
-  let architecturalPrompts = 0;
-  let planningPrompts = 0;
-  let exploratoryPrompts = 0;
-  let boilerplatePrompts = 0;
-  let testingPrompts = 0;
-  let highLeverageToolUses = 0;
-  let codingToolUses = 0;
-  let totalToolUses = 0;
-
-  // Track prompt complexity via length and structure
-  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 (isGoodEvidence(prompt) && prompt.length > bestArchLen) { bestArchLen = prompt.length; bestArchPrompt = prompt; }
-      }
-      if (planningPatterns.test(prompt)) {
-        planningPrompts++;
-        if (isGoodEvidence(prompt) && prompt.length > bestPlanLen) { bestPlanLen = prompt.length; bestPlanPrompt = prompt; }
-      }
-      if (exploratoryPatterns.test(prompt)) {
-        exploratoryPrompts++;
-        if (isGoodEvidence(prompt) && prompt.length > bestExploreLen) { bestExploreLen = prompt.length; bestExplorePrompt = prompt; }
-      }
-      if (boilerplatePatterns.test(prompt)) boilerplatePrompts++;
-      if (testingPatterns.test(prompt)) testingPrompts++;
-
-      // Complexity
-      const sentences = prompt.split(/[.!?]+/).filter(s => s.trim().length > 10);
-      if (prompt.length > 200 && sentences.length >= 2) {
-        complexPrompts++;
-      } else if (prompt.length < 50) {
-        trivialPrompts++;
-      }
-
-      // Tool usage from assistant responses
-      for (const tool of exchange.toolCalls) {
-        totalToolUses++;
-        const toolName = tool.tool || '';
-        if (highLeverageTools.some(t => toolName.includes(t))) {
-          highLeverageToolUses++;
-        }
-        if (codingTools.some(t => toolName.includes(t))) {
-          codingToolUses++;
-        }
-      }
-    }
-  }
-
-  // Score components
-
-  // High-level thinking ratio (architectural + planning + exploratory vs total)
-  const highLevelPrompts = architecturalPrompts + planningPrompts + exploratoryPrompts;
-  const highLevelRatio = totalPrompts > 0 ? highLevelPrompts / totalPrompts : 0;
-  const highLevelScore = Math.min(100, highLevelRatio * 250); // 40%+ = 100
-
-  // Boilerplate ratio (lower is better)
-  const boilerplateRatio = totalPrompts > 0 ? boilerplatePrompts / totalPrompts : 0;
-  const boilerplatePenalty = boilerplateRatio * 60;
-
-  // Complexity ratio
-  const complexRatio = totalPrompts > 0 ? complexPrompts / totalPrompts : 0;
-  const complexScore = Math.min(100, complexRatio * 300);
-
-  // Tool diversity - using AI for research/exploration not just coding
-  const researchToolRatio = totalToolUses > 0 ? highLeverageToolUses / totalToolUses : 0.5;
-  const toolDiversityScore = Math.min(100, researchToolRatio * 200);
-
-  // Testing awareness
-  const testingRatio = totalPrompts > 0 ? testingPrompts / totalPrompts : 0;
-  const testingBonus = Math.min(20, testingRatio * 200);
-
-  const score = Math.round(
-    highLevelScore * 0.35 +
-    (100 - boilerplatePenalty) * 0.2 +
-    complexScore * 0.2 +
-    toolDiversityScore * 0.15 +
-    testingBonus * 0.1 +
-    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 });
-
-  // ── Token cost evidence ──
-  // Compare cost of trivial prompts vs complex/architectural prompts
-  let trivialTokens = 0, trivialTokenCount = 0;
-  let complexTokensTotal = 0, complexTokensCount = 0;
-  let boilerplateTokens = 0, boilerplateTokenCount = 0;
-  let archTokens = 0, archTokenCount = 0;
-
-  for (const session of sessions) {
-    for (const exchange of session.exchanges) {
-      const prompt = exchange.userPrompt || '';
-      const t = exchange.tokenUsage;
-      const tokens = t ? (t.inputTokens + t.outputTokens + t.cacheReadTokens + t.cacheCreationTokens) : 0;
-      if (tokens === 0) continue;
-
-      if (prompt.length < 50) { trivialTokens += tokens; trivialTokenCount++; }
-      const sentences = prompt.split(/[.!?]+/).filter(s => s.trim().length > 10);
-      if (prompt.length > 200 && sentences.length >= 2) { complexTokensTotal += tokens; complexTokensCount++; }
-      if (boilerplatePatterns.test(prompt)) { boilerplateTokens += tokens; boilerplateTokenCount++; }
-      if (architecturalPatterns.test(prompt) || planningPatterns.test(prompt)) { archTokens += tokens; archTokenCount++; }
-    }
-  }
-
-  return {
-    score: Math.max(0, Math.min(100, score)),
-    details: {
-      totalPrompts,
-      architecturalPrompts,
-      planningPrompts,
-      exploratoryPrompts,
-      boilerplatePrompts,
-      testingPrompts,
-      highLevelRatio: Math.round(highLevelRatio * 100),
-      complexPromptRatio: Math.round(complexRatio * 100),
-      toolDiversity: {
-        total: totalToolUses,
-        research: highLeverageToolUses,
-        coding: codingToolUses,
-      },
-      tokenEvidence: {
-        avgTokensTrivialPrompt: trivialTokenCount > 0 ? Math.round(trivialTokens / trivialTokenCount) : null,
-        avgTokensComplexPrompt: complexTokensCount > 0 ? Math.round(complexTokensTotal / complexTokensCount) : null,
-        avgTokensBoilerplate: boilerplateTokenCount > 0 ? Math.round(boilerplateTokens / boilerplateTokenCount) : null,
-        avgTokensArchitectural: archTokenCount > 0 ? Math.round(archTokens / archTokenCount) : null,
-      },
-    },
-    examples,
-  };
-}

package/src/metrics/debug-cycles.js

@@ -1,204 +0,0 @@
-/**
- * Debug Cycle Efficiency
- *
- * Measures how effectively the engineer resolves issues with AI assistance.
- *
- * Signals:
- * - Error/fix loops: user reports error → assistant tries fix → user reports same error
- * - Number of turns to resolution
- * - Quality of error context provided (stack traces, specific error messages)
- * - "it's still broken" vs targeted debug prompts
- */
-
-// ── Evidence quality filter ──
-// Prompts used as evidence should be human-written, readable, and illustrative.
-// Reject system-generated context, raw log pastes, and extreme lengths.
-const noisePatterns = /^This session is being continued|^\[?[0-9T:.Z-]{20,}|^\S+@\S+.*[%$#>]|^\s*\$\s|^\s*>\s/;
-function isGoodEvidence(prompt) {
-  if (!prompt || prompt.length < 40 || prompt.length > 600) return false;
-  if (noisePatterns.test(prompt)) return false;
-  // Reject if >40% of content is non-alpha (log lines, stack traces, JSON blobs)
-  const alpha = prompt.replace(/[^a-zA-Z]/g, '').length;
-  if (alpha / prompt.length < 0.4) return false;
-  return true;
-}
-
-const errorPatterns = /\b(error|bug|broken|crash|fail|exception|traceback|stack trace|doesn'?t work|not working|issue|problem|wrong)\b/i;
-const vaguePhrases = /^(it'?s? (?:still )?(?:not working|broken|wrong|failing))|^(fix it|try again|still (?:the same|broken|failing|not working))|^(same (?:error|issue|problem|thing))/i;
-const specificDebugPatterns = /\b(line \d+|TypeError|SyntaxError|ImportError|ReferenceError|ValueError|KeyError|AttributeError|NoneType|undefined is not|cannot read prop|stack trace|traceback|\.py:\d+|\.ts:\d+|\.js:\d+|status (?:code )?\d{3}|HTTP \d{3}|ENOENT|EACCES|CORS|404|500|502|503)\b/i;
-const resolutionPatterns = /\b(works|working|fixed|solved|resolved|perfect|great|thanks|nice|awesome|that did it|looks good|ship it)\b/i;
-
-export function computeDebugCycles(sessions) {
-  if (sessions.length === 0) return { score: 50, details: {} };
-
-  let totalDebugSequences = 0;
-  let totalTurnsToResolve = 0;
-  let vagueReports = 0;
-  let specificReports = 0;
-  let unresolvedSequences = 0;
-  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 || '';
-
-      if (errorPatterns.test(prompt)) {
-        if (!inDebugMode) {
-          // Starting a new debug sequence
-          inDebugMode = true;
-          debugTurnCount = 1;
-          debugStartPrompt = prompt;
-          totalDebugSequences++;
-        } else {
-          debugTurnCount++;
-        }
-
-        // Check quality of error report
-        if (vaguePhrases.test(prompt)) {
-          vagueReports++;
-        }
-        if (specificDebugPatterns.test(prompt) || prompt.length > 200) {
-          specificReports++;
-          // Track best specific report — require actual debug pattern match
-          // and readable evidence quality
-          if (specificDebugPatterns.test(prompt) && isGoodEvidence(prompt) && 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 (!bestQuickFix && isGoodEvidence(debugStartPrompt)) 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;
-        }
-      }
-    }
-
-    // Handle session ending mid-debug
-    if (inDebugMode) {
-      totalTurnsToResolve += debugTurnCount;
-      if (debugTurnCount > 5) longLoops++;
-    }
-  }
-
-  const avgTurnsToResolve = totalDebugSequences > 0
-    ? totalTurnsToResolve / totalDebugSequences
-    : 0;
-
-  const totalReports = vagueReports + specificReports;
-  const specificRatio = totalReports > 0 ? specificReports / totalReports : 0.5;
-
-  // Score components
-  // Fewer turns to resolve = better
-  const turnsScore = avgTurnsToResolve === 0 ? 70 :
-                     avgTurnsToResolve <= 2 ? 95 :
-                     avgTurnsToResolve <= 3 ? 85 :
-                     avgTurnsToResolve <= 5 ? 65 :
-                     avgTurnsToResolve <= 8 ? 40 : 20;
-
-  // More specific reports = better
-  const specificScore = specificRatio * 100;
-
-  // Quick fix ratio
-  const quickFixRatio = totalDebugSequences > 0 ? quickFixes / totalDebugSequences : 0.5;
-  const quickFixScore = quickFixRatio * 100;
-
-  // Long loop penalty
-  const longLoopRatio = totalDebugSequences > 0 ? longLoops / totalDebugSequences : 0;
-  const longLoopPenalty = longLoopRatio * 50;
-
-  const score = Math.round(
-    turnsScore * 0.35 +
-    specificScore * 0.25 +
-    quickFixScore * 0.25 +
-    (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 });
-
-  // ── Token cost evidence ──
-  // Compare cost of vague vs specific debug exchanges
-  let vagueTokens = 0, vagueTokenCount = 0;
-  let specificTokens = 0, specificTokenCount = 0;
-  let longLoopTokens = 0, longLoopTokenCount = 0;
-  let quickFixTokens = 0, quickFixTokenCount = 0;
-
-  for (const session of sessions) {
-    const { exchanges } = session;
-    let debugExchanges = [];
-    let inDebug = false;
-
-    for (let i = 0; i < exchanges.length; i++) {
-      const prompt = exchanges[i].userPrompt || '';
-      const t = exchanges[i].tokenUsage;
-      const tokens = t ? (t.inputTokens + t.outputTokens + t.cacheReadTokens + t.cacheCreationTokens) : 0;
-
-      if (errorPatterns.test(prompt) && tokens > 0) {
-        if (!inDebug) { inDebug = true; debugExchanges = []; }
-        debugExchanges.push({ prompt, tokens });
-
-        if (vaguePhrases.test(prompt)) { vagueTokens += tokens; vagueTokenCount++; }
-        if (specificDebugPatterns.test(prompt) || prompt.length > 200) { specificTokens += tokens; specificTokenCount++; }
-      } else if (inDebug) {
-        if (debugExchanges.length <= 2) {
-          const total = debugExchanges.reduce((s, e) => s + e.tokens, 0);
-          quickFixTokens += total; quickFixTokenCount++;
-        } else if (debugExchanges.length > 5) {
-          const total = debugExchanges.reduce((s, e) => s + e.tokens, 0);
-          longLoopTokens += total; longLoopTokenCount++;
-        }
-        inDebug = false;
-        debugExchanges = [];
-      }
-    }
-  }
-
-  return {
-    score: Math.max(0, Math.min(100, score)),
-    details: {
-      totalDebugSequences,
-      avgTurnsToResolve: Math.round(avgTurnsToResolve * 10) / 10,
-      quickFixes,
-      longLoops,
-      specificReportRatio: Math.round(specificRatio * 100),
-      vagueReports,
-      specificReports,
-      tokenEvidence: {
-        avgTokensVagueDebug: vagueTokenCount > 0 ? Math.round(vagueTokens / vagueTokenCount) : null,
-        avgTokensSpecificDebug: specificTokenCount > 0 ? Math.round(specificTokens / specificTokenCount) : null,
-        avgTokensQuickFix: quickFixTokenCount > 0 ? Math.round(quickFixTokens / quickFixTokenCount) : null,
-        avgTokensLongLoop: longLoopTokenCount > 0 ? Math.round(longLoopTokens / longLoopTokenCount) : null,
-      },
-    },
-    examples,
-  };
-}

package/src/metrics/decomposition.js

@@ -1,158 +0,0 @@
-/**
- * Decomposition Quality
- *
- * Measures whether the engineer breaks complex tasks into subtasks
- * or dumps everything in single mega-prompts.
- *
- * Signals:
- * - Multi-step sessions (multiple exchanges building on each other) → higher
- * - Single mega-prompt sessions → lower
- * - Prompt length distribution (long single prompts = less decomposition)
- * - Follow-up prompts that reference or build on previous context
- */
-
-// ── Evidence quality filter ──
-const noisePatterns = /^This session is being continued|^\[?[0-9T:.Z-]{20,}|^\S+@\S+.*[%$#>]|^\s*\$\s|^\s*>\s/;
-function isGoodEvidence(prompt) {
-  if (!prompt || prompt.length < 40 || prompt.length > 600) return false;
-  if (noisePatterns.test(prompt)) return false;
-  const alpha = prompt.replace(/[^a-zA-Z]/g, '').length;
-  if (alpha / prompt.length < 0.4) return false;
-  return true;
-}
-
-export function computeDecomposition(sessions) {
-  if (sessions.length === 0) return { score: 50, details: {} };
-
-  let totalExchanges = 0;
-  let multiStepSessions = 0;
-  let singleShotSessions = 0;
-  let avgPromptLength = 0;
-  let promptCount = 0;
-  let longPromptCount = 0; // > 500 chars
-  let shortPromptCount = 0; // < 100 chars
-  let contextualFollowups = 0; // prompts that start with "now", "next", "also", "then", reference prev context
-
-  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;
-
-    if (exchanges.length >= 4) {
-      multiStepSessions++;
-    } else if (exchanges.length === 1) {
-      singleShotSessions++;
-    }
-
-    for (let i = 0; i < exchanges.length; i++) {
-      const prompt = exchanges[i].userPrompt || '';
-      const len = prompt.length;
-      promptCount++;
-      avgPromptLength += len;
-
-      if (len > 500) longPromptCount++;
-      if (len < 100) shortPromptCount++;
-
-      // Track decomposition examples (multi-sentence prompts showing task breakdown)
-      if (isGoodEvidence(prompt)) {
-        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 (isGoodEvidence(prompt) && (!bestFollowupPrompt || prompt.length > bestFollowupPrompt.length)) {
-            bestFollowupPrompt = prompt;
-          }
-        }
-      }
-    }
-  }
-
-  avgPromptLength = promptCount > 0 ? avgPromptLength / promptCount : 0;
-
-  // Score components (each 0-100)
-  const multiStepRatio = sessions.length > 0 ? multiStepSessions / sessions.length : 0;
-  const multiStepScore = Math.min(100, multiStepRatio * 150); // bonus for > 66%
-
-  const singleShotRatio = sessions.length > 0 ? singleShotSessions / sessions.length : 0;
-  const singleShotPenalty = singleShotRatio * 40; // up to -40
-
-  // Moderate prompt length is good (not too mega, not too terse)
-  const lengthScore = avgPromptLength > 50 && avgPromptLength < 400 ? 80 :
-                      avgPromptLength >= 400 && avgPromptLength < 800 ? 60 :
-                      avgPromptLength >= 800 ? 30 : 50;
-
-  // Contextual followups show iterative thinking
-  const followupRatio = promptCount > 0 ? contextualFollowups / promptCount : 0;
-  const followupScore = Math.min(100, followupRatio * 300);
-
-  const avgExchangesPerSession = sessions.length > 0 ? totalExchanges / sessions.length : 0;
-  const depthScore = Math.min(100, avgExchangesPerSession * 8); // 12+ exchanges = 100
-
-  const score = Math.round(
-    multiStepScore * 0.25 +
-    (100 - singleShotPenalty) * 0.15 +
-    lengthScore * 0.2 +
-    followupScore * 0.2 +
-    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 });
-
-  // ── Token cost evidence ──
-  // Compare token cost of single-shot sessions vs multi-step sessions
-  // to prove decomposition saves tokens
-  let singleShotTokens = 0, singleShotCount = 0;
-  let multiStepTokens = 0, multiStepCount = 0;
-  for (const session of sessions) {
-    const t = session.tokenUsage;
-    if (!t || (t.inputTokens + t.outputTokens + t.cacheReadTokens + t.cacheCreationTokens) === 0) continue;
-    const total = t.inputTokens + t.outputTokens + t.cacheReadTokens + t.cacheCreationTokens;
-    const perExchange = session.exchangeCount > 0 ? total / session.exchangeCount : total;
-    if (session.exchangeCount === 1) {
-      singleShotTokens += perExchange;
-      singleShotCount++;
-    } else if (session.exchangeCount >= 4) {
-      multiStepTokens += perExchange;
-      multiStepCount++;
-    }
-  }
-  const avgTokensSingleShot = singleShotCount > 0 ? Math.round(singleShotTokens / singleShotCount) : null;
-  const avgTokensMultiStep = multiStepCount > 0 ? Math.round(multiStepTokens / multiStepCount) : null;
-
-  return {
-    score: Math.max(0, Math.min(100, score)),
-    details: {
-      totalSessions: sessions.length,
-      multiStepSessions,
-      singleShotSessions,
-      avgExchangesPerSession: Math.round(avgExchangesPerSession * 10) / 10,
-      avgPromptLength: Math.round(avgPromptLength),
-      longPromptRatio: promptCount > 0 ? Math.round(longPromptCount / promptCount * 100) : 0,
-      contextualFollowupRatio: promptCount > 0 ? Math.round(followupRatio * 100) : 0,
-      tokenEvidence: {
-        avgTokensPerExchangeSingleShot: avgTokensSingleShot,
-        avgTokensPerExchangeMultiStep: avgTokensMultiStep,
-      },
-    },
-    examples,
-  };
-}