opencode-swarm 7.107.6 → 7.108.0

package/dist/cli/index-f1qyj61w.js

@@ -0,0 +1,418 @@
+// @bun
+import {
+  log
+} from "./index-zgwm4ryv.js";
+import {
+  bunSpawn
+} from "./index-7xgqky26.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
+
+// src/worktree/core.ts
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+var _internals = {
+  bunSpawn,
+  platform: process.platform,
+  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+  osTmpdir: () => os.tmpdir(),
+  getCoreLongPaths: async (directory) => {
+    const result = await runGit(["config", "core.longpaths"], directory);
+    if (result.exitCode !== 0) {
+      return;
+    }
+    const value = result.stdout.trim().toLowerCase();
+    return value === "" ? undefined : value;
+  },
+  fs: {
+    existsSync: fs.existsSync,
+    cp: fsPromises.cp,
+    cpSync: fs.cpSync,
+    symlinkSync: fs.symlinkSync
+  },
+  writeScopeToDisk: async (directory, taskId, files) => {
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-6m5nsp1r.js");
+    return realWrite(directory, taskId, files);
+  },
+  writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {
+    return writeLaneProfileToDiskReal(_worktreePath, _laneIndex, _envOverrides);
+  },
+  removeLaneProfileFromDisk: async (_worktreePath, _laneIndex) => {
+    return removeLaneProfileFromDiskReal(_worktreePath, _laneIndex);
+  },
+  removeWorktree
+};
+async function writeLaneProfileToDiskReal(worktreePath, laneIndex, envOverrides) {
+  const lines = [];
+  for (const [key, value] of Object.entries(envOverrides)) {
+    if (value === null)
+      continue;
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+      continue;
+    if (value.includes(`
+`) || value.includes("\r")) {
+      log("writeLaneProfileToDisk: skipping env var with newline in value", {
+        key
+      });
+      continue;
+    }
+    lines.push(`${key}=${value}`);
+  }
+  if (lines.length === 0)
+    return;
+  const lanesDir = path.join(worktreePath, ".swarm", "lanes");
+  await fs.promises.mkdir(lanesDir, { recursive: true });
+  const envPath = path.join(lanesDir, `${laneIndex}.env`);
+  await fs.promises.writeFile(envPath, `${lines.join(`
+`)}
+`, "utf-8");
+}
+async function removeLaneProfileFromDiskReal(worktreePath, laneIndex) {
+  const envPath = path.join(worktreePath, ".swarm", "lanes", `${laneIndex}.env`);
+  try {
+    await fs.promises.unlink(envPath);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      console.warn(`[worktree] Failed to remove lane profile ${envPath}: ${err.message}`);
+    }
+  }
+}
+var WORKTREE_TIMEOUT_MS = 30000;
+var WIN_PATH_BUDGET = 250;
+async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
+  const proc = _internals.bunSpawn(["git", ...args], {
+    cwd,
+    timeout: timeoutMs,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, LC_ALL: "C" }
+  });
+  try {
+    const exitCode = await proc.exited;
+    const stdout = await proc.stdout.text();
+    const stderr = await proc.stderr.text();
+    return { exitCode, stdout, stderr };
+  } finally {
+    try {
+      proc.kill();
+    } catch {}
+  }
+}
+async function checkPathBudget(worktreeRoot, directory) {
+  if (_internals.platform !== "win32") {
+    return { ok: true };
+  }
+  let longPaths;
+  try {
+    longPaths = await _internals.getCoreLongPaths(directory);
+  } catch {}
+  if (longPaths === "true") {
+    return { ok: true };
+  }
+  const proc = _internals.bunSpawn(["git", "ls-files"], {
+    cwd: directory,
+    timeout: WORKTREE_TIMEOUT_MS,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "ignore",
+    env: { ...process.env, LC_ALL: "C" }
+  });
+  try {
+    const exitCode = await proc.exited;
+    const stdout = await proc.stdout.text();
+    if (exitCode !== 0 || stdout.trim().length === 0) {
+      return { ok: true };
+    }
+    const files = stdout.split(/\r?\n/);
+    let longest = 0;
+    for (const file of files) {
+      if (file.length > longest) {
+        longest = file.length;
+      }
+    }
+    const totalPathLength = worktreeRoot.length + 1 + longest;
+    if (totalPathLength >= WIN_PATH_BUDGET) {
+      return {
+        ok: false,
+        error: `Total path budget exceeded: worktree root "${worktreeRoot}" (${worktreeRoot.length} chars) + longest file "${files.find((f) => f.length === longest)}" (${longest} chars) = ${totalPathLength} chars (budget: ${WIN_PATH_BUDGET})`,
+        suggestion: "Set config.worktree_dir to a shorter absolute path, or let the auto-shorten feature relocate the worktree to the system temp directory."
+      };
+    }
+    return { ok: true };
+  } finally {
+    try {
+      proc.kill();
+    } catch {}
+  }
+}
+function shortenWorktreePath(_directory, sessionId, laneId) {
+  let tmp = _internals.osTmpdir();
+  try {
+    tmp = fs.realpathSync(tmp);
+  } catch {}
+  return path.join(tmp, "swwt", sessionId, laneId);
+}
+function makeWorktreeBranchName(sessionId, id, options) {
+  if (options.branchStyle === "legacy-lane" && options.purpose === "lane") {
+    return `swarm-lane/${sessionId}/${id}`;
+  }
+  return `swarm/${options.purpose}/${sessionId}/${id}`;
+}
+async function provisionWorktree(directory, id, sessionId, options) {
+  const branchName = makeWorktreeBranchName(sessionId, id, options);
+  let worktreePath = options.worktreeDir ? path.resolve(directory, options.worktreeDir, sessionId, id) : path.resolve(path.dirname(directory), ".swarm-worktrees", sessionId, id);
+  const budgetResult = await checkPathBudget(worktreePath, directory);
+  if (budgetResult.ok === false) {
+    if (options.worktreeDir) {
+      console.warn(`[swarm] Path budget warning: ${budgetResult.error} ${budgetResult.suggestion}`);
+    } else {
+      const shortPath = shortenWorktreePath(directory, sessionId, id);
+      const shortBudget = await checkPathBudget(shortPath, directory);
+      if (shortBudget.ok === false) {
+        return { error: budgetResult.error };
+      }
+      worktreePath = shortPath;
+    }
+  }
+  const checkResult = await runGit(["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], directory);
+  if (checkResult.exitCode === 0) {
+    const listResult = await runGit(["worktree", "list", "--porcelain"], directory);
+    const normalizeGitPath = (p) => {
+      const lexical = p.replace(/\\/g, "/").replace(/\/+$/, "");
+      try {
+        return fs.realpathSync(p).replace(/\\/g, "/").replace(/\/+$/, "");
+      } catch {
+        return lexical;
+      }
+    };
+    const expectedPath = normalizeGitPath(worktreePath);
+    const entries = [];
+    let current = { path: "", branch: undefined };
+    if (listResult.exitCode !== 0) {
+      const raw = listResult.stderr.trim() || listResult.stdout.trim();
+      const bounded = raw.length > 500 ? `${raw.slice(0, 500)}... (truncated)` : raw;
+      return {
+        error: `worktree enumeration failed: ${bounded}`
+      };
+    }
+    for (const rawLine of listResult.stdout.split(`
+`)) {
+      const line = rawLine.trim();
+      if (line.startsWith("worktree ")) {
+        if (current.path)
+          entries.push(current);
+        current = {
+          path: normalizeGitPath(line.slice("worktree ".length)),
+          branch: undefined
+        };
+      } else if (line.startsWith("branch ")) {
+        current.branch = line.slice("branch ".length);
+      }
+    }
+    if (current.path)
+      entries.push(current);
+    const branchIsActiveSomewhere = entries.some((e) => e.branch === `refs/heads/${branchName}`);
+    const expectedPathIsRegistered = entries.some((e) => e.path === expectedPath);
+    if (branchIsActiveSomewhere || expectedPathIsRegistered) {
+      return {
+        error: `Branch already exists and worktree is active: ${branchName} (owned by another session)`
+      };
+    }
+    console.warn(`[swarm] adopting existing branch ${branchName} (stale worktree)`);
+    const adoptResult = await runGit(["worktree", "add", "-f", worktreePath, branchName], directory);
+    if (adoptResult.exitCode !== 0) {
+      return {
+        error: `Failed to adopt existing worktree: ${adoptResult.stderr.trim() || adoptResult.stdout.trim()}`
+      };
+    }
+    return {
+      worktreePath,
+      branchName,
+      purpose: options.purpose,
+      id,
+      sessionId
+    };
+  }
+  const addResult = await runGit(["worktree", "add", "-b", branchName, worktreePath, "HEAD"], directory);
+  if (addResult.exitCode !== 0) {
+    return {
+      error: `Failed to create worktree: ${addResult.stderr.trim() || addResult.stdout.trim()}`
+    };
+  }
+  const strategy = options.depsStrategy ?? "skip";
+  if (strategy !== "skip") {
+    const hostDepDir = path.join(directory, "node_modules");
+    const laneDepDir = path.join(worktreePath, "node_modules");
+    if (_internals.fs.existsSync(hostDepDir)) {
+      try {
+        if (strategy === "copy") {
+          await _internals.fs.cp(hostDepDir, laneDepDir, {
+            recursive: true,
+            force: true
+          });
+        } else if (strategy === "link") {
+          const isWindows = _internals.platform === "win32";
+          _internals.fs.symlinkSync(hostDepDir, laneDepDir, isWindows ? "junction" : "dir");
+        }
+      } catch (e) {
+        console.warn(`[swarm] deps_strategy '${strategy}' preparation failed for ${id}: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    } else {
+      return {
+        error: `WORKTREE_DEPS_STRATEGY_HOST_DIR_MISSING: deps_strategy ${strategy} requires node_modules at ${hostDepDir} but it does not exist`
+      };
+    }
+  }
+  if (options.scope?.taskId && Array.isArray(options.scope.files)) {
+    try {
+      await _internals.writeScopeToDisk(worktreePath, options.scope.taskId, options.scope.files);
+    } catch {}
+  }
+  if (options.laneProfile) {
+    try {
+      await _internals.writeLaneProfileToDisk(worktreePath, options.laneProfile.laneIndex, options.laneProfile.envOverrides);
+    } catch {}
+  }
+  return {
+    worktreePath,
+    branchName,
+    purpose: options.purpose,
+    id,
+    sessionId
+  };
+}
+async function removeWorktree(worktreePath, projectRoot) {
+  const isWindows = _internals.platform === "win32";
+  const MAX_RETRIES = 4;
+  const RETRY_DELAY_MS = 2000;
+  let lastError = "";
+  for (let attempt = 0;attempt < MAX_RETRIES; attempt++) {
+    const result = await runGit(["worktree", "remove", worktreePath], projectRoot);
+    if (result.exitCode === 0) {
+      return { success: true };
+    }
+    lastError = result.stderr.trim() || result.stdout.trim();
+    if (isWindows && (lastError.includes("EBUSY") || lastError.includes("EPERM")) && attempt < MAX_RETRIES - 1) {
+      await _internals.sleep(RETRY_DELAY_MS);
+      continue;
+    }
+    return { error: lastError };
+  }
+  return { error: lastError };
+}
+async function isCleanWorktree(worktreePath) {
+  const [statusResult, untrackedResult] = await Promise.all([
+    runGit(["status", "--porcelain"], worktreePath),
+    runGit(["ls-files", "--others", "--exclude-standard"], worktreePath)
+  ]);
+  if (statusResult.exitCode !== 0 || untrackedResult.exitCode !== 0) {
+    return false;
+  }
+  const hasChanges = statusResult.stdout.trim().length > 0;
+  const hasUntracked = untrackedResult.stdout.trim().length > 0;
+  return !hasChanges && !hasUntracked;
+}
+async function autoCommitDirty(worktreePath) {
+  const COMMIT_MESSAGE = "swarm-lane: auto-commit before cleanup";
+  const addResult = await runGit(["add", "-A"], worktreePath);
+  if (addResult.exitCode !== 0) {
+    return {
+      committed: false,
+      reason: `git add failed: ${addResult.stderr.trim() || addResult.stdout.trim()}`
+    };
+  }
+  const commitResult = await runGit(["commit", "-m", COMMIT_MESSAGE], worktreePath);
+  if (commitResult.exitCode !== 0) {
+    const stderr = commitResult.stderr.trim();
+    const stdout = commitResult.stdout.trim();
+    if (stderr.includes("nothing to commit") || stdout.includes("nothing to commit") || stderr.includes("nothing added to commit")) {
+      return { committed: false, reason: "Nothing to commit" };
+    }
+    return {
+      committed: false,
+      reason: `git commit failed: ${stderr || stdout}`
+    };
+  }
+  return { committed: true, message: COMMIT_MESSAGE };
+}
+var SAFE_CLEAN_PATTERNS = [
+  "dist/",
+  "build/",
+  ".turbo/",
+  "coverage/",
+  "node_modules/.cache/",
+  ".log",
+  ".tmp",
+  ".o",
+  ".pyc",
+  ".class"
+];
+function isSafeToClean(candidatePath) {
+  const normalized = candidatePath.replace(/\\/g, "/").toLowerCase();
+  return SAFE_CLEAN_PATTERNS.some((pattern) => {
+    const p = pattern.toLowerCase();
+    if (p.endsWith("/")) {
+      return normalized.startsWith(p) || normalized.includes(`/${p}`);
+    }
+    return normalized.endsWith(p);
+  });
+}
+async function cleanUntrackedFiles(worktreePath) {
+  const dryRun = await runGit(["clean", "-fdn"], worktreePath);
+  if (dryRun.exitCode === 0) {
+    const candidates = dryRun.stdout.trim().split(`
+`).map((line) => {
+      const match = line.match(/^Would remove (.+)$/);
+      return match ? match[1].trim() : "";
+    }).filter((p) => p.length > 0);
+    const unsafePaths = candidates.filter((p) => !isSafeToClean(p));
+    if (unsafePaths.length > 0) {
+      console.warn(`[swarm:cleanUntrackedFiles] Skipping clean \u2014 untracked source files detected: ${unsafePaths.join(", ")}`);
+      return {
+        cleaned: false,
+        error: "untracked source files detected \u2014 skipping clean to prevent data loss"
+      };
+    }
+  }
+  const result = await runGit(["clean", "-fd"], worktreePath);
+  if (result.exitCode !== 0) {
+    return {
+      cleaned: false,
+      error: result.stderr.trim() || result.stdout.trim()
+    };
+  }
+  return { cleaned: true };
+}
+async function assertCleanWorkingTree(directory) {
+  const [statusResult, untrackedResult] = await Promise.all([
+    runGit(["status", "--porcelain"], directory),
+    runGit(["ls-files", "--others", "--exclude-standard"], directory)
+  ]);
+  if (statusResult.exitCode !== 0) {
+    return {
+      clean: false,
+      error: `Unable to verify working tree cleanliness: ${statusResult.stderr.trim() || statusResult.stdout.trim()}`
+    };
+  }
+  if (untrackedResult.exitCode !== 0) {
+    return {
+      clean: false,
+      error: `Unable to verify working tree cleanliness: ${untrackedResult.stderr.trim() || untrackedResult.stdout.trim()}`
+    };
+  }
+  const hasChanges = statusResult.stdout.trim().length > 0;
+  const hasUntracked = untrackedResult.stdout.trim().length > 0;
+  if (hasChanges || hasUntracked) {
+    return {
+      clean: false,
+      error: "Working tree has uncommitted changes. Please commit or stash before provisioning worktrees. Run 'git status' for details."
+    };
+  }
+  return { clean: true };
+}
+
+export { _internals, writeLaneProfileToDiskReal, removeLaneProfileFromDiskReal, checkPathBudget, shortenWorktreePath, makeWorktreeBranchName, provisionWorktree, removeWorktree, isCleanWorktree, autoCommitDirty, cleanUntrackedFiles, assertCleanWorkingTree };

package/dist/cli/{index-wvxhynxq.js → index-fm7xz1ne.js}

@@ -3,7 +3,7 @@ import {
   ALL_AGENT_NAMES,
   PluginConfigSchema,
   stripKnownSwarmPrefix
-} from "./index-pchpahdf.js";
+} from "./index-h4c4rrwx.js";
 import {
   log
 } from "./index-zgwm4ryv.js";

package/dist/cli/{index-dfdg4ws5.js → index-fz1jgbvw.js}

@@ -6,20 +6,20 @@ import {
   resolveSwarmKnowledgePath,
   resolveSwarmRejectedPath,
   transactKnowledge
-} from "./index-xmarctsf.js";
+} from "./index-wg0665ft.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-n1sptn1w.js";
-import {
-  atomicWriteFile
-} from "./index-9b7qp18e.js";
+} from "./index-2nt4mq9n.js";
 import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  atomicWriteFile
+} from "./index-1cn967sa.js";
 import {
   require_proper_lockfile
-} from "./index-3naa2ajc.js";
+} from "./index-vvk2g744.js";
 import {
   __toESM
 } from "./index-a76rekgs.js";

package/dist/cli/{index-pchpahdf.js → index-h4c4rrwx.js}

@@ -1956,7 +1956,16 @@ var WorktreeIsolationConfigSchema = exports_external.object({
   policy: exports_external.enum(["auto", "required", "disabled"]).default("auto"),
   merge_strategy: exports_external.enum(["merge", "rebase", "cherry-pick"]).default("merge"),
   worktree_dir: exports_external.string().optional(),
-  deps_strategy: exports_external.enum(["skip", "copy", "link"]).default("skip")
+  deps_strategy: exports_external.enum(["skip", "copy", "link"]).default("skip"),
+  serialization_release_after_dispatches: exports_external.number().int().positive().default(5),
+  serialization_release_after_ms: exports_external.number().int().positive().default(60000),
+  runtime_isolation: exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    port_base: exports_external.number().int().nonnegative().max(65535).optional(),
+    port_stride: exports_external.number().int().positive().default(1),
+    env_overrides: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+    cache_redirects: exports_external.record(exports_external.string(), exports_external.string()).optional()
+  }).optional()
 });
 var LeanTurboConfigSchema = exports_external.object({
   max_parallel_coders: exports_external.number().int().min(1).max(6).default(4),
@@ -1967,9 +1976,17 @@ var LeanTurboConfigSchema = exports_external.object({
   phase_critic: exports_external.boolean().default(true),
   integrated_diff_required: exports_external.boolean().default(true),
   allow_docs_only_without_reviewer: exports_external.boolean().default(false),
-  worktree_isolation: exports_external.boolean().default(false),
+  worktree_isolation: exports_external.boolean().default(true),
   merge_strategy: exports_external.enum(["merge", "rebase", "cherry-pick"]).default("merge").optional(),
-  worktree_dir: exports_external.string().optional()
+  worktree_dir: exports_external.string().optional(),
+  deps_strategy: exports_external.enum(["skip", "copy", "link"]).optional(),
+  runtime_isolation: exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    port_base: exports_external.number().int().nonnegative().max(65535).optional(),
+    port_stride: exports_external.number().int().positive().default(1),
+    env_overrides: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+    cache_redirects: exports_external.record(exports_external.string(), exports_external.string()).optional()
+  }).optional()
 });
 var EpicConfigSchema = exports_external.object({
   cochange: exports_external.object({

package/dist/cli/{index-kxm3bdjh.js → index-mmny81g1.js}

@@ -1,17 +1,17 @@
 // @bun
 import {
   resolveKnowledgeStoreDir
-} from "./index-n1sptn1w.js";
-import {
-  atomicWriteFile
-} from "./index-9b7qp18e.js";
+} from "./index-2nt4mq9n.js";
 import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  atomicWriteFile
+} from "./index-1cn967sa.js";
 import {
   require_proper_lockfile
-} from "./index-3naa2ajc.js";
+} from "./index-vvk2g744.js";
 import {
   __require,
   __toESM
@@ -594,7 +594,7 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
       deltas.push({ id, delta });
     }
     if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-kyacem71.js");
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-exkw6yb1.js");
       await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {