@agent-finops/core 0.9.7 → 0.9.9

package/dist/localAgentLogs.d.ts

@@ -416,7 +416,10 @@ export declare const SAFE_QUALITATIVE_SCAN_POLICY: Readonly<LocalAgentQualitativ
  * intentionally unavailable: this path reads only the evidence needed for a
  * financial snapshot and transcript-reported plan limits.
  */
-export type LocalAgentFinancialLogOptions = Omit<LocalAgentLogOptions, "collectCodexInvocationEvidence" | "qualitativeScan" | "qualitativeIndex" | "ownershipIndex" | "coverageProjectRef">;
+export type LocalAgentFinancialLogOptions = Omit<LocalAgentLogOptions, "collectCodexInvocationEvidence" | "qualitativeScan" | "qualitativeIndex" | "ownershipIndex" | "coverageProjectRef"> & {
+    /** Explicit Workspace lane: Codex counter deltas at each UTC event, never lifetime totals on the last day. */
+    workspaceDailyFacts?: boolean;
+};
 export type LocalAgentLogDiagnosticCode = "directory_missing" | "directory_unreadable" | "file_unreadable" | "malformed_jsonl" | "malformed_session_file" | "unsupported_token_shape" | "qualitative_scan_incomplete" | "qualitative_index_error";
 export type LocalAgentLogDiagnostic = {
     agent: LocalAgentCall["agent"];
@@ -582,7 +585,7 @@ export declare function loadLocalAgentFinancialUsage(options?: LocalAgentFinanci
 /** Registry-driven financial-only engine; package-root exports stay unchanged. */
 export declare function loadLocalAgentFinancialUsageWithFormats(registry: readonly LocalAgentFormatRuntime[], options?: LocalAgentFinancialLogOptions): Promise<LocalAgentLogResult>;
 /** @internal Runtime hook owned by the Claude Code registry entry. */
-export declare function readClaudeCodeFinancialFileForRegistry(context: LocalAgentFormatFinancialFileContext): Promise<LocalAgentCall[]>;
+export declare function readClaudeCodeFinancialFileForRegistry(context: LocalAgentFormatFinancialFileContext, workspaceDailyFacts?: boolean): 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. */

package/dist/localAgentLogs.js

@@ -228,6 +228,20 @@ function parseClaudeFinancialUsage(value, onDiagnostic) {
     const write1hField = cacheCreation
         ? optionalTokenComponent(cacheCreation, "ephemeral_1h_input_tokens")
         : { present: false };
+    const writeTotal = writeTotalField.value;
+    let write5m = write5mField.value;
+    let write1h = write1hField.value;
+    const writeSplitConsistent = writeTotal === undefined || ((write5m === undefined || write5m <= writeTotal) &&
+        (write1h === undefined || write1h <= writeTotal) &&
+        (write5m === undefined || write1h === undefined || write5m + write1h === writeTotal));
+    // A total plus one disjoint duration determines the other duration. Never
+    // add the entire total to the supplied duration or invent a negative split.
+    if (writeTotal !== undefined && writeSplitConsistent) {
+        if (write5m === undefined && write1h !== undefined)
+            write5m = writeTotal - write1h;
+        else if (write1h === undefined && write5m !== undefined)
+            write1h = writeTotal - write5m;
+    }
     const componentsSupported = inputTokens !== undefined &&
         outputTokens !== undefined &&
         (!cacheReadField.present || cacheReadField.value !== undefined) &&
@@ -235,16 +249,18 @@ function parseClaudeFinancialUsage(value, onDiagnostic) {
         (!reportedTotalField.present || reportedTotalField.value !== undefined) &&
         (!cacheCreationPresent || Boolean(cacheCreation)) &&
         (!write5mField.present || write5mField.value !== undefined) &&
-        (!write1hField.present || write1hField.value !== undefined);
+        (!write1hField.present || write1hField.value !== undefined) &&
+        writeSplitConsistent;
     const usage = {
         // Retain every valid component for partial evidence, but never let a
         // missing/invalid required field become a priceable zero-dollar call.
         inputTokens: inputTokens ?? 0,
         outputTokens: outputTokens ?? 0,
         cacheReadTokens: cacheReadField.value ?? 0,
-        // Prefer the 5m/1h breakdown; fall back to the total as 5m (cheaper bound).
-        cacheWrite5mTokens: write5mField.value ?? writeTotalField.value ?? 0,
-        cacheWrite1hTokens: write1hField.value ?? 0
+        // With no duration split at all, keep the existing cheaper-bound estimate.
+        // Partial evidence without a total remains partial, never a complete sum.
+        cacheWrite5mTokens: write5m ?? (write1h === undefined ? writeTotal : undefined) ?? 0,
+        cacheWrite1hTokens: write1h ?? 0
     };
     if (componentsSupported) {
         const cacheWriteEvidence = writeTotalField.value !== undefined ||
@@ -1327,6 +1343,11 @@ export async function loadLocalAgentFinancialUsage(options = {}) {
 /** Registry-driven financial-only engine; package-root exports stay unchanged. */
 export async function loadLocalAgentFinancialUsageWithFormats(registry, options = {}) {
     validateLocalAgentFormatDescriptors(registry.map((entry) => entry.descriptor));
+    // Cumulative financial caches cannot supply event-day deltas. Keep their semantics unchanged.
+    if (options.workspaceDailyFacts) {
+        options = { ...options, financialIndex: undefined };
+        registry = registry.filter(runtime => runtime.descriptor.id === "claude-code" || runtime.descriptor.id === "codex");
+    }
     const home = homedir();
     const since = options.sinceIso ? Date.parse(options.sinceIso) : undefined;
     const sinceMs = typeof since === "number" && Number.isFinite(since) ? since : undefined;
@@ -1401,12 +1422,12 @@ export async function loadLocalAgentFinancialUsageWithFormats(registry, options
             const diagnosticsBefore = diagnostics.length;
             const unreadableBefore = scan.unreadableFiles;
             const filesParsedBefore = scan.filesParsed;
-            const parsedCalls = await runtime.parseFinancialFile({
-                filePath: file,
-                sinceMs,
-                scan,
-                diagnostics
-            });
+            const context = { filePath: file, sinceMs, scan, diagnostics };
+            const parsedCalls = options.workspaceDailyFacts && descriptor.id === "codex"
+                ? await readCodexDailyFinancialFile(context)
+                : options.workspaceDailyFacts && descriptor.id === "claude-code"
+                    ? await readClaudeCodeFinancialFileForRegistry(context, true)
+                    : await runtime.parseFinancialFile(context);
             assertFormatCallOwnership(descriptor, parsedCalls);
             assertFinancialSourceOwnership(descriptor, scan, diagnostics);
             calls.push(...parsedCalls);
@@ -1588,7 +1609,7 @@ function codexHeaderAttribution(header) {
     };
 }
 /** @internal Runtime hook owned by the Claude Code registry entry. */
-export async function readClaudeCodeFinancialFileForRegistry(context) {
+export async function readClaudeCodeFinancialFileForRegistry(context, workspaceDailyFacts = false) {
     const { filePath, sinceMs, scan, diagnostics } = context;
     if (!await shouldStreamFile(filePath, sinceMs, "claude-code", scan, diagnostics)) {
         return [];
@@ -1604,8 +1625,16 @@ export async function readClaudeCodeFinancialFileForRegistry(context) {
             // file so a narrow-window run can never truncate a wider one. The
             // loader's final timestamp filter performs all narrowing.
             undefined, seen, (diagnostic) => fileDiagnostics.push(diagnostic));
-            if (call)
+            if (call) {
+                if (workspaceDailyFacts) {
+                    const nativeAgent = stringOf(entry.agentId);
+                    const pathAgent = filePath.split(sep).includes("subagents")
+                        ? basename(filePath).match(/^agent-([A-Za-z0-9_-]+)\.jsonl$/)?.[1] : undefined;
+                    if (nativeAgent || pathAgent)
+                        call.subagentId = nativeAgent ?? pathAgent;
+                }
                 calls.push(call);
+            }
         });
     }
     catch (error) {
@@ -1668,6 +1697,77 @@ export async function readCodexFinancialFileForRegistry(context) {
     });
     return call ? [call] : [];
 }
+/** Workspace-only event deltas. The existing snapshot reader remains cumulative. */
+async function readCodexDailyFinancialFile(context) {
+    const { filePath, sinceMs, scan, diagnostics } = context;
+    if (!await shouldStreamFile(filePath, sinceMs, "codex", scan, diagnostics))
+        return [];
+    const state = createCodexFinancialStreamState(), calls = [];
+    const report = () => recordParseDiagnostic("codex", scan, diagnostics, { code: "unsupported_token_shape", count: 1 });
+    let priorEventAt;
+    try {
+        const streamed = await streamJsonlRecords(filePath, entry => {
+            const payload = isRecord(entry.payload) ? entry.payload : undefined;
+            const previousTotal = state.lastTotal ?? state.inheritedUsageBaseline;
+            consumeCodexFinancialEntry(state, entry);
+            if (entry.type !== "event_msg" || payload?.type !== "token_count"
+                || state.hasInheritedHistory && !state.rootTaskStarted)
+                return;
+            const info = isRecord(payload.info) ? payload.info : undefined;
+            const total = info && isRecord(info.total_token_usage) ? info.total_token_usage : undefined;
+            if (!total) {
+                // A usage-bearing event without its cumulative endpoint cannot be
+                // placed safely: a later counter may span this event's UTC day.
+                if (info && isRecord(info.last_token_usage))
+                    report();
+                return;
+            }
+            const timestamp = toIso(stringOf(entry.timestamp));
+            if (!timestamp || !state.sessionId) {
+                report();
+                return;
+            }
+            const parsed = parseCodexCumulativeUsage(total, previousTotal);
+            // Missing initial history cannot be assigned to a later day. A changed or
+            // decreasing counter remains unknown at that event; the next exact pair
+            // can establish a delta without pretending the reset was a zero.
+            const firstDayKnown = !!previousTotal || !!state.startedAt && state.startedAt.slice(0, 10) === timestamp.slice(0, 10);
+            const chronological = !priorEventAt || timestamp >= priorEventAt;
+            const cachedShapeStable = !previousTotal ||
+                Object.hasOwn(total, "cached_input_tokens") === Object.hasOwn(previousTotal, "cached_input_tokens");
+            const supported = parsed.supported && firstDayKnown && chronological && cachedShapeStable;
+            priorEventAt = timestamp;
+            if (supported && previousTotal && parsed.usage.inputTokens === 0 && parsed.usage.outputTokens === 0
+                && (parsed.usage.cacheReadTokens ?? 0) === 0 && (parsed.reportedTotalTokens ?? 0) === 0)
+                return;
+            if (!supported)
+                report();
+            const workingDirectory = absoluteWorkingDirectory(state.rootCwd);
+            // The cumulative endpoint fingerprint is stable across copies of a
+            // rollout. Different deltas for that same endpoint become a conflict in
+            // dedupeCumulativeSessionCalls rather than two financial contributions.
+            const callId = `callref_${createHash("sha256").update("codex-workspace-counter-event-v1\0")
+                .update(JSON.stringify([state.sessionId, timestamp, total.input_tokens ?? null,
+                total.output_tokens ?? null, total.cached_input_tokens ?? null, total.total_tokens ?? null])).digest("hex")}`;
+            calls.push({ agent: "codex", sessionId: state.sessionId, callId,
+                model: state.model ?? "codex", timestamp, startedAt: timestamp,
+                project: projectFromCwd(workingDirectory), workingDirectory,
+                usageScope: "turn", usageSupport: supported ? "complete" : "unsupported_token_shape",
+                usage: parsed.usage,
+                ...(supported && parsed.tokenComponentEvidence ? { tokenComponentEvidence: parsed.tokenComponentEvidence } : {}),
+                ...(parsed.reportedTotalTokens !== undefined ? { reportedTotalTokens: parsed.reportedTotalTokens } : {}) });
+        });
+        if (streamed.hadContent)
+            scan.filesParsed++;
+        if (streamed.malformedLines)
+            recordParseDiagnostic("codex", scan, diagnostics, { code: "malformed_jsonl", count: streamed.malformedLines });
+        return calls;
+    }
+    catch (error) {
+        recordUnreadableFile("codex", scan, diagnostics, error);
+        return [];
+    }
+}
 /** @internal Runtime hook owned by the Gemini CLI registry entry. */
 export async function readGeminiFinancialFileForRegistry(context) {
     const { filePath, sinceMs, scan, diagnostics } = context;

package/dist/modelPricing.js

@@ -10,6 +10,9 @@
 export const PRICING_TABLE_AS_OF = "2026-08-25";
 const pricingRules = [
     // Anthropic
+    // Reviewed 2026-09-20: platform.claude.com/docs/en/about-claude/pricing.
+    // Fable/Mythos 5.1 keep base/write rates; cache reads are $0.25 per MTok.
+    { match: /^claude-(?:fable|mythos)-5-1$/i, inputPerM: 10, outputPerM: 50, cacheReadPerM: 0.25 },
     { match: /^claude-fable-5/i, inputPerM: 10, outputPerM: 50 },
     { match: /^claude-mythos-5/i, inputPerM: 10, outputPerM: 50 },
     { match: /^claude-opus-5/i, inputPerM: 5, outputPerM: 25 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-finops/core",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "funding": "https://asktilden.com",
   "type": "module",
   "main": "./dist/index.js",