synabun 2.0.0-beta → 2.0.5

package/neural-interface/lib/native-binary-runtime.js

@@ -1,60 +1,31 @@
-// ── Cross-platform native binary runtime (resolve → verify → repair → diagnose) ──
+// ── Executables SynaBun starts: verify → repair → diagnose ──
 //
-// The Claude Agent SDK resolves its bundled native CLI with `require.resolve` +
-// `existsSync` and nothing else — no stat, no X_OK probe, no spawn test. When the
-// binary is present but not executable, `spawn` fails EACCES and the SDK reports:
+// Two kinds of executable pass through here.
 //
-//   "Claude Code native binary at <p> exists but failed to launch. This usually
-//    means the binary does not match this system's libc — e.g. spawning a
-//    musl-linked binary on a glibc Linux host…"
+// The user's Claude Code. SynaBun ships none (lib/external-tools.js at the
+// package root): every Agent SDK call is given the user's own installation as
+// `pathToClaudeCodeExecutable` (lib/claude-executable.js). The SDK uses that
+// value verbatim, with no stat, no X_OK probe and no spawn test, and when the
+// launch fails it buckets ENOENT/EACCES/EPERM/ENOTDIR/ELOOP/ENAMETOOLONG/EROFS
+// together and reports a musl/glibc mismatch, which is only ever right on
+// Linux. It also throws a ReferenceError, not an Error. So this module:
+//   - validates a path before the SDK gets it (a bare command name and a
+//     Windows command file cannot be spawned with shell:false)
+//   - recognises a launch failure, whatever shape the SDK gave it
+//   - explains it for the platform it happened on
 //
-// That wording is hardcoded and wrong everywhere except Linux: the SDK buckets
-// ENOENT/EACCES/EPERM/ENOTDIR/ELOOP/ENAMETOOLONG/EROFS together and picks the
-// message using only `existsSync`. It also throws a ReferenceError, not an Error.
+// SynaBun's own native helpers. node-pty's spawn-helper has to be executable
+// and npm does not preserve the bit, so a sweep restores it, built by
+// enumeration rather than a hardcoded list.
 //
-// SynaBun hits this constantly because `node_modules` is committed with
-// core.filemode=false, so every vendored binary checks out mode 0644.
-//
-// This module supplies what the SDK lacks:
-//   - a faithful reimplementation of the SDK's candidate resolution, so we know
-//     WHICH file it will pick and can stat/chmod exactly that one
-//   - exec-bit verification and repair (POSIX), plus an X_OK probe that catches
-//     modes the `& 0o111` mask misses (e.g. root-owned 0711)
-//   - a sweep over every vendored binary (Claude SDK, Codex, node-pty), built by
-//     enumeration rather than a hardcoded list
-//   - platform-accurate diagnosis + a recovery plan (repair-and-retry, then fall
-//     back to the user's global CLI)
-//
-// Resolution logic below mirrors @anthropic-ai/claude-agent-sdk@0.3.220. We never
-// hand the resolved path back to the SDK on the happy path — it re-resolves for
-// itself, and our copy exists only to know what to repair and how to explain a
-// failure. A drift between the two therefore degrades to "we chmod'd a file
-// nobody uses", never to launching the wrong binary.
-//
-// Every dependency is injectable (platform, arch, exists, stat, chmod, access,
-// readdir, report) so all eight platform targets are testable from one host.
-// Nothing here throws.
+// Every dependency is injectable (platform, exists, stat, chmod, access,
+// readdir), so every platform is testable from one host. Nothing here throws.
 
 import { existsSync, statSync, chmodSync, accessSync, readdirSync, constants } from 'node:fs';
-import { createRequire } from 'node:module';
 import path from 'node:path';
 
 export const SDK_PKG = '@anthropic-ai/claude-agent-sdk';
 
