@agent-finops/core 0.7.3 → 0.8.0

package/dist/localAgentFormats/runtimeRegistry.js

@@ -1,10 +1,12 @@
-import { parseClaudeCodeTranscript, parseCodexRollout, readClaudeCodeFinancialFileForRegistry, readCodexFinancialFileForRegistry } from "../localAgentLogs.js";
+import { parseClaudeCodeTranscript, parseCodexRollout, readClaudeCodeFinancialFileForRegistry, readCodexFinancialFileForRegistry, readGeminiFinancialFileForRegistry } from "../localAgentLogs.js";
 import { createCodexInvocationCollector } from "../toolInvocations.js";
 import { localAgentFormatDescriptors, validateLocalAgentFormatDescriptors } from "./registry.js";
+import { parseGeminiSession } from "./gemini.js";
 const byId = new Map(localAgentFormatDescriptors.map((descriptor) => [descriptor.id, descriptor]));
 const claudeCode = byId.get("claude-code");
 const codex = byId.get("codex");
-if (!claudeCode || !codex) {
+const geminiCli = byId.get("gemini-cli");
+if (!claudeCode || !codex || !geminiCli) {
     throw new Error("Built-in local-agent format descriptors are incomplete.");
 }
 validateLocalAgentFormatDescriptors();
@@ -28,6 +30,27 @@ const runtimes = [
             };
         },
         parseFinancialFile: readCodexFinancialFileForRegistry
+    },
+    {
+        descriptor: geminiCli,
+        parseFull: ({ content, filePath, sinceMs, onDiagnostic }) => {
+            const parsed = parseGeminiSession(content, {
+                filePath,
+                ...(sinceMs !== undefined ? { sinceMs } : {})
+            });
+            for (const diagnostic of parsed.diagnostics) {
+                onDiagnostic({
+                    code: diagnostic.code === "malformed_jsonl"
+                        ? "malformed_jsonl"
+                        : diagnostic.code === "unsupported_token_shape"
+                            ? "unsupported_token_shape"
+                            : "malformed_session_file",
+                    count: diagnostic.count
+                });
+            }
+            return { calls: parsed.calls };
+        },
+        parseFinancialFile: readGeminiFinancialFileForRegistry
     }
 ];
 export const localAgentFormatRuntimeRegistry = Object.freeze(runtimes.map((runtime) => Object.freeze(runtime)));

package/dist/localAgentFormats/types.d.ts

@@ -5,7 +5,7 @@ import type { ParsedInvocationFile } from "../toolInvocations.js";
  * registry-owned change so existing exhaustive consumers do not see an
  * unbounded `string` in a patch release.
  */
