@echomem/mcp 1.4.44 → 1.4.45

package/dist/forensics.js

@@ -0,0 +1,1531 @@
+/**
+ * Local "Context Doctor" forensic report — the pre-auth onboarding payload.
+ *
+ * Scans the user's LOCAL coding-agent transcripts (Claude Code under ~/.claude/projects AND Codex
+ * rollouts under ~/.codex/sessions) and turns them into a single MERGED workspace physical-exam:
+ * accomplishment (days/repos/tokens/cost/attention), the cost split (cold/cache/output per model),
+ * and the waste (token-reread forensics + a Context Cleanliness score). Everything is local; nothing
+ * leaves the machine and no model is called.
+ *
+ * Output shape mirrors the yeahecho `onboarding-two` ContextDoctorTwo report so the same UI renders it.
+ * Two source adapters feed ONE source-agnostic engine, so the reread/cleanliness logic is written once.
+ *
+ * Honesty (the team sanity-checks this): cost is an API-EQUIVALENT estimate at list prices, NOT a
+ * subscription bill; `time.*`/avoidableWait are ESTIMATES labeled as such; re-read % is a TOKEN share.
+ * Time-of-day buckets use the USER's LOCAL timezone (not a hardcoded one).
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { calculateContextMetrics } from "./context-metrics/calculate.js";
+import { resolveModelContextLimit } from "./context-metrics/model-limits.js";
+import { buildWorkspaceContextReport } from "./context-analysis/workspace-report.js";
+import { buildCanonicalGoldenReport } from "./context-analysis/canonical-golden.js";
+import { eachLine, walk } from "./report.js";
+import { discoverCodexSessionFiles } from "./codex-session-files.js";
+import { resolveClaudeProjectsDir } from "./local-data-paths.js";
+/** Fast, safe per-repo commit count since a date. Metadata only (no diffs) so it stays cheap;
+ * `rev-list --count` is git-indexed. Any failure (not a repo, git missing, timeout) → 0. */
+function gitCommitCount(cwd, sinceIso) {
+    if (!cwd)
+        return 0;
+    try {
+        const args = ["-C", cwd, "rev-list", "--count"];
+        if (sinceIso)
+            args.push(`--since=${sinceIso}`);
+        args.push("HEAD");
+        const out = execFileSync("git", args, { timeout: 3000, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+        const n = parseInt(out, 10);
+        return Number.isFinite(n) ? n : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+// ---------------------------------------------------------------------------
+// Constants (named on purpose — no magic numbers downstream)
+// ---------------------------------------------------------------------------
+const WORK_BLOCK_GAP_MS = 30 * 60 * 1000; // >30min gap between real user prompts => new work block
+const FOCUS_DAY_HOURS = 5; // one "focused work day" == 5h of attention, for day-equivalent math
+const CONTEXT_REACQUISITION_FRACTION = 0.5; // ESTIMATE: share of stale-reread time felt as avoidable wait
+const NIGHT_HOURS = new Set([22, 23, 0, 1, 2, 3]); // late-night grind window (local tz)
+const CHARS_PER_TOKEN = 4; // rough token estimate for read (tool-result) output size
+// Per-million-token USD. Standard API-equivalent list prices, reviewed 2026-07-12.
+// These are deliberately model-specific: using an Opus fallback for every repo was the source of
+// the old impossible city math where two repo labels alone exceeded TOTAL SPENT.
+const CLAUDE_PRICES = {
+    "claude-fable-5": { input: 10, cacheWrite: 12.5, cacheRead: 1, output: 50 },
+    "claude-opus-4-8": { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-7": { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-6": { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-5": { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 25 },
+    "claude-sonnet-4-6": { input: 3, cacheWrite: 3.75, cacheRead: 0.3, output: 15 },
+    "claude-sonnet-4-5": { input: 3, cacheWrite: 3.75, cacheRead: 0.3, output: 15 },
+    "claude-haiku-4-5": { input: 1, cacheWrite: 1.25, cacheRead: 0.1, output: 5 },
+};
+const CLAUDE_SONNET_5_INTRO = { input: 2, cacheWrite: 2.5, cacheRead: 0.2, output: 10 };
+const CLAUDE_SONNET_5_STANDARD = { input: 3, cacheWrite: 3.75, cacheRead: 0.3, output: 15 };
+const CLAUDE_SONNET_5_STANDARD_START_MS = Date.parse("2026-09-01T00:00:00.000Z");
+const CLAUDE_DEFAULT = CLAUDE_PRICES["claude-sonnet-4-6"];
+// OpenAI/Codex list prices. GPT-5.6 adds explicit cache writes; older Codex logs expose only
+// uncached and cached input, so their cacheWrite rate remains zero.
+const OPENAI_PRICES = {
+    "gpt-5.6-terra": { input: 2.5, cacheWrite: 3.125, cacheRead: 0.25, output: 15 },
+    "gpt-5.6-luna": { input: 1, cacheWrite: 1.25, cacheRead: 0.1, output: 6 },
+    "gpt-5.6-sol": { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 30 },
+    "gpt-5.6": { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 30 },
+    "gpt-5.4-mini": { input: 0.75, cacheWrite: 0, cacheRead: 0.075, output: 4.5 },
+    "gpt-5.4-nano": { input: 0.2, cacheWrite: 0, cacheRead: 0.02, output: 1.25 },
+    "gpt-5.5": { input: 5, cacheWrite: 0, cacheRead: 0.5, output: 30 },
+    "gpt-5.4": { input: 2.5, cacheWrite: 0, cacheRead: 0.25, output: 15 },
+    "gpt-5": { input: 1.25, cacheWrite: 0, cacheRead: 0.125, output: 10 },
+    "gpt-5-codex": { input: 1.25, cacheWrite: 0, cacheRead: 0.125, output: 10 },
+};
+const OPENAI_DEFAULT = OPENAI_PRICES["gpt-5"];
+function longestPrefixPrice(table, model) {
+    const key = Object.keys(table)
+        .filter((candidate) => model.startsWith(candidate))
+        .sort((a, b) => b.length - a.length)[0];
+    return key ? table[key] : null;
+}
+function priceFor(model, ms) {
+    if (model.startsWith("claude-sonnet-5")) {
+        const at = typeof ms === "number" && Number.isFinite(ms) ? ms : Date.now();
+        return at < CLAUDE_SONNET_5_STANDARD_START_MS ? CLAUDE_SONNET_5_INTRO : CLAUDE_SONNET_5_STANDARD;
+    }
+    const table = model.startsWith("gpt") || model.startsWith("o1") || model.startsWith("o3") ? OPENAI_PRICES : CLAUDE_PRICES;
+    const def = table === OPENAI_PRICES ? OPENAI_DEFAULT : CLAUDE_DEFAULT;
+    return table[model] || longestPrefixPrice(table, model) || def;
+}
+function hasOpenAiLongContextPremium(model, inputTokens) {
+    if (inputTokens <= 272_000 || model.startsWith("gpt-5.4-mini") || model.startsWith("gpt-5.4-nano"))
+        return false;
+    return model.startsWith("gpt-5.4") || model.startsWith("gpt-5.5") || model.startsWith("gpt-5.6");
+}
+export function estimateApiEquivalentCost(model, t, ms) {
+    const price = priceFor(model, ms);
+    const inputTokens = (t.cold || 0) + (t.cacheWrite || 0) + (t.cacheRead || 0);
+    const longContextPremiumApplied = hasOpenAiLongContextPremium(model, inputTokens);
+    const inputMultiplier = longContextPremiumApplied ? 2 : 1;
+    const outputMultiplier = longContextPremiumApplied ? 1.5 : 1;
+    const coldInputCost = ((t.cold || 0) * price.input * inputMultiplier) / 1_000_000;
+    const cacheWriteCost = ((t.cacheWrite || 0) * price.cacheWrite * inputMultiplier) / 1_000_000;
+    const cacheReadCost = ((t.cacheRead || 0) * price.cacheRead * inputMultiplier) / 1_000_000;
+    const outputCost = ((t.output || 0) * price.output * outputMultiplier) / 1_000_000;
+    return {
+        coldInputCost,
+        cacheWriteCost,
+        cacheReadCost,
+        outputCost,
+        total: coldInputCost + cacheWriteCost + cacheReadCost + outputCost,
+        longContextPremiumApplied,
+    };
+}
+function emptyCostAccumulator() {
+    return { coldInputCost: 0, cacheWriteCost: 0, cacheReadCost: 0, outputCost: 0, total: 0, longContextRequestCount: 0 };
+}
+function addEstimatedCost(target, value) {
+    target.coldInputCost += value.coldInputCost;
+    target.cacheWriteCost += value.cacheWriteCost;
+    target.cacheReadCost += value.cacheReadCost;
+    target.outputCost += value.outputCost;
+    target.total += value.total;
+    if (value.longContextPremiumApplied)
+        target.longContextRequestCount += 1;
+}
+function addAccumulatedCost(target, value) {
+    target.coldInputCost += value.coldInputCost;
+    target.cacheWriteCost += value.cacheWriteCost;
+    target.cacheReadCost += value.cacheReadCost;
+    target.outputCost += value.outputCost;
+    target.total += value.total;
+    target.longContextRequestCount += value.longContextRequestCount;
+}
+// Files that are "project rules / design principles / repo map" — re-reading these unchanged is the
+// most quotable kind of waste.
+const PRINCIPLE_FILE_RE = /(^claude\.md$|^agents\.md$|^tokens\.css$|^readme|cursorrules|^foundations|principle)/i;
+const IMAGE_FILE_RE = /\.(png|jpe?g|gif|webp|svg|ico|avif|bmp|mp4|mov)$/i;
+// Shell read commands whose target file we try to extract for Codex reread forensics.
+const SHELL_READ_BINS = new Set(["cat", "head", "tail", "less", "more", "bat", "nl", "sed", "awk", "od", "strings"]);
+// ---------------------------------------------------------------------------
+// Local-time helpers (USER's tz — never hardcode a zone)
+// ---------------------------------------------------------------------------
+const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function localDay(ms) {
+    const d = new Date(ms);
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${d.getFullYear()}-${m}-${day}`;
+}
+const localHour = (ms) => new Date(ms).getHours();
+const localWeekday = (ms) => WEEKDAYS[new Date(ms).getDay()];
+function round(value, digits = 1) {
+    const f = 10 ** digits;
+    return Math.round((Number(value) || 0) * f) / f;
+}
+function tokensFromChars(chars = 0) {
+    return Math.round((chars || 0) / CHARS_PER_TOKEN);
+}
+export 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 fileIdentity(target, cwd) {
+    const value = String(target).trim();
+    if (!value)
+        return "unknown";
+    if (value === "~")
+        return os.homedir();
+    if (value.startsWith(`~${path.sep}`) || value.startsWith("~/")) {
+        return path.normalize(path.join(os.homedir(), value.slice(2)));
+    }
+    if (path.isAbsolute(value))
+        return path.normalize(value);
+    if (cwd && path.isAbsolute(cwd))
+        return path.resolve(cwd, value);
+    // An unknown/relative cwd cannot safely be resolved against the MCP process cwd. Namespace it so
+    // identical relative paths in unrelated workspaces never become the same forensic file.
+    return `${repoLabel(cwd)}::${path.normalize(value)}`;
+}
+function fileLabel(filePath) {
+    return path.basename(String(filePath)) || "unknown";
+}
+function contentLength(content) {
+    if (content == null)
+        return 0;
+    if (typeof content === "string")
+        return content.length;
+    try {
+        return JSON.stringify(content).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function isRealUserText(text) {
+    if (typeof text !== "string")
+        return false;
+    const t = text.trim();
+    if (!t)
+        return false;
+    if (t.startsWith("<"))
+        return false; // <system-reminder>, <command-…, <local-command…
+    if (t.startsWith("Caveat:"))
+        return false;
+    if (t.startsWith("[Request interrupted"))
+        return false;
+    if (t.startsWith("This session is being continued"))
+        return false;
+    if (t.includes("<command-name>") || t.includes("<local-command"))
+        return false;
+    return true;
+}
+/** Best-effort: pull the file a Codex read-style shell command targets (cat/sed/head FILE). */
+function extractReadPath(cmd) {
+    const tokens = String(cmd).trim().split(/\s+/);
+    let bin = (tokens[0] || "").split("/").pop() || "";
+    if (bin === "sudo")
+        bin = (tokens[1] || "").split("/").pop() || "";
+    if (!SHELL_READ_BINS.has(bin))
+        return null;
+    // last token that looks like a path (has a / or a file extension, not a flag/number)
+    for (let i = tokens.length - 1; i >= 1; i--) {
+        const t = tokens[i].replace(/['"]/g, "");
+        if (!t || t.startsWith("-"))
+            continue;
+        if (t.includes("/") || /\.[A-Za-z0-9]{1,6}$/.test(t))
+            return t;
+    }
+    return null;
+}
+class Forensics {
+    models = new Map();
+    repos = new Map();
+    files = new Map();
+    fileVersions = new Map();
+    lastReadVersion = new Map();
+    fileReadSessions = new Map();
+    pendingReads = new Map();
+    latestContextObservation = null;
+    contextObservationSeq = 0;
+    hourHistogram = new Array(24).fill(0);
+    weekdayCounts = new Map();
+    lateNightSessions = new Map();
+    allSessionIds = new Set();
+    realUserTurns = 0;
+    minTs = null;
+    maxTs = null;
+    nightExample = null;
+    modelBucket(model) {
+        const key = model || "unknown";
+        let m = this.models.get(key);
+        if (!m) {
+            m = { messages: 0, cold: 0, cacheWrite: 0, cacheRead: 0, output: 0, cost: emptyCostAccumulator() };
+            this.models.set(key, m);
+        }
+        return m;
+    }
+    repoBucket(cwd) {
+        const name = repoLabel(cwd);
+        let r = this.repos.get(name);
+        if (!r) {
+            r = { name, cwd: null, sessions: new Set(), assistantMessages: 0, cold: 0, cacheWrite: 0, cacheRead: 0, output: 0, cost: emptyCostAccumulator(), codexTokens: 0, claudeTokens: 0, reads: 0, rereads: 0, staleRereads: 0, userTimestamps: [], byDay: new Map() };
+            this.repos.set(name, r);
+        }
+        if (cwd && !r.cwd)
+            r.cwd = cwd; // remember a real working dir for this repo (for the git pass)
+        return r;
+    }
+    fileRecord(p, repo) {
+        let rec = this.files.get(p);
+        if (!rec) {
+            const label = fileLabel(p);
+            rec = {
+                label, repo, isPrinciple: PRINCIPLE_FILE_RE.test(label), isImage: IMAGE_FILE_RE.test(label),
+                totalReads: 0, rereads: 0, staleRereads: 0, crossSessionRereads: 0, everEdited: false, editCount: 0,
+                readTokens: 0, staleReadTokens: 0, perSession: new Map(), days: new Set(), nightReads: 0,
+            };
+            this.files.set(p, rec);
+        }
+        return rec;
+    }
+    noteTs(ms) {
+        if (this.minTs == null || ms < this.minTs)
+            this.minTs = ms;
+        if (this.maxTs == null || ms > this.maxTs)
+            this.maxTs = ms;
+    }
+    noteSession(id) {
+        if (id)
+            this.allSessionIds.add(id);
+    }
+    /** assistant-turn token usage (already split into cold/cacheWrite/cacheRead/output). */
+    recordUsage(model, cwd, session, u, provider, ms) {
+        const m = this.modelBucket(model);
+        const estimatedCost = estimateApiEquivalentCost(model, u, ms);
+        m.messages += 1;
+        m.cold += u.cold;
+        m.cacheWrite += u.cacheWrite;
+        m.cacheRead += u.cacheRead;
+        m.output += u.output;
+        addEstimatedCost(m.cost, estimatedCost);
+        // Keep usage with missing legacy cwd metadata in an explicit "home" bucket. Silently omitting it
+        // makes repo/day timelines fail to reconcile with the provider ledger even though scale includes it.
+        const r = this.repoBucket(cwd);
+        if (session)
+            r.sessions.add(session);
+        r.assistantMessages += 1;
+        r.cold += u.cold;
+        r.cacheWrite += u.cacheWrite;
+        r.cacheRead += u.cacheRead;
+        r.output += u.output;
+        addEstimatedCost(r.cost, estimatedCost);
+        // per-repo provider split → drives the city's per-cube colour (Codex green / Claude orange)
+        const turnTokens = u.cold + u.cacheWrite + u.cacheRead + u.output;
+        if (provider === "codex")
+            r.codexTokens += turnTokens;
+        else
+            r.claudeTokens += turnTokens;
+        if (ms != null && turnTokens > 0) {
+            const d = localDay(ms);
+            r.byDay.set(d, (r.byDay.get(d) || 0) + turnTokens);
+        }
+    }
+    recordContextObservation(input) {
+        const inputTokens = Math.max(0, Math.round(input.inputTokens || 0));
+        if (inputTokens <= 0)
+            return;
+        const resolvedLimit = resolveModelContextLimit({
+            loggedLimitTokens: input.modelContextLimitTokens ?? null,
+            model: input.model,
+        });
+        const observation = {
+            seq: ++this.contextObservationSeq,
+            model: input.model || "unknown",
+            inputTokens,
+            outputTokens: Math.max(0, Math.round(input.outputTokens || 0)),
+            modelContextLimitTokens: resolvedLimit.tokens,
+            modelContextLimitSource: resolvedLimit.source,
+            ms: input.ms ?? null,
+        };
+        const current = this.latestContextObservation;
+        if (!current ||
+            (observation.ms != null && current.ms != null && observation.ms >= current.ms) ||
+            (observation.ms != null && current.ms == null) ||
+            (observation.ms == null && current.ms == null && observation.seq >= current.seq)) {
+            this.latestContextObservation = observation;
+        }
+    }
+    recordEdit(target, cwd) {
+        if (!target)
+            return;
+        const identity = fileIdentity(target, cwd);
+        this.fileVersions.set(identity, (this.fileVersions.get(identity) || 0) + 1);
+        const rec = this.fileRecord(identity, repoLabel(cwd));
+        rec.everEdited = true;
+        rec.editCount += 1;
+    }
+    /** A file read; decides stale/cross-session at read time and parks the token settle by toolId. */
+    recordRead(target, cwd, session, ms, toolId) {
+        if (!target)
+            return;
+        const repo = repoLabel(cwd);
+        const identity = fileIdentity(target, cwd);
+        const rec = this.fileRecord(identity, repo);
+        const priorReads = rec.totalReads;
+        const currentVersion = this.fileVersions.get(identity) || 0;
+        const seenSessions = this.fileReadSessions.get(identity) || new Set();
+        const isReread = priorReads > 0;
+        const crossSession = isReread && !!session && !seenSessions.has(session);
+        const changedSinceLastRead = isReread && currentVersion > (this.lastReadVersion.get(identity) || 0);
+        const stale = isReread && !changedSinceLastRead;
+        rec.totalReads += 1;
+        if (cwd)
+            this.repoBucket(cwd).reads += 1;
+        if (isReread) {
+            rec.rereads += 1;
+            if (cwd)
+                this.repoBucket(cwd).rereads += 1;
+        }
+        if (crossSession)
+            rec.crossSessionRereads += 1;
+        if (stale) {
+            rec.staleRereads += 1;
+            if (cwd)
+                this.repoBucket(cwd).staleRereads += 1;
+        }
+        const day = ms != null ? localDay(ms) : "unknown";
+        const hour = ms != null ? localHour(ms) : 12;
+        const isNight = NIGHT_HOURS.has(hour);
+        rec.days.add(day);
+        if (isNight)
+            rec.nightReads += 1;
+        const ps = rec.perSession.get(session || "") || { count: 0, day, nightCount: 0 };
+        ps.count += 1;
+        if (isNight)
+            ps.nightCount += 1;
+        rec.perSession.set(session || "", ps);
+        if (stale && isNight) {
+            const candidate = { file: rec.label, path: target, repo, day, hour, sessionShort: (session || "").slice(0, 8), priorReads };
+            if (!this.nightExample || priorReads > this.nightExample.priorReads)
+                this.nightExample = candidate;
+        }
+        if (!this.fileReadSessions.has(identity))
+            this.fileReadSessions.set(identity, new Set());
+        if (session)
+            this.fileReadSessions.get(identity).add(session);
+        this.lastReadVersion.set(identity, currentVersion);
+        if (toolId)
+            this.pendingReads.set(toolId, { rec, stale });
+    }
+    recordReadOutput(toolId, chars) {
+        const pending = this.pendingReads.get(toolId);
+        if (!pending)
+            return;
+        const tokens = tokensFromChars(chars);
+        pending.rec.readTokens += tokens;
+        if (pending.stale)
+            pending.rec.staleReadTokens += tokens;
+        this.pendingReads.delete(toolId);
+    }
+    recordUserMsg(cwd, session, ms) {
+        this.realUserTurns += 1;
+        const hour = localHour(ms);
+        this.hourHistogram[hour] += 1;
+        const wd = localWeekday(ms);
+        this.weekdayCounts.set(wd, (this.weekdayCounts.get(wd) || 0) + 1);
+        if (cwd)
+            this.repoBucket(cwd).userTimestamps.push(ms);
+        if (NIGHT_HOURS.has(hour) && session) {
+            const ln = this.lateNightSessions.get(session) || { repo: repoLabel(cwd), day: localDay(ms), nightMsgs: 0 };
+            ln.nightMsgs += 1;
+            this.lateNightSessions.set(session, ln);
+        }
+    }
+    // ----- work blocks (real attention hours) -----
+    workBlocks(timestamps) {
+        const sorted = [...timestamps].sort((a, b) => a - b);
+        const blocks = [];
+        let start = null;
+        let last = null;
+        for (const ms of sorted) {
+            if (start == null) {
+                start = ms;
+                last = ms;
+                continue;
+            }
+            if (ms - last > WORK_BLOCK_GAP_MS) {
+                blocks.push({ start, end: last });
+                start = ms;
+            }
+            last = ms;
+        }
+        if (start != null)
+            blocks.push({ start, end: last });
+        const attentionHours = blocks.reduce((s, b) => s + (b.end - b.start) / 3_600_000, 0);
+        const days = new Set(blocks.map((b) => localDay(b.start)));
+        return { blocks, attentionHours, activeDays: days.size };
+    }
+    build() {
+        // ----- tokens + cost -----
+        let cold = 0, cacheWrite = 0, cacheRead = 0, output = 0;
+        const modelOut = {};
+        const accumulatedCost = emptyCostAccumulator();
+        for (const [name, m] of this.models) {
+            cold += m.cold;
+            cacheWrite += m.cacheWrite;
+            cacheRead += m.cacheRead;
+            output += m.output;
+            addAccumulatedCost(accumulatedCost, m.cost);
+            if (name === "<synthetic>" || m.cold + m.cacheWrite + m.cacheRead + m.output === 0)
+                continue;
+            modelOut[name] = {
+                messages: m.messages, cold: m.cold, cacheWrite: m.cacheWrite, cacheRead: m.cacheRead, output: m.output,
+                total: m.cold + m.cacheWrite + m.cacheRead + m.output,
+                coldInputCost: round(m.cost.coldInputCost, 2),
+                cacheWriteCost: round(m.cost.cacheWriteCost, 2),
+                cacheReadCost: round(m.cost.cacheReadCost, 2),
+                outputCost: round(m.cost.outputCost, 2),
+                cost: round(m.cost.total, 2),
+                longContextRequestCount: m.cost.longContextRequestCount,
+            };
+        }
+        const totalInput = cold + cacheWrite + cacheRead;
+        const totalTokens = totalInput + output;
+        const cost = {
+            coldInputCost: round(accumulatedCost.coldInputCost, 2),
+            cacheWriteCost: round(accumulatedCost.cacheWriteCost, 2),
+            cacheReadCost: round(accumulatedCost.cacheReadCost, 2),
+            outputCost: round(accumulatedCost.outputCost, 2),
+            total: round(accumulatedCost.total, 2),
+            longContextRequestCount: accumulatedCost.longContextRequestCount,
+            pricingBasis: "standard-api-list-price",
+            pricingAsOf: "2026-07-12",
+        };
+        const rankedModels = Object.entries(modelOut).sort((a, b) => b[1].total - a[1].total);
+        const topModel = rankedModels[0]?.[0] || "unknown";
+        const topShare = totalTokens ? Math.round(((rankedModels[0]?.[1].total || 0) / totalTokens) * 100) : 0;
+        let identityLabel = "workspace power user";
+        if (topShare >= 95)
+            identityLabel = "all-in frontier-model builder";
+        else if (rankedModels.length >= 3)
+            identityLabel = "multi-model operator";
+        else if (topShare >= 75)
+            identityLabel = "primary-model power user";
+        // ----- per-repo attention + global -----
+        const allUserTimestamps = [];
+        const dayAttention = new Map();
+        const repoOut = [];
+        const sinceIso = this.minTs != null ? new Date(this.minTs).toISOString() : null;
+        let totalCommits = 0;
+        for (const repo of this.repos.values()) {
+            allUserTimestamps.push(...repo.userTimestamps);
+            const wb = this.workBlocks(repo.userTimestamps);
+            const commits = gitCommitCount(repo.cwd, sinceIso); // fast git pass: commits landed in this repo during the scan window
+            totalCommits += commits;
+            repoOut.push({
+                name: repo.name, sessions: repo.sessions.size, assistantMessages: repo.assistantMessages,
+                attentionHours: round(wb.attentionHours, 1), activeAttentionDays: wb.activeDays,
+                dailyFocusHours: wb.activeDays ? round(wb.attentionHours / wb.activeDays, 2) : 0,
+                equivalentFocusDays: round(wb.attentionHours / FOCUS_DAY_HOURS, 1), workBlocks: wb.blocks.length,
+                tokens: repo.cold + repo.cacheWrite + repo.cacheRead + repo.output,
+                cost: round(repo.cost.total, 2),
+                reads: repo.reads, rereads: repo.rereads, staleRereads: repo.staleRereads,
+                dominantProvider: repo.codexTokens >= repo.claudeTokens ? "codex" : "claude",
+                codexTokens: repo.codexTokens, claudeTokens: repo.claudeTokens,
+                commits,
+                daily: [...repo.byDay.entries()].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)),
+            });
+            for (const b of wb.blocks) {
+                const d = localDay(b.start);
+                dayAttention.set(d, (dayAttention.get(d) || 0) + (b.end - b.start) / 3_600_000);
+            }
+        }
+        repoOut.sort((a, b) => b.attentionHours - a.attentionHours || b.tokens - a.tokens);
+        const globalBlocks = this.workBlocks(allUserTimestamps);
+        const userAttentionHours = round(globalBlocks.attentionHours, 1);
+        const activeAttentionDays = globalBlocks.activeDays;
+        const dayHoursList = [...dayAttention.entries()].sort((a, b) => b[1] - a[1]);
+        const peakDay = dayHoursList[0] ? { date: dayHoursList[0][0], hours: round(dayHoursList[0][1], 1) } : null;
+        // ----- rhythm -----
+        const sumHours = (hrs) => hrs.reduce((s, h) => s + this.hourHistogram[h], 0);
+        const totalMsgForShare = Math.max(this.realUserTurns, 1);
+        const busiestWeekday = [...this.weekdayCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] || null;
+        const lateNightSessionList = [...this.lateNightSessions.entries()]
+            .map(([id, v]) => ({ session: id.slice(0, 8), repo: v.repo, day: v.day, nightMsgs: v.nightMsgs }))
+            .sort((a, b) => b.nightMsgs - a.nightMsgs)
+            .slice(0, 6);
+        // ----- cleanliness (token-weighted; non-image code/text reads only) -----
+        const codeFiles = [...this.files.values()].filter((f) => !f.isImage && f.totalReads > 0);
+        const codeReadTokens = codeFiles.reduce((s, f) => s + f.readTokens, 0);
+        const codeStaleReadTokens = codeFiles.reduce((s, f) => s + f.staleReadTokens, 0);
+        const codeReads = codeFiles.reduce((s, f) => s + f.totalReads, 0);
+        const codeRereads = codeFiles.reduce((s, f) => s + f.rereads, 0);
+        const codeStaleRereads = codeFiles.reduce((s, f) => s + f.staleRereads, 0);
+        const codeCrossStale = codeFiles.reduce((s, f) => s + f.crossSessionRereads, 0);
+        const staleShare = codeReadTokens ? codeStaleReadTokens / codeReadTokens : 0;
+        const cleanlinessScore = Math.max(0, Math.min(100, Math.round(100 * (1 - staleShare))));
+        // ----- reread forensics -----
+        const ranked = [...this.files.values()]
+            .filter((f) => f.totalReads > 0 && !f.isImage)
+            .sort((a, b) => b.crossSessionRereads - a.crossSessionRereads || b.perSession.size - a.perSession.size || b.rereads - a.rereads || b.totalReads - a.totalReads);
+        const topFiles = ranked.slice(0, 12).map((f) => ({
+            file: f.label, repo: f.repo, isPrinciple: f.isPrinciple, totalReads: f.totalReads, rereads: f.rereads,
+            staleRereads: f.staleRereads, crossSessionRereads: f.crossSessionRereads, everChanged: f.everEdited,
+            editCount: f.editCount, sessionsTouched: f.perSession.size, daysTouched: f.days.size, nightReads: f.nightReads,
+            readTokens: f.readTokens, staleReadTokens: f.staleReadTokens,
+            perSession: [...f.perSession.entries()].map(([id, v]) => ({ session: (id || "").slice(0, 8), count: v.count, day: v.day, nightCount: v.nightCount })).sort((a, b) => b.count - a.count).slice(0, 6),
+        }));
+        const neverChangedHeavy = ranked.filter((f) => !f.everEdited && f.rereads >= 2).slice(0, 8).map((f) => ({
+            file: f.label, repo: f.repo, isPrinciple: f.isPrinciple, totalReads: f.totalReads,
+            sessionsTouched: f.perSession.size, daysTouched: f.days.size, nightReads: f.nightReads, staleReadTokens: f.staleReadTokens,
+        }));
+        const principleReads = ranked.filter((f) => f.isPrinciple && f.rereads > 0).sort((a, b) => b.staleReadTokens - a.staleReadTokens).slice(0, 6).map((f) => ({
+            file: f.label, repo: f.repo, totalReads: f.totalReads, staleReadTokens: f.staleReadTokens, sessionsTouched: f.perSession.size,
+        }));
+        // ----- avoidable wait + counterfactual (ESTIMATES) -----
+        const dailyFocus = activeAttentionDays ? userAttentionHours / activeAttentionDays : repoOut[0]?.dailyFocusHours || 0;
+        const avoidableWaitHours = round(userAttentionHours * staleShare * CONTEXT_REACQUISITION_FRACTION, 1);
+        const avoidableWaitDays = dailyFocus ? round(avoidableWaitHours / dailyFocus, 1) : 0;
+        const daysAgo = Math.max(1, Math.round(avoidableWaitDays));
+        const scanEnd = this.maxTs ?? Date.now();
+        const cfDate = scanEnd - daysAgo * 86_400_000;
+        return {
+            schemaVersion: 1,
+            dataOrigin: "local-workspace-scan",
+            generatedFrom: [],
+            llmCallsUsed: 0,
+            transcriptsUploaded: false,
+            scanStartDate: this.minTs != null ? localDay(this.minTs) : null,
+            scanEndDate: this.maxTs != null ? localDay(this.maxTs) : null,
+            scale: {
+                sessionCount: this.allSessionIds.size,
+                repoCount: repoOut.length,
+                activeDays: activeAttentionDays,
+                totalCommits,
+                totalTokens, totalInputTokens: totalInput, coldInputTokens: cold, cacheWriteTokens: cacheWrite,
+                cacheReadTokens: cacheRead, outputTokens: output,
+                inputPct: totalTokens ? Math.round((totalInput / totalTokens) * 100) : 0,
+            },
+            cost: { ...cost, byModel: modelOut },
+            modelUsage: { topModel, topModelShare: topShare, identityLabel },
+            userWorkingHours: {
+                realUserTurns: this.realUserTurns, userAttentionHours, activeAttentionDays,
+                averageDailyAttentionHours: activeAttentionDays ? round(userAttentionHours / activeAttentionDays, 2) : 0,
+                maxDailyAttentionHours: peakDay ? peakDay.hours : 0, peakDay, workBlocks: globalBlocks.blocks.length,
+            },
+            repos: repoOut,
+            rhythm: {
+                hourHistogram: this.hourHistogram,
+                morningShare: Math.round((sumHours([5, 6, 7, 8, 9, 10, 11]) / totalMsgForShare) * 100),
+                eveningShare: Math.round((sumHours([18, 19, 20, 21]) / totalMsgForShare) * 100),
+                lateNightShare: Math.round((sumHours([22, 23, 0, 1, 2, 3]) / totalMsgForShare) * 100),
+                lateNightSessionCount: this.lateNightSessions.size, lateNightSessions: lateNightSessionList,
+                busiestWeekday, peakDay,
+            },
+            cleanliness: {
+                score: cleanlinessScore, totalReads: codeReads, rereads: codeRereads, staleRereads: codeStaleRereads,
+                crossSessionStaleReads: codeCrossStale, totalReadTokens: codeReadTokens, staleReadTokens: codeStaleReadTokens,
+                staleReadSharePct: Math.round(staleShare * 100),
+            },
+            contextWindow: this.buildContextWindowSummary(topModel, staleShare),
+            rereadForensics: { topFiles, neverChangedHeavy, principleReads, nightExample: this.nightExample },
+            avoidableWait: {
+                readTokens: codeStaleReadTokens,
+                hours: avoidableWaitHours,
+                days: avoidableWaitDays,
+                cost: round(estimateApiEquivalentCost(topModel, { cold: codeStaleReadTokens }, this.maxTs).total, 2),
+            },
+            counterfactual: { daysAgo, counterfactualDate: localDay(cfDate), daysGained: avoidableWaitDays, targetScore: Math.min(100, cleanlinessScore + 30) },
+        };
+    }
+    buildContextWindowSummary(topModel, staleShare) {
+        const latest = this.latestContextObservation;
+        const latestInputTokens = latest?.inputTokens ?? 0;
+        const currentResidentWasteTokens = Math.round(latestInputTokens * Math.max(0, staleShare));
+        return {
+            source: latest ? "latest-observed-input" : "unavailable",
+            model: latest?.model || topModel || "unknown",
+            modelContextLimitSource: latest?.modelContextLimitSource || "unavailable",
+            sampleCount: this.contextObservationSeq,
+            staleReadSharePct: Math.round(staleShare * 100),
+            metrics: calculateContextMetrics({
+                latestInputTokens,
+                modelContextLimitTokens: latest?.modelContextLimitTokens ?? null,
+                currentResidentWasteTokens,
+                newOutputThisTurnTokens: latest?.outputTokens,
+            }),
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Source adapters — translate each log schema into engine calls
+// ---------------------------------------------------------------------------
+function sessionTitleFromText(text) {
+    const normalized = text.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return null;
+    const sentence = normalized.split(/(?<=[.!?。！？])\s/)[0] || normalized;
+    return sentence.slice(0, 96);
+}
+/** Parse one Claude Code transcript without mutating global state. Replaying every provider on one
+ * timestamp-ordered timeline prevents a later-scanned file/source from contaminating reread order. */
+function extractClaude(file) {
+    const usageByRequest = new Map();
+    const seenToolUses = new Set();
+    const context = [];
+    const ev = [];
+    let cwd = null;
+    let session = null;
+    let firstTs = null;
+    let lastTs = null;
+    let fallbackTitle = null;
+    let anonymousRequestSeq = 0;
+    const requestKey = (row) => {
+        const messageId = typeof row.message?.id === "string" ? row.message.id.trim() : "";
+        if (messageId)
+            return `message:${messageId}`;
+        const requestId = typeof row.requestId === "string" ? row.requestId.trim() : "";
+        if (requestId)
+            return `request:${requestId}`;
+        const uuid = typeof row.uuid === "string" ? row.uuid.trim() : "";
+        if (uuid)
+            return `event:${uuid}`;
+        // Without a provider identifier it is unsafe to assume two rows are the same request.
+        return `anonymous:${++anonymousRequestSeq}`;
+    };
+    const usageNumber = (value) => (typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0);
+    const toolUseKey = (request, block, index) => {
+        const id = typeof block?.id === "string" ? block.id.trim() : "";
+        if (id)
+            return `id:${id}`;
+        let input = "";
+        try {
+            input = JSON.stringify(block?.input ?? null);
+        }
+        catch {
+            input = "[unserializable]";
+        }
+        // Claude tool_use blocks normally have an id. The positional fingerprint is a conservative
+        // fallback that deduplicates repeated snapshots without collapsing two calls in one request.
+        return `fallback:${request}:${index}:${String(block?.name || "")}:${input}`;
+    };
+    eachLine(file, (o) => {
+        const ts = typeof o.timestamp === "string" ? Date.parse(o.timestamp) : NaN;
+        if (Number.isFinite(ts)) {
+            if (firstTs == null || ts < firstTs)
+                firstTs = ts;
+            if (lastTs == null || ts > lastTs)
+                lastTs = ts;
+        }
+        if (!session && typeof o.sessionId === "string")
+            session = o.sessionId;
+        if (!cwd && typeof o.cwd === "string")
+            cwd = o.cwd;
+        if (o.type === "assistant" && o.message) {
+            const key = requestKey(o);
+            const u = o.message.usage || {};
+            const model = typeof o.message.model === "string" && o.message.model ? o.message.model : "unknown";
+            const existing = usageByRequest.get(key);
+            const merged = existing || {
+                model,
+                cwd,
+                session,
+                ms: Number.isFinite(ts) ? ts : null,
+                cold: 0,
+                cacheWrite: 0,
+                cacheRead: 0,
+                output: 0,
+            };
+            const candidateCold = usageNumber(u.input_tokens);
+            const candidateCacheWrite = usageNumber(u.cache_creation_input_tokens);
+            const candidateCacheRead = usageNumber(u.cache_read_input_tokens);
+            const candidateInput = candidateCold + candidateCacheWrite + candidateCacheRead;
+            const mergedInput = merged.cold + merged.cacheWrite + merged.cacheRead;
+            if (candidateInput > mergedInput) {
+                // Keep the three input components from one provider snapshot. Taking their independent
+                // maxima can synthesize an official-input total that never appeared in the transcript.
+                merged.cold = candidateCold;
+                merged.cacheWrite = candidateCacheWrite;
+                merged.cacheRead = candidateCacheRead;
+            }
+            merged.output = Math.max(merged.output, usageNumber(u.output_tokens));
+            if (merged.model === "unknown" && model !== "unknown")
+                merged.model = model;
+            if (!merged.cwd && cwd)
+                merged.cwd = cwd;
+            if (!merged.session && session)
+                merged.session = session;
+            if (Number.isFinite(ts) && (merged.ms == null || ts >= merged.ms))
+                merged.ms = ts;
+            usageByRequest.set(key, merged);
+            const blocks = Array.isArray(o.message.content) ? o.message.content : [];
+            for (let index = 0; index < blocks.length; index += 1) {
+                const b = blocks[index];
+                if (b?.type !== "tool_use")
+                    continue;
+                const name = String(b.name || "");
+                const toolKey = toolUseKey(key, b, index);
+                if (seenToolUses.has(toolKey))
+                    continue;
+                if (name === "Edit" || name === "Write" || name === "MultiEdit") {
+                    const target = b.input?.file_path || b.input?.path;
+                    if (target) {
+                        ev.push({ t: "e", path: target, ms: Number.isFinite(ts) ? ts : null });
+                        seenToolUses.add(toolKey);
+                    }
+                }
+                else if (name === "Read") {
+                    const target = b.input?.file_path;
+                    if (target) {
+                        ev.push({ t: "r", path: target, ms: Number.isFinite(ts) ? ts : null, id: b.id || null });
+                        seenToolUses.add(toolKey);
+                    }
+                }
+            }
+            return;
+        }
+        if (o.type === "user" && o.message) {
+            const content = o.message.content;
+            if (typeof content === "string") {
+                if (isRealUserText(content) && Number.isFinite(ts) && !o.isSidechain) {
+                    ev.push({ t: "m", ms: ts });
+                    if (!fallbackTitle)
+                        fallbackTitle = sessionTitleFromText(content);
+                }
+            }
+            else if (Array.isArray(content)) {
+                for (const b of content) {
+                    if (b?.type === "tool_result" && b.tool_use_id) {
+                        ev.push({ t: "o", id: b.tool_use_id, chars: contentLength(b.content), ms: Number.isFinite(ts) ? ts : null });
+                    }
+                }
+            }
+        }
+    });
+    const usage = [];
+    // Claude can persist several snapshots of the same provider message. Account official usage once,
+    // retaining the one input tuple with the largest official total.
+    for (const request of usageByRequest.values()) {
+        usage.push({
+            model: request.model,
+            cold: request.cold,
+            cacheWrite: request.cacheWrite,
+            cacheRead: request.cacheRead,
+            output: request.output,
+            ms: request.ms,
+        });
+        context.push({
+            model: request.model,
+            inputTokens: request.cold + request.cacheWrite + request.cacheRead,
+            outputTokens: request.output,
+            ms: request.ms,
+        });
+    }
+    return { source: "claude-code", session, cwd, firstTs, lastTs, fallbackTitle, usage, context, ev };
+}
+/** Parse one Codex rollout into a compact, cacheable FileEvents. token_count is CUMULATIVE (delta'd);
+ * edits arrive via patch_apply_end; reads are exec_command shell commands (path extracted best-effort). */
+function extractCodex(file) {
+    let cwd = null;
+    let session = null;
+    // Default to a Codex/OpenAI model so token counts logged before the model field appears are priced
+    // as OpenAI (not the Claude opus default) — the real model overrides this as soon as it's seen.
+    let model = "gpt-5-codex";
+    let prev = { cold: 0, cacheRead: 0, output: 0 }; // last cumulative seen (for deltas)
+    let firstTs = null;
+    let lastTs = null;
+    let fallbackTitle = null;
+    const usage = [];
+    const context = [];
+    const ev = [];
+    eachLine(file, (o) => {
+        const ts = typeof o.timestamp === "string" ? Date.parse(o.timestamp) : NaN;
+        if (Number.isFinite(ts)) {
+            if (firstTs == null || ts < firstTs)
+                firstTs = ts;
+            if (lastTs == null || ts > lastTs)
+                lastTs = ts;
+        }
+        const p = o && typeof o.payload === "object" && o.payload ? o.payload : o;
+        if (!p || typeof p !== "object")
+            return;
+        if (o.type === "session_meta") {
+            if (typeof p.cwd === "string")
+                cwd = p.cwd;
+            if (typeof p.id === "string" && !session)
+                session = p.id;
+            // Codex records the actual launch time in session metadata. It can precede the first persisted
+            // JSONL event by several seconds, so use it for the semantic start of the timeline when present.
+            const startedAt = typeof p.timestamp === "string" ? Date.parse(p.timestamp) : NaN;
+            if (Number.isFinite(startedAt) && (firstTs == null || startedAt < firstTs))
+                firstTs = startedAt;
+            return;
+        }
+        if (typeof p.model === "string")
+            model = p.model;
+        if (p.type === "token_count") {
+            const u = p.info?.total_token_usage;
+            if (u) {
+                const inputTotal = u.input_tokens || 0;
+                const cacheRead = u.cached_input_tokens || 0;
+                const cold = Math.max(0, inputTotal - cacheRead);
+                const out = (u.output_tokens || 0) + (u.reasoning_output_tokens || 0);
+                const dCold = Math.max(0, cold - prev.cold);
+                const dCr = Math.max(0, cacheRead - prev.cacheRead);
+                const dOut = Math.max(0, out - prev.output);
+                const last = p.info?.last_token_usage || {};
+                const lastInput = last.input_tokens || inputTotal;
+                const lastOutput = (last.output_tokens || 0) + (last.reasoning_output_tokens || 0) || dOut;
+                context.push({
+                    model,
+                    inputTokens: lastInput,
+                    outputTokens: lastOutput,
+                    modelContextLimitTokens: p.info?.model_context_window || p.model_context_window || null,
+                    ms: Number.isFinite(ts) ? ts : null,
+                });
+                if (dCold || dCr || dOut) {
+                    usage.push({
+                        model,
+                        cold: dCold,
+                        cacheWrite: 0,
+                        cacheRead: dCr,
+                        output: dOut,
+                        ms: Number.isFinite(ts) ? ts : null,
+                    });
+                }
+                prev = { cold, cacheRead, output: out };
+            }
+            return;
+        }
+        if (p.type === "user_message") {
+            if (Number.isFinite(ts))
+                ev.push({ t: "m", ms: ts });
+            if (!fallbackTitle) {
+                const text = typeof p.message === "string" ? p.message : typeof p.content === "string" ? p.content : "";
+                if (text)
+                    fallbackTitle = sessionTitleFromText(text);
+            }
+            return;
+        }
+        if (p.type === "patch_apply_end" && p.changes && typeof p.changes === "object") {
+            for (const target of Object.keys(p.changes))
+                ev.push({ t: "e", path: target, ms: Number.isFinite(ts) ? ts : null });
+            return;
+        }
+        // older format: exec_command_end with parsed_cmd[].type==='read'
+        if (p.type === "exec_command_end" && Array.isArray(p.parsed_cmd)) {
+            for (const c of p.parsed_cmd) {
+                if (c?.type === "read" && typeof c.path === "string")
+                    ev.push({ t: "r", path: c.path, ms: Number.isFinite(ts) ? ts : null, id: p.call_id || null });
+            }
+            return;
+        }
+        // newer format: reads are exec_command function_calls; extract the path best-effort
+        if (p.type === "function_call" && (p.name === "exec_command" || p.name === "shell")) {
+            try {
+                const args = JSON.parse(typeof p.arguments === "string" ? p.arguments : "{}");
+                const target = typeof args.cmd === "string" ? extractReadPath(args.cmd) : null;
+                if (target)
+                    ev.push({ t: "r", path: target, ms: Number.isFinite(ts) ? ts : null, id: p.call_id || null });
+            }
+            catch {
+                /* skip */
+            }
+            return;
+        }
+        if (p.type === "function_call_output" && p.call_id) {
+            ev.push({ t: "o", id: p.call_id, chars: contentLength(p.output), ms: Number.isFinite(ts) ? ts : null });
+        }
+    });
+    return { source: "codex", session, cwd, firstTs, lastTs, fallbackTitle, usage, context, ev };
+}
+/** Replay every provider on one semantic timeline. Provider timestamps, not source/path order, drive
+ * daily token buckets and order-dependent edit/reread state across overlapping sessions. */
+function replayTimelineFiles(eng, files) {
+    const orderedEvents = [];
+    const orderedUsage = [];
+    files.forEach(({ fe }, fileOrder) => {
+        if (fe.firstTs != null)
+            eng.noteTs(fe.firstTs);
+        if (fe.lastTs != null)
+            eng.noteTs(fe.lastTs);
+        eng.noteSession(fe.session);
+        (fe.usage || []).forEach((u, usageOrder) => orderedUsage.push({ fe, u, fileOrder, usageOrder }));
+        for (const c of fe.context || [])
+            eng.recordContextObservation(c);
+        (fe.ev || []).forEach((e, eventOrder) => orderedEvents.push({ fe, e, fileOrder, eventOrder }));
+    });
+    orderedUsage.sort((a, b) => (a.u.ms ?? a.fe.firstTs ?? Number.POSITIVE_INFINITY) - (b.u.ms ?? b.fe.firstTs ?? Number.POSITIVE_INFINITY) ||
+        a.fileOrder - b.fileOrder ||
+        a.usageOrder - b.usageOrder);
+    for (const { fe, u } of orderedUsage) {
+        const provider = fe.source === "codex" ? "codex" : "claude";
+        eng.recordUsage(u.model, fe.cwd, fe.session, { cold: u.cold, cacheWrite: u.cacheWrite, cacheRead: u.cacheRead, output: u.output }, provider, u.ms ?? undefined);
+    }
+    const eventMs = (item) => item.e.ms ?? item.fe.firstTs ?? Number.POSITIVE_INFINITY;
+    orderedEvents.sort((a, b) => eventMs(a) - eventMs(b) ||
+        a.fileOrder - b.fileOrder ||
+        a.eventOrder - b.eventOrder);
+    for (const { fe, e } of orderedEvents) {
+        const callId = (id) => id ? `${fe.source}:${fe.session || "unknown"}:${id}` : null;
+        if (e.t === "m")
+            eng.recordUserMsg(fe.cwd, fe.session, e.ms);
+        else if (e.t === "e")
+            eng.recordEdit(e.path, fe.cwd);
+        else if (e.t === "r")
+            eng.recordRead(e.path, fe.cwd, fe.session, e.ms, callId(e.id));
+        else if (e.t === "o")
+            eng.recordReadOutput(callId(e.id) || e.id, e.chars);
+    }
+}
+// ---------------------------------------------------------------------------
+// Per-file parse cache — keyed by path+mtime+size so re-runs only reparse changed/new Codex files.
+// ---------------------------------------------------------------------------
+const CACHE_VERSION = 6;
+function forensicCachePath() {
+    return path.join(os.homedir(), ".echomem", "forensic-cache.json");
+}
+function loadForensicCache() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(forensicCachePath(), "utf8"));
+        if (parsed && parsed.v === CACHE_VERSION && parsed.files && typeof parsed.files === "object")
+            return parsed.files;
+    }
+    catch {
+        /* no cache yet, or a stale/corrupt one — rebuild */
+    }
+    return {};
+}
+function saveForensicCache(files) {
+    try {
+        const p = forensicCachePath();
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify({ v: CACHE_VERSION, files }));
+    }
+    catch {
+        /* best effort: a cache write failure must never break the scan */
+    }
+}
+function loadCodexSessionTitles() {
+    const titles = new Map();
+    try {
+        const indexPath = path.join(os.homedir(), ".codex", "session_index.jsonl");
+        for (const line of fs.readFileSync(indexPath, "utf8").split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const row = JSON.parse(line);
+                if (typeof row.id === "string" && typeof row.thread_name === "string" && row.thread_name.trim()) {
+                    titles.set(row.id, row.thread_name.trim());
+                }
+            }
+            catch {
+                /* Ignore incomplete index rows. */
+            }
+        }
+    }
+    catch {
+        /* Index is optional; transcript-derived titles remain available. */
+    }
+    return titles;
+}
+function loadClaudeSessionTitles() {
+    const titles = new Map();
+    const roots = [
+        path.join(os.homedir(), "Library", "Application Support", "Claude", "claude-code-sessions"),
+        path.join(os.homedir(), "Library", "Application Support", "Claude", "local-agent-mode-sessions"),
+    ];
+    for (const root of roots) {
+        const files = walk(root, (p) => /^local_[0-9a-f-]+\.json$/i.test(path.basename(p)), () => false);
+        for (const file of files) {
+            try {
+                const row = JSON.parse(fs.readFileSync(file, "utf8"));
+                if (typeof row.cliSessionId === "string" && typeof row.title === "string" && row.title.trim()) {
+                    titles.set(row.cliSessionId, row.title.trim());
+                }
+            }
+            catch {
+                /* Ignore incomplete live metadata. */
+            }
+        }
+    }
+    return titles;
+}
+function enrichCanonicalSessionExamples(canonical, sessionRecords) {
+    if (!canonical || "error" in canonical)
+        return;
+    const codexTitles = loadCodexSessionTitles();
+    const claudeTitles = loadClaudeSessionTitles();
+    const records = sessionRecords
+        .filter((record) => Boolean(record.session))
+        .sort((a, b) => (a.firstTs ?? Number.POSITIVE_INFINITY) - (b.firstTs ?? Number.POSITIVE_INFINITY));
+    const sourceTotals = {
+        codex: records.filter((record) => record.source === "codex").length,
+        "claude-code": records.filter((record) => record.source === "claude-code").length,
+    };
+    const sourceOrdinals = { codex: 0, "claude-code": 0 };
+    const sessionMeta = new Map();
+    for (const record of records) {
+        if (!record.session)
+            continue;
+        sourceOrdinals[record.source] += 1;
+        const indexedTitle = record.source === "codex" ? codexTitles.get(record.session) : claudeTitles.get(record.session);
+        sessionMeta.set(record.session, {
+            id: record.session,
+            title: indexedTitle || record.fallbackTitle || `${record.cwd ? path.basename(record.cwd) : "Local"} session`,
+            ordinal: sourceOrdinals[record.source],
+            total: sourceTotals[record.source],
+        });
+    }
+    const reports = [canonical];
+    if (canonical.sourceReports?.codex)
+        reports.push(canonical.sourceReports.codex);
+    if (canonical.sourceReports?.claudeCode)
+        reports.push(canonical.sourceReports.claudeCode);
+    for (const contextReport of reports) {
+        for (const problem of contextReport.problems || []) {
+            for (const example of problem.examples || []) {
+                const exact = sessionMeta.get(example.session);
+                const matched = exact || [...sessionMeta.entries()].find(([id]) => id.startsWith(example.session))?.[1];
+                if (!matched)
+                    continue;
+                example.session = matched.id;
+                example.sessionTitle = matched.title;
+                example.sessionOrdinal = matched.ordinal;
+                example.sourceSessionCount = matched.total;
+            }
+        }
+    }
+}
+export function projectCanonicalWasteToBilledInput(billedInputTokens, summary) {
+    if (!Number.isFinite(billedInputTokens) ||
+        !Number.isFinite(summary.officialInputTokens) ||
+        !Number.isFinite(summary.wasteTokens))
+        return null;
+    const billedInput = Math.round(billedInputTokens);
+    const canonicalInput = Math.round(summary.officialInputTokens);
+    const canonicalWaste = Math.round(summary.wasteTokens);
+    // With aligned source scope, all provider requests must contain at least as many input tokens as
+    // one selected request per human turn. Refuse to manufacture a projection from inverted ledgers.
+    if (billedInput <= 0 ||
+        canonicalInput <= 0 ||
+        canonicalWaste < 0 ||
+        canonicalWaste > canonicalInput ||
+        billedInput < canonicalInput)
+        return null;
+    const billingMultiplier = billedInput / canonicalInput;
+    const projectedWaste = Math.max(0, Math.min(billedInput, Math.round(canonicalWaste * billingMultiplier)));
+    const wastePct = (canonicalWaste / canonicalInput) * 100;
+    return {
+        method: "canonical-window-share-over-provider-input",
+        billedInputTokens: billedInput,
+        canonicalInputTokens: canonicalInput,
+        canonicalUsefulTokens: canonicalInput - canonicalWaste,
+        canonicalWasteTokens: canonicalWaste,
+        billingMultiplier,
+        projectedUsefulTokens: billedInput - projectedWaste,
+        projectedWasteTokens: projectedWaste,
+        usefulPct: 100 - wastePct,
+        wastePct,
+    };
+}
+function recordValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0
+        ? value
+        : null;
+}
+function nonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function approximatelyEqual(actual, expected, relativeTolerance = 1e-9) {
+    return typeof actual === "number" &&
+        Number.isFinite(actual) &&
+        Math.abs(actual - expected) <= Math.max(1, Math.abs(expected)) * relativeTolerance;
+}
+function invalidSetupReport(code, message) {
+    return { ok: false, code, message };
+}
+/**
+ * Fail-closed boundary between the local scanner and setup UI.
+ *
+ * The setup page must never infer that a fixture, unreconciled scan, or internally inconsistent
+ * token ledger is the user's report. This validator checks provenance and the cross-ledger
+ * identities the UI relies on before any absolute token number is rendered.
+ */
+export function validateForensicReportForSetup(value) {
+    const report = recordValue(value);
+    if (!report)
+        return invalidSetupReport("REPORT_MALFORMED", "The local report payload is not an object.");
+    if (report.schemaVersion !== 1) {
+        return invalidSetupReport("REPORT_SCHEMA_UNSUPPORTED", "The local report schema is missing or unsupported.");
+    }
+    if (report.dataOrigin !== "local-workspace-scan") {
+        return invalidSetupReport("REPORT_NOT_LOCAL", "The report did not come from this local workspace scan.");
+    }
+    const scale = recordValue(report.scale);
+    const canonical = recordValue(report.canonicalGoldenStandard);
+    const requiredObjects = [
+        report.cost,
+        report.modelUsage,
+        report.userWorkingHours,
+        report.rhythm,
+        report.cleanliness,
+        report.contextWindow,
+        report.rereadForensics,
+        report.avoidableWait,
+        report.counterfactual,
+    ];
+    if (!scale ||
+        !canonical ||
+        !Array.isArray(report.generatedFrom) ||
+        !Array.isArray(report.repos) ||
+        requiredObjects.some((entry) => !recordValue(entry)) ||
+        typeof report.llmCallsUsed !== "number" ||
+        !Number.isFinite(report.llmCallsUsed) ||
+        typeof report.transcriptsUploaded !== "boolean" ||
+        !(report.scanStartDate === null || typeof report.scanStartDate === "string") ||
+        !(report.scanEndDate === null || typeof report.scanEndDate === "string")) {
+        return invalidSetupReport("REPORT_MALFORMED", "The local report is missing required setup fields.");
+    }
+    if (Object.prototype.hasOwnProperty.call(canonical, "error")) {
+        return invalidSetupReport("REPORT_CANONICAL_FAILED", "Canonical context analysis did not complete.");
+    }
+    const summary = recordValue(canonical.summary);
+    if (!summary)
+        return invalidSetupReport("REPORT_MALFORMED", "Canonical context summary is missing.");
+    const sessionCount = nonNegativeInteger(scale.sessionCount);
+    const canonicalSessionCount = nonNegativeInteger(summary.sessionsAnalyzed);
+    const billedInput = nonNegativeInteger(scale.totalInputTokens);
+    const totalTokens = nonNegativeInteger(scale.totalTokens);
+    const coldInput = nonNegativeInteger(scale.coldInputTokens);
+    const cacheWrite = nonNegativeInteger(scale.cacheWriteTokens);
+    const cacheRead = nonNegativeInteger(scale.cacheReadTokens);
+    const output = nonNegativeInteger(scale.outputTokens);
+    const canonicalInput = nonNegativeInteger(summary.officialInputTokens);
+    const canonicalUseful = nonNegativeInteger(summary.usefulTokens);
+    const canonicalWaste = nonNegativeInteger(summary.wasteTokens);
+    if (sessionCount === null ||
+        canonicalSessionCount === null ||
+        billedInput === null ||
+        totalTokens === null ||
+        coldInput === null ||
+        cacheWrite === null ||
+        cacheRead === null ||
+        output === null ||
+        canonicalInput === null ||
+        canonicalUseful === null ||
+        canonicalWaste === null) {
+        return invalidSetupReport("REPORT_USAGE_INVALID", "The report contains invalid token or session totals.");
+    }
+    if (coldInput + cacheWrite + cacheRead !== billedInput || billedInput + output !== totalTokens) {
+        return invalidSetupReport("REPORT_USAGE_INVALID", "Provider token totals do not reconcile.");
+    }
+    const reportCost = recordValue(report.cost);
+    const costByModel = reportCost ? recordValue(reportCost.byModel) : null;
+    const coldInputCost = reportCost ? nonNegativeNumber(reportCost.coldInputCost) : null;
+    const cacheWriteCost = reportCost ? nonNegativeNumber(reportCost.cacheWriteCost) : null;
+    const cacheReadCost = reportCost ? nonNegativeNumber(reportCost.cacheReadCost) : null;
+    const outputCost = reportCost ? nonNegativeNumber(reportCost.outputCost) : null;
+    const totalCost = reportCost ? nonNegativeNumber(reportCost.total) : null;
+    if (!reportCost || !costByModel || coldInputCost === null || cacheWriteCost === null ||
+        cacheReadCost === null || outputCost === null || totalCost === null) {
+        return invalidSetupReport("REPORT_COST_INVALID", "The API-equivalent cost ledger is missing or malformed.");
+    }
+    const componentCost = coldInputCost + cacheWriteCost + cacheReadCost + outputCost;
+    if (Math.abs(componentCost - totalCost) > 0.05) {
+        return invalidSetupReport("REPORT_COST_INVALID", "Cost components do not reconcile with total spend.");
+    }
+    const modelCosts = Object.values(costByModel).map((value) => {
+        const model = recordValue(value);
+        return model ? nonNegativeNumber(model.cost) : null;
+    });
+    if (modelCosts.some((value) => value === null)) {
+        return invalidSetupReport("REPORT_COST_INVALID", "A model cost entry is malformed.");
+    }
+    const modelCostSum = modelCosts.reduce((sum, value) => sum + (value ?? 0), 0);
+    if (Math.abs(modelCostSum - totalCost) > Math.max(0.05, modelCosts.length * 0.011)) {
+        return invalidSetupReport("REPORT_COST_INVALID", "Per-model costs do not reconcile with total spend.");
+    }
+    const repoCosts = report.repos.map((value) => {
+        const repo = recordValue(value);
+        return repo ? nonNegativeNumber(repo.cost) : null;
+    });
+    if (repoCosts.some((value) => value === null)) {
+        return invalidSetupReport("REPORT_COST_INVALID", "A workspace cost entry is malformed.");
+    }
+    const repoCostSum = repoCosts.reduce((sum, value) => sum + (value ?? 0), 0);
+    if (Math.abs(repoCostSum - totalCost) > Math.max(0.05, repoCosts.length * 0.011)) {
+        return invalidSetupReport("REPORT_COST_INVALID", "Per-workspace costs do not reconcile with total spend.");
+    }
+    const diagnostics = canonical.diagnostics === undefined ? null : recordValue(canonical.diagnostics);
+    let skippedCanonicalSessions = 0;
+    if (canonical.diagnostics !== undefined && !diagnostics) {
+        return invalidSetupReport("REPORT_MALFORMED", "Canonical scan diagnostics are malformed.");
+    }
+    if (diagnostics) {
+        const skippedSessions = nonNegativeInteger(diagnostics.skippedSessions);
+        const errors = diagnostics.errors;
+        if (skippedSessions === null || !Array.isArray(errors)) {
+            return invalidSetupReport("REPORT_MALFORMED", "Canonical scan diagnostics are malformed.");
+        }
+        if (skippedSessions !== errors.length) {
+            return invalidSetupReport("REPORT_MALFORMED", "Canonical scan diagnostics do not reconcile.");
+        }
+        skippedCanonicalSessions = skippedSessions;
+    }
+    if (canonicalSessionCount > sessionCount ||
+        canonicalSessionCount + skippedCanonicalSessions !== sessionCount ||
+        (sessionCount > 0 && canonicalSessionCount === 0)) {
+        return invalidSetupReport("REPORT_COHORT_MISMATCH", "Canonical analysis did not retain a usable local-session cohort.");
+    }
+    if (canonicalUseful + canonicalWaste !== canonicalInput) {
+        return invalidSetupReport("REPORT_CANONICAL_INVALID", "Canonical useful and waste totals do not reconcile.");
+    }
+    const canonicalWastePct = canonicalInput > 0 ? (canonicalWaste / canonicalInput) * 100 : 0;
+    const canonicalUsefulPct = canonicalInput > 0 ? (canonicalUseful / canonicalInput) * 100 : 0;
+    if (!approximatelyEqual(summary.wastePct, canonicalWastePct) ||
+        !approximatelyEqual(summary.usefulPct, canonicalUsefulPct)) {
+        return invalidSetupReport("REPORT_CANONICAL_INVALID", "Canonical token percentages do not reconcile with their totals.");
+    }
+    if (sessionCount === 0) {
+        if (totalTokens !== 0 ||
+            billedInput !== 0 ||
+            coldInput !== 0 ||
+            cacheWrite !== 0 ||
+            cacheRead !== 0 ||
+            output !== 0 ||
+            canonicalInput !== 0 ||
+            canonicalUseful !== 0 ||
+            canonicalWaste !== 0) {
+            return invalidSetupReport("REPORT_EMPTY_USAGE_MISMATCH", "An empty scan contains unexpected token usage.");
+        }
+        if (report.billedWasteProjection !== undefined) {
+            return invalidSetupReport("REPORT_PROJECTION_INVALID", "An empty scan must not contain a billed waste projection.");
+        }
+        return { ok: true, kind: "empty", report: report };
+    }
+    const hasRenderableRepo = report.repos.some((value) => {
+        const repo = recordValue(value);
+        return !!repo && typeof repo.name === "string" && repo.name.trim().length > 0 &&
+            nonNegativeInteger(repo.tokens) !== null && Number(repo.tokens) > 0;
+    });
+    if (!hasRenderableRepo) {
+        return invalidSetupReport("REPORT_REPOS_EMPTY", "A non-empty scan has no tokenized local workspace to render.");
+    }
+    if (billedInput <= 0 || canonicalInput <= 0) {
+        return invalidSetupReport("REPORT_USAGE_INVALID", "A non-empty scan must contain positive provider and canonical input totals.");
+    }
+    if (canonicalInput > billedInput) {
+        return invalidSetupReport("REPORT_LEDGER_INVERTED", "Canonical input exceeds provider-billed input for the same sessions.");
+    }
+    const expectedProjection = projectCanonicalWasteToBilledInput(billedInput, {
+        officialInputTokens: canonicalInput,
+        wasteTokens: canonicalWaste,
+    });
+    const projection = recordValue(report.billedWasteProjection);
+    if (!expectedProjection || !projection) {
+        return invalidSetupReport("REPORT_PROJECTION_MISSING", "The billed waste projection is missing for a non-empty scan.");
+    }
+    if (projection.method !== expectedProjection.method ||
+        nonNegativeInteger(projection.billedInputTokens) !== expectedProjection.billedInputTokens ||
+        nonNegativeInteger(projection.canonicalInputTokens) !== expectedProjection.canonicalInputTokens ||
+        nonNegativeInteger(projection.canonicalUsefulTokens) !== expectedProjection.canonicalUsefulTokens ||
+        nonNegativeInteger(projection.canonicalWasteTokens) !== expectedProjection.canonicalWasteTokens ||
+        nonNegativeInteger(projection.projectedUsefulTokens) !== expectedProjection.projectedUsefulTokens ||
+        nonNegativeInteger(projection.projectedWasteTokens) !== expectedProjection.projectedWasteTokens ||
+        !approximatelyEqual(projection.billingMultiplier, expectedProjection.billingMultiplier) ||
+        !approximatelyEqual(projection.usefulPct, expectedProjection.usefulPct) ||
+        !approximatelyEqual(projection.wastePct, expectedProjection.wastePct)) {
+        return invalidSetupReport("REPORT_PROJECTION_INVALID", "The billed waste projection does not reconcile with its source ledgers.");
+    }
+    if (expectedProjection.projectedUsefulTokens + expectedProjection.projectedWasteTokens !== billedInput ||
+        !approximatelyEqual(expectedProjection.projectedWasteTokens / billedInput, canonicalWaste / canonicalInput, 1 / Math.max(1, billedInput))) {
+        return invalidSetupReport("REPORT_PROJECTION_INVALID", "The billed waste projection violates its token-share identity.");
+    }
+    return { ok: true, kind: "ready", report: report };
+}
+/** Scan both sources and build the merged forensic report. Local-only, $0, never throws on bad files. */
+export async function buildForensicReport(opts) {
+    const sources = opts?.sources ?? ["codex", "claude"];
+    let eng = new Forensics();
+    const codexDiscovery = sources.includes("codex")
+        ? discoverCodexSessionFiles({ includeArchived: opts?.includeArchivedCodex !== false })
+        : null;
+    const claudeRoot = sources.includes("claude") ? resolveClaudeProjectsDir() : null;
+    // Discovery combines active + archived stores, de-duplicates by stable session identity, and orders
+    // sessions by semantic start time. Canonical human-turn analysis intentionally excludes subagents.
+    const reportCodexSessions = codexDiscovery?.files.filter((file) => file.userInitiated !== false) ?? [];
+    // Keep the canonical denominator on the same top-level-session population as the billed ledger.
+    // Legacy sessions without provenance are already admitted to reportCodexSessions; dropping them
+    // only here creates a small but real numerator/denominator scope mismatch.
+    const canonicalCodexFiles = reportCodexSessions.map((file) => file.path);
+    const codexFiles = reportCodexSessions.map((file) => file.path);
+    // Claude stores subagent/workflow implementation logs separately. They can share a parent
+    // session ID and must not be counted as additional user conversations.
+    const claudeFiles = claudeRoot
+        ? walk(claudeRoot, (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows").sort()
+        : [];
+    const total = codexFiles.length + claudeFiles.length;
+    let done = 0;
+    // Every stage reports the same file counters as scanned/total, so the visible "N of M sessions
+    // scanned" only ever climbs. A stage's own counters (the canonical pass counts a different set,
+    // on a different scale) drive nothing but its slice of the overall bar — feeding them straight
+    // into scanned/total is what made the bar and the caption fall back partway through the scan.
+    const STAGE_BANDS = {
+        "reading-transcripts": [0, 0.7],
+        "building-summary": [0.7, 0.75],
+        "classifying-repeated-context": [0.75, 0.95],
+        "finalizing-report": [0.95, 1],
+    };
+    const overallFor = (stage, stageDone, stageTotal) => {
+        const band = STAGE_BANDS[stage];
+        if (!band)
+            return 0;
+        const ratio = stageTotal > 0 ? Math.min(1, Math.max(0, stageDone / stageTotal)) : 0;
+        return band[0] + (band[1] - band[0]) * ratio;
+    };
+    const progress = (stage, detail, stageDone = done, stageTotal = total) => {
+        opts?.onProgress?.(done, total, stage, detail, overallFor(stage, stageDone, stageTotal), stageDone, stageTotal);
+    };
+    progress("reading-transcripts", "finding local Codex and Claude transcript files");
+    const tick = (stage = "reading-transcripts") => {
+        done++;
+        if (opts?.onProgress && (done % 8 === 0 || done === total))
+            progress(stage);
+    };
+    // Codex is the slow source (GB-scale rollouts). Cache each file's parse by mtime+size so only
+    // changed/new sessions reparse; the cross-session state is rebuilt later on one provider timeline.
+    const cache = loadForensicCache();
+    const nextCache = {};
+    const parsedCodexFiles = [];
+    const discoveredCodexByPath = new Map(codexDiscovery?.files.map((file) => [file.path, file]) ?? []);
+    for (const f of codexFiles) {
+        let st;
+        try {
+            st = fs.statSync(f);
+        }
+        catch {
+            tick("reading-transcripts");
+            continue;
+        }
+        const hit = cache[f];
+        const fe = hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size ? hit.fe : extractCodex(f);
+        const discovered = discoveredCodexByPath.get(f);
+        if (!fe.session && discovered)
+            fe.session = discovered.sessionKey;
+        nextCache[f] = { mtimeMs: st.mtimeMs, size: st.size, fe };
+        parsedCodexFiles.push({ path: f, fe });
+        tick("reading-transcripts");
+    }
+    if (codexFiles.length)
+        saveForensicCache(nextCache);
+    // Claude is fast (~0.6s) — parse live, then merge its events with Codex before replay.
+    const timelineFiles = [...parsedCodexFiles];
+    for (const f of claudeFiles) {
+        timelineFiles.push({ path: f, fe: extractClaude(f) });
+        tick("reading-transcripts");
+    }
+    timelineFiles.sort((a, b) => (a.fe.firstTs ?? Number.POSITIVE_INFINITY) - (b.fe.firstTs ?? Number.POSITIVE_INFINITY) ||
+        a.path.localeCompare(b.path));
+    // The title/enrichment pass only needs five scalar fields per session. Capture those before
+    // releasing the much larger usage/context/event arrays ahead of canonical classification.
+    const canonicalSessionRecords = timelineFiles.map(({ fe }) => ({
+        source: fe.source,
+        session: fe.session,
+        cwd: fe.cwd,
+        firstTs: fe.firstTs,
+        fallbackTitle: fe.fallbackTitle,
+    }));
+    replayTimelineFiles(eng, timelineFiles);
+    // Entering a stage means it has done none of its own work yet, so it opens its band rather than
+    // inheriting the finished file counters — otherwise a stage announces itself at its band ceiling
+    // and its real sub-progress then drags the bar back down.
+    progress("building-summary", "aggregating rereads, model usage, cost, and local context signals", 0, 1);
+    const report = eng.build();
+    eng = null;
+    const firstTimelineSession = timelineFiles.find(({ fe }) => fe.firstTs != null);
+    report.firstSession = firstTimelineSession ? {
+        date: firstTimelineSession.fe.firstTs != null ? new Date(firstTimelineSession.fe.firstTs).toISOString() : null,
+        source: firstTimelineSession.fe.source,
+        repo: firstTimelineSession.fe.cwd ? path.basename(firstTimelineSession.fe.cwd) : "workspace",
+    } : null;
+    const activeCodexCount = reportCodexSessions.filter((file) => file.rootKind === "active").length;
+    report.activeSessionCoverage = {
+        codex: activeCodexCount,
+        claudeCode: claudeFiles.length,
+        total: activeCodexCount + claudeFiles.length,
+    };
+    report.generatedFrom = [
+        ...(codexDiscovery?.roots.map((root) => root.kind === "active" ? "$CODEX_HOME/sessions" : "$CODEX_HOME/archived_sessions") ?? []),
+        ...(claudeRoot ? ["$CLAUDE_CONFIG_DIR/projects"] : []),
+    ];
+    if (codexDiscovery) {
+        report.sourceCoverage = {
+            codex: {
+                activeSessions: reportCodexSessions.filter((file) => file.rootKind === "active").length,
+                archivedSessions: reportCodexSessions.filter((file) => file.rootKind === "archived").length,
+                unclassifiedSessions: reportCodexSessions.filter((file) => file.userInitiated == null).length,
+                duplicateSessionsDiscarded: codexDiscovery.diagnostics.conflicts.length,
+                identityFallbacks: codexDiscovery.diagnostics.filenameIdentityFallbacks + codexDiscovery.diagnostics.pathIdentityFallbacks,
+                timelineBasis: "provider-event-timestamps",
+            },
+        };
+    }
+    // The forensic cache and timeline can be hundreds of MB for a small number of very long sessions.
+    // They are no longer needed after replay/build, and retaining them while loading the canonical
+    // cache was the peak-memory overlap that terminated the setup worker on large histories.
+    parsedCodexFiles.length = 0;
+    timelineFiles.length = 0;
+    for (const key of Object.keys(cache))
+        delete cache[key];
+    for (const key of Object.keys(nextCache))
+        delete nextCache[key];
+    if (opts?.includeLegacyGoldenStandard !== false) {
+        try {
+            report.goldenStandard = buildWorkspaceContextReport();
+        }
+        catch (error) {
+            report.goldenStandard = { error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    try {
+        const canonicalSources = [];
+        if (sources.includes("codex"))
+            canonicalSources.push("codex");
+        if (sources.includes("claude"))
+            canonicalSources.push("claude-code");
+        progress("classifying-repeated-context", "reconstructing context windows and attributing P01/P03/P08/P10/P13 waste", 0, 1);
+        report.canonicalGoldenStandard = await buildCanonicalGoldenReport({
+            sources: canonicalSources,
+            codexSessionPaths: canonicalCodexFiles,
+            claudeSessionPaths: claudeFiles,
+            // These paths were discovered from the user's local roots. One malformed/unsupported session
+            // must become a diagnostic, not erase the canonical report for every other valid session.
+            strictSessionErrors: false,
+            onProgress: (canonicalDone, canonicalTotal) => progress("classifying-repeated-context", "reconstructing context windows and attributing P01/P03/P08/P10/P13 waste", canonicalDone, canonicalTotal),
+        });
+        enrichCanonicalSessionExamples(report.canonicalGoldenStandard, canonicalSessionRecords);
+    }
+    catch (error) {
+        report.canonicalGoldenStandard = { error: error instanceof Error ? error.message : String(error) };
+    }
+    if (report.canonicalGoldenStandard &&
+        !("error" in report.canonicalGoldenStandard) &&
+        report.canonicalGoldenStandard.summary.sessionsAnalyzed > 0) {
+        const projection = projectCanonicalWasteToBilledInput(Number(report.scale.totalInputTokens || 0), report.canonicalGoldenStandard.summary);
+        if (projection)
+            report.billedWasteProjection = projection;
+    }
+    progress("finalizing-report", "preparing setup page data", total, total);
+    return report;
+}