opencode-swarm 7.107.5 → 7.108.0

package/dist/cli/{index-v4fcn4tr.js → index-q1exe2b3.js}

@@ -5,8 +5,7 @@ import {
 } from "./index-zgwm4ryv.js";
 import {
   __esm,
-  __export,
-  __toCommonJS
+  __export
 } from "./index-a76rekgs.js";
 
 // src/sandbox/win32/runner-client.ts
@@ -254,199 +253,4 @@ var init_runner_client = __esm(() => {
   };
 });
 
-// src/sandbox/capability-probe.ts
-import { execFile, spawnSync as spawnSync2 } from "child_process";
-import * as os2 from "os";
-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: os2.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 output = await withProbeTimeout("bwrap", ["--version"], 2000);
-    if (output.length > 0) {
-      return {
-        status: "enabled",
-        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 output = await withProbeTimeout("sandbox-exec", ["--version"], 2000);
-    if (output.length > 0) {
-      return {
-        status: "enabled",
-        mechanism: "sandbox-exec",
-        platform: "darwin"
-      };
-    }
-    return {
-      status: "disabled",
-      mechanism: "sandbox-exec",
-      platform: "darwin",
-      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: "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",
-        platform: "win32",
-        mechanism: `native-runner/${result.mode}`
-      };
-    }
-  } catch {}
-  try {
-    const result = spawnSync2("cmd", ["/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",
-      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() {
-    if (_cached !== undefined) {
-      return _cached;
-    }
-    const platform = process.platform;
-    switch (platform) {
-      case "linux":
-        _cached = await probeLinux();
-        break;
-      case "darwin":
-        _cached = await probeMacOS();
-        break;
-      case "win32":
-        _cached = probeWindows();
-        break;
-      default: {
-        _cached = {
-          status: "unsupported",
-          mechanism: "unknown",
-          platform,
-          error: `unsupported platform: ${platform}`
-        };
-      }
-    }
-    return _cached;
-  }
-}
-var _cached;
-var init_capability_probe = () => {};
-
-export { _internals, probe, execute, buildDefaultPolicy, init_runner_client, isBubblewrapAvailable, isSandboxExecAvailable, isWindowsSandboxAvailable, SandboxCapabilityProbe, init_capability_probe };
+export { _internals, probe, execute, buildDefaultPolicy, exports_runner_client, init_runner_client };

package/dist/cli/{index-57ymmh7h.js → index-r3j3458j.js}

@@ -1,16 +1,16 @@
 // @bun
-import {
-  SwarmError
-} from "./index-5e4e2hvv.js";
 import {
   readCachedTextFile
 } from "./index-jtqkh8jf.js";
+import {
+  SwarmError
+} from "./index-5e4e2hvv.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";
 import {
   bunFile
-} from "./index-b9v501fr.js";
+} from "./index-7xgqky26.js";
 
 // src/hooks/utils.ts
 import * as fs from "fs";

package/dist/cli/{index-3naa2ajc.js → index-vvk2g744.js}

@@ -1,11 +1,7 @@
 // @bun
-import {
-  emit
-} from "./index-vn263hqt.js";
 import {
   __commonJS,
-  __require,
-  __toESM
+  __require
 } from "./index-a76rekgs.js";
 
 // node_modules/graceful-fs/polyfills.js
@@ -1081,7 +1077,7 @@ var require_signal_exit = __commonJS((exports, module) => {
       emitter.count -= 1;
     };
     module.exports.unload = unload;
-    emit2 = function emit3(event, code, signal) {
+    emit = function emit2(event, code, signal) {
       if (emitter.emitted[event]) {
         return;
       }
@@ -1097,8 +1093,8 @@ var require_signal_exit = __commonJS((exports, module) => {
         var listeners = process2.listeners(sig);
         if (listeners.length === emitter.count) {
           unload();
-          emit2("exit", null, sig);
-          emit2("afterexit", null, sig);
+          emit("exit", null, sig);
+          emit("afterexit", null, sig);
           if (isWin && sig === "SIGHUP") {
             sig = "SIGINT";
           }
@@ -1134,8 +1130,8 @@ var require_signal_exit = __commonJS((exports, module) => {
         return;
       }
       process2.exitCode = code || 0;
-      emit2("exit", process2.exitCode, null);
-      emit2("afterexit", process2.exitCode, null);
+      emit("exit", process2.exitCode, null);
+      emit("afterexit", process2.exitCode, null);
       originalProcessReallyExit.call(process2, process2.exitCode);
     };
     originalProcessEmit = process2.emit;
@@ -1145,8 +1141,8 @@ var require_signal_exit = __commonJS((exports, module) => {
           process2.exitCode = arg;
         }
         var ret = originalProcessEmit.apply(this, arguments);
-        emit2("exit", process2.exitCode, null);
-        emit2("afterexit", process2.exitCode, null);
+        emit("exit", process2.exitCode, null);
+        emit("afterexit", process2.exitCode, null);
         return ret;
       } else {
         return originalProcessEmit.apply(this, arguments);
@@ -1159,7 +1155,7 @@ var require_signal_exit = __commonJS((exports, module) => {
   var EE;
   var emitter;
   var unload;
-  var emit2;
+  var emit;
   var sigListeners;
   var loaded;
   var load;
@@ -1528,146 +1524,4 @@ var require_proper_lockfile = __commonJS((exports, module) => {
   module.exports.checkSync = checkSync;
 });
 
-// src/parallel/file-locks.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import * as fs from "fs";
-import * as path from "path";
-var LOCKS_DIR = ".swarm/locks";
-var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
-var _internals = {
-  tryAcquireLock,
-  writeFile: fs.promises.writeFile
-};
-function getLockFilePath(directory, filePath) {
-  const normalized = path.resolve(directory, filePath);
-  const baseDir = path.resolve(directory) + path.sep;
-  const pathOk = process.platform === "win32" ? normalized.toLowerCase().startsWith(baseDir.toLowerCase()) : normalized.startsWith(baseDir);
-  if (!pathOk) {
-    throw new Error("Invalid file path: path traversal not allowed");
-  }
-  const pathForHash = process.platform === "win32" ? normalized.toLowerCase() : normalized;
-  const hash = Buffer.from(pathForHash).toString("base64").replace(/[/+=]/g, "_");
-  const lockPath = path.join(directory, LOCKS_DIR, `${hash}.lock`);
-  if (process.platform === "win32") {
-    const oldHash = Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
-    const oldLockPath = path.join(directory, LOCKS_DIR, `${oldHash}.lock`);
-    if (fs.existsSync(oldLockPath)) {
-      return oldLockPath;
-    }
-  }
-  return lockPath;
-}
-async function tryAcquireLock(directory, filePath, agent, taskId) {
-  const lockPath = getLockFilePath(directory, filePath);
-  const locksDir = path.dirname(lockPath);
-  if (!fs.existsSync(locksDir)) {
-    fs.mkdirSync(locksDir, { recursive: true });
-  }
-  if (!fs.existsSync(lockPath)) {
-    fs.writeFileSync(lockPath, "", "utf-8");
-  }
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(lockPath, {
-      stale: LOCK_TIMEOUT_MS,
-      retries: {
-        retries: 5,
-        minTimeout: 10,
-        maxTimeout: 500,
-        factor: 2
-      },
-      realpath: false
-    });
-  } catch (err) {
-    const code = err.code;
-    if (code === "ELOCKED" || code === "EEXIST") {
-      return { acquired: false };
-    }
-    throw err;
-  }
-  const lock = {
-    filePath,
-    agent,
-    taskId,
-    timestamp: new Date().toISOString(),
-    expiresAt: Date.now() + LOCK_TIMEOUT_MS,
-    _release: release
-  };
-  return { acquired: true, lock };
-}
-
-// src/evidence/lock.ts
-class EvidenceLockTimeoutError extends Error {
-  directory;
-  evidencePath;
-  agent;
-  taskId;
-  constructor(directory, evidencePath, agent, taskId, timeoutMs) {
-    super(`Evidence lock timeout after ${timeoutMs}ms for ${evidencePath} (agent=${agent}, task=${taskId})`);
-    this.name = "EvidenceLockTimeoutError";
-    this.directory = directory;
-    this.evidencePath = evidencePath;
-    this.agent = agent;
-    this.taskId = taskId;
-  }
-}
-var BACKOFF_START_MS = 50;
-var BACKOFF_MAX_MS = 2000;
-var BACKOFF_JITTER_RATIO = 0.25;
-function backoffMs(attempt) {
-  const base = Math.min(BACKOFF_START_MS * 2 ** attempt, BACKOFF_MAX_MS);
-  const jitter = base * BACKOFF_JITTER_RATIO * (Math.random() * 2 - 1);
-  return Math.max(1, Math.round(base + jitter));
-}
-async function withEvidenceLock(directory, evidencePath, agent, taskId, fn, timeoutMs = 60000) {
-  const deadline = Date.now() + timeoutMs;
-  let attempt = 0;
-  while (true) {
-    const result = await tryAcquireLock(directory, evidencePath, agent, taskId);
-    if (result.acquired) {
-      const lock = result.lock;
-      if (attempt > 0) {
-        emit("evidence_lock_stale_recovered", {
-          directory,
-          evidencePath,
-          agent,
-          taskId,
-          attempt
-        });
-      }
-      emit("evidence_lock_acquired", {
-        directory,
-        evidencePath,
-        agent,
-        taskId,
-        attempt
-      });
-      try {
-        return await fn();
-      } finally {
-        if (lock._release) {
-          try {
-            await lock._release();
-          } catch {}
-        }
-      }
-    }
-    if (Date.now() >= deadline) {
-      throw new EvidenceLockTimeoutError(directory, evidencePath, agent, taskId, timeoutMs);
-    }
-    emit("evidence_lock_contended", {
-      directory,
-      evidencePath,
-      agent,
-      taskId,
-      attempt
-    });
-    const delay = Math.min(backoffMs(attempt), deadline - Date.now());
-    if (delay > 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
-    }
-    attempt++;
-  }
-}
-
-export { require_proper_lockfile, tryAcquireLock, withEvidenceLock };
+export { require_proper_lockfile };

package/dist/cli/{index-zej8cy0j.js → index-vx76tcxe.js}

@@ -2,7 +2,7 @@
 import {
   redactPath,
   redactShellCommand
-} from "./index-4vsgp5a8.js";
+} from "./index-wj4jeavn.js";
 
 // src/services/guardrail-log-service.ts
 import * as fs from "fs/promises";

package/dist/cli/{index-xmarctsf.js → index-wg0665ft.js}

@@ -1,19 +1,19 @@
 // @bun
 import {
   resolveKnowledgeStoreDir
-} from "./index-n1sptn1w.js";
+} from "./index-2nt4mq9n.js";
 import {
   isActiveStatus
 } from "./index-bfwt3abw.js";
-import {
-  atomicWriteFile
-} from "./index-9b7qp18e.js";
 import {
   readCachedParsedFile
 } from "./index-jtqkh8jf.js";
+import {
+  atomicWriteFile
+} from "./index-1cn967sa.js";
 import {
   require_proper_lockfile
-} from "./index-3naa2ajc.js";
+} from "./index-vvk2g744.js";
 import {
   __require,
   __toESM
@@ -525,7 +525,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
   const recovered = touched.filter((e) => e.confidence > CONFIDENCE_FLOOR + FLOOR_EPSILON && e.confidence_floor_demoted);
   if (atFloor.length === 0 && recovered.length === 0)
     return;
-  const { readKnowledgeCounterRollups, effectiveRetrievalOutcomes } = await import("./knowledge-events-kfc6xmkw.js");
+  const { readKnowledgeCounterRollups, effectiveRetrievalOutcomes } = await import("./knowledge-events-6n3x3he2.js");
   const rollups = await readKnowledgeCounterRollups(directory);
   const flagIds = new Set;
   for (const e of atFloor) {
@@ -592,7 +592,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
     });
   }
   if (action === "quarantine" && toQuarantine.length > 0) {
-    const { quarantineEntry } = await import("./knowledge-validator-ez3ws8ef.js");
+    const { quarantineEntry } = await import("./knowledge-validator-exymfcb9.js");
     for (const { id } of toQuarantine) {
       await quarantineEntry(directory, id, "confidence_floor_negative_outcome", "auto").catch((err) => {
         console.warn("[knowledge-store] confidence-floor quarantine failed (best-effort):", err instanceof Error ? err.message : String(err));

package/dist/cli/{index-4vsgp5a8.js → index-wj4jeavn.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   stripKnownSwarmPrefix
-} from "./index-pchpahdf.js";
+} from "./index-h4c4rrwx.js";
 import {
   init_logger,
   warn

package/dist/cli/index-wvrj16f0.js

@@ -0,0 +1,206 @@
+// @bun
+import {
+  exports_runner_client,
+  init_runner_client
+} from "./index-q1exe2b3.js";
+import {
+  __esm,
+  __toCommonJS
+} from "./index-a76rekgs.js";
+
+// src/sandbox/capability-probe.ts
+import { execFile, spawnSync } from "child_process";
+import * as os from "os";
+function withProbeTimeout(cmd, args, ms) {
+  return new Promise((resolve, 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: os.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;
+        }
+        resolve(stdout?.trim() ?? "");
+      });
+    } catch (spawnError) {
+      clearTimeout(timer);
+      reject(spawnError);
+    }
+  });
+}
+async function probeLinux() {
+  try {
+    const output = await withProbeTimeout("bwrap", ["--version"], 2000);
+    if (output.length > 0) {
+      return {
+        status: "enabled",
+        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 output = await withProbeTimeout("sandbox-exec", ["--version"], 2000);
+    if (output.length > 0) {
+      return {
+        status: "enabled",
+        mechanism: "sandbox-exec",
+        platform: "darwin"
+      };
+    }
+    return {
+      status: "disabled",
+      mechanism: "sandbox-exec",
+      platform: "darwin",
+      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: "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",
+        platform: "win32",
+        mechanism: `native-runner/${result.mode}`
+      };
+    }
+  } catch {}
+  try {
+    const result = spawnSync("cmd", ["/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",
+      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() {
+    if (_cached !== undefined) {
+      return _cached;
+    }
+    const platform = process.platform;
+    switch (platform) {
+      case "linux":
+        _cached = await probeLinux();
+        break;
+      case "darwin":
+        _cached = await probeMacOS();
+        break;
+      case "win32":
+        _cached = probeWindows();
+        break;
+      default: {
+        _cached = {
+          status: "unsupported",
+          mechanism: "unknown",
+          platform,
+          error: `unsupported platform: ${platform}`
+        };
+      }
+    }
+    return _cached;
+  }
+}
+var _cached;
+var init_capability_probe = () => {};
+
+export { isBubblewrapAvailable, isSandboxExecAvailable, isWindowsSandboxAvailable, SandboxCapabilityProbe, init_capability_probe };