[Bug]: A zero-credit Codex cap delays usage-limit recovery until the monthly credit reset #34974

#!/bin/sh
set -eu
repo=${1:-$(pwd)}
repo=$(cd "$repo" && pwd)
fixture=$(mktemp -d "${REPRO_TMP_PARENT:-${TMPDIR:-/tmp}}/credit-reset-verify.XXXXXX")
trap 'rm -rf "$fixture"' EXIT HUP INT TERM
mkdir -p "$fixture/fake-home" "$fixture/tmp" "$fixture/t3-home"
export HOME="$fixture/fake-home" TMPDIR="$fixture/tmp" T3CODE_HOME="$fixture/t3-home"
export VP_REMOTE_CACHE=off VP_REMOTE_CACHE_URL= T3_VERIFY_REPO="$repo" T3_VERIFY_FIXTURE="$fixture"
ln -s "$repo/apps/server/node_modules" "$fixture/node_modules"
cat > "$fixture/package.json" <<'JSON'
{"type":"module"}
JSON
cat > "$fixture/vite.config.ts" <<'TS'
import { defineConfig } from 'vite-plus';
export default defineConfig({root: process.env.T3_VERIFY_FIXTURE, test: {environment: 'node', include: ['verify.test.ts'], testTimeout: 60000, maxWorkers: 1, fileParallelism: false}});
TS
cat > "$fixture/verify.test.ts.template" <<'TS'
import { readFileSync, writeFileSync } from 'node:fs';
import { assert, it } from '@effect/vitest';
import * as Effect from 'effect/Effect';
import * as Layer from 'effect/Layer';
import * as Ref from 'effect/Ref';
import * as CodexReplay from 'effect-codex-app-server/replay';
import * as DateTime from 'effect/DateTime';
import { TestClock } from 'effect/testing';
import { CommandId, ProviderDriverKind } from '@t3tools/contracts';
import * as IdAllocator from '@t3tools/provider-core/server/IdAllocator';
import { materializeReplayTranscriptWorkspace } from '@t3tools/provider-testing/replayTranscript';
import * as CodexTestkit from '__ROOT__/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.testkit.ts';
import { CodexOrchestratorReplayHarness } from '__ROOT__/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.testkit.ts';
import { runOrchestratorV2ProviderReplayScenario } from '__ROOT__/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts';
import { materializeFixtureInput, CODEX_MODEL_SELECTION, SIMPLE_PROMPT } from '__ROOT__/apps/server/src/orchestration-v2/testkit/fixtures/shared.ts';
import { limitRecoveryCommand } from '__ROOT__/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.ts';
import { codexRateLimitsToLimits, codexUsageLimitResetAt } from '__ROOT__/apps/server/src/provider/codexUsageLimits.ts';
import { exhaustedUsageWindow } from '__ROOT__/packages/shared/src/usageLimits.ts';

const repo = process.env.T3_VERIFY_REPO!;
const workspace = process.env.T3_VERIFY_FIXTURE!;
// Fixed clock and credit reset copied from the candidate's reported fixture.
const checkedAt = '2026-11-11T00:00:00.000Z';
const now = Date.parse(checkedAt);
const sessionSeconds = now / 1000 + 5 * 60 * 60;
const sessionReset = new Date(sessionSeconds * 1000).toISOString();
const creditReset = new Date(1796083200 * 1000).toISOString();
const source = readFileSync(repo + '/apps/server/src/orchestration-v2/testkit/fixtures/simple/codex_transcript.ndjson', 'utf8').trim().split('\n').map(JSON.parse);
const packageVersion = JSON.parse(readFileSync(repo + '/apps/server/package.json', 'utf8')).version;
const preamble = source.slice(1, source.findIndex(e => e.label === 'turn/started') + 1)
  .filter(e => ['initialize', 'initialized', 'thread/start', 'turn/start', 'turn/started'].includes(e.label));
preamble.find(e => e.type === 'expect_outbound' && e.label === 'initialize').frame.params.clientInfo.version = packageVersion;
const nativeThreadId = preamble.find(e => e.type === 'emit_inbound' && e.label === 'thread/start').frame.result.thread.id;
const nativeTurn = preamble.find(e => e.label === 'turn/started').frame.params.turn;

