@echomem/mcp 1.4.39 → 1.4.41

package/dist/forensics-10-problems.js

@@ -1,633 +0,0 @@
-/**
- * forensics-10-problems.ts — Incremental turn-level dirty-context problem scanner.
- *
- * Complements forensics.ts (static aggregate scan) with TURN-LEVEL labeling of 10
- * canonical dirty-context degradation patterns. For each session, walks turns in order,
- * detects problems, attributes wasted tokens per problem, and aggregates workspace-wide.
- *
- * The 10 problems (from the dirty-context canonical spec):
- *   P01  Image flood — binary blobs compaction can't clear
- *   P02  Correction cascade — ≥2 consecutive rework turns
- *   P03  Shadow file versions — stale read coexists with newer edit in context
- *   P04  Post-compaction re-discovery — re-reading unchanged files after context drop
- *   P05  False completion — agent commits, user immediately reworks
- *   P06  Gap state disconnect — long idle gap → re-orientation reads
- *   P07  Abort leaves bad patch — edit followed by user revert/undo
- *   P08  Git as memory substitute — repeated identical git queries
- *   P09  User pulls back trajectory — ≥2 explicit redirects in session
- *   P10  Search replay — duplicate grep/find/search commands
- *
- * Detection tiers:
- *   Tier 1 (deterministic, high confidence): P01, P04, P08, P10
- *   Tier 2 (structural heuristic, medium):   P03, P06, P07
- *   Tier 3 (keyword classification, lower):  P02, P05, P09
- *
- * All data stays local. No LLM calls. Transcripts never leave the machine.
- */
-import path from "node:path";
-import { eachLine, walk } from "./report.js";
-import { discoverCodexSessionFiles } from "./codex-session-files.js";
-import { resolveClaudeProjectsDir } from "./local-data-paths.js";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const IMAGE_RE = /\.(png|jpe?g|gif|webp|svg|ico|avif|bmp|mp4|mov)$/i;
-const CHARS_PER_TOKEN = 4;
-const GAP_MS = 30 * 60 * 1000; // 30 min gap = state disconnect
-const GIT_MEMORY_SUBS = new Set(["log", "show", "diff", "blame", "grep"]);
-const SEARCH_BINS = new Set(["grep", "egrep", "fgrep", "rg", "ag", "ack", "find", "fd"]);
-const SHELL_READ_BINS = new Set(["cat", "head", "tail", "less", "more", "bat", "nl", "sed", "awk"]);
-// Bilingual keyword classifiers — ported from turn-outcome.mjs with false-positive cleanup.
-const REWORK_RE = /(?<!对)不对|并不是|不是这样|不是我[要想说]|还是[不没]|又(?:回到|错|坏)|错了|搞错|理解错|弄错|重做|重新[做写改]|没(?:有)?(?:生效|起作用|变化)|不应该|不是让你|revert|undo|roll\s*back|\bthat'?s not (?:right|what|it)\b|\bnot what i\b|\bstill (?:broken|wrong|failing|not working|the same)\b|\byou (?:should have|were supposed)\b|\bredo\b/i;
-const REDIRECT_RE = /我说的是|我(?:之前|刚才)说|focus on|回到|你跑偏|不是要你|你在(?:做|干)什么|为什么在|let'?s get back|back to (?:the|what)|you'?re going off/i;
-const ABORT_RE = /revert|undo|roll\s*back|恢复|撤[回销]|回退|还原/i;
-const COMMIT_RE = /\bgit\s+(?:commit|push)\b/;
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function tokensFromChars(chars) {
-    return Math.round(chars / CHARS_PER_TOKEN);
-}
-function isRealUserText(text) {
-    if (typeof text !== "string")
-        return false;
-    const t = text.trim();
-    if (!t || t.startsWith("<") || t.startsWith("Caveat:") || t.startsWith("[Request interrupted"))
-        return false;
-    if (t.includes("<command-name>") || t.includes("<local-command"))
-        return false;
-    return true;
-}
-function cleanUserText(text) {
-    return text
-        .replace(/#\s*Files? mentioned by the user:[\s\S]*$/i, "")
-        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
-        .trim();
-}
-function classifyVerdict(text) {
-    const s = cleanUserText(text);
-    if (!s)
-        return "neutral";
-    if (REWORK_RE.test(s))
-        return "rework";
-    return "neutral";
-}
-function contentLength(content) {
-    if (content == null)
-        return 0;
-    if (typeof content === "string")
-        return content.length;
-    try {
-        return JSON.stringify(content).length;
-    }
-    catch {
-        return 0;
-    }
-}
-// ---------------------------------------------------------------------------
-// Command normalization for dedup detection
-// ---------------------------------------------------------------------------
-function gitReadKey(cmd) {
-    const m = cmd.match(/\bgit\s+(log|show|diff|blame|grep)\b/);
-    if (!m)
-        return null;
-    return cmd.trim().replace(/\s+/g, " ");
-}
-function searchKey(cmd) {
-    const first = cmd.trim().split(/[|;&\n]/)[0].trim();
-    const bin = (first.split(/\s+/)[0] || "").split("/").pop() || "";
-    if (!SEARCH_BINS.has(bin))
-        return null;
-    return first.replace(/\s+/g, " ");
-}
-function extractReadFile(cmd) {
-    const tokens = cmd.trim().split(/\s+/);
-    const bin = (tokens[0] || "").split("/").pop() || "";
-    if (!SHELL_READ_BINS.has(bin))
-        return null;
-    for (let i = tokens.length - 1; i >= 1; i--) {
-        const t = tokens[i].replace(/['"]/g, "");
-        if (!t || t.startsWith("-"))
-            continue;
-        if (t.includes("/") || /\.\w{1,6}$/.test(t))
-            return t;
-    }
-    return null;
-}
-const PROBLEM_META = [
-    { id: "P01", name: "Image flood", tier: 1, confidence: "high" },
-    { id: "P02", name: "Correction cascade", tier: 3, confidence: "low" },
-    { id: "P03", name: "Shadow file versions", tier: 2, confidence: "medium" },
-    { id: "P04", name: "Post-compaction re-discovery", tier: 1, confidence: "high" },
-    { id: "P05", name: "False completion", tier: 3, confidence: "low" },
-    { id: "P06", name: "Gap state disconnect", tier: 2, confidence: "medium" },
-    { id: "P07", name: "Abort leaves bad patch", tier: 2, confidence: "medium" },
-    { id: "P08", name: "Git as memory substitute", tier: 1, confidence: "high" },
-    { id: "P09", name: "User pulls back trajectory", tier: 3, confidence: "low" },
-    { id: "P10", name: "Search replay", tier: 1, confidence: "high" },
-];
-// ---------------------------------------------------------------------------
-// Turn parsers — translate each log schema into a common Turn[]
-// ---------------------------------------------------------------------------
-function parseCodexTurns(file) {
-    const turns = [];
-    let cur = null;
-    const pending = new Map();
-    const pushTurn = (text, ts) => {
-        cur = {
-            index: turns.length, ts, userText: text, inputTokens: 0, outputTokens: 0,
-            tools: [], editedFiles: [], committed: false, compacted: false,
-        };
-        turns.push(cur);
-    };
-    eachLine(file, (o) => {
-        const ts = typeof o.timestamp === "string" ? Date.parse(o.timestamp) : NaN;
-        const tsMs = Number.isFinite(ts) ? ts : null;
-        const p = o && typeof o.payload === "object" && o.payload ? o.payload : o;
-        if (!p || typeof p !== "object")
-            return;
-        if (p.type === "context_compacted") {
-            if (cur)
-                cur.compacted = true;
-            return;
-        }
-        if (p.type === "user_message") {
-            pushTurn(String(p.message ?? p.content ?? p.text ?? ""), tsMs);
-            return;
-        }
-        if (!cur)
-            return;
-        if (p.type === "token_count" && p.info?.last_token_usage) {
-            const u = p.info.last_token_usage;
-            if (u.input_tokens)
-                cur.inputTokens = Math.max(cur.inputTokens, u.input_tokens);
-            cur.outputTokens += u.output_tokens || 0;
-        }
-        if (p.type === "patch_apply_end" && p.changes) {
-            for (const target of Object.keys(p.changes))
-                cur.editedFiles.push(path.basename(target));
-        }
-        if (p.type === "function_call") {
-            const name = String(p.name || "");
-            let args = p.arguments;
-            if (typeof args === "string") {
-                try {
-                    args = JSON.parse(args);
-                }
-                catch {
-                    args = {};
-                }
-            }
-            const cmd = typeof (args?.cmd ?? args?.command) === "string" ? (args.cmd || args.command) : null;
-            const tc = {
-                name, file: null, command: cmd, id: p.call_id || null,
-                outputChars: 0, isImage: false, gitKey: null, searchKey: null,
-            };
-            if (cmd) {
-                if (COMMIT_RE.test(cmd))
-                    cur.committed = true;
-                tc.gitKey = gitReadKey(cmd);
-                tc.searchKey = searchKey(cmd);
-                const readFile = extractReadFile(cmd);
-                if (readFile) {
-                    tc.file = path.basename(readFile);
-                    tc.isImage = IMAGE_RE.test(readFile);
-                }
-            }
-            if (name === "view_image" || /image|screenshot/i.test(name))
-                tc.isImage = true;
-            cur.tools.push(tc);
-            if (tc.id)
-                pending.set(tc.id, tc);
-        }
-        if (p.type === "function_call_output" && p.call_id && pending.has(p.call_id)) {
-            pending.get(p.call_id).outputChars = contentLength(p.output);
-            pending.delete(p.call_id);
-        }
-    });
-    return turns;
-}
-function parseClaudeTurns(file) {
-    const turns = [];
-    let cur = null;
-    const pending = new Map();
-    const pushTurn = (text, ts) => {
-        cur = {
-            index: turns.length, ts, userText: text, inputTokens: 0, outputTokens: 0,
-            tools: [], editedFiles: [], committed: false, compacted: false,
-        };
-        turns.push(cur);
-    };
-    eachLine(file, (o) => {
-        const ts = typeof o.timestamp === "string" ? Date.parse(o.timestamp) : NaN;
-        const tsMs = Number.isFinite(ts) ? ts : null;
-        if (o.subtype === "compact_boundary" || o.isCompactSummary === true) {
-            if (cur)
-                cur.compacted = true;
-            return;
-        }
-        if (o.type === "user" && !o.isMeta && o.message) {
-            const c = o.message.content;
-            let text = "";
-            if (typeof c === "string") {
-                text = c;
-            }
-            else if (Array.isArray(c)) {
-                text = c.filter((b) => b?.type === "text").map((b) => b.text || "").join(" ");
-                for (const b of c) {
-                    if (b?.type === "tool_result" && b.tool_use_id && pending.has(b.tool_use_id)) {
-                        pending.get(b.tool_use_id).outputChars = contentLength(b.content);
-                        pending.delete(b.tool_use_id);
-                    }
-                }
-            }
-            if (isRealUserText(text) && !o.isSidechain)
-                pushTurn(text, tsMs);
-            return;
-        }
-        if (o.type === "assistant" && o.message) {
-            if (!cur)
-                return;
-            const u = o.message.usage;
-            if (u) {
-                const inp = (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0);
-                cur.inputTokens = Math.max(cur.inputTokens, inp);
-                cur.outputTokens += u.output_tokens || 0;
-            }
-            const content = o.message.content;
-            if (!Array.isArray(content))
-                return;
-            for (const b of content) {
-                if (b?.type !== "tool_use")
-                    continue;
-                const name = String(b.name || "");
-                const inp = b.input || {};
-                const tc = {
-                    name, file: null, command: null, id: b.id || null,
-                    outputChars: 0, isImage: false, gitKey: null, searchKey: null,
-                };
-                if (name === "Read") {
-                    tc.file = path.basename(inp.file_path || "");
-                    tc.isImage = IMAGE_RE.test(inp.file_path || "");
-                }
-                else if (name === "Edit" || name === "Write" || name === "MultiEdit") {
-                    cur.editedFiles.push(path.basename(inp.file_path || ""));
-                }
-                else if (name === "Bash" && typeof inp.command === "string") {
-                    tc.command = inp.command;
-                    if (COMMIT_RE.test(inp.command))
-                        cur.committed = true;
-                    tc.gitKey = gitReadKey(inp.command);
-                    tc.searchKey = searchKey(inp.command);
-                    const readFile = extractReadFile(inp.command);
-                    if (readFile) {
-                        tc.file = path.basename(readFile);
-                        tc.isImage = IMAGE_RE.test(readFile);
-                    }
-                }
-                else if (name === "Grep" || name === "Glob" || name === "LS") {
-                    tc.searchKey = `${name}:${inp.pattern || inp.path || ""}`;
-                }
-                cur.tools.push(tc);
-                if (tc.id)
-                    pending.set(tc.id, tc);
-            }
-        }
-    });
-    return turns;
-}
-// ---------------------------------------------------------------------------
-// Problem scanner — walks turns in order, maintains cross-turn state
-// ---------------------------------------------------------------------------
-function scanSession(turns, sessionLabel) {
-    // ---- Cross-turn state ----
-    const fileVersions = new Map();
-    const readHistory = new Map();
-    const gitCmds = new Map();
-    const searchCmds = new Map();
-    let lastCompactTurn = -1;
-    let prevTs = null;
-    const results = [];
-    // ==== First pass: Tier 1 + Tier 2 detection ====
-    for (let i = 0; i < turns.length; i++) {
-        const t = turns[i];
-        const problems = [];
-        // ---- Detect P06: gap → re-orientation reads ----
-        const hasGap = prevTs != null && t.ts != null && (t.ts - prevTs) > GAP_MS;
-        const gapMin = hasGap ? Math.round((t.ts - prevTs) / 60_000) : 0;
-        // ---- Per-tool detection (using state BEFORE this turn's updates) ----
-        let imageTokens = 0;
-        let postCompactTokens = 0;
-        const postCompactFiles = [];
-        let gapReorientTokens = 0;
-        const gapReorientFiles = [];
-        let dupGitTokens = 0;
-        const dupGitKeys = [];
-        let dupSearchTokens = 0;
-        const dupSearchKeys = [];
-        const turnReadEntries = [];
-        for (const tc of t.tools) {
-            const outTokens = tokensFromChars(tc.outputChars);
-            // --- P01: image content ---
-            if (tc.isImage && outTokens > 0) {
-                imageTokens += outTokens;
-            }
-            // --- File reads: P04 (post-compaction) + P06 (gap re-orientation) ---
-            if (tc.file && !tc.isImage) {
-                const base = tc.file;
-                const curVer = fileVersions.get(base) || 0;
-                turnReadEntries.push({ file: base, version: curVer, tokens: outTokens });
-                // P04: file was read before the most recent compaction, at the same version
-                if (lastCompactTurn >= 0 && i > lastCompactTurn) {
-                    const priorRead = readHistory.get(base)?.find((r) => r.turn <= lastCompactTurn && r.version === curVer);
-                    if (priorRead) {
-                        postCompactTokens += outTokens;
-                        postCompactFiles.push(base);
-                    }
-                }
-                // P06: file was read before the gap, now re-read after it
-                if (hasGap) {
-                    const priorRead = readHistory.get(base)?.find((r) => r.turn < i);
-                    if (priorRead) {
-                        gapReorientTokens += outTokens;
-                        gapReorientFiles.push(base);
-                    }
-                }
-            }
-            // --- P08: duplicate git queries ---
-            if (tc.gitKey) {
-                const prev = gitCmds.get(tc.gitKey);
-                if (prev && prev.length > 0) {
-                    dupGitTokens += outTokens;
-                    dupGitKeys.push(tc.gitKey);
-                }
-            }
-            // --- P10: duplicate search commands ---
-            if (tc.searchKey) {
-                const prev = searchCmds.get(tc.searchKey);
-                if (prev && prev.length > 0) {
-                    dupSearchTokens += outTokens;
-                    dupSearchKeys.push(tc.searchKey);
-                }
-            }
-        }
-        // ---- State updates (AFTER detection) ----
-        // Update read history
-        for (const entry of turnReadEntries) {
-            if (!readHistory.has(entry.file))
-                readHistory.set(entry.file, []);
-            readHistory.get(entry.file).push({ turn: i, version: entry.version, tokens: entry.tokens });
-        }
-        // Update git/search history
-        for (const tc of t.tools) {
-            if (tc.gitKey) {
-                if (!gitCmds.has(tc.gitKey))
-                    gitCmds.set(tc.gitKey, []);
-                gitCmds.get(tc.gitKey).push(i);
-            }
-            if (tc.searchKey) {
-                if (!searchCmds.has(tc.searchKey))
-                    searchCmds.set(tc.searchKey, []);
-                searchCmds.get(tc.searchKey).push(i);
-            }
-        }
-        // P03: edits create shadow versions of previously-read files still in context
-        let shadowTokens = 0;
-        const shadowFiles = [];
-        for (const editedFile of t.editedFiles) {
-            fileVersions.set(editedFile, (fileVersions.get(editedFile) || 0) + 1);
-            const history = readHistory.get(editedFile);
-            if (history) {
-                const curVer = fileVersions.get(editedFile) || 0;
-                for (const r of history) {
-                    if (r.version < curVer && r.turn > lastCompactTurn) {
-                        shadowTokens += r.tokens;
-                        if (!shadowFiles.includes(editedFile))
-                            shadowFiles.push(editedFile);
-                    }
-                }
-            }
-        }
-        // Compaction tracking (after detection so this turn's reads are pre-compaction)
-        if (t.compacted)
-            lastCompactTurn = i;
-        if (t.ts != null)
-            prevTs = t.ts;
-        // ---- Emit problem hits ----
-        if (imageTokens > 0) {
-            problems.push({ id: "P01", wastedTokens: imageTokens, confidence: "high",
-                evidence: `${imageTokens} tokens of image/binary content loaded` });
-        }
-        if (shadowTokens > 0) {
-            problems.push({ id: "P03", wastedTokens: shadowTokens, confidence: "medium",
-                evidence: `Edit to ${shadowFiles.join(", ")} shadowed ${shadowTokens} stale-read tokens still in context` });
-        }
-        if (postCompactTokens > 0) {
-            problems.push({ id: "P04", wastedTokens: postCompactTokens, confidence: "high",
-                evidence: `Re-read ${[...new Set(postCompactFiles)].join(", ")} unchanged after compaction; ${postCompactTokens} tokens re-gathered` });
-        }
-        if (gapReorientTokens > 0) {
-            problems.push({ id: "P06", wastedTokens: gapReorientTokens, confidence: "medium",
-                evidence: `${gapMin}min gap → re-read ${[...new Set(gapReorientFiles)].join(", ")}; ${gapReorientTokens} tokens` });
-        }
-        if (dupGitTokens > 0) {
-            problems.push({ id: "P08", wastedTokens: dupGitTokens, confidence: "high",
-                evidence: `Duplicate git queries (${[...new Set(dupGitKeys)].length} unique); ${dupGitTokens} tokens` });
-        }
-        if (dupSearchTokens > 0) {
-            problems.push({ id: "P10", wastedTokens: dupSearchTokens, confidence: "high",
-                evidence: `Duplicate searches (${[...new Set(dupSearchKeys)].length} unique); ${dupSearchTokens} tokens` });
-        }
-        const wastedSum = problems.reduce((s, p) => s + p.wastedTokens, 0);
-        results.push({
-            index: i, inputTokens: t.inputTokens, outputTokens: t.outputTokens,
-            verdict: "neutral", problems, wastedTokens: wastedSum,
-        });
-    }
-    // ==== Second pass: verdicts + Tier 3 problems (P02, P05, P07, P09) ====
-    // Compute verdicts: verdict of turn i = classify the user text of turn i+1.
-    for (let i = 0; i < turns.length - 1; i++) {
-        results[i].verdict = classifyVerdict(turns[i + 1].userText);
-    }
-    // P02: correction cascade — ≥2 consecutive rework-verdict turns
-    let cascadeStart = -1;
-    let cascadeLen = 0;
-    for (let i = 0; i <= results.length; i++) {
-        const isRework = i < results.length && results[i].verdict === "rework";
-        if (isRework) {
-            if (cascadeStart < 0)
-                cascadeStart = i;
-            cascadeLen++;
-        }
-        else {
-            if (cascadeLen >= 2) {
-                // Turns after the first in the cascade are the avoidable waste.
-                for (let j = cascadeStart + 1; j < cascadeStart + cascadeLen; j++) {
-                    const waste = results[j].outputTokens;
-                    if (waste > 0) {
-                        results[j].problems.push({ id: "P02", wastedTokens: waste, confidence: "low",
-                            evidence: `Turn ${j} in ${cascadeLen}-turn correction cascade (started turn ${cascadeStart})` });
-                        results[j].wastedTokens += waste;
-                    }
-                }
-            }
-            cascadeStart = -1;
-            cascadeLen = 0;
-        }
-    }
-    // P05: false completion — agent committed, next turn is rework
-    for (let i = 0; i < turns.length - 1; i++) {
-        if (turns[i].committed && results[i + 1].verdict === "rework") {
-            const waste = results[i].outputTokens;
-            if (waste > 0) {
-                results[i].problems.push({ id: "P05", wastedTokens: waste, confidence: "low",
-                    evidence: `Committed at turn ${i} but turn ${i + 1} is a rework` });
-                results[i].wastedTokens += waste;
-            }
-        }
-    }
-    // P07: abort → revert — user says revert/undo and previous turn had edits
-    for (let i = 1; i < turns.length; i++) {
-        if (ABORT_RE.test(cleanUserText(turns[i].userText)) && turns[i - 1].editedFiles.length > 0) {
-            const waste = results[i - 1].outputTokens;
-            if (waste > 0) {
-                results[i - 1].problems.push({ id: "P07", wastedTokens: waste, confidence: "medium",
-                    evidence: `Edits at turn ${i - 1} (${turns[i - 1].editedFiles.slice(0, 3).join(", ")}) reverted at turn ${i}` });
-                results[i - 1].wastedTokens += waste;
-            }
-        }
-    }
-    // P09: user pulls back trajectory — ≥2 redirect messages in session
-    const redirectTurns = [];
-    for (let i = 0; i < turns.length; i++) {
-        if (REDIRECT_RE.test(cleanUserText(turns[i].userText)))
-            redirectTurns.push(i);
-    }
-    if (redirectTurns.length >= 2) {
-        for (const ri of redirectTurns) {
-            if (ri > 0) {
-                const waste = results[ri - 1].outputTokens;
-                if (waste > 0) {
-                    results[ri - 1].problems.push({ id: "P09", wastedTokens: waste, confidence: "low",
-                        evidence: `User redirect at turn ${ri}; agent went off-track at turn ${ri - 1}` });
-                    results[ri - 1].wastedTokens += waste;
-                }
-            }
-        }
-    }
-    return results;
-}
-// ---------------------------------------------------------------------------
-// Aggregation — merge per-session results into a workspace-level report
-// ---------------------------------------------------------------------------
-function localDay(ms) {
-    const d = new Date(ms);
-    const m = String(d.getMonth() + 1).padStart(2, "0");
-    const day = String(d.getDate()).padStart(2, "0");
-    return `${d.getFullYear()}-${m}-${day}`;
-}
-function aggregateResults(sessionResults, firstTs, lastTs) {
-    let totalInput = 0;
-    let totalWaste = 0;
-    let turnCount = 0;
-    const byProblem = new Map();
-    for (const m of PROBLEM_META) {
-        byProblem.set(m.id, { turnKeys: new Set(), tokens: 0, episodes: [] });
-    }
-    for (const { session, results } of sessionResults) {
-        turnCount += results.length;
-        for (const r of results) {
-            totalInput += r.inputTokens;
-            totalWaste += r.wastedTokens;
-            for (const p of r.problems) {
-                const bucket = byProblem.get(p.id);
-                bucket.turnKeys.add(`${session}:${r.index}`);
-                bucket.tokens += p.wastedTokens;
-                bucket.episodes.push({
-                    session, turns: [r.index], wastedTokens: p.wastedTokens, evidence: p.evidence,
-                });
-            }
-        }
-    }
-    const problems = PROBLEM_META.map((m) => {
-        const bucket = byProblem.get(m.id);
-        return {
-            id: m.id, name: m.name, tier: m.tier, confidence: m.confidence,
-            turnsAffected: bucket.turnKeys.size,
-            turnsAffectedPct: turnCount > 0 ? Math.round((bucket.turnKeys.size / turnCount) * 100) : 0,
-            wastedTokens: bucket.tokens,
-            wastedPct: totalWaste > 0 ? Math.round((bucket.tokens / totalWaste) * 100) : 0,
-            topEpisodes: bucket.episodes.sort((a, b) => b.wastedTokens - a.wastedTokens).slice(0, 5),
-        };
-    });
-    return {
-        schemaVersion: 1,
-        generatedFrom: ["~/.codex/sessions", "~/.claude/projects"],
-        llmCallsUsed: 0,
-        transcriptsUploaded: false,
-        scanWindow: {
-            first: firstTs != null ? localDay(firstTs) : null,
-            last: lastTs != null ? localDay(lastTs) : null,
-        },
-        sessionCount: sessionResults.length,
-        turnCount,
-        overall: {
-            totalInputTokens: totalInput,
-            totalWastedTokens: totalWaste,
-            wasteRate: totalInput > 0 ? Math.round((totalWaste / totalInput) * 10_000) / 10_000 : 0,
-            avgWastePerTurn: turnCount > 0 ? Math.round(totalWaste / turnCount) : 0,
-        },
-        problems,
-    };
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export function buildProblemReport(opts) {
-    const sources = opts?.sources ?? ["codex", "claude"];
-    const codexDiscovery = sources.includes("codex") ? discoverCodexSessionFiles({ includeArchived: true }) : null;
-    const claudeRoot = sources.includes("claude") ? resolveClaudeProjectsDir() : null;
-    const codexFiles = codexDiscovery?.files.map((file) => file.path) ?? [];
-    const claudeFiles = claudeRoot
-        ? walk(claudeRoot, (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows").sort()
-        : [];
-    const total = codexFiles.length + claudeFiles.length;
-    let done = 0;
-    const tick = () => {
-        done++;
-        if (opts?.onProgress && (done % 8 === 0 || done === total))
-            opts.onProgress(done, total);
-    };
-    const sessionResults = [];
-    let globalFirstTs = null;
-    let globalLastTs = null;
-    const trackTs = (turns) => {
-        for (const t of turns) {
-            if (t.ts != null) {
-                if (globalFirstTs == null || t.ts < globalFirstTs)
-                    globalFirstTs = t.ts;
-                if (globalLastTs == null || t.ts > globalLastTs)
-                    globalLastTs = t.ts;
-            }
-        }
-    };
-    for (const f of codexFiles) {
-        const turns = parseCodexTurns(f);
-        if (turns.length > 0) {
-            trackTs(turns);
-            const label = path.basename(f, ".jsonl").slice(0, 16);
-            sessionResults.push({ session: label, results: scanSession(turns, label) });
-        }
-        tick();
-    }
-    for (const f of claudeFiles) {
-        const turns = parseClaudeTurns(f);
-        if (turns.length > 0) {
-            trackTs(turns);
-            const label = path.basename(f, ".jsonl").slice(0, 16);
-            sessionResults.push({ session: label, results: scanSession(turns, label) });
-        }
-        tick();
-    }
-    return aggregateResults(sessionResults, globalFirstTs, globalLastTs);
-}