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

package/README.md

@@ -11,7 +11,7 @@ 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
@@ -22,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.16';
+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',
@@ -5586,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 =
@@ -6175,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
@@ -6190,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 }
               : {}),
@@ -6206,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,
@@ -6374,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;
@@ -6812,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(