@agent-finops/core 0.5.8 → 0.6.0

package/dist/localAgentLogs.js

@@ -3,17 +3,67 @@ import { basename, isAbsolute, join, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { estimateTokenCostUsd } from "./modelPricing.js";
 import { redactSecrets } from "./discovery.js";
+import { createCodexInvocationCollector } from "./toolInvocations.js";
+/**
+ * Resolve the repository root most recently observed in transcript metadata.
+ *
+ * CLI, MCP, and Glance use this only to scope read-only project inventory when
+ * the caller did not explicitly choose a path. Absolute working directories
+ * never enter rendered output.
+ */
+export function latestObservedWorkingDirectory(calls) {
+    return calls
+        .filter((call) => call.workingDirectory)
+        .sort((left, right) => right.timestamp.localeCompare(left.timestamp))[0]
+        ?.workingDirectory;
+}
+/**
+ * Codex rollout/compaction files can repeat the same session's cumulative
+ * token counter. Keep only the latest snapshot per session so financial value,
+ * Glance, and project totals never add cumulative checkpoints together.
+ * Turn-scoped Claude calls and calls without a stable session id are retained.
+ */
+export function dedupeCumulativeSessionCalls(calls) {
+    const retained = [];
+    const cumulative = new Map();
+    for (const call of calls) {
+        if (call.usageScope !== "session_cumulative" || !call.sessionId) {
+            retained.push(call);
+            continue;
+        }
+        const key = `${call.agent}:${call.sessionId}`;
+        const prior = cumulative.get(key);
+        if (!prior || isLaterCumulativeSnapshot(call, prior)) {
+            cumulative.set(key, call);
+        }
+    }
+    return [...retained, ...cumulative.values()];
+}
+function isLaterCumulativeSnapshot(candidate, prior) {
+    const timestampOrder = candidate.timestamp.localeCompare(prior.timestamp);
+    if (timestampOrder !== 0)
+        return timestampOrder > 0;
+    return totalUsageTokens(candidate.usage) > totalUsageTokens(prior.usage);
+}
+function totalUsageTokens(usage) {
+    return usage.inputTokens +
+        usage.outputTokens +
+        (usage.cacheReadTokens ?? 0) +
+        (usage.cacheWrite5mTokens ?? 0) +
+        (usage.cacheWrite1hTokens ?? 0);
+}
 /** Parse one Claude Code transcript (JSONL). Exported for tests. */
-export function parseClaudeCodeTranscript(content, filePath = "") {
+export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDiagnostic) {
     const calls = [];
     const seen = new Set();
-    const prompts = [];
-    const fileCounts = new Map();
+    const pendingPrompts = [];
+    const activityEvidence = new Map();
     let title;
     let lastPrompt;
-    let toolCallCount = 0;
+    let latestActivityKey;
     let isSubagent = filePath.split(sep).includes("subagents");
     let parentSessionId;
+    let malformedLines = 0;
     for (const line of content.split("\n")) {
         if (!line.trim())
             continue;
@@ -22,6 +72,7 @@ export function parseClaudeCodeTranscript(content, filePath = "") {
             entry = JSON.parse(line);
         }
         catch {
+            malformedLines += 1;
             continue;
         }
         if (!isRecord(entry))
@@ -39,15 +90,7 @@ export function parseClaudeCodeTranscript(content, filePath = "") {
         if (entry.type === "user" && message) {
             for (const prompt of textValues(message.content)) {
                 if (isHumanPrompt(prompt))
-                    prompts.push(prompt);
-            }
-        }
-        if (entry.type === "assistant" && message) {
-            for (const item of recordValues(message.content)) {
-                if (item.type !== "tool_use")
-                    continue;
-                toolCallCount += 1;
-                collectToolFiles(item.input, fileCounts);
+                    pendingPrompts.push(prompt);
             }
         }
         if (entry.type !== "assistant")
@@ -63,57 +106,107 @@ export function parseClaudeCodeTranscript(content, filePath = "") {
         if (dedupeKey !== ":" && seen.has(dedupeKey))
             continue;
         seen.add(dedupeKey);
+        const timestamp = toIso(stringOf(entry.timestamp)) ?? new Date(0).toISOString();
+        if (typeof sinceMs === "number" && Date.parse(timestamp) < sinceMs) {
+            // These prompts led to a call outside the selected evidence window. Do
+            // not let them become the focus of a later in-window project/call.
+            pendingPrompts.length = 0;
+            continue;
+        }
         const cacheCreation = isRecord(usage.cache_creation) ? usage.cache_creation : undefined;
         const write5m = numberOf(cacheCreation?.ephemeral_5m_input_tokens);
         const write1h = numberOf(cacheCreation?.ephemeral_1h_input_tokens);
         const writeTotal = numberOf(usage.cache_creation_input_tokens) ?? 0;
-        calls.push({
+        const parsedUsage = {
+            inputTokens: numberOf(usage.input_tokens) ?? 0,
+            outputTokens: numberOf(usage.output_tokens) ?? 0,
+            cacheReadTokens: numberOf(usage.cache_read_input_tokens) ?? 0,
+            // Prefer the 5m/1h breakdown; fall back to the total as 5m (cheaper bound).
+            cacheWrite5mTokens: write5m ?? writeTotal,
+            cacheWrite1hTokens: write1h ?? 0
+        };
+        const workingDirectory = absoluteWorkingDirectory(stringOf(entry.cwd));
+        const project = projectFromCwd(workingDirectory) ?? projectFromTranscriptPath(filePath);
+        const sessionId = stringOf(entry.sessionId);
+        const call = {
             agent: "claude-code",
             model: stringOf(message.model) ?? "claude-code",
-            timestamp: toIso(stringOf(entry.timestamp)) ?? new Date(0).toISOString(),
-            project: projectFromCwd(stringOf(entry.cwd)) ?? projectFromTranscriptPath(filePath),
-            sessionId: stringOf(entry.sessionId),
-            usage: {
-                inputTokens: numberOf(usage.input_tokens) ?? 0,
-                outputTokens: numberOf(usage.output_tokens) ?? 0,
-                cacheReadTokens: numberOf(usage.cache_read_input_tokens) ?? 0,
-                // Prefer the 5m/1h breakdown; fall back to the total as 5m (cheaper bound).
-                cacheWrite5mTokens: write5m ?? writeTotal,
-                cacheWrite1hTokens: write1h ?? 0
-            }
-        });
+            timestamp,
+            project,
+            workingDirectory,
+            sessionId,
+            latestTurnUsage: toTurnUsage(parsedUsage, "assistant_message_usage"),
+            usageScope: "turn",
+            usage: parsedUsage
+        };
+        calls.push(call);
+        const activityKey = localActivityScopeKey(sessionId, workingDirectory, project);
+        const evidence = activityEvidence.get(activityKey) ?? {
+            prompts: [],
+            files: new Map(),
+            toolCallCount: 0
+        };
+        evidence.prompts.push(...pendingPrompts);
+        pendingPrompts.length = 0;
+        for (const item of recordValues(message.content)) {
+            if (item.type !== "tool_use")
+                continue;
+            evidence.toolCallCount += 1;
+            collectToolFiles(item.input, evidence.files);
+        }
+        activityEvidence.set(activityKey, evidence);
+        latestActivityKey = activityKey;
     }
     const fallbackPrompt = lastPrompt && isHumanPrompt(lastPrompt) ? lastPrompt : undefined;
-    const activity = buildLocalAgentActivity({
-        title,
-        prompts: prompts.length > 0 ? prompts : fallbackPrompt ? [fallbackPrompt] : [],
-        files: fileCounts,
-        toolCallCount,
-        project: calls[0]?.project ?? projectFromTranscriptPath(filePath),
-        isSubagent,
-        parentSessionId
-    });
-    if (activity) {
-        for (const call of calls)
-            call.activity = activity;
+    const activities = new Map();
+    for (const [activityKey, evidence] of activityEvidence) {
+        const matchingCall = calls.find((call) => (localActivityScopeKey(call.sessionId, call.workingDirectory, call.project) === activityKey));
+        const isLatest = activityKey === latestActivityKey;
+        const activity = buildLocalAgentActivity({
+            title: isLatest ? title : undefined,
+            prompts: evidence.prompts.length > 0
+                ? evidence.prompts
+                : isLatest && fallbackPrompt
+                    ? [fallbackPrompt]
+                    : [],
+            files: evidence.files,
+            toolCallCount: evidence.toolCallCount,
+            project: matchingCall?.project ?? projectFromTranscriptPath(filePath),
+            isSubagent,
+            parentSessionId
+        });
+        if (activity)
+            activities.set(activityKey, activity);
+    }
+    for (const call of calls) {
+        call.activity = activities.get(localActivityScopeKey(call.sessionId, call.workingDirectory, call.project));
+    }
+    if (malformedLines > 0) {
+        onDiagnostic?.({ code: "malformed_jsonl", count: malformedLines });
     }
     return calls;
 }
 /** Parse one Codex rollout file (JSONL event stream). Exported for tests. */
-export function parseCodexRollout(content) {
+export function parseCodexRollout(content, onEntry, onDiagnostic) {
     let model;
-    let cwd;
+    let rootCwd;
     const toolWorkdirs = new Map();
     let sessionId;
+    let rootSessionMetaSeen = false;
     let startedAt;
+    let rootStartedAtMs;
+    let rootTaskStarted = false;
+    let inheritedUsageBaseline;
     let lastActivityAt;
     let lastTotal;
+    let lastTurn;
     let lastRateLimits;
     const prompts = [];
     const fileCounts = new Map();
     let toolCallCount = 0;
     let isSubagent = false;
     let parentSessionId;
+    let malformedLines = 0;
     for (const line of content.split("\n")) {
         if (!line.trim())
             continue;
@@ -122,21 +215,50 @@ export function parseCodexRollout(content) {
             entry = JSON.parse(line);
         }
         catch {
+            malformedLines += 1;
             continue;
         }
         if (!isRecord(entry))
             continue;
+        onEntry?.(entry);
         const payload = isRecord(entry.payload) ? entry.payload : undefined;
-        if (entry.type === "session_meta" && payload) {
-            sessionId = stringOf(payload.id) ?? sessionId;
-            cwd = stringOf(payload.cwd) ?? cwd;
-            startedAt = toIso(stringOf(payload.timestamp) ?? stringOf(entry.timestamp)) ?? startedAt;
+        if (entry.type === "session_meta" && payload && !rootSessionMetaSeen) {
+            // A forked/subagent rollout can embed the parent transcript, including
+            // many later session_meta records. The first metadata record belongs to
+            // this rollout file; later records are nested/history evidence and must
+            // never replace the financial session identity or root cwd.
+            rootSessionMetaSeen = true;
+            sessionId = stringOf(payload.id);
+            rootCwd = stringOf(payload.cwd);
+            startedAt = toIso(stringOf(payload.timestamp) ?? stringOf(entry.timestamp));
+            rootStartedAtMs = timestampMilliseconds(payload.timestamp ?? entry.timestamp);
             isSubagent = stringOf(payload.thread_source) === "subagent" || isRecord(payload.source) && "subagent" in payload.source;
-            parentSessionId = stringOf(payload.parent_thread_id) ?? parentSessionId;
+            parentSessionId = stringOf(payload.parent_thread_id);
         }
         if (entry.type === "turn_context" && payload) {
             model = stringOf(payload.model) ?? model;
-            cwd = stringOf(payload.cwd) ?? cwd;
+            rootCwd ??= stringOf(payload.cwd);
+        }
+        if (isSubagent &&
+            !rootTaskStarted &&
+            payload?.type === "task_started" &&
+            isRootSpecificTaskStart(payload.started_at, rootStartedAtMs)) {
+            // Forked Codex rollouts copy the parent's complete event history after
+            // the child's root session_meta. The cumulative counter immediately
+            // before the child's first task is the inherited baseline, not child
+            // usage. Reset qualitative evidence at the same boundary so parent
+            // prompts/files cannot become the child's focus.
+            inheritedUsageBaseline = lastTotal;
+            lastTotal = undefined;
+            rootTaskStarted = true;
+            prompts.length = 0;
+            fileCounts.clear();
+            toolWorkdirs.clear();
+            toolCallCount = 0;
+            model = undefined;
+            lastTurn = undefined;
+            lastRateLimits = undefined;
+            lastActivityAt = toIso(stringOf(entry.timestamp)) ?? startedAt;
         }
         if (payload?.type === "function_call" || payload?.type === "custom_tool_call") {
             toolCallCount += 1;
@@ -165,21 +287,58 @@ export function parseCodexRollout(content) {
             const eventTimestamp = toIso(stringOf(entry.timestamp)) ?? lastActivityAt ?? startedAt;
             const info = isRecord(payload.info) ? payload.info : undefined;
             const total = info && isRecord(info.total_token_usage) ? info.total_token_usage : undefined;
+            const turn = info && isRecord(info.last_token_usage) ? info.last_token_usage : undefined;
             if (total) {
                 lastTotal = total;
                 lastActivityAt = eventTimestamp;
             }
+            if (turn) {
+                lastTurn = turn;
+                lastActivityAt = eventTimestamp;
+            }
             const rateLimits = parseCodexRateLimits(payload.rate_limits, eventTimestamp);
             if (rateLimits) {
                 lastRateLimits = rateLimits;
             }
         }
     }
-    if (!lastTotal)
+    // A fork without a recognized root-task boundary is ambiguous: older Codex
+    // formats may contain only inherited parent history. Omitting that child is
+    // safer than charging the parent cumulative counter again. Likewise, a
+    // recognized boundary with no later total_token_usage is not a financial
+    // call yet.
+    if (malformedLines > 0) {
+        onDiagnostic?.({ code: "malformed_jsonl", count: malformedLines });
+    }
+    if (!lastTotal || isSubagent && !rootTaskStarted)
         return [];
-    const input = numberOf(lastTotal.input_tokens) ?? 0;
-    const cached = numberOf(lastTotal.cached_input_tokens) ?? 0;
-    const project = projectFromCwd(dominantCodexCwd(cwd, toolWorkdirs));
+    const rawInput = numberOf(lastTotal.input_tokens);
+    const rawOutput = numberOf(lastTotal.output_tokens);
+    const rawCached = numberOf(lastTotal.cached_input_tokens);
+    const rawReportedTotal = numberOf(lastTotal.total_tokens);
+    const baselineInput = numberOf(inheritedUsageBaseline?.input_tokens);
+    const baselineOutput = numberOf(inheritedUsageBaseline?.output_tokens);
+    const baselineReportedTotal = numberOf(inheritedUsageBaseline?.total_tokens);
+    const currentComponentsComplete = rawInput !== undefined && rawOutput !== undefined && !((rawReportedTotal ?? 0) > 0 && rawInput === 0 && rawOutput === 0);
+    const baselineComponentsComplete = !inheritedUsageBaseline || (baselineInput !== undefined && baselineOutput !== undefined && !((baselineReportedTotal ?? 0) > 0 && baselineInput === 0 && baselineOutput === 0));
+    const usageSupport = currentComponentsComplete && baselineComponentsComplete
+        ? "complete"
+        : "unsupported_token_shape";
+    if (usageSupport === "unsupported_token_shape") {
+        onDiagnostic?.({ code: "unsupported_token_shape", count: 1 });
+    }
+    const input = Math.max(0, (rawInput ?? 0) - (baselineInput ?? 0));
+    const cached = Math.max(0, (rawCached ?? 0) -
+        (numberOf(inheritedUsageBaseline?.cached_input_tokens) ?? 0));
+    const output = Math.max(0, (rawOutput ?? 0) - (baselineOutput ?? 0));
+    const reportedTotalTokens = rawReportedTotal === undefined
+        ? undefined
+        : Math.max(0, rawReportedTotal - (baselineReportedTotal ?? 0));
+    const latestTurnUsage = lastTurn
+        ? codexTurnUsage(lastTurn)
+        : undefined;
+    const workingDirectory = absoluteWorkingDirectory(dominantCodexCwd(rootCwd, toolWorkdirs));
+    const project = projectFromCwd(workingDirectory);
     const activity = buildLocalAgentActivity({
         prompts,
         files: fileCounts,
@@ -194,13 +353,18 @@ export function parseCodexRollout(content) {
             timestamp: lastActivityAt ?? startedAt ?? new Date(0).toISOString(),
             startedAt,
             project,
+            workingDirectory,
             sessionId,
             rateLimits: lastRateLimits,
             activity,
+            latestTurnUsage,
+            usageScope: "session_cumulative",
+            usageSupport,
+            ...(reportedTotalTokens !== undefined ? { reportedTotalTokens } : {}),
             usage: {
                 // Codex input_tokens INCLUDES cached tokens; split them out.
                 inputTokens: Math.max(0, input - cached),
-                outputTokens: numberOf(lastTotal.output_tokens) ?? 0,
+                outputTokens: output,
                 cacheReadTokens: cached
             }
         }];
@@ -275,38 +439,78 @@ export async function loadLocalAgentUsage(options = {}) {
     const claudeDir = options.claudeProjectsDir ?? join(home, ".claude", "projects");
     const codexDir = options.codexSessionsDir ?? join(home, ".codex", "sessions");
     const calls = [];
+    const codexInvocationFiles = options.collectCodexInvocationEvidence
+        ? []
+        : undefined;
     let filesParsed = 0;
-    for (const file of await listJsonlFiles(claudeDir)) {
-        const content = await readFile(file, "utf8").catch(() => "");
+    const since = options.sinceIso ? Date.parse(options.sinceIso) : undefined;
+    const sinceMs = typeof since === "number" && Number.isFinite(since) ? since : undefined;
+    const diagnostics = [];
+    const sourceScans = [
+        emptySourceScan("claude-code"),
+        emptySourceScan("codex")
+    ];
+    const claudeScan = sourceScans[0];
+    const codexScan = sourceScans[1];
+    for (const file of await listJsonlFiles(claudeDir, claudeScan, diagnostics)) {
+        let content;
+        try {
+            content = await readFile(file, "utf8");
+        }
+        catch (error) {
+            recordUnreadableFile("claude-code", claudeScan, diagnostics, error);
+            continue;
+        }
         if (!content)
             continue;
         filesParsed += 1;
-        calls.push(...parseClaudeCodeTranscript(content, file));
+        claudeScan.filesParsed += 1;
+        calls.push(...parseClaudeCodeTranscript(content, file, sinceMs, (diagnostic) => {
+            recordParseDiagnostic("claude-code", claudeScan, diagnostics, diagnostic);
+        }));
     }
-    for (const file of await listJsonlFiles(codexDir)) {
+    for (const file of await listJsonlFiles(codexDir, codexScan, diagnostics)) {
         if (!basename(file).startsWith("rollout-"))
             continue;
-        const content = await readFile(file, "utf8").catch(() => "");
+        let content;
+        try {
+            content = await readFile(file, "utf8");
+        }
+        catch (error) {
+            recordUnreadableFile("codex", codexScan, diagnostics, error);
+            continue;
+        }
         if (!content)
             continue;
         filesParsed += 1;
-        calls.push(...parseCodexRollout(content));
+        codexScan.filesParsed += 1;
+        const collector = codexInvocationFiles
+            ? createCodexInvocationCollector(sinceMs)
+            : undefined;
+        calls.push(...parseCodexRollout(content, collector?.consume, (diagnostic) => {
+            recordParseDiagnostic("codex", codexScan, diagnostics, diagnostic);
+        }));
+        if (collector)
+            codexInvocationFiles.push(collector.finish());
     }
-    const since = options.sinceIso ? Date.parse(options.sinceIso) : undefined;
-    const filtered = typeof since === "number" && Number.isFinite(since)
-        ? calls.filter((call) => Date.parse(call.timestamp) >= since)
-        : calls;
+    const normalizedCalls = dedupeCumulativeSessionCalls(calls);
+    const filtered = typeof sinceMs === "number"
+        ? normalizedCalls.filter((call) => Date.parse(call.timestamp) >= sinceMs)
+        : normalizedCalls;
     return {
         records: aggregateCalls(filtered),
         calls: filtered,
         filesParsed,
-        agentsDetected: [...new Set(filtered.map((call) => call.agent))]
+        agentsDetected: [...new Set(filtered.map((call) => call.agent))],
+        sourceScans,
+        diagnostics,
+        ...(codexInvocationFiles ? { codexInvocationFiles } : {})
     };
 }
 /** Aggregate per-call usage into one UsageRecord per day+agent+model+project. */
 export function aggregateCalls(calls) {
     const groups = new Map();
-    for (const call of calls) {
+    for (const call of dedupeCumulativeSessionCalls(calls)) {
         const day = call.timestamp.slice(0, 10);
         const key = [day, call.agent, call.model, call.project ?? "unattributed"].join("|");
         groups.set(key, [...(groups.get(key) ?? []), call]);
@@ -321,8 +525,9 @@ export function aggregateCalls(calls) {
             cacheWrite5mTokens: sum(groupCalls, (c) => c.usage.cacheWrite5mTokens ?? 0),
             cacheWrite1hTokens: sum(groupCalls, (c) => c.usage.cacheWrite1hTokens ?? 0)
         };
-        const amountUsd = estimateTokenCostUsd(model, usage);
-        const priced = typeof amountUsd === "number";
+        const usageSupported = groupCalls.every((call) => call.usageSupport !== "unsupported_token_shape");
+        const amountUsd = usageSupported ? estimateTokenCostUsd(model, usage) : undefined;
+        const priced = usageSupported && typeof amountUsd === "number";
         records.push({
             id: slug(["local", agent, day, model, project].join("-")),
             timestamp: new Date(`${day}T00:00:00Z`).toISOString(),
@@ -344,31 +549,138 @@ export function aggregateCalls(calls) {
             projectId: project === "unattributed" || project === "(home)" ? undefined : project,
             agentId: agent,
             providerCostType: "local_agent_logs",
+            usageGranularity: "daily_aggregate",
             quantity: groupCalls.length,
             operation: `${agent} sessions`
         });
     }
     return records.sort((left, right) => left.id.localeCompare(right.id));
 }
-async function listJsonlFiles(root) {
-    const exists = await stat(root).then((s) => s.isDirectory()).catch(() => false);
-    if (!exists)
+async function listJsonlFiles(root, scan, diagnostics) {
+    let rootStat;
+    try {
+        rootStat = await stat(root);
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT")) {
+            scan.directoryStatus = "missing";
+            diagnostics.push({
+                agent: scan.agent,
+                code: "directory_missing",
+                severity: "info",
+                message: `${agentLabel(scan.agent)} transcript directory was not found.`,
+                count: 1
+            });
+        }
+        else {
+            scan.directoryStatus = "unreadable";
+            diagnostics.push({
+                agent: scan.agent,
+                code: "directory_unreadable",
+                severity: "error",
+                message: `${agentLabel(scan.agent)} transcript directory could not be read${errorCodeSuffix(error)}.`,
+                count: 1
+            });
+        }
+        return [];
+    }
+    if (!rootStat.isDirectory()) {
+        scan.directoryStatus = "unreadable";
+        diagnostics.push({
+            agent: scan.agent,
+            code: "directory_unreadable",
+            severity: "error",
+            message: `${agentLabel(scan.agent)} transcript path is not a readable directory.`,
+            count: 1
+        });
         return [];
+    }
+    scan.directoryStatus = "readable";
     const out = [];
     const queue = [root];
     while (queue.length > 0) {
         const dir = queue.pop();
-        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            scan.directoryStatus = "unreadable";
+            diagnostics.push({
+                agent: scan.agent,
+                code: "directory_unreadable",
+                severity: "error",
+                message: `${agentLabel(scan.agent)} transcript directory could not be read${errorCodeSuffix(error)}.`,
+                count: 1
+            });
+            continue;
+        }
         for (const entry of entries) {
             const path = join(dir, entry.name);
             if (entry.isDirectory())
                 queue.push(path);
-            else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
                 out.push(path);
+                scan.filesDiscovered += 1;
+            }
         }
     }
     return out;
 }
+function emptySourceScan(agent) {
+    return {
+        agent,
+        directoryStatus: "readable",
+        filesDiscovered: 0,
+        filesParsed: 0,
+        malformedLines: 0,
+        unreadableFiles: 0,
+        unsupportedUsageSnapshots: 0
+    };
+}
+function recordUnreadableFile(agent, scan, diagnostics, error) {
+    scan.unreadableFiles += 1;
+    diagnostics.push({
+        agent,
+        code: "file_unreadable",
+        severity: "error",
+        message: `${agentLabel(agent)} transcript file could not be read${errorCodeSuffix(error)}.`,
+        count: 1
+    });
+}
+function recordParseDiagnostic(agent, scan, diagnostics, diagnostic) {
+    if (diagnostic.code === "malformed_jsonl") {
+        scan.malformedLines += diagnostic.count;
+        diagnostics.push({
+            agent,
+            code: diagnostic.code,
+            severity: "warning",
+            message: `${diagnostic.count} malformed JSONL line(s) were skipped in ${agentLabel(agent)} transcripts.`,
+            count: diagnostic.count
+        });
+        return;
+    }
+    scan.unsupportedUsageSnapshots += diagnostic.count;
+    diagnostics.push({
+        agent,
+        code: diagnostic.code,
+        severity: "warning",
+        message: `${diagnostic.count} ${agentLabel(agent)} token snapshot(s) lacked the input/output components required for pricing.`,
+        count: diagnostic.count
+    });
+}
+function agentLabel(agent) {
+    return agent === "claude-code" ? "Claude Code" : "Codex";
+}
+function errorCodeSuffix(error) {
+    const code = error instanceof Error
+        ? error.code
+        : undefined;
+    return code && /^[A-Z0-9_]+$/.test(code) ? ` (${code})` : "";
+}
+function isNodeError(error, code) {
+    return error instanceof Error && error.code === code;
+}
 function projectFromCwd(cwd) {
     if (!cwd)
         return undefined;
@@ -379,6 +691,9 @@ function projectFromCwd(cwd) {
     const name = basename(cwd);
     return name.length > 0 ? name : undefined;
 }
+function absoluteWorkingDirectory(cwd) {
+    return cwd && isAbsolute(cwd) ? resolve(cwd) : undefined;
+}
 /**
  * Codex can be launched from HOME and do nearly all of its work through tools
  * that declare a more specific working directory. Prefer that observed
@@ -412,12 +727,18 @@ function projectFromTranscriptPath(filePath) {
     const tail = parent.split("-").filter(Boolean).pop();
     return tail && tail.length > 0 ? tail : undefined;
 }
+function localActivityScopeKey(sessionId, workingDirectory, project) {
+    // The absolute cwd stays inside this ephemeral parser key and is never
+    // persisted or rendered. It prevents one transcript that changes projects
+    // from attaching Project A's prompt/file evidence to Project B's calls.
+    return [sessionId ?? "unknown-session", workingDirectory ?? project ?? "unattributed"].join("\u0000");
+}
 const FOCUS_STOP_WORDS = new Set([
-    "about", "after", "again", "also", "and", "are", "at", "been", "being", "but",
+    "about", "above", "after", "again", "also", "and", "are", "at", "been", "being", "but",
     "can", "check", "could", "did", "does", "doing", "dont", "every", "from",
     "for", "have", "here", "how", "in", "into", "its", "just", "like", "make", "more",
     "need", "not", "now", "on", "only", "other", "our", "please", "really", "should",
-    "something", "sure", "than", "that", "the", "their", "them", "then", "there",
+    "earlier", "is", "mentioned", "one", "something", "sure", "than", "that", "the", "their", "them", "then", "there",
     "these", "they", "thing", "think", "this", "through", "to", "too", "use", "user",
     "users", "want", "was", "way", "we", "what", "when", "where", "which", "while",
     "who", "why", "will", "with", "work", "working", "would", "you", "your",
@@ -493,12 +814,49 @@ function focusTopic(prompts) {
     if (prompts.length === 0)
         return undefined;
     const recent = prompts.slice(-12);
-    const observedTopicTokens = new Set(recent.flatMap((prompt) => (topicTokens(prompt).filter((token) => !FOCUS_STOP_WORDS.has(token)))));
+    const promptTokenSets = recent.map((prompt) => (new Set(topicTokens(prompt).filter((token) => !FOCUS_STOP_WORDS.has(token)))));
+    const observedTopicTokens = new Set(promptTokenSets.flatMap((tokens) => [...tokens]));
+    // Recognized product/work concepts are meaningful even in one prompt. Generic
+    // tokens must repeat across distinct prompts below; that keeps attachment
+    // prose and one-off screenshot filenames from becoming a confident topic.
+    if (observedTopicTokens.has("aibill") && observedTopicTokens.has("prompt")) {
+        return "aibill prompt";
+    }
+    if (observedTopicTokens.has("glance") && observedTopicTokens.has("hover")) {
+        return observedTopicTokens.has("ui") ? "Glance hover UI" : "Glance hover";
+    }
+    if (observedTopicTokens.has("glance") &&
+        ["action", "agent", "handoff", "prompt"].some((token) => observedTopicTokens.has(token))) {
+        return "Glance agent handoff";
+    }
+    if (observedTopicTokens.has("landing") && observedTopicTokens.has("page"))
+        return "landing page";
+    if (observedTopicTokens.has("hover")) {
+        return observedTopicTokens.has("ui") ? "hover UI" : "hover interaction";
+    }
+    if (observedTopicTokens.has("mcp")) {
+        return observedTopicTokens.has("feature") ? "MCP feature" : "MCP";
+    }
+    if (observedTopicTokens.has("seo")) {
+        return observedTopicTokens.has("strategy") ? "SEO strategy" : "SEO";
+    }
+    const promptOccurrences = new Map();
+    for (const tokens of promptTokenSets) {
+        for (const token of tokens) {
+            promptOccurrences.set(token, (promptOccurrences.get(token) ?? 0) + 1);
+        }
+    }
+    const repeatedTokens = new Set([...promptOccurrences.entries()]
+        .filter(([, count]) => count >= 2)
+        .map(([token]) => token));
+    if (repeatedTokens.size === 0)
+        return undefined;
     const tokenScores = new Map();
     const pairScores = new Map();
     recent.forEach((prompt, index) => {
         const weight = 1 + index / Math.max(1, recent.length - 1);
-        const tokens = topicTokens(prompt).filter((token) => !FOCUS_STOP_WORDS.has(token));
+        const tokens = topicTokens(prompt)
+            .filter((token) => !FOCUS_STOP_WORDS.has(token) && repeatedTokens.has(token));
         const unique = [...new Set(tokens)];
         for (const token of unique) {
             tokenScores.set(token, (tokenScores.get(token) ?? 0) + weight);
@@ -526,22 +884,9 @@ function focusTopic(prompts) {
     if (candidateTokens.size === 0)
         return undefined;
     const tokens = [...candidateTokens].slice(0, 3);
-    if (tokens.includes("glance") && tokens.includes("hover")) {
-        return tokens.includes("ui") ? "Glance hover UI" : "Glance hover";
-    }
-    if (observedTopicTokens.has("glance") &&
-        ["action", "agent", "handoff", "prompt"].some((token) => observedTopicTokens.has(token))) {
-        return "Glance agent handoff";
-    }
     if (tokens.includes("hover")) {
         return tokens.includes("ui") ? "hover UI" : "hover interaction";
     }
-    if (tokens.includes("landing") && tokens.includes("page"))
-        return "landing page";
-    if (tokens.includes("mcp"))
-        return tokens.includes("feature") ? "MCP feature" : "MCP";
-    if (tokens.includes("seo"))
-        return tokens.includes("strategy") ? "SEO strategy" : "SEO";
     return tokens.map(displayToken).join(" ");
 }
 function inferAction(prompts, title) {
@@ -619,9 +964,36 @@ function topicTokens(value) {
     // Absolute paths often appear in attached-image metadata and tool-oriented
     // prompts. They are machine context, not the user's work topic, and can
     // otherwise outrank meaningful words when only one recent prompt exists.
-    const withoutAbsolutePaths = value.replace(/(^|[\s("'=:])(?:file:\/\/)?\/[^\s)"']+/g, "$1");
+    const withoutAbsolutePaths = value.replace(/(^|[\s("'=:])(?:file:\/\/)?\/[^\s)"']+/g, "$1")
+        .replace(/\b[^\s/\\]+\.(?:png|jpe?g|gif|webp|heic|svg|pdf|mov|mp4)\b/gi, " ")
+        .replace(/\b(?:attached|attachment|clipboard|image|images|photo|picture|screenshot|screenshots)\b/gi, " ");
     return promptTokens(sanitizeLocalActivityText(withoutAbsolutePaths));
 }
+function codexTurnUsage(value) {
+    const rawInput = numberOf(value.input_tokens) ?? 0;
+    const cached = Math.min(rawInput, numberOf(value.cached_input_tokens) ?? 0);
+    const output = numberOf(value.output_tokens) ?? 0;
+    return {
+        inputTokens: Math.max(0, rawInput - cached),
+        outputTokens: output,
+        cacheReadTokens: cached,
+        contextTokens: rawInput,
+        totalTokens: numberOf(value.total_tokens) ?? rawInput + output,
+        source: "transcript_last_token_usage"
+    };
+}
+function toTurnUsage(usage, source) {
+    const contextTokens = usage.inputTokens +
+        (usage.cacheReadTokens ?? 0) +
+        (usage.cacheWrite5mTokens ?? 0) +
+        (usage.cacheWrite1hTokens ?? 0);
+    return {
+        ...usage,
+        contextTokens,
+        totalTokens: contextTokens + usage.outputTokens,
+        source
+    };
+}
 /**
  * Remove known and assignment-shaped credentials from metadata before it can
  * become a topic, title, Glance field, MCP result, or copy-ready handoff.
@@ -698,6 +1070,26 @@ function toIso(value) {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) ? new Date(parsed).toISOString() : undefined;
 }
+const ROOT_TASK_CLOCK_TOLERANCE_MS = 5_000;
+function isRootSpecificTaskStart(value, rootStartedAtMs) {
+    const taskStartedAtMs = timestampMilliseconds(value);
+    return typeof rootStartedAtMs === "number" &&
+        typeof taskStartedAtMs === "number" &&
+        taskStartedAtMs >= rootStartedAtMs - ROOT_TASK_CLOCK_TOLERANCE_MS;
+}
+function timestampMilliseconds(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value < 1_000_000_000_000 ? value * 1_000 : value;
+    }
+    if (typeof value !== "string" || value.length === 0)
+        return undefined;
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) {
+        return numeric < 1_000_000_000_000 ? numeric * 1_000 : numeric;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 function sum(calls, pick) {
     return calls.reduce((total, call) => total + pick(call), 0);
 }