opencode-swarm 7.144.4 → 7.144.5

package/dist/cli/{index-cz25e8xp.js → index-a1hxejxc.js}

@@ -2,14 +2,18 @@
 import {
   autoCommitDirty,
   cleanUntrackedFiles
-} from "./index-8j0va7jp.js";
+} from "./index-855hseq4.js";
 import {
   isPathWithinDeclaredScope,
   unsafePathTextReason
 } from "./index-556ja8an.js";
 import {
   validateSwarmPath
-} from "./index-rn0eq85g.js";
+} from "./index-fv0s19g9.js";
+import {
+  init_git_executable,
+  resolveGitExecutable
+} from "./index-9e6fdz2h.js";
 import {
   advisoryWarn,
   init_warning_buffer
@@ -18,7 +22,7 @@ import {
   atomicWriteFile,
   taskEvidencePath,
   withTaskEvidenceLock
-} from "./index-mazgg5s2.js";
+} from "./index-9s8drsf9.js";
 import {
   telemetry
 } from "./index-1jsmmx7y.js";
@@ -27,8 +31,9 @@ import {
   init_zod
 } from "./index-bpmtbmy9.js";
 import {
-  bunSpawn
-} from "./index-4nt52yr9.js";
+  bunSpawn,
+  classifySpawnFailure
+} from "./index-zj6t9zgx.js";
 import {
   log
 } from "./index-zgwm4ryv.js";
@@ -148,33 +153,99 @@ function recoveryReadErrored(directory) {
   return readRecoveryRecords(directory).errored;
 }
 
+// src/utils/git-binary-missing-error.ts
+class GitUnavailableError extends Error {
+}
+
+class GitBinaryMissingError extends GitUnavailableError {
+  name = "GitBinaryMissingError";
+  constructor(message = "git binary is not available", options) {
+    super(message, options);
+  }
+}
+
+class GitSpawnCwdError extends GitUnavailableError {
+  name = "GitSpawnCwdError";
+  cwd;
+  fault;
+  constructor(cwd, fault, options) {
+    super(fault === "missing" ? `git could not start: working directory no longer exists: ${cwd}` : `git could not start: working directory could not be inspected (permission denied): ${cwd}`, options);
+    this.cwd = cwd;
+    this.fault = fault;
+  }
+}
+function isGitBinaryMissing(err, cwd) {
+  return classifySpawnFailure(err, cwd) === "binary-missing";
+}
+function isSpawnCwdMissing(err, cwd) {
+  return classifySpawnFailure(err, cwd) === "cwd-missing";
+}
+function isSpawnCwdUnreadable(err, cwd) {
+  return classifySpawnFailure(err, cwd) === "cwd-unreadable";
+}
+
 // src/worktree/merge.ts
+init_git_executable();
 var _internals = {
   bunSpawn,
   platform: process.platform,
   sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
   cleanupOrphanedBranches,
   startupOrphanRecovery,
-  extractSessionId
+  extractSessionId,
+  resolveGitExecutable
 };
 var MERGE_TIMEOUT_MS = 30000;
