synabun 2026.7.31 → 2026.7.34

package/CHANGELOG.md

@@ -1,3 +1,51 @@
+# SynaBun v.2026.07.34
+
+A reliability release: the Claude sidepanel no longer dies with a misleading "does not match this system's libc" error, and every bundled native binary is checked and repaired at startup.
+
+## 🛠 Fixed
+
+- **"Native binary exists but failed to launch"** — The Claude sidepanel could fail every turn with *"Claude Code native binary at `…/claude` exists but failed to launch. This usually means the binary does not match this system's libc…"*. On macOS and Windows that explanation is never right: the real cause is almost always a missing execute bit. npm does not preserve the execute bit for files a package ships without a `bin` entry, which is exactly how the Claude Agent SDK and Codex deliver their native payloads, so a perfectly good binary can land as mode `0644` and fail to spawn. SynaBun now stats the binary the SDK is about to launch, restores the execute bit when it is missing, and retries — and when it cannot repair it, it says what is actually wrong: a permission problem on macOS and Linux, Gatekeeper quarantine (with the `xattr -d com.apple.quarantine` command) on macOS, a genuine libc mismatch only on Linux, and an unlaunchable `.cmd`/`.bat`/`.ps1` shim on Windows.
+- **Only the current machine's binaries were repaired** — The startup repair looked at one directory, `prebuilds/<your platform>-<your arch>`, so a checkout carrying several platform builds left the others broken — including `darwin-x64`, which is what an Intel Mac needs for terminals. Startup and postinstall now sweep every vendored binary that is present (Claude Agent SDK, Codex, `node-pty`) by walking the tree instead of consulting a hardcoded list, so new platform directories are covered automatically.
+- **The postinstall repair had stopped doing anything** — `scripts/rebuild-pty.js` was still fixing permissions on `node_modules/.bin/claude` and `@anthropic-ai/claude-code/cli.js`, neither of which has existed since that package was replaced by the Agent SDK. Its prebuild list named Linux directories that are not shipped while missing ones that are. It now runs the shared sweep, and runs it *before* the "node-pty not found, skipping" guard — previously an install without node-pty skipped the Claude and Codex repair entirely.
+- **A `.cjs` executable override was launched the wrong way** — A custom Claude executable ending in `.cjs` was treated as a script to run through Node, but the SDK spawns it directly, so it needed the execute bit and did not get it.
+
+## ✨ New
+
+- **Runtime notices in the Claude sidepanel** — A new amber notice sits between grey status text and a red fatal error: something went wrong, was worked around, and the session is continuing in a degraded state. You will see it when the bundled binary is repaired and retried, and when a session falls back to your globally installed Claude CLI. It appears in both the sidepanel and the standalone chat page.
+- **Fallback to your installed Claude CLI** — If the bundled runtime cannot be launched or repaired, sessions and unattended automation loops now fall back to the Claude CLI you have installed rather than failing the turn. Because model aliases and effort levels resolve per-binary, a version difference between your CLI and the bundled runtime is reported alongside the fallback instead of silently changing which model runs.
+
+## ⚙️ Changed
+
+- **A custom Claude executable path is now validated before use** — The `claude-skin` → `sdkExecutable` override was passed straight through to the SDK, which uses it verbatim with no checks of its own. It is now vetted first, and a bare command name such as `claude` is rejected with an explanation: the SDK spawns without a shell and cannot resolve a name from `PATH`, so handing one over produces a worse and more confusing failure than the one being recovered from. Overrides may be either a script entrypoint or a native binary path, and the same rule now applies to automation loops, which previously accepted anything.
+
+---
+
+# SynaBun v.2026.07.33
+
+A Windows release: Codex schedules and sidepanels now find a globally installed Codex runtime instead of failing at launch.
+
+## 🛠 Fixed
+
+- **Codex could not be found on Windows even with the global CLI installed** — SynaBun located the Codex runtime by looking it up on the inherited `PATH`, and the PATH it built for that lookup only added POSIX directories (`~/.local/bin`, `/usr/local/bin`, `~/.npm-global/bin`) that do not exist on Windows. Started from anywhere whose environment did not already carry the npm global bin — a shortcut, a service, a fresh terminal after an install — Codex was invisible and every Codex schedule failed. Discovery no longer depends on `PATH` at all: `@openai/codex` is now located under `npm root -g`, `%APPDATA%\npm\node_modules`, an `npm_config_prefix` override, the `node_modules` directory that contains SynaBun itself, and Node's own install directory. The Windows PATH augmentation also picks up `%APPDATA%\npm`, the configured npm prefix, and Node's directory, deduplicated, so the shell-aware launch paths improve too.
+- **The native Codex executable was missed under current npm layouts** — The resolver looked in exactly one place, `vendor/<target>/codex/codex.exe` inside the platform package resolved through `require.resolve`. Current Codex releases ship the executable at `vendor/<target>/bin/`, and depending on the npm version the platform package sits either beside `@openai/codex` or nested inside its own `node_modules` — and package `exports` can block the resolve entirely. Both vendor layouts and all three package locations are now checked directly, so hoisting differences no longer read as "Codex is not installed".
+- **Windows launched npm's shell shim instead of the real launcher** — `npm install -g` writes both an extensionless `codex` sh shim and a `codex.cmd`, and `where codex` lists the shim first, which Windows cannot spawn. The sidepanel launch path now prefers a `.cmd`, `.exe`, `.bat`, or `.ps1` launcher and keeps the first result only as a fallback for non-npm installations.
+
+## ⚙️ Improved
+
+- **A missing Codex runtime says which problem it is** — The failure notice now distinguishes "the global Codex package is installed but its Windows runtime is missing" from "Codex is not installed globally", and both point at `npm install -g @openai/codex@latest --include=optional`. The platform executable ships as an optional dependency, so an install that skipped optional packages leaves a Codex that looks present and cannot run. Successful resolution logs which layout it came from, and failures log the candidate paths that were checked.
+
+---
+
+# SynaBun v.2026.07.32
+
+A follow-up to 2026.07.31 that makes updating fast again on a large data home.
+
+## 🛠 Fixed
+
+- **Updating took several minutes on a large data home** — Before a new version starts, SynaBun snapshots your data home so the update can be rolled back. That snapshot archived *everything*, so a multi-GB data home spent minutes compressing during `npm install` — one report was 9,470 files and 3,832 MB. An upgrade snapshot only needs to protect state: it never rewrites your generated images, audio, or video, and those survive a rollback on disk regardless. Upgrade snapshots now skip generated media, and if what remains is still over ~1 GB they fall back to irreplaceable state only — your `.env`, everything under `mcp-data/`, and any `.db`, `.sqlite`, or `.json`. Compression on the blocking path drops to the fastest level, since what is left is SQLite and JSON that still shrink well. The snapshot reports what it skipped and why, and its manifest records whether it is `state-only` or `complete` so a restore can never mistake one for the other. Scheduled and manual backups are unchanged and still capture everything.
+
+---
+
 # SynaBun v.2026.07.30
 
 A point release on top of 2026.07.20, focused on correct Claude Code model selection, a new project storage cleanup tool, and a stricter default browser policy.