-export type LocalAgentFormatId = "claude-code" | "codex";
+export type LocalAgentFormatId = "claude-code" | "codex" | "gemini-cli";
 export type LocalAgentFormatDescriptor = {
     readonly schemaVersion: 1;
     readonly id: LocalAgentFormatId;
@@ -13,11 +13,16 @@ export type LocalAgentFormatDescriptor = {
     readonly label: string;
     readonly provider: string;
     readonly defaultHomeRelative: readonly string[];
-    readonly legacyDirectoryOption?: "claudeProjectsDir" | "codexSessionsDir";
+    readonly legacyDirectoryOption?: "claudeProjectsDir" | "codexSessionsDir" | "geminiSessionsDir";
     readonly discovery: {
         readonly extension?: string;
+        readonly extensions?: readonly string[];
         readonly basename?: string;
         readonly basenamePrefix?: string;
+        /** Required directory name somewhere above a financial evidence file. */
+        readonly ancestorBasename?: string;
+        /** Presence signal only. This file must never reach a financial parser. */
+        readonly detectionBasename?: string;
     };
     readonly confidenceDefaults: {
         readonly validationCoverage: "live_verified" | "fixture_verified" | "untested" | "failed";
@@ -34,6 +39,8 @@ export type LocalAgentFormatDescriptor = {
         readonly operation: string;
     };
     readonly capabilities: {
+        /** May local rows from this source feed recommendation or Apply logic? */
+        readonly actionPlanning: boolean;
         readonly activity: boolean;
         readonly contextHealth: boolean;
         readonly financialFastPath: boolean;
@@ -41,8 +48,10 @@ export type LocalAgentFormatDescriptor = {
         readonly invocationEvidence: boolean;
         readonly planContext: boolean;
         readonly rateLimits: boolean;
+        /** Whether this source is allowed into the fixed Glance/statusline cache. */
+        readonly statuslineSnapshot: boolean;
     };
-    readonly financialRead: "full_jsonl" | "bounded_event_jsonl";
+    readonly financialRead: "full_jsonl" | "bounded_event_jsonl" | "full_session_files";
     readonly validationNote: string;
     readonly docs: {
         readonly format: string;
@@ -62,7 +71,7 @@ export type LocalAgentFormatParseContext = {
     sinceMs?: number;
     collectInvocationEvidence: boolean;
     onDiagnostic: (diagnostic: {
-        code: "malformed_jsonl" | "unsupported_token_shape";
+        code: "malformed_jsonl" | "malformed_session_file" | "unsupported_token_shape";
         count: number;
     }) => void;
 };

package/dist/localAgentLogs.d.ts

@@ -20,6 +20,8 @@ import type { LocalAgentFormatDescriptor, LocalAgentFormatFinancialFileContext,
  */
 export type LocalAgentCall = {
     agent: LocalAgentFormatId;
+    /** Stable source call/message identity when the format safely exposes one. */
+    callId?: string;
     model: string;
     /** ISO timestamp of this call, or the latest cumulative usage event. */
     timestamp: string;
@@ -50,6 +52,18 @@ export type LocalAgentCall = {
     usageSupport?: "complete" | "unsupported_token_shape";
     /** Provider-reported total retained when component fields are unavailable. */
     reportedTotalTokens?: number;
+    /** Optional parser/source version when the evolving session format reports it. */
+    sourceVersion?: string;
+    /** Raw Gemini token split retained for evidence/debugging, never prompt content. */
+    geminiTokenEvidence?: {
+        input?: number;
+        output?: number;
+        cached?: number;
+        thoughts?: number;
+        tool?: number;
+        total?: number;
+        cacheAccounting: "included" | "none" | "unknown";
+    };
     usage: TokenUsage;
     sessionId?: string;
     /** Provider-reported plan windows embedded in the transcript, when present. */
@@ -105,6 +119,8 @@ export type LocalAgentLogOptions = {
     claudeProjectsDir?: string;
     /** Default: ~/.codex/sessions */
     codexSessionsDir?: string;
+    /** Default: ~/.gemini/tmp (financial evidence is bounded to chats files). */
+    geminiSessionsDir?: string;
     /** Registry-native source-root overrides, keyed by format id. */
     sourceDirectories?: Readonly<Partial<Record<LocalAgentFormatId, string>>>;
     /** Only include calls at/after this ISO timestamp. */
@@ -118,7 +134,7 @@ export type LocalAgentLogOptions = {
  * financial snapshot and transcript-reported plan limits.
  */
 export type LocalAgentFinancialLogOptions = Omit<LocalAgentLogOptions, "collectCodexInvocationEvidence">;
-export type LocalAgentLogDiagnosticCode = "directory_missing" | "directory_unreadable" | "file_unreadable" | "malformed_jsonl" | "unsupported_token_shape";
+export type LocalAgentLogDiagnosticCode = "directory_missing" | "directory_unreadable" | "file_unreadable" | "malformed_jsonl" | "malformed_session_file" | "unsupported_token_shape";
 export type LocalAgentLogDiagnostic = {
     agent: LocalAgentCall["agent"];
     code: LocalAgentLogDiagnosticCode;
@@ -136,6 +152,8 @@ export type LocalAgentSourceScan = {
     malformedLines: number;
     unreadableFiles: number;
     unsupportedUsageSnapshots: number;
+    /** Presence-only files such as Gemini CLI logs.json; never financial rows. */
+    detectionSignals?: number;
     /** Regular files safely excluded because their metadata predates `sinceIso`. */
     filesSkippedBeforeWindow?: number;
     /** Codex files resolved from bounded head/tail financial evidence. */
@@ -164,7 +182,7 @@ export type LocalAgentLogResult = {
     codexInvocationFiles?: ParsedInvocationFile[];
 };
 type TranscriptParseDiagnostic = {
-    code: "malformed_jsonl" | "unsupported_token_shape";
+    code: "malformed_jsonl" | "malformed_session_file" | "unsupported_token_shape";
     count: number;
 };
 type TranscriptParseDiagnosticHandler = (diagnostic: TranscriptParseDiagnostic) => void;
@@ -172,9 +190,10 @@ type TranscriptParseDiagnosticHandler = (diagnostic: TranscriptParseDiagnostic)
  * 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.
+ * Turn-scoped calls with a stable session+call identity are also deduplicated
+ * across copied/checkpointed files. Calls without that proof are retained.
  */
-export declare function dedupeCumulativeSessionCalls(calls: LocalAgentCall[]): LocalAgentCall[];
+export declare function dedupeCumulativeSessionCalls(calls: LocalAgentCall[], onStableTurnConflict?: (agent: LocalAgentFormatId) => void): LocalAgentCall[];
 /** Parse one Claude Code transcript (JSONL). Exported for tests. */
 export declare function parseClaudeCodeTranscript(content: string, filePath?: string, sinceMs?: number, onDiagnostic?: TranscriptParseDiagnosticHandler): LocalAgentCall[];
 /** Parse one Codex rollout file (JSONL event stream). Exported for tests. */
@@ -204,6 +223,8 @@ export declare function loadLocalAgentFinancialUsageWithFormats(registry: readon
 export declare function readClaudeCodeFinancialFileForRegistry(context: LocalAgentFormatFinancialFileContext): Promise<LocalAgentCall[]>;
 /** @internal Runtime hook owned by the Codex registry entry. */
 export declare function readCodexFinancialFileForRegistry(context: LocalAgentFormatFinancialFileContext): Promise<LocalAgentCall[]>;
+/** @internal Runtime hook owned by the Gemini CLI registry entry. */
+export declare function readGeminiFinancialFileForRegistry(context: LocalAgentFormatFinancialFileContext): Promise<LocalAgentCall[]>;
 /** Aggregate per-call usage into one UsageRecord per day+agent+model+project. */
 export declare function aggregateCalls(calls: LocalAgentCall[]): UsageRecord[];
 /** @internal Registry-aware aggregation used by the extensible ingestion engine. */

package/dist/localAgentLogs.js

@@ -3,9 +3,10 @@ import { lstat, open, readdir, readFile, stat } from "node:fs/promises";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
-import { estimateTokenCostUsd } from "./modelPricing.js";
+import { canPriceTokenUsageAtScope, estimateTokenCostUsd, estimateTokenCostsUsd, promptTierThreshold, usesPromptTieredPricing } from "./modelPricing.js";
 import { redactSecrets } from "./discovery.js";
-import { localAgentFormatDescriptors, localAgentFormatLabel, matchesLocalAgentFormatFile, validateLocalAgentFormatDescriptors } from "./localAgentFormats/registry.js";
+import { localAgentFormatDescriptors, localAgentFormatLabel, matchesLocalAgentDetectionFile, matchesLocalAgentFormatFile, validateLocalAgentFormatDescriptors } from "./localAgentFormats/registry.js";
+import { parseGeminiSession } from "./localAgentFormats/gemini.js";
 /**
  * Resolve the repository root most recently observed in transcript metadata.
  *
@@ -23,12 +24,42 @@ export function latestObservedWorkingDirectory(calls) {
  * 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.
+ * Turn-scoped calls with a stable session+call identity are also deduplicated
+ * across copied/checkpointed files. Calls without that proof are retained.
  */
-export function dedupeCumulativeSessionCalls(calls) {
+export function dedupeCumulativeSessionCalls(calls, onStableTurnConflict) {
     const retained = [];
     const cumulative = new Map();
+    const stableTurns = new Map();
     for (const call of calls) {
+        if (call.usageScope === "turn" && call.sessionId && call.callId) {
+            const key = `${call.agent}:${call.sessionId}:${call.callId}`;
+            const prior = stableTurns.get(key);
+            if (!prior) {
+                stableTurns.set(key, call);
+            }
+            else if (isStableTurnConflict(prior)) {
+                continue;
+            }
+            else if (isCompleteStableTurn(prior) && isCompleteStableTurn(call) &&
+                stableTurnEvidenceFingerprint(call) !== stableTurnEvidenceFingerprint(prior)) {
+                stableTurns.set(key, conflictingStableTurn(prior, call));
+                onStableTurnConflict?.(call.agent);
+            }
+            else if (!isCompleteStableTurn(prior) && isCompleteStableTurn(call)) {
+                // JSONL/checkpoint copies can preserve an early tokenless snapshot
+                // beside its later complete update. Complete evidence supersedes only
+                // unsupported evidence for the same stable identity.
+                stableTurns.set(key, call);
+            }
+            else if (!isCompleteStableTurn(call) && isCompleteStableTurn(prior)) {
+                continue;
+            }
+            else if (isLaterCumulativeSnapshot(call, prior)) {
+                stableTurns.set(key, call);
+            }
+            continue;
+        }
         if (call.usageScope !== "session_cumulative" || !call.sessionId) {
             retained.push(call);
             continue;
@@ -39,7 +70,47 @@ export function dedupeCumulativeSessionCalls(calls) {
             cumulative.set(key, call);
         }
     }
-    return [...retained, ...cumulative.values()];
+    return [...retained, ...stableTurns.values(), ...cumulative.values()];
+}
+function isCompleteStableTurn(call) {
+    return call.usageSupport !== "unsupported_token_shape";
+}
+function stableTurnEvidenceFingerprint(call) {
+    return JSON.stringify({
+        timestamp: call.timestamp,
+        model: call.model,
+        project: call.project ?? null,
+        workingDirectory: call.workingDirectory ?? null,
+        usageSupport: call.usageSupport ?? null,
+        reportedTotalTokens: call.reportedTotalTokens ?? null,
+        usage: {
+            inputTokens: call.usage.inputTokens,
+            outputTokens: call.usage.outputTokens,
+            cacheReadTokens: call.usage.cacheReadTokens ?? null,
+            cacheWrite5mTokens: call.usage.cacheWrite5mTokens ?? null,
+            cacheWrite1hTokens: call.usage.cacheWrite1hTokens ?? null,
+            thoughtTokens: call.usage.thoughtTokens ?? null,
+            toolTokens: call.usage.toolTokens ?? null
+        },
+        geminiTokenEvidence: call.geminiTokenEvidence ?? null
+    });
+}
+function isStableTurnConflict(call) {
+    return call.model === "conflicting-local-evidence" &&
+        call.usageSupport === "unsupported_token_shape";
+}
+function conflictingStableTurn(left, right) {
+    const call = left.timestamp.localeCompare(right.timestamp) <= 0 ? left : right;
+    return {
+        agent: call.agent,
+        ...(call.callId ? { callId: call.callId } : {}),
+        ...(call.sessionId ? { sessionId: call.sessionId } : {}),
+        model: "conflicting-local-evidence",
+        timestamp: call.timestamp,
+        usageScope: "turn",
+        usageSupport: "unsupported_token_shape",
+        usage: { inputTokens: 0, outputTokens: 0 }
+    };
 }
 function isLaterCumulativeSnapshot(candidate, prior) {
     const timestampOrder = candidate.timestamp.localeCompare(prior.timestamp);
@@ -52,7 +123,9 @@ function totalUsageTokens(usage) {
         usage.outputTokens +
         (usage.cacheReadTokens ?? 0) +
         (usage.cacheWrite5mTokens ?? 0) +
-        (usage.cacheWrite1hTokens ?? 0);
+        (usage.cacheWrite1hTokens ?? 0) +
+        (usage.thoughtTokens ?? 0) +
+        (usage.toolTokens ?? 0);
 }
 function parseClaudeFinancialUsage(value, onDiagnostic) {
     const inputTokens = tokenComponentOf(value.input_tokens);
@@ -609,7 +682,15 @@ export async function loadLocalAgentUsageWithFormats(registry, options = {}) {
             }
         }
     }
-    const normalizedCalls = dedupeCumulativeSessionCalls(calls);
+    const normalizedCalls = dedupeCumulativeSessionCalls(calls, (agent) => {
+        const scan = sourceScans.find((entry) => entry.agent === agent);
+        if (scan) {
+            recordParseDiagnostic(agent, scan, diagnostics, {
+                code: "unsupported_token_shape",
+                count: 1
+            });
+        }
+    });
     const filtered = typeof sinceMs === "number"
         ? normalizedCalls.filter((call) => Date.parse(call.timestamp) >= sinceMs)
         : normalizedCalls;
@@ -666,7 +747,15 @@ export async function loadLocalAgentFinancialUsageWithFormats(registry, options
     // Sources scan concurrently, but flatten in registry order to preserve the
     // long-standing Claude-then-Codex output and diagnostic contract.
     const calls = scanned.flatMap((entry) => entry.calls);
-    const normalizedCalls = dedupeCumulativeSessionCalls(calls);
+    const normalizedCalls = dedupeCumulativeSessionCalls(calls, (agent) => {
+        const source = scanned.find((entry) => entry.scan.agent === agent);
+        if (source) {
+            recordParseDiagnostic(agent, source.scan, source.diagnostics, {
+                code: "unsupported_token_shape",
+                count: 1
+            });
+        }
+    });
     const filtered = typeof sinceMs === "number"
         ? normalizedCalls.filter((call) => Date.parse(call.timestamp) >= sinceMs)
         : normalizedCalls;
@@ -756,6 +845,38 @@ export async function readCodexFinancialFileForRegistry(context) {
     });
     return call ? [call] : [];
 }
+/** @internal Runtime hook owned by the Gemini CLI registry entry. */
+export async function readGeminiFinancialFileForRegistry(context) {
+    const { filePath, sinceMs, scan, diagnostics } = context;
+    if (!await shouldStreamFile(filePath, sinceMs, "gemini-cli", scan, diagnostics)) {
+        return [];
+    }
+    let content;
+    try {
+        content = await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        recordUnreadableFile("gemini-cli", scan, diagnostics, error);
+        return [];
+    }
+    if (!content)
+        return [];
+    scan.filesParsed += 1;
+    const parsed = parseGeminiSession(content, { filePath, ...(sinceMs !== undefined ? { sinceMs } : {}) });
+    for (const diagnostic of parsed.diagnostics) {
+        recordParseDiagnostic("gemini-cli", scan, diagnostics, normalizeGeminiDiagnostic(diagnostic));
+    }
+    return parsed.calls;
+}
+function normalizeGeminiDiagnostic(diagnostic) {
+    if (diagnostic.code === "malformed_jsonl") {
+        return { code: "malformed_jsonl", count: diagnostic.count };
+    }
+    if (diagnostic.code === "unsupported_token_shape") {
+        return { code: "unsupported_token_shape", count: diagnostic.count };
+    }
+    return { code: "malformed_session_file", count: diagnostic.count };
+}
 async function localAgentFormatRuntimes() {
     const module = await import("./localAgentFormats/runtimeRegistry.js");
     return module.localAgentFormatRuntimeRegistry;
@@ -770,6 +891,9 @@ function localAgentFormatRoot(descriptor, options, home) {
     if (descriptor.legacyDirectoryOption === "codexSessionsDir" && options.codexSessionsDir) {
         return options.codexSessionsDir;
     }
+    if (descriptor.legacyDirectoryOption === "geminiSessionsDir" && options.geminiSessionsDir) {
+        return options.geminiSessionsDir;
+    }
     const canonicalHome = resolve(home);
     const root = resolve(canonicalHome, ...descriptor.defaultHomeRelative);
     const fromHome = relative(canonicalHome, root);
@@ -1341,10 +1465,19 @@ export function aggregateCallsForFormats(calls, descriptors) {
             outputTokens: sum(groupCalls, (c) => c.usage.outputTokens),
             cacheReadTokens: sum(groupCalls, (c) => c.usage.cacheReadTokens ?? 0),
             cacheWrite5mTokens: sum(groupCalls, (c) => c.usage.cacheWrite5mTokens ?? 0),
-            cacheWrite1hTokens: sum(groupCalls, (c) => c.usage.cacheWrite1hTokens ?? 0)
+            cacheWrite1hTokens: sum(groupCalls, (c) => c.usage.cacheWrite1hTokens ?? 0),
+            thoughtTokens: sum(groupCalls, (c) => c.usage.thoughtTokens ?? 0),
+            toolTokens: sum(groupCalls, (c) => c.usage.toolTokens ?? 0)
         };
         const usageSupported = groupCalls.every((call) => call.usageSupport !== "unsupported_token_shape");
-        const amountUsd = usageSupported && format ? estimateTokenCostUsd(model, usage) : undefined;
+        const sourceVersions = [...new Set(groupCalls.flatMap((call) => call.sourceVersion ? [call.sourceVersion] : []))].sort().slice(0, 8);
+        const tieredPricingEvidenceSupported = !usesPromptTieredPricing(model) ||
+            groupCalls.every((call) => canPriceTokenUsageAtScope(model, call.usage, call.usageScope === "turn" ? "request" : "aggregate") && (agent !== "gemini-cli" || hasCompleteGeminiPromptEvidence(call)));
+        const amountUsd = usageSupported && tieredPricingEvidenceSupported && format
+            ? usesPromptTieredPricing(model)
+                ? estimateTokenCostsUsd(model, groupCalls.map((call) => call.usage))
+                : estimateTokenCostUsd(model, usage)
+            : undefined;
         const priced = usageSupported && typeof amountUsd === "number";
         records.push({
             id: slug(["local", agent, day, model, project].join("-")),
@@ -1357,8 +1490,27 @@ export function aggregateCallsForFormats(calls, descriptors) {
                 observedFrom: format?.sourceRecord.observedFrom ?? "unregistered local transcript (this machine)"
             },
             model,
-            inputTokens: usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWrite5mTokens ?? 0) + (usage.cacheWrite1hTokens ?? 0),
-            outputTokens: usage.outputTokens,
+            inputTokens: usage.inputTokens + (usage.cacheReadTokens ?? 0) +
+                (usage.cacheWrite5mTokens ?? 0) + (usage.cacheWrite1hTokens ?? 0) +
+                (usage.toolTokens ?? 0),
+            outputTokens: usage.outputTokens + (usage.thoughtTokens ?? 0),
+            ...(agent === "gemini-cli"
+                ? {
+                    ...(groupCalls.every((call) => call.usage.cacheReadTokens !== undefined)
+                        ? { cacheReadTokens: usage.cacheReadTokens ?? 0 }
+                        : {}),
+                    ...(groupCalls.every((call) => call.usage.thoughtTokens !== undefined)
+                        ? { thoughtTokens: usage.thoughtTokens ?? 0 }
+                        : {}),
+                    ...(groupCalls.every((call) => call.usage.toolTokens !== undefined)
+                        ? { toolTokens: usage.toolTokens ?? 0 }
+                        : {}),
+                    ...(groupCalls.every((call) => call.reportedTotalTokens !== undefined)
+                        ? { reportedTotalTokens: sum(groupCalls, (call) => call.reportedTotalTokens ?? 0) }
+                        : {}),
+                    ...(sourceVersions.length > 0 ? { sourceVersions } : {})
+                }
+                : {}),
             amountUsd: priced ? amountUsd : null,
             costConfidence: priced
                 ? format?.confidenceDefaults.pricedFinancialEvidence ?? "estimated"
@@ -1376,6 +1528,47 @@ export function aggregateCallsForFormats(calls, descriptors) {
     }
     return records.sort((left, right) => left.id.localeCompare(right.id));
 }
+function hasCompleteGeminiPromptEvidence(call) {
+    const evidence = call.geminiTokenEvidence;
+    if (call.usageSupport !== "complete" || !evidence ||
+        evidence.cacheAccounting === "unknown") {
+        return false;
+    }
+    const components = [
+        evidence.input,
+        evidence.output,
+        evidence.cached,
+        evidence.thoughts,
+        evidence.tool,
+        evidence.total
+    ];
+    if (!components.every((value) => Number.isSafeInteger(value) && (value ?? -1) >= 0)) {
+        return false;
+    }
+    const input = evidence.input;
+    const output = evidence.output;
+    const cached = evidence.cached;
+    const thoughts = evidence.thoughts;
+    const tool = evidence.tool;
+    const freshInput = evidence.cacheAccounting === "included"
+        ? input - cached
+        : input;
+    const expectedTotal = input + output + thoughts + tool;
+    const threshold = promptTierThreshold(call.model);
+    // Gemini exposes promptTokenCount and toolUsePromptTokenCount separately,
+    // while the published >200k rule does not resolve which side owns tool
+    // prompt tokens. Only price when both interpretations select the same tier.
+    const promptTierIsUnambiguous = threshold === undefined ||
+        input > threshold || input + tool <= threshold;
+    return freshInput >= 0 && Number.isSafeInteger(expectedTotal) &&
+        promptTierIsUnambiguous &&
+        evidence.total === expectedTotal &&
+        call.usage.inputTokens === freshInput &&
+        call.usage.outputTokens === output &&
+        call.usage.cacheReadTokens === cached &&
+        call.usage.thoughtTokens === thoughts &&
+        call.usage.toolTokens === tool;
+}
 async function listFormatCandidateFiles(root, descriptor, scan, diagnostics) {
     let rootStat;
     try {
@@ -1439,13 +1632,16 @@ async function listFormatCandidateFiles(root, descriptor, scan, diagnostics) {
             const path = join(dir, entry.name);
             if (entry.isDirectory())
                 queue.push(path);
-            else if (entry.isFile() && (!descriptor.discovery.extension || entry.name.endsWith(descriptor.discovery.extension))) {
+            else if (entry.isFile() && matchesLocalAgentDetectionFile(descriptor, path)) {
+                scan.detectionSignals = (scan.detectionSignals ?? 0) + 1;
+            }
+            else if (entry.isFile() && matchesLocalAgentFormatFile(descriptor, path)) {
                 out.push(path);
                 scan.filesDiscovered += 1;
             }
         }
     }
-    return out;
+    return out.sort((left, right) => left.localeCompare(right));
 }
 function emptySourceScan(agent) {
     return {
@@ -1469,13 +1665,15 @@ function recordUnreadableFile(agent, scan, diagnostics, error) {
     });
 }
 function recordParseDiagnostic(agent, scan, diagnostics, diagnostic) {
-    if (diagnostic.code === "malformed_jsonl") {
+    if (diagnostic.code === "malformed_jsonl" || diagnostic.code === "malformed_session_file") {
         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.`,
+            message: diagnostic.code === "malformed_jsonl"
+                ? `${diagnostic.count} malformed JSONL line(s) were skipped in ${agentLabel(agent)} transcripts.`
+                : `${diagnostic.count} malformed session file(s) were skipped in ${agentLabel(agent)} transcripts.`,
             count: diagnostic.count
         });
         return;
@@ -1485,7 +1683,7 @@ function recordParseDiagnostic(agent, scan, diagnostics, diagnostic) {
         agent,
         code: diagnostic.code,
         severity: "warning",
-        message: `${diagnostic.count} ${agentLabel(agent)} token snapshot(s) lacked the input/output components required for pricing.`,
+        message: `${diagnostic.count} ${agentLabel(agent)} token snapshot(s) lacked the complete, internally consistent fields required for safe normalization and pricing.`,
         count: diagnostic.count
     });
 }

package/dist/modelPricing.d.ts

@@ -7,7 +7,7 @@
  * matched top-down; first match wins. Unknown models return undefined so
  * callers can label the record "missing" instead of inventing a number.
  */
-export declare const PRICING_TABLE_AS_OF = "2026-07-28";
+export declare const PRICING_TABLE_AS_OF = "2026-08-13";
 export type TokenUsage = {
     /** Billable, uncached input tokens. */
     inputTokens: number;
@@ -15,6 +15,10 @@ export type TokenUsage = {
     cacheReadTokens?: number;
     cacheWrite5mTokens?: number;
     cacheWrite1hTokens?: number;
+    /** Explicit reasoning/thought tokens, priced on the output side when supported. */
+    thoughtTokens?: number;
+    /** Explicit tool prompt tokens, priced on the input side when supported. */
+    toolTokens?: number;
 };
 type PricingRule = {
     match: RegExp;
@@ -25,6 +29,15 @@ type PricingRule = {
     cacheReadPerM?: number;
     cacheWrite5mPerM?: number;
     cacheWrite1hPerM?: number;
+    /** Some providers select one rate for the whole request from prompt size. */
+    abovePromptTokens?: {
+        threshold: number;
+        inputPerM: number;
+        outputPerM: number;
+        cacheReadPerM?: number;
+        cacheWrite5mPerM?: number;
+        cacheWrite1hPerM?: number;
+    };
 };
 export declare function findPricingRule(model: string): PricingRule | undefined;
 /**
@@ -32,5 +45,24 @@ export declare function findPricingRule(model: string): PricingRule | undefined;
  * published price we recognize.
  */
 export declare function estimateTokenCostUsd(model: string, usage: TokenUsage): number | undefined;
+/**
+ * Price request-scoped usage before aggregating it. This is required for
+ * models whose entire request moves to a higher rate above a prompt-size
+ * threshold; pricing a daily token sum would incorrectly treat many small
+ * requests as one large request.
+ */
+export declare function estimateTokenCostsUsd(model: string, usages: readonly TokenUsage[]): number | undefined;
+/** Whether this model's rate selection depends on each request's prompt size. */
+export declare function usesPromptTieredPricing(model: string): boolean;
+/** Prompt-size threshold for tiered request pricing, when one is published. */
+export declare function promptTierThreshold(model: string): number | undefined;
+/**
+ * Tiered prices are selected per request, never from a multi-request sum.
+ * An aggregate is still unambiguous when its entire non-negative prompt-side
+ * total is at or below the threshold; then no constituent request can have
+ * crossed it. Larger aggregates fail closed until request-level evidence is
+ * available.
+ */
+export declare function canPriceTokenUsageAtScope(model: string, usage: TokenUsage, scope: "request" | "aggregate"): boolean;
 export {};
 //# sourceMappingURL=modelPricing.d.ts.map