it.effect('compares credit caps through the real Codex adapter, event ingestion, orchestrator, projection and recovery worker decision', () => Effect.gen(function* () {
  const rows: any[] = [];
  for (const scenario of [
    {name:'room-with-credit-cap', credit:true, used:0, fail:true},
    {name:'room-without-credit-cap', credit:false, used:0, fail:true},
    {name:'exhausted-with-credit-cap', credit:true, used:100, fail:true},
    {name:'exhausted-without-credit-cap', credit:false, used:100, fail:true},
    {name:'room-with-credit-cap-success', credit:true, used:0, fail:false, manual:false},
    {name:'credit-cap-manual-continuation', credit:true, used:100, fail:true, manual:true},
  ]) {
    yield* TestClock.setTime(now);
    const snapshot = {
      limitId:'codex', planType:'team', rateLimitReachedType:null,
      primary:{usedPercent:scenario.used, resetsAt:sessionSeconds, windowDurationMins:300},
      secondary:{usedPercent:14, resetsAt:sessionSeconds + 7*24*60*60, windowDurationMins:10080},
      individualLimit: scenario.credit ? {limit:'0', used:'0.0', remainingPercent:0, resetsAt:1796083200} : null,
    };
    const provider = {driver:'codex', usageLimits:codexRateLimitsToLimits({snapshot, checkedAt})} as any;
    const blocked = exhaustedUsageWindow(provider, now, CODEX_MODEL_SELECTION.model)?.id ?? null;
    const helperReset = codexUsageLimitResetAt(snapshot);
    const needsRead = scenario.fail && helperReset === null;
    const failureReset = scenario.fail ? (scenario.credit ? creditReset : sessionReset) : null;
    const expectedReset = 'manual' in scenario && scenario.manual ? null : failureReset;
    const entries:any[] = structuredClone(preamble);
    entries.push({type:'emit_inbound',label:'account/rateLimits/updated',frame:{method:'account/rateLimits/updated',params:{rateLimits:snapshot}}});
    entries.push({type:'emit_inbound',label:'turn/completed',frame:{method:'turn/completed',params:{threadId:nativeThreadId,turn:{...nativeTurn,status:scenario.fail?'failed':'completed',completedAt:sessionSeconds-1,error:scenario.fail?{message:'Provider stopped this request.',codexErrorInfo:'usageLimitExceeded'}:null}}}});
    if(needsRead) {
      entries.push({type:'expect_outbound',label:'account/rateLimits/read',frame:{id:4,method:'account/rateLimits/read',params:null}});
      entries.push({type:'emit_inbound',label:'account/rateLimits/read',frame:{id:4,result:{rateLimits:{...snapshot,primary:{...snapshot.primary,usedPercent:100}},rateLimitsByLimitId:null}}});
    }
    if ('manual' in scenario && scenario.manual) {
      const start=structuredClone(preamble.find(e=>e.type==='expect_outbound'&&e.label==='turn/start'));
      start.frame.id=4; start.frame.params.input=[{type:'text',text:'Continue.'}];
      const turn={...nativeTurn,id:'manual-continuation-turn',status:'inProgress',error:null};
      entries.push(start,{type:'emit_inbound',label:'turn/start',frame:{id:4,result:{turn}}},{type:'emit_inbound',label:'turn/started',frame:{method:'turn/started',params:{threadId:nativeThreadId,turn}}},{type:'emit_inbound',label:'turn/completed',frame:{method:'turn/completed',params:{threadId:nativeThreadId,turn:{...turn,status:'completed',completedAt:sessionSeconds+1}}}});
    }
    const transcript = yield* CodexOrchestratorReplayHarness.decodeTranscript(materializeReplayTranscriptWorkspace({provider:'codex',protocol:'codex.app-server',version:source[0].version,scenario:scenario.name,entries}, workspace));
    const materialized = yield* materializeFixtureInput({scenario:scenario.name, fixtureInput:{steps:[{type:'message',text:SIMPLE_PROMPT},...('manual' in scenario && scenario.manual ? [{type:'message' as const,text:'Continue.'}] : [])]},driver:ProviderDriverKind.make('codex'),modelSelection:CODEX_MODEL_SELECTION});
    const idAllocator = yield* IdAllocator.IdAllocatorV2;
    const threadId=materialized.projectionThreadIds[0];
    const runId=idAllocator.derive.run({threadId,ordinal:1});
    const arm:any = scenario.fail ? {type:'thread.metadata.update',commandId:CommandId.make('arm-'+scenario.name),threadId,limitRecovery:{runId,resetAt:failureReset,autoResume:true,snooze:false}} : null;
    const driverRef = yield* Ref.make<any>(undefined);
    const harness = {...CodexOrchestratorReplayHarness, makeProviderAdapterRegistryLayer: (transcript:any) => Layer.effectContext(Effect.gen(function*(){
      const driver = yield* CodexReplay.makeReplayDriver(transcript);
      yield* Ref.set(driverRef,driver);
      return yield* Layer.build(CodexTestkit.layer({transcript,driver}));
    }))};
    const firstIdle=materialized.steps.findIndex(s=>s.type==='await_thread_idle');
    const scenarioSteps = 'manual' in scenario && scenario.manual
      ? [...materialized.steps.slice(0,firstIdle+1),{type:'dispatch' as const,command:arm},{type:'advance_clock' as const,duration:'1 millis' as const},...materialized.steps.slice(firstIdle+1)]
      : [...materialized.steps,...(arm?[{type:'dispatch' as const,command:arm}]:[])];
    const result = yield* Effect.scoped(runOrchestratorV2ProviderReplayScenario({
      name:scenario.name,transcript,commands:[...materialized.commands,...(arm?[arm]:[])],
      steps:scenarioSteps,
      projectionThreadIds:materialized.projectionThreadIds,runtimePolicyOverride:{cwd:workspace},
    },harness));
    const driver=yield* Ref.get(driverRef);
    const replayState=yield* Ref.get(driver.state);
    assert.equal(replayState.failure,null);
    assert.equal(replayState.cursor,entries.length);
    const projection=result.projections.get(threadId)!;
    const error=projection.turnItems.find(i=>i.type==='error');
    const shell=result.shellSnapshot.threads.find(t=>t.id===threadId)!;
    const afterPlanReset = limitRecoveryCommand(shell as any,true,sessionSeconds*1000+1);
    const afterCreditReset = limitRecoveryCommand(shell as any,true,1796083200*1000+1);
    const row={scenario:scenario.name,blockedWindow:blocked,helperReset,accountReadExpectedAndConsumed:needsRead,runStatus:projection.runs.at(-1)!.status,allRunStatuses:projection.runs.map(r=>r.status),failure:error?.type==='error'?error.failure:null,shellReset:shell.usageLimitResetAt,limitRecovery:projection.thread.limitRecovery == null ? null : {resetAt:projection.thread.limitRecovery.resetAt,autoResume:projection.thread.limitRecovery.autoResume,snooze:projection.thread.limitRecovery.snooze},replayConsumed:replayState.cursor===entries.length,afterPlanReset:afterPlanReset?.type??null,afterCreditReset:afterCreditReset?.type??null};
    rows.push(row);
    console.log(JSON.stringify(row));
    assert.equal(projection.runs[0].status,scenario.fail?'failed':'completed');
    if ('manual' in scenario && scenario.manual) {
      assert.equal(projection.runs[1].status,'completed');
      assert.equal(shell.usageLimitResetAt,null);
      assert.equal(error?.type==='error'?error.failure.resetAt:null,creditReset);
      assert.equal(afterPlanReset,null);
      continue;
    }
    assert.equal(shell.usageLimitResetAt,expectedReset);
    if(scenario.fail) {
      assert.equal(projection.thread.limitRecovery?.resetAt,expectedReset);
      assert.equal(afterPlanReset?.type??null,scenario.credit?null:'message.dispatch');
      assert.equal(afterCreditReset?.type,'message.dispatch');
    } else { assert.equal(error,undefined); assert.equal(projection.thread.limitRecovery,null); }
  }
  assert.equal(rows[0].blockedWindow,null);
  assert.equal(rows[1].blockedWindow,null);
  assert.equal(rows[2].blockedWindow,'primary');
  assert.equal(rows[3].blockedWindow,'primary');
  writeFileSync(workspace + '/results.json', JSON.stringify(rows,null,2)+'\n');
  console.log('DEFECT PRESENT: real failed-turn projection arms the monthly credit reset and waits past the plan reset; no-cap controls use the plan reset; a successful turn remains completed.');
}).pipe(Effect.provide(IdAllocator.layer)));
TS
python3 - "$fixture/verify.test.ts.template" "$fixture/verify.test.ts" "$repo" <<'PY'
import sys
from pathlib import Path
Path(sys.argv[2]).write_text(Path(sys.argv[1]).read_text().replace('__ROOT__', sys.argv[3]))
PY
cd "$repo"
"$repo/node_modules/.bin/vp" test run --config "$fixture/vite.config.ts" verify.test.ts

cat "$fixture/results.json"
printf '%s\n' "DEFECT PRESENT: all six integrated scenarios matched; credit-cap failures wait past the plan reset and controls do not."