opencode-swarm 7.139.2 → 7.139.4

package/dist/cli/{index-5zyk8qgv.js → index-0xkjhgrf.js}

@@ -1,17 +1,17 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-x9q4bbhd.js";
+} from "./index-k46me75h.js";
 import {
   withEvidenceLock
-} from "./index-5j6chvj8.js";
+} from "./index-s0qc4gj6.js";
+import {
+  log
+} from "./index-zgwm4ryv.js";
 import {
   exports_external,
   init_zod
 } from "./index-bpmtbmy9.js";
-import {
-  log
-} from "./index-zgwm4ryv.js";
 
 // src/background/pr-subscriptions.ts
 init_zod();

package/dist/cli/{index-q7ezzgwq.js → index-1kyex7z2.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-x9q4bbhd.js";
+} from "./index-k46me75h.js";
 
 // src/hooks/delegation-gate/worktree-provisioning-owner.ts
 import { createHash, randomBytes } from "crypto";

package/dist/cli/{index-668dpw5e.js → index-33skgk1a.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   atomicWriteFile
-} from "./index-gvhvz176.js";
+} from "./index-6r522srn.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-vm4xw9z3.js → index-41hkt36g.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   simpleGlobToRegex
-} from "./index-z6xqpmqg.js";
+} from "./index-ee3x66a5.js";
 import {
   bunSpawnSync
-} from "./index-y111zefa.js";
+} from "./index-4nt52yr9.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";

package/dist/cli/{index-y111zefa.js → index-4nt52yr9.js}

@@ -124,24 +124,41 @@ function bunHash(input) {
   }
   return hash;
 }
-function killProcessTreeImpl(pid, signal, directKill, wasDetached) {
+async function killProcessTreeImpl(pid, signal, directKill, wasDetached) {
   if (typeof pid !== "number" || pid <= 0) {
-    directKill();
+    directKill(signal);
     return;
   }
-  if (process.platform === "win32") {
+  if (_internals.platform() === "win32") {
+    let taskkill;
     try {
-      const result = nodeSpawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
-        cwd: process.cwd(),
+      taskkill = _internals.spawnTaskkill(["/PID", String(pid), "/T", "/F"], {
+        cwd: _internals.cwd(),
         stdio: ["ignore", "ignore", "ignore"],
         timeout: 5000,
+        killSignal: "SIGKILL",
         windowsHide: true
       });
-      if (!result.error && result.status === 0)
+      const succeeded = await new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+          if (settled)
+            return;
+          settled = true;
+          resolve(value);
+        };
+        taskkill?.once("error", () => finish(false));
+        taskkill?.once("exit", (code) => finish(code === 0));
+      });
+      if (succeeded)
         return;
-    } catch {}
-    directKill();
-    return;
+    } catch {} finally {
+      try {
+        taskkill?.kill("SIGKILL");
+      } catch {}
+    }
+    directKill(signal);
+    throw new Error("Windows process-tree termination could not be confirmed");
   }
   if (wasDetached) {
     try {
@@ -149,8 +166,17 @@ function killProcessTreeImpl(pid, signal, directKill, wasDetached) {
       return;
     } catch {}
   }
-  directKill();
+  directKill(signal);
+}
+function createProcessTreeKiller(pid, directKill, wasDetached) {
+  return (signal) => killProcessTreeImpl(pid, signal, directKill, wasDetached);
 }
+var _internals = {
+  platform: () => process.platform,
+  cwd: () => process.cwd(),
+  spawnTaskkill: (args, options) => nodeSpawn("taskkill", args, options),
+  createProcessTreeKiller
+};
 function streamFromNode(pipe) {
   let collected;
   let readerClaimed = false;
@@ -312,18 +338,15 @@ function bunSpawn(cmd, options) {
       spawnOpts.detached = true;
     }
     const proc2 = bun.spawn(cmd, spawnOpts);
-    const killBunProcess = (sig) => {
-      if (options?.killProcessTree) {
-        killProcessTreeImpl(proc2.pid, sig, () => proc2.kill(sig), true);
-      } else {
-        proc2.kill(sig);
-      }
-    };
+    const killBunTree = createProcessTreeKiller(proc2.pid, (sig) => proc2.kill(sig), true);
+    const killBunProcess = (sig) => options?.killProcessTree ? killBunTree(sig) : Promise.resolve(proc2.kill(sig));
     let timeoutHandle2;
     if (options?.killProcessTree === true && options.timeout && options.timeout > 0) {
       timeoutHandle2 = setTimeout(() => {
         try {
-          killBunProcess("SIGKILL");
+          killBunProcess("SIGKILL").catch(() => {
+            return;
+          });
         } catch {}
       }, options.timeout);
       if (typeof timeoutHandle2.unref === "function")
@@ -340,9 +363,15 @@ function bunSpawn(cmd, options) {
       get exitCode() {
         return proc2.exitCode;
       },
+      get signalCode() {
+        return proc2.signalCode;
+      },
       kill(sig) {
-        killBunProcess(sig);
-      }
+        killBunProcess(sig).catch(() => {
+          return;
+        });
+      },
+      killTree: killBunProcess
     };
   }
   const [file, ...args] = cmd;
