opencode-swarm 7.58.1 → 7.59.1

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.58.1",
+    version: "7.59.1",
     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",
@@ -1044,7 +1044,9 @@ var init_constants = __esm(() => {
     phase_critic: true,
     integrated_diff_required: true,
     allow_docs_only_without_reviewer: false,
-    worktree_isolation: false
+    worktree_isolation: false,
+    merge_strategy: "merge",
+    worktree_dir: undefined
   };
 });
 
@@ -15917,9 +15919,9 @@ var init_schema = __esm(() => {
     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).refine((val) => val === false, {
-      message: "worktree_isolation: true is not yet implemented. Use false (the default) for in-repo parallel execution. Full worktree isolation will be available in a future release."
-    })
+    worktree_isolation: exports_external.boolean().default(false),
+    merge_strategy: exports_external.enum(["merge", "rebase", "cherry-pick"]).default("merge").optional(),
+    worktree_dir: exports_external.string().optional()
   });
   StandardTurboConfigSchema = exports_external.object({
     strategy: exports_external.literal("standard"),
@@ -57803,7 +57805,7 @@ var init_knowledge_validator = __esm(() => {
     /\bmkfs\b/,
     /\bdd\s+if=/,
     /:\(\)\s*\{/,
-    /\bchmod\s+-R\s+777\b/,
+    /\bchmod\s+-R\s+777\b/i,
     /\bdeltree\b/,
     /\brmdir\s+\/s\b/,
     /\bkill\s+-9\b/,
@@ -92851,7 +92853,7 @@ async function readMergedKnowledge(directory, config3, context, opts) {
   const retractionRecords = await readRetractionRecords(directory);
   const suppressedLessons = new Set(retractionRecords.map((record3) => record3.normalized_lesson).filter((value) => typeof value === "string" && value.length > 0));
   const scopeFilter = config3.scope_filter ?? ["global"];
-  const filtered = merged.filter((entry) => (opts?.skipScopeFilter || scopeFilter.some((pattern) => (entry.scope ?? "global") === pattern)) && NORMAL_RETRIEVAL_STATUSES.has(entry.status) && !suppressedLessons.has(normalize4(entry.lesson)));
+  const filtered = merged.filter((entry) => (opts?.skipScopeFilter || scopeFilter.some((pattern) => (entry.scope ?? "global") === pattern)) && entry.status !== QUARANTINED_STATUS && !suppressedLessons.has(normalize4(entry.lesson)));
   const ranked = filtered.map((entry) => {
     let categoryScore = 0;
     if (context?.currentPhase) {
@@ -93023,12 +93025,11 @@ function scoreDirectiveAgainstContext(entry, ctx) {
     score += 0.1;
   return { triggerHit, actionHit, agentHit, score: Math.min(1, score) };
 }
-var JACCARD_THRESHOLD2 = 0.6, HIVE_TIER_BOOST = 0.05, SAME_PROJECT_PENALTY = -0.05, NORMAL_RETRIEVAL_STATUSES;
+var JACCARD_THRESHOLD2 = 0.6, HIVE_TIER_BOOST = 0.05, SAME_PROJECT_PENALTY = -0.05, QUARANTINED_STATUS = "quarantined";
 var init_knowledge_reader = __esm(() => {
   init_task_file();
   init_logger();
   init_knowledge_store();
-  NORMAL_RETRIEVAL_STATUSES = new Set(["established", "promoted"]);
 });
 
 // src/hooks/search-knowledge.ts
@@ -93081,6 +93082,8 @@ async function searchKnowledge(params) {
     });
     const counterRollups = await readKnowledgeCounterRollups(directory);
     candidates = candidates.filter((e) => {
+      if (e.status === "archived")
+        return false;
       if (e.status === "quarantined")
         return false;
       if (tier === "hive" && e.tier !== "hive")
@@ -93513,10 +93516,10 @@ var init_curator_drift = __esm(() => {
 var exports_design_doc_drift = {};
 __export(exports_design_doc_drift, {
   runDesignDocDriftCheck: () => runDesignDocDriftCheck,
-  _internals: () => _internals67
+  _internals: () => _internals69
 });
 import * as fs109 from "node:fs";
-import * as path148 from "node:path";
+import * as path149 from "node:path";
 function mtimeMsOrNull(absPath) {
   try {
     return fs109.statSync(absPath).mtimeMs;
@@ -93527,35 +93530,35 @@ function mtimeMsOrNull(absPath) {
 function resolveAnchorWithin(directory, anchor) {
   if (!anchor || typeof anchor !== "string")
     return null;
-  const root = path148.resolve(directory);
-  const resolved = path148.resolve(root, anchor);
-  const rel = path148.relative(root, resolved);
-  if (rel.startsWith("..") || path148.isAbsolute(rel))
+  const root = path149.resolve(directory);
+  const resolved = path149.resolve(root, anchor);
+  const rel = path149.relative(root, resolved);
+  if (rel.startsWith("..") || path149.isAbsolute(rel))
     return null;
   return resolved;
 }
 async function runDesignDocDriftCheck(directory, phase, outDir) {
   try {
-    const root = path148.resolve(directory);
-    const outAbs = path148.resolve(root, outDir);
-    const outRel = path148.relative(root, outAbs);
-    if (outRel.startsWith("..") || path148.isAbsolute(outRel)) {
+    const root = path149.resolve(directory);
+    const outAbs = path149.resolve(root, outDir);
+    const outRel = path149.relative(root, outAbs);
+    if (outRel.startsWith("..") || path149.isAbsolute(outRel)) {
       return null;
     }
     const docMtimes = new Map;
     const checkedDocs = [];
     const missingDocs = [];
     for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
-      const abs = path148.join(outAbs, relFile);
+      const abs = path149.join(outAbs, relFile);
       const mtime = mtimeMsOrNull(abs);
       docMtimes.set(docName, mtime);
       if (mtime === null) {
-        missingDocs.push(path148.join(outDir, relFile));
+        missingDocs.push(path149.join(outDir, relFile));
       } else {
-        checkedDocs.push(path148.join(outDir, relFile));
+        checkedDocs.push(path149.join(outDir, relFile));
       }
     }
-    const traceabilityAbs = path148.join(outAbs, TRACEABILITY_REL);
+    const traceabilityAbs = path149.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
       const stat9 = await fs109.promises.stat(traceabilityAbs);
@@ -93568,7 +93571,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
       registry3 = null;
     }
     const noDocs = checkedDocs.length === 0 || registry3 === null;
-    const specMtime = mtimeMsOrNull(path148.join(root, ".swarm", "spec.md"));
+    const specMtime = mtimeMsOrNull(path149.join(root, ".swarm", "spec.md"));
     const staleSections = [];
     if (!noDocs && Array.isArray(registry3?.sections)) {
       for (const section of registry3.sections) {
@@ -93624,7 +93627,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     };
     const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
     const filePath = validateSwarmPath(directory, filename);
-    await fs109.promises.mkdir(path148.dirname(filePath), { recursive: true });
+    await fs109.promises.mkdir(path149.dirname(filePath), { recursive: true });
     await fs109.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
     getGlobalEventBus().publish("curator.docdrift.completed", {
       phase,
@@ -93645,7 +93648,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     return null;
   }
 }
-var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals67;
+var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals69;
 var init_design_doc_drift = __esm(() => {
   init_event_bus();
   init_logger();
@@ -93655,11 +93658,11 @@ var init_design_doc_drift = __esm(() => {
     domain: "domain.md",
     "technical-spec": "technical-spec.md",
     "behavior-spec": "behavior-spec.md",
-    "reference-impl": path148.join("reference", "reference-impl.md"),
-    "idiom-notes": path148.join("reference", "idiom-notes.md")
+    "reference-impl": path149.join("reference", "reference-impl.md"),
+    "idiom-notes": path149.join("reference", "idiom-notes.md")
   };
-  TRACEABILITY_REL = path148.join("reference", "traceability.json");
-  _internals67 = {
+  TRACEABILITY_REL = path149.join("reference", "traceability.json");
+  _internals69 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
     DESIGN_DOC_FILES
@@ -93670,11 +93673,11 @@ var init_design_doc_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals78,
+  _internals: () => _internals80,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs133 from "node:fs";
-import * as path177 from "node:path";
+import * as path178 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -93686,7 +93689,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs133.accessSync(path177.join(directory, pattern));
+    fs133.accessSync(path178.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -93695,7 +93698,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs133.readFileSync(path177.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs133.readFileSync(path178.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -93754,7 +93757,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals78.pickBackend(directory);
+  const backend = await _internals80.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -93793,17 +93796,17 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals78.pickedProfiles(directory);
+  const profiles = _internals80.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals78;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals80;
 var init_project_context = __esm(() => {
   init_dispatch();
   init_framework_detector();
-  _internals78 = {
+  _internals80 = {
     pickBackend,
     pickedProfiles
   };
@@ -93813,7 +93816,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path178 from "node:path";
+import * as path179 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/background/index.ts
@@ -116503,7 +116506,468 @@ init_state2();
 init_file_locks();
 init_manager();
 init_state();
+
+// src/turbo/lean/merge-back.ts
+init_bun_compat();
+
+// src/turbo/lean/worktree.ts
+init_bun_compat();
+import * as os14 from "node:os";
+import * as path137 from "node:path";
+var _internals62 = {
+  bunSpawn,
+  platform: process.platform,
+  sleep: (ms) => new Promise((resolve50) => setTimeout(resolve50, ms)),
+  osTmpdir: () => os14.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;
+  }
+};
+var WORKTREE_TIMEOUT_MS = 30000;
+var WIN_PATH_BUDGET = 250;
+async function runGit(args2, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
+  const proc = _internals62.bunSpawn(["git", ...args2], {
+    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 (_internals62.platform !== "win32") {
+    return { ok: true };
+  }
+  let longPaths;
+  try {
+    longPaths = await _internals62.getCoreLongPaths(directory);
+  } catch {}
+  if (longPaths === "true") {
+    return { ok: true };
+  }
+  const proc = _internals62.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 file3 of files) {
+      if (file3.length > longest) {
+        longest = file3.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) {
+  return path137.join(_internals62.osTmpdir(), "swwt", sessionId, laneId);
+}
+async function provisionWorktree(directory, laneId, sessionId, config3) {
+  const branchName = `swarm-lane/${sessionId}/${laneId}`;
+  let worktreePath = config3.worktree_dir ? path137.resolve(directory, config3.worktree_dir, sessionId, laneId) : path137.resolve(path137.dirname(directory), ".swarm-worktrees", sessionId, laneId);
+  const budgetResult = await checkPathBudget(worktreePath, directory);
+  if (budgetResult.ok === false) {
+    if (config3.worktree_dir) {
+      console.warn(`[swarm] Path budget warning: ${budgetResult.error} ${budgetResult.suggestion}`);
+    } else {
+      const shortPath = shortenWorktreePath(directory, sessionId, laneId);
+      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) {
+    return { error: `Branch already exists: ${branchName}` };
+  }
+  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()}`
+    };
+  }
+  return { worktreePath, branchName };
+}
+async function removeWorktree(worktreePath, projectRoot) {
+  const isWindows = _internals62.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 _internals62.sleep(RETRY_DELAY_MS);
+      continue;
+    }
+    return { error: lastError };
+  }
+  return { error: lastError };
+}
+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 — untracked source files detected: ${unsafePaths.join(", ")}`);
+      return {
+        cleaned: false,
+        error: "untracked source files detected — 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 };
+}
+
+// src/turbo/lean/merge-back.ts
+var _internals63 = {
+  bunSpawn,
+  platform: process.platform,
+  sleep: (ms) => new Promise((resolve50) => setTimeout(resolve50, ms))
+};
+var MERGE_TIMEOUT_MS = 30000;
+async function runGit2(args2, cwd, timeoutMs = MERGE_TIMEOUT_MS) {
+  const proc = _internals63.bunSpawn(["git", ...args2], {
+    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 {}
+  }
+}
+function parseConflictFiles(output) {
+  const files = [];
+  const lines = output.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/CONFLICT\b.*(?:Merge conflict in |in )(.+)/);
+    if (match?.[1]) {
+      files.push(match[1].trim());
+    }
+  }
+  return files;
+}
+function getMergeStrategy(config3) {
+  return config3.merge_strategy ?? "merge";
+}
+async function mergeLaneBranch(primaryDir, branchName, strategy) {
+  let result;
+  switch (strategy) {
+    case "merge":
+      result = await runGit2(["merge", "--no-edit", branchName], primaryDir);
+      break;
+    case "rebase":
+      result = await runGit2(["rebase", branchName], primaryDir);
+      break;
+    case "cherry-pick": {
+      const mergeBaseResult = await runGit2(["merge-base", "HEAD", branchName], primaryDir);
+      if (mergeBaseResult.exitCode === 0 && mergeBaseResult.stdout.trim()) {
+        const mergeBase = mergeBaseResult.stdout.trim();
+        result = await runGit2(["cherry-pick", `${mergeBase}..${branchName}`], primaryDir);
+      } else {
+        console.warn("[lean-turbo] mergeLaneBranch: git merge-base failed for cherry-pick; falling back to tip-only cherry-pick");
+        result = await runGit2(["cherry-pick", branchName], primaryDir);
+      }
+      break;
+    }
+  }
+  if (result.exitCode === 0) {
+    return { merged: true, strategy };
+  }
+  const combinedOutput = `${result.stderr}
+${result.stdout}`;
+  const hasConflict = /CONFLICT/i.test(combinedOutput) || /conflict/i.test(combinedOutput);
+  if (hasConflict) {
+    const files = parseConflictFiles(combinedOutput);
+    const abortArgs = strategy === "rebase" ? ["rebase", "--abort"] : strategy === "cherry-pick" ? ["cherry-pick", "--abort"] : ["merge", "--abort"];
+    await runGit2(abortArgs, primaryDir);
+    return {
+      conflict: true,
+      files,
+      message: result.stderr.trim()
+    };
+  }
+  return {
+    error: result.stderr.trim() || result.stdout.trim()
+  };
+}
+async function postMergeCleanup(directory, branchName) {
+  const deleteResult = await runGit2(["branch", "-D", branchName], directory);
+  const deleteOk = deleteResult.exitCode === 0;
+  const pruneResult = await runGit2(["worktree", "prune"], directory);
+  const pruneOk = pruneResult.exitCode === 0;
+  if (deleteOk && pruneOk) {
+    return { cleaned: true };
+  }
+  if (!deleteOk && pruneOk) {
+    return {
+      error: `Branch delete failed: ${deleteResult.stderr.trim() || deleteResult.stdout.trim()}`,
+      partial: true
+    };
+  }
+  return {
+    error: deleteOk ? `Worktree prune failed: ${pruneResult.stderr.trim() || pruneResult.stdout.trim()}` : `Branch delete failed: ${deleteResult.stderr.trim() || deleteResult.stdout.trim()}; worktree prune failed: ${pruneResult.stderr.trim() || pruneResult.stdout.trim()}`
+  };
+}
+async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, strategy) {
+  let autoCommitted = false;
+  let cleaned = false;
+  let autoCommitFailed = false;
+  let cleanFailed = false;
+  const commitResult = await autoCommitDirty(worktreePath);
+  if (commitResult.committed) {
+    autoCommitted = true;
+  } else if (commitResult.reason !== "Nothing to commit") {
+    autoCommitFailed = true;
+    console.warn(`[lean-turbo] attemptMergeBackFromDirty: auto-commit failed for worktree "${worktreePath}" branch "${branchName}": ${commitResult.reason}`);
+  }
+  const cleanResult = await cleanUntrackedFiles(worktreePath);
+  if (cleanResult.cleaned) {
+    cleaned = true;
+  } else {
+    cleanFailed = true;
+    console.warn(`[lean-turbo] attemptMergeBackFromDirty: clean untracked failed for worktree "${worktreePath}" branch "${branchName}": ${cleanResult.error}`);
+  }
+  if (autoCommitFailed && cleanFailed) {
+    return {
+      failed: true,
+      stage: "cleanup",
+      message: "Auto-commit and clean both failed; abandoning worktree"
+    };
+  }
+  const mergeResult = await mergeLaneBranch(primaryDir, branchName, strategy);
+  if ("merged" in mergeResult && mergeResult.merged) {
+    return { merged: true, strategy, autoCommitted, cleaned };
+  }
+  if ("conflict" in mergeResult) {
+    return {
+      partial: true,
+      stage: "merge",
+      autoCommitted,
+      cleaned,
+      message: mergeResult.message
+    };
+  }
+  if ("error" in mergeResult) {
+    return {
+      failed: true,
+      stage: "merge",
+      message: mergeResult.error
+    };
+  }
+  return {
+    failed: true,
+    stage: "merge",
+    message: "Merge failed with unexpected result"
+  };
+}
+function extractSessionId(branchName) {
+  const segments = branchName.trim().split("/");
+  if (segments.length >= 3 && segments[0] === "swarm-lane") {
+    return segments[1];
+  }
+  return null;
+}
+async function startupOrphanRecovery(directory, activeSessionIds = []) {
+  const warnings = [];
+  const pruneResult = await runGit2(["worktree", "prune"], directory);
+  if (pruneResult.exitCode !== 0) {
+    warnings.push(`git worktree prune failed: ${pruneResult.stderr.trim() || pruneResult.stdout.trim()}`);
+  }
+  const listResult = await runGit2(["branch", "--format=%(refname:short)", "--list", "swarm-lane/*"], directory);
+  const allBranches = listResult.stdout.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+  const orphanBranches = [];
+  for (const branch of allBranches) {
+    const sessionId = extractSessionId(branch);
+    if (sessionId === null || !activeSessionIds.includes(sessionId)) {
+      orphanBranches.push(branch);
+      warnings.push(`Orphaned swarm-lane branch "${branch}" detected in "${directory}"`);
+    }
+  }
+  for (const warning of warnings) {
+    console.warn(warning);
+  }
+  return {
+    prunedWorktrees: pruneResult.exitCode === 0,
+    remainingBranches: orphanBranches,
+    warnings
+  };
+}
+
+// src/turbo/lean/runner.ts
 init_state3();
+function isTransientProvisionError(errorMsg) {
+  const lower = errorMsg.toLowerCase();
+  if (lower.includes("already exists") || lower.includes("not a git repository")) {
+    return false;
+  }
+  const transientCodes = [
+    "enoent",
+    "econnrefused",
+    "etimedout",
+    "ebusy",
+    "eperm",
+    "enomem"
+  ];
+  for (const code of transientCodes) {
+    if (lower.includes(code)) {
+      return true;
+    }
+  }
+  const transientMessages = [
+    "disk full",
+    "no space left",
+    "resource temporarily unavailable"
+  ];
+  for (const msg of transientMessages) {
+    if (lower.includes(msg)) {
+      return true;
+    }
+  }
+  if (lower.includes("fatal:")) {
+    return true;
+  }
+  return false;
+}
 
 class LeanTurboRunner {
   static _internals = {
@@ -116516,7 +116980,15 @@ class LeanTurboRunner {
     hasActiveFullAuto,
     loadFullAutoRunState,
     writeLaneEvidence,
-    laneDispatchTimeoutMs: undefined
+    laneDispatchTimeoutMs: undefined,
+    provisionWorktree,
+    removeWorktree,
+    mergeLaneBranch,
+    postMergeCleanup,
+    attemptMergeBackFromDirty,
+    startupOrphanRecovery,
+    getMergeStrategy,
+    assertCleanWorkingTree
   };
   _sessionOps = null;
   _directory;
@@ -116575,6 +117047,22 @@ class LeanTurboRunner {
       }
     }
     const leanConfig = this._getLeanConfig(this._leanConfig);
+    if (leanConfig.worktree_isolation) {
+      await LeanTurboRunner._internals.startupOrphanRecovery(this._directory, [
+        this._sessionID
+      ]);
+      try {
+        const cleanResult = await LeanTurboRunner._internals.assertCleanWorkingTree(this._directory);
+        if (!cleanResult.clean) {
+          console.warn(`[lean-turbo] worktree isolation requires clean working tree: ${cleanResult.error}`);
+          leanConfig.worktree_isolation = false;
+        }
+      } catch (assertErr) {
+        const assertMsg = assertErr instanceof Error ? assertErr.message : String(assertErr);
+        console.warn(`[lean-turbo] unable to verify working tree cleanliness: ${assertMsg} — degrading to shared directory`);
+        leanConfig.worktree_isolation = false;
+      }
+    }
     const lanePlan = LeanTurboRunner._internals.planLeanTurboLanes(this._directory, phaseNumber, { phases: plan.phases }, leanConfig);
     const degradedTasks = lanePlan.degradedTasks.map((d) => d.taskId);
     if (lanePlan.lanes.length === 0 && degradedTasks.length === 0 && lanePlan.serializedTasks.length === 0) {
@@ -116598,21 +117086,23 @@ class LeanTurboRunner {
     await this._withStateLock(() => this._updateDurableState(lanePlan));
     this._laneStatuses = new Map(lanePlan.lanes.map((lane) => [lane.laneId, { ...lane }]));
     const laneResults = [];
-    const results = await Promise.all(lanePlan.lanes.map((lane) => this._processLane(lane)));
+    const results = await Promise.all(lanePlan.lanes.map((lane) => this._processLane(lane, leanConfig)));
     laneResults.push(...results);
+    const mergeBackFailures = await this._sequentialWorktreeCleanup(laneResults, leanConfig);
     return {
       ok: true,
       lanes: laneResults,
       degradedTasks,
-      serializedTasks: lanePlan.serializedTasks
+      serializedTasks: lanePlan.serializedTasks,
+      mergeBackFailures: mergeBackFailures.length > 0 ? mergeBackFailures : undefined
     };
   }
-  async dispatchLane(lane, agentName) {
+  async dispatchLane(lane, agentName, worktreeDirectory) {
     const session = this._sessionOps ?? this._client?.session;
     if (!session) {
       return { ok: false, error: "NO_CLIENT" };
     }
-    const dispatchPromise = this._doDispatch(session, lane, agentName);
+    const dispatchPromise = this._doDispatch(session, lane, agentName, worktreeDirectory);
     const timeoutMs = LeanTurboRunner._internals.laneDispatchTimeoutMs;
     if (timeoutMs !== undefined && timeoutMs > 0) {
       const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Lane dispatch timed out after ${timeoutMs}ms`)), timeoutMs));
@@ -116643,10 +117133,11 @@ class LeanTurboRunner {
     }
     return dispatchPromise;
   }
-  async _doDispatch(session, lane, agentName) {
+  async _doDispatch(session, lane, agentName, worktreeDirectory) {
     try {
+      const effectiveDirectory = worktreeDirectory ?? this._directory;
       const createResult = await session.create({
-        query: { directory: this._directory }
+        query: { directory: effectiveDirectory }
       });
       if (!createResult.data) {
         return {
@@ -116698,6 +117189,13 @@ class LeanTurboRunner {
       } catch {}
     }
     this._laneLockMap = {};
+    for (const [_laneId, lane] of this._laneStatuses) {
+      if (lane.worktreePath) {
+        try {
+          await LeanTurboRunner._internals.removeWorktree(lane.worktreePath, this._directory);
+        } catch {}
+      }
+    }
     await this._withStateLock(async () => {
       const runState = LeanTurboRunner._internals.loadLeanTurboRunState(this._directory, this._sessionID);
       if (runState) {
@@ -116745,7 +117243,7 @@ class LeanTurboRunner {
     }
     return defaults;
   }
-  async _processLane(lane) {
+  async _processLane(lane, leanConfig) {
     const laneInState = this._laneStatuses.get(lane.laneId);
     if (laneInState) {
       laneInState.status = "running";
@@ -116782,12 +117280,85 @@ class LeanTurboRunner {
       };
     }
     this._laneLockMap[lane.laneId] = [...lane.files];
-    const dispatchResult = await this.dispatchLane(lane, agent);
+    let worktreeDirectory;
+    if (leanConfig.worktree_isolation) {
+      let provisionError;
+      try {
+        const provisionResult = await LeanTurboRunner._internals.provisionWorktree(this._directory, lane.laneId, this._sessionID, leanConfig);
+        if ("worktreePath" in provisionResult) {
+          worktreeDirectory = provisionResult.worktreePath;
+          if (laneInState) {
+            laneInState.worktreePath = provisionResult.worktreePath;
+            laneInState.branchName = provisionResult.branchName;
+          }
+          await this._persistLaneWorktreeFields(lane.laneId, provisionResult.worktreePath, provisionResult.branchName);
+        } else {
+          provisionError = provisionResult.error;
+        }
+      } catch (provisionErr) {
+        provisionError = provisionErr instanceof Error ? provisionErr.message : String(provisionErr);
+      }
+      if (provisionError) {
+        if (isTransientProvisionError(provisionError)) {
+          console.warn(`[lean-turbo] worktree provision failed for lane ${lane.laneId}: ${provisionError} — retrying once...`);
+          await new Promise((r) => setTimeout(r, 100));
+          try {
+            const retryResult = await LeanTurboRunner._internals.provisionWorktree(this._directory, lane.laneId, this._sessionID, leanConfig);
+            if ("worktreePath" in retryResult) {
+              worktreeDirectory = retryResult.worktreePath;
+              if (laneInState) {
+                laneInState.worktreePath = retryResult.worktreePath;
+                laneInState.branchName = retryResult.branchName;
+              }
+              await this._persistLaneWorktreeFields(lane.laneId, retryResult.worktreePath, retryResult.branchName);
+              console.warn(`[lean-turbo] worktree provision retry succeeded for lane ${lane.laneId}`);
+              provisionError = undefined;
+            } else {
+              provisionError = retryResult.error;
+              console.warn(`[lean-turbo] worktree provision retry failed for lane ${lane.laneId}: ${retryResult.error}`);
+            }
+          } catch (retryErr) {
+            const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+            console.warn(`[lean-turbo] worktree provision retry threw for lane ${lane.laneId}: ${retryMsg}`);
+          }
+        } else {
+          console.warn(`[lean-turbo] worktree provision failed for lane ${lane.laneId}: ${provisionError}`);
+        }
+      }
+      if (!worktreeDirectory) {
+        const failMsg = `worktree provision failed: ${provisionError ?? "unknown error"}`;
+        try {
+          await LeanTurboRunner._internals.releaseLaneLocks(this._directory, lane.laneId);
+        } catch {}
+        delete this._laneLockMap[lane.laneId];
+        if (laneInState) {
+          laneInState.status = "failed";
+          laneInState.error = failMsg;
+        }
+        await this._updateDurableStateLaneStatus(lane.laneId, "failed");
+        await this._writeLaneEvidenceSafely(lane, "failed", {
+          status: "failed",
+          error: failMsg,
+          agent
+        });
+        return {
+          laneId: lane.laneId,
+          status: "failed",
+          taskIds: lane.taskIds,
+          agent,
+          error: failMsg
+        };
+      }
+    }
+    const dispatchResult = await this.dispatchLane(lane, agent, worktreeDirectory);
     if (!dispatchResult.ok) {
       try {
         await LeanTurboRunner._internals.releaseLaneLocks(this._directory, lane.laneId);
       } catch {}
       delete this._laneLockMap[lane.laneId];
+      if (worktreeDirectory && laneInState) {
+        laneInState._failureCleanupPending = true;
+      }
       if (laneInState) {
         laneInState.status = "failed";
         laneInState.error = dispatchResult.error;
@@ -116832,6 +117403,69 @@ class LeanTurboRunner {
       sessionId: dispatchResult.sessionId
     };
   }
+  async _sequentialWorktreeCleanup(laneResults, leanConfig) {
+    const mergeBackFailures = [];
+    for (const lr of laneResults) {
+      const laneInState = this._laneStatuses.get(lr.laneId);
+      if (!laneInState?.worktreePath)
+        continue;
+      let needsPostMergeCleanup = false;
+      if (lr.status === "completed") {
+        if (!laneInState.branchName)
+          continue;
+        try {
+          const strategy = LeanTurboRunner._internals.getMergeStrategy(leanConfig);
+          const mergeResult = await LeanTurboRunner._internals.mergeLaneBranch(this._directory, laneInState.branchName, strategy);
+          if ("merged" in mergeResult && mergeResult.merged) {
+            needsPostMergeCleanup = true;
+          } else if ("conflict" in mergeResult && mergeResult.conflict) {
+            const failureInfo = {
+              laneId: lr.laneId,
+              reason: mergeResult.message || "merge conflict",
+              conflictFiles: mergeResult.files
+            };
+            mergeBackFailures.push(failureInfo);
+            lr.mergeBackFailure = failureInfo;
+            console.warn(`[lean-turbo] merge-back CONFLICT for lane ${lr.laneId}: ${failureInfo.reason} — worktree preserved at ${laneInState.worktreePath} for manual recovery`);
+            continue;
+          } else if ("error" in mergeResult && mergeResult.error) {
+            const failureInfo = {
+              laneId: lr.laneId,
+              reason: mergeResult.error
+            };
+            mergeBackFailures.push(failureInfo);
+            lr.mergeBackFailure = failureInfo;
+            console.warn(`[lean-turbo] merge-back ERROR for lane ${lr.laneId}: ${failureInfo.reason} — worktree preserved at ${laneInState.worktreePath} for manual recovery`);
+            continue;
+          }
+        } catch (err2) {
+          const errMsg = err2 instanceof Error ? err2.message : String(err2);
+          const failureInfo = {
+            laneId: lr.laneId,
+            reason: errMsg
+          };
+          mergeBackFailures.push(failureInfo);
+          lr.mergeBackFailure = failureInfo;
+          console.warn(`[lean-turbo] merge-back EXCEPTION for lane ${lr.laneId}: ${errMsg} — worktree preserved at ${laneInState.worktreePath} for manual recovery`);
+          continue;
+        }
+      } else if (lr.status === "failed" && laneInState._failureCleanupPending) {
+        try {
+          const strategy = LeanTurboRunner._internals.getMergeStrategy(leanConfig);
+          await LeanTurboRunner._internals.attemptMergeBackFromDirty(laneInState.worktreePath, laneInState.branchName ?? `swarm-lane/${this._sessionID}/${lr.laneId}`, this._directory, strategy);
+        } catch {}
+      }
+      try {
+        await LeanTurboRunner._internals.removeWorktree(laneInState.worktreePath, this._directory);
+      } catch {}
+      if (needsPostMergeCleanup && laneInState.branchName) {
+        try {
+          await LeanTurboRunner._internals.postMergeCleanup(this._directory, laneInState.branchName);
+        } catch {}
+      }
+    }
+    return mergeBackFailures;
+  }
   _selectNextAgent() {
     if (this._availableAgents.length === 0) {
       return "coder";
@@ -116925,6 +117559,21 @@ ${fileList}
       LeanTurboRunner._internals.saveLeanTurboRunState(this._directory, runState);
     } catch {}
   }
+  async _persistLaneWorktreeFields(laneId, worktreePath, branchName) {
+    await this._withStateLock(async () => {
+      try {
+        const runState = LeanTurboRunner._internals.loadLeanTurboRunState(this._directory, this._sessionID);
+        if (!runState)
+          return;
+        const lane = runState.lanes.find((l) => l.laneId === laneId);
+        if (lane) {
+          lane.worktreePath = worktreePath;
+          lane.branchName = branchName;
+          LeanTurboRunner._internals.saveLeanTurboRunState(this._directory, runState);
+        }
+      } catch {}
+    });
+  }
   async _updateDurableStateLaneStatus(laneId, status) {
     await this._withStateLock(async () => {
       try {
@@ -116950,7 +117599,7 @@ ${fileList}
 
 // src/tools/lean-turbo-run-phase.ts
 init_create_tool();
-var _internals62 = {
+var _internals64 = {
   LeanTurboRunner,
   loadPluginConfigWithMeta
 };
@@ -116960,9 +117609,9 @@ async function executeLeanTurboRunPhase(args2) {
   let runError = null;
   let runner = null;
   try {
-    const { config: config3 } = _internals62.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals64.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.strategy === "lean" ? config3.turbo.lean : undefined;
-    runner = new _internals62.LeanTurboRunner({
+    runner = new _internals64.LeanTurboRunner({
       directory,
       sessionID,
       opencodeClient: swarmState.opencodeClient ?? null,
@@ -116995,6 +117644,7 @@ async function executeLeanTurboRunPhase(args2) {
     lanes: runResult.lanes,
     degradedTasks: runResult.degradedTasks,
     serializedTasks: runResult.serializedTasks,
+    mergeBackFailures: runResult.mergeBackFailures,
     reason: runResult.reason
   };
 }
@@ -117121,7 +117771,7 @@ init_lint();
 init_spec_schema();
 init_create_tool();
 import * as fs99 from "node:fs";
-import * as path137 from "node:path";
+import * as path138 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -117174,7 +117824,7 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path137.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    const specPath = path138.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
     if (!fs99.existsSync(specPath)) {
       const result2 = {
         valid: false,
@@ -117246,12 +117896,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs100 from "node:fs";
-import * as path139 from "node:path";
+import * as path140 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
 import { unlinkSync as unlinkSync19, writeFileSync as writeFileSync26 } from "node:fs";
-import * as path138 from "node:path";
+import * as path139 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -117323,7 +117973,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals63 = {
+var _internals65 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -117363,7 +118013,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals63.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals65.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err2) {
       results.push({
@@ -117382,7 +118032,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
 var MUTATION_TIMEOUT_MS = 30000;
 var TOTAL_BUDGET_MS = 300000;
 var GIT_APPLY_TIMEOUT_MS = 5000;
-var _internals64 = {
+var _internals66 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -117397,7 +118047,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path138.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path139.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync26(patchFile, patch.patch);
     } catch (writeErr) {
@@ -117414,7 +118064,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
       };
     }
     try {
-      const applyResult = _internals64.spawnSync("git", ["apply", "--", patchFile], {
+      const applyResult = _internals66.spawnSync("git", ["apply", "--", patchFile], {
         cwd: workingDir,
         timeout: GIT_APPLY_TIMEOUT_MS,
         stdio: "pipe"
@@ -117443,7 +118093,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
     }
     let testPassed = false;
     try {
-      const spawnResult = _internals64.spawnSync(testCommand[0], testCommand.slice(1), {
+      const spawnResult = _internals66.spawnSync(testCommand[0], testCommand.slice(1), {
         cwd: workingDir,
         timeout: MUTATION_TIMEOUT_MS,
         stdio: "pipe"
@@ -117476,7 +118126,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   } finally {
     if (patchFile) {
       try {
-        const revertResult = _internals64.spawnSync("git", ["apply", "-R", "--", patchFile], {
+        const revertResult = _internals66.spawnSync("git", ["apply", "-R", "--", patchFile], {
           cwd: workingDir,
           timeout: GIT_APPLY_TIMEOUT_MS,
           stdio: "pipe"
@@ -117669,7 +118319,7 @@ async function executeMutationSuite(patches, testCommand, testFiles, workingDir,
 }
 
 // src/mutation/gate.ts
-var _internals65 = {
+var _internals67 = {
   evaluateMutationGate,
   buildTestImprovementPrompt,
   buildMessage
@@ -117690,8 +118340,8 @@ function evaluateMutationGate(report, passThreshold = PASS_THRESHOLD, warnThresh
   } else {
     verdict = "fail";
   }
-  const testImprovementPrompt = _internals65.buildTestImprovementPrompt(report, passThreshold, verdict);
-  const message = _internals65.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
+  const testImprovementPrompt = _internals67.buildTestImprovementPrompt(report, passThreshold, verdict);
+  const message = _internals67.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
   return {
     verdict,
     killRate: report.killRate,
@@ -117801,7 +118451,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path139.resolve(cwd, filePath);
+          const resolvedPath = path140.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs100.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -117823,22 +118473,22 @@ init_config();
 init_schema();
 init_manager2();
 import * as fs110 from "node:fs";
-import * as path149 from "node:path";
+import * as path150 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state2();
 import * as fs101 from "node:fs";
-import * as path140 from "node:path";
+import * as path141 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path140.posix.join("evidence", String(phase)));
+    const dirPath = validateSwarmPath(directory, path141.posix.join("evidence", String(phase)));
     if (!fs101.existsSync(dirPath))
       return [];
     const entries = fs101.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path140.join(dirPath, e));
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path141.join(dirPath, e));
   } catch {
     return [];
   }
@@ -117979,16 +118629,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs102 from "node:fs";
-import * as path141 from "node:path";
+import * as path142 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path141.join(directory, ".swarm");
+    const swarmDir = path142.join(directory, ".swarm");
     fs102.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path141.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path141.join(swarmDir, "SWARM_PLAN.md");
+    const jsonPath = path142.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path142.join(swarmDir, "SWARM_PLAN.md");
     fs102.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs102.writeFileSync(mdPath, md, "utf8");
@@ -118007,7 +118657,7 @@ init_telemetry();
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
 import * as fs103 from "node:fs";
-import * as path142 from "node:path";
+import * as path143 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
   phase_reviewer: true,
@@ -118016,7 +118666,7 @@ var DEFAULT_CONFIG3 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path142.join(dir, ".swarm", "plan.json");
+    const planPath = path143.join(dir, ".swarm", "plan.json");
     if (!fs103.existsSync(planPath))
       return null;
     const raw = fs103.readFileSync(planPath, "utf-8");
@@ -118031,7 +118681,7 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path142.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    const evidencePath = path143.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
     if (!fs103.existsSync(evidencePath)) {
       return null;
     }
@@ -118051,7 +118701,7 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path142.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    const evidencePath = path143.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
     if (!fs103.existsSync(evidencePath)) {
       return null;
     }
@@ -118070,7 +118720,7 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path142.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path143.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
     entries = fs103.readdirSync(evidenceDir);
@@ -118086,7 +118736,7 @@ function listLaneEvidenceSync(directory, phase) {
   }
   return laneIds;
 }
-var _internals66 = {
+var _internals68 = {
   listActiveLocks,
   readPersisted: readPersisted2,
   readPlanJson: defaultReadPlanJson,
@@ -118140,14 +118790,14 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG3,
     ...actualConfig
   };
-  const statePath = path142.join(directory, ".swarm", "turbo-state.json");
+  const statePath = path143.join(directory, ".swarm", "turbo-state.json");
   if (!fs103.existsSync(statePath)) {
     return {
       ok: false,
       reason: "Lean Turbo state unreadable or missing"
     };
   }
-  const persisted = _internals66.readPersisted(directory);
+  const persisted = _internals68.readPersisted(directory);
   if (!persisted) {
     return {
       ok: false,
@@ -118211,7 +118861,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (runState.lanes.length > 0) {
-    const evidenceLaneIds = new Set(_internals66.listLaneEvidenceSync(directory, phase));
+    const evidenceLaneIds = new Set(_internals68.listLaneEvidenceSync(directory, phase));
     for (const lane of runState.lanes) {
       if ((lane.status === "completed" || lane.status === "failed") && !evidenceLaneIds.has(lane.laneId)) {
         return {
@@ -118221,7 +118871,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       }
     }
   }
-  const activeLocks = _internals66.listActiveLocks(directory);
+  const activeLocks = _internals68.listActiveLocks(directory);
   const phaseLaneIds = new Set(laneIds);
   for (const lock of activeLocks) {
     if (lock.laneId && phaseLaneIds.has(lock.laneId)) {
@@ -118241,7 +118891,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serialDegradedTasks = runState.degradedTasks.filter((dt) => !laneTaskIds.has(dt.taskId));
   if (serialDegradedTasks.length > 0) {
-    const plan = _internals66.readPlanJson(directory);
+    const plan = _internals68.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -118285,7 +118935,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serializedTasks = runState.serializedTasks;
   if (Array.isArray(serializedTasks) && serializedTasks.length > 0) {
-    const plan = _internals66.readPlanJson(directory);
+    const plan = _internals68.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -118328,7 +118978,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path142.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path143.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
       const content = fs103.readFileSync(evidencePath, "utf-8");
@@ -118344,7 +118994,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let reviewerVerdict = runState.lastReviewerVerdict;
   if (!reviewerVerdict) {
-    const evidence = _internals66.readReviewerEvidence(directory, phase);
+    const evidence = _internals68.readReviewerEvidence(directory, phase);
     reviewerVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_reviewer) {
@@ -118357,7 +119007,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let criticVerdict = runState.lastCriticVerdict;
   if (!criticVerdict) {
-    const evidence = _internals66.readCriticEvidence(directory, phase);
+    const evidence = _internals68.readCriticEvidence(directory, phase);
     criticVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_critic) {
@@ -118480,13 +119130,13 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs104 from "node:fs";
-import * as path143 from "node:path";
+import * as path144 from "node:path";
 async function runDriftGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let driftCheckEnabled = true;
   let driftHasSpecMd = false;
   try {
-    const specMdPath = path143.join(dir, ".swarm", "spec.md");
+    const specMdPath = path144.join(dir, ".swarm", "spec.md");
     driftHasSpecMd = fs104.existsSync(specMdPath);
     const gatePlan = await loadPlan(dir);
     if (gatePlan) {
@@ -118514,7 +119164,7 @@ async function runDriftGate(ctx) {
   }
   let phaseType;
   try {
-    const planPath = path143.join(dir, ".swarm", "plan.json");
+    const planPath = path144.join(dir, ".swarm", "plan.json");
     if (fs104.existsSync(planPath)) {
       const planRaw = fs104.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
@@ -118533,7 +119183,7 @@ async function runDriftGate(ctx) {
     };
   }
   try {
-    const driftEvidencePath = path143.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+    const driftEvidencePath = path144.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
     let driftVerdictFound = false;
     let driftVerdictApproved = false;
     try {
@@ -118569,7 +119219,7 @@ async function runDriftGate(ctx) {
         let incompleteTaskCount = 0;
         let planParseable = false;
         try {
-          const planPath = path143.join(dir, ".swarm", "plan.json");
+          const planPath = path144.join(dir, ".swarm", "plan.json");
           if (fs104.existsSync(planPath)) {
             const planRaw = fs104.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
@@ -118651,7 +119301,7 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs105 from "node:fs";
-import * as path144 from "node:path";
+import * as path145 from "node:path";
 async function runFinalCouncilGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let finalCouncilEnabled = false;
@@ -118669,7 +119319,7 @@ async function runFinalCouncilGate(ctx) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.final_council === true) {
             finalCouncilEnabled = true;
-            const fcPath = path144.join(dir, ".swarm", "evidence", "final-council.json");
+            const fcPath = path145.join(dir, ".swarm", "evidence", "final-council.json");
             let fcVerdictFound = false;
             let _fcVerdict;
             try {
@@ -118810,7 +119460,7 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs106 from "node:fs";
-import * as path145 from "node:path";
+import * as path146 from "node:path";
 async function runHallucinationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
@@ -118823,7 +119473,7 @@ async function runHallucinationGate(ctx) {
         const overrides = session?.qaGateSessionOverrides ?? {};
         const effective = getEffectiveGates(profile, overrides);
         if (effective.hallucination_guard === true) {
-          const hgPath = path145.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+          const hgPath = path146.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
           let hgVerdictFound = false;
           let hgVerdictApproved = false;
           try {
@@ -118886,7 +119536,7 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs107 from "node:fs";
-import * as path146 from "node:path";
+import * as path147 from "node:path";
 async function runMutationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
@@ -118899,7 +119549,7 @@ async function runMutationGate(ctx) {
         const overrides = session?.qaGateSessionOverrides ?? {};
         const effective = getEffectiveGates(profile, overrides);
         if (effective.mutation_test === true) {
-          const mgPath = path146.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+          const mgPath = path147.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
           let mgVerdictFound = false;
           let mgVerdict;
           try {
@@ -118962,7 +119612,7 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs108 from "node:fs";
-import * as path147 from "node:path";
+import * as path148 from "node:path";
 async function runPhaseCouncilGate(ctx) {
   const { phase, dir, sessionID, pluginConfig, agentsDispatched, safeWarn } = ctx;
   let councilModeEnabled = false;
@@ -118977,7 +119627,7 @@ async function runPhaseCouncilGate(ctx) {
         const effective = getEffectiveGates(profile, overrides);
         if (effective.council_mode === true) {
           councilModeEnabled = true;
-          const pcPath = path147.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+          const pcPath = path148.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
           let pcVerdictFound = false;
           let _pcVerdict;
           let pcQuorumSize;
@@ -119469,7 +120119,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       phase_critic: leanConfig.phase_critic,
       integrated_diff_required: leanConfig.integrated_diff_required
     } : undefined;
-    const leanCheck = _internals66.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
+    const leanCheck = _internals68.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
     if (!leanCheck.ok) {
       return JSON.stringify({
         success: false,
@@ -119492,7 +120142,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path149.basename(dir);
+      const projectName = path150.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -119935,7 +120585,7 @@ init_utils();
 init_bun_compat();
 init_create_tool();
 import * as fs111 from "node:fs";
-import * as path150 from "node:path";
+import * as path151 from "node:path";
 var MAX_OUTPUT_BYTES6 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -119963,16 +120613,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs111.existsSync(path150.join(cwd, "package.json"))) {
+  if (fs111.existsSync(path151.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs111.existsSync(path150.join(cwd, "pyproject.toml")) || fs111.existsSync(path150.join(cwd, "requirements.txt"))) {
+  if (fs111.existsSync(path151.join(cwd, "pyproject.toml")) || fs111.existsSync(path151.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs111.existsSync(path150.join(cwd, "Cargo.toml"))) {
+  if (fs111.existsSync(path151.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs111.existsSync(path150.join(cwd, "go.mod"))) {
+  if (fs111.existsSync(path151.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -119981,13 +120631,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs111.existsSync(path150.join(cwd, "Gemfile")) || fs111.existsSync(path150.join(cwd, "Gemfile.lock"))) {
+  if (fs111.existsSync(path151.join(cwd, "Gemfile")) || fs111.existsSync(path151.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs111.existsSync(path150.join(cwd, "pubspec.yaml"))) {
+  if (fs111.existsSync(path151.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs111.existsSync(path150.join(cwd, "composer.lock"))) {
+  if (fs111.existsSync(path151.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -120000,7 +120650,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve51) => setTimeout(() => resolve51("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve52) => setTimeout(() => resolve52("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr2]) => ({ stdout: stdout2, stderr: stderr2 })),
       timeoutPromise
@@ -120120,7 +120770,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve51) => setTimeout(() => resolve51("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve52) => setTimeout(() => resolve52("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr2]) => ({ stdout: stdout2, stderr: stderr2 })),
       timeoutPromise
@@ -120248,7 +120898,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve51) => setTimeout(() => resolve51("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve52) => setTimeout(() => resolve52("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -120372,7 +121022,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve51) => setTimeout(() => resolve51("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve52) => setTimeout(() => resolve52("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -120505,7 +121155,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve51) => setTimeout(() => resolve51("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve52) => setTimeout(() => resolve52("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -120621,7 +121271,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve51) => setTimeout(() => resolve51("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve52) => setTimeout(() => resolve52("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -120766,7 +121416,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve51) => setTimeout(() => resolve51("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve52) => setTimeout(() => resolve52("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -120881,7 +121531,7 @@ async function runComposerAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve51) => setTimeout(() => resolve51("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve52) => setTimeout(() => resolve52("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -121124,7 +121774,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs112 from "node:fs";
-import * as path151 from "node:path";
+import * as path152 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -121247,7 +121897,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path151.basename(filePath);
+  const filename = path152.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -121264,7 +121914,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path151.basename(filePath);
+    const filename = path152.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -121273,7 +121923,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path151.extname(filePath).toLowerCase();
+  const ext = path152.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -121520,9 +122170,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path151.isAbsolute(filePath) ? filePath : path151.resolve(directory, filePath);
-    const resolvedDirectory = path151.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path151.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path152.isAbsolute(filePath) ? filePath : path152.resolve(directory, filePath);
+    const resolvedDirectory = path152.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path152.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs112.existsSync(fullPath)) {
@@ -121531,7 +122181,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path151.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path152.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -121604,7 +122254,7 @@ var placeholder_scan = createSwarmTool({
 
 // src/tools/pre-check-batch.ts
 import * as fs116 from "node:fs";
-import * as path155 from "node:path";
+import * as path156 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -121732,11 +122382,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args2, directory) {
-    const result = await _internals68.qualityBudget(args2, directory);
+    const result = await _internals70.qualityBudget(args2, directory);
     return JSON.stringify(result);
   }
 });
-var _internals68 = {
+var _internals70 = {
   qualityBudget
 };
 
@@ -121745,7 +122395,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs115 from "node:fs";
-import * as path154 from "node:path";
+import * as path155 from "node:path";
 import { extname as extname22 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -122455,13 +123105,13 @@ function executeRulesSync(filePath, content, language) {
 // src/sast/semgrep.ts
 import * as child_process10 from "node:child_process";
 import * as fs113 from "node:fs";
-import * as path152 from "node:path";
+import * as path153 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
 var MAX_OUTPUT_BYTES7 = 10 * 1024 * 1024;
 var KILL_GRACE_MS = 2000;
-var _internals69 = {
+var _internals71 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -122487,7 +123137,7 @@ function isSemgrepAvailable() {
   }
 }
 async function checkSemgrepAvailable() {
-  return _internals69.isSemgrepAvailable();
+  return _internals71.isSemgrepAvailable();
 }
 function resetSemgrepCache() {
   semgrepAvailableCache = null;
@@ -122540,7 +123190,7 @@ function mapSemgrepSeverity(severity) {
 }
 async function executeWithTimeout(command, args2, options) {
   const maxOutputBytes = options.maxOutputBytes ?? MAX_OUTPUT_BYTES7;
-  return new Promise((resolve53) => {
+  return new Promise((resolve54) => {
     const child = child_process10.spawn(command, args2, {
       shell: false,
       cwd: options.cwd,
@@ -122572,7 +123222,7 @@ async function executeWithTimeout(command, args2, options) {
           escalation.unref();
         }
       }
-      resolve53({ ...result, truncated });
+      resolve54({ ...result, truncated });
     };
     timeout = setTimeout(() => {
       settle({
@@ -122631,12 +123281,12 @@ async function runSemgrep(options) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS3;
   if (files.length === 0) {
     return {
-      available: _internals69.isSemgrepAvailable(),
+      available: _internals71.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!_internals69.isSemgrepAvailable()) {
+  if (!_internals71.isSemgrepAvailable()) {
     return {
       available: false,
       findings: [],
@@ -122700,7 +123350,7 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path152.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path153.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
@@ -122721,24 +123371,24 @@ init_create_tool();
 init_utils2();
 import * as crypto12 from "node:crypto";
 import * as fs114 from "node:fs";
-import * as path153 from "node:path";
+import * as path154 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
 var MAX_BASELINE_BYTES = 2 * 1048576;
 var LOCK_RETRY_DELAYS_MS = [50, 100, 200, 400, 800];
 function normalizeFindingPath(directory, file3) {
-  const resolved = path153.isAbsolute(file3) ? file3 : path153.resolve(directory, file3);
-  const rel = path153.relative(path153.resolve(directory), resolved);
+  const resolved = path154.isAbsolute(file3) ? file3 : path154.resolve(directory, file3);
+  const rel = path154.relative(path154.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path153.join("evidence", String(phase), "sast-baseline.json");
+  return path154.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path153.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path154.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path153.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path154.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -122803,7 +123453,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals70.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals72.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -122824,7 +123474,7 @@ async function acquireLock2(lockPath) {
       };
     } catch {
       if (attempt < LOCK_RETRY_DELAYS_MS.length) {
-        await new Promise((resolve54) => setTimeout(resolve54, LOCK_RETRY_DELAYS_MS[attempt]));
+        await new Promise((resolve55) => setTimeout(resolve55, LOCK_RETRY_DELAYS_MS[attempt]));
       }
     }
   }
@@ -122859,8 +123509,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs114.mkdirSync(path153.dirname(baselinePath), { recursive: true });
-  fs114.mkdirSync(path153.dirname(tempPath), { recursive: true });
+  fs114.mkdirSync(path154.dirname(baselinePath), { recursive: true });
+  fs114.mkdirSync(path154.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
@@ -122872,7 +123522,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals70.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals72.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -123012,7 +123662,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals70 = {
+var _internals72 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -123133,9 +123783,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path154.isAbsolute(filePath) ? filePath : path154.resolve(directory, filePath);
-    const resolvedDirectory = path154.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path154.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path155.isAbsolute(filePath) ? filePath : path155.resolve(directory, filePath);
+    const resolvedDirectory = path155.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path155.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -123422,11 +124072,11 @@ var sast_scan = createSwarmTool({
       capture_baseline: safeArgs.capture_baseline,
       phase: safeArgs.phase
     };
-    const result = await _internals71.sastScan(input, directory);
+    const result = await _internals73.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals71 = {
+var _internals73 = {
   sastScan,
   sast_scan
 };
@@ -123450,18 +124100,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path155.win32.resolve(inputPath);
-  } else if (path155.isAbsolute(inputPath)) {
-    resolved = path155.resolve(inputPath);
+    resolved = path156.win32.resolve(inputPath);
+  } else if (path156.isAbsolute(inputPath)) {
+    resolved = path156.resolve(inputPath);
   } else {
-    resolved = path155.resolve(baseDir, inputPath);
+    resolved = path156.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path155.resolve(workspaceDir);
+  const workspaceResolved = path156.resolve(workspaceDir);
   let relative31;
   if (isWinAbs) {
-    relative31 = path155.win32.relative(workspaceResolved, resolved);
+    relative31 = path156.win32.relative(workspaceResolved, resolved);
   } else {
-    relative31 = path155.relative(workspaceResolved, resolved);
+    relative31 = path156.relative(workspaceResolved, resolved);
   }
   if (relative31.startsWith("..")) {
     return "path traversal detected";
@@ -123526,7 +124176,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path155.resolve(file3);
+    const resolvedPath = path156.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -123683,7 +124333,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path155.resolve(file3);
+      const resolvedPath = path156.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -123701,7 +124351,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path155.extname(file3).toLowerCase();
+      const ext = path156.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -123920,7 +124570,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path155.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path156.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -123971,7 +124621,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path155.resolve(directory, file3));
+    changedFiles.push(path156.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -124172,9 +124822,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path155.resolve(typedArgs.directory);
-    const workspaceAnchor = path155.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path155.sep)) {
+    const resolvedDirectory = path156.resolve(typedArgs.directory);
+    const workspaceAnchor = path156.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path156.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -124226,7 +124876,7 @@ var pre_check_batch = createSwarmTool({
 
 // src/tools/repo-map.ts
 init_zod();
-import * as path156 from "node:path";
+import * as path157 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -124251,7 +124901,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path156.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path157.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -124274,8 +124924,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path156.isAbsolute(normalized)) {
-    const rel = path156.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path157.isAbsolute(normalized)) {
+    const rel = path157.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -124421,7 +125071,7 @@ var repo_map = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs117 from "node:fs";
-import * as path157 from "node:path";
+import * as path158 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHOULD", "SHALL"];
@@ -124490,7 +125140,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path157.join(evidenceDir, entry);
+    const entryPath = path158.join(evidenceDir, entry);
     try {
       const stat9 = fs117.statSync(entryPath);
       if (!stat9.isDirectory()) {
@@ -124506,11 +125156,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path157.join(entryPath, "evidence.json");
+    const evidenceFilePath = path158.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path157.resolve(evidenceFilePath);
-      const evidenceDirResolved = path157.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path157.sep)) {
+      const resolvedPath = path158.resolve(evidenceFilePath);
+      const evidenceDirResolved = path158.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path158.sep)) {
         continue;
       }
       const stat9 = fs117.lstatSync(evidenceFilePath);
@@ -124544,7 +125194,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
             if (Array.isArray(diffEntry.files_changed)) {
               for (const file3 of diffEntry.files_changed) {
                 if (typeof file3 === "string") {
-                  touchedFiles.add(path157.resolve(cwd, file3));
+                  touchedFiles.add(path158.resolve(cwd, file3));
                 }
               }
             }
@@ -124557,8 +125207,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path157.resolve(filePath);
-    const cwdResolved = path157.resolve(cwd);
+    const resolvedPath = path158.resolve(filePath);
+    const cwdResolved = path158.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -124692,7 +125342,7 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path157.join(cwd, SPEC_FILE);
+    const specPath = path158.join(cwd, SPEC_FILE);
     let specContent;
     try {
       specContent = fs117.readFileSync(specPath, "utf-8");
@@ -124719,7 +125369,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path157.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path158.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -124745,7 +125395,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path157.join(evidenceDir, reportFilename);
+    const reportPath = path158.join(evidenceDir, reportFilename);
     try {
       if (!fs117.existsSync(evidenceDir)) {
         fs117.mkdirSync(evidenceDir, { recursive: true });
@@ -124835,7 +125485,7 @@ init_qa_gate_profile();
 init_file_locks();
 import * as crypto13 from "node:crypto";
 import * as fs118 from "node:fs";
-import * as path158 from "node:path";
+import * as path159 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -124916,8 +125566,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path158.resolve(args2.working_directory);
-    const resolvedRoot = path158.resolve(fallbackDir);
+    const resolvedTarget = path159.resolve(args2.working_directory);
+    const resolvedRoot = path159.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs118.accessSync(resolvedRoot, fs118.constants.F_OK);
@@ -124926,7 +125576,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path158.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path159.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -124942,7 +125592,7 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path158.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path159.join(targetWorkspace, ".swarm", "spec.md");
     try {
       const stat9 = await fs118.promises.stat(specPath);
       specMtime = stat9.mtime.toISOString();
@@ -124958,7 +125608,7 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path158.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path159.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs118.promises.readFile(contextPath, "utf8");
@@ -125248,7 +125898,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path158.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path159.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -125271,7 +125921,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path158.join(dir, ".swarm", "plan.json"),
+        plan_path: path159.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -125338,7 +125988,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs119 from "node:fs";
-import * as path159 from "node:path";
+import * as path160 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -126188,7 +126838,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs119.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path159.join(dir, entry.name);
+        const fullPath = path160.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -126197,7 +126847,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path159.relative(rootDir, fullPath));
+              manifestFiles.push(path160.relative(rootDir, fullPath));
               break;
             }
           }
@@ -126215,11 +126865,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs119.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path159.join(dir, entry.name);
+        const fullPath = path160.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path159.relative(workingDir, fullPath));
+              found.push(path160.relative(workingDir, fullPath));
               break;
             }
           }
@@ -126232,11 +126882,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path159.dirname(file3);
+    let currentDir = path160.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path159.sep) {
-        dirs.add(path159.join(workingDir, currentDir));
-        const parent = path159.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path160.sep) {
+        dirs.add(path160.join(workingDir, currentDir));
+        const parent = path160.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -126320,7 +126970,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path159.isAbsolute(relativeOutputDir) ? relativeOutputDir : path159.join(workingDir, relativeOutputDir);
+    const outputDir = path160.isAbsolute(relativeOutputDir) ? relativeOutputDir : path160.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -126343,7 +126993,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path159.isAbsolute(manifestFile) ? manifestFile : path159.join(workingDir, manifestFile);
+        const fullPath = path160.isAbsolute(manifestFile) ? manifestFile : path160.join(workingDir, manifestFile);
         if (!fs119.existsSync(fullPath)) {
           continue;
         }
@@ -126360,7 +127010,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path159.join(outputDir, filename);
+    const outputPath = path160.join(outputDir, filename);
     fs119.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -126405,7 +127055,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs120 from "node:fs";
-import * as path160 from "node:path";
+import * as path161 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -126437,12 +127087,12 @@ function normalizePath5(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path160.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path160.sep) ? cwd : cwd + path160.sep;
+    const resolvedPath = path161.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path161.sep) ? cwd : cwd + path161.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path160.extname(resolvedPath).toLowerCase();
+    const ext = path161.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -126456,7 +127106,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path160.resolve(cwd, candidate);
+    const candidatePath = path161.resolve(cwd, candidate);
     if (fs120.existsSync(candidatePath)) {
       const stats = fs120.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -126468,7 +127118,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs120.readFileSync(specFile, "utf-8");
-  const ext = path160.extname(specFile).toLowerCase();
+  const ext = path161.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -126544,7 +127194,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path160.join(dir, entry.name);
+      const fullPath = path161.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -126554,7 +127204,7 @@ function extractRoutes(cwd) {
         }
         walkDir2(fullPath);
       } else if (entry.isFile()) {
-        const ext = path160.extname(entry.name).toLowerCase();
+        const ext = path161.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -126723,7 +127373,7 @@ init_bun_compat();
 init_path_security();
 init_create_tool();
 import * as fs121 from "node:fs";
-import * as path161 from "node:path";
+import * as path162 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -126759,11 +127409,11 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path161.resolve(workspace, filePath);
+    const resolvedPath = path162.resolve(workspace, filePath);
     const realWorkspace = fs121.realpathSync(workspace);
     const realResolvedPath = fs121.realpathSync(resolvedPath);
-    const relativePath = path161.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path161.isAbsolute(relativePath)) {
+    const relativePath = path162.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path162.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -126776,11 +127426,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path161.delimiter)) {
+  for (const dir of searchPath.split(path162.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path161.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path162.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs121.existsSync(candidate))
       return candidate;
   }
@@ -126835,7 +127485,7 @@ async function ripgrepSearch(opts) {
       stderr: "pipe",
       cwd: opts.workspace
     });
-    const timeout = new Promise((resolve60) => setTimeout(() => resolve60("timeout"), REGEX_TIMEOUT_MS));
+    const timeout = new Promise((resolve61) => setTimeout(() => resolve61("timeout"), REGEX_TIMEOUT_MS));
     const exitPromise = proc.exited;
     const result = await Promise.race([exitPromise, timeout]);
     if (result === "timeout") {
@@ -126910,8 +127560,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs121.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path161.join(dir, entry.name);
-      const relativePath = path161.relative(workspace, fullPath);
+      const fullPath = path162.join(dir, entry.name);
+      const relativePath = path162.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -126952,7 +127602,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path161.join(opts.workspace, file3);
+    const fullPath = path162.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -127365,7 +128015,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir23, rename as rename10, writeFile as writeFile16 } from "node:fs/promises";
-import * as path162 from "node:path";
+import * as path163 from "node:path";
 var MAX_SPEC_BYTES = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -127406,8 +128056,8 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path162.join(directory, ".swarm", "spec.md");
-    await mkdir23(path162.dirname(target), { recursive: true });
+    const target = path163.join(directory, ".swarm", "spec.md");
+    await mkdir23(path163.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -127443,7 +128093,7 @@ import {
   unlinkSync as unlinkSync21,
   writeFileSync as writeFileSync32
 } from "node:fs";
-import path163 from "node:path";
+import path164 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -127587,7 +128237,7 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path163.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path164.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
     const raw = readFileSync81(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -127649,9 +128299,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis) {
-  const evidenceDir = path163.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  const evidenceDir = path164.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
   mkdirSync41(evidenceDir, { recursive: true });
-  const evidenceFile = path163.join(evidenceDir, "phase-council.json");
+  const evidenceFile = path164.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -127713,7 +128363,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs122 from "node:fs";
-import * as path164 from "node:path";
+import * as path165 from "node:path";
 var BINARY_EXTENSIONS2 = new Set([
   ".png",
   ".jpg",
@@ -127749,14 +128399,14 @@ function containsWindowsAttacks5(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path164.resolve(workspace, filePath);
+    const resolvedPath = path165.resolve(workspace, filePath);
     if (!fs122.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs122.realpathSync(workspace);
     const realResolvedPath = fs122.realpathSync(resolvedPath);
-    const relativePath = path164.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path164.isAbsolute(relativePath)) {
+    const relativePath = path165.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path165.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -127871,7 +128521,7 @@ function arraysEqual2(a, b) {
   return true;
 }
 function isBinaryFile4(filePath) {
-  const ext = path164.extname(filePath).toLowerCase();
+  const ext = path165.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS2.has(ext);
 }
 function splitDiffLines(content) {
@@ -128076,7 +128726,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path164.resolve(directory, change.file);
+      const fullPath = path165.resolve(directory, change.file);
       if (!fs122.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -128171,7 +128821,7 @@ var suggestPatch = createSwarmTool({
         const unifiedParts = [];
         for (const [file3, entries] of fileGroups) {
           entries.sort((a, b) => a.contextMatch.startLineIndex - b.contextMatch.startLineIndex);
-          const entryFullPath = path164.resolve(directory, file3);
+          const entryFullPath = path165.resolve(directory, file3);
           let entryContent;
           try {
             entryContent = fs122.readFileSync(entryFullPath, "utf-8");
@@ -128372,7 +129022,7 @@ var swarm_memory_propose = createSwarmTool({
     evidenceRefs: exports_external.array(exports_external.string().min(1).max(500)).max(20).optional().describe("Evidence refs such as files, commits, test outputs, or URLs")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals72.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals74.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -128388,7 +129038,7 @@ var swarm_memory_propose = createSwarmTool({
       });
     }
     const agent = getContextAgent2(ctx);
-    const gateway = _internals72.createMemoryGateway({
+    const gateway = _internals74.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -128413,7 +129063,7 @@ var swarm_memory_propose = createSwarmTool({
     }
   }
 });
-var _internals72 = {
+var _internals74 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -128451,7 +129101,7 @@ var swarm_memory_recall = createSwarmTool({
     maxItems: exports_external.number().int().min(1).max(20).optional().describe("Maximum memories to return")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals73.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals75.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -128467,7 +129117,7 @@ var swarm_memory_recall = createSwarmTool({
       });
     }
     const agent = getContextAgent3(ctx);
-    const gateway = _internals73.createMemoryGateway({
+    const gateway = _internals75.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -128500,7 +129150,7 @@ var RecallArgsSchema = exports_external.object({
   kinds: exports_external.array(exports_external.enum(MEMORY_KINDS2)).optional(),
   maxItems: exports_external.number().int().min(1).max(20).optional()
 });
-var _internals73 = {
+var _internals75 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -128513,7 +129163,7 @@ function getContextAgent3(ctx) {
 
 // src/tools/syntax-check.ts
 import * as fs123 from "node:fs";
-import * as path165 from "node:path";
+import * as path166 from "node:path";
 init_zod();
 init_manager2();
 init_detector();
@@ -128585,7 +129235,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path165.extname(file3.path).toLowerCase();
+      const ext = path166.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -128595,7 +129245,7 @@ async function syntaxCheck(input, directory, config3) {
   const { loadGrammar: loadGrammar2 } = await Promise.resolve().then(() => (init_runtime(), exports_runtime));
   async function checkOneFile(fileInfo) {
     const { path: filePath } = fileInfo;
-    const fullPath = path165.isAbsolute(filePath) ? filePath : path165.join(directory, filePath);
+    const fullPath = path166.isAbsolute(filePath) ? filePath : path166.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -128642,7 +129292,7 @@ async function syntaxCheck(input, directory, config3) {
         result.skipped_reason = "binary_file";
         return { result, counted: false, failed: false, skipped: true };
       }
-      const ext = path165.extname(filePath).toLowerCase();
+      const ext = path166.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -128754,7 +129404,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs124 from "node:fs";
-import * as path166 from "node:path";
+import * as path167 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -128820,9 +129470,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path166.resolve(paths);
-    const normalizedCwd = path166.resolve(cwd);
-    const normalizedResolved = path166.resolve(resolvedPath);
+    const resolvedPath = path167.resolve(paths);
+    const normalizedCwd = path167.resolve(cwd);
+    const normalizedResolved = path167.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -128838,7 +129488,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path166.extname(filePath).toLowerCase();
+  const ext = path167.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles4(dir, files = []) {
@@ -128853,7 +129503,7 @@ function findSourceFiles4(dir, files = []) {
     if (SKIP_DIRECTORIES6.has(entry)) {
       continue;
     }
-    const fullPath = path166.join(dir, entry);
+    const fullPath = path167.join(dir, entry);
     let stat9;
     try {
       stat9 = fs124.statSync(fullPath);
@@ -128965,7 +129615,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path166.extname(scanPath)}`,
+          error: `unsupported file extension: ${path167.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -129015,18 +129665,18 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs128 from "node:fs";
-import * as path170 from "node:path";
+import * as path171 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
 import * as fs126 from "node:fs";
-import * as path168 from "node:path";
+import * as path169 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs125 from "node:fs";
-import * as path167 from "node:path";
-var _internals74 = { bunSpawn };
+import * as path168 from "node:path";
+var _internals76 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
   for (const rawLine of content.split(`
@@ -129059,7 +129709,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
       checkIgnoreExitCode
     ] = await Promise.all([
       (async () => {
-        const proc = _internals74.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+        const proc = _internals76.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -129069,7 +129719,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals74.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+        const proc = _internals76.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -129079,7 +129729,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals74.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+        const proc = _internals76.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
         try {
           return await proc.exited;
         } finally {
@@ -129099,10 +129749,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path167.isAbsolute(excludeRelPath) ? excludeRelPath : path167.join(directory, excludeRelPath);
+    const excludePath = path168.isAbsolute(excludeRelPath) ? excludeRelPath : path168.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs125.mkdirSync(path167.dirname(excludePath), { recursive: true });
+        fs125.mkdirSync(path168.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
           existing = fs125.readFileSync(excludePath, "utf8");
@@ -129118,7 +129768,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       } catch {}
     }
-    const trackedProc = _internals74.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    const trackedProc = _internals76.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
     let trackedExitCode;
     let trackedOutput;
     try {
@@ -129143,10 +129793,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 }
 
 // src/hooks/diff-scope.ts
-var _internals75 = { bunSpawn };
+var _internals77 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path168.join(directory, ".swarm", "plan.json");
+    const planPath = path169.join(directory, ".swarm", "plan.json");
     if (!fs126.existsSync(planPath))
       return null;
     const raw = fs126.readFileSync(planPath, "utf-8");
@@ -129178,7 +129828,7 @@ var GIT_DIFF_SPAWN_OPTIONS = {
 };
 async function getChangedFiles(directory) {
   try {
-    const proc = _internals75.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals77.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -129195,7 +129845,7 @@ async function getChangedFiles(directory) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = _internals75.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals77.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -129252,8 +129902,8 @@ init_telemetry();
 // src/turbo/lean/task-completion.ts
 init_file_locks();
 import * as fs127 from "node:fs";
-import * as path169 from "node:path";
-var _internals76 = {
+import * as path170 from "node:path";
+var _internals78 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
 };
@@ -129271,7 +129921,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path169.basename(file3);
+    const fileName = path170.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -129283,7 +129933,7 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path169.join(directory, ".swarm", "turbo-state.json");
+    const statePath = path170.join(directory, ".swarm", "turbo-state.json");
     if (!fs127.existsSync(statePath)) {
       return {
         ok: false,
@@ -129367,11 +130017,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path169.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path169.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path169.resolve(evidencePath);
-  const resolvedDir = path169.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path169.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path170.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path170.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path170.resolve(evidencePath);
+  const resolvedDir = path170.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path170.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -129395,7 +130045,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  const activeLocks = _internals76.listActiveLocks(directory);
+  const activeLocks = _internals78.listActiveLocks(directory);
   const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
   if (laneLocks.length > 0) {
     return {
@@ -129411,7 +130061,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path169.join(directory, ".swarm", "plan.json");
+    const planPath = path170.join(directory, ".swarm", "plan.json");
     const planRaw = fs127.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
@@ -129495,7 +130145,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path170.basename(file3);
+    const fileName = path171.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -129534,7 +130184,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path170.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path171.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs128.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -129612,7 +130262,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path170.join(resolvedDir, ".swarm", "plan.json");
+        const planPath = path171.join(resolvedDir, ".swarm", "plan.json");
         const planRaw = fs128.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -129854,7 +130504,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   directory = resolveResult.directory;
-  const planPath = path170.join(directory, ".swarm", "plan.json");
+  const planPath = path171.join(directory, ".swarm", "plan.json");
   if (!fs128.existsSync(planPath)) {
     return {
       success: false,
@@ -129863,9 +130513,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs128.realpathSync(path170.resolve(directory));
-    const canonicalRoot = fs128.realpathSync(path170.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path170.sep)) {
+    const canonicalDir = fs128.realpathSync(path171.resolve(directory));
+    const canonicalRoot = fs128.realpathSync(path171.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path171.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -129877,8 +130527,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path170.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs128.mkdirSync(path170.dirname(evidencePath), { recursive: true });
+      const evidencePath = path171.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs128.mkdirSync(path171.dirname(evidencePath), { recursive: true });
       const fd = fs128.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -129902,7 +130552,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath2 = path170.join(directory, ".swarm", "plan.json");
+      const planPath2 = path171.join(directory, ".swarm", "plan.json");
       const planRaw = fs128.readFileSync(planPath2, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -130199,7 +130849,7 @@ init_utils2();
 init_redaction();
 import { createHash as createHash13 } from "node:crypto";
 import { appendFile as appendFile14, mkdir as mkdir24 } from "node:fs/promises";
-import * as path171 from "node:path";
+import * as path172 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
 async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
@@ -130207,7 +130857,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir24(path171.dirname(filePath), { recursive: true });
+    await mkdir24(path172.dirname(filePath), { recursive: true });
     await appendFile14(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -130373,7 +131023,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals77.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals79.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -130401,7 +131051,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals77 = {
+var _internals79 = {
   writeEvidenceDocuments
 };
 
@@ -130415,7 +131065,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path172 from "node:path";
+import * as path173 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -130479,7 +131129,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
       if (config3.architectural_supervision?.persist_knowledge_recommendations && args2.knowledge_recommendations.length > 0) {
         const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
         const lessons = args2.knowledge_recommendations.map((r) => r.lesson);
-        const result = await curateAndStoreSwarm(lessons, path172.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
+        const result = await curateAndStoreSwarm(lessons, path173.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
         knowledgeProposed = result.stored;
       }
     } catch {}
@@ -130515,7 +131165,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs129 from "node:fs";
-import path173 from "node:path";
+import path174 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -130563,7 +131213,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path173.join("evidence", String(phase), filename);
+  const relativePath = path174.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -130574,10 +131224,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path173.dirname(validatedPath);
+  const evidenceDir = path174.dirname(validatedPath);
   try {
     await fs129.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path173.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path174.join(evidenceDir, `.${filename}.tmp`);
     await fs129.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs129.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -130674,7 +131324,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs130 from "node:fs";
-import path174 from "node:path";
+import path175 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -130768,7 +131418,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path174.join("evidence", filename);
+  const relativePath = path175.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -130782,10 +131432,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path174.dirname(validatedPath);
+  const evidenceDir = path175.dirname(validatedPath);
   try {
     await fs130.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path174.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path175.join(evidenceDir, `.${filename}.tmp`);
     await fs130.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs130.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -130845,7 +131495,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs131 from "node:fs";
-import path175 from "node:path";
+import path176 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -130893,7 +131543,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path175.join("evidence", String(phase), filename);
+  const relativePath = path176.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -130904,10 +131554,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path175.dirname(validatedPath);
+  const evidenceDir = path176.dirname(validatedPath);
   try {
     await fs131.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path175.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path176.join(evidenceDir, `.${filename}.tmp`);
     await fs131.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs131.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -130957,7 +131607,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs132 from "node:fs";
-import path176 from "node:path";
+import path177 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -131031,7 +131681,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path176.join("evidence", String(phase), filename);
+  const relativePath = path177.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -131042,10 +131692,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path176.dirname(validatedPath);
+  const evidenceDir = path177.dirname(validatedPath);
   try {
     await fs132.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path176.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path177.join(evidenceDir, `.${filename}.tmp`);
     await fs132.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs132.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -131233,7 +131883,7 @@ ${footerLines.join(`
 init_warning_buffer();
 var _heartbeatTimers = new Map;
 var SWARM_COMMAND_SYSTEM_RULE_TAG = "[opencode-swarm:swarm-command-rule]";
-var PACKAGE_ROOT2 = path178.resolve(path178.dirname(fileURLToPath5(import.meta.url)), "..");
+var PACKAGE_ROOT2 = path179.resolve(path179.dirname(fileURLToPath5(import.meta.url)), "..");
 function createSwarmCommandSystemRuleHook(agentDefinitions, registeredAgents) {
   return async (input, output) => {
     const { sessionID } = input;
@@ -131503,7 +132153,7 @@ async function initializeOpenCodeSwarm(ctx) {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path178.resolve(ctx.directory, ".swarm");
+    const swarmDir = path179.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -132034,7 +132684,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path178.basename(path178.dirname(s.skillPath));
+                    desc = path179.basename(path179.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -132044,7 +132694,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path178.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path179.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {