@brunobracaioli/aibrain 0.3.0-beta.13 → 0.3.0-beta.14

package/README.md

@@ -3,11 +3,22 @@
 Assisted AI Brain context beta client for Linux/WSL with Node.js 22 or newer.
 
 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 or 2.1.302, and Codex CLI 0.161.0,
+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
 after its locally generated experimental protocol schemas and transport flags
 match the bundled adapter contract; prereleases, older releases and new majors
-remain rejected.
+remain rejected. Starting with beta14, newer stable Claude 2.1 patches can
+continue after isolated strict plugin validation, required hook/API checks and
+an enabled-hook test in the native offline runner. Doctor distinguishes
+`host_checked` from `qualified`; this check does not establish full behavioral
+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.
+
+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
+connection. Its failure or timeout closes only that auxiliary connection.
 
 ```sh
 # Install the published beta:
@@ -57,7 +68,7 @@ text; they do not claim that a live session is being monitored. Codex keeps nati
 compaction and recovery notes in the same thread. The backend checks paid access
 and unchanged shared quotas before any JEV request.
 
-The `0.3.0-beta.13` Claude launcher uses the durable context strategy and
+The `0.3.0-beta.14` Claude launcher uses the durable context strategy and
 records bounded recovery reasons when native summary proof cannot be confirmed:
 JEV selects compatible historical tool evidence, bounded private notes retain
 the selected text, and Claude core summarizes the reduced input. The next

package/dist/assets/claude/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-brain-context-compaction",
-  "version": "0.3.0-beta.13",
+  "version": "0.3.0-beta.14",
   "author": { "name": "AISAC" },
   "description": "AI Brain paid-plan context monitoring with conservative Claude compaction fallback.",
   "hooks": "./hooks/hooks.json",

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

@@ -0,0 +1,18 @@
+import { register as registerContext } from './context-compaction.ts';
+
+export function register(on: Parameters<typeof registerContext>[0]): void {
+  return registerContext(on, {
+    enabled: true,
+    disclosed: true,
+    policyVersion: 2,
+    compactAtPercent: 60,
+    keepThreshold: 0.5,
+    preserveRecentMessages: 6,
+    minReductionRatio: 0.25,
+    truncateHeadChars: 300,
+    maxStateTokens: 25_000,
+    maxRequestTokens: 30_000,
+    compactionStrategy: 'native_summary_notes',
+    preservationMode: 'upstream_compatible',
+  });
+}

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

@@ -0,0 +1,42 @@
+import { expect, test } from 'claude-code/testing';
+
+const contractTest: Parameters<typeof test>[2] = async ($, on) => {
+  on('prompt.submit', () => ({ text: 'native-host-contract-ok' }));
+  on('tool.call', () => ({ result: { content: 'native-host-tool-ok' } }));
+  on('session.messages', () => ({ value: [] }));
+  let usageCalls = 0;
+  on('session.usage', () => ({
+    value: (() => {
+      usageCalls += 1;
+      return { context: { percent: 90, tokens: 900, window: 1_000 } };
+    })(),
+  }));
+  on('ui.log', () => ({ value: undefined }));
+  on('ui.toast', () => ({ value: undefined }));
+  let compactCalls = 0;
+  on('session.compact', () => {
+    compactCalls += 1;
+    return {
+      messages: [{ role: 'assistant', text: 'native-summary-contract-ok', toolUses: [] }],
+    };
+  });
+  on('turn.complete', () => ({ text: '' }));
+  const prompt = await $.prompt.submit({ text: 'native-host-contract-input' });
+  const tool = await $.tool.call({ tool: 'Read', file_path: 'native-host-contract.txt' });
+  await $.turn.complete({
+    turnId: 'native-contract-turn',
+    answer: 'native-turn-contract-ok',
+    durationMs: 1,
+    isAborted: false,
+    usage: null,
+  });
+  expect(prompt.text).toBe('native-host-contract-ok');
+  expect(tool.result.content).toBe('native-host-tool-ok');
+  expect(usageCalls).toBe(1);
+  expect(compactCalls).toBe(1);
+};
+
+test(
+  'AI Brain enabled host contract invokes usage and native compaction through the dispatcher',
+  contractTest,
+);

package/dist/assets/jev-paid-pilot-terminal.mjs

@@ -12,6 +12,11 @@ const MAX_FRAME_BYTES = 16 * 1024 * 1024;
 const MAX_QUEUED_FRAMES = 64;
 const MAX_QUEUED_BYTES = 32 * 1024 * 1024;
 const STARTUP_HANDOFF_GRACE_MS = 5_000;
+const MAX_AUXILIARY_CONNECTIONS = 1;
+const MAX_AUXILIARY_MESSAGES = 64;
+const MAX_AUXILIARY_IN_FLIGHT = 32;
+const MAX_AUXILIARY_NOTIFICATIONS = 256;
+const DEFAULT_AUXILIARY_IDLE_TIMEOUT_MS = 120_000;
 const NORMAL_DISCOVERY_CLOSE_CODES = new Set([1000, 1001, 1005]);
 
 function repoRoot() {
@@ -60,7 +65,13 @@ async function main() {
   const codexBinary = process.env.CODEX_BIN ?? 'codex';
   const nativeArgs =
     process.argv.slice(2)[0] === '--' ? process.argv.slice(3) : process.argv.slice(2);
-  const allowStartupHandoff = nativeArgs[0] === 'resume';
+  // The bridge owns an interactive Codex TUI transport. Any native command
+  // that reaches this bridge may perform a short-lived read-only bootstrap
+  // before attaching its conversation transport. The protocol boundary below
+  // is the authority: initialize, same-client identity, successful allowlisted
+  // discovery, no started operation, one candidate, and a five-second deadline.
+  // Non-interactive Codex subcommands never open the socket and exit normally.
+  const allowStartupHandoff = true;
   const childEnv = { ...process.env };
   delete childEnv.JEV_API_KEY;
   delete childEnv.TYPESAFE_API_KEY;
@@ -71,11 +82,19 @@ async function main() {
   const generations = new Set();
   let activeConnection = null;
   let pendingCandidate = null;
+  const auxiliaryConnections = new Set();
   let handoffCount = 0;
   let handoffAttemptCount = 0;
   let socketUpgradeCount = 0;
   let secondConnectionRejectCount = 0;
   let candidateRejectCount = 0;
+  let auxiliaryConnectionCount = 0;
+  let auxiliaryRejectCount = 0;
+  let auxiliaryMutationRejectCount = 0;
+  let auxiliaryUnknownResponseCount = 0;
+  let auxiliaryIdleTimeoutCount = 0;
+  let auxiliaryMessageCount = 0;
+  let auxiliaryNotificationCount = 0;
   let shuttingDown = false;
   const reportPath = process.env.CODEX_TERMINAL_BRIDGE_REPORT;
   let initializeReceived = false;
@@ -110,10 +129,12 @@ async function main() {
   };
   const READ_ONLY_DISCOVERY = new Set([
     'account/read',
+    'account/bedrock/checkGovCloudRequirements',
+    'config/read',
+    'configRequirements/read',
     'thread/list',
     'thread/read',
     'model/list',
-    'configRequirements/read',
     'collaborationMode/list',
     'hooks/list',
     'thread/turns/list',
@@ -131,6 +152,8 @@ async function main() {
     'initialize',
     'initialized',
     'account/read',
+    'account/bedrock/checkGovCloudRequirements',
+    'config/read',
     'thread/list',
     'thread/read',
     'model/list',
@@ -192,6 +215,10 @@ async function main() {
         rejectCandidate(generation.connection, 1011, 'candidate_monitor_failed');
         return;
       }
+      if (generation.connection?.isAuxiliary) {
+        rejectAuxiliary(generation.connection, 'auxiliary_monitor_failed');
+        return;
+      }
       monitorExitCode = code;
       void cleanup().finally(() => process.exit(code));
     };
@@ -270,6 +297,10 @@ async function main() {
       rejectCandidate(connection, 1013, reason);
       return;
     }
+    if (connection?.isAuxiliary) {
+      rejectAuxiliary(connection, reason);
+      return;
+    }
     if (connection) connection.retiring = true;
     cleanupGeneration(generation);
     connection?.socket.close(1013, reason);
@@ -310,7 +341,7 @@ async function main() {
         ),
         new Promise((resolve) => setTimeout(resolve, 500)),
       ]);
-      for (const connection of [activeConnection, pendingCandidate]) {
+      for (const connection of [activeConnection, pendingCandidate, ...auxiliaryConnections]) {
         if (connection?.socket.readyState === WebSocket.OPEN)
           connection.socket.close(1001, 'bridge stopped');
         connection?.socket.terminate();
@@ -350,6 +381,13 @@ async function main() {
             socket_upgrade_count: socketUpgradeCount,
             second_connection_reject_count: secondConnectionRejectCount,
             candidate_reject_count: candidateRejectCount,
+            auxiliary_connection_count: auxiliaryConnectionCount,
+            auxiliary_reject_count: auxiliaryRejectCount,
+            auxiliary_mutation_reject_count: auxiliaryMutationRejectCount,
+            auxiliary_unknown_response_count: auxiliaryUnknownResponseCount,
+            auxiliary_idle_timeout_count: auxiliaryIdleTimeoutCount,
+            auxiliary_message_count: auxiliaryMessageCount,
+            auxiliary_notification_count: auxiliaryNotificationCount,
             cleanup_initiator: cleanupInitiator,
             last_socket_close_code: lastSocketCloseCode,
             terminal_alive_at_socket_close: terminalAliveAtSocketClose,
@@ -410,6 +448,24 @@ async function main() {
     connection.initialized === true &&
     connection.initializeAck === true &&
     (connection.socket.readyState === WebSocket.OPEN || connection.discoveryClosed === true);
+  const auxiliaryIdleTimeoutMs = (() => {
+    const value = Number.parseInt(process.env.CODEX_AUXILIARY_IDLE_TIMEOUT_MS ?? '', 10);
+    return Number.isSafeInteger(value) && value >= 1_000 && value <= 300_000
+      ? value
+      : DEFAULT_AUXILIARY_IDLE_TIMEOUT_MS;
+  })();
+  const rejectAuxiliary = (connection, reason = 'auxiliary_rejected') => {
+    if (!connection || connection.retiring || !connection.isAuxiliary) return;
+    connection.retiring = true;
+    if (connection.auxiliaryTimer !== null) clearTimeout(connection.auxiliaryTimer);
+    auxiliaryConnections.delete(connection);
+    auxiliaryRejectCount += 1;
+    if (reason === 'auxiliary_idle_timeout') auxiliaryIdleTimeoutCount += 1;
+    if (connection.socket.readyState === WebSocket.OPEN)
+      connection.socket.close(1008, reason);
+    else connection.socket.terminate();
+    cleanupGeneration(connection.generation);
+  };
   const rejectCandidate = (connection, statusCode = 1008, reason = 'handoff_rejected') => {
     if (!connection || connection.retiring) return;
     if (connection?.candidateTimer) clearTimeout(connection.candidateTimer);
@@ -474,7 +530,12 @@ async function main() {
     let parsed;
     try {
       parsed = JSON.parse(line.toString('utf8'));
-      if (connection.initializeId !== null && parsed.id === connection.initializeId) {
+      const isInitializeResponse =
+        connection.initializeId !== null &&
+        parsed.id === connection.initializeId &&
+        connection.initializeResponseConsumed === false;
+      if (isInitializeResponse) {
+        connection.initializeResponseConsumed = true;
         initializeResponseSeen = true;
         initializeErrorCode = parsed.error?.code ?? null;
         if (parsed.error === undefined && parsed.result !== undefined) {
@@ -501,6 +562,25 @@ async function main() {
       const isJsonRpcResponse =
         Object.prototype.hasOwnProperty.call(parsed, 'result') ||
         Object.prototype.hasOwnProperty.call(parsed, 'error');
+      if (connection.isAuxiliary && parsed.method !== undefined && parsed.id === undefined) {
+        auxiliaryNotificationCount += 1;
+        connection.auxiliaryNotificationCount += 1;
+        if (connection.auxiliaryNotificationCount > MAX_AUXILIARY_NOTIFICATIONS) {
+          rejectAuxiliary(connection, 'auxiliary_notification_limit');
+        }
+        return;
+      }
+      if (
+        connection.isAuxiliary &&
+        (parsed.method !== undefined ||
+          (isJsonRpcResponse &&
+            !isInitializeResponse &&
+            !connection.pendingRequests.has(parsed.id)))
+      ) {
+        auxiliaryUnknownResponseCount += 1;
+        rejectAuxiliary(connection, 'auxiliary_response_rejected');
+        return;
+      }
       if (
         isJsonRpcResponse &&
         parsed.id !== undefined &&
@@ -540,6 +620,11 @@ async function main() {
     } catch {
       parsed = null;
     }
+    if (connection.isAuxiliary && parsed === null) {
+      auxiliaryUnknownResponseCount += 1;
+      rejectAuxiliary(connection, 'auxiliary_response_rejected');
+      return;
+    }
     if (connection.socket.readyState !== WebSocket.OPEN) return;
     if (connection.socket.bufferedAmount + line.length > MAX_QUEUED_BYTES) {
       abortGeneration(generation, 'bridge_queue_limit');
@@ -555,18 +640,29 @@ async function main() {
       const parsed = JSON.parse(frame.toString('utf8'));
       if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
         throw new Error('bridge_message_not_object');
+      if (
+        connection.isAuxiliary &&
+        (typeof parsed.method !== 'string' ||
+          Object.prototype.hasOwnProperty.call(parsed, 'result') ||
+          Object.prototype.hasOwnProperty.call(parsed, 'error'))
+      ) {
+        auxiliaryMutationRejectCount += 1;
+        rejectAuxiliary(connection, 'auxiliary_client_frame_rejected');
+        return;
+      }
       const normalizedFrame = Buffer.from(JSON.stringify(parsed), 'utf8');
+      const wasInitialized = connection.initialized;
       if (!connection.initialized) {
         const initialize = parseInitialize(normalizedFrame.toString('utf8'));
         if (
-          connection.isCandidate &&
+          (connection.isCandidate || connection.isAuxiliary) &&
           !sameClient(activeConnection?.clientInfo, initialize.params.clientInfo)
         )
           throw new Error('handoff_client_mismatch');
         connection.initialized = true;
         connection.initializeId = initialize.id;
         connection.clientInfo = initialize.params.clientInfo;
-        if (!connection.isCandidate) {
+        if (!connection.isCandidate && !connection.isAuxiliary) {
           initializeReceived = true;
           experimentalApi = initialize.params.capabilities.experimentalApi === true;
         }
@@ -575,8 +671,30 @@ async function main() {
           connection.generation = spawnMonitor();
           connection.generation.connection = connection;
         }
+        if (connection.isAuxiliary && connection.generation === null) {
+          connection.generation = spawnMonitor();
+          connection.generation.connection = connection;
+        }
       }
-      if (parsed.method === 'turn/start') turnStartCount += 1;
+      if (connection.isAuxiliary) {
+        auxiliaryMessageCount += 1;
+        connection.auxiliaryMessageCount += 1;
+        if (connection.auxiliaryMessageCount > MAX_AUXILIARY_MESSAGES) {
+          rejectAuxiliary(connection, 'auxiliary_message_limit');
+          return;
+        }
+        if (connection.auxiliaryTimer !== null) clearTimeout(connection.auxiliaryTimer);
+        connection.auxiliaryTimer = setTimeout(
+          () => rejectAuxiliary(connection, 'auxiliary_idle_timeout'),
+          auxiliaryIdleTimeoutMs,
+        );
+      }
+      if (connection.isAuxiliary && wasInitialized && parsed.method === 'initialize') {
+        auxiliaryMutationRejectCount += 1;
+        rejectAuxiliary(connection, 'auxiliary_duplicate_initialize');
+        return;
+      }
+      if (parsed.method === 'turn/start' && !connection.isAuxiliary) turnStartCount += 1;
       if (typeof parsed.method === 'string') {
         if (DIAGNOSTIC_METHODS.has(parsed.method)) {
           if (observedMethods.size < MAX_DIAGNOSTIC_ENTRIES) observedMethods.add(parsed.method);
@@ -585,7 +703,33 @@ async function main() {
         }
         if (parsed.method === 'thread/resume') threadResumeCount += 1;
         if (parsed.method === 'initialize' || parsed.method === 'initialized') {
+          if (connection.isAuxiliary && parsed.method === 'initialized') {
+            if (connection.initializedNotificationSeen) {
+              auxiliaryMutationRejectCount += 1;
+              rejectAuxiliary(connection, 'auxiliary_duplicate_initialized');
+              return;
+            }
+            connection.initializedNotificationSeen = true;
+          }
           // The notification is part of the handshake and does not affect startup eligibility.
+        } else if (connection.isAuxiliary) {
+          if (!READ_ONLY_DISCOVERY.has(parsed.method)) {
+            auxiliaryMutationRejectCount += 1;
+            rejectAuxiliary(connection, 'auxiliary_mutation_rejected');
+            return;
+          }
+          const validRequestId =
+            (typeof parsed.id === 'string' && parsed.id.length > 0 && parsed.id.length <= 128) ||
+            (Number.isSafeInteger(parsed.id) && parsed.id >= 0);
+          if (
+            !validRequestId ||
+            connection.pendingRequests.has(parsed.id) ||
+            connection.pendingRequests.size >= MAX_AUXILIARY_IN_FLIGHT
+          ) {
+            rejectAuxiliary(connection, 'auxiliary_request_limit');
+            return;
+          }
+          connection.pendingRequests.set(parsed.id, parsed.method);
         } else if (READ_ONLY_DISCOVERY.has(parsed.method)) {
           const validRequestId =
             (typeof parsed.id === 'string' && parsed.id.length > 0 && parsed.id.length <= 128) ||
@@ -627,18 +771,22 @@ async function main() {
       }
     } catch (error) {
       if (connection.isCandidate) rejectCandidate(connection, 1008, safeError(error));
+      else if (connection.isAuxiliary) rejectAuxiliary(connection, safeError(error));
       else connection.socket.close(1008, safeError(error));
     }
   };
-  const attachConnection = (webSocket, isCandidate) => {
+  const attachConnection = (webSocket, isCandidate, isAuxiliary = false) => {
     const connection = {
       socket: webSocket,
-      generation: isCandidate ? null : initialGeneration,
+      generation: isCandidate || isAuxiliary ? null : initialGeneration,
       isCandidate,
-      isActive: !isCandidate,
+      isAuxiliary,
+      isActive: !isCandidate && !isAuxiliary,
       retiring: false,
       initialized: false,
       initializeId: null,
+      initializeResponseConsumed: false,
+      initializedNotificationSeen: false,
       initializeAck: false,
       clientInfo: null,
       pendingRequests: new Map(),
@@ -651,15 +799,27 @@ async function main() {
       handoffComplete: false,
       discoveryClosed: false,
       candidateTimer: null,
+      auxiliaryTimer: null,
+      auxiliaryMessageCount: 0,
+      auxiliaryNotificationCount: 0,
     };
-    if (!isCandidate) {
+    if (!isCandidate && !isAuxiliary) {
       activeConnection = connection;
       initialGeneration.connection = connection;
     }
+    if (isAuxiliary) {
+      auxiliaryConnections.add(connection);
+      auxiliaryConnectionCount += 1;
+      connection.auxiliaryTimer = setTimeout(
+        () => rejectAuxiliary(connection, 'auxiliary_idle_timeout'),
+        auxiliaryIdleTimeoutMs,
+      );
+    }
     webSocket.on('message', (data, isBinary) => handleClientMessage(connection, data, isBinary));
     webSocket.on('error', () => {
       if (connection.retiring || shuttingDown) return;
       if (connection.isCandidate) rejectCandidate(connection, 1011, 'candidate_socket_error');
+      else if (connection.isAuxiliary) rejectAuxiliary(connection, 'auxiliary_socket_error');
       else {
         cleanupInitiator = 'socket_error';
         recordLifecycle('socket_error');
@@ -672,6 +832,12 @@ async function main() {
       lastSocketCloseCode = code;
       terminalAliveAtSocketClose = terminal?.exitCode === null;
       recordLifecycle('socket_close');
+      if (connection.isAuxiliary) {
+        if (connection.auxiliaryTimer !== null) clearTimeout(connection.auxiliaryTimer);
+        auxiliaryConnections.delete(connection);
+        cleanupGeneration(connection.generation);
+        return;
+      }
       if (connection.isCandidate) {
         rejectCandidate(connection);
         return;
@@ -725,14 +891,23 @@ async function main() {
       closeSocket(socket, 403, 'origin_rejected');
       return;
     }
-    const isCandidate = activeConnection !== null;
-    if (isCandidate && !canHandoff(activeConnection)) {
+    const isCandidate = activeConnection !== null && canHandoff(activeConnection);
+    const isAuxiliary =
+      activeConnection !== null &&
+      !isCandidate &&
+      activeConnection.initialized === true &&
+      activeConnection.startedOperation === true;
+    if (
+      activeConnection !== null &&
+      !isCandidate &&
+      (!isAuxiliary || auxiliaryConnections.size >= MAX_AUXILIARY_CONNECTIONS)
+    ) {
       secondConnectionRejectCount += 1;
       closeSocket(socket, 409, 'second_connection_rejected');
       return;
     }
     webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
-      const connection = attachConnection(webSocket, isCandidate);
+      const connection = attachConnection(webSocket, isCandidate, isAuxiliary);
       if (isCandidate) {
         pendingCandidate = connection;
         connection.candidateTimer = setTimeout(

package/dist/claude-compatibility.mjs

@@ -0,0 +1,506 @@
+// @ts-check
+
+import {
+  chmod,
+  cp,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readdir,
+  realpath,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { spawn } from 'node:child_process';
+
+const MAX_OUTPUT_BYTES = 96 * 1024;
+const PROBE_TIMEOUT_MS = 30_000;
+const MAX_PLUGIN_ASSET_BYTES = 4 * 1024 * 1024;
+const MAX_PLUGIN_TOTAL_BYTES = 16 * 1024 * 1024;
+const HOST_MAJOR = 2;
+const HOST_MINOR = 1;
+const QUALIFIED_VERSIONS = new Set([
+  '2.1.294',
+  '2.1.295',
+  '2.1.296',
+  '2.1.299',
+  '2.1.300',
+  '2.1.301',
+  '2.1.302',
+  '2.1.303',
+]);
+const REQUIRED_FLAGS = ['--settings', '--mcp-config', '--allowedTools', '--plugin-dir'];
+const REQUIRED_INVENTORY = [
+  'prompt.submit',
+  'tool.call',
+  'session.end',
+  'turn.complete',
+  'session.compact',
+  '$.mcp.call',
+  '$.process.run',
+  '$.session.id',
+  '$.session.messages',
+  '$.session.usage',
+  '$.session.append',
+  '$.session.compact',
+  '$.store.get',
+  '$.store.set',
+  '$.store.delete',
+  '$.store.keys',
+  '$.ui.log',
+  '$.ui.toast',
+];
+const ALLOWED_PLUGIN_FILES = Object.freeze([
+  '.claude-plugin/plugin.json',
+  'hooks/hooks.json',
+  'hooks/context-compaction.ts',
+  'hooks/provider-window.js',
+  'hooks/state-fitting.mjs',
+  'hooks/state-fitting.d.mts',
+  'hooks/native-host-contract.test.ts',
+  'hooks/native-host-contract-runtime.ts',
+]);
+
+/** @param {string} executable */
+function safePath(executable) {
+  return [...new Set([dirname(executable), dirname(process.execPath), '/usr/bin', '/bin'])].join(
+    ':',
+  );
+}
+
+/** @param {string} executable @returns {Promise<string>} */
+async function readNativeVersion(executable) {
+  const root = await mkdtemp(join(tmpdir(), 'aibrain-claude-version-'));
+  const cwd = join(root, 'cwd');
+  const home = join(root, 'home');
+  const config = join(root, 'config');
+  await mkdir(cwd, { recursive: true, mode: 0o700 });
+  try {
+    /** @type {NodeJS.ProcessEnv} */
+    const environment = {
+      PATH: safePath(executable),
+      HOME: home,
+      CLAUDE_CONFIG_DIR: config,
+      CLAUDE_COMPAT_CWD: cwd,
+      NO_COLOR: '1',
+      CI: '1',
+      CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+    };
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    await mkdir(config, { recursive: true, mode: 0o700 });
+    const result = await runBounded(executable, ['--version'], environment, {
+      timeoutMs: 10_000,
+      maxOutputBytes: 2_048,
+    });
+    if (result.code !== 0 || result.overflow || result.timedOut) return '';
+    return result.stdout.split(/\r?\n/u, 1)[0]?.trim() ?? '';
+  } finally {
+    try {
+      await rm(root, { recursive: true, force: true });
+    } catch {
+      throw new Error('probe_cleanup_failed');
+    }
+  }
+}
+
+/** @typedef {'qualified'|'host_checked'|'rejected'} ClaudeCompatibilityStatus */
+
+/** @typedef {object} ClaudeCompatibility
+ * @property {ClaudeCompatibilityStatus} status
+ * @property {string|null} executable
+ * @property {string|null} version
+ * @property {string} reason
+ * @property {string[]} [checks]
+ */
+
+/** @param {string} output */
+export function parseClaudeStableVersion(output) {
+  const match = output
+    .trim()
+    .match(
+      /^(?:(?:claude(?:\s+code)?)\s+)?(0|[1-9]\d{0,2})\.(0|[1-9]\d{0,2})\.(0|[1-9]\d{0,2})(-[A-Za-z0-9.-]+)?(?:\s+\(Claude\s+Code\))?$/iu,
+    );
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] !== undefined,
+    text: `${match[1]}.${match[2]}.${match[3]}`,
+  };
+}
+
+/** @param {string} output */
+function parseVersion(output) {
+  return parseClaudeStableVersion(output) ?? null;
+}
+
+/** @param {string} executable @param {string[]} args @param {NodeJS.ProcessEnv} environment @param {{timeoutMs?:number,maxOutputBytes?:number}} [limits] */
+function runBounded(executable, args, environment, limits = {}) {
+  const timeoutMs = limits.timeoutMs ?? PROBE_TIMEOUT_MS;
+  const maxOutputBytes = limits.maxOutputBytes ?? MAX_OUTPUT_BYTES;
+  return new Promise((resolvePromise) => {
+    const child = spawn(executable, args, {
+      cwd: environment.CLAUDE_COMPAT_CWD,
+      env: environment,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+    });
+    let stdout = '';
+    let stderr = '';
+    let bytes = 0;
+    let overflow = false;
+    let settled = false;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      if (process.platform !== 'win32' && child.pid !== undefined) {
+        try {
+          process.kill(-child.pid, 'SIGKILL');
+        } catch {
+          child.kill('SIGKILL');
+        }
+      } else child.kill('SIGKILL');
+    }, timeoutMs);
+    /** @param {string} target @param {Buffer} chunk */
+    const append = (target, chunk) => {
+      bytes += chunk.byteLength;
+      if (bytes > maxOutputBytes) {
+        overflow = true;
+        return target;
+      }
+      return `${target}${chunk.toString('utf8')}`;
+    };
+    /** @param {number|null} code */
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise({ code, stdout, stderr, overflow, timedOut });
+    };
+    child.stdout.on('data', (chunk) => {
+      stdout = append(stdout, chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr = append(stderr, chunk);
+    });
+    child.once('error', () => finish(null));
+    child.once('close', (code) => finish(code));
+  });
+}
+
+/** @param {string} root @param {string} relativePath */
+async function assertNoSymlinkPath(root, relativePath) {
+  let current = resolve(root);
+  const parts = relativePath.split('/');
+  for (const part of parts) {
+    current = join(current, part);
+    const info = await lstat(current);
+    if (info.isSymbolicLink()) throw new Error('plugin_asset_symlink_rejected');
+  }
+}
+
+/** @param {string} source @param {string} destination */
+async function copyAllowlistedPlugin(source, destination) {
+  await mkdir(destination, { recursive: true, mode: 0o700 });
+  let totalBytes = 0;
+  for (const file of ALLOWED_PLUGIN_FILES) {
+    const input = join(source, file);
+    await assertNoSymlinkPath(source, file);
+    const info = await lstat(input);
+    if (!info.isFile() || info.isSymbolicLink()) throw new Error('plugin_asset_invalid');
+    const uid = process.getuid?.();
+    if (uid !== undefined && info.uid !== uid) throw new Error('plugin_asset_owner_mismatch');
+    if (info.size > MAX_PLUGIN_ASSET_BYTES) throw new Error('plugin_asset_too_large');
+    totalBytes += info.size;
+    if (totalBytes > MAX_PLUGIN_TOTAL_BYTES) throw new Error('plugin_assets_too_large');
+    const output = join(destination, file);
+    await mkdir(dirname(output), { recursive: true, mode: 0o700 });
+    await cp(input, output, { force: true, errorOnExist: true, verbatimSymlinks: true });
+    await chmod(output, 0o600);
+  }
+}
+
+/** @param {string} directory */
+async function assertEmptyDirectory(directory) {
+  const entries = await readdir(directory);
+  if (entries.length !== 0) throw new Error('probe_directory_not_empty');
+}
+
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function record(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/** @param {unknown} value @returns {value is string[]} */
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+
+/** @param {string} executable @param {string} pluginRoot @param {{timeoutMs?:number,maxOutputBytes?:number}} [limits] */
+async function runHostProbe(executable, pluginRoot, limits = {}) {
+  const root = await mkdtemp(join(tmpdir(), 'aibrain-claude-host-'));
+  const home = join(root, 'home');
+  const config = join(root, 'config');
+  const cwd = join(root, 'cwd');
+  const copiedPlugin = join(root, 'plugin');
+  const contractPlugin = join(root, 'contract-plugin');
+  await Promise.all([
+    mkdir(home, { recursive: true, mode: 0o700 }),
+    mkdir(config, { recursive: true, mode: 0o700 }),
+    mkdir(cwd, { recursive: true, mode: 0o700 }),
+  ]);
+  try {
+    await copyAllowlistedPlugin(pluginRoot, copiedPlugin);
+    await copyAllowlistedPlugin(pluginRoot, contractPlugin);
+    await writeFile(
+      join(contractPlugin, 'hooks', 'hooks.json'),
+      JSON.stringify({ modules: ['./native-host-contract-runtime.ts'] }),
+      { mode: 0o600 },
+    );
+    /** @type {NodeJS.ProcessEnv} */
+    const environment = {
+      PATH: safePath(executable),
+      HOME: home,
+      CLAUDE_CONFIG_DIR: config,
+      CLAUDE_COMPAT_CWD: cwd,
+      CLAUDE_CODE_ENABLE_FUNCTION_HOOKS: '1',
+      AIBRAIN_NATIVE_CONTRACT: '1',
+      CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1',
+      CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+      NO_COLOR: '1',
+      CI: '1',
+    };
+    const help = await runBounded(executable, ['--help'], environment, limits);
+    if (
+      help.code !== 0 ||
+      help.overflow ||
+      REQUIRED_FLAGS.some((flag) => !help.stdout.includes(flag))
+    )
+      return { ok: false, reason: 'launch_flags_missing' };
+    const validate = await runBounded(
+      executable,
+      ['plugin', 'validate', '--strict', '--json', copiedPlugin],
+      environment,
+      limits,
+    );
+    if (validate.code !== 0 || validate.overflow)
+      return { ok: false, reason: 'plugin_validation_failed' };
+    /** @type {Record<string, unknown>} */
+    let report;
+    try {
+      const parsed = JSON.parse(validate.stdout);
+      if (!record(parsed)) return { ok: false, reason: 'plugin_validation_malformed' };
+      report = parsed;
+    } catch {
+      return { ok: false, reason: 'plugin_validation_malformed' };
+    }
+    if (report.success !== true || report.strict !== true)
+      return { ok: false, reason: 'plugin_validation_failed' };
+    if (
+      !record(report.manifest) ||
+      !stringArray(report.manifest.errors) ||
+      !stringArray(report.manifest.warnings)
+    )
+      return { ok: false, reason: 'plugin_validation_malformed' };
+    if (
+      !Array.isArray(report.contents) ||
+      report.contents.length !== 1 ||
+      !report.contents.every(record)
+    )
+      return { ok: false, reason: 'plugin_validation_malformed' };
+    const contents = report.contents;
+    if (
+      !contents.every(
+        (item) => stringArray(item.errors) && stringArray(item.warnings) && stringArray(item.notes),
+      )
+    )
+      return { ok: false, reason: 'plugin_validation_malformed' };
+    const manifest = report.manifest;
+    const errors = [
+      ...(Array.isArray(manifest.errors) ? manifest.errors : []),
+      ...(Array.isArray(manifest.warnings) ? manifest.warnings : []),
+      ...contents.flatMap((item) => [
+        ...(Array.isArray(item.errors) ? item.errors : []),
+        ...(Array.isArray(item.warnings) ? item.warnings : []),
+      ]),
+    ];
+    if (errors.length > 0) return { ok: false, reason: 'plugin_validation_failed' };
+    const notes = contents.flatMap((item) => item.notes);
+    const hookNote = notes.find((note) => typeof note === 'string' && note.includes(' hooks: '));
+    const callNote = notes.find((note) => typeof note === 'string' && note.includes(' calls: '));
+    const hooks = new Set(
+      typeof hookNote === 'string'
+        ? hookNote
+            .split(' hooks: ', 2)[1]
+            .split(', ')
+            .map((item) => item.trim())
+        : [],
+    );
+    const calls = new Set(
+      typeof callNote === 'string'
+        ? callNote
+            .split(' calls: ', 2)[1]
+            .replace(/\s+\(via[^)]*\)/gu, '')
+            .split(', ')
+            .map((item) => item.trim())
+        : [],
+    );
+    const inventory = new Set([...hooks, ...calls]);
+    if (inventory.size === 0 || REQUIRED_INVENTORY.some((item) => !inventory.has(item)))
+      return { ok: false, reason: 'host_inventory_incomplete' };
+    const test = await runBounded(
+      executable,
+      ['plugin', 'test', contractPlugin],
+      environment,
+      limits,
+    );
+    const passMatch = (test.stdout + test.stderr).match(/(?:^|\s)(\d+)\s+pass(?:ed)?(?:\s|$)/iu);
+    const failMatch = (test.stdout + test.stderr).match(/(?:^|\s)(\d+)\s+fail(?:ed)?(?:\s|$)/iu);
+    if (test.timedOut) return { ok: false, reason: 'native_plugin_tests_failed' };
+    if (test.code !== 0) return { ok: false, reason: 'native_plugin_tests_failed' };
+    if (test.overflow) return { ok: false, reason: 'native_plugin_tests_failed' };
+    if (passMatch === null || Number(passMatch[1]) < 1)
+      return { ok: false, reason: 'native_plugin_tests_failed' };
+    if (failMatch === null || Number(failMatch[1]) !== 0)
+      return { ok: false, reason: 'native_plugin_tests_failed' };
+    if (
+      !test.stdout.includes(
+        'AI Brain enabled host contract invokes usage and native compaction through the dispatcher',
+      )
+    )
+      return { ok: false, reason: 'native_plugin_tests_failed' };
+    await assertEmptyDirectory(cwd);
+    return {
+      ok: true,
+      checks: [
+        'launch_flags',
+        'plugin_validate_strict',
+        'native_plugin_test',
+        'isolated_filesystem',
+      ],
+    };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : '';
+    const allowedReasons = new Set([
+      'plugin_asset_invalid',
+      'plugin_asset_symlink_rejected',
+      'plugin_asset_owner_mismatch',
+      'plugin_asset_too_large',
+      'plugin_assets_too_large',
+      'probe_directory_not_empty',
+    ]);
+    return { ok: false, reason: allowedReasons.has(reason) ? reason : 'host_probe_failed' };
+  } finally {
+    try {
+      await rm(root, { recursive: true, force: true });
+    } catch {
+      throw new Error('probe_cleanup_failed');
+    }
+  }
+}
+
+/** @param {string} executable @param {string} packageRoot */
+/** @param {string} executable @param {string} packageRoot @returns {Promise<ClaudeCompatibility>} */
+export async function resolveClaudeCompatibility(executable, packageRoot) {
+  let pinnedExecutable;
+  try {
+    pinnedExecutable = await realpath(executable);
+  } catch {
+    return {
+      status: 'rejected',
+      executable: null,
+      version: null,
+      reason: 'executable_unavailable',
+    };
+  }
+  let raw;
+  try {
+    raw = await readNativeVersion(pinnedExecutable);
+  } catch {
+    return {
+      status: 'rejected',
+      executable: pinnedExecutable,
+      version: null,
+      reason: 'version_probe_cleanup_failed',
+    };
+  }
+  const version = parseVersion(raw);
+  if (!version)
+    return {
+      status: 'rejected',
+      executable: pinnedExecutable,
+      version: null,
+      reason: 'version_unavailable',
+    };
+  if (version.prerelease)
+    return {
+      status: 'rejected',
+      executable: pinnedExecutable,
+      version: version.text,
+      reason: 'prerelease',
+    };
+  if (version.major !== HOST_MAJOR || version.minor !== HOST_MINOR) {
+    return {
+      status: 'rejected',
+      executable: pinnedExecutable,
+      version: version.text,
+      reason: 'major_minor_unsupported',
+    };
+  }
+  if (QUALIFIED_VERSIONS.has(version.text))
+    return {
+      status: 'qualified',
+      executable: pinnedExecutable,
+      version: version.text,
+      reason: 'known_stable',
+    };
+  if (version.patch < 303)
+    return {
+      status: 'rejected',
+      executable: pinnedExecutable,
+      version: version.text,
+      reason: 'unsupported_stable_patch',
+    };
+  let probe;
+  try {
+    probe = await runHostProbe(pinnedExecutable, join(resolve(packageRoot), 'assets', 'claude'));
+  } catch {
+    return {
+      status: 'rejected',
+      executable: pinnedExecutable,
+      version: version.text,
+      reason: 'host_probe_cleanup_failed',
+    };
+  }
+  if (!probe.ok)
+    return {
+      status: 'rejected',
+      executable: pinnedExecutable,
+      version: version.text,
+      reason: probe.reason ?? 'host_probe_failed',
+    };
+  return {
+    status: 'host_checked',
+    executable: pinnedExecutable,
+    version: version.text,
+    reason: 'native_host_contract',
+    ...(probe.checks === undefined ? {} : { checks: probe.checks }),
+  };
+}
+
+/** @param {ClaudeCompatibility} decision */
+export function claudeCompatibilityError(decision) {
+  const detected = decision.version ?? 'unavailable';
+  return `claude_version_unverified: Claude Code detected version ${detected}; reason ${decision.reason}; run aibrain doctor --json or install a compatible stable native version.`;
+}
+
+export const claudeCompatibilityInternals = Object.freeze({
+  REQUIRED_FLAGS,
+  REQUIRED_INVENTORY,
+  ALLOWED_PLUGIN_FILES,
+  parseVersion,
+  runHostProbe,
+});

package/dist/cli.mjs

@@ -15,21 +15,16 @@ import {
   stateRoot,
   tokenDigest,
 } from './state.mjs';
-import {
-  isTestedNativeVersion,
-  nativeVersion,
-  nativeVersionDiagnostic,
-  platformCheck,
-  resolveNative,
-} from './platform.mjs';
+import { nativeVersion, platformCheck, resolveNative } from './platform.mjs';
 import { launchClaude, launchCodex } from './launch.mjs';
+import { claudeCompatibilityError, resolveClaudeCompatibility } from './claude-compatibility.mjs';
 import { codexCompatibilityError, resolveCodexCompatibility } from './codex-compatibility.mjs';
 import { providerFreeProbe } from './mcp.mjs';
 import { codexPolicyJson, makePolicy, publicPolicy, isProfile } from './policy.mjs';
 import { readDiagnostics } from './claude-observation.mjs';
 import { readCodexDiagnostics } from './codex-diagnostics.mjs';
 
-const VERSION = '0.3.0-beta.13';
+const VERSION = '0.3.0-beta.14';
 const ENDPOINT = 'https://mcp.ai-brain.aisac.cloud/mcp';
 const PACKAGE_ROOT = dirname(fileURLToPath(import.meta.url));
 const LEGACY_DISCLOSURE_VERSION = 'aibrain-paid-context-v1-2026-10-09';
@@ -444,10 +439,13 @@ async function setup(args) {
   if ((clients === 'claude' || clients === 'both') && !claude) throw new Error('claude_not_found');
   if ((clients === 'codex' || clients === 'both') && (!codex || !node))
     throw new Error('codex_or_node_not_found');
-  const claudeVersion = claude ? nativeVersion(claude) : null;
-  const claudeSupported = claudeVersion !== null && isTestedNativeVersion('claude', claudeVersion);
-  if ((clients === 'claude' || clients === 'both') && !claudeSupported)
-    throw new Error(nativeVersionDiagnostic('claude', claudeVersion ?? ''));
+  const claudeCompatibility =
+    (clients === 'claude' || clients === 'both') && claude !== null
+      ? await resolveClaudeCompatibility(claude, PACKAGE_ROOT)
+      : null;
+  if (claudeCompatibility?.status === 'rejected')
+    throw new Error(claudeCompatibilityError(claudeCompatibility));
+  const claudeVersion = claudeCompatibility?.version ?? (claude ? nativeVersion(claude) : null);
   let codexCompatibility = null;
   if (clients === 'codex' || clients === 'both') {
     codexCompatibility = codex ? await resolveCodexCompatibility(codex) : null;
@@ -519,12 +517,14 @@ async function doctor(json) {
     codex: resolveNative('codex'),
     node: resolveNative('node'),
   };
+  const claudeCompatibility =
+    native.claude !== null ? await resolveClaudeCompatibility(native.claude, PACKAGE_ROOT) : null;
+  const codexCompatibility =
+    native.codex !== null ? await resolveCodexCompatibility(native.codex) : null;
   const rawNativeVersions = {
-    claude: native.claude ? nativeVersion(native.claude) : '',
+    claude: claudeCompatibility?.version ?? '',
     codex: native.codex ? nativeVersion(native.codex) : '',
   };
-  const codexCompatibility =
-    native.codex !== null ? await resolveCodexCompatibility(native.codex) : null;
   const nativeVersions = {
     ...rawNativeVersions,
     codex: codexCompatibility?.version ?? rawNativeVersions.codex,
@@ -533,7 +533,9 @@ async function doctor(json) {
   const needsCodex = config?.clientSelection === 'codex' || config?.clientSelection === 'both';
   const nativeReady =
     (!needsClaude ||
-      (native.claude !== null && isTestedNativeVersion('claude', nativeVersions.claude))) &&
+      (native.claude !== null &&
+        (claudeCompatibility?.status === 'qualified' ||
+          claudeCompatibility?.status === 'host_checked'))) &&
     (!needsCodex ||
       (native.codex !== null &&
         native.node !== null &&
@@ -552,6 +554,9 @@ async function doctor(json) {
       node: native.node !== null,
     },
     nativeVersions,
+    claudeCompatibility: claudeCompatibility?.status ?? 'unavailable',
+    claudeCompatibilityReason: claudeCompatibility?.reason ?? 'claude_not_found',
+    claudeCompatibilityVersion: claudeCompatibility?.version ?? null,
     codexCompatibility: codexCompatibility?.status ?? 'unavailable',
     codexCompatibilityReason: codexCompatibility?.reason ?? 'codex_not_found',
     codexCompatibilityVersion: codexCompatibility?.version ?? null,
@@ -663,17 +668,8 @@ async function main(argv) {
       throw new Error('disclosure_outdated');
     if (config.clientSelection !== command && config.clientSelection !== 'both')
       throw new Error('client_not_configured');
-    if (
-      command === 'claude' &&
-      (typeof config.claudeVersion !== 'string' ||
-        !isTestedNativeVersion('claude', config.claudeVersion))
-    )
-      throw new Error(
-        nativeVersionDiagnostic(
-          'claude',
-          typeof config.claudeVersion === 'string' ? config.claudeVersion : '',
-        ),
-      );
+    // The native executable is authoritative. The stored setup version is
+    // metadata only, so patch updates do not block a fresh compatibility check.
     if (command === 'codex' && typeof config.codexVersion !== 'string')
       throw new Error('codex_version_unverified');
     const root = stateRoot();

package/dist/launch.mjs

@@ -4,7 +4,8 @@ import { access, chmod, lstat, mkdir, mkdtemp, open, rm, writeFile } from 'node:
 import { spawn } from 'node:child_process';
 import { constants } from 'node:fs';
 import { isAbsolute, join, resolve, sep } from 'node:path';
-import { assertTestedNativeVersion, nativeVersion, resolveNative } from './platform.mjs';
+import { nativeVersion, resolveNative } from './platform.mjs';
+import { claudeCompatibilityError, resolveClaudeCompatibility } from './claude-compatibility.mjs';
 import { codexCompatibilityError, resolveCodexCompatibility } from './codex-compatibility.mjs';
 import {
   claudeCheckpointConfigBinding,
@@ -407,8 +408,14 @@ export async function launchClaude(config, root, args) {
   assertClaudeArgs(launchArgs.args);
   const executable = resolveNative('claude');
   if (!executable) throw new Error('claude_not_found');
-  const currentVersion = nativeVersion(executable);
-  assertTestedNativeVersion('claude', currentVersion);
+  const compatibility = await resolveClaudeCompatibility(executable, validated.packageRoot);
+  if (compatibility.status === 'rejected') throw new Error(claudeCompatibilityError(compatibility));
+  const pinnedExecutable = compatibility.executable ?? executable;
+  if (compatibility.status === 'host_checked')
+    process.stderr.write(
+      `aibrain: Claude ${compatibility.version ?? 'unknown'} accepted by the local native host contract; end-to-end recovery remains separately qualified.\n`,
+    );
+  const currentVersion = compatibility.version ?? nativeVersion(pinnedExecutable);
   const pluginRoot = await assertClaudeAssets(validated.packageRoot);
   const telemetryActive =
     validated.telemetry?.enabled === true && validated.telemetry?.disclosedAt != null;
@@ -533,7 +540,7 @@ export async function launchClaude(config, root, args) {
   let child;
   try {
     child = spawn(
-      executable,
+      pinnedExecutable,
       [
         '--settings',
         settingsPath,

package/dist/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@brunobracaioli/aibrain",
-  "version": "0.3.0-beta.13",
+  "version": "0.3.0-beta.14",
   "type": "module"
 }

package/dist/platform.mjs

@@ -70,7 +70,7 @@ export function nativeVersion(executable, environment = process.env) {
 export function isTestedNativeVersion(client, version) {
   const value = version.trim();
   if (client === 'claude')
-    return /^(?:(?:claude(?:\s+code)?)\s+)?2\.1\.(?:294|295|296|299|300|301|302)(?:\s+\(Claude\s+Code\))?$/iu.test(
+    return /^(?:(?:claude(?:\s+code)?)\s+)?2\.1\.(?:294|295|296|299|300|301|302|303)(?:\s+\(Claude\s+Code\))?$/iu.test(
       value,
     );
   return /^(?:codex(?:-cli)?\s+)?0\.16(?:1\.0|2\.0|2\.1|3\.0)$/iu.test(value);
@@ -85,6 +85,7 @@ const TESTED_NATIVE_VERSIONS = Object.freeze({
     '2.1.300',
     '2.1.301',
     '2.1.302',
+    '2.1.303',
   ]),
   codex: Object.freeze(['0.161.0', '0.162.0', '0.162.1', '0.163.0']),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunobracaioli/aibrain",
-  "version": "0.3.0-beta.13",
+  "version": "0.3.0-beta.14",
   "private": false,
   "description": "AI Brain assisted context beta client for Claude Code and Codex",
   "license": "UNLICENSED",