fix(server): recover missing initial Codex usage tiers

apps/server/src/provider/Drivers/CodexDriver.ts

@@ -7,6 +7,7 @@ import * as Schema from "effect/Schema";
 import { HttpClient } from "effect/http";
 import { ChildProcessSpawner } from "effect/process";
 
+import type * as CodexUsageHistory from "../../usage/CodexUsageHistory.ts";
 import { makeCodexTextGeneration } from "../../textGeneration/CodexTextGeneration.ts";
 import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
 import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
@@ -97,7 +98,11 @@ export type CodexDriverEnv =
   | ServerEnvironment.ServerEnvironmentIdentity
   | CodexInstallation.CodexInstallation;
 
-export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv, Path.Path> = {
+export const CodexDriver: ProviderDriver<
+  CodexSettings,
+  CodexDriverEnv,
+  Path.Path | CodexUsageHistory.CodexUsageHistory
+> = {
   driverKind: DRIVER_KIND,
   metadata: {
     displayName: "Codex",

apps/server/src/provider/Drivers/codexUsage.test.ts

@@ -251,6 +251,75 @@ describe("parseCodexLine", () => {
     expect(speedAfter(settings({ model: "gpt-6-astra" }), 4)).toBe("standard");
   });
 
+  it("retains initial tier evidence only for the own OpenAI session and exact context until native settings arrive", () => {
+    const meta = (id: string, model_provider?: string) =>
+      JSON.stringify({ type: "session_meta", payload: { id, model_provider } });
+    const context = (turn_id?: string, model?: string) =>
+      JSON.stringify({ type: "turn_context", payload: { turn_id, model } });
+    for (const provider of ["openai", "t3", "custom", undefined]) {
+      const state = initialCodexScanState();
+      parseCodexLine(meta("own-session", provider), state);
+      parseCodexLine(meta("ancestor", provider === "openai" ? "custom" : "openai"), state);
+      parseCodexLine(context("first-turn", "gpt-6-astra"), state);
+      const first = parseCodexLine(tokenCount(100, 0, 1, 0), state);
+      expect(first).toMatchObject({
+        sessionId: "own-session",
+        model: "gpt-6-astra",
+        speed: "standard",
+      });
+      if (provider === "openai") {
+        expect(first).toHaveProperty("unresolvedServiceTierTurnId", "first-turn");
+      } else {
+        expect(first).not.toHaveProperty("unresolvedServiceTierTurnId");
+      }
+
+      parseCodexLine(context(undefined, "gpt-6-astra"), state);
+      expect(parseCodexLine(tokenCount(100, 0, 2, 0), state)).not.toHaveProperty(
+        "unresolvedServiceTierTurnId",
+      );
+      parseCodexLine(context("missing-model"), state);
+      expect(parseCodexLine(tokenCount(100, 0, 3, 0), state)).not.toHaveProperty(
+        "unresolvedServiceTierTurnId",
+      );
+      parseCodexLine(context("next-turn", "gpt-6-astra"), state);
+      const next = parseCodexLine(tokenCount(100, 0, 4, 0), state);
+      if (provider === "openai") {
+        expect(next).toHaveProperty("unresolvedServiceTierTurnId", "next-turn");
+      } else {
+        expect(next).not.toHaveProperty("unresolvedServiceTierTurnId");
+      }
+    }
+
+    for (const service_tier of ["standard", "", undefined, "priority", "ultrafast"]) {
+      const state = initialCodexScanState();
+      parseCodexLine(meta("own-session", "openai"), state);
+      parseCodexLine(context("first-turn", "gpt-6-astra"), state);
+      expect(parseCodexLine(tokenCount(100, 0, 1, 0), state)).toHaveProperty(
+        "unresolvedServiceTierTurnId",
+        "first-turn",
+      );
+      parseCodexLine(
+        JSON.stringify({
+          type: "event_msg",
+          payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
+        }),
+        state,
+      );
+      for (const output of [2, 3]) {
+        parseCodexLine(context(`native-turn-${output}`, "gpt-6-astra"), state);
+        const record = parseCodexLine(tokenCount(100, 0, output, 0), state);
+        expect(record?.speed).toBe(
+          service_tier === "priority"
+            ? "fast"
+            : service_tier === "ultrafast"
+              ? "ultrafast"
+              : "standard",
+        );
+        expect(record).not.toHaveProperty("unresolvedServiceTierTurnId");
+      }
+    }
+  });
+
   // A forked/subagent rollout opens with the parent's history copied in and
   // every line re-stamped to the fork instant, then the ancestors' session
   // metas. Counting those again multiplied usage ~1.85x on real data (#5758).

apps/server/src/provider/Drivers/codexUsage.ts

@@ -13,6 +13,7 @@ import {
 } from "@t3tools/provider-core/server/usage";
 import type { UsageTokenTotals } from "@t3tools/contracts";
 
+import * as CodexUsageHistory from "../../usage/CodexUsageHistory.ts";
 import { resolveCodexHomeLayout } from "./CodexHomeLayout.ts";
 
 const TokenCount = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
@@ -72,6 +73,9 @@ export const CodexScanState = Schema.Struct({
   lastCumulativeUsage: Schema.mutableKey(Schema.NullOr(CodexTokenUsage)),
   malformedRecords: Schema.mutableKey(TokenCount),
   sawSessionMeta: Schema.mutableKey(Schema.Boolean),
+  modelProvider: Schema.mutableKey(Schema.String),
+  turnId: Schema.mutableKey(Schema.String),
+  sawThreadSettings: Schema.mutableKey(Schema.Boolean),
   suppressingForkCopies: Schema.mutableKey(Schema.Boolean),
   forkCopyAnchorMs: Schema.mutableKey(Schema.Finite),
 });
@@ -86,6 +90,9 @@ export function initialCodexScanState(): CodexScanState {
     lastCumulativeUsage: null,
     malformedRecords: 0,
     sawSessionMeta: false,
+    modelProvider: "",
+    turnId: "",
+    sawThreadSettings: false,
     suppressingForkCopies: false,
     forkCopyAnchorMs: 0,
   };
@@ -141,6 +148,9 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
     state.sawSessionMeta = true;
     const id = payloadRecord["id"] ?? payloadRecord["session_id"];
     if (typeof id === "string") state.sessionId = id;
+    if (typeof payloadRecord["model_provider"] === "string") {
+      state.modelProvider = payloadRecord["model_provider"];
+    }
     const metaTimestampMs = parseTimestampMs(record["timestamp"]);
     if (metaTimestampMs !== null && isForkedSessionMeta(payloadRecord)) {
       state.suppressingForkCopies = true;
@@ -151,10 +161,18 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
 
   if (record["type"] === "turn_context") {
     if (typeof payloadRecord["model"] === "string") state.model = payloadRecord["model"];
+    // Model carry is useful for usage, but history recovery needs this context's own identity.
+    state.turnId =
+      typeof payloadRecord["turn_id"] === "string" &&
+      typeof payloadRecord["model"] === "string" &&
+      payloadRecord["model"].length > 0
+        ? payloadRecord["turn_id"]
+        : "";
     return null;
   }
 
   if (payloadType === "thread_settings_applied") {
+    state.sawThreadSettings = true;
     const settings = payloadRecord["thread_settings"];
     if (typeof settings === "object" && settings !== null) {
       state.speed = codexSpeed((settings as Record<string, unknown>)["service_tier"]);
@@ -270,6 +288,12 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
     totals,
     reportedCostUsd: null,
     speed: state.speed,
+    ...(!state.sawThreadSettings &&
+    state.modelProvider === "openai" &&
+    state.sessionId.length > 0 &&
+    state.turnId.length > 0
+      ? { unresolvedServiceTierTurnId: state.turnId }
+      : {}),
     dedupeKey: null,
   };
 }
@@ -295,6 +319,8 @@ export const codexUsageFormat: TranscriptUsageFormat<CodexScanState> = {
       type: true,
       id: true,
       session_id: true,
+      model_provider: true,
+      turn_id: true,
       model: true,
       thread_settings: { service_tier: true },
       forked_from_id: true,
@@ -313,10 +339,40 @@ export const codexUsageFormat: TranscriptUsageFormat<CodexScanState> = {
   sharedSessionsAcrossFiles: true,
 };
 
-export const codexUsageReader: ProviderUsageReader<CodexSettings, Path.Path> = {
+export const codexUsageReader: ProviderUsageReader<
+  CodexSettings,
+  Path.Path | CodexUsageHistory.CodexUsageHistory
+> = {
   kind: "transcripts",
   provider: "codex",
   format: codexUsageFormat,
+  resolveServiceTiers: Effect.fn("codexUsageReader.resolveServiceTiers")(function* (records) {
+    const history = yield* CodexUsageHistory.CodexUsageHistory;
+    const requests = new Map<CodexUsageHistory.CodexUsageHistoryRequest, UsageRecord>();
+    for (const record of records) {
+      if (record.unresolvedServiceTierTurnId === undefined) continue;
+      requests.set(
+        {
+          sessionId: record.sessionId,
+          nativeTurnId: record.unresolvedServiceTierTurnId,
+          model: record.model,
+        },
+        record,
+      );
+    }
+    const resolved = yield* history.resolve([...requests.keys()]).pipe(
+      Effect.catchTags({
+        CodexUsageHistoryReadError: () =>
+          Effect.succeed(new Map<CodexUsageHistory.CodexUsageHistoryRequest, UsageSpeed>()),
+      }),
+    );
+    const speeds = new Map<UsageRecord, UsageSpeed>();
+    for (const [request, speed] of resolved) {
+      const record = requests.get(request);
+      if (record !== undefined) speeds.set(record, speed);
+    }
+    return speeds;
+  }),
   directories: Effect.fn("codexUsageReader.directories")(function* ({ config, environment }) {
     if (config === undefined) return [];
     const path = yield* Path.Path;

apps/server/src/server.ts

@@ -170,6 +170,7 @@ import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAcco
 import * as CursorKeychain from "@t3tools/provider-cursor/server/CursorKeychain";
 import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts";
 import * as UsageService from "./usage/UsageService.ts";
+import * as CodexUsageHistory from "./usage/CodexUsageHistory.ts";
 import * as RuntimeLayer from "./orchestration-v2/runtimeLayer.ts";
 import * as ProjectStore from "./orchestration-v2/ProjectStore.ts";
 import * as ThreadSearch from "./orchestration-v2/ThreadSearch.ts";
@@ -265,6 +266,7 @@ const layerUsage = UsageService.layer.pipe(
   Layer.provide(
     Layer.mergeAll(
       AntigravityUsage.layer,
+      CodexUsageHistory.layer,
       CursorUsageAccounts.layer.pipe(
         Layer.provide(CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer))),
       ),

apps/server/src/usage/CodexUsageHistory.ts

@@ -12,7 +12,7 @@ import { getCodexServiceTierOptionValue } from "../codexModelOptions.ts";
 
 export class CodexUsageHistoryReadError extends Schema.TaggedError<CodexUsageHistoryReadError>()(
   "CodexUsageHistoryReadError",
-  { cause: Schema.Defect() },
+  { requestedTurnCount: Schema.Number, cause: Schema.Defect() },
 ) {
   override get message(): string {
     return "Could not read historical Codex usage tiers.";
@@ -84,7 +84,9 @@ const make = Effect.gen(function* () {
         )
     `.pipe(
       NodeSqliteClient.readOnly,
-      Effect.mapError((cause) => new CodexUsageHistoryReadError({ cause })),
+      Effect.mapError(
+        (cause) => new CodexUsageHistoryReadError({ requestedTurnCount: requests.length, cause }),
+      ),
     );
 
     // Keep duplicates ambiguous even when an attempt is missing or its destination differs.