opencode-swarm 7.49.1 → 7.50.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.49.1",
+    version: "7.50.0",
     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",
@@ -679,6 +679,10 @@ var init_tool_metadata = __esm(() => {
     lean_turbo_status: {
       description: "returns Lean Turbo configuration and active status for the current session",
       agents: ["architect"]
+    },
+    apply_patch: {
+      description: "Apply a unified diff patch to workspace files with exact context matching, atomic writes, and path validation",
+      agents: ["coder"]
     }
   };
   TOOL_NAMES = Object.keys(TOOL_METADATA);
@@ -92314,7 +92318,7 @@ __export(exports_design_doc_drift, {
   _internals: () => _internals60
 });
 import * as fs98 from "node:fs";
-import * as path136 from "node:path";
+import * as path137 from "node:path";
 function mtimeMsOrNull(absPath) {
   try {
     return fs98.statSync(absPath).mtimeMs;
@@ -92325,35 +92329,35 @@ function mtimeMsOrNull(absPath) {
 function resolveAnchorWithin(directory, anchor) {
   if (!anchor || typeof anchor !== "string")
     return null;
-  const root = path136.resolve(directory);
-  const resolved = path136.resolve(root, anchor);
-  const rel = path136.relative(root, resolved);
-  if (rel.startsWith("..") || path136.isAbsolute(rel))
+  const root = path137.resolve(directory);
+  const resolved = path137.resolve(root, anchor);
+  const rel = path137.relative(root, resolved);
+  if (rel.startsWith("..") || path137.isAbsolute(rel))
     return null;
   return resolved;
 }
 async function runDesignDocDriftCheck(directory, phase, outDir) {
   try {
-    const root = path136.resolve(directory);
-    const outAbs = path136.resolve(root, outDir);
-    const outRel = path136.relative(root, outAbs);
-    if (outRel.startsWith("..") || path136.isAbsolute(outRel)) {
+    const root = path137.resolve(directory);
+    const outAbs = path137.resolve(root, outDir);
+    const outRel = path137.relative(root, outAbs);
+    if (outRel.startsWith("..") || path137.isAbsolute(outRel)) {
       return null;
     }
     const docMtimes = new Map;
     const checkedDocs = [];
     const missingDocs = [];
     for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
-      const abs = path136.join(outAbs, relFile);
+      const abs = path137.join(outAbs, relFile);
       const mtime = mtimeMsOrNull(abs);
       docMtimes.set(docName, mtime);
       if (mtime === null) {
-        missingDocs.push(path136.join(outDir, relFile));
+        missingDocs.push(path137.join(outDir, relFile));
       } else {
-        checkedDocs.push(path136.join(outDir, relFile));
+        checkedDocs.push(path137.join(outDir, relFile));
       }
     }
-    const traceabilityAbs = path136.join(outAbs, TRACEABILITY_REL);
+    const traceabilityAbs = path137.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
       const stat9 = await fs98.promises.stat(traceabilityAbs);
@@ -92366,7 +92370,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
       registry3 = null;
     }
     const noDocs = checkedDocs.length === 0 || registry3 === null;
-    const specMtime = mtimeMsOrNull(path136.join(root, ".swarm", "spec.md"));
+    const specMtime = mtimeMsOrNull(path137.join(root, ".swarm", "spec.md"));
     const staleSections = [];
     if (!noDocs && Array.isArray(registry3?.sections)) {
       for (const section of registry3.sections) {
@@ -92422,7 +92426,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     };
     const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
     const filePath = validateSwarmPath(directory, filename);
-    await fs98.promises.mkdir(path136.dirname(filePath), { recursive: true });
+    await fs98.promises.mkdir(path137.dirname(filePath), { recursive: true });
     await fs98.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
     getGlobalEventBus().publish("curator.docdrift.completed", {
       phase,
@@ -92453,10 +92457,10 @@ var init_design_doc_drift = __esm(() => {
     domain: "domain.md",
     "technical-spec": "technical-spec.md",
     "behavior-spec": "behavior-spec.md",
-    "reference-impl": path136.join("reference", "reference-impl.md"),
-    "idiom-notes": path136.join("reference", "idiom-notes.md")
+    "reference-impl": path137.join("reference", "reference-impl.md"),
+    "idiom-notes": path137.join("reference", "idiom-notes.md")
   };
-  TRACEABILITY_REL = path136.join("reference", "traceability.json");
+  TRACEABILITY_REL = path137.join("reference", "traceability.json");
   _internals60 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
@@ -92472,7 +92476,7 @@ __export(exports_project_context, {
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs122 from "node:fs";
-import * as path165 from "node:path";
+import * as path166 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -92484,7 +92488,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs122.accessSync(path165.join(directory, pattern));
+    fs122.accessSync(path166.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -92493,7 +92497,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs122.readFileSync(path165.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs122.readFileSync(path166.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -92602,7 +92606,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path166 from "node:path";
+import * as path167 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -103467,29 +103471,34 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
       if (!declaredScope || declaredScope.length === 0)
         return;
       const argsObj = output.args;
-      const rawFilePath = argsObj?.path ?? argsObj?.filePath ?? argsObj?.file;
-      if (typeof rawFilePath !== "string" || !rawFilePath)
-        return;
-      const filePath = rawFilePath.replace(/[\r\n\t]/g, "_").split(String.fromCharCode(27)).join("_").replace(/\[[\d;]*m/g, "");
-      if (!isFileInScope(filePath, declaredScope, directory)) {
-        const taskId2 = session?.currentTaskId ?? "unknown";
-        const violationMessage = `SCOPE VIOLATION: ${agentName} attempted to modify '${filePath}' which is not in declared scope for task ${taskId2}. Declared scope: [${declaredScope.slice(0, 3).join(", ")}${declaredScope.length > 3 ? "..." : ""}]`;
-        if (session) {
-          session.lastScopeViolation = violationMessage;
-          session.scopeViolationDetected = true;
-        }
-        if (injectAdvisory) {
-          for (const [archSessionId, archSession] of swarmState.agentSessions) {
-            const archAgent = swarmState.activeAgent.get(archSessionId) ?? archSession.agentName;
-            if (stripKnownSwarmPrefix(archAgent) === ORCHESTRATOR_NAME) {
-              try {
-                injectAdvisory(archSessionId, `[SCOPE GUARD] ${violationMessage}`);
-              } catch {}
-              break;
+      const candidatePaths = [];
+      const singlePathKeys = ["path", "filePath", "file"];
+      for (const key of singlePathKeys) {
+        const val = argsObj?.[key];
+        if (typeof val === "string" && val) {
+          candidatePaths.push(val);
+        }
+      }
+      let hasArrayKeys = false;
+      const arrayPathKeys = ["files", "paths", "targetFiles"];
+      for (const key of arrayPathKeys) {
+        const val = argsObj?.[key];
+        if (Array.isArray(val)) {
+          hasArrayKeys = true;
+          for (const item of val) {
+            if (typeof item === "string" && item) {
+              candidatePaths.push(item);
             }
           }
         }
-        throw new Error(violationMessage);
+      }
+      if (candidatePaths.length === 0 && !hasArrayKeys)
+        return;
+      for (const rawPath of candidatePaths) {
+        const filePath = sanitizePath(rawPath);
+        if (!isFileInScope(filePath, declaredScope, directory)) {
+          reportScopeViolation(agentName, filePath, taskId, session, injectAdvisory, swarmState, declaredScope);
+        }
       }
     }
   };
@@ -103497,7 +103506,7 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
 function isFileInScope(filePath, scopeEntries, directory) {
   const dir = directory ?? process.cwd();
   const resolvedFile = path102.resolve(dir, filePath);
-  return scopeEntries.some((scope) => {
+  return scopeEntries.filter((scope) => scope.length > 0).some((scope) => {
     const resolvedScope = path102.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
@@ -103505,6 +103514,38 @@ function isFileInScope(filePath, scopeEntries, directory) {
     return rel.length > 0 && !rel.startsWith("..") && !path102.isAbsolute(rel);
   });
 }
+function sanitizePath(raw) {
+  let result = "";
+  for (let i2 = 0;i2 < raw.length; i2++) {
+    const c = raw.charCodeAt(i2);
+    if (c <= 31 || c === 127 || c >= 128 && c <= 159) {
+      result += "_";
+      continue;
+    }
+    result += raw[i2];
+  }
+  return result.replace(/\[[\d;]*m/g, "");
+}
+function reportScopeViolation(agentName, filePath, taskId, session, injectAdvisory, state, scopeEntries) {
+  const taskLabel = taskId ?? "unknown";
+  const violationMessage = `SCOPE VIOLATION: ${agentName} attempted to modify '${filePath}' which is not in declared scope for task ${taskLabel}. Declared scope: [${scopeEntries.slice(0, 3).join(", ")}${scopeEntries.length > 3 ? "..." : ""}]`;
+  if (session) {
+    session.lastScopeViolation = violationMessage;
+    session.scopeViolationDetected = true;
+  }
+  if (injectAdvisory) {
+    for (const [archSessionId, archSession] of state.agentSessions) {
+      const archAgent = state.activeAgent.get(archSessionId) ?? archSession.agentName;
+      if (stripKnownSwarmPrefix(archAgent) === ORCHESTRATOR_NAME) {
+        try {
+          injectAdvisory(archSessionId, `[SCOPE GUARD] ${violationMessage}`);
+        } catch {}
+        break;
+      }
+    }
+  }
+  throw new Error(violationMessage);
+}
 
 // src/hooks/self-review.ts
 init_constants();
@@ -105997,20 +106038,836 @@ init_snapshot_writer();
 init_state();
 init_telemetry();
 
+// src/tools/apply-patch.ts
+init_zod();
+init_path_security();
+init_create_tool();
+import {
+  existsSync as existsSync58,
+  mkdirSync as mkdirSync27,
+  mkdtempSync as mkdtempSync2,
+  readFileSync as readFileSync39,
+  realpathSync as realpathSync13,
+  renameSync as renameSync20,
+  rmdirSync,
+  unlinkSync as unlinkSync17,
+  writeFileSync as writeFileSync20
+} from "node:fs";
+import * as path109 from "node:path";
+var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
+var MAX_PATCH_SIZE = 500000;
+function containsWindowsAttacks2(filePath) {
+  if (/:[^\\/]/.test(filePath))
+    return true;
+  const parts2 = filePath.split(/[/\\]/);
+  for (const part of parts2) {
+    if (WINDOWS_RESERVED_NAMES2.test(part))
+      return true;
+  }
+  return false;
+}
+function isProtectedPath2(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const segments = normalized.split("/");
+  return segments.some((seg) => seg === ".git" || seg === ".swarm");
+}
+function containsStrictControlChars(str) {
+  for (let i2 = 0;i2 < str.length; i2++) {
+    const c = str.charCodeAt(i2);
+    if (c <= 31 && c !== 9 && c !== 10 && c !== 13)
+      return true;
+  }
+  return false;
+}
+function isCanonicalProtectedPath(targetPath, workspace) {
+  try {
+    const canonicalTarget = realpathSync13(targetPath);
+    const canonicalWorkspace = realpathSync13(workspace);
+    const relative21 = path109.relative(canonicalWorkspace, canonicalTarget).replace(/\\/g, "/");
+    const segments = relative21.split("/").filter(Boolean);
+    return segments.some((seg) => seg === ".git" || seg === ".swarm");
+  } catch {
+    const parentDir = path109.dirname(targetPath);
+    if (parentDir === targetPath)
+      return false;
+    try {
+      const canonicalParent = realpathSync13(parentDir);
+      const canonicalWorkspace = realpathSync13(workspace);
+      const relative21 = path109.relative(canonicalWorkspace, canonicalParent).replace(/\\/g, "/");
+      const segments = relative21.split("/").filter(Boolean);
+      return segments.some((seg) => seg === ".git" || seg === ".swarm");
+    } catch {
+      return false;
+    }
+  }
+}
+function isCanonicalPathWithinWorkspace(targetPath, workspaceRoot) {
+  try {
+    const canonicalTarget = realpathSync13(targetPath);
+    const canonicalWorkspace = realpathSync13(workspaceRoot);
+    const relative21 = path109.relative(canonicalWorkspace, canonicalTarget);
+    if (relative21.startsWith("..") || path109.isAbsolute(relative21))
+      return false;
+    const segments = relative21.replace(/\\/g, "/").split("/").filter(Boolean);
+    if (segments.some((seg) => seg === ".git" || seg === ".swarm"))
+      return false;
+    return true;
+  } catch {
+    const parentDir = path109.dirname(targetPath);
+    if (parentDir === targetPath) {
+      return false;
+    }
+    try {
+      const canonicalParent = realpathSync13(parentDir);
+      const canonicalWorkspace = realpathSync13(workspaceRoot);
+      const relative21 = path109.relative(canonicalWorkspace, canonicalParent);
+      if (relative21.startsWith("..") || path109.isAbsolute(relative21))
+        return false;
+      const segments = relative21.replace(/\\/g, "/").split("/").filter(Boolean);
+      if (segments.some((seg) => seg === ".git" || seg === ".swarm"))
+        return false;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function validatePatchTargetPath(filePath, workspace) {
+  if (!filePath || filePath.trim() === "") {
+    return "Empty file path";
+  }
+  if (path109.isAbsolute(filePath) || /^[A-Za-z]:[/\\]/.test(filePath)) {
+    return `Absolute path rejected: ${filePath}`;
+  }
+  if (containsPathTraversal(filePath)) {
+    return `Path traversal detected: ${filePath}`;
+  }
+  if (containsStrictControlChars(filePath)) {
+    return `Control characters detected in path: ${filePath}`;
+  }
+  if (containsControlChars(filePath)) {
+    return `Control characters detected in path: ${filePath}`;
+  }
+  if (containsWindowsAttacks2(filePath)) {
+    return `Windows reserved name or invalid path: ${filePath}`;
+  }
+  if (isProtectedPath2(filePath)) {
+    return `Protected directory target rejected: ${filePath}`;
+  }
+  const resolved = path109.resolve(workspace, filePath);
+  const relative21 = path109.relative(workspace, resolved);
+  if (relative21.startsWith("..") || path109.isAbsolute(relative21)) {
+    return `Path escapes workspace: ${filePath}`;
+  }
+  if (!isCanonicalPathWithinWorkspace(resolved, workspace)) {
+    return `Path escapes workspace via symlink/junction: ${filePath}`;
+  }
+  return null;
+}
+function extractHeaderPath(header, prefix) {
+  const trimmed = header.trim();
+  if (!trimmed.startsWith(prefix))
+    return null;
+  const rest = trimmed.slice(prefix.length).trim();
+  if (rest === "/dev/null")
+    return "/dev/null";
+  if (rest.startsWith("a/") || rest.startsWith("b/")) {
+    const stripped = rest.slice(2);
+    if (stripped.length === 0)
+      return null;
+    return stripped;
+  }
+  return rest.length > 0 ? rest : null;
+}
+function parseHunkHeader(line) {
+  const match = line.match(/^@@\s*-(\d+)(?:,(\d+))?\s*\+(\d+)(?:,(\d+))?\s*@@/);
+  if (!match)
+    return null;
+  return {
+    oldStart: parseInt(match[1], 10),
+    oldCount: match[2] !== undefined ? parseInt(match[2], 10) : 1,
+    newStart: parseInt(match[3], 10),
+    newCount: match[4] !== undefined ? parseInt(match[4], 10) : 1
+  };
+}
+function parseUnifiedDiff(patchText) {
+  if (patchText.length > MAX_PATCH_SIZE) {
+    return {
+      files: [],
+      error: `Patch exceeds maximum size of ${MAX_PATCH_SIZE} characters`
+    };
+  }
+  if (patchText.includes("\x00")) {
+    return {
+      files: [],
+      error: "Binary content detected (null byte) — binary patches are not supported (FR-013)"
+    };
+  }
+  const normalized = patchText.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+  let lines = normalized.split(`
+`);
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines = lines.slice(0, -1);
+  }
+  for (const line of lines) {
+    if (line === "GIT binary patch" || line.startsWith("Binary files ")) {
+      return { files: [], error: "Binary patches are not supported (FR-013)" };
+    }
+    if (line.startsWith("rename from") || line.startsWith("rename to") || line.startsWith("copy from") || line.startsWith("copy to")) {
+      return {
+        files: [],
+        error: "Rename/copy patches are not supported (FR-013)"
+      };
+    }
+  }
+  const fileDiffs = [];
+  let i2 = 0;
+  while (i2 < lines.length) {
+    let oldHeaderPath = null;
+    let newHeaderPath = null;
+    if (lines[i2].startsWith("diff --git ")) {
+      i2++;
+      while (i2 < lines.length && (lines[i2].startsWith("index ") || lines[i2].startsWith("old mode ") || lines[i2].startsWith("new mode ") || lines[i2].startsWith("deleted file ") || lines[i2].startsWith("new file ") || lines[i2].startsWith("similarity index ") || lines[i2].startsWith("dissimilarity index "))) {
+        i2++;
+      }
+    }
+    if (i2 < lines.length && lines[i2].startsWith("--- ")) {
+      oldHeaderPath = extractHeaderPath(lines[i2], "--- ");
+      i2++;
+    } else if (oldHeaderPath === null) {
+      i2++;
+      continue;
+    }
+    if (i2 < lines.length && lines[i2].startsWith("+++ ")) {
+      newHeaderPath = extractHeaderPath(lines[i2], "+++ ");
+      i2++;
+    } else {
+      continue;
+    }
+    if (oldHeaderPath === null || newHeaderPath === null) {
+      continue;
+    }
+    const isNewFile = oldHeaderPath === "/dev/null";
+    const isDelete = newHeaderPath === "/dev/null";
+    const targetPath = isDelete ? oldHeaderPath : newHeaderPath;
+    if (targetPath === "/dev/null") {
+      continue;
+    }
+    const hunks = [];
+    while (i2 < lines.length && lines[i2].startsWith("@@")) {
+      const header = parseHunkHeader(lines[i2]);
+      if (!header) {
+        i2++;
+        continue;
+      }
+      i2++;
+      const hunkLines = [];
+      while (i2 < lines.length) {
+        const line = lines[i2];
+        if (line.startsWith("@@") || line.startsWith("diff --git ") || line.startsWith("--- ") || line.startsWith("+++ ")) {
+          break;
+        }
+        if (line.startsWith("\\")) {
+          i2++;
+          continue;
+        }
+        if (line.length === 0) {
+          break;
+        }
+        const firstChar = line[0];
+        if (firstChar !== " " && firstChar !== "+" && firstChar !== "-") {
+          break;
+        }
+        if (firstChar === "+") {
+          hunkLines.push({ type: "addition", content: line.slice(1) });
+        } else if (firstChar === "-") {
+          hunkLines.push({ type: "removal", content: line.slice(1) });
+        } else {
+          hunkLines.push({ type: "context", content: line.slice(1) });
+        }
+        i2++;
+      }
+      hunks.push({
+        oldStart: header.oldStart,
+        oldCount: header.oldCount,
+        newStart: header.newStart,
+        newCount: header.newCount,
+        lines: hunkLines
+      });
+    }
+    if (hunks.length > 0) {
+      fileDiffs.push({
+        oldPath: oldHeaderPath,
+        newPath: newHeaderPath,
+        isNewFile,
+        isDelete,
+        hunks
+      });
+    } else {
+      fileDiffs.push({
+        oldPath: oldHeaderPath,
+        newPath: newHeaderPath,
+        isNewFile,
+        isDelete,
+        hunks: []
+      });
+    }
+  }
+  return { files: fileDiffs, error: null };
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let idx = 0;idx < a.length; idx++) {
+    if (a[idx] !== b[idx])
+      return false;
+  }
+  return true;
+}
+function applyHunks(content, fileDiff) {
+  const normalizedContent = content.replace(/\r\n/g, `
+`);
+  const fileLines = normalizedContent.split(`
+`);
+  if (fileDiff.isNewFile) {
+    const newLines = [];
+    for (const hunk of fileDiff.hunks) {
+      for (const line of hunk.lines) {
+        if (line.type === "addition" || line.type === "context") {
+          newLines.push(line.content);
+        }
+      }
+    }
+    return { success: true, appliedLines: newLines };
+  }
+  if (fileDiff.isDelete) {
+    return { success: true, appliedLines: [] };
+  }
+  let accumulatedDelta = 0;
+  for (let hunkIdx = 0;hunkIdx < fileDiff.hunks.length; hunkIdx++) {
+    const hunk = fileDiff.hunks[hunkIdx];
+    const searchStart = Math.max(0, hunk.oldStart - 1 + accumulatedDelta);
+    const expectedOldLines = [];
+    const newLinesForHunk = [];
+    for (const line of hunk.lines) {
+      if (line.type === "context") {
+        expectedOldLines.push(line.content);
+        newLinesForHunk.push(line.content);
+      } else if (line.type === "removal") {
+        expectedOldLines.push(line.content);
+      } else if (line.type === "addition") {
+        newLinesForHunk.push(line.content);
+      }
+    }
+    const exactOffset = searchStart;
+    const matchFound = exactOffset <= fileLines.length - expectedOldLines.length && arraysEqual(fileLines.slice(exactOffset, exactOffset + expectedOldLines.length), expectedOldLines);
+    if (matchFound) {
+      fileLines.splice(exactOffset, expectedOldLines.length, ...newLinesForHunk);
+      const delta = newLinesForHunk.length - expectedOldLines.length;
+      accumulatedDelta += delta;
+    }
+    if (!matchFound) {
+      const diagStart = Math.min(searchStart, fileLines.length);
+      const diagEnd = Math.min(diagStart + expectedOldLines.length, fileLines.length);
+      const actualContent = fileLines.slice(diagStart, diagEnd).join(`
+`);
+      const expectedContent = expectedOldLines.join(`
+`);
+      return {
+        success: false,
+        failedHunkIndex: hunkIdx,
+        error: {
+          hunkIndex: hunkIdx,
+          type: "context-mismatch",
+          message: `Context mismatch in hunk ${hunkIdx + 1} at line ${searchStart + 1}: expected context does not match file content`,
+          expected: expectedContent.length > 200 ? `${expectedContent.slice(0, 200)}... (truncated)` : expectedContent,
+          actual: actualContent.length > 200 ? `${actualContent.slice(0, 200)}... (truncated)` : actualContent,
+          line: searchStart + 1
+        }
+      };
+    }
+  }
+  return { success: true, appliedLines: fileLines };
+}
+function atomicWriteFileSync(targetPath, content) {
+  const dir = path109.dirname(targetPath);
+  mkdirSync27(dir, { recursive: true });
+  const tempPrefix = `.apply-patch-${Date.now()}-${process.pid}`;
+  let tempPath;
+  try {
+    const tempDir = realpathSync13(mkdtempSync2(path109.join(dir, tempPrefix)));
+    tempPath = path109.join(tempDir, "content");
+  } catch {
+    tempPath = path109.join(dir, `${tempPrefix}.tmp`);
+  }
+  try {
+    writeFileSync20(tempPath, content, "utf-8");
+    renameSync20(tempPath, targetPath);
+  } finally {
+    if (existsSync58(tempPath)) {
+      try {
+        unlinkSync17(tempPath);
+      } catch {}
+    }
+    const tempDir = path109.dirname(tempPath);
+    if (tempDir !== dir && existsSync58(tempDir)) {
+      try {
+        rmdirSync(tempDir);
+      } catch {}
+    }
+  }
+}
+function detectLineEnding(content) {
+  return content.includes(`\r
+`) ? `\r
+` : `
+`;
+}
+function ensureFinalNewline(content, originalEndsWithNewline) {
+  if (originalEndsWithNewline && !content.endsWith(`
+`)) {
+    return `${content}
+`;
+  }
+  if (!originalEndsWithNewline && content.endsWith(`
+`)) {
+    return content.slice(0, -1);
+  }
+  return content;
+}
+function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allowCreates, allowDeletes) {
+  const hunksTotal = fileDiff.hunks.length;
+  if (!isCanonicalPathWithinWorkspace(fullPath, workspace)) {
+    return {
+      file: targetPath,
+      status: "error",
+      hunks: hunksTotal,
+      hunksApplied: 0,
+      hunksFailed: hunksTotal,
+      errors: [
+        {
+          hunkIndex: 0,
+          type: "context-mismatch",
+          message: `Path escapes workspace via symlink/junction: ${targetPath}`
+        }
+      ]
+    };
+  }
+  if (isCanonicalProtectedPath(fullPath, workspace)) {
+    return {
+      file: targetPath,
+      status: "error",
+      hunks: hunksTotal,
+      hunksApplied: 0,
+      hunksFailed: hunksTotal,
+      errors: [
+        {
+          hunkIndex: 0,
+          type: "context-mismatch",
+          message: `Protected directory target rejected via symlink: ${targetPath}`
+        }
+      ]
+    };
+  }
+  if (fileDiff.isNewFile) {
+    if (!allowCreates) {
+      return {
+        file: targetPath,
+        status: "error",
+        hunks: hunksTotal,
+        hunksApplied: 0,
+        hunksFailed: hunksTotal,
+        errors: [
+          {
+            hunkIndex: 0,
+            type: "create-not-allowed",
+            message: `New file creation not allowed: ${targetPath} (set allowCreates to true)`
+          }
+        ]
+      };
+    }
+    const parentDir = path109.dirname(fullPath);
+    if (!existsSync58(parentDir)) {
+      return {
+        file: targetPath,
+        status: "error",
+        hunks: hunksTotal,
+        hunksApplied: 0,
+        hunksFailed: hunksTotal,
+        errors: [
+          {
+            hunkIndex: 0,
+            type: "file-not-found",
+            message: `Parent directory does not exist: ${parentDir}`
+          }
+        ]
+      };
+    }
+    if (existsSync58(fullPath)) {
+      return {
+        file: targetPath,
+        status: "error",
+        hunks: hunksTotal,
+        hunksApplied: 0,
+        hunksFailed: hunksTotal,
+        errors: [
+          {
+            hunkIndex: 0,
+            type: "file-not-found",
+            message: `File already exists: ${targetPath} (cannot create — patch may be stale)`
+          }
+        ]
+      };
+    }
+    if (hunksTotal === 0) {
+      return {
+        file: targetPath,
+        status: "no-changes",
+        hunks: 0,
+        hunksApplied: 0,
+        hunksFailed: 0
+      };
+    }
+    const hunkResult2 = applyHunks("", fileDiff);
+    if (!hunkResult2.success || !hunkResult2.appliedLines) {
+      return {
+        file: targetPath,
+        status: "error",
+        hunks: hunksTotal,
+        hunksApplied: 0,
+        hunksFailed: hunksTotal,
+        errors: hunkResult2.error ? [hunkResult2.error] : []
+      };
+    }
+    if (!dryRun) {
+      const content2 = ensureFinalNewline(hunkResult2.appliedLines.join(`
+`), true);
+      atomicWriteFileSync(fullPath, content2);
+    }
+    return {
+      file: targetPath,
+      status: "created",
+      hunks: hunksTotal,
+      hunksApplied: hunksTotal,
+      hunksFailed: 0
+    };
+  }
+  if (fileDiff.isDelete) {
+    if (hunksTotal === 0) {
+      return {
+        file: targetPath,
+        status: "no-changes",
+        hunks: 0,
+        hunksApplied: 0,
+        hunksFailed: 0
+      };
+    }
+    if (!allowDeletes) {
+      return {
+        file: targetPath,
+        status: "error",
+        hunks: hunksTotal,
+        hunksApplied: 0,
+        hunksFailed: hunksTotal,
+        errors: [
+          {
+            hunkIndex: 0,
+            type: "delete-not-allowed",
+            message: `File deletion not allowed: ${targetPath} (set allowDeletes to true)`
+          }
+        ]
+      };
+    }
+    if (!existsSync58(fullPath)) {
+      return {
+        file: targetPath,
+        status: "error",
+        hunks: hunksTotal,
+        hunksApplied: 0,
+        hunksFailed: hunksTotal,
+        errors: [
+          {
+            hunkIndex: 0,
+            type: "file-not-found",
+            message: `File not found for deletion: ${targetPath}`
+          }
+        ]
+      };
+    }
+    if (!dryRun) {
+      try {
+        unlinkSync17(fullPath);
+      } catch (err2) {
+        return {
+          file: targetPath,
+          status: "error",
+          hunks: hunksTotal,
+          hunksApplied: 0,
+          hunksFailed: hunksTotal,
+          errors: [
+            {
+              hunkIndex: 0,
+              type: "file-not-found",
+              message: `Failed to delete file: ${err2 instanceof Error ? err2.message : String(err2)}`
+            }
+          ]
+        };
+      }
+    }
+    return {
+      file: targetPath,
+      status: "applied",
+      hunks: hunksTotal,
+      hunksApplied: hunksTotal,
+      hunksFailed: 0
+    };
+  }
+  if (!existsSync58(fullPath)) {
+    return {
+      file: targetPath,
+      status: "error",
+      hunks: hunksTotal,
+      hunksApplied: 0,
+      hunksFailed: hunksTotal,
+      errors: [
+        {
+          hunkIndex: 0,
+          type: "file-not-found",
+          message: `File not found: ${targetPath}`
+        }
+      ]
+    };
+  }
+  let content;
+  try {
+    content = readFileSync39(fullPath, "utf-8");
+  } catch (err2) {
+    return {
+      file: targetPath,
+      status: "error",
+      hunks: hunksTotal,
+      hunksApplied: 0,
+      hunksFailed: hunksTotal,
+      errors: [
+        {
+          hunkIndex: 0,
+          type: "file-not-found",
+          message: `Could not read file: ${err2 instanceof Error ? err2.message : String(err2)}`
+        }
+      ]
+    };
+  }
+  if (hunksTotal === 0) {
+    return {
+      file: targetPath,
+      status: "no-changes",
+      hunks: 0,
+      hunksApplied: 0,
+      hunksFailed: 0
+    };
+  }
+  const originalEndsWithNewline = content.endsWith(`
+`);
+  const originalLineEnding = detectLineEnding(content);
+  const hunkResult = applyHunks(content, fileDiff);
+  if (!hunkResult.success) {
+    return {
+      file: targetPath,
+      status: "error",
+      hunks: hunksTotal,
+      hunksApplied: 0,
+      hunksFailed: hunksTotal,
+      errors: hunkResult.error ? [hunkResult.error] : []
+    };
+  }
+  const resultContent = hunkResult.appliedLines.join(`
+`);
+  if (resultContent === "" && !dryRun && !allowDeletes && content.length > 0) {
+    return {
+      file: targetPath,
+      status: "error",
+      hunks: hunksTotal,
+      hunksApplied: hunksTotal,
+      hunksFailed: 0,
+      errors: [
+        {
+          hunkIndex: 0,
+          type: "delete-not-allowed",
+          message: `Patch would delete all content from ${targetPath}. Set allowDeletes to true to permit file deletion.`
+        }
+      ]
+    };
+  }
+  let finalContent;
+  if (resultContent === "") {
+    finalContent = "";
+  } else {
+    const withLineEnding = originalLineEnding === `\r
+` ? resultContent.replace(/\n/g, `\r
+`) : resultContent;
+    finalContent = ensureFinalNewline(withLineEnding, originalEndsWithNewline);
+  }
+  if (finalContent === content) {
+    return {
+      file: targetPath,
+      status: "no-changes",
+      hunks: hunksTotal,
+      hunksApplied: hunksTotal,
+      hunksFailed: 0
+    };
+  }
+  if (!dryRun) {
+    atomicWriteFileSync(fullPath, finalContent);
+  }
+  return {
+    file: targetPath,
+    status: "applied",
+    hunks: hunksTotal,
+    hunksApplied: hunksTotal,
+    hunksFailed: 0
+  };
+}
+function buildErrorResult(message) {
+  return {
+    success: false,
+    files: [
+      {
+        file: "",
+        status: "error",
+        hunks: 0,
+        hunksApplied: 0,
+        hunksFailed: 0,
+        errors: [
+          {
+            hunkIndex: 0,
+            type: "context-mismatch",
+            message
+          }
+        ]
+      }
+    ],
+    summary: {
+      totalFiles: 0,
+      applied: 0,
+      failed: 1,
+      totalHunks: 0
+    }
+  };
+}
+var applyPatch = createSwarmTool({
+  description: "Apply a unified diff patch to workspace files. Validates paths, matches context exactly, and writes atomically. Coder-scoped write tool.",
+  args: {
+    patch: exports_external.string().min(1).describe("Unified diff text to parse and apply"),
+    files: exports_external.array(exports_external.string()).min(1).describe("Array of target file paths the patch is expected to touch. Every parsed target must appear in this list."),
+    dryRun: exports_external.boolean().optional().default(false).describe("Validate without writing files (default: false)"),
+    allowCreates: exports_external.boolean().optional().default(false).describe("Allow creating new files from patches with --- /dev/null (default: false)"),
+    allowDeletes: exports_external.boolean().optional().default(false).describe("Allow deleting files from patches with +++ /dev/null (default: false)")
+  },
+  execute: async (args2, directory) => {
+    if (!args2 || typeof args2 !== "object") {
+      return JSON.stringify(buildErrorResult("Could not parse apply_patch arguments"), null, 2);
+    }
+    const obj = args2;
+    const patchText = obj.patch ?? "";
+    const files = obj.files ?? [];
+    const dryRun = obj.dryRun ?? false;
+    const allowCreates = obj.allowCreates ?? false;
+    const allowDeletes = obj.allowDeletes ?? false;
+    if (!existsSync58(directory)) {
+      return JSON.stringify(buildErrorResult("Workspace directory does not exist"), null, 2);
+    }
+    if (files.length === 0) {
+      return JSON.stringify(buildErrorResult("files array cannot be empty"), null, 2);
+    }
+    if (!patchText || patchText.trim() === "") {
+      return JSON.stringify(buildErrorResult("patch text cannot be empty"), null, 2);
+    }
+    for (const filePath of files) {
+      const validationError = validatePatchTargetPath(filePath, directory);
+      if (validationError) {
+        return JSON.stringify(buildErrorResult(validationError), null, 2);
+      }
+    }
+    const { files: parsedFiles, error: parseError } = parseUnifiedDiff(patchText);
+    if (parseError) {
+      return JSON.stringify(buildErrorResult(parseError), null, 2);
+    }
+    if (parsedFiles.length === 0) {
+      return JSON.stringify({
+        success: true,
+        dryRun,
+        files: [],
+        summary: { totalFiles: 0, applied: 0, failed: 0, totalHunks: 0 }
+      }, null, 2);
+    }
+    const declaredFileSet = new Set(files);
+    const undeclaredTargets = [];
+    for (const fileDiff of parsedFiles) {
+      const targetPath = fileDiff.isDelete ? fileDiff.oldPath : fileDiff.newPath;
+      if (targetPath && targetPath !== "/dev/null" && !declaredFileSet.has(targetPath)) {
+        undeclaredTargets.push(targetPath);
+      }
+    }
+    if (undeclaredTargets.length > 0) {
+      return JSON.stringify(buildErrorResult(`Patch targets files not in the declared files array: ${undeclaredTargets.join(", ")}`), null, 2);
+    }
+    const parsedTargetSet = new Set(parsedFiles.map((fd) => fd.isDelete ? fd.oldPath : fd.newPath).filter(Boolean));
+    const extraFiles = files.filter((f) => !parsedTargetSet.has(f));
+    const fileResults = [];
+    let totalApplied = 0;
+    let totalFailed = 0;
+    let totalHunks = 0;
+    for (const fileDiff of parsedFiles) {
+      const targetPath = fileDiff.isDelete ? fileDiff.oldPath : fileDiff.newPath;
+      const fullPath = path109.resolve(directory, targetPath);
+      totalHunks += fileDiff.hunks.length;
+      const result = processFileDiff(fileDiff, targetPath, fullPath, directory, dryRun, allowCreates, allowDeletes);
+      fileResults.push(result);
+      if (result.status === "applied" || result.status === "created") {
+        totalApplied++;
+      } else if (result.status === "error") {
+        totalFailed++;
+      }
+    }
+    const output = {
+      success: totalFailed === 0,
+      dryRun,
+      files: fileResults,
+      summary: {
+        totalFiles: fileResults.length,
+        applied: totalApplied,
+        failed: totalFailed,
+        totalHunks
+      }
+    };
+    if (extraFiles.length > 0) {
+      return JSON.stringify({
+        ...output,
+        warnings: [
+          `files[] contains entries not targeted by the patch: ${extraFiles.join(", ")}`
+        ]
+      }, null, 2);
+    }
+    return JSON.stringify(output, null, 2);
+  }
+});
+
 // src/tools/batch-symbols.ts
 init_dist();
 init_create_tool();
 import * as fs72 from "node:fs";
-import * as path109 from "node:path";
+import * as path110 from "node:path";
 init_path_security();
-var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
-function containsWindowsAttacks2(str) {
+var WINDOWS_RESERVED_NAMES3 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
+function containsWindowsAttacks3(str) {
   if (/:[^\\/]/.test(str)) {
     return true;
   }
   const parts2 = str.split(/[/\\]/);
   for (const part of parts2) {
-    if (WINDOWS_RESERVED_NAMES2.test(part)) {
+    if (WINDOWS_RESERVED_NAMES3.test(part)) {
       return true;
     }
   }
@@ -106018,14 +106875,14 @@ function containsWindowsAttacks2(str) {
 }
 function isPathInWorkspace2(filePath, workspace) {
   try {
-    const resolvedPath = path109.resolve(workspace, filePath);
+    const resolvedPath = path110.resolve(workspace, filePath);
     if (!fs72.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs72.realpathSync(workspace);
     const realResolvedPath = fs72.realpathSync(resolvedPath);
-    const relativePath = path109.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path109.isAbsolute(relativePath)) {
+    const relativePath = path110.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path110.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -106034,7 +106891,7 @@ function isPathInWorkspace2(filePath, workspace) {
   }
 }
 function processFile2(file3, cwd, exportedOnly) {
-  const ext = path109.extname(file3);
+  const ext = path110.extname(file3);
   if (containsControlChars(file3)) {
     return {
       file: file3,
@@ -106051,7 +106908,7 @@ function processFile2(file3, cwd, exportedOnly) {
       errorType: "path-traversal"
     };
   }
-  if (containsWindowsAttacks2(file3)) {
+  if (containsWindowsAttacks3(file3)) {
     return {
       file: file3,
       success: false,
@@ -106067,7 +106924,7 @@ function processFile2(file3, cwd, exportedOnly) {
       errorType: "path-outside-workspace"
     };
   }
-  const fullPath = path109.join(cwd, file3);
+  const fullPath = path110.join(cwd, file3);
   if (!fs72.existsSync(fullPath)) {
     return {
       file: file3,
@@ -106361,15 +107218,15 @@ init_task_id();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs73 from "node:fs";
-import * as path110 from "node:path";
+import * as path111 from "node:path";
 var EVIDENCE_DIR = ".swarm/evidence";
 function isValidTaskId3(taskId) {
   return isStrictTaskId(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path110.resolve(workspaceRoot);
-  const swarmPath = path110.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path110.resolve(filePath);
+  const normalizedWorkspace = path111.resolve(workspaceRoot);
+  const swarmPath = path111.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path111.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
@@ -106450,7 +107307,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path110.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path111.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -106547,7 +107404,7 @@ init_state();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs74 from "node:fs";
-import * as path111 from "node:path";
+import * as path112 from "node:path";
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
 }
@@ -106699,10 +107556,10 @@ async function executeCompletionVerify(args2, directory) {
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
       const normalizedPath = filePath.replace(/\\/g, "/");
-      const resolvedPath = path111.resolve(directory, normalizedPath);
-      const projectRoot = path111.resolve(directory);
-      const relative22 = path111.relative(projectRoot, resolvedPath);
-      const withinProject = relative22 === "" || !relative22.startsWith("..") && !path111.isAbsolute(relative22);
+      const resolvedPath = path112.resolve(directory, normalizedPath);
+      const projectRoot = path112.resolve(directory);
+      const relative23 = path112.relative(projectRoot, resolvedPath);
+      const withinProject = relative23 === "" || !relative23.startsWith("..") && !path112.isAbsolute(relative23);
       if (!withinProject) {
         blockedTasks.push({
           task_id: task.id,
@@ -106757,8 +107614,8 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path111.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path111.join(evidenceDir, "completion-verify.json");
+    const evidenceDir = path112.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path112.join(evidenceDir, "completion-verify.json");
     fs74.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
@@ -106836,11 +107693,11 @@ var completion_verify = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_zod();
 import * as fs76 from "node:fs";
-import * as path113 from "node:path";
+import * as path114 from "node:path";
 
 // src/quality/metrics.ts
 import * as fs75 from "node:fs";
-import * as path112 from "node:path";
+import * as path113 from "node:path";
 var MAX_FILE_SIZE_BYTES4 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -106892,7 +107749,7 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path112.isAbsolute(file3) ? file3 : path112.join(workingDir, file3);
+    const fullPath = path113.isAbsolute(file3) ? file3 : path113.join(workingDir, file3);
     if (!fs75.existsSync(fullPath)) {
       continue;
     }
@@ -107015,7 +107872,7 @@ function countGoExports(content) {
 function getExportCountForFile(filePath) {
   try {
     const content = fs75.readFileSync(filePath, "utf-8");
-    const ext = path112.extname(filePath).toLowerCase();
+    const ext = path113.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -107041,7 +107898,7 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path112.isAbsolute(file3) ? file3 : path112.join(workingDir, file3);
+    const fullPath = path113.isAbsolute(file3) ? file3 : path113.join(workingDir, file3);
     if (!fs75.existsSync(fullPath)) {
       continue;
     }
@@ -107075,7 +107932,7 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path112.isAbsolute(file3) ? file3 : path112.join(workingDir, file3);
+    const fullPath = path113.isAbsolute(file3) ? file3 : path113.join(workingDir, file3);
     if (!fs75.existsSync(fullPath)) {
       continue;
     }
@@ -107108,8 +107965,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename16 = path112.basename(filePath);
-  const _ext = path112.extname(filePath).toLowerCase();
+  const basename16 = path113.basename(filePath);
+  const _ext = path113.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -107190,8 +108047,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path113, glob) {
-  const normalizedPath = path113.replace(/\\/g, "/");
+function matchesGlobSegment(path114, glob) {
+  const normalizedPath = path114.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -107222,8 +108079,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path113, glob) {
-  const normalizedPath = path113.replace(/\\/g, "/");
+function globMatches(path114, glob) {
+  const normalizedPath = path114.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -107259,7 +108116,7 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path112.join(workingDir, "src");
+  const srcDir = path113.join(workingDir, "src");
   if (fs75.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
@@ -107267,14 +108124,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path112.join(workingDir, dir);
+    const dirPath = path113.join(workingDir, dir);
     if (fs75.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path112.join(workingDir, "tests");
+  const testsDir = path113.join(workingDir, "tests");
   if (fs75.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
@@ -107282,7 +108139,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path112.join(workingDir, dir);
+    const dirPath = path113.join(workingDir, dir);
     if (fs75.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
@@ -107297,7 +108154,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
   try {
     const entries = fs75.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path112.join(dirPath, entry.name);
+      const fullPath = path113.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -107305,7 +108162,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${dirPath}/`, "");
-        const ext = path112.extname(entry.name).toLowerCase();
+        const ext = path113.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -107556,7 +108413,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path113.extname(file3).toLowerCase();
+    const ext = path114.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -107567,7 +108424,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
     if (!fs76.existsSync(fullPath)) {
-      fullPath = path113.join(cwd, file3);
+      fullPath = path114.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
     if (complexity !== null) {
@@ -107736,8 +108593,8 @@ ${body2}`);
 
 // src/council/council-evidence-writer.ts
 init_task_file();
-import { appendFileSync as appendFileSync12, existsSync as existsSync62, mkdirSync as mkdirSync28, readFileSync as readFileSync44 } from "node:fs";
-import { join as join94 } from "node:path";
+import { appendFileSync as appendFileSync12, existsSync as existsSync63, mkdirSync as mkdirSync29, readFileSync as readFileSync45 } from "node:fs";
+import { join as join95 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
@@ -107774,14 +108631,14 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   if (!VALID_TASK_ID.test(synthesis.taskId)) {
     throw new Error(`writeCouncilEvidence: invalid taskId "${synthesis.taskId}" — must match N.M or N.M.P format`);
   }
-  const dir = join94(workingDir, EVIDENCE_DIR2);
-  mkdirSync28(dir, { recursive: true });
+  const dir = join95(workingDir, EVIDENCE_DIR2);
+  mkdirSync29(dir, { recursive: true });
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
   await _internals53.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
-    if (existsSync62(filePath)) {
+    if (existsSync63(filePath)) {
       try {
-        const parsed = JSON.parse(readFileSync44(filePath, "utf-8"));
+        const parsed = JSON.parse(readFileSync45(filePath, "utf-8"));
         if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
           safeAssignOwnProps(existingRoot, parsed);
         }
@@ -107812,15 +108669,15 @@ async function writeCouncilEvidence(workingDir, synthesis) {
     await atomicWriteFile(filePath, JSON.stringify(updated, null, 2));
   });
   try {
-    const councilDir = join94(workingDir, ".swarm", "council");
-    mkdirSync28(councilDir, { recursive: true });
+    const councilDir = join95(workingDir, ".swarm", "council");
+    mkdirSync29(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
       verdict: synthesis.overallVerdict,
       timestamp: synthesis.timestamp,
       vetoedBy: synthesis.vetoedBy
     });
-    appendFileSync12(join94(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
+    appendFileSync12(join95(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
 `);
   } catch (auditError) {
     console.warn(`writeCouncilEvidence: failed to append round-history audit log: ${auditError instanceof Error ? auditError.message : String(auditError)}`);
@@ -108142,25 +108999,25 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 }
 
 // src/council/criteria-store.ts
-import { existsSync as existsSync63, mkdirSync as mkdirSync29, readFileSync as readFileSync45, writeFileSync as writeFileSync21 } from "node:fs";
-import { join as join95 } from "node:path";
+import { existsSync as existsSync64, mkdirSync as mkdirSync30, readFileSync as readFileSync46, writeFileSync as writeFileSync22 } from "node:fs";
+import { join as join96 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 function writeCriteria(workingDir, taskId, criteria) {
-  const dir = join95(workingDir, COUNCIL_DIR);
-  mkdirSync29(dir, { recursive: true });
+  const dir = join96(workingDir, COUNCIL_DIR);
+  mkdirSync30(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
     declaredAt: new Date().toISOString()
   };
-  writeFileSync21(join95(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
+  writeFileSync22(join96(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
 }
 function readCriteria(workingDir, taskId) {
-  const filePath = join95(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
-  if (!existsSync63(filePath))
+  const filePath = join96(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
+  if (!existsSync64(filePath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync45(filePath, "utf-8"));
+    const parsed = JSON.parse(readFileSync46(filePath, "utf-8"));
     if (parsed && typeof parsed === "object" && typeof parsed.taskId === "string" && Array.isArray(parsed.criteria)) {
       return parsed;
     }
@@ -108310,7 +109167,7 @@ var submit_council_verdicts = createSwarmTool({
 init_zod();
 init_loader();
 import * as fs77 from "node:fs";
-import * as path114 from "node:path";
+import * as path115 from "node:path";
 
 // src/council/general-council-advisory.ts
 var ADVISORY_HEADER = "[general_council] (advisory; not blocking)";
@@ -108738,10 +109595,10 @@ var convene_general_council = createSwarmTool({
     const round1 = input.round1Responses;
     const round2 = input.round2Responses ?? [];
     const result = synthesizeGeneralCouncil(input.question, input.mode, round1, round2);
-    const evidenceDir = path114.join(workingDir, ".swarm", "council", "general");
+    const evidenceDir = path115.join(workingDir, ".swarm", "council", "general");
     const safeTimestamp = result.timestamp.replace(/[:.]/g, "-");
     const evidenceFile = `${safeTimestamp}-${input.mode}.json`;
-    const evidencePath = path114.join(evidenceDir, evidenceFile);
+    const evidencePath = path115.join(evidenceDir, evidenceFile);
     try {
       await fs77.promises.mkdir(evidenceDir, { recursive: true });
       await fs77.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
@@ -109012,7 +109869,7 @@ init_state();
 init_task_id();
 init_create_tool();
 import * as fs78 from "node:fs";
-import * as path115 from "node:path";
+import * as path116 from "node:path";
 function validateTaskIdFormat2(taskId) {
   return validateTaskIdFormat(taskId);
 }
@@ -109086,8 +109943,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path115.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path115.sep);
+    normalizedDir = path116.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path116.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -109097,10 +109954,10 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path115.resolve(normalizedDir);
+    const resolvedDir = path116.resolve(normalizedDir);
     try {
       const realPath = fs78.realpathSync(resolvedDir);
-      const planPath2 = path115.join(realPath, ".swarm", "plan.json");
+      const planPath2 = path116.join(realPath, ".swarm", "plan.json");
       if (!fs78.existsSync(planPath2)) {
         return {
           success: false,
@@ -109121,9 +109978,9 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
     if (normalizedDir && fallbackDir) {
       try {
-        const canonicalWorkingDir = fs78.realpathSync(path115.resolve(normalizedDir));
-        const canonicalProjectRoot = fs78.realpathSync(path115.resolve(fallbackDir));
-        if (canonicalWorkingDir.startsWith(canonicalProjectRoot + path115.sep)) {
+        const canonicalWorkingDir = fs78.realpathSync(path116.resolve(normalizedDir));
+        const canonicalProjectRoot = fs78.realpathSync(path116.resolve(fallbackDir));
+        if (canonicalWorkingDir.startsWith(canonicalProjectRoot + path116.sep)) {
           return {
             success: false,
             message: `working_directory "${normalizedDir}" is a subdirectory of the project root. Use the project root "${fallbackDir}" instead.`,
@@ -109145,7 +110002,7 @@ async function executeDeclareScope(args2, fallbackDir) {
     };
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path115.resolve(directory, ".swarm", "plan.json");
+  const planPath = path116.resolve(directory, ".swarm", "plan.json");
   if (!fs78.existsSync(planPath)) {
     return {
       success: false,
@@ -109185,8 +110042,8 @@ async function executeDeclareScope(args2, fallbackDir) {
   const normalizeErrors = [];
   const dir = directory;
   const mergedFiles = rawMergedFiles.map((file3) => {
-    if (path115.isAbsolute(file3)) {
-      const relativePath = path115.relative(dir, file3).replace(/\\/g, "/");
+    if (path116.isAbsolute(file3)) {
+      const relativePath = path116.relative(dir, file3).replace(/\\/g, "/");
       if (relativePath.startsWith("..")) {
         normalizeErrors.push(`Path '${file3}' resolves outside the project directory`);
         return file3;
@@ -109248,7 +110105,7 @@ var declare_scope = createSwarmTool({
 init_zod();
 import * as child_process7 from "node:child_process";
 import * as fs79 from "node:fs";
-import * as path116 from "node:path";
+import * as path117 from "node:path";
 init_create_tool();
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
@@ -109277,20 +110134,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path117 of paths) {
-    if (!path117 || path117.length === 0) {
+  for (const path118 of paths) {
+    if (!path118 || path118.length === 0) {
       return "empty path not allowed";
     }
-    if (path117.length > MAX_PATH_LENGTH) {
+    if (path118.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path117)) {
+    if (SHELL_METACHARACTERS2.test(path118)) {
       return "path contains shell metacharacters";
     }
-    if (path117.startsWith("-")) {
+    if (path118.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path117)) {
+    if (CONTROL_CHAR_PATTERN2.test(path118)) {
       return "path contains control characters";
     }
   }
@@ -109398,8 +110255,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path117 = parts2[2];
-          files.push({ path: path117, additions, deletions });
+          const path118 = parts2[2];
+          files.push({ path: path118, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -109438,7 +110295,7 @@ var diff = createSwarmTool({
           } else if (base === "unstaged") {
             const oldRef = `:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
-            newContent = fs79.readFileSync(path116.join(directory, file3.path), "utf-8");
+            newContent = fs79.readFileSync(path117.join(directory, file3.path), "utf-8");
           } else {
             const oldRef = `${base}:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
@@ -109515,12 +110372,12 @@ var diff = createSwarmTool({
 init_zod();
 import * as child_process8 from "node:child_process";
 import * as fs80 from "node:fs";
-import * as path117 from "node:path";
+import * as path118 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 async function execGit2(workingDir, args2, options) {
   try {
-    const stdout = await new Promise((resolve40, reject) => {
+    const stdout = await new Promise((resolve41, reject) => {
       const execOpts = {
         encoding: "utf-8",
         cwd: workingDir,
@@ -109533,7 +110390,7 @@ async function execGit2(workingDir, args2, options) {
           reject(error93);
           return;
         }
-        resolve40(output ?? "");
+        resolve41(output ?? "");
       });
     });
     return stdout;
@@ -109584,7 +110441,7 @@ var diff_summary = createSwarmTool({
         }
         try {
           let oldContent;
-          const newContent = await fs80.promises.readFile(path117.join(workingDir, filePath), "utf-8");
+          const newContent = await fs80.promises.readFile(path118.join(workingDir, filePath), "utf-8");
           if (fileExistsInHead) {
             oldContent = await execGit2(workingDir, ["show", `HEAD:${filePath}`], {
               timeout: 5000,
@@ -109814,7 +110671,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs81 from "node:fs";
-import * as path118 from "node:path";
+import * as path119 from "node:path";
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR3 = ".swarm/evidence";
@@ -109841,9 +110698,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path118.resolve(cwd);
-  const swarmPath = path118.join(normalizedCwd, ".swarm");
-  const normalizedPath = path118.resolve(filePath);
+  const normalizedCwd = path119.resolve(cwd);
+  const swarmPath = path119.join(normalizedCwd, ".swarm");
+  const normalizedPath = path119.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -109873,10 +110730,10 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path118.join(evidenceDir, filename);
+    const filePath = path119.join(evidenceDir, filename);
     try {
-      const resolvedPath = path118.resolve(filePath);
-      const evidenceDirResolved = path118.resolve(evidenceDir);
+      const resolvedPath = path119.resolve(filePath);
+      const evidenceDirResolved = path119.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
@@ -109994,7 +110851,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path118.join(cwd, PLAN_FILE);
+    const planPath = path119.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -110026,7 +110883,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path118.join(cwd, EVIDENCE_DIR3);
+    const evidenceDir = path119.join(cwd, EVIDENCE_DIR3);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -110045,7 +110902,7 @@ var evidence_check = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs82 from "node:fs";
-import * as path119 from "node:path";
+import * as path120 from "node:path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -110126,12 +110983,12 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path119.join(targetDir, filename);
-      const base = path119.basename(filepath, path119.extname(filepath));
-      const ext = path119.extname(filepath);
+      let filepath = path120.join(targetDir, filename);
+      const base = path120.basename(filepath, path120.extname(filepath));
+      const ext = path120.extname(filepath);
       let counter = 1;
       while (fs82.existsSync(filepath)) {
-        filepath = path119.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path120.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -110473,7 +111330,7 @@ init_create_tool();
 var GITINGEST_TIMEOUT_MS = 1e4;
 var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
 var GITINGEST_MAX_RETRIES = 2;
-var delay = (ms) => new Promise((resolve41) => setTimeout(resolve41, ms));
+var delay = (ms) => new Promise((resolve42) => setTimeout(resolve42, ms));
 async function fetchGitingest(args2) {
   for (let attempt = 0;attempt <= GITINGEST_MAX_RETRIES; attempt++) {
     try {
@@ -110562,7 +111419,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs83 from "node:fs";
-import * as path120 from "node:path";
+import * as path121 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
@@ -110610,7 +111467,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path120.extname(filePath).toLowerCase();
+  const ext = path121.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -110634,15 +111491,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path120.resolve(targetFile);
+    _resolvedTarget = path121.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path120.basename(targetFile, path120.extname(targetFile));
+  const targetBasename = path121.basename(targetFile, path121.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path120.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path120.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path121.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path121.normalize(targetWithoutExt).replace(/\\/g, "/");
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
   for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
     const modulePath = match[1] || match[2] || match[3];
@@ -110665,9 +111522,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path120.dirname(targetFile);
-    const targetExt = path120.extname(targetFile);
-    const targetBasenameNoExt = path120.basename(targetFile, targetExt);
+    const _targetDir = path121.dirname(targetFile);
+    const targetExt = path121.extname(targetFile);
+    const targetBasenameNoExt = path121.basename(targetFile, targetExt);
     const moduleNormalized = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
     const moduleName = modulePath.split(/[/\\]/).pop() || "";
     const moduleNameNoExt = moduleName.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
@@ -110735,10 +111592,10 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES4.has(entry)) {
-      stats.skippedDirs.push(path120.join(dir, entry));
+      stats.skippedDirs.push(path121.join(dir, entry));
       continue;
     }
-    const fullPath = path120.join(dir, entry);
+    const fullPath = path121.join(dir, entry);
     let stat9;
     try {
       stat9 = fs83.statSync(fullPath);
@@ -110752,7 +111609,7 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat9.isDirectory()) {
       findSourceFiles2(fullPath, files, stats);
     } else if (stat9.isFile()) {
-      const ext = path120.extname(fullPath).toLowerCase();
+      const ext = path121.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -110809,7 +111666,7 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path120.resolve(file3);
+      const targetFile = path121.resolve(file3);
       if (!fs83.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
@@ -110831,7 +111688,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path120.dirname(targetFile);
+      const baseDir = path121.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -111219,7 +112076,7 @@ init_zod();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync68 } from "node:fs";
+import { existsSync as existsSync69 } from "node:fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -111295,14 +112152,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync68(swarmPath)) {
+  if (!existsSync69(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync68(hivePath)) {
+  if (!existsSync69(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -111728,11 +112585,11 @@ var lean_turbo_acquire_locks = createSwarmTool({
 init_zod();
 init_constants();
 import * as fs85 from "node:fs";
-import * as path122 from "node:path";
+import * as path123 from "node:path";
 
 // src/turbo/lean/conflicts.ts
 import * as fs84 from "node:fs";
-import * as path121 from "node:path";
+import * as path122 from "node:path";
 var DEFAULT_GLOBAL_FILES = [
   "package.json",
   "package-lock.json",
@@ -111835,7 +112692,7 @@ function isGlobalFile(normalizedPath) {
   }
   return false;
 }
-function isProtectedPath2(normalizedPath) {
+function isProtectedPath3(normalizedPath) {
   const lowerPath = normalizedPath.toLowerCase();
   for (const pattern of DEFAULT_PROTECTED_PATTERNS) {
     if (lowerPath.includes(pattern.toLowerCase())) {
@@ -111859,7 +112716,7 @@ function isProtectedPath2(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path121.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path122.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
     if (!fs84.existsSync(scopePath)) {
       return null;
@@ -111885,7 +112742,7 @@ function assessTaskRisk(files, hasDeclaredScope, hasInvalidScope, config3) {
       files: globalFiles
     };
   }
-  const protectedFiles = files.filter(isProtectedPath2);
+  const protectedFiles = files.filter(isProtectedPath3);
   if (protectedFiles.length > 0) {
     return {
       category: "protected",
@@ -112247,7 +113104,7 @@ function createEmptyPlan(phaseNumber, planId) {
 // src/tools/lean-turbo-plan-lanes.ts
 init_create_tool();
 function readPlanJson(directory) {
-  const planPath = path122.join(directory, ".swarm", "plan.json");
+  const planPath = path123.join(directory, ".swarm", "plan.json");
   if (!fs85.existsSync(planPath)) {
     return null;
   }
@@ -112303,15 +113160,15 @@ init_config();
 // src/turbo/lean/reviewer.ts
 init_state();
 import * as fs87 from "node:fs/promises";
-import * as path124 from "node:path";
+import * as path125 from "node:path";
 
 // src/turbo/lean/evidence.ts
 init_bun_compat();
 import { rmSync as rmSync6 } from "node:fs";
 import * as fs86 from "node:fs/promises";
-import * as path123 from "node:path";
+import * as path124 from "node:path";
 function leanTurboEvidenceDir(directory, phase) {
-  return path123.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  return path124.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
 }
 function validateLaneId(laneId) {
   if (laneId.length === 0) {
@@ -112333,16 +113190,16 @@ function validateLaneId(laneId) {
 function laneEvidencePath(directory, phase, laneId) {
   validateLaneId(laneId);
   const expectedDir = leanTurboEvidenceDir(directory, phase);
-  const resolvedPath = path123.resolve(path123.join(expectedDir, `${laneId}.json`));
-  const resolvedDir = path123.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path123.sep) && resolvedPath !== resolvedDir) {
+  const resolvedPath = path124.resolve(path124.join(expectedDir, `${laneId}.json`));
+  const resolvedDir = path124.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path124.sep) && resolvedPath !== resolvedDir) {
     throw new Error(`Invalid laneId: path traversal detected (got "${laneId}")`);
   }
   return resolvedPath;
 }
 async function atomicWriteJson(filePath, data) {
   const content = JSON.stringify(data, null, 2);
-  const dir = path123.dirname(filePath);
+  const dir = path124.dirname(filePath);
   await fs86.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   try {
@@ -112356,7 +113213,7 @@ async function atomicWriteJson(filePath, data) {
   }
 }
 function phaseEvidencePath(directory, phase) {
-  return path123.join(leanTurboEvidenceDir(directory, phase), "lean-turbo-phase.json");
+  return path124.join(leanTurboEvidenceDir(directory, phase), "lean-turbo-phase.json");
 }
 async function writeLaneEvidence(directory, phase, evidence) {
   const targetPath = laneEvidencePath(directory, phase, evidence.laneId);
@@ -112400,7 +113257,7 @@ async function listLaneEvidence(directory, phase) {
     if (entry === "lean-turbo-phase.json") {
       continue;
     }
-    const filePath = path123.join(evidenceDir, entry);
+    const filePath = path124.join(evidenceDir, entry);
     let content;
     try {
       content = await fs86.readFile(filePath, "utf-8");
@@ -112531,9 +113388,9 @@ function parseReviewerVerdict(responseText) {
   return { verdict, reason };
 }
 async function writeReviewerEvidence(directory, phase, verdict, reason) {
-  const evidenceDir = path124.join(directory, ".swarm", "evidence", String(phase));
+  const evidenceDir = path125.join(directory, ".swarm", "evidence", String(phase));
   await fs87.mkdir(evidenceDir, { recursive: true });
-  const evidencePath = path124.join(evidenceDir, "lean-turbo-reviewer.json");
+  const evidencePath = path125.join(evidenceDir, "lean-turbo-reviewer.json");
   const content = JSON.stringify({
     phase,
     verdict,
@@ -113345,7 +114202,7 @@ init_lint();
 init_spec_schema();
 init_create_tool();
 import * as fs88 from "node:fs";
-import * as path125 from "node:path";
+import * as path126 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -113398,7 +114255,7 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path125.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    const specPath = path126.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
     if (!fs88.existsSync(specPath)) {
       const result2 = {
         valid: false,
@@ -113470,12 +114327,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs89 from "node:fs";
-import * as path127 from "node:path";
+import * as path128 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
-import { unlinkSync as unlinkSync17, writeFileSync as writeFileSync23 } from "node:fs";
-import * as path126 from "node:path";
+import { unlinkSync as unlinkSync18, writeFileSync as writeFileSync24 } from "node:fs";
+import * as path127 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -113621,9 +114478,9 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path126.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path127.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
-      writeFileSync23(patchFile, patch.patch);
+      writeFileSync24(patchFile, patch.patch);
     } catch (writeErr) {
       error93 = `Failed to write patch file: ${writeErr}`;
       outcome = "error";
@@ -113719,7 +114576,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
         revertError = new Error(`Failed to revert mutation ${patch.id}: ${revertErr}. Working tree may be dirty.`);
       }
       try {
-        unlinkSync17(patchFile);
+        unlinkSync18(patchFile);
       } catch (_unlinkErr) {}
     }
   }
@@ -114025,7 +114882,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path127.resolve(cwd, filePath);
+          const resolvedPath = path128.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs89.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -114047,22 +114904,22 @@ init_config();
 init_schema();
 init_manager2();
 import * as fs99 from "node:fs";
-import * as path137 from "node:path";
+import * as path138 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state2();
 import * as fs90 from "node:fs";
-import * as path128 from "node:path";
+import * as path129 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path128.posix.join("evidence", String(phase)));
+    const dirPath = validateSwarmPath(directory, path129.posix.join("evidence", String(phase)));
     if (!fs90.existsSync(dirPath))
       return [];
     const entries = fs90.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path128.join(dirPath, e));
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path129.join(dirPath, e));
   } catch {
     return [];
   }
@@ -114203,16 +115060,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs91 from "node:fs";
-import * as path129 from "node:path";
+import * as path130 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path129.join(directory, ".swarm");
+    const swarmDir = path130.join(directory, ".swarm");
     fs91.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path129.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path129.join(swarmDir, "SWARM_PLAN.md");
+    const jsonPath = path130.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path130.join(swarmDir, "SWARM_PLAN.md");
     fs91.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs91.writeFileSync(mdPath, md, "utf8");
@@ -114231,7 +115088,7 @@ init_telemetry();
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
 import * as fs92 from "node:fs";
-import * as path130 from "node:path";
+import * as path131 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
   phase_reviewer: true,
@@ -114240,7 +115097,7 @@ var DEFAULT_CONFIG3 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path130.join(dir, ".swarm", "plan.json");
+    const planPath = path131.join(dir, ".swarm", "plan.json");
     if (!fs92.existsSync(planPath))
       return null;
     const raw = fs92.readFileSync(planPath, "utf-8");
@@ -114255,7 +115112,7 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path130.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    const evidencePath = path131.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
     if (!fs92.existsSync(evidencePath)) {
       return null;
     }
@@ -114275,7 +115132,7 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path130.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    const evidencePath = path131.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
     if (!fs92.existsSync(evidencePath)) {
       return null;
     }
@@ -114294,7 +115151,7 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path130.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path131.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
     entries = fs92.readdirSync(evidenceDir);
@@ -114364,7 +115221,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG3,
     ...actualConfig
   };
-  const statePath = path130.join(directory, ".swarm", "turbo-state.json");
+  const statePath = path131.join(directory, ".swarm", "turbo-state.json");
   if (!fs92.existsSync(statePath)) {
     return {
       ok: false,
@@ -114552,7 +115409,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path130.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path131.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
       const content = fs92.readFileSync(evidencePath, "utf-8");
@@ -114704,13 +115561,13 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs93 from "node:fs";
-import * as path131 from "node:path";
+import * as path132 from "node:path";
 async function runDriftGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let driftCheckEnabled = true;
   let driftHasSpecMd = false;
   try {
-    const specMdPath = path131.join(dir, ".swarm", "spec.md");
+    const specMdPath = path132.join(dir, ".swarm", "spec.md");
     driftHasSpecMd = fs93.existsSync(specMdPath);
     const gatePlan = await loadPlan(dir);
     if (gatePlan) {
@@ -114738,7 +115595,7 @@ async function runDriftGate(ctx) {
   }
   let phaseType;
   try {
-    const planPath = path131.join(dir, ".swarm", "plan.json");
+    const planPath = path132.join(dir, ".swarm", "plan.json");
     if (fs93.existsSync(planPath)) {
       const planRaw = fs93.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
@@ -114757,7 +115614,7 @@ async function runDriftGate(ctx) {
     };
   }
   try {
-    const driftEvidencePath = path131.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+    const driftEvidencePath = path132.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
     let driftVerdictFound = false;
     let driftVerdictApproved = false;
     try {
@@ -114793,7 +115650,7 @@ async function runDriftGate(ctx) {
         let incompleteTaskCount = 0;
         let planParseable = false;
         try {
-          const planPath = path131.join(dir, ".swarm", "plan.json");
+          const planPath = path132.join(dir, ".swarm", "plan.json");
           if (fs93.existsSync(planPath)) {
             const planRaw = fs93.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
@@ -114875,7 +115732,7 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs94 from "node:fs";
-import * as path132 from "node:path";
+import * as path133 from "node:path";
 async function runFinalCouncilGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let finalCouncilEnabled = false;
@@ -114892,7 +115749,7 @@ async function runFinalCouncilGate(ctx) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.final_council === true) {
             finalCouncilEnabled = true;
-            const fcPath = path132.join(dir, ".swarm", "evidence", "final-council.json");
+            const fcPath = path133.join(dir, ".swarm", "evidence", "final-council.json");
             let fcVerdictFound = false;
             let _fcVerdict;
             try {
@@ -115022,7 +115879,7 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs95 from "node:fs";
-import * as path133 from "node:path";
+import * as path134 from "node:path";
 async function runHallucinationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
@@ -115035,7 +115892,7 @@ async function runHallucinationGate(ctx) {
         const overrides = session?.qaGateSessionOverrides ?? {};
         const effective = getEffectiveGates(profile, overrides);
         if (effective.hallucination_guard === true) {
-          const hgPath = path133.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+          const hgPath = path134.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
           let hgVerdictFound = false;
           let hgVerdictApproved = false;
           try {
@@ -115098,7 +115955,7 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs96 from "node:fs";
-import * as path134 from "node:path";
+import * as path135 from "node:path";
 async function runMutationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
@@ -115111,7 +115968,7 @@ async function runMutationGate(ctx) {
         const overrides = session?.qaGateSessionOverrides ?? {};
         const effective = getEffectiveGates(profile, overrides);
         if (effective.mutation_test === true) {
-          const mgPath = path134.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+          const mgPath = path135.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
           let mgVerdictFound = false;
           let mgVerdict;
           try {
@@ -115174,7 +116031,7 @@ init_qa_gate_profile();
 init_manager();
 init_state();
 import * as fs97 from "node:fs";
-import * as path135 from "node:path";
+import * as path136 from "node:path";
 async function runPhaseCouncilGate(ctx) {
   const { phase, dir, sessionID, pluginConfig, agentsDispatched, safeWarn } = ctx;
   let councilModeEnabled = false;
@@ -115189,7 +116046,7 @@ async function runPhaseCouncilGate(ctx) {
         const effective = getEffectiveGates(profile, overrides);
         if (effective.council_mode === true) {
           councilModeEnabled = true;
-          const pcPath = path135.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+          const pcPath = path136.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
           let pcVerdictFound = false;
           let _pcVerdict;
           let pcQuorumSize;
@@ -115704,7 +116561,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path137.basename(dir);
+      const projectName = path138.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -116147,7 +117004,7 @@ init_utils();
 init_bun_compat();
 init_create_tool();
 import * as fs100 from "node:fs";
-import * as path138 from "node:path";
+import * as path139 from "node:path";
 var MAX_OUTPUT_BYTES6 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -116175,16 +117032,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs100.existsSync(path138.join(cwd, "package.json"))) {
+  if (fs100.existsSync(path139.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs100.existsSync(path138.join(cwd, "pyproject.toml")) || fs100.existsSync(path138.join(cwd, "requirements.txt"))) {
+  if (fs100.existsSync(path139.join(cwd, "pyproject.toml")) || fs100.existsSync(path139.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs100.existsSync(path138.join(cwd, "Cargo.toml"))) {
+  if (fs100.existsSync(path139.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs100.existsSync(path138.join(cwd, "go.mod"))) {
+  if (fs100.existsSync(path139.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -116193,13 +117050,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs100.existsSync(path138.join(cwd, "Gemfile")) || fs100.existsSync(path138.join(cwd, "Gemfile.lock"))) {
+  if (fs100.existsSync(path139.join(cwd, "Gemfile")) || fs100.existsSync(path139.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs100.existsSync(path138.join(cwd, "pubspec.yaml"))) {
+  if (fs100.existsSync(path139.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs100.existsSync(path138.join(cwd, "composer.lock"))) {
+  if (fs100.existsSync(path139.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -116212,7 +117069,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve46) => setTimeout(() => resolve46("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
@@ -116332,7 +117189,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve46) => setTimeout(() => resolve46("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
@@ -116460,7 +117317,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve46) => setTimeout(() => resolve46("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -116584,7 +117441,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve46) => setTimeout(() => resolve46("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -116717,7 +117574,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve46) => setTimeout(() => resolve46("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -116833,7 +117690,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve46) => setTimeout(() => resolve46("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -116978,7 +117835,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve46) => setTimeout(() => resolve46("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -117093,7 +117950,7 @@ async function runComposerAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve46) => setTimeout(() => resolve46("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -117336,7 +118193,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs101 from "node:fs";
-import * as path139 from "node:path";
+import * as path140 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -117459,7 +118316,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path139.basename(filePath);
+  const filename = path140.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -117476,7 +118333,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path139.basename(filePath);
+    const filename = path140.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -117485,7 +118342,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path139.extname(filePath).toLowerCase();
+  const ext = path140.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -117732,9 +118589,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path139.isAbsolute(filePath) ? filePath : path139.resolve(directory, filePath);
-    const resolvedDirectory = path139.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path139.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path140.isAbsolute(filePath) ? filePath : path140.resolve(directory, filePath);
+    const resolvedDirectory = path140.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path140.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs101.existsSync(fullPath)) {
@@ -117743,7 +118600,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path139.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path140.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -117816,7 +118673,7 @@ var placeholder_scan = createSwarmTool({
 
 // src/tools/pre-check-batch.ts
 import * as fs105 from "node:fs";
-import * as path143 from "node:path";
+import * as path144 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -117957,7 +118814,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs104 from "node:fs";
-import * as path142 from "node:path";
+import * as path143 from "node:path";
 import { extname as extname20 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -118673,7 +119530,7 @@ function executeRulesSync(filePath, content, language) {
 // src/sast/semgrep.ts
 import * as child_process9 from "node:child_process";
 import * as fs102 from "node:fs";
-import * as path140 from "node:path";
+import * as path141 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
@@ -118754,7 +119611,7 @@ function mapSemgrepSeverity(severity) {
   }
 }
 async function executeWithTimeout(command, args2, options) {
-  return new Promise((resolve47) => {
+  return new Promise((resolve48) => {
     const child = child_process9.spawn(command, args2, {
       shell: false,
       cwd: options.cwd
@@ -118763,7 +119620,7 @@ async function executeWithTimeout(command, args2, options) {
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve47({
+      resolve48({
         stdout,
         stderr: "Process timed out",
         exitCode: 124
@@ -118777,7 +119634,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve47({
+      resolve48({
         stdout,
         stderr,
         exitCode: code ?? 0
@@ -118785,7 +119642,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve47({
+      resolve48({
         stdout,
         stderr: err2.message,
         exitCode: 1
@@ -118860,7 +119717,7 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path140.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path141.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
@@ -118881,24 +119738,24 @@ init_create_tool();
 init_utils2();
 import * as crypto11 from "node:crypto";
 import * as fs103 from "node:fs";
-import * as path141 from "node:path";
+import * as path142 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 = path141.isAbsolute(file3) ? file3 : path141.resolve(directory, file3);
-  const rel = path141.relative(path141.resolve(directory), resolved);
+  const resolved = path142.isAbsolute(file3) ? file3 : path142.resolve(directory, file3);
+  const rel = path142.relative(path142.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path141.join("evidence", String(phase), "sast-baseline.json");
+  return path142.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path141.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path142.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path141.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path142.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -118984,7 +119841,7 @@ async function acquireLock2(lockPath) {
       };
     } catch {
       if (attempt < LOCK_RETRY_DELAYS_MS.length) {
-        await new Promise((resolve48) => setTimeout(resolve48, LOCK_RETRY_DELAYS_MS[attempt]));
+        await new Promise((resolve49) => setTimeout(resolve49, LOCK_RETRY_DELAYS_MS[attempt]));
       }
     }
   }
@@ -119019,8 +119876,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs103.mkdirSync(path141.dirname(baselinePath), { recursive: true });
-  fs103.mkdirSync(path141.dirname(tempPath), { recursive: true });
+  fs103.mkdirSync(path142.dirname(baselinePath), { recursive: true });
+  fs103.mkdirSync(path142.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
@@ -119293,9 +120150,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path142.isAbsolute(filePath) ? filePath : path142.resolve(directory, filePath);
-    const resolvedDirectory = path142.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path142.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path143.isAbsolute(filePath) ? filePath : path143.resolve(directory, filePath);
+    const resolvedDirectory = path143.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path143.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -119610,20 +120467,20 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path143.win32.resolve(inputPath);
-  } else if (path143.isAbsolute(inputPath)) {
-    resolved = path143.resolve(inputPath);
+    resolved = path144.win32.resolve(inputPath);
+  } else if (path144.isAbsolute(inputPath)) {
+    resolved = path144.resolve(inputPath);
   } else {
-    resolved = path143.resolve(baseDir, inputPath);
+    resolved = path144.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path143.resolve(workspaceDir);
-  let relative27;
+  const workspaceResolved = path144.resolve(workspaceDir);
+  let relative28;
   if (isWinAbs) {
-    relative27 = path143.win32.relative(workspaceResolved, resolved);
+    relative28 = path144.win32.relative(workspaceResolved, resolved);
   } else {
-    relative27 = path143.relative(workspaceResolved, resolved);
+    relative28 = path144.relative(workspaceResolved, resolved);
   }
-  if (relative27.startsWith("..")) {
+  if (relative28.startsWith("..")) {
     return "path traversal detected";
   }
   return null;
@@ -119686,7 +120543,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path143.resolve(file3);
+    const resolvedPath = path144.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -119843,7 +120700,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path143.resolve(file3);
+      const resolvedPath = path144.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -119861,7 +120718,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path143.extname(file3).toLowerCase();
+      const ext = path144.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -120080,7 +120937,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path143.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path144.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -120131,7 +120988,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path143.resolve(directory, file3));
+    changedFiles.push(path144.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -120332,9 +121189,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path143.resolve(typedArgs.directory);
-    const workspaceAnchor = path143.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path143.sep)) {
+    const resolvedDirectory = path144.resolve(typedArgs.directory);
+    const workspaceAnchor = path144.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path144.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,
@@ -120386,7 +121243,7 @@ var pre_check_batch = createSwarmTool({
 
 // src/tools/repo-map.ts
 init_zod();
-import * as path144 from "node:path";
+import * as path145 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -120411,7 +121268,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path144.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path145.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -120434,8 +121291,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path144.isAbsolute(normalized)) {
-    const rel = path144.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path145.isAbsolute(normalized)) {
+    const rel = path145.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -120581,7 +121438,7 @@ var repo_map = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs106 from "node:fs";
-import * as path145 from "node:path";
+import * as path146 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHOULD", "SHALL"];
@@ -120650,7 +121507,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path145.join(evidenceDir, entry);
+    const entryPath = path146.join(evidenceDir, entry);
     try {
       const stat9 = fs106.statSync(entryPath);
       if (!stat9.isDirectory()) {
@@ -120666,11 +121523,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path145.join(entryPath, "evidence.json");
+    const evidenceFilePath = path146.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path145.resolve(evidenceFilePath);
-      const evidenceDirResolved = path145.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path145.sep)) {
+      const resolvedPath = path146.resolve(evidenceFilePath);
+      const evidenceDirResolved = path146.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path146.sep)) {
         continue;
       }
       const stat9 = fs106.lstatSync(evidenceFilePath);
@@ -120704,7 +121561,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(path145.resolve(cwd, file3));
+                  touchedFiles.add(path146.resolve(cwd, file3));
                 }
               }
             }
@@ -120717,8 +121574,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path145.resolve(filePath);
-    const cwdResolved = path145.resolve(cwd);
+    const resolvedPath = path146.resolve(filePath);
+    const cwdResolved = path146.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -120852,7 +121709,7 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path145.join(cwd, SPEC_FILE);
+    const specPath = path146.join(cwd, SPEC_FILE);
     let specContent;
     try {
       specContent = fs106.readFileSync(specPath, "utf-8");
@@ -120879,7 +121736,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path145.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path146.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -120905,7 +121762,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path145.join(evidenceDir, reportFilename);
+    const reportPath = path146.join(evidenceDir, reportFilename);
     try {
       if (!fs106.existsSync(evidenceDir)) {
         fs106.mkdirSync(evidenceDir, { recursive: true });
@@ -120995,7 +121852,7 @@ init_qa_gate_profile();
 init_file_locks();
 import * as crypto12 from "node:crypto";
 import * as fs107 from "node:fs";
-import * as path146 from "node:path";
+import * as path147 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -121076,8 +121933,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path146.resolve(args2.working_directory);
-    const resolvedRoot = path146.resolve(fallbackDir);
+    const resolvedTarget = path147.resolve(args2.working_directory);
+    const resolvedRoot = path147.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs107.accessSync(resolvedRoot, fs107.constants.F_OK);
@@ -121086,7 +121943,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path146.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path147.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -121102,7 +121959,7 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path146.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path147.join(targetWorkspace, ".swarm", "spec.md");
     try {
       const stat9 = await fs107.promises.stat(specPath);
       specMtime = stat9.mtime.toISOString();
@@ -121118,7 +121975,7 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path146.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path147.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs107.promises.readFile(contextPath, "utf8");
@@ -121408,7 +122265,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path146.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path147.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -121431,7 +122288,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path146.join(dir, ".swarm", "plan.json"),
+        plan_path: path147.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -121498,7 +122355,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs108 from "node:fs";
-import * as path147 from "node:path";
+import * as path148 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -122348,7 +123205,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs108.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path147.join(dir, entry.name);
+        const fullPath = path148.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -122357,7 +123214,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path147.relative(rootDir, fullPath));
+              manifestFiles.push(path148.relative(rootDir, fullPath));
               break;
             }
           }
@@ -122375,11 +123232,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs108.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path147.join(dir, entry.name);
+        const fullPath = path148.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path147.relative(workingDir, fullPath));
+              found.push(path148.relative(workingDir, fullPath));
               break;
             }
           }
@@ -122392,11 +123249,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path147.dirname(file3);
+    let currentDir = path148.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path147.sep) {
-        dirs.add(path147.join(workingDir, currentDir));
-        const parent = path147.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path148.sep) {
+        dirs.add(path148.join(workingDir, currentDir));
+        const parent = path148.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -122480,7 +123337,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path147.isAbsolute(relativeOutputDir) ? relativeOutputDir : path147.join(workingDir, relativeOutputDir);
+    const outputDir = path148.isAbsolute(relativeOutputDir) ? relativeOutputDir : path148.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -122503,7 +123360,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path147.isAbsolute(manifestFile) ? manifestFile : path147.join(workingDir, manifestFile);
+        const fullPath = path148.isAbsolute(manifestFile) ? manifestFile : path148.join(workingDir, manifestFile);
         if (!fs108.existsSync(fullPath)) {
           continue;
         }
@@ -122520,7 +123377,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path147.join(outputDir, filename);
+    const outputPath = path148.join(outputDir, filename);
     fs108.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -122565,7 +123422,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs109 from "node:fs";
-import * as path148 from "node:path";
+import * as path149 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -122597,12 +123454,12 @@ function normalizePath5(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path148.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path148.sep) ? cwd : cwd + path148.sep;
+    const resolvedPath = path149.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path149.sep) ? cwd : cwd + path149.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path148.extname(resolvedPath).toLowerCase();
+    const ext = path149.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -122616,7 +123473,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path148.resolve(cwd, candidate);
+    const candidatePath = path149.resolve(cwd, candidate);
     if (fs109.existsSync(candidatePath)) {
       const stats = fs109.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -122628,7 +123485,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs109.readFileSync(specFile, "utf-8");
-  const ext = path148.extname(specFile).toLowerCase();
+  const ext = path149.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -122704,7 +123561,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path148.join(dir, entry.name);
+      const fullPath = path149.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -122714,7 +123571,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path148.extname(entry.name).toLowerCase();
+        const ext = path149.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -122883,7 +123740,7 @@ init_bun_compat();
 init_path_security();
 init_create_tool();
 import * as fs110 from "node:fs";
-import * as path149 from "node:path";
+import * as path150 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -122906,24 +123763,24 @@ function matchesGlobs(filePath, globs) {
     return true;
   return globs.some((glob) => globMatch(glob, filePath));
 }
-var WINDOWS_RESERVED_NAMES3 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
-function containsWindowsAttacks3(str) {
+var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
+function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
     return true;
   const parts2 = str.split(/[/\\]/);
   for (const part of parts2) {
-    if (WINDOWS_RESERVED_NAMES3.test(part))
+    if (WINDOWS_RESERVED_NAMES4.test(part))
       return true;
   }
   return false;
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path149.resolve(workspace, filePath);
+    const resolvedPath = path150.resolve(workspace, filePath);
     const realWorkspace = fs110.realpathSync(workspace);
     const realResolvedPath = fs110.realpathSync(resolvedPath);
-    const relativePath = path149.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path149.isAbsolute(relativePath)) {
+    const relativePath = path150.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path150.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -122936,11 +123793,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path149.delimiter)) {
+  for (const dir of searchPath.split(path150.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path149.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path150.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs110.existsSync(candidate))
       return candidate;
   }
@@ -122995,7 +123852,7 @@ async function ripgrepSearch(opts) {
       stderr: "pipe",
       cwd: opts.workspace
     });
-    const timeout = new Promise((resolve54) => setTimeout(() => resolve54("timeout"), REGEX_TIMEOUT_MS));
+    const timeout = new Promise((resolve55) => setTimeout(() => resolve55("timeout"), REGEX_TIMEOUT_MS));
     const exitPromise = proc.exited;
     const result = await Promise.race([exitPromise, timeout]);
     if (result === "timeout") {
@@ -123070,8 +123927,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs110.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path149.join(dir, entry.name);
-      const relativePath = path149.relative(workspace, fullPath);
+      const fullPath = path150.join(dir, entry.name);
+      const relativePath = path150.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -123112,7 +123969,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path149.join(opts.workspace, file3);
+    const fullPath = path150.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -123225,14 +124082,14 @@ var search = createSwarmTool({
         message: "Exclude pattern contains path traversal sequence"
       }, null, 2);
     }
-    if (include && containsWindowsAttacks3(include)) {
+    if (include && containsWindowsAttacks4(include)) {
       return JSON.stringify({
         error: true,
         type: "path-escape",
         message: "Include pattern contains invalid Windows-specific sequence"
       }, null, 2);
     }
-    if (exclude && containsWindowsAttacks3(exclude)) {
+    if (exclude && containsWindowsAttacks4(exclude)) {
       return JSON.stringify({
         error: true,
         type: "path-escape",
@@ -123525,7 +124382,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir24, rename as rename10, writeFile as writeFile19 } from "node:fs/promises";
-import * as path150 from "node:path";
+import * as path151 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.",
@@ -123566,8 +124423,8 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path150.join(directory, ".swarm", "spec.md");
-    await mkdir24(path150.dirname(target), { recursive: true });
+    const target = path151.join(directory, ".swarm", "spec.md");
+    await mkdir24(path151.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -123596,14 +124453,14 @@ ${content}
 init_zod();
 init_loader();
 import {
-  existsSync as existsSync84,
-  mkdirSync as mkdirSync35,
-  readFileSync as readFileSync71,
-  renameSync as renameSync21,
-  unlinkSync as unlinkSync19,
-  writeFileSync as writeFileSync29
+  existsSync as existsSync85,
+  mkdirSync as mkdirSync36,
+  readFileSync as readFileSync72,
+  renameSync as renameSync22,
+  unlinkSync as unlinkSync20,
+  writeFileSync as writeFileSync30
 } from "node:fs";
-import path151 from "node:path";
+import path152 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -123733,9 +124590,9 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path151.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path152.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
-    const raw = readFileSync71(mutationGatePath, "utf-8");
+    const raw = readFileSync72(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
     const gateEntry = (parsed.entries ?? []).find((entry) => entry?.type === "mutation-gate");
     if (!gateEntry) {
@@ -123795,9 +124652,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis) {
-  const evidenceDir = path151.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
-  mkdirSync35(evidenceDir, { recursive: true });
-  const evidenceFile = path151.join(evidenceDir, "phase-council.json");
+  const evidenceDir = path152.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  mkdirSync36(evidenceDir, { recursive: true });
+  const evidenceFile = path152.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -123830,11 +124687,11 @@ function writePhaseCouncilEvidence(workingDir, synthesis) {
   };
   const tempFile = `${evidenceFile}.tmp-${Date.now()}`;
   try {
-    writeFileSync29(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
-    renameSync21(tempFile, evidenceFile);
+    writeFileSync30(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
+    renameSync22(tempFile, evidenceFile);
   } finally {
-    if (existsSync84(tempFile)) {
-      unlinkSync19(tempFile);
+    if (existsSync85(tempFile)) {
+      unlinkSync20(tempFile);
     }
   }
 }
@@ -123859,28 +124716,28 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs111 from "node:fs";
-import * as path152 from "node:path";
-var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
-function containsWindowsAttacks4(str) {
+import * as path153 from "node:path";
+var WINDOWS_RESERVED_NAMES5 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
+function containsWindowsAttacks5(str) {
   if (/:[^\\/]/.test(str))
     return true;
   const parts2 = str.split(/[/\\]/);
   for (const part of parts2) {
-    if (WINDOWS_RESERVED_NAMES4.test(part))
+    if (WINDOWS_RESERVED_NAMES5.test(part))
       return true;
   }
   return false;
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path152.resolve(workspace, filePath);
+    const resolvedPath = path153.resolve(workspace, filePath);
     if (!fs111.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs111.realpathSync(workspace);
     const realResolvedPath = fs111.realpathSync(resolvedPath);
-    const relativePath = path152.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path152.isAbsolute(relativePath)) {
+    const relativePath = path153.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path153.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -123895,7 +124752,7 @@ function validateFilePath(filePath, workspace) {
     return false;
   if (containsControlChars(filePath))
     return false;
-  if (containsWindowsAttacks4(filePath))
+  if (containsWindowsAttacks5(filePath))
     return false;
   return isPathInWorkspace4(filePath, workspace);
 }
@@ -123908,12 +124765,12 @@ function findContextMatch(content, contextBefore, contextAfter, oldContent) {
   if (contextBefore && contextBefore.length > 0) {
     for (let i2 = 0;i2 <= lines.length - contextBefore.length; i2++) {
       const slice = lines.slice(i2, i2 + contextBefore.length);
-      if (arraysEqual(slice, contextBefore)) {
+      if (arraysEqual2(slice, contextBefore)) {
         const afterStart = i2 + contextBefore.length;
         if (contextAfter && contextAfter.length > 0) {
           for (let j = afterStart;j <= lines.length - contextAfter.length; j++) {
             const afterSlice = lines.slice(j, j + contextAfter.length);
-            if (arraysEqual(afterSlice, contextAfter)) {
+            if (arraysEqual2(afterSlice, contextAfter)) {
               if (j === afterStart) {
                 return {
                   startLineIndex: i2,
@@ -123926,7 +124783,7 @@ function findContextMatch(content, contextBefore, contextAfter, oldContent) {
                   const oldContentLines = oldContent.split(`
 `);
                   const betweenLines = lines.slice(afterStart, j);
-                  if (arraysEqual(betweenLines, oldContentLines)) {
+                  if (arraysEqual2(betweenLines, oldContentLines)) {
                     return {
                       startLineIndex: i2,
                       endLineIndex: j - 1,
@@ -123952,7 +124809,7 @@ function findContextMatch(content, contextBefore, contextAfter, oldContent) {
 `);
             for (let k = afterStart;k <= lines.length - oldContentLines.length; k++) {
               const candidate = lines.slice(k, k + oldContentLines.length);
-              if (arraysEqual(candidate, oldContentLines)) {
+              if (arraysEqual2(candidate, oldContentLines)) {
                 return {
                   startLineIndex: i2,
                   endLineIndex: k + oldContentLines.length - 1,
@@ -123976,7 +124833,7 @@ function findContextMatch(content, contextBefore, contextAfter, oldContent) {
   } else if (contextAfter && contextAfter.length > 0) {
     for (let j = 0;j <= lines.length - contextAfter.length; j++) {
       const afterSlice = lines.slice(j, j + contextAfter.length);
-      if (arraysEqual(afterSlice, contextAfter)) {
+      if (arraysEqual2(afterSlice, contextAfter)) {
         return {
           startLineIndex: 0,
           endLineIndex: j - 1,
@@ -123988,7 +124845,7 @@ function findContextMatch(content, contextBefore, contextAfter, oldContent) {
   }
   return null;
 }
-function arraysEqual(a, b) {
+function arraysEqual2(a, b) {
   if (a.length !== b.length)
     return false;
   for (let i2 = 0;i2 < a.length; i2++) {
@@ -124088,7 +124945,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path152.resolve(directory, change.file);
+      const fullPath = path153.resolve(directory, change.file);
       if (!fs111.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -124492,7 +125349,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs112 from "node:fs";
-import * as path153 from "node:path";
+import * as path154 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -124558,7 +125415,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path153.extname(file3.path).toLowerCase();
+      const ext = path154.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -124571,7 +125428,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path153.isAbsolute(filePath) ? filePath : path153.join(directory, filePath);
+    const fullPath = path154.isAbsolute(filePath) ? filePath : path154.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -124620,7 +125477,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path153.extname(filePath).toLowerCase();
+      const ext = path154.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -124719,7 +125576,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs113 from "node:fs";
-import * as path154 from "node:path";
+import * as path155 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -124785,9 +125642,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path154.resolve(paths);
-    const normalizedCwd = path154.resolve(cwd);
-    const normalizedResolved = path154.resolve(resolvedPath);
+    const resolvedPath = path155.resolve(paths);
+    const normalizedCwd = path155.resolve(cwd);
+    const normalizedResolved = path155.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -124803,7 +125660,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path154.extname(filePath).toLowerCase();
+  const ext = path155.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
@@ -124818,7 +125675,7 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path154.join(dir, entry);
+    const fullPath = path155.join(dir, entry);
     let stat9;
     try {
       stat9 = fs113.statSync(fullPath);
@@ -124930,7 +125787,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path154.extname(scanPath)}`,
+          error: `unsupported file extension: ${path155.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -124980,17 +125837,17 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs117 from "node:fs";
-import * as path158 from "node:path";
+import * as path159 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
 import * as fs115 from "node:fs";
-import * as path156 from "node:path";
+import * as path157 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs114 from "node:fs";
-import * as path155 from "node:path";
+import * as path156 from "node:path";
 var _internals67 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
@@ -125064,10 +125921,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path155.isAbsolute(excludeRelPath) ? excludeRelPath : path155.join(directory, excludeRelPath);
+    const excludePath = path156.isAbsolute(excludeRelPath) ? excludeRelPath : path156.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs114.mkdirSync(path155.dirname(excludePath), { recursive: true });
+        fs114.mkdirSync(path156.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
           existing = fs114.readFileSync(excludePath, "utf8");
@@ -125111,7 +125968,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 var _internals68 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path156.join(directory, ".swarm", "plan.json");
+    const planPath = path157.join(directory, ".swarm", "plan.json");
     if (!fs115.existsSync(planPath))
       return null;
     const raw = fs115.readFileSync(planPath, "utf-8");
@@ -125217,7 +126074,7 @@ init_telemetry();
 // src/turbo/lean/task-completion.ts
 init_file_locks();
 import * as fs116 from "node:fs";
-import * as path157 from "node:path";
+import * as path158 from "node:path";
 var _internals69 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
@@ -125236,7 +126093,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path157.basename(file3);
+    const fileName = path158.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -125248,7 +126105,7 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path157.join(directory, ".swarm", "turbo-state.json");
+    const statePath = path158.join(directory, ".swarm", "turbo-state.json");
     if (!fs116.existsSync(statePath)) {
       return {
         ok: false,
@@ -125332,11 +126189,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path157.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path157.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path157.resolve(evidencePath);
-  const resolvedDir = path157.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path157.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path158.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path158.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path158.resolve(evidencePath);
+  const resolvedDir = path158.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path158.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -125376,7 +126233,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path157.join(directory, ".swarm", "plan.json");
+    const planPath = path158.join(directory, ".swarm", "plan.json");
     const planRaw = fs116.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
@@ -125460,7 +126317,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path158.basename(file3);
+    const fileName = path159.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -125499,7 +126356,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path158.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path159.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs117.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -125577,7 +126434,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path158.join(resolvedDir, ".swarm", "plan.json");
+        const planPath = path159.join(resolvedDir, ".swarm", "plan.json");
         const planRaw = fs117.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -125813,7 +126670,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   directory = resolveResult.directory;
-  const planPath = path158.join(directory, ".swarm", "plan.json");
+  const planPath = path159.join(directory, ".swarm", "plan.json");
   if (!fs117.existsSync(planPath)) {
     return {
       success: false,
@@ -125822,9 +126679,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs117.realpathSync(path158.resolve(directory));
-    const canonicalRoot = fs117.realpathSync(path158.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path158.sep)) {
+    const canonicalDir = fs117.realpathSync(path159.resolve(directory));
+    const canonicalRoot = fs117.realpathSync(path159.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path159.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.`,
@@ -125836,8 +126693,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path158.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs117.mkdirSync(path158.dirname(evidencePath), { recursive: true });
+      const evidencePath = path159.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs117.mkdirSync(path159.dirname(evidencePath), { recursive: true });
       const fd = fs117.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -125861,7 +126718,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath2 = path158.join(directory, ".swarm", "plan.json");
+      const planPath2 = path159.join(directory, ".swarm", "plan.json");
       const planRaw = fs117.readFileSync(planPath2, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -126090,7 +126947,7 @@ init_utils2();
 init_redaction();
 import { createHash as createHash12 } from "node:crypto";
 import { appendFile as appendFile14, mkdir as mkdir25 } from "node:fs/promises";
-import * as path159 from "node:path";
+import * as path160 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) {
@@ -126098,7 +126955,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 mkdir25(path159.dirname(filePath), { recursive: true });
+    await mkdir25(path160.dirname(filePath), { recursive: true });
     await appendFile14(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -126295,7 +127152,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path160 from "node:path";
+import * as path161 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -126359,7 +127216,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, path160.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
+        const result = await curateAndStoreSwarm(lessons, path161.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
         knowledgeProposed = result.stored;
       }
     } catch {}
@@ -126395,7 +127252,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs118 from "node:fs";
-import path161 from "node:path";
+import path162 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -126443,7 +127300,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path161.join("evidence", String(phase), filename);
+  const relativePath = path162.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126454,10 +127311,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path161.dirname(validatedPath);
+  const evidenceDir = path162.dirname(validatedPath);
   try {
     await fs118.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path161.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path162.join(evidenceDir, `.${filename}.tmp`);
     await fs118.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs118.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -126554,7 +127411,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs119 from "node:fs";
-import path162 from "node:path";
+import path163 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -126642,7 +127499,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path162.join("evidence", filename);
+  const relativePath = path163.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126656,10 +127513,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path162.dirname(validatedPath);
+  const evidenceDir = path163.dirname(validatedPath);
   try {
     await fs119.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path162.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path163.join(evidenceDir, `.${filename}.tmp`);
     await fs119.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs119.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -126719,7 +127576,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs120 from "node:fs";
-import path163 from "node:path";
+import path164 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -126767,7 +127624,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path163.join("evidence", String(phase), filename);
+  const relativePath = path164.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126778,10 +127635,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path163.dirname(validatedPath);
+  const evidenceDir = path164.dirname(validatedPath);
   try {
     await fs120.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path163.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path164.join(evidenceDir, `.${filename}.tmp`);
     await fs120.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs120.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -126831,7 +127688,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs121 from "node:fs";
-import path164 from "node:path";
+import path165 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -126905,7 +127762,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path164.join("evidence", String(phase), filename);
+  const relativePath = path165.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126916,10 +127773,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path164.dirname(validatedPath);
+  const evidenceDir = path165.dirname(validatedPath);
   try {
     await fs121.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path164.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path165.join(evidenceDir, `.${filename}.tmp`);
     await fs121.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs121.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -127055,7 +127912,8 @@ var TOOL_MANIFEST = defineHandlers({
   lean_turbo_runner_status: () => lean_turbo_runner_status,
   lean_turbo_review: () => lean_turbo_review,
   lean_turbo_run_phase: () => lean_turbo_run_phase,
-  lean_turbo_status: () => lean_turbo_status
+  lean_turbo_status: () => lean_turbo_status,
+  apply_patch: () => applyPatch
 });
 
 // src/tools/plugin-registration.ts
@@ -127366,7 +128224,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 = path166.resolve(ctx.directory, ".swarm");
+    const swarmDir = path167.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -127880,7 +128738,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path166.basename(path166.dirname(s.skillPath));
+                    desc = path167.basename(path167.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -127890,7 +128748,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path166.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path167.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {