@agent-finops/core 0.9.5 → 0.9.6

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