@echomem/mcp 1.4.7 → 1.4.9

package/dist/context-analysis/workspace-report.js

@@ -0,0 +1,1838 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { discoverCodexSessionFiles } from "../codex-session-files.js";
+import { resolveClaudeProjectsDir } from "../local-data-paths.js";
+import { eachLine, walk } from "../report.js";
+const PROBLEMS = {
+    P01: { id: "P01", label: "Outdated Images & Screenshots", bucket: "dead", category: "Runtime Bug", confidence: "high" },
+    P02: { id: "P02", label: "Ignored User Instructions", bucket: "refind", category: "Model Behavior", confidence: "medium" },
+    P03: { id: "P03", label: "Old Files", bucket: "duplicate", category: "Structural Accumulation", confidence: "high" },
+    P04: { id: "P04", label: "Repeated Setup After Compaction", bucket: "refind", category: "Structural Accumulation", confidence: "high" },
+    P05: { id: "P05", label: "Premature Completion Fixes", bucket: "refind", category: "Human Cost", confidence: "medium" },
+    P06: { id: "P06", label: "Session Re-heat", bucket: "refind", category: "Human Cost", confidence: "medium" },
+    P07: { id: "P07", label: "Failed Turn Leftovers", bucket: "dead", category: "Runtime Bug", confidence: "medium" },
+    P08: { id: "P08", label: "Repeated Git Check Logs", bucket: "refind", category: "Model Behavior", confidence: "high" },
+    P09: { id: "P09", label: "Repeated Fix Attempts", bucket: "refind", category: "Human Cost", confidence: "medium" },
+    P10: { id: "P10", label: "Repeated Search", bucket: "refind", category: "Model Behavior", confidence: "high" },
+    P11: { id: "P11", label: "Visual Debug Logs", bucket: "dead", category: "Context Hygiene", confidence: "fallback" },
+    P12: { id: "P12", label: "Tool Call Logs", bucket: "dead", category: "Context Hygiene", confidence: "fallback" },
+    P13: { id: "P13", label: "Agent's Reasoning Notes", bucket: "dead", category: "Context Hygiene", confidence: "fallback" },
+};
+const READ_BINS = new Set(["cat", "head", "tail", "less", "more", "bat", "nl", "sed", "awk", "strings", "view"]);
+const SEARCH_BINS = new Set(["grep", "egrep", "fgrep", "rg", "ag", "ack", "find", "fd"]);
+const GIT_MEMORY_SUBS = new Set(["log", "show", "diff", "blame", "grep", "status", "ls-files", "cat-file"]);
+const RUN_BINS = new Set(["npm", "pnpm", "yarn", "bun", "node", "npx", "tsx", "vitest", "jest", "pytest", "cargo", "go", "make"]);
+const CONTENT_KINDS = new Set(["read", "search", "command", "image", "written", "conv_user", "conv_agent"]);
+const R_CODE = 3.3;
+const R_TEXT = 4;
+const OUTPUT_TOKEN_CAP = 12_000;
+const IMAGE_TOKENS = 4_000;
+const SERIALIZATION_FRACTION = 0.03;
+const GAP_MS = 30 * 60 * 1000;
+const ORIGINAL_TOKEN_RE = /Original token count:\s*(\d+)/;
+const CORRECTION_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 CONSTRAINT_RE = /must|must not|should not|never|always|required|constraint|requirement|important|do not|don't|only|exactly|instead|避免|必须|不要|不能|只要|约束|protect|private|signed|preserve/i;
+const VIOLATION_RE = /violat|broke|ignored|missed|didn'?t follow|not follow|against|违背|违反|没按|不符合/i;
+const COMPLETION_RE = /done|complete|fixed|implemented|finished|ready|all set|works now|完成|修好了|搞定/i;
+const REORIENT_RE = /where were we|continue|pick up|resume|recap|remind|what did we|state|status|context|继续|接着|恢复|进展|状态/i;
+const MANUAL_REPAIR_RE = /try again|rerun|retry|fix it|still broken|again|重新|再试|再跑|继续修|还是不对/i;
+export function buildWorkspaceContextReport(opts) {
+    const scoringMode = opts?.scoringMode ?? "local-live";
+    const sources = opts?.sources ?? ["codex", "claude-code"];
+    const claudeRoot = sources.includes("claude-code") && !opts?.claudeSessionPaths ? resolveClaudeProjectsDir() : null;
+    const discoveredCodexFiles = sources.includes("codex")
+        ? (opts?.codexSessionPaths
+            ?? discoverCodexSessionFiles({
+                includeArchived: true,
+                userInitiatedOnly: opts?.userInitiatedCodexOnly === true,
+            }).files.map((file) => file.path))
+        : [];
+    const codexFiles = opts?.userInitiatedCodexOnly
+        ? discoveredCodexFiles.filter(isUserInitiatedCodexSession)
+        : discoveredCodexFiles;
+    const claudeFiles = sources.includes("claude-code")
+        ? (opts?.claudeSessionPaths ?? (claudeRoot ? walk(claudeRoot, (p) => p.endsWith(".jsonl") && !p.includes(`${path.sep}subagents${path.sep}`) && !p.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort()
+        : [];
+    const selectedCodex = typeof opts?.limitFiles === "number" ? codexFiles.slice(-Math.max(0, opts.limitFiles)) : codexFiles;
+    const selectedClaude = typeof opts?.limitFiles === "number" ? claudeFiles.slice(-Math.max(0, opts.limitFiles)) : claudeFiles;
+    const useCache = scoringMode === "local-live";
+    const cache = useCache ? loadCache() : {};
+    const nextCache = {};
+    const codexFindings = [];
+    const claudeFindings = [];
+    const total = selectedCodex.length + selectedClaude.length;
+    let done = 0;
+    for (const file of selectedCodex) {
+        let st;
+        try {
+            st = fs.statSync(file);
+        }
+        catch {
+            done += 1;
+            continue;
+        }
+        const hit = cache[file];
+        const cacheHit = useCache && hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size;
+        const finding = cacheHit ? hit.finding : analyzeCodexSession(file, scoringMode);
+        if (useCache)
+            nextCache[file] = { mtimeMs: st.mtimeMs, size: st.size, finding };
+        codexFindings.push(finding);
+        done += 1;
+        if (opts?.onProgress && (done % 8 === 0 || done === total))
+            opts.onProgress(done, total);
+    }
+    for (const file of selectedClaude) {
+        try {
+            claudeFindings.push(analyzeClaudeSession(file, scoringMode));
+        }
+        catch {
+            /* Ignore malformed/partial Claude Code sessions; the setup report should still render. */
+        }
+        done += 1;
+        if (opts?.onProgress && (done % 8 === 0 || done === total))
+            opts.onProgress(done, total);
+    }
+    if (useCache)
+        saveCache(nextCache);
+    const codexReport = aggregate(codexFindings, {
+        scoringMode,
+        generatedFrom: ["~/.codex/sessions"],
+        note: "Each Codex JSONL session is analyzed independently. Every token-counted turn is reconstructed as a retained context window that reconciles to C_t, partitioned into keep_oh/keep_prod/opt_dup/opt_refind/opt_dead, then opt_* waste is attributed to P01-P13 before workspace aggregation.",
+    });
+    const claudeReport = aggregate(claudeFindings, {
+        scoringMode,
+        generatedFrom: ["~/.claude/projects"],
+        note: "Each Claude Code JSONL session is analyzed independently with the golden-standard Claude adapter. C_t is input_tokens + cache_read_input_tokens + cache_creation_input_tokens. Retained-window useful/waste is estimated from Claude tool effort and on-target efficiency, then waste is attributed across P01-P13. This is comparable for dashboarding but not the same raw Codex payload reconstruction.",
+    });
+    const combined = aggregate([...codexFindings, ...claudeFindings], {
+        scoringMode,
+        generatedFrom: ["~/.codex/sessions", "~/.claude/projects"],
+        note: "Combined Codex + Claude Code workspace rollup. Codex uses retained-window reconstruction against official C_t. Claude Code uses the golden-standard Claude adapter over per-request usage and tool results. Source tabs expose each basis separately.",
+    });
+    combined.sourceReports = {
+        codex: codexReport,
+        claudeCode: claudeReport,
+    };
+    return combined;
+}
+function isUserInitiatedCodexSession(file) {
+    try {
+        const fd = fs.openSync(file, "r");
+        try {
+            const buffer = Buffer.alloc(64 * 1024);
+            const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+            const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n", 1)[0];
+            const top = JSON.parse(firstLine);
+            const record = isRecord(top) ? top : {};
+            const payload = isRecord(record.payload) ? record.payload : record;
+            const source = payload.source;
+            const spawnedByCodex = isRecord(source) && Object.prototype.hasOwnProperty.call(source, "subagent");
+            const hasParentThread = typeof payload.parent_thread_id === "string" && payload.parent_thread_id.length > 0;
+            return !spawnedByCodex && !hasParentThread;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        // Older user sessions may not carry provenance metadata; keep them unless they explicitly identify as spawned.
+        return true;
+    }
+}
+function analyzeCodexSession(file, scoringMode) {
+    const parsed = parseCodexSession(file);
+    assignEpisodes(parsed.turns);
+    qualifyProblems(parsed.turns);
+    return buildSessionFinding(parsed, scoringMode);
+}
+function analyzeClaudeSession(file, scoringMode) {
+    const parsed = parseClaudeSession(file);
+    applyClaudeOnTarget(parsed.turns);
+    applyClaudeProblemAttribution(parsed.turns);
+    return buildClaudeSessionFinding(parsed, scoringMode);
+}
+function parseClaudeSession(file) {
+    const turns = [];
+    let current = null;
+    let session = path.basename(file).replace(/\.jsonl$/, "");
+    let cwd = null;
+    let firstTs = null;
+    let lastTs = null;
+    let lastUserTs = null;
+    const callMeta = new Map();
+    const lines = fs.readFileSync(file, "utf8").split(/\n/);
+    for (const raw of lines) {
+        if (!raw.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        const top = isRecord(record) ? record : {};
+        if (typeof top.sessionId === "string")
+            session = top.sessionId;
+        if (typeof top.cwd === "string") {
+            cwd ||= top.cwd;
+        }
+        const ts = typeof top.timestamp === "string" ? Date.parse(top.timestamp) : NaN;
+        const ms = Number.isFinite(ts) ? ts : null;
+        if (ms != null) {
+            if (firstTs == null)
+                firstTs = ms;
+            lastTs = ms;
+        }
+        const type = typeof top.type === "string" ? top.type : "";
+        if (type === "user" && !isClaudeToolResultUser(top)) {
+            const text = extractClaudeText(isRecord(top.message) ? top.message.content : null);
+            current = {
+                number: turns.length + 1,
+                timestampMs: ms,
+                userMessage: text,
+                inputTokens: 0,
+                gapHours: lastUserTs != null && ms != null ? Math.max(0, (ms - lastUserTs) / 36e5) : 0,
+                effortTokens: 0,
+                onTargetTokens: 0,
+                markers: { commit: false, compaction: false, abort: false, rollback: false },
+                items: [],
+            };
+            turns.push(current);
+            if (ms != null)
+                lastUserTs = ms;
+            continue;
+        }
+        if (!current)
+            continue;
+        if (type === "assistant") {
+            const message = isRecord(top.message) ? top.message : {};
+            const usage = isRecord(message.usage) ? message.usage : {};
+            current.inputTokens = Math.max(current.inputTokens, claudeInputTokens(usage));
+            const content = Array.isArray(message.content) ? message.content : [];
+            for (const block of content) {
+                if (!isRecord(block) || block.type !== "tool_use")
+                    continue;
+                const toolUse = claudeItemFromToolUse(block, current.number);
+                if (!toolUse)
+                    continue;
+                addClaudeItem(current, toolUse);
+                if (typeof block.id === "string") {
+                    callMeta.set(block.id, {
+                        kind: toolUse.kind,
+                        file: toolUse.file,
+                        command: toolUse.command,
+                        imageProducer: toolUse.imageOutput,
+                    });
+                }
+            }
+            continue;
+        }
+        if (type === "user" && isClaudeToolResultUser(top)) {
+            const content = isRecord(top.message) && Array.isArray(top.message.content) ? top.message.content : [];
+            for (const block of content) {
+                if (!isRecord(block) || block.type !== "tool_result")
+                    continue;
+                const toolId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
+                const meta = callMeta.get(toolId);
+                const text = extractClaudeText(block.content);
+                const imageCount = countClaudeImages(block.content);
+                const imageOutput = imageCount > 0 || Boolean(isRecord(top.toolUseResult) && top.toolUseResult.isImage);
+                const tokens = Math.min(OUTPUT_TOKEN_CAP, codeTokens(text) + (imageOutput ? IMAGE_TOKENS : 0));
+                if (tokens <= 0)
+                    continue;
+                addClaudeItem(current, {
+                    kind: meta?.kind || "command",
+                    tokens,
+                    turn: current.number,
+                    file: meta?.file || null,
+                    command: meta?.command || "tool_result",
+                    imageOutput,
+                    claim: null,
+                });
+            }
+        }
+    }
+    return {
+        session,
+        cwd,
+        repo: repoLabel(cwd),
+        firstTs,
+        lastTs,
+        turns,
+    };
+}
+function claudeItemFromToolUse(block, turn) {
+    const name = typeof block.name === "string" ? block.name : "";
+    const input = isRecord(block.input) ? block.input : {};
+    const command = String(input.command || input.pattern || input.query || name || "");
+    const file = typeof input.file_path === "string" ? input.file_path : typeof input.path === "string" ? input.path : "";
+    let kind = "command";
+    if (/^(Read|Glob|LS|NotebookRead)$/i.test(name))
+        kind = "read";
+    if (/^(Grep|WebSearch|WebFetch)$/i.test(name) || isSearchCommand(command))
+        kind = "search";
+    if (/^(Write|Edit|MultiEdit|NotebookEdit)$/i.test(name))
+        kind = "write";
+    if (name === "Bash" && /\bgit\s+/.test(command))
+        kind = "git";
+    const tokens = Math.max(1, Math.min(OUTPUT_TOKEN_CAP, codeTokens(safeJson(input))));
+    return {
+        kind,
+        tokens,
+        turn,
+        file: file ? normalizeFile(file) : null,
+        command: command || name,
+        imageOutput: isVisualToolName(name) || isVisualProbeCommand(command),
+        claim: null,
+    };
+}
+function addClaudeItem(turn, item) {
+    turn.items.push(item);
+    turn.effortTokens += item.tokens;
+    if (item.kind === "git" && /\bgit\s+commit\b/.test(item.command))
+        turn.markers.commit = true;
+}
+function applyClaudeOnTarget(turns) {
+    const scores = new Map();
+    for (const turn of turns) {
+        for (const item of turn.items) {
+            if (!item.file)
+                continue;
+            scores.set(item.file, (scores.get(item.file) || 0) + (item.kind === "write" ? 5 : 1));
+        }
+    }
+    const targetFiles = new Set([...scores.entries()].sort((a, b) => b[1] - a[1]).map(([file]) => file));
+    for (const turn of turns) {
+        let onTarget = 0;
+        for (const item of turn.items) {
+            if (item.kind === "write")
+                onTarget += item.tokens;
+            else if (item.kind === "read" && item.file && targetFiles.has(item.file))
+                onTarget += item.tokens;
+        }
+        turn.onTargetTokens = onTarget;
+    }
+}
+function applyClaudeProblemAttribution(turns) {
+    const seenSearch = new Map();
+    const seenRead = new Map();
+    const seenGit = new Map();
+    let lastEditTurn = 0;
+    for (const turn of turns) {
+        if (turn.gapHours >= 1) {
+            claimFirstClaudeItem(turn, (item) => item.kind === "read" || item.kind === "search" || item.kind === "command", "P06", "temporal gap followed by re-anchor/rediscovery");
+        }
+        const localSearches = new Map();
+        for (const item of turn.items) {
+            if (item.kind === "write")
+                lastEditTurn = turn.number;
+            if (item.claim)
+                continue;
+            if (item.imageOutput) {
+                item.claim = { problemId: "P01", label: "image-bearing tool output" };
+                continue;
+            }
+            if (item.kind === "git") {
+                const key = normalizeCommand(item.command).slice(0, 140);
+                const previous = seenGit.get(key);
+                if (previous && turn.number - previous <= 5)
+                    item.claim = { problemId: "P08", label: "repeated git command" };
+                seenGit.set(key, turn.number);
+                continue;
+            }
+            if (item.kind === "search") {
+                const key = canonicalClaudeSearch(item.command);
+                const localCount = localSearches.get(key) || 0;
+                localSearches.set(key, localCount + 1);
+                const previous = seenSearch.get(key);
+                if (localCount > 0)
+                    item.claim = { problemId: "P10", label: `same search pattern repeated in T${turn.number}` };
+                else if (previous && previous > lastEditTurn)
+                    item.claim = { problemId: "P10", label: "same search pattern replayed with no intervening edit" };
+                seenSearch.set(key, turn.number);
+                continue;
+            }
+            if (item.kind === "read" && item.file) {
+                const previous = seenRead.get(item.file);
+                if (previous && turn.number - previous <= 8)
+                    item.claim = { problemId: "P03", label: "same file read again within nearby turns" };
+                seenRead.set(item.file, turn.number);
+            }
+        }
+        if (MANUAL_REPAIR_RE.test(turn.userMessage) || CORRECTION_RE.test(turn.userMessage)) {
+            claimFirstClaudeItem(turn, (item) => !item.claim && item.kind !== "write", "P05", "repair/rerun language in user turn");
+        }
+    }
+}
+function claimFirstClaudeItem(turn, predicate, problemId, label) {
+    const item = turn.items.find(predicate);
+    if (item && !item.claim)
+        item.claim = { problemId, label };
+}
+function buildClaudeSessionFinding(parsed, scoringMode) {
+    void scoringMode;
+    const buckets = { duplicate: 0, refind: 0, dead: 0, unattributed: 0 };
+    const items = [];
+    const qualifiedTokenPressure = {};
+    let officialInputTokens = 0;
+    let usefulTokens = 0;
+    let wasteTokens = 0;
+    for (const turn of parsed.turns) {
+        if (turn.inputTokens <= 0)
+            continue;
+        const efficiency = Math.max(0, Math.min(0.92, turn.effortTokens > 0 ? turn.onTargetTokens / turn.effortTokens : 0));
+        const useful = Math.round(turn.inputTokens * efficiency);
+        const waste = Math.max(0, turn.inputTokens - useful);
+        officialInputTokens += turn.inputTokens;
+        usefulTokens += useful;
+        wasteTokens += waste;
+        const contributions = turn.items.filter((item) => item.claim);
+        const weighted = contributions.length
+            ? contributions.map((item) => ({ item, weight: Math.max(1, item.tokens) }))
+            : [{ item: null, weight: 1 }];
+        const totalWeight = weighted.reduce((sum, entry) => sum + entry.weight, 0) || 1;
+        let allocated = 0;
+        weighted.forEach((entry, index) => {
+            const tokens = index === weighted.length - 1 ? waste - allocated : Math.round((waste * entry.weight) / totalWeight);
+            allocated += tokens;
+            if (tokens <= 0)
+                return;
+            const problemId = entry.item?.claim?.problemId || "P13";
+            const bucket = publicBucket(bucketForClaudeProblem(problemId));
+            buckets[bucket] += tokens;
+            qualifiedTokenPressure[problemId] = (qualifiedTokenPressure[problemId] || 0) + turn.inputTokens;
+            items.push({
+                problemId,
+                bucket,
+                tokens,
+                turn: turn.number,
+                sourceTurn: turn.number,
+                evidence: entry.item?.claim?.label || "claude adapter estimated residual context",
+            });
+        });
+    }
+    return {
+        source: "claude-code",
+        session: parsed.session,
+        cwd: parsed.cwd,
+        repo: parsed.repo,
+        firstTs: parsed.firstTs,
+        lastTs: parsed.lastTs,
+        turnCount: parsed.turns.length,
+        officialInputTokens,
+        usefulTokens: Math.round(usefulTokens),
+        wasteTokens: Math.round(wasteTokens),
+        rawUsefulTokens: Math.round(usefulTokens),
+        rawOutcomeResidueTokens: Math.round(wasteTokens),
+        excludedUnlabeledTokens: 0,
+        buckets: mapBucketValues(buckets, Math.round),
+        rawBuckets: {
+            keep_oh: Math.round(usefulTokens),
+            keep_prod: 0,
+            opt_dup: Math.round(buckets.duplicate),
+            opt_refind: Math.round(buckets.refind),
+            opt_dead: Math.round(buckets.dead),
+        },
+        qualifiedTokenPressure,
+        items: items.map((item) => ({ ...item, tokens: Math.round(item.tokens) })),
+        episodes: buildClaudeEpisodes(parsed.turns, items),
+    };
+}
+function buildClaudeEpisodes(turns, items) {
+    const byProblem = new Map();
+    let wasteTokens = 0;
+    for (const item of items) {
+        wasteTokens += item.tokens;
+        if (item.problemId)
+            byProblem.set(item.problemId, (byProblem.get(item.problemId) || 0) + item.tokens);
+    }
+    const top = [...byProblem.entries()].sort((a, b) => b[1] - a[1])[0] || null;
+    return [{
+            id: "E1",
+            turnStart: turns[0]?.number || 1,
+            turnEnd: turns[turns.length - 1]?.number || turns.length,
+            wasteTokens: Math.round(wasteTokens),
+            dominantProblemId: top ? top[0] : null,
+        }];
+}
+function parseCodexSession(file) {
+    let session = "";
+    let cwd = null;
+    let repo = "home";
+    let firstTs = null;
+    let lastTs = null;
+    let current = null;
+    let itemId = 0;
+    let imageId = 0;
+    let baseTokens = 0;
+    let toolTokens = 0;
+    let turnContextTokens = 0;
+    const turns = [];
+    const ledgerItems = [];
+    const callMeta = new Map();
+    eachLine(file, (raw) => {
+        const top = isRecord(raw) ? raw : {};
+        const payload = isRecord(top.payload) ? top.payload : top;
+        const type = typeof payload.type === "string" ? payload.type : typeof top.type === "string" ? top.type : "";
+        const ts = typeof top.timestamp === "string" ? Date.parse(top.timestamp) : typeof payload.timestamp === "string" ? Date.parse(payload.timestamp) : NaN;
+        const ms = Number.isFinite(ts) ? ts : null;
+        if (ms != null) {
+            if (firstTs == null)
+                firstTs = ms;
+            lastTs = ms;
+        }
+        if (top.type === "session_meta" || type === "session_meta") {
+            if (typeof payload.id === "string")
+                session = payload.id;
+            if (typeof payload.cwd === "string") {
+                cwd = payload.cwd;
+                repo = repoLabel(cwd);
+            }
+            baseTokens = Math.max(baseTokens, textTokens(readNestedText(payload.base_instructions)));
+            toolTokens = Math.max(toolTokens, codeTokens(JSON.stringify(payload.dynamic_tools || [])));
+            return;
+        }
+        if (top.type === "turn_context" || isRecord(payload.collaboration_mode)) {
+            turnContextTokens = Math.max(turnContextTokens, textTokens(JSON.stringify(payload)));
+            return;
+        }
+        if (type === "user_message") {
+            const text = userTextFromPayload(payload);
+            current = {
+                number: turns.length + 1,
+                timestampMs: ms,
+                userMessage: text,
+                inputTokens: 0,
+                cachedInputTokens: 0,
+                outputTokens: 0,
+                reasoningTokens: 0,
+                compaction: false,
+                abort: false,
+                rollback: false,
+                commit: false,
+                patchFiles: [],
+                commands: [],
+                assistantMessages: [],
+                episode: 1,
+                episodeStart: 1,
+                anchorKind: null,
+                qualifiedProblems: new Set(),
+            };
+            turns.push(current);
+            addLedger(ledgerItems, {
+                id: ++itemId,
+                turn: current.number,
+                kind: "conv_user",
+                tokens: textTokens(text),
+                label: "user_message",
+            });
+            for (let i = 0; i < countUserImages(payload); i += 1) {
+                addLedger(ledgerItems, {
+                    id: ++itemId,
+                    turn: current.number,
+                    kind: "image",
+                    tokens: IMAGE_TOKENS,
+                    label: "user_reference",
+                    source: "user_reference",
+                    target: "user_reference",
+                    imageId: ++imageId,
+                });
+            }
+            return;
+        }
+        if (!current)
+            return;
+        if (type === "token_count") {
+            const info = isRecord(payload.info) ? payload.info : {};
+            const last = isRecord(info.last_token_usage) ? info.last_token_usage : {};
+            const input = readNumber(last.input_tokens);
+            if (input > current.inputTokens) {
+                current.inputTokens = input;
+                current.cachedInputTokens = readNumber(last.cached_input_tokens);
+                current.outputTokens = readNumber(last.output_tokens);
+            }
+            current.reasoningTokens = Math.max(current.reasoningTokens, readNumber(last.reasoning_output_tokens));
+            return;
+        }
+        if (type === "context_compacted" || top.type === "compacted" || type === "compacted") {
+            current.compaction = true;
+            return;
+        }
+        if (type === "turn_aborted") {
+            current.abort = true;
+            return;
+        }
+        if (type === "thread_rolled_back") {
+            current.rollback = true;
+            return;
+        }
+        if (type === "agent_message" || type === "assistant_message") {
+            const text = assistantTextFromPayload(payload);
+            if (text) {
+                current.assistantMessages.push(text);
+                addLedger(ledgerItems, {
+                    id: ++itemId,
+                    turn: current.number,
+                    kind: "conv_agent",
+                    tokens: textTokens(text),
+                    label: "agent_message",
+                });
+            }
+            return;
+        }
+        if (type === "reasoning") {
+            addLedger(ledgerItems, {
+                id: ++itemId,
+                turn: current.number,
+                kind: "reasoning",
+                tokens: 450,
+                label: "reasoning",
+            });
+            return;
+        }
+        if (type === "patch_apply_end" && isRecord(payload.changes)) {
+            const files = Object.keys(payload.changes);
+            current.patchFiles.push(...files);
+            return;
+        }
+        if ((type === "custom_tool_call" || type === "tool_call") && typeof payload.input === "string") {
+            const files = extractPatchFiles(payload.input);
+            addLedger(ledgerItems, {
+                id: ++itemId,
+                turn: current.number,
+                kind: "written",
+                tokens: codeTokens(payload.input),
+                file: files.length === 1 ? files[0] : null,
+                files,
+                label: String(payload.name || "tool_call"),
+                text: payload.input.slice(0, 400_000),
+            });
+            return;
+        }
+        if (type === "function_call") {
+            const name = typeof payload.name === "string" ? payload.name : "";
+            const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+            const args = parseArguments(payload.arguments);
+            if (name === "exec_command" || name === "shell") {
+                const cmd = isRecord(args) && typeof args.cmd === "string" ? args.cmd : isRecord(args) && typeof args.command === "string" ? args.command : "";
+                const normalizedCommand = normalizeCommand(cmd);
+                const commandKind = classifyCommand(cmd);
+                const read = shellRead(cmd);
+                const kind = commandKind === "read" ? "read" : commandKind === "search" ? "search" : "command";
+                current.commands.push({
+                    kind: commandKind,
+                    command: cmd,
+                    normalized: normalizedCommand,
+                    file: read?.file || null,
+                });
+                if (/git\s+(?:-[^\s]+\s+)*commit\b/.test(cmd))
+                    current.commit = true;
+                if (callId) {
+                    callMeta.set(callId, {
+                        kind,
+                        file: read?.file || null,
+                        range: read ? { start: read.start, end: read.end } : null,
+                        command: cmd,
+                        normalizedCommand,
+                        imageProducer: isVisualToolName(name) || isVisualProbeCommand(cmd),
+                        target: isVisualProbeCommand(cmd) ? normalizeCommand(cmd) : undefined,
+                    });
+                }
+                return;
+            }
+            if (callId) {
+                callMeta.set(callId, {
+                    kind: "command",
+                    command: name,
+                    normalizedCommand: normalizeCommand(name),
+                    imageProducer: name === "view_image" || isVisualToolName(name),
+                    target: name || "tool_image",
+                });
+            }
+            return;
+        }
+        if (type === "function_call_output") {
+            const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+            const meta = callMeta.get(callId);
+            const output = payload.output;
+            const image = outputLooksLikeImage(output) || Boolean(meta?.imageProducer && typeof output !== "string");
+            if (image) {
+                addLedger(ledgerItems, {
+                    id: ++itemId,
+                    turn: current.number,
+                    kind: "image",
+                    tokens: IMAGE_TOKENS,
+                    command: meta?.command || null,
+                    normalizedCommand: meta?.normalizedCommand || null,
+                    label: meta?.command || "image",
+                    source: "tool_screenshot",
+                    target: meta?.target || meta?.command || "tool_image",
+                    imageId: ++imageId,
+                    imageOutput: true,
+                });
+                return;
+            }
+            const tokens = tokensFromOutput(output);
+            if (tokens <= 0)
+                return;
+            const outputText = typeof output === "string" ? output : safeJson(output);
+            addLedger(ledgerItems, {
+                id: ++itemId,
+                turn: current.number,
+                kind: meta?.kind || "command",
+                tokens,
+                file: meta?.file || null,
+                range: meta?.range || null,
+                command: meta?.command || null,
+                normalizedCommand: meta?.normalizedCommand || null,
+                label: meta?.file || meta?.normalizedCommand || meta?.command || "tool_output",
+                text: meta?.kind === "read" ? outputText.slice(0, 60_000) : undefined,
+            });
+        }
+    });
+    if (!session)
+        session = path.basename(file).replace(/^rollout-/, "").replace(/\.jsonl$/, "");
+    const overheadTokens = Math.max(0, baseTokens + toolTokens + turnContextTokens);
+    return { session, cwd, repo, firstTs, lastTs, overheadTokens, turns, ledgerItems };
+}
+function assignEpisodes(turns) {
+    const anchors = chooseCodexEpisodeAnchors(turns);
+    let episode = 1;
+    let start = 1;
+    let anchorIndex = 0;
+    for (const turn of turns) {
+        while (anchorIndex < anchors.length && turn.number > anchors[anchorIndex].turn) {
+            episode += 1;
+            start = anchors[anchorIndex].turn + 1;
+            anchorIndex += 1;
+        }
+        turn.episode = episode;
+        turn.episodeStart = start;
+        const anchor = anchors.find((item) => item.turn === turn.number);
+        turn.anchorKind = anchor?.kind || null;
+    }
+}
+export function chooseCodexEpisodeAnchors(turns) {
+    const commits = turns.filter((turn) => turn.commit).map((turn) => ({ turn: turn.number, kind: "commit" }));
+    if (commits.length)
+        return commits;
+    const userTurns = turns.filter((turn) => turn.inputTokens > 0);
+    const positive = turns
+        .filter((turn) => turn.inputTokens > 0 && isStrongPositiveFeedback(turn.userMessage))
+        .map((turn) => ({ turn: turn.number, kind: "positive-user-feedback" }));
+    if (positive.length)
+        return positive;
+    const last = userTurns[userTurns.length - 1];
+    return last ? [{ turn: last.number, kind: "final-fallback" }] : [];
+}
+export function isStrongPositiveFeedback(message) {
+    const text = String(message || "")
+        .toLowerCase()
+        .replace(/[’]/g, "'")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!text)
+        return false;
+    if (/\b(no|not|wrong|incorrect|fix|bad|worse|broken|laggy|shaking|remove|revert|don't|do not|doesn't|does not|didn't|did not|isn't|is not)\b/.test(text)) {
+        if (!/\b(save this|looks good|perfect|exactly what i want|that's what i want|that is what i want)\b/.test(text))
+            return false;
+    }
+    return [
+        /\blooks? good\b/,
+        /\bthis is good\b/,
+        /\bcaveat font is good\b/,
+        /\bperfect\b/,
+        /\bthis is exactly\b/,
+        /\bthat's exactly\b/,
+        /\bthat is exactly\b/,
+        /\bexactly what i want\b/,
+        /\bthat's what i want\b/,
+        /\bthat is what i want\b/,
+        /\bwhat i want\b/,
+        /\byes[,.\s].*\blet'?s do it\b/,
+        /\bok[,.\s].*\blet'?s do it\b/,
+        /\blet'?s do it\b/,
+        /\bsave this\b/,
+        /\bship it\b/,
+        /\bapproved\b/,
+    ].some((pattern) => pattern.test(text));
+}
+function qualifyProblems(turns) {
+    for (const turn of turns) {
+        const previous = turns[turn.number - 2];
+        const previousText = [previous?.userMessage || "", ...(previous?.assistantMessages || [])].join("\n");
+        if (CORRECTION_RE.test(turn.userMessage)) {
+            if (CONSTRAINT_RE.test(previousText) || VIOLATION_RE.test(turn.userMessage))
+                turn.qualifiedProblems.add("P02");
+            if ((previous?.patchFiles.length || 0) > 0 || COMPLETION_RE.test(previousText))
+                turn.qualifiedProblems.add("P05");
+        }
+        if (MANUAL_REPAIR_RE.test(turn.userMessage))
+            turn.qualifiedProblems.add("P09");
+        if (previous?.timestampMs != null && turn.timestampMs != null && turn.timestampMs - previous.timestampMs >= GAP_MS) {
+            if (REORIENT_RE.test(turn.userMessage) || turn.commands.some((cmd) => ["read", "git", "search"].includes(cmd.kind))) {
+                turn.qualifiedProblems.add("P06");
+            }
+        }
+        if (turn.abort)
+            turn.qualifiedProblems.add("P07");
+    }
+    for (const compactionTurn of turns.filter((turn) => turn.compaction)) {
+        const knownFiles = new Set(turns
+            .filter((turn) => turn.number <= compactionTurn.number)
+            .flatMap((turn) => turn.commands.filter((command) => command.kind === "read" && command.file).map((command) => command.file)));
+        const knownCommands = new Set(turns
+            .filter((turn) => turn.number <= compactionTurn.number)
+            .flatMap((turn) => turn.commands.filter((command) => ["git", "search"].includes(command.kind)).map((command) => command.normalized)));
+        for (const turn of turns.filter((turn) => turn.number > compactionTurn.number && turn.number <= compactionTurn.number + 3)) {
+            const rediscovered = turn.commands.some((command) => command.kind === "read" && Boolean(command.file && knownFiles.has(command.file))
+                || ["git", "search"].includes(command.kind) && knownCommands.has(command.normalized));
+            if (rediscovered)
+                turn.qualifiedProblems.add("P04");
+        }
+    }
+    const seenGit = new Map();
+    const seenSearch = new Map();
+    const seenRun = new Map();
+    for (const turn of turns) {
+        for (const command of turn.commands) {
+            const key = `${turn.episode}:${command.normalized}`;
+            if (command.kind === "git") {
+                if (seenGit.has(key))
+                    turn.qualifiedProblems.add("P08");
+                else
+                    seenGit.set(key, turn.number);
+            }
+            else if (command.kind === "search") {
+                if (seenSearch.has(key))
+                    turn.qualifiedProblems.add("P10");
+                else
+                    seenSearch.set(key, turn.number);
+            }
+            else if (command.kind === "run" || command.kind === "command") {
+                const prior = seenRun.get(key);
+                if (prior != null && turn.number - prior <= 8)
+                    turn.qualifiedProblems.add("P09");
+                else if (prior == null)
+                    seenRun.set(key, turn.number);
+            }
+        }
+    }
+}
+function buildSessionFinding(parsed, scoringMode) {
+    const turnByNumber = new Map(parsed.turns.map((turn) => [turn.number, turn]));
+    const compactionTurns = parsed.turns.filter((turn) => turn.compaction).map((turn) => turn.number);
+    const eligibleTurns = parsed.turns.filter((turn) => turn.inputTokens > 0);
+    const episodeOutcomes = buildEpisodeOutcomeIndex(parsed);
+    const buckets = { duplicate: 0, refind: 0, dead: 0, unattributed: 0 };
+    const rawBuckets = { keep_oh: 0, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0 };
+    const items = [];
+    let officialInputTokens = 0;
+    let usefulTokens = 0;
+    let wasteTokens = 0;
+    let rawUsefulTokens = 0;
+    let rawOutcomeResidueTokens = 0;
+    let excludedUnlabeledTokens = 0;
+    for (const turn of eligibleTurns) {
+        const row = buildTurnAccounting({
+            turn,
+            turns: parsed.turns,
+            turnByNumber,
+            ledgerItems: parsed.ledgerItems,
+            compactionTurns,
+            overheadTokens: parsed.overheadTokens,
+            scoringMode,
+            episodeOutcomes,
+        });
+        for (const item of row.wasteItems)
+            item.problemId = problemForWasteItem(item, turn, turnByNumber);
+        const rawUseful = row.keep_oh + row.keep_prod;
+        const rawResidue = row.opt_dup + row.opt_refind + row.opt_dead;
+        rawBuckets.keep_oh += row.keep_oh;
+        rawBuckets.keep_prod += row.keep_prod;
+        rawBuckets.opt_dup += row.opt_dup;
+        rawBuckets.opt_refind += row.opt_refind;
+        rawBuckets.opt_dead += row.opt_dead;
+        const labeledItems = row.wasteItems.filter((item) => item.problemId);
+        const labeledWaste = labeledItems.reduce((total, item) => total + item.tokens, 0);
+        officialInputTokens += row.C_t;
+        rawUsefulTokens += rawUseful;
+        rawOutcomeResidueTokens += rawResidue;
+        usefulTokens += rawUseful;
+        wasteTokens += rawResidue;
+        excludedUnlabeledTokens += Math.max(0, rawResidue - labeledWaste);
+        buckets.duplicate += row.opt_dup;
+        buckets.refind += row.opt_refind;
+        buckets.dead += row.opt_dead;
+        for (const item of row.wasteItems) {
+            items.push({
+                ...item,
+                timestampMs: turn.timestampMs,
+                turnInputTokens: row.C_t,
+                turnUsefulTokens: Math.round(rawUseful),
+                turnWasteTokens: Math.round(rawResidue),
+            });
+        }
+    }
+    const qualifiedTokenPressure = {};
+    const qualifiedProblemTurns = new Set();
+    for (const turn of eligibleTurns) {
+        for (const problemId of turn.qualifiedProblems) {
+            qualifiedProblemTurns.add(`${problemId}:${turn.number}`);
+        }
+    }
+    for (const item of items) {
+        if (item.problemId)
+            qualifiedProblemTurns.add(`${item.problemId}:${item.turn}`);
+    }
+    for (const key of qualifiedProblemTurns) {
+        const [problemId, turnRaw] = key.split(":");
+        const turn = turnByNumber.get(Number(turnRaw));
+        if (turn?.inputTokens)
+            qualifiedTokenPressure[problemId] = (qualifiedTokenPressure[problemId] || 0) + turn.inputTokens;
+    }
+    return {
+        source: "codex",
+        session: parsed.session,
+        cwd: parsed.cwd,
+        repo: parsed.repo,
+        firstTs: parsed.firstTs,
+        lastTs: parsed.lastTs,
+        turnCount: parsed.turns.length,
+        officialInputTokens,
+        usefulTokens: Math.round(usefulTokens),
+        wasteTokens: Math.round(wasteTokens),
+        rawUsefulTokens: Math.round(rawUsefulTokens),
+        rawOutcomeResidueTokens: Math.round(rawOutcomeResidueTokens),
+        excludedUnlabeledTokens: Math.round(excludedUnlabeledTokens),
+        buckets: mapBucketValues(buckets, Math.round),
+        rawBuckets: mapBucketValues(rawBuckets, Math.round),
+        qualifiedTokenPressure,
+        items: items.map((item) => ({ ...item, tokens: Math.round(item.tokens) })),
+        episodes: buildSessionEpisodes(parsed, items.filter((item) => item.problemId)),
+    };
+}
+function buildTurnAccounting(args) {
+    const { turn, turns, ledgerItems, compactionTurns, overheadTokens, scoringMode, episodeOutcomes } = args;
+    const C_t = turn.inputTokens;
+    const lastCompaction = lastBefore(compactionTurns, turn.number);
+    const reasoningSegments = reasoningSegmentsSinceCompaction(turns, lastCompaction, turn.number);
+    const reasoningTokens = reasoningSegments.reduce((total, segment) => total + segment.tokens, 0);
+    const structureFloor = Math.round(SERIALIZATION_FRACTION * C_t);
+    const fixed = Math.min(C_t, overheadTokens + structureFloor + reasoningTokens);
+    const budget = Math.max(0, C_t - fixed);
+    const carried = ledgerItems.filter((item) => item.turn <= turn.number && CONTENT_KINDS.has(item.kind));
+    const retained = retainMostRecentFirst(carried, budget);
+    const row = { C_t, keep_oh: overheadTokens + structureFloor, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0, wasteItems: [] };
+    const outcome = episodeOutcomes.get(turn.episode);
+    for (const segment of reasoningSegments) {
+        const bucket = scoringMode === "episode-outcome"
+            ? segment.turn === turn.number && turn.number === outcome?.end ? "keep_prod" : "opt_refind"
+            : segment.turn === turn.number ? "keep_prod" : "opt_refind";
+        row[bucket] += segment.tokens;
+        if (bucket === "opt_refind") {
+            row.wasteItems.push({
+                problemId: scoringMode === "local-live" ? "P13" : null,
+                bucket: "refind",
+                tokens: segment.tokens,
+                turn: turn.number,
+                sourceTurn: segment.turn,
+                kind: "reasoning",
+                evidence: scoringMode === "episode-outcome" ? "reasoning did not survive as episode outcome context" : "resident reasoning/self-talk in retained context",
+                prompt: compactPreview(turn.userMessage),
+                output: compactBlockPreview(turn.assistantMessages[turn.assistantMessages.length - 1] || ""),
+            });
+        }
+    }
+    const localState = { seenWrite: false, seenSameTurnTransient: new Set() };
+    for (const item of retained) {
+        const classified = scoringMode === "episode-outcome"
+            ? classifyEpisodeOutcomeItem({ item, turn, turns, ledgerItems, outcome })
+            : classifyLocalLiveItem({ item, turn, turns, ledgerItems, outcome, state: localState });
+        row[classified.bucket] += item.retainedTokens;
+        if (classified.bucket.startsWith("opt_")) {
+            const bucket = publicBucket(classified.bucket);
+            row.wasteItems.push({
+                problemId: classified.problemId,
+                bucket,
+                tokens: item.retainedTokens,
+                turn: turn.number,
+                sourceTurn: item.turn,
+                kind: item.kind,
+                file: item.file,
+                files: item.files,
+                command: item.command,
+                normalizedCommand: item.normalizedCommand,
+                source: item.source,
+                imageOutput: item.imageOutput,
+                evidence: classified.evidence,
+                prompt: compactPreview(turn.userMessage),
+                output: compactBlockPreview(turn.assistantMessages[turn.assistantMessages.length - 1] || ""),
+            });
+        }
+    }
+    const sum = row.keep_oh + row.keep_prod + row.opt_dup + row.opt_refind + row.opt_dead;
+    const residual = C_t - sum;
+    if (residual >= 0) {
+        row.opt_refind += residual;
+        if (residual > 0) {
+            row.wasteItems.push({
+                problemId: null,
+                bucket: "refind",
+                tokens: residual,
+                turn: turn.number,
+                sourceTurn: turn.number,
+                kind: "residual",
+                evidence: "unrepresented serialization/reconciliation residue",
+                prompt: compactPreview(turn.userMessage),
+                output: compactBlockPreview(turn.assistantMessages[turn.assistantMessages.length - 1] || ""),
+            });
+        }
+    }
+    else {
+        const scale = C_t / Math.max(1, sum);
+        row.keep_oh *= scale;
+        row.keep_prod *= scale;
+        row.opt_dup *= scale;
+        row.opt_refind *= scale;
+        row.opt_dead *= scale;
+        for (const item of row.wasteItems)
+            item.tokens *= scale;
+    }
+    return row;
+}
+function reasoningSegmentsSinceCompaction(turns, lastCompaction, currentTurn) {
+    const segments = [];
+    let previousCumulative = 0;
+    for (const turn of turns.filter((item) => item.number > lastCompaction && item.number <= currentTurn)) {
+        const cumulative = Math.max(previousCumulative, turn.reasoningTokens || previousCumulative);
+        const tokens = cumulative - previousCumulative;
+        if (tokens > 0)
+            segments.push({ turn: turn.number, tokens });
+        previousCumulative = cumulative;
+    }
+    return segments;
+}
+function buildEpisodeOutcomeIndex(parsed) {
+    const outcomes = new Map();
+    const supportingFiles = buildSupportingFileSet(parsed);
+    const episodeNumbers = [...new Set(parsed.turns.map((turn) => turn.episode))].sort((a, b) => a - b);
+    for (const episode of episodeNumbers) {
+        const episodeTurns = parsed.turns.filter((turn) => turn.episode === episode);
+        if (!episodeTurns.length)
+            continue;
+        const start = episodeTurns[0].number;
+        const end = episodeTurns[episodeTurns.length - 1].number;
+        const editedFiles = new Set(episodeTurns.flatMap((turn) => turn.patchFiles.map(normalizeFile)));
+        const writtenItems = parsed.ledgerItems
+            .filter((item) => item.kind === "written" && item.turn >= start && item.turn <= end)
+            .sort((a, b) => b.id - a.id);
+        const usefulWrittenIds = new Set();
+        const latestByFile = new Map();
+        const unfiled = [];
+        for (const item of writtenItems) {
+            const files = item.files?.length ? item.files : item.file ? [item.file] : [];
+            if (!files.length) {
+                unfiled.push(item);
+                continue;
+            }
+            for (const file of files) {
+                const versions = latestByFile.get(file) || [];
+                if (versions.length >= 2)
+                    continue;
+                versions.push(item);
+                usefulWrittenIds.add(item.id);
+                latestByFile.set(file, versions);
+            }
+        }
+        for (const item of unfiled.slice(0, 2))
+            usefulWrittenIds.add(item.id);
+        const latestTransientByKey = new Map();
+        for (const item of parsed.ledgerItems) {
+            if (item.turn < start || item.turn > end || (item.kind !== "search" && item.kind !== "command"))
+                continue;
+            const key = transientKey(item);
+            if (!key)
+                continue;
+            const previous = latestTransientByKey.get(key);
+            if (!previous || item.id > previous.id)
+                latestTransientByKey.set(key, item);
+        }
+        outcomes.set(episode, { episode, start, end, editedFiles, supportingFiles, usefulWrittenIds, latestTransientByKey });
+    }
+    return outcomes;
+}
+function buildSupportingFileSet(parsed) {
+    const supporting = new Set(parsed.turns.flatMap((turn) => turn.patchFiles.map(normalizeFile)));
+    const writeSignals = contentSignals(parsed.ledgerItems.filter((item) => item.kind === "written").map((item) => item.text || "").join("\n"));
+    const readTextByFile = new Map();
+    for (const item of parsed.ledgerItems) {
+        if (item.kind !== "read" || !item.file || !item.text)
+            continue;
+        const previous = readTextByFile.get(item.file) || "";
+        if (previous.length < 60_000)
+            readTextByFile.set(item.file, `${previous}\n${item.text}`.slice(0, 60_000));
+    }
+    for (const [file, text] of readTextByFile) {
+        const readSignals = contentSignals(text);
+        let matches = 0;
+        for (const signal of readSignals)
+            if (writeSignals.has(signal))
+                matches += 1;
+        if (matches >= 4 || (readSignals.size >= 8 && matches / readSignals.size >= 0.15))
+            supporting.add(file);
+    }
+    return supporting;
+}
+function contentSignals(text) {
+    const signals = new Set();
+    for (const match of String(text).matchAll(/#[0-9a-fA-F]{3,8}\b/g))
+        signals.add(`c:${match[0].toLowerCase()}`);
+    for (const match of String(text).matchAll(/--[a-zA-Z][\w-]{2,}/g))
+        signals.add(`v:${match[0].toLowerCase()}`);
+    for (const match of String(text).matchAll(/\b\d{1,4}(?:\.\d+)?(?:px|rem|em|vh|vw|ms)\b/g))
+        signals.add(`u:${match[0].toLowerCase()}`);
+    return signals;
+}
+function transientKey(item) {
+    if (item.kind === "search")
+        return `search:${item.normalizedCommand || item.command || ""}`;
+    if (item.kind === "command")
+        return `command:${item.normalizedCommand || item.command || ""}`;
+    return "";
+}
+function classifyLocalLiveItem(args) {
+    const { item, turn, turns, ledgerItems, outcome, state } = args;
+    if (item.kind === "conv_user")
+        return { bucket: "keep_prod", problemId: null, evidence: "current user request/product instruction" };
+    if (item.kind === "conv_agent") {
+        return item.turn === turn.number
+            ? { bucket: "keep_prod", problemId: null, evidence: "current assistant output" }
+            : { bucket: "opt_refind", problemId: null, evidence: "carried assistant explanation residue" };
+    }
+    if (item.kind === "search" || item.kind === "command") {
+        if (item.turn !== turn.number)
+            return { bucket: "opt_refind", problemId: null, evidence: "carried transient tool output" };
+        const key = transientKey(item);
+        if (key && state.seenSameTurnTransient.has(key)) {
+            return { bucket: "opt_refind", problemId: null, evidence: "same-turn transient output superseded by a later duplicate" };
+        }
+        if (key)
+            state.seenSameTurnTransient.add(key);
+        return { bucket: "keep_prod", problemId: null, evidence: "active same-turn discovery/support" };
+    }
+    if (item.kind === "image") {
+        const currentOutcome = outcome
+            ? { ...outcome, end: turn.number }
+            : { episode: turn.episode, start: turn.episodeStart, end: turn.number, editedFiles: new Set(), supportingFiles: new Set(), usefulWrittenIds: new Set(), latestTransientByKey: new Map() };
+        return imageActiveAtEpisodeOutcome(item, currentOutcome, turns, ledgerItems)
+            ? { bucket: "keep_prod", problemId: null, evidence: "current visual/reference evidence" }
+            : { bucket: "opt_dead", problemId: null, evidence: "expired or superseded visual context" };
+    }
+    if (item.kind === "written") {
+        if (!state.seenWrite) {
+            state.seenWrite = true;
+            return { bucket: "keep_prod", problemId: null, evidence: "latest written work" };
+        }
+        return { bucket: "opt_dup", problemId: null, evidence: "superseded earlier written version" };
+    }
+    if (item.kind === "read") {
+        if (hasPriorUnchangedRead(item, turns, ledgerItems)) {
+            return { bucket: "opt_dup", problemId: null, evidence: "same file/range was read earlier without an intervening edit" };
+        }
+        if (item.turn === turn.number)
+            return { bucket: "keep_prod", problemId: null, evidence: "active same-turn file context" };
+        return item.file && outcome?.supportingFiles.has(item.file)
+            ? { bucket: "keep_prod", problemId: null, evidence: "carried read supports edited product files" }
+            : { bucket: "opt_dead", problemId: null, evidence: "carried read has no outcome connection" };
+    }
+    return { bucket: "opt_dead", problemId: null, evidence: "context item is no longer active" };
+}
+function hasPriorUnchangedRead(item, turns, ledgerItems) {
+    if (item.kind !== "read" || !item.file)
+        return false;
+    return ledgerItems.some((prior) => prior.kind === "read"
+        && prior.file === item.file
+        && prior.turn < item.turn
+        && rangesOverlap(prior.range, item.range)
+        && !fileEditedBetween(turns, item.file, prior.turn, item.turn));
+}
+function classifyEpisodeOutcomeItem(args) {
+    const { item, turn, turns, ledgerItems } = args;
+    const outcome = args.outcome || {
+        episode: turn.episode,
+        start: turn.episodeStart,
+        end: turn.number,
+        editedFiles: new Set(),
+        supportingFiles: new Set(),
+        usefulWrittenIds: new Set(),
+        latestTransientByKey: new Map(),
+    };
+    const sourceTurn = turns[item.turn - 1];
+    if (item.kind === "conv_user") {
+        return sourceTurn?.episode === turn.episode
+            ? { bucket: "keep_prod", problemId: null, evidence: "same-episode user/product instruction" }
+            : { bucket: "opt_dead", problemId: null, evidence: "user/spec context from an older episode" };
+    }
+    if (item.kind === "conv_agent") {
+        return item.turn === outcome.end && turn.number === outcome.end
+            ? { bucket: "keep_prod", problemId: null, evidence: "assistant output active at episode outcome" }
+            : { bucket: "opt_refind", problemId: null, evidence: "assistant explanation did not survive as episode outcome context" };
+    }
+    if (item.kind === "search" || item.kind === "command") {
+        const key = transientKey(item);
+        const latest = key ? outcome.latestTransientByKey.get(key) : null;
+        if (latest && latest.id !== item.id) {
+            return { bucket: "opt_refind", problemId: null, evidence: "transient output superseded before episode outcome" };
+        }
+        return item.turn === outcome.end && turn.number === outcome.end
+            ? { bucket: "keep_prod", problemId: null, evidence: "transient output active at episode outcome" }
+            : { bucket: "opt_refind", problemId: null, evidence: "transient output did not survive as episode outcome context" };
+    }
+    if (item.kind === "image") {
+        return imageActiveAtEpisodeOutcome(item, outcome, turns, ledgerItems)
+            ? { bucket: "keep_prod", problemId: null, evidence: "visual/reference context active at episode outcome" }
+            : { bucket: "opt_dead", problemId: null, evidence: "visual/reference context expired before episode outcome" };
+    }
+    if (item.kind === "written") {
+        return outcome.usefulWrittenIds.has(item.id)
+            ? { bucket: "keep_prod", problemId: null, evidence: "latest two written versions by episode outcome" }
+            : { bucket: "opt_dup", problemId: null, evidence: "written version older than latest two before episode outcome" };
+    }
+    if (item.kind === "read") {
+        if (hasLaterDuplicateReadBeforeOutcome(item, outcome, turns, ledgerItems)) {
+            return { bucket: "opt_dup", problemId: null, evidence: "same file/range was re-read before episode outcome" };
+        }
+        const connects = item.file && (outcome.editedFiles.size ? outcome.editedFiles.has(item.file) : outcome.supportingFiles.has(item.file));
+        return connects
+            ? { bucket: "keep_prod", problemId: null, evidence: "read connects to episode outcome files" }
+            : { bucket: "opt_dead", problemId: null, evidence: "read does not connect to episode outcome files" };
+    }
+    return { bucket: "opt_dead", problemId: null, evidence: "item does not connect to episode outcome" };
+}
+function hasLaterDuplicateReadBeforeOutcome(item, outcome, turns, ledgerItems) {
+    if (item.kind !== "read" || !item.file)
+        return false;
+    return ledgerItems.some((later) => later.kind === "read"
+        && later.file === item.file
+        && later.turn > item.turn
+        && later.turn <= outcome.end
+        && rangesOverlap(later.range, item.range)
+        && !fileEditedBetween(turns, item.file, item.turn, later.turn));
+}
+function imageActiveAtEpisodeOutcome(item, outcome, turns, ledgerItems) {
+    if (item.source === "user_reference") {
+        if (turns[item.turn - 1]?.episode !== outcome.episode)
+            return false;
+        return !ledgerItems.some((later) => later.kind === "image"
+            && later.source === "user_reference"
+            && later.turn > item.turn
+            && later.turn <= outcome.end
+            && userReferenceReplacement(turns[later.turn - 1]?.userMessage || ""));
+    }
+    if (item.source === "tool_screenshot") {
+        const laterEdit = turns.some((turn) => turn.number > item.turn && turn.number <= outcome.end && turn.patchFiles.length > 0);
+        const laterScreenshot = ledgerItems.some((later) => later.kind === "image"
+            && later.source === "tool_screenshot"
+            && later.turn > item.turn
+            && later.turn <= outcome.end
+            && (later.target || "tool_image") === (item.target || "tool_image"));
+        return !laterEdit && !laterScreenshot;
+    }
+    return false;
+}
+function userReferenceReplacement(message) {
+    return /\b(use this instead|instead use|replace|updated|new mockup|new reference|ignore (?:the )?(?:previous|old)|actually use|latest version|use this version)\b/i.test(message);
+}
+function fileEditedBetween(turns, file, startExclusive, endInclusive) {
+    return turns.some((turn) => turn.number > startExclusive
+        && turn.number <= endInclusive
+        && turn.patchFiles.some((edited) => normalizeFile(edited) === file));
+}
+function problemForWasteItem(item, currentTurn, turnByNumber) {
+    const kind = item.kind || "";
+    const command = String(item.command || item.normalizedCommand || "");
+    const age = Math.max(0, currentTurn.number - item.sourceTurn);
+    const currentProblems = currentTurn.qualifiedProblems;
+    const sourceProblems = turnByNumber.get(item.sourceTurn)?.qualifiedProblems || new Set();
+    const rediscovery = ["read", "search", "command", "residual", "conv_agent"].includes(kind);
+    const repairLocal = age <= 1;
+    if (currentProblems.has("P07") && rediscovery)
+        return "P07";
+    if (currentProblems.has("P02") && rediscovery && repairLocal)
+        return "P02";
+    if (kind === "command" && isGitCommand(command) && (currentProblems.has("P08") || sourceProblems.has("P08")))
+        return "P08";
+    if (kind === "search" && (currentProblems.has("P10") || sourceProblems.has("P10")))
+        return "P10";
+    if (currentProblems.has("P06") && rediscovery)
+        return "P06";
+    if ((currentProblems.has("P04") || sourceProblems.has("P04")) && isConcreteRediscoveryItem(item) && repairLocal)
+        return "P04";
+    if (currentProblems.has("P05") && rediscovery && repairLocal)
+        return "P05";
+    if (item.bucket === "duplicate" && (kind === "read" || kind === "written"))
+        return "P03";
+    if (currentProblems.has("P09") && rediscovery && repairLocal)
+        return "P09";
+    if ((kind === "image" && item.bucket === "dead") || item.imageOutput)
+        return "P01";
+    if (isVisualProbeCommand(command))
+        return "P11";
+    if (kind === "command" || kind === "search" || (kind === "read" && item.bucket === "dead") || isOrientationCommand(command))
+        return "P12";
+    if (kind === "reasoning" || kind === "residual" || kind === "conv_agent" || kind === "conv_user")
+        return "P13";
+    return null;
+}
+function isConcreteRediscoveryItem(item) {
+    if (item.kind === "read" || item.kind === "search")
+        return true;
+    return item.kind === "command" && isGitCommand(String(item.command || item.normalizedCommand || ""));
+}
+function isOrientationCommand(command) {
+    const normalized = command.trim();
+    return normalized === "search_memories"
+        || normalized === "search_memories_by_keywords"
+        || isGitCommand(normalized)
+        || /^ls(?:\s|$)/.test(normalized);
+}
+function aggregate(sessions, opts) {
+    const problemStats = new Map();
+    const exampleCandidates = new Map();
+    const repos = new Map();
+    const sessionRows = [];
+    const episodes = [];
+    const buckets = { duplicate: 0, refind: 0, dead: 0, unattributed: 0 };
+    const rawBuckets = { keep_oh: 0, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0 };
+    let officialInputTokens = 0;
+    let usefulTokens = 0;
+    let wasteTokens = 0;
+    let rawUsefulTokens = 0;
+    let rawOutcomeResidueTokens = 0;
+    let excludedUnlabeledTokens = 0;
+    let turnsAnalyzed = 0;
+    for (const session of sessions) {
+        officialInputTokens += session.officialInputTokens;
+        usefulTokens += session.usefulTokens;
+        wasteTokens += session.wasteTokens;
+        rawUsefulTokens += session.rawUsefulTokens;
+        rawOutcomeResidueTokens += session.rawOutcomeResidueTokens;
+        excludedUnlabeledTokens += session.excludedUnlabeledTokens;
+        turnsAnalyzed += session.turnCount;
+        for (const bucket of Object.keys(buckets))
+            buckets[bucket] += session.buckets[bucket] || 0;
+        for (const bucket of Object.keys(rawBuckets))
+            rawBuckets[bucket] += session.rawBuckets[bucket] || 0;
+        const repo = repos.get(session.repo) || { sessions: new Set(), officialInputTokens: 0, wasteTokens: 0 };
+        repo.sessions.add(session.session);
+        repo.officialInputTokens += session.officialInputTokens;
+        repo.wasteTokens += session.wasteTokens;
+        repos.set(session.repo, repo);
+        const byProblem = new Map();
+        for (const item of session.items) {
+            if (!item.problemId) {
+                continue;
+            }
+            byProblem.set(item.problemId, (byProblem.get(item.problemId) || 0) + item.tokens);
+            const stat = problemStats.get(item.problemId) || { count: 0, tokens: 0, pressure: 0, sessions: new Set(), examples: [] };
+            stat.count += 1;
+            stat.tokens += item.tokens;
+            stat.sessions.add(session.session);
+            problemStats.set(item.problemId, stat);
+            const candidateKey = `${item.problemId}:${session.session}:${item.turn}`;
+            const candidate = exampleCandidates.get(candidateKey) || {
+                // Full id: the setup page's "open original session" button needs it to resume the session.
+                session: session.session,
+                repo: session.repo,
+                agentSource: session.source,
+                turn: item.turn,
+                tokens: 0,
+                evidence: item.evidence,
+                command: item.command || item.normalizedCommand || null,
+                file: item.file || null,
+                prompt: item.prompt,
+                output: item.output,
+                timestampMs: item.timestampMs ?? null,
+                sessionStartedAt: session.firstTs,
+                sessionTurns: session.turnCount,
+                turnInputTokens: item.turnInputTokens,
+                turnUsefulTokens: item.turnUsefulTokens,
+                turnWasteTokens: item.turnWasteTokens,
+            };
+            candidate.tokens += item.tokens;
+            if (item.tokens > 0 && item.evidence)
+                candidate.evidence = item.evidence;
+            exampleCandidates.set(candidateKey, candidate);
+        }
+        for (const [problemId, pressure] of Object.entries(session.qualifiedTokenPressure)) {
+            const stat = problemStats.get(problemId) || { count: 0, tokens: 0, pressure: 0, sessions: new Set(), examples: [] };
+            stat.pressure += pressure;
+            stat.sessions.add(session.session);
+            problemStats.set(problemId, stat);
+        }
+        const topProblem = [...byProblem.entries()].sort((a, b) => b[1] - a[1])[0] || null;
+        sessionRows.push({
+            session: session.session.slice(0, 8),
+            repo: session.repo,
+            turns: session.turnCount,
+            officialInputTokens: session.officialInputTokens,
+            wasteTokens: session.wasteTokens,
+            topProblemId: topProblem ? topProblem[0] : null,
+        });
+        for (const episode of session.episodes) {
+            if (!episode.dominantProblemId)
+                continue;
+            episodes.push({
+                id: `${session.session.slice(0, 8)}-${episode.id}`,
+                session: session.session.slice(0, 8),
+                repo: session.repo,
+                turnStart: episode.turnStart,
+                turnEnd: episode.turnEnd,
+                wasteTokens: episode.wasteTokens,
+                dominantProblemId: episode.dominantProblemId,
+            });
+        }
+    }
+    for (const [key, candidate] of exampleCandidates) {
+        const problemId = key.split(":")[0];
+        const stat = problemStats.get(problemId);
+        if (!stat)
+            continue;
+        upsertWorstExample(stat.examples, { ...candidate, tokens: Math.round(candidate.tokens) });
+    }
+    const problems = Object.keys(PROBLEMS)
+        .map((id) => {
+        const base = PROBLEMS[id];
+        const stat = problemStats.get(id) || { count: 0, tokens: 0, pressure: 0, sessions: new Set(), examples: [] };
+        return {
+            ...base,
+            count: stat.count,
+            sessions: stat.sessions.size,
+            allocatedWasteTokens: Math.round(stat.tokens),
+            qualifiedTokenPressure: Math.round(stat.pressure),
+            severity: severity(stat.tokens, stat.count, sessions.length),
+            examples: stat.examples,
+        };
+    })
+        .sort((a, b) => b.allocatedWasteTokens - a.allocatedWasteTokens || b.count - a.count);
+    return {
+        version: 1,
+        generatedFrom: opts?.generatedFrom || ["~/.codex/sessions"],
+        methodology: {
+            name: "Context Golden Standard workspace rollup",
+            status: "deterministic-plus-heuristic",
+            scoringMode: opts?.scoringMode || "local-live",
+            note: opts?.note || "Each session is analyzed independently, partitioned into episodes where the source supports it, and waste is attributed to P01-P13 before workspace aggregation.",
+        },
+        summary: {
+            sessionsAnalyzed: sessions.length,
+            reposAnalyzed: repos.size,
+            turnsAnalyzed,
+            officialInputTokens: Math.round(officialInputTokens),
+            usefulTokens: Math.round(usefulTokens),
+            wasteTokens: Math.round(wasteTokens),
+            usefulPct: pct(usefulTokens, officialInputTokens),
+            wastePct: pct(wasteTokens, officialInputTokens),
+            attributedWasteTokens: Math.round(Math.max(0, wasteTokens - excludedUnlabeledTokens)),
+            unattributedWasteTokens: Math.round(excludedUnlabeledTokens),
+            rawUsefulTokens: Math.round(rawUsefulTokens),
+            rawOutcomeResidueTokens: Math.round(rawOutcomeResidueTokens),
+            excludedUnlabeledTokens: 0,
+        },
+        buckets: mapBucketValues(buckets, Math.round),
+        rawBuckets: mapBucketValues(rawBuckets, Math.round),
+        problems,
+        sessions: sessionRows.sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
+        repos: [...repos.entries()]
+            .map(([repoName, value]) => ({
+            repo: repoName,
+            sessions: value.sessions.size,
+            officialInputTokens: Math.round(value.officialInputTokens),
+            wasteTokens: Math.round(value.wasteTokens),
+        }))
+            .sort((a, b) => b.wasteTokens - a.wasteTokens)
+            .slice(0, 8),
+        episodes: episodes.sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
+    };
+}
+function buildSessionEpisodes(parsed, items) {
+    const groups = new Map();
+    for (const turn of parsed.turns) {
+        const group = groups.get(turn.episode) || { start: turn.number, end: turn.number, waste: 0, byProblem: new Map() };
+        group.start = Math.min(group.start, turn.number);
+        group.end = Math.max(group.end, turn.number);
+        groups.set(turn.episode, group);
+    }
+    for (const item of items) {
+        const turn = parsed.turns[item.turn - 1];
+        if (!turn)
+            continue;
+        const group = groups.get(turn.episode);
+        if (!group)
+            continue;
+        group.waste += item.tokens;
+        if (item.problemId)
+            group.byProblem.set(item.problemId, (group.byProblem.get(item.problemId) || 0) + item.tokens);
+    }
+    return [...groups.entries()].map(([episode, group]) => {
+        const top = [...group.byProblem.entries()].sort((a, b) => b[1] - a[1])[0] || null;
+        return {
+            id: `E${episode}`,
+            turnStart: group.start,
+            turnEnd: group.end,
+            wasteTokens: Math.round(group.waste),
+            dominantProblemId: top ? top[0] : null,
+        };
+    });
+}
+function retainMostRecentFirst(items, budget) {
+    const retained = [];
+    let running = 0;
+    for (const item of [...items].reverse()) {
+        if (running >= budget)
+            break;
+        const tokens = Math.min(item.tokens, budget - running);
+        if (tokens <= 0)
+            continue;
+        retained.push({ ...item, retainedTokens: tokens, partial: tokens < item.tokens });
+        running += tokens;
+    }
+    return retained;
+}
+function addLedger(items, item) {
+    if (item.tokens > 0)
+        items.push(item);
+}
+function classifyCommand(cmd) {
+    const first = firstCommand(cmd);
+    const bin = first.split(/\s+/)[0] || "";
+    if (bin === "git") {
+        const sub = first.split(/\s+/).find((part, index) => index > 0 && !part.startsWith("-")) || "";
+        return GIT_MEMORY_SUBS.has(sub) ? "git" : "command";
+    }
+    if (READ_BINS.has(bin))
+        return "read";
+    if (SEARCH_BINS.has(bin))
+        return "search";
+    if (RUN_BINS.has(bin))
+        return "run";
+    return "command";
+}
+function isClaudeToolResultUser(record) {
+    const message = isRecord(record.message) ? record.message : {};
+    const content = message.content;
+    return Array.isArray(content) && content.some((block) => isRecord(block) && block.type === "tool_result");
+}
+function extractClaudeText(value) {
+    if (!value)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(extractClaudeText).filter(Boolean).join("\n");
+    if (isRecord(value)) {
+        if (typeof value.text === "string")
+            return value.text;
+        if (typeof value.content === "string")
+            return value.content;
+        if (Array.isArray(value.content))
+            return value.content.map(extractClaudeText).filter(Boolean).join("\n");
+    }
+    return "";
+}
+function countClaudeImages(value) {
+    const text = extractClaudeText(value);
+    return (text.match(/data:image\/|codex-clipboard-|\.png|\.jpe?g|\.webp/gi) || []).length;
+}
+function claudeInputTokens(usage) {
+    return readNumber(usage.input_tokens) + readNumber(usage.cache_read_input_tokens) + readNumber(usage.cache_creation_input_tokens);
+}
+function isSearchCommand(command) {
+    const first = firstCommand(command);
+    const bin = first.split(/\s+/)[0] || "";
+    return SEARCH_BINS.has(bin) || bin === "ls";
+}
+function canonicalClaudeSearch(command) {
+    return normalizeCommand(command)
+        .replace(/\/private\/tmp\/[^/\s]+\/[^\s]+/g, "/tmp/...")
+        .replace(/\d{4}-\d{2}-\d{2}T[^\s]+/g, "<timestamp>")
+        .replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,36}\b/g, "<uuid>")
+        .slice(0, 180);
+}
+function bucketForClaudeProblem(problemId) {
+    if (problemId === "P03")
+        return "opt_dup";
+    if (problemId === "P01" || problemId === "P02" || problemId === "P05" || problemId === "P07" || problemId === "P09" || problemId === "P13")
+        return "opt_dead";
+    return "opt_refind";
+}
+function compactPreview(text, limit = 360) {
+    const compacted = text.replace(/\s+/g, " ").trim();
+    if (!compacted)
+        return undefined;
+    return compacted.length > limit ? `${compacted.slice(0, limit - 1)}…` : compacted;
+}
+function compactBlockPreview(text, limit = 900) {
+    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;
+}
+function upsertWorstExample(examples, example) {
+    examples.push(example);
+    examples.sort((left, right) => (right.tokens || 0) - (left.tokens || 0));
+    examples.splice(1);
+}
+function shellRead(cmd) {
+    const first = firstCommand(cmd);
+    const parts = first.split(/\s+/).map((part) => part.replace(/^['"]|['"]$/g, ""));
+    const bin = parts[0] || "";
+    if (!READ_BINS.has(bin))
+        return null;
+    let start = 1;
+    let end = Infinity;
+    const sedRange = first.match(/(\d+),(\d+)p/);
+    if (sedRange) {
+        start = Number(sedRange[1]);
+        end = Number(sedRange[2]);
+    }
+    for (let i = parts.length - 1; i >= 1; i -= 1) {
+        const token = parts[i];
+        if (!token || token.startsWith("-") || /^\d+,?\d*p?$/.test(token))
+            continue;
+        if (token.includes("/") || /\.[A-Za-z0-9]{1,8}$/.test(token))
+            return { file: normalizeFile(token), start, end };
+    }
+    return null;
+}
+function firstCommand(cmd) {
+    return String(cmd).split(/&&|\|\||[;|\n]/)[0]?.split("|")[0]?.trim() || "";
+}
+function normalizeCommand(cmd) {
+    return String(cmd)
+        .replace(/\s+/g, " ")
+        .replace(/(['"])([^'"]{160,})\1/g, "$1...$1")
+        .trim()
+        .slice(0, 260);
+}
+function isGitCommand(cmd) {
+    return /^\s*git(?:\s|$)/.test(firstCommand(cmd));
+}
+function isRunCommand(cmd) {
+    const bin = firstCommand(cmd).split(/\s+/)[0] || "";
+    return RUN_BINS.has(bin);
+}
+function isVisualToolName(name) {
+    return /browser|screenshot|playwright|chrome|view_image|computer/i.test(name);
+}
+function isVisualProbeCommand(cmd) {
+    const normalized = String(cmd).trim();
+    return normalized === "js" || /^curl\s+-I\s+https?:\/\/(?:127\.0\.0\.1|localhost|\[?::1\]?)(?::|\b|\/)/.test(normalized);
+}
+function outputLooksLikeImage(output) {
+    if (Array.isArray(output))
+        return output.some((item) => isRecord(item) && (item.type === "input_image" || item.image_url));
+    if (!isRecord(output))
+        return false;
+    return output.type === "input_image" || typeof output.image_url === "string";
+}
+function countImagesDeep(value) {
+    if (!value)
+        return 0;
+    if (typeof value === "string") {
+        return (value.match(/"type"\s*:\s*"input_image"/g) || []).length + (value.match(/data:image\//g) || []).length;
+    }
+    if (Array.isArray(value))
+        return value.reduce((total, item) => total + countImagesDeep(item), 0);
+    if (isRecord(value)) {
+        return (value.type === "input_image" ? 1 : 0) + Object.values(value).reduce((total, item) => total + countImagesDeep(item), 0);
+    }
+    return 0;
+}
+function countUserImages(payload) {
+    const images = Array.isArray(payload.images) ? payload.images.length : 0;
+    const localImages = Array.isArray(payload.local_images) ? payload.local_images.length : 0;
+    return images + localImages + countImagesDeep(payload.message || "");
+}
+function extractPatchFiles(input) {
+    const files = new Set();
+    for (const line of String(input || "").split("\n")) {
+        const match = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/) || line.match(/^\*\*\* Move to: (.+)$/);
+        if (match?.[1])
+            files.add(normalizeFile(match[1]));
+    }
+    return [...files];
+}
+function tokensFromOutput(output) {
+    const text = typeof output === "string" ? output : safeJson(output);
+    if (!text)
+        return 0;
+    const original = text.match(ORIGINAL_TOKEN_RE);
+    const tokens = original ? Number(original[1]) : codeTokens(text);
+    return Math.min(OUTPUT_TOKEN_CAP, Math.max(0, tokens));
+}
+function textTokens(text) {
+    return Math.round(String(text || "").length / R_TEXT);
+}
+function codeTokens(text) {
+    return Math.round(String(text || "").length / R_CODE);
+}
+function readNestedText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!isRecord(value))
+        return "";
+    if (typeof value.text === "string")
+        return value.text;
+    return safeJson(value);
+}
+function userTextFromPayload(payload) {
+    const message = payload.message;
+    if (typeof message === "string")
+        return message.trim();
+    if (Array.isArray(message))
+        return message.map(textFromContentBlock).filter(Boolean).join("\n").trim();
+    if (isRecord(message)) {
+        const content = message.content;
+        if (typeof content === "string")
+            return content.trim();
+        if (Array.isArray(content))
+            return content.map(textFromContentBlock).filter(Boolean).join("\n").trim();
+    }
+    return "";
+}
+function assistantTextFromPayload(payload) {
+    const message = payload.message;
+    if (typeof message === "string")
+        return message.trim();
+    if (isRecord(message)) {
+        const content = message.content;
+        if (typeof content === "string")
+            return content.trim();
+        if (Array.isArray(content))
+            return content.map(textFromContentBlock).filter(Boolean).join("\n").trim();
+    }
+    const content = payload.content;
+    if (typeof content === "string")
+        return content.trim();
+    if (Array.isArray(content))
+        return content.map(textFromContentBlock).filter(Boolean).join("\n").trim();
+    return "";
+}
+function textFromContentBlock(block) {
+    if (typeof block === "string")
+        return block;
+    if (!isRecord(block))
+        return "";
+    const text = block.text;
+    if (typeof text === "string")
+        return text;
+    const content = block.content;
+    return typeof content === "string" ? content : "";
+}
+function parseArguments(value) {
+    if (isRecord(value))
+        return value;
+    if (typeof value !== "string")
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function normalizeFile(filePath) {
+    return String(filePath).replace(/^['"]|['"]$/g, "").replace(/^\.\//, "").toLowerCase();
+}
+function repoLabel(cwd) {
+    if (!cwd)
+        return "home";
+    const m = cwd.match(/worktrees\/[^/]+\/(.+)$/);
+    const base = path.basename(m ? m[1] : cwd);
+    return base && base !== "." && base !== "/" ? base : "home";
+}
+function lastBefore(values, turn) {
+    let out = 0;
+    for (const value of values)
+        if (value < turn)
+            out = Math.max(out, value);
+    return out;
+}
+function rangesOverlap(a, b) {
+    if (!a || !b)
+        return true;
+    return a.start <= b.end && b.start <= a.end;
+}
+function publicBucket(bucket) {
+    if (bucket === "opt_dup")
+        return "duplicate";
+    if (bucket === "opt_refind")
+        return "refind";
+    if (bucket === "opt_dead")
+        return "dead";
+    return "unattributed";
+}
+function itemEvidence(item) {
+    return (item.label || item.file || item.normalizedCommand || item.command || item.kind || "item").replace(/\s+/g, " ").slice(0, 180);
+}
+function mapBucketValues(values, fn) {
+    const out = { ...values };
+    for (const key of Object.keys(out))
+        out[key] = fn(out[key]);
+    return out;
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value || "");
+    }
+    catch {
+        return "";
+    }
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function pct(part, total) {
+    return total > 0 ? Math.round((part / total) * 1000) / 10 : 0;
+}
+function severity(tokens, count, sessionCount) {
+    if (tokens <= 0 && count <= 0)
+        return 0;
+    const tokenScore = Math.log10(Math.max(10, tokens)) * 1.15;
+    const frequencyScore = Math.log10(Math.max(1, count) + 1) * 1.4;
+    const spreadScore = sessionCount ? Math.min(2, count / Math.max(1, sessionCount)) : 0;
+    return Math.round(Math.min(10, tokenScore + frequencyScore + spreadScore) * 10) / 10;
+}
+function loadCache() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(cachePath(), "utf8"));
+        return parsed && parsed.v === 7 && parsed.files && typeof parsed.files === "object" ? parsed.files : {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveCache(files) {
+    try {
+        const target = cachePath();
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, JSON.stringify({ v: 7, files }));
+    }
+    catch {
+        /* best effort */
+    }
+}
+function cachePath() {
+    return path.join(os.homedir(), ".echomem", "context-analysis-cache.json");
+}