sailfork / t3code-github / apps/ server/ src/ provider/ Drivers/ codexUsage.test.ts

import { describe, expect, it } from "@effect/vitest";
import { totalTokens } from "@t3tools/provider-core/server/usage";

import {
  type CodexScanState,
  codexUsageFormat,
  initialCodexScanState,
  parseCodexLine as parseCodexRecords,
} from "./codexUsage.ts";

function parseCodexLine(line: string, state: CodexScanState) {
  const records = parseCodexRecords(line, state);
  expect(records.length).toBeLessThanOrEqual(1);
  return records[0] ?? null;
}

describe("parseCodexLine", () => {
  const sessionMeta = JSON.stringify({
    type: "session_meta",
    timestamp: "2026-08-01T05:17:41.289Z",
    payload: { type: "session_meta", id: "019fbbc1-b12c-7360-a685-28c181f0025f" },
  });
  const turnContext = JSON.stringify({
    type: "turn_context",
    timestamp: "2026-08-01T05:17:42.694Z",
    payload: { type: "turn_context", model: "gpt-5.6-sol" },
  });
  const tokenCount = (inputTokens: number, cached: number, output: number, reasoning: number) =>
    JSON.stringify({
      type: "event_msg",
      timestamp: "2026-08-01T05:17:49.919Z",
      payload: {
        type: "token_count",
        info: {
          last_token_usage: {
            input_tokens: inputTokens,
            cached_input_tokens: cached,
            cache_write_input_tokens: 0,
            output_tokens: output,
            reasoning_output_tokens: reasoning,
          },
        },
      },
    });
  const counters = (input: number, output: number) => ({
    input_tokens: input,
    cached_input_tokens: 0,
    cache_write_input_tokens: 0,
    output_tokens: output,
    reasoning_output_tokens: 0,
    total_tokens: input + output,
  });
  const counted = (last: unknown, total?: unknown, extra = {}) =>
    JSON.stringify({
      type: "event_msg",
      timestamp: "2026-08-01T05:17:49.919Z",
      payload: {
        type: "token_count",
        info: { last_token_usage: last, total_token_usage: total, ...extra },
      },
    });

  it("attributes usage to the model from the preceding turn context", () => {
    const state = initialCodexScanState();
    parseCodexLine(sessionMeta, state);
    parseCodexLine(turnContext, state);
    const record = parseCodexLine(tokenCount(19239, 11008, 299, 116), state);

    expect(record?.provider).toBe("codex");
    expect(record?.model).toBe("gpt-5.6-sol");
    expect(record?.sessionId).toBe("019fbbc1-b12c-7360-a685-28c181f0025f");
    expect(record?.totals.uncachedInputTokens).toBe(19239 - 11008);
    expect(record?.totals.cachedInputTokens).toBe(11008);
    expect(record?.totals.reasoningTokens).toBe(116);
  });

  it("skips a repeated token_count so deltas are not double counted", () => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    const first = parseCodexLine(tokenCount(100, 0, 10, 0), state);
    const repeat = parseCodexLine(tokenCount(100, 0, 10, 0), state);

    expect(first).not.toBeNull();
    expect(repeat).toBeNull();
  });

  it("does not consume counters before the model and timestamp are valid", () => {
    const state = initialCodexScanState();
    expect(parseCodexLine(tokenCount(100, 0, 10, 0), state)).toBeNull();
    parseCodexLine(turnContext, state);
    expect(parseCodexLine(tokenCount(100, 0, 10, 0), state)).not.toBeNull();

    const cumulativeState = initialCodexScanState();
    const line = counted(counters(100, 20), counters(100, 20));
    expect(parseCodexLine(line, cumulativeState)).toBeNull();
    parseCodexLine(turnContext, cumulativeState);
    expect(
      parseCodexLine(line.replace("2026-08-01T05:17:49.919Z", "invalid"), cumulativeState),
    ).toBeNull();
    expect(parseCodexLine(line, cumulativeState)?.totals.outputTokens).toBe(20);
    expect(codexUsageFormat.readMalformedRecords?.(cumulativeState)).toBe(0);
  });

  it("ignores stale changed requests but counts equal requests when totals advance across contexts", () => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    const request = counters(100, 20);
    expect(parseCodexLine(counted(request, request), state)?.totals.outputTokens).toBe(20);
    expect(parseCodexLine(counted(counters(20, 5), request), state)).toBeNull();
    expect(
      parseCodexLine(
        counted({ ...counters(0, 0), total_tokens: 20330 }, request, {
          model_context_window: 258400,
        }),
        state,
      ),
    ).toBeNull();
    expect(parseCodexLine(counted(request, counters(200, 40)), state)?.totals.outputTokens).toBe(
      20,
    );

    for (const [index, tier] of ["priority", "ultrafast"].entries()) {
      parseCodexLine(
        JSON.stringify({ type: "turn_context", payload: { model: "gpt-6-astra" } }),
        state,
      );
      parseCodexLine(
        JSON.stringify({
          type: "event_msg",
          payload: { type: "thread_settings_applied", thread_settings: { service_tier: tier } },
        }),
        state,
      );
      const record = parseCodexLine(
        counted(request, counters(100 * (index + 3), 20 * (index + 3))),
        state,
      );
      expect(record).toMatchObject({
        model: "gpt-6-astra",
        speed: tier === "priority" ? "fast" : "ultrafast",
        totals: { uncachedInputTokens: 100, outputTokens: 20 },
      });
    }
    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
  });

  it.each([false, true])(
    "does not rebill legacy requests or drop the next cumulative delta (initial cumulative=%s)",
    (initialCumulative) => {
      const state = initialCodexScanState();
      parseCodexLine(turnContext, state);
      const first = counters(100, 20);
      expect(
        parseCodexLine(counted(first, initialCumulative ? first : undefined), state)?.totals
          .outputTokens,
      ).toBe(20);
      expect(parseCodexLine(counted(first), state)).toBeNull();
      expect(parseCodexLine(counted(counters(20, 5)), state)?.totals.outputTokens).toBe(5);
      expect(parseCodexLine(counted(counters(20, 5), counters(120, 25)), state)).toBeNull();
      expect(
        parseCodexLine(counted(counters(10, 2), counters(130, 27)), state)?.totals.outputTokens,
      ).toBe(2);
      expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
    },
  );

  it("checks every cumulative component and recovers using an inconsistent pair's valid baseline", () => {
    const request = {
      ...counters(100, 20),
      cached_input_tokens: 30,
      cache_write_input_tokens: 10,
      reasoning_output_tokens: 5,
    };
    const fields = Object.keys(request) as (keyof typeof request)[];
    for (const field of fields) {
      const state = initialCodexScanState();
      parseCodexLine(turnContext, state);
      expect(parseCodexLine(counted(request, request), state)?.totals).toEqual({
        uncachedInputTokens: 60,
        cachedInputTokens: 30,
        cacheCreationTokens: 10,
        outputTokens: 20,
        reasoningTokens: 5,
      });
      const total = { ...request };
      for (const key of fields) total[key] *= 2;
      total[field] += 1;
      if (field === "input_tokens" || field === "output_tokens") total.total_tokens += 1;
      expect(parseCodexLine(counted(request, total), state), field).toBeNull();
      expect(codexUsageFormat.readMalformedRecords?.(state), field).toBe(1);
      for (const key of fields) total[key] += request[key];
      expect(parseCodexLine(counted(request, total), state)?.totals.outputTokens, field).toBe(20);
      expect(codexUsageFormat.readMalformedRecords?.(state), field).toBe(1);
    }
  });

  it.each(["continuation", "fork", "subagent"])(
    "bills only the latest request when a %s has no initial counter baseline",
    (source) => {
      const state = initialCodexScanState();
      parseCodexLine(
        JSON.stringify({
          type: "session_meta",
          timestamp: "2026-08-01T05:17:41.000Z",
          payload: {
            id: "child",
            model_provider: "openai",
            ...(source === "fork" ? { forked_from_id: "parent" } : {}),
            ...(source === "subagent"
              ? { source: { subagent: { thread_spawn: { parent_thread_id: "parent" } } } }
              : { source: "vscode" }),
          },
        }),
        state,
      );
      parseCodexLine(turnContext, state);
      const request = {
        ...counters(100, 20),
        cached_input_tokens: 30,
        cache_write_input_tokens: 10,
        reasoning_output_tokens: 5,
      };
      const cumulative = {
        ...counters(500, 60),
        cached_input_tokens: 200,
        cache_write_input_tokens: 20,
        reasoning_output_tokens: 15,
      };
      const first = counted(request, cumulative);
      expect(parseCodexLine(first, state)).toMatchObject({
        sessionId: "child",
        totals: {
          uncachedInputTokens: 60,
          cachedInputTokens: 30,
          cacheCreationTokens: 10,
          outputTokens: 20,
          reasoningTokens: 5,
        },
      });
      expect(parseCodexLine(first, state)).toBeNull();
      expect(parseCodexLine(counted(counters(10, 2), cumulative), state)).toBeNull();
      expect(
        parseCodexLine(
          counted(counters(10, 2), {
            ...cumulative,
            input_tokens: 510,
            output_tokens: 62,
            total_tokens: 572,
          }),
          state,
        )?.totals.outputTokens,
      ).toBe(2);
      expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
    },
  );

  it.each([
    {
      ...counters(90, 40),
      cached_input_tokens: 60,
      cache_write_input_tokens: 20,
      reasoning_output_tokens: 10,
    },
    {
      ...counters(200, 10),
      cached_input_tokens: 60,
      cache_write_input_tokens: 20,
      reasoning_output_tokens: 5,
    },
    {
      ...counters(200, 40),
      cached_input_tokens: 20,
      cache_write_input_tokens: 20,
      reasoning_output_tokens: 10,
    },
    {
      ...counters(200, 40),
      cached_input_tokens: 60,
      cache_write_input_tokens: 5,
      reasoning_output_tokens: 10,
    },
    {
      ...counters(200, 40),
      cached_input_tokens: 60,
      cache_write_input_tokens: 20,
      reasoning_output_tokens: 3,
    },
    {
      ...counters(110, 40),
      cached_input_tokens: 60,
      cache_write_input_tokens: 20,
      reasoning_output_tokens: 10,
    },
    {
      ...counters(200, 30),
      cached_input_tokens: 60,
      cache_write_input_tokens: 20,
      reasoning_output_tokens: 20,
    },
  ])("rejects an initial snapshot with an impossible inherited baseline: %j", (cumulative) => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    const request = {
      ...counters(100, 20),
      cached_input_tokens: 30,
      cache_write_input_tokens: 10,
      reasoning_output_tokens: 5,
    };
    expect(parseCodexLine(counted(request, cumulative), state)).toBeNull();
    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(1);
    expect(state.lastCumulativeUsage).toEqual(cumulative);
  });

  it.each(["request", "cumulative"])("skips malformed %s counters and recovers", (malformed) => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    const request = counters(100, 20);
    parseCodexLine(counted(request, request), state);
    expect(
      parseCodexLine(
        counted(
          malformed === "request" ? { ...request, cached_input_tokens: -1 } : request,
          malformed === "cumulative"
            ? { ...counters(200, 40), output_tokens: "40" }
            : counters(200, 40),
        ),
        state,
      ),
    ).toBeNull();
    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(1);
    expect(
      parseCodexLine(
        counted(request, malformed === "request" ? counters(300, 60) : counters(200, 40)),
        state,
      )?.totals.outputTokens,
    ).toBe(20);
    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(1);
  });

  it("bills only the reported request when usage records sit between reconciling snapshots", () => {
    const state = initialCodexScanState();
    const usageRecord = (usage: unknown) =>
      JSON.stringify({
        type: "token_usage_record",
        timestamp: "2026-08-01T05:17:45.000Z",
        payload: { usage },
      });
    parseCodexLine(turnContext, state);
    parseCodexLine(counted(counters(100, 20), counters(100, 20)), state);
    for (const usage of [counters(40, 5), counters(60, 15), counters(30, 3)]) {
      expect(parseCodexLine(usageRecord(usage), state)).toBeNull();
    }
    expect(
      parseCodexLine(counted(counters(100, 20), counters(200, 40)), state)?.totals.outputTokens,
    ).toBe(20);
    // Records explained by an earlier snapshot cannot bridge a later gap.
    parseCodexLine(usageRecord(counters(10, 2)), state);
    expect(parseCodexLine(counted(counters(10, 2), counters(340, 65)), state)).toBeNull();
    expect(state.malformedRecords).toBe(1);
  });

  it("bills each interrupted turn's request with the model, tier and time it was read under", () => {
    const state = initialCodexScanState();
    const line = (type: string, time: string, payload: Record<string, unknown>) =>
      JSON.stringify({ type, timestamp: `2026-11-0${time}Z`, payload });
    const context = (time: string, turn_id: string, model: string) =>
      line("turn_context", time, { turn_id, model });
    const tier = (time: string, service_tier: string) =>
      line("event_msg", time, {
        type: "thread_settings_applied",
        thread_settings: { service_tier },
      });
    const request = (time: string, usage: unknown) => line("token_usage_record", time, { usage });
    const snapshot = (time: string, last: unknown, total: unknown) =>
      line("event_msg", time, {
        type: "token_count",
        info: { last_token_usage: last, total_token_usage: total },
      });
    const parsed = [
      line("session_meta", "1T23:59:50", { id: "session-a", model_provider: "openai" }),
      context("1T23:59:50", "turn-1", "gpt-6-sol"),
      request("1T23:59:51", counters(100, 20)),
      snapshot("1T23:59:52", counters(100, 20), counters(100, 20)),
      // One interrupted turn whose requests straddle midnight.
      request("1T23:59:59", counters(150, 10)),
      request("2T00:00:01", counters(50, 5)),
      tier("2T00:00:02", "priority"),
      context("2T00:00:02", "turn-2", "gpt-6-astra"),
      request("2T00:00:03", counters(50, 5)),
      request("2T00:00:04", counters(30, 5)),
      tier("2T00:00:05", "default"),
      context("2T00:00:05", "turn-3", "gpt-6-sol"),
      request("2T00:00:06", counters(200, 30)),
      snapshot("2T00:00:07", counters(200, 30), counters(580, 75)),
    ].flatMap((value) => parseCodexRecords(value, state));

    const at = (time: string) => Date.parse(`2026-11-0${time}Z`);
    expect(
      parsed.map((record) => ({
        tokens: totalTokens(record.totals),
        model: record.model,
        speed: record.speed,
        timestampMs: record.timestampMs,
        unresolvedServiceTierTurnId: record.unresolvedServiceTierTurnId,
      })),
    ).toEqual([
      {
        tokens: 120,
        model: "gpt-6-sol",
        speed: "standard",
        timestampMs: at("1T23:59:52"),
        unresolvedServiceTierTurnId: "turn-1",
      },
      {
        tokens: 160,
        model: "gpt-6-sol",
        speed: "standard",
        timestampMs: at("1T23:59:59"),
        unresolvedServiceTierTurnId: "turn-1",
      },
      {
        tokens: 55,
        model: "gpt-6-sol",
        speed: "standard",
        timestampMs: at("2T00:00:01"),
        unresolvedServiceTierTurnId: "turn-1",
      },
      {
        tokens: 55,
        model: "gpt-6-astra",
        speed: "fast",
        timestampMs: at("2T00:00:03"),
        unresolvedServiceTierTurnId: undefined,
      },
      {
        tokens: 35,
        model: "gpt-6-astra",
        speed: "fast",
        timestampMs: at("2T00:00:04"),
        unresolvedServiceTierTurnId: undefined,
      },
      {
        tokens: 230,
        model: "gpt-6-sol",
        speed: "standard",
        timestampMs: at("2T00:00:07"),
        unresolvedServiceTierTurnId: undefined,
      },
    ]);
    expect(state.malformedRecords).toBe(0);
  });

  it("does not bill a context-window estimate or lose the following real request", () => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    parseCodexLine(counted(counters(100, 20), counters(100, 20)), state);
    const estimate = { ...counters(0, 0), total_tokens: 1000 };
    expect(
      parseCodexLine(
        counted({ ...estimate, total_tokens: 880 }, estimate, { model_context_window: 1000 }),
        state,
      ),
    ).toBeNull();
    expect(
      parseCodexLine(counted(counters(10, 2), { ...counters(10, 2), total_tokens: 1012 }), state)
        ?.totals.outputTokens,
    ).toBe(2);
    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
  });

  it.each([false, true])(
    "accepts the post-compaction context marker without a malformed record (prior request: %s)",
    (priorRequest) => {
      const state = initialCodexScanState();
      parseCodexLine(turnContext, state);
      if (priorRequest) parseCodexLine(counted(counters(100, 20), counters(100, 20)), state);
      const marker = counted({ ...counters(0, 0), total_tokens: 26387 }, counters(0, 0), {
        model_context_window: 475000,
      });
      expect(parseCodexLine(marker, state)).toBeNull();
      expect(
        parseCodexLine(counted(counters(30, 5), counters(30, 5)), state)?.totals.outputTokens,
      ).toBe(5);
      expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
    },
  );

  it("bills the first request after a resume restarts the cumulative counters", () => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    parseCodexLine(counted(counters(100, 20), counters(100, 20)), state);
    expect(
      parseCodexLine(counted(counters(30, 5), counters(30, 5)), state)?.totals.outputTokens,
    ).toBe(5);
    expect(
      parseCodexLine(counted(counters(10, 2), counters(40, 7)), state)?.totals.outputTokens,
    ).toBe(2);
    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
  });

  it("ignores a replay of the current sequence's first request without rewinding the baseline", () => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    const request = counters(100, 20);
    const processed = [
      counted(request, request),
      counted(request, counters(200, 40)),
      counted(request, request),
      counted(request, counters(300, 60)),
    ].map((line) => {
      const record = parseCodexLine(line, state);
      return record === null ? 0 : totalTokens(record.totals);
    });

    expect({
      processed,
      skipped: codexUsageFormat.readMalformedRecords?.(state),
    }).toEqual({ processed: [120, 120, 0, 120], skipped: 0 });
  });

  it("bills a genuine restart with the same counters at a new timestamp", () => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    const request = counters(100, 20);
    const lines = [
      counted(request, request),
      counted(request, counters(200, 40)),
      counted(request, request).replace("05:17:49.919Z", "05:18:49.919Z"),
      counted(counters(30, 5), counters(130, 25)),
    ];
    const processed = lines.map((line) => {
      const record = parseCodexLine(line, state);
      return record === null ? 0 : totalTokens(record.totals);
    });
    expect({ processed, skipped: codexUsageFormat.readMalformedRecords?.(state) }).toEqual({
      processed: [120, 120, 120, 35],
      skipped: 0,
    });
  });

  it.each([
    {
      reset: true,
      markerTotal: counters(0, 0),
      nextTotal: counters(130, 25),
      processed: [120, 120, 0, 120, 35],
    },
    {
      reset: false,
      markerTotal: counters(200, 40),
      nextTotal: counters(230, 45),
      processed: [120, 120, 0, 0, 35],
    },
  ])(
    "bills a request equal to the old sequence start only after a context marker reset the counters (reset: $reset)",
    ({ markerTotal, nextTotal, processed }) => {
      const state = initialCodexScanState();
      parseCodexLine(turnContext, state);
      const request = counters(100, 20);
      const marker = counted({ ...counters(0, 0), total_tokens: 26387 }, markerTotal, {
        model_context_window: 475000,
      });
      const billed = [
        counted(request, request),
        counted(request, counters(200, 40)),
        marker,
        counted(request, request),
        counted(counters(30, 5), nextTotal),
      ].map((line) => {
        const record = parseCodexLine(line, state);
        return record === null ? 0 : totalTokens(record.totals);
      });

      expect({
        processed: billed,
        skipped: codexUsageFormat.readMalformedRecords?.(state),
      }).toEqual({ processed, skipped: 0 });
    },
  );

  it("forgets the old sequence start when a malformed pair zeroes the cumulative baseline", () => {
    const state = initialCodexScanState();
    parseCodexLine(turnContext, state);
    const request = counters(100, 20);
    const processed = [
      counted(request, request),
      counted(counters(30, 5), counters(0, 0)),
      counted(request, request),
      counted(counters(30, 5), counters(130, 25)),
    ].map((line) => {
      const record = parseCodexLine(line, state);
      return record === null ? 0 : totalTokens(record.totals);
    });

    expect({
      processed,
      skipped: codexUsageFormat.readMalformedRecords?.(state),
    }).toEqual({ processed: [120, 0, 120, 35], skipped: 1 });
  });

  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.
  describe("forked rollouts", () => {
    const meta = (overrides: {
      id: string;
      timestamp: string;
      forkedFromId?: string;
      spawnParentId?: string;
    }) =>
      JSON.stringify({
        type: "session_meta",
        timestamp: overrides.timestamp,
        payload: {
          type: "session_meta",
          id: overrides.id,
          ...(overrides.forkedFromId === undefined
            ? {}
            : { forked_from_id: overrides.forkedFromId }),
          ...(overrides.spawnParentId === undefined
            ? {}
            : {
                source: {
                  subagent: { thread_spawn: { parent_thread_id: overrides.spawnParentId } },
                },
              }),
        },
      });
    const stamped = (timestamp: string, line: string) => {
      const parsed = JSON.parse(line) as { timestamp: string };
      parsed.timestamp = timestamp;
      return JSON.stringify(parsed);
    };

    it("drops the re-stamped copied burst and keeps the first real event", () => {
      const state = initialCodexScanState();
      const forkInstant = "2026-08-01T05:00:00.000Z";
      parseCodexLine(meta({ id: "child", timestamp: forkInstant, forkedFromId: "parent" }), state);
      parseCodexLine(meta({ id: "parent", timestamp: forkInstant }), state);
      parseCodexLine(stamped(forkInstant, turnContext), state);

      expect(
        parseCodexLine(
          stamped("2026-08-01T05:00:00.001Z", counted(counters(100, 10), counters(100, 10))),
          state,
        ),
      ).toBeNull();
      expect(
        parseCodexLine(
          stamped("2026-08-01T05:00:00.002Z", counted(counters(200, 20), counters(300, 30))),
          state,
        ),
      ).toBeNull();

      const real = parseCodexLine(
        stamped("2026-08-01T05:00:06.000Z", counted(counters(200, 20), counters(500, 50))),
        state,
      );
      expect(real).not.toBeNull();
      expect(real?.sessionId).toBe("child");
      expect(real?.totals.outputTokens).toBe(20);

      const next = parseCodexLine(
        stamped("2026-08-01T05:00:06.100Z", counted(counters(400, 40), counters(900, 90))),
        state,
      );
      expect(next).not.toBeNull();
      expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
    });

    it("recognizes subagent spawns without forked_from_id", () => {
      const state = initialCodexScanState();
      const spawnInstant = "2026-08-01T05:00:00.000Z";
      parseCodexLine(
        meta({ id: "child", timestamp: spawnInstant, spawnParentId: "parent" }),
        state,
      );
      parseCodexLine(stamped(spawnInstant, turnContext), state);
      expect(
        parseCodexLine(stamped("2026-08-01T05:00:00.001Z", tokenCount(100, 0, 10, 0)), state),
      ).toBeNull();
    });

    it("does not suppress anything in a rollout that is not a fork", () => {
      const state = initialCodexScanState();
      parseCodexLine(meta({ id: "root", timestamp: "2026-08-01T05:00:00.000Z" }), state);
      parseCodexLine(stamped("2026-08-01T05:00:00.100Z", turnContext), state);
      const record = parseCodexLine(
        stamped("2026-08-01T05:00:00.200Z", tokenCount(100, 0, 10, 0)),
        state,
      );
      expect(record).not.toBeNull();
    });

    it("forgets the old sequence start when a copied zero baseline rebases the counters", () => {
      const state = initialCodexScanState();
      const forkInstant = "2026-08-01T05:00:00.000Z";
      const request = counters(100, 20);
      const billed = (line: string) => {
        const record = parseCodexLine(line, state);
        return record === null ? 0 : totalTokens(record.totals);
      };
      parseCodexLine(stamped("2026-08-01T04:59:00.000Z", turnContext), state);
      const first = billed(stamped("2026-08-01T04:59:01.000Z", counted(request, request)));
      parseCodexLine(meta({ id: "child", timestamp: forkInstant, forkedFromId: "parent" }), state);
      const copied = billed(
        stamped(
          "2026-08-01T05:00:00.001Z",
          counted({ ...counters(0, 0), total_tokens: 26387 }, counters(0, 0)),
        ),
      );
      const afterBurst = billed(stamped("2026-08-01T05:00:06.000Z", counted(request, request)));
      const next = billed(
        stamped("2026-08-01T05:00:06.100Z", counted(counters(30, 5), counters(130, 25))),
      );

      expect({
        processed: [first, copied, afterBurst, next],
        skipped: codexUsageFormat.readMalformedRecords?.(state),
      }).toEqual({ processed: [120, 0, 120, 35], skipped: 0 });
    });

    it("bills the child's first request when its turn is interrupted before any snapshot", () => {
      const state = initialCodexScanState();
      const forkInstant = "2026-08-01T05:00:00.000Z";
      const request = (timestamp: string, usage: unknown) =>
        JSON.stringify({ type: "token_usage_record", timestamp, payload: { usage } });
      const billed = [
        meta({ id: "child", timestamp: forkInstant, forkedFromId: "parent" }),
        stamped(forkInstant, turnContext),
        request("2026-08-01T05:00:00.001Z", counters(100, 20)),
        stamped("2026-08-01T05:00:00.001Z", counted(counters(100, 20), counters(100, 20))),
        request("2026-08-01T05:00:06.000Z", counters(150, 10)),
        request("2026-08-01T05:00:10.000Z", counters(200, 30)),
        stamped("2026-08-01T05:00:10.000Z", counted(counters(200, 30), counters(450, 60))),
      ].flatMap((line) => parseCodexRecords(line, state));

      expect({
        processed: billed.map((record) => totalTokens(record.totals)),
        skipped: codexUsageFormat.readMalformedRecords?.(state),
      }).toEqual({ processed: [160, 230], skipped: 0 });
    });
  });
});