@brunobracaioli/aibrain 0.3.0-beta.15 → 0.3.0-beta.18

package/README.md

@@ -2,9 +2,16 @@
 
 Assisted AI Brain context beta client for Linux/WSL with Node.js 22 or newer.
 
+Codex capture also requires the `flock` utility from `util-linux`, normally
+included in Linux/WSL. The launcher and doctor check availability before a
+monitored Codex session starts. Capture coordination is released by the kernel
+after a process exits unexpectedly. An unidentifiable empty lock left by an
+older client requires a verified support migration; do not delete checkpoints,
+notes or lock files to work around a reported storage error.
+
 The reviewed native compatibility set is Claude Code 2.1.294, 2.1.295, 2.1.296,
 2.1.299, 2.1.300, 2.1.301, 2.1.302 or 2.1.303, and Codex CLI 0.161.0,
-0.162.0, 0.162.1 or 0.163.0. A newer stable Codex 0.x release may continue only
+0.162.0, 0.162.1, 0.163.0 or 0.164.0. A newer stable Codex 0.x release may continue only
 after its locally generated experimental protocol schemas and transport flags
 match the bundled adapter contract; prereleases, older releases and new majors
 remain rejected. Starting with beta14, newer stable Claude 2.1 patches can
@@ -15,6 +22,11 @@ equivalence with a tested native release. Unknown older patches, prereleases
 and other major/minor families remain rejected. No credentials, conversations,
 model requests or JEV calls are used by these compatibility probes.
 
+Beta17 refreshes the Codex contract to 0.164.0, including its image-generation
+record formats. Native launch/resume qualification is separate from a new
+model/JEV compaction qualification. A later native release that changes the
+consumed contract can still require an AI Brain compatibility update.
+
 The Codex terminal bridge permits the native session picker's separate read-only
 connection while keeping the primary conversation and monitor intact. A picker
 cannot compact, start a turn, inject history or take ownership of the primary

package/dist/assets/claude/hooks/context-compaction.ts

@@ -107,6 +107,7 @@ type HookApi = {
   };
 };
 type HookOptions = Record<string, unknown>;
+type MonotonicClock = () => number | undefined;
 type PreservationMode = 'preserve_internal' | 'upstream_compatible';
 type CompactionStrategy = 'direct_experimental' | 'native_summary_notes';
 type ToolPolicy = 'read_only' | 'compatible';
@@ -150,7 +151,7 @@ type Register = (
 ) => void;
 
 const MAX_RESULT_BYTES = 256 * 1024;
-const CLAUDE_HOOK_VERSION = '0.3.0-beta.13';
+const CLAUDE_HOOK_VERSION = '0.3.0-beta.18';
 const MAX_DIAGNOSTIC_BYTE_COUNT = 128 * 1024 * 1024;
 const COOLDOWN_MS = 60_000;
 const MAX_TRUNCATED_CODE_POINTS = 300;
@@ -686,6 +687,8 @@ type ContextBudgetSnapshot = {
   readonly accountInFlight: boolean;
   readonly retryAfterMs: number;
   readonly expiresAt: string;
+  readonly requestStartedAtMonotonic: number;
+  readonly lifetimeMs: number;
   readonly windowEnd: string;
   readonly correlationId: string;
 };
@@ -699,7 +702,25 @@ type ContextBudgetRead =
       readonly error?: Error | undefined;
     };
 
