opencode-swarm 7.152.1 → 7.153.1

package/dist/cli/{index-85gkedsf.js → index-4fwbbad3.js}

@@ -169,7 +169,7 @@ class MacOSSandboxExecutor {
     this._available = false;
     warn(`Sandbox disabled: ${reason}. Falling through to tool-layer enforcement.`);
   }
-  wrapCommand(command, scopePaths, tempDir, envOverrides) {
+  wrapCommand(command, scopePaths, tempDir, envOverrides, _policy) {
     if (!this._available) {
       throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
     }
@@ -878,16 +878,16 @@ class NativeWindowsSandboxExecutor {
     this._disabledReason = reason;
     warn(`Sandbox disabled: ${reason}. Falling through to tool-layer enforcement.`);
   }
-  wrapCommand(command, scopePaths, tempDir, envOverrides) {
+  wrapCommand(command, scopePaths, tempDir, envOverrides, policy) {
     if (!this.isAvailable()) {
       throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
     }
     if (this._strength === "strong") {
-      return this._wrapWithRunner(command, scopePaths, tempDir, envOverrides);
+      return this._wrapWithRunner(command, scopePaths, tempDir, envOverrides, policy);
     }
     return this._fallbackExecutor.wrapCommand(command, scopePaths, tempDir, envOverrides);
   }
-  _wrapWithRunner(command, scopePaths, tempDir, _envOverrides) {
+  _wrapWithRunner(command, scopePaths, tempDir, _envOverrides, policyOverride) {
     const binary = _internals3.findRunnerBinary();
     if (!binary) {
       throw new SandboxError("Runner binary not found", "RUNNER_NOT_FOUND");
@@ -899,7 +899,8 @@ class NativeWindowsSandboxExecutor {
       policy.temp_root = tempDir;
     }
     policy.workspace_roots = scopePaths.length > 0 ? scopePaths : [workspaceRoot];
-    policy.writable_roots = policy.workspace_roots;
+    policy.writable_roots = policyOverride?.writable_roots && policyOverride.writable_roots.length > 0 ? [...policyOverride.writable_roots] : policy.workspace_roots;
+    policy.network_mode = policyOverride?.network_mode ?? policy.network_mode;
     if (_envOverrides) {
       for (const [key, value] of Object.entries(_envOverrides)) {
         if (!isValidEnvKey(key))
@@ -1006,8 +1007,8 @@ async function _createExecutor() {
   return null;
 }
 async function _createLinuxExecutor() {
-  const { SandboxCapabilityProbe, isBubblewrapAvailable } = await import("./capability-probe-va4kk8vg.js");
-  await new SandboxCapabilityProbe().detect();
+  const { SandboxCapabilityProbe: SandboxCapabilityProbe2, isBubblewrapAvailable } = await import("./capability-probe-5wa7mcp6.js");
+  await new SandboxCapabilityProbe2().detect();
   if (!isBubblewrapAvailable()) {
     return null;
   }
@@ -1026,8 +1027,8 @@ async function _createMacOSExecutor() {
     }
     return null;
   }
-  const { SandboxCapabilityProbe, isSandboxExecAvailable } = await import("./capability-probe-va4kk8vg.js");
-  await new SandboxCapabilityProbe().detect();
+  const { SandboxCapabilityProbe: SandboxCapabilityProbe2, isSandboxExecAvailable } = await import("./capability-probe-5wa7mcp6.js");
+  await new SandboxCapabilityProbe2().detect();
   if (!isSandboxExecAvailable()) {
     return null;
   }
@@ -1039,8 +1040,8 @@ async function _createMacOSExecutor() {
   }
 }
 async function _createWindowsExecutor() {
-  const { SandboxCapabilityProbe, isWindowsSandboxAvailable } = await import("./capability-probe-va4kk8vg.js");
-  await new SandboxCapabilityProbe().detect();
+  const { SandboxCapabilityProbe: SandboxCapabilityProbe2, isWindowsSandboxAvailable } = await import("./capability-probe-5wa7mcp6.js");
+  await new SandboxCapabilityProbe2().detect();
   if (!isWindowsSandboxAvailable()) {
     return null;
   }
@@ -1051,9 +1052,10 @@ async function _createWindowsExecutor() {
     return null;
   }
 }
-var SandboxError, UNTRUSTED_ENV_KEY_PREFIXES, _cachedExecutorPromise, _macosSandboxEnabled = false, _hasWarnedMacOSSandboxDisabledByConfig = false;
+var SandboxError, UNTRUSTED_ENV_KEY_PREFIXES, _cachedExecutorPromise, _sandboxAssessmentCache, _macosSandboxEnabled = false, _hasWarnedMacOSSandboxDisabledByConfig = false;
 var init_executor = __esm(() => {
   init_logger();
+  init_capability_probe();
   SandboxError = class SandboxError extends Error {
     code;
     constructor(message, code) {
@@ -1063,6 +1065,7 @@ var init_executor = __esm(() => {
     }
   };
   UNTRUSTED_ENV_KEY_PREFIXES = ["GIT_", "LD_", "DYLD_"];
+  _sandboxAssessmentCache = new Map;
 });
 
 // src/sandbox/linux/bubblewrap-executor.ts
@@ -1138,7 +1141,7 @@ class BubblewrapSandboxExecutor {
     this._disabledReason = reason;
     warn(`Sandbox disabled: ${reason}. Falling through to tool-layer enforcement.`);
   }
-  wrapCommand(command, scopePaths, tempDir, envOverrides) {
+  wrapCommand(command, scopePaths, tempDir, envOverrides, policy) {
     if (!this._available) {
       throw new SandboxError("Sandbox not available", "SANDBOX_UNAVAILABLE");
     }
@@ -1164,7 +1167,6 @@ class BubblewrapSandboxExecutor {
     }
     const args = [
       "--unshare-user",
-      "--unshare-net",
       "--unshare-ipc",
       "--die-with-parent",
       "--new-session",
@@ -1198,6 +1200,9 @@ class BubblewrapSandboxExecutor {
       "-c",
       `'${shellEscape2(command)}'`
     ];
+    if ((policy?.network_mode ?? "off") === "off") {
+      args.splice(1, 0, "--unshare-net");
+    }
     const binary = _internals4.resolveBwrapBinary();
     return `${binary} ${args.join(" ")}`;
   }
@@ -1216,4 +1221,505 @@ var init_bubblewrap_executor = __esm(() => {
   };
 });
 
-export { _internals4 as _internals, init_bubblewrap_executor, _internals as _internals1, init_sandbox_exec_executor, exports_runner_client, init_runner_client, isValidEnvKey, isUntrustedEnvKey, getExecutor, init_executor };
+// src/sandbox/capability-probe.ts
+import { execFile, spawnSync as spawnSync5 } from "child_process";
+import * as fs3 from "fs";
+import * as os5 from "os";
+import * as path5 from "path";
+function assessSandboxRequirements(capability, requirements) {
+  if (!requirements || requirements.mode !== "required") {
+    return { satisfied: true, missing: [] };
+  }
+  const missing = [];
+  if (requirements.require_filesystem && capability.filesystem !== "real") {
+    missing.push("filesystem");
+  }
+  if (requirements.require_network && capability.network !== "real") {
+    missing.push("network");
+  }
+  if (requirements.require_process && capability.process !== "real") {
+    missing.push("process");
+  }
+  return { satisfied: missing.length === 0, missing };
+}
+function fileIdentity(input) {
+  if (!input)
+    return "missing";
+  const candidate = path5.normalize(input);
+  try {
+    const link = fs3.lstatSync(candidate, { bigint: true });
+    const stat = fs3.statSync(candidate, { bigint: true });
+    return [
+      candidate,
+      `l=${link.dev}:${link.ino}:${link.size}:${link.mtimeNs}`,
+      `s=${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}`
+    ].join(":");
+  } catch {
+    return `${candidate}:missing`;
+  }
+}
+function currentProbeSourceIdentity(platform) {
+  if (platform === "linux") {
+    return `linux:${fileIdentity(_internals4.resolveBwrapBinary())}`;
+  }
+  if (platform === "darwin") {
+    return `darwin:${fileIdentity(_internals.resolveSandboxExecBinary())}:${fileIdentity(_internals.resolveProbeTargetBinary())}`;
+  }
+  if (platform === "win32") {
+    const cmdBinary = resolveWindowsCommandProcessorBinary();
+    try {
+      const {
+        _internals: runnerClientInternals
+      } = (init_runner_client(), __toCommonJS(exports_runner_client));
+      return `win32:${fileIdentity(runnerClientInternals.findRunnerBinary?.())}:${fileIdentity(cmdBinary)}`;
+    } catch {
+      return `win32:${fileIdentity(cmdBinary)}`;
+    }
+  }
+  return `unknown:${platform}`;
+}
+function resolveWindowsCommandProcessorBinary() {
+  const candidates = [];
+  const comSpec = process.env.ComSpec?.trim();
+  if (comSpec) {
+    candidates.push(comSpec);
+  }
+  const pathEnv = process.env.Path ?? process.env.PATH ?? "";
+  for (const entry of pathEnv.split(path5.delimiter)) {
+    const trimmed = entry.trim();
+    if (!trimmed)
+      continue;
+    candidates.push(path5.join(trimmed, "cmd.exe"));
+  }
+  for (const candidate of candidates) {
+    try {
+      if (fs3.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {}
+  }
+  return comSpec || "cmd";
+}
+function cleanupProbeTempRoot(tempRoot, mechanism, reasons) {
+  try {
+    _internals5.removeProbeTempRoot(tempRoot);
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code ?? "unknown" : "unknown";
+    reasons.push(`${mechanism} probe temp cleanup failed (${code})`);
+    warn(`[sandbox] ${mechanism} probe temp cleanup failed (${code}); continuing with bounded probe result`);
+  }
+}
+function weakest(...dimensions) {
+  return dimensions.includes("none") ? "none" : dimensions.includes("weak") ? "weak" : "real";
+}
+function upgradeCapability(capability, evidence) {
+  let filesystem = "none";
+  let network = "none";
+  let process2 = "none";
+  const reasons = [...evidence.reasons];
+  if (capability.status === "enabled" && capability.platform === "linux") {
+    filesystem = evidence.filesystem;
+    network = evidence.network;
+    process2 = evidence.process;
+    if (reasons.length === 0) {
+      reasons.push("bubblewrap availability is evidenced, but denial behavior is not independently exercised here", "seccomp unsupported: no filter is installed");
+    }
+  } else if (capability.status === "enabled" && capability.platform === "darwin") {
+    filesystem = evidence.filesystem;
+    network = evidence.network;
+    process2 = evidence.process;
+    if (reasons.length === 0) {
+      reasons.push("Seatbelt availability is evidenced, but denial behavior is not independently exercised here", "(allow default) leaves network, IPC, and process-spawn behavior outside the boundary");
+    }
+  } else if (capability.status === "enabled" && capability.platform === "win32") {
+    const mechanism = capability.mechanism.toLowerCase();
+    const appContainer = mechanism.includes("app-container");
+    const restrictedToken = mechanism.includes("restricted-token");
+    filesystem = evidence.filesystem || (appContainer || restrictedToken ? "weak" : "none");
+    network = evidence.network || (appContainer ? "weak" : "none");
+    process2 = evidence.process || (appContainer || restrictedToken ? "weak" : "none");
+    reasons.push(appContainer ? "native AppContainer runner probe succeeded, but end-to-end denial behavior is not independently verified from this host" : restrictedToken ? "restricted-token runner probe succeeded, but it remains a conservative weak boundary until independently verified" : "PowerShell fallback is defense in depth, not containment");
+  } else {
+    reasons.push(capability.error ?? "sandbox mechanism unavailable");
+  }
+  return {
+    ...capability,
+    v: 1,
+    filesystem,
+    network,
+    process: process2,
+    effective: weakest(filesystem, network, process2),
+    reasons,
+    identity: `${capability.platform}:${capability.mechanism.toLowerCase()}:${capability.status}:${capability.strength ?? "none"}:fs=${filesystem}:net=${network}:proc=${process2}`
+  };
+}
+function withProbeIdentity(capability, probeSourceIdentity) {
+  return {
+    ...capability,
+    identity: `${capability.identity}:probe=${probeSourceIdentity}`
+  };
+}
+function runBoundedSync(cmd, args, input) {
+  return _internals5.spawnSync(cmd, args, {
+    windowsHide: true,
+    encoding: "utf-8",
+    timeout: 2000,
+    stdio: ["pipe", "pipe", "pipe"],
+    input,
+    cwd: os5.tmpdir()
+  });
+}
+function probeLinuxBehavior() {
+  const binary = _internals4.resolveBwrapBinary();
+  const tempRoot = fs3.mkdtempSync(path5.join(os5.tmpdir(), "swarm-bwrap-probe-"));
+  const allowedRoot = path5.join(tempRoot, "allowed");
+  const inScopeFile = path5.join(allowedRoot, "inside.txt");
+  const outOfScopeFile = path5.join(tempRoot, "outside.txt");
+  fs3.mkdirSync(allowedRoot, { recursive: true });
+  const reasons = [];
+  let filesystem = "weak";
+  let network = "weak";
+  try {
+    const baseArgs = [
+      "--unshare-user",
+      "--unshare-net",
+      "--unshare-ipc",
+      "--die-with-parent",
+      "--new-session",
+      "--cap-drop",
+      "ALL",
+      "--bind",
+      allowedRoot,
+      allowedRoot,
+      "--dev",
+      "/dev",
+      "--ro-bind",
+      "/etc",
+      "/etc",
+      "--ro-bind",
+      "/usr",
+      "/usr",
+      "--ro-bind",
+      "/lib",
+      "/lib",
+      "--ro-bind",
+      "/lib64",
+      "/lib64",
+      "--proc",
+      "/proc",
+      "--unshare-pid"
+    ];
+    const inScope = runBoundedSync(binary, [...baseArgs, "--", "/usr/bin/tee", inScopeFile], "ok");
+    const outOfScope = runBoundedSync(binary, [...baseArgs, "--", "/usr/bin/tee", outOfScopeFile], "blocked");
+    if (inScope.status === 0 && fs3.existsSync(inScopeFile) && outOfScope.status !== 0 && !fs3.existsSync(outOfScopeFile)) {
+      filesystem = "real";
+      reasons.push("bubblewrap allowed in-scope writes and blocked out-of-scope writes in a bounded probe");
+    } else {
+      reasons.push("bubblewrap denial behavior was not independently verified in a bounded probe");
+    }
+    try {
+      const hostNetNs = fs3.readlinkSync("/proc/self/ns/net");
+      const childNetNs = runBoundedSync(binary, [
+        ...baseArgs,
+        "--",
+        "/usr/bin/readlink",
+        "/proc/self/ns/net"
+      ]);
+      if (childNetNs.status === 0 && childNetNs.stdout.trim() !== "" && childNetNs.stdout.trim() !== hostNetNs.trim()) {
+        network = "real";
+        reasons.push("bubblewrap produced a distinct network namespace in a bounded probe");
+      } else {
+        reasons.push("bubblewrap network namespace isolation was not independently verified");
+      }
+    } catch {
+      reasons.push("bubblewrap network namespace isolation was not independently verified");
+    }
+  } finally {
+    cleanupProbeTempRoot(tempRoot, "bubblewrap", reasons);
+  }
+  return {
+    filesystem,
+    network,
+    process: "none",
+    reasons
+  };
+}
+function probeMacOSBehavior() {
+  const binary = _internals.resolveSandboxExecBinary();
+  const tempRoot = fs3.mkdtempSync(path5.join(os5.tmpdir(), "swarm-seatbelt-probe-"));
+  const allowedRoot = path5.join(tempRoot, "allowed");
+  const sandboxTemp = path5.join(tempRoot, "sandbox-tmp");
+  const inScopeFile = path5.join(allowedRoot, "inside.txt");
+  const outOfScopeFile = path5.join(tempRoot, "outside.txt");
+  fs3.mkdirSync(allowedRoot, { recursive: true });
+  fs3.mkdirSync(sandboxTemp, { recursive: true });
+  const profile = _internals.buildSandboxProfile([allowedRoot], sandboxTemp);
+  const reasons = [];
+  let filesystem = "weak";
+  try {
+    const inScope = runBoundedSync(binary, ["-p", profile, "/usr/bin/tee", inScopeFile], "ok");
+    const outOfScope = runBoundedSync(binary, ["-p", profile, "/usr/bin/tee", outOfScopeFile], "blocked");
+    if (inScope.status === 0 && fs3.existsSync(inScopeFile) && outOfScope.status !== 0 && !fs3.existsSync(outOfScopeFile)) {
+      filesystem = "real";
+      reasons.push("sandbox-exec allowed in-scope writes and blocked out-of-scope writes in a bounded probe");
+    } else {
+      reasons.push("sandbox-exec denial behavior was not independently verified in a bounded probe");
+    }
+  } finally {
+    cleanupProbeTempRoot(tempRoot, "sandbox-exec", reasons);
+  }
+  reasons.push("(allow default) leaves network, IPC, and process-spawn behavior outside the boundary");
+  return {
+    filesystem,
+    network: "none",
+    process: "none",
+    reasons
+  };
+}
+function detectBehavioralEvidence(capability) {
+  if (capability.status !== "enabled") {
+    return {
+      filesystem: "none",
+      network: "none",
+      process: "none",
+      reasons: [capability.error ?? "sandbox mechanism unavailable"]
+    };
+  }
+  if (capability.platform === "linux") {
+    return probeLinuxBehavior();
+  }
+  if (capability.platform === "darwin") {
+    return probeMacOSBehavior();
+  }
+  if (capability.platform === "win32") {
+    const mechanism = capability.mechanism.toLowerCase();
+    const appContainer = mechanism.includes("app-container");
+    const restrictedToken = mechanism.includes("restricted-token");
+    return {
+      filesystem: appContainer || restrictedToken ? "weak" : "none",
+      network: appContainer ? "weak" : "none",
+      process: appContainer || restrictedToken ? "weak" : "none",
+      reasons: []
+    };
+  }
+  return {
+    filesystem: "none",
+    network: "none",
+    process: "none",
+    reasons: [capability.error ?? "sandbox mechanism unavailable"]
+  };
+}
+function _resetCapabilityCache() {
+  _cached = undefined;
+  _cachedProbeSourceIdentity = undefined;
+}
+function withProbeTimeout(cmd, args, ms) {
+  return new Promise((resolve2, reject) => {
+    const controller = new AbortController;
+    const timer = setTimeout(() => {
+      controller.abort();
+      proc?.kill();
+    }, ms);
+    const unref = timer.unref;
+    if (typeof unref === "function") {
+      unref.call(timer);
+    }
+    let proc;
+    try {
+      proc = execFile(cmd, args, {
+        signal: controller.signal,
+        timeout: ms,
+        windowsHide: true,
+        cwd: os5.tmpdir()
+      }, (error, stdout, _stderr) => {
+        clearTimeout(timer);
+        if (error) {
+          const exc = error;
+          if (exc.code === "ENOENT" || exc.code === "ENOTFOUND") {
+            reject(new Error("binary not found"));
+          } else {
+            reject(error);
+          }
+          return;
+        }
+        resolve2(stdout?.trim() ?? "");
+      });
+    } catch (spawnError) {
+      clearTimeout(timer);
+      reject(spawnError);
+    }
+  });
+}
+async function probeLinux() {
+  try {
+    const binary = _internals4.resolveBwrapBinary();
+    const output = await _internals5.withProbeTimeout(binary, ["--version"], 2000);
+    if (output.length > 0) {
+      return {
+        status: "enabled",
+        strength: "strong",
+        mechanism: "Bubblewrap",
+        platform: "linux"
+      };
+    }
+    return {
+      status: "disabled",
+      mechanism: "Bubblewrap",
+      platform: "linux",
+      error: "binary returned empty version"
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg === "binary not found") {
+      return {
+        status: "unsupported",
+        mechanism: "Bubblewrap",
+        platform: "linux",
+        error: msg
+      };
+    }
+    return {
+      status: "disabled",
+      mechanism: "Bubblewrap",
+      platform: "linux",
+      error: msg
+    };
+  }
+}
+async function probeMacOS() {
+  try {
+    const binary = _internals.resolveSandboxExecBinary();
+    const target = _internals.resolveProbeTargetBinary();
+    const profile = _internals.buildProbeProfile(os5.tmpdir());
+    await _internals5.withProbeTimeout(binary, ["-p", profile, target], 2000);
+    return {
+      status: "enabled",
+      strength: "strong",
+      mechanism: "sandbox-exec",
+      platform: "darwin"
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg === "binary not found") {
+      return {
+        status: "unsupported",
+        mechanism: "sandbox-exec",
+        platform: "darwin",
+        error: msg
+      };
+    }
+    return {
+      status: "disabled",
+      mechanism: "sandbox-exec",
+      platform: "darwin",
+      error: msg
+    };
+  }
+}
+function probeWindows() {
+  try {
+    const { probe: runnerProbe } = (init_runner_client(), __toCommonJS(exports_runner_client));
+    const result = runnerProbe();
+    if (result.available) {
+      return {
+        status: "enabled",
+        strength: "strong",
+        platform: "win32",
+        mechanism: `native-runner/${result.mode}`
+      };
+    }
+  } catch {}
+  try {
+    const cmdBinary = resolveWindowsCommandProcessorBinary();
+    const result = _internals5.spawnSync(cmdBinary, ["/c", "echo", "ok"], {
+      windowsHide: true,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (result.error) {
+      return {
+        status: "disabled",
+        platform: "win32",
+        mechanism: "PowerShell wrapper",
+        error: `cmd.exe probe failed: ${result.error.code}`
+      };
+    }
+    return result.status === 0 ? {
+      status: "enabled",
+      strength: "advisory",
+      platform: "win32",
+      mechanism: "PowerShell wrapper"
+    } : {
+      status: "disabled",
+      platform: "win32",
+      mechanism: "PowerShell wrapper",
+      error: "cmd.exe probe returned non-zero"
+    };
+  } catch (err) {
+    return {
+      status: "disabled",
+      platform: "win32",
+      mechanism: "PowerShell wrapper",
+      error: String(err)
+    };
+  }
+}
+function isBubblewrapAvailable() {
+  return _cached?.status === "enabled" && _cached?.platform === "linux";
+}
+function isSandboxExecAvailable() {
+  return _cached?.status === "enabled" && _cached?.platform === "darwin";
+}
+function isWindowsSandboxAvailable() {
+  return _cached?.status === "enabled" && _cached?.platform === "win32";
+}
+
+class SandboxCapabilityProbe {
+  async detect() {
+    const platform = process.platform;
+    const probeSourceIdentity = currentProbeSourceIdentity(platform);
+    if (_cached !== undefined && _cachedProbeSourceIdentity === probeSourceIdentity) {
+      return _cached;
+    }
+    let detected;
+    switch (platform) {
+      case "linux":
+        detected = await probeLinux();
+        break;
+      case "darwin":
+        detected = await probeMacOS();
+        break;
+      case "win32":
+        detected = probeWindows();
+        break;
+      default: {
+        detected = {
+          status: "unsupported",
+          mechanism: "unknown",
+          platform,
+          error: `unsupported platform: ${platform}`
+        };
+      }
+    }
+    _cached = withProbeIdentity(upgradeCapability(detected, _internals5.detectBehavioralEvidence(detected)), probeSourceIdentity);
+    _cachedProbeSourceIdentity = probeSourceIdentity;
+    return _cached;
+  }
+}
+var _cached, _cachedProbeSourceIdentity, _internals5;
+var init_capability_probe = __esm(() => {
+  init_logger();
+  init_bubblewrap_executor();
+  init_sandbox_exec_executor();
+  _internals5 = {
+    withProbeTimeout,
+    spawnSync: spawnSync5,
+    detectBehavioralEvidence,
+    resolveWindowsCommandProcessorBinary,
+    currentProbeSourceIdentity,
+    removeProbeTempRoot: fs3.rmSync
+  };
+});
+
+export { assessSandboxRequirements, _resetCapabilityCache, _internals5 as _internals, isBubblewrapAvailable, isSandboxExecAvailable, isWindowsSandboxAvailable, SandboxCapabilityProbe, init_capability_probe, isValidEnvKey, isUntrustedEnvKey, getExecutor, init_executor };

package/dist/cli/{index-qqrdmaxq.js → index-4g0g3dqz.js}

@@ -5,7 +5,7 @@ import {
 import {
   SWARM_WORKTREE_DIR_NAME,
   init_constants
-} from "./index-cpg98bh1.js";
+} from "./index-myt57pht.js";
 import {
   init_git_executable,
   resolveGitExecutable
@@ -92,7 +92,7 @@ var _internals = {
     symlinkSync: fs.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-y2r227r0.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-5xt2m5ep.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {

package/dist/cli/{index-44xdtqz8.js → index-4pjkdcgc.js}

@@ -9,7 +9,7 @@ import {
   readEvaluationRun,
   saveEvaluationRun,
   saveTaskSetSnapshot
-} from "./index-73pmnsjg.js";
+} from "./index-1gzdnjg9.js";
 import {
   canonicalHash,
   computeCandidateInputContentHash,

package/dist/cli/{index-29vd7v3e.js → index-6vgb5fyb.js}

@@ -4,7 +4,7 @@ import {
   readShellAuditTail,
   redactPath,
   redactShellCommand
-} from "./index-k3d919yf.js";
+} from "./index-gn26q90p.js";
 
 // src/services/guardrail-log-service.ts
 var BLOCK_TYPES = new Set([