@agent-finops/core 0.9.4 → 0.9.6

package/dist/actionVerification.d.ts

@@ -673,10 +673,10 @@ declare const experimentBodySchema: z.ZodObject<{
     }, z.core.$strict>>;
     invalidation: z.ZodOptional<z.ZodObject<{
         reason: z.ZodEnum<{
-            manual: "manual";
             scope_changed: "scope_changed";
             source_semantics_changed: "source_semantics_changed";
             concurrent_change: "concurrent_change";
+            manual: "manual";
         }>;
         invalidatedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     }, z.core.$strict>>;
@@ -1115,10 +1115,10 @@ declare const experimentObjectSchema: z.ZodObject<{
     }, z.core.$strict>>;
     invalidation: z.ZodOptional<z.ZodObject<{
         reason: z.ZodEnum<{
-            manual: "manual";
             scope_changed: "scope_changed";
             source_semantics_changed: "source_semantics_changed";
             concurrent_change: "concurrent_change";
+            manual: "manual";
         }>;
         invalidatedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     }, z.core.$strict>>;

package/dist/activitySnapshot.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { aggregateCalls, dedupeCumulativeSessionCalls } from "./localAgentLogs.js";
 import { localAgentFormatDescriptors } from "./localAgentFormats/registry.js";
-import { canPriceTokenUsageAtScope, estimateTokenCostUsd, PRICING_TABLE_AS_OF } from "./modelPricing.js";
+import { canPriceTokenUsageAtScope, estimateTokenCostsUsd, PRICING_TABLE_AS_OF } from "./modelPricing.js";
 import { subscriptionPlans } from "./planMath.js";
 import { isBundledSampleUsage } from "./schema.js";
 import { sourceValidationCoverageValues } from "./sourceStatus.js";
@@ -937,13 +937,22 @@ function apiEquivalentObservations(records, calls, trustedProviderIds) {
     }
     return observations;
 }
