opencode-swarm 7.107.5 → 7.108.0

package/dist/cli/{index-6h82c2h0.js → index-48mc4d48.js}

@@ -3,15 +3,16 @@ import {
   readEffectiveSpecSync
 } from "./index-91j1sqzm.js";
 import {
-  isValidTaskId,
-  readTaskEvidence,
-  readTaskEvidenceRaw,
-  sanitizeTaskId
-} from "./index-0kxc7t16.js";
+  _internals,
+  buildDefaultPolicy,
+  execute,
+  init_runner_client,
+  probe
+} from "./index-q1exe2b3.js";
 import {
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-57ymmh7h.js";
+} from "./index-r3j3458j.js";
 import {
   readCachedParsedFile
 } from "./index-jtqkh8jf.js";
@@ -21,20 +22,825 @@ import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  isValidTaskId,
+  readTaskEvidence,
+  readTaskEvidenceRaw,
+  sanitizeTaskId
+} from "./index-6jng9c8t.js";
 import {
   ZodError,
   exports_external
 } from "./index-293f68mj.js";
 import {
   withEvidenceLock
-} from "./index-3naa2ajc.js";
-import {
-  bunHash,
-  bunWrite
-} from "./index-b9v501fr.js";
+} from "./index-5mkc2f9z.js";
 import {
   emit
 } from "./index-vn263hqt.js";
