@echomem/mcp 1.4.7 → 1.4.9

package/assets/canonical-scorer/analyze-10-problems.mjs

@@ -0,0 +1,857 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import readline from "node:readline";
+
+const DEFAULT_DATA_DIR = "ErikMachine-Context_Golden_Standard/data";
+const DEFAULT_REPORT_DIR = "ErikMachine-Context_Golden_Standard/reports";
+const SESSION_EPISODES = {
+  "019f19e7-9e7a-72a3-86ad-bf7c6bcc6ab1": [
+    { id: "E1", label: "T1-T4", start: 1, end: 4 },
+    { id: "E2", label: "T5-T37", start: 5, end: 37 },
+    { id: "E3", label: "T38-T39", start: 38, end: 39 },
+    { id: "E4", label: "T40-T62", start: 40, end: 62 },
+    { id: "E5", label: "T63-T77", start: 63, end: 77 }
+  ]
+};
+
+const PROBLEMS = [
+  { id: "P01", name: "Outdated Images & Screenshots", category: "Runtime Bug" },
+  { id: "P02", name: "Ignored User Instructions", category: "Model Behavior" },
+  { id: "P03", name: "Old Files", category: "Structural Accumulation" },
+  { id: "P04", name: "Repeated Setup After Compaction", category: "Structural Accumulation" },
+  { id: "P05", name: "Premature Completion Fixes", category: "Human Cost" },
+  { id: "P06", name: "Session Re-heat", category: "Human Cost" },
+  { id: "P07", name: "Failed Turn Leftovers", category: "Runtime Bug" },
+  { id: "P08", name: "Repeated Git Check Logs", category: "Model Behavior" },
+  { id: "P09", name: "Repeated Fix Attempts", category: "Human Cost" },
+  { id: "P10", name: "Repeated Search", category: "Model Behavior" }
+];
+
+const args = parseArgs(process.argv.slice(2));
+const sessionId = args["session-id"] || args.session || args._[0];
+if (!sessionId && !args.jsonl) {
+  throw new Error("Usage: node tools/analyze-10-problems.mjs --session-id <id> [--jsonl path] [--out report.json] [--html report.html]");
+}
+
+const jsonlPath = args.jsonl ? path.resolve(args.jsonl) : findSessionJsonl(sessionId);
+const parsed = await parseSession(jsonlPath);
+const id = sessionId || parsed.session.id || path.basename(jsonlPath, ".jsonl");
+const outPath = path.resolve(args.out || path.join(DEFAULT_DATA_DIR, `TEN_PROBLEM_ANALYSIS_${id}.json`));
+const htmlPath = path.resolve(args.html || path.join(DEFAULT_REPORT_DIR, `TEN_PROBLEM_ANALYSIS_${id}.html`));
+const episodes = SESSION_EPISODES[id] || [{ id: "E1", label: `T1-T${parsed.turns.length}`, start: 1, end: parsed.turns.length }];
+const report = buildReport({ sessionId: id, jsonlPath, parsed, episodes });
+
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.mkdirSync(path.dirname(htmlPath), { recursive: true });
+fs.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}\n`);
+if (process.env.GOLDEN_JSON_ONLY !== "1") fs.writeFileSync(htmlPath, renderHtml(report));
+
+console.log("10-problem analysis complete");
+console.log(`  Session: ${id}`);
+console.log(`  Turns: ${report.session.turns}`);
+console.log(`  Token pressure: ${fmt(report.totals.officialInputTokens)}`);
+console.log(`  Problems with evidence: ${report.problems.filter((p) => p.eventsFound > 0).length}/10`);
+console.log(`  JSON: ${outPath}`);
+console.log(`  HTML: ${htmlPath}`);
+
+function buildReport({ sessionId, jsonlPath, parsed, episodes }) {
+  for (const turn of parsed.turns) {
+    turn.episode = episodeForTurn(turn.number, episodes);
+  }
+
+  const detections = [
+    detectP01(parsed.turns),
+    detectP02(parsed.turns),
+    detectP03(parsed.turns),
+    detectP04(parsed.turns),
+    detectP05(parsed.turns),
+    detectP06(parsed.turns),
+    detectP07(parsed.turns),
+    detectP08(parsed.turns),
+    detectP09(parsed.turns),
+    detectP10(parsed.turns)
+  ];
+
+  const problems = PROBLEMS.map((meta, index) => finalizeProblem(meta, detections[index] || [], parsed.turns));
+  const tokenPressureTurns = new Set();
+  for (const problem of problems) {
+    for (const turn of problem.turns) tokenPressureTurns.add(turn);
+  }
+
+  return {
+    schemaVersion: "0.1.0",
+    generatedAt: new Date().toISOString(),
+    session: {
+      id: sessionId,
+      jsonlPath,
+      cwd: parsed.session.cwd || null,
+      startedAt: parsed.session.startedAt || null,
+      turns: parsed.turns.length,
+      tokenCountedTurns: parsed.turns.filter((turn) => turn.usage.inputTokens > 0).length,
+      compactions: parsed.turns.filter((turn) => turn.compaction).length,
+      aborts: parsed.turns.filter((turn) => turn.abort).length,
+      rollbacks: parsed.turns.filter((turn) => turn.rollback).length
+    },
+    method: {
+      costInterpretation: "tokenPressure is the sum of official JSONL input_tokens for turns where the problem has evidence. It is not exact item-level waste.",
+      exactWasteTokens: "not_available_for_this_jsonl_first_report",
+      sqliteNote: "Use SQLite payload attribution only when exact main-model payload rows are available for the same turn."
+    },
+    episodes,
+    totals: {
+      officialInputTokens: sum(parsed.turns, (turn) => turn.usage.inputTokens),
+      officialCachedInputTokens: sum(parsed.turns, (turn) => turn.usage.cachedInputTokens),
+      officialOutputTokens: sum(parsed.turns, (turn) => turn.usage.outputTokens),
+      officialReasoningOutputTokens: sum(parsed.turns, (turn) => turn.usage.reasoningOutputTokens),
+      turnsWithAnyProblem: tokenPressureTurns.size,
+      grossProblemTokenPressure: sum(problems, (problem) => problem.tokenPressure),
+      uniqueProblemTurnTokenPressure: [...tokenPressureTurns].reduce((total, number) => total + (parsed.turns[number - 1]?.usage.inputTokens || 0), 0)
+    },
+    problems,
+    turns: parsed.turns.map(publicTurn)
+  };
+}
+
+async function parseSession(jsonlPath) {
+  const session = { id: null, cwd: null, startedAt: null };
+  const turns = [];
+  const calls = new Map();
+  const requestTracker = createProviderRequestTracker();
+  let current = null;
+  let lineNumber = 0;
+  const lines = readline.createInterface({ input: fs.createReadStream(jsonlPath), crlfDelay: Infinity });
+
+  for await (const line of lines) {
+    lineNumber += 1;
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const payload = record.payload || {};
+    const type = payload.type || record.type;
+    const timestamp = record.timestamp || payload.timestamp || null;
+
+    if (record.type === "session_meta" || type === "session_meta") {
+      session.id ||= payload.id || null;
+      session.cwd ||= payload.cwd || null;
+      session.startedAt ||= payload.timestamp || timestamp || null;
+      continue;
+    }
+
+    if (record.type === "event_msg" && type === "user_message") {
+      current = {
+        number: turns.length + 1,
+        line: lineNumber,
+        timestamp,
+        timestampMs: Date.parse(timestamp),
+        userMessage: String(payload.message || ""),
+        imageCount: countImagesInPayload(payload),
+        fileMentionCount: countFileMentions(payload.message || ""),
+        screenshotMentionCount: countScreenshotMentions(payload.message || ""),
+        usage: emptyUsage(),
+        tokenCountLines: [],
+        assistantMessages: [],
+        commands: [],
+        commandOutputs: [],
+        patches: [],
+        patchFiles: [],
+        customCalls: [],
+        compaction: false,
+        compactionImages: 0,
+        abort: false,
+        rollback: false,
+        reasoningCount: 0,
+        lastTimestamp: timestamp,
+        lineEnd: lineNumber
+      };
+      turns.push(current);
+      continue;
+    }
+
+    if ((record.type === "event_msg" || record.type === "compacted") && type === "token_count") {
+      const usage = acceptProviderRequest(payload.info, requestTracker);
+      if (usage && current) {
+        // A human turn can cause several provider requests (tool-use cycles). C_t is the final
+        // de-duplicated request in log order, not the largest request seen during the turn.
+        current.usage = usage;
+        current.tokenCountLines.push(lineNumber);
+      }
+      continue;
+    }
+
+    if (!current) continue;
+    current.lineEnd = lineNumber;
+    current.lastTimestamp = timestamp || current.lastTimestamp;
+
+    if (record.type === "event_msg" || record.type === "compacted") {
+      if (type === "context_compacted" || type === "compacted") {
+        current.compaction = true;
+        current.compactionImages = Math.max(current.compactionImages, countImagesInPayload(payload.replacement_history || payload));
+      } else if (type === "turn_aborted") {
+        current.abort = true;
+      } else if (type === "thread_rolled_back") {
+        current.rollback = true;
+      } else if (type === "agent_message" && payload.message) {
+        current.assistantMessages.push({ line: lineNumber, text: String(payload.message) });
+      } else if (type === "patch_apply_end" && payload.changes) {
+        const files = Object.keys(payload.changes || {});
+        current.patchFiles.push(...files.map((file) => path.basename(file)));
+        current.patches.push({ line: lineNumber, files });
+      }
+      continue;
+    }
+
+    if (record.type !== "response_item") continue;
+
+    if (type === "reasoning") {
+      current.reasoningCount += 1;
+      continue;
+    }
+
+    if (type === "function_call") {
+      const command = payload.name === "exec_command" ? extractCommand(payload.arguments) : payload.name || "";
+      const meta = {
+        line: lineNumber,
+        callId: payload.call_id || null,
+        name: payload.name || null,
+        command,
+        normalized: normalizeCommand(command),
+        kind: commandKind(command),
+        file: readFileArg(command),
+        searchPattern: searchPattern(command)
+      };
+      current.commands.push(meta);
+      if (meta.callId) calls.set(meta.callId, { turn: current.number, command: meta });
+      continue;
+    }
+
+    if (type === "function_call_output") {
+      const call = calls.get(payload.call_id);
+      const output = typeof payload.output === "string" ? payload.output : JSON.stringify(payload.output || "");
+      const outputRow = {
+        line: lineNumber,
+        callId: payload.call_id || null,
+        command: call?.command || null,
+        tokens: estimateOutputTokens(output),
+        preview: compact(output).slice(0, 220)
+      };
+      current.commandOutputs.push(outputRow);
+      if (call?.command) call.command.outputTokens = outputRow.tokens;
+      continue;
+    }
+
+    if (type === "custom_tool_call" || type === "tool_call") {
+      current.customCalls.push({
+        line: lineNumber,
+        name: payload.name || payload.tool_name || null,
+        inputChars: String(payload.input || payload.arguments || "").length
+      });
+    }
+  }
+
+  for (let i = 0; i < turns.length; i += 1) {
+    turns[i].next = turns[i + 1] || null;
+    turns[i].prev = turns[i - 1] || null;
+  }
+
+  return { session, turns };
+}
+
+function detectP01(turns) {
+  return turns
+    .filter((turn) => turn.imageCount > 0 || turn.screenshotMentionCount > 0 || turn.compactionImages > 0)
+    .map((turn) => evidence(turn, "probable", "Image/screenshot payload or file reference appears in this turn.", {
+      signal: { imageCount: turn.imageCount, screenshotMentionCount: turn.screenshotMentionCount, compactionImages: turn.compactionImages }
+    }));
+}
+
+function detectP02(turns) {
+  const out = [];
+  for (const turn of turns) {
+    if (!correctionRe().test(turn.userMessage)) continue;
+    const prevText = [turn.prev?.userMessage || "", ...(turn.prev?.assistantMessages || []).map((msg) => msg.text)].join("\n");
+    if (constraintRe().test(prevText) || violationRe().test(turn.userMessage)) {
+      out.push(evidence(turn, "probable", "User correction follows nearby constraint or violation language.", {
+        relatedTurn: turn.prev?.number || null
+      }));
+    }
+  }
+  return out;
+}
+
+function detectP03(turns) {
+  const out = [];
+  const seen = new Map();
+  for (const turn of turns) {
+    for (const cmd of turn.commands.filter((cmd) => cmd.kind === "read" && cmd.file)) {
+      const key = `${turn.episode.id}:${cmd.file}`;
+      const prior = seen.get(key);
+      if (prior && turn.number - prior.turn >= 2) {
+        out.push(evidence(turn, "probable", `Repeated file read in same episode: ${cmd.file}.`, {
+          command: cmd.command,
+          priorTurn: prior.turn,
+          file: cmd.file
+        }));
+      } else if (!prior) {
+        seen.set(key, { turn: turn.number, command: cmd.command });
+      }
+    }
+    for (const cmd of turn.commands.filter((cmd) => /(backup|old|copy|v\d+|final|tmp|archive)/i.test(cmd.command))) {
+      out.push(evidence(turn, "edge", "Command references version-like or shadow-file naming.", { command: cmd.command }));
+    }
+  }
+  return out;
+}
+
+function detectP04(turns) {
+  const out = [];
+  for (const turn of turns) {
+    if (!turn.compaction) continue;
+    const before = turns.filter((candidate) => candidate.number <= turn.number);
+    const readFilesBefore = new Set(before.flatMap((candidate) => candidate.commands
+      .filter((cmd) => cmd.kind === "read" && cmd.file)
+      .map((cmd) => cmd.file)));
+    const replayCommandsBefore = new Set(before.flatMap((candidate) => candidate.commands
+      .filter((cmd) => ["search", "git"].includes(cmd.kind) && cmd.normalized)
+      .map((cmd) => cmd.normalized)));
+
+    for (const next of turns.slice(turn.number, turn.number + 3)) {
+      const rediscovery = next.commands.filter((cmd) => {
+        if (cmd.kind === "read" && cmd.file) return readFilesBefore.has(cmd.file);
+        if (["search", "git"].includes(cmd.kind) && cmd.normalized) return replayCommandsBefore.has(cmd.normalized);
+        return false;
+      });
+      if (rediscovery.length) {
+        out.push(evidence(next, "definitive", "Reacquired pre-compaction file/search/git state shortly after compaction.", {
+          afterCompactionTurn: turn.number,
+          commands: rediscovery.slice(0, 3).map((cmd) => cmd.command),
+          matchedFiles: rediscovery.filter((cmd) => cmd.file).slice(0, 3).map((cmd) => cmd.file)
+        }));
+      }
+    }
+  }
+  return out;
+}
+
+function detectP05(turns) {
+  const out = [];
+  for (const turn of turns) {
+    if (!correctionRe().test(turn.userMessage)) continue;
+    const prevDidWork = (turn.prev?.patches.length || 0) > 0 || (turn.prev?.assistantMessages || []).some((msg) => completionRe().test(msg.text));
+    if (prevDidWork) {
+      out.push(evidence(turn, "probable", "User correction follows previous completion/work signal.", {
+        relatedTurn: turn.prev?.number || null
+      }));
+    }
+  }
+  return out;
+}
+
+function detectP06(turns) {
+  const out = [];
+  for (const turn of turns) {
+    if (!turn.prev?.timestampMs || !turn.timestampMs) continue;
+    const gapMinutes = (turn.timestampMs - turn.prev.timestampMs) / 60000;
+    if (gapMinutes < 30) continue;
+    const reorient = reorientRe().test(turn.userMessage) || turn.commands.some((cmd) => ["read", "git", "search"].includes(cmd.kind));
+    if (reorient) {
+      out.push(evidence(turn, "probable", `Large gap followed by reorientation activity (${Math.round(gapMinutes)} minutes).`, {
+        gapMinutes: Math.round(gapMinutes)
+      }));
+    }
+  }
+  return out;
+}
+
+function detectP07(turns) {
+  return turns
+    .filter((turn) => turn.abort)
+    .map((turn) => evidence(turn, turn.rollback ? "edge" : "probable", "Turn aborted; check whether disk side effects survived.", {
+      patchFiles: turn.patchFiles,
+      rollback: turn.rollback
+    }));
+}
+
+function detectP08(turns) {
+  const out = [];
+  const seen = new Map();
+  for (const turn of turns) {
+    for (const cmd of turn.commands.filter((cmd) => cmd.kind === "git")) {
+      const key = `${turn.episode.id}:${cmd.normalized}`;
+      const prior = seen.get(key);
+      if (prior) {
+        out.push(evidence(turn, "probable", `Repeated git command in same episode: ${cmd.normalized}.`, {
+          command: cmd.command,
+          priorTurn: prior.turn
+        }));
+      } else {
+        seen.set(key, { turn: turn.number });
+      }
+    }
+  }
+  return out;
+}
+
+function detectP09(turns) {
+  const out = [];
+  const seen = new Map();
+  for (const turn of turns) {
+    if (manualRepairRe().test(turn.userMessage)) {
+      out.push(evidence(turn, "probable", "User gives repair/retry instruction that suggests execution drift.", {}));
+    }
+    for (const cmd of turn.commands.filter((cmd) => ["run", "command"].includes(cmd.kind))) {
+      const key = `${turn.episode.id}:${cmd.normalized}`;
+      const prior = seen.get(key);
+      if (prior && turn.number - prior.turn <= 8) {
+        out.push(evidence(turn, "edge", `Repeated execution command: ${cmd.normalized}.`, {
+          command: cmd.command,
+          priorTurn: prior.turn
+        }));
+      } else if (!prior) {
+        seen.set(key, { turn: turn.number });
+      }
+    }
+  }
+  return out;
+}
+
+function detectP10(turns) {
+  const out = [];
+  const seen = new Map();
+  for (const turn of turns) {
+    for (const cmd of turn.commands.filter((cmd) => cmd.kind === "search")) {
+      const key = `${turn.episode.id}:${cmd.normalized}`;
+      const prior = seen.get(key);
+      if (prior) {
+        out.push(evidence(turn, "probable", `Repeated search/query in same episode: ${cmd.normalized}.`, {
+          command: cmd.command,
+          priorTurn: prior.turn,
+          searchPattern: cmd.searchPattern
+        }));
+      } else {
+        seen.set(key, { turn: turn.number });
+      }
+    }
+  }
+  return out;
+}
+
+function finalizeProblem(meta, rawEvents, turns) {
+  const deduped = dedupeEvidence(rawEvents);
+  const turnNumbers = [...new Set(deduped.map((item) => item.turn))].sort((a, b) => a - b);
+  const qualifiedTurnNumbers = [
+    ...new Set(deduped.filter((item) => item.qualification !== "edge").map((item) => item.turn))
+  ].sort((a, b) => a - b);
+  const tokenPressure = turnNumbers.reduce((total, number) => total + (turns[number - 1]?.usage.inputTokens || 0), 0);
+  const qualifiedTokenPressure = qualifiedTurnNumbers.reduce((total, number) => total + (turns[number - 1]?.usage.inputTokens || 0), 0);
+  const episodePressure = {};
+  for (const number of turnNumbers) {
+    const turn = turns[number - 1];
+    const key = turn.episode.label;
+    episodePressure[key] = (episodePressure[key] || 0) + (turn.usage.inputTokens || 0);
+  }
+  const worstTurn = turnNumbers
+    .map((number) => turns[number - 1])
+    .sort((a, b) => (b?.usage.inputTokens || 0) - (a?.usage.inputTokens || 0))[0] || null;
+  const confidence = confidenceFor(deduped);
+  return {
+    ...meta,
+    eventsFound: deduped.length,
+    turns: turnNumbers,
+    qualifiedTurns: qualifiedTurnNumbers,
+    tokenPressure,
+    qualifiedTokenPressure,
+    exactWasteTokens: null,
+    costKind: "official_turn_token_pressure_not_exact_waste",
+    confidence,
+    worstTurn: worstTurn ? {
+      turn: worstTurn.number,
+      inputTokens: worstTurn.usage.inputTokens,
+      messagePreview: compact(worstTurn.userMessage).slice(0, 180)
+    } : null,
+    episodePressure,
+    evidence: deduped.slice(0, 8)
+  };
+}
+
+function evidence(turn, qualification, label, extra) {
+  return {
+    turn: turn.number,
+    episode: turn.episode?.label || null,
+    line: turn.line,
+    timestamp: turn.timestamp,
+    inputTokens: turn.usage.inputTokens,
+    cachedInputTokens: turn.usage.cachedInputTokens,
+    qualification,
+    label,
+    messagePreview: compact(turn.userMessage).slice(0, 220),
+    ...extra
+  };
+}
+
+function dedupeEvidence(items) {
+  const seen = new Set();
+  const out = [];
+  for (const item of items) {
+    const key = `${item.turn}:${item.label}:${item.command || ""}:${item.priorTurn || ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(item);
+  }
+  return out.sort((a, b) => a.turn - b.turn || String(a.label).localeCompare(String(b.label)));
+}
+
+function publicTurn(turn) {
+  return {
+    number: turn.number,
+    episode: turn.episode.label,
+    line: turn.line,
+    timestamp: turn.timestamp,
+    inputTokens: turn.usage.inputTokens,
+    cachedInputTokens: turn.usage.cachedInputTokens,
+    messagePreview: compact(turn.userMessage).slice(0, 220),
+    imageCount: turn.imageCount,
+    screenshotMentionCount: turn.screenshotMentionCount,
+    commands: turn.commands.length,
+    reads: turn.commands.filter((cmd) => cmd.kind === "read").length,
+    searches: turn.commands.filter((cmd) => cmd.kind === "search").length,
+    gitCalls: turn.commands.filter((cmd) => cmd.kind === "git").length,
+    patches: turn.patches.length,
+    patchFiles: [...new Set(turn.patchFiles)].sort(),
+    compaction: turn.compaction,
+    abort: turn.abort,
+    rollback: turn.rollback
+  };
+}
+
+function renderHtml(report) {
+  const maxPressure = Math.max(1, ...report.problems.map((problem) => problem.tokenPressure));
+  const problemRows = report.problems.map((problem) => {
+    const width = Math.max(1, Math.round(problem.tokenPressure / maxPressure * 100));
+    return `
+      <tr>
+        <td><b>${escapeHtml(problem.id)}</b><br><span>${escapeHtml(problem.name)}</span></td>
+        <td>${escapeHtml(problem.category)}</td>
+        <td class="num">${fmt(problem.eventsFound)}</td>
+        <td class="num">${fmt(problem.turns.length)}</td>
+        <td class="num">${fmt(problem.tokenPressure)}</td>
+        <td class="num">${fmt(problem.qualifiedTokenPressure)}</td>
+        <td><div class="bar" style="width:${width}%"></div></td>
+        <td>${escapeHtml(problem.worstTurn ? `T${problem.worstTurn.turn}` : "-")}<br><span>${escapeHtml(problem.worstTurn?.messagePreview || "")}</span></td>
+        <td>${escapeHtml(problem.costKind)}</td>
+      </tr>`;
+  }).join("");
+  const evidenceRows = report.problems.flatMap((problem) => problem.evidence.map((item) => `
+    <tr>
+      <td><b>${escapeHtml(problem.id)}</b><br><span>${escapeHtml(problem.name)}</span></td>
+      <td class="num">T${item.turn}</td>
+      <td>${escapeHtml(item.episode || "")}</td>
+      <td class="num">${fmt(item.inputTokens)}</td>
+      <td>${escapeHtml(item.qualification)}</td>
+      <td>${escapeHtml(item.label)}<br><span>${escapeHtml(item.messagePreview || "")}</span></td>
+    </tr>`)).join("");
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>10 Problem Analysis</title>
+<style>
+:root { color-scheme: light; --ink:#172033; --muted:#64748b; --line:#dbe4f0; --bg:#f7f9fc; --teal:#0f8a7a; --blue:#3267d6; }
+body { margin:0; background:var(--bg); color:var(--ink); font-family:Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+header { background:#fff; border-bottom:1px solid var(--line); padding:28px 32px 20px; }
+h1 { margin:0; font-size:26px; letter-spacing:0; }
+.sub { margin-top:8px; color:var(--muted); font-family:ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size:13px; }
+main { padding:22px 32px 44px; }
+.cards { display:grid; grid-template-columns:repeat(5,minmax(140px,1fr)); gap:10px; margin-bottom:22px; }
+.card { background:#fff; border:1px solid var(--line); border-radius:8px; padding:14px; }
+.card b { display:block; font-size:21px; }
+.card span { display:block; color:var(--muted); font-size:12px; margin-top:4px; }
+.note { max-width:980px; color:var(--muted); font-size:13px; line-height:1.5; margin:0 0 20px; }
+h2 { margin:28px 0 10px; font-size:15px; text-transform:uppercase; letter-spacing:.04em; }
+.table-wrap { overflow:auto; background:#fff; border:1px solid var(--line); border-radius:8px; }
+table { border-collapse:collapse; width:100%; min-width:980px; }
+th,td { border-bottom:1px solid #edf2f8; padding:10px 12px; text-align:left; vertical-align:top; font-size:13px; }
+th { color:var(--muted); background:#fbfdff; text-transform:uppercase; font-size:11px; letter-spacing:.05em; }
+td span { color:var(--muted); font-size:12px; }
+.num { text-align:right; font-family:ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; white-space:nowrap; }
+.bar { height:10px; border-radius:999px; background:linear-gradient(90deg,var(--teal),var(--blue)); min-width:2px; }
+</style>
+</head>
+<body>
+<header>
+  <h1>10 Problem Analysis</h1>
+  <div class="sub">${escapeHtml(report.session.id)}</div>
+</header>
+<main>
+  <section class="cards">
+    ${metricCard(fmt(report.session.turns), "turns")}
+    ${metricCard(fmt(report.session.tokenCountedTurns), "token-counted turns")}
+    ${metricCard(fmt(report.totals.officialInputTokens), "official input tokens")}
+    ${metricCard(fmt(report.totals.turnsWithAnyProblem), "turns with evidence")}
+    ${metricCard(fmt(report.problems.filter((p) => p.eventsFound).length), "problems present")}
+  </section>
+  <p class="note">${escapeHtml(report.method.costInterpretation)} Exact item-level waste requires matching main-model SQLite payloads.</p>
+  <h2>Problem Pressure</h2>
+  <div class="table-wrap">
+    <table>
+      <thead><tr><th>Problem</th><th>Category</th><th class="num">Events</th><th class="num">Turns</th><th class="num">Token Pressure</th><th class="num">Qualified Pressure</th><th>Bar</th><th>Worst Turn</th><th>Cost Kind</th></tr></thead>
+      <tbody>${problemRows}</tbody>
+    </table>
+  </div>
+  <h2>Evidence Samples</h2>
+  <div class="table-wrap">
+    <table>
+      <thead><tr><th>Problem</th><th class="num">Turn</th><th>Episode</th><th class="num">Input Tokens</th><th>Qualification</th><th>Evidence</th></tr></thead>
+      <tbody>${evidenceRows}</tbody>
+    </table>
+  </div>
+</main>
+</body>
+</html>`;
+}
+
+function metricCard(value, label) {
+  return `<div class="card"><b>${escapeHtml(value)}</b><span>${escapeHtml(label)}</span></div>`;
+}
+
+function episodeForTurn(number, episodes) {
+  return episodes.find((episode) => number >= episode.start && number <= episode.end) || episodes[episodes.length - 1];
+}
+
+function commandKind(command) {
+  const first = firstCommand(command);
+  if (["rg", "grep", "ag", "ack", "find", "fd", "fgrep", "egrep"].includes(first)) return "search";
+  if (["cat", "head", "tail", "sed", "nl", "less", "more", "bat", "strings", "view"].includes(first)) return "read";
+  if (first === "git") return "git";
+  if (["npm", "pnpm", "yarn", "node", "npx", "pytest", "cargo", "go"].includes(first)) return "run";
+  if (/^[a-z_]+$/.test(first) && !String(command || "").includes(" ")) return "tool";
+  return "command";
+}
+
+function firstCommand(command) {
+  return String(command || "").split("|")[0].split(">")[0].trim().split(/\s+/)[0]?.split("/").pop() || "";
+}
+
+function normalizeCommand(command) {
+  return compact(String(command || ""))
+    .replace(/["'][^"']{40,}["']/g, "\"...\"")
+    .replace(/\b\d{4,}\b/g, "N")
+    .slice(0, 220);
+}
+
+function extractCommand(argumentsValue) {
+  if (!argumentsValue) return "";
+  if (typeof argumentsValue === "object") return argumentsValue.cmd || argumentsValue.command || "";
+  try {
+    const parsed = JSON.parse(argumentsValue);
+    return parsed.cmd || parsed.command || "";
+  } catch {
+    return String(argumentsValue);
+  }
+}
+
+function readFileArg(command) {
+  const text = String(command || "");
+  const parts = text.split(/\s+/).filter(Boolean);
+  const first = firstCommand(text);
+  if (!["cat", "head", "tail", "sed", "nl", "less", "more", "bat"].includes(first)) return null;
+  const candidate = [...parts].reverse().find((part) => !part.startsWith("-") && !/^\d/.test(part) && !part.includes("="));
+  return candidate ? path.basename(candidate.replace(/^['"]|['"]$/g, "")) : null;
+}
+
+function searchPattern(command) {
+  const text = String(command || "");
+  const first = firstCommand(text);
+  if (!["rg", "grep", "ag", "ack"].includes(first)) return null;
+  const match = text.match(/(?:rg|grep|ag|ack)\s+(?:-[^\s]+\s+)*['"]?([^'"\s][^'"]{0,80})/);
+  return match ? compact(match[1]) : compact(text).slice(0, 80);
+}
+
+function estimateOutputTokens(output) {
+  const text = String(output || "");
+  const match = text.match(/Original token count:\s*(\d+)/);
+  if (match) return Math.min(Number(match[1]), 12000);
+  return Math.min(Math.round(text.length / 3.3), 12000);
+}
+
+function countImagesInPayload(value) {
+  let count = 0;
+  visit(value);
+  return count;
+  function visit(node) {
+    if (!node) return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (typeof node === "object") {
+      if (node.type === "input_image") {
+        count += 1;
+        return;
+      }
+      if (typeof node.image_url === "string" && node.image_url) count += 1;
+      if (typeof node.local_image === "string" && node.local_image) count += 1;
+      if (Array.isArray(node.local_images)) count += node.local_images.length;
+      for (const item of Object.values(node)) visit(item);
+      return;
+    }
+    if (typeof node === "string" && /data:image\/|codex-clipboard-|\.png|\.jpe?g|\.webp/i.test(node)) count += 1;
+  }
+}
+
+function countFileMentions(text) {
+  return (String(text || "").match(/(?:^|\s)##?\s+[^:\n]+:|\/[\w./-]+\.\w+/g) || []).length;
+}
+
+function countScreenshotMentions(text) {
+  return (String(text || "").match(/codex-clipboard-|\.png|\.jpe?g|screenshot|image|picture/gi) || []).length;
+}
+
+function normalizeUsage(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 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;
+    // Codex can emit several snapshots while one provider request is still generating output.
+    // Only cumulative input grows when the next request starts, so output/total growth must not
+    // create a false request boundary. Keep this ledger session-global so a repeated snapshot
+    // cannot migrate into the following human turn.
+    if (cumulativeInput <= tracker.cumulativeInputTokens) return null;
+    tracker.cumulativeInputTokens = cumulativeInput;
+    if (!last || typeof last !== "object") return null;
+    const usage = normalizeUsage(last);
+    tracker.legacyFingerprint = usageFingerprint(usage);
+    return usage;
+  }
+
+  // Backward compatibility for older fixtures/logs that predate total_token_usage. Keep the
+  // fingerprint global across human turns so an identical repeated snapshot cannot migrate forward.
+  if (tracker.sawCumulativeInput || !last || typeof last !== "object") return null;
+  const usage = normalizeUsage(last);
+  const fingerprint = usageFingerprint(usage);
+  if (fingerprint === tracker.legacyFingerprint) return null;
+  tracker.legacyFingerprint = fingerprint;
+  return usage;
+}
+
+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 usageFingerprint(usage) {
+  return [usage.inputTokens, usage.cachedInputTokens, usage.outputTokens, usage.reasoningOutputTokens, usage.totalTokens].join(":");
+}
+
+function emptyUsage() {
+  return normalizeUsage({});
+}
+
+function confidenceFor(items) {
+  if (items.some((item) => item.qualification === "definitive")) return 0.9;
+  if (items.some((item) => item.qualification === "probable")) return 0.7;
+  if (items.length) return 0.45;
+  return 0;
+}
+
+function correctionRe() {
+  return /\b(wrong|fix it|still|not correct|not right|undo|redo|revert|delete|remove|broken|laggy|doesn't|isn't|should be|shouldn't|should not|don't need|do not need|we don't want|we do not want|no swiping|no fading|no tilt|no rotation|不对|错|还是不|重新)\b/i;
+}
+
+function constraintRe() {
+  return /\b(must|should|cannot|can't|keep|preserve|protect|private|constraint|don't|do not|不要|不能|必须|保留)\b/i;
+}
+
+function violationRe() {
+  return /\b(you changed|you removed|should have|should be|shouldn't|should not|not supposed|don't need|do not need|we don't want|we do not want|no swiping|no fading|no tilt|no rotation|怎么|不能这样|不该)\b/i;
+}
+
+function completionRe() {
+  return /\b(done|fixed|implemented|updated|should now|looks good|works|complete|完成|好了)\b/i;
+}
+
+function reorientRe() {
+  return /\b(resume|recap|where were we|continue|last time|still|current state|上次|继续|恢复|总结|还记得)\b/i;
+}
+
+function manualRepairRe() {
+  return /\b(still|again|fix it|try again|redo|not working|doesn't work|isn't|should be|shouldn't|should not|don't need|do not need|we don't want|we do not want|no swiping|no fading|no tilt|no rotation|please do|重新|还是不|再来)\b/i;
+}
+
+function findSessionJsonl(id) {
+  const root = path.join(os.homedir(), ".codex", "sessions");
+  const found = [];
+  visit(root);
+  if (!found.length) throw new Error(`Could not find JSONL for session id ${id} under ${root}`);
+  found.sort();
+  return found[0];
+  function visit(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) visit(full);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl") && entry.name.includes(id)) found.push(full);
+    }
+  }
+}
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      out._.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) out[key] = true;
+    else {
+      out[key] = next;
+      i += 1;
+    }
+  }
+  return out;
+}
+
+function sum(items, pick) {
+  return items.reduce((total, item) => total + Number(pick(item) || 0), 0);
+}
+
+function compact(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
+function fmt(value) {
+  return Number(value || 0).toLocaleString();
+}
+
+function escapeHtml(value) {
+  return String(value ?? "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}