+/**
+ * One call's API-equivalent cost with its tier taken from the largest single
+ * request it contains, matching the report's aggregation. Weighting a
+ * session-cumulative slice at its own cache-inflated prompt would put it on the
+ * wrong tier and skew the allocation.
+ */
+function callAmountUsd(call) {
+    return estimateTokenCostsUsd(call.model, [call.usage], [call.maxRequestPromptTokens]);
+}
 function allocateAggregateAmount(amountUsd, calls) {
     if (amountUsd === null)
         return calls.map(() => null);
-    const priceable = calls.map((call) => canPriceTokenUsageAtScope(call.model, call.usage, call.usageScope === "turn" ? "request" : "aggregate") && estimateTokenCostUsd(call.model, call.usage) !== undefined);
+    const priceable = calls.map((call) => canPriceTokenUsageAtScope(call.model, call.usage, call.usageScope === "turn" ? "request" : "aggregate", call.maxRequestPromptTokens) && callAmountUsd(call) !== undefined);
     if (priceable.some((supported) => !supported))
         return calls.map(() => null);
-    const weights = calls.map((call) => estimateTokenCostUsd(call.model, call.usage) ?? 0);
+    const weights = calls.map((call) => callAmountUsd(call) ?? 0);
     const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
     if (totalWeight <= 0) {
         return amountUsd === 0 ? calls.map(() => 0) : calls.map(() => null);

package/dist/glance.js

@@ -1,5 +1,5 @@
 import { dedupeCumulativeSessionCalls, sanitizeLocalActivityText } from "./localAgentLogs.js";
-import { canPriceTokenUsageAtScope, estimateTokenCostUsd, PRICING_TABLE_AS_OF } from "./modelPricing.js";
+import { canPriceTokenUsageAtScope, estimateTokenCostsUsd, PRICING_TABLE_AS_OF } from "./modelPricing.js";
 import { subscriptionPlans } from "./planMath.js";
 import { buildContextHealth } from "./contextHealth.js";
 import { localAgentFormatDescriptors, localAgentFormatSupports } from "./localAgentFormats/registry.js";
@@ -106,7 +106,7 @@ export function buildUsageGlance(calls, options = {}) {
         "Claude Code transcripts do not report plan headroom. Missing limits remain unavailable instead of being inferred.",
         "Cursor and GitHub Copilot require their provider connections because their local chat stores are not treated as authoritative billing transcripts.",
         ...(qualitativeComplete ? [] : [
-            "Main focus, anomaly, and context-change handoff are unavailable because the bounded qualitative index is incomplete; no global driver was inferred from a selected subset."
+            "Main focus, anomaly, and context-change handoff are unavailable because some session transcripts have not been read yet; no global driver was inferred from a partly-read subset."
         ])
     ];
     return {
@@ -202,10 +202,10 @@ function buildCoverageLimitedPrimaryAction(input) {
         kind: "session_handoff",
         intent: "inspect_current_work",
         label: project ? `Refresh evidence · ${project}` : "Refresh evidence",
-        detail: `Main focus unavailable · qualitative index ${status}`,
+        detail: `Main focus unavailable · session transcripts ${status === "partial" ? "only partly read" : "not available"}`,
         ...(project ? { project } : {}),
         agentPrompt: [
-            "aibill's bounded qualitative evidence is incomplete.",
+            "Some coding-agent session transcripts have not been read yet.",
             "Do not infer a global main focus, waste cause, or context change from the selected subset.",
             `Run \`${aibillImproveCommandV0()}\` from the exact project root to refresh the private index, then review the new evidence before editing.`
         ].join("\n"),
@@ -793,9 +793,13 @@ function limitActionName(limit) {
 function callCost(call) {
     if (call.usageSupport === "unsupported_token_shape")
         return undefined;
-    if (!canPriceTokenUsageAtScope(call.model, call.usage, call.usageScope === "turn" ? "request" : "aggregate"))
+    if (!canPriceTokenUsageAtScope(call.model, call.usage, call.usageScope === "turn" ? "request" : "aggregate", call.maxRequestPromptTokens))
         return undefined;
-    return estimateTokenCostUsd(call.model, call.usage);
+    // Tier must come from the largest single request, exactly as the report's
+    // aggregation does — otherwise the statusline and the receipt disagree on
+    // the same session (a cache-heavy Codex session voided here while the
+    // receipt prices it, or priced here at 2x).
+    return estimateTokenCostsUsd(call.model, [call.usage], [call.maxRequestPromptTokens]);
 }
 function inputSideTokens(call) {
     return call.usage.inputTokens +

package/dist/localAgentLogs.d.ts

@@ -49,6 +49,16 @@ export type LocalAgentCall = {
     latestTurnUsage?: LocalAgentTurnUsage;
     /** Whether `usage` is one model turn or the session's cumulative financial total. */
     usageScope?: "turn" | "session_cumulative";
+    /**
+     * Largest single-request prompt (effective input, cache reads included)
+     * observed within a `session_cumulative` `usage`. Tiered per-request pricing
+     * is selected per request, never from a cumulative sum: a cache-heavy session
+     * routinely clears a per-request tier threshold in aggregate while no single
+     * request did. This evidence lets pricing keep such a total on the base tier
+     * (exact) instead of failing closed to "missing". Absent for turn-scoped
+     * calls, which are already a single request.
+     */
+    maxRequestPromptTokens?: number;
     /**
      * Whether the transcript exposed the input/output components required for
      * pricing. A total-only snapshot is still usage evidence, but pricing it as
@@ -374,7 +384,7 @@ export type LocalAgentStreamCheckpointAdapter = {
     writeStreamCheckpoint: (agent: LocalAgentFormatId, pathHash: string, checkpoint: Readonly<LocalAgentStreamCheckpointRecord>) => Promise<void>;
     deleteStreamCheckpoint: (agent: LocalAgentFormatId, pathHash: string) => Promise<void>;
 };
-export declare const localAgentFinancialParserVersion = 1;
+export declare const localAgentFinancialParserVersion = 3;
 /**
  * Qualitative parser contract version. Bumped to 2 with the checkpointed
  * streaming path (A4b): entries and checkpoints written by the pre-streaming
@@ -385,9 +395,15 @@ export declare const localAgentFinancialParserVersion = 1;
  * cross-file completion evidence (`subagentCompletions`, from both Task tool
  * results and background task-notifications): entries persisted by the
  * collapsing parser must re-parse rather than silently keep merging subagent
- * runs into their parent session.
+ * runs into their parent session. Bumped to 5 when Codex reducer checkpoints
+ * gained `maxTurnPromptTokens` (largest single request): a checkpoint written
+ * by v4 lacks the running per-request maximum, so restoring it could under-read
+ * the tier evidence for a cumulative session that crossed the boundary — a
+ * version mismatch discards it and re-parses from scratch instead. Bumped to 6
+ * with the user-fork inherited-baseline fix: v5 entries and checkpoints treated
+ * a fork's replayed parent history as the child's own usage and activity.
  */
-export declare const localAgentQualitativeParserVersion = 4;
+export declare const localAgentQualitativeParserVersion = 6;
 /**
  * Conservative launch defaults for action-capable qualitative evidence.
  * Callers must still inspect `qualitativeCoverage` before deriving a finding:

package/dist/localAgentLogs.js

@@ -22,7 +22,15 @@ export function latestObservedWorkingDirectory(calls) {
         .sort((left, right) => right.timestamp.localeCompare(left.timestamp))[0]
         ?.workingDirectory;
 }
-export const localAgentFinancialParserVersion = 1;
+// Bumped to 2 when session-cumulative Codex calls gained `maxRequestPromptTokens`
+// (largest single request in the session). Financial caches written by v1 lack
+// this per-request tier evidence, so a >272K-cumulative Codex session would
+// stay voided to "missing" on reuse; a version mismatch re-parses instead.
+// Bumped to 3 when user forks (`forked_from_id`) started resetting their
+// inherited baseline: v2 entries priced a fork's replayed parent history as
+// the child's own usage, so those cached amounts are overstated and must not
+// be reused.
+export const localAgentFinancialParserVersion = 3;
 /**
  * Qualitative parser contract version. Bumped to 2 with the checkpointed
  * streaming path (A4b): entries and checkpoints written by the pre-streaming
@@ -33,9 +41,15 @@ export const localAgentFinancialParserVersion = 1;
  * cross-file completion evidence (`subagentCompletions`, from both Task tool
  * results and background task-notifications): entries persisted by the
  * collapsing parser must re-parse rather than silently keep merging subagent
- * runs into their parent session.
+ * runs into their parent session. Bumped to 5 when Codex reducer checkpoints
+ * gained `maxTurnPromptTokens` (largest single request): a checkpoint written
+ * by v4 lacks the running per-request maximum, so restoring it could under-read
+ * the tier evidence for a cumulative session that crossed the boundary — a
+ * version mismatch discards it and re-parses from scratch instead. Bumped to 6
+ * with the user-fork inherited-baseline fix: v5 entries and checkpoints treated
+ * a fork's replayed parent history as the child's own usage and activity.
  */
-export const localAgentQualitativeParserVersion = 4;
+export const localAgentQualitativeParserVersion = 6;
 /**
  * Conservative launch defaults for action-capable qualitative evidence.
  * Callers must still inspect `qualitativeCoverage` before deriving a finding:
@@ -384,6 +398,42 @@ function parseCodexTurnUsage(value) {
         }
     };
 }
+/**
+ * The tier-relevant prompt size of one Codex `last_token_usage` turn: its full
+ * request input (Codex `input_tokens` already includes cached input), which is
+ * exactly `effectivePromptTokens` of the parsed turn usage. Returned only when
+ * the field parses to a non-negative number, so an unreadable turn never lowers
+ * a running maximum. Used to prove whether any single request in a cumulative
+ * session crossed a per-request tier threshold.
+ */
+function codexTurnPromptTokens(turn) {
+    const input = tokenComponentOf(turn.input_tokens);
+    return input === undefined ? undefined : input;
+}
+/**
+ * Whether a Codex rollout replays another session's history before its own
+ * work, so the cumulative counter at its first real task is an inherited
+ * baseline rather than this session's usage.
+ *
+ * TWO kinds of rollout do this, and only the first was recognized before:
+ *  - subagent rollouts (`thread_source: "subagent"`, or a `source.subagent`);
+ *  - USER FORKS (`forked_from_id`), which carry `thread_source: "user"` and
+ *    replay the parent transcript verbatim. Observed: a forked rollout whose
+ *    first 9,051 of 9,442 token_count events are byte-identical copies of the
+ *    parent's, all with earlier parent timestamps, carrying 1,204,265,192 of
+ *    its 1,256,637,395 final cumulative input tokens (95.9%) — parent usage
+ *    that was being billed again under the child, and again down each fork
+ *    chain.
+ *
+ * This is deliberately NOT folded into `isSubagent`: that flag also drives
+ * activity attribution and checkpoint identity, where a user fork is a normal
+ * user session and must not be relabelled a subagent.
+ */
+function codexHasInheritedHistory(payload) {
+    return stringOf(payload.thread_source) === "subagent" ||
+        isRecord(payload.source) && "subagent" in payload.source ||
+        stringOf(payload.forked_from_id) !== undefined;
+}
 /** Parse one Claude Code transcript (JSONL). Exported for tests. */
 export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDiagnostic) {
     const calls = [];
@@ -634,6 +684,7 @@ function createCodexRolloutParserState() {
         fileCounts: new Map(),
         toolCallCount: 0,
         isSubagent: false,
+        hasInheritedHistory: false,
         malformedLines: 0
     };
 }
@@ -666,6 +717,7 @@ function consumeCodexRolloutLine(state, line, onEntry) {
         state.rootStartedAtMs = timestampMilliseconds(payload.timestamp ?? entry.timestamp);
         state.isSubagent = stringOf(payload.thread_source) === "subagent" ||
             isRecord(payload.source) && "subagent" in payload.source;
+        state.hasInheritedHistory = codexHasInheritedHistory(payload);
         state.parentSessionId = stringOf(payload.parent_thread_id);
     }
     if (entry.type === "turn_context" && payload) {
@@ -677,7 +729,7 @@ function consumeCodexRolloutLine(state, line, onEntry) {
             state.rootCwd = stringOf(payload.cwd);
         }
     }
-    if (state.isSubagent &&
+    if (state.hasInheritedHistory &&
         !state.rootTaskStarted &&
         payload?.type === "task_started" &&
         isRootSpecificTaskStart(payload.started_at, state.rootStartedAtMs)) {
@@ -688,6 +740,11 @@ function consumeCodexRolloutLine(state, line, onEntry) {
         // prompts/files cannot become the child's focus. Restored checkpoint
         // evidence predating the boundary is parent history too and resets with
         // it (the raw session cwd deliberately survives, exactly as rootCwd).
+        //
+        // Replayed task_started events keep the PARENT's original started_at, so
+        // `isRootSpecificTaskStart` rejects them and the first accepted task is
+        // this session's own — which is why the boundary lands exactly at the end
+        // of the replay.
         state.inheritedUsageBaseline = state.lastTotal;
         state.lastTotal = undefined;
         state.rootTaskStarted = true;
@@ -699,10 +756,11 @@ function consumeCodexRolloutLine(state, line, onEntry) {
         state.toolCallCount = 0;
         state.model = undefined;
         state.lastTurn = undefined;
+        state.maxTurnPromptTokens = undefined;
         state.lastRateLimits = undefined;
         state.lastActivityAt = toIso(stringOf(entry.timestamp)) ?? state.startedAt;
     }
-    if (payload?.type === "task_started" && (!state.isSubagent || state.rootTaskStarted)) {
+    if (payload?.type === "task_started" && (!state.hasInheritedHistory || state.rootTaskStarted)) {
         state.pendingTaskTurnId = stringOf(payload.turn_id);
         state.completedTask = undefined;
     }
@@ -757,6 +815,10 @@ function consumeCodexRolloutLine(state, line, onEntry) {
         if (turn) {
             state.lastTurn = turn;
             state.lastActivityAt = eventTimestamp;
+            const turnPrompt = codexTurnPromptTokens(turn);
+            if (turnPrompt !== undefined) {
+                state.maxTurnPromptTokens = Math.max(state.maxTurnPromptTokens ?? 0, turnPrompt);
+            }
         }
         const rateLimits = parseCodexRateLimits(payload.rate_limits, eventTimestamp);
         if (rateLimits) {
@@ -774,7 +836,7 @@ function finishCodexRolloutParse(state, onDiagnostic) {
     if (state.malformedLines > 0) {
         onDiagnostic?.({ code: "malformed_jsonl", count: state.malformedLines });
     }
-    if (!state.lastTotal || state.isSubagent && !state.rootTaskStarted)
+    if (!state.lastTotal || state.hasInheritedHistory && !state.rootTaskStarted)
         return [];
     const parsedUsage = parseCodexCumulativeUsage(state.lastTotal, state.inheritedUsageBaseline);
     const parsedTurn = state.lastTurn
@@ -834,6 +896,9 @@ function finishCodexRolloutParse(state, onDiagnostic) {
                 : {}),
             usageScope: "session_cumulative",
             usageSupport,
+            ...(usageSupport === "complete" && state.maxTurnPromptTokens !== undefined
+                ? { maxRequestPromptTokens: state.maxTurnPromptTokens }
+                : {}),
             ...(parsedUsage.reportedTotalTokens !== undefined
                 ? { reportedTotalTokens: parsedUsage.reportedTotalTokens }
                 : {}),
@@ -1999,6 +2064,7 @@ function serializeCodexReducerState(state) {
         ...(state.rootStartedAtMs !== undefined ? { rootStartedAtMs: state.rootStartedAtMs } : {}),
         rootTaskStarted: state.rootTaskStarted,
         isSubagent: state.isSubagent,
+        hasInheritedHistory: state.hasInheritedHistory,
         ...(state.parentSessionId !== undefined ? { parentSessionId: state.parentSessionId } : {}),
         ...(state.pendingTaskTurnId !== undefined ? { pendingTaskTurnId: state.pendingTaskTurnId } : {}),
         ...(state.completedTask !== undefined ? { completedTask: state.completedTask } : {}),
@@ -2006,6 +2072,9 @@ function serializeCodexReducerState(state) {
         ...(state.lastActivityAt !== undefined ? { lastActivityAt: state.lastActivityAt } : {}),
         ...(state.lastTotal !== undefined ? { lastTotal: state.lastTotal } : {}),
         ...(state.lastTurn !== undefined ? { lastTurn: state.lastTurn } : {}),
+        ...(state.maxTurnPromptTokens !== undefined
+            ? { maxTurnPromptTokens: state.maxTurnPromptTokens }
+            : {}),
         ...(state.inheritedUsageBaseline !== undefined
             ? { inheritedUsageBaseline: state.inheritedUsageBaseline }
             : {}),
@@ -2050,6 +2119,8 @@ function isPersistedCodexReducerState(value) {
     return typeof value.rootSessionMetaSeen === "boolean" &&
         typeof value.rootTaskStarted === "boolean" &&
         typeof value.isSubagent === "boolean" &&
+        (value.hasInheritedHistory === undefined ||
+            typeof value.hasInheritedHistory === "boolean") &&
         optionalString(value.model) &&
         optionalString(value.sessionId) &&
         optionalString(value.sourceVersion) &&
@@ -2062,6 +2133,7 @@ function isPersistedCodexReducerState(value) {
         optionalString(value.lastActivityAt) &&
         optionalRecord(value.lastTotal) &&
         optionalRecord(value.lastTurn) &&
+        optionalFinite(value.maxTurnPromptTokens) &&
         optionalRecord(value.inheritedUsageBaseline) &&
         validRateLimits &&
         validRootCwd &&
@@ -2084,6 +2156,10 @@ function restoreCodexReducerState(persisted) {
     state.rootStartedAtMs = persisted.rootStartedAtMs;
     state.rootTaskStarted = persisted.rootTaskStarted;
     state.isSubagent = persisted.isSubagent;
+    // Pre-fork-fix checkpoints carry no flag; fall back to the subagent bit so a
+    // restored subagent keeps its boundary (a restored user fork re-parses, its
+    // parser version having changed).
+    state.hasInheritedHistory = persisted.hasInheritedHistory ?? persisted.isSubagent;
     state.parentSessionId = persisted.parentSessionId;
     state.pendingTaskTurnId = persisted.pendingTaskTurnId;
     state.completedTask = persisted.completedTask;
@@ -2091,6 +2167,7 @@ function restoreCodexReducerState(persisted) {
     state.lastActivityAt = persisted.lastActivityAt;
     state.lastTotal = persisted.lastTotal;
     state.lastTurn = persisted.lastTurn;
+    state.maxTurnPromptTokens = persisted.maxTurnPromptTokens;
     state.inheritedUsageBaseline = persisted.inheritedUsageBaseline;
     state.lastRateLimits = persisted.lastRateLimits;
     state.restoredRootCwd = persisted.rootCwd;
@@ -2726,8 +2803,11 @@ async function readCodexFinancialFile(file) {
         const rootPayload = rootEntry?.type === "session_meta" && isRecord(rootEntry.payload)
             ? rootEntry.payload
             : undefined;
-        const isSubagent = Boolean(rootPayload) && (stringOf(rootPayload?.thread_source) === "subagent" ||
-            isRecord(rootPayload?.source) && "subagent" in rootPayload.source);
+        // A rollout that replays another session's history must be read WHOLE:
+        // its inherited-baseline boundary sits mid-file, and a proof-complete tail
+        // would never reach it. User forks need this exactly as subagents do.
+        const hasInheritedHistory = rootPayload !== undefined &&
+            codexHasInheritedHistory(rootPayload);
         const entriesReverse = [];
         let malformedLines = 0;
         let prefilteredLines = 0;
@@ -2738,7 +2818,7 @@ async function readCodexFinancialFile(file) {
         let suffixPartsReverse = [];
         let stoppedEarly = false;
         let bytesSkipped = 0;
-        const proof = createCodexReverseProof(isSubagent, !rootPayload);
+        const proof = createCodexReverseProof(hasInheritedHistory, !rootPayload);
         while (position > 0 && !stoppedEarly) {
             const chunkStart = Math.max(0, position - FINANCIAL_REVERSE_CHUNK_BYTES);
             const length = position - chunkStart;
@@ -2979,9 +3059,9 @@ function skipJsonWhitespace(input, start) {
         index += 1;
     return index;
 }
-function createCodexReverseProof(isSubagent, forceFullScan) {
+function createCodexReverseProof(hasInheritedHistory, forceFullScan) {
     return {
-        isSubagent,
+        hasInheritedHistory,
         forceFullScan,
         totalSeen: false,
         turnSeen: false,
@@ -2990,7 +3070,7 @@ function createCodexReverseProof(isSubagent, forceFullScan) {
     };
 }
 function observeCodexReverseProof(proof, entry) {
-    if (proof.forceFullScan || proof.isSubagent)
+    if (proof.forceFullScan || proof.hasInheritedHistory)
         return false;
     const payload = isRecord(entry.payload) ? entry.payload : undefined;
     const info = payload?.type === "token_count" && isRecord(payload.info)
@@ -3007,7 +3087,7 @@ function observeCodexReverseProof(proof, entry) {
     if (entry.type === "turn_context" && stringOf(payload?.model)) {
         proof.modelSeen = true;
     }
-    return !proof.isSubagent &&
+    return !proof.hasInheritedHistory &&
         proof.totalSeen &&
         proof.turnSeen &&
         proof.rateLimitsSeen &&
@@ -3112,7 +3192,8 @@ function createCodexFinancialStreamState() {
     return {
         rootSessionMetaSeen: false,
         rootTaskStarted: false,
-        isSubagent: false
+        isSubagent: false,
+        hasInheritedHistory: false
     };
 }
 function consumeCodexFinancialEntry(state, entry) {
@@ -3126,12 +3207,13 @@ function consumeCodexFinancialEntry(state, entry) {
         state.rootStartedAtMs = timestampMilliseconds(payload.timestamp ?? entry.timestamp);
         state.isSubagent = stringOf(payload.thread_source) === "subagent" ||
             isRecord(payload.source) && "subagent" in payload.source;
+        state.hasInheritedHistory = codexHasInheritedHistory(payload);
     }
     if (entry.type === "turn_context" && payload) {
         state.model = stringOf(payload.model) ?? state.model;
         state.rootCwd ??= stringOf(payload.cwd);
     }
-    if (state.isSubagent &&
+    if (state.hasInheritedHistory &&
         !state.rootTaskStarted &&
         payload?.type === "task_started" &&
         isRootSpecificTaskStart(payload.started_at, state.rootStartedAtMs)) {
@@ -3140,6 +3222,7 @@ function consumeCodexFinancialEntry(state, entry) {
         state.rootTaskStarted = true;
         state.model = undefined;
         state.lastTurn = undefined;
+        state.maxTurnPromptTokens = undefined;
         state.lastRateLimits = undefined;
         state.lastActivityAt = toIso(stringOf(entry.timestamp)) ?? state.startedAt;
     }
@@ -3162,13 +3245,17 @@ function consumeCodexFinancialEntry(state, entry) {
     if (turn) {
         state.lastTurn = turn;
         state.lastActivityAt = eventTimestamp;
+        const turnPrompt = codexTurnPromptTokens(turn);
+        if (turnPrompt !== undefined) {
+            state.maxTurnPromptTokens = Math.max(state.maxTurnPromptTokens ?? 0, turnPrompt);
+        }
     }
     const rateLimits = parseCodexRateLimits(payload.rate_limits, eventTimestamp);
     if (rateLimits)
         state.lastRateLimits = rateLimits;
 }
 function finishCodexFinancialStream(state, onDiagnostic) {
-    if (!state.lastTotal || state.isSubagent && !state.rootTaskStarted)
+    if (!state.lastTotal || state.hasInheritedHistory && !state.rootTaskStarted)
         return undefined;
     const parsedUsage = parseCodexCumulativeUsage(state.lastTotal, state.inheritedUsageBaseline);
     const parsedTurn = state.lastTurn
@@ -3196,6 +3283,9 @@ function finishCodexFinancialStream(state, onDiagnostic) {
             : {}),
         usageScope: "session_cumulative",
         usageSupport,
+        ...(usageSupport === "complete" && state.maxTurnPromptTokens !== undefined
+            ? { maxRequestPromptTokens: state.maxTurnPromptTokens }
+            : {}),
         ...(parsedUsage.reportedTotalTokens !== undefined
             ? { reportedTotalTokens: parsedUsage.reportedTotalTokens }
             : {}),
@@ -3234,10 +3324,14 @@ export function aggregateCallsForFormats(calls, descriptors) {
         const usageSupported = groupCalls.every((call) => call.usageSupport !== "unsupported_token_shape");
         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)));
+            groupCalls.every((call) => canPriceTokenUsageAtScope(model, call.usage, call.usageScope === "turn" ? "request" : "aggregate", call.maxRequestPromptTokens) && (agent !== "gemini-cli" || hasCompleteGeminiPromptEvidence(call)));
         const amountUsd = usageSupported && tieredPricingEvidenceSupported && format
             ? usesPromptTieredPricing(model)
-                ? estimateTokenCostsUsd(model, groupCalls.map((call) => call.usage))
+                ? estimateTokenCostsUsd(model, groupCalls.map((call) => call.usage), 
+                // Fix each cumulative slice's tier from its largest single request
+                // rather than its cache-inflated sum. Turn-scoped slices carry no
+                // such evidence and keep selecting their tier from their own prompt.
+                groupCalls.map((call) => call.maxRequestPromptTokens))
                 : estimateTokenCostUsd(model, usage)
             : undefined;
         const priced = usageSupported && typeof amountUsd === "number";

package/dist/modelPricing.d.ts

@@ -50,8 +50,17 @@ export declare function estimateTokenCostUsd(model: string, usage: TokenUsage):
  * 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.
+ *
+ * `tierPromptTokens[i]`, when provided, fixes the tier of `usages[i]` from
+ * request-level evidence instead of the slice's own prompt total. A
+ * session-cumulative slice is a sum of many requests whose prompt total
+ * routinely clears a per-request threshold on cache reads alone, even though no
+ * single request did; supplying the largest single request's prompt keeps such
+ * a slice on the base tier (and pricing it there is exact, since the base rate
+ * distributes over the sum). Omitting the array preserves single-request
+ * behaviour: each slice's own prompt selects its tier.
  */
-export declare function estimateTokenCostsUsd(model: string, usages: readonly TokenUsage[]): number | undefined;
+export declare function estimateTokenCostsUsd(model: string, usages: readonly TokenUsage[], tierPromptTokens?: readonly (number | undefined)[]): 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. */
@@ -60,9 +69,13 @@ 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.
+ * crossed it. It is also unambiguous when request-level evidence
+ * (`maxRequestPromptTokens`, the largest single request the aggregate contains)
+ * proves that no constituent request crossed the threshold: every request was
+ * base-tier, so the whole sum is base-tier and prices exactly at the base rate.
+ * Larger aggregates without such evidence fail closed to keep an unpriceable
+ * total honestly "missing" rather than guessing a tier.
  */
-export declare function canPriceTokenUsageAtScope(model: string, usage: TokenUsage, scope: "request" | "aggregate"): boolean;
+export declare function canPriceTokenUsageAtScope(model: string, usage: TokenUsage, scope: "request" | "aggregate", maxRequestPromptTokens?: number): boolean;
 export {};
 //# sourceMappingURL=modelPricing.d.ts.map

package/dist/modelPricing.js

@@ -20,21 +20,38 @@ const pricingRules = [
     { match: /^claude-haiku-4/i, inputPerM: 1, outputPerM: 5 },
     { match: /^claude-3-7-sonnet|^claude-3-5-sonnet/i, inputPerM: 3, outputPerM: 15 },
     { match: /^claude-3-5-haiku/i, inputPerM: 0.8, outputPerM: 4 },
-    // OpenAI (newer and more specific families must precede the GPT-5 fallback)
+    // OpenAI (newer and more specific families must precede the GPT-5 fallback).
+    // Rates from developers.openai.com/api/docs/pricing cross-checked against each
+    // model's own doc page, both fetched 2026-08-25.
+    //
+    // GPT-5.6 ships exactly three API models — sol, terra, luna
+    // (developers.openai.com/api/docs/models, 2026-08-25). Each 5.6/5.5/5.4 rule
+    // below is END-ANCHORED on purpose: an undocumented or future sibling
+    // (gpt-5.6-cyber, gpt-5.5-pro, gpt-5.7-sol) must fall through to
+    // honest-unpriced rather than inherit a neighbour's rate. That is the 0.9.4
+    // `^kimi-k2` mistake one family up, and it is the expensive direction here —
+    // the pre-0.9.6 `^gpt-5.6(?:-sol)?$` rule carried GPT-5.5's numbers, so every
+    // gpt-5.6-sol record was overstated by 25% on input and 50% on output.
+    //
+    // Long context, published identically on all three 5.6 pages plus 5.5/5.4:
+    // "Prompts with >272K input tokens are priced at 2x input and 1.5x output for
+    // the full request." Cached input scales with the 2x input leg.
     {
-        match: /^gpt-5\.6(?:-sol)?$/i,
-        inputPerM: 5,
-        outputPerM: 30,
-        cacheReadPerM: 0.5,
+        // developers.openai.com/api/docs/models/gpt-5.6-sol, 2026-08-25
+        match: /^gpt-5\.6-sol$/i,
+        inputPerM: 4,
+        outputPerM: 20,
+        cacheReadPerM: 0.4,
         abovePromptTokens: {
             threshold: 272_000,
-            inputPerM: 10,
-            outputPerM: 45,
-            cacheReadPerM: 1
+            inputPerM: 8,
+            outputPerM: 30,
+            cacheReadPerM: 0.8
         }
     },
     {
-        match: /^gpt-5\.6-terra/i,
+        // developers.openai.com/api/docs/models/gpt-5.6-terra, 2026-08-25
+        match: /^gpt-5\.6-terra$/i,
         inputPerM: 2,
         outputPerM: 12,
         cacheReadPerM: 0.2,
@@ -46,7 +63,8 @@ const pricingRules = [
         }
     },
     {
-        match: /^gpt-5\.6-luna/i,
+        // developers.openai.com/api/docs/models/gpt-5.6-luna, 2026-08-25
+        match: /^gpt-5\.6-luna$/i,
         inputPerM: 0.2,
         outputPerM: 1.2,
         cacheReadPerM: 0.02,
@@ -57,15 +75,50 @@ const pricingRules = [
             cacheReadPerM: 0.04
         }
     },
-    { match: /^gpt-5\.5(?:-codex)?/i, inputPerM: 5, outputPerM: 30, cacheReadPerM: 0.5 },
+    {
+        // developers.openai.com/api/docs/models/gpt-5.5, 2026-08-25
+        match: /^gpt-5\.5$/i,
+        inputPerM: 5,
+        outputPerM: 30,
+        cacheReadPerM: 0.5,
+        abovePromptTokens: {
+            threshold: 272_000,
+            inputPerM: 10,
+            outputPerM: 45,
+            cacheReadPerM: 1
+        }
+    },
+    // gpt-5.5-codex bills at the 5.5 base rate but is absent from the published
+    // long-context list, so it deliberately carries no >272K tier.
+    { match: /^gpt-5\.5-codex$/i, inputPerM: 5, outputPerM: 30, cacheReadPerM: 0.5 },
     { match: /^gpt-5\.4-mini/i, inputPerM: 0.75, outputPerM: 4.5, cacheReadPerM: 0.075 },
     { match: /^gpt-5\.4-nano/i, inputPerM: 0.2, outputPerM: 1.25, cacheReadPerM: 0.02 },
-    { match: /^gpt-5\.4/i, inputPerM: 2.5, outputPerM: 15, cacheReadPerM: 0.25 },
+    {
+        // developers.openai.com/api/docs/models/gpt-5.4, 2026-08-25
+        match: /^gpt-5\.4$/i,
+        inputPerM: 2.5,
+        outputPerM: 15,
+        cacheReadPerM: 0.25,
+        abovePromptTokens: {
+            threshold: 272_000,
+            inputPerM: 5,
+            outputPerM: 22.5,
+            cacheReadPerM: 0.5
+        }
+    },
     { match: /^gpt-5\.3-codex/i, inputPerM: 1.75, outputPerM: 14, cacheReadPerM: 0.175 },
     { match: /^gpt-5\.2(?:-codex)?/i, inputPerM: 1.75, outputPerM: 14, cacheReadPerM: 0.175 },
     { match: /^gpt-5(?:\.1)?-codex/i, inputPerM: 1.25, outputPerM: 10, cacheReadPerM: 0.125 },
     { match: /^gpt-5(?:\.1)?-mini/i, inputPerM: 0.25, outputPerM: 2, cacheReadPerM: 0.025 },
-    { match: /^gpt-5/i, inputPerM: 1.25, outputPerM: 10, cacheReadPerM: 0.125 },
+    // developers.openai.com/api/docs/models/gpt-5-nano, 2026-08-25. Before 0.9.6
+    // this fell through to the ^gpt-5 fallback and billed at $1.25/$10 — 25x the
+    // real rate in both directions. No published long-context tier.
+    { match: /^gpt-5-nano/i, inputPerM: 0.05, outputPerM: 0.4, cacheReadPerM: 0.005 },
+    // GPT-5 base and its dash-suffixed snapshots only. The `-|$` boundary stops
+    // this fallback from swallowing dot-minor families it knows nothing about:
+    // gpt-5.7-*, gpt-5.6-cyber and any future gpt-5.6-<variant> now return
+    // undefined -> "missing" instead of silently billing at GPT-5's $1.25/$10.
+    { match: /^gpt-5(?:-|$)/i, inputPerM: 1.25, outputPerM: 10, cacheReadPerM: 0.125 },
     { match: /^gpt-4\.1-nano/i, inputPerM: 0.1, outputPerM: 0.4 },
     { match: /^gpt-4\.1-mini/i, inputPerM: 0.4, outputPerM: 1.6 },
     { match: /^gpt-4\.1/i, inputPerM: 2, outputPerM: 8, cacheReadPerM: 0.5 },
@@ -122,6 +175,23 @@ const pricingRules = [
     // - deepseek-v4-* (api-docs.deepseek.com/quick_start/pricing): published
     //   rates are time-of-day (off-peak = half price, up to 2x swing), so any
     //   flat number here would be dishonest; needs timestamp-aware pricing.
+    //
+    // Deliberate deferrals (2026-08-25 OpenAI review), same honest path:
+    // - gpt-5.6-cyber / gpt-5.5-cyber ($12.50/$1.25/$75 on the pricing page):
+    //   the two canonical sources disagree on whether the >272K tier applies —
+    //   the pricing page omits cyber from its long-context list while
+    //   developers.openai.com/api/docs/models/gpt-5.6-cyber states the 2x/1.5x
+    //   rule does apply. Access is gated behind the Daybreak program, so the
+    //   cost of leaving it unpriced is near zero and a coin-flip on the tier
+    //   would be a real number that is wrong on long requests.
+    // - gpt-5.5-pro / gpt-5.4-pro: listed as long-context-capable but no
+    //   per-model rate is published on either canonical source.
+    // - bare gpt-5.1 / gpt-5.3: the pricing page quotes the 5/5.1/5.2 group as a
+    //   RANGE ($1.25-$1.75) and neither has a resolved per-model figure. Their
+    //   -codex and -mini variants keep their own verified rules above.
+    // - gpt-5.6-codex / gpt-5.5-mini: NOT OpenAI model ids (both 404 on the model
+    //   docs and are absent from developers.openai.com/api/docs/models). They
+    //   appear only in this repo's fixtures and sample CSVs.
 ];
 export function findPricingRule(model) {
     return pricingRules.find((rule) => rule.match.test(model));
@@ -139,11 +209,20 @@ export function estimateTokenCostUsd(model, usage) {
  * 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.
+ *
+ * `tierPromptTokens[i]`, when provided, fixes the tier of `usages[i]` from
+ * request-level evidence instead of the slice's own prompt total. A
+ * session-cumulative slice is a sum of many requests whose prompt total
+ * routinely clears a per-request threshold on cache reads alone, even though no
+ * single request did; supplying the largest single request's prompt keeps such
+ * a slice on the base tier (and pricing it there is exact, since the base rate
+ * distributes over the sum). Omitting the array preserves single-request
+ * behaviour: each slice's own prompt selects its tier.
  */
-export function estimateTokenCostsUsd(model, usages) {
+export function estimateTokenCostsUsd(model, usages, tierPromptTokens) {
     let total = 0;
-    for (const usage of usages) {
-        const usd = rawTokenCostUsd(model, usage);
+    for (let index = 0; index < usages.length; index += 1) {
+        const usd = rawTokenCostUsd(model, usages[index], tierPromptTokens?.[index]);
         if (usd === undefined)
             return undefined;
         total += usd;
@@ -162,21 +241,34 @@ export function promptTierThreshold(model) {
  * 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.
+ * crossed it. It is also unambiguous when request-level evidence
+ * (`maxRequestPromptTokens`, the largest single request the aggregate contains)
+ * proves that no constituent request crossed the threshold: every request was
+ * base-tier, so the whole sum is base-tier and prices exactly at the base rate.
+ * Larger aggregates without such evidence fail closed to keep an unpriceable
+ * total honestly "missing" rather than guessing a tier.
  */
-export function canPriceTokenUsageAtScope(model, usage, scope) {
+export function canPriceTokenUsageAtScope(model, usage, scope, maxRequestPromptTokens) {
     const threshold = promptTierThreshold(model);
     if (threshold === undefined || scope === "request")
         return true;
-    return effectivePromptTokens(usage) <= threshold;
+    if (effectivePromptTokens(usage) <= threshold)
+        return true;
+    return maxRequestPromptTokens !== undefined && maxRequestPromptTokens <= threshold;
 }
-function rawTokenCostUsd(model, usage) {
+/**
+ * @param tierPromptTokens Prompt size used ONLY to select the request tier,
+ *   when it differs from the priced slice's own prompt total (e.g. a
+ *   session-cumulative slice whose tier is fixed by its largest single
+ *   request). Component pricing always uses `usage`; defaults to the slice's
+ *   own effective prompt so single-request callers are unchanged.
+ */
+function rawTokenCostUsd(model, usage, tierPromptTokens) {
     const rule = findPricingRule(model);
     if (!rule) {
         return undefined;
     }
-    const promptTokens = effectivePromptTokens(usage);
+    const promptTokens = tierPromptTokens ?? effectivePromptTokens(usage);
     const rates = rule.abovePromptTokens &&
         promptTokens > rule.abovePromptTokens.threshold
         ? rule.abovePromptTokens

package/dist/projectIndexStore.d.ts

@@ -7,7 +7,7 @@ export declare const projectIndexStoreLockFileName = ".project-index-v2.lock";
 export declare const projectIndexMaxDocumentBytes: number;
 /** Null-window variant plus the newest bounded windows (BLOCKER-2 option i). */
 export declare const projectIndexMaxWindowedVariants = 4;
-export declare const projectIndexFinancialParserVersion = 1;
+export declare const projectIndexFinancialParserVersion = 3;
 declare const financialKeySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<2>;
     section: z.ZodLiteral<"financial">;
@@ -18,7 +18,7 @@ declare const financialKeySchema: z.ZodObject<{
     }>;
     pathHash: z.ZodString;
     fileIdentity: z.ZodString;
-    financialParserVersion: z.ZodLiteral<1>;
+    financialParserVersion: z.ZodLiteral<3>;
 }, z.core.$strict>;
 /**
  * Header-pass ownership evidence (A4a consumer). "unknown" is a first-class
@@ -53,7 +53,7 @@ declare const documentSchema: z.ZodObject<{
     qualitative: z.ZodArray<z.ZodObject<{
         key: z.ZodObject<{
             schemaVersion: z.ZodLiteral<1>;
-            parserVersion: z.ZodLiteral<4>;
+            parserVersion: z.ZodLiteral<6>;
             agent: z.ZodEnum<{
                 "claude-code": "claude-code";
                 codex: "codex";
@@ -89,19 +89,20 @@ declare const documentSchema: z.ZodObject<{
                     contextTokens: z.ZodNumber;
                     totalTokens: z.ZodNumber;
                     source: z.ZodEnum<{
-                        transcript_last_token_usage: "transcript_last_token_usage";
                         assistant_message_usage: "assistant_message_usage";
+                        transcript_last_token_usage: "transcript_last_token_usage";
                         call_usage: "call_usage";
                     }>;
                 }, z.core.$strict>>;
                 usageScope: z.ZodOptional<z.ZodEnum<{
-                    session_cumulative: "session_cumulative";
                     turn: "turn";
+                    session_cumulative: "session_cumulative";
                 }>>;
                 usageSupport: z.ZodOptional<z.ZodEnum<{
                     complete: "complete";
                     unsupported_token_shape: "unsupported_token_shape";
                 }>>;
+                maxRequestPromptTokens: z.ZodOptional<z.ZodNumber>;
                 reportedTotalTokens: z.ZodOptional<z.ZodNumber>;
                 tokenComponentEvidence: z.ZodOptional<z.ZodObject<{
                     inputTokens: z.ZodLiteral<"observed">;
@@ -150,8 +151,8 @@ declare const documentSchema: z.ZodObject<{
                     total: z.ZodOptional<z.ZodNumber>;
                     cacheAccounting: z.ZodEnum<{
                         unknown: "unknown";
-                        none: "none";
                         included: "included";
+                        none: "none";
                     }>;
                 }, z.core.$strict>>;
                 usage: z.ZodObject<{
@@ -190,12 +191,11 @@ declare const documentSchema: z.ZodObject<{
                     kind: z.ZodEnum<{
                         file: "file";
                         agent: "agent";
-                        task: "task";
                         project: "project";
+                        task: "task";
                         automation: "automation";
                     }>;
                     action: z.ZodEnum<{
-                        working: "working";
                         building: "building";
                         refining: "refining";
                         fixing: "fixing";
@@ -205,11 +205,12 @@ declare const documentSchema: z.ZodObject<{
                         configuring: "configuring";
                         publishing: "publishing";
                         running: "running";
+                        working: "working";
                     }>;
                     source: z.ZodEnum<{
-                        user_prompts: "user_prompts";
                         project: "project";
                         agent_title: "agent_title";
+                        user_prompts: "user_prompts";
                         file_activity: "file_activity";
                     }>;
                     promptCount: z.ZodNumber;
@@ -261,9 +262,9 @@ declare const documentSchema: z.ZodObject<{
             }, z.core.$strict>>;
             diagnostics: z.ZodArray<z.ZodObject<{
                 code: z.ZodEnum<{
+                    unsupported_token_shape: "unsupported_token_shape";
                     malformed_jsonl: "malformed_jsonl";
                     malformed_session_file: "malformed_session_file";
-                    unsupported_token_shape: "unsupported_token_shape";
                 }>;
                 count: z.ZodNumber;
             }, z.core.$strict>>;
@@ -280,7 +281,7 @@ declare const documentSchema: z.ZodObject<{
             }>;
             pathHash: z.ZodString;
             fileIdentity: z.ZodString;
-            financialParserVersion: z.ZodLiteral<1>;
+            financialParserVersion: z.ZodLiteral<3>;
         }, z.core.$strict>;
         storedAt: z.ZodString;
         value: z.ZodObject<{
@@ -307,19 +308,20 @@ declare const documentSchema: z.ZodObject<{
                     contextTokens: z.ZodNumber;
                     totalTokens: z.ZodNumber;
                     source: z.ZodEnum<{
-                        transcript_last_token_usage: "transcript_last_token_usage";
                         assistant_message_usage: "assistant_message_usage";
+                        transcript_last_token_usage: "transcript_last_token_usage";
                         call_usage: "call_usage";
                     }>;
                 }, z.core.$strict>>;
                 usageScope: z.ZodOptional<z.ZodEnum<{
-                    session_cumulative: "session_cumulative";
                     turn: "turn";
+                    session_cumulative: "session_cumulative";
                 }>>;
                 usageSupport: z.ZodOptional<z.ZodEnum<{
                     complete: "complete";
                     unsupported_token_shape: "unsupported_token_shape";
                 }>>;
+                maxRequestPromptTokens: z.ZodOptional<z.ZodNumber>;
                 reportedTotalTokens: z.ZodOptional<z.ZodNumber>;
                 tokenComponentEvidence: z.ZodOptional<z.ZodObject<{
                     inputTokens: z.ZodLiteral<"observed">;
@@ -368,8 +370,8 @@ declare const documentSchema: z.ZodObject<{
                     total: z.ZodOptional<z.ZodNumber>;
                     cacheAccounting: z.ZodEnum<{
                         unknown: "unknown";
-                        none: "none";
                         included: "included";
+                        none: "none";
                     }>;
                 }, z.core.$strict>>;
                 usage: z.ZodObject<{
@@ -408,12 +410,11 @@ declare const documentSchema: z.ZodObject<{
                     kind: z.ZodEnum<{
                         file: "file";
                         agent: "agent";
-                        task: "task";
                         project: "project";
+                        task: "task";
                         automation: "automation";
                     }>;
                     action: z.ZodEnum<{
-                        working: "working";
                         building: "building";
                         refining: "refining";
                         fixing: "fixing";
@@ -423,11 +424,12 @@ declare const documentSchema: z.ZodObject<{
                         configuring: "configuring";
                         publishing: "publishing";
                         running: "running";
+                        working: "working";
                     }>;
                     source: z.ZodEnum<{
-                        user_prompts: "user_prompts";
                         project: "project";
                         agent_title: "agent_title";
+                        user_prompts: "user_prompts";
                         file_activity: "file_activity";
                     }>;
                     promptCount: z.ZodNumber;
@@ -479,9 +481,9 @@ declare const documentSchema: z.ZodObject<{
             }, z.core.$strict>>;
             diagnostics: z.ZodArray<z.ZodObject<{
                 code: z.ZodEnum<{
+                    unsupported_token_shape: "unsupported_token_shape";
                     malformed_jsonl: "malformed_jsonl";
                     malformed_session_file: "malformed_session_file";
-                    unsupported_token_shape: "unsupported_token_shape";
                 }>;
                 count: z.ZodNumber;
             }, z.core.$strict>>;

package/dist/qualitativeIndexCache.d.ts

@@ -25,7 +25,7 @@ export declare class QualitativeIndexCacheError extends Error {
 }
 declare const keySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
-    parserVersion: z.ZodLiteral<4>;
+    parserVersion: z.ZodLiteral<6>;
     agent: z.ZodEnum<{
         "claude-code": "claude-code";
         codex: "codex";
@@ -60,19 +60,20 @@ declare const valueSchema: z.ZodObject<{
             contextTokens: z.ZodNumber;
             totalTokens: z.ZodNumber;
             source: z.ZodEnum<{
-                transcript_last_token_usage: "transcript_last_token_usage";
                 assistant_message_usage: "assistant_message_usage";
+                transcript_last_token_usage: "transcript_last_token_usage";
                 call_usage: "call_usage";
             }>;
         }, z.core.$strict>>;
         usageScope: z.ZodOptional<z.ZodEnum<{
-            session_cumulative: "session_cumulative";
             turn: "turn";
+            session_cumulative: "session_cumulative";
         }>>;
         usageSupport: z.ZodOptional<z.ZodEnum<{
             complete: "complete";
             unsupported_token_shape: "unsupported_token_shape";
         }>>;
+        maxRequestPromptTokens: z.ZodOptional<z.ZodNumber>;
         reportedTotalTokens: z.ZodOptional<z.ZodNumber>;
         tokenComponentEvidence: z.ZodOptional<z.ZodObject<{
             inputTokens: z.ZodLiteral<"observed">;
@@ -121,8 +122,8 @@ declare const valueSchema: z.ZodObject<{
             total: z.ZodOptional<z.ZodNumber>;
             cacheAccounting: z.ZodEnum<{
                 unknown: "unknown";
-                none: "none";
                 included: "included";
+                none: "none";
             }>;
         }, z.core.$strict>>;
         usage: z.ZodObject<{
@@ -161,12 +162,11 @@ declare const valueSchema: z.ZodObject<{
             kind: z.ZodEnum<{
                 file: "file";
                 agent: "agent";
-                task: "task";
                 project: "project";
+                task: "task";
                 automation: "automation";
             }>;
             action: z.ZodEnum<{
-                working: "working";
                 building: "building";
                 refining: "refining";
                 fixing: "fixing";
@@ -176,11 +176,12 @@ declare const valueSchema: z.ZodObject<{
                 configuring: "configuring";
                 publishing: "publishing";
                 running: "running";
+                working: "working";
             }>;
             source: z.ZodEnum<{
-                user_prompts: "user_prompts";
                 project: "project";
                 agent_title: "agent_title";
+                user_prompts: "user_prompts";
                 file_activity: "file_activity";
             }>;
             promptCount: z.ZodNumber;
@@ -232,9 +233,9 @@ declare const valueSchema: z.ZodObject<{
     }, z.core.$strict>>;
     diagnostics: z.ZodArray<z.ZodObject<{
         code: z.ZodEnum<{
+            unsupported_token_shape: "unsupported_token_shape";
             malformed_jsonl: "malformed_jsonl";
             malformed_session_file: "malformed_session_file";
-            unsupported_token_shape: "unsupported_token_shape";
         }>;
         count: z.ZodNumber;
     }, z.core.$strict>>;
@@ -250,7 +251,7 @@ type PersistedValue = PersistedQualitativeValue;
  */
 export declare const qualitativeEntryKeySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
-    parserVersion: z.ZodLiteral<4>;
+    parserVersion: z.ZodLiteral<6>;
     agent: z.ZodEnum<{
         "claude-code": "claude-code";
         codex: "codex";
@@ -285,19 +286,20 @@ export declare const qualitativeEntryValueSchema: z.ZodObject<{
             contextTokens: z.ZodNumber;
             totalTokens: z.ZodNumber;
             source: z.ZodEnum<{
-                transcript_last_token_usage: "transcript_last_token_usage";
                 assistant_message_usage: "assistant_message_usage";
+                transcript_last_token_usage: "transcript_last_token_usage";
                 call_usage: "call_usage";
             }>;
         }, z.core.$strict>>;
         usageScope: z.ZodOptional<z.ZodEnum<{
-            session_cumulative: "session_cumulative";
             turn: "turn";
+            session_cumulative: "session_cumulative";
         }>>;
         usageSupport: z.ZodOptional<z.ZodEnum<{
             complete: "complete";
             unsupported_token_shape: "unsupported_token_shape";
         }>>;
+        maxRequestPromptTokens: z.ZodOptional<z.ZodNumber>;
         reportedTotalTokens: z.ZodOptional<z.ZodNumber>;
         tokenComponentEvidence: z.ZodOptional<z.ZodObject<{
             inputTokens: z.ZodLiteral<"observed">;
@@ -346,8 +348,8 @@ export declare const qualitativeEntryValueSchema: z.ZodObject<{
             total: z.ZodOptional<z.ZodNumber>;
             cacheAccounting: z.ZodEnum<{
                 unknown: "unknown";
-                none: "none";
                 included: "included";
+                none: "none";
             }>;
         }, z.core.$strict>>;
         usage: z.ZodObject<{
@@ -386,12 +388,11 @@ export declare const qualitativeEntryValueSchema: z.ZodObject<{
             kind: z.ZodEnum<{
                 file: "file";
                 agent: "agent";
-                task: "task";
                 project: "project";
+                task: "task";
                 automation: "automation";
             }>;
             action: z.ZodEnum<{
-                working: "working";
                 building: "building";
                 refining: "refining";
                 fixing: "fixing";
@@ -401,11 +402,12 @@ export declare const qualitativeEntryValueSchema: z.ZodObject<{
                 configuring: "configuring";
                 publishing: "publishing";
                 running: "running";
+                working: "working";
             }>;
             source: z.ZodEnum<{
-                user_prompts: "user_prompts";
                 project: "project";
                 agent_title: "agent_title";
+                user_prompts: "user_prompts";
                 file_activity: "file_activity";
             }>;
             promptCount: z.ZodNumber;
@@ -457,9 +459,9 @@ export declare const qualitativeEntryValueSchema: z.ZodObject<{
     }, z.core.$strict>>;
     diagnostics: z.ZodArray<z.ZodObject<{
         code: z.ZodEnum<{
+            unsupported_token_shape: "unsupported_token_shape";
             malformed_jsonl: "malformed_jsonl";
             malformed_session_file: "malformed_session_file";
-            unsupported_token_shape: "unsupported_token_shape";
         }>;
         count: z.ZodNumber;
     }, z.core.$strict>>;

package/dist/qualitativeIndexCache.js

@@ -129,6 +129,11 @@ const callSchema = z.object({
     latestTurnUsage: turnUsageSchema.optional(),
     usageScope: z.enum(["turn", "session_cumulative"]).optional(),
     usageSupport: z.enum(["complete", "unsupported_token_shape"]).optional(),
+    // Per-request tier evidence for session-cumulative slices. The strict schema
+    // must carry it: without this key the entry fails validation on write, the
+    // failure is swallowed by the caller, and every run re-parses the whole
+    // corpus instead of reusing the cache.
+    maxRequestPromptTokens: finiteNonnegativeInteger.optional(),
     reportedTotalTokens: finiteNonnegativeInteger.optional(),
     tokenComponentEvidence: tokenComponentEvidenceSchema.optional(),
     sourceVersion: z.string().min(1).max(64).optional(),

package/package.json

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

package/dist/emailAddress.d.ts

@@ -1,7 +0,0 @@
-/**
- * One intentionally pragmatic normalizer for waitlist and receipt-email
- * boundaries. It prevents header/control injection without pretending to be
- * a mailbox-verification system; ownership still requires an explicit flow.
- */
-export declare function normalizeAibillEmailAddress(value: string): string | undefined;
-//# sourceMappingURL=emailAddress.d.ts.map

package/dist/emailAddress.js

@@ -1,16 +0,0 @@
-const controlCharacters = /[\u0000-\u001F\u007F]/u;
-const pragmaticEmailAddress = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
-/**
- * One intentionally pragmatic normalizer for waitlist and receipt-email
- * boundaries. It prevents header/control injection without pretending to be
- * a mailbox-verification system; ownership still requires an explicit flow.
- */
-export function normalizeAibillEmailAddress(value) {
-    const normalized = value.trim().toLowerCase();
-    if (normalized.length < 3 || normalized.length > 254)
-        return undefined;
-    if (controlCharacters.test(normalized))
-        return undefined;
-    return pragmaticEmailAddress.test(normalized) ? normalized : undefined;
-}
-//# sourceMappingURL=emailAddress.js.map