From 939ac7c30269e8bc0c5851c329800f1d0c925d9a Mon Sep 17 00:00:00 2001 From: Kameron Smith Date: Thu, 19 Nov 2026 20:20:39 -0500 Subject: [PATCH 1/5] fix(server): stop recounting resumed Claude sessions as other usage WIP. A resumed Claude CLI process can restore the session's cumulative modelUsage, so the first result's ledger growth recounted all earlier input as otherUsage. The adapter now keeps the last ledger per native thread in provider thread nativeMetadata, and the first result of a resumed process records otherUsage only when the counter is provably fresh; otherwise otherUsage is unknown. Model: claude-opus-5-5 Task: coding Agent: T3 Claude Code (CLO-920 lane) Lane: magpie Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.ts | 46 +++++++++++++++++-- .../claude_transcript.ndjson | 19 ++++++++ .../output.ts | 40 ++++++++++++++++ .../testkit/fixtures/index.ts | 16 +++++++ .../src/provider/ClaudeTurnTokenUsage.ts | 20 ++++++++ .../src/provider/TurnTokenUsage.test.ts | 23 ++++++++++ packages/contracts/src/orchestrationV2.ts | 8 ++++ 7 files changed, 168 insertions(+), 4 deletions(-) create mode 100644 apps/server/src/orchestration-v2/testkit/fixtures/claude_idle_resume_restored_ledger/claude_transcript.ndjson create mode 100644 apps/server/src/orchestration-v2/testkit/fixtures/claude_idle_resume_restored_ledger/output.ts diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 25d9d616cb939..b33cd5bc338a9 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -30,6 +30,7 @@ import { addClaudeLedgerUsage, claudeLedgerDelta, claudeModelLedger, + claudeResumedLedgerDelta, claudeReportedContextWindows, normalizeClaudeTurnTokenUsage, type ClaudeLedgerUsage, @@ -5113,6 +5114,7 @@ interface ClaudeLiveQueryContext { handedOffSubagents: ReadonlySet; // The SDK's per-process model ledger at the last result; a new process starts at zero. modelLedger: ClaudeModelLedger | undefined; + resumedLedgerPending: boolean; // Per process, not per session: a relative temp dir follows the cwd this CLI // was launched in, and a later turn's cwd can differ. readonly taskOutputRoot: string | undefined; @@ -5852,6 +5854,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( const queryContext = yield* Ref.make(null); // Wake buffers replay result frames, so ledger growth is measured once on arrival. const resultLedgerUsage = new WeakMap(); + const lastModelLedgers = new Map(); const resultsReportingNewContextWindow = new WeakSet(); // A worktree handoff changes the project settings even within one session. let bypassCache: { cwd: string | null; availability: ClaudeBypassAvailability } | null = @@ -6226,9 +6229,16 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( const budget = pdfBudgets.get(nativeThreadId); const hasAppliedTitle = appliedSessionTitles.has(nativeThreadId); const recordedTitle = providerThread.nativeMetadata?.title; - if (budget === undefined && !hasAppliedTitle && recordedTitle === undefined) { + const hasModelLedger = lastModelLedgers.has(nativeThreadId); + if ( + budget === undefined && + !hasAppliedTitle && + recordedTitle === undefined && + !hasModelLedger + ) { return providerThread; } + const modelLedger = lastModelLedgers.get(nativeThreadId); return { ...providerThread, nativeMetadata: { @@ -6247,6 +6257,14 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( : recordedTitle === undefined ? {} : { title: null }), + ...(hasModelLedger + ? { + claudeModelLedger: + modelLedger === null || modelLedger === undefined + ? null + : Object.fromEntries(modelLedger), + } + : {}), }, }; }; @@ -12874,6 +12892,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( ), ), modelLedger: new Map(), + resumedLedgerPending: shouldResume, taskOutputRoot: claudeTaskOutputRoot( adapterOptions.environment, path, @@ -12926,13 +12945,23 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( } if (message.type === "result") { const ledger = claudeModelLedger(message.modelUsage); - const growth = claudeLedgerDelta(context.modelLedger, ledger); + const resumedFirstResult = context.resumedLedgerPending; + context.resumedLedgerPending = false; + const growth = resumedFirstResult + ? claudeResumedLedgerDelta( + lastModelLedgers.get(context.nativeThreadId) ?? undefined, + ledger, + message.usage, + ) + : claudeLedgerDelta(context.modelLedger, ledger); if (growth !== undefined) resultLedgerUsage.set(message, growth); - // A ledger that went backwards cannot anchor the next turn's growth. context.modelLedger = - growth === undefined && context.modelLedger !== undefined + !resumedFirstResult && + growth === undefined && + context.modelLedger !== undefined ? undefined : ledger; + lastModelLedgers.set(context.nativeThreadId, ledger ?? null); for (const [model, window] of claudeReportedContextWindows( message.modelUsage, )) { @@ -13058,6 +13087,15 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( const used = turnInput.providerThread.nativeMetadata?.claudeAttachmentBudget; pdfBudgets.set(nativeThreadId, makeClaudeAttachmentBudget(used)); } + if (!lastModelLedgers.has(nativeThreadId)) { + const recordedLedger = turnInput.providerThread.nativeMetadata?.claudeModelLedger; + if (recordedLedger !== undefined) { + lastModelLedgers.set( + nativeThreadId, + recordedLedger === null ? null : new Map(Object.entries(recordedLedger)), + ); + } + } if (!appliedSessionTitles.has(nativeThreadId)) { const recordedTitle = turnInput.providerThread.nativeMetadata?.title; if (recordedTitle !== undefined && recordedTitle !== null) { diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/claude_idle_resume_restored_ledger/claude_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/claude_idle_resume_restored_ledger/claude_transcript.ndjson new file mode 100644 index 0000000000000..73427b7da86ad --- /dev/null +++ b/apps/server/src/orchestration-v2/testkit/fixtures/claude_idle_resume_restored_ledger/claude_transcript.ndjson @@ -0,0 +1,19 @@ +{"type":"transcript_start","provider":"claudeAgent","protocol":"claude-agent-sdk.query","version":"0.2.111","scenario":"claude_idle_resume_restored_ledger","metadata":{"prompts":["Respond with exactly: idle resume first turn complete","Respond with exactly: idle resume second turn complete"],"model":"claude-sonnet-4-6","nativeSessionId":"1d1e5e55-1041-4e40-8e40-000000000001","queryMode":"restart","tools":"claude_code","permissionMode":"bypassPermissions","generatedBy":"manual-replay-from-thread-d0fe9018 runs 6-8 (idle-released session must reopen with resume, 2026-07-02T20:46:05Z)"}} +{"type":"expect_outbound","label":"query.open:1","frame":{"type":"query.open","options":{"model":"claude-sonnet-4-6","tools":{"type":"preset","preset":"claude_code"},"permissionMode":"bypassPermissions","allowDangerouslySkipPermissions":true,"sessionId":"1d1e5e55-1041-4e40-8e40-000000000001","settings":{"showThinkingSummaries":true}}}} +{"type":"expect_outbound","label":"prompt.offer:1","frame":{"type":"prompt.offer","message":{"type":"user","message":{"role":"user","content":"Respond with exactly: idle resume first turn complete"},"parent_tool_use_id":null}}} +{"type":"emit_inbound","label":"system","frame":{"type":"system","subtype":"hook_started","hook_id":"96353a54-8984-4e77-8060-b1dc6b030cf6","hook_name":"SessionStart:startup","hook_event":"SessionStart","uuid":"ffbfcc28-dd82-4c2a-a99f-58e5af6e393e","session_id":"1d1e5e55-1041-4e40-8e40-000000000001"}} +{"type":"emit_inbound","label":"system","frame":{"type":"system","subtype":"hook_response","hook_id":"96353a54-8984-4e77-8060-b1dc6b030cf6","hook_name":"SessionStart:startup","hook_event":"SessionStart","output":"","stdout":"","stderr":"","exit_code":0,"outcome":"success","uuid":"bbf29fb9-d4b3-4ab2-b0e3-9d2aa833099c","session_id":"1d1e5e55-1041-4e40-8e40-000000000001"}} +{"type":"emit_inbound","label":"system","frame":{"type":"system","subtype":"init","agents":[],"apiKeySource":"none","claude_code_version":"2.1.111","cwd":"/tmp/claude-replay-claude_idle_resume","tools":[],"mcp_servers":[],"model":"claude-sonnet-4-6","permissionMode":"bypassPermissions","slash_commands":[],"output_style":"default","skills":[],"plugins":[],"fast_mode_state":"off","uuid":"f468f37d-e0e6-43cf-bcd7-71e34045083e","session_id":"1d1e5e55-1041-4e40-8e40-000000000001"}} +{"type":"emit_inbound","label":"assistant","frame":{"type":"assistant","message":{"model":"claude-sonnet-4-6","id":"msg_01DKpWHtEMhugcX5nJwxKfeM","type":"message","role":"assistant","content":[{"type":"text","text":"idle resume first turn complete"}],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":3,"cache_creation_input_tokens":0,"cache_read_input_tokens":11792,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"not_available"},"context_management":null},"parent_tool_use_id":null,"session_id":"1d1e5e55-1041-4e40-8e40-000000000001","uuid":"7e96c9db-0543-4276-b97d-ced7f53b93c4"}} +{"type":"emit_inbound","label":"rate_limit_event","frame":{"type":"rate_limit_event","rate_limit_info":{"status":"allowed"},"uuid":"28620e49-aa10-42fa-a7f9-768c9c79c093","session_id":"1d1e5e55-1041-4e40-8e40-000000000001"}} +{"type":"emit_inbound","label":"result","frame":{"type":"result","subtype":"success","is_error":false,"api_error_status":null,"duration_ms":2809,"duration_api_ms":2523,"num_turns":1,"result":"idle resume first turn complete","stop_reason":"end_turn","session_id":"1d1e5e55-1041-4e40-8e40-000000000001","total_cost_usd":0.0036516,"usage":{"input_tokens":3,"cache_creation_input_tokens":0,"cache_read_input_tokens":11792,"output_tokens":7,"server_tool_use":{"web_search_requests":0,"web_fetch_requests":0},"service_tier":"standard","cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"inference_geo":"","iterations":[{"input_tokens":3,"output_tokens":7,"cache_read_input_tokens":11792,"cache_creation_input_tokens":0,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"type":"message"}],"speed":"standard"},"modelUsage":{"claude-sonnet-4-6":{"inputTokens":3,"outputTokens":7,"cacheReadInputTokens":11792,"cacheCreationInputTokens":0,"webSearchRequests":0,"costUSD":0.0036516,"contextWindow":200000,"maxOutputTokens":32000}},"permission_denials":[],"terminal_reason":"completed","fast_mode_state":"off","uuid":"d88c31ae-a8fd-4ed4-a168-96cfd3b0edd7"}} +{"type":"runtime_exit","status":"success"} +{"type":"expect_outbound","label":"query.open:2","frame":{"type":"query.open","options":{"model":"claude-sonnet-4-6","tools":{"type":"preset","preset":"claude_code"},"permissionMode":"bypassPermissions","allowDangerouslySkipPermissions":true,"resume":"1d1e5e55-1041-4e40-8e40-000000000001","settings":{"showThinkingSummaries":true}}}} +{"type":"expect_outbound","label":"prompt.offer:2","frame":{"type":"prompt.offer","message":{"type":"user","message":{"role":"user","content":"Respond with exactly: idle resume second turn complete"},"parent_tool_use_id":null}}} +{"type":"emit_inbound","label":"system","frame":{"type":"system","subtype":"hook_started","hook_id":"4db1e61e-de28-49ee-b7ef-c375670d0aae","hook_name":"SessionStart:resume","hook_event":"SessionStart","uuid":"66e900fe-b02e-41a0-ac08-92260125b13d","session_id":"377e06a0-fe46-420e-bfaa-b4b9fcc8b871"}} +{"type":"emit_inbound","label":"system","frame":{"type":"system","subtype":"hook_response","hook_id":"4db1e61e-de28-49ee-b7ef-c375670d0aae","hook_name":"SessionStart:resume","hook_event":"SessionStart","output":"","stdout":"","stderr":"","exit_code":0,"outcome":"success","uuid":"03f2754d-daee-4128-b180-c1a39faa03f0","session_id":"377e06a0-fe46-420e-bfaa-b4b9fcc8b871"}} +{"type":"emit_inbound","label":"system","frame":{"type":"system","subtype":"init","agents":[],"apiKeySource":"none","claude_code_version":"2.1.111","cwd":"/tmp/claude-replay-claude_idle_resume","tools":[],"mcp_servers":[],"model":"claude-sonnet-4-6","permissionMode":"bypassPermissions","slash_commands":[],"output_style":"default","skills":[],"plugins":[],"fast_mode_state":"off","uuid":"5e1d64c9-a2ca-4ad1-ba2c-546ba18d1785","session_id":"1d1e5e55-1041-4e40-8e40-000000000001"}} +{"type":"emit_inbound","label":"assistant","frame":{"type":"assistant","message":{"model":"claude-sonnet-4-6","id":"msg_01CiTVsN2HCfqr6Ge166z8hv","type":"message","role":"assistant","content":[{"type":"text","text":"idle resume second turn complete"}],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":3,"cache_creation_input_tokens":0,"cache_read_input_tokens":11811,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":7,"service_tier":"standard","inference_geo":"not_available"},"context_management":null},"parent_tool_use_id":null,"session_id":"1d1e5e55-1041-4e40-8e40-000000000001","uuid":"e821cdff-a217-4fb3-b1d0-f89387dbac41"}} +{"type":"emit_inbound","label":"rate_limit_event","frame":{"type":"rate_limit_event","rate_limit_info":{"status":"allowed"},"uuid":"21e2dfd3-a7f5-48d1-a343-ddb1be3198c8","session_id":"1d1e5e55-1041-4e40-8e40-000000000001"}} +{"type":"emit_inbound","label":"result","frame":{"type":"result","subtype":"success","is_error":false,"api_error_status":null,"duration_ms":2103,"duration_api_ms":1644,"num_turns":1,"result":"idle resume second turn complete","stop_reason":"end_turn","session_id":"1d1e5e55-1041-4e40-8e40-000000000001","total_cost_usd":0.0073089,"usage":{"input_tokens":3,"cache_creation_input_tokens":0,"cache_read_input_tokens":11811,"output_tokens":7,"server_tool_use":{"web_search_requests":0,"web_fetch_requests":0},"service_tier":"standard","cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"inference_geo":"","iterations":[{"input_tokens":3,"output_tokens":7,"cache_read_input_tokens":11811,"cache_creation_input_tokens":0,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"type":"message"}],"speed":"standard"},"modelUsage":{"claude-sonnet-4-6":{"inputTokens":6,"outputTokens":14,"cacheReadInputTokens":23603,"cacheCreationInputTokens":0,"webSearchRequests":0,"costUSD":0.0073089,"contextWindow":200000,"maxOutputTokens":32000}},"permission_denials":[],"terminal_reason":"completed","fast_mode_state":"off","uuid":"a876579c-a18c-4237-ba4e-6105b2162bbb"}} +{"type":"runtime_exit","status":"success"} diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/claude_idle_resume_restored_ledger/output.ts b/apps/server/src/orchestration-v2/testkit/fixtures/claude_idle_resume_restored_ledger/output.ts new file mode 100644 index 0000000000000..e26ce7b389bb7 --- /dev/null +++ b/apps/server/src/orchestration-v2/testkit/fixtures/claude_idle_resume_restored_ledger/output.ts @@ -0,0 +1,40 @@ +import { assert } from "@effect/vitest"; +import type { ProviderReplayTranscript } from "@t3tools/contracts"; + +import type { OrchestratorV2ScenarioResult } from "../../OrchestratorScenario.ts"; +import { + assertBaseProjection, + assertSemanticProjectionIntegrity, + assertUserMessagesInclude, + projectionFor, +} from "../shared.ts"; +import { + CLAUDE_IDLE_RESUME_PROMPT_1, + CLAUDE_IDLE_RESUME_PROMPT_2, +} from "../claude_idle_resume/input.ts"; + +export function assertClaudeIdleResumeRestoredLedgerOutput( + result: OrchestratorV2ScenarioResult, + transcript: ProviderReplayTranscript, +) { + assertBaseProjection({ + result, + transcript, + runCount: 2, + runStatuses: ["completed", "completed"], + }); + + const projection = projectionFor(result, transcript.scenario); + assertSemanticProjectionIntegrity(projection); + assertUserMessagesInclude(projection, [CLAUDE_IDLE_RESUME_PROMPT_1, CLAUDE_IDLE_RESUME_PROMPT_2]); + + const [first, second] = projection.providerTurns.map((turn) => turn.turnTokenUsage); + assert.deepInclude(first, { + usageStatus: "complete", + inputTokens: 11_795, + outputTokens: 7, + otherUsage: { inputTokens: 0, outputTokens: 0 }, + }); + assert.deepInclude(second, { usageStatus: "complete", inputTokens: 11_814, outputTokens: 7 }); + assert.notProperty(second, "otherUsage"); +} diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/index.ts b/apps/server/src/orchestration-v2/testkit/fixtures/index.ts index ba2730a163f4d..3be9e636f0ce5 100644 --- a/apps/server/src/orchestration-v2/testkit/fixtures/index.ts +++ b/apps/server/src/orchestration-v2/testkit/fixtures/index.ts @@ -26,6 +26,7 @@ import { claudeCompactAfterResumeWakeInput } from "./claude_compact_after_resume import { assertClaudeCompactAfterResumeWakeOutput } from "./claude_compact_after_resume_wake/output.ts"; import { claudeIdleResumeInput } from "./claude_idle_resume/input.ts"; import { assertClaudeIdleResumeOutput } from "./claude_idle_resume/output.ts"; +import { assertClaudeIdleResumeRestoredLedgerOutput } from "./claude_idle_resume_restored_ledger/output.ts"; import { claudeLocalBashTaskInput } from "./claude_local_bash_task/input.ts"; import { assertClaudeLocalBashTaskOutput } from "./claude_local_bash_task/output.ts"; import { claudeNestedBackgroundSubagentWakeInput } from "./claude_nested_background_subagent_wake/input.ts"; @@ -510,6 +511,21 @@ export const ORCHESTRATOR_REPLAY_FIXTURES: ReadonlyArray; + const resultInput = BILLED_USAGE_FIELDS.filter((field) => field !== "output_tokens").map( + (field) => finiteNonNegativeInteger(usage[field]) ?? 0, + ); + const resultOutput = finiteNonNegativeInteger(usage.output_tokens) ?? 0; + const restoredCounterCannotHoldResult = + sincePreviousProcess.inputTokens < resultInput.reduce((sum, count) => sum + count, 0) || + sincePreviousProcess.outputTokens < resultOutput; + return restoredCounterCannotHoldResult ? fromZero : undefined; +} + export function addClaudeLedgerUsage( left: ClaudeLedgerUsage | undefined, right: ClaudeLedgerUsage | undefined, diff --git a/apps/server/src/provider/TurnTokenUsage.test.ts b/apps/server/src/provider/TurnTokenUsage.test.ts index fb14511211e36..a132fe65739ee 100644 --- a/apps/server/src/provider/TurnTokenUsage.test.ts +++ b/apps/server/src/provider/TurnTokenUsage.test.ts @@ -2,6 +2,7 @@ import { describe, expect, it } from "vite-plus/test"; import { claudeLedgerDelta, claudeModelLedger, + claudeResumedLedgerDelta, normalizeClaudeTurnTokenUsage, } from "./ClaudeTurnTokenUsage.ts"; import { @@ -222,6 +223,28 @@ describe("billable native turn usage", () => { expect(claudeModelLedger({})).toBeUndefined(); }); + it("does not recount a resumed session's earlier usage as other usage", () => { + const ledger = (input: number, output: number) => + claudeModelLedger({ "claude-sonnet-4-6": { inputTokens: input, outputTokens: output } }); + const result = { input_tokens: 40, output_tokens: 5 }; + expect(claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_040, 105), result)).toBeUndefined(); + expect(claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_000, 100), {})).toBeUndefined(); + expect(claudeResumedLedgerDelta(undefined, ledger(1_040, 105), result)).toBeUndefined(); + expect(claudeResumedLedgerDelta(ledger(30, 4), ledger(40, 5), result)).toEqual({ + inputTokens: 40, + outputTokens: 5, + }); + expect(claudeResumedLedgerDelta(ledger(1_000, 100), ledger(60, 9), result)).toEqual({ + inputTokens: 60, + outputTokens: 9, + }); + expect( + normalizeClaudeTurnTokenUsage({ subtype: "success", usage: result }, false, "completed", [], { + ledger: claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_040, 105), result), + }), + ).not.toHaveProperty("otherUsage"); + }); + it("adds Claude steering segments to the final measured result once", () => { expect( normalizeClaudeTurnTokenUsage( diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts index f51b431c7b98a..a3827f9d4dabe 100644 --- a/packages/contracts/src/orchestrationV2.ts +++ b/packages/contracts/src/orchestrationV2.ts @@ -1144,6 +1144,14 @@ export const OrchestrationV2ProviderThreadNativeMetadata = Schema.Struct({ claudeAttachmentBudget: Schema.optional( Schema.Struct({ bytesUsed: NonNegativeInt, pagesUsed: NonNegativeInt }), ), + claudeModelLedger: Schema.optional( + Schema.NullOr( + Schema.Record( + Schema.String, + Schema.Struct({ input: NonNegativeInt, output: NonNegativeInt }), + ), + ), + ), }); export type OrchestrationV2ProviderThreadNativeMetadata = typeof OrchestrationV2ProviderThreadNativeMetadata.Type; From 3cf025d515178e6271d41d100947b2cea7d4762c Mon Sep 17 00:00:00 2001 From: nullStack65 <112618179+nullStack65@users.noreply.github.com> Date: Fri, 20 Nov 2026 03:53:28 +0000 Subject: [PATCH 2/5] fix(server): record the Claude ledger's tool-schema size The resumed-session ledger is part of provider-thread metadata, so the advertised MCP tool schemas grow by that field. Record the measured size, and wrap the new usage assertion so formatting passes. Model: grok/grok-4.7 Task: coding Agent: T3 Codex (CLO-920 lane) Lane: magpie --- apps/server/src/provider/TurnTokenUsage.test.ts | 4 +++- apps/server/src/provider/agentContextBudget.json | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/apps/server/src/provider/TurnTokenUsage.test.ts b/apps/server/src/provider/TurnTokenUsage.test.ts index a132fe65739ee..34026f84c117a 100644 --- a/apps/server/src/provider/TurnTokenUsage.test.ts +++ b/apps/server/src/provider/TurnTokenUsage.test.ts @@ -227,7 +227,9 @@ describe("billable native turn usage", () => { const ledger = (input: number, output: number) => claudeModelLedger({ "claude-sonnet-4-6": { inputTokens: input, outputTokens: output } }); const result = { input_tokens: 40, output_tokens: 5 }; - expect(claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_040, 105), result)).toBeUndefined(); + expect( + claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_040, 105), result), + ).toBeUndefined(); expect(claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_000, 100), {})).toBeUndefined(); expect(claudeResumedLedgerDelta(undefined, ledger(1_040, 105), result)).toBeUndefined(); expect(claudeResumedLedgerDelta(ledger(30, 4), ledger(40, 5), result)).toEqual({ diff --git a/apps/server/src/provider/agentContextBudget.json b/apps/server/src/provider/agentContextBudget.json index 2522389c9f9ee..ee70abac0767d 100644 --- a/apps/server/src/provider/agentContextBudget.json +++ b/apps/server/src/provider/agentContextBudget.json @@ -1,5 +1,5 @@ { "claudeSystemAppendBytes": 5930, "codexAdditionalContextBytes": 7324, - "mcpToolListJsonBytes": 53783 + "mcpToolListJsonBytes": 55240 } From e3c194b9755249db10474963596ef598150e7a4b Mon Sep 17 00:00:00 2001 From: nullStack65 <112618179+nullStack65@users.noreply.github.com> Date: Fri, 20 Nov 2026 04:11:34 +0000 Subject: [PATCH 3/5] fix(server): do not treat a short Claude ledger as a fresh counter A resumed counter that drops a model, or grows by less than this result, is not proof it restarted at zero. Using the whole current ledger still recounted the saved history as otherUsage. That charge is now omitted unless the current ledger fits inside this result. Model: grok/grok-4.7 Task: coding Agent: T3 Codex (CLO-920 lane) Lane: magpie --- .../src/provider/ClaudeTurnTokenUsage.ts | 21 +++++---- .../src/provider/TurnTokenUsage.test.ts | 43 ++++++++++++++----- 2 files changed, 45 insertions(+), 19 deletions(-) diff --git a/apps/server/src/provider/ClaudeTurnTokenUsage.ts b/apps/server/src/provider/ClaudeTurnTokenUsage.ts index 026c4a0a02b8e..8c0da474a0534 100644 --- a/apps/server/src/provider/ClaudeTurnTokenUsage.ts +++ b/apps/server/src/provider/ClaudeTurnTokenUsage.ts @@ -119,17 +119,22 @@ export function claudeResumedLedgerDelta( ): ClaudeLedgerUsage | undefined { const fromZero = claudeLedgerDelta(new Map(), current); if (previousProcess === undefined || fromZero === undefined) return undefined; - const sincePreviousProcess = claudeLedgerDelta(previousProcess, current); - if (sincePreviousProcess === undefined) return fromZero; const usage = (resultUsage ?? {}) as Record; - const resultInput = BILLED_USAGE_FIELDS.filter((field) => field !== "output_tokens").map( - (field) => finiteNonNegativeInteger(usage[field]) ?? 0, + const resultInput = BILLED_USAGE_FIELDS.filter((field) => field !== "output_tokens").reduce( + (sum, field) => sum + (finiteNonNegativeInteger(usage[field]) ?? 0), + 0, ); const resultOutput = finiteNonNegativeInteger(usage.output_tokens) ?? 0; - const restoredCounterCannotHoldResult = - sincePreviousProcess.inputTokens < resultInput.reduce((sum, count) => sum + count, 0) || - sincePreviousProcess.outputTokens < resultOutput; - return restoredCounterCannotHoldResult ? fromZero : undefined; + if (fromZero.inputTokens > resultInput || fromZero.outputTokens > resultOutput) return undefined; + const sincePreviousProcess = claudeLedgerDelta(previousProcess, current); + if ( + sincePreviousProcess !== undefined && + sincePreviousProcess.inputTokens >= resultInput && + sincePreviousProcess.outputTokens >= resultOutput + ) { + return undefined; + } + return fromZero; } export function addClaudeLedgerUsage( diff --git a/apps/server/src/provider/TurnTokenUsage.test.ts b/apps/server/src/provider/TurnTokenUsage.test.ts index 34026f84c117a..aeb23295287f0 100644 --- a/apps/server/src/provider/TurnTokenUsage.test.ts +++ b/apps/server/src/provider/TurnTokenUsage.test.ts @@ -227,24 +227,45 @@ describe("billable native turn usage", () => { const ledger = (input: number, output: number) => claudeModelLedger({ "claude-sonnet-4-6": { inputTokens: input, outputTokens: output } }); const result = { input_tokens: 40, output_tokens: 5 }; + const otherUsage = ( + previous: ReturnType, + current: ReturnType, + usage: object, + ) => + normalizeClaudeTurnTokenUsage({ subtype: "success", usage }, false, "completed", [], { + ledger: claudeResumedLedgerDelta(previous, current, usage), + }).otherUsage; expect( claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_040, 105), result), ).toBeUndefined(); + expect(otherUsage(ledger(1_000, 100), ledger(1_040, 105), result)).toBeUndefined(); expect(claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_000, 100), {})).toBeUndefined(); expect(claudeResumedLedgerDelta(undefined, ledger(1_040, 105), result)).toBeUndefined(); - expect(claudeResumedLedgerDelta(ledger(30, 4), ledger(40, 5), result)).toEqual({ - inputTokens: 40, - outputTokens: 5, - }); - expect(claudeResumedLedgerDelta(ledger(1_000, 100), ledger(60, 9), result)).toEqual({ - inputTokens: 60, - outputTokens: 9, + expect(otherUsage(ledger(30, 4), ledger(40, 5), result)).toEqual({ + inputTokens: 0, + outputTokens: 0, }); + expect(claudeResumedLedgerDelta(ledger(1_000, 100), ledger(60, 9), result)).toBeUndefined(); + expect(otherUsage(ledger(1_000, 100), ledger(60, 9), result)).toBeUndefined(); + const shortOfResult = { input_tokens: 80, output_tokens: 5 }; expect( - normalizeClaudeTurnTokenUsage({ subtype: "success", usage: result }, false, "completed", [], { - ledger: claudeResumedLedgerDelta(ledger(1_000, 100), ledger(1_040, 105), result), - }), - ).not.toHaveProperty("otherUsage"); + claudeResumedLedgerDelta(ledger(10_000, 100), ledger(10_040, 104), shortOfResult), + ).toBeUndefined(); + expect(otherUsage(ledger(10_000, 100), ledger(10_040, 104), shortOfResult)).toBeUndefined(); + const droppedModel = claudeModelLedger({ + "claude-sonnet-4-6": { inputTokens: 100_000, outputTokens: 10 }, + "claude-haiku-4-5": { inputTokens: 20_000, outputTokens: 5 }, + }); + const continuedSonnet = claudeModelLedger({ + "claude-sonnet-4-6": { inputTokens: 100_100, outputTokens: 12 }, + }); + const droppedResult = { input_tokens: 100, output_tokens: 2 }; + expect(claudeResumedLedgerDelta(droppedModel, continuedSonnet, droppedResult)).toBeUndefined(); + expect(otherUsage(droppedModel, continuedSonnet, droppedResult)).toBeUndefined(); + expect(otherUsage(ledger(1_000, 100), ledger(40, 5), result)).toEqual({ + inputTokens: 0, + outputTokens: 0, + }); }); it("adds Claude steering segments to the final measured result once", () => { From 1eb34ceef9a61e6688321d3bddd853da20dc2a45 Mon Sep 17 00:00:00 2001 From: nullStack65 <112618179+nullStack65@users.noreply.github.com> Date: Fri, 20 Nov 2026 19:07:43 +0000 Subject: [PATCH 4/5] fix(server): keep an omitted model's ledger across a resumed result A resumed Claude process's first result can omit a model the saved ledger still has. Storing that partial ledger as the baseline made the model's return count its earlier tokens again as other usage. The baseline now keeps the omitted model's last total. Co-Authored-By: Claude Fable 5.2 --- .../Adapters/ClaudeAdapterV2.ts | 11 +++++++++- .../src/provider/ClaudeTurnTokenUsage.ts | 17 ++++++++++++++++ .../src/provider/TurnTokenUsage.test.ts | 20 +++++++++++++++++++ 3 files changed, 47 insertions(+), 1 deletion(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index b33cd5bc338a9..cfc4ca32b8946 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -31,6 +31,7 @@ import { claudeLedgerDelta, claudeModelLedger, claudeResumedLedgerDelta, + mergeOmittedLedgerModels, claudeReportedContextWindows, normalizeClaudeTurnTokenUsage, type ClaudeLedgerUsage, @@ -12961,7 +12962,15 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( context.modelLedger !== undefined ? undefined : ledger; - lastModelLedgers.set(context.nativeThreadId, ledger ?? null); + lastModelLedgers.set( + context.nativeThreadId, + resumedFirstResult + ? (mergeOmittedLedgerModels( + lastModelLedgers.get(context.nativeThreadId) ?? undefined, + ledger, + ) ?? null) + : (ledger ?? null), + ); for (const [model, window] of claudeReportedContextWindows( message.modelUsage, )) { diff --git a/apps/server/src/provider/ClaudeTurnTokenUsage.ts b/apps/server/src/provider/ClaudeTurnTokenUsage.ts index 8c0da474a0534..815af052d3e1b 100644 --- a/apps/server/src/provider/ClaudeTurnTokenUsage.ts +++ b/apps/server/src/provider/ClaudeTurnTokenUsage.ts @@ -112,6 +112,23 @@ export function claudeLedgerDelta( return { inputTokens, outputTokens }; } +/** + * A resumed process's first result can omit a model the saved ledger still has. + * Keep that model's last total, so its return later is growth rather than a recount from zero. + */ +export function mergeOmittedLedgerModels( + previous: ClaudeModelLedger | undefined, + current: ClaudeModelLedger | undefined, +): ClaudeModelLedger | undefined { + if (current === undefined) return previous; + if (previous === undefined) return current; + const merged = new Map(current); + for (const [model, before] of previous) { + if (!merged.has(model)) merged.set(model, before); + } + return merged; +} + export function claudeResumedLedgerDelta( previousProcess: ClaudeModelLedger | undefined, current: ClaudeModelLedger | undefined, diff --git a/apps/server/src/provider/TurnTokenUsage.test.ts b/apps/server/src/provider/TurnTokenUsage.test.ts index aeb23295287f0..2ece841420ea3 100644 --- a/apps/server/src/provider/TurnTokenUsage.test.ts +++ b/apps/server/src/provider/TurnTokenUsage.test.ts @@ -3,6 +3,7 @@ import { claudeLedgerDelta, claudeModelLedger, claudeResumedLedgerDelta, + mergeOmittedLedgerModels, normalizeClaudeTurnTokenUsage, } from "./ClaudeTurnTokenUsage.ts"; import { @@ -262,6 +263,25 @@ describe("billable native turn usage", () => { const droppedResult = { input_tokens: 100, output_tokens: 2 }; expect(claudeResumedLedgerDelta(droppedModel, continuedSonnet, droppedResult)).toBeUndefined(); expect(otherUsage(droppedModel, continuedSonnet, droppedResult)).toBeUndefined(); + const haikuReturns = claudeModelLedger({ + "claude-sonnet-4-6": { inputTokens: 100_150, outputTokens: 14 }, + "claude-haiku-4-5": { inputTokens: 20_050, outputTokens: 7 }, + }); + const haikuResult = { input_tokens: 50, output_tokens: 2 }; + const haikuGrowth = claudeLedgerDelta( + mergeOmittedLedgerModels(droppedModel, continuedSonnet), + haikuReturns, + ); + expect(haikuGrowth).toEqual({ inputTokens: 100, outputTokens: 4 }); + expect( + normalizeClaudeTurnTokenUsage( + { subtype: "success", usage: haikuResult }, + false, + "completed", + [], + { ledger: haikuGrowth }, + ).otherUsage, + ).toEqual({ inputTokens: 50, outputTokens: 2 }); expect(otherUsage(ledger(1_000, 100), ledger(40, 5), result)).toEqual({ inputTokens: 0, outputTokens: 0, From 7dca9e49bdba1e25610f966364d390a3cbc850f0 Mon Sep 17 00:00:00 2001 From: nullStack65 <112618179+nullStack65@users.noreply.github.com> Date: Fri, 20 Nov 2026 19:16:51 +0000 Subject: [PATCH 5/5] fix(server): keep the omitted model in the resumed process baseline The next result of the same resumed process diffs against the turn context's ledger, not the persisted one, so keeping the omitted model only in the persisted baseline still recounted it. Co-Authored-By: Claude Fable 5.2 --- .../Adapters/ClaudeAdapterV2.ts | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index cfc4ca32b8946..57ff18ff55fe1 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -12956,20 +12956,20 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( ) : claudeLedgerDelta(context.modelLedger, ledger); if (growth !== undefined) resultLedgerUsage.set(message, growth); - context.modelLedger = - !resumedFirstResult && - growth === undefined && - context.modelLedger !== undefined + const resumedBaseline = resumedFirstResult + ? mergeOmittedLedgerModels( + lastModelLedgers.get(context.nativeThreadId) ?? undefined, + ledger, + ) + : undefined; + context.modelLedger = resumedFirstResult + ? resumedBaseline + : growth === undefined && context.modelLedger !== undefined ? undefined : ledger; lastModelLedgers.set( context.nativeThreadId, - resumedFirstResult - ? (mergeOmittedLedgerModels( - lastModelLedgers.get(context.nativeThreadId) ?? undefined, - ledger, - ) ?? null) - : (ledger ?? null), + resumedFirstResult ? (resumedBaseline ?? null) : (ledger ?? null), ); for (const [model, window] of claudeReportedContextWindows( message.modelUsage,