From b962d909445f30b19aa8ace91a4d7d6897b3c00a Mon Sep 17 00:00:00 2001 From: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com> Date: Thu, 12 Nov 2026 08:59:09 +0000 Subject: [PATCH] fix(native-chat): keep Claude's context ring after compaction when responses carry no usage --- .../context-usage/claude-context-facts.ts | 37 +++--- .../claude-context-usage.test.ts | 121 ++++++++++++++++++ .../context-usage/claude-context-usage.ts | 13 +- .../structured/claude-structured-dispatch.ts | 2 - .../claude-journal-translator-contract.ts | 11 +- .../claude-structured-journal-translation.ts | 3 +- 6 files changed, 152 insertions(+), 35 deletions(-) create mode 100644 src/main/claude/context-usage/claude-context-usage.test.ts diff --git a/src/main/claude/context-usage/claude-context-facts.ts b/src/main/claude/context-usage/claude-context-facts.ts index 2c2f7f7c062..7d8aa2c9256 100644 --- a/src/main/claude/context-usage/claude-context-facts.ts +++ b/src/main/claude/context-usage/claude-context-facts.ts @@ -28,12 +28,18 @@ const CONVERSATION_FRAME_TYPES = new Set(['assistant', 'user', 'stream_event']) /** Null targets the newest journal turn when no turn was open at request time. */ export type ClaudeContextReportTarget = AgentJournalItemIdentity | null -export type ClaudeContextReportPart = 'report' | 'window' +/** `askedAt` returns with the answer to `recordReport`. */ +export type ClaudeContextReportListener = ( + target: ClaudeContextReportTarget, + askedAt: number +) => void const STALE = Symbol('stale-window') export class ClaudeContextFacts { private activity = 0 + /** Advances on every newer used count, written or held back; a report asked for earlier must not replace it. */ + private usedCounts = 0 private mainModel: ClaudeMainThreadModel = { initModel: null, responseModel: null } /** Null adopts the next response model; STALE blocks estimates until a fresh window arrives. */ private servedModel: string | null | typeof STALE = null @@ -44,7 +50,7 @@ export class ClaudeContextFacts { /** Check the journal before seeding a configured window hint. */ private journalMayLackWindow = true private lastResponse: string | null = null - private readonly requestListeners = new Set<(target: ClaudeContextReportTarget) => void>() + private readonly requestListeners = new Set() constructor( private readonly turn: ClaudeOpenTurn, @@ -111,6 +117,7 @@ export class ClaudeContextFacts { if (this.servedModel === STALE) { // After a model change, only a configured hint can serve estimates before the report. if (!hint) { + this.usedCounts += 1 return } window = hint @@ -157,28 +164,25 @@ export class ClaudeContextFacts { this.requestReport(settled) } - /** Reports overtaken by activity retain only the window; full reports also replace usage. */ + /** A report asked for before a newer used count retains only the window; otherwise it also replaces usage. */ recordReport( target: ClaudeContextReportTarget, report: AgentSessionContextReport, - part: ClaudeContextReportPart + askedAt: number ): void { const window = { tokens: report.windowTokens, capturedAt: report.capturedAt } this.servedModel = null this.windowReported = true // Before the first turn exists, retain the report's window for the first response. this.windowHint = report.windowTokens - const contextUsage: AgentSessionContextUsage = - part === 'report' ? { used: { kind: 'report', ...report }, window } : { window } - writeAgentJournalTurnRow( - this.sink, - target === null ? { newest: true } : { identity: target }, - { contextUsage }, - { publish: true } + this.write( + askedAt === this.usedCounts ? { used: { kind: 'report', ...report }, window } : { window }, + undefined, + target ) } - subscribeReportRequests(listener: (target: ClaudeContextReportTarget) => void): () => void { + subscribeReportRequests(listener: ClaudeContextReportListener): () => void { this.requestListeners.add(listener) return () => this.requestListeners.delete(listener) } @@ -189,9 +193,12 @@ export class ClaudeContextFacts { private write( contextUsage: AgentSessionContextUsage, - windowIfNoneHeld?: AgentSessionContextWindow + windowIfNoneHeld?: AgentSessionContextWindow, + identity: ClaudeContextReportTarget = this.turn.identity ): void { - const identity = this.turn.identity + if (contextUsage.used) { + this.usedCounts += 1 + } const target: AgentJournalTurnRowTarget = identity ? { identity } : { newest: true } // No later frame may arrive to publish this fact. writeAgentJournalTurnRow( @@ -213,7 +220,7 @@ export class ClaudeContextFacts { private requestReport(target: ClaudeContextReportTarget): void { for (const listener of this.requestListeners) { - listener(target) + listener(target, this.usedCounts) } } } diff --git a/src/main/claude/context-usage/claude-context-usage.test.ts b/src/main/claude/context-usage/claude-context-usage.test.ts new file mode 100644 index 00000000000..49769b469fd --- /dev/null +++ b/src/main/claude/context-usage/claude-context-usage.test.ts @@ -0,0 +1,121 @@ +import { mkdtemp, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, beforeEach, expect, it } from 'vitest' +import { selectStructuredAgentContextUsage } from '../../../shared/agent-session/structured-agent-session-context-usage' +import { claudeProviderHandle } from '../../../shared/agent-session/lifecycle/agent-session-provider-handle-encoding' +import { createTrackedJournalOpener } from '../../native-chat/agent-session-journal/store-lifecycle/journal-host-database-test-support' +import { createDeferredStructuredAgentSessionEventSink } from '../../native-chat/agent-session-wire/journal-ingress/structured-agent-session-event-sink' +import { testEventSinkLogging } from '../../native-chat/agent-session-wire/host/testing/structured-agent-session-logger-test-support' +import { createClaudeJournalTranslator } from '../structured/journal/claude-structured-journal-translation' +import { bindClaudeContextUsageCapture } from './claude-context-usage' + +const journals = createTrackedJournalOpener() +let root: string + +beforeEach(async () => { + root = await mkdtemp(join(tmpdir(), 'orca-claude-context-usage-')) +}) + +afterEach(async () => { + await journals.closeAll() + await rm(root, { recursive: true, force: true }) +}) + +function frame(message: Record, observedAt: number, startsTurn = false) { + return { + type: 'message' as const, + sessionId: 'orca-session', + observedAt, + ...(startsTurn ? { startsTurn: true as const } : {}), + message: { session_id: 'claude-session', parent_tool_use_id: null, ...message } + } +} + +// Gateways that convert OpenAI streams send usage only in message_delta, so Claude's frames carry zeros. +const responseWithoutUsage = (uuid: string, at: number) => + frame( + { + type: 'assistant', + uuid, + message: { + role: 'assistant', + model: 'deepseek-v4.1-flash', + content: [{ type: 'text', text: uuid }], + usage: { input_tokens: 0, output_tokens: 0 } + } + }, + at + ) + +it('shows the report after a compaction when responses carry no usage', async () => { + const journal = await journals.open({ + identity: { + sessionId: 'orca-session', + workspaceId: 'workspace-1', + hostId: 'local', + agent: 'claude', + providerHandle: claudeProviderHandle('claude-session', null) + }, + now: () => 9_000, + stateDirectory: join(root, 'orca-session') + }) + const deferred = createDeferredStructuredAgentSessionEventSink(testEventSinkLogging()) + const translator = createClaudeJournalTranslator({ sink: deferred.sink, coalesceMs: 0 }) + deferred.bind({ journal, fence: 1, publish: () => {} }) + const answers: ((value: unknown) => void)[] = [] + const unbind = bindClaudeContextUsageCapture( + { getContextUsage: () => new Promise((resolve) => answers.push(resolve)) }, + translator, + { now: () => 20_000 } + ) + const settle = async (): Promise => { + for (let index = 0; index < 4; index += 1) { + await Promise.resolve() + } + await expect(deferred.drained()).resolves.toEqual({ ok: true }) + } + const ring = () => selectStructuredAgentContextUsage(journal.snapshot().items) + + translator.handle( + frame({ type: 'system', subtype: 'init', uuid: 'init', model: 'deepseek-v4.1-flash' }, 900) + ) + translator.handle( + frame( + { + type: 'user', + uuid: 'turn-a', + message: { role: 'user', content: [{ type: 'text', text: 'go' }] } + }, + 1_000, + true + ) + ) + translator.handle(responseWithoutUsage('reply-a', 2_000)) + translator.handle( + frame( + { + type: 'system', + subtype: 'compact_boundary', + uuid: 'compact', + compact_metadata: { trigger: 'auto' } + }, + 3_000 + ) + ) + translator.handle(responseWithoutUsage('reply-a2', 4_000)) + await settle() + expect(ring()).toBeNull() + + answers.at(-1)?.({ + model: 'deepseek-v4.1-flash', + totalTokens: 40_000, + rawMaxTokens: 200_000, + categories: [] + }) + await settle() + expect(ring()).toMatchObject({ usedTokens: 40_000, windowTokens: 200_000, estimated: false }) + unbind?.() + translator.dispose() + deferred.close() +}) diff --git a/src/main/claude/context-usage/claude-context-usage.ts b/src/main/claude/context-usage/claude-context-usage.ts index 64b6100efa7..faf8510cf6c 100644 --- a/src/main/claude/context-usage/claude-context-usage.ts +++ b/src/main/claude/context-usage/claude-context-usage.ts @@ -175,10 +175,10 @@ export type ClaudeContextUsageReader = Pick -/** Newer requests discard old answers; conversation activity invalidates only usage, not the window. */ +/** Newer requests discard old answers; the translator decides whether a late answer still replaces usage. */ export function bindClaudeContextUsageCapture( connection: ClaudeContextUsageReader, translator: ClaudeContextUsageTarget | null, @@ -189,9 +189,8 @@ export function bindClaudeContextUsageCapture( } let bound = true let requests = 0 - const unsubscribe = translator.subscribeContextUsageRequests((target) => { + const unsubscribe = translator.subscribeContextUsageRequests((target, askedAt) => { const request = ++requests - const activity = translator.contextActivity void connection .getContextUsage({ timeoutMs: options.timeoutMs ?? CLAUDE_CONTEXT_USAGE_TIMEOUT_MS }) .then( @@ -203,11 +202,7 @@ export function bindClaudeContextUsageCapture( if (!report) { return } - if (activity !== translator.contextActivity) { - translator.recordContextReport(target, report, 'window') - return - } - translator.recordContextReport(target, report, 'report') + translator.recordContextReport(target, report, askedAt) }, () => {} ) diff --git a/src/main/claude/structured/claude-structured-dispatch.ts b/src/main/claude/structured/claude-structured-dispatch.ts index 031fdea5da7..7f06dba903e 100644 --- a/src/main/claude/structured/claude-structured-dispatch.ts +++ b/src/main/claude/structured/claude-structured-dispatch.ts @@ -154,8 +154,6 @@ export async function dispatchClaudeTurn( : randomUUID()) const arm = () => { ++session.dispatchSequence - // Invalidate context reports requested before this send. - session.translator?.markContextActivity() return waitForReplay( session, acceptsResult, diff --git a/src/main/claude/structured/journal/claude-journal-translator-contract.ts b/src/main/claude/structured/journal/claude-journal-translator-contract.ts index 8c7626b8a1d..88cf38f72fa 100644 --- a/src/main/claude/structured/journal/claude-journal-translator-contract.ts +++ b/src/main/claude/structured/journal/claude-journal-translator-contract.ts @@ -8,7 +8,7 @@ import type { } from '../../../native-chat/agent-session-wire/journal-ingress/structured-agent-session-event-sink' import type { ClaudeChildToolQueries } from '../../subagents/claude-child-tool-queries' import type { - ClaudeContextReportPart, + ClaudeContextReportListener, ClaudeContextReportTarget } from '../../context-usage/claude-context-facts' import type { ClaudeJournalPrompts } from './claude-structured-journal-prompts' @@ -59,18 +59,15 @@ export type ClaudeJournalTranslator = { retryPendingCancellations?: () => StructuredAgentSessionSinkAdmission /** Streamed blocks awaiting final frames; settlement clears them. */ readonly pendingStreamedBlocks: number - /** Advances on conversation activity and accepted sends, invalidating older context requests. */ + /** Advances on conversation activity; history catch-up refuses to finish past it. */ readonly contextActivity: number /** Every final snapshot and turn settlement this acquisition tried was admitted. */ readonly finalOutputAdmitted: boolean - markContextActivity: () => void - subscribeContextUsageRequests: ( - listener: (target: ClaudeContextReportTarget) => void - ) => () => void + subscribeContextUsageRequests: (listener: ClaudeContextReportListener) => () => void recordContextReport: ( target: ClaudeContextReportTarget, report: AgentSessionContextReport, - part: ClaudeContextReportPart + askedAt: number ) => void /** Defer context estimates until a model change yields a new window. */ modelMayHaveChanged: () => void diff --git a/src/main/claude/structured/journal/claude-structured-journal-translation.ts b/src/main/claude/structured/journal/claude-structured-journal-translation.ts index 4591d740244..685c7223bc6 100644 --- a/src/main/claude/structured/journal/claude-structured-journal-translation.ts +++ b/src/main/claude/structured/journal/claude-structured-journal-translation.ts @@ -288,9 +288,8 @@ export function createClaudeJournalTranslator( get finalOutputAdmitted() { return coverage.admitted }, - markContextActivity: () => context.markActivity(), subscribeContextUsageRequests: (listener) => context.subscribeReportRequests(listener), - recordContextReport: (target, report, part) => context.recordReport(target, report, part), + recordContextReport: (target, report, askedAt) => context.recordReport(target, report, askedAt), modelMayHaveChanged: () => context.modelMayHaveChanged(), modelWritten: (model) => context.modelWritten(model), dispose: () => {