@openagents-org/agent-launcher 0.2.183 → 0.2.184

package/src/adapters/opencode.js

@@ -114,12 +114,54 @@ class OpenCodeAdapter extends BaseAdapter {
 
     this._opencodeBinary = this._findOpencodeBinary();
     if (this._opencodeBinary) {
-      this._log(`Using OpenCode subprocess mode: ${this._opencodeBinary}`);
+      this._log(`Using ${this._cliLabel()} subprocess mode: ${this._opencodeBinary}`);
     } else {
-      this._log(`OpenCode binary not found. Install with: npm install -g opencode-ai@${OPENCODE_PINNED_VERSION}`);
+      this._log(`${this._cliLabel()} binary not found. ${this._installHint()}`);
     }
   }
 
+  // ------------------------------------------------------------------
+  // What differs between OpenCode and the CLIs built on it
+  // ------------------------------------------------------------------
+  //
+  // Vendors ship their own agents on top of OpenCode (Huawei's CodeArts Agent
+  // is one — see codearts.js). They keep its `run --format json` stream, its
+  // sessions and its failure shapes, and change how the CLI is found, launched
+  // and authenticated. These hooks are exactly that difference.
+
+  /** Product name used in logs and user-facing errors. */
+  _cliLabel() {
+    return 'OpenCode';
+  }
+
+  _installHint() {
+    return `Install with: npm install -g opencode-ai@${OPENCODE_PINNED_VERSION}`;
+  }
+
+  /** User-facing message per failure category. */
+  _failureMessages() {
+    return FAILURE_MESSAGES;
+  }
+
+  /** Whether a run may not start without a model (OpenCode hangs without one). */
+  _modelRequired() {
+    return true;
+  }
+
+  /** Arguments after the binary for one `run`. */
+  _buildRunArgs({ runCwd, model, sessionId }) {
+    // Preflight guarantees a resolvable model; pin it explicitly — without it
+    // opencode hangs waiting for interactive provider/model selection.
+    const args = ['run', '--format', 'json', '--dir', runCwd, '--model', model];
+    if (sessionId) args.push('--session', sessionId);
+    return args;
+  }
+
+  /** Environment the CLI is spawned with. */
+  _spawnEnv() {
+    return { ...(this.agentEnv || process.env) };
+  }
+
   /**
    * Migrate sessions file from old location to agent home.
    */
