opencode-swarm 7.144.3 → 7.144.5

package/dist/cli/{index-wck434f8.js → index-63tgh0cn.js}

@@ -2,10 +2,14 @@
 import {
   readKnowledge,
   transactKnowledge
-} from "./index-xwpmxpb7.js";
+} from "./index-641yjpk8.js";
+import {
+  init_git_executable,
+  resolveGitExecutableAsync
+} from "./index-9e6fdz2h.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-dpfphnmy.js";
+} from "./index-h1p08s3n.js";
 import {
   init_knowledge_types,
   isActiveStatus
@@ -27,6 +31,7 @@ init_knowledge_types();
 init_logger();
 
 // src/knowledge/cohort-identity.ts
+init_git_executable();
 import { execFile } from "child_process";
 import { createHash } from "crypto";
 import { realpathSync } from "fs";
@@ -111,10 +116,16 @@ function normalizeGitRemote(rawUrl) {
     return null;
   return `${host}/${pathPart}`;
 }
-function runGit(directory, args) {
+async function runGit(directory, args) {
+  let gitExecutable;
+  try {
+    gitExecutable = await resolveGitExecutableAsync();
+  } catch {
+    return null;
+  }
   return new Promise((resolve2) => {
     try {
-      const child = execFile("git", ["-C", directory, ...args], {
+      const child = execFile(gitExecutable, ["-C", directory, ...args], {
         timeout: GIT_TIMEOUT_MS,
         windowsHide: true,
         encoding: "utf-8",

package/dist/cli/{index-xwpmxpb7.js → index-641yjpk8.js}

@@ -6,10 +6,10 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-dpfphnmy.js";
+} from "./index-h1p08s3n.js";
 import {
   atomicWriteFile
-} from "./index-zswmbm15.js";
+} from "./index-9s8drsf9.js";
 import {
   readCachedParsedFile
 } from "./index-ed5ykebp.js";
@@ -709,7 +709,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
   const {
     readAuthoritativeKnowledgeCounterRollups,
     effectiveRetrievalOutcomes
-  } = await import("./knowledge-events-aw22r72m.js");
+  } = await import("./knowledge-events-ces29ncg.js");
   const rollups = await readAuthoritativeKnowledgeCounterRollups(directory);
   const flagIds = new Set;
   for (const e of atFloor) {
@@ -776,11 +776,11 @@ async function applyConfidenceFloorAction(directory, touched, options) {
     });
   }
   if (action === "quarantine" && toQuarantine.length > 0) {
-    const { quarantineEntry } = await import("./knowledge-validator-8wh82z0a.js");
-    const { KnowledgeConfigSchema } = await import("./schema-jdwjcby0.js");
+    const { quarantineEntry } = await import("./knowledge-validator-4yjf1f7k.js");
+    const { KnowledgeConfigSchema } = await import("./schema-2esybebd.js");
     let config;
     try {
-      const { loadPluginConfigWithMeta } = await import("./index-ep14xc5z.js");
+      const { loadPluginConfigWithMeta } = await import("./index-fv2pzwnp.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-zwrqe065.js → index-6z5jtf7d.js}

@@ -9,7 +9,7 @@ import {
   readEvaluationRun,
   saveEvaluationRun,
   saveTaskSetSnapshot
-} from "./index-8214dd7j.js";
+} from "./index-wknz5c8q.js";
 import {
   canonicalHash,
   computeCandidateInputContentHash,
@@ -24,7 +24,7 @@ import {
 } from "./index-bpmtbmy9.js";
 import {
   bunSpawn
-} from "./index-4nt52yr9.js";
+} from "./index-zj6t9zgx.js";
 
 // src/evaluation/runner.ts
 import * as fs3 from "fs";

package/dist/cli/{index-j6mfyy0a.js → index-7e4q41nb.js}

@@ -4,14 +4,14 @@ import {
   PlanSchema,
   TaskStatusSchema,
   init_loader
-} from "./index-8hkjk37c.js";
+} from "./index-58cvm3dw.js";
 import {
   assertProjectRoot,
   withEvidenceLock
-} from "./index-wd24zn2e.js";
+} from "./index-f9vvg5xb.js";
 import {
   emit
-} from "./index-s2rcz51a.js";
+} from "./index-1jsmmx7y.js";
 import {
   criticalWarn,
   init_logger,

package/dist/cli/{index-6s2q144w.js → index-855hseq4.js}

@@ -1,15 +1,19 @@
 // @bun
+import {
+  SWARM_WORKTREE_DIR_NAME,
+  init_constants
+} from "./index-v3y3qg48.js";
+import {
+  init_git_executable,
+  resolveGitExecutable
+} from "./index-9e6fdz2h.js";
 import {
   advisoryWarn,
   init_warning_buffer
 } from "./index-4rhhvd1a.js";
-import {
-  SWARM_WORKTREE_DIR_NAME,
-  init_constants
-} from "./index-whezv7vc.js";
 import {
   bunSpawn
-} from "./index-4nt52yr9.js";
+} from "./index-zj6t9zgx.js";
 import {
   log
 } from "./index-zgwm4ryv.js";
@@ -66,8 +70,10 @@ function matchSwarmLaneBranch(branch) {
 
 // src/worktree/core.ts
 init_warning_buffer();
+init_git_executable();
 var _internals = {
   bunSpawn,
+  resolveGitExecutable,
   platform: process.platform,
   sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
   osTmpdir: () => os.tmpdir(),
@@ -86,7 +92,7 @@ var _internals = {
     symlinkSync: fs.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-s0s1bz15.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-ej59x0yc.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {
@@ -134,15 +140,25 @@ async function removeLaneProfileFromDiskReal(worktreePath, laneIndex) {
 }
 var WORKTREE_TIMEOUT_MS = 30000;
 var WIN_PATH_BUDGET = 250;
+var GIT_SPAWN_FAILURE_EXIT_CODE = 1;
 async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
-  const proc = _internals.bunSpawn(["git", ...args], {
-    cwd,
-    timeout: timeoutMs,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, LC_ALL: "C" }
-  });
+  let proc;
+  try {
+    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), ...args], {
+      cwd,
+      timeout: timeoutMs,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, LC_ALL: "C" }
+    });
+  } catch (error) {
+    return {
+      exitCode: GIT_SPAWN_FAILURE_EXIT_CODE,
+      stdout: "",
+      stderr: `git ${args[0] ?? "command"} could not start in ${cwd}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
   try {
     const exitCode = await proc.exited;
     const stdout = await proc.stdout.text();
@@ -165,14 +181,19 @@ async function checkPathBudget(worktreeRoot, directory) {
   if (longPaths === "true") {
     return { ok: true };
   }
-  const proc = _internals.bunSpawn(["git", "ls-files"], {
-    cwd: directory,
-    timeout: WORKTREE_TIMEOUT_MS,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "ignore",
-    env: { ...process.env, LC_ALL: "C" }
-  });
+  let proc;
+  try {
+    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), "ls-files"], {
+      cwd: directory,
+      timeout: WORKTREE_TIMEOUT_MS,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+      env: { ...process.env, LC_ALL: "C" }
+    });
+  } catch {
+    return { ok: true };
+  }
   try {
     const exitCode = await proc.exited;
     const stdout = await proc.stdout.text();

package/dist/cli/index-9e6fdz2h.js

@@ -0,0 +1,282 @@
+// @bun
+import {
+  advisoryWarn,
+  init_warning_buffer
+} from "./index-4rhhvd1a.js";
+import {
+  __esm
+} from "./index-a76rekgs.js";
+
+// src/utils/git-executable.ts
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function excerptProbeOutput(raw) {
+  return raw.slice(0, PROBE_OUTPUT_EXCERPT_CHARS).replace(/[^\x20-\x7E]/g, " ").trim();
+}
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function envOverride() {
+  const raw = _internals.env()[GIT_BINARY_ENV_VAR];
+  return raw && raw.trim() !== "" ? raw : undefined;
+}
+function effectiveOverride() {
+  return envOverride() ?? configuredOverride;
+}
+function overrideSource() {
+  if (envOverride() !== undefined)
+    return "env";
+  if (configuredOverride !== undefined)
+    return "config";
+  return;
+}
+function isAbsoluteForPlatform(candidate, platform) {
+  return platform === "win32" ? path.win32.isAbsolute(candidate) : path.posix.isAbsolute(candidate);
+}
+function windowsPlatformCandidates() {
+  const env = _internals.env();
+  const roots = unique([
+    env.ProgramFiles ?? "",
+    env["ProgramFiles(x86)"] ?? "",
+    env.LOCALAPPDATA ? `${env.LOCALAPPDATA}\\Programs` : ""
+  ]);
+  const installed = roots.flatMap((root) => [
+    `${root}\\Git\\cmd\\git.exe`,
+    `${root}\\Git\\bin\\git.exe`
+  ]);
+  return unique(installed);
+}
+function platformCandidates(platform) {
+  if (platform === "darwin") {
+    return ["/opt/homebrew/bin/git", "/usr/local/bin/git", "/usr/bin/git"];
+  }
+  if (platform === "win32") {
+    return windowsPlatformCandidates();
+  }
+  return ["/usr/bin/git", "/usr/local/bin/git", "/bin/git"];
+}
+function pathDelimiterFor(platform) {
+  return platform === "win32" ? ";" : ":";
+}
+function joinDirAndName(dir, name, platform) {
+  const sep = platform === "win32" ? "\\" : "/";
+  const trimmed = dir.replace(/[\\/]+$/, "");
+  return trimmed ? `${trimmed}${sep}${name}` : `${sep}${name}`;
+}
+function pathCandidates(platform) {
+  const pathValue = _internals.env().PATH ?? "";
+  if (!pathValue)
+    return [];
+  const dirs = pathValue.split(pathDelimiterFor(platform)).filter(Boolean);
+  const names = platform === "win32" ? [...WINDOWS_PATH_EXTENSIONS.map((ext) => `git${ext}`), "git"] : ["git"];
+  const out = [];
+  for (const dir of dirs) {
+    for (const name of names) {
+      out.push(joinDirAndName(dir, name, platform));
+    }
+  }
+  return unique(out);
+}
+function buildCandidates(platform) {
+  const override = effectiveOverride();
+  const overrideCandidate = override ? [{ source: "override", path: override }] : [];
+  const seen = new Set(overrideCandidate.map((c) => c.path));
+  const rest = [];
+  for (const p of platformCandidates(platform)) {
+    if (seen.has(p))
+      continue;
+    seen.add(p);
+    rest.push({ source: "platform", path: p });
+  }
+  for (const p of pathCandidates(platform)) {
+    if (seen.has(p))
+      continue;
+    seen.add(p);
+    rest.push({ source: "path", path: p });
+  }
+  return [...overrideCandidate, ...rest];
+}
+function probeCandidate(candidatePath, platform) {
+  if (!isAbsoluteForPlatform(candidatePath, platform)) {
+    return { accepted: false, reason: "not an absolute path" };
+  }
+  let stat;
+  try {
+    stat = fs.statSync(candidatePath);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT")
+      return { accepted: false, reason: "no such file" };
+    return {
+      accepted: false,
+      reason: `cannot stat (${code ?? "unknown error"})`
+    };
+  }
+  if (stat.isDirectory()) {
+    return { accepted: false, reason: "is a directory" };
+  }
+  if (!stat.isFile()) {
+    return { accepted: false, reason: "not a regular file" };
+  }
+  let result;
+  try {
+    result = _internals.spawnSync(candidatePath, ["--version"], {
+      cwd: os.tmpdir(),
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+      timeout: PER_PROBE_TIMEOUT_MS,
+      maxBuffer: PROBE_MAX_BUFFER_BYTES
+    });
+  } catch (err) {
+    return {
+      accepted: false,
+      reason: `spawn threw: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (result.error) {
+    return { accepted: false, reason: `spawn failed: ${result.error.message}` };
+  }
+  if (result.status !== 0) {
+    const statusDescription = result.status !== null ? `exit ${result.status}` : `signal ${result.signal ?? "unknown"}`;
+    return {
+      accepted: false,
+      reason: `git --version returned ${statusDescription}`
+    };
+  }
+  const versionOutput = (result.stdout ?? "").toString().trim();
+  if (!GIT_VERSION_PATTERN.test(versionOutput)) {
+    const excerpt = excerptProbeOutput(versionOutput);
+    return {
+      accepted: false,
+      reason: excerpt ? `not git: --version printed "${excerpt}"` : "not git: --version printed nothing"
+    };
+  }
+  return { accepted: true };
+}
+function* probeCycle(candidates, platform, attempts) {
+  const start = _internals.now();
+  let budgetExceeded = false;
+  for (const candidate of candidates) {
+    if (_internals.now() - start > TOTAL_BUDGET_MS) {
+      budgetExceeded = true;
+      break;
+    }
+    const result = probeCandidate(candidate.path, platform);
+    attempts.push({
+      source: candidate.source,
+      candidate: candidate.path,
+      accepted: result.accepted,
+      reason: result.reason
+    });
+    if (candidate.source === "override" && !result.accepted) {
+      advisoryWarn(`[opencode-swarm] git.binary override "${candidate.path}" is unusable (${result.reason}); falling back to automatic git resolution.`);
+    }
+    if (result.accepted) {
+      return { outcome: "accepted", path: candidate.path };
+    }
+    yield;
+  }
+  return budgetExceeded ? { outcome: "exhausted-budget" } : { outcome: "all-rejected" };
+}
+function driveSync(gen) {
+  let step = gen.next();
+  while (!step.done) {
+    step = gen.next();
+  }
+  return step.value;
+}
+async function driveAsync(gen) {
+  let step = gen.next();
+  while (!step.done) {
+    await _internals.yieldToEventLoop();
+    step = gen.next();
+  }
+  return step.value;
+}
+function readCache() {
+  if (cache === null)
+    return null;
+  if (cache.kind === "success")
+    return cache;
+  if (_internals.now() < cache.expiresAt)
+    return cache;
+  cache = null;
+  return null;
+}
+function applyProbeResult(result, attempts, generation) {
+  if (generation !== cacheGeneration) {
+    return result.outcome === "accepted" ? result.path : BARE_GIT;
+  }
+  lastAttempts = attempts;
+  if (result.outcome === "accepted") {
+    cache = { kind: "success", path: result.path };
+    return result.path;
+  }
+  cache = {
+    kind: "fallback",
+    expiresAt: _internals.now() + NEGATIVE_CACHE_TTL_MS
+  };
+  return BARE_GIT;
+}
+function resolveGitExecutable() {
+  const cached = readCache();
+  if (cached)
+    return cached.kind === "success" ? cached.path : BARE_GIT;
+  const platform = _internals.platform();
+  const attempts = [];
+  const generation = cacheGeneration;
+  const candidates = buildCandidates(platform);
+  const result = driveSync(probeCycle(candidates, platform, attempts));
+  return applyProbeResult(result, attempts, generation);
+}
+async function resolveGitExecutableAsync() {
+  const cached = readCache();
+  if (cached)
+    return cached.kind === "success" ? cached.path : BARE_GIT;
+  if (inFlightAsync)
+    return inFlightAsync;
+  const platform = _internals.platform();
+  const attempts = [];
+  const generation = cacheGeneration;
+  const candidates = buildCandidates(platform);
+  const run = (async () => {
+    const result = await driveAsync(probeCycle(candidates, platform, attempts));
+    return applyProbeResult(result, attempts, generation);
+  })();
+  inFlightAsync = run;
+  try {
+    return await run;
+  } finally {
+    if (inFlightAsync === run)
+      inFlightAsync = null;
+  }
+}
+function describeGitResolution() {
+  const cached = cache;
+  return {
+    resolved: cached?.kind === "success",
+    resolvedPath: cached?.kind === "success" ? cached.path : undefined,
+    attempts: [...lastAttempts],
+    overrideValue: effectiveOverride(),
+    overrideSource: overrideSource()
+  };
+}
+var GIT_BINARY_ENV_VAR = "OPENCODE_SWARM_GIT_BINARY", PER_PROBE_TIMEOUT_MS = 250, TOTAL_BUDGET_MS = 1000, NEGATIVE_CACHE_TTL_MS = 60000, BARE_GIT = "git", PROBE_MAX_BUFFER_BYTES, WINDOWS_PATH_EXTENSIONS, GIT_VERSION_PATTERN, PROBE_OUTPUT_EXCERPT_CHARS = 60, cache = null, lastAttempts, configuredOverride, inFlightAsync = null, cacheGeneration = 0, _internals;
+var init_git_executable = __esm(() => {
+  init_warning_buffer();
+  PROBE_MAX_BUFFER_BYTES = 64 * 1024;
+  WINDOWS_PATH_EXTENSIONS = [".exe", ".cmd", ".bat"];
+  GIT_VERSION_PATTERN = /^git version \d+\.\d+/;
+  lastAttempts = [];
+  _internals = {
+    spawnSync,
+    platform: () => process.platform,
+    env: () => process.env,
+    now: () => Date.now(),
+    yieldToEventLoop: () => new Promise((resolve) => setTimeout(resolve, 0))
+  };
+});
+
+export { GIT_BINARY_ENV_VAR, resolveGitExecutable, resolveGitExecutableAsync, describeGitResolution, init_git_executable };

package/dist/cli/{index-zswmbm15.js → index-9s8drsf9.js}

@@ -4,10 +4,10 @@ import {
 } from "./index-ed5ykebp.js";
 import {
   withEvidenceLock
-} from "./index-wd24zn2e.js";
+} from "./index-f9vvg5xb.js";
 import {
   bunWrite
-} from "./index-4nt52yr9.js";
+} from "./index-zj6t9zgx.js";
 
 // src/evidence/task-file.ts
 import { renameSync, unlinkSync } from "fs";