@echomem/mcp 1.4.8 → 1.4.9

package/dist/context-analysis/claude-native-canonical.js

@@ -0,0 +1,1193 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { resolveClaudeProjectsDir } from "../local-data-paths.js";
+import { walk } from "../report.js";
+import { isStrongPositiveFeedback, } from "./workspace-report.js";
+const OUTPUT_TOKEN_CAP = 12_000;
+const IMAGE_TOKENS = 4_000;
+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 PROBLEM_IDS = Object.keys(PROBLEM_META);
+export function buildClaudeNativeCanonicalReport(opts) {
+    const claudeRoot = opts?.sessionPaths ? null : resolveClaudeProjectsDir();
+    const discovered = (opts?.sessionPaths ?? (claudeRoot ? walk(claudeRoot, (candidate) => candidate.endsWith(".jsonl") && !candidate.includes(`${path.sep}subagents${path.sep}`) && !candidate.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort();
+    const files = typeof opts?.limitFiles === "number" ? discovered.slice(-Math.max(0, opts.limitFiles)) : discovered;
+    const sessions = [];
+    const errors = [];
+    const strictSessionErrors = opts?.strictSessionErrors ?? Boolean(opts?.sessionPaths);
+    for (let index = 0; index < files.length; index += 1) {
+        const file = files[index];
+        try {
+            sessions.push(scoreClaudeNativeSession(parseClaudeNativeSession(file)));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const session = path.basename(file, ".jsonl").slice(0, 32);
+            if (strictSessionErrors)
+                throw new Error(`Failed to score Claude session ${session}: ${message}`);
+            errors.push({ session, message });
+        }
+        opts?.onProgress?.(index + 1, files.length);
+    }
+    const report = aggregateClaudeNative(sessions);
+    return errors.length ? { ...report, diagnostics: { skippedSessions: errors.length, errors } } : report;
+}
+function parseClaudeNativeSession(file) {
+    const rows = readRows(file);
+    let session = firstString(rows, "sessionId") || path.basename(file, ".jsonl");
+    let cwd = firstString(rows, "cwd");
+    let firstTs = null;
+    let lastTs = null;
+    let turn = 0;
+    let itemId = 0;
+    let seq = 0;
+    let requestSeq = 0;
+    const items = [];
+    const requests = new Map();
+    const pendingTools = new Map();
+    for (const row of rows) {
+        if (typeof row.sessionId === "string")
+            session = row.sessionId;
+        if (!cwd && typeof row.cwd === "string")
+            cwd = row.cwd;
+        const ts = typeof row.timestamp === "string" ? Date.parse(row.timestamp) : NaN;
+        if (Number.isFinite(ts)) {
+            if (firstTs == null)
+                firstTs = ts;
+            lastTs = ts;
+        }
+        const type = stringValue(row.type);
+        if (type === "user" && !isClaudeToolResultUser(row)) {
+            turn += 1;
+            const text = extractClaudeText(recordValue(row.message).content);
+            const images = countClaudeImages(recordValue(row.message).content);
+            if (text.trim() || images > 0) {
+                items.push({
+                    id: ++itemId,
+                    seq: ++seq,
+                    requestSeq,
+                    turn,
+                    kind: images > 0 ? "image" : "user",
+                    tokens: Math.max(1, codeTokens(text) + images * IMAGE_TOKENS),
+                    text,
+                });
+            }
+            continue;
+        }
+        if (turn === 0)
+            continue;
+        if (type === "assistant") {
+            const message = recordValue(row.message);
+            const usage = recordValue(message.usage);
+            const model = stringValue(message.model) || null;
+            const requestId = stringValue(row.requestId) || stringValue(row.uuid) || `assistant-${requests.size + 1}`;
+            const officialInput = claudeOfficialInputTokens(usage);
+            let request = requests.get(requestId);
+            if (!request) {
+                request = {
+                    id: requestId,
+                    seq: ++requestSeq,
+                    turn,
+                    inputTokens: officialInput,
+                    cacheReadTokens: numberValue(usage.cache_read_input_tokens),
+                    cacheCreationTokens: numberValue(usage.cache_creation_input_tokens),
+                    outputTokens: numberValue(usage.output_tokens),
+                    episode: 1,
+                    model,
+                };
+                requests.set(requestId, request);
+            }
+            else {
+                request.inputTokens = Math.max(request.inputTokens, officialInput);
+                request.cacheReadTokens = Math.max(request.cacheReadTokens, numberValue(usage.cache_read_input_tokens));
+                request.cacheCreationTokens = Math.max(request.cacheCreationTokens, numberValue(usage.cache_creation_input_tokens));
+                request.outputTokens = Math.max(request.outputTokens, numberValue(usage.output_tokens));
+                request.model ||= model;
+            }
+            for (const block of arrayValue(message.content)) {
+                if (!isRecord(block))
+                    continue;
+                const blockType = stringValue(block.type);
+                if (blockType === "text") {
+                    const text = stringValue(block.text);
+                    if (text) {
+                        items.push({
+                            id: ++itemId,
+                            seq: ++seq,
+                            requestSeq: request.seq,
+                            turn,
+                            kind: "assistant",
+                            tokens: codeTokens(text),
+                            requestId,
+                            text,
+                        });
+                    }
+                    continue;
+                }
+                if (blockType === "thinking") {
+                    const text = stringValue(block.thinking) || safeJson(block);
+                    items.push({
+                        id: ++itemId,
+                        seq: ++seq,
+                        requestSeq: request.seq,
+                        turn,
+                        kind: "reasoning",
+                        tokens: Math.max(1, codeTokens(text)),
+                        requestId,
+                    });
+                    continue;
+                }
+                if (blockType !== "tool_use")
+                    continue;
+                const toolName = stringValue(block.name);
+                const input = recordValue(block.input);
+                const callId = stringValue(block.id);
+                if (callId)
+                    pendingTools.set(callId, { toolName, input, turn, requestSeq: request.seq, seq });
+                items.push({
+                    id: ++itemId,
+                    seq: ++seq,
+                    requestSeq: request.seq,
+                    turn,
+                    kind: "tool_call",
+                    tokens: Math.max(1, codeTokens(safeJson(input))),
+                    command: commandForTool(toolName, input),
+                    file: fileForTool(toolName, input),
+                    toolName,
+                    inputFingerprint: toolInputFingerprint(toolName, input),
+                    requestId,
+                });
+            }
+            continue;
+        }
+        if (type === "user" && isClaudeToolResultUser(row)) {
+            const message = recordValue(row.message);
+            for (const block of arrayValue(message.content)) {
+                if (!isRecord(block) || block.type !== "tool_result")
+                    continue;
+                const callId = stringValue(block.tool_use_id);
+                const meta = pendingTools.get(callId) || { toolName: "unknown", input: {}, turn, requestSeq, seq };
+                items.push(resultItem({
+                    id: ++itemId,
+                    seq: ++seq,
+                    turn: meta.turn,
+                    requestSeq: meta.requestSeq,
+                    toolName: meta.toolName,
+                    input: meta.input,
+                    result: row.toolUseResult,
+                    fallbackContent: block.content,
+                    isError: block.is_error === true,
+                }));
+            }
+        }
+    }
+    const episodes = assignNativeEpisodes(items, [...requests.values()], turn);
+    return {
+        session,
+        cwd,
+        repo: repoLabel(cwd),
+        firstTs,
+        lastTs,
+        turns: turn,
+        requests: [...requests.values()].sort((a, b) => a.seq - b.seq).filter((request) => request.inputTokens > 0),
+        items,
+        episodes,
+        overheadTokens: inferOverheadTokens(rows),
+    };
+}
+function assignNativeEpisodes(items, requests, turnCount) {
+    if (turnCount <= 0)
+        return [];
+    const commitTurns = new Set(items
+        .filter((item) => item.kind === "bash" && item.successful === true && /\bgit\s+commit\b/i.test(item.command || ""))
+        .map((item) => item.turn));
+    const positiveTurns = new Set(items
+        .filter((item) => (item.kind === "user" || (item.kind === "image" && !item.toolName)) && isStrongPositiveFeedback(item.text || ""))
+        .map((item) => item.turn));
+    const anchors = commitTurns.size ? commitTurns : positiveTurns;
+    const episodeByTurn = new Map();
+    const episodes = [];
+    let episode = 1;
+    let startTurn = 1;
+    for (let turn = 1; turn <= turnCount; turn += 1) {
+        episodeByTurn.set(turn, episode);
+        const closesEpisode = anchors.has(turn) && turn < turnCount;
+        if (closesEpisode) {
+            episodes.push({ id: episode, startTurn, endTurn: turn });
+            episode += 1;
+            startTurn = turn + 1;
+        }
+    }
+    episodes.push({ id: episode, startTurn, endTurn: turnCount });
+    for (const item of items)
+        item.episode = episodeByTurn.get(item.turn) || 1;
+    for (const request of requests)
+        request.episode = episodeByTurn.get(request.turn) || 1;
+    return episodes;
+}
+function resultItem(args) {
+    const result = recordValue(args.result);
+    const fallbackText = extractClaudeText(args.fallbackContent);
+    const resultPayload = meaningfulJson(args.result);
+    const toolName = args.toolName;
+    if (/^Bash$/i.test(toolName)) {
+        const stdout = stringValue(result.stdout);
+        const stderr = stringValue(result.stderr);
+        const output = `${stdout}\n${stderr}`.trim() || fallbackText;
+        return {
+            id: args.id,
+            seq: args.seq,
+            requestSeq: args.requestSeq,
+            turn: args.turn,
+            kind: commandKind(commandForTool(toolName, args.input)),
+            tokens: boundedTokens(output || safeJson(result)),
+            command: commandForTool(toolName, args.input),
+            toolName,
+            inputFingerprint: toolInputFingerprint(toolName, args.input),
+            successful: !args.isError && result.interrupted !== true,
+        };
+    }
+    if (/^(Read|NotebookRead)$/i.test(toolName)) {
+        const fileRecord = recordValue(result.file);
+        const content = stringValue(fileRecord.content) || stringValue(result.content) || fallbackText || safeJson(result);
+        return {
+            id: args.id,
+            seq: args.seq,
+            requestSeq: args.requestSeq,
+            turn: args.turn,
+            kind: "read",
+            tokens: boundedTokens(content),
+            file: normalizeFile(stringValue(fileRecord.filePath) || stringValue(result.filePath) || fileForTool(toolName, args.input) || "unknown"),
+            toolName,
+            inputFingerprint: toolInputFingerprint(toolName, args.input),
+        };
+    }
+    if (/^(Write|Edit|MultiEdit|NotebookEdit)$/i.test(toolName)) {
+        const patchText = [
+            stringValue(result.structuredPatch),
+            stringValue(result.oldString),
+            stringValue(result.newString),
+            stringValue(result.content),
+            fallbackText,
+        ].filter(Boolean).join("\n");
+        return {
+            id: args.id,
+            seq: args.seq,
+            requestSeq: args.requestSeq,
+            turn: args.turn,
+            kind: "write",
+            tokens: Math.max(1, boundedTokens(patchText || safeJson(args.input))),
+            file: normalizeFile(stringValue(result.filePath) || fileForTool(toolName, args.input) || "unknown"),
+            toolName,
+            inputFingerprint: toolInputFingerprint(toolName, args.input),
+        };
+    }
+    if (/^(Grep|Glob|WebSearch|WebFetch|ToolSearch)$/i.test(toolName)) {
+        return {
+            id: args.id,
+            seq: args.seq,
+            requestSeq: args.requestSeq,
+            turn: args.turn,
+            kind: "search",
+            tokens: boundedTokens(resultPayload || fallbackText || safeJson(args.input)),
+            command: commandForTool(toolName, args.input),
+            file: fileForTool(toolName, args.input),
+            toolName,
+            inputFingerprint: toolInputFingerprint(toolName, args.input),
+        };
+    }
+    if (/^(TaskCreate|TaskUpdate|TaskList|TodoWrite)$/i.test(toolName)) {
+        return {
+            id: args.id,
+            seq: args.seq,
+            requestSeq: args.requestSeq,
+            turn: args.turn,
+            kind: "task",
+            tokens: boundedTokens(resultPayload || fallbackText || safeJson(args.input)),
+            toolName,
+            inputFingerprint: toolInputFingerprint(toolName, args.input),
+        };
+    }
+    if (/^AskUserQuestion$/i.test(toolName)) {
+        return {
+            id: args.id,
+            seq: args.seq,
+            requestSeq: args.requestSeq,
+            turn: args.turn,
+            kind: "question",
+            tokens: boundedTokens(resultPayload || fallbackText || safeJson(args.input)),
+            toolName,
+            inputFingerprint: toolInputFingerprint(toolName, args.input),
+        };
+    }
+    return {
+        id: args.id,
+        seq: args.seq,
+        requestSeq: args.requestSeq,
+        turn: args.turn,
+        kind: isVisualToolName(toolName) ? "image" : "mcp",
+        tokens: boundedTokens(resultPayload || fallbackText || safeJson(args.input)),
+        command: commandForTool(toolName, args.input),
+        file: fileForTool(toolName, args.input),
+        toolName,
+        inputFingerprint: toolInputFingerprint(toolName, args.input),
+    };
+}
+function scoreClaudeNativeSession(parsed) {
+    classifyItems(parsed.items);
+    const requestRows = [];
+    for (const request of parsed.requests) {
+        const rawBuckets = { keep_oh: 0, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0 };
+        const buckets = { duplicate: 0, refind: 0, dead: 0, unattributed: 0 };
+        const problemStats = new Map();
+        const occurrences = [];
+        const priorItems = parsed.items
+            .filter((item) => item.requestSeq < request.seq)
+            .flatMap((item) => {
+            const classification = classForRequest(item, request);
+            return classification ? [{ item, classification }] : [];
+        });
+        const overhead = Math.min(request.inputTokens, parsed.overheadTokens);
+        const productBudget = Math.max(0, request.inputTokens - overhead);
+        const usefulItemTokens = priorItems
+            .filter(({ classification }) => classification.kind === "useful")
+            .reduce((sum, { item }) => sum + item.tokens, 0);
+        const wasteItemTokens = priorItems
+            .filter(({ classification }) => classification.kind === "waste")
+            .reduce((sum, { item }) => sum + item.tokens, 0);
+        const totalObserved = usefulItemTokens + wasteItemTokens;
+        const scale = totalObserved > productBudget && totalObserved > 0 ? productBudget / totalObserved : 1;
+        const keepProd = usefulItemTokens * scale;
+        const rawResidue = Math.max(0, productBudget - keepProd);
+        const rawUseful = overhead + keepProd;
+        rawBuckets.keep_oh += overhead;
+        rawBuckets.keep_prod += keepProd;
+        let attributedWaste = 0;
+        const requestProblems = new Set();
+        for (const { item, classification } of priorItems) {
+            if (classification.kind !== "waste" || !classification.problemId || !classification.bucket)
+                continue;
+            const tokens = item.tokens * scale;
+            if (tokens <= 0)
+                continue;
+            attributedWaste += tokens;
+            const internal = internalBucket(classification.bucket);
+            rawBuckets[internal] += tokens;
+            buckets[classification.bucket] += tokens;
+            const stat = problemStats.get(classification.problemId) || { tokens: 0, count: 0, pressure: 0, examples: [] };
+            stat.tokens += tokens;
+            stat.count += 1;
+            requestProblems.add(classification.problemId);
+            if (stat.examples.length < 4) {
+                stat.examples.push({
+                    session: parsed.session,
+                    repo: parsed.repo,
+                    agentSource: "claude-code",
+                    turn: request.turn,
+                    tokens: Math.round(tokens),
+                    evidence: classification.evidence,
+                    command: item.command || null,
+                    file: item.file || null,
+                    prompt: promptForClaudeTurn(parsed, request.turn),
+                    output: outputForClaudeTurn(parsed, request.turn),
+                    timestampMs: requestTimestampMs(parsed, request.turn),
+                    sessionStartedAt: parsed.firstTs,
+                    turnInputTokens: request.inputTokens,
+                    turnUsefulTokens: Math.round(rawUseful),
+                    turnWasteTokens: Math.round(rawResidue),
+                });
+            }
+            problemStats.set(classification.problemId, stat);
+            occurrences.push({
+                episode: request.episode,
+                problemId: classification.problemId,
+                bucket: classification.bucket,
+                tokens,
+                turn: item.turn,
+                evidence: classification.evidence,
+            });
+        }
+        for (const problemId of requestProblems) {
+            const stat = problemStats.get(problemId);
+            if (stat)
+                stat.pressure += request.inputTokens;
+        }
+        attributedWaste = Math.min(rawResidue, attributedWaste);
+        const excluded = Math.max(0, rawResidue - attributedWaste);
+        const allocatedResidual = allocateResidualToProblemSignals({
+            tokens: excluded,
+            request,
+            parsed,
+            requestProblems,
+            problemStats,
+            buckets,
+            rawBuckets,
+            occurrences,
+            requestUsefulTokens: rawUseful,
+            requestWasteTokens: rawResidue,
+        });
+        const unattributed = Math.max(0, excluded - allocatedResidual);
+        buckets.unattributed += unattributed;
+        rawBuckets.opt_dead += unattributed;
+        for (const [problemId, stat] of problemStats) {
+            if (stat.tokens <= 0)
+                continue;
+            const firstExample = stat.examples[0];
+            stat.examples = [{
+                    session: parsed.session,
+                    repo: parsed.repo,
+                    agentSource: "claude-code",
+                    turn: request.turn,
+                    tokens: Math.round(stat.tokens),
+                    evidence: firstExample?.evidence || PROBLEM_META[problemId].label,
+                    command: firstExample?.command || null,
+                    file: firstExample?.file || null,
+                    prompt: promptForClaudeTurn(parsed, request.turn),
+                    output: outputForClaudeTurn(parsed, request.turn),
+                    timestampMs: requestTimestampMs(parsed, request.turn),
+                    sessionStartedAt: parsed.firstTs,
+                    turnInputTokens: request.inputTokens,
+                    turnUsefulTokens: Math.round(rawUseful),
+                    turnWasteTokens: Math.round(rawResidue),
+                }];
+        }
+        requestRows.push({
+            request,
+            officialInputTokens: request.inputTokens,
+            usefulTokens: rawUseful,
+            wasteTokens: rawResidue,
+            rawUsefulTokens: rawUseful,
+            rawOutcomeResidueTokens: rawResidue,
+            excludedUnlabeledTokens: unattributed,
+            buckets,
+            rawBuckets,
+            problems: problemStats,
+            occurrences,
+        });
+    }
+    const selectedRows = selectTerminalRequestPerTurn(requestRows);
+    const selected = mergeRequestAccountingRows(selectedRows);
+    const zeroBuckets = { duplicate: 0, refind: 0, dead: 0, unattributed: 0 };
+    const zeroRawBuckets = { keep_oh: 0, keep_prod: 0, opt_dup: 0, opt_refind: 0, opt_dead: 0 };
+    const episodes = buildNativeEpisodes(parsed, selected.occurrences);
+    return {
+        session: parsed.session,
+        repo: parsed.repo,
+        turns: parsed.turns,
+        officialInputTokens: selected.officialInputTokens,
+        usefulTokens: Math.round(selected.usefulTokens),
+        wasteTokens: Math.round(selected.wasteTokens),
+        rawUsefulTokens: Math.round(selected.rawUsefulTokens),
+        rawOutcomeResidueTokens: Math.round(selected.rawOutcomeResidueTokens),
+        excludedUnlabeledTokens: Math.round(selected.excludedUnlabeledTokens),
+        buckets: mapBucketValues(selected.buckets || zeroBuckets),
+        rawBuckets: mapBucketValues(selected.rawBuckets || zeroRawBuckets),
+        problems: selected.problems,
+        episodes,
+    };
+}
+function allocateResidualToProblemSignals(args) {
+    const problemIds = [...args.requestProblems];
+    if (args.tokens <= 0 || problemIds.length === 0)
+        return 0;
+    let allocated = 0;
+    const share = args.tokens / problemIds.length;
+    for (let index = 0; index < problemIds.length; index += 1) {
+        const problemId = problemIds[index];
+        const tokens = index === problemIds.length - 1 ? args.tokens - allocated : share;
+        if (tokens <= 0)
+            continue;
+        allocated += tokens;
+        const bucket = PROBLEM_META[problemId].bucket;
+        args.buckets[bucket] += tokens;
+        args.rawBuckets[internalBucket(bucket)] += tokens;
+        const stat = args.problemStats.get(problemId) || { tokens: 0, count: 0, pressure: 0, examples: [] };
+        stat.tokens += tokens;
+        stat.count += 1;
+        if (stat.examples.length < 4) {
+            stat.examples.push({
+                session: args.parsed.session,
+                repo: args.parsed.repo,
+                agentSource: "claude-code",
+                turn: args.request.turn,
+                tokens: Math.round(tokens),
+                evidence: "residual context mass assigned from same request problem signal",
+                prompt: promptForClaudeTurn(args.parsed, args.request.turn),
+                output: outputForClaudeTurn(args.parsed, args.request.turn),
+                timestampMs: requestTimestampMs(args.parsed, args.request.turn),
+                sessionStartedAt: args.parsed.firstTs,
+                turnInputTokens: args.request.inputTokens,
+                turnUsefulTokens: Math.round(args.requestUsefulTokens),
+                turnWasteTokens: Math.round(args.requestWasteTokens),
+            });
+        }
+        args.problemStats.set(problemId, stat);
+        args.occurrences.push({
+            episode: args.request.episode,
+            problemId,
+            bucket,
+            tokens,
+            turn: args.request.turn,
+            evidence: "residual context mass assigned from same request problem signal",
+        });
+    }
+    return allocated;
+}
+function selectTerminalRequestPerTurn(rows) {
+    const byTurn = new Map();
+    for (const row of rows) {
+        const current = byTurn.get(row.request.turn);
+        if (!current || row.request.seq > current.request.seq) {
+            byTurn.set(row.request.turn, row);
+        }
+    }
+    return [...byTurn.values()].sort((left, right) => left.request.turn - right.request.turn || left.request.seq - right.request.seq);
+}
+function mergeRequestAccountingRows(rows) {
+    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 problems = new Map();
+    const merged = {
+        officialInputTokens: 0,
+        usefulTokens: 0,
+        wasteTokens: 0,
+        rawUsefulTokens: 0,
+        rawOutcomeResidueTokens: 0,
+        excludedUnlabeledTokens: 0,
+        buckets,
+        rawBuckets,
+        problems,
+        occurrences: [],
+    };
+    for (const row of rows) {
+        merged.officialInputTokens += row.officialInputTokens;
+        merged.usefulTokens += row.usefulTokens;
+        merged.wasteTokens += row.wasteTokens;
+        merged.rawUsefulTokens += row.rawUsefulTokens;
+        merged.rawOutcomeResidueTokens += row.rawOutcomeResidueTokens;
+        merged.excludedUnlabeledTokens += row.excludedUnlabeledTokens;
+        for (const key of Object.keys(buckets))
+            merged.buckets[key] += row.buckets[key] || 0;
+        for (const key of Object.keys(rawBuckets))
+            merged.rawBuckets[key] += row.rawBuckets[key] || 0;
+        for (const [problemId, stat] of row.problems) {
+            const target = merged.problems.get(problemId) || { tokens: 0, count: 0, pressure: 0, examples: [] };
+            target.tokens += stat.tokens;
+            target.count += stat.count;
+            target.pressure += stat.pressure;
+            target.examples.push(...stat.examples);
+            target.examples.sort((left, right) => (right.tokens || 0) - (left.tokens || 0));
+            target.examples.splice(1);
+            merged.problems.set(problemId, target);
+        }
+        merged.occurrences.push(...row.occurrences);
+    }
+    return merged;
+}
+function classifyItems(items) {
+    const byEpisode = new Map();
+    for (const item of items) {
+        const list = byEpisode.get(item.episode || 1) || [];
+        list.push(item);
+        byEpisode.set(item.episode || 1, list);
+    }
+    for (const episodeItems of byEpisode.values())
+        classifyEpisodeItems(episodeItems.sort((a, b) => a.seq - b.seq));
+}
+function classifyEpisodeItems(items) {
+    const lastWriteByFile = new Map();
+    const lastReadByGeneration = new Map();
+    const lastSearchByGeneration = new Map();
+    const lastDiagnosticByGeneration = new Map();
+    const lastMcpByGeneration = new Map();
+    const lastToolImageByKey = new Map();
+    const itemKeys = new Map();
+    let mutationGeneration = 0;
+    for (const item of items) {
+        if (item.kind === "write" && item.file) {
+            mutationGeneration += 1;
+            lastWriteByFile.set(item.file, item.seq);
+        }
+        else if (item.kind === "bash" && isStatefulBashCommand(item.command || "")) {
+            mutationGeneration += 1;
+        }
+        if (item.kind === "read" && item.file) {
+            const key = `${item.inputFingerprint || item.file}:${mutationGeneration}`;
+            itemKeys.set(item.id, key);
+            lastReadByGeneration.set(key, item.seq);
+        }
+        else if (item.kind === "search") {
+            const key = `${item.inputFingerprint || normalizeCommand(item.command || item.toolName || "search")}:${mutationGeneration}`;
+            itemKeys.set(item.id, key);
+            lastSearchByGeneration.set(key, item.seq);
+        }
+        else if (item.kind === "bash" && isRepeatableDiagnosticCommand(item.command || "")) {
+            const key = `${normalizeCommand(item.command || "")}:${mutationGeneration}`;
+            itemKeys.set(item.id, key);
+            lastDiagnosticByGeneration.set(key, item.seq);
+        }
+        else if (item.kind === "mcp") {
+            const key = `${item.inputFingerprint || normalizeCommand(`${item.toolName || "mcp"}:${item.command || ""}`)}:${mutationGeneration}`;
+            itemKeys.set(item.id, key);
+            lastMcpByGeneration.set(key, item.seq);
+        }
+        else if (item.kind === "image" && item.toolName) {
+            const key = item.inputFingerprint || normalizeCommand(`${item.toolName}:${item.command || "image"}`);
+            itemKeys.set(item.id, key);
+            lastToolImageByKey.set(key, item.seq);
+        }
+    }
+    const lastAssistantSeq = Math.max(0, ...items.filter((item) => item.kind === "assistant").map((item) => item.seq));
+    const lastTaskSeq = Math.max(0, ...items.filter((item) => item.kind === "task").map((item) => item.seq));
+    for (const item of items) {
+        if (item.kind === "user" || (item.kind === "image" && !item.toolName)) {
+            item.class = { kind: "useful", evidence: "same-episode user prompt or attached image" };
+        }
+        else if (item.kind === "read" && item.file) {
+            item.class = item.seq === lastReadByGeneration.get(itemKeys.get(item.id) || "")
+                ? { kind: "useful", evidence: "latest file evidence for this episode state" }
+                : { kind: "waste", bucket: "duplicate", problemId: "P03", evidence: "same file re-read without an intervening state change" };
+        }
+        else if (item.kind === "write" && item.file) {
+            item.class = item.seq === lastWriteByFile.get(item.file)
+                ? { kind: "useful", evidence: "latest surviving edit for file in episode" }
+                : { kind: "waste", bucket: "dead", problemId: "P12", evidence: "edit output superseded within the same episode" };
+        }
+        else if (item.kind === "search") {
+            item.class = item.seq === lastSearchByGeneration.get(itemKeys.get(item.id) || "")
+                ? { kind: "useful", evidence: "latest discovery result for query and state" }
+                : { kind: "waste", bucket: "refind", problemId: "P10", evidence: "same discovery repeated without an intervening state change" };
+        }
+        else if (item.kind === "bash") {
+            const key = itemKeys.get(item.id);
+            if (!key || item.seq === lastDiagnosticByGeneration.get(key)) {
+                item.class = { kind: "useful", evidence: "unique, state-changing, or latest diagnostic command result" };
+            }
+            else {
+                const isGit = /\bgit\b/i.test(item.command || "");
+                item.class = { kind: "waste", bucket: "refind", problemId: isGit ? "P08" : "P09", evidence: isGit ? "same git inspection repeated without a state change" : "same verification repeated without a state change" };
+            }
+        }
+        else if (item.kind === "image") {
+            item.class = item.seq === lastToolImageByKey.get(itemKeys.get(item.id) || "")
+                ? { kind: "useful", evidence: "latest visual evidence for tool target" }
+                : { kind: "waste", bucket: "dead", problemId: "P01", evidence: "visual evidence superseded within the episode" };
+        }
+        else if (item.kind === "reasoning") {
+            item.class = { kind: "waste", bucket: "dead", evidence: "reasoning retention requires request-model evaluation" };
+        }
+        else if (item.kind === "assistant") {
+            item.class = item.seq === lastAssistantSeq
+                ? { kind: "useful", evidence: "assistant output at this episode outcome" }
+                : { kind: "waste", bucket: "dead", evidence: "intermediate assistant output did not survive as the episode outcome" };
+        }
+        else if (item.kind === "task") {
+            item.class = item.seq === lastTaskSeq
+                ? { kind: "useful", evidence: "latest task state in episode" }
+                : { kind: "waste", bucket: "dead", problemId: "P12", evidence: "older task state superseded within the episode" };
+        }
+        else if (item.kind === "question") {
+            item.class = { kind: "useful", evidence: "user clarification exchange" };
+        }
+        else if (item.kind === "mcp") {
+            item.class = item.seq === lastMcpByGeneration.get(itemKeys.get(item.id) || "")
+                ? { kind: "useful", evidence: "latest MCP result for tool, query, and state" }
+                : { kind: "waste", bucket: "dead", problemId: "P12", evidence: "same MCP result superseded without a state change" };
+        }
+        else if (item.kind === "tool_call" || item.kind === "metadata") {
+            item.class = { kind: "waste", bucket: "dead", problemId: "P12", evidence: "tool-call metadata retained alongside its extracted result" };
+        }
+        else {
+            item.class = { kind: "waste", bucket: "dead", evidence: "item did not connect to the episode outcome" };
+        }
+    }
+}
+function classForRequest(item, request) {
+    if (item.kind === "reasoning") {
+        if (item.turn === request.turn) {
+            return { kind: "useful", evidence: "thinking required for the active tool-use cycle" };
+        }
+        const retention = priorThinkingRetention(request.model);
+        if (retention === "stripped")
+            return null;
+        if (retention === "preserved") {
+            return { kind: "waste", bucket: "dead", problemId: "P13", evidence: `prior thinking retained by ${request.model || "model"}` };
+        }
+        return { kind: "waste", bucket: "dead", problemId: "P13", evidence: "prior-thinking retention unknown for request model" };
+    }
+    const classification = item.class || { kind: "waste", evidence: "unclassified context item" };
+    if ((item.episode || 1) === request.episode || classification.kind === "waste")
+        return attachClaudeProblemFallback(item, classification);
+    return carriedContextFallback(item);
+}
+function attachClaudeProblemFallback(item, classification) {
+    if (classification.kind !== "waste" || classification.problemId)
+        return classification;
+    const fallback = claudeProblemFallback(item);
+    return fallback ? { ...classification, ...fallback } : classification;
+}
+function carriedContextFallback(item) {
+    const fallback = claudeProblemFallback(item);
+    return {
+        kind: "waste",
+        bucket: fallback?.bucket || "dead",
+        problemId: fallback?.problemId || null,
+        evidence: fallback?.evidence || "useful context from a completed earlier episode",
+    };
+}
+function claudeProblemFallback(item) {
+    if (item.kind === "read" || item.kind === "write") {
+        return { bucket: "duplicate", problemId: "P03", evidence: "old file context carried after its episode ended" };
+    }
+    if (item.kind === "image") {
+        return { bucket: "dead", problemId: "P01", evidence: "old visual context carried after its episode ended" };
+    }
+    if (item.kind === "assistant" || item.kind === "user" || item.kind === "question" || item.kind === "reasoning") {
+        return { bucket: "dead", problemId: "P13", evidence: "old conversation or reasoning context carried after its episode ended" };
+    }
+    if (item.kind === "search") {
+        return { bucket: "dead", problemId: "P12", evidence: "old search/tool output carried after it stopped being active" };
+    }
+    if (item.kind === "bash")
+        return bashProblemFallback(item.command || "", item.successful);
+    if (item.kind === "tool_call" || item.kind === "task" || item.kind === "mcp" || item.kind === "metadata") {
+        return { bucket: "dead", problemId: "P12", evidence: "old tool-call log carried after it stopped being active" };
+    }
+    return null;
+}
+function bashProblemFallback(command, successful) {
+    if (successful === false) {
+        return { bucket: "dead", problemId: "P07", evidence: "failed shell command output carried into later context" };
+    }
+    if (isGitDiagnosticCommand(command)) {
+        return { bucket: "refind", problemId: "P08", evidence: "old git inspection output carried into later context" };
+    }
+    if (isVerificationCommand(command)) {
+        return { bucket: "refind", problemId: "P09", evidence: "old verification output carried into later context" };
+    }
+    return { bucket: "dead", problemId: "P12", evidence: "old shell/tool output carried after it stopped being active" };
+}
+function priorThinkingRetention(model) {
+    const value = String(model || "").toLowerCase();
+    if (!value || value.includes("synthetic"))
+        return "unknown";
+    if (value.includes("haiku"))
+        return "stripped";
+    if (value.includes("fable") || value.includes("mythos"))
+        return "preserved";
+    const family = value.includes("opus") ? "opus" : value.includes("sonnet") ? "sonnet" : null;
+    if (!family)
+        return "unknown";
+    const version = modelVersion(value, family);
+    if (!version)
+        return "unknown";
+    const [major, minor] = version;
+    if (major > 4)
+        return "preserved";
+    if (major < 4)
+        return "stripped";
+    return family === "opus"
+        ? (minor >= 5 ? "preserved" : "stripped")
+        : (minor >= 6 ? "preserved" : "stripped");
+}
+function modelVersion(model, family) {
+    const afterFamily = model.match(new RegExp(`${family}[-_.](\\d+)(?:[-_.](\\d{1,2})(?:[-_.]|$))?`));
+    const beforeFamily = model.match(new RegExp(`(\\d+)[-_.](\\d{1,2})[-_.]${family}`));
+    const match = afterFamily || beforeFamily;
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2] || 0)];
+}
+function isStatefulBashCommand(command) {
+    const value = normalizeCommand(command);
+    return /(?:^|\s)(?:git\s+(?:add|commit|checkout|switch|merge|rebase|pull|push|reset|restore|cherry-pick|stash)|npm\s+(?:install|uninstall)|pnpm\s+(?:add|install|remove)|yarn\s+(?:add|install|remove)|rm|mv|cp|mkdir|touch|chmod|chown)(?:\s|$)/.test(value)
+        || /\b(?:sed|perl)\s+-i\b/.test(value)
+        || /\b(?:migrate|deploy|format|write|update|generate)\b/.test(value);
+}
+function isRepeatableDiagnosticCommand(command) {
+    const value = normalizeCommand(command);
+    return isGitDiagnosticCommand(value)
+        || isVerificationCommand(value)
+        || /^(?:ls|pwd|ps|lsof)(?:\s|$)/.test(value);
+}
+function isGitDiagnosticCommand(command) {
+    return /\bgit\s+(?:status|diff|log|show|branch|rev-parse)\b/.test(normalizeCommand(command));
+}
+function isVerificationCommand(command) {
+    return /\b(?:test|build|tsc|lint|typecheck|check)\b/.test(normalizeCommand(command));
+}
+function aggregateClaudeNative(sessions) {
+    const summary = sessions.reduce((sum, session) => {
+        sum.input += session.officialInputTokens;
+        sum.useful += session.usefulTokens;
+        sum.waste += session.wasteTokens;
+        sum.rawUseful += session.rawUsefulTokens;
+        sum.rawResidue += session.rawOutcomeResidueTokens;
+        sum.excluded += session.excludedUnlabeledTokens;
+        sum.turns += session.turns;
+        return sum;
+    }, { input: 0, useful: 0, waste: 0, rawUseful: 0, rawResidue: 0, excluded: 0, turns: 0 });
+    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 repos = new Map();
+    const problemRows = new Map();
+    for (const id of PROBLEM_IDS)
+        problemRows.set(id, { tokens: 0, count: 0, pressure: 0, sessions: 0, examples: [] });
+    for (const session of sessions) {
+        for (const key of Object.keys(buckets))
+            buckets[key] += session.buckets[key] || 0;
+        for (const key of Object.keys(rawBuckets))
+            rawBuckets[key] += session.rawBuckets[key] || 0;
+        const repo = repos.get(session.repo) || { sessions: 0, officialInputTokens: 0, wasteTokens: 0 };
+        repo.sessions += 1;
+        repo.officialInputTokens += session.officialInputTokens;
+        repo.wasteTokens += session.wasteTokens;
+        repos.set(session.repo, repo);
+        for (const [id, stats] of session.problems) {
+            const row = problemRows.get(id);
+            row.tokens += stats.tokens;
+            row.count += stats.count;
+            row.pressure += stats.pressure;
+            if (stats.tokens > 0)
+                row.sessions += 1;
+            row.examples.push(...stats.examples);
+            row.examples.sort((left, right) => (right.tokens || 0) - (left.tokens || 0));
+            row.examples.splice(1);
+        }
+    }
+    const problems = PROBLEM_IDS.map((id) => {
+        const meta = PROBLEM_META[id];
+        const row = problemRows.get(id);
+        return {
+            id,
+            label: meta.label,
+            bucket: meta.bucket,
+            category: meta.category,
+            confidence: meta.confidence,
+            count: row.count,
+            sessions: row.sessions,
+            allocatedWasteTokens: Math.round(row.tokens),
+            qualifiedTokenPressure: Math.round(row.pressure),
+            severity: summary.waste ? (row.tokens / summary.waste) * 100 : 0,
+            examples: row.examples,
+        };
+    }).sort((a, b) => b.allocatedWasteTokens - a.allocatedWasteTokens || a.id.localeCompare(b.id));
+    return {
+        version: 1,
+        generatedFrom: ["~/.claude/projects", "Claude Code native useful/waste ledger"],
+        methodology: {
+            name: "Claude Code native retained-context analysis",
+            status: "deterministic-plus-heuristic",
+            scoringMode: "episode-outcome",
+            note: "Claude Code sessions are scored natively from JSONL requestIds and toolUseResult objects. For each human turn, the terminal unique provider request by request sequence is selected as the retained context-window proxy; episode-aware evidence determines raw useful/residue for each selected turn request. Raw residue is counted as waste, while P01-P13 explain the attributable portion and remaining unlabeled residue stays included in headline waste.",
+        },
+        summary: {
+            sessionsAnalyzed: sessions.length,
+            reposAnalyzed: repos.size,
+            turnsAnalyzed: summary.turns,
+            officialInputTokens: Math.round(summary.input),
+            usefulTokens: Math.round(summary.useful),
+            wasteTokens: Math.round(summary.waste),
+            usefulPct: percentage(summary.useful, summary.input),
+            wastePct: percentage(summary.waste, summary.input),
+            attributedWasteTokens: Math.round(Math.max(0, summary.waste - summary.excluded)),
+            unattributedWasteTokens: Math.round(summary.excluded),
+            rawUsefulTokens: Math.round(summary.rawUseful),
+            rawOutcomeResidueTokens: Math.round(summary.rawResidue),
+            excludedUnlabeledTokens: 0,
+        },
+        buckets: mapBucketValues(buckets),
+        rawBuckets: mapBucketValues(rawBuckets),
+        problems,
+        sessions: sessions.map((session) => {
+            const top = [...session.problems.entries()].sort((a, b) => b[1].tokens - a[1].tokens)[0];
+            return {
+                session: session.session,
+                repo: session.repo,
+                turns: session.turns,
+                officialInputTokens: Math.round(session.officialInputTokens),
+                wasteTokens: Math.round(session.wasteTokens),
+                topProblemId: top && top[1].tokens > 0 ? top[0] : null,
+            };
+        }).sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
+        repos: [...repos.entries()].map(([repo, value]) => ({ repo, ...mapBucketValues(value) }))
+            .sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
+        episodes: sessions.flatMap((session) => session.episodes).sort((a, b) => b.wasteTokens - a.wasteTokens).slice(0, 8),
+    };
+}
+function buildNativeEpisodes(parsed, occurrences) {
+    return parsed.episodes.flatMap((episode) => {
+        const rows = occurrences.filter((item) => item.episode === episode.id);
+        const byProblem = new Map();
+        let wasteTokens = 0;
+        for (const row of rows) {
+            wasteTokens += row.tokens;
+            byProblem.set(row.problemId, (byProblem.get(row.problemId) || 0) + row.tokens);
+        }
+        const top = [...byProblem.entries()].sort((a, b) => b[1] - a[1])[0];
+        if (!top || wasteTokens <= 0)
+            return [];
+        return [{
+                id: `${parsed.session.slice(0, 8)}-E${episode.id}`,
+                session: parsed.session,
+                repo: parsed.repo,
+                turnStart: episode.startTurn,
+                turnEnd: episode.endTurn,
+                wasteTokens: Math.round(wasteTokens),
+                dominantProblemId: top[0],
+            }];
+    });
+}
+function inferOverheadTokens(rows) {
+    let firstUserTokens = 0;
+    let awaitingUsage = false;
+    for (const row of rows) {
+        const type = stringValue(row.type);
+        if (type === "user" && !isClaudeToolResultUser(row)) {
+            if (!awaitingUsage) {
+                const content = recordValue(row.message).content;
+                firstUserTokens = codeTokens(extractClaudeText(content)) + countClaudeImages(content) * IMAGE_TOKENS;
+                awaitingUsage = true;
+            }
+            continue;
+        }
+        if (type !== "assistant" || !awaitingUsage)
+            continue;
+        const total = claudeOfficialInputTokens(recordValue(recordValue(row.message).usage));
+        if (total <= 0)
+            continue;
+        return Math.max(0, total - firstUserTokens - Math.round(total * 0.03));
+    }
+    return 0;
+}
+function commandForTool(name, input) {
+    return stringValue(input.command)
+        || stringValue(input.pattern)
+        || stringValue(input.query)
+        || stringValue(input.url)
+        || name;
+}
+function fileForTool(name, input) {
+    void name;
+    const value = stringValue(input.file_path) || stringValue(input.notebook_path) || stringValue(input.path);
+    return value ? normalizeFile(value) : null;
+}
+function commandKind(command) {
+    if (/\brg\b|\bgrep\b|^find\s/.test(command))
+        return "search";
+    return "bash";
+}
+function internalBucket(bucket) {
+    if (bucket === "duplicate")
+        return "opt_dup";
+    if (bucket === "refind")
+        return "opt_refind";
+    return "opt_dead";
+}
+function readRows(file) {
+    const rows = [];
+    const fd = fs.openSync(file, "r");
+    const decoder = new StringDecoder("utf8");
+    const buffer = Buffer.allocUnsafe(1 << 20);
+    let carry = "";
+    const appendLine = (line) => {
+        if (!line.trim())
+            return;
+        try {
+            const parsed = JSON.parse(line);
+            if (isRecord(parsed))
+                rows.push(parsed);
+        }
+        catch {
+            // Claude Code may leave an active final JSONL line partial.
+        }
+    };
+    const consume = (chunk) => {
+        let start = 0;
+        for (;;) {
+            const newline = chunk.indexOf("\n", start);
+            if (newline < 0) {
+                carry += chunk.slice(start);
+                return;
+            }
+            appendLine(carry + chunk.slice(start, newline));
+            carry = "";
+            start = newline + 1;
+        }
+    };
+    try {
+        let bytesRead;
+        while ((bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null)) > 0) {
+            consume(decoder.write(buffer.subarray(0, bytesRead)));
+        }
+        consume(decoder.end());
+        appendLine(carry);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return rows;
+}
+function isClaudeToolResultUser(record) {
+    const content = recordValue(record.message).content;
+    return arrayValue(content).some((block) => isRecord(block) && block.type === "tool_result");
+}
+function extractClaudeText(value) {
+    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 (Array.isArray(value.content))
+            return value.content.map(extractClaudeText).filter(Boolean).join("\n");
+    }
+    return "";
+}
+function countClaudeImages(value) {
+    if (!value)
+        return 0;
+    if (Array.isArray(value))
+        return value.reduce((sum, item) => sum + countClaudeImages(item), 0);
+    if (!isRecord(value))
+        return 0;
+    const own = value.type === "image" || value.type === "input_image" ? 1 : 0;
+    return own + Object.values(value).reduce((sum, item) => sum + countClaudeImages(item), 0);
+}
+function claudeOfficialInputTokens(usage) {
+    return numberValue(usage.input_tokens)
+        + numberValue(usage.cache_read_input_tokens)
+        + numberValue(usage.cache_creation_input_tokens);
+}
+function promptForClaudeTurn(parsed, turn) {
+    const text = parsed.items
+        .filter((item) => item.turn === turn && item.kind === "user" && item.text)
+        .map((item) => item.text || "")
+        .join("\n")
+        .trim();
+    return compactPreview(text);
+}
+function outputForClaudeTurn(parsed, turn) {
+    const text = parsed.items
+        .filter((item) => item.turn === turn && item.kind === "assistant" && item.text)
+        .map((item) => item.text || "")
+        .join("\n")
+        .trim();
+    return compactBlockPreview(text);
+}
+function requestTimestampMs(parsed, _turn) {
+    return parsed.firstTs;
+}
+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 boundedTokens(text) {
+    return Math.max(1, Math.min(OUTPUT_TOKEN_CAP, codeTokens(text)));
+}
+function codeTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function normalizeFile(file) {
+    return file.replace(/\\/g, "/");
+}
+function normalizeCommand(command) {
+    return command.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function toolInputFingerprint(toolName, input) {
+    const canonical = JSON.stringify({
+        tool: toolName.trim().toLowerCase(),
+        input: stableJsonValue(input),
+    });
+    return createHash("sha256").update(canonical).digest("hex");
+}
+function stableJsonValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableJsonValue);
+    if (!isRecord(value))
+        return typeof value === "string" ? value.replace(/\r\n/g, "\n") : value;
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, stableJsonValue(value[key])]));
+}
+function repoLabel(cwd) {
+    if (!cwd)
+        return "home";
+    const label = path.basename(cwd);
+    return label && label !== "." && label !== "/" ? label : "home";
+}
+function firstString(rows, key) {
+    for (const row of rows)
+        if (typeof row[key] === "string" && row[key])
+            return row[key];
+    return null;
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value) || "";
+    }
+    catch {
+        return "";
+    }
+}
+function meaningfulJson(value) {
+    if (value == null)
+        return "";
+    if (isRecord(value) && Object.keys(value).length === 0)
+        return "";
+    if (Array.isArray(value) && value.length === 0)
+        return "";
+    return safeJson(value);
+}
+function percentage(value, total) {
+    return total > 0 ? (value / total) * 100 : 0;
+}
+function mapBucketValues(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, tokens]) => [key, Math.round(tokens)]));
+}
+function isVisualToolName(name) {
+    return /screenshot|image|preview|browser|chrome/i.test(name);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function recordValue(value) {
+    return isRecord(value) ? value : {};
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}