-function parseContextBudget(value: unknown, now = Date.now()): ContextBudgetSnapshot | undefined {
+function monotonicNow(): number | undefined {
+  const host = globalThis as unknown as {
+    readonly performance?: { readonly now?: () => number };
+  };
+  const now = host.performance?.now;
+  if (typeof now !== 'function') return undefined;
+  try {
+    const value = now.call(host.performance);
+    return Number.isFinite(value) && value >= 0 ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function parseContextBudget(
+  value: unknown,
+  requestStartedAt: number,
+  responseReceivedAt: number,
+): ContextBudgetSnapshot | undefined {
   if (!isRecord(value)) return undefined;
   const allowed = [
     'schema_version',
@@ -727,9 +748,22 @@ function parseContextBudget(value: unknown, now = Date.now()): ContextBudgetSnap
     !Number.isFinite(Date.parse(value.window_end))
   )
     return undefined;
+  const serverTime = Date.parse(value.server_time);
   const expiresAt = Date.parse(value.expires_at);
   const windowEnd = Date.parse(value.window_end);
-  if (expiresAt <= now || expiresAt - now > BUDGET_SNAPSHOT_MAX_AGE_MS || windowEnd < expiresAt)
+  const snapshotLifetimeMs = expiresAt - serverTime;
+  const requestElapsedMs = responseReceivedAt - requestStartedAt;
+  if (
+    !Number.isFinite(requestStartedAt) ||
+    !Number.isFinite(responseReceivedAt) ||
+    requestStartedAt < 0 ||
+    requestElapsedMs < 0 ||
+    !Number.isSafeInteger(snapshotLifetimeMs) ||
+    snapshotLifetimeMs <= 0 ||
+    snapshotLifetimeMs > BUDGET_SNAPSHOT_MAX_AGE_MS ||
+    requestElapsedMs >= snapshotLifetimeMs ||
+    windowEnd < expiresAt
+  )
     return undefined;
   const nonnegative = (candidate: unknown): candidate is number =>
     typeof candidate === 'number' && Number.isSafeInteger(candidate) && candidate >= 0;
@@ -742,10 +776,8 @@ function parseContextBudget(value: unknown, now = Date.now()): ContextBudgetSnap
     !nonnegative(value.retry_after_ms) ||
     value.retry_after_ms > 3_600_000 ||
     typeof value.account_in_flight !== 'boolean' ||
-    !nonnegative(value.provider_batches) ||
-    value.provider_batches > 4 ||
-    (value.provider_model !== null &&
-      (typeof value.provider_model !== 'string' || value.provider_model.length > 128))
+    value.provider_batches !== 0 ||
+    value.provider_model !== null
   )
     return undefined;
   const correlationId = boundedSafeIdentifier(value.correlation_id);
@@ -758,6 +790,8 @@ function parseContextBudget(value: unknown, now = Date.now()): ContextBudgetSnap
     accountInFlight: value.account_in_flight,
     retryAfterMs: value.retry_after_ms,
     expiresAt: value.expires_at,
+    requestStartedAtMonotonic: requestStartedAt,
+    lifetimeMs: snapshotLifetimeMs,
     windowEnd: value.window_end,
     correlationId,
   };
@@ -777,8 +811,14 @@ function mcpStructuredValue(response: McpResult, maxTextBytes = 8 * 1024): unkno
   }
 }
 
-async function readContextBudget(api: HookApi, server: string): Promise<ContextBudgetRead> {
+export async function readContextBudget(
+  api: HookApi,
+  server: string,
+  now: MonotonicClock = monotonicNow,
+): Promise<ContextBudgetRead> {
   try {
+    const requestStartedAt = now();
+    if (requestStartedAt === undefined) return { ok: false, kind: 'provider_unavailable' };
     const call = api.mcp.call(server, 'brain_context_budget', { schema_version: 1 });
     const hostTimers = globalThis as unknown as {
       setTimeout?: (callback: () => void, delay: number) => unknown;
@@ -792,8 +832,12 @@ async function readContextBudget(api: HookApi, server: string): Promise<ContextB
         resolve(undefined);
       }, BUDGET_PREFLIGHT_TIMEOUT_MS);
     });
-    const response = await Promise.race([call, timeout]);
-    if (timer !== undefined) hostTimers.clearTimeout?.(timer);
+    let response: McpResult | undefined;
+    try {
+      response = await Promise.race([call, timeout]);
+    } finally {
+      if (timer !== undefined) hostTimers.clearTimeout?.(timer);
+    }
     if (response === undefined)
       return { ok: false, kind: timedOut ? 'timeout' : 'invalid_response' };
     if (response.isError === true) {
@@ -804,7 +848,15 @@ async function readContextBudget(api: HookApi, server: string): Promise<ContextB
         error,
       };
     }
