opencode-swarm 7.107.6 → 7.108.0

package/dist/cli/{index-bq8kd9r9.js → index-5gnp8fyw.js}

@@ -4,7 +4,7 @@ import {
   countEntryViolationsInWindow,
   readKnowledgeEvents,
   recordKnowledgeEvent
-} from "./index-kxm3bdjh.js";
+} from "./index-mmny81g1.js";
 import {
   jaccardBigram,
   readKnowledge,
@@ -12,7 +12,7 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-xmarctsf.js";
+} from "./index-wg0665ft.js";
 import {
   isActiveStatus
 } from "./index-bfwt3abw.js";
@@ -188,7 +188,7 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-ez3ws8ef.js");
+    const { quarantineEntry } = await import("./knowledge-validator-exymfcb9.js");
     await quarantineEntry(directory, entryId, `repeat_contradiction: ${count} contradicted events in ${windowDays}d`, "auto");
     return { quarantined: true, entryId, contradictionsInWindow: count };
   } catch {

package/dist/cli/index-5mkc2f9z.js

@@ -0,0 +1,154 @@
+// @bun
+import {
+  emit
+} from "./index-vn263hqt.js";
+import {
+  require_proper_lockfile
+} from "./index-vvk2g744.js";
+import {
+  __toESM
+} from "./index-a76rekgs.js";
+
+// 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 { tryAcquireLock, withEvidenceLock };

package/dist/cli/{index-0kxc7t16.js → index-6jng9c8t.js}

@@ -3,7 +3,7 @@ import {
   atomicWriteFile,
   taskEvidencePath,
   withTaskEvidenceLock
-} from "./index-9b7qp18e.js";
+} from "./index-1cn967sa.js";
 import {
   exports_external
 } from "./index-293f68mj.js";

package/dist/cli/{index-57rthc1z.js → index-7jyndvsy.js}

@@ -12,14 +12,14 @@ import {
   detectPosixWrites,
   detectWindowsWrites,
   resolveWriteTargets
-} from "./index-572t1qff.js";
+} from "./index-1emhz3zb.js";
 import {
   checkFileAuthority,
   classifyFile,
   isInDeclaredScope,
   redactPath,
   redactShellCommand
-} from "./index-4vsgp5a8.js";
+} from "./index-wj4jeavn.js";
 
 // src/services/guardrail-explain-service.ts
 import path from "path";

package/dist/cli/{index-b9v501fr.js → index-7xgqky26.js}

@@ -255,10 +255,34 @@ function streamFromBun(stream) {
   }).getReader();
   return { text, bytes, getReader };
 }
+function mergeEnvForChild(baseEnv, envOverrides) {
+  const hasExplicitBaseEnv = baseEnv !== undefined;
+  const baseSource = baseEnv ?? process.env;
+  const merged = {};
+  for (const [key, value] of Object.entries(baseSource)) {
+    if (typeof value === "string")
+      merged[key] = value;
+  }
+  if (envOverrides) {
+    for (const [key, value] of Object.entries(envOverrides)) {
+      if (value === null) {
+        delete merged[key];
+      } else {
+        merged[key] = value;
+      }
+    }
+  }
+  if (Object.keys(merged).length === 0) {
+    return hasExplicitBaseEnv ? {} : undefined;
+  }
+  return merged;
+}
 function bunSpawn(cmd, options) {
   const bun = getBun();
   if (bun?.spawn) {
-    const proc2 = bun.spawn(cmd, options);
+    const mergedEnv2 = mergeEnvForChild(options?.env, options?.envOverrides);
+    const spawnOpts = mergedEnv2 !== undefined ? { ...options, env: mergedEnv2 } : options;
+    const proc2 = bun.spawn(cmd, spawnOpts);
     return {
       stdout: streamFromBun(proc2.stdout),
       stderr: streamFromBun(proc2.stderr),
@@ -277,9 +301,10 @@ function bunSpawn(cmd, options) {
   }
   const [file, ...args] = cmd;
   const detached = options?.killProcessTree === true;
+  const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
   const proc = nodeSpawn(file, args, {
     cwd: options?.cwd,
-    env: options?.env,
+    env: mergedEnv,
     detached,
     windowsHide: true,
     stdio: [
@@ -328,7 +353,9 @@ function bunSpawn(cmd, options) {
 function bunSpawnSync(cmd, options) {
   const bun = getBun();
   if (bun?.spawnSync) {
-    const result2 = bun.spawnSync(cmd, options);
+    const mergedEnv2 = mergeEnvForChild(options?.env, options?.envOverrides);
+    const spawnOpts = mergedEnv2 !== undefined ? { ...options, env: mergedEnv2 } : options;
+    const result2 = bun.spawnSync(cmd, spawnOpts);
     return result2;
   }
   let argv;
@@ -350,9 +377,10 @@ function bunSpawnSync(cmd, options) {
     }
   }
   const [file, ...args] = argv;
+  const mergedEnv = mergeEnvForChild(mergedOptions.env, options?.envOverrides);
   const result = nodeSpawnSync(file, args, {
     cwd: mergedOptions.cwd,
-    env: mergedOptions.env,
+    env: mergedEnv,
     input: mergedOptions.stdin instanceof Uint8Array || typeof mergedOptions.stdin === "string" ? mergedOptions.stdin : undefined,
     timeout: mergedOptions.timeout,
     windowsHide: true
@@ -368,4 +396,4 @@ function bunSpawnSync(cmd, options) {
   };
 }
 
-export { bunFile, bunWrite, bunHash, bunSpawn, bunSpawnSync };
+export { bunFile, bunWrite, bunHash, mergeEnvForChild, bunSpawn, bunSpawnSync };

package/dist/cli/{index-4r5z8sgw.js → index-85bacexr.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-57ymmh7h.js";
+} from "./index-r3j3458j.js";
 import {
   log
 } from "./index-zgwm4ryv.js";
@@ -10,7 +10,7 @@ import {
 } from "./index-293f68mj.js";
 import {
   withEvidenceLock
-} from "./index-3naa2ajc.js";
+} from "./index-5mkc2f9z.js";
 
 // src/background/pr-subscriptions.ts
 import * as fs from "fs";

package/dist/cli/{index-bpgqbwmf.js → index-9qxntjtx.js}

@@ -1,19 +1,19 @@
 // @bun
-import {
-  ALLOWED_SKILL_PATH_PREFIXES,
-  validateSkillPath
-} from "./index-dfdg4ws5.js";
 import {
   effectiveRetrievalOutcomes,
   readKnowledgeCounterRollups
-} from "./index-kxm3bdjh.js";
+} from "./index-mmny81g1.js";
+import {
+  ALLOWED_SKILL_PATH_PREFIXES,
+  validateSkillPath
+} from "./index-fz1jgbvw.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   rewriteKnowledge
-} from "./index-xmarctsf.js";
+} from "./index-wg0665ft.js";
 import {
   init_logger,
   warn