+import {
+  bunHash,
+  bunWrite,
+  mergeEnvForChild
+} from "./index-7xgqky26.js";
+import {
+  __esm,
+  __export,
+  __require,
+  __toCommonJS
+} from "./index-a76rekgs.js";
+
+// src/sandbox/linux/bubblewrap-executor.ts
+import { spawnSync } from "child_process";
+function probeBwrap() {
+  try {
+    const result = spawnSync("bwrap", ["--version"], {
+      windowsHide: true,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (result.error) {
+      const code = result.error.code;
+      if (code && BWRAP_UNAVAILABLE_CODES.has(code)) {
+        warn(`Sandbox disabled: bwrap error (${code}). Falling through to tool-layer enforcement.`);
+        return false;
+      }
+      warn(`Sandbox disabled: bwrap spawn error (${result.error.message}). Falling through to tool-layer enforcement.`);
+      return false;
+    }
+    return result.status === BWRAP_VERSION_EXIT && result.stdout.trim().length > 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`Sandbox disabled: probe threw (${message}). Falling through to tool-layer enforcement.`);
+    return false;
+  }
+}
+function shellEscape(s) {
+  return s.replace(/'/g, "'\\''");
+}
+
+class BubblewrapSandboxExecutor {
+  mechanism = "Bubblewrap";
+  _scopePaths;
+  _tempDir;
+  _available;
+  _disabledReason;
+  constructor(scopePaths = [], tempDir) {
+    this._scopePaths = scopePaths;
+    this._tempDir = tempDir;
+    this._available = false;
+    this._disabledReason = null;
+    try {
+      if (!_internals2.probeBwrap()) {
+        this._disabledReason = "bwrap not available or not functional";
+        warn(`Sandbox disabled: ${this._disabledReason}. Falling through to tool-layer enforcement.`);
+      } else {
+        this._available = true;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._disabledReason = `constructor threw: ${message}`;
+      this._available = false;
+      warn(`Sandbox disabled: ${this._disabledReason}. Falling through to tool-layer enforcement.`);
+    }
+  }
+  isAvailable() {
+    return this._available;
+  }
+  disable(reason) {
+    this._available = false;
+    this._disabledReason = reason;
+    warn(`Sandbox disabled: ${reason}. Falling through to tool-layer enforcement.`);
+  }
+  wrapCommand(command, scopePaths, tempDir, envOverrides) {
+    if (!this._available) {
+      throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
+    }
+    const temp = tempDir ?? this._tempDir ?? "/tmp";
+    const allScopes = [...this._scopePaths, ...scopePaths];
+    const bindArgs = allScopes.flatMap((p) => [
+      "--bind",
+      `'${shellEscape(p)}'`,
+      `'${shellEscape(p)}'`
+    ]);
+    const envArgs = [];
+    if (envOverrides) {
+      for (const [key, value] of Object.entries(envOverrides)) {
+        if (!isValidEnvKey(key)) {
+          continue;
+        }
+        if (value === null) {
+          envArgs.push("--unsetenv", key);
+        } else {
+          envArgs.push("--setenv", key, value);
+        }
+      }
+    }
+    const args = [
+      "--unshare-user",
+      "--unshare-net",
+      "--unshare-ipc",
+      "--die-with-parent",
+      "--new-session",
+      "--cap-drop",
+      "ALL",
+      ...bindArgs,
+      "--dev",
+      "/dev",
+      "--size",
+      "500M",
+      "--tmpfs",
+      `'${shellEscape(temp)}'`,
+      "--ro-bind",
+      "/etc",
+      "/etc",
+      "--ro-bind",
+      "/usr",
+      "/usr",
+      "--ro-bind",
+      "/lib",
+      "/lib",
+      "--ro-bind",
+      "/lib64",
+      "/lib64",
+      "--proc",
+      "/proc",
+      "--unshare-pid",
+      ...envArgs,
+      "--",
+      "bash",
+      "-c",
+      `'${shellEscape(command)}'`
+    ];
+    return `bwrap ${args.join(" ")}`;
+  }
+  getEnvOverrides() {
+    return {};
+  }
+}
+var BWRAP_VERSION_EXIT = 0, BWRAP_UNAVAILABLE_CODES, _internals2;
+var init_bubblewrap_executor = __esm(() => {
+  init_logger();
+  init_executor();
+  BWRAP_UNAVAILABLE_CODES = new Set(["ENOENT", "EACCES", "ENOSPC"]);
+  _internals2 = {
+    probeBwrap
+  };
+});
+
+// src/sandbox/executors/bubblewrap.ts
+var exports_bubblewrap = {};
+__export(exports_bubblewrap, {
+  BubblewrapSandboxExecutor: () => BubblewrapSandboxExecutor
+});
+var init_bubblewrap = __esm(() => {
+  init_bubblewrap_executor();
+});
+
+// src/sandbox/macos/sandbox-exec-executor.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { mkdtempSync, writeFileSync } from "fs";
+import * as os from "os";
+import * as path from "path";
+function probeSandboxExec() {
+  try {
+    const result = spawnSync2("sandbox-exec", ["--version"], {
+      windowsHide: true,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (result.error) {
+      const code = result.error.code;
+      if (code && SANDBOX_UNAVAILABLE_CODES.has(code)) {
+        warn(`Sandbox disabled: sandbox-exec error (${code}). Falling through to tool-layer enforcement.`);
+        return false;
+      }
+      warn(`Sandbox disabled: spawn error (${result.error.message}). Falling through to tool-layer enforcement.`);
+      return false;
+    }
+    return result.status === 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`Sandbox disabled: probe threw (${message}). Falling through to tool-layer enforcement.`);
+    return false;
+  }
+}
+function shellEscape2(s) {
+  return s.replace(/'/g, "'\\''");
+}
+function sbplEscapePath(path2) {
+  const withoutControlChars = path2.split("").filter((ch) => {
+    const cp = ch.codePointAt(0);
+    return cp >= 32 && cp !== 127;
+  }).join("");
+  return withoutControlChars.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function buildSandboxProfile(scopePaths, tempDir, envOverrides) {
+  const rwPaths = [...scopePaths];
+  if (tempDir) {
+    rwPaths.push(tempDir);
+  }
+  const rwAllowLines = rwPaths.map((p) => `(allow file-write* (subpath "${sbplEscapePath(p)}"))`).join(`
+`);
+  const envLines = [];
+  if (envOverrides) {
+    for (const [key, value] of Object.entries(envOverrides)) {
+      if (!isValidEnvKey(key)) {
+        continue;
+      }
+      if (value === null) {
+        envLines.push(`(unsetenv ${key})`);
+      } else {
+        const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+        envLines.push(`(setenv ${key} "${escaped}")`);
+      }
+    }
+  }
+  const profile = `(version 1)
+(allow default)
+(allow file-read* (subpath "/usr"))
+(allow file-read* (subpath "/bin"))
+(allow file-read* (subpath "/sbin"))
+(allow file-read* (subpath "/lib"))
+(allow file-read* (subpath "/lib64"))
+${rwAllowLines}
+${envLines.join(`
+`)}
+(deny file-write*)`;
+  return profile;
+}
+
+class MacOSSandboxExecutor {
+  mechanism = "sandbox-exec";
+  _scopePaths;
+  _tempDir;
+  _available;
+  _disabledReason;
+  constructor(scopePaths = [], tempDir) {
+    if (process.platform !== "darwin") {
+      throw new Error("MacOSSandboxExecutor not yet implemented");
+    }
+    this._scopePaths = scopePaths;
+    this._tempDir = tempDir;
+    this._available = false;
+    this._disabledReason = null;
+    try {
+      if (!_internals3.probeSandboxExec()) {
+        this._disabledReason = "sandbox-exec not available or not functional";
+        warn(`Sandbox disabled: ${this._disabledReason}. Falling through to tool-layer enforcement.`);
+      } else {
+        this._available = true;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._disabledReason = `constructor threw: ${message}`;
+      this._available = false;
+      warn(`Sandbox disabled: ${this._disabledReason}. Falling through to tool-layer enforcement.`);
+    }
+  }
+  isAvailable() {
+    return this._available;
+  }
+  disable(reason) {
+    this._disabledReason = reason;
+    this._available = false;
+    warn(`Sandbox disabled: ${reason}. Falling through to tool-layer enforcement.`);
+  }
+  wrapCommand(command, scopePaths, tempDir, envOverrides) {
+    if (!this._available) {
+      throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
+    }
+    if (!_internals3.probeSandboxExec()) {
+      this._available = false;
+      this._disabledReason = "sandbox-exec became unavailable between calls";
+      warn(`Sandbox disabled: ${this._disabledReason}. Falling through to tool-layer enforcement.`);
+      throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
+    }
+    const temp = tempDir ?? this._tempDir ?? os.tmpdir();
+    const allScopes = [...this._scopePaths, ...scopePaths];
+    const profile = buildSandboxProfile(allScopes, temp, envOverrides);
+    let profilePath;
+    try {
+      const profileDir = mkdtempSync(path.join(os.tmpdir(), "sandbox-"));
+      profilePath = path.join(profileDir, `profile-${process.pid}-${Date.now()}.sb`);
+      writeFileSync(profilePath, profile, { mode: 384 });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      warn(`Sandbox disabled: failed to write profile (${message}). Falling through to tool-layer enforcement.`);
+      throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
+    }
+    const escapedCommand = shellEscape2(command);
+    const escapedProfilePath = shellEscape2(profilePath);
+    return `sandbox-exec -f '${escapedProfilePath}' bash -c '${escapedCommand}'`;
+  }
+  getEnvOverrides() {
+    return {
+      DYLD_INSERT_LIBRARIES: null,
+      DYLD_LIBRARY_PATH: null,
+      DYLD_FRAMEWORK_PATH: null,
+      DYLD_ROOT_PATH: null,
+      PATH: "/usr/bin:/bin:/usr/sbin:/sbin"
+    };
+  }
+}
+var SANDBOX_UNAVAILABLE_CODES, _internals3;
+var init_sandbox_exec_executor = __esm(() => {
+  init_logger();
+  init_executor();
+  SANDBOX_UNAVAILABLE_CODES = new Set(["ENOENT", "EACCES", "ENOSPC"]);
+  _internals3 = {
+    probeSandboxExec
+  };
+});
+
+// src/sandbox/executors/macos.ts
+var exports_macos = {};
+__export(exports_macos, {
+  MacOSSandboxExecutor: () => MacOSSandboxExecutor
+});
+var init_macos = __esm(() => {
+  init_sandbox_exec_executor();
+});
+
+// src/sandbox/win32/edge-cases.ts
+function detectPowerShellEscape(command) {
+  if (process.platform !== "win32")
+    return false;
+  const encodedCommandPattern = /-EncodedCommand/i;
+  if (encodedCommandPattern.test(command)) {
+    return true;
+  }
+  const encodedBase64Pattern = /-Enc(odedCommand)?\s+[A-Za-z0-9+/=]+/i;
+  if (encodedBase64Pattern.test(command)) {
+    return true;
+  }
+  const psExePattern = /powershell\.exe?\s+.*-(?:e(?:n(?:c(?:odedCommand)?)?)?|wmi|remote)/i;
+  if (psExePattern.test(command)) {
+    return true;
+  }
+  const iexPattern = /\biex\b/i;
+  if (iexPattern.test(command)) {
+    return true;
+  }
+  const invokeExpressionPattern = /Invoke-Expression/i;
+  if (invokeExpressionPattern.test(command)) {
+    return true;
+  }
+  const invokeCommandRemotePattern = /Invoke-Command\s+.*-ComputerName/i;
+  if (invokeCommandRemotePattern.test(command)) {
+    return true;
+  }
+  const psCommandPattern = /powershell.*-Command\s+["'].*\$/i;
+  if (psCommandPattern.test(command)) {
+    return true;
+  }
+  const execPolicyPattern = /-ExecutionPolicy\s+(?:Bypass|RemoteSigned|Unrestricted)/i;
+  if (execPolicyPattern.test(command)) {
+    return true;
+  }
+  const noProfilePattern = /-NoProfile\s+-/i;
+  if (noProfilePattern.test(command)) {
+    return true;
+  }
+  const automationPattern = /New-Object\s+.*Management\.Automation/i;
+  if (automationPattern.test(command)) {
+    return true;
+  }
+  const downloadPattern = /\[System\.Net\.(?:WebClient|Http).*\]\.(?:DownloadString|DownloadFile)/i;
+  if (downloadPattern.test(command)) {
+    return true;
+  }
+  const hiddenWindowPattern = /-WindowStyle\s+Hidden/i;
+  if (hiddenWindowPattern.test(command)) {
+    return true;
+  }
+  const scriptInjectionPattern = /\$(?:env|input|host)\b.*\|/i;
+  if (scriptInjectionPattern.test(command)) {
+    return true;
+  }
+  const obfuscatedIexPattern = /IEX|i:eX/i;
+  if (obfuscatedIexPattern.test(command)) {
+    return true;
+  }
+  return false;
+}
+var init_edge_cases = () => {};
+
+// src/sandbox/win32/restricted-environment-executor.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import * as os2 from "os";
+import * as path2 from "path";
+function probeWindowsSandbox() {
+  try {
+    const result = spawnSync3("cmd", ["/c", "echo", "ok"], {
+      windowsHide: true,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (result.error) {
+      const code = result.error.code;
+      if (code && SANDBOX_UNAVAILABLE_CODES2.has(code)) {
+        warn(`Sandbox disabled: spawn error (${code}). Falling through to tool-layer enforcement.`);
+        return false;
+      }
+      warn(`Sandbox disabled: spawn error (${result.error.message}). Falling through to tool-layer enforcement.`);
+      return false;
+    }
+    return result.status === 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`Sandbox disabled: probe threw (${message}). Falling through to tool-layer enforcement.`);
+    return false;
+  }
+}
+function psStringEscape(s) {
+  return s.replace(/[`"$]/g, "`$&");
+}
+function getSafeWindowsPath() {
+  const raw = process.env.SystemRoot;
+  const isValid = typeof raw === "string" && raw.length > 0 && /^[A-Za-z]:[\\/](?:[^\\/;"'<>|*?\r\n]+[\\/]?)*$/.test(raw);
+  const sysRoot = isValid ? raw : "C:\\Windows";
+  return `${sysRoot}\\System32;${sysRoot}`;
+}
+function isPowerShellNativeCommand(command) {
+  return /^(?:Remove-Item|rm|del|erase|Copy-Item|cp|copy|Move-Item|mv|move|Rename-Item|ren|New-Item|ni|Get-Item|gi|Get-ChildItem|ls|dir|gci|Get-Content|cat|type|gc|Set-Content|sc|Add-Content|ac|Clear-Content|clc|Test-Path|Resolve-Path|Split-Path|Join-Path|Out-File|Get-Date)\b/i.test(command.trimStart());
+}
+function isSafePsCommandBody(command) {
+  return !/[;&|`$()\r\n]/.test(command);
+}
+function isPathInScopes(command, scopes) {
+  if (scopes.length === 0)
+    return true;
+  const pathPattern = /[A-Za-z]:(?:[^\\/:*?"<>|\r\n]+(?:\\[^\\/:*?"<>|\r\n]+)*)/g;
+  const paths = command.match(pathPattern) || [];
+  if (paths.length === 0)
+    return true;
+  const normalizedPaths = paths.map((p) => path2.win32.resolve(p));
+  const normalizedScopes = scopes.map((s) => s.toLowerCase().replace(/\\+$/, ""));
+  return normalizedPaths.every((p) => {
+    const lower = p.toLowerCase();
+    return normalizedScopes.some((scope) => lower.startsWith(scope));
+  });
+}
+
+class WindowsSandboxExecutor {
+  mechanism = "powershell-wrapper";
+  _scopePaths;
+  _tempDir;
+  _available;
+  _disabled;
+  _disabledReason;
+  constructor(scopePaths = [], tempDir) {
+    this._scopePaths = scopePaths;
+    this._tempDir = tempDir;
+    this._available = false;
+    this._disabled = false;
+    this._disabledReason = null;
+    try {
+      if (!_internals4.probeWindowsSandbox()) {
+        this._available = false;
+        this._disabledReason = "Windows sandbox not available or not functional";
+        warn(`Sandbox unavailable: ${this._disabledReason}. Falling through to tool-layer enforcement.`);
+      } else {
+        this._available = true;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._available = false;
+      this._disabledReason = `constructor probe threw: ${message}`;
+      warn(`Sandbox unavailable: ${this._disabledReason}. Falling through to tool-layer enforcement.`);
+    }
+  }
+  isAvailable() {
+    return this._available && !this._disabled;
+  }
+  disable(reason) {
+    this._disabled = true;
+    this._disabledReason = reason;
+    warn(`Sandbox disabled: ${reason}. Falling through to tool-layer enforcement.`);
+  }
+  wrapCommand(command, scopePaths, tempDir, envOverrides) {
+    if (!this.isAvailable()) {
+      throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
+    }
+    if (!_internals4.probeWindowsSandbox()) {
+      this._available = false;
+      this._disabledReason = "Windows sandbox became unavailable between calls";
+      warn(`Sandbox disabled: ${this._disabledReason}. Falling through to tool-layer enforcement.`);
+      throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
+    }
+    const temp = tempDir ?? this._tempDir ?? os2.tmpdir();
+    const _allScopes = [...this._scopePaths, ...scopePaths];
+    if (detectPowerShellEscape(command)) {
+      throw new SandboxError("Command contains PowerShell escape patterns", "DETECT_POWERSHELL_ESCAPE");
+    }
+    if (!isPathInScopes(command, _allScopes)) {
+      throw new SandboxError("Command targets paths outside authorized scopes", "PATH_ESCAPE_SCOPE");
+    }
+    if (isPowerShellNativeCommand(command) && !isSafePsCommandBody(command)) {
+      throw new SandboxError("PowerShell-native command body contains unsafe characters", "UNSAFE_PS_COMMAND");
+    }
+    const safePath = getSafeWindowsPath();
+    const escapedTemp = psStringEscape(temp);
+    const escapedCommand = psStringEscape(command);
+    const envOverrideLines = [];
+    if (envOverrides) {
+      for (const [key, value] of Object.entries(envOverrides)) {
+        if (!isValidEnvKey(key)) {
+          continue;
+        }
+        if (value === null) {
+          envOverrideLines.push(`Remove-Item Env:${key} -Force -ErrorAction SilentlyContinue;`);
+        } else {
+          const psEscaped = value.replace(/'/g, "''");
+          envOverrideLines.push(`$env:${key} = '${psEscaped}';`);
+        }
+      }
+    }
+    const commandExec = isPowerShellNativeCommand(command) ? `Invoke-Expression "${escapedCommand}"` : `cmd /c "${escapedCommand}"`;
+    const envOverrideBlock = envOverrideLines.length > 0 ? `
+  ${envOverrideLines.join(`
+  `)}` : "";
+    const psScript = `
+$ErrorActionPreference = 'Stop';
+try {
+  # Set scoped temp directory
+  $env:TEMP = '${escapedTemp}';
+  $env:TMP = '${escapedTemp}';
+
+  # Restrict PATH to safe system paths only
+  $env:PATH = '${safePath}';
+
+  # Remove dangerous environment variables that could be used to bypass restrictions
+  # Note: LD_PRELOAD, DYLD_* don't apply on Windows but we clear them for completeness
+  $dangerousVars = @(
+    'LD_PRELOAD',
+    'DYLD_INSERT_LIBRARIES',
+    'DYLD_LIBRARY_PATH',
+    'DYLD_FRAMEWORK_PATH',
+    'DYLD_ROOT_PATH',
+    'DYLD_FORCE_FLAT_NAMESPACE'
+  );
+  foreach ($v in $dangerousVars) {
+    if (Test-Path Env:$v) {
+      Remove-Item Env:$v -Force -ErrorAction SilentlyContinue;
+    }
+  }
+  ${envOverrideBlock}
+
+  # Execute the command \u2014 PS-native cmdlets via Invoke-Expression, others via the standard command interpreter
+  ${commandExec};
+} catch {
+  Write-Error $_.Exception.Message;
+  exit 1;
+}`;
+    return `powershell -ExecutionPolicy Bypass -NoProfile -WindowStyle Hidden -Command "${psScript.replace(/\n/g, " ").trim()}"`;
+  }
+  getEnvOverrides() {
+    return {
+      PATH: getSafeWindowsPath(),
+      TEMP: null,
+      TMP: null,
+      LD_PRELOAD: null,
+      DYLD_INSERT_LIBRARIES: null,
+      DYLD_LIBRARY_PATH: null,
+      DYLD_FRAMEWORK_PATH: null,
+      DYLD_ROOT_PATH: null,
+      DYLD_FORCE_FLAT_NAMESPACE: null
+    };
+  }
+}
+var SANDBOX_UNAVAILABLE_CODES2, _internals4;
+var init_restricted_environment_executor = __esm(() => {
+  init_logger();
+  init_executor();
+  init_edge_cases();
+  SANDBOX_UNAVAILABLE_CODES2 = new Set([
+    "ENOENT",
+    "EACCES",
+    "EPERM",
+    "ENOSPC"
+  ]);
+  _internals4 = {
+    probeWindowsSandbox
+  };
+});
+
+// src/sandbox/win32/native-sandbox-executor.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as os3 from "os";
+import * as path3 from "path";
+
+class NativeWindowsSandboxExecutor {
+  mechanism;
+  _probeResult;
+  _fallbackExecutor;
+  _strength;
+  _disabled;
+  _disabledReason;
+  constructor(scopePaths = [], tempDir) {
+    this._disabled = false;
+    this._disabledReason = null;
+    this._fallbackExecutor = new WindowsSandboxExecutor(scopePaths, tempDir);
+    this._probeResult = probe();
+    if (this._probeResult.available) {
+      this._strength = "strong";
+      this.mechanism = `native-runner/${this._probeResult.mode}`;
+    } else if (this._fallbackExecutor.isAvailable()) {
+      this._strength = "weak";
+      this.mechanism = "powershell-wrapper";
+      warn(`Native sandbox runner unavailable (${this._probeResult.error ?? "unknown"}); ` + "falling back to PowerShell environment restrictions (weak sandbox)");
+    } else {
+      this._strength = "none";
+      this.mechanism = "none";
+    }
+  }
+  get strength() {
+    if (this._disabled)
+      return "none";
+    return this._strength;
+  }
+  isAvailable() {
+    return !this._disabled && this._strength !== "none";
+  }
+  disable(reason) {
+    this._disabled = true;
+    this._disabledReason = reason;
+    warn(`Sandbox disabled: ${reason}. Falling through to tool-layer enforcement.`);
+  }
+  wrapCommand(command, scopePaths, tempDir, envOverrides) {
+    if (!this.isAvailable()) {
+      throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
+    }
+    if (this._strength === "strong") {
+      return this._wrapWithRunner(command, scopePaths, tempDir, envOverrides);
+    }
+    return this._fallbackExecutor.wrapCommand(command, scopePaths, tempDir, envOverrides);
+  }
+  _wrapWithRunner(command, scopePaths, tempDir, _envOverrides) {
+    const binary = _internals.findRunnerBinary();
+    if (!binary) {
+      throw new SandboxError("Runner binary not found", "RUNNER_NOT_FOUND");
+    }
+    const workspaceRoot = scopePaths[0] ?? process.cwd();
+    const runId = `swarm-${crypto.randomUUID?.() ?? Date.now()}`;
+    const policy = buildDefaultPolicy(workspaceRoot, runId);
+    if (tempDir) {
+      policy.temp_root = tempDir;
+    }
+    policy.workspace_roots = scopePaths.length > 0 ? scopePaths : [workspaceRoot];
+    policy.writable_roots = policy.workspace_roots;
+    if (_envOverrides) {
+      for (const [key, value] of Object.entries(_envOverrides)) {
+        if (!isValidEnvKey(key))
+          continue;
+        if (typeof value === "string") {
+          policy.env_overrides[key] = value;
+        }
+      }
+    }
+    const policyJson = JSON.stringify(policy);
+    const policyDir = path3.join(os3.tmpdir(), "swarm-sandbox-policies");
+    try {
+      fs.mkdirSync(policyDir, { recursive: true });
+    } catch {}
+    const policyFile = path3.join(policyDir, `${runId}.json`);
+    fs.writeFileSync(policyFile, policyJson, "utf-8");
+    const mode = this._probeResult.mode === "none" ? "auto" : this._probeResult.mode;
+    const escapedBinary = binary.includes(" ") ? `"${binary}"` : binary;
+    const escapedPolicyFile = policyFile.includes(" ") ? `"${policyFile}"` : policyFile;
+    const escapedCommand = command.replace(/"/g, "\\\"");
+    return `cmd /c "type ${escapedPolicyFile} | ${escapedBinary} --policy-stdin --mode ${mode} -- ${escapedCommand} & del ${escapedPolicyFile} 2>nul"`;
+  }
+  getEnvOverrides() {
+    if (this._strength === "strong") {
+      return {
+        PATH: null,
+        TEMP: null,
+        TMP: null,
+        LD_PRELOAD: null,
+        DYLD_INSERT_LIBRARIES: null,
+        DYLD_LIBRARY_PATH: null,
+        DYLD_FRAMEWORK_PATH: null,
+        DYLD_ROOT_PATH: null,
+        DYLD_FORCE_FLAT_NAMESPACE: null
+      };
+    }
+    return this._fallbackExecutor.getEnvOverrides();
+  }
+  async executeNative(command, workspaceRoot, runId) {
+    if (this._strength !== "strong") {
+      throw new SandboxError("Native execution requires strong sandbox (runner binary)", "NATIVE_UNAVAILABLE");
+    }
+    const policy = buildDefaultPolicy(workspaceRoot, runId);
+    return execute(command, policy);
+  }
+  get hasNativeRunner() {
+    return this._strength === "strong";
+  }
+  get disabledReason() {
+    return this._disabledReason;
+  }
+  get probeResult() {
+    return this._probeResult;
+  }
+}
+var init_native_sandbox_executor = __esm(() => {
+  init_logger();
+  init_executor();
+  init_restricted_environment_executor();
+  init_runner_client();
+});
+
+// src/sandbox/executors/windows.ts
+var exports_windows = {};
+__export(exports_windows, {
+  WindowsSandboxExecutor: () => NativeWindowsSandboxExecutor,
+  LegacyWindowsSandboxExecutor: () => WindowsSandboxExecutor
+});
+var init_windows = __esm(() => {
+  init_native_sandbox_executor();
+  init_restricted_environment_executor();
+});
+
+// src/sandbox/executor.ts
+function isValidEnvKey(key) {
+  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key);
+}
+async function getExecutor() {
+  if (_cachedExecutorPromise !== undefined) {
+    return _cachedExecutorPromise;
+  }
+  _cachedExecutorPromise = _createExecutor();
+  return _cachedExecutorPromise;
+}
+async function _createExecutor() {
+  const platform = process.platform;
+  if (platform === "linux") {
+    return _createLinuxExecutor();
+  }
+  if (platform === "darwin") {
+    return _createMacOSExecutor();
+  }
+  if (platform === "win32") {
+    return _createWindowsExecutor();
+  }
+  return null;
+}
+async function _createLinuxExecutor() {
+  const { SandboxCapabilityProbe, isBubblewrapAvailable } = await import("./capability-probe-sh9bwh39.js");
+  await new SandboxCapabilityProbe().detect();
+  if (!isBubblewrapAvailable()) {
+    return null;
+  }
+  try {
+    const { BubblewrapSandboxExecutor: BubblewrapSandboxExecutor2 } = (init_bubblewrap(), __toCommonJS(exports_bubblewrap));
+    return new BubblewrapSandboxExecutor2([]);
+  } catch {
+    return null;
+  }
+}
+async function _createMacOSExecutor() {
+  const { SandboxCapabilityProbe, isSandboxExecAvailable } = await import("./capability-probe-sh9bwh39.js");
+  await new SandboxCapabilityProbe().detect();
+  if (!isSandboxExecAvailable()) {
+    return null;
+  }
+  try {
+    const { MacOSSandboxExecutor: MacOSSandboxExecutor2 } = (init_macos(), __toCommonJS(exports_macos));
+    return new MacOSSandboxExecutor2([]);
+  } catch {
+    return null;
+  }
+}
+async function _createWindowsExecutor() {
+  const { SandboxCapabilityProbe, isWindowsSandboxAvailable } = await import("./capability-probe-sh9bwh39.js");
+  await new SandboxCapabilityProbe().detect();
+  if (!isWindowsSandboxAvailable()) {
+    return null;
+  }
+  try {
+    const { WindowsSandboxExecutor: WindowsSandboxExecutor2 } = (init_windows(), __toCommonJS(exports_windows));
+    return new WindowsSandboxExecutor2([]);
+  } catch {
+    return null;
+  }
+}
+var SandboxError, _cachedExecutorPromise;
+var init_executor = __esm(() => {
+  SandboxError = class SandboxError extends Error {
+    code;
+    constructor(message, code) {
+      super(message);
+      this.code = code;
+      this.name = "SandboxError";
+    }
+  };
+});
 
 // src/plan/manager.ts
 import {
@@ -45,7 +851,7 @@ import {
   unlinkSync as unlinkSync3
 } from "fs";
 import * as fsPromises from "fs/promises";
-import * as path5 from "path";
+import * as path9 from "path";
 
 // src/config/plan-schema.ts
 var ExecutionProfileSchema = exports_external.object({
@@ -109,8 +915,10 @@ var PlanSchema = exports_external.object({
 });
 
 // src/git/branch.ts
+init_executor();
 import * as child_process from "child_process";
-import path from "path";
+import * as fsSync from "fs";
+import path4 from "path";
 
 // src/utils/git-binary-missing-error.ts
 class GitBinaryMissingError extends Error {
@@ -157,11 +965,11 @@ function windowsGitCandidates() {
   const roots = unique([
     process.env.ProgramFiles ?? "",
     process.env["ProgramFiles(x86)"] ?? "",
-    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, "Programs") : ""
+    process.env.LOCALAPPDATA ? path4.join(process.env.LOCALAPPDATA, "Programs") : ""
   ]);
   const installed = roots.flatMap((root) => [
-    path.join(root, "Git", "cmd", "git.exe"),
-    path.join(root, "Git", "bin", "git.exe")
+    path4.join(root, "Git", "cmd", "git.exe"),
+    path4.join(root, "Git", "bin", "git.exe")
   ]);
   return unique(["git", ...installed]);
 }
@@ -172,20 +980,59 @@ function isNotGitRepositoryMessage(message) {
   const lower = message.toLowerCase();
   return lower.includes("not a git repository") || lower.includes("not a git repo");
 }
-function gitExec(args, cwd) {
+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 = path4.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;
+    result[k] = v;
+  }
+  return result;
+}
+function gitExec(args, cwd, laneEnv, laneIndex) {
+  const resolvedLaneEnv = laneEnv ?? (laneIndex !== undefined ? readLaneEnvFileFromDiskSync(cwd, laneIndex) : undefined);
   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()) {
     for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
-      const result = child_process.spawnSync(command, hardenedArgs, {
+      const result = _internals5.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" }
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+        envOverrides: resolvedLaneEnv
       });
       if (!result.error && result.status === 0) {
         return result.stdout;
@@ -231,8 +1078,8 @@ function getGitRepositoryStatus(cwd) {
 function isGitRepo(cwd) {
   return getGitRepositoryStatus(cwd).isRepo;
 }
-function getCurrentBranch(cwd) {
-  const output = gitExec(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+function getCurrentBranch(cwd, laneEnv, laneIndex) {
+  const output = gitExec(["rev-parse", "--abbrev-ref", "HEAD"], cwd, laneEnv, laneIndex);
   return output.trim();
 }
 function getDefaultBaseBranch(cwd) {
@@ -248,8 +1095,8 @@ function getDefaultBaseBranch(cwd) {
     }
   }
 }
-function hasUncommittedChanges(cwd) {
-  const status = gitExec(["status", "--porcelain"], cwd);
+function hasUncommittedChanges(cwd, laneEnv, laneIndex) {
+  const status = gitExec(["status", "--porcelain"], cwd, laneEnv, laneIndex);
   return status.trim().length > 0;
 }
 function detectDefaultRemoteBranch(cwd) {
@@ -283,7 +1130,7 @@ async function resetToRemoteBranch(cwd, options) {
   const prunedBranches = [];
   try {
     const currentBranch = getCurrentBranch(cwd);
-    const defaultRemoteBranch = _internals.detectDefaultRemoteBranch(cwd);
+    const defaultRemoteBranch = _internals5.detectDefaultRemoteBranch(cwd);
     if (!defaultRemoteBranch) {
       return {
         success: false,
@@ -465,7 +1312,7 @@ var GITIGNORED_BUILD_ARTIFACTS = ["dist"];
 async function resetToMainAfterMerge(cwd, options) {
   const warnings = [];
   try {
-    const defaultBranch = _internals.detectDefaultRemoteBranch(cwd);
+    const defaultBranch = _internals5.detectDefaultRemoteBranch(cwd);
     if (!defaultBranch) {
       return {
         success: false,
@@ -492,7 +1339,7 @@ async function resetToMainAfterMerge(cwd, options) {
     }
     if (currentBranch === defaultBranch) {
       try {
-        const logOutput = _internals.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
+        const logOutput = _internals5.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
         if (logOutput.trim().length > 0) {
           return {
             success: false,
@@ -507,11 +1354,11 @@ async function resetToMainAfterMerge(cwd, options) {
       } catch {}
     } else {
       try {
-        _internals.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
+        _internals5.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();
+          const localSha = _internals5.gitExec(["rev-parse", "HEAD"], cwd).trim();
+          const remoteSha = _internals5.gitExec(["rev-parse", targetBranch], cwd).trim();
           if (localSha !== remoteSha) {
             return {
               success: false,
@@ -537,7 +1384,7 @@ async function resetToMainAfterMerge(cwd, options) {
       }
     }
     try {
-      _internals.gitExec(["fetch", "--prune", "origin"], cwd);
+      _internals5.gitExec(["fetch", "--prune", "origin"], cwd);
     } catch (err) {
       return {
         success: false,
@@ -553,7 +1400,7 @@ async function resetToMainAfterMerge(cwd, options) {
     let switchedBranch = false;
     if (currentBranch !== defaultBranch) {
       try {
-        _internals.gitExec(["checkout", defaultBranch], cwd);
+        _internals5.gitExec(["checkout", defaultBranch], cwd);
         switchedBranch = true;
       } catch (err) {
         return {
@@ -568,7 +1415,7 @@ async function resetToMainAfterMerge(cwd, options) {
       }
     }
     try {
-      _internals.gitExec(["reset", "--hard", targetBranch], cwd);
+      _internals5.gitExec(["reset", "--hard", targetBranch], cwd);
     } catch (err) {
       return {
         success: false,
@@ -588,7 +1435,7 @@ async function resetToMainAfterMerge(cwd, options) {
           await new Promise((resolve) => setTimeout(resolve, 500));
         }
         try {
-          _internals.gitExec(["checkout", "--", "."], cwd);
+          _internals5.gitExec(["checkout", "--", "."], cwd);
           discardSucceeded = true;
           break;
         } catch {}
@@ -599,18 +1446,18 @@ async function resetToMainAfterMerge(cwd, options) {
       changesDiscarded = discardSucceeded;
     }
     try {
-      _internals.gitExec(["clean", "-fdX", "--", ...GITIGNORED_BUILD_ARTIFACTS], cwd);
+      _internals5.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 mergedOutput = _internals5.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);
+          _internals5.gitExec(["branch", "-d", previousBranch], cwd);
           branchDeleted = true;
         } else {
           warnings.push(`Branch ${previousBranch} is not merged into ${defaultBranch} \u2014 keeping it`);
@@ -621,7 +1468,7 @@ async function resetToMainAfterMerge(cwd, options) {
     }
     if (options?.pruneBranches) {
       try {
-        const mergedOutput = _internals.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const mergedOutput = _internals5.gitExec(["branch", "--merged", defaultBranch], cwd);
         const mergedLines = mergedOutput.split(`
 `);
         for (const line of mergedLines) {
@@ -630,7 +1477,7 @@ async function resetToMainAfterMerge(cwd, options) {
             continue;
           }
           try {
-            _internals.gitExec(["branch", "-d", trimmedLine], cwd);
+            _internals5.gitExec(["branch", "-d", trimmedLine], cwd);
           } catch {
             warnings.push(`Could not prune branch: ${trimmedLine}`);
           }
@@ -660,28 +1507,31 @@ async function resetToMainAfterMerge(cwd, options) {
     };
   }
 }
-var _internals = {
+var _internals5 = {
   gitExec,
   detectDefaultRemoteBranch,
   getDefaultBaseBranch,
   getGitRepositoryStatus,
   resetToRemoteBranch,
-  resetToMainAfterMerge
+  resetToMainAfterMerge,
+  spawnSync: __spawnSyncSeam.spawnSync,
+  readLaneEnvFileFromDiskSync
 };
 
 // src/hooks/delegation-gate/worktree-merge-status.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
+import * as path5 from "path";
 var failuresByTask = new Map;
 var durableStatusPath;
 var hasLoaded = false;
 function loadDurableStatus(statusPath) {
   try {
     hasLoaded = true;
-    if (!fs.existsSync(statusPath)) {
+    if (!fs2.existsSync(statusPath)) {
       failuresByTask.clear();
       return;
     }
-    const data = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+    const data = JSON.parse(fs2.readFileSync(statusPath, "utf-8"));
     if (data && typeof data === "object") {
       failuresByTask.clear();
       for (const [taskId, failure] of Object.entries(data)) {
@@ -692,25 +1542,39 @@ function loadDurableStatus(statusPath) {
     failuresByTask.clear();
   }
 }
+function initDurableStatusPath(projectDir) {
+  const nextPath = path5.join(projectDir, ".swarm", "worktree-merge-status.json");
+  if (durableStatusPath === nextPath && hasLoaded)
+    return;
+  durableStatusPath = nextPath;
+  hasLoaded = false;
+  loadDurableStatus(durableStatusPath);
+}
 function getWorktreeMergeFailure(taskId) {
   if (!hasLoaded && durableStatusPath) {
     loadDurableStatus(durableStatusPath);
   }
   return failuresByTask.get(taskId);
 }
+function getAllWorktreeMergeFailures() {
+  if (!hasLoaded && durableStatusPath) {
+    loadDurableStatus(durableStatusPath);
+  }
+  return failuresByTask.entries();
+}
 
 // src/turbo/epic/state.ts
 init_logger();
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path6 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 });
+  const swarmDir = path6.resolve(directory, ".swarm");
+  if (!fs3.existsSync(swarmDir)) {
+    fs3.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -730,17 +1594,17 @@ function markStateUnreadable(directory, reason) {
 }
 function readPersisted(directory) {
   try {
-    const filePath = path2.join(directory, ".swarm", STATE_FILE);
-    if (!fs2.existsSync(filePath)) {
+    const filePath = path6.join(directory, ".swarm", STATE_FILE);
+    if (!fs3.existsSync(filePath)) {
       const seed = emptyPersisted();
       try {
         ensureSwarmDir(directory);
-        fs2.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs3.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs2.readFileSync(filePath, "utf-8");
+    const raw = fs3.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})`);
@@ -766,7 +1630,7 @@ function writePersisted(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir(directory);
-    filePath = path2.join(directory, ".swarm", STATE_FILE);
+    filePath = path6.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)}
@@ -777,14 +1641,14 @@ function writePersisted(directory, persisted) {
     throw new Error(`Epic state persistence prepare failed: ${msg}`);
   }
   try {
-    fs2.writeFileSync(tmpPath, payload, "utf-8");
-    fs2.renameSync(tmpPath, filePath);
+    fs3.writeFileSync(tmpPath, payload, "utf-8");
+    fs3.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);
+      if (fs3.existsSync(tmpPath))
+        fs3.unlinkSync(tmpPath);
     } catch {}
     throw new Error(`Epic state persistence failed: ${msg}`);
   }
@@ -815,7 +1679,7 @@ function isEpicModeActive(directory, sessionID) {
 function isEpicModeActiveForProject(directory) {
   if (stateUnreadableMap.get(directory))
     return false;
-  if (!fs2.existsSync(path2.join(directory, ".swarm", STATE_FILE))) {
+  if (!fs3.existsSync(path6.join(directory, ".swarm", STATE_FILE))) {
     return false;
   }
   const persisted = readPersisted(directory);
@@ -866,11 +1730,11 @@ function isLockContentionError(err) {
   return INDEX_LOCK_ERROR_RE.test(msg);
 }
 async function commitTaskCompletion(directory, taskId, description, scopePaths) {
-  if (!_internals2.isGitRepo(directory)) {
+  if (!_internals6.isGitRepo(directory)) {
     return { committed: false, reason: "no-git" };
   }
   try {
-    if (_internals2.hasExistingTaskCommit(directory, taskId)) {
+    if (_internals6.hasExistingTaskCommit(directory, taskId)) {
       return { committed: true, reason: "idempotent-skip" };
     }
   } catch {}
@@ -891,15 +1755,15 @@ async function commitTaskCompletion(directory, taskId, description, scopePaths)
   for (let attempt = 0;attempt <= INDEX_LOCK_BACKOFF_MS.length; attempt++) {
     try {
       if (paths.length > 0) {
-        _internals2.stageScopedPaths(directory, paths);
+        _internals6.stageScopedPaths(directory, paths);
       }
-      _internals2.commitAllowEmpty(directory, message);
-      const sha = _internals2.gitHeadSha(directory);
+      _internals6.commitAllowEmpty(directory, message);
+      const sha = _internals6.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]);
+        await _internals6.sleep(INDEX_LOCK_BACKOFF_MS[attempt]);
         continue;
       }
       break;
@@ -909,26 +1773,26 @@ async function commitTaskCompletion(directory, taskId, description, scopePaths)
   criticalWarn(`[epic:task-commit] commit for task ${taskId} failed (non-fatal): ${msg}`);
   return { committed: false, reason: "commit-failed", error: msg };
 }
-var _internals2 = {
+var _internals6 = {
   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);
+      _internals5.gitExec(["add", "--", ...chunk, ":(exclude,glob)**/.swarm/**"], cwd);
     }
   },
   commitAllowEmpty: (cwd, message) => {
-    _internals.gitExec(["commit", "--allow-empty", "--no-verify", "-m", message], cwd);
+    _internals5.gitExec(["commit", "--allow-empty", "--no-verify", "-m", message], cwd);
   },
   gitHeadSha: (cwd) => {
-    return _internals.gitExec(["rev-parse", "HEAD"], cwd).trim();
+    return _internals5.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([
+    const output = _internals5.gitExec([
       "log",
       "--extended-regexp",
       `--grep=^swarm\\(task ${escaped}\\):`,
@@ -941,8 +1805,8 @@ var _internals2 = {
 };
 
 // src/turbo/lean/conflicts.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path7 from "path";
 
 // src/utils/path.ts
 function normalizePath(p) {
@@ -1070,12 +1934,12 @@ function isProtectedPath(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path3.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path7.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
-    if (!fs3.existsSync(scopePath)) {
+    if (!fs4.existsSync(scopePath)) {
       return null;
     }
-    const raw = fs3.readFileSync(scopePath, "utf-8");
+    const raw = fs4.readFileSync(scopePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.files)) {
       return null;
@@ -1088,16 +1952,16 @@ function readTaskScopes(directory, taskId) {
 
 // src/utils/spec-hash.ts
 import { createHash } from "crypto";
-import * as fsSync from "fs";
-import { join as join3 } from "path";
+import * as fsSync2 from "fs";
+import { join as join6 } from "path";
 async function computeSpecHash(directory) {
-  const spec = _internals3.readEffectiveSpecSync(directory);
+  const spec = _internals7.readEffectiveSpecSync(directory);
   if (!spec)
     return null;
   return createHash("sha256").update(spec.content, "utf-8").digest("hex");
 }
 async function isSpecStale(directory, plan) {
-  const currentHash = await _internals3.computeSpecHash(directory);
+  const currentHash = await _internals7.computeSpecHash(directory);
   if (!plan.specHash) {
     return { stale: false };
   }
@@ -1118,15 +1982,15 @@ async function isSpecStale(directory, plan) {
   return { stale: false };
 }
 function isObligationPreserving(directory) {
-  const snapshotPath = join3(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join6(directory, ".swarm", "spec-snapshot.md");
   try {
     let recordedContent;
     try {
-      recordedContent = fsSync.readFileSync(snapshotPath, "utf-8");
+      recordedContent = fsSync2.readFileSync(snapshotPath, "utf-8");
     } catch {
       return false;
     }
-    const currentResult = _internals3.readEffectiveSpecSync(directory);
+    const currentResult = _internals7.readEffectiveSpecSync(directory);
     if (!currentResult || !currentResult.content) {
       return false;
     }
@@ -1156,7 +2020,7 @@ function isObligationPreserving(directory) {
     return false;
   }
 }
-var _internals3 = {
+var _internals7 = {
   computeSpecDiff,
   computeSpecHash,
   isObligationPreserving,
@@ -1164,19 +2028,19 @@ var _internals3 = {
   readEffectiveSpecSync
 };
 function computeSpecDiff(directory) {
-  const snapshotPath = join3(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join6(directory, ".swarm", "spec-snapshot.md");
   let recordedContent;
   try {
-    const snapshotSize = fsSync.statSync(snapshotPath).size;
+    const snapshotSize = fsSync2.statSync(snapshotPath).size;
     const MAX_SNAPSHOT_BYTES = 512 * 1024;
     if (snapshotSize > MAX_SNAPSHOT_BYTES) {
       return null;
     }
-    recordedContent = fsSync.readFileSync(snapshotPath, "utf-8");
+    recordedContent = fsSync2.readFileSync(snapshotPath, "utf-8");
   } catch {
     return null;
   }
-  const spec = _internals3.readEffectiveSpecSync(directory);
+  const spec = _internals7.readEffectiveSpecSync(directory);
   if (!spec) {
     return null;
   }
@@ -1250,9 +2114,9 @@ function computeLcsDiff(oldLines, newLines) {
 }
 
 // src/plan/ledger.ts
-import * as crypto from "crypto";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as crypto2 from "crypto";
+import * as fs5 from "fs";
+import * as path8 from "path";
 
 // src/plan/utils.ts
 function derivePlanId(plan) {
@@ -1262,7 +2126,7 @@ function derivePlanId(plan) {
 // src/plan/ledger.ts
 var LEDGER_SCHEMA_VERSION = "1.1.0";
 var LEDGER_FILENAME = "plan-ledger.jsonl";
-var LEDGER_LOCK_PATH = path4.join(".swarm", LEDGER_FILENAME);
+var LEDGER_LOCK_PATH = path8.join(".swarm", LEDGER_FILENAME);
 var PLAN_JSON_FILENAME = "plan.json";
 
 class LedgerStaleWriterError extends Error {
@@ -1272,10 +2136,10 @@ class LedgerStaleWriterError extends Error {
   }
 }
 function getLedgerPath(directory) {
-  return path4.join(directory, ".swarm", LEDGER_FILENAME);
+  return path8.join(directory, ".swarm", LEDGER_FILENAME);
 }
 function getPlanJsonPath(directory) {
-  return path4.join(directory, ".swarm", PLAN_JSON_FILENAME);
+  return path8.join(directory, ".swarm", PLAN_JSON_FILENAME);
 }
 function computePlanHash(plan) {
   const normalized = {
@@ -1305,12 +2169,12 @@ function computePlanHash(plan) {
     }))
   };
   const jsonString = JSON.stringify(normalized);
-  return crypto.createHash("sha256").update(jsonString, "utf8").digest("hex");
+  return crypto2.createHash("sha256").update(jsonString, "utf8").digest("hex");
 }
 function computeCurrentPlanHash(directory) {
   const planPath = getPlanJsonPath(directory);
   try {
-    const content = fs4.readFileSync(planPath, "utf8");
+    const content = fs5.readFileSync(planPath, "utf8");
     const plan = JSON.parse(content);
     return computePlanHash(plan);
   } catch {
@@ -1319,15 +2183,15 @@ function computeCurrentPlanHash(directory) {
 }
 async function ledgerExists(directory) {
   const ledgerPath = getLedgerPath(directory);
-  return fs4.existsSync(ledgerPath);
+  return fs5.existsSync(ledgerPath);
 }
 async function getLatestLedgerSeq(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs4.existsSync(ledgerPath)) {
+  if (!fs5.existsSync(ledgerPath)) {
     return 0;
   }
   try {
-    const content = fs4.readFileSync(ledgerPath, "utf8");
+    const content = fs5.readFileSync(ledgerPath, "utf8");
     const lines = content.trim().split(`
 `).filter((line) => line.trim() !== "");
     if (lines.length === 0) {
@@ -1349,11 +2213,11 @@ async function getLatestLedgerSeq(directory) {
 }
 async function readLedgerEvents(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs4.existsSync(ledgerPath)) {
+  if (!fs5.existsSync(ledgerPath)) {
     return [];
   }
   try {
-    const content = fs4.readFileSync(ledgerPath, "utf8");
+    const content = fs5.readFileSync(ledgerPath, "utf8");
     const lines = content.trim().split(`
 `).filter((line) => line.trim() !== "");
     const events = [];
@@ -1378,15 +2242,15 @@ async function readLedgerEvents(directory) {
 async function initLedger(directory, planId, initialPlanHash, initialPlan) {
   const ledgerPath = getLedgerPath(directory);
   const planJsonPath = getPlanJsonPath(directory);
-  if (fs4.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 (fs4.existsSync(planJsonPath)) {
-        const content = fs4.readFileSync(planJsonPath, "utf8");
+      if (fs5.existsSync(planJsonPath)) {
+        const content = fs5.readFileSync(planJsonPath, "utf8");
         const plan = JSON.parse(content);
         planHashAfter = computePlanHash(plan);
         if (!embeddedPlan)
@@ -1406,12 +2270,12 @@ async function initLedger(directory, planId, initialPlanHash, initialPlan) {
     schema_version: LEDGER_SCHEMA_VERSION,
     ...payload ? { payload } : {}
   };
-  fs4.mkdirSync(path4.join(directory, ".swarm"), { recursive: true });
+  fs5.mkdirSync(path8.join(directory, ".swarm"), { recursive: true });
   const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
-  fs4.writeFileSync(tempPath, line, "utf8");
-  fs4.renameSync(tempPath, ledgerPath);
+  fs5.writeFileSync(tempPath, line, "utf8");
+  fs5.renameSync(tempPath, ledgerPath);
 }
 async function appendLedgerEvent(directory, eventInput, options) {
   return withEvidenceLock(directory, LEDGER_LOCK_PATH, "plan-ledger", "append-ledger-event", async () => {
@@ -1434,17 +2298,17 @@ async function appendLedgerEvent(directory, eventInput, options) {
       plan_hash_after: planHashAfter,
       schema_version: LEDGER_SCHEMA_VERSION
     };
-    fs4.mkdirSync(path4.join(directory, ".swarm"), { recursive: true });
+    fs5.mkdirSync(path8.join(directory, ".swarm"), { recursive: true });
     const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
     const line = `${JSON.stringify(event)}
 `;
-    if (fs4.existsSync(ledgerPath)) {
-      const existingContent = fs4.readFileSync(ledgerPath, "utf8");
-      fs4.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.");
     }
-    fs4.renameSync(tempPath, ledgerPath);
+    fs5.renameSync(tempPath, ledgerPath);
     return event;
   });
 }
@@ -1532,12 +2396,12 @@ async function replayFromLedger(directory, _options) {
     }
   }
   const planJsonPath = getPlanJsonPath(directory);
-  if (!fs4.existsSync(planJsonPath)) {
+  if (!fs5.existsSync(planJsonPath)) {
     return null;
   }
   let plan;
   try {
-    const content = fs4.readFileSync(planJsonPath, "utf8");
+    const content = fs5.readFileSync(planJsonPath, "utf8");
     plan = JSON.parse(content);
   } catch {
     return null;
@@ -1632,11 +2496,11 @@ function applyEventToPlan(plan, event) {
 }
 async function readLedgerEventsWithIntegrity(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs4.existsSync(ledgerPath)) {
+  if (!fs5.existsSync(ledgerPath)) {
     return { events: [], truncated: false, badSuffix: null };
   }
   try {
-    const content = fs4.readFileSync(ledgerPath, "utf8");
+    const content = fs5.readFileSync(ledgerPath, "utf8");
     const lines = content.split(`
 `);
     const events = [];
@@ -1665,9 +2529,9 @@ async function readLedgerEventsWithIntegrity(directory) {
 }
 async function quarantineLedgerSuffix(directory, badSuffix) {
   try {
-    const quarantinePath = path4.join(directory, ".swarm", "plan-ledger.quarantine");
-    fs4.writeFileSync(quarantinePath, badSuffix, "utf8");
-    console.warn(`[ledger] Corrupted suffix quarantined to ${path4.relative(directory, quarantinePath)}`);
+    const quarantinePath = path8.join(directory, ".swarm", "plan-ledger.quarantine");
+    fs5.writeFileSync(quarantinePath, badSuffix, "utf8");
+    console.warn(`[ledger] Corrupted suffix quarantined to ${path8.relative(directory, quarantinePath)}`);
   } catch {}
 }
 async function loadLastApprovedPlan(directory, expectedPlanId) {
@@ -1726,7 +2590,7 @@ var startupLedgerCheckedWorkspaces = new Set;
 var ledgerStaleWorkspaces = new Set;
 var recoveryMutexes = new Map;
 var PLAN_JSON_CACHE_NAMESPACE = "plan-json:validated:v1";
-var _internals4 = {
+var _internals8 = {
   loadPlan,
   loadPlanJsonOnly,
   regeneratePlanMarkdown,
@@ -1866,7 +2730,7 @@ async function getLatestLedgerHash(directory) {
   }
 }
 async function surfaceLedgerStaleIfPersisted(directory, plan) {
-  const resolvedWorkspace = path5.resolve(directory);
+  const resolvedWorkspace = path9.resolve(directory);
   if (!ledgerStaleWorkspaces.has(resolvedWorkspace)) {
     return plan;
   }
@@ -1885,7 +2749,7 @@ async function surfaceLedgerStaleIfPersisted(directory, plan) {
   return plan;
 }
 async function parsePlanJsonCached(directory) {
-  const planJsonPath = path5.resolve(directory, ".swarm", "plan.json");
+  const planJsonPath = path9.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");
@@ -1945,13 +2809,13 @@ async function isPlanMdInSync(directory, plan, cache) {
   return false;
 }
 async function regeneratePlanMarkdown(directory, plan) {
-  const swarmDir = path5.resolve(directory, ".swarm");
+  const swarmDir = path9.resolve(directory, ".swarm");
   const contentHash = computePlanContentHash(plan);
   const markdown = derivePlanMarkdown(plan);
   const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-  const mdPath = path5.join(swarmDir, "plan.md");
-  const mdTempPath = path5.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const mdPath = path9.join(swarmDir, "plan.md");
+  const mdTempPath = path9.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(mdTempPath, markdownWithHash);
     renameSync4(mdTempPath, mdPath);
@@ -1975,7 +2839,7 @@ async function loadPlan(directory, cache) {
           const inSync = await isPlanMdInSync(directory, validated, cache);
           if (!inSync) {
             try {
-              await _internals4.regeneratePlanMarkdown(directory, validated);
+              await _internals8.regeneratePlanMarkdown(directory, validated);
             } catch (regenError) {
               warn(`Failed to regenerate plan.md: ${regenError instanceof Error ? regenError.message : String(regenError)}. Proceeding with plan.json only.`);
             }
@@ -1983,7 +2847,7 @@ async function loadPlan(directory, cache) {
           if (await ledgerExists(directory)) {
             const planHash = computePlanHash(validated);
             const ledgerHash = await getLatestLedgerHash(directory);
-            const resolvedWorkspace = path5.resolve(directory);
+            const resolvedWorkspace = path9.resolve(directory);
             if (!startupLedgerCheckedWorkspaces.has(resolvedWorkspace)) {
               startupLedgerCheckedWorkspaces.add(resolvedWorkspace);
               if (ledgerHash !== "" && planHash !== ledgerHash) {
@@ -2049,7 +2913,7 @@ async function loadPlan(directory, cache) {
               if (!preserving) {
                 try {
                   const diffInfo = computeSpecDiff(directory);
-                  const specStalenessPath = path5.join(directory, ".swarm", "spec-staleness.json");
+                  const specStalenessPath = path9.join(directory, ".swarm", "spec-staleness.json");
                   await fsPromises.writeFile(specStalenessPath, JSON.stringify({
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -2063,7 +2927,7 @@ async function loadPlan(directory, cache) {
                   }, null, 2), "utf-8");
                 } catch {}
                 try {
-                  const eventsPath = path5.join(directory, ".swarm", "events.jsonl");
+                  const eventsPath = path9.join(directory, ".swarm", "events.jsonl");
                   const event = {
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -2129,11 +2993,11 @@ async function loadPlan(directory, cache) {
     return migrated;
   }
   if (await ledgerExists(directory)) {
-    const resolvedDir = path5.resolve(directory);
+    const resolvedDir = path9.resolve(directory);
     const existingMutex = recoveryMutexes.get(resolvedDir);
     if (existingMutex) {
       await existingMutex;
-      const postRecoveryPlan = await _internals4.loadPlanJsonOnly(directory);
+      const postRecoveryPlan = await _internals8.loadPlanJsonOnly(directory);
       if (postRecoveryPlan)
         return postRecoveryPlan;
     }
@@ -2193,7 +3057,7 @@ async function loadPlan(directory, cache) {
   return null;
 }
 async function savePlanWithAutoAcknowledgedRemovals(directory, plan, source, reason, options) {
-  const existing = await _internals4.loadPlanJsonOnly(directory);
+  const existing = await _internals8.loadPlanJsonOnly(directory);
   const newIds = new Set;
   for (const phase of plan.phases) {
     for (const task of phase.tasks)
@@ -2221,7 +3085,7 @@ async function savePlan(directory, plan, options) {
   const validated = PlanSchema.parse(plan);
   if (options?.preserveCompletedStatuses !== false) {
     try {
-      const currentPlan2 = await _internals4.loadPlanJsonOnly(directory);
+      const currentPlan2 = await _internals8.loadPlanJsonOnly(directory);
       if (currentPlan2) {
         const completedTaskIds = new Set;
         for (const phase of currentPlan2.phases) {
@@ -2243,7 +3107,7 @@ async function savePlan(directory, plan, options) {
     } catch {}
   }
   derivePhaseStatusesInPlace(validated);
-  const currentPlan = await _internals4.loadPlanJsonOnly(directory);
+  const currentPlan = await _internals8.loadPlanJsonOnly(directory);
   const planId = derivePlanId(validated);
   const planHashForInit = computePlanHash(validated);
   if (!await ledgerExists(directory)) {
@@ -2258,9 +3122,9 @@ async function savePlan(directory, plan, options) {
   } else {
     const existingEvents = await readLedgerEvents(directory);
     if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
-      const swarmDir2 = path5.resolve(directory, ".swarm");
-      const oldLedgerPath = path5.join(swarmDir2, "plan-ledger.jsonl");
-      const oldLedgerBackupPath = path5.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+      const swarmDir2 = path9.resolve(directory, ".swarm");
+      const oldLedgerPath = path9.join(swarmDir2, "plan-ledger.jsonl");
+      const oldLedgerBackupPath = path9.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
       let backupExists = false;
       if (existsSync5(oldLedgerPath)) {
         try {
@@ -2298,7 +3162,7 @@ async function savePlan(directory, plan, options) {
         }
       }
       if (initSucceeded && backupExists) {
-        const archivePath = path5.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+        const archivePath = path9.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
         try {
           renameSync4(oldLedgerBackupPath, archivePath);
           warn(`[savePlan] Ledger identity mismatch (was "${existingEvents[0].plan_id}", now "${planId}") \u2014 archived old ledger to ${archivePath} and reinitializing.`);
@@ -2323,7 +3187,7 @@ async function savePlan(directory, plan, options) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
           for (const file of toRemove) {
             try {
-              unlinkSync3(path5.join(swarmDir2, file));
+              unlinkSync3(path9.join(swarmDir2, file));
             } catch {}
           }
         }
@@ -2388,7 +3252,7 @@ async function savePlan(directory, plan, options) {
             expectedHash: currentHash,
             planHashAfter: hashAfter,
             verifyValid: async () => {
-              const onDisk = await _internals4.loadPlanJsonOnly(directory);
+              const onDisk = await _internals8.loadPlanJsonOnly(directory);
               if (!onDisk)
                 return true;
               for (const p of onDisk.phases) {
@@ -2426,7 +3290,7 @@ async function savePlan(directory, plan, options) {
               expectedHash: currentHash,
               planHashAfter: hashAfter,
               verifyValid: async () => {
-                const onDisk = await _internals4.loadPlanJsonOnly(directory);
+                const onDisk = await _internals8.loadPlanJsonOnly(directory);
                 if (!onDisk)
                   return true;
                 for (const p of onDisk.phases) {
@@ -2466,9 +3330,9 @@ async function savePlan(directory, plan, options) {
       source: "savePlan_manager"
     });
   }
-  const swarmDir = path5.resolve(directory, ".swarm");
-  const planPath = path5.join(swarmDir, "plan.json");
-  const tempPath = path5.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path9.resolve(directory, ".swarm");
+  const planPath = path9.join(swarmDir, "plan.json");
+  const tempPath = path9.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(tempPath, JSON.stringify(projectedPlan, null, 2));
     renameSync4(tempPath, planPath);
@@ -2478,7 +3342,7 @@ async function savePlan(directory, plan, options) {
     } catch {}
   }
   try {
-    const markerPath = path5.join(swarmDir, ".plan-write-marker");
+    const markerPath = path9.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -2493,8 +3357,8 @@ async function savePlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(projectedPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdPath = path5.join(swarmDir, "plan.md");
-    const mdTempPath = path5.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdPath = path9.join(swarmDir, "plan.md");
+    const mdTempPath = path9.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await bunWrite(mdTempPath, markdownWithHash);
       renameSync4(mdTempPath, mdPath);
@@ -2515,7 +3379,7 @@ ${markdown}`;
     } catch {}
   }
   try {
-    const markerPath = path5.join(swarmDir, ".plan-write-marker");
+    const markerPath = path9.join(swarmDir, ".plan-write-marker");
     const tasksCount = projectedPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
     const marker = JSON.stringify({
       source: "plan_manager",
@@ -2531,14 +3395,14 @@ async function rebuildPlan(directory, plan, options) {
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
-  const swarmDir = path5.join(directory, ".swarm");
-  const planPath = path5.join(swarmDir, "plan.json");
-  const mdPath = path5.join(swarmDir, "plan.md");
-  const tempPlanPath = path5.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path9.join(directory, ".swarm");
+  const planPath = path9.join(swarmDir, "plan.json");
+  const mdPath = path9.join(swarmDir, "plan.md");
+  const tempPlanPath = path9.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(targetPlan, null, 2));
   renameSync4(tempPlanPath, planPath);
   try {
-    const markerPath = path5.join(swarmDir, ".plan-write-marker");
+    const markerPath = path9.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -2553,12 +3417,12 @@ async function rebuildPlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(targetPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const tempMdPath = path5.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const tempMdPath = path9.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(tempMdPath, markdownWithHash);
     renameSync4(tempMdPath, mdPath);
   } finally {
     try {
-      const markerPath = path5.join(swarmDir, ".plan-write-marker");
+      const markerPath = path9.join(swarmDir, ".plan-write-marker");
       const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager",
@@ -2621,13 +3485,13 @@ async function closePlanTerminalState(directory, plan, options) {
     planHashAfter: hashAfter,
     source: "close_terminal"
   });
-  const swarmDir = path5.join(directory, ".swarm");
-  const planPath = path5.join(swarmDir, "plan.json");
-  const tempPlanPath = path5.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path9.join(directory, ".swarm");
+  const planPath = path9.join(swarmDir, "plan.json");
+  const tempPlanPath = path9.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
   renameSync4(tempPlanPath, planPath);
   try {
-    const markerPath = path5.join(swarmDir, ".plan-write-marker");
+    const markerPath = path9.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager_close",
       timestamp: new Date().toISOString(),
@@ -2638,17 +3502,17 @@ async function closePlanTerminalState(directory, plan, options) {
     await bunWrite(markerPath, inProgressMarker);
   } catch {}
   try {
-    const mdPath = path5.join(swarmDir, "plan.md");
+    const mdPath = path9.join(swarmDir, "plan.md");
     const contentHash = computePlanContentHash(validated);
     const markdown = derivePlanMarkdown(validated);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdTempPath = path5.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdTempPath = path9.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(mdTempPath, markdownWithHash);
     renameSync4(mdTempPath, mdPath);
   } finally {
     try {
-      const markerPath = path5.join(swarmDir, ".plan-write-marker");
+      const markerPath = path9.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",
@@ -2932,15 +3796,15 @@ function migrateLegacyPlan(planContent, swarmId) {
 
 // src/evidence/manager.ts
 import {
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
   realpathSync,
   rmSync,
   statSync as statSync2
 } from "fs";
-import * as fs5 from "fs/promises";
-import * as os from "os";
-import * as path6 from "path";
+import * as fs6 from "fs/promises";
+import * as os4 from "os";
+import * as path10 from "path";
 
 // src/config/evidence-schema.ts
 var EVIDENCE_MAX_JSON_BYTES = 500 * 1024;
@@ -3261,10 +4125,10 @@ var PROJECT_INDICATORS = [
 function isWeakConfigContainerRoot(directory) {
   try {
     const resolved = realpathSync(directory);
-    return resolved === realpathSync(os.tmpdir()) || resolved === realpathSync(os.homedir());
+    return resolved === realpathSync(os4.tmpdir()) || resolved === realpathSync(os4.homedir());
   } catch {
-    const resolved = path6.resolve(directory);
-    return resolved === path6.resolve(os.tmpdir()) || resolved === path6.resolve(os.homedir());
+    const resolved = path10.resolve(directory);
+    return resolved === path10.resolve(os4.tmpdir()) || resolved === path10.resolve(os4.homedir());
   }
 }
 function hasAccessibleProjectIndicator(directory, options = {}) {
@@ -3274,7 +4138,7 @@ function hasAccessibleProjectIndicator(directory, options = {}) {
       continue;
     }
     try {
-      const indicatorStat = statSync2(path6.join(directory, indicator));
+      const indicatorStat = statSync2(path10.join(directory, indicator));
       if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
         return true;
       }
@@ -3296,14 +4160,14 @@ function validateProjectRoot(directory) {
     if (depth >= MAX_DEPTH)
       break;
     depth++;
-    const parent = path6.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current)
       break;
-    if (path6.dirname(parent) === parent) {
+    if (path10.dirname(parent) === parent) {
       current = parent;
       continue;
     }
-    const parentSwarm = path6.join(parent, ".swarm");
+    const parentSwarm = path10.join(parent, ".swarm");
     try {
       if (statSync2(parentSwarm).isDirectory()) {
         if (hasAccessibleProjectIndicator(parent, {
@@ -3322,14 +4186,14 @@ function validateProjectRoot(directory) {
   }
 }
 async function saveEvidence(directory, taskId, evidence) {
-  _internals5.validateProjectRoot(directory);
+  _internals9.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path6.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path10.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
-  _internals5.validateEvidence(evidence);
+  _internals9.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path6.dirname(evidencePath);
+    const evidenceDir = path10.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     if (existingContent !== null) {
@@ -3371,11 +4235,11 @@ 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)`);
     }
-    mkdirSync4(evidenceDir, { recursive: true });
-    const tempPath = path6.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    mkdirSync5(evidenceDir, { recursive: true });
+    const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
-      await fs5.rename(tempPath, evidencePath);
+      await fs6.rename(tempPath, evidencePath);
     } catch (error2) {
       try {
         rmSync(tempPath, { force: true });
@@ -3416,7 +4280,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 }
 async function loadEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path6.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path10.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -3432,17 +4296,17 @@ async function loadEvidence(directory, taskId) {
     return { status: "invalid_schema", errors: ["Invalid JSON"] };
   }
   if (isFlatRetrospective(parsed)) {
-    const wrappedBundle = _internals5.wrapFlatRetrospective(parsed, sanitizedTaskId);
+    const wrappedBundle = _internals9.wrapFlatRetrospective(parsed, sanitizedTaskId);
     try {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       try {
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path6.dirname(evidencePath);
+          const evidenceDir = path10.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path6.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
-            await fs5.rename(tempPath, evidencePath);
+            await fs6.rename(tempPath, evidencePath);
           } catch (writeError) {
             try {
               rmSync(tempPath, { force: true });
@@ -3484,7 +4348,7 @@ async function listEvidenceTaskIds(directory) {
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path6.join(evidenceBasePath, entry);
+    const entryPath = path10.join(evidenceBasePath, entry);
     try {
       const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
@@ -3502,7 +4366,7 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path6.join("evidence", sanitizedTaskId);
+  const relativePath = path10.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
     statSync2(evidenceDir);
@@ -3518,24 +4382,24 @@ async function deleteEvidence(directory, taskId) {
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path6.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path6.resolve(directory, ".swarm", relativePath);
+  const relativePath = path10.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path10.resolve(directory, ".swarm", relativePath);
   try {
-    await fs5.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 _internals5.listEvidenceTaskIds(directory);
+  const taskIds = await _internals9.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 _internals5.loadEvidence(directory, taskId);
+    const result = await _internals9.loadEvidence(directory, taskId);
     if (result.status !== "found") {
       continue;
     }
@@ -3566,7 +4430,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
 function validateEvidence(evidence) {
   return EvidenceSchema.parse(evidence);
 }
-var _internals5 = {
+var _internals9 = {
   wrapFlatRetrospective,
   loadEvidence,
   listEvidenceTaskIds,
@@ -3685,4 +4549,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { PlanSchema, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, 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, getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, resetToRemoteBranch, resetToMainAfterMerge, initDurableStatusPath, getAllWorktreeMergeFailures, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, 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 };