-    const snapshot = parseContextBudget(mcpStructuredValue(response));
+    const responseReceivedAt = now();
+    if (responseReceivedAt === undefined) return { ok: false, kind: 'provider_unavailable' };
+    if (responseReceivedAt - requestStartedAt > BUDGET_PREFLIGHT_TIMEOUT_MS)
+      return { ok: false, kind: 'timeout' };
+    const snapshot = parseContextBudget(
+      mcpStructuredValue(response),
+      requestStartedAt,
+      responseReceivedAt,
+    );
     return snapshot === undefined
       ? { ok: false, kind: 'invalid_response' }
       : { ok: true, snapshot };
@@ -823,6 +875,25 @@ async function readContextBudget(api: HookApi, server: string): Promise<ContextB
   }
 }
 
+export function contextBudgetIsFresh(
+  snapshot: ContextBudgetSnapshot,
+  now = monotonicNow(),
+): boolean {
+  const elapsedMs = now === undefined ? Number.NaN : now - snapshot.requestStartedAtMonotonic;
+  return (
+    now !== undefined &&
+    Number.isFinite(now) &&
+    Number.isFinite(snapshot.requestStartedAtMonotonic) &&
+    Number.isSafeInteger(snapshot.lifetimeMs) &&
+    snapshot.requestStartedAtMonotonic >= 0 &&
+    snapshot.lifetimeMs > 0 &&
+    snapshot.lifetimeMs <= BUDGET_SNAPSHOT_MAX_AGE_MS &&
+    Number.isFinite(elapsedMs) &&
+    elapsedMs >= 0 &&
+    elapsedMs < snapshot.lifetimeMs
+  );
+}
+
 function safeRpcStatus(error: unknown): number | undefined {
   const record = isRecord(error) ? error : {};
   const candidate = record.rpc_status ?? record.status ?? record.code;
@@ -930,6 +1001,7 @@ const CHECKPOINT_ERRORS: readonly CheckpointError[] = [
 type CompactErrorCode =
   | 'state_budget_exceeded'
   | 'shared_admission_exceeded'
+  | 'budget_response_invalid'
   | 'provider_budget_exceeded'
   | 'provider_unavailable'
   | 'provider_auth_denied'
@@ -944,6 +1016,7 @@ type CompactErrorCode =
 const COMPACT_ERROR_CODES: readonly CompactErrorCode[] = [
   'state_budget_exceeded',
   'shared_admission_exceeded',
+  'budget_response_invalid',
   'provider_budget_exceeded',
   'provider_unavailable',
   'provider_auth_denied',
@@ -974,6 +1047,7 @@ type ObservationRecord = {
     | 'compact_entry'
     | 'compact_exit'
     | 'native_summary_proof'
+    | 'native_fallback_proof'
     | 'native_error';
   readonly category:
     | 'observed'
@@ -1790,6 +1864,37 @@ async function flushProofDiagnostic(
   ]);
 }
 
+async function flushNativeFallbackProofDiagnostic(
+  api: HookApi,
+  options: ObservationOptions,
+  operationId: string,
+  sessionId: string,
+  instanceId: string,
+  clientVersion: string,
+  fields: Pick<
+    ObservationRecord,
+    | 'proof_expected_count'
+    | 'proof_actual_count'
+    | 'proof_match'
+    | 'proof_match_offset'
+    | 'proof_view_source'
+    | 'proof_api_view_match'
+    | 'proof_api_count'
+  >,
+): Promise<void> {
+  if (!options.diagnosticsEnabled) return;
+  await flushObservationDiagnostics(api, options, operationId, sessionId, instanceId, [
+    observationRecord(
+      operationId,
+      'native_fallback_proof',
+      'observed',
+      clientVersion,
+      undefined,
+      fields,
+    ),
+  ]);
+}
+
 async function flushNativeSummaryProofDiagnostic(
   api: HookApi,
   options: ObservationOptions,
@@ -3590,6 +3695,8 @@ type PendingFallbackProof = {
   readonly expected_hash?: string;
   readonly expected_count?: number;
   readonly expected_message_hashes?: readonly string[];
+  readonly delivery_mode?: 'atomic_marker';
+  readonly marker_digest?: string;
   readonly anchor_counts?: readonly number[];
   readonly anchor_hashes?: readonly string[];
   readonly expires_at: string;
@@ -4131,6 +4238,8 @@ function structurallyValidPendingProof(value: unknown): value is PendingProof {
           'expected_hash',
           'expected_count',
           'expected_message_hashes',
+          'delivery_mode',
+          'marker_digest',
           'anchor_counts',
           'anchor_hashes',
           'expires_at',
@@ -4161,6 +4270,10 @@ function structurallyValidPendingProof(value: unknown): value is PendingProof {
           value.expected_message_hashes.every(
             (hash): hash is string => typeof hash === 'string' && /^[a-f0-9]{16}$/u.test(hash),
           ))) &&
+      (value.delivery_mode === undefined || value.delivery_mode === 'atomic_marker') &&
+      (value.marker_digest === undefined || /^[a-f0-9]{64}$/u.test(String(value.marker_digest))) &&
+      ((value.delivery_mode === undefined && value.marker_digest === undefined) ||
+        (value.delivery_mode === 'atomic_marker' && typeof value.marker_digest === 'string')) &&
       ((value.anchor_counts === undefined && value.anchor_hashes === undefined) ||
         (Array.isArray(value.anchor_counts) &&
           Array.isArray(value.anchor_hashes) &&
@@ -4803,6 +4916,26 @@ function getTelemetry(
   return state.current;
 }
 
+async function nativeFallbackMarker(
+  operationId: string,
+  sessionRef: string,
+  baselineHash: string,
+): Promise<{ readonly text: string; readonly digest: string }> {
+  const digest = await sha256(
+    `aibrain-native-fallback-v1|${operationId}|${sessionRef}|${baselineHash}`,
+  );
+  return { digest, text: `[AI Brain native fallback receipt v1:${digest}]` };
+}
+
+function nativeFallbackDeliveryResult(nativeResult: unknown, marker: string): unknown {
+  const messages = nativeResultMessages(nativeResult);
+  if (messages === undefined || messages.length === 0) return nativeResult;
+  return {
+    ...(nativeResult as Record<string, unknown>),
+    messages: [...messages, { role: 'user', text: marker, toolUses: [] }],
+  };
+}
+
 async function queueNativeFallbackProof(
   api: HookApi,
   runtime: ProofRuntimeState,
@@ -4813,7 +4946,7 @@ async function queueNativeFallbackProof(
   nativeResult: unknown,
   beforeVisibleMessages: readonly string[] | undefined,
   activeOffset: number | undefined,
-): Promise<void> {
+): Promise<unknown> {
   const expectedMessages = nativeResultMessages(nativeResult);
   const expectedHash =
     expectedMessages === undefined
@@ -4831,6 +4964,10 @@ async function queueNativeFallbackProof(
     beforeVisibleMessages === undefined || expectedMessages === undefined
       ? undefined
       : await nativeProofAnchors(beforeVisibleMessages, expectedMessages.length, activeOffset);
+  const marker =
+    expectedMessages === undefined
+      ? undefined
+      : await nativeFallbackMarker(operationId, sessionRef, baselineHash);
   const proof: PendingFallbackProof = {
     schema_version: 1,
     kind: 'native_fallback',
@@ -4844,6 +4981,9 @@ async function queueNativeFallbackProof(
     ...(expectedMessageHashes === undefined
       ? {}
       : { expected_message_hashes: expectedMessageHashes }),
+    ...(marker === undefined
+      ? {}
+      : { delivery_mode: 'atomic_marker' as const, marker_digest: marker.digest }),
     ...(anchors === undefined
       ? {}
       : { anchor_counts: anchors.counts, anchor_hashes: anchors.hashes }),
@@ -4854,6 +4994,9 @@ async function queueNativeFallbackProof(
   };
   runtime.pendingProofMemory = proof;
   runtime.pendingProofPersistenceFailed = !(await savePendingProof(api, proof));
+  return runtime.pendingProofPersistenceFailed || marker === undefined
+    ? nativeResult
+    : nativeFallbackDeliveryResult(nativeResult, marker.text);
 }
 
 async function confirmPendingProof(
@@ -4937,38 +5080,83 @@ async function confirmPendingProof(
       proof_actual_count: messages.length,
     };
     if (proof.expected_hash !== undefined && expectedCount !== undefined) {
-      fallbackMatch = await nativeSummaryViewMatch(
-        messages,
-        expectedCount,
-        proof.expected_hash,
-        proof.expected_message_hashes,
-        proof.anchor_counts,
-        proof.anchor_hashes,
-      );
-      const fallbackOffset =
-        fallbackMatch === 'active_suffix'
-          ? await nativeSummaryMatchedOffset(
-              messages,
-              expectedCount,
-              proof.expected_hash,
-              proof.expected_message_hashes,
-              proof.anchor_counts,
-              proof.anchor_hashes,
-            )
-          : undefined;
-      fallbackProofFields = {
-        ...fallbackProofFields,
-        proof_match: fallbackMatch,
-        ...(fallbackMatch === 'exact' ? { proof_match_offset: 0 } : {}),
-        ...(fallbackOffset === undefined ? {} : { proof_match_offset: fallbackOffset }),
-      };
-      verified = fallbackMatch === 'exact' || fallbackMatch === 'active_suffix';
+      if (proof.delivery_mode === 'atomic_marker' && proof.marker_digest !== undefined) {
+        try {
+          const apiView = await boundedApiMessages(api);
+          const marker = await nativeFallbackMarker(
+            proof.operation_id,
+            sessionRef,
+            proof.baseline_hash,
+          );
+          const markerValid = marker.digest === proof.marker_digest;
+          const markerCount = exactTextCount(apiView, marker.text);
+          fallbackProofFields = {
+            ...fallbackProofFields,
+            proof_view_source: 'api',
+            proof_api_view_match: markerValid && markerCount === 1 ? 'exact' : 'mismatch',
+            proof_api_count: apiView.length,
+          };
+          if (markerValid && markerCount === 1) {
+            fallbackMatch = 'exact';
+            fallbackProofFields = {
+              ...fallbackProofFields,
+              proof_match: 'exact',
+              proof_match_offset: 0,
+            };
+            verified = true;
+          }
+        } catch {
+          fallbackProofFields = {
+            ...fallbackProofFields,
+            proof_view_source: 'api',
+            proof_api_view_match: 'unavailable',
+          };
+        }
+      } else {
+        // Compatibility with proofs written by beta15 and earlier. These
+        // proofs predate the API-view fingerprint and retain the old strict
+        // default-view check.
+        fallbackMatch = await nativeSummaryViewMatch(
+          messages,
+          expectedCount,
+          proof.expected_hash,
+          proof.expected_message_hashes,
+          proof.anchor_counts,
+          proof.anchor_hashes,
+        );
+        const fallbackOffset =
+          fallbackMatch === 'active_suffix'
+            ? await nativeSummaryMatchedOffset(
+                messages,
+                expectedCount,
+                proof.expected_hash,
+                proof.expected_message_hashes,
+                proof.anchor_counts,
+                proof.anchor_hashes,
+              )
+            : undefined;
+        fallbackProofFields = {
+          ...fallbackProofFields,
+          proof_view_source: 'default',
+          proof_match: fallbackMatch,
+          ...(fallbackMatch === 'exact' ? { proof_match_offset: 0 } : {}),
+          ...(fallbackOffset === undefined ? {} : { proof_match_offset: fallbackOffset }),
+        };
+        verified = fallbackMatch === 'exact' || fallbackMatch === 'active_suffix';
+      }
     }
   }
   if (runtime.pendingProofPersistenceFailed) verified = false;
   const telemetry = getTelemetry(api, runtime.brainServer, runtime.options, runtime.telemetryState);
   if (!verified) {
-    if (deferMismatch) return;
+    // Only the atomic native fallback marker may wait for the host's active
+    // API view. A prepared JEV capsule remains strict at every callback.
+    if (
+      deferMismatch &&
+      proof.kind === 'native_fallback' &&
+      proof.delivery_mode === 'atomic_marker'
+    )
+      return;
     runtime.pendingProofMemory = undefined;
     runtime.pendingProofPersistenceFailed = false;
     await clearPendingProof(api, sessionRef);
@@ -4993,6 +5181,16 @@ async function confirmPendingProof(
   runtime.pendingProofMemory = undefined;
   runtime.pendingProofPersistenceFailed = false;
   await clearPendingProof(api, sessionRef);
+  if (proof.kind === 'native_fallback')
+    await flushNativeFallbackProofDiagnostic(
+      api,
+      runtime.observation,
+      proof.operation_id,
+      sessionRef,
+      runtime.observationInstanceId,
+      nativeClientVersion(runtime.options),
+      fallbackProofFields,
+    );
   if (proof.kind === 'custom') {
     const dropped = proof.pairs.filter((pair) => pair.action === 'drop_pair').length;
     const reduced = proof.pairs.filter((pair) => pair.action === 'truncate_result').length;
@@ -5461,7 +5659,11 @@ async function runShadowPreview(
     );
 }
 
-export const register: Register = (on, options) => {
+const registerWithClock = (
+  on: Parameters<Register>[0],
+  options: HookOptions,
+  monotonicClock: MonotonicClock,
+): void => {
   const enabled = options.enabled === true;
   const disclosed = options.disclosed === true;
   const preservationMode: PreservationMode =
@@ -5579,7 +5781,10 @@ export const register: Register = (on, options) => {
 
   on('prompt.submit', async (api, rawEvent, next) => {
     const event = rawEvent as unknown as PromptSubmitHookEvent;
-    await confirmPendingProof(api, proofRuntime, true);
+    // The host has completed the prior native turn before accepting a new
+    // prompt. This is the final proof opportunity for a fallback whose first
+    // turn.complete callback observed the retired/default view.
+    await confirmPendingProof(api, proofRuntime);
     if (
       proofRuntime.compactionStrategy === 'native_summary_notes' &&
       enabled &&
@@ -5654,7 +5859,10 @@ export const register: Register = (on, options) => {
   });
 
   on('turn.complete', async (api, event, next) => {
-    await confirmPendingProof(api, proofRuntime);
+    // The native host can publish the result before its active API view catches
+    // up. Keep only the atomic fallback marker pending through this lifecycle
+    // edge; prompt.submit performs the strict confirmation on the next turn.
+    await confirmPendingProof(api, proofRuntime, true);
     if (
       proofRuntime.compactionStrategy === 'native_summary_notes' &&
       enabled &&
@@ -5826,7 +6034,7 @@ export const register: Register = (on, options) => {
       nativeContinuationStarted = true;
       const nativeResult = await next(event);
       if (fallbackCapture !== undefined)
-        await queueNativeFallbackProof(
+        return queueNativeFallbackProof(
           api,
           proofRuntime,
           fallbackCapture.operationId,
@@ -6044,7 +6252,7 @@ export const register: Register = (on, options) => {
         markDiagnostic('budget', 'provider_not_attempted', {
           item_count: built.pairs.filter((pair) => !pair.protectedPair).length,
         });
-        const budgetRead = await readContextBudget(api, brainServer);
+        const budgetRead = await readContextBudget(api, brainServer, monotonicClock);
         if (!budgetRead.ok) {
           const admission = budgetRead.kind === 'admission_denied';
           const category: ObservationRecord['category'] = admission
@@ -6059,8 +6267,13 @@ export const register: Register = (on, options) => {
           const errorMetadata: Partial<ContextErrorMetadata> = isRecord(budgetRead.error)
             ? (budgetRead.error as ContextErrorMetadata)
             : {};
+          const budgetErrorCode = admission
+            ? 'shared_admission_exceeded'
+            : budgetRead.kind === 'invalid_response'
+              ? 'budget_response_invalid'
+              : 'provider_unavailable';
           markDiagnostic('budget', category, {
-            compact_error_code: admission ? 'shared_admission_exceeded' : 'provider_unavailable',
+            compact_error_code: budgetErrorCode,
             ...(typeof errorMetadata.admissionDetail === 'string'
               ? { admission_detail: errorMetadata.admissionDetail }
               : {}),
@@ -6075,7 +6288,7 @@ export const register: Register = (on, options) => {
               : {}),
           });
           markDiagnostic('fallback', category, {
-            compact_error_code: admission ? 'shared_admission_exceeded' : 'provider_unavailable',
+            compact_error_code: budgetErrorCode,
           });
           logFallback(
             api,
@@ -6243,18 +6456,42 @@ export const register: Register = (on, options) => {
           projection: providerProjection,
           ...(policyVersion === 2 ? { schema_version: 2, options: wireOptions } : {}),
         };
+        await persistDiagnostics();
+        if (!contextBudgetIsFresh(budget, monotonicClock())) {
+          markDiagnostic('budget', 'invalid_response', {
+            compact_error_code: 'budget_response_invalid',
+          });
+          markDiagnostic('fallback', 'invalid_response', {
+            compact_error_code: 'budget_response_invalid',
+          });
+          logFallback(api, 'budget_unavailable', undefined, policyVersion === 2);
+          getTelemetry(api, brainServer, options, telemetryState).fallback(
+            operationId,
+            'budget_unavailable',
+          );
+          return continueWithTelemetryFlush({
+            operationId,
+            sessionRef,
+            baselineHash: rereadBaselineHash,
+            baselineCount: reread.length,
+            beforeVisibleMessages: visibleMessageCanonicalStrings(reread),
+            activeOffset: baselineActiveOffset,
+          });
+        }
         stage = 'mcp_call';
         markDiagnostic('provider_request', 'request_attempted', {
           item_count: providerPairs.filter((pair) => !pair.protectedPair).length,
           byte_count: byteLength(JSON.stringify(input)),
         });
-        await persistDiagnostics();
         if (diagnosticMode)
           api.ui.log(
             `AI Brain context diagnostic ${JSON.stringify({ hook: 'session.compact', phase: 'mcp_started' })}`,
           );
         const call = api.mcp.call(brainServer, 'brain_context_compact', input);
         pendingMcp = call;
+        // The request has started, so persist its attempt without delaying the
+        // budget freshness check or extending the provider deadline.
+        void persistDiagnostics();
         let timedOut = false;
         const hostTimers = globalThis as unknown as {
           setTimeout?: (callback: () => void, delay: number) => unknown;
@@ -6681,3 +6918,13 @@ export const register: Register = (on, options) => {
     });
   });
 };
+
+export const register: Register = (on, options) => registerWithClock(on, options, monotonicNow);
+
+export function registerForTesting(
+  on: Parameters<Register>[0],
+  options: HookOptions,
+  monotonicClock: MonotonicClock,
+): void {
+  registerWithClock(on, options, monotonicClock);
+}

package/dist/assets/claude/hooks/native-host-contract.test.ts

@@ -1,6 +1,8 @@
 import { expect, test } from 'claude-code/testing';
 
 const contractTest: Parameters<typeof test>[2] = async ($, on) => {
+  const monotonicStart = globalThis.performance?.now?.();
+  expect(Number.isFinite(monotonicStart)).toBe(true);
   on('prompt.submit', () => ({ text: 'native-host-contract-ok' }));
   on('tool.call', () => ({ result: { content: 'native-host-tool-ok' } }));
   on('session.messages', () => ({ value: [] }));
@@ -34,6 +36,13 @@ const contractTest: Parameters<typeof test>[2] = async ($, on) => {
   expect(tool.result.content).toBe('native-host-tool-ok');
   expect(usageCalls).toBe(1);
   expect(compactCalls).toBe(1);
+  const monotonicEnd = globalThis.performance?.now?.();
+  expect(Number.isFinite(monotonicEnd)).toBe(true);
+  expect(
+    typeof monotonicStart === 'number' &&
+      typeof monotonicEnd === 'number' &&
+      monotonicEnd >= monotonicStart,
+  ).toBe(true);
 };
 
 test(