@echomem/mcp 1.4.8 → 1.4.9

package/dist/context-analysis/vendored-canonical.js

@@ -0,0 +1,793 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { fileURLToPath } from "node:url";
+import { discoverCodexSessionFiles } from "../codex-session-files.js";
+import { resolveClaudeProjectsDir } from "../local-data-paths.js";
+import { walk } from "../report.js";
+import { buildClaudeNativeCanonicalReport } from "./claude-native-canonical.js";
+const PROBLEM_IDS = [
+    "P01", "P02", "P03", "P04", "P05", "P06", "P07", "P08", "P09", "P10", "P11", "P12", "P13",
+];
+const PROBLEM_META = {
+    P01: { label: "Outdated Images & Screenshots", bucket: "dead", category: "Runtime Bug", confidence: "high" },
+    P02: { label: "Ignored User Instructions", bucket: "refind", category: "Model Behavior", confidence: "medium" },
+    P03: { label: "Old Files", bucket: "duplicate", category: "Structural Accumulation", confidence: "high" },
+    P04: { label: "Repeated Setup After Compaction", bucket: "refind", category: "Structural Accumulation", confidence: "high" },
+    P05: { label: "Premature Completion Fixes", bucket: "refind", category: "Human Cost", confidence: "medium" },
+    P06: { label: "Session Re-heat", bucket: "refind", category: "Human Cost", confidence: "medium" },
+    P07: { label: "Failed Turn Leftovers", bucket: "dead", category: "Runtime Bug", confidence: "medium" },
+    P08: { label: "Repeated Git Check Logs", bucket: "refind", category: "Model Behavior", confidence: "high" },
+    P09: { label: "Repeated Fix Attempts", bucket: "refind", category: "Human Cost", confidence: "medium" },
+    P10: { label: "Repeated Search", bucket: "refind", category: "Model Behavior", confidence: "high" },
+    P11: { label: "Visual Debug Logs", bucket: "dead", category: "Context Hygiene", confidence: "fallback" },
+    P12: { label: "Tool Call Logs", bucket: "dead", category: "Context Hygiene", confidence: "fallback" },
+    P13: { label: "Agent's Reasoning Notes", bucket: "dead", category: "Context Hygiene", confidence: "fallback" },
+};
+const SCORER_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/canonical-scorer");
+// Per-session scored-result cache. Each Codex session is scored by spawning 3 vendored scorer
+// processes (~300ms/session) — the dominant cost of the whole forensic scan. A session's scored
+// output is a pure function of its immutable JSONL, so cache it by (mtime, size): re-runs only
+// re-score new/changed sessions. Mirrors the forensic engine's codex parse cache. Bump the version
+// whenever the vendored scorer scripts change so stale results are discarded.
+const CANONICAL_CACHE_VERSION = 3;
+function canonicalCachePath() {
+    return path.join(os.homedir(), ".echomem", "canonical-cache.json");
+}
+function loadCanonicalCache() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(canonicalCachePath(), "utf8"));
+        if (parsed && parsed.v === CANONICAL_CACHE_VERSION && parsed.files && typeof parsed.files === "object")
+            return parsed.files;
+    }
+    catch {
+        /* no cache yet, or a stale/corrupt one — rebuild */
+    }
+    return {};
+}
+function saveCanonicalCache(files) {
+    try {
+        const p = canonicalCachePath();
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify({ v: CANONICAL_CACHE_VERSION, files }));
+    }
+    catch {
+        /* best effort: a cache write failure must never break the scan */
+    }
+}
+export async function buildVendoredCanonicalReport(opts) {
+    const sources = opts?.sources ?? defaultSources(opts);
+    const claudeRoot = sources.includes("claude-code") ? resolveClaudeProjectsDir() : null;
+    const discoveredCodex = sources.includes("codex")
+        ? (opts?.codexSessionPaths
+            ?? opts?.sessionPaths
+            ?? discoverCodexSessionFiles({ includeArchived: true, userInitiatedOnly: true }).files.map((file) => file.path))
+            .filter(isUserInitiatedSession)
+        : [];
+    const discoveredClaude = sources.includes("claude-code")
+        ? (opts?.claudeSessionPaths ?? (claudeRoot ? walk(claudeRoot, (candidate) => candidate.endsWith(".jsonl") && !candidate.includes(`${path.sep}subagents${path.sep}`) && !candidate.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort()
+        : [];
+    const codexFiles = limitFiles(discoveredCodex, opts?.limitFiles);
+    const claudeFiles = limitFiles(discoveredClaude, opts?.limitFiles);
+    const scored = [];
+    const codexErrors = [];
+    let done = 0;
+    const cache = loadCanonicalCache();
+    const nextCache = {};
+    const codexStart = Date.now();
+    let cachedCount = 0;
+    let rescoredCount = 0;
+    const total = codexFiles.length + claudeFiles.length;
+    const strictCodexErrors = opts?.strictSessionErrors ?? Boolean(opts?.codexSessionPaths || opts?.sessionPaths);
+    // Score sessions across all cores. Each session is independent (isolated temp dir, no cross-session
+    // state) so order only affects the final aggregate iteration — results are written back in file
+    // order below to keep the report deterministic. Leave one core for the main thread.
+    const poolSize = Number(process.env.ECHOMEM_CANON_POOL) || Math.max(2, os.cpus().length - 1);
+    const perFile = await mapPool(codexFiles, poolSize, async (file) => {
+        let st = null;
+        try {
+            st = fs.statSync(file);
+        }
+        catch {
+            /* file vanished mid-scan — skip it */
+        }
+        try {
+            const hit = st ? cache[file] : null;
+            const fresh = hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size;
+            const slim = fresh ? hit.scored : slimScored(await scoreSession(file, "codex"));
+            if (fresh)
+                cachedCount++;
+            else
+                rescoredCount++;
+            return { st, slim, error: null };
+        }
+        catch (error) {
+            if (strictCodexErrors)
+                throw error;
+            const session = sessionIdFor(file).slice(0, 32);
+            return {
+                st,
+                slim: null,
+                error: { session, message: "Canonical scorer could not process this local session." },
+            };
+        }
+        finally {
+            opts?.onProgress?.(++done, total);
+        }
+    });
+    codexFiles.forEach((file, i) => {
+        const { st, slim, error } = perFile[i];
+        if (error)
+            codexErrors.push(error);
+        if (!slim)
+            return;
+        if (st)
+            nextCache[file] = { mtimeMs: st.mtimeMs, size: st.size, scored: slim };
+        scored.push({ ...slim, source: "codex" });
+    });
+    if (codexFiles.length)
+        saveCanonicalCache(nextCache);
+    if (codexFiles.length) {
+        // One-line breakdown so slow scans are diagnosable: how many sessions were freshly scored (the
+        // expensive part) vs reused from cache, across how many parallel workers, and how long it took.
+        const skipped = codexErrors.length ? `, ${codexErrors.length} skipped` : "";
+        console.error(`[echomem] canonical codex: ${codexFiles.length} sessions (${cachedCount} cached, ${rescoredCount} rescored${skipped}, ${poolSize}-way parallel) in ${((Date.now() - codexStart) / 1000).toFixed(1)}s`);
+    }
+    const codexScored = scored.filter((row) => row.source === "codex");
+    const codexReport = sources.includes("codex") ? aggregate(codexScored, reportMetadata("codex")) : null;
+    if (codexReport && codexErrors.length) {
+        codexReport.diagnostics = { skippedSessions: codexErrors.length, errors: codexErrors };
+    }
+    const claudeReport = sources.includes("claude-code")
+        ? buildClaudeNativeCanonicalReport({
+            sessionPaths: claudeFiles,
+            strictSessionErrors: opts?.strictSessionErrors ?? Boolean(opts?.claudeSessionPaths),
+            onProgress: (claudeDone) => opts?.onProgress?.(done + claudeDone, codexFiles.length + claudeFiles.length),
+        })
+        : null;
+    const reports = [codexReport, claudeReport].filter((report) => Boolean(report));
+    const report = reports.length === 1 ? reports[0] : combineReports(reports, reportMetadata("combined"));
+    report.sourceReports = {};
+    if (codexReport)
+        report.sourceReports.codex = stripSourceReports(codexReport);
+    if (claudeReport)
+        report.sourceReports.claudeCode = stripSourceReports(claudeReport);
+    return report;
+}
+async function scoreSession(sessionPath, source) {
+    const temp = fs.mkdtempSync(path.join(os.tmpdir(), "echomem-canonical-"));
+    try {
+        const scorerInput = sessionPath;
+        const sessionId = sessionIdFor(sessionPath);
+        const problemsPath = path.join(temp, "problems.json");
+        const efficiencyPath = path.join(temp, "efficiency.json");
+        const dashboardPath = path.join(temp, "dashboard.json");
+        const placeholderHtml = path.join(temp, "unused.html");
+        const env = {
+            ...process.env,
+            GOLDEN_ROOT: temp,
+            GOLDEN_PAYLOAD_ACCOUNTING: "0",
+            GOLDEN_JSON_ONLY: "1",
+        };
+        // Run the three scripts in sequence for THIS session (the dashboard needs both prior outputs,
+        // and the scorers are not safe to overlap inside one shared temp dir). Parallelism happens
+        // ACROSS sessions via the pool below, which is where the speedup comes from.
+        // The three scripts have a dependency chain (the dashboard needs both prior outputs), so they run
+        // in sequence for THIS session. Parallelism happens ACROSS sessions via the pool above, which
+        // already saturates every core — running these two side-by-side only adds contention.
+        await runVendored("analyze-10-problems.mjs", [
+            "--session-id", sessionId,
+            "--jsonl", scorerInput,
+            "--out", problemsPath,
+            "--html", placeholderHtml,
+        ], env);
+        await runVendored("optimizable_detail.mjs", [scorerInput, "--scoring-mode", "episode-outcome"], env);
+        const generatedEfficiency = fs.readdirSync(temp)
+            .find((name) => name.startsWith("OPTIMIZABLE_DETAIL_EPISODE_OUTCOME_") && name.endsWith(".json"));
+        if (!generatedEfficiency)
+            throw new Error(`Canonical efficiency output was not created for ${sessionId}`);
+        fs.renameSync(path.join(temp, generatedEfficiency), efficiencyPath);
+        await runVendored("build-session-waste-dashboard.mjs", [
+            "--session-id", sessionId,
+            "--problems", problemsPath,
+            "--efficiency", efficiencyPath,
+            "--out", dashboardPath,
+            "--html", placeholderHtml,
+        ], env);
+        const dashboard = readJson(dashboardPath);
+        const efficiency = readJson(efficiencyPath);
+        await enrichCodexDashboardTurns(dashboard, sessionPath);
+        return {
+            dashboard,
+            efficiency,
+            repo: repoLabel(dashboard.session.sourceSession?.cwd || null),
+            source,
+        };
+    }
+    finally {
+        fs.rmSync(temp, { recursive: true, force: true });
+    }
+}
+// Run fn over items with at most `limit` in flight at once, returning results in input order.
+async function mapPool(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const i = next++;
+            results[i] = await fn(items[i], i);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, () => worker()));
+    return results;
+}
+async function enrichCodexDashboardTurns(dashboard, sessionPath) {
+    const previews = await readCodexTurnPreviews(sessionPath);
+    if (!dashboard.session.sourceSession)
+        dashboard.session.sourceSession = {};
+    if (!dashboard.session.sourceSession.startedAt && previews.startedAt)
+        dashboard.session.sourceSession.startedAt = previews.startedAt;
+    if (!dashboard.session.sourceSession.cwd && previews.cwd)
+        dashboard.session.sourceSession.cwd = previews.cwd;
+    for (const turn of dashboard.timeline || []) {
+        const preview = previews.turns.get(turn.turn);
+        if (!preview)
+            continue;
+        turn.userMessage ||= preview.userMessage;
+        turn.assistantOutput ||= compactBlockPreview(preview.assistantMessages.join("\n\n"), 1200);
+        turn.timestamp ||= preview.timestamp;
+    }
+}
+async function readCodexTurnPreviews(sessionPath) {
+    let cwd = null;
+    let startedAt = null;
+    let current = null;
+    const turns = new Map();
+    const lines = readline.createInterface({ input: fs.createReadStream(sessionPath), crlfDelay: Infinity });
+    for await (const line of lines) {
+        if (!line.trim())
+            continue;
+        let row;
+        try {
+            row = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(row))
+            continue;
+        const payload = recordValue(row.payload);
+        const type = stringValue(payload.type) || stringValue(row.type);
+        const timestamp = stringValue(row.timestamp) || stringValue(payload.timestamp) || null;
+        if (stringValue(row.type) === "session_meta" || type === "session_meta") {
+            cwd ||= stringValue(payload.cwd) || null;
+            startedAt ||= stringValue(payload.timestamp) || timestamp;
+            continue;
+        }
+        const userMessage = codexUserMessageText(row, payload, type);
+        if (userMessage) {
+            if (current && current.userMessage === userMessage) {
+                current.timestamp ||= timestamp;
+                continue;
+            }
+            current = { userMessage, assistantMessages: [], timestamp };
+            turns.set(turns.size + 1, current);
+            continue;
+        }
+        if (!current)
+            continue;
+        const assistantMessage = codexAssistantMessageText(row, payload, type);
+        if (assistantMessage && current.assistantMessages[current.assistantMessages.length - 1] !== assistantMessage) {
+            current.assistantMessages.push(assistantMessage);
+        }
+    }
+    return { cwd, startedAt, turns };
+}
+function codexUserMessageText(row, payload, type) {
+    if (stringValue(row.type) === "event_msg" && type === "user_message")
+        return stringValue(payload.message).trim();
+    if (stringValue(row.type) !== "response_item" || type !== "message" || stringValue(payload.role) !== "user")
+        return "";
+    return codexContentText(payload.content).trim();
+}
+function codexAssistantMessageText(row, payload, type) {
+    if ((stringValue(row.type) === "event_msg" || stringValue(row.type) === "compacted") && type === "agent_message")
+        return stringValue(payload.message).trim();
+    if (stringValue(row.type) !== "response_item" || type !== "message" || stringValue(payload.role) !== "assistant")
+        return "";
+    return codexContentText(payload.content).trim();
+}
+function codexContentText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(codexContentText).filter(Boolean).join("\n");
+    if (!isRecord(value))
+        return "";
+    return stringValue(value.text) || codexContentText(value.content);
+}
+function compactBlockPreview(text, limit = 1200) {
+    const compacted = text
+        .replace(/\r\n/g, "\n")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    if (!compacted)
+        return undefined;
+    return compacted.length > limit ? `${compacted.slice(0, limit - 1)}…` : compacted;
+}
+// Keep only the fields aggregate() reads. The vendored scorer emits large dashboard-HTML payloads
+// (topWasteTurns/topInputTurns/keyDataPoints, ~32MB) and a full per-turn efficiency.series (~129MB)
+// that ride along via readJson's cast but are never consumed here. Slimming shrinks the on-disk cache
+// from ~200MB to a few MB and cuts peak memory, with byte-identical aggregate output.
+function slimScored(row) {
+    const d = row.dashboard;
+    const t = d.totals;
+    return {
+        dashboard: {
+            session: {
+                id: d.session.id,
+                sourceSession: d.session.sourceSession ? {
+                    cwd: d.session.sourceSession.cwd ?? null,
+                    turns: d.session.sourceSession.turns,
+                    startedAt: d.session.sourceSession.startedAt ?? null,
+                } : undefined,
+            },
+            totals: {
+                officialInputTokens: t.officialInputTokens || 0,
+                usefulTokens: t.usefulTokens || 0,
+                wasteTokens: t.wasteTokens || 0,
+                duplicateWasteTokens: t.duplicateWasteTokens || 0,
+                refindWasteTokens: t.refindWasteTokens || 0,
+                deadWasteTokens: t.deadWasteTokens || 0,
+                excludedUnlabeledTokens: t.excludedUnlabeledTokens || 0,
+                unattributedWasteTokens: t.unattributedWasteTokens || 0,
+            },
+            problemContributions: (d.problemContributions || []).map((p) => ({
+                id: p.id, name: p.name, category: p.category,
+                eventsFound: p.eventsFound, evidenceTurns: p.evidenceTurns, qualifiedTurns: p.qualifiedTurns,
+                qualifiedTokenPressure: p.qualifiedTokenPressure, allocatedWasteTokens: p.allocatedWasteTokens || 0,
+                worstTurnByAllocatedWaste: p.worstTurnByAllocatedWaste
+                    ? {
+                        turn: p.worstTurnByAllocatedWaste.turn,
+                        allocatedWasteTokens: p.worstTurnByAllocatedWaste.allocatedWasteTokens,
+                        inputTokens: p.worstTurnByAllocatedWaste.inputTokens,
+                        usefulTokens: p.worstTurnByAllocatedWaste.usefulTokens,
+                        wasteTokens: p.worstTurnByAllocatedWaste.wasteTokens,
+                        itemReason: p.worstTurnByAllocatedWaste.itemReason,
+                    }
+                    : null,
+            })),
+            timeline: (d.timeline || []).map((tt) => ({
+                turn: tt.turn, episode: tt.episode,
+                inputTokens: tt.inputTokens || 0, usefulTokens: tt.usefulTokens || 0, wasteTokens: tt.wasteTokens || 0,
+                rawUsefulTokens: tt.rawUsefulTokens || 0, rawOutcomeWasteTokens: tt.rawOutcomeWasteTokens || 0,
+                userMessage: tt.userMessage,
+                assistantOutput: tt.assistantOutput,
+                timestamp: tt.timestamp ?? null,
+                allocatedItems: (tt.allocatedItems || []).map((it) => ({ problemId: it.problemId, tokens: it.tokens })),
+            })),
+        },
+        efficiency: {
+            series: (row.efficiency.series || []).map((s) => ({
+                keep_oh: s.keep_oh || 0, keep_prod: s.keep_prod || 0, opt_dup: s.opt_dup || 0, opt_refind: s.opt_refind || 0, opt_dead: s.opt_dead || 0,
+            })),
+        },
+        repo: row.repo,
+    };
+}
+function aggregate(scored, metadata) {
+    const totals = scored.reduce((sum, row) => {
+        const value = row.dashboard.totals;
+        sum.input += value.officialInputTokens || 0;
+        sum.useful += value.usefulTokens || 0;
+        sum.waste += value.wasteTokens || 0;
+        sum.duplicate += value.duplicateWasteTokens || 0;
+        sum.refind += value.refindWasteTokens || 0;
+        sum.dead += value.deadWasteTokens || 0;
+        sum.unattributed += value.unattributedWasteTokens || 0;
+        sum.excluded += value.excludedUnlabeledTokens || 0;
+        sum.turns += row.dashboard.session.sourceSession?.turns ?? row.dashboard.timeline.length;
+        return sum;
+    }, { input: 0, useful: 0, waste: 0, duplicate: 0, refind: 0, dead: 0, unattributed: 0, excluded: 0, turns: 0 });
+    const rawBuckets = { keep_oh: 0, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0 };
+    for (const row of scored) {
+        for (const turn of row.efficiency.series) {
+            rawBuckets.keep_oh += turn.keep_oh || 0;
+            rawBuckets.keep_prod += turn.keep_prod || 0;
+            rawBuckets.opt_dup += turn.opt_dup || 0;
+            rawBuckets.opt_refind += turn.opt_refind || 0;
+            rawBuckets.opt_dead += turn.opt_dead || 0;
+        }
+    }
+    const problemRows = new Map();
+    for (const id of PROBLEM_IDS)
+        problemRows.set(id, { tokens: 0, count: 0, pressure: 0, sessions: 0, examples: [] });
+    for (const row of scored) {
+        const turnByNumber = new Map(row.dashboard.timeline.map((turn) => [turn.turn, turn]));
+        for (const problem of row.dashboard.problemContributions || []) {
+            const aggregateProblem = problemRows.get(problem.id);
+            if (!aggregateProblem)
+                continue;
+            aggregateProblem.tokens += problem.allocatedWasteTokens || 0;
+            aggregateProblem.count += problem.eventsFound ?? problem.evidenceTurns ?? problem.qualifiedTurns ?? 0;
+            aggregateProblem.pressure += problem.qualifiedTokenPressure || 0;
+            if ((problem.allocatedWasteTokens || 0) > 0)
+                aggregateProblem.sessions += 1;
+            const worst = problem.worstTurnByAllocatedWaste;
+            if (worst) {
+                const turn = turnByNumber.get(worst.turn || 0);
+                aggregateProblem.examples.push({
+                    session: row.dashboard.session.id,
+                    repo: row.repo,
+                    agentSource: "codex",
+                    turn: worst.turn || 0,
+                    tokens: Math.round(worst.allocatedWasteTokens || 0),
+                    evidence: worst.itemReason || "allocated by vendored canonical scorer",
+                    prompt: turn?.userMessage,
+                    output: turn?.assistantOutput,
+                    timestampMs: turn?.timestamp ? Date.parse(turn.timestamp) : null,
+                    sessionStartedAt: row.dashboard.session.sourceSession?.startedAt ? Date.parse(row.dashboard.session.sourceSession.startedAt) : null,
+                    turnInputTokens: worst.inputTokens || turn?.inputTokens || 0,
+                    turnUsefulTokens: Math.round(worst.usefulTokens || turn?.usefulTokens || 0),
+                    turnWasteTokens: Math.round(worst.wasteTokens || turn?.wasteTokens || 0),
+                });
+                aggregateProblem.examples.sort(compareProblemExamples);
+                aggregateProblem.examples.splice(1);
+            }
+        }
+    }
+    const problems = PROBLEM_IDS.map((id) => {
+        const meta = PROBLEM_META[id];
+        const values = problemRows.get(id);
+        return {
+            id,
+            label: meta.label,
+            bucket: meta.bucket,
+            category: meta.category,
+            confidence: meta.confidence,
+            count: values.count,
+            sessions: values.sessions,
+            allocatedWasteTokens: values.tokens,
+            qualifiedTokenPressure: values.pressure,
+            severity: totals.waste ? (values.tokens / totals.waste) * 100 : 0,
+            examples: values.examples,
+        };
+    }).sort((a, b) => b.allocatedWasteTokens - a.allocatedWasteTokens || a.id.localeCompare(b.id));
+    const repoRows = new Map();
+    for (const row of scored) {
+        const repo = repoRows.get(row.repo) || { sessions: 0, officialInputTokens: 0, wasteTokens: 0 };
+        repo.sessions += 1;
+        repo.officialInputTokens += row.dashboard.totals.officialInputTokens;
+        repo.wasteTokens += row.dashboard.totals.wasteTokens;
+        repoRows.set(row.repo, repo);
+    }
+    const episodes = [];
+    for (const row of scored) {
+        const byEpisode = new Map();
+        for (const turn of row.dashboard.timeline) {
+            const list = byEpisode.get(turn.episode) || [];
+            list.push(turn);
+            byEpisode.set(turn.episode, list);
+        }
+        for (const [episode, turns] of byEpisode) {
+            const byProblem = new Map();
+            for (const turn of turns)
+                for (const item of turn.allocatedItems || []) {
+                    if (item.problemId)
+                        byProblem.set(item.problemId, (byProblem.get(item.problemId) || 0) + (item.tokens || 0));
+                }
+            const dominant = [...byProblem.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+            if (!dominant)
+                continue;
+            episodes.push({
+                id: `E${episode}`,
+                session: row.dashboard.session.id,
+                repo: row.repo,
+                turnStart: turns[0]?.turn || 0,
+                turnEnd: turns[turns.length - 1]?.turn || 0,
+                wasteTokens: turns.reduce((sum, turn) => sum + turn.wasteTokens, 0),
+                dominantProblemId: dominant,
+            });
+        }
+    }
+    const sessions = scored.map((row) => {
+        const top = [...row.dashboard.problemContributions].sort((a, b) => b.allocatedWasteTokens - a.allocatedWasteTokens)[0];
+        return {
+            session: row.dashboard.session.id,
+            repo: row.repo,
+            turns: row.dashboard.session.sourceSession?.turns ?? row.dashboard.timeline.length,
+            officialInputTokens: row.dashboard.totals.officialInputTokens,
+            wasteTokens: row.dashboard.totals.wasteTokens,
+            topProblemId: top?.allocatedWasteTokens > 0 ? top.id : null,
+        };
+    });
+    return {
+        version: 1,
+        generatedFrom: metadata.generatedFrom,
+        methodology: {
+            name: "Canonical retained-window episode-outcome analysis",
+            status: "deterministic-plus-heuristic",
+            scoringMode: "episode-outcome",
+            note: metadata.note,
+        },
+        summary: {
+            sessionsAnalyzed: scored.length,
+            reposAnalyzed: repoRows.size,
+            turnsAnalyzed: totals.turns,
+            officialInputTokens: totals.input,
+            usefulTokens: totals.useful,
+            wasteTokens: totals.waste,
+            usefulPct: percentage(totals.useful, totals.input),
+            wastePct: percentage(totals.waste, totals.input),
+            attributedWasteTokens: Math.round(Math.max(0, totals.waste - totals.unattributed)),
+            unattributedWasteTokens: totals.unattributed,
+            rawUsefulTokens: rawBuckets.keep_oh + rawBuckets.keep_prod,
+            rawOutcomeResidueTokens: rawBuckets.opt_dup + rawBuckets.opt_refind + rawBuckets.opt_dead,
+            excludedUnlabeledTokens: totals.excluded,
+        },
+        buckets: { duplicate: totals.duplicate, refind: totals.refind, dead: totals.dead, unattributed: totals.unattributed },
+        rawBuckets,
+        problems,
+        sessions,
+        repos: [...repoRows.entries()].map(([repo, values]) => ({ repo, ...values })).sort((a, b) => b.officialInputTokens - a.officialInputTokens),
+        episodes,
+    };
+}
+function limitFiles(files, limit) {
+    return typeof limit === "number" ? files.slice(-Math.max(0, limit)) : files;
+}
+function defaultSources(opts) {
+    if (opts?.sessionPaths)
+        return ["codex"];
+    const sources = [];
+    if (opts?.codexSessionPaths)
+        sources.push("codex");
+    if (opts?.claudeSessionPaths)
+        sources.push("claude-code");
+    return sources.length ? sources : ["codex", "claude-code"];
+}
+function reportMetadata(source) {
+    const scorer = "vendored context-golden-standard scorer";
+    if (source === "codex") {
+        return {
+            generatedFrom: ["~/.codex/sessions", scorer],
+            note: "Codex JSONL sessions run through the vendored canonical optimizable-detail, P01-P13 detector, and waste-allocation pipeline without reimplementing its rules.",
+        };
+    }
+    if (source === "claude-code") {
+        return {
+            generatedFrom: ["~/.claude/projects", "Claude Code native useful/waste ledger"],
+            note: "Claude Code JSONL sessions are scored natively from requestIds and toolUseResult objects. Useful/waste is computed before P01-P13 attribution, then explainable waste is mapped onto the shared problem endpoint.",
+        };
+    }
+    return {
+        generatedFrom: ["~/.codex/sessions", "~/.claude/projects", scorer, "Claude Code native useful/waste ledger"],
+        note: "Combined Codex + Claude Code canonical rollup. Codex uses the vendored retained-window episode-outcome scorer; Claude Code uses a native JSONL/toolUseResult ledger that computes useful vs waste before mapping explainable waste to P01-P13.",
+    };
+}
+function combineReports(reports, metadata) {
+    const totals = reports.reduce((sum, report) => {
+        const summary = report.summary;
+        sum.sessions += summary.sessionsAnalyzed;
+        sum.repos += summary.reposAnalyzed;
+        sum.turns += summary.turnsAnalyzed;
+        sum.input += summary.officialInputTokens;
+        sum.useful += summary.usefulTokens;
+        sum.waste += summary.wasteTokens;
+        sum.attributed += summary.attributedWasteTokens;
+        sum.unattributed += summary.unattributedWasteTokens;
+        sum.rawUseful += summary.rawUsefulTokens;
+        sum.rawResidue += summary.rawOutcomeResidueTokens;
+        sum.excluded += summary.excludedUnlabeledTokens;
+        return sum;
+    }, { sessions: 0, repos: 0, turns: 0, input: 0, useful: 0, waste: 0, attributed: 0, unattributed: 0, rawUseful: 0, rawResidue: 0, excluded: 0 });
+    const buckets = reports.reduce((sum, report) => {
+        sum.duplicate += report.buckets.duplicate || 0;
+        sum.refind += report.buckets.refind || 0;
+        sum.dead += report.buckets.dead || 0;
+        sum.unattributed += report.buckets.unattributed || 0;
+        return sum;
+    }, { duplicate: 0, refind: 0, dead: 0, unattributed: 0 });
+    const rawBuckets = reports.reduce((sum, report) => {
+        sum.keep_oh += report.rawBuckets.keep_oh || 0;
+        sum.keep_prod += report.rawBuckets.keep_prod || 0;
+        sum.opt_dup += report.rawBuckets.opt_dup || 0;
+        sum.opt_refind += report.rawBuckets.opt_refind || 0;
+        sum.opt_dead += report.rawBuckets.opt_dead || 0;
+        return sum;
+    }, { keep_oh: 0, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0 });
+    const problemRows = new Map();
+    for (const id of PROBLEM_IDS) {
+        const meta = PROBLEM_META[id];
+        problemRows.set(id, {
+            id,
+            label: meta.label,
+            bucket: meta.bucket,
+            category: meta.category,
+            confidence: meta.confidence,
+            count: 0,
+            sessions: 0,
+            allocatedWasteTokens: 0,
+            qualifiedTokenPressure: 0,
+            severity: 0,
+            examples: [],
+        });
+    }
+    for (const report of reports) {
+        for (const problem of report.problems) {
+            const row = problemRows.get(problem.id);
+            if (!row)
+                continue;
+            row.count += problem.count;
+            row.sessions += problem.sessions;
+            row.allocatedWasteTokens += problem.allocatedWasteTokens;
+            row.qualifiedTokenPressure += problem.qualifiedTokenPressure;
+            row.examples.push(...problem.examples);
+            row.examples.sort(compareProblemExamples);
+            row.examples.splice(1);
+        }
+    }
+    const problems = [...problemRows.values()].map((problem) => ({
+        ...problem,
+        severity: totals.waste ? (problem.allocatedWasteTokens / totals.waste) * 100 : 0,
+    })).sort((a, b) => b.allocatedWasteTokens - a.allocatedWasteTokens || a.id.localeCompare(b.id));
+    const diagnosticErrors = reports.flatMap((report) => report.diagnostics?.errors || []);
+    const repoRows = new Map();
+    for (const report of reports)
+        for (const repo of report.repos) {
+            const row = repoRows.get(repo.repo) || { sessions: 0, officialInputTokens: 0, wasteTokens: 0 };
+            row.sessions += repo.sessions;
+            row.officialInputTokens += repo.officialInputTokens;
+            row.wasteTokens += repo.wasteTokens;
+            repoRows.set(repo.repo, row);
+        }
+    return {
+        version: 1,
+        generatedFrom: metadata.generatedFrom,
+        methodology: {
+            name: "Canonical retained-window episode-outcome analysis",
+            status: "deterministic-plus-heuristic",
+            scoringMode: "episode-outcome",
+            note: metadata.note,
+        },
+        summary: {
+            sessionsAnalyzed: totals.sessions,
+            reposAnalyzed: repoRows.size || totals.repos,
+            turnsAnalyzed: totals.turns,
+            officialInputTokens: totals.input,
+            usefulTokens: totals.useful,
+            wasteTokens: totals.waste,
+            usefulPct: percentage(totals.useful, totals.input),
+            wastePct: percentage(totals.waste, totals.input),
+            attributedWasteTokens: totals.attributed,
+            unattributedWasteTokens: totals.unattributed,
+            rawUsefulTokens: totals.rawUseful,
+            rawOutcomeResidueTokens: totals.rawResidue,
+            excludedUnlabeledTokens: totals.excluded,
+        },
+        buckets,
+        rawBuckets,
+        problems,
+        sessions: reports.flatMap((report) => report.sessions).sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
+        repos: [...repoRows.entries()].map(([repo, value]) => ({ repo, ...value })).sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
+        episodes: reports.flatMap((report) => report.episodes).sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
+        ...(diagnosticErrors.length ? { diagnostics: { skippedSessions: diagnosticErrors.length, errors: diagnosticErrors } } : {}),
+    };
+}
+function stripSourceReports(report) {
+    const { sourceReports: _sourceReports, ...sourceReport } = report;
+    return sourceReport;
+}
+function runVendored(script, args, env) {
+    // Async spawn (not spawnSync) so many sessions' scorers run concurrently across CPU cores. The
+    // scorers write their results to files (--out), so stdout is not a data channel; we only keep a
+    // tail of stderr for error reporting.
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [path.join(SCORER_DIR, script), ...args], {
+            env,
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+        let stderr = "";
+        child.stderr?.on("data", (chunk) => { if (stderr.length < 8000)
+            stderr += String(chunk); });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                return resolve();
+            const detail = stderr.trim().split("\n").slice(-3).join(" ") || "unknown scorer failure";
+            reject(new Error(`Vendored canonical scorer failed (${script}): ${detail}`));
+        });
+    });
+}
+function isUserInitiatedSession(file) {
+    try {
+        const firstLine = readFirstLine(file);
+        const parsed = JSON.parse(firstLine);
+        const source = parsed.payload?.source;
+        const spawned = Boolean(source && typeof source === "object" && "subagent" in source);
+        const hasParent = typeof parsed.payload?.parent_thread_id === "string" && parsed.payload.parent_thread_id.length > 0;
+        return !spawned && !hasParent;
+    }
+    catch {
+        return true;
+    }
+}
+function sessionIdFor(file) {
+    try {
+        const firstLine = readFirstLine(file);
+        const parsed = JSON.parse(firstLine);
+        if (typeof parsed.payload?.id === "string")
+            return parsed.payload.id;
+    }
+    catch {
+        // Fall back to the rollout filename for older sessions.
+    }
+    const match = path.basename(file).match(/([0-9a-f]{8}-[0-9a-f-]{27,})\.jsonl$/i);
+    return match?.[1] || path.basename(file, ".jsonl").replace(/^rollout-/, "");
+}
+const MAX_FIRST_LINE_BYTES = 8 * 1024 * 1024;
+/** Read only a bounded first JSONL record without materializing the rest of a rollout. */
+function readFirstLine(file) {
+    const fd = fs.openSync(file, "r");
+    const chunks = [];
+    let total = 0;
+    try {
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        for (;;) {
+            const bytes = fs.readSync(fd, buffer, 0, buffer.length, null);
+            if (bytes <= 0)
+                break;
+            const newline = buffer.subarray(0, bytes).indexOf(0x0a);
+            const length = newline >= 0 ? newline : bytes;
+            if (total + length > MAX_FIRST_LINE_BYTES) {
+                throw new Error(`First JSONL record exceeds ${MAX_FIRST_LINE_BYTES} bytes`);
+            }
+            chunks.push(Buffer.from(buffer.subarray(0, length)));
+            total += length;
+            if (newline >= 0)
+                break;
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return Buffer.concat(chunks, total).toString("utf8").replace(/\r$/, "");
+}
+function repoLabel(cwd) {
+    if (!cwd)
+        return "home";
+    const label = path.basename(cwd);
+    return label && label !== "." && label !== "/" ? label : "home";
+}
+function readJson(file) {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function recordValue(value) {
+    return isRecord(value) ? value : {};
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function compareProblemExamples(left, right) {
+    return exampleDisplayRank(right) - exampleDisplayRank(left) || (right.tokens || 0) - (left.tokens || 0);
+}
+function exampleDisplayRank(example) {
+    const hasPrompt = Boolean(String(example.prompt || "").trim());
+    const hasOutput = Boolean(String(example.output || "").trim());
+    if (hasPrompt && hasOutput)
+        return 3;
+    if (hasPrompt)
+        return 2;
+    if (hasOutput)
+        return 1;
+    return 0;
+}
+function percentage(value, total) {
+    return total > 0 ? (value / total) * 100 : 0;
+}