+var GIT_SPAWN_FAILURE_EXIT_CODE = 1;
+var SOURCE_WORKTREE_GONE_STAGE = "source-worktree-gone";
+var SOURCE_WORKTREE_UNCERTAIN_STAGE = "source-worktree-uncertain";
+function gitSpawnFailureResult(error, cwd, args) {
+  const operation = args[0] ?? "command";
+  let kind;
+  let message;
+  if (isSpawnCwdMissing(error, cwd)) {
+    kind = "cwd-missing";
+    message = `git ${operation} could not start: working directory no longer exists: ${cwd}`;
+  } else if (isSpawnCwdUnreadable(error, cwd)) {
+    kind = "cwd-unreadable";
+    message = `git ${operation} could not start: working directory could not be inspected: ${cwd}`;
+  } else {
+    kind = "spawn-failed";
+    message = `git ${operation} could not start in ${cwd}: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  return {
+    exitCode: GIT_SPAWN_FAILURE_EXIT_CODE,
+    stdout: "",
+    stderr: message,
+    spawnFailure: { kind, cwd, message }
+  };
+}
 async function runGit(args, cwd, timeoutMs = MERGE_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" }
+    });
+    if (proc.spawnError) {
+      return gitSpawnFailureResult(proc.spawnError, cwd, args);
+    }
     const exitCode = await proc.exited;
+    if (proc.spawnError) {
+      return gitSpawnFailureResult(proc.spawnError, cwd, args);
+    }
     const stdout = await proc.stdout.text();
     const stderr = await proc.stderr.text();
     return { exitCode, stdout, stderr };
+  } catch (error) {
+    return gitSpawnFailureResult(error, cwd, args);
   } finally {
     try {
-      proc.kill();
+      proc?.kill();
     } catch {}
   }
 }
@@ -275,10 +346,10 @@ async function reconcileLandedMerge(primaryDir, provenance) {
   return trailerSearch.stdout.trim() ? { landed: true, method: "cherry-pick-trailer" } : { landed: false };
 }
 async function postMergeCleanup(directory, branchName) {
-  const deleteResult = await runGit(["branch", "-D", branchName], directory);
-  const deleteOk = deleteResult.exitCode === 0;
   const pruneResult = await runGit(["worktree", "prune"], directory);
   const pruneOk = pruneResult.exitCode === 0;
+  const deleteResult = await runGit(["branch", "-D", branchName], directory);
+  const deleteOk = deleteResult.exitCode === 0;
   if (deleteOk && pruneOk) {
     return { cleaned: true };
   }
@@ -300,12 +371,46 @@ async function pruneStaleWorktreeMetadata(directory) {
     error: result.stderr.trim() || result.stdout.trim() || `git worktree prune exited ${result.exitCode}`
   };
 }
+async function readLaneBranchHead(branchName, primaryDir) {
+  return runGit(["rev-parse", "--verify", "--quiet", `refs/heads/${branchName}`], primaryDir);
+}
+async function captureLaneSourceHead(worktreePath, branchName, primaryDir, knownMissing) {
+  if (!knownMissing) {
+    const fromWorktree = await runGit(["rev-parse", "HEAD"], worktreePath);
+    if (fromWorktree.spawnFailure?.kind !== "cwd-missing") {
+      return { result: fromWorktree, sourceWorktreeMissing: false };
+    }
+  }
+  return {
+    result: await readLaneBranchHead(branchName, primaryDir),
+    sourceWorktreeMissing: true
+  };
+}
+async function handleSourceWorktreeGone(branchHead, worktreePath, branchName, primaryDir, provenance) {
+  const branchResolved = branchHead.spawnFailure === undefined && branchHead.exitCode === 0 && branchHead.stdout.trim().length > 0;
+  if (!branchResolved) {
+    const definitelyAbsent = branchHead.spawnFailure === undefined && branchHead.exitCode === 1;
+    return {
+      failed: true,
+      stage: definitelyAbsent ? SOURCE_WORKTREE_GONE_STAGE : SOURCE_WORKTREE_UNCERTAIN_STAGE,
+      message: definitelyAbsent ? `Lane worktree "${worktreePath}" is gone and branch "${branchName}" no longer exists; nothing is recoverable` : `Lane worktree "${worktreePath}" is gone and branch "${branchName}" existence could not be determined: ${branchHead.stderr.trim() || `git exited ${branchHead.exitCode}`}`,
+      ...provenance ? { provenance } : {}
+    };
+  }
+  const prune = await runGit(["worktree", "prune"], primaryDir);
+  if (prune.exitCode !== 0) {
+    log(`[worktree] attemptMergeBackFromDirty: worktree prune failed for "${worktreePath}": ${prune.stderr.trim() || prune.stdout.trim()}`);
+  }
+  advisoryWarn(`STALE_LANE_WORKTREE_DETECTED: lane worktree "${worktreePath}" no longer exists. ` + `Its stale git registration was pruned, and the merge-back for branch "${branchName}" ` + `is being taken from "${primaryDir}" instead. Any uncommitted work in that worktree is ` + "unrecoverable; every commit on the branch is preserved.");
+  return null;
+}
 async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, strategy, options = {}) {
   let autoCommitted = false;
   let cleaned = false;
   let autoCommitFailed = false;
   let cleanFailed = false;
   let provenance = options.resume;
+  let sourceWorktreeMissing = false;
   if (provenance) {
     if (provenance.branchName !== branchName || provenance.strategy !== strategy || options.operationId !== undefined && provenance.operationId !== options.operationId) {
       return {
@@ -334,7 +439,14 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
         provenance
       };
     }
-    const sourceHead = await runGit(["rev-parse", "HEAD"], worktreePath);
+    const source = await captureLaneSourceHead(worktreePath, branchName, primaryDir, false);
+    if (source.sourceWorktreeMissing) {
+      const unrecoverable = await handleSourceWorktreeGone(source.result, worktreePath, branchName, primaryDir, provenance);
+      if (unrecoverable)
+        return unrecoverable;
+      sourceWorktreeMissing = true;
+    }
+    const sourceHead = source.result;
     const targetHead = await runGit(["rev-parse", "HEAD"], primaryDir);
     if (sourceHead.exitCode !== 0 || targetHead.exitCode !== 0 || sourceHead.stdout.trim() !== provenance.sourceHead || targetHead.stdout.trim() !== provenance.targetHeadBefore) {
       return {
@@ -345,7 +457,7 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
       };
     }
   }
-  if (!provenance) {
+  if (!provenance && !sourceWorktreeMissing) {
     const commitResult = await autoCommitDirty(worktreePath);
     if (commitResult.committed) {
       autoCommitted = true;
@@ -354,20 +466,33 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
       log(`[worktree] attemptMergeBackFromDirty: auto-commit failed for worktree "${worktreePath}" branch "${branchName}": ${commitResult.reason}`);
     }
   }
-  const cleanResult = await cleanUntrackedFiles(worktreePath);
-  if (cleanResult.cleaned) {
-    cleaned = true;
-  } else {
-    cleanFailed = true;
-    log(`[worktree] attemptMergeBackFromDirty: clean untracked failed for worktree "${worktreePath}" branch "${branchName}": ${cleanResult.error}`);
+  if (!sourceWorktreeMissing) {
+    const cleanResult = await cleanUntrackedFiles(worktreePath);
+    if (cleanResult.cleaned) {
+      cleaned = true;
+    } else {
+      cleanFailed = true;
+      log(`[worktree] attemptMergeBackFromDirty: clean untracked failed for worktree "${worktreePath}" branch "${branchName}": ${cleanResult.error}`);
+    }
   }
   if (autoCommitFailed && cleanFailed) {
-    return {
-      failed: true,
-      stage: "cleanup",
-      message: "Auto-commit and clean both failed; abandoning worktree",
-      ...provenance ? { provenance } : {}
-    };
+    const probe = await runGit(["rev-parse", "--git-dir"], worktreePath);
+    if (probe.spawnFailure?.kind === "cwd-missing") {
+      const unrecoverable = await handleSourceWorktreeGone(await readLaneBranchHead(branchName, primaryDir), worktreePath, branchName, primaryDir, provenance);
+      if (unrecoverable)
+        return unrecoverable;
+      sourceWorktreeMissing = true;
+      autoCommitFailed = false;
+      cleanFailed = false;
+      cleaned = false;
+    } else {
+      return {
+        failed: true,
+        stage: "cleanup",
+        message: "Auto-commit and clean both failed; abandoning worktree",
+        ...provenance ? { provenance } : {}
+      };
+    }
   }
   if (!provenance && (options.operationId || options.onBeforeMerge)) {
     if (!options.operationId) {
@@ -377,7 +502,14 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
         message: "A pre-merge callback requires a stable operationId"
       };
     }
-    const sourceHead = await runGit(["rev-parse", "HEAD"], worktreePath);
+    const source = await captureLaneSourceHead(worktreePath, branchName, primaryDir, sourceWorktreeMissing);
+    if (source.sourceWorktreeMissing && !sourceWorktreeMissing) {
+      const unrecoverable = await handleSourceWorktreeGone(source.result, worktreePath, branchName, primaryDir, provenance);
+      if (unrecoverable)
+        return unrecoverable;
+      sourceWorktreeMissing = true;
+    }
+    const sourceHead = source.result;
     const targetHead = await runGit(["rev-parse", "HEAD"], primaryDir);
     if (sourceHead.exitCode !== 0 || targetHead.exitCode !== 0 || !sourceHead.stdout.trim() || !targetHead.stdout.trim()) {
       return {
@@ -484,6 +616,7 @@ async function cleanupOrphanedBranches(directory, activeSessionIds = [], options
     };
   }
   const branches = await listLaneBranches(directory);
+  await runGit(["worktree", "prune"], directory);
   for (const branch of branches) {
     const sessionId = extractSessionId(branch);
     if (sessionId !== null && activeSessionIds.includes(sessionId)) {
@@ -504,7 +637,6 @@ async function cleanupOrphanedBranches(directory, activeSessionIds = [], options
       });
     }
   }
-  await runGit(["worktree", "prune"], directory);
   return {
     removed,
     skipped,
@@ -1369,4 +1501,4 @@ function compareTaskWorkflowStateRank(left, right) {
   return WORKFLOW_STATE_RANK[left] - WORKFLOW_STATE_RANK[right];
 }
 
-export { sanitizeTaskId, listRecoveryRecords, _internals, getMergeStrategy, reconcileLandedMerge, postMergeCleanup, pruneStaleWorktreeMetadata, attemptMergeBackFromDirty, cleanupOrphanedBranches, startupOrphanRecovery, readWorkflowWalFile, writeWorkflowWalFile, TASK_WORKFLOW_SCHEMA_MARKER, assertTaskEvidenceWriteAllowed, parseTaskEvidence, DEFAULT_REQUIRED_GATES, isValidTaskId, getTaskWorkflowSnapshot, reduceTaskWorkflowSnapshot, deriveRequiredGates, expandRequiredGates, transitionTaskWorkflowEvidence, withTaskEvidenceTransaction, recordGateEvidence, recordAgentDispatch, readTaskEvidence, readTaskEvidenceRaw, hasPassedAllGates, compareTaskWorkflowStateRank };
+export { sanitizeTaskId, listRecoveryRecords, GitBinaryMissingError, GitSpawnCwdError, isGitBinaryMissing, isSpawnCwdMissing, isSpawnCwdUnreadable, _internals, SOURCE_WORKTREE_GONE_STAGE, SOURCE_WORKTREE_UNCERTAIN_STAGE, getMergeStrategy, reconcileLandedMerge, postMergeCleanup, pruneStaleWorktreeMetadata, attemptMergeBackFromDirty, cleanupOrphanedBranches, startupOrphanRecovery, readWorkflowWalFile, writeWorkflowWalFile, TASK_WORKFLOW_SCHEMA_MARKER, assertTaskEvidenceWriteAllowed, parseTaskEvidence, DEFAULT_REQUIRED_GATES, isValidTaskId, getTaskWorkflowSnapshot, reduceTaskWorkflowSnapshot, deriveRequiredGates, expandRequiredGates, transitionTaskWorkflowEvidence, withTaskEvidenceTransaction, recordGateEvidence, recordAgentDispatch, readTaskEvidence, readTaskEvidenceRaw, hasPassedAllGates, compareTaskWorkflowStateRank };

package/dist/cli/{index-b6e016tv.js → index-abtrcs16.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-z6xqpmqg.js";
 import {
   bunSpawnSync
-} from "./index-4nt52yr9.js";
+} from "./index-zj6t9zgx.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";

package/dist/cli/{index-8fwhhayc.js → index-b44qqqt2.js}

@@ -1,8 +1,12 @@
 // @bun
 import {
+  _internals,
+  _internals1 as _internals2,
   exports_runner_client,
-  init_runner_client
-} from "./index-q1exe2b3.js";
+  init_bubblewrap_executor,
+  init_runner_client,
+  init_sandbox_exec_executor
+} from "./index-zy7f84cs.js";
 import {
   __esm,
   __toCommonJS
@@ -11,6 +15,9 @@ import {
 // src/sandbox/capability-probe.ts
 import { execFile, spawnSync } from "child_process";
 import * as os from "os";
+function _resetCapabilityCache() {
+  _cached = undefined;
+}
 function withProbeTimeout(cmd, args, ms) {
   return new Promise((resolve, reject) => {
     const controller = new AbortController;
@@ -50,7 +57,8 @@ function withProbeTimeout(cmd, args, ms) {
 }
 async function probeLinux() {
   try {
-    const output = await withProbeTimeout("bwrap", ["--version"], 2000);
+    const binary = _internals.resolveBwrapBinary();
+    const output = await _internals3.withProbeTimeout(binary, ["--version"], 2000);
     if (output.length > 0) {
       return {
         status: "enabled",
@@ -85,20 +93,15 @@ async function probeLinux() {
 }
 async function probeMacOS() {
   try {
-    const output = await withProbeTimeout("sandbox-exec", ["--version"], 2000);
-    if (output.length > 0) {
-      return {
-        status: "enabled",
-        strength: "strong",
-        mechanism: "sandbox-exec",
-        platform: "darwin"
-      };
-    }
+    const binary = _internals2.resolveSandboxExecBinary();
+    const target = _internals2.resolveProbeTargetBinary();
+    const profile = _internals2.buildProbeProfile(os.tmpdir());
+    await _internals3.withProbeTimeout(binary, ["-p", profile, target], 2000);
     return {
-      status: "disabled",
+      status: "enabled",
+      strength: "strong",
       mechanism: "sandbox-exec",
-      platform: "darwin",
-      error: "binary returned empty version"
+      platform: "darwin"
     };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -204,7 +207,13 @@ class SandboxCapabilityProbe {
     return _cached;
   }
 }
-var _cached;
-var init_capability_probe = () => {};
+var _cached, _internals3;
+var init_capability_probe = __esm(() => {
+  init_bubblewrap_executor();
+  init_sandbox_exec_executor();
+  _internals3 = {
+    withProbeTimeout
+  };
+});
 
-export { isBubblewrapAvailable, isSandboxExecAvailable, isWindowsSandboxAvailable, SandboxCapabilityProbe, init_capability_probe };
+export { _resetCapabilityCache, _internals3 as _internals, isBubblewrapAvailable, isSandboxExecAvailable, isWindowsSandboxAvailable, SandboxCapabilityProbe, init_capability_probe };

package/dist/cli/{index-k3cxyk66.js → index-cwtpqm5f.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-rn0eq85g.js";
+} from "./index-fv0s19g9.js";
 
 // src/hooks/delegation-gate/worktree-provisioning-owner.ts
 import { createHash, randomBytes } from "crypto";

package/dist/cli/{index-h98t1m88.js → index-dc04v786.js}

@@ -6,7 +6,7 @@ import {
   PluginConfigSchema,
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-y8j8ehc8.js";
+} from "./index-kdak6s63.js";
 import {
   ALL_AGENT_NAMES,
   init_constants
@@ -944,6 +944,34 @@ function validateConfigKey(path2, value) {
       emitObjectTypeMismatch("design_docs", value, findings);
       break;
     }
+    case "git": {
+      emitObjectTypeMismatch("git", value, findings);
+      break;
+    }
+    case "git.binary": {
+      if (value !== undefined && typeof value !== "string") {
+        findings.push({
+          id: "invalid-git-binary-type",
+          title: "Invalid git.binary type",
+          description: `"git.binary" must be a string, got ${typeof value}`,
+          severity: "error",
+          path: "git.binary",
+          currentValue: value,
+          autoFixable: false
+        });
+      } else if (typeof value === "string" && value.trim() === "") {
+        findings.push({
+          id: "empty-git-binary",
+          title: "Empty git.binary",
+          description: '"git.binary" is blank, so no git executable is named. Remove the key to fall back to the default `git` lookup, or set it to a real git executable path.',
+          severity: "error",
+          path: "git.binary",
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
     case "ui_review": {
       emitObjectTypeMismatch("ui_review", value, findings);
       break;

package/dist/cli/{index-d12jd5mn.js → index-dtbzyr3s.js}

@@ -11,7 +11,7 @@ import {
 import {
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-y8j8ehc8.js";
+} from "./index-kdak6s63.js";
 import {
   init_constants
 } from "./index-v3y3qg48.js";

package/dist/cli/{index-x6tp0hfr.js → index-ea09xax6.js}

@@ -6,12 +6,12 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-03pv47h2.js";
+} from "./index-641yjpk8.js";
 import {
   queryHistoricalOutcomes,
   readKnowledgeEvents,
   recordKnowledgeEvent
-} from "./index-4w5qdbk7.js";
+} from "./index-wbrqvm2g.js";
 import {
   init_knowledge_types,
   isActiveStatus
@@ -224,11 +224,11 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-jrxvexv6.js");
+    const { quarantineEntry } = await import("./knowledge-validator-4yjf1f7k.js");
     let policyConfig;
     try {
-      const { KnowledgeConfigSchema } = await import("./schema-rptwqbm4.js");
-      const { loadPluginConfigWithMeta } = await import("./index-btmsqv7p.js");
+      const { KnowledgeConfigSchema } = await import("./schema-2esybebd.js");
+      const { loadPluginConfigWithMeta } = await import("./index-fv2pzwnp.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-74hpm6sh.js → index-f36ybbsv.js}

@@ -1,13 +1,18 @@
 // @bun
+import {
+  init_git_executable,
+  resolveGitExecutable
+} from "./index-9e6fdz2h.js";
 import {
   bunSpawn
-} from "./index-4nt52yr9.js";
+} from "./index-zj6t9zgx.js";
 
 // src/background/workspace-snapshot.ts
 import * as child_process from "child_process";
 import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
+init_git_executable();
 var GIT_SNAPSHOT_TIMEOUT_MS = 3000;
 var GIT_SNAPSHOT_MAX_BUFFER = 32 * 1024 * 1024;
 var REVISION_MAX_FILES = 50000;
@@ -53,7 +58,7 @@ async function readBoundedGitOutput(stream, maxBytes, onOverflow) {
   }
 }
 function runGit(directory, args, timeoutMs = GIT_SNAPSHOT_TIMEOUT_MS) {
-  const result = _internals.spawnSync("git", ["-C", directory, ...args], {
+  const result = _internals.spawnSync(_internals.resolveGitExecutable(), ["-C", directory, ...args], {
     cwd: directory,
     encoding: "utf-8",
     timeout: timeoutMs,
@@ -76,7 +81,7 @@ async function runGitAsync(directory, args, timeoutMs = _internals.gitTimeoutMs)
       timeout: timeoutMs,
       killProcessTree: true
     };
-    proc = _internals.bunSpawn(["git", "-C", directory, ...args], options);
+    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), "-C", directory, ...args], options);
     let overflowed = false;
     const stopOverflow = () => {
       overflowed = true;
@@ -115,7 +120,7 @@ async function runGitAsync(directory, args, timeoutMs = _internals.gitTimeoutMs)
   }
 }
 function runGitDetailed(directory, args, timeoutMs) {
-  const result = _internals.spawnSync("git", ["-C", directory, ...args], {
+  const result = _internals.spawnSync(_internals.resolveGitExecutable(), ["-C", directory, ...args], {
     cwd: directory,
     encoding: "utf-8",
     timeout: timeoutMs,
@@ -143,7 +148,7 @@ async function runGitAsyncDetailed(directory, args, timeoutMs) {
       stderr: "pipe",
       killProcessTree: true
     };
-    proc = _internals.bunSpawn(["git", "-C", directory, ...args], options);
+    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), "-C", directory, ...args], options);
     let overflowed = false;
     const stopOverflow = () => {
       overflowed = true;
@@ -190,7 +195,7 @@ function readGitTextAtRevision(directory, revision, relativePath) {
   if (!isSafeGitRevisionToken(revision) || !/^\.?(?:[A-Za-z0-9][A-Za-z0-9._-]*\/)*[A-Za-z0-9][A-Za-z0-9._-]*$/.test(relativePath) || relativePath.split("/").includes("..")) {
     return null;
   }
-  const result = _internals.spawnSync("git", ["-C", directory, "show", `${revision}:${relativePath}`], {
+  const result = _internals.spawnSync(_internals.resolveGitExecutable(), ["-C", directory, "show", `${revision}:${relativePath}`], {
     cwd: directory,
     encoding: "utf-8",
     timeout: GIT_SNAPSHOT_TIMEOUT_MS,
@@ -1046,6 +1051,7 @@ function digest(text) {
 var _internals = {
   spawnSync: child_process.spawnSync,
   bunSpawn,
+  resolveGitExecutable,
   gitTimeoutMs: GIT_SNAPSHOT_TIMEOUT_MS,
   yieldControl: () => new Promise((resolve2) => setImmediate(resolve2)),
   parsePorcelainV2Snapshot,

package/dist/cli/{index-rn0eq85g.js → index-fv0s19g9.js}

@@ -7,7 +7,7 @@ import {
 } from "./index-ed5ykebp.js";
 import {
   bunFile
-} from "./index-4nt52yr9.js";
+} from "./index-zj6t9zgx.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";

package/dist/cli/{index-btmsqv7p.js → index-fv2pzwnp.js}

@@ -2,7 +2,7 @@
 import {
   _internals,
   resolveWorktreeIsolationConfig
-} from "./index-psvxq93b.js";
+} from "./index-1pxqkvvq.js";
 import {
   ApprovalEvidenceSchema,
   BaseEvidenceSchema,
@@ -42,7 +42,7 @@ import {
   loadPluginConfig,
   loadPluginConfigWithMeta,
   loadPluginConfigWithMetaAsync
-} from "./index-9qq7c18c.js";
+} from "./index-58cvm3dw.js";
 import {
   AUTO_REVIEW_V8_BURN_IN_DECISION,
   AgentOverrideConfigSchema,
@@ -64,8 +64,7 @@ import {
   TurboConfigSchema,
   WorktreeIsolationConfigSchema,
   resolveAutoReviewConfig
-} from "./index-y8j8ehc8.js";
-import"./index-4rhhvd1a.js";
+} from "./index-kdak6s63.js";
 import {
   ALL_AGENT_NAMES,
   ALL_SUBAGENT_NAMES,
@@ -76,6 +75,8 @@ import {
   isQAAgent,
   isSubagent
 } from "./index-v3y3qg48.js";
+import"./index-9e6fdz2h.js";
+import"./index-4rhhvd1a.js";
 import"./index-zjygnfay.js";
 import"./index-bk5tah7q.js";
 import"./index-bpmtbmy9.js";

package/dist/cli/{index-ywn7vtxp.js → index-h1p08s3n.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   atomicWriteFile
-} from "./index-mazgg5s2.js";
+} from "./index-9s8drsf9.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-bt9aa01f.js → index-hkdgkkhb.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-rn0eq85g.js";
+} from "./index-fv0s19g9.js";
 import {
   withEvidenceLock
 } from "./index-f9vvg5xb.js";