synabun 2.0.7 → 2.0.10

package/neural-interface/lib/codex-settings-schema.js

@@ -1,10 +1,66 @@
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+// The probes run no command: always the Windows sandbox that needs no administrator (lib/agent-sandbox-elevation.js).
+import { CODEX_PROBE_SANDBOX_ARGS } from './agent-sandbox-elevation.js';
 
+// The probes start Codex itself (a 300 MB binary on Windows) once per setting value: asynchronous, never
+// more than two at a time, one run per binary for every caller, and kept per binary identity (path, mtime,
+// size: an update is another binary) in memory and, through setCodexSettingsStore(), across restarts.
 const cache = new Map();
 const featureCache = new Map();
+const inflight = new Map();
+const latestSchema = new Map(); // codexBin → the schema of the binary as it was last read
+let store = null;
+const MAX_PROBES = 2;
+let running = 0;
+const waiting = [];
+
+/** Where answers are kept across restarts: `{ get(key) → value | undefined, set(key, value) }` (lib/launch-cache.js). */
+export function setCodexSettingsStore(next) {
+  store = next && typeof next.get === 'function' && typeof next.set === 'function' ? next : null;
+}
+
+function limited(job) {
+  return new Promise((resolve, reject) => {
+    waiting.push({ job, resolve, reject });
+    const pump = () => {
+      while (running < MAX_PROBES && waiting.length) {
+        const next = waiting.shift();
+        running += 1;
+        Promise.resolve().then(next.job).then(next.resolve, next.reject).finally(() => { running -= 1; pump(); });
+      }
+    };
+    pump();
+  });
+}
+
+// One Codex run: { status, stdout } (status null when it could not start or ran out of time).
+function probe(codexBin, args, { env, timeout }) {
+  return limited(() => new Promise((resolve) => {
+    execFile(codexBin, args, { env, encoding: 'utf8', timeout, windowsHide: true, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => {
+      resolve({ status: error ? (typeof error.code === 'number' ? error.code : null) : 0, stdout: String(stdout || '') });
+    });
+  }));
+}
+
+// What was found for `key` before (this run, or the last one through the store), or undefined.
+function known(memo, key) {
+  if (memo.has(key)) return memo.get(key);
+  try {
+    const kept = store?.get(key);
+    if (kept && typeof kept === 'object') { memo.set(key, kept); return kept; }
+  } catch { /* nothing kept */ }
+  return undefined;
+}
+
+function once(key, run) {
+  if (inflight.has(key)) return inflight.get(key);
+  const job = Promise.resolve().then(run).finally(() => inflight.delete(key));
+  inflight.set(key, job);
+  return job;
+}
 export const CODEX_SETTINGS_KEYS = Object.freeze([
   'model', 'review_model', 'model_provider', 'approval_policy', 'sandbox_mode', 'personality',
   'service_tier', 'model_reasoning_effort', 'model_reasoning_summary', 'model_verbosity',
@@ -38,33 +94,38 @@ export function settingsSchemaFromProtocol(configSchema, threadSchema) {
 }
 
 /** Generate from the executable we actually launch; never use the global home. */
-export function readCodexSettingsSchema(codexBin) {
-  const stamp = statSync(codexBin);
-  const key = `${codexBin}:${stamp.mtimeMs}:${stamp.size}`;
-  if (cache.has(key)) return cache.get(key);
-  const home = mkdtempSync(join(tmpdir(), 'synabun-codex-schema-'));
-  try {
-    const out = join(home, 'schema');
-    const run = spawnSync(codexBin, ['app-server', 'generate-json-schema', '--experimental', '--out', out], {
-      env: { ...process.env, CODEX_HOME: home }, encoding: 'utf8', timeout: 15000, windowsHide: true,
-    });
-    if (run.error || run.status !== 0) throw new Error('Codex could not report its settings schema');
-    const read = name => JSON.parse(readFileSync(join(out, 'v2', `${name}.json`), 'utf8'));
-    const schema = settingsSchemaFromProtocol(read('ConfigReadResponse'), read('ThreadStartParams'));
-    // Protocol enums can retain deprecated variants that the config loader
-    // already rejects (0.162 still exports `untrusted`). Ask the loader too.
-    // `features list` validates config locally and never runs a model or tool.
-    for (const [fieldKey, field] of Object.entries(schema.fields)) {
-      field.values = field.values.filter(value => {
-        const check = spawnSync(codexBin, ['-c', `${fieldKey}=${JSON.stringify(value)}`, 'features', 'list'], {
-          env: { ...process.env, CODEX_HOME: home }, encoding: 'utf8', timeout: 5000, windowsHide: true,
-        });
-        return !check.error && check.status === 0;
-      });
-    }
-    cache.set(key, schema);
-    return schema;
-  } finally { rmSync(home, { recursive: true, force: true }); }
+export async function readCodexSettingsSchema(codexBin) {
+  const stamp = await stat(codexBin);
+  const key = `schema:${codexBin}:${stamp.mtimeMs}:${stamp.size}`;
+  const found = known(cache, key);
+  if (found) { latestSchema.set(codexBin, found); return found; }
+  return once(key, async () => {
+    const home = await mkdtemp(join(tmpdir(), 'synabun-codex-schema-'));
+    try {
+      const env = { ...process.env, CODEX_HOME: home };
+      const out = join(home, 'schema');
+      const run = await probe(codexBin, ['app-server', 'generate-json-schema', '--experimental', '--out', out, ...CODEX_PROBE_SANDBOX_ARGS], { env, timeout: 15000 });
+      if (run.status !== 0) throw new Error('Codex could not report its settings schema');
+      const read = async name => JSON.parse(await readFile(join(out, 'v2', `${name}.json`), 'utf8'));
+      const schema = settingsSchemaFromProtocol(await read('ConfigReadResponse'), await read('ThreadStartParams'));
+      // Protocol enums can retain deprecated variants that the config loader
+      // already rejects (0.162 still exports `untrusted`). Ask the loader too.
+      // `features list` validates config locally and never runs a model or tool.
+      for (const [fieldKey, field] of Object.entries(schema.fields)) {
+        const checks = await Promise.all(field.values.map(value => probe(codexBin, [...CODEX_PROBE_SANDBOX_ARGS, '-c', `${fieldKey}=${JSON.stringify(value)}`, 'features', 'list'], { env, timeout: 5000 })));
+        field.values = field.values.filter((_, index) => checks[index].status === 0);
+      }
+      cache.set(key, schema);
+      latestSchema.set(codexBin, schema);
+      try { store?.set(key, schema); } catch { /* kept in memory */ }
+      return schema;
+    } finally { await rm(home, { recursive: true, force: true }).catch(() => {}); }
+  });
+}
+
+/** The schema readCodexSettingsSchema() last gave for this binary, or null: never starts Codex. */
+export function cachedCodexSettingsSchema(codexBin) {
+  return latestSchema.get(codexBin) || null;
 }
 
 export function validateCodexSettings(config, schema, features = []) {
@@ -97,24 +158,27 @@ export function validateCodexSettings(config, schema, features = []) {
 
 /** Some stable flags are now mandatory and ignore false (e.g. unified_exec).
  * Check both states with the local loader instead of offering a no-op switch. */
-export function readCodexFeatureSupport(codexBin, features) {
+export async function readCodexFeatureSupport(codexBin, features) {
   const names = features.filter(f => ['stable', 'beta'].includes(f.stage) && /^[A-Za-z0-9_-]+$/.test(f.name)).map(f => f.name).sort();
-  const stat = statSync(codexBin);
-  const key = `${codexBin}:${stat.mtimeMs}:${stat.size}:${names.join(',')}`;
-  if (featureCache.has(key)) return featureCache.get(key);
-  const home = mkdtempSync(join(tmpdir(), 'synabun-feature-support-'));
-  try {
-    const states = [false, true].map(value => {
-      const check = spawnSync(codexBin, ['-c', `features={${names.map(name => `${name}=${value}`).join(',')}}`, 'features', 'list'], {
-        env: { ...process.env, CODEX_HOME: home }, encoding: 'utf8', timeout: 10000, windowsHide: true,
-      });
-      if (check.error || check.status !== 0) throw new Error('Codex could not validate feature switches');
-      return new Map(check.stdout.split('\n').map(line => {
-        const parts = line.trim().split(/\s+/); return [parts[0], parts.at(-1)];
+  const stamp = await stat(codexBin);
+  const key = `features:${codexBin}:${stamp.mtimeMs}:${stamp.size}:${names.join(',')}`;
+  const found = known(featureCache, key);
+  if (found) return found;
+  return once(key, async () => {
+    const home = await mkdtemp(join(tmpdir(), 'synabun-feature-support-'));
+    try {
+      const env = { ...process.env, CODEX_HOME: home };
+      const states = await Promise.all([false, true].map(async value => {
+        const check = await probe(codexBin, [...CODEX_PROBE_SANDBOX_ARGS, '-c', `features={${names.map(name => `${name}=${value}`).join(',')}}`, 'features', 'list'], { env, timeout: 10000 });
+        if (check.status !== 0) throw new Error('Codex could not validate feature switches');
+        return new Map(check.stdout.split('\n').map(line => {
+          const parts = line.trim().split(/\s+/); return [parts[0], parts.at(-1)];
+        }));
       }));
-    });
-    const supported = Object.fromEntries(names.map(name => [name, states[0].get(name) === 'false' && states[1].get(name) === 'true']));
-    featureCache.set(key, supported);
-    return supported;
-  } finally { rmSync(home, { recursive: true, force: true }); }
+      const supported = Object.fromEntries(names.map(name => [name, states[0].get(name) === 'false' && states[1].get(name) === 'true']));
+      featureCache.set(key, supported);
+      try { store?.set(key, supported); } catch { /* kept in memory */ }
+      return supported;
+    } finally { await rm(home, { recursive: true, force: true }).catch(() => {}); }
+  });
 }

package/neural-interface/lib/editor-completion-opencode.js

@@ -26,13 +26,22 @@
 // that folder are deleted: every request that arrives meanwhile waits for the
 // same start, so no request's own session is ever taken for a leftover. A start
 // that fails after its process was spawned (the serve never answers, its client
-// cannot be built, a stop is asked for meanwhile) stops that process and fails
-// for everybody who waited for it; stop() ends a start that is under way too.
+// cannot be built, a stop is asked for meanwhile) stops that process (SIGTERM,
+// then SIGKILL when it does not end) and fails for everybody who waited for it;
+// stop() ends a start that is under way too. Another server that took the port
+// (trackServe says 'foreign') is left running while the start tries another.
 // There is no fallback to the shared serve. Everything that touches a process,
 // a port or the network is injected: tests run against a fake.
 
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, resolve, sep } from 'node:path';
+import { checkOpencodeServer, newServePassword } from './opencode-protocol.js';
+
+// OpenCode 2 (lib/opencode-protocol.js) runs the same way: the serve gets a
+// password of its own, is healthy only when its /api answers JSON, and is
+// spoken to through lib/opencode2-client.js; its configuration is the OpenCode
+// 1 file below, which OpenCode 2 reads (agent → agents, prompt → system,
+// temperature → request body).
 
 export const COMPLETION_AGENT = 'synabun-complete';
 /** Every session of this serve carries this title: no title is generated, and leftovers of a crash are recognisable. */
@@ -41,6 +50,8 @@ export const IDLE_STOP_MS = 10 * 60_000;
 export const START_TIMEOUT_MS = 15_000;
 /** How long a start waits for the sessions a crash left behind to be listed and deleted. */
 export const SWEEP_TIMEOUT_MS = 5000;
+/** How many ports a start tries when another server takes the one it was given. */
+export const START_ATTEMPTS = 3;
 
 // What of the user's OpenCode configuration decides which models can be reached.
 const CARRIED_KEYS = ['provider', 'disabled_providers', 'enabled_providers'];
@@ -196,11 +207,25 @@ function abortError() {
  * @param {() => object | null} deps.readUserConfig the user's OpenCode configuration, read at each start
  * @param {() => string | null} [deps.userConfigDir] the folder that configuration is in (relative {file:…}
  *   references of its providers are resolved against it)
- * @param {() => number | null} deps.allocPort a free port (server.js allocOpencodeIsoPort)
- * @param {(o: { port: number, env: object, cwd: string }) => object} deps.spawnServe starts `opencode serve` on the
- *   port and returns its process (`on('exit')`, `kill()`)
- * @param {(proc: object) => void} [deps.killServe] stops that process (default: SIGTERM)
- * @param {(o: { port: number }) => object} deps.createClient lib/opencode-v2-client.js createClientInstance
+ * @param {() => number | null | Promise<number | null>} deps.allocPort a free port (server.js: what an earlier
+ *   SynaBun left running goes first, then allocOpencodeIsoPort)
+ * @param {(o: { port: number, env: object, cwd: string, protocol: 1 | 2 | null, password: string | null }) => object}
+ *   deps.spawnServe starts `opencode serve` on the port (OpenCode 2: with that password) and returns its process
+ *   (`on('exit')`, `kill()`)
+ * @param {(proc: object, signal?: string) => void} [deps.killServe] stops that process: SIGTERM, or SIGKILL for a
+ *   failed start's process that did not end (default: proc.kill(signal))
+ * @param {(o: { port: number, protocol?: number, password?: string | null, version?: string }) => object}
+ *   deps.createClient lib/opencode-v2-client.js createClientInstance
+ * @param {() => Promise<number | null | { protocol: number | null, major?: number | null, supported?: boolean, reason?: string }>}
+ *   [deps.detectProtocol] the OpenCode major the serve will be (server.js detectOpencodeProtocol); 1 when not given
+ * @param {(protocol: number | null, run: () => Promise<any>) => Promise<any>} [deps.startOneAtATime] runs a start
+ *   in its turn among every serve SynaBun starts (server.js oneOpencodeStartAtATime); by itself when not given
+ * @param {number} [deps.exitWaitMs] how long a failed start waits for its process to exit after SIGTERM, and again
+ *   after SIGKILL, before its turn ends
+ * @param {(o: { port: number, proc: object }) => any} [deps.trackServe] told once something answers on the port
+ *   (server.js keeps the serve on record from its spawn, so that a crash of SynaBun does not leave it running for
+ *   good); 'foreign' (or a promise of it): what answers is not this start's process but another server that took
+ *   the port, which is left running while the start ends its own process and tries another port
  * @param {typeof fetch} [deps.fetchImpl]
  * @param {object} [deps.env] the environment the serve starts from
  * @param {number} [deps.idleMs] the serve is stopped after this long without a request
@@ -210,9 +235,11 @@ function abortError() {
  */
 export function createOpencodeCompletionEngine({
   dataDir, system, readUserConfig = () => null, userConfigDir = () => null, allocPort, spawnServe,
-  killServe = (proc) => { try { proc.kill('SIGTERM'); } catch { /* gone */ } },
+  killServe = (proc, signal = 'SIGTERM') => { try { proc.kill(signal); } catch { /* gone */ } },
   createClient, fetchImpl = (...args) => fetch(...args), env = process.env, now = Date.now,
   idleMs = IDLE_STOP_MS, startTimeoutMs = START_TIMEOUT_MS, sweepTimeoutMs = SWEEP_TIMEOUT_MS, healthPollMs = 100, log = () => {},
+  detectProtocol = async () => 1, newPassword = newServePassword,
+  startOneAtATime = (_protocol, run) => run(), exitWaitMs = 3000, trackServe = () => {},
 } = {}) {
   if (!dataDir || !system) throw new Error('createOpencodeCompletionEngine requires dataDir and system');
   if (typeof allocPort !== 'function' || typeof spawnServe !== 'function' || typeof createClient !== 'function') {
@@ -266,7 +293,7 @@ export function createOpencodeCompletionEngine({
 
   async function start() {
     const mine = epoch;
-    const port = allocPort();
+    let port = await allocPort();
     if (port == null) throw new Error('No free port for the completion server');
     mkdirSync(join(dataDir, 'opencode'), { recursive: true });
     mkdirSync(workDir, { recursive: true });
@@ -276,39 +303,100 @@ export function createOpencodeCompletionEngine({
     try { configDir = userConfigDir() || null; } catch { configDir = null; }
     writeFileSync(join(dataDir, 'opencode', 'config.json'), `${JSON.stringify(buildCompletionServeConfig(userConfig, { system, configDir, log }), null, 2)}\n`, 'utf8');
 
-    const started = { port, proc: null, client: null, variants: new Map(), providers: null, providersAt: 0, exited: false, killed: false, halt: null };
+    // Which OpenCode this is (null: not known, told apart by what answers); a major SynaBun does not speak never starts.
+    const detected = await detectProtocol();
+    const protocol = detected && typeof detected === 'object' ? (detected.protocol ?? null) : (detected ?? null);
+    if (detected && typeof detected === 'object' && detected.supported === false && detected.major != null) {
+      throw new Error(detected.reason || `OpenCode ${detected.major} is not supported`);
+    }
+    if (mine !== epoch) throw new Error('The completion server was stopped while it was starting');
+    const password = protocol === 1 ? null : newPassword();
+
+    // Another server that takes the port while the serve boots is a start collision: it is left running, this start's
+    // own process is ended, and the start tries another port (START_ATTEMPTS ports at most).
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return await startOn(port, { mine, protocol, password });
+      } catch (error) {
+        if (!error?.portTaken || attempt >= START_ATTEMPTS || mine !== epoch) throw error;
+        log('editor-complete:serve', `another server answers on port ${port}: it is left running, and the completion server tries another port`);
+        port = await allocPort();
+        if (port == null) throw new Error('No free port for the completion server');
+      }
+    }
+  }
+
+  // A start that failed holds its turn until its process has exited (OpenCode 2 cannot open its database while a
+  // serve that is going holds it). It was sent SIGTERM (end()); one still running after `exitWaitMs` is sent SIGKILL
+  // (killServe, through its handle: SynaBun's own child, never another pid) and waited for once more. One that
+  // outlives even that stays on record (server.js keeps a serve on record until its exit is seen). True once it exited.
+  async function waitForExit(serve) {
+    const exited = async () => {
+      for (let waited = 0; serve.proc && !serve.exited && waited < exitWaitMs; waited += 25) await sleep(25);
+      return !serve.proc || serve.exited;
+    };
+    if (await exited()) return true;
+    log('editor-complete:serve', `the completion server's process did not end within ${Math.round(exitWaitMs / 1000)} s of SIGTERM: SIGKILL`);
+    try { killServe(serve.proc, 'SIGKILL'); } catch { /* already gone */ }
+    if (await exited()) return true;
+    log('editor-complete:serve', 'the completion server\'s process still runs after SIGKILL: it stays on record');
+    return false;
+  }
+
+  async function startOn(port, { mine, protocol, password }) {
+    const started = { port, proc: null, client: null, variants: new Map(), providers: null, providersAt: 0, exited: false, killed: false, halt: null, protocol, password };
     // What a stop wakes: a start that waits (for the serve to answer, for the next look) goes on at once.
     const halted = new Promise((done) => { started.halt = done; });
-    started.proc = spawnServe({ port, env: completionServeEnvironment(env, { configHome: dataDir }), cwd: workDir });
-    starts++;
-    spawned = started;
-    // From here on a process runs. Whatever goes wrong before the serve is ready, it does not stay behind.
+    // Both are checked before and after each wait: a stop may have been asked for, or the process may be gone.
+    const stillWanted = () => {
+      if (mine !== epoch) throw new Error('The completion server was stopped while it was starting');
+      if (started.exited) throw new Error('The completion server stopped while it was starting. Is OpenCode installed?');
+    };
+    // Whatever goes wrong once a process runs, before the serve is ready, it does not stay behind.
     try {
-      started.proc?.on?.('exit', () => {
-        started.exited = true;
-        if (entry === started) { entry = null; if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; } }
-      });
-      started.proc?.on?.('error', () => { started.exited = true; });
-
-      // Both are checked before and after each wait: a stop may have been asked for, or the process may be gone.
-      const stillWanted = () => {
-        if (mine !== epoch) throw new Error('The completion server was stopped while it was starting');
-        if (started.exited) throw new Error('The completion server stopped while it was starting. Is OpenCode installed?');
-      };
-      const deadline = now() + startTimeoutMs;
-      for (;;) {
+      // One start at a time with every other serve SynaBun starts (OpenCode 2 cannot open its database while
+      // another serve is opening it): from the spawn until this serve answers, or until a failed start's process
+      // is gone.
+      const check = await startOneAtATime(protocol, async () => {
         stillWanted();
+        started.proc = spawnServe({ port, env: completionServeEnvironment(env, { configHome: dataDir }), cwd: workDir, protocol, password });
+        starts++;
+        spawned = started;
+        started.proc?.on?.('exit', () => {
+          started.exited = true;
+          if (entry === started) { entry = null; if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; } }
+        });
+        started.proc?.on?.('error', () => { started.exited = true; });
         try {
-          const res = await Promise.race([fetchImpl(`http://127.0.0.1:${port}/global/health`, { signal: AbortSignal.timeout(2000) }), halted]);
-          if (res?.ok) break;
-        } catch { /* not up yet */ }
-        stillWanted();
-        if (now() >= deadline) throw new Error(`The completion server did not answer within ${Math.round(startTimeoutMs / 1000)} seconds`);
-        await Promise.race([sleep(healthPollMs), halted]);
-      }
+          const deadline = now() + startTimeoutMs;
+          for (;;) {
+            stillWanted();
+            // The right API answering JSON, never a web page (lib/opencode-protocol.js).
+            const answer = await Promise.race([checkOpencodeServer({ port, protocol, password, fetchImpl, timeoutMs: 2000 }), halted]);
+            if (answer?.ok) {
+              // Only this start's own process counts: another server that took the port answers for itself.
+              let verdict = null;
+              try { verdict = await trackServe({ port, proc: started.proc }); } catch { /* the record is the caller's */ }
+              if (verdict === 'foreign') throw Object.assign(new Error(`Another server answers on port ${port}`), { portTaken: true });
+              return answer;
+            }
+            stillWanted();
+            if (now() >= deadline) {
+              const what = answer && answer.state && answer.state !== 'down' ? `: ${answer.error}` : '';
+              throw new Error(`The completion server did not answer within ${Math.round(startTimeoutMs / 1000)} seconds${what}`);
+            }
+            await Promise.race([sleep(healthPollMs), halted]);
+          }
+        } catch (error) {
+          end(started);
+          await waitForExit(started);
+          throw error;
+        }
+      });
       stillWanted();
 
-      started.client = createClient({ port });
+      started.protocol = check.protocol || protocol || 1;
+      started.client = createClient({ port, protocol: started.protocol, password, version: check.version || '' });
       // It answers, and takes no request yet. First the sessions a crash left behind go: a sweep that ran beside the
       // first requests would find their sessions in its listing and delete them under the model call. Meanwhile,
       // which lighter reasoning setting each model offers; worth a short wait, as without it the first completions
@@ -335,6 +423,15 @@ export function createOpencodeCompletionEngine({
 
   async function loadProviders(serve, { signal } = {}) {
     if (serve.providers && now() - serve.providersAt < 60_000) return serve.providers;
+    if (serve.protocol === 2) {
+      // OpenCode 2 has no /provider: its client answers in OpenCode 1's shape ({ all, default, connected }).
+      const listed = await serve.client.getClient().provider.list({ directory: workDir });
+      if (listed?.error) throw new Error(`The completion server answered ${listed.response?.status || 'an error'} for its model list`);
+      serve.providers = listed.data;
+      serve.providersAt = now();
+      serve.variants = variantsByModel(serve.providers);
+      return serve.providers;
+    }
     const res = await fetchImpl(serveUrl(serve.port, '/provider'), { signal: signal || AbortSignal.timeout(8000) });
     if (!res.ok) throw new Error(`The completion server answered ${res.status} for its model list`);
     serve.providers = await res.json();

package/neural-interface/lib/exec-loop-command.js

@@ -82,6 +82,10 @@ export function buildExecInvocation({
   model,
   effort,
   mcpEnvOverrides = [],
+  // Codex: launch overrides as `-c` words (the Windows sandbox of the Admin sandbox setting).
+  codexConfigArgs = [],
+  // OpenCode: the major of the CLI (lib/opencode-protocol.js); 2 has other `run` flags.
+  opencodeMajor = 1,
   platform = process.platform,
   commandExists = existsSync,
 } = {}) {
@@ -94,7 +98,7 @@ export function buildExecInvocation({
 
   switch (profile) {
     case 'codex': {
-      args.push('exec', '--dangerously-bypass-approvals-and-sandbox');
+      args.push('exec', '--dangerously-bypass-approvals-and-sandbox', ...codexConfigArgs);
       for (const [key, value] of mcpEnvOverrides) {
         args.push('-c', `mcp_servers.SynaBun.env.${key}=${codexConfigString(value)}`);
       }
@@ -109,7 +113,12 @@ export function buildExecInvocation({
       if (model) args.push('--model', String(model));
       break;
     case 'opencode':
-      args.push('run', '--dangerously-skip-permissions');
+      // OpenCode 2: a private server for this run (`--standalone`; without it the
+      // CLI uses the machine's background service, which has none of the loop's
+      // configuration) and `--auto` (approve what is not denied) for the flag
+      // OpenCode 1 took.
+      if (Number(opencodeMajor) >= 2) args.push('run', '--standalone', '--auto');
+      else args.push('run', '--dangerously-skip-permissions');
       if (model) args.push('--model', String(model));
       args.push('--format', 'default');
       break;

package/neural-interface/lib/install-details.js

@@ -26,15 +26,29 @@ export function packagesInLock(lock) {
   return entries.filter(key => /(?:^|\/)node_modules\//.test(key)).length;
 }
 
+/** How many packages of a lockfile are on disk under `root` (npm-shrinkwrap.json of an npm install). */
+export function installedFromLock(lock, root, { exists = existsSync } = {}) {
+  const entries = lock && typeof lock.packages === 'object' ? Object.keys(lock.packages) : [];
+  return entries.filter(key => /(?:^|\/)node_modules\//.test(key) && exists(path.join(root, ...key.split('/')))).length;
+}
+
 /**
- * A part's own dependencies (its package.json), each with the version installed in its node_modules, or null
- * when it is not installed. Sorted by name.
+ * A part's own dependencies (its package.json), each with the version Node finds for it, or null when it is not
+ * installed. Sorted by name. Found in the part's node_modules, and with `stopAt` (the package root) in each folder
+ * up to it too: `npm i -g synabun` installs every part's dependencies at the package root.
  */
-export function directDependencies(dir, { readJson = readJsonFile } = {}) {
+export function directDependencies(dir, { readJson = readJsonFile, stopAt = null } = {}) {
   const manifest = readJson(path.join(dir, 'package.json')) || {};
   const wanted = { ...(manifest.optionalDependencies || {}), ...(manifest.dependencies || {}) };
+  const limit = stopAt ? path.resolve(stopAt) : null;
+  const find = (name) => {
+    for (let folder = path.resolve(dir); ; folder = path.dirname(folder)) {
+      const found = readJson(path.join(folder, 'node_modules', ...name.split('/'), 'package.json'));
+      if (found || !limit || folder === limit || path.dirname(folder) === folder) return found;
+    }
+  };
   return Object.keys(wanted).sort().map((name) => {
-    const installed = readJson(path.join(dir, 'node_modules', ...name.split('/'), 'package.json'));
+    const installed = find(name);
     return { name, wanted: String(wanted[name]), installed: installed?.version ? String(installed.version) : null };
   });
 }
@@ -112,10 +126,14 @@ export async function collectInstallDetails({
   const userNpmPath = firstOnPath('npm', osPath, { platform, exists, skip: runtimeBin ? [runtimeBin, impl.dirname(execPath)] : [] });
   const userNpm = userNpmPath && userNpmPath !== ownNpm ? { path: userNpmPath, ...(await version(userNpmPath, { platform, env })) } : null;
 
+  // A part's own install record when it has one (a development checkout, a desktop build); an npm install keeps
+  // both parts' dependencies at the package root instead, pinned by npm-shrinkwrap.json.
+  const shrinkwrap = readJson(path.join(packageRoot, 'npm-shrinkwrap.json'));
   const parts = [['Neural Interface', 'neural-interface'], ['MCP server', 'mcp-server']].map(([name, folder]) => {
     const dir = path.join(packageRoot, folder);
     const installed = readJson(path.join(dir, 'node_modules', '.package-lock.json'));
-    return { name, folder, packages: packagesInLock(installed), dependencies: directDependencies(dir, { readJson }) };
+    const packages = installed ? packagesInLock(installed) : installedFromLock(shrinkwrap, packageRoot, { exists });
+    return { name, folder, packages, dependencies: directDependencies(dir, { readJson, stopAt: packageRoot }) };
   });
   const mcpBuilt = exists(path.join(packageRoot, 'mcp-server', 'dist', 'index.js'));