@openagents-org/agent-launcher 0.2.181 → 0.2.183

package/src/adapters/pi.js

@@ -34,7 +34,11 @@ const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { execFileSync, execSync, spawn } = require('child_process');
+const { execFileSync, execSync } = require('child_process');
+// spawn() here is the WSL bridge from ../wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
@@ -1391,6 +1395,7 @@ class PiAdapter extends BaseAdapter {
       endpoint: this.endpoint,
       token: this.token,
       mode: this._mode,
+      model: this.modelLabel(),
       disabledModules: this.disabledModules,
       browserEnabled,
     });

package/src/adapters/workspace-prompt.js

@@ -121,7 +121,7 @@ function workspaceSkillName(agentName) {
  * - `'skills'` → points at the agent's workspace skill (Bash + curl),
  *   since no MCP server is spawned and that tool would not exist.
  */
-function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'execute', toolMode = 'mcp') {
+function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'execute', toolMode = 'mcp', model = null) {
   const priorContext = toolMode === 'skills'
     ? (
       `When you need prior context, use the ${workspaceSkillName(agentName)} skill to ` +
@@ -135,6 +135,15 @@ function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'exe
       'channel argument the tool falls back to a default channel that may ' +
       'be different from where you are.\n'
     );
+  // The model is the one fact about itself an agent cannot look up. Asked
+  // "what model are you?", a CLI-driven agent answers from whatever its
+  // weights remember about their own training — which is how an agent
+  // configured with deepseek came to tell a user it was Claude. The launcher
+  // knows the answer exactly (it is what was passed to the CLI), so state it
+  // rather than leaving the agent to guess.
+  const modelLine = String(model || '').trim()
+    ? `- Model: ${String(model).trim()}  (this is the model you are running on — do not guess otherwise)\n`
+    : '';
   return (
     `You are agent '${agentName}' connected to an OpenAgents workspace.\n` +
     'Your text responses are automatically posted to the workspace chat ' +
@@ -142,7 +151,9 @@ function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'exe
     '## Workspace Context\n' +
     `- Workspace ID: ${workspaceId}\n` +
     `- Channel: ${channelName}  (this is the channel you are currently speaking in)\n` +
-    `- Mode: ${mode}\n\n` +
+    `- Mode: ${mode}\n` +
+    modelLine +
+    '\n' +
     priorContext
   );
 }
@@ -931,10 +942,10 @@ function buildPinnedSections({ toolMode = 'mcp', channelName, mode = 'execute',
  * writeAccess? }. Both default to off — other adapters that reuse this
  * builder (e.g. Gemini) are unaffected unless they pass them.
  */
-function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = 'execute', browserEnabled = false, toolMode = 'mcp', decisionLog = null, glossary = null }) {
+function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = 'execute', browserEnabled = false, toolMode = 'mcp', decisionLog = null, glossary = null, model = null }) {
   const skillName = workspaceSkillName(agentName);
   const parts = [];
-  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, toolMode));
+  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, toolMode, model));
   parts.push(toolMode === 'skills' ? buildClaudeSkillsToolBlock(skillName) : buildClaudeMcpToolBlock());
   parts.push(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt(toolMode, skillName));
@@ -960,9 +971,9 @@ function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = '
  * buildClaudeSystemPrompt (with skills-mode tool phrasing, since these
  * agents reach the knowledge API through curl commands).
  */
