@echomem/mcp 1.4.7 → 1.4.9

package/assets/canonical-scorer/build-session-waste-dashboard.mjs

@@ -0,0 +1,1628 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+
+const DEFAULT_SESSION_ID = "019f19e7-9e7a-72a3-86ad-bf7c6bcc6ab1";
+const DEFAULT_DATA_DIR = "ErikMachine-Context_Golden_Standard/data";
+const DEFAULT_REPORT_DIR = "ErikMachine-Context_Golden_Standard/reports";
+const DEFAULT_EFFICIENCY = path.join(DEFAULT_DATA_DIR, "OPTIMIZABLE_DETAIL_WebPageReactVersion_77t.json");
+const USEFUL_COLOR = "#3baa75";
+const UNATTRIBUTED_WASTE = {
+  id: "unattributed",
+  name: "Unlabeled outcome residue",
+  color: "#b7bdc8"
+};
+const PROBLEM_COLORS = {
+  P01: "#4c78a8",
+  P02: "#f58518",
+  P03: "#c06c2f",
+  P04: "#7b61b9",
+  P05: "#d45087",
+  P06: "#8c6d62",
+  P07: "#e45756",
+  P08: "#2cb1bc",
+  P09: "#72b01d",
+  P10: "#c17db4",
+  P11: "#f2c14e",
+  P12: "#00a878",
+  P13: "#5b6cff"
+};
+const PROBLEM_DEFINITIONS = {
+  P01: "Too many screenshots or images remain in context after they stop being the active reference.",
+  P02: "The model had a known user constraint or correction signal, but the work still violated it and required repair.",
+  P03: "Old file reads, duplicate file versions, or superseded patch drafts accumulate beside the current version.",
+  P04: "After compaction, the model has to rediscover files, searches, or git state that it had already found.",
+  P05: "The assistant treated work as done, but the user corrected it, so the next turn pays repair debt.",
+  P06: "After a time gap or state gap, the model's working view no longer matches the repo or task state.",
+  P07: "A long or aborted turn may leave file, process, or disk side effects that later turns must recover from.",
+  P08: "Git status, git diff, or related repo-state commands are repeated without adding enough new information.",
+  P09: "The execution path drifts and needs repeated correction, retry, validation, or reorientation.",
+  P10: "The model repeats the same search, query, or memory lookup instead of reusing prior knowledge.",
+  P11: "Browser/visual inspection outputs, DOM dumps, route checks, and viewport/debug metadata remain in context after serving visual QA.",
+  P12: "Tool, command, search, file-read, memory lookup, and orientation logs remain in context after they stop being operationally useful.",
+  P13: "Agent explanations, reconciliation notes, planning residue, and conversation/reasoning-adjacent text remain in context after they stop being operationally useful."
+};
+const DIRECT_PROBLEM_PRIORITY = ["P07", "P02", "P08", "P10", "P06", "P04", "P05", "P03", "P09", "P01"];
+const ADDITIONAL_PROBLEMS = [
+  { id: "P11", name: "Visual Debug Logs", category: "Context Hygiene" },
+  { id: "P12", name: "Tool Call Logs", category: "Context Hygiene" },
+  { id: "P13", name: "Agent's Reasoning Notes", category: "Context Hygiene" }
+];
+
+const args = parseArgs(process.argv.slice(2));
+const sessionId = args["session-id"] || args.session || args._[0] || DEFAULT_SESSION_ID;
+const problemPath = path.resolve(
+  args.problems || path.join(DEFAULT_DATA_DIR, `TEN_PROBLEM_ANALYSIS_${sessionId}.json`)
+);
+const efficiencyPath = path.resolve(args.efficiency || DEFAULT_EFFICIENCY);
+const outPath = path.resolve(
+  args.out || path.join(DEFAULT_DATA_DIR, `SESSION_WASTE_DASHBOARD_${sessionId}.json`)
+);
+const htmlPath = path.resolve(
+  args.html || path.join(DEFAULT_REPORT_DIR, `SESSION_WASTE_DASHBOARD_${sessionId}.html`)
+);
+
+const problemReport = readJson(problemPath);
+const efficiencyReport = readJson(efficiencyPath);
+const dashboard = buildDashboard({ sessionId, problemPath, efficiencyPath, problemReport, efficiencyReport });
+
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.writeFileSync(outPath, `${JSON.stringify(dashboard, null, 2)}\n`);
+if (process.env.GOLDEN_JSON_ONLY !== "1") {
+  fs.mkdirSync(path.dirname(htmlPath), { recursive: true });
+  fs.writeFileSync(htmlPath, renderHtml(dashboard));
+}
+
+console.log("Session waste dashboard complete");
+console.log(`  Session: ${sessionId}`);
+console.log(`  Total input: ${fmt(dashboard.totals.officialInputTokens)}`);
+console.log(`  Useful: ${fmt(dashboard.totals.usefulTokens)} (${pct(dashboard.totals.usefulSharePct)})`);
+console.log(`  Waste: ${fmt(dashboard.totals.wasteTokens)} (${pct(dashboard.totals.wasteSharePct)})`);
+console.log(`  Major contributor: ${dashboard.majorContributor.byAllocatedWaste.id} ${dashboard.majorContributor.byAllocatedWaste.name}`);
+console.log(`  JSON: ${outPath}`);
+if (process.env.GOLDEN_JSON_ONLY !== "1") console.log(`  HTML: ${htmlPath}`);
+
+function buildDashboard({ sessionId, problemPath, efficiencyPath, problemReport, efficiencyReport }) {
+  const efficiencyRows = efficiencyReport.series || [];
+  const turnMetaByNumber = new Map((problemReport.turns || []).map((turn) => [turn.number, turn]));
+  const allProblems = [...(problemReport.problems || []), ...ADDITIONAL_PROBLEMS];
+  const problemMetaById = new Map(allProblems.map((problem) => [problem.id, problem]));
+  const problemByTurn = new Map();
+
+  for (const problem of problemReport.problems || []) {
+    for (const turn of problem.qualifiedTurns || []) {
+      const list = problemByTurn.get(turn) || [];
+      list.push(problem.id);
+      problemByTurn.set(turn, list);
+    }
+  }
+
+  const contributions = allProblems.map((problem) => ({
+    id: problem.id,
+    name: problem.name,
+    category: problem.category,
+    definition: PROBLEM_DEFINITIONS[problem.id] || "",
+    color: PROBLEM_COLORS[problem.id] || "#475467",
+    eventsFound: problem.eventsFound,
+    evidenceTurns: problem.turns?.length || 0,
+    qualifiedTurns: problem.qualifiedTurns?.length || 0,
+    tokenPressure: problem.tokenPressure || 0,
+    qualifiedTokenPressure: problem.qualifiedTokenPressure || 0,
+    allocatedWasteTokens: 0,
+    allocatedWasteByBucket: {
+      duplicateTokens: 0,
+      refindTokens: 0,
+      deadTokens: 0
+    },
+    _turnWasteTokensByTurn: {},
+    worstTurnByAllocatedWaste: null,
+    worstTurnByQualifiedPressure: problem.worstTurn || null
+  }));
+  const contributionById = new Map(contributions.map((problem) => [problem.id, problem]));
+
+  let wasteCoveredByProblems = 0;
+  let unlabeledResidueTokens = 0;
+  let overheadUsefulTokens = 0;
+  const timeline = [];
+
+  for (const row of efficiencyRows) {
+    const turnMeta = turnMetaByNumber.get(row.turn) || {};
+    const turnProblems = problemByTurn.get(row.turn) || [];
+    const overheadTokens = row.keep_oh || 0;
+    const confidentlyUsefulTokens = row.keep_prod || 0;
+    const rawUsefulTokens = overheadTokens + confidentlyUsefulTokens;
+    const rawOutcomeWasteTokens = (row.opt_dup || 0) + (row.opt_refind || 0) + (row.opt_dead || 0);
+    const officialInputTokens = row.C_t || rawUsefulTokens + rawOutcomeWasteTokens;
+    const allocation = allocateTurnWaste({
+      row,
+      turnProblems,
+      wasteTokens: rawOutcomeWasteTokens,
+      problemMetaById,
+      problemByTurn
+    });
+    const labeledWasteTokens = allocation.coveredWasteTokens;
+    const usefulTokens = rawUsefulTokens;
+    const wasteTokens = rawOutcomeWasteTokens;
+    const classifiedInputTokens = confidentlyUsefulTokens + labeledWasteTokens;
+    const namedBuckets = sumLabeledBuckets(allocation.problemItems);
+
+    wasteCoveredByProblems += labeledWasteTokens;
+    unlabeledResidueTokens += allocation.unattributedWasteTokens;
+    overheadUsefulTokens += overheadTokens;
+
+    for (const item of allocation.problemItems) {
+      const contribution = contributionById.get(item.problemId);
+      if (!contribution) continue;
+      contribution.allocatedWasteTokens += item.tokens;
+      contribution.allocatedWasteByBucket.duplicateTokens += item.bucket === "opt_dup" ? item.tokens : 0;
+      contribution.allocatedWasteByBucket.refindTokens += item.bucket === "opt_refind" ? item.tokens : 0;
+      contribution.allocatedWasteByBucket.deadTokens += item.bucket === "opt_dead" ? item.tokens : 0;
+      const turnKey = String(row.turn);
+      const turnWaste = (contribution._turnWasteTokensByTurn[turnKey] || 0) + item.tokens;
+      contribution._turnWasteTokensByTurn[turnKey] = turnWaste;
+      if (!contribution.worstTurnByAllocatedWaste || turnWaste > contribution.worstTurnByAllocatedWaste.allocatedWasteTokens) {
+        contribution.worstTurnByAllocatedWaste = {
+          turn: row.turn,
+          episode: row.episode,
+          inputTokens: officialInputTokens,
+          usefulTokens,
+          wasteTokens,
+          usefulSharePct: officialInputTokens ? (usefulTokens / officialInputTokens) * 100 : 0,
+          wasteSharePct: officialInputTokens ? (wasteTokens / officialInputTokens) * 100 : 0,
+          allocatedWasteTokens: turnWaste,
+          allocationMethod: allocation.method,
+          assignmentBasis: item.assignmentBasis,
+          sourceTurn: item.sourceTurn ?? row.turn,
+          itemKind: item.kind,
+          itemReason: item.reason
+        };
+      }
+    }
+
+    if (allocation.method === "turn_equal_split") {
+      for (const problemId of turnProblems) {
+        const contribution = contributionById.get(problemId);
+        if (!contribution) continue;
+        const fallbackItem = allocation.problemItems.find((item) => item.problemId === problemId);
+        if (!fallbackItem) continue;
+        contribution.allocatedWasteByBucket.duplicateTokens += (row.opt_dup || 0) / turnProblems.length;
+        contribution.allocatedWasteByBucket.refindTokens += (row.opt_refind || 0) / turnProblems.length;
+        contribution.allocatedWasteByBucket.deadTokens += (row.opt_dead || 0) / turnProblems.length;
+      }
+    }
+
+    timeline.push({
+      turn: row.turn,
+      episode: row.episode,
+      inputTokens: officialInputTokens,
+      officialInputTokens,
+      classifiedInputTokens,
+      userMessage: turnMeta.messagePreview || "",
+      timestamp: turnMeta.timestamp || null,
+      usefulTokens,
+      wasteTokens,
+      usefulSharePct: officialInputTokens ? (usefulTokens / officialInputTokens) * 100 : 0,
+      wasteSharePct: officialInputTokens ? (wasteTokens / officialInputTokens) * 100 : 0,
+      duplicateTokens: Math.round(row.opt_dup || 0),
+      refindTokens: Math.round(row.opt_refind || 0),
+      deadTokens: Math.round(row.opt_dead || 0),
+      namedWasteTokens: labeledWasteTokens,
+      unlabeledResidueTokens: allocation.unattributedWasteTokens,
+      productUsefulTokens: confidentlyUsefulTokens,
+      overheadUsefulTokens: overheadTokens,
+      namedDuplicateTokens: namedBuckets.duplicateTokens,
+      namedRefindTokens: namedBuckets.refindTokens,
+      namedDeadTokens: namedBuckets.deadTokens,
+      rawUsefulTokens,
+      rawOutcomeWasteTokens,
+      problems: allocation.problemIds,
+      detectedProblems: turnProblems,
+      problemCount: allocation.problemIds.length,
+      detectedProblemCount: turnProblems.length,
+      allocationMethod: allocation.method,
+      unattributedWasteTokens: allocation.unattributedWasteTokens,
+      allocatedItems: compactTimelineItems(allocation.problemItems, row.turn),
+      baselineItems: compactTimelineItems(allocation.unattributedItems, row.turn),
+      segments: buildTimelineSegments({
+        exactTotal: officialInputTokens,
+        usefulTokens,
+        wasteTokens,
+        allocation,
+        problemMetaById
+      }),
+      compaction: Boolean(turnMeta.compaction),
+      abort: Boolean(turnMeta.abort),
+      rollback: Boolean(turnMeta.rollback),
+      commit: Boolean(row.commit),
+      anchorKind: row.anchorKind || null
+    });
+  }
+
+  const totals = sumDashboardTimeline(timeline);
+  const officialTotal = problemReport.totals?.officialInputTokens || totals.officialInputTokens;
+  const classifiedTotal = totals.classifiedInputTokens;
+  const tokenPressureTotal = sum(contributions, (problem) => problem.qualifiedTokenPressure);
+
+  for (const contribution of contributions) {
+    contribution.allocatedWasteTokens = Math.round(contribution.allocatedWasteTokens);
+    contribution.allocatedWasteByBucket = mapValues(contribution.allocatedWasteByBucket, Math.round);
+    contribution.allocatedWasteShareOfTotalPct = totals.wasteTokens
+      ? round((contribution.allocatedWasteTokens / totals.wasteTokens) * 100, 1)
+      : 0;
+    contribution.allocatedWasteShareOfCoveredPct = wasteCoveredByProblems
+      ? round((contribution.allocatedWasteTokens / wasteCoveredByProblems) * 100, 1)
+      : 0;
+    contribution.qualifiedPressureSharePct = tokenPressureTotal
+      ? round((contribution.qualifiedTokenPressure / tokenPressureTotal) * 100, 1)
+      : 0;
+    contribution.qualifiedPressureVsSessionPct = officialTotal
+      ? round((contribution.qualifiedTokenPressure / officialTotal) * 100, 1)
+      : 0;
+    if (contribution.worstTurnByAllocatedWaste) {
+      contribution.worstTurnByAllocatedWaste.allocatedWasteTokens = Math.round(
+        contribution.worstTurnByAllocatedWaste.allocatedWasteTokens
+      );
+    }
+    delete contribution._turnWasteTokensByTurn;
+  }
+
+  const sortedByAllocatedWaste = [...contributions].sort((a, b) => b.allocatedWasteTokens - a.allocatedWasteTokens);
+  const sortedByQualifiedPressure = [...contributions].sort((a, b) => b.qualifiedTokenPressure - a.qualifiedTokenPressure);
+  const episodeSummaries = buildEpisodeSummaries(timeline, problemReport.episodes || []);
+  const timelineTurnNumbers = new Set(timeline.map((turn) => turn.turn));
+  const keyDataPoints = buildKeyDataPoints({
+    problemReport,
+    timeline,
+    episodeSummaries,
+    totals,
+    sortedByAllocatedWaste
+  });
+
+  return {
+    schemaVersion: "0.1.0",
+    generatedAt: new Date().toISOString(),
+    session: {
+      id: sessionId,
+      sourceSession: problemReport.session,
+      efficiencySource: efficiencyReport.session,
+      turnsInEfficiency: efficiencyRows.length,
+      turnsInProblemReport: problemReport.session?.turns || null,
+      tokenCountedTurns: problemReport.session?.tokenCountedTurns || null,
+      zeroInputTurnsExcluded: (problemReport.turns || [])
+        .filter((turn) => !timelineTurnNumbers.has(turn.number))
+        .map((turn) => ({
+          turn: turn.number,
+          inputTokens: turn.inputTokens || 0,
+          abort: Boolean(turn.abort),
+          rollback: Boolean(turn.rollback),
+          messagePreview: turn.messagePreview || ""
+        }))
+    },
+    inputs: {
+      problemPath,
+      efficiencyPath
+    },
+    method: {
+      wasteDefinition: "The headline denominator is the full official JSONL input token count for each turn. Useful includes required overhead plus product/task payload content. Waste includes all OPTIMIZABLE_DETAIL duplicate, re-find, and dead-work residue; named P-problem waste is shown as a breakdown, and unassigned residue is shown as Unlabeled outcome residue.",
+      problemAttribution: "Waste is attributed at item level when OPTIMIZABLE_DETAIL provides wasteItems. Direct matching uses the current turn's qualified P-problems; correction/drift-style labels P02, P05, and P09 only claim current or immediately adjacent repair residue rather than all carried context. Image-bearing function/tool outputs can source-causally claim P01; carried git command residue can source-causally claim P08; carried search residue can source-causally claim P10. P04 is intentionally narrow: it only claims concrete read/search/git items on real post-compaction rediscovery turns or their immediate carry-forward, not generic self-talk/residual or long-lived residue. P11-P13 are broad fallback owners for otherwise-unclaimed visual probe spillover, tool/search/read/orientation logs, and conversation/reasoning/reconciliation residue, including same-turn residue. Equal turn-level splitting is used only as a legacy fallback when no item ledger is available. Remaining unlabeled outcome residue is counted as waste but not assigned to P01-P13.",
+      pressureDefinition: "Qualified pressure is the sum of official JSONL input_tokens on turns with probable or definitive evidence for a problem. It is shown as supporting evidence, not exact item-level waste."
+    },
+    totals: {
+      officialInputTokens: officialTotal,
+      analyzedInputTokens: officialTotal,
+      classifiedInputTokens: Math.round(classifiedTotal),
+      usefulTokens: totals.usefulTokens,
+      wasteTokens: totals.wasteTokens,
+      usefulSharePct: officialTotal ? round((totals.usefulTokens / officialTotal) * 100, 1) : 0,
+      wasteSharePct: officialTotal ? round((totals.wasteTokens / officialTotal) * 100, 1) : 0,
+      duplicateWasteTokens: totals.duplicateWasteTokens,
+      refindWasteTokens: totals.refindWasteTokens,
+      deadWasteTokens: totals.deadWasteTokens,
+      wasteCoveredByProblems: Math.round(wasteCoveredByProblems),
+      wasteCoveredByProblemsPct: totals.wasteTokens ? round((wasteCoveredByProblems / totals.wasteTokens) * 100, 1) : 0,
+      unattributedWasteTokens: Math.round(unlabeledResidueTokens),
+      unattributedWastePct: totals.wasteTokens ? round((unlabeledResidueTokens / totals.wasteTokens) * 100, 1) : 0,
+      unlabeledResidueTokens: Math.round(unlabeledResidueTokens),
+      unlabeledResiduePctOfInput: officialTotal ? round((unlabeledResidueTokens / officialTotal) * 100, 1) : 0,
+      overheadUsefulTokens: Math.round(overheadUsefulTokens),
+      overheadUsefulPctOfInput: officialTotal ? round((overheadUsefulTokens / officialTotal) * 100, 1) : 0,
+      excludedUnlabeledTokens: 0,
+      excludedUnlabeledPct: 0,
+      excludedOverheadTokens: 0,
+      excludedOverheadPct: 0,
+      grossQualifiedProblemPressure: tokenPressureTotal,
+      uniqueProblemTurnPressure: problemReport.totals?.uniqueProblemTurnTokenPressure || null
+    },
+    majorContributor: {
+      byAllocatedWaste: pickMajor(sortedByAllocatedWaste[0]),
+      byQualifiedPressure: pickMajor(sortedByQualifiedPressure[0]),
+      interpretation:
+        sortedByAllocatedWaste[0]?.id === sortedByQualifiedPressure[0]?.id
+          ? `${sortedByAllocatedWaste[0].id} is largest by both allocated waste and qualified token pressure.`
+          : `${sortedByAllocatedWaste[0]?.id} is largest by allocated waste, while ${sortedByQualifiedPressure[0]?.id} is largest by qualified token pressure.`
+    },
+    wasteBuckets: [
+      { id: "useful", label: "Useful + required overhead", tokens: totals.usefulTokens, sharePct: officialTotal ? round((totals.usefulTokens / officialTotal) * 100, 1) : 0 },
+      { id: "duplicate", label: "Duplicate waste", tokens: totals.duplicateWasteTokens, sharePct: officialTotal ? round((totals.duplicateWasteTokens / officialTotal) * 100, 1) : 0 },
+      { id: "refind", label: "Re-find waste", tokens: totals.refindWasteTokens, sharePct: officialTotal ? round((totals.refindWasteTokens / officialTotal) * 100, 1) : 0 },
+      { id: "dead", label: "Dead work waste", tokens: totals.deadWasteTokens, sharePct: officialTotal ? round((totals.deadWasteTokens / officialTotal) * 100, 1) : 0 }
+    ],
+    problemLegend: buildProblemLegend(allProblems),
+    problemContributions: sortedByAllocatedWaste,
+    episodeSummaries,
+    keyDataPoints,
+    topWasteTurns: [...timeline].sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 12),
+    topInputTurns: [...timeline].sort((a, b) => b.inputTokens - a.inputTokens).slice(0, 12),
+    timeline
+  };
+}
+
+function allocateTurnWaste({ row, turnProblems, wasteTokens, problemByTurn }) {
+  const rawItems = Array.isArray(row.wasteItems) ? row.wasteItems.filter((item) => Number(item.tokens || 0) > 0) : [];
+  if (!rawItems.length) return allocateTurnWasteFallback({ row, turnProblems, wasteTokens });
+
+  const problemSet = new Set(turnProblems);
+  const problemItems = [];
+  const unattributedItems = [];
+  let coveredWasteTokens = 0;
+  let attributedItemTokens = 0;
+  const rawItemTokens = sum(rawItems, (item) => Number(item.tokens || 0));
+  const scale = rawItemTokens > wasteTokens && rawItemTokens > 0 ? wasteTokens / rawItemTokens : 1;
+
+  for (const rawItem of rawItems) {
+    const tokens = Number(rawItem.tokens || 0) * scale;
+    if (!tokens) continue;
+    attributedItemTokens += tokens;
+    const item = {
+      ...rawItem,
+      tokens,
+      ...problemForWasteItem(rawItem, problemSet, problemByTurn, row.turn)
+    };
+    if (item.problemId) {
+      problemItems.push(item);
+      coveredWasteTokens += tokens;
+    } else {
+      unattributedItems.push(item);
+    }
+  }
+
+  const itemTokenGap = Math.max(0, wasteTokens - attributedItemTokens);
+  if (itemTokenGap > 0) {
+    unattributedItems.push({
+      sourceTurn: row.turn,
+      kind: "unrepresented",
+      bucket: "opt_refind",
+      tokens: itemTokenGap,
+      assignmentBasis: "baseline",
+      reason: "waste total not represented by concrete item ledger"
+    });
+  }
+
+  const groupedProblemItems = groupAllocatedItems(problemItems);
+  const groupedUnattributedItems = groupUnattributedItems(unattributedItems);
+
+  return {
+    method: "item_level",
+    coveredWasteTokens,
+    unattributedWasteTokens: Math.max(0, wasteTokens - coveredWasteTokens),
+    problemItems: groupedProblemItems,
+    unattributedItems: groupedUnattributedItems,
+    problemIds: [...new Set(groupedProblemItems.map((item) => item.problemId))]
+  };
+}
+
+function allocateTurnWasteFallback({ row, turnProblems, wasteTokens }) {
+  if (!turnProblems.length) {
+    return {
+      method: "unattributed",
+      coveredWasteTokens: 0,
+      unattributedWasteTokens: wasteTokens,
+      problemItems: [],
+      unattributedItems: wasteTokens > 0 ? [{
+        sourceTurn: row.turn,
+        kind: "turn_waste",
+        bucket: "mixed",
+        tokens: wasteTokens,
+        assignmentBasis: "baseline",
+        reason: "no qualified P-problem label detected on this turn"
+      }] : [],
+      problemIds: []
+    };
+  }
+
+  const perProblemWaste = wasteTokens / turnProblems.length;
+  return {
+    method: "turn_equal_split",
+    coveredWasteTokens: wasteTokens,
+    unattributedWasteTokens: 0,
+    problemItems: turnProblems.map((problemId) => ({
+      sourceTurn: row.turn,
+      kind: "turn_waste",
+      bucket: "mixed",
+      tokens: perProblemWaste,
+      problemId,
+      assignmentBasis: "turn-fallback",
+      reason: "legacy fallback: no item-level waste ledger available"
+    })),
+    unattributedItems: [],
+    problemIds: [...turnProblems]
+  };
+}
+
+function problemForWasteItem(item, problemSet, problemByTurn = new Map(), currentTurn = null) {
+  const kind = item.kind || "";
+  const sourceAssignable = kind === "read" || kind === "search" || kind === "command";
+  if (item.imageOutput && sourceAssignable) return { problemId: "P01", assignmentBasis: "image-output" };
+
+  for (const problemId of DIRECT_PROBLEM_PRIORITY) {
+    if (problemMatchesItem(problemId, item, problemSet, currentTurn)) return { problemId, assignmentBasis: "direct-item" };
+  }
+  const sourceTurn = item.sourceTurn ?? currentTurn;
+  const sourceProblemSet = new Set(problemByTurn.get(sourceTurn) || []);
+  const command = String(item.command || item.normalizedCommand || "");
+  const commandIsGit = /^git(?:\s|$)/.test(command.trim());
+  if (kind === "command" && commandIsGit && sourceProblemSet.has("P08")) return { problemId: "P08", assignmentBasis: "source-causal" };
+  if (kind === "search" && sourceProblemSet.has("P10")) return { problemId: "P10", assignmentBasis: "source-causal" };
+  if (isConcreteP04RediscoveryItem(item) && sourceProblemSet.has("P04") && sourceTurnAge(item, currentTurn) <= 1) {
+    return { problemId: "P04", assignmentBasis: "source-causal" };
+  }
+  const fallbackProblemId = fallbackProblemForBaselineItem(item, currentTurn);
+  if (fallbackProblemId) return { problemId: fallbackProblemId, assignmentBasis: "baseline-derived" };
+  return { problemId: null, assignmentBasis: "baseline" };
+}
+
+function problemMatchesItem(problemId, item, problemSet, currentTurn = null) {
+  const kind = item.kind || "";
+  const bucket = item.bucket || "";
+  const command = String(item.command || item.normalizedCommand || "");
+  const commandIsGit = /^git(?:\s|$)/.test(command.trim());
+  const commandIsRun = /^(npm|pnpm|yarn|node|npx|pytest|cargo|go)(?:\s|$)/.test(command.trim());
+  const isRediscovery = kind === "read" || kind === "search" || kind === "command" || kind === "residual" || kind === "conv_agent";
+  const isRepairLocal = sourceTurnAge(item, currentTurn) <= 1;
+
+  if (problemId === "P07") return problemSet.has("P07") && isRediscovery;
+  if (problemId === "P02") return problemSet.has("P02") && isRediscovery && isRepairLocal;
+  if (problemId === "P08") return kind === "command" && commandIsGit && problemSet.has("P08");
+  if (problemId === "P10") return kind === "search" && problemSet.has("P10");
+  if (problemId === "P06") return problemSet.has("P06") && isRediscovery;
+  if (problemId === "P04") return problemSet.has("P04") && isConcreteP04RediscoveryItem(item) && sourceTurnAge(item, currentTurn) <= 1;
+  if (problemId === "P05") return problemSet.has("P05") && isRediscovery && isRepairLocal;
+  if (problemId === "P03") return (kind === "read" && bucket === "opt_dup") || (kind === "written" && bucket === "opt_dup");
+  if (problemId === "P09") return problemSet.has("P09") && (commandIsRun || isRediscovery) && isRepairLocal;
+  if (problemId === "P01") return kind === "image" && bucket === "opt_dead";
+  return false;
+}
+
+function isConcreteP04RediscoveryItem(item) {
+  const kind = item.kind || "";
+  if (kind === "read" || kind === "search") return true;
+  if (kind !== "command") return false;
+  const command = String(item.command || item.normalizedCommand || "").trim();
+  return /^git(?:\s|$)/.test(command);
+}
+
+function sourceTurnAge(item, currentTurn = null) {
+  if (currentTurn == null) return 0;
+  const sourceTurn = item.sourceTurn ?? currentTurn;
+  return Math.max(0, currentTurn - sourceTurn);
+}
+
+function fallbackProblemForBaselineItem(item, currentTurn = null) {
+  const kind = item.kind || "";
+  const bucket = item.bucket || "";
+  const command = String(item.command || item.normalizedCommand || "");
+  if (isVisualProbeCommand(command)) return "P11";
+  if (kind === "command" || kind === "search" || kind === "read" && bucket === "opt_dead" || isOrientationCommand(command)) return "P12";
+  if (kind === "reasoning" || kind === "residual" || kind === "conv_agent" || kind === "conv_user" || kind === "unrepresented") return "P13";
+  return null;
+}
+
+function isVisualProbeCommand(command) {
+  const normalized = command.trim();
+  return normalized === "js"
+    || /^curl\s+-I\s+https?:\/\/(?:127\.0\.0\.1|localhost|\[?::1\]?)(?::|\b|\/)/.test(normalized);
+}
+
+function isOrientationCommand(command) {
+  const normalized = command.trim();
+  return normalized === "search_memories"
+    || normalized === "search_memories_by_keywords"
+    || /^git(?:\s|$)/.test(normalized)
+    || /^ls(?:\s|$)/.test(normalized);
+}
+
+function groupAllocatedItems(items) {
+  const groups = new Map();
+  for (const item of items) {
+    const key = [
+      item.problemId,
+      item.sourceTurn || "",
+      item.assignmentBasis || "",
+      item.bucket,
+      item.kind,
+      item.file || "",
+      item.normalizedCommand || item.command || "",
+      item.reason || ""
+    ].join("\u0000");
+    const group = groups.get(key) || {
+      problemId: item.problemId,
+      sourceTurn: item.sourceTurn,
+      assignmentBasis: item.assignmentBasis,
+      bucket: item.bucket,
+      kind: item.kind,
+      file: item.file,
+      command: item.normalizedCommand || item.command,
+      reason: item.reason,
+      tokens: 0,
+      count: 0
+    };
+    group.tokens += item.tokens;
+    group.count += 1;
+    groups.set(key, group);
+  }
+  return [...groups.values()];
+}
+
+function compactTimelineItems(items, turn) {
+  return items.map((item) => ({
+    turn,
+    sourceTurn: item.sourceTurn ?? turn,
+    assignmentBasis: item.assignmentBasis || "baseline",
+    problemId: item.problemId || null,
+    bucket: item.bucket || null,
+    kind: item.kind || null,
+    tokens: Math.round(item.tokens || 0),
+    count: item.count || 1,
+    file: item.file || null,
+    command: item.command || null,
+    reason: item.reason || ""
+  }));
+}
+
+function groupUnattributedItems(items) {
+  const groups = new Map();
+  for (const item of items) {
+    const key = [item.sourceTurn || "", item.assignmentBasis || "", item.bucket, item.kind, item.file || "", item.reason || ""].join("\u0000");
+    const group = groups.get(key) || {
+      sourceTurn: item.sourceTurn,
+      assignmentBasis: item.assignmentBasis || "baseline",
+      bucket: item.bucket,
+      kind: item.kind,
+      file: item.file,
+      reason: item.reason,
+      tokens: 0,
+      count: 0
+    };
+    group.tokens += item.tokens;
+    group.count += 1;
+    groups.set(key, group);
+  }
+  return [...groups.values()];
+}
+
+function sumEfficiency(rows) {
+  const duplicateWasteTokens = sum(rows, (row) => row.opt_dup || 0);
+  const refindWasteTokens = sum(rows, (row) => row.opt_refind || 0);
+  const deadWasteTokens = sum(rows, (row) => row.opt_dead || 0);
+  const usefulTokens = sum(rows, (row) => (row.keep_oh || 0) + (row.keep_prod || 0));
+  return {
+    officialInputTokens: sum(rows, (row) => row.C_t || 0),
+    usefulTokens,
+    wasteTokens: duplicateWasteTokens + refindWasteTokens + deadWasteTokens,
+    duplicateWasteTokens,
+    refindWasteTokens,
+    deadWasteTokens
+  };
+}
+
+function sumLabeledBuckets(items) {
+  return {
+    duplicateTokens: Math.round(sum(items, (item) => item.bucket === "opt_dup" ? item.tokens || 0 : 0)),
+    refindTokens: Math.round(sum(items, (item) => item.bucket === "opt_refind" ? item.tokens || 0 : 0)),
+    deadTokens: Math.round(sum(items, (item) => item.bucket === "opt_dead" ? item.tokens || 0 : 0))
+  };
+}
+
+function sumDashboardTimeline(timeline) {
+  return {
+    officialInputTokens: sum(timeline, (turn) => turn.officialInputTokens || 0),
+    analyzedInputTokens: sum(timeline, (turn) => turn.inputTokens || 0),
+    classifiedInputTokens: sum(timeline, (turn) => turn.classifiedInputTokens || 0),
+    usefulTokens: sum(timeline, (turn) => turn.usefulTokens || 0),
+    wasteTokens: sum(timeline, (turn) => turn.wasteTokens || 0),
+    duplicateWasteTokens: sum(timeline, (turn) => turn.duplicateTokens || 0),
+    refindWasteTokens: sum(timeline, (turn) => turn.refindTokens || 0),
+    deadWasteTokens: sum(timeline, (turn) => turn.deadTokens || 0)
+  };
+}
+
+function buildTimelineSegments({ exactTotal, usefulTokens, wasteTokens, allocation, problemMetaById }) {
+  const segments = [];
+  if (usefulTokens > 0) {
+    segments.push({
+      id: "useful",
+      type: "useful",
+      label: "Useful content",
+      tokens: usefulTokens,
+      sharePct: exactTotal ? (usefulTokens / exactTotal) * 100 : 0,
+      color: USEFUL_COLOR
+    });
+  }
+
+  if (wasteTokens <= 0) return segments;
+
+  const problemTotals = new Map();
+  for (const item of allocation.problemItems) {
+    problemTotals.set(item.problemId, (problemTotals.get(item.problemId) || 0) + item.tokens);
+  }
+  for (const [problemId, tokens] of problemTotals) {
+    const problem = problemMetaById.get(problemId);
+    segments.push({
+      id: problemId,
+      type: "waste",
+      label: problem?.name || problemId,
+      tokens,
+      sharePct: exactTotal ? (tokens / exactTotal) * 100 : 0,
+      color: PROBLEM_COLORS[problemId] || "#475467"
+    });
+  }
+  if (allocation.unattributedWasteTokens > 0) {
+    segments.push({
+      id: UNATTRIBUTED_WASTE.id,
+      type: "waste",
+      label: UNATTRIBUTED_WASTE.name,
+      tokens: allocation.unattributedWasteTokens,
+      sharePct: exactTotal ? (allocation.unattributedWasteTokens / exactTotal) * 100 : 0,
+      color: UNATTRIBUTED_WASTE.color
+    });
+  }
+  return segments;
+}
+
+function buildProblemLegend(problems) {
+  return [
+    {
+      id: "useful",
+      name: "Useful + required overhead",
+      definition: "Required overhead plus product/task payload content retained as useful.",
+      color: USEFUL_COLOR,
+      type: "useful"
+    },
+    ...problems.map((problem) => ({
+      id: problem.id,
+      name: problem.name,
+      category: problem.category,
+      definition: PROBLEM_DEFINITIONS[problem.id] || "",
+      color: PROBLEM_COLORS[problem.id] || "#475467",
+      type: "problem"
+    })),
+    {
+      id: UNATTRIBUTED_WASTE.id,
+      name: UNATTRIBUTED_WASTE.name,
+      definition: "Outcome residue that did not receive a named P-problem label. It is counted as waste, but not attributed to P01-P13.",
+      color: UNATTRIBUTED_WASTE.color,
+      type: "problem"
+    }
+  ];
+}
+
+function buildEpisodeSummaries(timeline, episodes) {
+  const labelsByNumber = new Map((episodes || []).map((episode, index) => [index + 1, episode.label || `Episode ${index + 1}`]));
+  const groups = new Map();
+  for (const turn of timeline) {
+    const group = groups.get(turn.episode) || {
+      episode: turn.episode,
+      label: labelsByNumber.get(turn.episode) || `Episode ${turn.episode}`,
+      turns: 0,
+      inputTokens: 0,
+      usefulTokens: 0,
+      wasteTokens: 0,
+      duplicateTokens: 0,
+      refindTokens: 0,
+      deadTokens: 0,
+      problemTurnCount: 0
+    };
+    group.turns += 1;
+    group.inputTokens += turn.inputTokens;
+    group.usefulTokens += turn.usefulTokens;
+    group.wasteTokens += turn.wasteTokens;
+    group.duplicateTokens += turn.duplicateTokens;
+    group.refindTokens += turn.refindTokens;
+    group.deadTokens += turn.deadTokens;
+    if (turn.problemCount) group.problemTurnCount += 1;
+    groups.set(turn.episode, group);
+  }
+
+  return [...groups.values()].map((episode) => ({
+    ...episode,
+    usefulSharePct: round((episode.usefulTokens / episode.inputTokens) * 100, 1),
+    wasteSharePct: round((episode.wasteTokens / episode.inputTokens) * 100, 1)
+  }));
+}
+
+function buildKeyDataPoints({ problemReport, timeline, episodeSummaries, totals, sortedByAllocatedWaste }) {
+  const peakInputTurn = maxBy(timeline, (turn) => turn.inputTokens);
+  const peakWasteTurn = maxBy(timeline, (turn) => turn.wasteTokens);
+  const bestUsefulTurn = maxBy(timeline, (turn) => turn.usefulSharePct);
+  const worstWasteShareTurn = maxBy(timeline, (turn) => turn.wasteSharePct);
+  const worstEpisode = maxBy(episodeSummaries, (episode) => episode.wasteTokens);
+  const largestBucket = maxBy(
+    [
+      { label: "duplicate", tokens: totals.duplicateWasteTokens },
+      { label: "re-find", tokens: totals.refindWasteTokens },
+      { label: "dead work", tokens: totals.deadWasteTokens }
+    ],
+    (bucket) => bucket.tokens
+  );
+
+  return {
+    turns: problemReport.session?.turns || timeline.length,
+    tokenCountedTurns: problemReport.session?.tokenCountedTurns || timeline.length,
+    compactions: problemReport.session?.compactions || 0,
+    aborts: problemReport.session?.aborts || 0,
+    rollbacks: problemReport.session?.rollbacks || 0,
+    turnsWithAnyProblem: problemReport.totals?.turnsWithAnyProblem || 0,
+    qualifiedProblemTurnsInTimeline: timeline.filter((turn) => turn.problemCount > 0).length,
+    peakInputTurn,
+    peakWasteTurn,
+    bestUsefulTurn,
+    worstWasteShareTurn,
+    worstEpisode,
+    largestWasteBucket: largestBucket,
+    topProblems: sortedByAllocatedWaste.slice(0, 3).map(pickMajor)
+  };
+}
+
+function renderHtml(report) {
+  const topContribution = report.problemContributions[0];
+  const topPressure = [...report.problemContributions].sort((a, b) => b.qualifiedTokenPressure - a.qualifiedTokenPressure)[0];
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Session Waste Dashboard ${escapeHtml(report.session.id)}</title>
+  <style>
+    :root {
+      --bg: #f7f4ee;
+      --ink: #18202d;
+      --muted: #667085;
+      --line: #ded7cb;
+      --panel: #fffdf8;
+      --teal: #15837a;
+      --green: #3f8f62;
+      --amber: #cc8a1e;
+      --rose: #c24a4a;
+      --blue: #315ea8;
+      --violet: #7c5eb8;
+      --shadow: 0 18px 48px rgba(45, 36, 20, 0.12);
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background: var(--bg);
+      color: var(--ink);
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      line-height: 1.45;
+    }
+    main { max-width: 1420px; margin: 0 auto; padding: 28px; }
+    h1, h2, h3, p { margin: 0; }
+    h1 { font-size: clamp(28px, 4vw, 54px); line-height: 1; letter-spacing: 0; }
+    h2 { font-size: 18px; letter-spacing: 0.08em; text-transform: uppercase; }
+    h3 { font-size: 16px; }
+    .hero {
+      display: grid;
+      grid-template-columns: 1.25fr 0.75fr;
+      gap: 22px;
+      align-items: stretch;
+      margin-bottom: 22px;
+    }
+    .panel {
+      background: var(--panel);
+      border: 1px solid var(--line);
+      box-shadow: var(--shadow);
+      border-radius: 8px;
+    }
+    .hero-copy { padding: 26px; }
+    .eyebrow { color: var(--teal); font-weight: 800; text-transform: uppercase; letter-spacing: 0.12em; font-size: 13px; }
+    .subtitle { color: var(--muted); max-width: 820px; margin-top: 14px; font-size: 17px; }
+    .method-note { margin-top: 18px; padding: 12px 14px; border-left: 4px solid var(--amber); background: #fff5df; color: #594019; border-radius: 4px; }
+    .donut-wrap { display: grid; place-items: center; padding: 26px; }
+    .donut {
+      width: min(320px, 72vw);
+      aspect-ratio: 1;
+      border-radius: 50%;
+      background:
+        radial-gradient(circle at center, var(--panel) 0 55%, transparent 56%),
+        conic-gradient(var(--rose) 0 ${report.totals.wasteSharePct}%, var(--green) ${report.totals.wasteSharePct}% 100%);
+      display: grid;
+      place-items: center;
+      border: 1px solid var(--line);
+    }
+    .donut strong { display: block; font-size: 46px; line-height: 1; }
+    .donut span { color: var(--muted); font-weight: 700; text-transform: uppercase; font-size: 12px; letter-spacing: 0.08em; }
+    .cards { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: 12px; margin-bottom: 22px; }
+    .card { padding: 16px; background: var(--panel); border: 1px solid var(--line); border-radius: 8px; min-height: 112px; }
+    .card .label { color: var(--muted); font-size: 12px; font-weight: 800; text-transform: uppercase; letter-spacing: 0.08em; }
+    .card .value { font-size: clamp(22px, 3vw, 34px); line-height: 1.05; font-weight: 850; margin-top: 10px; }
+    .card .sub { color: var(--muted); margin-top: 8px; font-size: 13px; }
+    .grid-2 { display: grid; grid-template-columns: minmax(0, 1.08fr) minmax(0, 0.92fr); gap: 18px; margin-bottom: 22px; }
+    .section { padding: 20px; }
+    .section-head { display: flex; justify-content: space-between; gap: 16px; align-items: end; margin-bottom: 16px; }
+    .small-note { color: var(--muted); font-size: 13px; max-width: 680px; }
+    .stack { display: flex; height: 36px; overflow: hidden; border-radius: 6px; border: 1px solid var(--line); background: #eee7dc; }
+    .stack span { display: block; min-width: 1px; }
+    .legend { display: flex; flex-wrap: wrap; gap: 10px 16px; margin-top: 12px; color: var(--muted); font-size: 13px; }
+    .legend i {
+      display: inline-block;
+      width: 12px;
+      height: 12px;
+      border-radius: 3px;
+      margin-right: 6px;
+      vertical-align: -2px;
+      box-shadow: inset 0 0 0 1px rgba(17, 24, 39, 0.18);
+    }
+    .bar-list { display: grid; gap: 12px; }
+    .problem-row {
+      display: grid;
+      grid-template-columns: 86px minmax(180px, 1fr) 170px;
+      gap: 12px;
+      align-items: center;
+      padding: 12px 0 12px 10px;
+      border-top: 1px solid #ebe4d9;
+      border-left: 5px solid var(--problem-color, var(--teal));
+    }
+    .problem-row:first-child { border-top: 0; }
+    .problem-id { font-weight: 900; color: var(--teal); }
+    .problem-name { font-weight: 800; }
+    .problem-meta { color: var(--muted); font-size: 13px; margin-top: 4px; }
+    .problem-definition { color: #475467; font-size: 13px; margin-top: 5px; max-width: 780px; }
+    .bar-bg { height: 14px; background: #ebe4d9; border-radius: 999px; overflow: hidden; margin-top: 8px; }
+    .bar-fill { height: 100%; background: var(--problem-color, var(--teal)); border-radius: inherit; }
+    .number { font-variant-numeric: tabular-nums; text-align: right; font-weight: 850; }
+    .definition-grid {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 12px;
+    }
+    .definition-item {
+      display: grid;
+      grid-template-columns: 42px minmax(0, 1fr);
+      gap: 10px;
+      padding: 12px;
+      border: 1px solid #ebe4d9;
+      border-left: 5px solid var(--problem-color, var(--teal));
+      border-radius: 8px;
+      background: rgba(255, 253, 248, 0.72);
+    }
+    .definition-item strong {
+      display: block;
+      font-size: 13px;
+      line-height: 1.2;
+    }
+    .definition-item p {
+      margin-top: 4px;
+      color: var(--muted);
+      font-size: 13px;
+      line-height: 1.35;
+    }
+    .timeline {
+      display: grid;
+      grid-template-columns: repeat(${Math.max(1, report.timeline.length)}, minmax(7px, 1fr));
+      gap: 3px;
+      align-items: end;
+      min-width: 920px;
+      min-height: 178px;
+      padding-top: 132px;
+      border-bottom: 1px solid var(--line);
+    }
+    .timeline-frame {
+      overflow: visible;
+      padding-bottom: 2px;
+    }
+    .episode-ruler {
+      display: grid;
+      grid-template-columns: repeat(${Math.max(1, report.timeline.length)}, minmax(7px, 1fr));
+      gap: 3px;
+      min-width: 920px;
+      margin: 2px 0 -58px;
+      padding-top: 8px;
+      position: relative;
+      z-index: 20;
+    }
+    .episode-band {
+      min-width: 0;
+      position: relative;
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      min-height: 36px;
+      border: 1px solid rgba(21, 131, 122, 0.2);
+      border-bottom: 3px solid var(--teal);
+      border-radius: 8px 8px 4px 4px;
+      background: linear-gradient(180deg, rgba(21, 131, 122, 0.13), rgba(255, 253, 248, 0.94));
+      padding: 5px 8px;
+      color: #144d48;
+      overflow: visible;
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.78);
+      transition: transform 120ms ease, box-shadow 120ms ease, border-color 120ms ease;
+    }
+    .episode-band:nth-child(even) {
+      border-bottom-color: var(--amber);
+      border-color: rgba(204, 138, 30, 0.24);
+      background: linear-gradient(180deg, rgba(204, 138, 30, 0.12), rgba(255, 253, 248, 0.9));
+      color: #5d4218;
+    }
+    .episode-band:hover,
+    .episode-band:focus {
+      z-index: 70;
+      transform: translateY(-1px);
+      border-color: rgba(17, 24, 39, 0.28);
+      box-shadow: 0 10px 24px rgba(24, 32, 45, 0.16), inset 0 1px 0 rgba(255, 255, 255, 0.84);
+      outline: none;
+    }
+    .episode-badge {
+      display: inline-grid;
+      place-items: center;
+      flex: 0 0 auto;
+      min-width: 25px;
+      height: 22px;
+      padding: 0 6px;
+      border-radius: 999px;
+      background: rgba(21, 131, 122, 0.13);
+      color: #115a54;
+      font-size: 11px;
+      font-weight: 900;
+      line-height: 1;
+    }
+    .episode-band:nth-child(even) .episode-badge {
+      background: rgba(204, 138, 30, 0.16);
+      color: #714b10;
+    }
+    .episode-label {
+      min-width: 0;
+      display: grid;
+      gap: 1px;
+    }
+    .episode-label strong {
+      display: block;
+      font-size: 12px;
+      line-height: 1.1;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .episode-label > span {
+      display: block;
+      margin-top: 3px;
+      color: var(--muted);
+      font-size: 11px;
+      line-height: 1.1;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .episode-band.narrow {
+      justify-content: center;
+      padding: 5px 3px;
+    }
+    .episode-band.narrow .episode-label {
+      display: none;
+    }
+    .episode-tip {
+      position: absolute;
+      left: 50%;
+      top: calc(100% + 8px);
+      z-index: 90;
+      width: 360px;
+      padding: 10px 12px;
+      border-radius: 8px;
+      background: #111827;
+      color: #f9fafb;
+      border: 1px solid rgba(255, 255, 255, 0.12);
+      box-shadow: 0 18px 40px rgba(17, 24, 39, 0.26);
+      transform: translateX(-50%) translateY(-4px);
+      opacity: 0;
+      pointer-events: none;
+      transition: opacity 120ms ease, transform 120ms ease;
+    }
+    .episode-band:hover .episode-tip,
+    .episode-band:focus .episode-tip {
+      opacity: 1;
+      transform: translateX(-50%) translateY(0);
+    }
+    .episode-band:first-child .episode-tip {
+      left: 0;
+      transform: translateX(0) translateY(-4px);
+    }
+    .episode-band:first-child:hover .episode-tip,
+    .episode-band:first-child:focus .episode-tip {
+      transform: translateX(0) translateY(0);
+    }
+    .episode-band:last-child .episode-tip {
+      left: auto;
+      right: 0;
+      transform: translateX(0) translateY(-4px);
+    }
+    .episode-band:last-child:hover .episode-tip,
+    .episode-band:last-child:focus .episode-tip {
+      transform: translateX(0) translateY(0);
+    }
+    .episode-tip-title {
+      display: flex;
+      justify-content: space-between;
+      gap: 10px;
+      margin-bottom: 7px;
+      font-weight: 850;
+    }
+    .episode-tip-grid {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 6px 12px;
+      font-size: 12px;
+    }
+    .episode-tip-grid span {
+      display: block;
+    }
+    .episode-tip-grid strong {
+      display: block;
+      margin-top: 1px;
+      color: #f9fafb;
+      font-size: 12px;
+      line-height: 1.1;
+    }
+    .episode-tip-muted {
+      color: #cbd5e1;
+    }
+    .turn-bar {
+      min-height: 5px;
+      border-radius: 3px 3px 0 0;
+      outline: 1px solid rgba(24, 32, 45, 0.08);
+      position: relative;
+      display: flex;
+      flex-direction: column-reverse;
+      overflow: visible;
+      background: #ebe4d9;
+    }
+    .turn-bar.has-problem { box-shadow: inset 0 0 0 2px rgba(21, 131, 122, 0.35); }
+    .turn-bar.compaction::after {
+      content: "";
+      position: absolute;
+      top: -8px;
+      left: 50%;
+      width: 5px;
+      height: 5px;
+      border-radius: 50%;
+      background: var(--blue);
+      transform: translateX(-50%);
+    }
+    .turn-segment {
+      width: 100%;
+      min-height: 1px;
+      opacity: 0.98;
+      box-shadow: inset 0 -1px 0 rgba(17, 24, 39, 0.12);
+    }
+    .turn-segment:first-child { border-radius: 0 0 3px 3px; }
+    .turn-segment:last-child { border-radius: 3px 3px 0 0; }
+    .turn-tooltip {
+      position: absolute;
+      left: 50%;
+      bottom: calc(100% + 12px);
+      z-index: 180;
+      width: min(330px, 82vw);
+      padding: 10px 12px;
+      background: #141c2b;
+      color: #f9fafb;
+      border: 1px solid rgba(255, 255, 255, 0.12);
+      border-radius: 7px;
+      box-shadow: 0 14px 34px rgba(17, 24, 39, 0.25);
+      transform: translateX(-50%) translateY(6px);
+      opacity: 0;
+      pointer-events: none;
+      transition: opacity 120ms ease, transform 120ms ease;
+    }
+    .turn-bar:hover,
+    .turn-bar:focus {
+      z-index: 160;
+      outline: 2px solid rgba(17, 24, 39, 0.32);
+      filter: saturate(1.08);
+    }
+    .turn-bar:hover .turn-tooltip,
+    .turn-bar:focus .turn-tooltip {
+      opacity: 1;
+      transform: translateX(-50%) translateY(0);
+    }
+    .turn-bar:nth-child(-n + 8) .turn-tooltip {
+      left: 0;
+      transform: translateX(0) translateY(4px);
+    }
+    .turn-bar:nth-child(-n + 8):hover .turn-tooltip,
+    .turn-bar:nth-child(-n + 8):focus .turn-tooltip {
+      transform: translateX(0) translateY(0);
+    }
+    .turn-bar:nth-child(n + ${Math.max(1, report.timeline.length - 7)}) .turn-tooltip {
+      left: auto;
+      right: 0;
+      transform: translateX(0) translateY(4px);
+    }
+    .turn-bar:nth-child(n + ${Math.max(1, report.timeline.length - 7)}):hover .turn-tooltip,
+    .turn-bar:nth-child(n + ${Math.max(1, report.timeline.length - 7)}):focus .turn-tooltip {
+      transform: translateX(0) translateY(0);
+    }
+    .tip-title {
+      display: flex;
+      justify-content: space-between;
+      gap: 12px;
+      font-weight: 850;
+      margin-bottom: 7px;
+      font-size: 12px;
+    }
+    .tip-muted { color: #cbd5e1; font-size: 11px; }
+    .tip-message {
+      margin: 0 0 8px;
+      padding: 7px 8px;
+      border-radius: 5px;
+      background: rgba(255, 255, 255, 0.08);
+      color: #e5e7eb;
+      font-size: 11px;
+      line-height: 1.35;
+    }
+    .tip-message strong {
+      color: #f9fafb;
+      font-weight: 850;
+    }
+    .tip-grid {
+      display: grid;
+      grid-template-columns: 1fr auto;
+      gap: 2px 10px;
+      font-size: 11px;
+      margin-bottom: 7px;
+    }
+    .tip-breakdown {
+      display: grid;
+      gap: 4px;
+      padding-top: 7px;
+      border-top: 1px solid rgba(255, 255, 255, 0.14);
+      font-size: 11px;
+    }
+    .tip-line {
+      display: grid;
+      grid-template-columns: 9px minmax(0, 1fr) auto;
+      gap: 6px;
+      align-items: center;
+    }
+    .tip-swatch {
+      width: 9px;
+      height: 9px;
+      border-radius: 2px;
+    }
+    .timeline-legend {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px 12px;
+      margin-top: 14px;
+    }
+    .legend-chip {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      min-height: 26px;
+      padding: 3px 8px;
+      border: 1px solid var(--line);
+      border-radius: 999px;
+      background: rgba(255, 253, 248, 0.7);
+      color: #334155;
+      font-size: 12px;
+      font-weight: 750;
+    }
+    .legend-chip i {
+      width: 13px;
+      height: 13px;
+      border-radius: 3px;
+      box-shadow: inset 0 0 0 1px rgba(17, 24, 39, 0.18);
+    }
+    table { width: 100%; border-collapse: collapse; font-size: 14px; }
+    th {
+      text-align: left;
+      color: var(--muted);
+      font-size: 12px;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      padding: 10px 8px;
+      border-bottom: 1px solid var(--line);
+    }
+    td { padding: 11px 8px; border-bottom: 1px solid #ebe4d9; vertical-align: top; }
+    td.num, th.num { text-align: right; font-variant-numeric: tabular-nums; }
+    .pill {
+      display: inline-flex;
+      align-items: center;
+      min-height: 24px;
+      padding: 2px 8px;
+      border-radius: 999px;
+      background: #e8f3ef;
+      color: #0d6b63;
+      font-size: 12px;
+      font-weight: 850;
+      margin: 0 4px 4px 0;
+      white-space: nowrap;
+    }
+    .callout {
+      border-left: 5px solid var(--teal);
+      background: #ecf7f5;
+      padding: 14px 16px;
+      border-radius: 6px;
+      color: #134b48;
+      margin-top: 16px;
+    }
+    @media (max-width: 1000px) {
+      main { padding: 18px; }
+      .hero, .grid-2 { grid-template-columns: 1fr; }
+      .cards { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+      .problem-row { grid-template-columns: 56px minmax(0, 1fr); }
+      .problem-row .number { grid-column: 1 / -1; text-align: left; }
+      .definition-grid { grid-template-columns: 1fr; }
+      .timeline, .episode-ruler { grid-template-columns: repeat(${Math.max(1, report.timeline.length)}, minmax(6px, 1fr)); min-width: 920px; }
+      .turn-tooltip {
+        position: fixed;
+        left: 18px !important;
+        right: 18px !important;
+        top: 72px;
+        bottom: auto;
+        width: auto;
+        transform: translateY(4px);
+      }
+      .turn-bar:hover .turn-tooltip,
+      .turn-bar:focus .turn-tooltip,
+      .turn-bar:nth-child(-n + 8):hover .turn-tooltip,
+      .turn-bar:nth-child(-n + 8):focus .turn-tooltip,
+      .turn-bar:nth-child(n + ${Math.max(1, report.timeline.length - 7)}):hover .turn-tooltip,
+      .turn-bar:nth-child(n + ${Math.max(1, report.timeline.length - 7)}):focus .turn-tooltip {
+        transform: translateY(0);
+      }
+    }
+  </style>
+</head>
+<body>
+<main>
+  <section class="hero">
+    <div class="panel hero-copy">
+      <p class="eyebrow">Session waste dashboard</p>
+      <h1>10-problem waste contribution</h1>
+      <p class="subtitle">This joins the finalized efficiency buckets with the JSONL-first 10-problem detector for session <strong>${escapeHtml(report.session.id)}</strong>.</p>
+      <div class="method-note">${escapeHtml(report.method.problemAttribution)}</div>
+    </div>
+    <div class="panel donut-wrap">
+      <div class="donut" aria-label="Waste share donut">
+        <div>
+          <strong>${pct(report.totals.wasteSharePct)}</strong>
+          <span>waste</span>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <section class="cards">
+    ${metricCard("Total input", fmt(report.totals.officialInputTokens), "Official JSONL input tokens")}
+    ${metricCard("Waste", fmt(report.totals.wasteTokens), `${pct(report.totals.wasteSharePct)} of total input`)}
+    ${metricCard("Useful", fmt(report.totals.usefulTokens), `${pct(report.totals.usefulSharePct)} of total input`)}
+    ${metricCard("Named P-problem waste", fmt(report.totals.wasteCoveredByProblems), `${pct(report.totals.wasteCoveredByProblemsPct)} of waste`)}
+    ${metricCard("Unlabeled residue", fmt(report.totals.unlabeledResidueTokens), `${pct(report.totals.unlabeledResiduePctOfInput)} of input`)}
+    ${metricCard("Required overhead", fmt(report.totals.overheadUsefulTokens), `${pct(report.totals.overheadUsefulPctOfInput)} of input`)}
+    ${metricCard("Main contributor", `${escapeHtml(topContribution.id)}`, escapeHtml(topContribution.name))}
+    ${metricCard("Worst turn", `T${report.keyDataPoints.peakWasteTurn.turn}`, `${fmt(report.keyDataPoints.peakWasteTurn.wasteTokens)} waste tokens`)}
+  </section>
+
+  <section class="grid-2">
+    <div class="panel section">
+      <div class="section-head">
+        <h2>Useful vs Waste</h2>
+        <p class="small-note">Exact totals from the efficiency model.</p>
+      </div>
+      <div class="stack">
+        ${report.wasteBuckets.map((bucket) => `<span style="width:${bucket.sharePct}%; background:${bucketColor(bucket.id)}" title="${escapeHtml(bucket.label)} ${fmt(bucket.tokens)}"></span>`).join("")}
+      </div>
+      <div class="legend">
+        ${report.wasteBuckets.map((bucket) => `<span><i style="background:${bucketColor(bucket.id)}"></i>${escapeHtml(bucket.label)}: ${fmt(bucket.tokens)} (${pct(bucket.sharePct)})</span>`).join("")}
+      </div>
+      <div class="callout">
+        The biggest waste bucket is <strong>${escapeHtml(report.keyDataPoints.largestWasteBucket.label)}</strong> at ${fmt(report.keyDataPoints.largestWasteBucket.tokens)} tokens.
+      </div>
+    </div>
+
+    <div class="panel section">
+      <div class="section-head">
+        <h2>Major Contributor</h2>
+        <p class="small-note">Two lenses are shown because pressure can overlap across problems.</p>
+      </div>
+      <table>
+        <tbody>
+          <tr><td>Largest by allocated waste</td><td class="num"><strong>${escapeHtml(topContribution.id)} ${escapeHtml(topContribution.name)}</strong><br>${fmt(topContribution.allocatedWasteTokens)} tokens</td></tr>
+          <tr><td>Largest by qualified pressure</td><td class="num"><strong>${escapeHtml(topPressure.id)} ${escapeHtml(topPressure.name)}</strong><br>${fmt(topPressure.qualifiedTokenPressure)} tokens</td></tr>
+          <tr><td>Unlabeled outcome residue</td><td class="num">${fmt(report.totals.unlabeledResidueTokens)} tokens<br>${pct(report.totals.unlabeledResiduePctOfInput)} of input, counted as waste</td></tr>
+        </tbody>
+      </table>
+      <div class="callout">${escapeHtml(report.majorContributor.interpretation)}</div>
+    </div>
+  </section>
+
+  <section class="panel section">
+    <div class="section-head">
+      <h2>10 Problems Contribution</h2>
+      <p class="small-note">Bars show allocated waste share. The right column also shows qualified pressure as a separate evidence measure.</p>
+    </div>
+    <div class="bar-list">
+      ${report.problemContributions.map((problem) => problemContributionRow(problem, report.problemContributions[0].allocatedWasteTokens)).join("")}
+    </div>
+  </section>
+
+  <section class="panel section" style="margin-top:22px">
+    <div class="section-head">
+      <h2>Problem Definitions</h2>
+      <p class="small-note">Plain-language meaning of each P label used in the allocation chart and timeline.</p>
+    </div>
+    ${problemDefinitionsGrid(report.problemContributions)}
+  </section>
+
+  <section class="panel section" style="margin-top:22px">
+    <div class="section-head">
+      <h2>Whole Session Timeline</h2>
+      <p class="small-note">Each bar is one token-counted turn. Height is official total input; green is useful plus required overhead; colored waste segments include named P-problem waste and unlabeled residue. Hover a bar for details.</p>
+    </div>
+    <div class="timeline-frame">
+      ${episodeRuler(report.episodeSummaries)}
+      <div class="timeline">
+        ${report.timeline.map((turn) => timelineBar(turn, report.keyDataPoints.peakInputTurn.inputTokens)).join("")}
+      </div>
+    </div>
+    <div class="timeline-legend">
+      ${report.problemLegend.map((item) => `<span class="legend-chip" title="${escapeHtml(item.definition || item.name)}"><i style="background:${escapeHtml(item.color)}"></i>${escapeHtml(item.id === "useful" || item.id === "unattributed" ? item.name : `${item.id} ${item.name}`)}</span>`).join("")}
+      <span class="legend-chip"><i style="background:var(--blue); border-radius:50%"></i>Compaction marker</span>
+    </div>
+  </section>
+
+  <section class="grid-2" style="margin-top:22px">
+    <div class="panel section">
+      <div class="section-head">
+        <h2>Episode Summary</h2>
+      </div>
+      ${episodeTable(report.episodeSummaries)}
+    </div>
+    <div class="panel section">
+      <div class="section-head">
+        <h2>Key Data Points</h2>
+      </div>
+      <table>
+        <tbody>
+          <tr><td>Turns</td><td class="num">${report.keyDataPoints.turns}</td></tr>
+          <tr><td>Token-counted turns</td><td class="num">${report.keyDataPoints.tokenCountedTurns}</td></tr>
+          <tr><td>Turns with any problem evidence</td><td class="num">${report.keyDataPoints.turnsWithAnyProblem}</td></tr>
+          <tr><td>Qualified problem turns in timeline</td><td class="num">${report.keyDataPoints.qualifiedProblemTurnsInTimeline}</td></tr>
+          <tr><td>Compactions / aborts / rollbacks</td><td class="num">${report.keyDataPoints.compactions} / ${report.keyDataPoints.aborts} / ${report.keyDataPoints.rollbacks}</td></tr>
+          <tr><td>Peak input turn</td><td class="num">T${report.keyDataPoints.peakInputTurn.turn}, ${fmt(report.keyDataPoints.peakInputTurn.inputTokens)}</td></tr>
+          <tr><td>Peak waste turn</td><td class="num">T${report.keyDataPoints.peakWasteTurn.turn}, ${fmt(report.keyDataPoints.peakWasteTurn.wasteTokens)}</td></tr>
+          <tr><td>Worst waste percent turn</td><td class="num">T${report.keyDataPoints.worstWasteShareTurn.turn}, ${pct(report.keyDataPoints.worstWasteShareTurn.wasteSharePct)}</td></tr>
+        </tbody>
+      </table>
+    </div>
+  </section>
+
+  <section class="panel section" style="margin-top:22px">
+    <div class="section-head">
+      <h2>Largest Waste Turns</h2>
+      <p class="small-note">Useful for checking whether the chart matches the underlying session shape.</p>
+    </div>
+    ${turnTable(report.topWasteTurns)}
+  </section>
+</main>
+</body>
+</html>`;
+}
+
+function problemContributionRow(problem, maxWaste) {
+  const width = maxWaste ? Math.max(2, (problem.allocatedWasteTokens / maxWaste) * 100) : 0;
+  return `<div class="problem-row" style="--problem-color:${escapeHtml(problem.color)}">
+    <div class="problem-id">${escapeHtml(problem.id)}</div>
+    <div>
+      <div class="problem-name">${escapeHtml(problem.name)}</div>
+      <div class="problem-meta">${problem.qualifiedTurns} qualified turns, ${pct(problem.allocatedWasteShareOfTotalPct)} of total waste, ${pct(problem.qualifiedPressureVsSessionPct)} qualified pressure vs session</div>
+      <div class="problem-definition">${escapeHtml(problem.definition)}</div>
+      <div class="bar-bg"><div class="bar-fill" style="width:${round(width, 1)}%"></div></div>
+    </div>
+    <div class="number">${fmt(problem.allocatedWasteTokens)}<br><span class="small-note">${fmt(problem.qualifiedTokenPressure)} pressure</span></div>
+  </div>`;
+}
+
+function problemDefinitionsGrid(problems) {
+  const sorted = [...problems].sort((a, b) => a.id.localeCompare(b.id));
+  return `<div class="definition-grid">
+    ${sorted.map((problem) => `<div class="definition-item" style="--problem-color:${escapeHtml(problem.color)}">
+      <div class="problem-id">${escapeHtml(problem.id)}</div>
+      <div>
+        <strong>${escapeHtml(problem.name)}</strong>
+        <p>${escapeHtml(problem.definition)}</p>
+      </div>
+    </div>`).join("")}
+  </div>`;
+}
+
+function episodeRuler(episodes) {
+  if (!episodes?.length) return "";
+  return `<div class="episode-ruler" aria-label="Episode ranges">
+    ${episodes.map((episode) => {
+      const narrow = episode.turns < 6;
+      const label = `Episode ${episode.episode}: ${episode.label}`;
+      return `<div class="episode-band${narrow ? " narrow" : ""}" style="grid-column: span ${Math.max(1, episode.turns)}" tabindex="0" aria-label="${escapeHtml(label)}">
+        <span class="episode-badge">E${episode.episode}</span>
+        <span class="episode-label">
+          <strong>${escapeHtml(episode.label)}</strong>
+          <span>${fmt(episode.inputTokens)} input · ${pct(episode.wasteSharePct)} waste</span>
+        </span>
+        <span class="episode-tip" role="tooltip">
+          <span class="episode-tip-title"><span>E${episode.episode}</span><span>${escapeHtml(episode.label)}</span></span>
+          <span class="episode-tip-grid">
+            <span><span class="episode-tip-muted">Turns</span><strong>${episode.turns}</strong></span>
+            <span><span class="episode-tip-muted">Input</span><strong>${fmt(episode.inputTokens)}</strong></span>
+            <span><span class="episode-tip-muted">Useful</span><strong>${fmt(episode.usefulTokens)} (${pct(episode.usefulSharePct)})</strong></span>
+            <span><span class="episode-tip-muted">Waste</span><strong>${fmt(episode.wasteTokens)} (${pct(episode.wasteSharePct)})</strong></span>
+            <span style="grid-column:1 / -1"><span class="episode-tip-muted">Duplicate / re-find / dead</span><strong>${fmt(episode.duplicateTokens)} / ${fmt(episode.refindTokens)} / ${fmt(episode.deadTokens)}</strong></span>
+          </span>
+        </span>
+      </div>`;
+    }).join("")}
+  </div>`;
+}
+
+function timelineBar(turn, maxInputTokens) {
+  const height = maxInputTokens ? Math.max(5, (turn.inputTokens / maxInputTokens) * 158) : 5;
+  const classes = ["turn-bar"];
+  if (turn.problemCount) classes.push("has-problem");
+  if (turn.commit || turn.anchorKind === "commit") classes.push("commit");
+  if (turn.compaction) classes.push("compaction");
+  const label = `T${turn.turn}: ${fmt(turn.inputTokens)} input, ${pct(turn.usefulSharePct)} useful, ${pct(turn.wasteSharePct)} waste`;
+  return `<div class="${classes.join(" ")}" style="height:${round(height, 1)}px" tabindex="0" aria-label="${escapeHtml(label)}">
+    ${turn.segments.map(timelineSegment).join("")}
+    ${timelineTooltip(turn)}
+  </div>`;
+}
+
+function timelineSegment(segment) {
+  return `<span class="turn-segment" style="height:${round(segment.sharePct, 3)}%; background:${escapeHtml(segment.color)}"></span>`;
+}
+
+function timelineTooltip(turn) {
+  const wasteSegments = turn.segments.filter((segment) => segment.type === "waste" && segment.tokens > 0);
+  const userMessage = String(turn.userMessage || "").trim();
+  return `<div class="turn-tooltip" role="tooltip">
+    <div class="tip-title"><span>Turn ${turn.turn}</span><span>${pct(turn.wasteSharePct)} waste</span></div>
+    ${userMessage ? `<p class="tip-message"><strong>User:</strong> ${escapeHtml(userMessage)}</p>` : ""}
+    <div class="tip-grid">
+      <span class="tip-muted">Input</span><strong>${fmt(turn.inputTokens)}</strong>
+      <span class="tip-muted">Useful</span><strong>${fmt(turn.usefulTokens)} (${pct(turn.usefulSharePct)})</strong>
+      <span class="tip-muted">Waste</span><strong>${fmt(turn.wasteTokens)} (${pct(turn.wasteSharePct)})</strong>
+      <span class="tip-muted">Product / overhead useful</span><strong>${fmt(turn.productUsefulTokens)} / ${fmt(turn.overheadUsefulTokens)}</strong>
+      <span class="tip-muted">Named / unlabeled waste</span><strong>${fmt(turn.namedWasteTokens)} / ${fmt(turn.unlabeledResidueTokens)}</strong>
+      <span class="tip-muted">Duplicate / re-find / dead</span><strong>${fmt(turn.duplicateTokens)} / ${fmt(turn.refindTokens)} / ${fmt(turn.deadTokens)}</strong>
+      <span class="tip-muted">Flags</span><strong>${turnFlags(turn)}</strong>
+    </div>
+    <div class="tip-breakdown">
+      ${wasteSegments.length ? wasteSegments.map((segment) => `<div class="tip-line"><i class="tip-swatch" style="background:${escapeHtml(segment.color)}"></i><span>${escapeHtml(segment.id === "unattributed" ? segment.label : `${segment.id} ${segment.label}`)}</span><strong>${fmt(segment.tokens)} (${pct(segment.sharePct)})</strong></div>`).join("") : "<span class=\"tip-muted\">No waste segment</span>"}
+    </div>
+  </div>`;
+}
+
+function turnFlags(turn) {
+  const flags = [];
+  if (turn.compaction) flags.push("compaction");
+  if (turn.abort) flags.push("abort");
+  if (turn.rollback) flags.push("rollback");
+  if (turn.commit || turn.anchorKind === "commit") flags.push("commit");
+  if (!flags.length) return "none";
+  return escapeHtml(flags.join(", "));
+}
+
+function episodeTable(episodes) {
+  return `<table>
+    <thead><tr><th>Episode</th><th class="num">Input</th><th class="num">Waste</th><th class="num">Waste %</th></tr></thead>
+    <tbody>
+      ${episodes.map((episode) => `<tr><td>${escapeHtml(episode.label)}</td><td class="num">${fmt(episode.inputTokens)}</td><td class="num">${fmt(episode.wasteTokens)}</td><td class="num">${pct(episode.wasteSharePct)}</td></tr>`).join("")}
+    </tbody>
+  </table>`;
+}
+
+function turnTable(turns) {
+  return `<table>
+    <thead><tr><th>Turn</th><th class="num">Input</th><th class="num">Useful</th><th class="num">Waste</th><th>Problems</th></tr></thead>
+    <tbody>
+      ${turns.map((turn) => `<tr>
+        <td><strong>T${turn.turn}</strong></td>
+        <td class="num">${fmt(turn.inputTokens)}</td>
+        <td class="num">${fmt(turn.usefulTokens)} (${pct(turn.usefulSharePct)})</td>
+        <td class="num">${fmt(turn.wasteTokens)} (${pct(turn.wasteSharePct)})</td>
+        <td>${turn.problems.length ? turn.problems.map((id) => `<span class="pill">${escapeHtml(id)}</span>`).join("") : "<span class=\"small-note\">none</span>"}</td>
+      </tr>`).join("")}
+    </tbody>
+  </table>`;
+}
+
+function metricCard(label, value, sub) {
+  return `<div class="card"><div class="label">${escapeHtml(label)}</div><div class="value">${value}</div><div class="sub">${escapeHtml(sub)}</div></div>`;
+}
+
+function bucketColor(id) {
+  return {
+    useful: "var(--green)",
+    duplicate: "var(--amber)",
+    refind: "var(--rose)",
+    dead: "var(--violet)"
+  }[id] || "var(--muted)";
+}
+
+function pickMajor(problem) {
+  if (!problem) return null;
+  return {
+    id: problem.id,
+    name: problem.name,
+    allocatedWasteTokens: problem.allocatedWasteTokens,
+    allocatedWasteShareOfTotalPct: problem.allocatedWasteShareOfTotalPct,
+    qualifiedTokenPressure: problem.qualifiedTokenPressure,
+    qualifiedPressureVsSessionPct: problem.qualifiedPressureVsSessionPct
+  };
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      args._.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+    } else {
+      args[key] = next;
+      i += 1;
+    }
+  }
+  return args;
+}
+
+function sum(items, getter) {
+  return items.reduce((total, item) => total + getter(item), 0);
+}
+
+function maxBy(items, getter) {
+  return items.reduce((best, item) => (!best || getter(item) > getter(best) ? item : best), null);
+}
+
+function mapValues(object, mapper) {
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, mapper(value)]));
+}
+
+function fmt(value) {
+  return Math.round(value || 0).toLocaleString("en-US");
+}
+
+function pct(value) {
+  return `${round(value || 0, 1).toFixed(1)}%`;
+}
+
+function round(value, decimals = 0) {
+  const factor = 10 ** decimals;
+  return Math.round((value + Number.EPSILON) * factor) / factor;
+}
+
+function escapeHtml(value) {
+  return String(value ?? "")
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#039;");
+}