opencode-swarm 7.160.1 → 7.160.2

package/dist/cli/{index-nj6rmyeh.js → index-3146wmgv.js}

@@ -95,13 +95,13 @@ LANGUAGE_REGISTRY.register({
       },
       {
         name: "tsc",
-        cmd: "npx tsc --noEmit",
+        cmd: "tsc --noEmit",
         detectFile: "tsconfig.json",
         priority: 9
       },
       {
         name: "vite build",
-        cmd: "npx vite build",
+        cmd: "vite build",
         detectFile: "vite.config.ts",
         priority: 8
       }
@@ -122,7 +122,7 @@ LANGUAGE_REGISTRY.register({
         cmd: "bun test",
         priority: 10
       },
-      { name: "jest", detect: "jest.config.js", cmd: "npx jest", priority: 9 },
+      { name: "jest", detect: "jest.config.js", cmd: "jest", priority: 9 },
       {
         name: "bun:test",
         detect: "bun.lock",
@@ -132,7 +132,7 @@ LANGUAGE_REGISTRY.register({
       {
         name: "mocha",
         detect: ".mocharc.json",
-        cmd: "npx mocha",
+        cmd: "mocha",
         priority: 7
       }
     ]
@@ -154,7 +154,7 @@ LANGUAGE_REGISTRY.register({
       {
         name: "eslint",
         detect: ".eslintrc.js",
-        cmd: "npx eslint --fix .",
+        cmd: "eslint --fix .",
         priority: 9
       }
     ]
@@ -203,13 +203,13 @@ LANGUAGE_REGISTRY.register({
       },
       {
         name: "tsc",
-        cmd: "npx tsc --noEmit",
+        cmd: "tsc --noEmit",
         detectFile: "tsconfig.json",
         priority: 9
       },
       {
         name: "vite build",
-        cmd: "npx vite build",
+        cmd: "vite build",
         detectFile: "vite.config.ts",
         priority: 8
       }
@@ -230,7 +230,7 @@ LANGUAGE_REGISTRY.register({
         cmd: "bun test",
         priority: 10
       },
-      { name: "jest", detect: "jest.config.js", cmd: "npx jest", priority: 9 },
+      { name: "jest", detect: "jest.config.js", cmd: "jest", priority: 9 },
       {
         name: "bun:test",
         detect: "bun.lock",
@@ -240,7 +240,7 @@ LANGUAGE_REGISTRY.register({
       {
         name: "mocha",
         detect: ".mocharc.json",
-        cmd: "npx mocha",
+        cmd: "mocha",
         priority: 7
       }
     ]
@@ -262,7 +262,7 @@ LANGUAGE_REGISTRY.register({
       {
         name: "eslint",
         detect: ".eslintrc.js",
-        cmd: "npx eslint --fix .",
+        cmd: "eslint --fix .",
         priority: 9
       }
     ]
@@ -1231,12 +1231,138 @@ async function detectProjectLanguages(projectDir) {
 }
 
 // src/lang/default-backend.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
-// src/build/discovery.ts
+// src/build/command-resolution.ts
 import * as fs from "fs";
 import * as path from "path";
+var WINDOWS_LOCAL_SHIM_CANDIDATES = [
+  { suffix: ".cmd", requiresNode: true },
+  { suffix: ".exe", requiresNode: false },
+  { suffix: ".bat", requiresNode: true },
+  { suffix: ".ps1", requiresNode: true },
+  { suffix: "", requiresNode: true }
+];
+function tokenizeCommand(command) {
+  const out = [];
+  let buf = "";
+  let quote = null;
+  for (const ch of command.trim()) {
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        buf += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === " " || ch === "\t") {
+      if (buf.length > 0) {
+        out.push(buf);
+        buf = "";
+      }
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.length > 0)
+    out.push(buf);
+  return out;
+}
+function findCommandSuffixStart(command) {
+  let quote = null;
+  let sawTokenChar = false;
+  for (let i = 0;i < command.length; i++) {
+    const ch = command[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        sawTokenChar = true;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      sawTokenChar = true;
+      continue;
+    }
+    if ((ch === " " || ch === "\t") && sawTokenChar) {
+      return i;
+    }
+    if (ch !== " " && ch !== "\t") {
+      sawTokenChar = true;
+    }
+  }
+  return command.length;
+}
+function resolveLocalCandidate(binary, workingDir, platform = process.platform, isAvailable) {
+  const candidates = platform === "win32" ? WINDOWS_LOCAL_SHIM_CANDIDATES : [{ suffix: "", requiresNode: true }];
+  for (const candidate of candidates) {
+    const executable = `${binary}${candidate.suffix}`;
+    const absolute = path.join(workingDir, "node_modules", ".bin", executable);
+    if (!fs.existsSync(absolute))
+      continue;
+    if (candidate.requiresNode && isAvailable && !isAvailable("node"))
+      continue;
+    const relative = platform === "win32" ? path.win32.join("node_modules", ".bin", executable) : path.posix.join("node_modules", ".bin", executable);
+    return {
+      absolute,
+      relative,
+      requiresNode: candidate.requiresNode
+    };
+  }
+  return null;
+}
+function hasAnyLocalCandidate(binary, workingDir, platform = process.platform) {
+  const candidates = platform === "win32" ? WINDOWS_LOCAL_SHIM_CANDIDATES : [{ suffix: "", requiresNode: true }];
+  for (const candidate of candidates) {
+    const executable = `${binary}${candidate.suffix}`;
+    if (fs.existsSync(path.join(workingDir, "node_modules", ".bin", executable))) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveLocalCommand(command, workingDir, isAvailable, platform = process.platform) {
+  const tokens = tokenizeCommand(command);
+  if (tokens.length === 0)
+    return null;
+  const [binary, ...args] = tokens;
+  if (["npx", "bunx", "pnpx"].includes(binary))
+    return null;
+  if (binary.includes("/") || binary.includes("\\"))
+    return null;
+  const trimmed = command.trim();
+  const local = resolveLocalCandidate(binary, workingDir, platform, isAvailable);
+  if (local) {
+    const shellPath = platform === "win32" ? local.relative : `./${local.relative}`;
+    return {
+      argv: [local.absolute, ...args],
+      shellCommand: `${shellPath}${trimmed.slice(findCommandSuffixStart(trimmed))}`
+    };
+  }
+  if (hasAnyLocalCandidate(binary, workingDir, platform))
+    return null;
+  return isAvailable(binary) ? { argv: tokens, shellCommand: command } : null;
+}
+function resolveLocalNodeTool(tool, args, workingDir, platform = process.platform, isAvailable) {
+  const local = resolveLocalCandidate(tool, workingDir, platform, platform === "win32" ? isAvailable : undefined);
+  if (local)
+    return [local.absolute, ...args];
+  if (hasAnyLocalCandidate(tool, workingDir, platform))
+    return null;
+  return isAvailable?.(tool) ? [tool, ...args] : null;
+}
+
+// src/build/discovery.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
 
 // node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -1967,10 +2093,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2329,11 +2455,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -2501,7 +2627,7 @@ function treeifyError(error, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error2, path = []) => {
+  const processError = (error2, path2 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -2511,7 +2637,7 @@ function treeifyError(error, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2543,8 +2669,8 @@ function treeifyError(error, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13559,11 +13685,13 @@ function tool(input) {
 }
 tool.schema = exports_external;
 // src/build/discovery.ts
+var SUPPORTED_NODE_PACKAGE_MANAGERS = ["bun", "npm", "pnpm", "yarn"];
+var MAX_PACKAGE_MANAGER_EVIDENCE_CHARS = 120;
 var ECOSYSTEMS = [
   {
     ecosystem: "node",
     buildFiles: ["package.json"],
-    toolchainCommands: ["npm", "yarn", "pnpm"],
+    toolchainCommands: [...SUPPORTED_NODE_PACKAGE_MANAGERS],
     commands: [
       { command: "npm run build", priority: 30 },
       { command: "npm run typecheck", priority: 20 },
@@ -13657,6 +13785,7 @@ var ECOSYSTEMS = [
 ];
 var PROFILE_TO_ECOSYSTEM_NAMES = {
   typescript: ["node"],
+  javascript: ["node"],
   python: ["python"],
   rust: ["rust"],
   go: ["go"],
@@ -13694,52 +13823,120 @@ function isCommandAvailable(command) {
   }
 }
 function checkToolchain(commands) {
-  return commands.some((cmd) => isCommandAvailable(cmd));
+  return commands.some((cmd) => _internals.isCommandAvailable(cmd));
 }
 function findBuildFiles(workingDir, patterns) {
   for (const pattern of patterns) {
     if (pattern.includes("*")) {
       const dir = workingDir;
       try {
-        const files = fs.readdirSync(dir);
+        const files = fs2.readdirSync(dir);
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path.join(dir, matches[0]);
+          return path2.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path.join(workingDir, pattern);
-      if (fs.existsSync(filePath)) {
+      const filePath = path2.join(workingDir, pattern);
+      if (fs2.existsSync(filePath)) {
         return filePath;
       }
     }
   }
   return null;
 }
+function sanitizeEvidenceText(raw, maxChars) {
+  let withoutControls = "";
+  for (const char of raw) {
+    const code = char.charCodeAt(0);
+    withoutControls += code < 32 || code === 127 ? " " : char;
+  }
+  const normalized = withoutControls.replace(/\s+/g, " ").trim();
+  if (!normalized)
+    return "(empty)";
+  if (normalized.length <= maxChars)
+    return normalized;
+  if (maxChars <= 3)
+    return normalized.slice(0, maxChars);
+  return `${normalized.slice(0, maxChars - 3)}...`;
+}
+function sanitizeRequiredCommand(command) {
+  const sanitized = sanitizeEvidenceText(command, 40);
+  return sanitized === "(empty)" ? null : sanitized;
+}
+function getBinaryFromCommand(command) {
+  return command.trim().split(/\s+/)[0] ?? "";
+}
+function getProfileRequiredCommands(commands) {
+  const uniqueCommands = new Set;
+  for (const command of commands) {
+    const binary = sanitizeRequiredCommand(getBinaryFromCommand(command.cmd));
+    if (binary)
+      uniqueCommands.add(binary);
+  }
+  return Array.from(uniqueCommands);
+}
+function getNoMatchingBuildFilesReason(profileId, commands) {
+  const detectFiles = Array.from(new Set(commands.map((command) => command.detectFile?.trim()).filter((detectFile) => Boolean(detectFile))));
+  if (detectFiles.length === 0) {
+    return `No matching build files for profile ${profileId}`;
+  }
+  return `No matching build files for profile ${profileId}: expected ${detectFiles.join(" or ")}`;
+}
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path.join(workingDir, "package.json");
-  if (!fs.existsSync(packageJsonPath)) {
-    return [];
+  const packageJsonPath = path2.join(workingDir, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
+    return { commands: [], hasScripts: false };
   }
   try {
-    const content = fs.readFileSync(packageJsonPath, "utf-8");
+    const content = fs2.readFileSync(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.scripts || typeof pkg.scripts !== "object") {
-      return [];
-    }
-    const found = [];
-    for (const scriptName of scripts) {
-      if (pkg.scripts[scriptName]) {
-        found.push({
-          script: `npm run ${scriptName}`,
-          priority: 100
-        });
-      }
+      return { commands: [], hasScripts: false };
+    }
+    const scriptNames = scripts.filter((name) => typeof pkg.scripts[name] === "string" && pkg.scripts[name].trim());
+    if (scriptNames.length === 0)
+      return { commands: [], hasScripts: false };
+    const rawPackageManager = typeof pkg.packageManager === "string" ? pkg.packageManager.trim() : undefined;
+    const declared = rawPackageManager?.split("@")[0]?.trim();
+    const supported = [...SUPPORTED_NODE_PACKAGE_MANAGERS];
+    const sanitizedDeclared = declared ? sanitizeRequiredCommand(declared) : null;
+    const candidates = declared ? [declared] : supported;
+    if (rawPackageManager !== undefined && (!declared || !supported.includes(declared))) {
+      return {
+        commands: [],
+        hasScripts: true,
+        skip: {
+          ecosystem: "node",
+          code: "environment_unavailable",
+          required_commands: sanitizedDeclared ? [sanitizedDeclared] : [],
+          reason: `Unsupported packageManager: ${sanitizeEvidenceText(rawPackageManager, MAX_PACKAGE_MANAGER_EVIDENCE_CHARS)}`
+        }
+      };
+    }
+    const manager = candidates.find((candidate) => _internals.isCommandAvailable(candidate));
+    if (!manager) {
+      return {
+        commands: [],
+        hasScripts: true,
+        skip: {
+          ecosystem: "node",
+          code: "environment_unavailable",
+          required_commands: candidates,
+          reason: `Package manager not available: ${candidates.join(" or ")}`
+        }
+      };
     }
-    return found;
+    return {
+      hasScripts: true,
+      commands: scriptNames.map((scriptName) => ({
+        command: `${manager} run ${scriptName}`,
+        priority: 100
+      }))
+    };
   } catch {
-    return [];
+    return { commands: [], hasScripts: false };
   }
 }
 function filterByScope(workingDir, scope, changedFiles) {
@@ -13759,8 +13956,8 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path.join(workingDir, pattern);
-        if (fs.existsSync(filePath)) {
+        const filePath = path2.join(workingDir, pattern);
+        if (fs2.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
       }
@@ -13770,9 +13967,9 @@ function findAllBuildFiles(workingDir) {
 }
 function findFilesRecursive(dir, regex, results) {
   try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
         findFilesRecursive(fullPath, regex, results);
       } else if (entry.isFile() && regex.test(entry.name)) {
@@ -13787,32 +13984,41 @@ var _internals = {
   discoverBuildCommands,
   clearToolchainCache,
   getEcosystems,
+  detectProjectLanguagesImpl: detectProjectLanguages,
+  getLanguageProfileImpl: LANGUAGE_REGISTRY.get.bind(LANGUAGE_REGISTRY),
   spawnSyncImpl: bunSpawnSync
 };
 async function discoverBuildCommandsFromProfiles(workingDir) {
   const commands = [];
   const skipped = [];
-  const detectedProfiles = await detectProjectLanguages(workingDir);
+  const detectedProfiles = await _internals.detectProjectLanguagesImpl(workingDir);
   for (const profile of detectedProfiles) {
-    const fullProfile = LANGUAGE_REGISTRY.get(profile.id);
+    const fullProfile = _internals.getLanguageProfileImpl(profile.id);
     if (!fullProfile) {
       warn(`[build-discovery] profile ${profile.id} not found in registry, skipping`);
       continue;
     }
     const sortedCommands = [...fullProfile.build.commands].sort((a, b) => b.priority - a.priority);
+    const applicableCommands = sortedCommands.filter((cmd) => {
+      if (!cmd.detectFile)
+        return true;
+      const detectFilePath = path2.join(workingDir, cmd.detectFile);
+      return fs2.existsSync(detectFilePath);
+    });
+    if (applicableCommands.length === 0) {
+      skipped.push({
+        ecosystem: fullProfile.id,
+        reason: getNoMatchingBuildFilesReason(fullProfile.id, sortedCommands)
+      });
+      continue;
+    }
     let foundCommand = false;
-    for (const cmd of sortedCommands) {
-      if (cmd.detectFile) {
-        const detectFilePath = path.join(workingDir, cmd.detectFile);
-        if (!fs.existsSync(detectFilePath)) {
-          continue;
-        }
-      }
-      const binaryName = cmd.cmd.split(" ")[0];
-      if (isCommandAvailable(binaryName)) {
+    for (const cmd of applicableCommands) {
+      const resolved = resolveLocalCommand(cmd.cmd, workingDir, _internals.isCommandAvailable);
+      if (resolved) {
         commands.push({
           ecosystem: fullProfile.id,
-          command: cmd.cmd,
+          command: resolved.shellCommand,
           cwd: workingDir,
           priority: cmd.priority
         });
@@ -13821,10 +14027,13 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
       }
     }
     if (!foundCommand) {
-      const triedBinaries = sortedCommands.map((c) => c.name || c.cmd.split(" ")[0]).join(", ");
+      const requiredCommands = getProfileRequiredCommands(applicableCommands);
+      const triedBinaries = requiredCommands.join(", ");
       const reason = `No binary available for profile ${fullProfile.id}: tried ${triedBinaries}`;
       skipped.push({
         ecosystem: fullProfile.id,
+        code: "environment_unavailable",
+        required_commands: requiredCommands,
         reason
       });
       warn(`[build-discovery] profile ${fullProfile.id}: no binary available, skipping`);
@@ -13839,16 +14048,53 @@ async function discoverBuildCommands(workingDir, options) {
   const profileResult = await _internals.discoverBuildCommandsFromProfiles(workingDir);
   const profileCommands = profileResult.commands;
   const profileSkipped = profileResult.skipped;
+  const repoDefinedScriptsByEcosystem = new Map;
+  const repoScriptSkips = [];
+  const repoDeclaredEcosystems = new Set;
+  for (const ecosystem of ECOSYSTEMS) {
+    if (!ecosystem.repoDefinedScripts)
+      continue;
+    const repoResult = getRepoDefinedScripts(workingDir, ecosystem.repoDefinedScripts);
+    if (repoResult.commands.length > 0) {
+      repoDefinedScriptsByEcosystem.set(ecosystem.ecosystem, repoResult.commands);
+    }
+    if (repoResult.hasScripts)
+      repoDeclaredEcosystems.add(ecosystem.ecosystem);
+    if (repoResult.skip)
+      repoScriptSkips.push(repoResult.skip);
+  }
+  const filteredProfileCommands = profileCommands.filter((cmd) => {
+    const ecosystemNames = PROFILE_TO_ECOSYSTEM_NAMES[cmd.ecosystem] ?? [];
+    return ecosystemNames.every((name) => !repoDeclaredEcosystems.has(name));
+  });
   const coveredEcosystems = new Set;
-  for (const cmd of profileCommands) {
+  for (const cmd of filteredProfileCommands) {
     const ecosystemNames = PROFILE_TO_ECOSYSTEM_NAMES[cmd.ecosystem] ?? [];
     for (const name of ecosystemNames) {
       coveredEcosystems.add(name);
     }
   }
-  const commands = [...profileCommands];
-  const skipped = [...profileSkipped];
+  const commands = [...filteredProfileCommands];
+  const skipped = [...profileSkipped, ...repoScriptSkips];
   for (const ecosystem of ECOSYSTEMS) {
+    const buildFile = findBuildFiles(workingDir, ecosystem.buildFiles);
+    if (!buildFile)
+      continue;
+    const repoScripts = repoDefinedScriptsByEcosystem.get(ecosystem.ecosystem);
+    if (repoScripts && repoScripts.length > 0) {
+      for (const script of repoScripts) {
+        commands.push({
+          ecosystem: ecosystem.ecosystem,
+          command: script.command,
+          cwd: workingDir,
+          priority: script.priority
+        });
+      }
+      continue;
+    }
+    if (repoDeclaredEcosystems.has(ecosystem.ecosystem)) {
+      continue;
+    }
     if (coveredEcosystems.has(ecosystem.ecosystem)) {
       skipped.push({
         ecosystem: ecosystem.ecosystem,
@@ -13859,28 +14105,13 @@ async function discoverBuildCommands(workingDir, options) {
     if (!checkToolchain(ecosystem.toolchainCommands)) {
       skipped.push({
         ecosystem: ecosystem.ecosystem,
+        code: "environment_unavailable",
+        required_commands: ecosystem.toolchainCommands,
         reason: `Toolchain not found: ${ecosystem.toolchainCommands.join(" or ")} not on PATH`
       });
       continue;
     }
-    const buildFile = findBuildFiles(workingDir, ecosystem.buildFiles);
-    if (!buildFile) {
-      skipped.push({
-        ecosystem: ecosystem.ecosystem,
-        reason: `No build file found: ${ecosystem.buildFiles.join(", ")}`
-      });
-      continue;
-    }
-    let availableCommands = ecosystem.commands;
-    if (ecosystem.repoDefinedScripts) {
-      const repoScripts = getRepoDefinedScripts(workingDir, ecosystem.repoDefinedScripts);
-      if (repoScripts.length > 0) {
-        availableCommands = repoScripts.map((s) => ({
-          command: s.script,
-          priority: s.priority
-        }));
-      }
-    }
+    const availableCommands = ecosystem.commands;
     for (const cmd of availableCommands) {
       commands.push({
         ecosystem: ecosystem.ecosystem,
@@ -13919,7 +14150,7 @@ var build_discovery = tool({
 function detectFileExists(dir, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
-      const files = fs2.readdirSync(dir);
+      const files = fs3.readdirSync(dir);
       const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
       return files.some((f) => regex.test(f));
     } catch {
@@ -13927,42 +14158,12 @@ function detectFileExists(dir, pattern) {
     }
   }
   try {
-    fs2.accessSync(path2.join(dir, pattern));
+    fs3.accessSync(path3.join(dir, pattern));
     return true;
   } catch {
     return false;
   }
 }
-function tokenizeCommand(cmd) {
-  const out = [];
-  let buf = "";
-  let quote = null;
-  for (const ch of cmd) {
-    if (quote) {
-      if (ch === quote) {
-        quote = null;
-      } else {
-        buf += ch;
-      }
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quote = ch;
-      continue;
-    }
-    if (ch === " " || ch === "\t") {
-      if (buf.length > 0) {
-        out.push(buf);
-        buf = "";
-      }
-      continue;
-    }
-    buf += ch;
-  }
-  if (buf.length > 0)
-    out.push(buf);
-  return out;
-}
 async function defaultSelectTestFramework(profile, dir) {
   const sorted = [...profile.test.frameworks].sort((a, b) => b.priority - a.priority);
   for (const fw of sorted) {
@@ -14006,14 +14207,14 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       return args;
     }
     case "vitest": {
-      const args = [
-        "npx",
-        "vitest",
+      const args = resolveLocalNodeTool("vitest", [
         "run",
         "--reporter=json",
         "--outputFile",
         ".swarm/cache/test-runner-vitest.json"
-      ];
+      ], dir, process.platform, isCommandAvailable);
+      if (!args)
+        return null;
       if (coverage)
         args.push("--coverage");
       if (bail)
@@ -14023,7 +14224,9 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       return args;
     }
     case "jest": {
-      const args = ["npx", "jest", "--json"];
+      const args = resolveLocalNodeTool("jest", ["--json"], dir, process.platform, isCommandAvailable);
+      if (!args)
+        return null;
       if (coverage)
         args.push("--coverage");
       if (bail)
@@ -14033,7 +14236,9 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       return args;
     }
     case "mocha": {
-      const args = ["npx", "mocha"];
+      const args = resolveLocalNodeTool("mocha", [], dir, process.platform, isCommandAvailable);
+      if (!args)
+        return null;
       if (bail)
         args.push("--bail");
       if (scope !== "all" && files.length > 0)
@@ -14087,8 +14292,8 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
     }
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs2.existsSync(path2.join(dir, "gradlew.bat"));
-      const hasGradlew = fs2.existsSync(path2.join(dir, "gradlew"));
+      const hasGradlewBat = fs3.existsSync(path3.join(dir, "gradlew.bat"));
+      const hasGradlew = fs3.existsSync(path3.join(dir, "gradlew"));
       const args = [];
       if (hasGradlewBat && isWindows)
         args.push("gradlew.bat");
@@ -14119,7 +14324,7 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs2.existsSync(path2.join(dir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs3.existsSync(path3.join(dir, d, "CMakeCache.txt"))) ?? "build";
       const args = ["ctest", "--test-dir", actualBuildDir];
       if (targets && targets.length > 0) {
         args.push("-R", targets.join("|"));
@@ -14205,7 +14410,7 @@ function buildNativeTargetCommand(target) {
   return ["go", "test", "-v", "-run", selector, packagePath];
 }
 function phpVendorBin(name) {
-  return path2.join("vendor", "bin", process.platform === "win32" ? `${name}.bat` : name);
+  return path3.join("vendor", "bin", process.platform === "win32" ? `${name}.bat` : name);
 }
 function defaultParseTestOutput(framework, stdout, stderr, exitCode) {
   const output = stdout && stderr ? `${stdout}
@@ -14468,14 +14673,12 @@ async function defaultSelectBuildCommand(profile, dir) {
   for (const cmd of sorted) {
     if (cmd.detectFile && !detectFileExists(dir, cmd.detectFile))
       continue;
-    const argv = tokenizeCommand(cmd.cmd);
-    if (argv.length === 0)
-      continue;
-    if (!isCommandAvailable(argv[0]))
+    const resolved = resolveLocalCommand(cmd.cmd, dir, isCommandAvailable);
+    if (!resolved)
       continue;
     return {
       name: cmd.name,
-      cmd: argv,
+      cmd: resolved.argv,
       cwd: dir,
       detectedVia: cmd.detectFile ?? `${profile.id} default`
     };
@@ -14483,23 +14686,23 @@ async function defaultSelectBuildCommand(profile, dir) {
   return null;
 }
 async function defaultTestFilesFor(profile, sourceFile, dir) {
-  const ext = path2.extname(sourceFile);
+  const ext = path3.extname(sourceFile);
   if (!profile.extensions.includes(ext))
     return [];
-  const base = path2.basename(sourceFile, ext);
-  const rel = path2.relative(dir, sourceFile);
-  const relDir = path2.dirname(rel);
+  const base = path3.basename(sourceFile, ext);
+  const rel = path3.relative(dir, sourceFile);
+  const relDir = path3.dirname(rel);
   const stripSrc = relDir.replace(/^src(\/|\\)/, "");
   const candidates = new Set;
   for (const tDir of ["tests", "test", "__tests__", "spec"]) {
     for (const suffix of ["", "_test", ".test", "_spec", ".spec"]) {
-      candidates.add(path2.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
+      candidates.add(path3.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
     }
   }
   const existing = [];
   for (const c of candidates) {
     try {
-      fs2.accessSync(c);
+      fs3.accessSync(c);
       existing.push(c);
     } catch {}
   }
@@ -14530,8 +14733,8 @@ function defaultBackendFor(profile) {
 }
 
 // src/lang/backends/go.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var PROFILE_ID = "go";
 var IMPORT_REGEX_SINGLE = /^\s*import\s+(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/gm;
 var IMPORT_REGEX_GROUP = /^\s*import\s*\(([\s\S]*?)\)/gm;
@@ -14561,7 +14764,7 @@ function extractImports(_sourceFile, source) {
 async function selectFramework(dir) {
   let content;
   try {
-    content = fs3.readFileSync(path3.join(dir, "go.mod"), "utf-8");
+    content = fs4.readFileSync(path4.join(dir, "go.mod"), "utf-8");
   } catch {
     return null;
   }
@@ -14582,16 +14785,16 @@ async function selectFramework(dir) {
 async function selectEntryPoints(dir) {
   const points = [];
   try {
-    fs3.accessSync(path3.join(dir, "main.go"));
+    fs4.accessSync(path4.join(dir, "main.go"));
     points.push("main.go");
   } catch {}
   try {
-    const cmdDir = path3.join(dir, "cmd");
-    const subdirs = fs3.readdirSync(cmdDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    const cmdDir = path4.join(dir, "cmd");
+    const subdirs = fs4.readdirSync(cmdDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const sub of subdirs) {
-      const main = path3.join("cmd", sub.name, "main.go");
+      const main = path4.join("cmd", sub.name, "main.go");
       try {
-        fs3.accessSync(path3.join(dir, main));
+        fs4.accessSync(path4.join(dir, main));
         points.push(main);
       } catch {}
     }
@@ -14613,8 +14816,8 @@ function buildGoBackend() {
 var _internals2 = { extractImports };
 
 // src/lang/backends/python.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 var PROFILE_ID2 = "python";
 var IMPORT_REGEX_FROM_WITH_TARGETS = /^\s*from\s+(\.*[\w.]*)\s+import\s+(\([^)]*\)|[^\n#]+)/gm;
 var IMPORT_REGEX_IMPORT = /^\s*import\s+([^\n#]+)/gm;
@@ -14677,7 +14880,7 @@ async function selectFramework2(dir) {
   ];
   for (const candidate of ["pyproject.toml", "requirements.txt", "setup.py"]) {
     try {
-      const content = fs4.readFileSync(path4.join(dir, candidate), "utf-8");
+      const content = fs5.readFileSync(path5.join(dir, candidate), "utf-8");
       const lower = content.toLowerCase();
       for (const [pkg, name] of candidates) {
         if (lower.includes(pkg)) {
@@ -14691,7 +14894,7 @@ async function selectFramework2(dir) {
 async function selectEntryPoints2(dir) {
   const points = new Set;
   try {
-    const content = fs4.readFileSync(path4.join(dir, "pyproject.toml"), "utf-8");
+    const content = fs5.readFileSync(path5.join(dir, "pyproject.toml"), "utf-8");
     const scriptsBlock = content.match(/\[project\.scripts\][\s\S]*?(?=\n\[|$)/);
     if (scriptsBlock) {
       for (const line of scriptsBlock[0].split(`
@@ -14706,7 +14909,7 @@ async function selectEntryPoints2(dir) {
   } catch {}
   for (const name of ["manage.py", "main.py", "app.py", "__main__.py"]) {
     try {
-      fs4.accessSync(path4.join(dir, name));
+      fs5.accessSync(path5.join(dir, name));
       points.add(name);
     } catch {}
   }
@@ -14726,4 +14929,4 @@ function buildPythonBackend() {
 }
 var _internals3 = { extractImports: extractImports2 };
 
-export { tool, LANGUAGE_REGISTRY, getProfileForFile, detectProjectLanguages, isCommandAvailable, tokenizeCommand, defaultSelectTestFramework, defaultBuildTestCommand, buildNativeTargetCommand, defaultParseTestOutput, defaultSelectBuildCommand, defaultTestFilesFor, defaultBackendFor, buildGoBackend, _internals2 as _internals, buildPythonBackend, _internals3 as _internals1 };
+export { tool, LANGUAGE_REGISTRY, getProfileForFile, detectProjectLanguages, tokenizeCommand, resolveLocalNodeTool, isCommandAvailable, defaultSelectTestFramework, defaultBuildTestCommand, buildNativeTargetCommand, defaultParseTestOutput, defaultSelectBuildCommand, defaultTestFilesFor, defaultBackendFor, buildGoBackend, _internals2 as _internals, buildPythonBackend, _internals3 as _internals1 };