-function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, decisionLog = null, glossary = null }) {
+function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, decisionLog = null, glossary = null, model = null }) {
   const parts = [];
-  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills'));
+  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills', model));
   parts.push(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt('skills', workspaceSkillName(agentName)));
   parts.push(buildModePrompt(mode));
@@ -1009,8 +1020,8 @@ function buildOpenclawSkillMd({ endpoint, workspaceId, token, agentName, channel
  * `decisionLog` / `glossary` opt in to knowledge pinning exactly as in
  * buildOpenclawSystemPrompt.
  */
-function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, decisionLog = null, glossary = null, isWindows = process.platform === 'win32' }) {
-  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills');
+function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, decisionLog = null, glossary = null, isWindows = process.platform === 'win32', model = null }) {
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills', model);
   const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt('skills', workspaceSkillName(agentName));
   const modePrompt = buildModePrompt(mode) + buildWindowsShellHint(isWindows);
@@ -1031,8 +1042,8 @@ function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoi
  * NOTE: this is APPENDED, never passed via `--system-prompt` — that flag would
  * REPLACE Pi's own coding-assistant prompt and strip its tool instructions.
  */
-function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false }) {
-  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills');
+function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, model = null }) {
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills', model);
   const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt('skills', workspaceSkillName(agentName));
   const modePrompt = buildModePrompt(mode);
@@ -1060,8 +1071,8 @@ function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, to
  *     conversation, so it is sent once and still in context on every later turn
  *     — which is why it must read as a briefing, not as a system directive.
  */
-function buildOpenWorkerSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false }) {
-  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills');
+function buildOpenWorkerSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, model = null }) {
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills', model);
   const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt('skills', workspaceSkillName(agentName));
   const modePrompt = buildModePrompt(mode);

package/src/daemon.js

@@ -2,7 +2,11 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawn, execSync, execFileSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
+// spawn() here is the WSL bridge from ./wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('./wsl');
 const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');

package/src/installer.js

@@ -5,6 +5,7 @@ const os = require('os');
 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 { EnvManager } = require('./env');
 const { nodeDistUrls, installRegistry } = require('./mirrors');
 const { readinessReason, REASON } = require('./adapters/health-status');
@@ -173,6 +174,13 @@ class Installer {
       return { installed: false, managed: false, location: null };
     }
 
+    // Installed inside a WSL distro. Never 'managed': the launcher did not put
+    // it there and cannot uninstall it, and the isolated-runtime bookkeeping
+    // below is all about Windows paths that an in-distro binary can never match.
+    if (isWslBinary(binaryPath)) {
+      return { installed: true, managed: false, location: 'wsl' };
+    }
+
     // Verify it's not a stale shim pointing to a missing package
     const openagentsDir = path.join(os.homedir(), '.openagents');
     if (binaryPath.startsWith(openagentsDir)) {
@@ -580,6 +588,11 @@ class Installer {
    * shebang), so it's applied on every platform for consistency.
    */
   _versionProbeCommand(binary) {
+    // A binary inside WSL has to be asked through wsl.exe; running the Linux
+    // path as a Windows command yields "not recognized" and the marketplace
+    // then shows an installed agent with no version at all.
+    const bridged = bridgedCommandString(binary, ['--version']);
+    if (bridged) return bridged;
     if (/\.(mjs|cjs|js)$/i.test(binary)) {
       return `"${this._nodeBinary()}" "${binary}" --version`;
     }
@@ -744,14 +757,14 @@ class Installer {
     // authoritative; the legacy parser treats an empty {} as ready.
     const credsReady = checkReady.creds_json_has_entries
       ? false
-      : this._checkCredsReady(checkReady);
+      : this._checkCredsReady(checkReady, agentType);
     // Content-free credential probes (opt-in via check_ready). Detect agents
     // whose sign-in is a local OAuth/credential FILE (e.g. Gemini's
     // ~/.gemini/oauth_creds.json) or a service-account file path, WITHOUT
     // parsing or logging the token. Additive: agents that don't declare
     // creds_no_parse / creds_path_env get identical behavior to before.
-    const credsFile = this._evaluateCredsFile(checkReady);
-    const credsPathReady = this._checkCredsPathEnv(checkReady, savedEnv);
+    const credsFile = this._evaluateCredsFile(checkReady, agentType);
+    const credsPathReady = this._checkCredsPathEnv(checkReady, savedEnv, agentType);
 
     let cliReady = false;
     if (checkReady.status_command && binary) {
@@ -839,10 +852,10 @@ class Installer {
     return keys.some((key) => !!(source && source[key]));
   }
 
-  _checkCredsReady(checkReady) {
+  _checkCredsReady(checkReady, agentType) {
     if (checkReady.creds_file) {
       try {
-        const credsPath = checkReady.creds_file.replace('~', os.homedir());
+        const credsPath = this._expandHome(checkReady.creds_file, agentType);
         if (fs.existsSync(credsPath)) {
           const stat = fs.statSync(credsPath);
           if (stat.isDirectory()) return fs.readdirSync(credsPath).length > 0;
@@ -862,14 +875,38 @@ class Installer {
     return false;
   }
 
-  /** Expand a leading "~" to the running user's home directory. */
-  _expandHome(p) {
+  /**
+   * Expand a leading "~" to the home directory the AGENT writes its sign-in to.
+   *
+   * Normally the running user's. For an agent that resolved inside WSL it is
+   * the distro's $HOME, reached over the \\wsl.localhost mount — `claude login`
+   * run in the distro leaves ~/.claude there, and expanding against the Windows
+   * profile instead reports a signed-in agent as "Not logged in".
+   */
+  _expandHome(p, agentType) {
     if (typeof p !== 'string' || !p) return p;
-    if (p === '~') return os.homedir();
-    if (p.startsWith('~/') || p.startsWith('~\\')) return path.join(os.homedir(), p.slice(2));
+    const home = this._homeForAgent(agentType);
+    if (p === '~') return home;
+    if (p.startsWith('~/') || p.startsWith('~\\')) return path.join(home, p.slice(2));
     return p;
   }
 
+  /**
+   * Where this agent's dotfiles live, as a path this process can read. Falls
+   * back to the running user's home for every native install — and for a WSL
+   * one whose distro home could not be resolved, which is no worse than the
+   * behaviour before the WSL tier existed.
+   */
+  _homeForAgent(agentType) {
+    if (!agentType) return os.homedir();
+    try {
+      if (isWslBinary(this._whichBinary(agentType))) {
+        return wslHomeUnc() || os.homedir();
+      }
+    } catch { /* resolution is best-effort; the host home is the safe answer */ }
+    return os.homedir();
+  }
+
   /**
    * Existence/readability of a credential file. Returns 'present' |
    * 'unreadable' | 'absent'. A non-empty readable file (or a non-empty
@@ -881,9 +918,9 @@ class Installer {
    * against the running user's home (the daemon/launcher user), not the
    * renderer/browser user.
    */
-  _credsFileState(checkReady) {
+  _credsFileState(checkReady, agentType) {
     if (!checkReady || !checkReady.creds_file) return 'absent';
-    const p = this._expandHome(checkReady.creds_file);
+    const p = this._expandHome(checkReady.creds_file, agentType);
     let exists = false;
     try { exists = fs.existsSync(p); } catch { return 'unreadable'; }
     if (!exists) return 'absent';
@@ -922,11 +959,11 @@ class Installer {
    * parse + match `creds_key` via _checkCredsReady) keep their exact behavior.
    * Returns { ready, unreadable }.
    */
-  _evaluateCredsFile(checkReady) {
+  _evaluateCredsFile(checkReady, agentType) {
     if (!checkReady || !checkReady.creds_file || !checkReady.creds_no_parse) {
       return { ready: false, unreadable: false };
     }
-    const state = this._credsFileState(checkReady);
+    const state = this._credsFileState(checkReady, agentType);
     return { ready: state === 'present', unreadable: state === 'unreadable' };
   }
 
@@ -936,14 +973,14 @@ class Installer {
    * exists and is a readable file — a non-empty value alone is NOT enough.
    * Checks both the process env and the agent's saved env.
    */
-  _checkCredsPathEnv(checkReady, savedEnv) {
+  _checkCredsPathEnv(checkReady, savedEnv, agentType) {
     const names = checkReady && checkReady.creds_path_env;
     if (!Array.isArray(names) || !names.length) return false;
     for (const name of names) {
       const raw = ((process.env[name] || (savedEnv && savedEnv[name]) || '') + '').trim();
       if (!raw) continue;
       try {
-        const p = this._expandHome(raw);
+        const p = this._expandHome(raw, agentType);
         if (!fs.existsSync(p)) continue;
         fs.accessSync(p, fs.constants.R_OK);
         if (fs.statSync(p).isFile()) return true;
@@ -1568,8 +1605,12 @@ class Installer {
     const managed = this._resolveManagedBinary(agentType, entry, binary, aliases);
     if (managed) return managed;
 
+    // allowWsl:false — whichBinary would otherwise end its own search inside
+    // the distro, and this method still has two NATIVE tiers to run below. A
+    // Windows copy must win over a WSL one; resolveBinaryInKnownDirs() reaches
+    // the distro at the very end, once everything on this side has missed.
     for (const candidate of [binary, ...aliases]) {
-      const found = whichBinary(candidate);
+      const found = whichBinary(candidate, { allowWsl: false });
       if (found) return found;
     }
     // Fallback: resolve the installed package's OWN bin from its package.json

package/src/paths.js

@@ -12,6 +12,12 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const { execSync, execFileSync } = require('child_process');
+const {
+  isRunningInWsl,
+  resolveWslBinary,
+  clearWslBinaryCache,
+  wslBinDirs,
+} = require('./wsl');
 
 const IS_WINDOWS = process.platform === 'win32';
 const IS_MACOS = process.platform === 'darwin';
@@ -183,24 +189,84 @@ function getEnhancedEnv(baseEnv) {
 
 /**
  * Find a binary by name. Returns full path or null.
+ *
+ * On Windows the search ends INSIDE WSL when nothing native turned up: an agent
+ * CLI the user installed in their distro is a real, usable install, and the
+ * Linux path that comes back is what adapters hand to the wsl.js spawn bridge.
+ * It is deliberately the last thing tried — a native copy always wins — and
+ * `allowWsl: false` opts out for callers (installer.js) that have further
+ * native tiers of their own to run first.
+ *
+ * @param {string} name
+ * @param {{allowWsl?: boolean}} [opts]
  */
-function whichBinary(name) {
+function whichBinary(name, { allowWsl = true } = {}) {
   if (!name) return null;
   const currentPATH = process.env.PATH || '';
-  const cacheKey = `${name}\0${currentPATH}`;
+  const cacheKey = `${name}\0${currentPATH}\0${allowWsl ? 'wsl' : 'native'}`;
   const cached = whichBinaryCache.get(cacheKey);
   if (cached && Date.now() - cached.at < PATH_LOOKUP_CACHE_TTL_MS) {
     return cached.value;
   }
 
-  // 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 one that's 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).
+  let value = _whichNative(name);
+  if (!value && allowWsl) value = resolveWslBinary(name);
+  whichBinaryCache.set(cacheKey, { value, at: Date.now() });
+  return value;
+}
+
+/** The PATH lookup proper — `where`/`which`, this side of any boundary. */
+function _whichNative(name) {
+  let hits = _runWhich(name);
+
+  if (isRunningInWsl()) {
+    // Interop puts the Windows PATH on the distro's PATH, so `which claude`
+    // happily answers /mnt/c/Users/…/AppData/Roaming/npm/claude — npm's
+    // extensionless POSIX shim, a sh script that execs node.exe with Windows
+    // paths. Linux cannot run it, and returning it turns "not installed" into
+    // the more confusing "installed but every run fails". Only a real PE image
+    // crosses back this way, which interop does exec with argv intact.
+    hits = hits.filter((h) => !_isWindowsMount(h) || /\.exe$/i.test(h));
+    // `which cursor-agent` can't see cursor-agent.exe — the name on disk
+    // carries the suffix — so ask for it explicitly before giving up.
+    if (!hits.length && !/\.exe$/i.test(name)) hits = _runWhich(`${name}.exe`);
+  }
+
+  let value = hits[0] || null;
+  if (IS_WINDOWS && hits.length) {
+    // `where` can list npm's extensionless POSIX shim (node_modules/.bin/
+    // claude, a sh script) ahead of claude.cmd. Windows cannot execute that
+    // file — spawning it fails and the probe misreports an installed CLI as
+    // "not installed" while the chat adapters (which prefer .cmd) work fine.
+    // Prefer a hit Windows can run; failing that, a runnable sibling of the
+    // shim; only then fall back to the raw first hit.
+    const RUNNABLE = /\.(cmd|exe|bat|com)$/i;
+    const runnable = hits.find((h) => RUNNABLE.test(h));
+    if (runnable) {
+      value = runnable;
+    } else {
+      for (const h of hits) {
+        const sibling = ['.cmd', '.exe', '.bat'].map((e) => h + e).find((c) => fs.existsSync(c));
+        if (sibling) { value = sibling; break; }
+      }
+    }
+  }
+  return value;
+}
+
+/**
+ * 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).
+ */
+function _runWhich(name) {
   const cmd = IS_WINDOWS ? `where ${name}` : `which ${name}`;
   try {
     const result = execSync(cmd, {
@@ -221,33 +287,21 @@ function whichBinary(name) {
       const hit = line.trim();
       if (hit && fs.existsSync(hit)) hits.push(hit);
     }
-    let value = hits[0] || null;
-    if (IS_WINDOWS && hits.length) {
-      // `where` can list npm's extensionless POSIX shim (node_modules/.bin/
-      // claude, a sh script) ahead of claude.cmd. Windows cannot execute that
-      // file — spawning it fails and the probe misreports an installed CLI as
-      // "not installed" while the chat adapters (which prefer .cmd) work fine.
-      // Prefer a hit Windows can run; failing that, a runnable sibling of the
-      // shim; only then fall back to the raw first hit.
-      const RUNNABLE = /\.(cmd|exe|bat|com)$/i;
-      const runnable = hits.find((h) => RUNNABLE.test(h));
-      if (runnable) {
-        value = runnable;
-      } else {
-        for (const h of hits) {
-          const sibling = ['.cmd', '.exe', '.bat'].map((e) => h + e).find((c) => fs.existsSync(c));
-          if (sibling) { value = sibling; break; }
-        }
-      }
-    }
-    whichBinaryCache.set(cacheKey, { value, at: Date.now() });
-    return value;
+    return hits;
   } catch {
-    whichBinaryCache.set(cacheKey, { value: null, at: Date.now() });
-    return null;
+    return [];
   }
 }
 
+/**
+ * A path on a Windows drive as mounted inside a distro (/mnt/c/…). /mnt is
+ * WSL's default automount root and the only one interop puts on PATH itself;
+ * a distro that moved it in /etc/wsl.conf simply gets the old behaviour.
+ */
+function _isWindowsMount(p) {
+  return /^\/mnt\/[a-z]\//i.test(String(p || ''));
+}
+
 /**
  * Codepage-safe `where`/`which` lookup, shared by every CLI adapter.
  *
@@ -916,6 +970,7 @@ function clearBinaryLookupCache() {
   knownBinDirsCache = { value: null, at: 0 };
   extraBinDirsCache = { value: null, at: 0, path: '' };
   whichBinaryCache.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
   // about any install, and this is called after every install/uninstall.
@@ -933,6 +988,11 @@ function primeBinaryLookup() {
   try { loginShellDirs(); } catch {}
   try { _npmPrefix(); } catch {}
   try { getKnownBinDirs(); } catch {}
+  // The WSL side has the same shape of cost — one `wsl.exe -e bash -ilc` to
+  // learn the distro's login PATH — and it is paid by the first lookup that
+  // misses natively, which is the marketplace enumerating agents nobody has
+  // installed. Warm it here instead.
+  try { wslBinDirs(); } catch {}
 }
 
 /**
@@ -1035,7 +1095,11 @@ function resolveBinaryInKnownDirs(names, agentType) {
       }
     }
   }
-  return null;
+
+  // Nothing native anywhere: the last place left to look is inside WSL, whose
+  // filesystem none of the dirs above can reach. Last by construction — a
+  // Windows copy of the CLI is always preferred to an in-distro one.
+  return resolveWslBinary(list);
 }
 
 

package/src/probe.js

@@ -26,7 +26,10 @@
  */
 
 const os = require('os');
-const { spawn } = require('child_process');
+// spawn() here is the WSL bridge from ./wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('./wsl');
 const { getEnhancedEnv } = require('./paths');
 const { shouldUseShellForBinary } = require('./adapters/health-status');
 const { formatAuthGuidance } = require('./auth-guidance');