-// Platform packages the SDK declares as optionalDependencies. Kept here so a
-// test can assert we still match the installed SDK's own list (see the drift
-// guard in tests/native-binary-runtime.test.mjs).
-export const SDK_PLATFORM_PACKAGES = [
-  `${SDK_PKG}-darwin-arm64`,
-  `${SDK_PKG}-darwin-x64`,
-  `${SDK_PKG}-linux-arm64`,
-  `${SDK_PKG}-linux-arm64-musl`,
-  `${SDK_PKG}-linux-x64`,
-  `${SDK_PKG}-linux-x64-musl`,
-  `${SDK_PKG}-win32-arm64`,
-  `${SDK_PKG}-win32-x64`,
-];
-
 // The SDK's isNativeBinary(): a path NOT ending in one of these is spawned
 // directly and needs +x. Note `.cjs` is absent — it IS spawned directly.
 const SCRIPT_EXTENSIONS = ['.js', '.mjs', '.tsx', '.ts', '.jsx'];
@@ -67,91 +38,6 @@ const LAUNCH_ERROR_CODES = new Set([
 
 export const SDK_LIBC_MESSAGE_RE = /native binary at .+ exists but failed to launch/i;
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Resolution (faithful to the SDK)
-// ─────────────────────────────────────────────────────────────────────────────
-
-/**
- * musl detection, exactly as the SDK does it: linux-only, and an ABSENT
- * `glibcVersionRuntime` in the diagnostic report means musl. Anything we cannot
- * read falls back to the glibc ordering, matching the SDK.
- */
-export function detectMusl({ platform = process.platform, report = process.report } = {}) {
-  if (platform !== 'linux') return false;
-  try {
-    if (typeof report?.getReport !== 'function') return false;
-    const r = report.getReport();
-    return r != null && r.header?.glibcVersionRuntime === undefined;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * The request specifiers the SDK tries, in order. Each is `<pkg>/claude`, or
- * `<pkg>/claude.exe` on Windows. darwin and win32 get a SINGLE candidate with no
- * fallback; only linux has a two-entry list, ordered by libc.
- */
-export function sdkBinaryCandidates({
-  platform = process.platform,
-  arch = process.arch,
-  preferMusl,
-} = {}) {
-  const musl = preferMusl === undefined ? detectMusl({ platform }) : !!preferMusl;
-  const binary = platform === 'win32' ? 'claude.exe' : 'claude';
-
-  let packages;
-  if (platform === 'android') {
-    packages = [`${SDK_PKG}-linux-${arch}-android`];
-  } else if (platform === 'linux') {
-    packages = musl
-      ? [`${SDK_PKG}-linux-${arch}-musl`, `${SDK_PKG}-linux-${arch}`]
-      : [`${SDK_PKG}-linux-${arch}`, `${SDK_PKG}-linux-${arch}-musl`];
-  } else {
-    packages = [`${SDK_PKG}-${platform}-${arch}`];
-  }
-  return packages.map((p) => `${p}/${binary}`);
-}
-
-// Anchor resolution at the SDK's own entry file, NOT at this module. The SDK
-// calls createRequire(fileURLToPath(import.meta.url)) from inside sdk.mjs, so a
-// nested or pnpm-style layout resolves from that directory's ancestry — not
-// ours. Resolving from here would find a different (or no) platform package.
-const _selfRequire = createRequire(import.meta.url);
-function defaultSdkResolve(specifier) {
-  const sdkRequire = createRequire(_selfRequire.resolve(SDK_PKG));
-  return sdkRequire.resolve(specifier);
-}
-
-/**
- * Resolve the native binary the SDK would pick.
- * @returns {{path: string|null, specifier: string|null, candidates: string[], checked: object[]}}
- */
-export function resolveSdkBinary({
-  platform = process.platform,
-  arch = process.arch,
-  preferMusl,
-  resolve = defaultSdkResolve,
-  exists = existsSync,
-} = {}) {
-  const candidates = sdkBinaryCandidates({ platform, arch, preferMusl });
-  const checked = [];
-
-  for (const specifier of candidates) {
-    try {
-      const resolved = resolve(specifier);
-      const found = exists(resolved);
-      checked.push({ specifier, path: resolved, exists: found });
-      if (found) return { path: resolved, specifier, candidates, checked };
-    } catch (error) {
-      // MODULE_NOT_FOUND on an uninstalled optional dep — the SDK swallows this
-      // per-candidate too and moves on.
-      checked.push({ specifier, error: error?.message || String(error) });
-    }
-  }
-  return { path: null, specifier: null, candidates, checked };
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Exec-bit verification and repair
 // ─────────────────────────────────────────────────────────────────────────────
@@ -254,77 +140,16 @@ export function ensureExecutable(binPath, {
   };
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Claude runtime (resolution + repair, memoized)
-// ─────────────────────────────────────────────────────────────────────────────
-
-const _runtimeCache = new Map();
-
-export function clearNativeBinaryCache() {
-  _runtimeCache.clear();
-}
-
-/**
- * Resolve and repair the SDK's bundled Claude binary.
- *
- * The returned `path` is informational: callers should NOT pass it to the SDK as
- * `pathToClaudeCodeExecutable` on the happy path. Calling this for its chmod
- * side effect and letting the SDK resolve for itself keeps us immune to future
- * changes in the SDK's resolution.
- */
-export function claudeRuntime({
-  platform = process.platform,
-  arch = process.arch,
-  preferMusl,
-  resolve,
-  exists,
-  stat,
-  chmod,
-  access,
-  cache = true,
-} = {}) {
-  const musl = preferMusl === undefined ? detectMusl({ platform }) : !!preferMusl;
-  const key = `${platform}:${arch}:${musl}`;
-  if (cache && _runtimeCache.has(key)) return _runtimeCache.get(key);
-
-  const resolved = resolveSdkBinary({ platform, arch, preferMusl: musl, resolve, exists });
-
-  let result;
-  if (!resolved.path) {
-    result = {
-      path: null,
-      specifier: null,
-      ok: false,
-      state: 'not-installed',
-      repaired: false,
-      repairCommand: null,
-      candidates: resolved.candidates,
-      checked: resolved.checked,
-      reason: `No Claude native binary is installed for ${platform}-${arch}`,
-    };
-  } else {
-    const verdict = ensureExecutable(resolved.path, { platform, stat, chmod, access });
-    result = {
-      ...verdict,
-      specifier: resolved.specifier,
-      candidates: resolved.candidates,
-      checked: resolved.checked,
-    };
-  }
-
-  if (cache) _runtimeCache.set(key, result);
-  return result;
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Executable override contract (one contract for every SDK caller)
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Validate a user-supplied `pathToClaudeCodeExecutable`.
+ * Validate a path before it becomes `pathToClaudeCodeExecutable`: the explicit
+ * override, or the installation lib/claude-executable.js found.
  *
- * The SDK uses that value verbatim with zero validation, so a bad one produces a
- * worse failure than the one we are fixing. In particular a BARE COMMAND NAME
+ * The SDK uses that value verbatim with zero validation, so a bad one fails
+ * late and with the wrong explanation. In particular a BARE COMMAND NAME
  * (e.g. the string 'claude', which getClaudeBin() returns as its last resort)
  * is a guaranteed ENOENT under spawn(shell:false) — it must be rejected here.
  *
@@ -379,9 +204,6 @@ export function resolveClaudeExecutableOverride(spec, {
 // Vendored binary sweep
 // ─────────────────────────────────────────────────────────────────────────────
 
-const CODEX_VENDOR_BIN_DIRS = ['bin', 'codex', 'path'];
-const CODEX_VENDOR_BIN_NAMES = ['codex', 'codex.exe', 'rg', 'rg.exe'];
-
 function safeReaddir(readdir, dir) {
   try {
     return readdir(dir, { withFileTypes: false }) || [];
@@ -391,12 +213,15 @@ function safeReaddir(readdir, dir) {
 }
 
 /**
- * Enumerate every vendored binary that must be executable, by walking the tree
- * rather than hardcoding names. This is what keeps the sweep correct as
- * platform packages and node-pty prebuild directories come and go — the old
+ * Enumerate every native helper of SynaBun's own that must be executable, by
+ * walking the tree rather than hardcoding names: node-pty's spawn-helper, for
+ * every prebuild directory present and for a build from source. The old
  * hardcoded list in scripts/rebuild-pty.js named linux dirs that do not exist
  * here while missing ones that do.
  *
+ * The agent tools are not in this list: Claude Code and Codex are the user's
+ * installations, outside this tree, and nothing of theirs is repaired here.
+ *
  * Every target is optional: a given checkout has only a subset installed.
  */
 export function vendoredBinaryTargets({
@@ -410,18 +235,6 @@ export function vendoredBinaryTargets({
   const targets = [];
   const add = (id, p, kind) => { if (exists(p)) targets.push({ id, path: p, kind }); };
 
-  // 1. Claude Agent SDK platform packages (all of them, not just this host's —
-  //    a vendored checkout can carry several).
-  const anthropicDir = path.join(nm, '@anthropic-ai');
-  for (const entry of safeReaddir(readdir, anthropicDir)) {
-    const name = String(entry);
-    if (!name.startsWith('claude-agent-sdk-')) continue;
-    const pkgDir = path.join(anthropicDir, name);
-    add(`sdk:${name}`, path.join(pkgDir, 'claude'), 'sdk-claude');
-    add(`sdk:${name}:exe`, path.join(pkgDir, 'claude.exe'), 'sdk-claude');
-  }
-
-  // 2. node-pty spawn-helper, for every prebuild directory present.
   const ptyDir = path.join(nm, 'node-pty');
   const prebuildsDir = path.join(ptyDir, 'prebuilds');
   for (const entry of safeReaddir(readdir, prebuildsDir)) {
@@ -429,26 +242,6 @@ export function vendoredBinaryTargets({
   }
   add('pty:build', path.join(ptyDir, 'build', 'Release', 'spawn-helper'), 'pty-spawn-helper');
 
-  // 3. Codex platform packages: vendor/<triple>/{bin,codex,path}/{codex,rg}.
-  //    Hygiene only — server.js deliberately never falls back to the bundled
-  //    Codex binary (macOS quarantine); repairing the bit must not be read as
-  //    enabling that fallback.
-  const openaiDir = path.join(nm, '@openai');
-  for (const entry of safeReaddir(readdir, openaiDir)) {
-    const name = String(entry);
-    if (!name.startsWith('codex')) continue;
-    const vendorDir = path.join(openaiDir, name, 'vendor');
-    for (const triple of safeReaddir(readdir, vendorDir)) {
-      for (const binDir of CODEX_VENDOR_BIN_DIRS) {
-        for (const binName of CODEX_VENDOR_BIN_NAMES) {
-          const p = path.join(vendorDir, String(triple), binDir, binName);
-          add(`codex:${name}:${triple}:${binDir}:${binName}`, p, binName.startsWith('rg') ? 'ripgrep' : 'codex');
-        }
-      }
-    }
-    add(`codex:${name}:bin-rg`, path.join(openaiDir, name, 'bin', 'rg'), 'ripgrep');
-  }
-
   return targets;
 }
 
@@ -514,137 +307,76 @@ export function isNativeBinaryLaunchFailure(err) {
 }
 
 /**
- * Turn a launch failure into a platform-accurate explanation, replacing the
- * SDK's hardcoded musl/glibc story (which is only correct on Linux).
+ * Turn a launch failure of the user's Claude Code into an explanation for the
+ * platform it happened on, replacing the SDK's hardcoded musl/glibc story
+ * (which is only correct on Linux). `executable` is the path the SDK was given.
  *
- * @returns {{kind: string, message: string, repairCommand: string|null, canRetryAfterRepair: boolean}}
+ * @returns {{kind: string, message: string, repairCommand: string|null}}
  */
 export function diagnoseLaunchFailure({
   err,
-  runtime,
+  executable,
   platform = process.platform,
   arch = process.arch,
+  stat = statSync,
+  access = accessSync,
 } = {}) {
-  const rt = runtime || {};
-  const p = rt.path || '(unresolved)';
+  const p = executable || '';
   const raw = (typeof err === 'string' ? err : err?.message) || '';
 
-  switch (rt.state) {
-    case 'repaired':
-      return {
-        kind: 'exec-bit',
-        repairCommand: rt.repairCommand,
-        canRetryAfterRepair: true,
-        message: [
-          `The bundled Claude binary was not executable (mode ${(rt.mode & 0o777).toString(8).padStart(3, '0')}).`,
-          'This is a file permission problem, not a libc mismatch — the SDK always blames libc here.',
-          'Execute permission has been restored; retrying.',
-        ].join(' '),
-      };
+  // The literal "Claude CLI not found" keeps the panel's install help
+  // (ui-claude-panel.js) appearing without a frontend change.
+  const missing = {
+    kind: 'missing',
+    repairCommand: null,
+    message: p
+      ? `Claude CLI not found at ${p}. Claude Code is installed separately from SynaBun: install it again, or correct its path in Settings > Terminal.`
+      : 'Claude CLI not found. Claude Code is installed separately from SynaBun: install it, then send your message again.',
+  };
+  if (!p) return missing;
 
-    case 'chmod-failed':
-    case 'access-denied':
-      return {
-        kind: 'exec-bit',
-        repairCommand: rt.repairCommand,
-        canRetryAfterRepair: false,
-        message: [
-          `The bundled Claude binary at ${p} is not executable and the permission could not be repaired`,
-          `(${rt.error || rt.state}).`,
-          'This is a file permission problem, not a libc mismatch.',
-          `The install may be read-only or owned by another user. Fix it with: sudo ${rt.repairCommand || `chmod +x ${quoteForShell(p)}`}`,
-        ].join(' '),
-      };
+  let info = null;
+  try { info = stat(p); } catch { return missing; }
+  if (typeof info?.isFile === 'function' && !info.isFile()) return { ...missing, message: `Claude CLI not found: ${p} is not a file. Correct its path in Settings > Terminal.` };
 
-    case 'windows-bad-name':
+  if (platform === 'win32') {
+    if (!/\.exe$/i.test(p) && !isScriptPath(p)) {
       return {
         kind: 'shim',
         repairCommand: null,
-        canRetryAfterRepair: false,
-        message: [
-          `${p} cannot be launched: the Claude Agent SDK spawns with shell:false,`,
-          'so npm .cmd/.bat/.ps1 shims will not run. Point the override at the real claude.exe instead.',
-        ].join(' '),
+        message: `${p} cannot be started: the Claude Agent SDK spawns without a shell, so a .cmd, .bat or .ps1 launcher will not run. Name the real claude.exe in cli-config.json ("claude-skin": { "sdkExecutable": "…" }).`,
       };
+    }
+    return { kind: 'unknown', repairCommand: null, message: raw || `Claude Code at ${p} could not be started.` };
+  }
 
-    case 'not-installed':
-    case 'missing':
-    case 'not-a-file':
+  if (!isScriptPath(p)) {
+    try {
+      access(p, constants.X_OK);
+    } catch {
+      const repairCommand = `chmod +x ${quoteForShell(p)}`;
       return {
-        kind: 'missing',
-        repairCommand: null,
-        canRetryAfterRepair: false,
-        // The literal "Claude CLI not found" keeps the panel's existing
-        // install-CTA regex (ui-claude-panel.js) firing without a frontend change.
-        message: [
-          `Claude CLI not found for ${platform}-${arch}.`,
-          'The SDK ships its native binary as a per-platform optional dependency.',
-          'Reinstall without --omit=optional (npm install --include=optional), or install Claude Code globally.',
-        ].join(' '),
+        kind: 'exec-bit',
+        repairCommand,
+        message: `Claude Code at ${p} is not executable by this user. This is a file permission problem, not a libc mismatch. Fix it with: ${repairCommand}`,
       };
-
-    default:
-      break;
+    }
   }
 
-  // Resolved, executable, and it still would not launch.
   if (platform === 'darwin') {
+    const repairCommand = `xattr -d com.apple.quarantine ${quoteForShell(p)}`;
     return {
       kind: 'gatekeeper',
-      repairCommand: `xattr -d com.apple.quarantine ${quoteForShell(p)}`,
-      canRetryAfterRepair: false,
-      message: [
-        `The Claude binary at ${p} is executable but macOS refused to launch it.`,
-        `Usually Gatekeeper quarantine, or a binary built for another architecture (this host is ${arch}).`,
-        `Try: xattr -d com.apple.quarantine ${quoteForShell(p)}`,
-      ].join(' '),
+      repairCommand,
+      message: `Claude Code at ${p} is executable but macOS refused to start it. Usually Gatekeeper quarantine, or a build for another processor (this one is ${arch}). Try: ${repairCommand}`,
     };
   }
   if (platform === 'linux') {
     return {
       kind: 'libc',
       repairCommand: null,
-      canRetryAfterRepair: false,
-      message: [
-        `The Claude binary at ${p} is executable but failed to launch.`,
-        `This host looks like ${detectMusl({ platform }) ? 'musl' : 'glibc'}.`,
-        'A musl-linked binary on a glibc host (or the reverse) fails because the matching dynamic loader is missing.',
-        'Reinstall so the correct linux variant is selected.',
-      ].join(' '),
-    };
-  }
-  return {
-    kind: 'unknown',
-    repairCommand: null,
-    canRetryAfterRepair: false,
-    message: raw || `The Claude binary at ${p} failed to launch.`,
-  };
-}
-
-/**
- * Decide what to do about a launch failure. Pure, so the bridge's recovery
- * behaviour is unit-testable without a live WebSocket.
- *
- * @returns {{action: 'retry'|'fallback'|'fail', message: string, kind: string, repairCommand: string|null}}
- */
-export function planRuntimeRecovery({
-  err,
-  runtime,
-  fallbackBin = null,
-  alreadyTried = false,
-  platform = process.platform,
-  arch = process.arch,
-} = {}) {
-  const dx = diagnoseLaunchFailure({ err, runtime, platform, arch });
-  const base = { message: dx.message, kind: dx.kind, repairCommand: dx.repairCommand };
-
-  if (dx.canRetryAfterRepair && !alreadyTried) return { ...base, action: 'retry' };
-  if (fallbackBin) {
-    return {
-      ...base,
-      action: 'fallback',
-      message: `${dx.message}\nFalling back to your installed Claude CLI: ${fallbackBin}`,
+      message: `Claude Code at ${p} is executable but could not be started. A musl-linked build on a glibc system (or the reverse) fails because its dynamic loader is missing. Reinstall Claude Code so that the build for this system is selected.`,
     };
   }
-  return { ...base, action: 'fail' };
+  return { kind: 'unknown', repairCommand: null, message: raw || `Claude Code at ${p} could not be started.` };
 }

package/neural-interface/lib/native-loop-providers.js

@@ -1,8 +1,8 @@
 import { detectProject as memoryProject } from '../../mcp-server/dist/config.js';
 import { Codex } from '@openai/codex-sdk';
 import { query as claudeQuery } from '@anthropic-ai/claude-agent-sdk';
-import { CLAUDE_EFFORT_LEVELS, markAlignedClaudeExecutableFailed } from './claude-model-catalog.js';
-import { claudeRuntime, isNativeBinaryLaunchFailure, resolveClaudeExecutableOverride } from './native-binary-runtime.js';
+import { CLAUDE_EFFORT_LEVELS } from './claude-model-catalog.js';
+import { CLAUDE_NOT_INSTALLED, resolveClaudeSdkExecutable } from './claude-executable.js';
 import { extractOpenCodeText } from './session-title-generator.js';
 import { patchCodexLineSplitting } from './jsonl-lines.js';
 import { dirname } from 'node:path';
@@ -286,6 +286,14 @@ export async function createCodexNativeLoopAdapter(options = {}) {
   if (Object.keys(pins).length) config.mcp_servers = { SynaBun: { env: pins } };
   if (extended) config.model_context_window = Math.floor(Number(modelContextWindow));
   if (browserPolicy) Object.assign(config, browserPolicy.config);
+  // The SDK is always told which Codex to start: the user's own installation.
+  // SynaBun carries none, and left to itself the SDK would look for one inside
+  // its own packages and report that as a broken install.
+  if (!codexPath && CodexClass === Codex) {
+    const error = new Error('Codex CLI not found. Codex is installed separately from SynaBun: install it, then run this again.');
+    error.code = 'CODEX_NOT_INSTALLED';
+    throw error;
+  }
   const codex = new CodexClass({
     ...(codexPath ? { codexPathOverride: codexPath } : {}),
     env,
@@ -406,12 +414,11 @@ export async function createClaudeNativeLoopAdapter(options = {}) {
   const {
     runId, cwd, model, effort, browserSessionId, browserTabId,
     mcpUrl, onIdentity = () => {}, onEvent = () => {}, queryFactory = claudeQuery,
-    sdkExecutable, includePartialMessages = process.platform !== 'win32',
-    // Fallback CLI + runtime probe, injectable for tests.
-    claudeBin = null, resolveRuntime = claudeRuntime, logWarn = console.warn,
-    // Installed CLI to run instead of the bundled one because it is newer — see
-    // alignedClaudeExecutable() in claude-model-catalog.js. null keeps bundled.
-    alignedClaudeBin = null,
+    includePartialMessages = process.platform !== 'win32',
+    // Which Claude Code runs the loop: the answer of resolveClaudeSdkExecutable()
+    // (lib/claude-executable.js), as the host worked it out. A caller without
+    // one names the pieces instead: the cli-config override and the installed CLI.
+    claudeExecutable = null, sdkExecutable = null, claudeBin = null, logWarn = console.warn,
     // Task-mode options (assistant dispatch).
     extraEnv = {}, permissionPolicy: rawPolicy = 'auto', permissionBroker = null,
     capability: rawCapability = 'full', maxBudgetUsd = null, outputSchema = null, runMode = 'loop',
@@ -522,41 +529,22 @@ export async function createClaudeNativeLoopAdapter(options = {}) {
   if (capability === 'read-only') queryOptions.disallowedTools = [...CLAUDE_READ_ONLY_DISALLOWED_TOOLS];
   if (Number(maxBudgetUsd) > 0) queryOptions.maxBudgetUsd = Number(maxBudgetUsd);
   if (outputSchema && typeof outputSchema === 'object') queryOptions.outputFormat = { type: 'json_schema', schema: outputSchema };
-  // The SDK uses pathToClaudeCodeExecutable verbatim with no validation, so vet
-  // the override first (a bare command name would ENOENT under shell:false).
-  // With no override, calling resolveRuntime() also restores the execute bit on
-  // the bundled binary — npm drops it, and this repo commits node_modules.
+  // The loop runs the user's own Claude Code: SynaBun carries none, and the SDK
+  // is never left to look for one. The SDK uses pathToClaudeCodeExecutable
+  // verbatim with no validation, so the path was vetted where it was resolved
+  // (a bare command name would ENOENT under shell:false).
   //
-  // Pre-flight only: unattended loops have no one to prompt, and retries are
-  // owned by native-loop-runtime.js. A bad runtime here means we pick the
-  // fallback CLI up front rather than failing mid-loop.
-  const override = resolveClaudeExecutableOverride(sdkExecutable);
-  // The installed CLI, when it is newer than the bundled one: the loop's model was
-  // picked from that CLI's list, and the bundled binary would resolve the same alias
-  // to an older model. Vetted with the same contract as any override.
-  const aligned = !override.path && alignedClaudeBin
-    ? resolveClaudeExecutableOverride(alignedClaudeBin)
-    : null;
-  const alignedPath = aligned?.ok && aligned.path ? aligned.path : null;
-  if (override.path) {
-    queryOptions.pathToClaudeCodeExecutable = override.path;
-  } else {
-    if (sdkExecutable) logWarn(`[native-loop] ignoring sdkExecutable override — ${override.reason}`);
-    if (alignedPath) {
-      queryOptions.pathToClaudeCodeExecutable = alignedPath;
-    } else {
-      const runtime = resolveRuntime();
-      if (!runtime.ok) {
-        const fallback = resolveClaudeExecutableOverride(claudeBin);
-        if (fallback.ok && fallback.path) {
-          queryOptions.pathToClaudeCodeExecutable = fallback.path;
-          logWarn(`[native-loop] bundled Claude binary unusable (${runtime.state}) — using ${fallback.path}`);
-        } else {
-          logWarn(`[native-loop] bundled Claude binary unusable (${runtime.state}) and no launchable `
-            + `fallback CLI: ${runtime.reason || fallback.reason || 'none configured'}`);
-        }
-      }
-    }
+  // Pre-flight only: an unattended loop has no one to prompt, and retries are
+  // owned by native-loop-runtime.js. Without a Claude Code to start, the run
+  // fails here, with the reason, instead of somewhere inside the first turn.
+  const executable = claudeExecutable || resolveClaudeSdkExecutable({ launcher: claudeBin, sdkExecutable });
+  if (executable.ignored) logWarn(`[native-loop] ignoring sdkExecutable override — ${executable.ignored}`);
+  if (executable.path) {
+    queryOptions.pathToClaudeCodeExecutable = executable.path;
+  } else if (queryFactory === claudeQuery) {
+    const error = new Error(executable.reason || CLAUDE_NOT_INSTALLED);
+    error.code = 'CLAUDE_NOT_INSTALLED';
+    throw error;
   }
 
   const q = queryFactory({ prompt: input, options: queryOptions });
@@ -648,8 +636,6 @@ export async function createClaudeNativeLoopAdapter(options = {}) {
       }
     } catch (error) {
       pumpError = error;
-      // The aligned CLI would not start. Later runs go back to the bundled runtime.
-      if (alignedPath && isNativeBinaryLaunchFailure(error)) markAlignedClaudeExecutableFailed(alignedPath);
     } finally {
       flushDeltas();
       if (alive) {
@@ -663,11 +649,16 @@ export async function createClaudeNativeLoopAdapter(options = {}) {
     }
     if (pumpError) throw pumpError;
   })();
-  pump.catch((error) => onEvent({
-    provider: 'claude-code',
-    runId,
-    event: { type: 'synabun.error', message: error?.message || String(error) },
-  }));
+  pump.catch((error) => {
+    // dispose() aborts the query when the run ends, however it ended, and the
+    // SDK throws "Claude Code process aborted by user" for it: not a failure.
+    if (abortController.signal.aborted) return;
+    onEvent({
+      provider: 'claude-code',
+      runId,
+      event: { type: 'synabun.error', message: error?.message || String(error) },
+    });
+  });
 
   return {
     identity: () => ({ providerSessionId: sessionId }),