package/mcp-server/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-memory-mcp",
-  "version": "2026.7.30",
+  "version": "2026.7.34",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-memory-mcp",
-      "version": "2026.7.30",
+      "version": "2026.7.34",
       "license": "Apache-2.0",
       "dependencies": {
         "@huggingface/transformers": "^3.0.0",

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-memory-mcp",
-  "version": "2026.7.30",
+  "version": "2026.7.34",
   "private": true,
   "description": "Private MCP server runtime bundled with SynaBun for persistent memory and agent tooling",
   "license": "Apache-2.0",

package/neural-interface/lib/backup-service.js

@@ -59,6 +59,65 @@ const INCOMPRESSIBLE_EXTENSIONS = new Set([
   '.png', '.webm', '.webp', '.woff', '.woff2', '.zip',
 ]);
 
+// Generated media. An upgrade snapshot exists to roll back *state* if a new
+// version misbehaves; it never rewrites these, and they survive a rollback on
+// disk regardless. Archiving them put multi-GB data homes through several
+// minutes of compression on the npm update path, so upgrade snapshots skip
+// them. Scheduled and manual backups still capture everything.
+const BULK_MEDIA_EXTENSIONS = new Set([
+  '.avif', '.bmp', '.gif', '.heic', '.jpeg', '.jpg', '.m4a', '.m4v', '.mkv',
+  '.mov', '.mp3', '.mp4', '.ogg', '.png', '.tiff', '.wav', '.webm', '.webp',
+]);
+
+// Snapshot kinds taken while the user is blocked on a version change.
+const UPGRADE_BACKUP_KINDS = new Set(['pre-update', 'pre-migration']);
+
+// Irreplaceable state: the memory database, UI state databases, and the JSON
+// that configures them. Everything a rollback actually needs lives here.
+const ESSENTIAL_STATE_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.json']);
+
+// Above this, an upgrade snapshot stops trying to be comprehensive and keeps
+// only irreplaceable state. Dropping media is not enough on its own — a data
+// home can reach multiple GB in ordinary files, and compressing that on the
+// npm update path is what made upgrades look broken.
+const UPGRADE_SNAPSHOT_SOFT_LIMIT_BYTES = 1024 * 1024 * 1024;
+
+function fileBytes(path) {
+  try { return statSync(path).size; } catch { return 0; }
+}
+
+/**
+ * Pick what an upgrade snapshot archives. Generated media always goes; if the
+ * remainder is still oversized, fall back to irreplaceable state only. Returns
+ * the kept files plus what was dropped, so the caller can say so out loud.
+ */
+function selectUpgradeSnapshotFiles(files, { softLimitBytes = UPGRADE_SNAPSHOT_SOFT_LIMIT_BYTES } = {}) {
+  const excluded = { reason: 'generated-media', files: 0, bytes: 0 };
+  const kept = [];
+  for (const file of files) {
+    if (BULK_MEDIA_EXTENSIONS.has(extname(file.archivePath).toLowerCase())) {
+      excluded.files += 1;
+      excluded.bytes += fileBytes(file.diskPath);
+      continue;
+    }
+    kept.push(file);
+  }
+
+  const keptBytes = kept.reduce((total, file) => total + fileBytes(file.diskPath), 0);
+  if (keptBytes <= softLimitBytes) return { files: kept, excluded };
+
+  const essential = [];
+  for (const file of kept) {
+    const isEnv = file.archivePath === 'env.bak';
+    const isMcpState = file.archivePath.startsWith('mcp-data/');
+    const isStateFile = ESSENTIAL_STATE_EXTENSIONS.has(extname(file.archivePath).toLowerCase());
+    if (isEnv || isMcpState || isStateFile) { essential.push(file); continue; }
+    excluded.files += 1;
+    excluded.bytes += fileBytes(file.diskPath);
+  }
+  return { files: essential, excluded: { ...excluded, reason: 'oversized-data-home' } };
+}
+
 export class BackupStorageError extends Error {
   constructor({ availableBytes, requiredBytes, folderPath }) {
     const availableMiB = Math.floor(availableBytes / 1024 / 1024);
@@ -293,11 +352,11 @@ function normalizeAdditionalEntries(entries = []) {
   return result;
 }
 
-async function writeArchive({ tempPath, files, manifest }) {
+async function writeArchive({ tempPath, files, manifest, level = 6 }) {
   const { createWriteStream } = await import('node:fs');
   await new Promise((resolveWrite, reject) => {
     const output = createWriteStream(tempPath, { flags: 'wx' });
-    const archive = archiver('zip', { zlib: { level: 6 } });
+    const archive = archiver('zip', { zlib: { level } });
     output.on('close', resolveWrite);
     output.on('error', reject);
     archive.on('warning', error => error.code === 'ENOENT' ? null : reject(error));
@@ -341,6 +400,7 @@ export async function createVerifiedBackup({
   getAvailableBytes = backupAvailableBytes,
   onBeforeArchive = null,
   onProgress = null,
+  upgradeSoftLimitBytes = UPGRADE_SNAPSHOT_SOFT_LIMIT_BYTES,
   now = () => new Date(),
 } = {}) {
   // A large data home spends minutes in checksum/archive with no output. Phase
@@ -372,10 +432,19 @@ export async function createVerifiedBackup({
 
     // De-duplicate before estimating work space so explicit additional entries
     // cannot inflate the preflight or create ambiguous ZIP members.
-    const sourceFiles = [...new Map(files.map(file => [
+    const deduped = [...new Map(files.map(file => [
       file.archivePath.replace(/\\/g, '/'),
       file,
     ])).values()];
+
+    // Keep the upgrade path bounded: state is archived, generated media is not.
+    const leanSnapshot = UPGRADE_BACKUP_KINDS.has(kind);
+    const selection = leanSnapshot
+      ? selectUpgradeSnapshotFiles(deduped, { softLimitBytes: upgradeSoftLimitBytes })
+      : { files: deduped, excluded: null };
+    const sourceFiles = selection.files;
+    const excluded = selection.excluded;
+
     const workingSpace = assertBackupWorkingSpace({
       folderPath,
       files: sourceFiles,
@@ -384,7 +453,14 @@ export async function createVerifiedBackup({
       freeSpaceReserveBytes,
       getAvailableBytes,
     });
-    report({ phase: 'collect', files: sourceFiles.length, bytes: workingSpace.archiveBytes });
+    report({
+      phase: 'collect',
+      files: sourceFiles.length,
+      bytes: workingSpace.archiveBytes,
+      skippedFiles: excluded?.files ?? 0,
+      skippedBytes: excluded?.bytes ?? 0,
+      skippedReason: excluded?.reason ?? null,
+    });
 
     sqliteSnapshot = createConsistentSqliteSnapshot(databasePath, sqliteTemp);
     files.length = 0;
@@ -429,12 +505,18 @@ export async function createVerifiedBackup({
       } : null,
       files: finalFiles.map(file => file.archivePath),
       checksums,
+      // A lean snapshot is not a whole-data-home backup. Recording that here
+      // keeps a restore from silently presenting it as one.
+      scope: leanSnapshot ? 'state-only' : 'complete',
+      excluded,
       verified: true,
       verification: { algorithm: 'sha256', publication: 'verify-before-atomic-rename' },
     };
     if (typeof onBeforeArchive === 'function') await onBeforeArchive({ files: finalFiles, manifest });
     report({ phase: 'archive', files: finalFiles.length, bytes: workingSpace.archiveBytes });
-    await writeArchive({ tempPath, files: finalFiles, manifest });
+    // Level 1 on the blocking upgrade path: the remaining payload is mostly
+    // SQLite and JSON, where fast deflate still shrinks well.
+    await writeArchive({ tempPath, files: finalFiles, manifest, level: leanSnapshot ? 1 : 6 });
     report({ phase: 'verify', files: finalFiles.length });
     const publishedManifest = verifyBackupArchive(tempPath);
     renameSync(tempPath, destination);

package/neural-interface/lib/claude-agent-bridge.js

@@ -20,7 +20,14 @@
 // session with no WS bound, so page-refresh reattach is the same object.
 
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { CLAUDE_EFFORT_LEVELS } from './claude-model-catalog.js';
+import { CLAUDE_EFFORT_LEVELS, checkClaudeCliSkew } from './claude-model-catalog.js';
+import {
+  claudeRuntime,
+  clearNativeBinaryCache,
+  isNativeBinaryLaunchFailure,
+  planRuntimeRecovery,
+  resolveClaudeExecutableOverride,
+} from './native-binary-runtime.js';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
@@ -154,6 +161,12 @@ class ClaudeSession {
     this.lastPrompt = null;
     this.stallRetries = 0;
 
+    // Native-runtime recovery latches. Set here and NOWHERE else — resetting
+    // them on query recreation would turn a permanently broken binary into an
+    // infinite repair/retry loop.
+    this._nativeRepairTried = false;
+    this._fallbackBin = null;
+
     this.pendingPerms = new Map(); // requestId → { toolName, resolve, input, kind }
     this.alwaysAllowed = new Set();
 
@@ -291,13 +304,34 @@ class ClaudeSession {
     if (parentDir && parentDir !== workDir && dirname(parentDir) !== parentDir) {
       options.additionalDirectories = [parentDir];
     }
-    // Default to the SDK's bundled CLI (version-matched). An explicit .js override
-    // can be set via cli-config.json → "claude-skin": { "sdkExecutable": "…/cli.js" }.
+    // Default to the SDK's bundled CLI (version-matched). An override can be set
+    // via cli-config.json → "claude-skin": { "sdkExecutable": "…" } and may be
+    // either a .js entrypoint (launched via node) or a native binary path.
+    //
+    // The SDK uses pathToClaudeCodeExecutable verbatim with zero validation, so
+    // everything is vetted here first — notably a bare command name, which would
+    // ENOENT under the SDK's spawn(shell:false).
     const sdkExec = deps.sdkExecutable;
-    if (sdkExec && /\.[cm]?js$/i.test(sdkExec) && existsSync(sdkExec)) {
-      options.pathToClaudeCodeExecutable = sdkExec;
+    const override = resolveClaudeExecutableOverride(sdkExec);
+    if (override.path) {
+      options.pathToClaudeCodeExecutable = override.path;
     } else if (sdkExec) {
-      log('ignoring non-.js sdkExecutable override:', sdkExec);
+      log('ignoring sdkExecutable override:', override.reason);
+      this.send({ type: 'stderr', text: `Ignoring sdkExecutable override — ${override.reason}` });
+    }
+
+    if (!options.pathToClaudeCodeExecutable) {
+      if (this._fallbackBin) {
+        // A previous turn proved the bundled binary unusable; stay on the CLI we
+        // already fell back to rather than re-failing every turn.
+        options.pathToClaudeCodeExecutable = this._fallbackBin;
+      } else {
+        // Called for its side effect only: this stats the binary the SDK is about
+        // to resolve and restores the execute bit if it is missing. We
+        // deliberately do NOT pass the resolved path on — letting the SDK resolve
+        // for itself keeps us correct even if its resolution logic changes.
+        claudeRuntime();
+      }
     }
 
     log(`session create: resume=${this.sessionId || 'none'} model=${this.model || 'default'} effort=${this.effort || 'default'} mode=${this.permissionMode} cwd=${workDir} sdk=${SDK_VERSION}`);
@@ -327,10 +361,11 @@ class ClaudeSession {
       const msg = err?.message || String(err);
       log('pump error:', msg);
       if (/No conversation found/i.test(msg)) { this._recoverLostSession(); return; }
-      const friendly = /ENOENT/.test(msg)
-        ? 'Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code'
-        : msg;
-      this._finishTurnWithError(friendly);
+      // The SDK cannot tell a permission problem from a libc mismatch: it buckets
+      // every spawn error together and always blames musl/glibc. Diagnose it
+      // properly, repair what we can, and fall back to the user's CLI.
+      if (isNativeBinaryLaunchFailure(err)) { this._recoverNativeRuntime(err); return; }
+      this._finishTurnWithError(msg);
     } finally {
       if (this.q === q) this.q = null;
     }
@@ -384,6 +419,80 @@ class ClaudeSession {
     });
   }
 
+  /**
+   * The bundled native CLI failed to launch.
+   *
+   * The SDK's own message for this always blames a musl/glibc mismatch, which is
+   * only ever right on Linux — on macOS and Windows the real cause is almost
+   * always a missing execute bit (npm does not preserve it for binaries shipped
+   * without a `bin` entry, and this repo commits node_modules).
+   *
+   * Recovery is: re-stat and repair → retry once → fall back to the user's
+   * installed CLI with a visible notice → give up with an accurate diagnosis.
+   */
+  _recoverNativeRuntime(err) {
+    const prompt = this.lastPrompt;
+    // The cached verdict predates the failure; re-stat so a repair performed by
+    // another session (or the boot sweep) is visible.
+    clearNativeBinaryCache();
+    const runtime = claudeRuntime();
+
+    let fallbackBin = this._fallbackBin;
+    if (!fallbackBin) {
+      // getClaudeBin()'s last resort is the bare string 'claude'. The SDK spawns
+      // with shell:false, so a bare name is a guaranteed ENOENT — the override
+      // validator rejects it, leaving fallbackBin null and giving the user a
+      // real diagnosis instead of a second, more confusing failure.
+      const candidate = resolveClaudeExecutableOverride(deps.getClaudeBin?.());
+      if (candidate.ok && candidate.path) fallbackBin = candidate.path;
+    }
+
+    const plan = planRuntimeRecovery({
+      err,
+      runtime,
+      fallbackBin,
+      alreadyTried: this._nativeRepairTried,
+    });
+    log(`native runtime recovery: action=${plan.action} state=${runtime.state} kind=${plan.kind}`);
+
+    if (plan.action === 'retry') {
+      this._nativeRepairTried = true;
+      this.sendEvent({ type: 'system', subtype: 'runtime_notice', level: 'warn', message: plan.message });
+      this._recreateQuery(prompt);
+      return;
+    }
+
+    if (plan.action === 'fallback') {
+      this._fallbackBin = fallbackBin;
+      this.sendEvent({ type: 'system', subtype: 'runtime_notice', level: 'warn', message: plan.message });
+      // Report-only: the fallback CLI may be a different version than the SDK
+      // was built against, and alias ids like "opus[1m]" resolve per-binary — so
+      // a picked model can silently launch as another version.
+      this._announceSkew(fallbackBin);
+      this._recreateQuery(prompt);
+      return;
+    }
+
+    this._finishTurnWithError(plan.message);
+  }
+
+  _announceSkew(bin) {
+    Promise.resolve()
+      .then(() => checkClaudeCliSkew(bin, { log: () => {} }))
+      .then((skew) => {
+        if (!skew?.skewed || this.destroyed) return;
+        this.sendEvent({
+          type: 'system',
+          subtype: 'runtime_notice',
+          level: 'warn',
+          message: `Version skew: your installed Claude CLI is ${skew.discovered}, but the bundled `
+            + `runtime is ${skew.bundled}. Model aliases and effort levels resolve per-binary, so `
+            + 'behaviour may differ until the bundled binary is repaired.',
+        });
+      })
+      .catch(() => {});
+  }
+
   _pushUserText(text, images) {
     const content = [];
     if (images?.length) {

package/neural-interface/lib/codex-runtime-path.js

@@ -15,6 +15,8 @@ const CODEX_TARGETS = {
   },
 };
 
+const CODEX_VENDOR_BINARY_DIRS = ['bin', 'codex'];
+
 export function codexPlatformTarget(platform = process.platform, arch = process.arch) {
   return CODEX_TARGETS[`${platform}:${arch}`] || null;
 }
@@ -34,6 +36,19 @@ function uniquePaths(values, pathImpl) {
   return result;
 }
 
+/**
+ * Pick a Windows launcher suitable for the sidepanel's shell-aware spawn path.
+ * npm lists its extensionless sh shim before the native Windows launcher, so
+ * prefer a PATHEXT-style launcher while retaining the first result as a last
+ * resort for non-npm installations.
+ */
+export function selectWindowsCodexLauncher(launchers = [], acceptLauncher = () => true) {
+  const accepted = uniquePaths(launchers, path.win32).filter(acceptLauncher);
+  return accepted.find((launcher) => /\.(cmd|exe|bat|ps1)$/i.test(launcher))
+    || accepted[0]
+    || null;
+}
+
 function packageJsonCandidatesForLauncher(launcher, pathImpl) {
   const binDir = pathImpl.dirname(launcher);
   const candidates = [
@@ -45,11 +60,55 @@ function packageJsonCandidatesForLauncher(launcher, pathImpl) {
   return candidates;
 }
 
+export function windowsCodexPackageJsonCandidates({
+  npmRoots = [],
+  appData = '',
+  npmConfigPrefix = '',
+  synabunPackageRoot = '',
+  nodeExecutable = '',
+} = {}) {
+  const pathImpl = path.win32;
+  const nodeModulesRoots = [...npmRoots];
+  if (appData) nodeModulesRoots.push(pathImpl.join(appData, 'npm', 'node_modules'));
+  if (npmConfigPrefix) {
+    nodeModulesRoots.push(
+      pathImpl.basename(npmConfigPrefix).toLowerCase() === 'node_modules'
+        ? npmConfigPrefix
+        : pathImpl.join(npmConfigPrefix, 'node_modules'),
+    );
+  }
+  if (
+    synabunPackageRoot
+    && pathImpl.basename(synabunPackageRoot).toLowerCase() === 'synabun'
+    && pathImpl.basename(pathImpl.dirname(synabunPackageRoot)).toLowerCase() === 'node_modules'
+  ) {
+    nodeModulesRoots.push(pathImpl.dirname(synabunPackageRoot));
+  }
+  if (nodeExecutable) {
+    nodeModulesRoots.push(pathImpl.join(pathImpl.dirname(nodeExecutable), 'node_modules'));
+  }
+  return uniquePaths(
+    nodeModulesRoots.map((root) => pathImpl.join(root, '@openai', 'codex', 'package.json')),
+    pathImpl,
+  );
+}
+
 function defaultResolvePlatformPackage(codexPackageJsonPath, platformPackage) {
   const req = createRequire(codexPackageJsonPath);
   return req.resolve(`${platformPackage}/package.json`);
 }
 
+function vendorBinaryCandidates(packageJsonPath, spec, pathImpl) {
+  const packageDir = pathImpl.dirname(packageJsonPath);
+  return CODEX_VENDOR_BINARY_DIRS.map((binaryDir) => pathImpl.join(
+    packageDir,
+    'vendor',
+    spec.targetTriple,
+    binaryDir,
+    spec.binaryName,
+  ));
+}
+
 /**
  * Resolve the spawnable native Codex executable from a trusted global npm
  * installation on Windows. `@openai/codex-sdk` uses child_process.spawn with
@@ -91,50 +150,58 @@ export function resolveTrustedWindowsCodexBinary({
     checked.push(codexPackageJsonPath);
     if (!exists(codexPackageJsonPath)) continue;
 
-    const localVendorBinary = pathImpl.join(
-      pathImpl.dirname(codexPackageJsonPath),
-      'vendor',
-      spec.targetTriple,
-      'codex',
-      spec.binaryName,
-    );
-    checked.push(localVendorBinary);
-    if (exists(localVendorBinary) && acceptBinary(localVendorBinary)) {
-      return {
-        path: localVendorBinary,
-        source: 'global-package-vendor',
-        packageJsonPath: codexPackageJsonPath,
-        ...spec,
-        checked,
-      };
-    }
-
-    try {
-      const platformPackageJsonPath = resolvePlatformPackage(
-        codexPackageJsonPath,
-        spec.platformPackage,
-      );
-      const platformBinary = pathImpl.join(
-        pathImpl.dirname(platformPackageJsonPath),
-        'vendor',
-        spec.targetTriple,
-        'codex',
-        spec.binaryName,
-      );
-      checked.push(platformPackageJsonPath, platformBinary);
-      if (exists(platformBinary) && acceptBinary(platformBinary)) {
+    for (const localVendorBinary of vendorBinaryCandidates(codexPackageJsonPath, spec, pathImpl)) {
+      checked.push(localVendorBinary);
+      if (exists(localVendorBinary) && acceptBinary(localVendorBinary)) {
         return {
-          path: platformBinary,
-          source: 'global-platform-package',
+          path: localVendorBinary,
+          source: 'global-package-vendor',
           packageJsonPath: codexPackageJsonPath,
-          platformPackageJsonPath,
           ...spec,
           checked,
         };
       }
+    }
+
+    let resolvedPlatformPackageJsonPath = null;
+    try {
+      resolvedPlatformPackageJsonPath = resolvePlatformPackage(
+        codexPackageJsonPath,
+        spec.platformPackage,
+      );
     } catch (error) {
       checked.push(`${codexPackageJsonPath} -> ${spec.platformPackage}: ${error.message}`);
     }
+
+    // npm usually hoists the aliased platform package beside @openai/codex,
+    // but some npm versions keep it inside that package's node_modules. Check
+    // both layouts directly so package exports/hoisting do not block discovery.
+    const platformSegments = spec.platformPackage.split('/');
+    const codexPackageDir = pathImpl.dirname(codexPackageJsonPath);
+    const globalNodeModules = pathImpl.dirname(pathImpl.dirname(codexPackageDir));
+    const platformPackageJsonPaths = uniquePaths([
+      resolvedPlatformPackageJsonPath,
+      pathImpl.join(globalNodeModules, ...platformSegments, 'package.json'),
+      pathImpl.join(codexPackageDir, 'node_modules', ...platformSegments, 'package.json'),
+    ], pathImpl);
+
+    for (const platformPackageJsonPath of platformPackageJsonPaths) {
+      checked.push(platformPackageJsonPath);
+      if (!exists(platformPackageJsonPath)) continue;
+      for (const platformBinary of vendorBinaryCandidates(platformPackageJsonPath, spec, pathImpl)) {
+        checked.push(platformBinary);
+        if (exists(platformBinary) && acceptBinary(platformBinary)) {
+          return {
+            path: platformBinary,
+            source: 'global-platform-package',
+            packageJsonPath: codexPackageJsonPath,
+            platformPackageJsonPath,
+            ...spec,
+            checked,
+          };
+        }
+      }
+    }
   }
 
   return {