opencode-swarm 7.86.0 → 7.87.0

package/dist/cli/{index-red8fm8p.js → index-89xjr3h4.js}

@@ -8,13 +8,16 @@ import {
 import {
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-ckntc5gf.js";
+} from "./index-gn8n22th.js";
 import {
   readCachedParsedFile
 } from "./index-jtqkh8jf.js";
 import {
+  criticalWarn,
+  error,
+  init_logger,
   warn
-} from "./index-yx44zd0p.js";
+} from "./index-zgwm4ryv.js";
 import {
   withEvidenceLock
 } from "./index-bcp79s17.js";
@@ -33,13 +36,13 @@ import {
 // src/plan/manager.ts
 import {
   copyFileSync,
-  existsSync as existsSync3,
+  existsSync as existsSync6,
   readdirSync as readdirSync2,
-  renameSync as renameSync3,
-  unlinkSync
+  renameSync as renameSync5,
+  unlinkSync as unlinkSync3
 } from "fs";
 import * as fsPromises from "fs/promises";
-import * as path3 from "path";
+import * as path6 from "path";
 
 // src/config/plan-schema.ts
 var ExecutionProfileSchema = exports_external.object({
@@ -102,13 +105,953 @@ var PlanSchema = exports_external.object({
   execution_profile: ExecutionProfileSchema.optional()
 });
 
+// src/git/branch.ts
+import * as child_process from "child_process";
+import path from "path";
+
+// src/utils/git-binary-missing-error.ts
+class GitBinaryMissingError extends Error {
+  name = "GitBinaryMissingError";
+  constructor(message = "git binary is not available", options) {
+    super(message, options);
+  }
+}
+function isGitBinaryMissing(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+
+// src/git/branch.ts
+init_logger();
+var GIT_TIMEOUT_MS = 30000;
+var GIT_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function windowsGitCandidates() {
+  if (process.platform !== "win32")
+    return ["git"];
+  const roots = unique([
+    process.env.ProgramFiles ?? "",
+    process.env["ProgramFiles(x86)"] ?? "",
+    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, "Programs") : ""
+  ]);
+  const installed = roots.flatMap((root) => [
+    path.join(root, "Git", "cmd", "git.exe"),
+    path.join(root, "Git", "bin", "git.exe")
+  ]);
+  return unique(["git", ...installed]);
+}
+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 gitExec(args, cwd) {
+  let missingGitError;
+  const subcommand = args[0];
+  const hardenedArgs = subcommand === "commit" || subcommand === "tag" ? ["-c", "commit.gpgsign=false", "-c", "tag.gpgsign=false", ...args] : args;
+  for (const command of windowsGitCandidates()) {
+    const result = child_process.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" }
+    });
+    if (result.error) {
+      if (isGitBinaryMissing(result.error)) {
+        missingGitError ??= result.error;
+        continue;
+      }
+      throw new Error(errorMessage(result.error));
+    }
+    if (result.status !== 0) {
+      throw new Error(result.stderr || result.stdout || `git exited with ${result.status}`);
+    }
+    return result.stdout;
+  }
+  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", { cause: missingGitError });
+}
+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) {
+  const output = gitExec(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  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) {
+  const status = gitExec(["status", "--porcelain"], cwd);
+  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: []
+      };
+    }
+    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", trimmedLine], 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", branchName], 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: []
+    };
+  }
+}
+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);
+    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"], cwd);
+    } catch {
+      warnings.push("Could not clean untracked files");
+    }
+    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", 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", trimmedLine], 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
+};
+
+// src/hooks/delegation-gate/worktree-merge-status.ts
+import * as fs from "fs";
+var failuresByTask = new Map;
+var durableStatusPath;
+var hasLoaded = false;
+function loadDurableStatus(statusPath) {
+  try {
+    hasLoaded = true;
+    if (!fs.existsSync(statusPath)) {
+      failuresByTask.clear();
+      return;
+    }
+    const data = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+    if (data && typeof data === "object") {
+      failuresByTask.clear();
+      for (const [taskId, failure] of Object.entries(data)) {
+        failuresByTask.set(taskId, failure);
+      }
+    }
+  } catch {
+    failuresByTask.clear();
+  }
+}
+function getWorktreeMergeFailure(taskId) {
+  if (!hasLoaded && durableStatusPath) {
+    loadDurableStatus(durableStatusPath);
+  }
+  return failuresByTask.get(taskId);
+}
+
+// src/turbo/epic/state.ts
+init_logger();
+import * as fs2 from "fs";
+import * as path2 from "path";
+var STATE_FILE = "epic-state.json";
+function nowISO() {
+  return new Date().toISOString();
+}
+function ensureSwarmDir(directory) {
+  const swarmDir = path2.resolve(directory, ".swarm");
+  if (!fs2.existsSync(swarmDir)) {
+    fs2.mkdirSync(swarmDir, { recursive: true });
+  }
+  return swarmDir;
+}
+function emptyPersisted() {
+  return { version: 1, updatedAt: nowISO(), sessions: {} };
+}
+function emptySessionState(sessionID) {
+  return { sessionID, active: false };
+}
+var stateUnreadableMap = new Map;
+function isStateUnreadable(directory) {
+  return stateUnreadableMap.get(directory) ?? false;
+}
+function markStateUnreadable(directory, reason) {
+  stateUnreadableMap.set(directory, true);
+  error(`[turbo/epic/state] state file unreadable for ${directory}: ${reason} \u2014 failing closed`);
+}
+function readPersisted(directory) {
+  try {
+    const filePath = path2.join(directory, ".swarm", STATE_FILE);
+    if (!fs2.existsSync(filePath)) {
+      const seed = emptyPersisted();
+      try {
+        ensureSwarmDir(directory);
+        fs2.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+`, "utf-8");
+      } catch {}
+      return seed;
+    }
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
+      markStateUnreadable(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
+      return null;
+    }
+    return {
+      version: 1,
+      updatedAt: parsed.updatedAt ?? nowISO(),
+      sessions: parsed.sessions
+    };
+  } catch (error2) {
+    const reason = error2 instanceof Error ? error2.message : String(error2);
+    markStateUnreadable(directory, reason);
+    return null;
+  }
+}
+function writePersisted(directory, persisted) {
+  if (stateUnreadableMap.get(directory)) {
+    throw new Error(`Epic state is unreadable. Please repair .swarm/${STATE_FILE} before continuing.`);
+  }
+  let filePath;
+  let tmpPath;
+  let payload;
+  try {
+    ensureSwarmDir(directory);
+    filePath = path2.join(directory, ".swarm", STATE_FILE);
+    tmpPath = `${filePath}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    persisted.updatedAt = nowISO();
+    payload = `${JSON.stringify(persisted, null, 2)}
+`;
+  } catch (error2) {
+    const msg = error2 instanceof Error ? error2.message : String(error2);
+    error(`[turbo/epic/state] Failed to prepare ${STATE_FILE} write: ${msg}`);
+    throw new Error(`Epic state persistence prepare failed: ${msg}`);
+  }
+  try {
+    fs2.writeFileSync(tmpPath, payload, "utf-8");
+    fs2.renameSync(tmpPath, filePath);
+  } catch (error2) {
+    const msg = error2 instanceof Error ? error2.message : String(error2);
+    error(`[turbo/epic/state] Failed to persist ${STATE_FILE} atomically: ${msg}`);
+    try {
+      if (fs2.existsSync(tmpPath))
+        fs2.unlinkSync(tmpPath);
+    } catch {}
+    throw new Error(`Epic state persistence failed: ${msg}`);
+  }
+}
+function loadEpicSessionState(directory, sessionID) {
+  if (stateUnreadableMap.get(directory))
+    return null;
+  const persisted = readPersisted(directory);
+  if (!persisted)
+    return null;
+  return persisted.sessions[sessionID] ?? null;
+}
+function saveEpicSessionState(directory, state) {
+  if (stateUnreadableMap.get(directory)) {
+    throw new Error(`Epic state is unreadable for ${directory}. Repair .swarm/${STATE_FILE} before continuing.`);
+  }
+  const persisted = readPersisted(directory);
+  if (!persisted) {
+    throw new Error(`Epic state is unreadable for ${directory}. Repair .swarm/${STATE_FILE} before continuing.`);
+  }
+  persisted.sessions[state.sessionID] = state;
+  writePersisted(directory, persisted);
+}
+function isEpicModeActive(directory, sessionID) {
+  const state = loadEpicSessionState(directory, sessionID);
+  return state?.active === true;
+}
+function isEpicModeActiveForProject(directory) {
+  if (stateUnreadableMap.get(directory))
+    return false;
+  if (!fs2.existsSync(path2.join(directory, ".swarm", STATE_FILE))) {
+    return false;
+  }
+  const persisted = readPersisted(directory);
+  if (!persisted)
+    return false;
+  for (const session of Object.values(persisted.sessions)) {
+    if (session?.active === true)
+      return true;
+  }
+  return false;
+}
+function enableEpicMode(directory, sessionID) {
+  const current = loadEpicSessionState(directory, sessionID) ?? emptySessionState(sessionID);
+  current.active = true;
+  current.enabledAt = nowISO();
+  current.disabledAt = undefined;
+  saveEpicSessionState(directory, current);
+}
+function disableEpicMode(directory, sessionID) {
+  const current = loadEpicSessionState(directory, sessionID);
+  if (!current) {
+    saveEpicSessionState(directory, {
+      ...emptySessionState(sessionID),
+      disabledAt: nowISO()
+    });
+    return;
+  }
+  current.active = false;
+  current.disabledAt = nowISO();
+  saveEpicSessionState(directory, current);
+}
+
+// src/turbo/epic/task-commit.ts
+init_logger();
+function scrubTaskIdForGitSubject(taskId) {
+  return taskId.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function formatTaskCommitMessage(taskId, description) {
+  const safeId = scrubTaskIdForGitSubject(taskId);
+  const summary = (description ?? "completed").replace(/\s+/g, " ").trim();
+  const truncated = summary.length > 60 ? `${summary.slice(0, 57)}...` : summary;
+  return `swarm(task ${safeId}): ${truncated || "completed"}`;
+}
+var INDEX_LOCK_BACKOFF_MS = [100, 200, 400, 800];
+var INDEX_LOCK_ERROR_RE = /index\.lock|unable to create.*\.lock/i;
+function isLockContentionError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return INDEX_LOCK_ERROR_RE.test(msg);
+}
+async function commitTaskCompletion(directory, taskId, description, scopePaths) {
+  if (!_internals2.isGitRepo(directory)) {
+    return { committed: false, reason: "no-git" };
+  }
+  try {
+    if (_internals2.hasExistingTaskCommit(directory, taskId)) {
+      return { committed: true, reason: "idempotent-skip" };
+    }
+  } catch {}
+  const rawPaths = (scopePaths ?? []).filter((p) => typeof p === "string" && p.trim().length > 0);
+  const droppedMagic = [];
+  const paths = rawPaths.filter((p) => {
+    if (p.startsWith(":")) {
+      droppedMagic.push(p);
+      return false;
+    }
+    return true;
+  });
+  if (droppedMagic.length > 0) {
+    criticalWarn(`[epic:task-commit] dropped ${droppedMagic.length} scope path(s) starting with ':' (git pathspec magic, not allowed): ${droppedMagic.slice(0, 5).join(", ")}${droppedMagic.length > 5 ? `, +${droppedMagic.length - 5} more` : ""}. Architect should declare literal file paths only.`);
+  }
+  const message = formatTaskCommitMessage(taskId, description);
+  let lastError = null;
+  for (let attempt = 0;attempt <= INDEX_LOCK_BACKOFF_MS.length; attempt++) {
+    try {
+      if (paths.length > 0) {
+        _internals2.stageScopedPaths(directory, paths);
+      }
+      _internals2.commitAllowEmpty(directory, message);
+      const sha = _internals2.gitHeadSha(directory);
+      return { committed: true, reason: "success", sha };
+    } catch (err) {
+      lastError = err;
+      if (attempt < INDEX_LOCK_BACKOFF_MS.length && isLockContentionError(err)) {
+        await _internals2.sleep(INDEX_LOCK_BACKOFF_MS[attempt]);
+        continue;
+      }
+      break;
+    }
+  }
+  const msg = lastError instanceof Error ? lastError.message : String(lastError);
+  criticalWarn(`[epic:task-commit] commit for task ${taskId} failed (non-fatal): ${msg}`);
+  return { committed: false, reason: "commit-failed", error: msg };
+}
+var _internals2 = {
+  isGitRepo: (cwd) => isGitRepo(cwd),
+  stageScopedPaths: (cwd, paths) => {
+    const CHUNK = 200;
+    for (let i = 0;i < paths.length; i += CHUNK) {
+      const chunk = paths.slice(i, i + CHUNK);
+      _internals.gitExec(["add", "--", ...chunk, ":(exclude,glob)**/.swarm/**"], cwd);
+    }
+  },
+  commitAllowEmpty: (cwd, message) => {
+    _internals.gitExec(["commit", "--allow-empty", "--no-verify", "-m", message], cwd);
+  },
+  gitHeadSha: (cwd) => {
+    return _internals.gitExec(["rev-parse", "HEAD"], cwd).trim();
+  },
+  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+  hasExistingTaskCommit: (cwd, taskId) => {
+    const safeId = scrubTaskIdForGitSubject(taskId);
+    const escaped = safeId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const output = _internals.gitExec([
+      "log",
+      "--extended-regexp",
+      `--grep=^swarm\\(task ${escaped}\\):`,
+      "--pretty=format:%H",
+      "-n",
+      "1"
+    ], cwd);
+    return output.trim().length > 0;
+  }
+};
+
+// src/turbo/lean/conflicts.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var DEFAULT_GLOBAL_FILES = [
+  "package.json",
+  "package-lock.json",
+  "bun.lock",
+  "bun.lockb",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "Cargo.lock",
+  "Gemfile.lock",
+  "composer.lock",
+  "poetry.lock",
+  "go.mod",
+  "go.sum",
+  "tsconfig.json",
+  "bunfig.toml",
+  "CHANGELOG.md",
+  ".release-please-manifest.json",
+  "src/index.ts",
+  "src/tools/index.ts",
+  "src/agents/index.ts",
+  "src/config/index.ts",
+  "src/hooks/index.ts",
+  "turbo.json",
+  "nx.json",
+  "packageManager",
+  ".npmrc",
+  ".nvmrc",
+  ".node-version"
+];
+var DEFAULT_PROTECTED_PATTERNS = [
+  "guardrail",
+  "delegation",
+  "authority",
+  "permission",
+  "crypto",
+  "secret",
+  "security",
+  "auth",
+  "/auth/",
+  "/auth.",
+  "auth.",
+  ".env",
+  "credentials",
+  "secrets",
+  "private",
+  "/security/",
+  "/security.",
+  "/protect/",
+  "/protect."
+];
+var BARREL_FILE_PATTERNS = [
+  /\/index\.ts$/,
+  /\/index\.tsx$/,
+  /\/index\.js$/,
+  /\/index\.mjs$/,
+  /\/exports\.ts$/,
+  /\/types\.ts$/
+];
+function normalizePath(filePath) {
+  if (filePath === "." || filePath === "./") {
+    return ".";
+  }
+  let result = filePath.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\.\//, "").replace(/(?:^|\/)\.\//g, "/");
+  result = result.replace(/\/$/, "");
+  result = result.replace(/\/\.$/, "");
+  if (process.platform === "win32") {
+    result = result.toLowerCase();
+  }
+  return result;
+}
+function pathsConflict(path1, path22) {
+  if (process.platform === "win32") {
+    path1 = path1.toLowerCase();
+    path22 = path22.toLowerCase();
+  }
+  if (path1 === path22) {
+    return true;
+  }
+  const [shorter, longer] = path1.length <= path22.length ? [path1, path22] : [path22, path1];
+  if (longer.startsWith(`${shorter}/`)) {
+    return true;
+  }
+  return false;
+}
+function isGlobalFile(normalizedPath) {
+  if (DEFAULT_GLOBAL_FILES.some((gf) => normalizedPath.endsWith(gf))) {
+    return true;
+  }
+  for (const pattern of BARREL_FILE_PATTERNS) {
+    if (pattern.test(normalizedPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isProtectedPath(normalizedPath) {
+  const lowerPath = normalizedPath.toLowerCase();
+  for (const pattern of DEFAULT_PROTECTED_PATTERNS) {
+    if (lowerPath.includes(pattern.toLowerCase())) {
+      if (pattern === "auth" || pattern === "/auth/") {
+        if (lowerPath === "auth" || lowerPath.endsWith("/auth") || lowerPath.includes("/auth/")) {
+          return true;
+        }
+      } else if (pattern === "auth.") {
+        const idx = lowerPath.indexOf("auth.");
+        if (idx !== -1) {
+          const before = idx === 0 || lowerPath[idx - 1] === "/";
+          if (before) {
+            return true;
+          }
+        }
+      } else {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function readTaskScopes(directory, taskId) {
+  const scopePath = path3.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  try {
+    if (!fs3.existsSync(scopePath)) {
+      return null;
+    }
+    const raw = fs3.readFileSync(scopePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.files)) {
+      return null;
+    }
+    return parsed.files;
+  } catch {
+    return null;
+  }
+}
+
 // src/utils/spec-hash.ts
 import { createHash as createHash2 } from "crypto";
 
 // src/sdd/effective-spec.ts
 import { createHash } from "crypto";
-import * as fs from "fs";
-import * as path from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 
 // src/config/spec-schema.ts
 var ObligationSchema = exports_external.enum(["MUST", "SHALL", "SHOULD", "MAY"]);
@@ -198,32 +1141,32 @@ function validateSpecContent(content) {
 }
 
 // src/sdd/effective-spec.ts
-var SWARM_SPEC_REL = path.join(".swarm", "spec.md");
+var SWARM_SPEC_REL = path4.join(".swarm", "spec.md");
 var OPENSPEC_ROOT = "openspec";
 var MAX_SPEC_BYTES = 256 * 1024;
 var MAX_SOURCE_BYTES = 512 * 1024;
 var MAX_SPEC_FILES = 100;
 var MAX_WALK_DEPTH = 10;
 function toPosix(relPath) {
-  return relPath.split(path.sep).join("/");
+  return relPath.split(path4.sep).join("/");
 }
 function hash(content) {
   return createHash("sha256").update(content, "utf-8").digest("hex");
 }
 function readTextBounded(absPath) {
-  const stat = fs.lstatSync(absPath);
+  const stat = fs4.lstatSync(absPath);
   if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES) {
     return null;
   }
-  return fs.readFileSync(absPath, "utf-8");
+  return fs4.readFileSync(absPath, "utf-8");
 }
 function fileArtifact(root, absPath) {
   try {
-    const stat = fs.lstatSync(absPath);
+    const stat = fs4.lstatSync(absPath);
     if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES)
       return null;
     return {
-      relPath: toPosix(path.relative(root, absPath)),
+      relPath: toPosix(path4.relative(root, absPath)),
       bytes: stat.size,
       mtimeMs: stat.mtimeMs
     };
@@ -232,8 +1175,8 @@ function fileArtifact(root, absPath) {
   }
 }
 function walkSpecFiles(root, startRel) {
-  const start = path.join(root, startRel);
-  if (!fs.existsSync(start))
+  const start = path4.join(root, startRel);
+  if (!fs4.existsSync(start))
     return [];
   const artifacts = [];
   const stack = [
@@ -245,13 +1188,13 @@ function walkSpecFiles(root, startRel) {
       continue;
     let entries;
     try {
-      entries = fs.readdirSync(item.abs, { withFileTypes: true });
+      entries = fs4.readdirSync(item.abs, { withFileTypes: true });
     } catch {
       continue;
     }
     const dirents = entries.filter((entry) => typeof entry?.name === "string");
     for (const entry of dirents.sort((a, b) => b.name.localeCompare(a.name))) {
-      const abs = path.join(item.abs, entry.name);
+      const abs = path4.join(item.abs, entry.name);
       if (entry.isSymbolicLink())
         continue;
       if (entry.isDirectory()) {
@@ -268,23 +1211,23 @@ function walkSpecFiles(root, startRel) {
   return artifacts.sort((a, b) => a.relPath.localeCompare(b.relPath));
 }
 function listOpenSpecChanges(root) {
-  const changesDir = path.join(root, OPENSPEC_ROOT, "changes");
-  if (!fs.existsSync(changesDir))
+  const changesDir = path4.join(root, OPENSPEC_ROOT, "changes");
+  if (!fs4.existsSync(changesDir))
     return [];
   let entries;
   try {
-    entries = fs.readdirSync(changesDir, { withFileTypes: true });
+    entries = fs4.readdirSync(changesDir, { withFileTypes: true });
   } catch {
     return [];
   }
   return entries.filter((entry) => entry.isDirectory() && entry.name !== "archive").sort((a, b) => a.name.localeCompare(b.name)).map((entry) => {
-    const rel = path.join(OPENSPEC_ROOT, "changes", entry.name);
+    const rel = path4.join(OPENSPEC_ROOT, "changes", entry.name);
     return {
       id: entry.name,
-      proposal: fs.existsSync(path.join(root, rel, "proposal.md")),
-      design: fs.existsSync(path.join(root, rel, "design.md")),
-      tasks: fs.existsSync(path.join(root, rel, "tasks.md")),
-      specs: walkSpecFiles(root, path.join(rel, "specs"))
+      proposal: fs4.existsSync(path4.join(root, rel, "proposal.md")),
+      design: fs4.existsSync(path4.join(root, rel, "design.md")),
+      tasks: fs4.existsSync(path4.join(root, rel, "tasks.md")),
+      specs: walkSpecFiles(root, path4.join(rel, "specs"))
     };
   });
 }
@@ -379,14 +1322,14 @@ function renderRequirement(req, used, warnings) {
   return `- ${text} _(source: ${req.sourceRel})_`;
 }
 function loadSddStatusSync(directory) {
-  const root = path.resolve(directory);
-  const swSpecPath = path.join(root, SWARM_SPEC_REL);
-  const openSpecPath = path.join(root, OPENSPEC_ROOT);
+  const root = path4.resolve(directory);
+  const swSpecPath = path4.join(root, SWARM_SPEC_REL);
+  const openSpecPath = path4.join(root, OPENSPEC_ROOT);
   const errors = [];
   const warnings = [];
-  const swSpecExists = fs.existsSync(swSpecPath);
-  const openSpecExists = fs.existsSync(openSpecPath);
-  const currentSpecs = walkSpecFiles(root, path.join(OPENSPEC_ROOT, "specs"));
+  const swSpecExists = fs4.existsSync(swSpecPath);
+  const openSpecExists = fs4.existsSync(openSpecPath);
+  const currentSpecs = walkSpecFiles(root, path4.join(OPENSPEC_ROOT, "specs"));
   const changes = listOpenSpecChanges(root);
   const effectiveSpec = readEffectiveSpecSync(root);
   if (openSpecExists && currentSpecs.length === 0 && changes.length === 0) {
@@ -415,8 +1358,8 @@ function loadSddStatusSync(directory) {
   };
 }
 function buildOpenSpecProjectionSync(directory, options = {}) {
-  const root = path.resolve(directory);
-  const currentSpecs = walkSpecFiles(root, path.join(OPENSPEC_ROOT, "specs"));
+  const root = path4.resolve(directory);
+  const currentSpecs = walkSpecFiles(root, path4.join(OPENSPEC_ROOT, "specs"));
   const allChanges = listOpenSpecChanges(root);
   const changes = options.changeId ? allChanges.filter((change) => change.id === options.changeId) : allChanges;
   const sourcePaths = [];
@@ -431,7 +1374,7 @@ function buildOpenSpecProjectionSync(directory, options = {}) {
   if (currentSpecs.length === 0 && changes.length === 0)
     return null;
   for (const artifact of currentSpecs) {
-    const abs = path.join(root, artifact.relPath);
+    const abs = path4.join(root, artifact.relPath);
     const content2 = readTextBounded(abs);
     if (content2 === null) {
       warnings.push(`Skipped unreadable or oversized spec ${artifact.relPath}.`);
@@ -446,7 +1389,7 @@ function buildOpenSpecProjectionSync(directory, options = {}) {
   for (const change of changes) {
     const reqs = [];
     for (const artifact of change.specs) {
-      const abs = path.join(root, artifact.relPath);
+      const abs = path4.join(root, artifact.relPath);
       const content2 = readTextBounded(abs);
       if (content2 === null) {
         warnings.push(`Skipped unreadable or oversized spec ${artifact.relPath}.`);
@@ -513,12 +1456,12 @@ function buildOpenSpecProjectionSync(directory, options = {}) {
   };
 }
 function readEffectiveSpecSync(directory) {
-  const root = path.resolve(directory);
-  const swSpecPath = path.join(root, SWARM_SPEC_REL);
+  const root = path4.resolve(directory);
+  const swSpecPath = path4.join(root, SWARM_SPEC_REL);
   try {
-    const stat = fs.lstatSync(swSpecPath);
+    const stat = fs4.lstatSync(swSpecPath);
     if (stat.isFile() && stat.size <= MAX_SPEC_BYTES) {
-      const content = fs.readFileSync(swSpecPath, "utf-8");
+      const content = fs4.readFileSync(swSpecPath, "utf-8");
       return {
         source: "swarm",
         content,
@@ -528,49 +1471,49 @@ function readEffectiveSpecSync(directory) {
         warnings: []
       };
     }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
+  } catch (error2) {
+    if (error2.code !== "ENOENT") {
+      throw error2;
     }
   }
   return buildOpenSpecProjectionSync(root);
 }
 function writeProjectedSpecSync(directory, options = {}) {
-  const root = path.resolve(directory);
+  const root = path4.resolve(directory);
   const projection = buildOpenSpecProjectionSync(root, {
     changeId: options.changeId
   });
-  const target = path.join(root, SWARM_SPEC_REL);
+  const target = path4.join(root, SWARM_SPEC_REL);
   if (!projection || options.dryRun) {
     return { written: false, projection, path: target };
   }
-  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs4.mkdirSync(path4.dirname(target), { recursive: true });
   let archivePath;
-  if (fs.existsSync(target)) {
-    const prior = fs.readFileSync(target, "utf-8");
+  if (fs4.existsSync(target)) {
+    const prior = fs4.readFileSync(target, "utf-8");
     if (prior !== projection.content) {
-      const archiveDir = path.join(root, ".swarm", "spec-archive");
-      fs.mkdirSync(archiveDir, { recursive: true });
+      const archiveDir = path4.join(root, ".swarm", "spec-archive");
+      fs4.mkdirSync(archiveDir, { recursive: true });
       const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-      archivePath = path.join(archiveDir, `sdd-projection-${stamp}.md`);
-      fs.writeFileSync(archivePath, prior, "utf-8");
+      archivePath = path4.join(archiveDir, `sdd-projection-${stamp}.md`);
+      fs4.writeFileSync(archivePath, prior, "utf-8");
     }
   }
   const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
-  fs.writeFileSync(tmp, projection.content, "utf-8");
-  fs.renameSync(tmp, target);
+  fs4.writeFileSync(tmp, projection.content, "utf-8");
+  fs4.renameSync(tmp, target);
   return { written: true, projection, archivePath, path: target };
 }
 
 // src/utils/spec-hash.ts
 async function computeSpecHash(directory) {
-  const spec = _internals.readEffectiveSpecSync(directory);
+  const spec = _internals3.readEffectiveSpecSync(directory);
   if (!spec)
     return null;
   return createHash2("sha256").update(spec.content, "utf-8").digest("hex");
 }
 async function isSpecStale(directory, plan) {
-  const currentHash = await _internals.computeSpecHash(directory);
+  const currentHash = await _internals3.computeSpecHash(directory);
   if (!plan.specHash) {
     return { stale: false };
   }
@@ -590,7 +1533,7 @@ async function isSpecStale(directory, plan) {
   }
   return { stale: false };
 }
-var _internals = {
+var _internals3 = {
   computeSpecHash,
   isSpecStale,
   readEffectiveSpecSync
@@ -598,8 +1541,8 @@ var _internals = {
 
 // src/plan/ledger.ts
 import * as crypto from "crypto";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 
 // src/plan/utils.ts
 function derivePlanId(plan) {
@@ -618,10 +1561,10 @@ class LedgerStaleWriterError extends Error {
   }
 }
 function getLedgerPath(directory) {
-  return path2.join(directory, ".swarm", LEDGER_FILENAME);
+  return path5.join(directory, ".swarm", LEDGER_FILENAME);
 }
 function getPlanJsonPath(directory) {
-  return path2.join(directory, ".swarm", PLAN_JSON_FILENAME);
+  return path5.join(directory, ".swarm", PLAN_JSON_FILENAME);
 }
 function computePlanHash(plan) {
   const normalized = {
@@ -656,7 +1599,7 @@ function computePlanHash(plan) {
 function computeCurrentPlanHash(directory) {
   const planPath = getPlanJsonPath(directory);
   try {
-    const content = fs2.readFileSync(planPath, "utf8");
+    const content = fs5.readFileSync(planPath, "utf8");
     const plan = JSON.parse(content);
     return computePlanHash(plan);
   } catch {
@@ -665,15 +1608,15 @@ function computeCurrentPlanHash(directory) {
 }
 async function ledgerExists(directory) {
   const ledgerPath = getLedgerPath(directory);
-  return fs2.existsSync(ledgerPath);
+  return fs5.existsSync(ledgerPath);
 }
 async function getLatestLedgerSeq(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs2.existsSync(ledgerPath)) {
+  if (!fs5.existsSync(ledgerPath)) {
     return 0;
   }
   try {
-    const content = fs2.readFileSync(ledgerPath, "utf8");
+    const content = fs5.readFileSync(ledgerPath, "utf8");
     const lines = content.trim().split(`
 `).filter((line) => line.trim() !== "");
     if (lines.length === 0) {
@@ -695,11 +1638,11 @@ async function getLatestLedgerSeq(directory) {
 }
 async function readLedgerEvents(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs2.existsSync(ledgerPath)) {
+  if (!fs5.existsSync(ledgerPath)) {
     return [];
   }
   try {
-    const content = fs2.readFileSync(ledgerPath, "utf8");
+    const content = fs5.readFileSync(ledgerPath, "utf8");
     const lines = content.trim().split(`
 `).filter((line) => line.trim() !== "");
     const events = [];
@@ -724,15 +1667,15 @@ async function readLedgerEvents(directory) {
 async function initLedger(directory, planId, initialPlanHash, initialPlan) {
   const ledgerPath = getLedgerPath(directory);
   const planJsonPath = getPlanJsonPath(directory);
-  if (fs2.existsSync(ledgerPath)) {
+  if (fs5.existsSync(ledgerPath)) {
     throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
   }
   let planHashAfter = initialPlanHash ?? "";
   let embeddedPlan = initialPlan;
   if (!initialPlanHash) {
     try {
-      if (fs2.existsSync(planJsonPath)) {
-        const content = fs2.readFileSync(planJsonPath, "utf8");
+      if (fs5.existsSync(planJsonPath)) {
+        const content = fs5.readFileSync(planJsonPath, "utf8");
         const plan = JSON.parse(content);
         planHashAfter = computePlanHash(plan);
         if (!embeddedPlan)
@@ -752,12 +1695,12 @@ async function initLedger(directory, planId, initialPlanHash, initialPlan) {
     schema_version: LEDGER_SCHEMA_VERSION,
     ...payload ? { payload } : {}
   };
-  fs2.mkdirSync(path2.join(directory, ".swarm"), { recursive: true });
+  fs5.mkdirSync(path5.join(directory, ".swarm"), { recursive: true });
   const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
-  fs2.writeFileSync(tempPath, line, "utf8");
-  fs2.renameSync(tempPath, ledgerPath);
+  fs5.writeFileSync(tempPath, line, "utf8");
+  fs5.renameSync(tempPath, ledgerPath);
 }
 async function appendLedgerEvent(directory, eventInput, options) {
   const ledgerPath = getLedgerPath(directory);
@@ -779,17 +1722,17 @@ async function appendLedgerEvent(directory, eventInput, options) {
     plan_hash_after: planHashAfter,
     schema_version: LEDGER_SCHEMA_VERSION
   };
-  fs2.mkdirSync(path2.join(directory, ".swarm"), { recursive: true });
+  fs5.mkdirSync(path5.join(directory, ".swarm"), { recursive: true });
   const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
-  if (fs2.existsSync(ledgerPath)) {
-    const existingContent = fs2.readFileSync(ledgerPath, "utf8");
-    fs2.writeFileSync(tempPath, existingContent + line, "utf8");
+  if (fs5.existsSync(ledgerPath)) {
+    const existingContent = fs5.readFileSync(ledgerPath, "utf8");
+    fs5.writeFileSync(tempPath, existingContent + line, "utf8");
   } else {
     throw new Error("Ledger not initialized. Call initLedger() first.");
   }
-  fs2.renameSync(tempPath, ledgerPath);
+  fs5.renameSync(tempPath, ledgerPath);
   return event;
 }
 async function takeSnapshotWithRetry(directory, plan, options) {
@@ -876,12 +1819,12 @@ async function replayFromLedger(directory, _options) {
     }
   }
   const planJsonPath = getPlanJsonPath(directory);
-  if (!fs2.existsSync(planJsonPath)) {
+  if (!fs5.existsSync(planJsonPath)) {
     return null;
   }
   let plan;
   try {
-    const content = fs2.readFileSync(planJsonPath, "utf8");
+    const content = fs5.readFileSync(planJsonPath, "utf8");
     plan = JSON.parse(content);
   } catch {
     return null;
@@ -976,11 +1919,11 @@ function applyEventToPlan(plan, event) {
 }
 async function readLedgerEventsWithIntegrity(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs2.existsSync(ledgerPath)) {
+  if (!fs5.existsSync(ledgerPath)) {
     return { events: [], truncated: false, badSuffix: null };
   }
   try {
-    const content = fs2.readFileSync(ledgerPath, "utf8");
+    const content = fs5.readFileSync(ledgerPath, "utf8");
     const lines = content.split(`
 `);
     const events = [];
@@ -1009,9 +1952,9 @@ async function readLedgerEventsWithIntegrity(directory) {
 }
 async function quarantineLedgerSuffix(directory, badSuffix) {
   try {
-    const quarantinePath = path2.join(directory, ".swarm", "plan-ledger.quarantine");
-    fs2.writeFileSync(quarantinePath, badSuffix, "utf8");
-    console.warn(`[ledger] Corrupted suffix quarantined to ${path2.relative(directory, quarantinePath)}`);
+    const quarantinePath = path5.join(directory, ".swarm", "plan-ledger.quarantine");
+    fs5.writeFileSync(quarantinePath, badSuffix, "utf8");
+    console.warn(`[ledger] Corrupted suffix quarantined to ${path5.relative(directory, quarantinePath)}`);
   } catch {}
 }
 async function loadLastApprovedPlan(directory, expectedPlanId) {
@@ -1069,10 +2012,15 @@ class PlanTaskRemovalNotAcknowledgedError extends Error {
 var startupLedgerCheckedWorkspaces = new Set;
 var recoveryMutexes = new Map;
 var PLAN_JSON_CACHE_NAMESPACE = "plan-json:validated:v1";
-var _internals2 = {
+var _internals4 = {
   loadPlan,
   loadPlanJsonOnly,
-  regeneratePlanMarkdown
+  regeneratePlanMarkdown,
+  isGitRepo,
+  isEpicModeActiveForProject,
+  readTaskScopes,
+  commitTaskCompletion,
+  getWorktreeMergeFailure
 };
 var CAS_BACKOFF_START_MS = 5;
 var CAS_BACKOFF_CAP_MS = 250;
@@ -1088,9 +2036,9 @@ async function retryCasWithBackoff(directory, eventInput, options) {
         expectedHash: currentExpected,
         planHashAfter: options.planHashAfter
       });
-    } catch (error) {
-      if (!(error instanceof LedgerStaleWriterError) || attempt >= maxRetries) {
-        throw error;
+    } catch (error2) {
+      if (!(error2 instanceof LedgerStaleWriterError) || attempt >= maxRetries) {
+        throw error2;
       }
       attempt++;
       const base = Math.min(CAS_BACKOFF_START_MS * 2 ** (attempt - 1), CAS_BACKOFF_CAP_MS);
@@ -1101,7 +2049,7 @@ async function retryCasWithBackoff(directory, eventInput, options) {
         expectedHashPrefix: currentExpected.slice(0, 8),
         delayMs
       });
-      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+      await new Promise((resolve4) => setTimeout(resolve4, delayMs));
       if (options.verifyValid) {
         const stillValid = await options.verifyValid();
         if (!stillValid)
@@ -1114,8 +2062,8 @@ async function retryCasWithBackoff(directory, eventInput, options) {
 async function loadPlanJsonOnly(directory) {
   try {
     return await parsePlanJsonCached(directory);
-  } catch (error) {
-    warn(`Plan validation failed for .swarm/plan.json: ${error instanceof Error ? error.message : String(error)}`);
+  } catch (error2) {
+    warn(`Plan validation failed for .swarm/plan.json: ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
   return null;
 }
@@ -1144,7 +2092,7 @@ async function getLatestLedgerHash(directory) {
   }
 }
 async function parsePlanJsonCached(directory) {
-  const planJsonPath = path3.resolve(directory, ".swarm", "plan.json");
+  const planJsonPath = path6.resolve(directory, ".swarm", "plan.json");
   return readCachedParsedFile(planJsonPath, PLAN_JSON_CACHE_NAMESPACE, () => readSwarmFileAsync(directory, "plan.json"), (planJsonContent) => {
     if (planJsonContent.includes("\x00") || planJsonContent.includes("\uFFFD")) {
       throw new Error("Plan rejected: .swarm/plan.json contains null bytes or invalid encoding");
@@ -1204,19 +2152,19 @@ async function isPlanMdInSync(directory, plan) {
   return normalizedActual.includes(normalizedExpected) || normalizedExpected.includes(normalizedActual.replace(/^#.*$/gm, "").trim());
 }
 async function regeneratePlanMarkdown(directory, plan) {
-  const swarmDir = path3.resolve(directory, ".swarm");
+  const swarmDir = path6.resolve(directory, ".swarm");
   const contentHash = computePlanContentHash(plan);
   const markdown = derivePlanMarkdown(plan);
   const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-  const mdPath = path3.join(swarmDir, "plan.md");
-  const mdTempPath = path3.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const mdPath = path6.join(swarmDir, "plan.md");
+  const mdTempPath = path6.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync3(mdTempPath, mdPath);
+    renameSync5(mdTempPath, mdPath);
   } finally {
     try {
-      unlinkSync(mdTempPath);
+      unlinkSync3(mdTempPath);
     } catch {}
   }
 }
@@ -1234,7 +2182,7 @@ async function loadPlan(directory) {
           const inSync = await isPlanMdInSync(directory, validated);
           if (!inSync) {
             try {
-              await _internals2.regeneratePlanMarkdown(directory, validated);
+              await _internals4.regeneratePlanMarkdown(directory, validated);
             } catch (regenError) {
               warn(`Failed to regenerate plan.md: ${regenError instanceof Error ? regenError.message : String(regenError)}. Proceeding with plan.json only.`);
             }
@@ -1242,7 +2190,7 @@ async function loadPlan(directory) {
           if (await ledgerExists(directory)) {
             const planHash = computePlanHash(validated);
             const ledgerHash = await getLatestLedgerHash(directory);
-            const resolvedWorkspace = path3.resolve(directory);
+            const resolvedWorkspace = path6.resolve(directory);
             if (!startupLedgerCheckedWorkspaces.has(resolvedWorkspace)) {
               startupLedgerCheckedWorkspaces.add(resolvedWorkspace);
               if (ledgerHash !== "" && planHash !== ledgerHash) {
@@ -1299,7 +2247,7 @@ async function loadPlan(directory) {
               runtimePlan._specStale = true;
               runtimePlan._specStaleReason = staleResult.reason;
               try {
-                const specStalenessPath = path3.join(directory, ".swarm", "spec-staleness.json");
+                const specStalenessPath = path6.join(directory, ".swarm", "spec-staleness.json");
                 await fsPromises.writeFile(specStalenessPath, JSON.stringify({
                   type: "spec_stale_detected",
                   timestamp: new Date().toISOString(),
@@ -1311,7 +2259,7 @@ async function loadPlan(directory) {
                 }, null, 2), "utf-8");
               } catch {}
               try {
-                const eventsPath = path3.join(directory, ".swarm", "events.jsonl");
+                const eventsPath = path6.join(directory, ".swarm", "events.jsonl");
                 const event = {
                   type: "spec_stale_detected",
                   timestamp: new Date().toISOString(),
@@ -1328,8 +2276,8 @@ async function loadPlan(directory) {
           }
           return validated;
         }
-      } catch (error) {
-        warn(`[loadPlan] plan.json validation failed: ${error instanceof Error ? error.message : String(error)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/SWARM_PLAN.md for a checkpoint.`);
+      } catch (error2) {
+        warn(`[loadPlan] plan.json validation failed: ${error2 instanceof Error ? error2.message : String(error2)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/SWARM_PLAN.md for a checkpoint.`);
         let rawPlanId = null;
         try {
           const rawParsed = JSON.parse(planJsonContent);
@@ -1376,11 +2324,11 @@ async function loadPlan(directory) {
     return migrated;
   }
   if (await ledgerExists(directory)) {
-    const resolvedDir = path3.resolve(directory);
+    const resolvedDir = path6.resolve(directory);
     const existingMutex = recoveryMutexes.get(resolvedDir);
     if (existingMutex) {
       await existingMutex;
-      const postRecoveryPlan = await _internals2.loadPlanJsonOnly(directory);
+      const postRecoveryPlan = await _internals4.loadPlanJsonOnly(directory);
       if (postRecoveryPlan)
         return postRecoveryPlan;
     }
@@ -1440,7 +2388,7 @@ async function loadPlan(directory) {
   return null;
 }
 async function savePlanWithAutoAcknowledgedRemovals(directory, plan, source, reason, options) {
-  const existing = await _internals2.loadPlanJsonOnly(directory);
+  const existing = await _internals4.loadPlanJsonOnly(directory);
   const newIds = new Set;
   for (const phase of plan.phases) {
     for (const task of phase.tasks)
@@ -1468,7 +2416,7 @@ async function savePlan(directory, plan, options) {
   const validated = PlanSchema.parse(plan);
   if (options?.preserveCompletedStatuses !== false) {
     try {
-      const currentPlan2 = await _internals2.loadPlanJsonOnly(directory);
+      const currentPlan2 = await _internals4.loadPlanJsonOnly(directory);
       if (currentPlan2) {
         const completedTaskIds = new Set;
         for (const phase of currentPlan2.phases) {
@@ -1501,7 +2449,7 @@ async function savePlan(directory, plan, options) {
       phase.status = "pending";
     }
   }
-  const currentPlan = await _internals2.loadPlanJsonOnly(directory);
+  const currentPlan = await _internals4.loadPlanJsonOnly(directory);
   const planId = derivePlanId(validated);
   const planHashForInit = computePlanHash(validated);
   if (!await ledgerExists(directory)) {
@@ -1516,13 +2464,13 @@ async function savePlan(directory, plan, options) {
   } else {
     const existingEvents = await readLedgerEvents(directory);
     if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
-      const swarmDir2 = path3.resolve(directory, ".swarm");
-      const oldLedgerPath = path3.join(swarmDir2, "plan-ledger.jsonl");
-      const oldLedgerBackupPath = path3.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+      const swarmDir2 = path6.resolve(directory, ".swarm");
+      const oldLedgerPath = path6.join(swarmDir2, "plan-ledger.jsonl");
+      const oldLedgerBackupPath = path6.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
       let backupExists = false;
-      if (existsSync3(oldLedgerPath)) {
+      if (existsSync6(oldLedgerPath)) {
         try {
-          renameSync3(oldLedgerPath, oldLedgerBackupPath);
+          renameSync5(oldLedgerPath, oldLedgerBackupPath);
           backupExists = true;
         } catch (renameErr) {
           throw new Error(`[savePlan] Cannot reinitialize ledger: could not move old ledger aside (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). The existing ledger has plan_id="${existingEvents[0].plan_id}" which does not match the current plan="${planId}". To proceed, close any programs that may have the ledger file open, or run /swarm reset-session to clear the ledger.`);
@@ -1534,20 +2482,20 @@ async function savePlan(directory, plan, options) {
           await initLedger(directory, planId, planHashForInit, validated);
           initSucceeded = true;
         } catch (initErr) {
-          const errorMessage = String(initErr);
-          if (errorMessage.includes("already initialized")) {
+          const errorMessage2 = String(initErr);
+          if (errorMessage2.includes("already initialized")) {
             try {
-              if (existsSync3(oldLedgerBackupPath))
-                unlinkSync(oldLedgerBackupPath);
+              if (existsSync6(oldLedgerBackupPath))
+                unlinkSync3(oldLedgerBackupPath);
             } catch {}
           } else {
-            if (existsSync3(oldLedgerBackupPath)) {
+            if (existsSync6(oldLedgerBackupPath)) {
               try {
-                renameSync3(oldLedgerBackupPath, oldLedgerPath);
+                renameSync5(oldLedgerBackupPath, oldLedgerPath);
               } catch {
                 copyFileSync(oldLedgerBackupPath, oldLedgerPath);
                 try {
-                  unlinkSync(oldLedgerBackupPath);
+                  unlinkSync3(oldLedgerBackupPath);
                 } catch {}
               }
             }
@@ -1556,21 +2504,21 @@ async function savePlan(directory, plan, options) {
         }
       }
       if (initSucceeded && backupExists) {
-        const archivePath = path3.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+        const archivePath = path6.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
         try {
-          renameSync3(oldLedgerBackupPath, archivePath);
+          renameSync5(oldLedgerBackupPath, archivePath);
           warn(`[savePlan] Ledger identity mismatch (was "${existingEvents[0].plan_id}", now "${planId}") \u2014 archived old ledger to ${archivePath} and reinitializing.`);
         } catch (renameErr) {
           warn(`[savePlan] Could not archive old ledger (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). Old ledger may still exist at ${oldLedgerBackupPath}.`);
           try {
-            if (existsSync3(oldLedgerBackupPath))
-              unlinkSync(oldLedgerBackupPath);
+            if (existsSync6(oldLedgerBackupPath))
+              unlinkSync3(oldLedgerBackupPath);
           } catch {}
         }
       } else if (!initSucceeded && backupExists) {
         try {
-          if (existsSync3(oldLedgerBackupPath))
-            unlinkSync(oldLedgerBackupPath);
+          if (existsSync6(oldLedgerBackupPath))
+            unlinkSync3(oldLedgerBackupPath);
         } catch {}
       }
       const MAX_ARCHIVED_SIBLINGS = 5;
@@ -1581,7 +2529,7 @@ async function savePlan(directory, plan, options) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
           for (const file of toRemove) {
             try {
-              unlinkSync(path3.join(swarmDir2, file));
+              unlinkSync3(path6.join(swarmDir2, file));
             } catch {}
           }
         }
@@ -1646,7 +2594,7 @@ async function savePlan(directory, plan, options) {
             expectedHash: currentHash,
             planHashAfter: hashAfter,
             verifyValid: async () => {
-              const onDisk = await _internals2.loadPlanJsonOnly(directory);
+              const onDisk = await _internals4.loadPlanJsonOnly(directory);
               if (!onDisk)
                 return true;
               for (const p of onDisk.phases) {
@@ -1657,11 +2605,11 @@ async function savePlan(directory, plan, options) {
             }
           });
         }
-      } catch (error) {
-        if (error instanceof LedgerStaleWriterError) {
-          throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error.message}. Please retry the operation.`);
+      } catch (error2) {
+        if (error2 instanceof LedgerStaleWriterError) {
+          throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error2.message}. Please retry the operation.`);
         }
-        throw error;
+        throw error2;
       }
     }
     try {
@@ -1684,7 +2632,7 @@ async function savePlan(directory, plan, options) {
               expectedHash: currentHash,
               planHashAfter: hashAfter,
               verifyValid: async () => {
-                const onDisk = await _internals2.loadPlanJsonOnly(directory);
+                const onDisk = await _internals4.loadPlanJsonOnly(directory);
                 if (!onDisk)
                   return true;
                 for (const p of onDisk.phases) {
@@ -1699,11 +2647,11 @@ async function savePlan(directory, plan, options) {
           }
         }
       }
-    } catch (error) {
-      if (error instanceof LedgerStaleWriterError) {
-        throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error.message}. Please retry the operation.`);
+    } catch (error2) {
+      if (error2 instanceof LedgerStaleWriterError) {
+        throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error2.message}. Please retry the operation.`);
       }
-      throw error;
+      throw error2;
     }
   }
   const SNAPSHOT_INTERVAL = 50;
@@ -1714,19 +2662,19 @@ async function savePlan(directory, plan, options) {
       source: "savePlan_manager"
     });
   }
-  const swarmDir = path3.resolve(directory, ".swarm");
-  const planPath = path3.join(swarmDir, "plan.json");
-  const tempPath = path3.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path6.resolve(directory, ".swarm");
+  const planPath = path6.join(swarmDir, "plan.json");
+  const tempPath = path6.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(tempPath, JSON.stringify(validated, null, 2));
-    renameSync3(tempPath, planPath);
+    renameSync5(tempPath, planPath);
   } finally {
     try {
-      unlinkSync(tempPath);
+      unlinkSync3(tempPath);
     } catch {}
   }
   try {
-    const markerPath = path3.join(swarmDir, ".plan-write-marker");
+    const markerPath = path6.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -1741,14 +2689,14 @@ async function savePlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(validated);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdPath = path3.join(swarmDir, "plan.md");
-    const mdTempPath = path3.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdPath = path6.join(swarmDir, "plan.md");
+    const mdTempPath = path6.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await bunWrite(mdTempPath, markdownWithHash);
-      renameSync3(mdTempPath, mdPath);
+      renameSync5(mdTempPath, mdPath);
     } finally {
       try {
-        unlinkSync(mdTempPath);
+        unlinkSync3(mdTempPath);
       } catch {}
     }
   } catch (mdError) {
@@ -1763,7 +2711,7 @@ ${markdown}`;
     } catch {}
   }
   try {
-    const markerPath = path3.join(swarmDir, ".plan-write-marker");
+    const markerPath = path6.join(swarmDir, ".plan-write-marker");
     const tasksCount = validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
     const marker = JSON.stringify({
       source: "plan_manager",
@@ -1779,14 +2727,14 @@ async function rebuildPlan(directory, plan, options) {
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
-  const swarmDir = path3.join(directory, ".swarm");
-  const planPath = path3.join(swarmDir, "plan.json");
-  const mdPath = path3.join(swarmDir, "plan.md");
-  const tempPlanPath = path3.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path6.join(directory, ".swarm");
+  const planPath = path6.join(swarmDir, "plan.json");
+  const mdPath = path6.join(swarmDir, "plan.md");
+  const tempPlanPath = path6.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(targetPlan, null, 2));
-  renameSync3(tempPlanPath, planPath);
+  renameSync5(tempPlanPath, planPath);
   try {
-    const markerPath = path3.join(swarmDir, ".plan-write-marker");
+    const markerPath = path6.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -1801,12 +2749,12 @@ async function rebuildPlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(targetPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const tempMdPath = path3.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const tempMdPath = path6.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(tempMdPath, markdownWithHash);
-    renameSync3(tempMdPath, mdPath);
+    renameSync5(tempMdPath, mdPath);
   } finally {
     try {
-      const markerPath = path3.join(swarmDir, ".plan-write-marker");
+      const markerPath = path6.join(swarmDir, ".plan-write-marker");
       const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager",
@@ -1869,13 +2817,13 @@ async function closePlanTerminalState(directory, plan, options) {
     planHashAfter: hashAfter,
     source: "close_terminal"
   });
-  const swarmDir = path3.join(directory, ".swarm");
-  const planPath = path3.join(swarmDir, "plan.json");
-  const tempPlanPath = path3.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path6.join(directory, ".swarm");
+  const planPath = path6.join(swarmDir, "plan.json");
+  const tempPlanPath = path6.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
-  renameSync3(tempPlanPath, planPath);
+  renameSync5(tempPlanPath, planPath);
   try {
-    const markerPath = path3.join(swarmDir, ".plan-write-marker");
+    const markerPath = path6.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager_close",
       timestamp: new Date().toISOString(),
@@ -1886,17 +2834,17 @@ async function closePlanTerminalState(directory, plan, options) {
     await bunWrite(markerPath, inProgressMarker);
   } catch {}
   try {
-    const mdPath = path3.join(swarmDir, "plan.md");
+    const mdPath = path6.join(swarmDir, "plan.md");
     const contentHash = computePlanContentHash(validated);
     const markdown = derivePlanMarkdown(validated);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdTempPath = path3.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdTempPath = path6.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync3(mdTempPath, mdPath);
+    renameSync5(mdTempPath, mdPath);
   } finally {
     try {
-      const markerPath = path3.join(swarmDir, ".plan-write-marker");
+      const markerPath = path6.join(swarmDir, ".plan-write-marker");
       const tasksCount = validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager_close",
@@ -2180,14 +3128,14 @@ function migrateLegacyPlan(planContent, swarmId) {
 
 // src/evidence/manager.ts
 import {
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync3,
   realpathSync,
   rmSync,
   statSync
 } from "fs";
-import * as fs3 from "fs/promises";
-import * as path4 from "path";
+import * as fs6 from "fs/promises";
+import * as path7 from "path";
 
 // src/config/evidence-schema.ts
 var EVIDENCE_MAX_JSON_BYTES = 500 * 1024;
@@ -2519,22 +3467,22 @@ function validateProjectRoot(directory) {
     if (depth >= MAX_DEPTH)
       break;
     depth++;
-    const parent = path4.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current)
       break;
-    const parentSwarm = path4.join(parent, ".swarm");
+    const parentSwarm = path7.join(parent, ".swarm");
     try {
       if (statSync(parentSwarm).isDirectory()) {
         let hasProjectIndicator = false;
         for (const indicator of PROJECT_INDICATORS) {
           try {
-            const indicatorStat = statSync(path4.join(parent, indicator));
+            const indicatorStat = statSync(path7.join(parent, indicator));
             if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
               hasProjectIndicator = true;
               break;
             }
-          } catch (error) {
-            if (error instanceof Error && "code" in error && error.code === "ENOENT") {} else {
+          } catch (error2) {
+            if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {} else {
               hasProjectIndicator = true;
               break;
             }
@@ -2545,30 +3493,30 @@ function validateProjectRoot(directory) {
           throw new Error(`Cannot write evidence in "${resolved}" \u2014 parent directory "${parent}" already contains a .swarm/ folder. Evidence must be written to the project root.`);
         }
       }
-    } catch (error) {
-      if (error instanceof Error && error.message.startsWith("Cannot write evidence")) {
-        throw error;
+    } catch (error2) {
+      if (error2 instanceof Error && error2.message.startsWith("Cannot write evidence")) {
+        throw error2;
       }
     }
     current = parent;
   }
 }
 async function saveEvidence(directory, taskId, evidence) {
-  _internals3.validateProjectRoot(directory);
+  _internals5.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path4.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path7.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path4.dirname(evidencePath);
+    const evidenceDir = path7.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     if (existingContent !== null) {
       try {
         const parsed = JSON.parse(existingContent);
         bundle = EvidenceBundleSchema.parse(parsed);
-      } catch (error) {
-        warn(`Existing evidence bundle invalid for task ${sanitizedTaskId}, creating new: ${error instanceof Error ? error.message : String(error)}`);
+      } catch (error2) {
+        warn(`Existing evidence bundle invalid for task ${sanitizedTaskId}, creating new: ${error2 instanceof Error ? error2.message : String(error2)}`);
         const now = new Date().toISOString();
         bundle = {
           schema_version: "1.0.0",
@@ -2602,16 +3550,16 @@ async function saveEvidence(directory, taskId, evidence) {
     if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
-    mkdirSync3(evidenceDir, { recursive: true });
-    const tempPath = path4.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    mkdirSync5(evidenceDir, { recursive: true });
+    const tempPath = path7.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
-      await fs3.rename(tempPath, evidencePath);
-    } catch (error) {
+      await fs6.rename(tempPath, evidencePath);
+    } catch (error2) {
       try {
         rmSync(tempPath, { force: true });
       } catch {}
-      throw error;
+      throw error2;
     }
     return updatedBundle;
   });
@@ -2647,7 +3595,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 }
 async function loadEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path4.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path7.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -2663,17 +3611,17 @@ async function loadEvidence(directory, taskId) {
     return { status: "invalid_schema", errors: ["Invalid JSON"] };
   }
   if (isFlatRetrospective(parsed)) {
-    const wrappedBundle = _internals3.wrapFlatRetrospective(parsed, sanitizedTaskId);
+    const wrappedBundle = _internals5.wrapFlatRetrospective(parsed, sanitizedTaskId);
     try {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       try {
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path4.dirname(evidencePath);
+          const evidenceDir = path7.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path4.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path7.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
-            await fs3.rename(tempPath, evidencePath);
+            await fs6.rename(tempPath, evidencePath);
           } catch (writeError) {
             try {
               rmSync(tempPath, { force: true });
@@ -2685,18 +3633,18 @@ async function loadEvidence(directory, taskId) {
         warn(`Evidence lock failed during flat-retrospective write-back for task ${sanitizedTaskId}: ${lockErr instanceof Error ? lockErr.message : String(lockErr)}`);
       }
       return { status: "found", bundle: validated };
-    } catch (error) {
-      warn(`Wrapped flat retrospective failed validation for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
-      const errors = error instanceof ZodError ? error.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error instanceof Error ? error.message : String(error)];
+    } catch (error2) {
+      warn(`Wrapped flat retrospective failed validation for task ${sanitizedTaskId}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      const errors = error2 instanceof ZodError ? error2.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error2 instanceof Error ? error2.message : String(error2)];
       return { status: "invalid_schema", errors };
     }
   }
   try {
     const validated = EvidenceBundleSchema.parse(parsed);
     return { status: "found", bundle: validated };
-  } catch (error) {
-    warn(`Evidence bundle validation failed for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
-    const errors = error instanceof ZodError ? error.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error instanceof Error ? error.message : String(error)];
+  } catch (error2) {
+    warn(`Evidence bundle validation failed for task ${sanitizedTaskId}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    const errors = error2 instanceof ZodError ? error2.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error2 instanceof Error ? error2.message : String(error2)];
     return { status: "invalid_schema", errors };
   }
 }
@@ -2715,7 +3663,7 @@ async function listEvidenceTaskIds(directory) {
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path4.join(evidenceBasePath, entry);
+    const entryPath = path7.join(evidenceBasePath, entry);
     try {
       const stats = statSync(entryPath);
       if (!stats.isDirectory()) {
@@ -2723,9 +3671,9 @@ async function listEvidenceTaskIds(directory) {
       }
       sanitizeTaskId2(entry);
       taskIds.push(entry);
-    } catch (error) {
-      if (error instanceof Error && !error.message.startsWith("Invalid task ID")) {
-        warn(`Error reading evidence entry '${entry}': ${error.message}`);
+    } catch (error2) {
+      if (error2 instanceof Error && !error2.message.startsWith("Invalid task ID")) {
+        warn(`Error reading evidence entry '${entry}': ${error2.message}`);
       }
     }
   }
@@ -2733,7 +3681,7 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path4.join("evidence", sanitizedTaskId);
+  const relativePath = path7.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
     statSync(evidenceDir);
@@ -2743,30 +3691,30 @@ async function deleteEvidence(directory, taskId) {
   try {
     rmSync(evidenceDir, { recursive: true, force: true });
     return true;
-  } catch (error) {
-    warn(`Failed to delete evidence for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
+  } catch (error2) {
+    warn(`Failed to delete evidence for task ${sanitizedTaskId}: ${error2 instanceof Error ? error2.message : String(error2)}`);
     return false;
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path4.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path4.resolve(directory, ".swarm", relativePath);
+  const relativePath = path7.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path7.resolve(directory, ".swarm", relativePath);
   try {
-    await fs3.access(absolutePath);
+    await fs6.access(absolutePath);
     return { exists: true, path: absolutePath };
   } catch {
     return { exists: false, path: absolutePath };
   }
 }
 async function archiveEvidence(directory, maxAgeDays, maxBundles) {
-  const taskIds = await _internals3.listEvidenceTaskIds(directory);
+  const taskIds = await _internals5.listEvidenceTaskIds(directory);
   const cutoffDate = new Date;
   cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
   const cutoffIso = cutoffDate.toISOString();
   const archived = [];
   const remainingBundles = [];
   for (const taskId of taskIds) {
-    const result = await _internals3.loadEvidence(directory, taskId);
+    const result = await _internals5.loadEvidence(directory, taskId);
     if (result.status !== "found") {
       continue;
     }
@@ -2794,7 +3742,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
   }
   return archived;
 }
-var _internals3 = {
+var _internals5 = {
   wrapFlatRetrospective,
   loadEvidence,
   listEvidenceTaskIds,
@@ -2911,4 +3859,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { PlanSchema, loadSddStatusSync, buildOpenSpecProjectionSync, readEffectiveSpecSync, writeProjectedSpecSync, computeSpecHash, derivePlanId, computePlanHash, initLedger, appendLedgerEvent, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, RetrospectiveEvidenceSchema, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { PlanSchema, getGitRepositoryStatus, isGitRepo, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, loadSddStatusSync, buildOpenSpecProjectionSync, readEffectiveSpecSync, writeProjectedSpecSync, computeSpecHash, derivePlanId, computePlanHash, initLedger, appendLedgerEvent, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, RetrospectiveEvidenceSchema, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };