@echomem/mcp 1.4.7 → 1.4.9

package/assets/canonical-scorer/optimizable_detail.mjs

@@ -0,0 +1,633 @@
+#!/usr/bin/env node
+// OPTIMIZABLE DETAIL — per turn, what inside the window is removable and WHY, anchored to each commit message.
+// Partition of every turn's real C_t into KEEP (floor) + 3 cleanable buckets (mapped to EchoMem's redundancy types):
+//   KEEP  overhead   = system/tools/turn_ctx + serialization            (irreducible)
+//   KEEP  product    = current/near-current committed file context + the user spec + active same-turn discovery
+//   OPT   dup        = duplicate/stale rereads + superseded write versions  → "Stale Reread" (hold 1, not N)
+//   OPT   refind     = carried search/git/status/build/reasoning/self-talk after the source turn → "Repo re-discovery / tool-instead-of-recall / self-explanation"
+//   OPT   dead       = reads unrelated to any commit (tier-3) + piled-up screenshots → "Irrelevant injection / expired view"
+// optimizable = dup + refind + dead.  Each turn sums to real C_t.  Commit message of the episode is the anchor.
+// Important interpretation: "OPT/waste" does NOT mean the work was useless when it happened.
+// Early orientation turns legitimately need searches, git checks, memory lookup, route reads,
+// and wrapper-file reads to understand the app. This strict Kobe-style score asks a narrower
+// question: which tokens should keep riding in the context window after they served that purpose?
+// In other words, OPT is "non-final / compressible / droppable later" context. For product
+// judgment, separate temporary discovery/support cost from truly avoidable waste.
+// Same-turn discovery/support gets a grace turn: it becomes waste only when carried
+// forward, or when superseded by a later same-turn duplicate.
+// Usage: node optimizable_detail.mjs WebPageReactVersion 70
+
+import fs from 'fs';
+import os from 'os';
+import readline from 'readline';
+import path from 'path';
+import { chooseGroundTruthAnchors } from './golden_anchors.mjs';
+
+const HOME = os.homedir();
+const PACKAGE_ROOT = path.resolve(process.cwd(), 'ErikMachine-Context_Golden_Standard');
+const ROOT = process.env.GOLDEN_ROOT || path.join(PACKAGE_ROOT, 'data');
+const ECHO = process.env.GOLDEN_ECHO || path.join(PACKAGE_ROOT, 'inputs', 'kobe-compatible');
+const args = parseArgs(process.argv.slice(2));
+const argTarget = args._[0] || 'WebPageReactVersion';
+const argTurns = +(args._[1]) || 0;
+const scoringMode = normalizeScoringMode(args['scoring-mode'] || args.scorer || args.mode || 'local-live');
+const isEpisodeOutcome = scoringMode === 'episode-outcome';
+const debugItems = Boolean(args['debug-items'] || args.debugItems);
+const directSessionPath = resolveDirectSession(argTarget);
+const proj = directSessionPath ? sessionIdFromFile(directSessionPath) : argTarget;
+const wantTurns = argTurns || (directSessionPath ? await countUserTurns(directSessionPath) : 70);
+const READ_VERBS = new Set(['cat', 'head', 'tail', 'sed', 'nl', 'less', 'more', 'bat', 'strings', 'view']);
+const SEARCH_VERBS = new Set(['rg', 'grep', 'ag', 'ack', 'find', 'fd', 'fgrep', 'egrep']);
+const R_CODE = 3.3, R_TEXT = 4.0, IMG_TOK = 4000, TRUNC_CAP = 12000, SER_FRAC = 0.03;
+const reTok = /Original token count:\s*(\d+)/;
+const baseName = (p) => p ? String(p).split('/').pop().toLowerCase() : null;
+const isImageOut = (out) => Array.isArray(out) ? out.some((b) => b?.type === 'input_image' || b?.image_url) : false;
+function countImagesDeep(value) {
+  if (!value) return 0;
+  if (typeof value === 'string') return (value.match(/"type"\s*:\s*"input_image"/g) || []).length + (value.match(/data:image\//g) || []).length;
+  if (Array.isArray(value)) return value.reduce((a, x) => a + countImagesDeep(x), 0);
+  if (typeof value === 'object') return (value.type === 'input_image' ? 1 : 0) + Object.values(value).reduce((a, x) => a + countImagesDeep(x), 0);
+  return 0;
+}
+function countUserImages(payload) {
+  return (payload.images?.length || 0) + (payload.local_images?.length || 0) + countImagesDeep(payload.message || '');
+}
+function messageText(payload) {
+  return typeof payload.message === 'string' ? payload.message : JSON.stringify(payload.message || '');
+}
+function walk(dir, out) { let e; try { e = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; } for (const x of e) { const p = path.join(dir, x.name); if (x.isDirectory()) walk(p, out); else if (x.name.endsWith('.jsonl')) out.set(x.name, p); } }
+function resolveDirectSession(value) {
+  if (!value) return null;
+  if (String(value).endsWith('.jsonl') && fs.existsSync(value)) return path.resolve(value);
+  if (!/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i.test(String(value))) return null;
+  const idx = new Map();
+  walk(path.join(HOME, '.codex', 'sessions'), idx);
+  const matches = [...idx.values()].filter((fp) => fp.includes(value));
+  if (!matches.length) return null;
+  return matches.sort((a, b) => a.length - b.length)[0];
+}
+async function countUserTurns(file) {
+  let n = 0;
+  const lines = readline.createInterface({ input: fs.createReadStream(file), crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    let r; try { r = JSON.parse(line); } catch { continue; }
+    if ((r.payload || {}).type === 'user_message') n++;
+  }
+  return n;
+}
+function createProviderRequestTracker() { return { cumulativeInputTokens: 0, sawCumulativeInput: false, legacyFingerprint: null }; }
+function acceptProviderRequest(info, tracker) {
+  if (!info || typeof info !== 'object') return null;
+  const last = info.last_token_usage;
+  const cumulativeInput = cumulativeInputTokens(info.total_token_usage);
+  if (cumulativeInput != null) {
+    tracker.sawCumulativeInput = true;
+    // Output and total can grow across snapshots of one in-flight provider request. Only a strict
+    // increase in cumulative input starts the next request; the session-global ledger also prevents
+    // a repeated snapshot from moving into the following human turn.
+    if (cumulativeInput <= tracker.cumulativeInputTokens) return null;
+    tracker.cumulativeInputTokens = cumulativeInput;
+    if (!last || typeof last !== 'object') return null;
+    const request = normalizeProviderUsage(last);
+    tracker.legacyFingerprint = providerUsageFingerprint(request);
+    return request;
+  }
+  // Compatibility for older JSONL fixtures without total_token_usage. The session-global
+  // fingerprint still de-duplicates repeated snapshots across human-turn boundaries.
+  if (tracker.sawCumulativeInput || !last || typeof last !== 'object') return null;
+  const request = normalizeProviderUsage(last);
+  const fingerprint = providerUsageFingerprint(request);
+  if (fingerprint === tracker.legacyFingerprint) return null;
+  tracker.legacyFingerprint = fingerprint;
+  return request;
+}
+function cumulativeInputTokens(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  const input = Number(usage.input_tokens);
+  return Number.isFinite(input) && input > 0 ? input : null;
+}
+function normalizeProviderUsage(usage) {
+  return {
+    inputTokens: Number(usage.input_tokens || 0),
+    cachedInputTokens: Number(usage.cached_input_tokens || 0),
+    outputTokens: Number(usage.output_tokens || 0),
+    reasoningOutputTokens: Number(usage.reasoning_output_tokens || 0),
+    totalTokens: Number(usage.total_tokens || 0),
+  };
+}
+function providerUsageFingerprint(usage) {
+  return [usage.inputTokens, usage.cachedInputTokens, usage.outputTokens, usage.reasoningOutputTokens, usage.totalTokens].join(':');
+}
+function readFileArg(cmd) { if (typeof cmd !== 'string') return null; const seg = cmd.split('|')[0].split('>')[0].trim(); const t = seg.split(/\s+/); const v = (t[0] || '').split('/').pop(); if (!READ_VERBS.has(v)) return null; for (let i = t.length - 1; i >= 1; i--) { let x = t[i].replace(/^['"]|['"]$/g, ''); if (x && !x.startsWith('-') && (x.includes('/') || x.includes('.'))) return x; } return null; }
+function readRange(cmd) { const ms = [...String(cmd).matchAll(/(\d+),(\d+)\s*p/g)]; if (!ms.length) return null; return [Math.min(...ms.map((m) => +m[1])), Math.max(...ms.map((m) => +m[2]))]; }
+const rangeOverlap = (a, b) => !a || !b || (a[0] <= b[1] && b[0] <= a[1]);
+function cmdKind(cmd) { const v = (String(cmd).split('|')[0].split('>')[0].trim().split(/\s+/)[0] || '').split('/').pop(); if (SEARCH_VERBS.has(v)) return 'search'; if (READ_VERBS.has(v)) return 'read'; return 'command'; }
+function normalizeCommand(cmd) { return String(cmd || '').replace(/\s+/g, ' ').trim().replace(/["'][^"']{40,}["']/g, '"..."').replace(/\b\d{4,}\b/g, 'N').slice(0, 220); }
+function searchPattern(cmd) { const match = String(cmd || '').match(/(?:rg|grep|ag|ack)\s+(?:-[^\s]+\s+)*['"]?([^'"\s][^'"]{0,80})/); return match ? match[1].replace(/\s+/g, ' ').trim() : normalizeCommand(cmd).slice(0, 80); }
+function signals(text) { const out = new Set(); for (const m of String(text).matchAll(/#[0-9a-fA-F]{3,8}\b/g)) out.add('c:' + m[0].toLowerCase()); for (const m of String(text).matchAll(/--[a-zA-Z][\w-]{2,}/g)) out.add('v:' + m[0].toLowerCase()); for (const m of String(text).matchAll(/\b\d{1,4}(?:\.\d+)?(?:px|rem|em|vh|vw|ms)\b/g)) out.add('u:' + m[0].toLowerCase()); return out; }
+function patchFiles(input) {
+  const files = new Set();
+  for (const line of String(input || '').split(/\n/)) {
+    const match = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/) || line.match(/^\*\*\* Move to: (.+)$/);
+    const file = baseName(match?.[1]);
+    if (file) files.add(file);
+  }
+  return [...files];
+}
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) {
+      out._.push(arg);
+      continue;
+    }
+    const [rawKey, inline] = arg.slice(2).split('=', 2);
+    const key = rawKey.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    if (inline != null) out[rawKey] = out[key] = inline;
+    else if (argv[i + 1] && !argv[i + 1].startsWith('--')) out[rawKey] = out[key] = argv[++i];
+    else out[rawKey] = out[key] = true;
+  }
+  return out;
+}
+function normalizeScoringMode(value) {
+  const mode = String(value || '').trim().toLowerCase().replace(/_/g, '-');
+  if (['local', 'live', 'local-live', 'current'].includes(mode)) return 'local-live';
+  if (['episode', 'episode-outcome', 'outcome', 'offline-outcome'].includes(mode)) return 'episode-outcome';
+  console.error(`unknown scoring mode: ${value}`);
+  process.exit(1);
+}
+
+const cadence = directSessionPath ? { rows: [] } : JSON.parse(fs.readFileSync(path.join(ECHO, 'forensics/commit-cadence.json'), 'utf8'));
+const sample = directSessionPath ? { sessions: [] } : JSON.parse(fs.readFileSync(path.join(ECHO, 'dirty-context-sample.json'), 'utf8'));
+const byKey = new Map(sample.sessions.filter((s) => (s.turns || 0) >= 8).map((s) => [[s.tool, s.project, s.turns, s.reads, s.totalTokens, s.inputTokens].join('|'), s]));
+const idx = new Map(); walk(path.join(HOME, '.codex', 'sessions'), idx);
+const row = directSessionPath
+  ? { project: path.basename(directSessionPath, '.jsonl'), turns: wantTurns }
+  : (cadence.rows || []).find((c) => !c.usedEchoMem && c.tool === 'codex' && (c.project || '').includes(proj) && c.turns === wantTurns);
+const s = directSessionPath ? null : row && byKey.get([row.tool, row.project, row.turns, row.reads, row.totalTok, row.inTok].join('|'));
+const fp = directSessionPath || (s && idx.get(s.file));
+if (!fp) { console.log('session not found'); process.exit(1); }
+const sessionId = sessionIdFromFile(fp);
+const payloadAccounting = loadPayloadAccounting(sessionId);
+const payloadEvidenceByTurn = new Map((payloadAccounting?.turns || []).map((turn) => [turn.number, summarizePayloadEvidence(turn)]));
+
+let turn = 0, baseTok = 0, toolsTok = 0, turnCtxTok = 0, imageSeq = 0;
+const items = []; const editEpoch = new Map(); const compactionTurns = []; const usage = new Map(); const reasoningCalls = [];
+const callKind = new Map(); const commitTurns = new Set(); const commitMsg = new Map(); const userMessages = new Map(); const readText = new Map(); let writeCorpus = ''; const CAP = 60000;
+const requestTracker = createProviderRequestTracker();
+const rl = readline.createInterface({ input: fs.createReadStream(fp), crlfDelay: Infinity });
+for await (const line of rl) {
+  if (!line.trim()) continue; let r; try { r = JSON.parse(line); } catch { continue; }
+  const p = r.payload || {}; const pt = p.type;
+  if (r.type === 'session_meta' || pt === 'session_meta') { baseTok = Math.max(baseTok, Math.round((p.base_instructions?.text || '').length / R_TEXT)); toolsTok = Math.max(toolsTok, Math.round(JSON.stringify(p.dynamic_tools || []).length / R_CODE)); }
+  else if (r.type === 'turn_context' || (p && p.collaboration_mode)) turnCtxTok = Math.max(turnCtxTok, Math.round(JSON.stringify(p).length / R_TEXT));
+  else if (pt === 'user_message') { if (turn >= wantTurns) break; turn++; const txt = messageText(p); userMessages.set(turn, txt); items.push({ turn, kind: 'conv_user', tokens: Math.round(txt.length / R_TEXT) }); for (let i = 0; i < countUserImages(p); i++) items.push({ turn, kind: 'image', source: 'user_reference', target: 'user_reference', imageId: ++imageSeq, tokens: IMG_TOK }); }
+  else if (pt === 'token_count') { const request = acceptProviderRequest(p.info, requestTracker); if (request && turn > 0) { usage.set(turn, { input: request.inputTokens, cached: request.cachedInputTokens }); if (request.reasoningOutputTokens) reasoningCalls.push({ turn, tokens: request.reasoningOutputTokens }); } }
+  else if (turn === 0) continue;
+  else if (pt === 'message' && p.role === 'developer') { const txt = Array.isArray(p.content) ? p.content.map((b) => b?.text || '').join('') : ''; items.push({ turn, kind: 'conv_agent', tokens: Math.round(txt.length / R_TEXT) }); }
+  else if (pt === 'context_compacted') compactionTurns.push(turn);
+  else if (pt === 'agent_message') items.push({ turn, kind: 'conv_agent', tokens: Math.round((p.message || '').length / R_TEXT) });
+  else if (pt === 'patch_apply_end' && p.changes) for (const f of Object.keys(p.changes)) editEpoch.set(baseName(f), [...(editEpoch.get(baseName(f)) || []), turn]);
+  else if (pt === 'custom_tool_call' && typeof p.input === 'string') { const files = patchFiles(p.input); items.push({ turn, kind: 'written', file: files.length === 1 ? files[0] : undefined, files, tokens: Math.round(p.input.length / R_CODE) }); if (writeCorpus.length < 400000) writeCorpus += '\n' + p.input; }
+  else if (pt === 'function_call') { if (p.name === 'exec_command') { let a = p.arguments; if (typeof a === 'string') { try { a = JSON.parse(a); } catch { a = { cmd: a }; } } const cmd = a?.cmd || a?.command || ''; const cm = cmd.match(/commit[^"']*-m\s+["']([^"']+)["']/) || cmd.match(/-m\s+["']([^"']+)["']/); if (/git\s+(?:-[^\s]+\s+)*commit/.test(cmd)) { commitTurns.add(turn); if (cm) commitMsg.set(turn, cm[1]); } if (p.call_id) callKind.set(p.call_id, { kind: cmdKind(cmd), file: baseName(readFileArg(cmd)), range: readRange(cmd), command: cmd, normalizedCommand: normalizeCommand(cmd), searchPattern: searchPattern(cmd) }); } else if (p.call_id) callKind.set(p.call_id, { kind: 'command', target: p.name || 'tool_image', imageProducer: (p.name === 'view_image' || p.name === 'js'), command: p.name || 'tool_image', normalizedCommand: p.name || 'tool_image' }); }
+  else if (pt === 'function_call_output') { const m = callKind.get(p.call_id) || { kind: 'command' }; const out = p.output; const imageCount = countImagesDeep(out); if (isImageOut(out) || (m.imageProducer && typeof out !== 'string')) items.push({ turn, kind: 'image', source: 'tool_screenshot', target: m.target || 'tool_image', imageId: ++imageSeq, callId: p.call_id, imageOutput: true, imageCount: imageCount || 1, tokens: IMG_TOK }); else { const str = typeof out === 'string' ? out : JSON.stringify(out || ''); const mm = str.match(reTok); const tok = Math.min(mm ? +mm[1] : Math.round(str.length / R_CODE), TRUNC_CAP); const kind = m.kind === 'read' ? 'read' : (m.kind === 'search' ? 'search' : 'command'); items.push({ turn, kind, file: m.file, range: m.range, command: m.command, normalizedCommand: m.normalizedCommand, searchPattern: m.searchPattern, callId: p.call_id, imageOutput: imageCount > 0, imageCount: imageCount || undefined, tokens: tok }); if (kind === 'read' && m.file) { const cur = readText.get(m.file) || ''; if (cur.length < CAP) readText.set(m.file, cur + '\n' + str.slice(0, CAP)); } } }
+}
+items.forEach((it, seq) => { it.seq = seq; });
+const userTurns = [...new Set(items.filter((i) => i.kind === 'conv_user' && i.turn).map((i) => i.turn))].sort((a, b) => a - b).filter((t) => (usage.get(t)?.input || 0) > 0);
+const overhead = baseTok + toolsTok + turnCtxTok;
+const lastCompBefore = (t) => { let c = 0; for (const x of compactionTurns) if (x < t) c = x; return c; };
+const Fstar = new Set([...editEpoch.keys()]);
+const groundTruth = chooseGroundTruthAnchors({ commitTurns, commitMessages: commitMsg, userMessages, userTurns });
+const commits = groundTruth.turns.slice();
+const anchorMsg = groundTruth.labelByTurn;
+const episodeOf = (t) => { let e = 1; for (const c of commits) { if (t <= c) return e; e++; } return e; };
+const firstUserTurn = userTurns[0] || 1;
+const lastUserTurn = userTurns[userTurns.length - 1] || wantTurns;
+const episodeStartTurn = (e) => e <= 1 ? firstUserTurn : ((commits[e - 2] || firstUserTurn - 1) + 1);
+const episodeEndTurn = (e) => commits[e - 1] || lastUserTurn;
+const writeSig = signals(writeCorpus); const tierOf = (f) => { if (!f) return 3; if (Fstar.has(f)) return 1; const txt = readText.get(f); if (!txt) return 3; const sig = signals(txt); let m = 0; for (const x of sig) if (writeSig.has(x)) m++; return (m >= 4 || (sig.size >= 8 && m / sig.size >= 0.15)) ? 2 : 3; };
+const episodeOutcome = buildEpisodeOutcomeIndex();
+
+const CONTENT = new Set(['read', 'search', 'command', 'image', 'written', 'conv_user', 'conv_agent']);
+// a read is a true duplicate only if an earlier read of the SAME file overlapped the SAME range with no edit in between
+const isDupRead = (it) => it.kind === 'read' && it.file && items.some((h) => h.kind === 'read' && h.file === it.file && h.turn < it.turn && rangeOverlap(h.range, it.range) && !(editEpoch.get(it.file) || []).some((e) => e > h.turn && e <= it.turn));
+const maxReasoningAt = new Map();
+for (const x of reasoningCalls) maxReasoningAt.set(x.turn, Math.max(maxReasoningAt.get(x.turn) || 0, x.tokens));
+function reasoningSegmentsSinceCompaction(lastCompactionTurn, currentTurn) {
+  const segments = [];
+  let previousCumulative = 0;
+  for (let k = lastCompactionTurn + 1; k <= currentTurn; k++) {
+    const cumulative = Math.max(previousCumulative, maxReasoningAt.get(k) || previousCumulative);
+    const tokens = cumulative - previousCumulative;
+    if (tokens > 0) segments.push({ turn: k, kind: 'reasoning', tokens });
+    previousCumulative = cumulative;
+  }
+  return segments;
+}
+function transientKey(it) {
+  if (it.kind === 'search') return `search:${it.searchPattern || it.normalizedCommand || it.command || ''}`;
+  if (it.kind === 'command') return `command:${it.normalizedCommand || it.command || ''}`;
+  return '';
+}
+const userReferenceReplacement = (text) => /\b(use this instead|instead use|replace|updated|new mockup|new reference|ignore (?:the )?(?:previous|old)|actually use|latest version|use this version)\b/i.test(String(text || ''));
+const hasEditAfter = (startTurn, endTurn) => [...editEpoch.values()].some((turns) => turns.some((e) => e > startTurn && e <= endTurn));
+const hasLaterScreenshot = (it, endTurn) => items.some((h) => h.kind === 'image' && h.source === 'tool_screenshot' && h.turn > it.turn && h.turn <= endTurn && (h.target || 'tool_image') === (it.target || 'tool_image'));
+const userReferenceSuperseded = (it, endTurn) => items.some((h) => h.kind === 'image' && h.source === 'user_reference' && h.turn > it.turn && h.turn <= endTurn && userReferenceReplacement(userMessages.get(h.turn)));
+function imageBucket(it, currentTurn) {
+  if (it.source === 'user_reference') {
+    if (episodeOf(it.turn) !== episodeOf(currentTurn)) return 'opt_dead';
+    return userReferenceSuperseded(it, currentTurn) ? 'opt_dead' : 'keep_prod';
+  }
+  if (it.source === 'tool_screenshot') {
+    if (hasEditAfter(it.turn, currentTurn) || hasLaterScreenshot(it, currentTurn)) return 'opt_dead';
+    return 'keep_prod';
+  }
+  return 'opt_dead';
+}
+function buildEpisodeOutcomeIndex() {
+  const byEpisode = new Map();
+  const maxEpisode = Math.max(1, ...userTurns.map((t) => episodeOf(t)));
+  for (let e = 1; e <= maxEpisode; e++) {
+    const start = episodeStartTurn(e);
+    const end = episodeEndTurn(e);
+    const editedFiles = new Set();
+    for (const [file, turns] of editEpoch.entries()) {
+      if (turns.some((editTurn) => editTurn >= start && editTurn <= end)) editedFiles.add(file);
+    }
+    const writtenItems = items
+      .filter((it) => it.kind === 'written' && it.turn >= start && it.turn <= end)
+      .sort((a, b) => b.seq - a.seq);
+    const usefulWrittenSeqs = new Set();
+    const latestWrittenByFile = new Map();
+    const unfiledWritten = [];
+    for (const it of writtenItems) {
+      const files = it.files?.length ? it.files : (it.file ? [it.file] : []);
+      if (!files.length) {
+        unfiledWritten.push(it);
+        continue;
+      }
+      for (const file of files) {
+        const list = latestWrittenByFile.get(file) || [];
+        if (list.length < 2) {
+          list.push(it);
+          usefulWrittenSeqs.add(it.seq);
+          latestWrittenByFile.set(file, list);
+        }
+      }
+    }
+    for (const it of unfiledWritten.slice(0, 2)) usefulWrittenSeqs.add(it.seq);
+    const latestTransientByKey = new Map();
+    for (const it of items) {
+      if (it.turn < start || it.turn > end) continue;
+      if (it.kind !== 'search' && it.kind !== 'command') continue;
+      const key = transientKey(it);
+      if (!key) continue;
+      const prev = latestTransientByKey.get(key);
+      if (!prev || it.seq > prev.seq) latestTransientByKey.set(key, it);
+    }
+    byEpisode.set(e, { episode: e, start, end, editedFiles, usefulWrittenSeqs, latestTransientByKey });
+  }
+  return byEpisode;
+}
+function hasLaterDuplicateReadBeforeOutcome(it, outcome) {
+  if (it.kind !== 'read' || !it.file) return false;
+  return items.some((h) =>
+    h.kind === 'read' &&
+    h.file === it.file &&
+    h.turn > it.turn &&
+    h.turn <= outcome.end &&
+    rangeOverlap(h.range, it.range) &&
+    !(editEpoch.get(it.file) || []).some((e) => e > it.turn && e <= h.turn)
+  );
+}
+function readConnectsToEpisodeOutcome(it, outcome) {
+  if (it.kind !== 'read' || !it.file) return false;
+  if (outcome.editedFiles.size) return outcome.editedFiles.has(it.file);
+  return tierOf(it.file) <= 2;
+}
+function episodeOutcomeBucket(it, currentTurn) {
+  const e = episodeOf(currentTurn);
+  const outcome = episodeOutcome.get(e) || { start: episodeStartTurn(e), end: episodeEndTurn(e), editedFiles: new Set(), latestTransientByKey: new Map(), usefulWrittenSeqs: new Set() };
+  const outcomeIt = { ...it, scoringMode };
+  if (it.kind === 'conv_user') return episodeOf(it.turn) === e ? 'keep_prod' : 'opt_dead';
+  if (it.kind === 'conv_agent') return it.turn === outcome.end && currentTurn === outcome.end ? 'keep_prod' : 'opt_refind';
+  if (it.kind === 'search' || it.kind === 'command') {
+    const key = transientKey(it);
+    const latest = key ? outcome.latestTransientByKey.get(key) : null;
+    if (latest && latest.seq !== it.seq && latest.turn <= outcome.end) return 'opt_refind';
+    return it.turn === outcome.end && currentTurn === outcome.end ? 'keep_prod' : 'opt_refind';
+  }
+  if (it.kind === 'image') return imageBucket(outcomeIt, outcome.end);
+  if (it.kind === 'written') return outcome.usefulWrittenSeqs?.has(it.seq) ? 'keep_prod' : 'opt_dup';
+  if (it.kind === 'read') {
+    if (hasLaterDuplicateReadBeforeOutcome(it, outcome)) return 'opt_dup';
+    if (readConnectsToEpisodeOutcome(it, outcome)) return 'keep_prod';
+    return 'opt_dead';
+  }
+  return null;
+}
+function serializeEpisodeOutcomes() {
+  return [...episodeOutcome.values()].map((outcome) => {
+    const usefulWrittenItems = items
+      .filter((it) => outcome.usefulWrittenSeqs?.has(it.seq))
+      .map((it) => ({
+        seq: it.seq,
+        turn: it.turn,
+        kind: it.kind,
+        file: it.file || null,
+        files: it.files || [],
+        tokens: it.tokens
+      }));
+    const latestTransientItems = [...(outcome.latestTransientByKey || new Map()).entries()].map(([key, it]) => ({
+      key,
+      seq: it.seq,
+      turn: it.turn,
+      kind: it.kind,
+      command: it.command || null,
+      normalizedCommand: it.normalizedCommand || null,
+      searchPattern: it.searchPattern || null,
+      tokens: it.tokens
+    }));
+    return {
+      episode: outcome.episode,
+      start: outcome.start,
+      end: outcome.end,
+      editedFiles: [...outcome.editedFiles].sort(),
+      usefulWrittenItems,
+      latestTransientItems
+    };
+  });
+}
+function sessionIdFromFile(file) {
+  const match = String(file || '').match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+  return match?.[1] || null;
+}
+function loadPayloadAccounting(id) {
+  if (process.env.GOLDEN_PAYLOAD_ACCOUNTING === '0') return null;
+  const configured = process.env.GOLDEN_PAYLOAD_ACCOUNTING;
+  const fp = configured || (id ? path.join(PACKAGE_ROOT, 'data', `TURN_PAYLOAD_ACCOUNTING_${id}.json`) : null);
+  if (!fp || !fs.existsSync(fp)) return null;
+  try { return JSON.parse(fs.readFileSync(fp, 'utf8')); } catch { return null; }
+}
+function summarizePayloadEvidence(turn) {
+  const payload = turn.payload || null;
+  const comparison = turn.comparison || null;
+  return {
+    matched: Boolean(turn.join?.matched),
+    sqliteLogId: turn.join?.sqliteLogId || null,
+    model: payload?.model || null,
+    requestKind: payload?.request?.requestKind || null,
+    directlyComparable: comparison?.directlyComparable ?? null,
+    officialInputTokens: turn.jsonl?.usage?.inputTokens || null,
+    localRawPayloadTokens: payload?.rawPayloadTokens || null,
+    localInputItemTokens: payload?.input?.tokens || null,
+    localInputToolsInstructionsTokens: comparison?.localInputToolsInstructionsTokens || null,
+    rawVsOfficialRatio: comparison?.rawVsOfficialRatio || null,
+    caveat: comparison?.caveat || null,
+    topSemanticBuckets: (payload?.input?.bySemanticBucket || []).slice(0, 5).map((b) => ({ key: b.key, tokens: b.tokens, count: b.count })),
+    topInputItems: (payload?.input?.topItems || []).slice(0, 5).map((item) => ({
+      type: item.type,
+      role: item.role,
+      semanticBucket: item.semanticBucket,
+      metadataTurnId: item.metadataTurnId,
+      tokens: item.tokens,
+      preview: item.preview
+    }))
+  };
+}
+const BANDS = ['keep_oh', 'keep_prod', 'opt_dup', 'opt_refind', 'opt_dead'];
+const series = []; const agg = Object.fromEntries(BANDS.map((b) => [b, 0]));
+function itemReason(it, bucket) {
+  if (it.scoringMode === 'episode-outcome') {
+    if (bucket === 'keep_prod') {
+      if (it.kind === 'conv_user') return 'same-episode user/product instruction';
+      if (it.kind === 'read') return 'read connects to episode outcome files';
+      if (it.kind === 'written') return 'latest two written versions by episode outcome';
+      if (it.kind === 'image' && it.source === 'user_reference') return 'reference still active at episode outcome';
+      if (it.kind === 'image') return 'visual evidence still active at episode outcome';
+      return 'active at episode outcome';
+    }
+    if (bucket === 'opt_dup') {
+      if (it.kind === 'written') return 'written version older than latest two before episode outcome';
+      if (it.kind === 'read') return 'same file/range was re-read before episode outcome';
+      return 'duplicate before episode outcome';
+    }
+    if (bucket === 'opt_dead') {
+      if (it.kind === 'read') return 'read does not connect to episode outcome files';
+      if (it.kind === 'image') return 'visual/reference context expired before episode outcome';
+      return 'does not connect to episode outcome';
+    }
+    if (bucket === 'opt_refind') return 'transient output did not survive as episode outcome context';
+  }
+  if (bucket === 'keep_prod') {
+    if (it.kind === 'conv_user') return 'current user request / product instruction';
+    if (it.kind === 'image' && it.source === 'user_reference') return 'active user reference image';
+    if (it.kind === 'image') return 'current visual evidence';
+    if (it.kind === 'written') return 'latest written work';
+    if (it.kind === 'read') return 'relevant file context';
+    return 'useful product context';
+  }
+  if (bucket === 'keep_oh') return 'required request overhead';
+  if (bucket === 'opt_dup') {
+    if (it.kind === 'read') return 'same file/range was read earlier without an intervening edit';
+    if (it.kind === 'written') return 'superseded earlier written version';
+    return 'duplicate or stale context';
+  }
+  if (bucket === 'opt_dead') {
+    if (it.kind === 'image') return 'expired or superseded visual context';
+    if (it.kind === 'read') return 'read has no detected connection to final work';
+    return 'dead or unrelated context';
+  }
+  if (bucket === 'opt_refind') {
+    if (it.kind === 'search') return 'search/re-discovery output';
+    if (it.kind === 'command') return 'command output used as external working memory';
+    if (it.kind === 'conv_agent') return 'agent self-talk / explanation residue';
+    if (it.kind === 'reasoning') return 'reasoning token residue';
+    return 're-find or reconciliation residue';
+  }
+  return bucket;
+}
+function publicItem(it, bucket, tok) {
+  return {
+    sourceTurn: it.turn,
+    kind: it.kind,
+    bucket,
+    tokens: Math.round(tok),
+    file: it.file || undefined,
+    files: it.files?.length ? it.files : undefined,
+    range: it.range || undefined,
+    command: it.command || undefined,
+    normalizedCommand: it.normalizedCommand || undefined,
+    searchPattern: it.searchPattern || undefined,
+    source: it.source || undefined,
+    target: it.target || undefined,
+    imageId: it.imageId || undefined,
+    callId: it.callId || undefined,
+    imageOutput: it.imageOutput || undefined,
+    imageCount: it.imageCount || undefined,
+    scoringMode: it.scoringMode || undefined,
+    reason: itemReason(it, bucket)
+  };
+}
+function groupItems(list) {
+  const groups = new Map();
+  for (const it of list) {
+    const key = [it.sourceTurn || '', it.callId || '', it.bucket, it.kind, it.file || '', JSON.stringify(it.files || null), JSON.stringify(it.range || null), it.normalizedCommand || it.command || '', it.source || '', it.target || '', it.imageOutput ? 'image' : '', it.reason || ''].join('\u0000');
+    const g = groups.get(key) || { ...it, tokens: 0, count: 0 };
+    g.tokens += it.tokens;
+    g.count += it.count || 1;
+    groups.set(key, g);
+  }
+  return [...groups.values()].map((it) => ({ ...it, tokens: Math.round(it.tokens) }));
+}
+for (const t of userTurns) {
+  const lc = lastCompBefore(t);
+  const u = usage.get(t) || { input: 0, cached: 0 }; const C_t = u.input;
+  const reasoningSegments = reasoningSegmentsSinceCompaction(lc, t);
+  const reasoning = reasoningSegments.reduce((sum, segment) => sum + segment.tokens, 0);
+  const structureFloor = Math.round(SER_FRAC * C_t);
+  const budget = Math.max(0, C_t - overhead - reasoning - structureFloor);
+  const carried = items.filter((it) => it.turn <= t && CONTENT.has(it.kind)).slice().reverse();
+  const b = { keep_oh: overhead + structureFloor, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0 };
+  const classifiedItems = [];
+  if (overhead + structureFloor > 0) classifiedItems.push(publicItem({ turn: t, kind: 'overhead' }, 'keep_oh', overhead + structureFloor));
+  for (const segment of reasoningSegments) {
+    const bucket = isEpisodeOutcome
+      ? (segment.turn === t && t === episodeEndTurn(episodeOf(t)) ? 'keep_prod' : 'opt_refind')
+      : (segment.turn === t ? 'keep_prod' : 'opt_refind');
+    b[bucket] += segment.tokens;
+    classifiedItems.push(publicItem(isEpisodeOutcome ? { ...segment, scoringMode } : segment, bucket, segment.tokens));
+  }
+  let running = 0; const seenRead = new Set(); let seenWrite = false; const seenSameTurnTransient = new Set();
+  for (const it of carried) {
+    if (running >= budget) break;
+    const tok = Math.min(it.tokens, budget - running); running += tok;
+    let bucket = null;
+    if (isEpisodeOutcome) {
+      bucket = episodeOutcomeBucket(it, t);
+    } else {
+      if (it.kind === 'conv_user') bucket = 'keep_prod';
+      else if (it.kind === 'conv_agent') bucket = it.turn === t ? 'keep_prod' : 'opt_refind';
+      else if (it.kind === 'search' || it.kind === 'command') {
+        if (it.turn === t) {
+          const key = transientKey(it);
+          bucket = key && seenSameTurnTransient.has(key) ? 'opt_refind' : 'keep_prod';
+          if (key) seenSameTurnTransient.add(key);
+        } else {
+          bucket = 'opt_refind';
+        }
+      }
+      else if (it.kind === 'image') bucket = imageBucket(it, t);
+      else if (it.kind === 'written') { if (!seenWrite) { bucket = 'keep_prod'; seenWrite = true; } else bucket = 'opt_dup'; }
+      else if (it.kind === 'read') { const tr = tierOf(it.file); if (isDupRead(it)) bucket = 'opt_dup'; else if (it.turn === t) bucket = 'keep_prod'; else if (tr === 3) bucket = 'opt_dead'; else bucket = 'keep_prod'; }
+    }
+    if (bucket) {
+      b[bucket] += tok;
+      const publicSource = isEpisodeOutcome ? { ...it, scoringMode } : it;
+      classifiedItems.push(publicItem(publicSource, bucket, tok));
+    }
+  }
+  const sum = BANDS.reduce((a, x) => a + b[x], 0);
+  const residual = C_t - sum;
+  b.opt_refind += residual; // reconcile rounding / serialization that is not represented by a concrete item
+  if (residual > 0) classifiedItems.push(publicItem({ turn: t, kind: 'residual' }, 'opt_refind', residual));
+  for (const x of BANDS) agg[x] += b[x];
+  const opt = b.opt_dup + b.opt_refind + b.opt_dead;
+  const wasteItems = groupItems(classifiedItems.filter((it) => it.bucket === 'opt_dup' || it.bucket === 'opt_refind' || it.bucket === 'opt_dead'));
+  const rowOut = { turn: t, episode: episodeOf(t), commit: groundTruth.byTurn.has(t), anchorKind: groundTruth.byTurn.get(t)?.kind || null, C_t, ...b, optimizablePct: +(100 * opt / C_t).toFixed(1), wasteItems, sqlitePayload: payloadEvidenceByTurn.get(t) || { matched: false } };
+  if (debugItems) rowOut.allItems = groupItems(classifiedItems);
+  series.push(rowOut);
+}
+const billTot = series.reduce((a, r) => a + r.C_t, 0);
+const share = (x) => +(100 * agg[x] / billTot).toFixed(1);
+const optTot = agg.opt_dup + agg.opt_refind + agg.opt_dead;
+
+console.log(`OPTIMIZABLE DETAIL — codex/${row.project} · ${row.turns} turns · ${commits.length} ${groundTruth.source} anchors · scoring=${scoringMode}\n`);
+console.log(`=== ground-truth anchors ===`);
+for (const c of commits) console.log(`  ep${episodeOf(c)}  @T${c}  "${anchorMsg.get(c)}"`);
+console.log(`\n=== overall partition of the ${(billTot / 1e6).toFixed(1)}M window ===`);
+console.log(`  KEEP overhead   ${share('keep_oh')}%`);
+console.log(`  KEEP product    ${share('keep_prod')}%`);
+console.log(`  ── KEEP total   ${(share('keep_oh') + share('keep_prod')).toFixed(1)}%`);
+console.log(`  OPT  dup (stale reread / superseded writes)        ${share('opt_dup')}%`);
+console.log(`  OPT  refind (re-grep / re-diff / reasoning / self)  ${share('opt_refind')}%`);
+console.log(`  OPT  dead (unrelated reads / piled screenshots)     ${share('opt_dead')}%`);
+console.log(`  ══ OPTIMIZABLE  ${(100 * optTot / billTot).toFixed(1)}%`);
+
+const out = { session: `codex/${row.project}`, sessionId, turns: row.turns, scoringMode, scoringDescription: isEpisodeOutcome ? 'Offline scoring that compares retained items in each turn against the final/anchor turn of that item’s episode.' : 'Local-live-compatible scoring that classifies retained items from turn-local and carried-context signals.', commits: commits.map((c) => ({ turn: c, episode: episodeOf(c), message: anchorMsg.get(c), kind: groundTruth.byTurn.get(c)?.kind || 'anchor' })), groundTruth: { source: groundTruth.source, anchors: groundTruth.anchors }, Fstar: [...Fstar], debug: debugItems && isEpisodeOutcome ? { episodeOutcomes: serializeEpisodeOutcomes() } : undefined, payloadAccounting: payloadAccounting ? { source: payloadAccounting.session?.dbPath || null, status: payloadAccounting.quality?.status || null, hasMainModelPayloads: Boolean(payloadAccounting.quality?.hasMainModelPayloads), matchedTurns: payloadAccounting.session?.matchedTurns || 0, sqlitePayloadRows: payloadAccounting.session?.sqlitePayloadRows || 0, caveats: payloadAccounting.quality?.caveats || [], note: 'JSONL input_tokens remain authoritative; SQLite payload evidence is diagnostic unless main-model payload rows are present.' } : null, billTot, shares: Object.fromEntries(BANDS.map((x) => [x, share(x)])), optimizablePct: +(100 * optTot / billTot).toFixed(1), series };
+const outputStem = isEpisodeOutcome ? `OPTIMIZABLE_DETAIL_EPISODE_OUTCOME_${proj}_${wantTurns}t` : `OPTIMIZABLE_DETAIL_${proj}_${wantTurns}t`;
+fs.writeFileSync(path.join(ROOT, `${outputStem}.json`), JSON.stringify(out, null, 2));
+if (process.env.GOLDEN_JSON_ONLY === '1') process.exit(0);
+
+// ---- detailed chart, commit-message anchored ----
+const W = 1480, H = 820, BG = '#15161a', PANEL = '#0f1014', GRID = '#2c2e36', TXT = '#9aa0ad', INK = '#f4f5f7';
+const COL = { keep_prod: '#2E9E6B', keep_oh: '#5b606e', opt_dup: '#C23B3B', opt_refind: '#E8A23D', opt_dead: '#8A4FCF' };
+const LBL = {
+  keep_prod: 'KEEP · current product (committed files + your spec)',
+  keep_oh: 'KEEP · overhead + serialize',
+  opt_dup: 'OPT · stale reread / superseded write versions  (hold 1, not N)',
+  opt_refind: 'OPT · re-grep / re-diff / reasoning / self-talk  (tool-instead-of-recall)',
+  opt_dead: 'OPT · unrelated reads + piled-up screenshots  (irrelevant injection / expired view)',
+};
+const drawOrder = ['keep_prod', 'keep_oh', 'opt_dup', 'opt_refind', 'opt_dead']; // bottom→top: KEEP floor, then cleanable
+const px = 64, py = 150, ph = 460, pw = W - 470;
+const axisMax = Math.ceil(Math.max(...series.map((r) => r.C_t)) / 60000) * 60000;
+const slot = pw / series.length, bw = slot * 0.82;
+const svg = []; const P = (x) => svg.push(x);
+P(`<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" font-family="-apple-system,Segoe UI,Roboto,sans-serif"><rect width="${W}" height="${H}" fill="${BG}"/>`);
+P(`<text x="40" y="36" font-size="18" font-weight="700" fill="${INK}">What's optimizable in each turn — and why — anchored to each ground truth · codex/${row.project} · ${row.turns} turns · ${scoringMode}</text>`);
+P(`<text x="40" y="58" font-size="12.5" fill="${TXT}">Each bar = that turn's full input window (real tokens). Green/gray = the floor you must keep. Red/amber/purple = removable with a memory layer. The red line is the optimizable %.</text>`);
+P(`<text x="40" y="76" font-size="12.5" fill="${TXT}">"Optimizable" = everything the model is carrying that is NOT the current product of its commit: copies it already had, things it re-found, things it read but never used.</text>`);
+P(`<rect x="${px}" y="${py}" width="${pw}" height="${ph}" fill="${PANEL}" rx="4"/>`);
+for (let v = 0; v <= axisMax; v += 60000) { const y = py + ph - v / axisMax * ph; P(`<line x1="${px}" y1="${y.toFixed(1)}" x2="${px + pw}" y2="${y.toFixed(1)}" stroke="${GRID}" stroke-width="0.6"/><text x="${px - 8}" y="${(y + 4).toFixed(1)}" font-size="10.5" fill="${TXT}" text-anchor="end">${Math.round(v / 1000)}k</text>`); }
+// episode spans + commit message labels at the top
+const epColors = ['#1b1d24', '#171922'];
+let epStart = 0;
+for (let e = 1; e <= commits.length; e++) {
+  const rows = series.map((r, i) => ({ r, i })).filter((o) => o.r.episode === e); if (!rows.length) continue;
+  const i0 = rows[0].i, i1 = rows[rows.length - 1].i;
+  const x0 = px + i0 * slot, x1 = px + (i1 + 1) * slot;
+  P(`<rect x="${x0.toFixed(1)}" y="${py}" width="${(x1 - x0).toFixed(1)}" height="${ph}" fill="${epColors[e % 2]}" opacity="0.5"/>`);
+  const cx = (x0 + x1) / 2; const msg = anchorMsg.get(commits[e - 1]) || '';
+  P(`<line x1="${x1.toFixed(1)}" y1="${py}" x2="${x1.toFixed(1)}" y2="${py + ph}" stroke="#3B6D11" stroke-width="0.9" stroke-dasharray="2,3" opacity="0.7"/>`);
+  // commit message above the span (wrap to 2 lines)
+  const words = msg.split(' '); let l1 = '', l2 = ''; for (const w of words) { if ((l1 + ' ' + w).length <= 26 || !l1) l1 += (l1 ? ' ' : '') + w; else l2 += (l2 ? ' ' : '') + w; }
+  P(`<text x="${cx.toFixed(1)}" y="${py - 30}" font-size="11" font-weight="700" fill="#9ED49B" text-anchor="middle">ep${e} · ${groundTruth.byTurn.get(commits[e - 1])?.kind || 'anchor'} @T${commits[e - 1]}</text>`);
+  P(`<text x="${cx.toFixed(1)}" y="${py - 16}" font-size="10.5" fill="${INK}" text-anchor="middle">"${l1}</text>`);
+  P(`<text x="${cx.toFixed(1)}" y="${py - 4}" font-size="10.5" fill="${INK}" text-anchor="middle">${l2 ? l2 + '"' : '"'}</text>`);
+}
+// compaction markers
+for (const ct of compactionTurns) { const i = series.findIndex((r) => r.turn === ct); if (i < 0) continue; const x = px + i * slot + bw / 2; P(`<text x="${x.toFixed(1)}" y="${py + ph + 30}" font-size="12" fill="#c9c9d2" text-anchor="middle">↺</text>`); }
+// bars
+series.forEach((r, i) => { const x = px + i * slot; let yTop = py + ph; for (const c of drawOrder) { const h = r[c] / axisMax * ph; if (h <= 0.2) continue; yTop -= h; P(`<rect x="${x.toFixed(1)}" y="${yTop.toFixed(1)}" width="${bw.toFixed(1)}" height="${h.toFixed(1)}" fill="${COL[c]}"/>`); } });
+// optimizable % line (0-100 on the same panel height)
+const lp = series.map((r, i) => `${(px + i * slot + bw / 2).toFixed(1)},${(py + ph - r.optimizablePct / 100 * ph).toFixed(1)}`).join(' ');
+P(`<polyline points="${lp}" fill="none" stroke="#ff5a5a" stroke-width="2" opacity="0.9"/>`);
+series.forEach((r, i) => P(`<circle cx="${(px + i * slot + bw / 2).toFixed(1)}" cy="${(py + ph - r.optimizablePct / 100 * ph).toFixed(1)}" r="1.8" fill="#ff5a5a"/>`));
+P(`<text x="${px + pw - 4}" y="${py + 14}" font-size="10" fill="#ff7a7a" text-anchor="end">optimizable % (right-read 0–100)</text>`);
+// x labels
+for (const tl of Array.from(new Set([1, Math.ceil(row.turns * 0.25), Math.ceil(row.turns * 0.5), Math.ceil(row.turns * 0.75), row.turns]))) { const i = series.findIndex((r) => r.turn === tl); if (i < 0) continue; const x = px + i * slot + bw / 2; P(`<text x="${x.toFixed(1)}" y="${py + ph + 16}" font-size="11" fill="${TXT}" text-anchor="middle">T${tl}</text>`); }
+// legend
+let ly = py + 10; const lx = px + pw + 28;
+P(`<text x="${lx}" y="${ly - 14}" font-size="12.5" font-weight="700" fill="${INK}">bands (bottom → top)</text>`);
+for (const c of drawOrder) { P(`<rect x="${lx}" y="${ly - 10}" width="13" height="13" rx="2" fill="${COL[c]}"/>`); const w = LBL[c].split('  '); P(`<text x="${lx + 19}" y="${ly}" font-size="10.8" fill="${c.startsWith('keep') ? '#cfd3da' : '#e7c9c9'}">${w[0]}</text>`); if (w[1]) P(`<text x="${lx + 19}" y="${ly + 13}" font-size="9.6" fill="${TXT}">${w[1]}</text>`); ly += w[1] ? 34 : 22; }
+ly += 10;
+P(`<text x="${lx}" y="${ly}" font-size="12.5" font-weight="700" fill="${INK}">overall — this ${(billTot / 1e6).toFixed(1)}M-token session</text>`); ly += 20;
+const sumLines = [
+  ['KEEP (floor, must carry)', (share('keep_oh') + share('keep_prod')).toFixed(1) + '%', '#9ED49B'],
+  ['  · current product', share('keep_prod') + '%', '#cfd3da'],
+  ['  · overhead', share('keep_oh') + '%', '#cfd3da'],
+  ['OPTIMIZABLE (memory removes)', out.optimizablePct + '%', '#ff7a7a'],
+  ['  · stale reread / dup writes', share('opt_dup') + '%', '#e7a3a3'],
+  ['  · re-find (grep/diff/reason)', share('opt_refind') + '%', '#f0c98a'],
+  ['  · dead / unrelated / view', share('opt_dead') + '%', '#c4a3e8'],
+];
+for (const [n, v, col] of sumLines) { P(`<text x="${lx}" y="${ly}" font-size="11.5" fill="${TXT}" font-family="ui-monospace,Menlo,monospace">${n}</text>`); P(`<text x="${lx + 248}" y="${ly}" font-size="11.5" font-weight="700" fill="${col}" text-anchor="end" font-family="ui-monospace,Menlo,monospace">${v}</text>`); ly += 19; }
+ly += 14;
+P(`<text x="${lx}" y="${ly}" font-size="11" font-weight="700" fill="${INK}">why each red band is removable</text>`); ly += 17;
+for (const t of ['dup → you already had that exact copy', 'refind → you searched/diffed what you', '          already saw; recall ≠ re-dump', 'dead → read once for orientation, never', '         used to build this commit', '', 'enemy = RE-FEED: carry 220k to produce', '~2k of product sourced from a 400-tok spec']) { P(`<text x="${lx}" y="${ly}" font-size="10" fill="${TXT}">${t}</text>`); ly += 14; }
+P('</svg>');
+fs.writeFileSync(path.join(ROOT, `${outputStem}.svg`), svg.join('\n'));
+console.log(`\nwrote ${outputStem}.json + .svg`);