@@ -793,30 +835,25 @@ class OpenCodeAdapter extends BaseAdapter {
     try { this._ensureCustomProviderConfig(runCwd); } catch (e) {
       this._log(`Gateway provider config failed (continuing): ${e.message}`);
     }
-    const cmd = [binary, 'run', '--format', 'json', '--dir', runCwd];
-
-    // Preflight guarantees a resolvable model; pin it explicitly — without it
-    // opencode hangs waiting for interactive provider/model selection.
     const model = this._resolveModel();
-    cmd.push('--model', model);
-
     const sessionId = this._channelSessions[msgChannel];
+    const args = this._buildRunArgs({ runCwd, model, sessionId });
+
     let fullPrompt;
     if (sessionId) {
       fullPrompt = content;
-      cmd.push('--session', sessionId);
     } else {
       this._ensureWorkspaceSkill(msgChannel);
       const context = this._buildSystemContext(msgChannel);
       fullPrompt = `${context}\n\n---\n\n${content}`;
     }
 
-    this._log(`CLI: ${binary} run --format json --dir ${runCwd} --model ${model || '(none)'}`);
+    this._log(`CLI: ${binary} ${args.join(' ')}`);
 
-    const spawnEnv = { ...(this.agentEnv || process.env) };
+    const spawnEnv = this._spawnEnv();
 
-    let spawnBinary = cmd[0];
-    let spawnArgs = cmd.slice(1);
+    let spawnBinary = binary;
+    let spawnArgs = args;
     // Only the npm `.cmd` shim needs a cmd.exe host. The native opencode.exe
     // (preferred by _findOpencodeBinary) is spawned directly — no console host.
     if (IS_WINDOWS && spawnBinary.toLowerCase().endsWith('.cmd')) {
@@ -905,7 +942,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
         if (signal) {
           this._log(`opencode killed by signal ${signal} after ${TIMEOUT_MS / 1000}s (output: ${!!stdout})`);
-          const cls = OpenCodeAdapter._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
           // A signal almost always means our own timeout fired; only override to
           // a more specific provider error if stdout/stderr clearly show one.
           const category = (cls.category === 'unknown_error' || cls.category === 'process_crashed')
@@ -914,14 +951,14 @@ class OpenCodeAdapter extends BaseAdapter {
         }
 
         if (code !== 0) {
-          const cls = OpenCodeAdapter._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
           this._log(`opencode exited code ${code} → [${cls.category}]: ${OpenCodeAdapter._redact(cls.diagnostic).slice(0, 300)}`);
           return finish(reject, this._failure(cls.category, cls.diagnostic, cls.detail));
         }
 
         // Exit 0.
         if (stdout) this._persistSessionId(msgChannel, stdout);
-        const outcome = OpenCodeAdapter._outcomeForCleanExit({ stdout, stderr, stdoutErr, responseState });
+        const outcome = this.constructor._outcomeForCleanExit({ stdout, stderr, stdoutErr, responseState });
         if (outcome.text) return finish(resolve, outcome.text);
         const f = outcome.failure;
         this._log(`opencode exit 0 → [${f.category}]: ${OpenCodeAdapter._redact(f.diagnostic).slice(0, 300)}`);
@@ -951,7 +988,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
     if (endedOnTool) {
       if (stdoutErr) {
-        const cls = OpenCodeAdapter._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
+        const cls = this._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
         const vague = ['unknown_error', 'process_crashed', 'empty_response'].includes(cls.category);
         return {
           failure: {
@@ -977,7 +1014,7 @@ class OpenCodeAdapter extends BaseAdapter {
     // provider — it can be a structured error on stdout, an incomplete
     // stream, or a genuinely empty completion. Classify rather than guess.
     if (stdoutErr) {
-      const cls = OpenCodeAdapter._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
+      const cls = this._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
       return { failure: { category: cls.category, diagnostic: `exit 0 with error event: ${cls.diagnostic || ''}`, detail: cls.detail } };
     }
     const emptyCat = OpenCodeAdapter._emptyExitCategory(stdout);
@@ -1010,7 +1047,7 @@ class OpenCodeAdapter extends BaseAdapter {
     if (!probe.executable) {
       return { ok: false, category: 'cli_not_executable', diagnostic: 'opencode --version did not run' };
     }
-    const vclass = OpenCodeAdapter._classifyVersion(probe.version);
+    const vclass = this.constructor._classifyVersion(probe.version);
     if (vclass === 'unsupported') {
       return {
         ok: false,
@@ -1022,7 +1059,7 @@ class OpenCodeAdapter extends BaseAdapter {
     // 'unknown' (unparseable) and 'degraded' (newer than tested) still run.
 
     const model = this._resolveModel();
-    if (!model) return { ok: false, category: 'model_missing' };
+    if (!model && this._modelRequired()) return { ok: false, category: 'model_missing' };
 
     const cred = this._credentialState();
     if (cred === 'missing') return { ok: false, category: 'credential_missing' };
@@ -1140,10 +1177,12 @@ class OpenCodeAdapter extends BaseAdapter {
    * normal reply. Carries `error_category` in metadata so the UI can route it.
    */
   async _sendClassifiedError(channel, category, detail) {
-    const base = FAILURE_MESSAGES[category] || FAILURE_MESSAGES.unknown_error;
+    const messages = this._failureMessages();
+    const base = messages[category] || messages.unknown_error;
     const safe = detail ? OpenCodeAdapter._redact(detail).trim() : '';
     const body = safe ? `${base}\n\n> ${safe}` : base;
-    const headline = category === 'incomplete_run' ? 'OpenCode stopped mid-task' : "OpenCode couldn't run";
+    const label = this._cliLabel();
+    const headline = category === 'incomplete_run' ? `${label} stopped mid-task` : `${label} couldn't run`;
     const content = `⚠️ **${headline}** — ${body}`;
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, content, {

package/src/daemon.js

@@ -369,11 +369,32 @@ class Daemon {
    */
   async _setModelEnv(type, model) {
     const val = String(model || '');
-    const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type];
     await this._runAgn(['env', type, '--set', `LLM_MODEL=${val}`]);
+    const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type] || this._nativeModelVar(type);
     if (nativeVar) await this._runAgn(['env', type, '--set', `${nativeVar}=${val}`]);
   }
 
+  /**
+   * The agent's own model setting, for a type whose registry declares one and
+   * does not map LLM_MODEL onto anything itself (CodeArts reads CODEARTS_MODEL
+   * and nothing else). A type with a resolve_env rule for LLM_MODEL already
+   * gets there through env resolution, so it is left alone.
+   */
+  _nativeModelVar(type) {
+    try {
+      const entry = this.registry.getEntry(type);
+      if (!entry) return null;
+      const rules = (entry.resolve_env && entry.resolve_env.rules) || [];
+      if (rules.some((r) => r && r.from === 'LLM_MODEL')) return null;
+      const field = (entry.env_config || []).find(
+        (f) => f && /_MODEL$/.test(f.name || '') && f.name !== 'LLM_MODEL',
+      );
+      return field ? field.name : null;
+    } catch {
+      return null;
+    }
+  }
+
   async _refreshRuntimes() {
     try {
       const r = await this._runAgn(['runtimes', '--json']);

package/src/installer.js

@@ -6,6 +6,7 @@ const path = require('path');
 const { execSync, exec } = require('child_process');
 const { whichBinary, getEnhancedEnv, getRuntimePrefix, clearBinaryLookupCache, aiderBinDirs, resolveBinaryInKnownDirs } = require('./paths');
 const { isWslBinary, bridgedCommandString, wslHomeUnc } = require('./wsl');
+const { canBlock } = require('./probe-mode');
 const { EnvManager } = require('./env');
 const { nodeDistUrls, installRegistry } = require('./mirrors');
 const { readinessReason, REASON } = require('./adapters/health-status');
@@ -39,6 +40,19 @@ const STALL_POLL_MS = Math.max(50, Math.min(15000, Math.floor(INSTALL_STALL_MS /
 // results are cached briefly and invalidated on install/uninstall.
 const VERSION_CACHE_TTL_MS = 60000;
 const versionCache = new Map();
+/** Version probes running in the background, by cache key. See probe-mode.js. */
+const versionRefresh = new Set();
+
+/** The version token in a `--version` output, or its first line. */
+function parseVersionOutput(raw) {
+  // The optional `-prerelease` tail is NOT decoration. An agent pinned to a
+  // preview release (`@deepseek-ai/dsh@0.1.0-rc.6`) is gated on the exact
+  // version, and dropping the suffix reported a correctly installed rc.6 as
+  // plain `0.1.0` — which then failed its own gate. Agents without a
+  // prerelease segment match exactly as before.
+  const match = raw.match(/(\d+[\d.]+\d+(?:-[0-9A-Za-z.-]+)?)/);
+  return match ? match[1] : (raw.split('\n')[0] || null);
+}
 
 /**
  * Compare two dotted version strings numerically, ignoring any pre-release /
@@ -616,15 +630,8 @@ class Installer {
     ]) {
       if (fs.existsSync(candidate)) return candidate;
     }
-    try {
-      const found = execSync(isWin ? 'where node.exe' : 'which node', {
-        encoding: 'utf-8',
-        timeout: 5000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: getEnhancedEnv(),
-      }).split(/\r?\n/)[0].trim();
-      if (found) return found;
-    } catch {}
+    const found = whichBinary(nodeName, { allowWsl: false });
+    if (found) return found;
     return 'node';
   }
 
@@ -636,6 +643,14 @@ class Installer {
     const cached = versionCache.get(key);
     if (cached && (Date.now() - cached.ts) < VERSION_CACHE_TTL_MS) return cached.version;
 
+    if (!canBlock()) {
+      // A node CLI's `--version` takes 0.5s+ (seconds for one inside WSL).
+      // Report the last known version — or unknown, which healthCheck already
+      // handles — and let the next check pick up the answer.
+      this._refreshVersion(key, versionCmd);
+      return cached ? cached.version : null;
+    }
+
     let version = null;
     try {
       const raw = execSync(versionCmd, {
@@ -644,19 +659,36 @@ class Installer {
         env: getEnhancedEnv(),
         timeout: 10000,
       }).trim();
-      // The optional `-prerelease` tail is NOT decoration. An agent pinned to a
-      // preview release (`@deepseek-ai/dsh@0.1.0-rc.6`) is gated on the exact
-      // version, and dropping the suffix reported a correctly installed rc.6 as
-      // plain `0.1.0` — which then failed its own gate. Agents without a
-      // prerelease segment match exactly as before.
-      const match = raw.match(/(\d+[\d.]+\d+(?:-[0-9A-Za-z.-]+)?)/);
-      version = match ? match[1] : (raw.split('\n')[0] || null);
+      version = parseVersionOutput(raw);
     } catch {}
 
     versionCache.set(key, { version, ts: Date.now() });
     return version;
   }
 
+  /** _detectVersion's probe, off the calling thread. */
+  _refreshVersion(key, versionCmd) {
+    if (versionRefresh.has(key)) return;
+    versionRefresh.add(key);
+    try {
+      const child = exec(versionCmd, {
+        encoding: 'utf-8',
+        env: getEnhancedEnv(),
+        timeout: 10000,
+        windowsHide: true,
+      }, (err, stdout) => {
+        versionRefresh.delete(key);
+        versionCache.set(key, {
+          version: err ? null : parseVersionOutput(String(stdout).trim()),
+          ts: Date.now(),
+        });
+      });
+      if (child.stdin) child.stdin.end();
+    } catch {
+      versionRefresh.delete(key);
+    }
+  }
+
   /**
    * Evaluate a registry version gate against a detected version. Generic for any
    * agent. Returns { compatible: true|false|null, minVersion, message }.

package/src/paths.js

@@ -11,13 +11,14 @@
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-const { execSync, execFileSync } = require('child_process');
+const { exec, execSync, execFile, execFileSync } = require('child_process');
 const {
   isRunningInWsl,
   resolveWslBinary,
   clearWslBinaryCache,
   wslBinDirs,
 } = require('./wsl');
+const { canBlock } = require('./probe-mode');
 
 const IS_WINDOWS = process.platform === 'win32';
 const IS_MACOS = process.platform === 'darwin';
@@ -254,43 +255,107 @@ function _whichNative(name) {
   return value;
 }
 
+/** The value of an env var, matching the key case-insensitively on Windows. */
+function _envValue(env, name) {
+  if (!IS_WINDOWS) return env[name];
+  const key = Object.keys(env).find((k) => k.toUpperCase() === name);
+  return key ? env[key] : undefined;
+}
+
 /**
- * Existing paths `where`/`which` reports for a name, in its own order.
- *
- * On a non-English Windows the console OUTPUT codepage is OEM (e.g. 936/GBK on
- * zh-CN), so `where` prints a path whose non-ASCII bytes don't match the utf-8
- * decoding execSync does — a Chinese username comes back mangled (e.g.
- * `C:\Users\??.?[\…`) and yields ENOENT downstream. We can't reliably re-encode
- * it (and forcing `chcp` is unsafe under windowsHide's console-less cmd), so we
- * existence-check every hit and only return ones that are real; a mangled path
- * fails and the caller falls through to its Node-derived tiers (built from
- * process.env / os.homedir, which the OS hands us as correct UTF-16).
+ * Directory listings for _searchPath, keyed by dir. One sweep over every agent
+ * type asks for ~20 names × every PATHEXT spelling × every PATH dir — thousands
+ * of stats — where reading each dir once answers all of them.
  */
-function _runWhich(name) {
-  const cmd = IS_WINDOWS ? `where ${name}` : `which ${name}`;
+const DIR_INDEX_TTL_MS = 5000;
+const dirIndexCache = new Map();
+
+/** name (lower-cased on Windows) → name on disk; null when unlistable. */
+function _dirIndex(dir) {
+  const hit = dirIndexCache.get(dir);
+  if (hit && Date.now() - hit.at < DIR_INDEX_TTL_MS) return hit.names;
+  let names = new Map();
   try {
-    const result = execSync(cmd, {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      // getEnhancedEnv(), never `{...process.env, PATH}`: spreading process.env
-      // on Windows yields a "Path" key, so assigning PATH creates a SECOND path
-      // variable and which of the two the child reads is undefined. It also
-      // supplies ComSpec, without which execSync's shell cannot even start in an
-      // Electron process that has no cmd.exe on PATH — and a `where` that never
-      // ran looks exactly like a CLI that isn't installed.
-      env: getEnhancedEnv(),
-      timeout: 5000,
-      windowsHide: true,
-    });
-    const hits = [];
-    for (const line of result.split(/\r?\n/)) {
-      const hit = line.trim();
-      if (hit && fs.existsSync(hit)) hits.push(hit);
-    }
-    return hits;
+    for (const n of fs.readdirSync(dir)) names.set(IS_WINDOWS ? n.toLowerCase() : n, n);
+  } catch (e) {
+    // A dir that isn't there holds nothing. One we may not list can still hold
+    // files we may run (an execute-only dir), so that one is stat'ed instead.
+    if (e && e.code !== 'ENOENT' && e.code !== 'ENOTDIR') names = null;
+  }
+  dirIndexCache.set(dir, { names, at: Date.now() });
+  return names;
+}
+
+/** Whether `p` is a file `where`/`which` would report. */
+function _isCommandFile(p) {
+  try {
+    if (!fs.statSync(p).isFile()) return false;
   } catch {
-    return [];
+    // App Execution Aliases (…\WindowsApps\*.exe) are reparse points stat
+    // cannot follow, yet Windows runs them and `where` lists them.
+    if (!IS_WINDOWS) return false;
+    try { fs.lstatSync(p); return true; } catch { return false; }
+  }
+  if (IS_WINDOWS) return true;
+  try { fs.accessSync(p, fs.constants.X_OK); return true; } catch { return false; }
+}
+
+/**
+ * What `where name` (Windows: every match, PATH order, PATHEXT applied to a
+ * bare name) or `which name` (Unix: the first executable) would report.
+ *
+ * Walked in-process rather than by spawning either command. Detection asks
+ * this for every agent type every time a lookup cache expires, and each spawn
+ * is a cmd.exe start — ~60-300ms apiece on Windows, far more under an
+ * antivirus scan — which in the desktop app froze the window for seconds on
+ * every refresh. It also removes the codepage hazard the spawn had: `where`
+ * printed paths in the OEM codepage (936 on zh-CN), mangling any non-ASCII
+ * user name, whereas these paths never leave UTF-16.
+ */
+function _searchPath(name, env) {
+  const hits = [];
+  if (!name) return hits;
+  const source = env || process.env;
+  let names = [name];
+  if (IS_WINDOWS) {
+    const exts = String(_envValue(source, 'PATHEXT') || '.COM;.EXE;.BAT;.CMD')
+      .split(';')
+      .map((e) => e.trim().toLowerCase())
+      .filter((e) => e.startsWith('.'));
+    const ext = path.extname(name).toLowerCase();
+    if (!ext || !exts.includes(ext)) names = [name, ...exts.map((e) => name + e)];
+  }
+  const seen = new Set();
+  for (const raw of String(_envValue(source, 'PATH') || '').split(SEP)) {
+    const dir = raw.trim().replace(/^"(.*)"$/, '$1');
+    if (!dir) continue;
+    const index = _dirIndex(dir);
+    for (const n of names) {
+      let full;
+      if (index) {
+        const onDisk = index.get(IS_WINDOWS ? n.toLowerCase() : n);
+        if (!onDisk) continue;
+        full = path.join(dir, onDisk);
+      } else {
+        full = path.join(dir, n);
+      }
+      const key = IS_WINDOWS ? full.toLowerCase() : full;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (!_isCommandFile(full)) continue;
+      hits.push(full);
+      if (!IS_WINDOWS) return hits;
+    }
   }
+  return hits;
+}
+
+/** Existing paths `where`/`which` reports for a name, in its own order. */
+function _runWhich(name) {
+  // getEnhancedEnv(), never `{...process.env, PATH}`: spreading process.env on
+  // Windows yields a "Path" key, and a second PATH key makes which one counts
+  // undefined.
+  return _searchPath(name, getEnhancedEnv());
 }
 
 /**
@@ -303,18 +368,12 @@ function _isWindowsMount(p) {
 }
 
 /**
- * Codepage-safe `where`/`which` lookup, shared by every CLI adapter.
+ * `where`/`which` lookup, shared by every CLI adapter.
  *
- * Hazard: on a non-English Windows the console output codepage is OEM (e.g.
- * 936/GBK on zh-CN), so execSync decodes `where` stdout with the wrong codepage
- * and mangles a non-ASCII (e.g. Chinese) username in the path — yielding ENOENT
- * downstream (the `C:\Users\??.?[\…\claude.cmd` failure). Two safe defenses,
- * no `chcp` (which is unreliable under windowsHide's console-less cmd):
- *   1. (Windows) check the npm-global default `%APPDATA%\npm\<name>.cmd` FIRST.
- *      APPDATA comes from the OS as UTF-16 via Node, so this path is always
- *      correctly encoded — and it's where the npm-installed CLIs actually live.
- *   2. Fall back to `where`/`which`, but existence-check every hit so a mangled
- *      path is skipped and the caller drops to its own Node-derived tiers.
+ *   1. (Windows) the npm-global default `%APPDATA%\npm\<name>.cmd` FIRST —
+ *      it's where the npm-installed CLIs actually live.
+ *   2. Then PATH, as `where <name>.cmd || where <name>.exe || where <name>`
+ *      (Unix: `which <name>`) would search it — see _searchPath.
  *
  * @param {string|string[]} names  base name(s), e.g. 'claude' or ['cursor-agent','agent'].
  *                                  On Windows each is tried as <name>.cmd, <name>.exe, <name>.
@@ -333,33 +392,27 @@ function whereBinary(names, env) {
     }
   }
 
-  // 2. PATH lookup, existence-guarded.
-  let cmd;
-  if (IS_WINDOWS) {
-    const parts = [];
-    for (const b of bases) {
-      parts.push(`where ${b}.cmd 2>nul`, `where ${b}.exe 2>nul`, `where ${b} 2>nul`);
+  // 2. PATH lookup.
+  const lookupEnv = env || getEnhancedEnv();
+  for (const b of bases) {
+    for (const form of IS_WINDOWS ? [`${b}.cmd`, `${b}.exe`, b] : [b]) {
+      const hit = _searchPath(form, lookupEnv)[0];
+      if (hit) return hit;
     }
-    cmd = parts.join(' || ');
-  } else {
-    cmd = bases.map((b) => `which ${b}`).join(' || ');
   }
-  try {
-    const out = execSync(cmd, {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 5000,
-      windowsHide: true,
-      env: env || getEnhancedEnv(),
-    });
-    for (const line of out.split(/\r?\n/)) {
-      const hit = line.trim();
-      if (hit && fs.existsSync(hit)) return hit;
-    }
-  } catch {}
   return null;
 }
 
+/**
+ * Drop the bin-dir snapshots and every lookup answered from them — for when a
+ * background probe has just learned of directories they did not include.
+ */
+function _invalidateBinDirCaches() {
+  knownBinDirsCache = { value: null, at: 0 };
+  extraBinDirsCache = { value: null, at: 0, path: '' };
+  whichBinaryCache.clear();
+}
+
 /**
  * Global bin directories for every JS package manager we might find an agent
  * CLI in — plus the npm prefix the user has actually configured.
@@ -451,6 +504,13 @@ function _addAgentInstallerPaths(dirs) {
   // these; the installer that decides whether it EXISTS had not.
   _push(dirs, path.join(HOME, '.codebuddy', 'bin'));
 
+  // codearts — Huawei's install.sh / install.ps1 unpack into
+  // ~/.codeartsdoer/installers and put that dir on PATH through a shell rc
+  // edit or the user `Path` registry value. The `codearts` there is a wrapper
+  // script; the CLI itself sits in its bin/, which the installer deliberately
+  // keeps off PATH.
+  _push(dirs, path.join(HOME, '.codeartsdoer', 'installers'));
+
   // claude — `claude install` (the native, non-npm build) relocates the CLI to
   // ~/.claude/local and reaches it through a shell alias, which a GUI process
   // inherits no more than it inherits an rc-file PATH edit.
@@ -602,14 +662,28 @@ function _npmPrefix() {
     }
   } catch {}
 
+  const opts = {
+    encoding: 'utf-8',
+    timeout: 8000,
+    windowsHide: true,
+    // The user's PATH first: it is their npm we are asking about.
+    env: { ...process.env, PATH: _basePATH() },
+  };
+  if (!canBlock()) {
+    // npm takes a second or more to start on Windows. Answer "no custom
+    // prefix" for now; the bin dirs are rebuilt once npm has said otherwise.
+    try {
+      const child = exec('npm config get prefix', opts, (err, stdout) => {
+        if (!err && accept(String(stdout).trim())) _invalidateBinDirCaches();
+      });
+      if (child.stdin) child.stdin.end();
+    } catch {}
+    return npmPrefixCache;
+  }
   try {
     const out = execSync('npm config get prefix', {
-      encoding: 'utf-8',
-      timeout: 8000,
-      windowsHide: true,
+      ...opts,
       stdio: ['ignore', 'pipe', 'ignore'],
-      // The user's PATH first: it is their npm we are asking about.
-      env: { ...process.env, PATH: _basePATH() },
     }).trim();
     accept(out);
   } catch {}
@@ -663,34 +737,54 @@ function loginShellDirs() {
   if (IS_WINDOWS) return loginShellDirsCache;
   if (process.env.OPENAGENTS_SKIP_SHELL_PATH === '1') return loginShellDirsCache;
   const shell = process.env.SHELL || '/bin/zsh';
+  const argv = ['-ilc', `echo ${SHELL_ENV_DELIM}; command env; echo ${SHELL_ENV_DELIM}`];
+  const opts = {
+    encoding: 'utf-8',
+    timeout: SHELL_PROBE_TIMEOUT_MS,
+    killSignal: 'SIGKILL',
+    maxBuffer: 4 * 1024 * 1024,
+  };
   try {
     if (!fs.existsSync(shell)) return loginShellDirsCache;
-    const out = execFileSync(
-      shell,
-      ['-ilc', `echo ${SHELL_ENV_DELIM}; command env; echo ${SHELL_ENV_DELIM}`],
-      {
-        encoding: 'utf-8',
-        timeout: SHELL_PROBE_TIMEOUT_MS,
-        killSignal: 'SIGKILL',
-        // stdin closed, stderr dropped: an interactive shell with no tty writes
-        // job-control warnings there and we do not want them in the output.
-        stdio: ['ignore', 'pipe', 'ignore'],
-        maxBuffer: 4 * 1024 * 1024,
-      },
-    );
-    const parts = String(out).split(SHELL_ENV_DELIM);
-    if (parts.length < 3) return loginShellDirsCache;
-    const line = parts[1].split(/\r?\n/).find((l) => l.startsWith('PATH='));
-    if (!line) return loginShellDirsCache;
-    const seen = new Set();
-    for (const d of line.slice('PATH='.length).split(SEP)) {
-      const dir = d.trim();
-      if (dir && !seen.has(dir)) { seen.add(dir); loginShellDirsCache.push(dir); }
+    if (!canBlock()) {
+      // A login shell with nvm/oh-my-zsh in its rc files takes seconds. Search
+      // the curated dirs meanwhile and add the shell's once it has answered.
+      const child = execFile(shell, argv, opts, (err, stdout) => {
+        const dirs = err ? [] : _parseLoginShellPath(stdout);
+        if (dirs.length) {
+          loginShellDirsCache = dirs;
+          _invalidateBinDirCaches();
+        }
+      });
+      if (child.stdin) child.stdin.end();
+      return loginShellDirsCache;
     }
+    const out = execFileSync(shell, argv, {
+      ...opts,
+      // stdin closed, stderr dropped: an interactive shell with no tty writes
+      // job-control warnings there and we do not want them in the output.
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    loginShellDirsCache = _parseLoginShellPath(out);
   } catch {}
   return loginShellDirsCache;
 }
 
+/** The PATH entries in a delimited `env` dump, in order and deduplicated. */
+function _parseLoginShellPath(out) {
+  const parts = String(out).split(SHELL_ENV_DELIM);
+  if (parts.length < 3) return [];
+  const line = parts[1].split(/\r?\n/).find((l) => l.startsWith('PATH='));
+  if (!line) return [];
+  const dirs = [];
+  const seen = new Set();
+  for (const d of line.slice('PATH='.length).split(SEP)) {
+    const dir = d.trim();
+    if (dir && !seen.has(dir)) { seen.add(dir); dirs.push(dir); }
+  }
+  return dirs;
+}
+
 // ---- Windows paths ----
 
 function _addWindowsPaths(dirs) {
@@ -970,6 +1064,7 @@ function clearBinaryLookupCache() {
   knownBinDirsCache = { value: null, at: 0 };
   extraBinDirsCache = { value: null, at: 0, path: '' };
   whichBinaryCache.clear();
+  dirIndexCache.clear();
   clearWslBinaryCache();
   // The login-shell / npm-prefix probes are deliberately NOT cleared: they each
   // cost a process spawn, they answer a question about the machine rather than