@@ -353,27 +382,38 @@ function bunSpawn(cmd, options) {
     env: mergedEnv,
     detached,
     windowsHide: true,
+    windowsVerbatimArguments: options?.windowsVerbatimArguments,
     stdio: [
       mapStdio(options?.stdin),
       mapStdio(options?.stdout),
       mapStdio(options?.stderr)
     ]
   });
+  const killChildTree = createProcessTreeKiller(proc.pid, (signal) => proc.kill(signal), true);
   const killChild = (signal) => {
-    if (detached) {
-      killProcessTreeImpl(proc.pid, signal, () => proc.kill(signal), true);
-    } else {
-      proc.kill(signal);
-    }
+    if (detached)
+      return killChildTree(signal);
+    proc.kill(signal);
+    return Promise.resolve();
   };
   let timeoutHandle;
+  let observedSignal = null;
+  let observedSpawnError = null;
   const exited = new Promise((resolve) => {
-    proc.on("exit", (code) => resolve(code ?? 0));
-    proc.on("error", () => resolve(1));
+    proc.on("exit", (code, signal) => {
+      observedSignal = signal;
+      resolve(code ?? -1);
+    });
+    proc.on("error", (error) => {
+      observedSpawnError = error;
+      resolve(1);
+    });
     if (options?.timeout && options.timeout > 0) {
       timeoutHandle = setTimeout(() => {
         try {
-          killChild("SIGKILL");
+          killChild("SIGKILL").catch(() => {
+            return;
+          });
         } catch {}
       }, options.timeout);
       if (typeof timeoutHandle.unref === "function") {
@@ -389,11 +429,20 @@ function bunSpawn(cmd, options) {
     stderr: streamFromNode(proc.stderr),
     exited,
     get exitCode() {
-      return proc.exitCode;
+      return observedSpawnError ? null : proc.exitCode;
+    },
+    get signalCode() {
+      return observedSignal ?? proc.signalCode;
+    },
+    get spawnError() {
+      return observedSpawnError;
     },
     kill(signal) {
-      killChild(signal);
-    }
+      killChild(signal).catch(() => {
+        return;
+      });
+    },
+    killTree: killChild
   };
 }
 function bunSpawnSync(cmd, options) {

package/dist/cli/{index-3jcyn8g6.js → index-4wjk296r.js}

@@ -639,7 +639,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect"]
     },
     set_qa_gates: {
-      description: "configure the QA gate profile for the current plan. Architect-only. Ratchet-tighter only \u2014 rejected once the profile is locked after critic approval. Supports: reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, phase_council, drift_check, final_council.",
+      description: "configure the QA gate profile for the current plan. Architect-only. The initial selection may override defaults; existing profiles are ratchet-tighter and rejected once locked after critic approval. Supports: reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, phase_council, drift_check, final_council.",
       agents: ["architect"]
     },
     web_search: {

package/dist/cli/{index-3radty3f.js → index-5azdnaty.js}

@@ -4,13 +4,13 @@ import {
 } from "./index-rtry5xyf.js";
 import {
   readKnowledgeEvents
-} from "./index-e9tx99ds.js";
+} from "./index-k41dn8me.js";
 import {
   isLinked,
   readLinkPointer,
   resolveKnowledgeStoreDir,
   resolveLinkDir
-} from "./index-668dpw5e.js";
+} from "./index-33skgk1a.js";
 
 // src/knowledge/curation-policy.ts
 import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";

package/dist/cli/{index-8p9pasnp.js → index-5s23pfsy.js}

@@ -1,13 +1,13 @@
 // @bun
-import {
-  OUTCOME_BLOCK_THRESHOLD,
-  init_knowledge_types
-} from "./index-bk5tah7q.js";
 import {
   ALL_AGENT_NAMES,
   SUMMARIZER_EXEMPT_TOOL_NAMES,
   init_constants
-} from "./index-3jcyn8g6.js";
+} from "./index-4wjk296r.js";
+import {
+  OUTCOME_BLOCK_THRESHOLD,
+  init_knowledge_types
+} from "./index-bk5tah7q.js";
 import {
   exports_external,
   init_zod
@@ -21,7 +21,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.139.2",
+    version: "7.139.4",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -1297,13 +1297,13 @@ var init_schema = __esm(() => {
       ping_pong: exports_external.number().min(1).default(2),
       expansion_drift: exports_external.number().min(1).default(3),
       stuck_on_test: exports_external.number().min(1).default(3),
-      context_thrash: exports_external.number().min(1).default(3)
+      context_thrash: exports_external.number().min(1).default(10)
     }).default(() => ({
       repetition_loop: 2,
       ping_pong: 2,
       expansion_drift: 3,
       stuck_on_test: 3,
-      context_thrash: 3
+      context_thrash: 10
     })),
     max_trajectory_lines: exports_external.number().min(10).default(1000),
     escalation_enabled: exports_external.boolean().default(true),

package/dist/cli/{index-5w7ekpy3.js → index-5z2xps64.js}

@@ -3,10 +3,10 @@ import {
   atomicWriteFile,
   taskEvidencePath,
   withTaskEvidenceLock
-} from "./index-gvhvz176.js";
+} from "./index-6r522srn.js";
 import {
   telemetry
-} from "./index-a5eba0t8.js";
+} from "./index-rsrx77fg.js";
 import {
   exports_external,
   init_zod

package/dist/cli/{index-0wp67gqj.js → index-6nzmp937.js}

@@ -3,28 +3,10 @@ import {
   EvaluationRunV1Schema,
   GateAuditResultV1Schema,
   getProtectedEvaluationRunIds
-} from "./index-s608d3hw.js";
+} from "./index-nrx08gcr.js";
 import {
   readEffectiveSpecSync
 } from "./index-9ss2m4rs.js";
