chekk 0.5.0 → 0.5.1

package/bin/chekk.js

@@ -4,7 +4,7 @@ import { execSync, spawn } from 'child_process';
 import { Command } from 'commander';
 import { run } from '../src/index.js';
 
-const LOCAL_VERSION = '0.5.0';
+const LOCAL_VERSION = '0.5.1';
 
 // ── Auto-update check ──
 // If running from a cached npx install, check if there's a newer version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chekk",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "See how you prompt. Chekk analyzes your AI coding workflow, tells you what kind of engineer you are, and shows what your habits actually cost.",
   "bin": {
     "chekk": "./bin/chekk.js"

package/src/display.js

@@ -173,7 +173,7 @@ export function displayHeader() {
   console.log();
   const lines = [
     '',
-    `   ${bold.white('chekk')}${dim(' v0.5.0')}`,
+    `   ${bold.white('chekk')}${dim(' v0.5.1')}`,
     `   ${dim('prompt engineering capability profile')}`,
     '',
   ];
@@ -231,7 +231,7 @@ function displayProfileHeader(result, extra = {}) {
   console.log(`  ${bold.white('PROMPT ENGINEERING CAPABILITY PROFILE')}`);
   console.log();
   if (sessionStats) {
-    console.log(`  ${dim(`Generated ${dateStr} | chekk v0.5.0`)}`);
+    console.log(`  ${dim(`Generated ${dateStr} | chekk v0.5.1`)}`);
     console.log(`  ${dim(`Analysis: ${sessionStats.totalSessions} sessions \u00B7 ${sessionStats.tools.length} tool${sessionStats.tools.length > 1 ? 's' : ''} \u00B7 ${numberFormat(sessionStats.totalExchanges)} exchanges`)}`);
     if (sessionStats.dateRangeShort) {
       console.log(`  ${dim(`Period: ${sessionStats.dateRangeShort}`)}`);
@@ -412,6 +412,7 @@ export function displayTokenEfficiency(tokenEfficiency, metrics) {
 
   // Format percentages with appropriate precision
   function fmtPct(pct) {
+    if (pct >= 99.5) return pct.toFixed(1) + '%';
     if (pct >= 10) return Math.round(pct) + '%';
     if (pct >= 1) return pct.toFixed(1) + '%';
     if (pct > 0) return pct.toFixed(2) + '%';
@@ -470,20 +471,93 @@ export function displayTokenEfficiency(tokenEfficiency, metrics) {
   }
 
   // ── Token cost evidence from metrics ──
-  displayTokenEvidence(metrics);
+  displayTokenEvidence(metrics, tokenEfficiency);
 }
 
-function displayTokenEvidence(metrics) {
+// ── Per-dimension cost annotation ──
+// Shows a single cost insight line under each scored dimension
+
+function dollarFormat(amount) {
+  if (amount >= 1000) return '$' + (amount / 1000).toFixed(1).replace(/\.0$/, '') + 'k';
+  if (amount >= 100) return '$' + Math.round(amount);
+  if (amount >= 1) return '$' + amount.toFixed(2);
+  return '$' + amount.toFixed(2);
+}
+
+function displayDimensionCostLine(dimensionName, metrics, tokenEfficiency) {
+  if (!tokenEfficiency || !tokenEfficiency.hasData) return;
+
+  const pricing = tokenEfficiency.estimatedCostTotal / Math.max(1, tokenEfficiency.grandTotal);
+
+  if (dimensionName === 'thinking') {
+    const de = metrics.decomposition.details.tokenEvidence;
+    if (de && de.avgTokensPerExchangeSingleShot && de.avgTokensPerExchangeMultiStep) {
+      const ssCost = de.avgTokensPerExchangeSingleShot * pricing;
+      const msCost = de.avgTokensPerExchangeMultiStep * pricing;
+      if (ssCost > msCost * 1.1) {
+        console.log(`  ${dim('\u21B3 Cost:')} ${dim('single-shot')} ${orange(dollarFormat(ssCost) + '/exchange')} ${dim('vs multi-step')} ${green(dollarFormat(msCost) + '/exchange')}`);
+      }
+    }
+  }
+
+  if (dimensionName === 'debugging') {
+    const dbe = metrics.debugCycles.details.tokenEvidence;
+    if (dbe && dbe.avgTokensQuickFix && dbe.avgTokensLongLoop) {
+      const qfCost = dbe.avgTokensQuickFix * pricing;
+      const llCost = dbe.avgTokensLongLoop * pricing;
+      console.log(`  ${dim('\u21B3 Cost:')} ${dim('quick fix')} ${green(dollarFormat(qfCost))} ${dim('vs debug spiral')} ${orange(dollarFormat(llCost))}`);
+    } else if (dbe && dbe.avgTokensSpecificDebug) {
+      const spCost = dbe.avgTokensSpecificDebug * pricing;
+      console.log(`  ${dim('\u21B3 Cost:')} ${dim('avg debug cycle')} ${dim(dollarFormat(spCost))}`);
+    }
+  }
+
+  if (dimensionName === 'ai leverage') {
+    const aie = metrics.aiLeverage.details.tokenEvidence;
+    if (aie && aie.avgTokensArchitectural && aie.avgTokensBoilerplate) {
+      const archCost = aie.avgTokensArchitectural * pricing;
+      const boilCost = aie.avgTokensBoilerplate * pricing;
+      console.log(`  ${dim('\u21B3 Cost:')} ${dim('architectural prompt')} ${dim(dollarFormat(archCost))} ${dim('vs boilerplate')} ${dim(dollarFormat(boilCost))}`);
+    } else if (aie && aie.avgTokensTrivialPrompt && aie.avgTokensComplexPrompt) {
+      const trivCost = aie.avgTokensTrivialPrompt * pricing;
+      const compCost = aie.avgTokensComplexPrompt * pricing;
+      console.log(`  ${dim('\u21B3 Cost:')} ${dim('trivial prompt')} ${dim(dollarFormat(trivCost))} ${dim('vs detailed')} ${dim(dollarFormat(compCost))}`);
+    }
+  }
+
+  if (dimensionName === 'workflow') {
+    const sse = metrics.sessionStructure.details.tokenEvidence;
+    if (sse && sse.avgTokensPerExchangeMarathon && sse.avgTokensPerExchangeFocused) {
+      const marCost = sse.avgTokensPerExchangeMarathon * pricing;
+      const focCost = sse.avgTokensPerExchangeFocused * pricing;
+      if (marCost > focCost * 1.1) {
+        console.log(`  ${dim('\u21B3 Cost:')} ${dim('marathon')} ${orange(dollarFormat(marCost) + '/exchange')} ${dim('vs focused')} ${green(dollarFormat(focCost) + '/exchange')}`);
+      }
+    }
+  }
+}
+
+function displayTokenEvidence(metrics, tokenEfficiency) {
   const evidenceLines = [];
+  const pricing = tokenEfficiency && tokenEfficiency.hasData
+    ? tokenEfficiency.estimatedCostTotal / Math.max(1, tokenEfficiency.grandTotal) : 0;
 
   // Decomposition: single-shot vs multi-step cost
   const de = metrics.decomposition.details.tokenEvidence;
   if (de && de.avgTokensPerExchangeSingleShot && de.avgTokensPerExchangeMultiStep) {
     const ratio = (de.avgTokensPerExchangeSingleShot / de.avgTokensPerExchangeMultiStep).toFixed(1);
     if (parseFloat(ratio) > 1.2) {
-      evidenceLines.push(
-        `  ${dim('\u2022 Single-shot prompts cost')} ${orange(ratio + 'x')} ${dim('more tokens per exchange than multi-step sessions')}`
-      );
+      if (pricing > 0) {
+        const ssCost = dollarFormat(de.avgTokensPerExchangeSingleShot * pricing);
+        const msCost = dollarFormat(de.avgTokensPerExchangeMultiStep * pricing);
+        evidenceLines.push(
+          `  ${dim('\u2022 Single-shot prompts cost')} ${orange(ssCost + '/exchange')} ${dim('vs')} ${green(msCost)} ${dim('in multi-step sessions')} ${dim('(' + ratio + 'x)')}`
+        );
+      } else {
+        evidenceLines.push(
+          `  ${dim('\u2022 Single-shot prompts cost')} ${orange(ratio + 'x')} ${dim('more tokens per exchange than multi-step sessions')}`
+        );
+      }
     }
   }
 
@@ -492,32 +566,62 @@ function displayTokenEvidence(metrics) {
   if (dbe && dbe.avgTokensVagueDebug && dbe.avgTokensSpecificDebug) {
     const ratio = (dbe.avgTokensVagueDebug / dbe.avgTokensSpecificDebug).toFixed(1);
     if (parseFloat(ratio) > 1.2) {
-      evidenceLines.push(
-        `  ${dim('\u2022 Vague debug prompts cost')} ${orange(ratio + 'x')} ${dim('more than specific error reports')}`
-      );
+      if (pricing > 0) {
+        const vCost = dollarFormat(dbe.avgTokensVagueDebug * pricing);
+        const sCost = dollarFormat(dbe.avgTokensSpecificDebug * pricing);
+        evidenceLines.push(
+          `  ${dim('\u2022 Vague debug prompts cost')} ${orange(vCost)} ${dim('vs')} ${green(sCost)} ${dim('for specific reports')} ${dim('(' + ratio + 'x)')}`
+        );
+      } else {
+        evidenceLines.push(
+          `  ${dim('\u2022 Vague debug prompts cost')} ${orange(ratio + 'x')} ${dim('more than specific error reports')}`
+        );
+      }
     }
   }
 
   // AI Leverage: trivial prompts vs detailed ones
   const aie = metrics.aiLeverage.details.tokenEvidence;
   if (aie && aie.avgTokensTrivialPrompt && aie.avgTokensComplexPrompt) {
-    // Trivial prompts often cost nearly as much because Claude re-reads everything anyway
     const savingsPct = Math.round((1 - aie.avgTokensTrivialPrompt / aie.avgTokensComplexPrompt) * 100);
-    if (savingsPct < 40) {
+    if (pricing > 0) {
+      const trivCost = dollarFormat(aie.avgTokensTrivialPrompt * pricing);
+      const compCost = dollarFormat(aie.avgTokensComplexPrompt * pricing);
+      evidenceLines.push(
+        `  ${dim('\u2022 Short vague prompts (<50 chars) cost')} ${dim(trivCost)} ${dim('— only ' + savingsPct + '% less than detailed ones at')} ${dim(compCost)}`
+      );
+    } else if (savingsPct < 40) {
       evidenceLines.push(
         `  ${dim('\u2022 Short vague prompts (<50 chars) cost')} ${dim(numberFormat(aie.avgTokensTrivialPrompt) + ' tokens')} ${dim('— only ' + savingsPct + '% less than detailed ones')}`
       );
     }
   }
 
+  // AI Leverage: architectural vs boilerplate cost
+  if (aie && aie.avgTokensArchitectural && aie.avgTokensBoilerplate && pricing > 0) {
+    const archCost = dollarFormat(aie.avgTokensArchitectural * pricing);
+    const boilCost = dollarFormat(aie.avgTokensBoilerplate * pricing);
+    evidenceLines.push(
+      `  ${dim('\u2022 Architectural prompts cost')} ${dim(archCost + '/exchange')} ${dim('vs boilerplate at')} ${dim(boilCost + '/exchange')}`
+    );
+  }
+
   // Session structure: marathon vs focused cost
   const sse = metrics.sessionStructure.details.tokenEvidence;
   if (sse && sse.avgTokensPerExchangeMarathon && sse.avgTokensPerExchangeFocused) {
     const ratio = (sse.avgTokensPerExchangeMarathon / sse.avgTokensPerExchangeFocused).toFixed(1);
     if (parseFloat(ratio) > 1.1) {
-      evidenceLines.push(
-        `  ${dim('\u2022 Marathon sessions (>60m) cost')} ${orange(ratio + 'x')} ${dim('more per exchange than focused ones (10-45m)')}`
-      );
+      if (pricing > 0) {
+        const marCost = dollarFormat(sse.avgTokensPerExchangeMarathon * pricing);
+        const focCost = dollarFormat(sse.avgTokensPerExchangeFocused * pricing);
+        evidenceLines.push(
+          `  ${dim('\u2022 Marathon sessions (>60m) cost')} ${orange(marCost + '/exchange')} ${dim('vs focused at')} ${green(focCost)} ${dim('(' + ratio + 'x)')}`
+        );
+      } else {
+        evidenceLines.push(
+          `  ${dim('\u2022 Marathon sessions (>60m) cost')} ${orange(ratio + 'x')} ${dim('more per exchange than focused ones (10-45m)')}`
+        );
+      }
     }
   }
 
@@ -525,9 +629,32 @@ function displayTokenEvidence(metrics) {
   if (sse && sse.avgTokensPerExchangeNoContext && sse.avgTokensPerExchangeWithContext) {
     const ratio = (sse.avgTokensPerExchangeNoContext / sse.avgTokensPerExchangeWithContext).toFixed(1);
     if (parseFloat(ratio) > 1.1) {
-      evidenceLines.push(
-        `  ${dim('\u2022 Sessions without upfront context cost')} ${orange(ratio + 'x')} ${dim('more per exchange')}`
-      );
+      if (pricing > 0) {
+        const noCost = dollarFormat(sse.avgTokensPerExchangeNoContext * pricing);
+        const wCost = dollarFormat(sse.avgTokensPerExchangeWithContext * pricing);
+        evidenceLines.push(
+          `  ${dim('\u2022 Sessions without upfront context cost')} ${orange(noCost + '/exchange')} ${dim('vs')} ${green(wCost)} ${dim('with context')} ${dim('(' + ratio + 'x)')}`
+        );
+      } else {
+        evidenceLines.push(
+          `  ${dim('\u2022 Sessions without upfront context cost')} ${orange(ratio + 'x')} ${dim('more per exchange')}`
+        );
+      }
+    }
+  }
+
+  // Session length cost curve from token efficiency
+  if (tokenEfficiency && tokenEfficiency.hasData && tokenEfficiency.sessionLengthAnalysis) {
+    const sla = tokenEfficiency.sessionLengthAnalysis;
+    if (sla.length >= 2 && pricing > 0) {
+      const sorted = [...sla].sort((a, b) => a.avgTokensPerExchange - b.avgTokensPerExchange);
+      const cheapest = sorted[0];
+      const costliest = sorted[sorted.length - 1];
+      if (costliest.avgTokensPerExchange > cheapest.avgTokensPerExchange * 1.5) {
+        evidenceLines.push(
+          `  ${dim('\u2022 Cost curve:')} ${dim(cheapest.label)} ${green(dollarFormat(cheapest.avgTokensPerExchange * pricing) + '/exchange')} ${dim('\u2192')} ${dim(costliest.label)} ${orange(dollarFormat(costliest.avgTokensPerExchange * pricing) + '/exchange')}`
+        );
+      }
     }
   }
 
@@ -572,10 +699,18 @@ function displayCrossPlatform(perToolScores) {
 // PROJECT ANALYSIS
 // ══════════════════════════════════════════════
 
-function displayProjects(insights) {
+function displayProjects(insights, tokenEfficiency = null) {
   const projects = insights?.projectComplexity;
   if (!projects || projects.length === 0) return;
 
+  // Build a lookup from token efficiency per-project data
+  const projectCostMap = {};
+  if (tokenEfficiency && tokenEfficiency.hasData && tokenEfficiency.perProject) {
+    for (const pp of tokenEfficiency.perProject) {
+      projectCostMap[pp.fullName] = pp;
+    }
+  }
+
   console.log(dim('  PROJECT ANALYSIS\n'));
   for (const p of projects) {
     const compColor = p.complexity === 'HIGH' ? green : p.complexity === 'MEDIUM' ? yellow : dim;
@@ -584,7 +719,17 @@ function displayProjects(insights) {
     if (signals) {
       console.log(`  ${dim(signals)}`);
     }
-    console.log(`  ${dim(`${p.sessions} sessions \u00B7 ${numberFormat(p.exchanges)} exchanges \u00B7 ${p.daysActive} days active`)}`);
+    // Look up cost data — match by full project name or short name
+    const costData = Object.values(projectCostMap).find(pp =>
+      p.name === pp.name || pp.fullName?.endsWith(p.name.replace('...', ''))
+    );
+    if (costData && costData.exchanges > 0) {
+      const costPerExchange = costData.estimatedCost / costData.exchanges;
+      const totalCost = costData.estimatedCost;
+      console.log(`  ${dim(`${p.sessions} sessions \u00B7 ${numberFormat(p.exchanges)} exchanges \u00B7 ${p.daysActive} days active`)}  ${dim('|')}  ${dim('$' + totalCost.toFixed(0) + ' total \u00B7 $' + costPerExchange.toFixed(2) + '/exchange')}`);
+    } else {
+      console.log(`  ${dim(`${p.sessions} sessions \u00B7 ${numberFormat(p.exchanges)} exchanges \u00B7 ${p.daysActive} days active`)}`);
+    }
     console.log();
   }
 }
@@ -593,7 +738,7 @@ function displayProjects(insights) {
 // DIMENSION NARRATIVES — Clinical, benchmarked
 // ══════════════════════════════════════════════
 
-export function displayNarratives(metrics, prose) {
+export function displayNarratives(metrics, prose, tokenEfficiency = null) {
   const shownSnippets = new Set();
   function showLabeledSnippet(label, prompt) {
     if (!prompt) return;
@@ -617,17 +762,19 @@ export function displayNarratives(metrics, prose) {
       for (const line of lines) {
         console.log(`  ${dim(line.trim())}`);
       }
+      // Add token cost line for this dimension
       const titleLower = section.title.toLowerCase();
+      displayDimensionCostLine(titleLower, metrics, tokenEfficiency);
       const matched = sectionSnippetMap[titleLower];
       if (matched && matched.prompt) showLabeledSnippet(matched.label, matched.prompt);
       console.log();
     }
   } else {
-    displayDataNarratives(metrics, shownSnippets);
+    displayDataNarratives(metrics, shownSnippets, tokenEfficiency);
   }
 }
 
-function displayDataNarratives(metrics, shownSnippets) {
+function displayDataNarratives(metrics, shownSnippets, tokenEfficiency = null) {
   const d = metrics.decomposition.details;
   const db = metrics.debugCycles.details;
   const ai = metrics.aiLeverage.details;
@@ -646,6 +793,7 @@ function displayDataNarratives(metrics, shownSnippets) {
   console.log(`  ${dim(`Avg session depth: ${d.avgExchangesPerSession} exchanges (benchmark: ${BENCHMARKS.avgExchangesPerSession})`)}`);
   console.log(`  ${dim(`Avg prompt length: ${numberFormat(d.avgPromptLength)} chars (benchmark: ${BENCHMARKS.avgPromptLength})`)}`);
   console.log(`  ${dim(`Multi-step ratio: ${d.multiStepSessions}/${d.totalSessions} sessions (${Math.round(d.multiStepSessions / Math.max(1, d.totalSessions) * 100)}%)`)}`);
+  displayDimensionCostLine('thinking', metrics, tokenEfficiency);
   showSnippet('Evidence', pickExample(metrics.decomposition.examples, 'decomposition'));
   console.log();
 
@@ -654,6 +802,7 @@ function displayDataNarratives(metrics, shownSnippets) {
   console.log(`  ${dim(`Avg resolution: ${db.avgTurnsToResolve} turns (benchmark: ${BENCHMARKS.avgTurnsToResolve})`)}`);
   console.log(`  ${dim(`Specific reports: ${db.specificReportRatio}% (benchmark: ${BENCHMARKS.specificReportRatio}%)`)}`);
   console.log(`  ${dim(`Extended loops: ${db.longLoops} | Quick fixes: ${db.quickFixes}/${db.totalDebugSequences}`)}`);
+  displayDimensionCostLine('debugging', metrics, tokenEfficiency);
   showSnippet('Evidence', pickExample(metrics.debugCycles.examples, 'specific_report') || pickExample(metrics.debugCycles.examples, 'quick_fix'));
   console.log();
 
@@ -662,6 +811,7 @@ function displayDataNarratives(metrics, shownSnippets) {
   console.log(`  ${dim(`High-level ratio: ${ai.highLevelRatio}% (benchmark: ${BENCHMARKS.highLevelRatio}%)`)}`);
   console.log(`  ${dim(`Breakdown: ${ai.architecturalPrompts} architectural \u00B7 ${ai.planningPrompts} planning \u00B7 ${ai.exploratoryPrompts} exploratory`)}`);
   console.log(`  ${dim(`Boilerplate: ${ai.boilerplatePrompts} (${Math.round(ai.boilerplatePrompts / Math.max(1, ai.totalPrompts) * 100)}%) \u00B7 Testing: ${ai.testingPrompts}`)}`);
+  displayDimensionCostLine('ai leverage', metrics, tokenEfficiency);
   showSnippet('Evidence', pickExample(metrics.aiLeverage.examples, 'architectural') || pickExample(metrics.aiLeverage.examples, 'planning'));
   console.log();
 
@@ -670,6 +820,7 @@ function displayDataNarratives(metrics, shownSnippets) {
   console.log(`  ${dim(`Context-setting: ${ss.contextSetRatio}% (benchmark: ${BENCHMARKS.contextSetRatio}%)`)}`);
   console.log(`  ${dim(`Review at end: ${ss.reviewEndRatio}% (benchmark: ${BENCHMARKS.reviewEndRatio}%)`)}`);
   console.log(`  ${dim(`Refinement rate: ${ss.refinementRatio}% (benchmark: ${BENCHMARKS.refinementRatio}%)`)}`);
+  displayDimensionCostLine('workflow', metrics, tokenEfficiency);
   showSnippet('Evidence', pickExample(metrics.sessionStructure.examples, 'context_setting') || pickExample(metrics.sessionStructure.examples, 'refinement'));
   console.log();
 }
@@ -838,7 +989,7 @@ function displayNextSteps(result) {
 // VERBOSE: DETAILED BREAKDOWN
 // ══════════════════════════════════════════════
 
-export function displayVerbose(metrics, sessions) {
+export function displayVerbose(metrics, sessions, tokenEfficiency = null) {
   console.log(doubleRule());
   console.log(dim('\n  DETAILED BREAKDOWN\n'));
 
@@ -894,6 +1045,7 @@ export function displayVerbose(metrics, sessions) {
   console.log(`  ${dim(pad('Multi-step sessions', 28))} ${white(d.multiStepSessions + '/' + d.totalSessions)} ${dim('(' + Math.round(d.multiStepSessions / Math.max(1, d.totalSessions) * 100) + '%)')}`);
   console.log(`  ${dim(pad('Single-shot sessions', 28))} ${white(String(d.singleShotSessions))}`);
   console.log(`  ${dim(pad('Contextual followups', 28))} ${white(d.contextualFollowupRatio + '%')}${d.contextualFollowupRatio > 20 ? cyan(' builds on context well') : orange(' could reference prior work more')}`);
+  displayDimensionCostLine('thinking', metrics, tokenEfficiency);
   console.log();
 
   // ── Debugging ──
@@ -906,6 +1058,7 @@ export function displayVerbose(metrics, sessions) {
   console.log(`  ${dim(pad('Extended loops (>5 turns)', 28))} ${db.longLoops === 0 ? green('0 -- zero spirals') : orange(String(db.longLoops))}`);
   metricRow('Specific report ratio', db.specificReportRatio, BENCHMARKS.specificReportRatio, '%');
   console.log(`  ${dim(pad('Vague reports', 28))} ${db.vagueReports === 0 ? green('0 -- never vague') : orange(String(db.vagueReports))}`);
+  displayDimensionCostLine('debugging', metrics, tokenEfficiency);
   console.log();
 
   // ── AI Leverage ──
@@ -923,6 +1076,7 @@ export function displayVerbose(metrics, sessions) {
   console.log(`  ${dim(pad('  Testing', 28))} ${white(String(ai.testingPrompts))} ${dim('(' + Math.round(ai.testingPrompts / total * 100) + '%)')}`);
   console.log();
   metricRow('High-level ratio', ai.highLevelRatio, BENCHMARKS.highLevelRatio, '%');
+  displayDimensionCostLine('ai leverage', metrics, tokenEfficiency);
   console.log();
 
   // ── Session Structure ──
@@ -943,6 +1097,7 @@ export function displayVerbose(metrics, sessions) {
     console.log(`  ${dim(pad('  Medium (5-60m)', 28))} ${white(String(dur.medium))}`);
     console.log(`  ${dim(pad('  Long (>60m)', 28))} ${white(String(dur.long))}`);
   }
+  displayDimensionCostLine('workflow', metrics, tokenEfficiency);
   console.log();
 }
 
@@ -957,8 +1112,8 @@ export function displayOffline(result, metrics, extra = {}) {
   displayDimensions(result);
   displayTokenEfficiency(extra.tokenEfficiency, metrics);
   displayCrossPlatform(extra.perToolScores);
-  displayDataNarratives(metrics, new Set());
-  displayProjects(extra.insights);
+  displayDataNarratives(metrics, new Set(), extra.tokenEfficiency);
+  displayProjects(extra.insights, extra.tokenEfficiency);
   displaySignatures(extra.insights);
   displayWatchPoints(extra.insights);
   displayTrajectory(extra.insights);
@@ -980,8 +1135,8 @@ export function displayFull(result, metrics, prose, extra = {}) {
   displayDimensions(result);
   displayTokenEfficiency(extra.tokenEfficiency, metrics);
   displayCrossPlatform(extra.perToolScores);
-  displayNarratives(metrics, prose);
-  displayProjects(extra.insights);
+  displayNarratives(metrics, prose, extra.tokenEfficiency);
+  displayProjects(extra.insights, extra.tokenEfficiency);
   displaySignatures(extra.insights);
   displayWatchPoints(extra.insights);
   displayTrajectory(extra.insights);

package/src/index.js

@@ -213,13 +213,13 @@ export async function run(options = {}) {
 
   // ── Step 6: Verbose prompt (interactive) ──
   if (options.verbose) {
-    displayVerbose(metrics, allSessions);
+    displayVerbose(metrics, allSessions, tokenEfficiency);
   } else {
     try {
       const wantsVerbose = await askVerbose();
       if (wantsVerbose) {
         console.log();
-        displayVerbose(metrics, allSessions);
+        displayVerbose(metrics, allSessions, tokenEfficiency);
       } else {
         console.log();
       }

package/src/insights.js

@@ -250,9 +250,21 @@ export function computeWatchPoints(allSessions, metrics, tokenEfficiency = null)
   }
   const totalFollowupSessions = Object.values(projectSessions).reduce((sum, s) => sum + Math.max(0, s.length - 1), 0);
   if (totalFollowupSessions > 3 && contextRestarts / totalFollowupSessions > 0.5) {
+    // Estimate cost of context restarts — each restart forces full context re-read
+    let costNote = '';
+    if (tokenEfficiency && tokenEfficiency.hasData) {
+      const avgCostPerSession = tokenEfficiency.estimatedCostTotal / Math.max(1, tokenEfficiency.sessionsAnalyzed);
+      // The re-read cost of each restart scales with context size — estimate as % of avg session cost
+      const rereadPct = tokenEfficiency.contextRereadRatio || 0.94;
+      const wastedPerRestart = avgCostPerSession * rereadPct * 0.3; // ~30% of re-read is avoidable with context continuity
+      const totalWasted = wastedPerRestart * contextRestarts;
+      if (totalWasted > 1) {
+        costNote = ` Estimated wasted re-read cost: ~$${totalWasted.toFixed(0)}.`;
+      }
+    }
     watchPoints.push({
       name: 'Context amnesia',
-      detail: `You restart context from scratch in ${Math.round(contextRestarts / totalFollowupSessions * 100)}% of follow-up sessions on the same project. Engineers who maintain context across sessions are more efficient.`,
+      detail: `You restart context from scratch in ${Math.round(contextRestarts / totalFollowupSessions * 100)}% of follow-up sessions on the same project. Engineers who maintain context across sessions are more efficient.${costNote}`,
       evidence: bestContextRestartPrompt,
     });
   }
@@ -290,27 +302,58 @@ export function computeWatchPoints(allSessions, metrics, tokenEfficiency = null)
         }
       }
     }
+    // Dollar annotation: long prompts trigger large context re-reads each time
+    let monologueCostNote = '';
+    if (tokenEfficiency && tokenEfficiency.hasData) {
+      // Compare avg tokens for long vs short prompts from the prompt length analysis
+      const longBucket = tokenEfficiency.promptLengthAnalysis.find(b => b.label === '500+ chars');
+      const shortBucket = tokenEfficiency.promptLengthAnalysis.find(b => b.label === '20-100 chars');
+      if (longBucket && shortBucket && longBucket.avgCost && shortBucket.avgCost) {
+        const ratio = (longBucket.avgCost / shortBucket.avgCost).toFixed(1);
+        monologueCostNote = ` Long prompts cost ${ratio}x more per exchange ($${longBucket.avgCost.toFixed(2)} vs $${shortBucket.avgCost.toFixed(2)}).`;
+      }
+    }
     watchPoints.push({
       name: 'Monologue prompting',
-      detail: `Avg prompt length of ${d.avgPromptLength} chars is ${Math.round(d.avgPromptLength / BENCHMARKS.avgPromptLength)}x the benchmark. Breaking complex requests into 2-3 shorter prompts typically yields better AI output.`,
+      detail: `Avg prompt length of ${d.avgPromptLength} chars is ${Math.round(d.avgPromptLength / BENCHMARKS.avgPromptLength)}x the benchmark. Breaking complex requests into 2-3 shorter prompts typically yields better AI output.${monologueCostNote}`,
       evidence: bestLongPrompt,
     });
   }
 
   // Low context-setting
   if (ss.contextSetRatio < 20) {
+    let contextCostNote = '';
+    if (ss.tokenEvidence?.avgTokensPerExchangeWithContext && ss.tokenEvidence?.avgTokensPerExchangeNoContext) {
+      const pricing = tokenEfficiency && tokenEfficiency.hasData
+        ? tokenEfficiency.estimatedCostTotal / Math.max(1, tokenEfficiency.grandTotal) : 0;
+      if (pricing > 0) {
+        const withCtx = ss.tokenEvidence.avgTokensPerExchangeWithContext * pricing;
+        const noCtx = ss.tokenEvidence.avgTokensPerExchangeNoContext * pricing;
+        if (noCtx > withCtx * 1.1) {
+          contextCostNote = ` Sessions without context cost $${noCtx.toFixed(2)}/exchange vs $${withCtx.toFixed(2)} with context.`;
+        }
+      }
+    }
     watchPoints.push({
       name: 'Missing context',
-      detail: `Only ${ss.contextSetRatio}% of sessions start with context-setting (benchmark: ${BENCHMARKS.contextSetRatio}%). Upfront context leads to better first responses and fewer corrections.`,
+      detail: `Only ${ss.contextSetRatio}% of sessions start with context-setting (benchmark: ${BENCHMARKS.contextSetRatio}%). Upfront context leads to better first responses and fewer corrections.${contextCostNote}`,
       evidence: null,
     });
   }
 
   // Extended debug spirals
   if (db.longLoops > 2) {
-    const loopCostStr = db.tokenEvidence?.avgTokensLongLoop
-      ? ` Each spiral averages ${numberFormatInsight(db.tokenEvidence.avgTokensLongLoop)} tokens.`
-      : '';
+    let loopCostStr = '';
+    if (db.tokenEvidence?.avgTokensLongLoop) {
+      const pricing = tokenEfficiency && tokenEfficiency.hasData
+        ? tokenEfficiency.estimatedCostTotal / Math.max(1, tokenEfficiency.grandTotal) : 0;
+      if (pricing > 0) {
+        const costPerLoop = db.tokenEvidence.avgTokensLongLoop * pricing;
+        loopCostStr = ` Each spiral costs ~$${costPerLoop.toFixed(2)}.`;
+      } else {
+        loopCostStr = ` Each spiral averages ${numberFormatInsight(db.tokenEvidence.avgTokensLongLoop)} tokens.`;
+      }
+    }
     watchPoints.push({
       name: 'Debug spirals',
       detail: `${db.longLoops} extended debug loops (>5 turns) detected.${loopCostStr} When stuck, try providing more specific error context or breaking the problem differently.`,