opencode-swarm 7.200.0 → 7.200.2

package/dist/cli/{index-22atsy06.js → index-sv514p10.js}

@@ -4,10 +4,15 @@ import {
   ensureTaskCheckpointReceipt,
   loadPlan,
   updateTaskCheckpointReceipt
-} from "./index-35tf03js.js";
+} from "./index-yk3b7ywa.js";
 import {
   tool
 } from "./index-9nyqt3kb.js";
+import {
+  init_executor,
+  isUntrustedEnvKey,
+  isValidEnvKey
+} from "./index-8mrentmw.js";
 import {
   GitBinaryMissingError,
   GitSpawnCwdError,
@@ -17,13 +22,13 @@ import {
 } from "./index-spggmr30.js";
 import {
   validateSwarmPath
-} from "./index-x1z5d5kj.js";
+} from "./index-xyvsdn07.js";
 import {
   readLedgerEvents
-} from "./index-7v74n9a1.js";
+} from "./index-bncex5hw.js";
 import {
   appendCoreEventSync
-} from "./index-wr0n2w3z.js";
+} from "./index-nzfq1ms2.js";
 import {
   derivePlanId,
   derivePlanIdentityHash
@@ -38,18 +43,22 @@ import {
 } from "./index-ejhxgyvm.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-q1x73nnd.js";
+} from "./index-epzadpmm.js";
 import {
   loadPluginConfigWithMeta
-} from "./index-gwc7jahh.js";
+} from "./index-pvpeggb5.js";
 import {
+  GIT_BINARY_ENV_VAR,
+  describeGitResolution,
   init_git_executable,
   resolveGitExecutable,
   resolveGitExecutableAsync
 } from "./index-sp2cxpaq.js";
 import {
   bunSpawn,
-  init_bun_compat
+  classifySpawnFailure,
+  init_bun_compat,
+  mergeEnvForChild
 } from "./index-qbxk2rn6.js";
 import {
   init_logger,
@@ -62,16 +71,675 @@ import {
 
 // src/tools/checkpoint.ts
 init_zod();
-import * as child_process from "child_process";
+import * as child_process2 from "child_process";
 import * as fs4 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 
 // src/commands/destructive-purge.ts
 import { createHash, randomBytes } from "crypto";
 import * as fs from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
+init_logger();
+
+// src/git/branch.ts
+init_executor();
+init_bun_compat();
+import * as child_process from "child_process";
+import * as fsSync from "fs";
+import path from "path";
+init_git_executable();
 init_logger();
 
+// src/utils/transient-retry.ts
+var MAX_TRANSIENT_RETRIES = 5;
+var RETRY_BASE_DELAY_MS = 200;
+function isTransientSpawnError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const code = error.code;
+  return code === "ETIMEDOUT";
+}
+function transientBackoff(attempt) {
+  const delay = RETRY_BASE_DELAY_MS * 2 ** attempt;
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
+  } catch {
+    const start = Date.now();
+    while (Date.now() - start < delay) {}
+  }
+}
+
+// src/git/safe-ref.ts
+class UnsafeGitRefError extends Error {
+  ref;
+  context;
+  constructor(ref, context) {
+    super(`Refused unsafe git ref "${ref}" at ${context}: a ref argument ` + 'starting with "-" can be parsed by git as an option (issue #2265/#2476)');
+    this.ref = ref;
+    this.context = context;
+    this.name = "UnsafeGitRefError";
+  }
+}
+function isSafeGitRefArg(value) {
+  if (value.length === 0)
+    return false;
+  for (const side of value.split("..")) {
+    if (side.startsWith("-"))
+      return false;
+  }
+  return true;
+}
+function assertSafeGitRefArg(value, context) {
+  if (!isSafeGitRefArg(value)) {
+    throw new UnsafeGitRefError(value, context);
+  }
+  return value;
+}
+
+// src/git/branch.ts
+var GIT_TIMEOUT_MS = 30000;
+var GIT_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
+var MAX_RENDERED_GIT_CANDIDATES = 10;
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function isNotGitRepositoryMessage(message) {
+  const lower = message.toLowerCase();
+  return lower.includes("not a git repository") || lower.includes("not a git repo");
+}
+function getChildProcessSpawnSync() {
+  return child_process.spawnSync;
+}
+var __spawnSyncSeam = {
+  spawnSync: (cmd, args, options) => {
+    const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
+    return getChildProcessSpawnSync()(cmd, args, {
+      ...options,
+      env: mergedEnv
+    });
+  }
+};
+function readLaneEnvFileFromDiskSync(worktreePath, laneIndex) {
+  const envPath = path.join(worktreePath, ".swarm", "lanes", `${laneIndex}.env`);
+  let content;
+  try {
+    content = fsSync.readFileSync(envPath, "utf-8");
+  } catch {
+    return {};
+  }
+  const result = {};
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const eqIdx = line.indexOf("=");
+    if (eqIdx < 0)
+      continue;
+    const k = line.slice(0, eqIdx);
+    const v = line.slice(eqIdx + 1);
+    if (!isValidEnvKey(k))
+      continue;
+    if (isUntrustedEnvKey(k))
+      continue;
+    result[k] = v;
+  }
+  return result;
+}
+function gitBinaryMissingMessage(cwd) {
+  const resolution = describeGitResolution();
+  const lines = [
+    `git executable is not available: spawning "${resolution.resolvedPath ?? "git"}" failed, and the working directory ${cwd} exists and is a directory.`
+  ];
+  if (resolution.attempts.length > 0) {
+    lines.push("Candidates tried:");
+    const shown = resolution.attempts.slice(0, MAX_RENDERED_GIT_CANDIDATES);
+    for (const attempt of shown) {
+      lines.push(`  - [${attempt.source}] ${attempt.candidate}: ${attempt.accepted ? "accepted" : attempt.reason ?? "rejected"}`);
+    }
+    const omitted = resolution.attempts.length - shown.length;
+    if (omitted > 0)
+      lines.push(`  ... and ${omitted} more`);
+  } else {
+    lines.push("No candidate probe results are recorded for this process (the resolver was pre-seeded or has not probed yet).");
+  }
+  lines.push(resolution.overrideValue ? `The configured override (${resolution.overrideSource ?? "unknown"}) "${resolution.overrideValue}" did not work \u2014 point the ${GIT_BINARY_ENV_VAR} environment variable, or the "git.binary" value in your USER config (a project .opencode config is ignored for this key), at a working git executable.` : `No override is configured. Set the ${GIT_BINARY_ENV_VAR} environment variable, or the "git.binary" value in your USER config (a project .opencode config is ignored for this key), to point at a working git executable.`);
+  return lines.join(`
+`);
+}
+function gitExec(args, cwd, laneEnv, laneIndex) {
+  const resolvedLaneEnv = laneEnv ?? (laneIndex !== undefined ? readLaneEnvFileFromDiskSync(cwd, laneIndex) : undefined);
+  const subcommand = args[0];
+  const hardenedArgs = subcommand === "commit" || subcommand === "tag" ? ["-c", "commit.gpgsign=false", "-c", "tag.gpgsign=false", ...args] : args;
+  const command = _internals.resolveGitExecutable();
+  for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
+    const result = _internals.spawnSync(command, hardenedArgs, {
+      cwd,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      windowsHide: true,
+      maxBuffer: GIT_MAX_BUFFER_BYTES,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+      envOverrides: resolvedLaneEnv
+    });
+    if (!result.error && result.status === 0) {
+      return result.stdout;
+    }
+    if (result.error) {
+      if (isSpawnCwdMissing(result.error, cwd)) {
+        throw new GitSpawnCwdError(cwd, "missing", { cause: result.error });
+      }
+      if (isSpawnCwdUnreadable(result.error, cwd)) {
+        throw new GitSpawnCwdError(cwd, "unreadable", {
+          cause: result.error
+        });
+      }
+      if (isGitBinaryMissing(result.error, cwd)) {
+        throw new GitBinaryMissingError(gitBinaryMissingMessage(cwd), {
+          cause: result.error
+        });
+      }
+      if (isTransientSpawnError(result.error) && attempt < MAX_TRANSIENT_RETRIES - 1) {
+        transientBackoff(attempt);
+        continue;
+      }
+      throw new Error(errorMessage(result.error));
+    }
+    if (result.status !== 0) {
+      throw new Error(result.stderr || result.stdout || `git exited with ${result.status}`);
+    }
+  }
+  throw new GitBinaryMissingError(process.platform === "win32" ? "git executable is not available on PATH or common Windows install locations" : "git executable is not available on PATH");
+}
+function getGitRepositoryStatus(cwd) {
+  try {
+    gitExec(["rev-parse", "--git-dir"], cwd);
+    return { isRepo: true };
+  } catch (err) {
+    if (err instanceof GitBinaryMissingError) {
+      return {
+        isRepo: false,
+        reason: "git_unavailable",
+        message: err.message
+      };
+    }
+    const message = errorMessage(err);
+    return {
+      isRepo: false,
+      reason: isNotGitRepositoryMessage(message) ? "not_git_repo" : "git_error",
+      message
+    };
+  }
+}
+function isGitRepo(cwd) {
+  return getGitRepositoryStatus(cwd).isRepo;
+}
+function getCurrentBranch(cwd, laneEnv, laneIndex) {
+  const output = gitExec(["rev-parse", "--abbrev-ref", "HEAD"], cwd, laneEnv, laneIndex);
+  return output.trim();
+}
+function getDefaultBaseBranch(cwd) {
+  try {
+    gitExec(["rev-parse", "--verify", "origin/main"], cwd);
+    return "origin/main";
+  } catch {
+    try {
+      gitExec(["rev-parse", "--verify", "origin/master"], cwd);
+      return "origin/master";
+    } catch {
+      return "origin/main";
+    }
+  }
+}
+function hasUncommittedChanges(cwd, laneEnv, laneIndex) {
+  const status = gitExec(["status", "--porcelain"], cwd, laneEnv, laneIndex);
+  return status.trim().length > 0;
+}
+function detectDefaultRemoteBranch(cwd) {
+  try {
+    const output = gitExec(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
+    const trimmed = output.trim();
+    if (trimmed.startsWith("refs/remotes/origin/")) {
+      return trimmed.slice("refs/remotes/origin/".length);
+    }
+  } catch {}
+  try {
+    const output = gitExec(["config", "init.defaultBranch"], cwd);
+    const branch = output.trim();
+    if (branch) {
+      return branch;
+    }
+  } catch {}
+  try {
+    gitExec(["rev-parse", "--verify", "origin/main"], cwd);
+    return "main";
+  } catch {}
+  try {
+    gitExec(["rev-parse", "--verify", "origin/master"], cwd);
+    return "master";
+  } catch {
+    return null;
+  }
+}
+async function resetToRemoteBranch(cwd, options) {
+  const warnings = [];
+  const prunedBranches = [];
+  try {
+    const currentBranch = getCurrentBranch(cwd);
+    const defaultRemoteBranch = _internals.detectDefaultRemoteBranch(cwd);
+    if (!defaultRemoteBranch) {
+      return {
+        success: false,
+        targetBranch: "",
+        localBranch: currentBranch,
+        message: "Could not detect default remote branch",
+        alreadyAligned: false,
+        prunedBranches: [],
+        warnings: []
+      };
+    }
+    assertSafeGitRefArg(currentBranch, "resetToRemoteBranch currentBranch");
+    assertSafeGitRefArg(defaultRemoteBranch, "resetToRemoteBranch defaultRemoteBranch");
+    const targetBranch = `origin/${defaultRemoteBranch}`;
+    if (currentBranch === "HEAD") {
+      return {
+        success: false,
+        targetBranch,
+        localBranch: "HEAD",
+        message: "Cannot reset: detached HEAD state",
+        alreadyAligned: false,
+        prunedBranches: [],
+        warnings: []
+      };
+    }
+    if (hasUncommittedChanges(cwd)) {
+      return {
+        success: false,
+        targetBranch,
+        localBranch: currentBranch,
+        message: "Cannot reset: uncommitted changes in working tree",
+        alreadyAligned: false,
+        prunedBranches: [],
+        warnings: []
+      };
+    }
+    try {
+      const logOutput = gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
+      if (logOutput.trim().length > 0) {
+        return {
+          success: false,
+          targetBranch,
+          localBranch: currentBranch,
+          message: "Cannot reset: unpushed commits",
+          alreadyAligned: false,
+          prunedBranches: [],
+          warnings: []
+        };
+      }
+    } catch {}
+    try {
+      gitExec(["fetch", "--prune", "origin"], cwd);
+    } catch (err) {
+      return {
+        success: false,
+        targetBranch,
+        localBranch: currentBranch,
+        message: `Fetch failed: ${err instanceof Error ? err.message : String(err)}`,
+        alreadyAligned: false,
+        prunedBranches: [],
+        warnings: []
+      };
+    }
+    const headSha = gitExec(["rev-parse", "HEAD"], cwd).trim();
+    const remoteSha = gitExec(["rev-parse", `${targetBranch}`], cwd).trim();
+    if (headSha === remoteSha) {
+      return {
+        success: true,
+        targetBranch,
+        localBranch: currentBranch,
+        message: "Already aligned with remote",
+        alreadyAligned: true,
+        prunedBranches: [],
+        warnings: []
+      };
+    }
+    try {
+      gitExec(["checkout", currentBranch], cwd);
+    } catch (err) {
+      return {
+        success: false,
+        targetBranch,
+        localBranch: currentBranch,
+        message: `Checkout failed: ${err instanceof Error ? err.message : String(err)}`,
+        alreadyAligned: false,
+        prunedBranches: [],
+        warnings: []
+      };
+    }
+    let resetSucceeded = false;
+    let lastError;
+    for (let retry = 0;retry < 4; retry++) {
+      if (retry > 0 && process.platform === "win32") {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+      try {
+        gitExec(["reset", "--hard", targetBranch], cwd);
+        resetSucceeded = true;
+        break;
+      } catch (err) {
+        lastError = err;
+      }
+    }
+    if (!resetSucceeded) {
+      return {
+        success: false,
+        targetBranch,
+        localBranch: currentBranch,
+        message: `Reset failed: ${lastError instanceof Error ? lastError.message : String(lastError)}`,
+        alreadyAligned: false,
+        prunedBranches: [],
+        warnings: []
+      };
+    }
+    if (options?.pruneBranches) {
+      try {
+        const mergedOutput = gitExec(["branch", "--merged", targetBranch], cwd);
+        const mergedLines = mergedOutput.split(`
+`);
+        for (const line of mergedLines) {
+          const trimmedLine = line.trim();
+          if (!trimmedLine || trimmedLine.startsWith("*")) {
+            continue;
+          }
+          try {
+            gitExec([
+              "branch",
+              "-d",
+              "--",
+              assertSafeGitRefArg(trimmedLine, "resetToRemoteBranch prune merged branch")
+            ], cwd);
+            prunedBranches.push(trimmedLine);
+          } catch {
+            warnings.push(`Could not safely delete branch: ${trimmedLine}`);
+          }
+        }
+      } catch (err) {
+        warnings.push(`Failed to get merged branches: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        const branchVvOutput = gitExec(["branch", "-vv"], cwd);
+        const vvLines = branchVvOutput.split(`
+`);
+        for (const line of vvLines) {
+          const trimmedLine = line.trim();
+          if (!trimmedLine || trimmedLine.startsWith("*")) {
+            continue;
+          }
+          if (trimmedLine.includes(": gone]")) {
+            const parts = trimmedLine.split(/\s+/);
+            const branchName = parts[0];
+            try {
+              gitExec([
+                "branch",
+                "-d",
+                "--",
+                assertSafeGitRefArg(branchName, "resetToRemoteBranch prune gone branch")
+              ], cwd);
+              prunedBranches.push(branchName);
+            } catch {
+              warnings.push(`Could not delete gone branch: ${branchName}`);
+            }
+          }
+        }
+      } catch (err) {
+        warnings.push(`Failed to prune gone branches: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return {
+      success: true,
+      targetBranch,
+      localBranch: currentBranch,
+      message: "Successfully reset to remote branch",
+      alreadyAligned: false,
+      prunedBranches,
+      warnings
+    };
+  } catch (err) {
+    return {
+      success: false,
+      targetBranch: "",
+      localBranch: "",
+      message: `Unexpected error: ${err instanceof Error ? err.message : String(err)}`,
+      alreadyAligned: false,
+      prunedBranches: [],
+      warnings: []
+    };
+  }
+}
+var GITIGNORED_BUILD_ARTIFACTS = ["dist"];
+async function resetToMainAfterMerge(cwd, options) {
+  const warnings = [];
+  try {
+    const defaultBranch = _internals.detectDefaultRemoteBranch(cwd);
+    if (!defaultBranch) {
+      return {
+        success: false,
+        targetBranch: "",
+        previousBranch: "",
+        message: "Could not detect default remote branch",
+        branchDeleted: false,
+        changesDiscarded: false,
+        warnings
+      };
+    }
+    const currentBranch = getCurrentBranch(cwd);
+    assertSafeGitRefArg(currentBranch, "resetToMainAfterMerge currentBranch");
+    assertSafeGitRefArg(defaultBranch, "resetToMainAfterMerge defaultBranch");
+    const targetBranch = `origin/${defaultBranch}`;
+    if (currentBranch === "HEAD") {
+      return {
+        success: false,
+        targetBranch,
+        previousBranch: "HEAD",
+        message: "Cannot reset: detached HEAD state",
+        branchDeleted: false,
+        changesDiscarded: false,
+        warnings
+      };
+    }
+    if (currentBranch === defaultBranch) {
+      try {
+        const logOutput = _internals.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
+        if (logOutput.trim().length > 0) {
+          return {
+            success: false,
+            targetBranch,
+            previousBranch: currentBranch,
+            message: `Cannot reset: ${defaultBranch} has unpushed commits. Push them first.`,
+            branchDeleted: false,
+            changesDiscarded: false,
+            warnings
+          };
+        }
+      } catch {}
+    } else {
+      try {
+        _internals.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
+      } catch {
+        try {
+          const localSha = _internals.gitExec(["rev-parse", "HEAD"], cwd).trim();
+          const remoteSha = _internals.gitExec(["rev-parse", targetBranch], cwd).trim();
+          if (localSha !== remoteSha) {
+            return {
+              success: false,
+              targetBranch,
+              previousBranch: currentBranch,
+              message: `Cannot reset: branch ${currentBranch} is local-only and diverges from ${defaultBranch}. Push or check manually.`,
+              branchDeleted: false,
+              changesDiscarded: false,
+              warnings
+            };
+          }
+        } catch {
+          return {
+            success: false,
+            targetBranch,
+            previousBranch: currentBranch,
+            message: `Cannot reset: unable to compare ${currentBranch} with ${defaultBranch}`,
+            branchDeleted: false,
+            changesDiscarded: false,
+            warnings
+          };
+        }
+      }
+    }
+    try {
+      _internals.gitExec(["fetch", "--prune", "origin"], cwd);
+    } catch (err) {
+      return {
+        success: false,
+        targetBranch,
+        previousBranch: currentBranch,
+        message: `Cannot reset: fetch failed \u2014 ${err instanceof Error ? err.message : String(err)}`,
+        branchDeleted: false,
+        changesDiscarded: false,
+        warnings
+      };
+    }
+    const previousBranch = currentBranch;
+    let switchedBranch = false;
+    if (currentBranch !== defaultBranch) {
+      try {
+        _internals.gitExec(["checkout", defaultBranch], cwd);
+        switchedBranch = true;
+      } catch (err) {
+        return {
+          success: false,
+          targetBranch,
+          previousBranch,
+          message: `Checkout to ${defaultBranch} failed: ${err instanceof Error ? err.message : String(err)}`,
+          branchDeleted: false,
+          changesDiscarded: false,
+          warnings
+        };
+      }
+    }
+    try {
+      _internals.gitExec(["reset", "--hard", targetBranch], cwd);
+    } catch (err) {
+      return {
+        success: false,
+        targetBranch,
+        previousBranch,
+        message: `Reset to ${targetBranch} failed: ${err instanceof Error ? err.message : String(err)}`,
+        branchDeleted: false,
+        changesDiscarded: false,
+        warnings
+      };
+    }
+    let changesDiscarded = false;
+    if (hasUncommittedChanges(cwd)) {
+      let discardSucceeded = false;
+      for (let retry = 0;retry < 4; retry++) {
+        if (retry > 0 && process.platform === "win32") {
+          await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+        try {
+          _internals.gitExec(["checkout", "--", "."], cwd);
+          discardSucceeded = true;
+          break;
+        } catch {}
+      }
+      if (!discardSucceeded) {
+        warnings.push("Could not discard all uncommitted changes after reset");
+      }
+      changesDiscarded = discardSucceeded;
+    }
+    try {
+      _internals.gitExec(["clean", "-fdX", "--", ...GITIGNORED_BUILD_ARTIFACTS], cwd);
+    } catch {
+      warnings.push("Could not clean build artifacts");
+    }
+    let branchDeleted = false;
+    if (switchedBranch && previousBranch !== defaultBranch) {
+      try {
+        const mergedOutput = _internals.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const isMerged = mergedOutput.split(`
+`).some((line) => line.trim() === previousBranch || line.trim() === `* ${previousBranch}`);
+        if (isMerged) {
+          _internals.gitExec([
+            "branch",
+            "-d",
+            "--",
+            assertSafeGitRefArg(previousBranch, "resetToMainAfterMerge previousBranch")
+          ], cwd);
+          branchDeleted = true;
+        } else {
+          warnings.push(`Branch ${previousBranch} is not merged into ${defaultBranch} \u2014 keeping it`);
+        }
+      } catch {
+        warnings.push(`Could not delete branch ${previousBranch}`);
+      }
+    }
+    if (options?.pruneBranches) {
+      try {
+        const mergedOutput = _internals.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const mergedLines = mergedOutput.split(`
+`);
+        for (const line of mergedLines) {
+          const trimmedLine = line.trim();
+          if (!trimmedLine || trimmedLine.startsWith("*") || trimmedLine === defaultBranch) {
+            continue;
+          }
+          try {
+            _internals.gitExec([
+              "branch",
+              "-d",
+              "--",
+              assertSafeGitRefArg(trimmedLine, "resetToMainAfterMerge prune branch")
+            ], cwd);
+          } catch {
+            warnings.push(`Could not prune branch: ${trimmedLine}`);
+          }
+        }
+      } catch (err) {
+        warnings.push(`Prune failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return {
+      success: true,
+      targetBranch,
+      previousBranch,
+      message: branchDeleted ? `Reset to ${defaultBranch} and deleted branch ${previousBranch}` : `Reset to ${defaultBranch}`,
+      branchDeleted,
+      changesDiscarded,
+      warnings
+    };
+  } catch (err) {
+    return {
+      success: false,
+      targetBranch: "",
+      previousBranch: "",
+      message: `Unexpected error: ${err instanceof Error ? err.message : String(err)}`,
+      branchDeleted: false,
+      changesDiscarded: false,
+      warnings
+    };
+  }
+}
+var _internals = {
+  gitExec,
+  detectDefaultRemoteBranch,
+  getDefaultBaseBranch,
+  getGitRepositoryStatus,
+  resetToRemoteBranch,
+  resetToMainAfterMerge,
+  spawnSync: __spawnSyncSeam.spawnSync,
+  readLaneEnvFileFromDiskSync,
+  resolveGitExecutable
+};
+
 // src/commands/git-status-read.ts
 init_bun_compat();
 init_git_executable();
@@ -269,10 +937,59 @@ async function readGitRepositoryStatusAsync(cwd) {
   const result = await gitStatusReadInternals.readOnce(["rev-parse", "--git-dir"], cwd, GIT_READ_DEFAULT_TIMEOUT_MS);
   return result.ok;
 }
+async function readGitRepositoryStatusDetailedAsync(cwd) {
+  const result = await gitStatusReadInternals.readOnce(["rev-parse", "--git-dir"], cwd, GIT_READ_DEFAULT_TIMEOUT_MS);
+  if (result.ok)
+    return { isRepo: true };
+  if (result.code === "ENOENT") {
+    const failureClass = classifySpawnFailure({ code: result.code }, cwd);
+    if (failureClass === "cwd-missing") {
+      return {
+        isRepo: false,
+        reason: "git_error",
+        message: `git spawn cwd is missing: ${cwd} (ENOENT)`
+      };
+    }
+    if (failureClass === "cwd-unreadable") {
+      return {
+        isRepo: false,
+        reason: "git_error",
+        message: `git spawn cwd could not be inspected: ${cwd} (ENOENT)`
+      };
+    }
+    return {
+      isRepo: false,
+      reason: "git_unavailable",
+      message: gitBinaryMissingMessage(cwd)
+    };
+  }
+  if (result.code === null) {
+    const stderrTail2 = result.stderrTail ?? "";
+    if (isNotGitRepositoryMessage(stderrTail2)) {
+      return {
+        isRepo: false,
+        reason: "not_git_repo",
+        message: stderrTail2 || `rev-parse exited ${result.status}`
+      };
+    }
+    const exitNote = result.status === null ? "rev-parse failed (no exit status reported)" : `rev-parse exited ${result.status}`;
+    return {
+      isRepo: false,
+      reason: "git_error",
+      message: `${exitNote}${stderrTail2 ? `: ${stderrTail2}` : ""}`
+    };
+  }
+  const tail = result.stderrTail ?? "";
+  return {
+    isRepo: false,
+    reason: "git_error",
+    message: `git read failed (${result.code})${tail ? `: ${tail}` : ""}`
+  };
+}
 
 // src/commands/rollback-gate.ts
-import * as fsSync from "fs";
-import * as path from "path";
+import * as fsSync2 from "fs";
+import * as path2 from "path";
 var ROLLBACK_GIT_KIND = "swarm-rollback-git";
 var ROLLBACK_PHASE_KIND = "swarm-rollback-phase";
 var GIT_LIST_MAX_BUFFER_BYTES = 32 * 1024 * 1024;
@@ -304,15 +1021,29 @@ async function readFailureDetail(raw) {
 }
 function isRealGitRepository(directory) {
   try {
-    if (fsSync.statSync(path.join(directory, ".git")).isFile())
+    if (fsSync2.statSync(path2.join(directory, ".git")).isFile())
       return true;
   } catch {
     return false;
   }
-  return fsSync.existsSync(path.join(directory, ".git", "HEAD"));
+  return fsSync2.existsSync(path2.join(directory, ".git", "HEAD"));
+}
+function isOutOfRootRelativePath(rel) {
+  if (rel === "")
+    return false;
+  const normalized = path2.posix.normalize(rel);
+  return normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/");
 }
-function parseTrackedDirtyPaths(statusOutput) {
+function parseTrackedDirtyPathsWithExclusions(statusOutput) {
   const dirtyPaths = [];
+  const excludedOutOfRoot = [];
+  const push = (candidate) => {
+    if (isOutOfRootRelativePath(candidate)) {
+      excludedOutOfRoot.push(candidate);
+      return;
+    }
+    dirtyPaths.push(candidate);
+  };
   const tokens = statusOutput.split("\x00");
   for (let i = 0;i < tokens.length; i += 1) {
     const token = tokens[i];
@@ -324,44 +1055,83 @@ function parseTrackedDirtyPaths(statusOutput) {
     const filePath = token.slice(3);
     if (!filePath)
       continue;
-    dirtyPaths.push(filePath);
+    push(filePath);
     if (/[RC]/.test(xy) && i + 1 < tokens.length && tokens[i + 1] !== "") {
-      dirtyPaths.push(tokens[i + 1]);
+      push(tokens[i + 1]);
       i += 1;
     }
   }
-  return dirtyPaths;
+  return { dirtyPaths, excludedOutOfRoot };
 }
 async function untrackedPathsInTargetTree(directory, targetSha) {
-  if (!isRealGitRepository(directory))
-    return [];
-  const targetTree = await readToString(await _rollbackGateInternals.runGitBuffered(["ls-tree", "-r", "-z", "--name-only", targetSha], directory));
-  const index = await readToString(await _rollbackGateInternals.runGitBuffered(["ls-files", "-z"], directory));
-  if (targetTree === null || index === null)
-    return [];
+  if (!isRealGitRepository(directory)) {
+    return { paths: [], failure: null };
+  }
+  const targetTreeRaw = await _rollbackGateInternals.runGitBuffered(["ls-tree", "-r", "-z", "--name-only", targetSha], directory);
+  const targetTree = await readToString(targetTreeRaw);
+  if (targetTree === null) {
+    const detail = await readFailureDetail(targetTreeRaw);
+    return {
+      paths: [],
+      failure: detail ?? { code: null, status: null, stderrTail: "" }
+    };
+  }
+  const indexRaw = await _rollbackGateInternals.runGitBuffered(["ls-files", "-z"], directory);
+  const index = await readToString(indexRaw);
+  if (index === null) {
+    const detail = await readFailureDetail(indexRaw);
+    return {
+      paths: [],
+      failure: detail ?? { code: null, status: null, stderrTail: "" }
+    };
+  }
   const indexed = new Set(index.split("\x00").filter((p) => p !== ""));
   const inWay = [];
   for (const rel of targetTree.split("\x00")) {
     if (rel === "" || indexed.has(rel))
       continue;
-    if (fsSync.existsSync(path.join(directory, rel)))
+    if (fsSync2.existsSync(path2.join(directory, rel)))
       inWay.push(rel);
   }
-  return inWay;
+  return { paths: inWay, failure: null };
 }
 function trackedDirtyCandidates(directory, dirtyRelPaths) {
   return dirtyRelPaths.map((rel) => ({
-    path: path.join(directory, rel),
+    path: path2.join(directory, rel),
     reason: "uncommitted tracked change \u2014 destroyed by git reset --hard"
   }));
 }
 function swarmOverwriteCandidates(directory, overwriteRelPaths) {
   return overwriteRelPaths.map((rel) => ({
-    path: path.join(directory, ".swarm", rel),
+    path: path2.join(directory, ".swarm", rel),
     reason: "live .swarm state replaced by the checkpoint copy"
   }));
 }
-function describeUnreadableCause(measurement) {
+function describeUnreadableCause(measurement, source = "status") {
+  if (source === "status") {
+    return describeUnreadableStatusCause(measurement);
+  }
+  if (measurement.code === "ETIMEDOUT") {
+    return "the target-tree listing read timed out (ETIMEDOUT) \u2014 the host may be unable to complete child spawns while loaded; restart the host and retry";
+  }
+  if (measurement.code === "EOUTPUT") {
+    return `the listing output exceeded the read safety bound (${measurement.stderrTail ?? "output too large"}) \u2014 reduce the change footprint (commit or stash some work, or remove untracked bulk) and retry`;
+  }
+  if (measurement.code === "ESIGNAL") {
+    return "the target-tree listing process was terminated before it answered (signal) \u2014 something external stopped it; retry, and inspect what terminates child processes if it recurs";
+  }
+  if (measurement.code === "ENOENT") {
+    return "the git executable was not found (ENOENT) \u2014 install git on PATH, or set git.binary in your USER-level config, and retry";
+  }
+  if (measurement.status !== null && measurement.status !== undefined) {
+    return `the target-tree listing exited with status ${measurement.status}${measurement.stderrTail ? `: ${measurement.stderrTail}` : ""} \u2014 repair the repository state and retry`;
+  }
+  if (measurement.code) {
+    return `the listing read failed with code ${measurement.code} \u2014 retry, or inspect the repository state manually`;
+  }
+  return "retry, or inspect the repository state manually";
+}
+function describeUnreadableStatusCause(measurement) {
   if (measurement.code === "ETIMEDOUT") {
     return "the read timed out (ETIMEDOUT) \u2014 the host may be unable to complete child spawns while loaded; restart the host and retry";
   }
@@ -382,9 +1152,13 @@ function describeUnreadableCause(measurement) {
   }
   return "retry, or inspect git status manually";
 }
+function formatExcludedRecord(rel) {
+  const sanitized = rel.replace(/[\x00-\x1f\x7f]+/g, " ").trim();
+  return sanitized.length > 200 ? `${sanitized.slice(0, 200)}\u2026` : sanitized;
+}
 async function measureGitDestruction(directory, targetSha) {
   if (!isRealGitRepository(directory)) {
-    return { kind: "ok", dirtyRelPaths: [] };
+    return { kind: "ok", dirtyRelPaths: [], excludedOutOfRoot: [] };
   }
   const raw = _rollbackGateInternals.runGit(["--no-optional-locks", "status", "--porcelain", "-z"], directory);
   const status = await readToString(raw);
@@ -394,23 +1168,35 @@ async function measureGitDestruction(directory, targetSha) {
       kind: "unreadable",
       code: failure.code,
       status: failure.status,
-      stderrTail: failure.stderrTail
-    } : { kind: "unreadable" };
+      stderrTail: failure.stderrTail,
+      source: "status"
+    } : { kind: "unreadable", source: "status" };
   }
-  const dirtyRelPaths = parseTrackedDirtyPaths(status);
+  const { dirtyPaths: dirtyRelPaths, excludedOutOfRoot } = parseTrackedDirtyPathsWithExclusions(status);
   if (targetSha) {
-    for (const rel of await untrackedPathsInTargetTree(directory, targetSha)) {
+    const { paths, failure } = await untrackedPathsInTargetTree(directory, targetSha);
+    if (failure) {
+      return {
+        kind: "unreadable",
+        code: failure.code,
+        status: failure.status,
+        stderrTail: failure.stderrTail,
+        source: "enumeration",
+        excludedOutOfRoot
+      };
+    }
+    for (const rel of paths) {
       if (!dirtyRelPaths.includes(rel))
         dirtyRelPaths.push(rel);
     }
   }
-  return { kind: "ok", dirtyRelPaths };
+  return { kind: "ok", dirtyRelPaths, excludedOutOfRoot };
 }
 
 // src/commands/destructive-purge.ts
 var PENDING_PURGE_PATH = "pending-purge.json";
 var PENDING_PURGE_TTL_MS = 15 * 60 * 1000;
-var _internals = {
+var _internals2 = {
   readFileSync: fs.readFileSync,
   rmSync: fs.rmSync.bind(fs),
   existsSync: fs.existsSync.bind(fs),
@@ -426,7 +1212,7 @@ var GIT_STATUS_ARGS = [
   "--porcelain"
 ];
 async function runGitStatusRead(args, cwd) {
-  const raw = await _internals.runGitStatus(args, cwd);
+  const raw = await _internals2.runGitStatus(args, cwd);
   if (typeof raw === "string")
     return { stdout: raw };
   if (raw === null)
@@ -437,8 +1223,16 @@ async function runGitStatusRead(args, cwd) {
     cause: { code: raw.code, status: raw.status, stderrTail: raw.stderrTail }
   };
 }
-function parseTrackedDirtyPaths2(statusOutput) {
+function parseTrackedDirtyPathsWithExclusions2(statusOutput) {
   const dirtyPaths = [];
+  const excludedOutOfRoot = [];
+  const push = (candidate) => {
+    if (isOutOfRootRelativePath(candidate)) {
+      excludedOutOfRoot.push(candidate);
+      return;
+    }
+    dirtyPaths.push(candidate);
+  };
   for (const line of statusOutput.split(`
 `)) {
     if (!line)
@@ -452,13 +1246,13 @@ function parseTrackedDirtyPaths2(statusOutput) {
       for (const side of filePath.split(" -> ")) {
         const cleaned = side.trim().replace(/^"|"$/g, "");
         if (cleaned)
-          dirtyPaths.push(cleaned);
+          push(cleaned);
       }
     } else {
-      dirtyPaths.push(filePath);
+      push(filePath);
     }
   }
-  return dirtyPaths;
+  return { dirtyPaths, excludedOutOfRoot };
 }
 async function readTrackedDirtyPaths(directory) {
   const read = await runGitStatusRead(GIT_STATUS_ARGS, directory);
@@ -466,7 +1260,8 @@ async function readTrackedDirtyPaths(directory) {
     return { ok: false };
   if ("cause" in read)
     return { ok: false, failure: read.cause };
-  return { ok: true, dirtyPaths: parseTrackedDirtyPaths2(read.stdout) };
+  const { dirtyPaths, excludedOutOfRoot } = parseTrackedDirtyPathsWithExclusions2(read.stdout);
+  return { ok: true, dirtyPaths, excludedOutOfRoot };
 }
 async function recheckBeforeDestructive(directory, expectedDirtyPaths) {
   const read = await readTrackedDirtyPaths(directory);
@@ -502,7 +1297,7 @@ function resolveCandidates(scopeTarget, extra) {
 }
 function scopeDigest(kind, candidates) {
   const paths = candidates.map((c) => {
-    const resolved = path2.resolve(c.path);
+    const resolved = path3.resolve(c.path);
     if (resolved.includes("\x00") || resolved.includes(`
 `)) {
       throw new Error(`Purge candidate path contains a NUL or newline separator character and cannot be scope-bound: ${JSON.stringify(resolved)}`);
@@ -514,20 +1309,20 @@ function scopeDigest(kind, candidates) {
   return createHash("sha256").update(`${kind}\x00${sorted}`).digest("hex");
 }
 function mintToken(digest) {
-  return createHash("sha256").update(`${digest}:${_internals.randomBytes(16).toString("hex")}`).digest("hex").slice(0, 24);
+  return createHash("sha256").update(`${digest}:${_internals2.randomBytes(16).toString("hex")}`).digest("hex").slice(0, 24);
 }
 function readPending(directory) {
   try {
-    const raw = _internals.readFileSync(pendingPath(directory), "utf-8");
+    const raw = _internals2.readFileSync(pendingPath(directory), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.schemaVersion !== 1 || typeof parsed.scopeDigest !== "string" || typeof parsed.confirmToken !== "string" || typeof parsed.createdAt !== "number") {
       return null;
     }
     if (!Number.isFinite(parsed.createdAt))
       return null;
-    if (parsed.createdAt > _internals.now() + 60000)
+    if (parsed.createdAt > _internals2.now() + 60000)
       return null;
-    if (_internals.now() - parsed.createdAt > PENDING_PURGE_TTL_MS) {
+    if (_internals2.now() - parsed.createdAt > PENDING_PURGE_TTL_MS) {
       return null;
     }
     return {
@@ -541,7 +1336,7 @@ function readPending(directory) {
   }
 }
 function writePending(directory, record) {
-  _internals.atomicWriteSwarmFileSync(pendingPath(directory), JSON.stringify(record, null, 2));
+  _internals2.atomicWriteSwarmFileSync(pendingPath(directory), JSON.stringify(record, null, 2));
 }
 function previewDestructivePurge(scopeTarget, projectRoot, extra) {
   const scope = resolveCandidates(scopeTarget, extra);
@@ -566,7 +1361,7 @@ function issueConfirmToken(scopeTarget, projectRoot, extra) {
     schemaVersion: 1,
     scopeDigest: digest,
     confirmToken: token,
-    createdAt: _internals.now()
+    createdAt: _internals2.now()
   });
   return token;
 }
@@ -575,7 +1370,7 @@ function consumeConfirmToken(scopeTarget, projectRoot, token, extra) {
   if (!verdict.ok)
     return verdict;
   try {
-    _internals.rmSync(pendingPath(projectRoot), { force: true });
+    _internals2.rmSync(pendingPath(projectRoot), { force: true });
   } catch (error) {
     log(`[destructive-purge] could not consume pending record: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -609,14 +1404,14 @@ function executeDestructivePurge(scopeTarget, projectRoot, token, extra) {
   const { candidates } = resolveCandidates(scopeTarget, extra);
   const purged = [];
   for (const candidate of candidates) {
-    if (!_internals.existsSync(candidate.path))
+    if (!_internals2.existsSync(candidate.path))
       continue;
     try {
-      _internals.rmSync(candidate.path, { recursive: true, force: true });
+      _internals2.rmSync(candidate.path, { recursive: true, force: true });
       purged.push(candidate.path);
     } catch (error) {
       try {
-        _internals.rmSync(pendingPath(projectRoot), { force: true });
+        _internals2.rmSync(pendingPath(projectRoot), { force: true });
       } catch {}
       return {
         ok: false,
@@ -625,7 +1420,7 @@ function executeDestructivePurge(scopeTarget, projectRoot, token, extra) {
     }
   }
   try {
-    _internals.rmSync(pendingPath(projectRoot), { force: true });
+    _internals2.rmSync(pendingPath(projectRoot), { force: true });
   } catch (error) {
     log(`[destructive-purge] could not consume pending record: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -634,12 +1429,12 @@ function executeDestructivePurge(scopeTarget, projectRoot, token, extra) {
 
 // src/commands/reset-backup.ts
 import * as fs2 from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 var RESET_BACKUP_RETENTION = 5;
 function backupSwarmStateBeforeReset(directory, kind, relEntries, opts) {
   const warnings = [];
   const copied = [];
-  const swarmDir = path3.join(directory, ".swarm");
+  const swarmDir = path4.join(directory, ".swarm");
   try {
     const stat = fs2.lstatSync(swarmDir);
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
@@ -651,8 +1446,8 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries, opts) {
     return { backupDir: null, copied, warnings };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupsRoot = path3.join(swarmDir, opts?.backupsRoot ?? "reset-backups");
-  const backupDir = path3.join(backupsRoot, `${kind}-${timestamp}`);
+  const backupsRoot = path4.join(swarmDir, opts?.backupsRoot ?? "reset-backups");
+  const backupDir = path4.join(backupsRoot, `${kind}-${timestamp}`);
   let backupDirCreated = false;
   const ensureBackupDir = () => {
     if (!backupDirCreated) {
@@ -672,8 +1467,8 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries, opts) {
       continue;
     try {
       ensureBackupDir();
-      const dest = path3.join(backupDir, rel);
-      fs2.mkdirSync(path3.dirname(dest), { recursive: true });
+      const dest = path4.join(backupDir, rel);
+      fs2.mkdirSync(path4.dirname(dest), { recursive: true });
       fs2.cpSync(src, dest, { recursive: true });
       copied.push(rel);
     } catch (err) {
@@ -688,7 +1483,7 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries, opts) {
     }
     return { backupDir: null, copied, warnings };
   }
-  pruneOldResetBackups(backupsRoot, warnings, path3.basename(backupDir));
+  pruneOldResetBackups(backupsRoot, warnings, path4.basename(backupDir));
   return { backupDir, copied, warnings };
 }
 var BACKUP_KIND_PREFIXES = [
@@ -712,7 +1507,7 @@ function pruneOldResetBackups(backupsRoot, warnings, keepDirName) {
       if (stale.name === keepDirName)
         continue;
       try {
-        fs2.rmSync(path3.join(backupsRoot, stale.name), {
+        fs2.rmSync(path4.join(backupsRoot, stale.name), {
           recursive: true,
           force: true
         });
@@ -727,7 +1522,7 @@ function pruneOldResetBackups(backupsRoot, warnings, keepDirName) {
 function backupTrackedChangesBeforeRollback(directory, repoRelPaths) {
   const warnings = [];
   const copied = [];
-  const swarmDir = path3.join(directory, ".swarm");
+  const swarmDir = path4.join(directory, ".swarm");
   try {
     const stat = fs2.lstatSync(swarmDir);
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
@@ -739,8 +1534,8 @@ function backupTrackedChangesBeforeRollback(directory, repoRelPaths) {
     return { backupDir: null, copied, warnings };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupsRoot = path3.join(swarmDir, "rollback-backups");
-  const backupDir = path3.join(backupsRoot, `rollback-git-${timestamp}`);
+  const backupsRoot = path4.join(swarmDir, "rollback-backups");
+  const backupDir = path4.join(backupsRoot, `rollback-git-${timestamp}`);
   let backupDirCreated = false;
   const ensureBackupDir = () => {
     if (!backupDirCreated) {
@@ -751,13 +1546,13 @@ function backupTrackedChangesBeforeRollback(directory, repoRelPaths) {
   for (const rel of repoRelPaths) {
     if (!rel)
       continue;
-    const src = path3.join(directory, rel);
+    const src = path4.join(directory, rel);
     if (!fs2.existsSync(src))
       continue;
     try {
       ensureBackupDir();
-      const dest = path3.join(backupDir, "tracked", rel);
-      fs2.mkdirSync(path3.dirname(dest), { recursive: true });
+      const dest = path4.join(backupDir, "tracked", rel);
+      fs2.mkdirSync(path4.dirname(dest), { recursive: true });
       fs2.cpSync(src, dest, { recursive: true });
       copied.push(rel);
     } catch (err) {
@@ -772,38 +1567,19 @@ function backupTrackedChangesBeforeRollback(directory, repoRelPaths) {
     }
     return { backupDir: null, copied, warnings };
   }
-  pruneOldResetBackups(backupsRoot, warnings, path3.basename(backupDir));
+  pruneOldResetBackups(backupsRoot, warnings, path4.basename(backupDir));
   return { backupDir, copied, warnings };
 }
 
 // src/tools/checkpoint.ts
 init_git_executable();
 
-// src/utils/transient-retry.ts
-var MAX_TRANSIENT_RETRIES = 5;
-var RETRY_BASE_DELAY_MS = 200;
-function isTransientSpawnError(error) {
-  if (!error || typeof error !== "object")
-    return false;
-  const code = error.code;
-  return code === "ETIMEDOUT";
-}
-function transientBackoff(attempt) {
-  const delay = RETRY_BASE_DELAY_MS * 2 ** attempt;
-  try {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
-  } catch {
-    const start = Date.now();
-    while (Date.now() - start < delay) {}
-  }
-}
-
 // src/tools/create-tool.ts
 init_zod();
 
 // src/tools/resolve-working-directory.ts
 import * as fs3 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -848,8 +1624,8 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path4.normalize(workingDirectory);
-  const resolvedDir = path4.resolve(normalizedDir);
+  const normalizedDir = path5.normalize(workingDirectory);
+  const resolvedDir = path5.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs3.statSync(resolvedDir);
@@ -876,7 +1652,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path4.resolve(fallbackDirectory);
+  const resolvedFallback = path5.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs3.statSync(resolvedFallback);
@@ -966,8 +1742,8 @@ var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json";
 var PLAN_LOCK_PATH = "plan.json";
 var CHECKPOINT_AGENT_NAME = "checkpoint";
 var MAX_LABEL_LENGTH = 100;
-var GIT_TIMEOUT_MS = 30000;
-var GIT_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
+var GIT_TIMEOUT_MS2 = 30000;
+var GIT_MAX_BUFFER_BYTES2 = 5 * 1024 * 1024;
 var CHECKPOINT_LOCK_MAX_ATTEMPTS = 20;
 var CHECKPOINT_LOCK_DELAY_MS = 250;
 var CHECKPOINT_LOCK_DEADLINE_MS = 45000;
@@ -981,14 +1757,17 @@ var SHELL_METACHARACTERS = /[;|&$`(){}<>!'"]/;
 var SAFE_LABEL_PATTERN = /^[a-zA-Z0-9_ -]+$/;
 var CONTROL_CHAR_PATTERN = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/;
 var NON_ASCII_PATTERN = /[^\x20-\x7E]/;
-var _internals2 = {
+var _internals3 = {
   tryAcquireLock,
   loadPlan,
-  gitExec,
+  gitExec: gitExec2,
   sleep: (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)),
   findCommitByExactSubject,
   stageAllExcludingSwarm,
-  resolveGitExecutable
+  resolveGitExecutable,
+  measureGitDestruction,
+  readGitStatusAsync,
+  readGitRepositoryStatusDetailedAsync
 };
 function serializeResult(action, payload) {
   return JSON.stringify({
@@ -1039,7 +1818,7 @@ function validateLabel(label) {
   return null;
 }
 function getCheckpointLogPath(directory) {
-  return path5.join(directory, CHECKPOINT_LOG_PATH);
+  return path6.join(directory, CHECKPOINT_LOG_PATH);
 }
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
@@ -1057,7 +1836,7 @@ function readCheckpointLog(directory) {
 }
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
-  const dir = path5.dirname(logPath);
+  const dir = path6.dirname(logPath);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
@@ -1124,17 +1903,17 @@ function upsertTaskCompletionCheckpointEntry(directory, log2, entry, maxCheckpoi
   }
 }
 function stageAllExcludingSwarm(directory) {
-  _internals2.gitExec(["add", "--all", "--", ...NON_SWARM_COMMIT_PATHSPEC], directory);
+  _internals3.gitExec(["add", "--all", "--", ...NON_SWARM_COMMIT_PATHSPEC], directory);
 }
-function gitExec(args, cwd) {
+function gitExec2(args, cwd) {
   for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
-    const result = child_process.spawnSync(_internals2.resolveGitExecutable(), args, {
+    const result = child_process2.spawnSync(_internals3.resolveGitExecutable(), args, {
       cwd,
       encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
+      timeout: GIT_TIMEOUT_MS2,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
-      maxBuffer: GIT_MAX_BUFFER_BYTES
+      maxBuffer: GIT_MAX_BUFFER_BYTES2
     });
     if (result.error) {
       const code = result.error.code;
@@ -1163,29 +1942,10 @@ function gitExec(args, cwd) {
   throw new Error("git command failed after transient retries");
 }
 function getCurrentSha(directory) {
-  return gitExec(["rev-parse", "HEAD"], directory).trim();
-}
-function isGitRepo(directory) {
-  try {
-    gitExec(["rev-parse", "--git-dir"], directory);
-    return { isRepo: true };
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    const isTransient = /ETIMEDOUT|timed out/i.test(message) && !/not a git repository/i.test(message);
-    if (isTransient) {
-      return {
-        isRepo: false,
-        warning: "git probe failed after retry exhaustion - treating as not a git repository"
-      };
-    }
-    return {
-      isRepo: false,
-      warning: "git probe failed - directory may not be a git repository"
-    };
-  }
+  return gitExec2(["rev-parse", "HEAD"], directory).trim();
 }
 function findCommitByExactSubject(directory, subject) {
-  const output = _internals2.gitExec([
+  const output = _internals3.gitExec([
     "log",
     "HEAD",
     "--format=%H%x00%s",
@@ -1215,7 +1975,7 @@ async function withTaskCompletionLocksResult(input) {
     attempts++;
     let planLockResult;
     try {
-      planLockResult = await _internals2.tryAcquireLock(input.directory, PLAN_LOCK_PATH, CHECKPOINT_AGENT_NAME, `save-task-completion-plan-${input.taskId}`);
+      planLockResult = await _internals3.tryAcquireLock(input.directory, PLAN_LOCK_PATH, CHECKPOINT_AGENT_NAME, `save-task-completion-plan-${input.taskId}`);
     } catch (error) {
       if (input.onFailure) {
         return input.onFailure(error);
@@ -1229,13 +1989,13 @@ async function withTaskCompletionLocksResult(input) {
       if (attempts >= CHECKPOINT_LOCK_MAX_ATTEMPTS || Date.now() + CHECKPOINT_LOCK_DELAY_MS > deadline) {
         break;
       }
-      await _internals2.sleep(CHECKPOINT_LOCK_DELAY_MS);
+      await _internals3.sleep(CHECKPOINT_LOCK_DELAY_MS);
       continue;
     }
     try {
       let checkpointLockResult;
       try {
-        checkpointLockResult = await _internals2.tryAcquireLock(input.directory, CHECKPOINT_LOG_PATH, CHECKPOINT_AGENT_NAME, `save-task-completion-checkpoint-${input.taskId}`);
+        checkpointLockResult = await _internals3.tryAcquireLock(input.directory, CHECKPOINT_LOG_PATH, CHECKPOINT_AGENT_NAME, `save-task-completion-checkpoint-${input.taskId}`);
       } catch (error) {
         if (input.onFailure) {
           return input.onFailure(error);
@@ -1249,7 +2009,7 @@ async function withTaskCompletionLocksResult(input) {
         if (attempts >= CHECKPOINT_LOCK_MAX_ATTEMPTS || Date.now() + CHECKPOINT_LOCK_DELAY_MS > deadline) {
           break;
         }
-        await _internals2.sleep(CHECKPOINT_LOCK_DELAY_MS);
+        await _internals3.sleep(CHECKPOINT_LOCK_DELAY_MS);
         continue;
       }
       try {
@@ -1305,7 +2065,7 @@ async function withCheckpointMutationLockResult(input) {
     attempts++;
     let lockResult;
     try {
-      lockResult = await _internals2.tryAcquireLock(input.directory, CHECKPOINT_LOG_PATH, CHECKPOINT_AGENT_NAME, input.operationKey);
+      lockResult = await _internals3.tryAcquireLock(input.directory, CHECKPOINT_LOG_PATH, CHECKPOINT_AGENT_NAME, input.operationKey);
     } catch (error) {
       if (input.onFailure) {
         return input.onFailure(error);
@@ -1342,7 +2102,7 @@ async function withCheckpointMutationLockResult(input) {
     if (attempts >= CHECKPOINT_LOCK_MAX_ATTEMPTS || Date.now() + CHECKPOINT_LOCK_DELAY_MS > deadline) {
       break;
     }
-    await _internals2.sleep(CHECKPOINT_LOCK_DELAY_MS);
+    await _internals3.sleep(CHECKPOINT_LOCK_DELAY_MS);
   }
   if (input.onBusy) {
     return input.onBusy(attempts);
@@ -1367,19 +2127,19 @@ function handleSave(label, directory) {
       });
     }
     const timestamp = new Date().toISOString();
-    _internals2.stageAllExcludingSwarm(directory);
+    _internals3.stageAllExcludingSwarm(directory);
     const hasStagedChanges = (() => {
       try {
-        gitExec(["diff", "--cached", "--quiet"], directory);
+        gitExec2(["diff", "--cached", "--quiet"], directory);
         return false;
       } catch {
         return true;
       }
     })();
     if (hasStagedChanges) {
-      gitExec(["commit", "-m", `checkpoint: ${label}`], directory);
+      gitExec2(["commit", "-m", `checkpoint: ${label}`], directory);
     } else if (allowEmptyCommits) {
-      gitExec(["commit", "--allow-empty", "-m", `checkpoint: ${label}`], directory);
+      gitExec2(["commit", "--allow-empty", "-m", `checkpoint: ${label}`], directory);
     }
     const newSha = getCurrentSha(directory);
     appendCheckpointEntry(directory, log2, {
@@ -1416,8 +2176,8 @@ async function saveCheckpointRecord(label, directory) {
         return { success: false, error: `duplicate label: "${label}"` };
       }
       let sha = "";
-      const repoProbe = isGitRepo(directory);
-      if (repoProbe.isRepo) {
+      const saveProbe = await _internals3.readGitStatusAsync(["rev-parse", "--git-dir"], directory);
+      if (saveProbe.ok) {
         try {
           sha = getCurrentSha(directory);
         } catch {
@@ -1456,14 +2216,16 @@ async function handleRestore(label, directory, confirmToken) {
         error: `checkpoint not found: "${label}"`
       });
     }
-    const measurement = await measureGitDestruction(directory, checkpoint.sha);
+    const measurement = await _internals3.measureGitDestruction(directory, checkpoint.sha);
     if (measurement.kind === "unreadable") {
-      const cause = describeUnreadableCause(measurement);
+      const cause = describeUnreadableCause(measurement, measurement.source);
+      const unreadableNote = measurement.excludedOutOfRoot && measurement.excludedOutOfRoot.length > 0 ? ` \u2014 ${measurement.excludedOutOfRoot.length} out-of-root porcelain record(s) had been excluded from the scope before the read failed (first: ${formatExcludedRecord(measurement.excludedOutOfRoot[0])})` : "";
       return serializeResult("restore", {
         success: false,
-        error: `cannot verify the working tree (git status unreadable; ${cause}) \u2014 refusing to restore without a preview.`
+        error: `cannot verify the working tree (${measurement.source === "enumeration" ? "the target-tree listing could not be read" : "git status unreadable"}; ${cause})${unreadableNote} \u2014 refusing to restore without a preview.`
       });
     }
+    const exclusionNote = measurement.excludedOutOfRoot.length > 0 ? `${measurement.excludedOutOfRoot.length} out-of-root porcelain record(s) were excluded from this scope (first: ${formatExcludedRecord(measurement.excludedOutOfRoot[0])})` : null;
     if (measurement.dirtyRelPaths.length > 0) {
       const candidates = trackedDirtyCandidates(directory, measurement.dirtyRelPaths);
       const scopeAnchor = candidates[0].path;
@@ -1481,6 +2243,7 @@ async function handleRestore(label, directory, confirmToken) {
             `Restoring to checkpoint "${label}" runs a hard git reset and would DESTROY ${candidates.length} uncommitted tracked file(s):`,
             ...shown.map((p) => `  - ${p}`),
             ...overflow > 0 ? [`  (+${overflow} more)`] : [],
+            ...exclusionNote ? [`\u26A0 ${exclusionNote}`] : [],
             "Backups are taken automatically once confirmed."
           ],
           confirm_token: token,
@@ -1495,7 +2258,7 @@ async function handleRestore(label, directory, confirmToken) {
         });
       }
       const backup = backupTrackedChangesBeforeRollback(directory, measurement.dirtyRelPaths);
-      const atRiskExisting = measurement.dirtyRelPaths.filter((rel) => fs4.existsSync(path5.join(directory, rel))).length;
+      const atRiskExisting = measurement.dirtyRelPaths.filter((rel) => fs4.existsSync(path6.join(directory, rel))).length;
       if (!backup.backupDir || backup.copied.length < atRiskExisting) {
         return serializeResult("restore", {
           success: false,
@@ -1503,7 +2266,7 @@ async function handleRestore(label, directory, confirmToken) {
         });
       }
       const logBeforeReset2 = log2;
-      gitExec(["reset", "--hard", checkpoint.sha], directory);
+      gitExec2(["reset", "--hard", checkpoint.sha], directory);
       writeCheckpointLog(logBeforeReset2, directory);
       return serializeResult("restore", {
         success: true,
@@ -1511,17 +2274,17 @@ async function handleRestore(label, directory, confirmToken) {
         sha: checkpoint.sha,
         backup_dir: backup.backupDir,
         ...backup.warnings.length > 0 ? { backup_warnings: backup.warnings } : {},
-        message: `Restored to checkpoint: "${label}" (hard reset)${backup.backupDir ? `; destroyed bytes backed up to ${path5.relative(directory, backup.backupDir)}` : ""}${backup.warnings.length > 0 ? `; warnings: ${backup.warnings.join("; ")}` : ""}`
+        message: `Restored to checkpoint: "${label}" (hard reset)${backup.backupDir ? `; destroyed bytes backed up to ${path6.relative(directory, backup.backupDir)}` : ""}${backup.warnings.length > 0 ? `; warnings: ${backup.warnings.join("; ")}` : ""}${exclusionNote ? `; \u26A0 ${exclusionNote}` : ""}`
       });
     }
     const logBeforeReset = log2;
-    gitExec(["reset", "--hard", checkpoint.sha], directory);
+    gitExec2(["reset", "--hard", checkpoint.sha], directory);
     writeCheckpointLog(logBeforeReset, directory);
     return serializeResult("restore", {
       success: true,
       label,
       sha: checkpoint.sha,
-      message: `Restored to checkpoint: "${label}" (hard reset)`
+      message: `Restored to checkpoint: "${label}" (hard reset)${exclusionNote ? `; \u26A0 ${exclusionNote}` : ""}`
     });
   } catch (e) {
     return serializeResult("restore", {
@@ -1568,7 +2331,7 @@ async function handleSaveTaskCompletion(taskId, directory) {
     directory,
     taskId,
     run: async () => {
-      const plan = await _internals2.loadPlan(directory);
+      const plan = await _internals3.loadPlan(directory);
       if (!plan) {
         return serializeResult("save_task_completion", {
           success: false,
@@ -1588,7 +2351,7 @@ async function handleSaveTaskCompletion(taskId, directory) {
           error: `save_task_completion failed: task "${taskId}" is ${task.status}, not completed`
         });
       }
-      await _internals2.afterTaskEligibilityRead?.(directory, task.id);
+      await _internals3.afterTaskEligibilityRead?.(directory, task.id);
       const planIdentityHash = derivePlanIdentityHash(plan);
       const planId = derivePlanId(plan);
       const ledgerEvents = await readLedgerEvents(directory);
@@ -1624,12 +2387,12 @@ async function handleSaveTaskCompletion(taskId, directory) {
           message: `Checkpoint task completion already logged for "${descriptor.taskId}"`
         });
       }
-      const recoveredSha = _internals2.findCommitByExactSubject(directory, descriptor.subject);
+      const recoveredSha = _internals3.findCommitByExactSubject(directory, descriptor.subject);
       let committedSha = null;
       committedSha = recoveredSha ?? receipt.sha;
       if (!committedSha) {
-        _internals2.stageAllExcludingSwarm(directory);
-        _internals2.gitExec([
+        _internals3.stageAllExcludingSwarm(directory);
+        _internals3.gitExec([
           "commit",
           "--allow-empty",
           "-m",
@@ -1671,11 +2434,12 @@ var checkpoint = createSwarmTool({
     task_id: exports_external.string().optional().describe('Plan task ID (required for save_task_completion), e.g. "1.1"')
   },
   execute: async (args, directory) => {
-    const repoProbe = isGitRepo(directory);
-    if (!repoProbe.isRepo) {
+    const repoStatus = await _internals3.readGitRepositoryStatusDetailedAsync(directory);
+    if (!repoStatus.isRepo) {
+      const reason = repoStatus.reason === "not_git_repo" ? "not a git repository" : repoStatus.reason === "git_unavailable" ? "git executable is not available" : `git probe failed (${repoStatus.message})`;
       return serializeResult("unknown", {
         success: false,
-        error: `${repoProbe.warning ?? "not a git repository"} - checkpoint tools require a git repository`
+        error: `${reason} - checkpoint tools require a git repository`
       });
     }
     let action;
@@ -1764,4 +2528,4 @@ var checkpoint = createSwarmTool({
   }
 });
 
-export { MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, gitStatusReadInternals, readGitStatusAsync, readGitRepositoryStatusAsync, ROLLBACK_GIT_KIND, ROLLBACK_PHASE_KIND, trackedDirtyCandidates, swarmOverwriteCandidates, describeUnreadableCause, measureGitDestruction, GIT_STATUS_ARGS, parseTrackedDirtyPaths2 as parseTrackedDirtyPaths, recheckBeforeDestructive, previewDestructivePurge, issueConfirmToken, consumeConfirmToken, executeDestructivePurge, backupSwarmStateBeforeReset, resolveWorkingDirectory, createSwarmTool, _internals2 as _internals, saveCheckpointRecord, checkpoint };
+export { MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, assertSafeGitRefArg, readLaneEnvFileFromDiskSync, isGitRepo, getDefaultBaseBranch, detectDefaultRemoteBranch, resetToRemoteBranch, resetToMainAfterMerge, _internals, gitStatusReadInternals, readGitStatusAsync, readGitRepositoryStatusAsync, readGitRepositoryStatusDetailedAsync, ROLLBACK_GIT_KIND, ROLLBACK_PHASE_KIND, trackedDirtyCandidates, swarmOverwriteCandidates, describeUnreadableCause, formatExcludedRecord, measureGitDestruction, GIT_STATUS_ARGS, parseTrackedDirtyPathsWithExclusions2 as parseTrackedDirtyPathsWithExclusions, recheckBeforeDestructive, previewDestructivePurge, issueConfirmToken, consumeConfirmToken, executeDestructivePurge, backupSwarmStateBeforeReset, resolveWorkingDirectory, createSwarmTool, _internals3 as _internals1, saveCheckpointRecord, checkpoint };