-import {
-  isValidTaskId,
-  readTaskEvidence,
-  readTaskEvidenceRaw,
-  sanitizeTaskId
-} from "./index-5w7ekpy3.js";
-import {
-  EVIDENCE_MAX_JSON_BYTES,
-  EvidenceBundleSchema,
-  EvidenceSchema
-} from "./index-gprxjmm7.js";
-import {
-  _internals,
-  buildDefaultPolicy,
-  execute,
-  init_runner_client,
-  probe
-} from "./index-q1exe2b3.js";
 import {
   LedgerStaleWriterError,
   appendLedgerEvent,
@@ -40,42 +22,61 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-4xbyy6aw.js";
-import {
-  PlanSchema
-} from "./index-1kz6da87.js";
+} from "./index-6rxgb5r9.js";
 import {
   getWorktreeMergeFailure
 } from "./index-b8zgtz81.js";
 import {
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-x9q4bbhd.js";
+} from "./index-k46me75h.js";
+import {
+  isValidTaskId,
+  readTaskEvidence,
+  readTaskEvidenceRaw,
+  sanitizeTaskId
+} from "./index-5z2xps64.js";
+import {
+  _internals,
+  buildDefaultPolicy,
+  execute,
+  init_runner_client,
+  probe
+} from "./index-q1exe2b3.js";
 import {
   invalidateCachedArtifact,
   readCachedParsedFile
 } from "./index-ed5ykebp.js";
 import {
+  assertProjectRoot,
   withEvidenceLock
-} from "./index-5j6chvj8.js";
-import {
-  emit
-} from "./index-a5eba0t8.js";
-import {
-  ZodError,
-  init_zod
-} from "./index-bpmtbmy9.js";
+} from "./index-s0qc4gj6.js";
 import {
   bunHash,
   bunWrite,
   mergeEnvForChild
-} from "./index-y111zefa.js";
+} from "./index-4nt52yr9.js";
+import {
+  EVIDENCE_MAX_JSON_BYTES,
+  EvidenceBundleSchema,
+  EvidenceSchema
+} from "./index-gprxjmm7.js";
+import {
+  PlanSchema
+} from "./index-1kz6da87.js";
 import {
   criticalWarn,
   error,
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  emit
+} from "./index-rsrx77fg.js";
+import {
+  ZodError,
+  init_zod
+} from "./index-bpmtbmy9.js";
 import {
   __esm,
   __export,
@@ -2659,6 +2660,7 @@ async function isPlanMdInSync(directory, plan, cache) {
   return false;
 }
 async function regeneratePlanMarkdown(directory, plan) {
+  assertProjectRoot(directory);
   const swarmDir = path8.resolve(directory, ".swarm");
   const contentHash = computePlanContentHash(plan);
   const markdown = derivePlanMarkdown(plan);
@@ -2771,6 +2773,7 @@ async function loadPlan(directory, cache) {
               const preserving = await isObligationPreserving(directory);
               if (!preserving) {
                 try {
+                  assertProjectRoot(directory);
                   const diffInfo = computeSpecDiff(directory);
                   const specStalenessPath = path8.join(directory, ".swarm", "spec-staleness.json");
                   await fsPromises.writeFile(specStalenessPath, JSON.stringify({
@@ -2787,6 +2790,7 @@ async function loadPlan(directory, cache) {
                   invalidateCachedArtifact(specStalenessPath);
                 } catch {}
                 try {
+                  assertProjectRoot(directory);
                   const eventsPath = path8.join(directory, ".swarm", "events.jsonl");
                   const event = {
                     type: "spec_stale_detected",
@@ -2942,6 +2946,7 @@ async function savePlan(directory, plan, options) {
   if (directory === null || directory === undefined || typeof directory !== "string" || directory.trim().length === 0) {
     throw new Error(`Invalid directory: directory must be a non-empty string`);
   }
+  assertProjectRoot(directory);
   const validated = PlanSchema.parse(plan);
   if (options?.preserveCompletedStatuses !== false) {
     try {
@@ -3254,6 +3259,7 @@ ${markdown}`;
   } catch {}
 }
 async function rebuildPlan(directory, plan, options) {
+  assertProjectRoot(directory);
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
@@ -3324,6 +3330,7 @@ ${markdown}`;
   return targetPlan;
 }
 async function closePlanTerminalState(directory, plan, options) {
+  assertProjectRoot(directory);
   const planId = derivePlanId(plan);
   const validated = PlanSchema.parse(plan);
   const hashAfter = computePlanHash(validated);
@@ -3679,11 +3686,11 @@ import {
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync2,
   realpathSync,
+  renameSync as renameSync3,
   rmSync,
   statSync as statSync2
 } from "fs";
 import * as fs7 from "fs/promises";
-import * as os4 from "os";
 import * as path10 from "path";
 
 // src/evaluation/retention.ts
@@ -3792,6 +3799,7 @@ var _retentionInternals = {
   removeCandidate
 };
 async function archiveEvaluationArtifacts(args) {
+  assertProjectRoot(args.directory);
   return withEvidenceLock(args.directory, path9.join("evolution", "retention-index"), "evaluation-retention", "archive", async () => {
     const inventory = await retentionCandidates(args.directory);
     let protectedKeys = await _retentionInternals.protectedArtifacts(args.directory);
@@ -3992,6 +4000,7 @@ async function rewriteAtomic(filePath, survivors) {
   return Buffer.byteLength(payload, "utf8");
 }
 async function pruneEvidenceDocuments(args) {
+  assertProjectRoot(args.directory);
   const dryRun = args.dryRun === true;
   const capsUnset = (typeof args.maxBytes !== "number" || args.maxBytes <= 0) && (typeof args.maxRecords !== "number" || args.maxRecords <= 0);
   const filePath = validateSwarmPath(args.directory, EVIDENCE_CACHE_FILE);
@@ -4096,94 +4105,26 @@ function isValidEvidenceType(type) {
   return VALID_EVIDENCE_TYPES.includes(type);
 }
 var sanitizeTaskId2 = sanitizeTaskId;
-var MAX_DEPTH = 20;
-var PROJECT_INDICATORS = [
-  "package.json",
-  ".git",
-  ".opencode",
-  "Cargo.toml",
-  "go.mod",
-  "pyproject.toml",
-  "Gemfile",
-  "composer.json",
-  "pom.xml",
-  "build.gradle",
-  "CMakeLists.txt"
-];
-function isWeakConfigContainerRoot(directory) {
-  try {
-    const resolved = realpathSync(directory);
-    return resolved === realpathSync(os4.tmpdir()) || resolved === realpathSync(os4.homedir());
-  } catch {
-    const resolved = path10.resolve(directory);
-    return resolved === path10.resolve(os4.tmpdir()) || resolved === path10.resolve(os4.homedir());
-  }
-}
-function hasAccessibleProjectIndicator(directory, options = {}) {
-  const allowConfigOnly = options.allowConfigOnly ?? true;
-  for (const indicator of PROJECT_INDICATORS) {
-    if (!allowConfigOnly && indicator === ".opencode") {
-      continue;
-    }
-    try {
-      const indicatorStat = statSync2(path10.join(directory, indicator));
-      if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
-        return true;
-      }
-    } catch {}
-  }
-  return false;
-}
 function validateProjectRoot(directory) {
-  let resolved;
-  try {
-    resolved = realpathSync(directory);
-  } catch {
-    warn(`[evidence] Cannot canonicalize directory "${directory}" \u2014 failing closed`);
-    throw new Error(`Cannot verify project root for "${directory}" \u2014 directory may not exist or is inaccessible`);
-  }
-  let current = resolved;
-  let depth = 0;
-  while (true) {
-    if (depth >= MAX_DEPTH)
-      break;
-    depth++;
-    const parent = path10.dirname(current);
-    if (parent === current)
-      break;
-    if (path10.dirname(parent) === parent) {
-      current = parent;
-      continue;
-    }
-    const parentSwarm = path10.join(parent, ".swarm");
-    try {
-      if (statSync2(parentSwarm).isDirectory()) {
-        if (hasAccessibleProjectIndicator(parent, {
-          allowConfigOnly: !isWeakConfigContainerRoot(parent)
-        })) {
-          warn(`[evidence] Rejecting write to subdirectory "${resolved}" \u2014 parent "${parent}" already contains .swarm/`);
-          throw new Error(`Cannot write evidence in "${resolved}" \u2014 parent directory "${parent}" already contains a .swarm/ folder. Evidence must be written to the project root.`);
-        }
-      }
-    } catch (error2) {
-      if (error2 instanceof Error && error2.message.startsWith("Cannot write evidence")) {
-        throw error2;
-      }
-    }
-    current = parent;
-  }
+  assertProjectRoot(directory, {
+    realpathSync: _internals11.realpathSync,
+    statSync: _internals11.statSync
+  }, "evidence");
 }
-async function saveEvidence(directory, taskId, evidence) {
+async function saveEvidence(directory, taskId, evidence, abortSignal) {
+  abortSignal?.throwIfAborted();
   _internals11.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
   const relativePath = path10.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
   _internals11.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
+    abortSignal?.throwIfAborted();
     const evidencePath = validateSwarmPath(directory, relativePath);
     const evidenceDir = path10.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
+    abortSignal?.throwIfAborted();
     if (existingContent !== null) {
       try {
         const parsed = JSON.parse(existingContent);
@@ -4227,7 +4168,8 @@ async function saveEvidence(directory, taskId, evidence) {
     const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
-      await fs7.rename(tempPath, evidencePath);
+      abortSignal?.throwIfAborted();
+      renameSync3(tempPath, evidencePath);
     } catch (error2) {
       try {
         rmSync(tempPath, { force: true });
@@ -4292,6 +4234,7 @@ async function loadEvidence(directory, taskId, options) {
         return { status: "found", bundle: validated };
       }
       try {
+        validateProjectRoot(directory);
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
           const evidenceDir = path10.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
@@ -4359,6 +4302,11 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
+  try {
+    validateProjectRoot(directory);
+  } catch {
+    return false;
+  }
   const relativePath = path10.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
@@ -4489,6 +4437,8 @@ var _internals11 = {
   saveEvidence,
   deleteEvidence,
   pruneEvidenceDocuments,
+  realpathSync,
+  statSync: statSync2,
   now: () => new Date
 };
 

package/dist/cli/{index-gvhvz176.js → index-6r522srn.js}

@@ -4,10 +4,10 @@ import {
 } from "./index-ed5ykebp.js";
 import {
   withEvidenceLock
-} from "./index-5j6chvj8.js";
+} from "./index-s0qc4gj6.js";
 import {
   bunWrite
-} from "./index-y111zefa.js";
+} from "./index-4nt52yr9.js";
 
 // src/evidence/task-file.ts
 import { renameSync, unlinkSync } from "fs";