opencode-swarm 6.36.0 → 6.38.0

package/dist/index.js

@@ -14916,7 +14916,7 @@ var init_schema = __esm(() => {
     max_encounter_score: exports_external.number().min(1).max(20).default(10)
   });
   CuratorConfigSchema = exports_external.object({
-    enabled: exports_external.boolean().default(false),
+    enabled: exports_external.boolean().default(true),
     init_enabled: exports_external.boolean().default(true),
     phase_enabled: exports_external.boolean().default(true),
     max_summary_tokens: exports_external.number().min(500).max(8000).default(2000),
@@ -30051,6 +30051,10 @@ var init_create_tool = __esm(() => {
 });
 
 // src/tools/checkpoint.ts
+var exports_checkpoint = {};
+__export(exports_checkpoint, {
+  checkpoint: () => checkpoint
+});
 import { spawnSync } from "child_process";
 import * as fs8 from "fs";
 import * as path10 from "path";
@@ -34195,7 +34199,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   return false;
 }
 function containsControlChars(str) {
-  return /[\0\r]/.test(str);
+  return /[\0\t\r\n]/.test(str);
 }
 function validateDirectoryInput(dir) {
   if (!dir || dir.length === 0) {
@@ -36647,11 +36651,11 @@ __export(exports_curator_drift, {
   readPriorDriftReports: () => readPriorDriftReports,
   buildDriftInjectionText: () => buildDriftInjectionText
 });
-import * as fs26 from "fs";
-import * as path37 from "path";
+import * as fs27 from "fs";
+import * as path38 from "path";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path37.join(directory, ".swarm");
-  const entries = await fs26.promises.readdir(swarmDir).catch(() => null);
+  const swarmDir = path38.join(directory, ".swarm");
+  const entries = await fs27.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
   const reportFiles = entries.filter((name2) => name2.startsWith(DRIFT_REPORT_PREFIX) && name2.endsWith(".json")).sort();
@@ -36677,10 +36681,10 @@ async function readPriorDriftReports(directory) {
 async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
-  const swarmDir = path37.dirname(filePath);
-  await fs26.promises.mkdir(swarmDir, { recursive: true });
+  const swarmDir = path38.dirname(filePath);
+  await fs27.promises.mkdir(swarmDir, { recursive: true });
   try {
-    await fs26.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs27.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
   } catch (err2) {
     throw new Error(`[curator-drift] Failed to write drift report to ${filePath}: ${String(err2)}`);
   }
@@ -38247,8 +38251,8 @@ ${JSON.stringify(symbolNames, null, 2)}`);
       var moduleRtn;
       var Module = moduleArg;
       var readyPromiseResolve, readyPromiseReject;
-      var readyPromise = new Promise((resolve17, reject) => {
-        readyPromiseResolve = resolve17;
+      var readyPromise = new Promise((resolve15, reject) => {
+        readyPromiseResolve = resolve15;
         readyPromiseReject = reject;
       });
       var ENVIRONMENT_IS_WEB = typeof window == "object";
@@ -38270,11 +38274,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path50) {
+      function locateFile(path45) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path50, scriptDirectory);
+          return Module["locateFile"](path45, scriptDirectory);
         }
-        return scriptDirectory + path50;
+        return scriptDirectory + path45;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -38328,13 +38332,13 @@ ${JSON.stringify(symbolNames, null, 2)}`);
           }
           readAsync = /* @__PURE__ */ __name(async (url3) => {
             if (isFileURI(url3)) {
-              return new Promise((resolve17, reject) => {
+              return new Promise((resolve15, reject) => {
                 var xhr = new XMLHttpRequest;
                 xhr.open("GET", url3, true);
                 xhr.responseType = "arraybuffer";
                 xhr.onload = () => {
                   if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                    resolve17(xhr.response);
+                    resolve15(xhr.response);
                     return;
                   }
                   reject(xhr.status);
@@ -38495,10 +38499,10 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         return getBinarySync(binaryFile);
       }
       __name(getWasmBinary, "getWasmBinary");
-      async function instantiateArrayBuffer(binaryFile, imports2) {
+      async function instantiateArrayBuffer(binaryFile, imports) {
         try {
           var binary2 = await getWasmBinary(binaryFile);
-          var instance2 = await WebAssembly.instantiate(binary2, imports2);
+          var instance2 = await WebAssembly.instantiate(binary2, imports);
           return instance2;
         } catch (reason) {
           err(`failed to asynchronously prepare wasm: ${reason}`);
@@ -38506,20 +38510,20 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         }
       }
       __name(instantiateArrayBuffer, "instantiateArrayBuffer");
-      async function instantiateAsync(binary2, binaryFile, imports2) {
+      async function instantiateAsync(binary2, binaryFile, imports) {
         if (!binary2 && typeof WebAssembly.instantiateStreaming == "function" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
           try {
             var response = fetch(binaryFile, {
               credentials: "same-origin"
             });
-            var instantiationResult = await WebAssembly.instantiateStreaming(response, imports2);
+            var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
             return instantiationResult;
           } catch (reason) {
             err(`wasm streaming compile failed: ${reason}`);
             err("falling back to ArrayBuffer instantiation");
           }
         }
-        return instantiateArrayBuffer(binaryFile, imports2);
+        return instantiateArrayBuffer(binaryFile, imports);
       }
       __name(instantiateAsync, "instantiateAsync");
       function getWasmImports() {
@@ -38554,10 +38558,10 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         __name(receiveInstantiationResult, "receiveInstantiationResult");
         var info2 = getWasmImports();
         if (Module["instantiateWasm"]) {
-          return new Promise((resolve17, reject) => {
+          return new Promise((resolve15, reject) => {
             Module["instantiateWasm"](info2, (mod, inst) => {
               receiveInstance(mod, inst);
-              resolve17(mod.exports);
+              resolve15(mod.exports);
             });
           });
         }
@@ -40014,15 +40018,96 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 });
 
 // src/lang/runtime.ts
-var parserCache, initializedLanguages;
+import { fileURLToPath } from "url";
+async function initTreeSitter() {
+  if (treeSitterInitialized) {
+    return;
+  }
+  await Parser.init();
+  treeSitterInitialized = true;
+}
+function sanitizeLanguageId(languageId) {
+  const normalized = languageId.toLowerCase();
+  if (!/^[a-z0-9-]+$/.test(normalized)) {
+    throw new Error(`Invalid language ID: ${languageId}`);
+  }
+  return normalized;
+}
+function getWasmFileName(languageId) {
+  const sanitized = sanitizeLanguageId(languageId).toLowerCase();
+  if (LANGUAGE_WASM_MAP[sanitized]) {
+    return LANGUAGE_WASM_MAP[sanitized];
+  }
+  return `tree-sitter-${sanitized}.wasm`;
+}
+function getGrammarsPath() {
+  const isProduction = !import.meta.url.includes("src/");
+  if (isProduction) {
+    return "./lang/grammars/";
+  }
+  return "../../dist/lang/grammars/";
+}
+async function loadGrammar(languageId) {
+  if (typeof languageId !== "string" || languageId.length > 100) {
+    throw new Error(`Invalid languageId: must be a string of at most 100 characters`);
+  }
+  const normalizedId = sanitizeLanguageId(languageId).toLowerCase();
+  if (normalizedId.length === 0) {
+    throw new Error(`Invalid languageId: empty after sanitization`);
+  }
+  if (parserCache.has(normalizedId)) {
+    return parserCache.get(normalizedId);
+  }
+  await initTreeSitter();
+  const parser = new Parser;
+  const wasmFileName = getWasmFileName(normalizedId);
+  const grammarsPath = getGrammarsPath();
+  const wasmPath = fileURLToPath(new URL(`${grammarsPath}${wasmFileName}`, import.meta.url));
+  const { existsSync: existsSync27 } = await import("fs");
+  if (!existsSync27(wasmPath)) {
+    throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
+Make sure to run 'bun run build' to copy grammar files to dist/lang/grammars/`);
+  }
+  try {
+    const language = await Language.load(wasmPath);
+    parser.setLanguage(language);
+  } catch (error93) {
+    throw new Error(`Failed to load grammar for ${languageId}: ${error93 instanceof Error ? error93.message : String(error93)}
+WASM path: ${wasmPath}`);
+  }
+  parserCache.set(normalizedId, parser);
+  initializedLanguages.add(normalizedId);
+  return parser;
+}
+var parserCache, initializedLanguages, treeSitterInitialized = false, LANGUAGE_WASM_MAP;
 var init_runtime = __esm(() => {
   init_tree_sitter();
   parserCache = new Map;
   initializedLanguages = new Set;
+  LANGUAGE_WASM_MAP = {
+    javascript: "tree-sitter-javascript.wasm",
+    typescript: "tree-sitter-typescript.wasm",
+    python: "tree-sitter-python.wasm",
+    go: "tree-sitter-go.wasm",
+    rust: "tree-sitter-rust.wasm",
+    cpp: "tree-sitter-cpp.wasm",
+    c: "tree-sitter-cpp.wasm",
+    csharp: "tree-sitter-c-sharp.wasm",
+    css: "tree-sitter-css.wasm",
+    html: "tree-sitter-html.wasm",
+    json: "tree-sitter-json.wasm",
+    bash: "tree-sitter-bash.wasm",
+    ruby: "tree-sitter-ruby.wasm",
+    php: "tree-sitter-php.wasm",
+    java: "tree-sitter-java.wasm",
+    kotlin: "tree-sitter-kotlin.wasm",
+    swift: "tree-sitter-swift.wasm",
+    dart: "tree-sitter-dart.wasm"
+  };
 });
 
 // src/index.ts
-import * as path60 from "path";
+import * as path62 from "path";
 
 // src/agents/index.ts
 init_config();
@@ -40386,7 +40471,7 @@ async function readPlanFromDisk(directory) {
     return null;
   }
 }
-async function readEvidenceFromDisk(directory) {
+async function readGateEvidenceFromDisk(directory) {
   const evidenceMap = new Map;
   try {
     const evidenceDir = path3.join(directory, ".swarm", "evidence");
@@ -40421,7 +40506,7 @@ async function buildRehydrationCache(directory) {
       }
     }
   }
-  const evidenceMap = await readEvidenceFromDisk(directory);
+  const evidenceMap = await readGateEvidenceFromDisk(directory);
   _rehydrationCache = { planTaskStates, evidenceMap };
 }
 function applyRehydrationCache(session) {
@@ -40530,7 +40615,9 @@ Do not re-trigger DISCOVER or CONSULT because you noticed a project phase bounda
 Output to .swarm/plan.md MUST use "## Phase N" headers. Do not write MODE labels into plan.md.
 
 1. DELEGATE all coding to {{AGENT_PREFIX}}coder. You do NOT write code.
-YOUR TOOLS: Task (delegation), diff, syntax_check, placeholder_scan, imports, lint, secretscan, sast_scan, build_check, pre_check_batch, quality_budget, symbols, complexity_hotspots, schema_drift, todo_extract, evidence_check, sbom_generate, checkpoint, pkg_audit, test_runner.
+// IMPORTANT: This list MUST match AGENT_TOOL_MAP['architect'] in src/config/constants.ts
+// If you add a tool to the map, add it here. If you remove it from the map, remove it here.
+YOUR TOOLS: Task (delegation), checkpoint, check_gate_status, complexity_hotspots, declare_scope, detect_domains, diff, evidence_check, extract_code_blocks, gitingest, imports, knowledge_query, lint, pkg_audit, pre_check_batch, retrieve_summary, save_plan, schema_drift, secretscan, symbols, test_runner, todo_extract, update_task_status, write_retro.
 CODER'S TOOLS: write, edit, patch, apply_patch, create_file, insert, replace \u2014 any tool that modifies file contents.
 If a tool modifies a file, it is a CODER tool. Delegate.
 2. ONE agent per message. Send, STOP, wait for response.
@@ -42364,6 +42451,82 @@ RULES:
 - Do NOT rephrase or summarize doc content with your own words \u2014 use the actual text from the file
 - Full doc content is only loaded when relevant to the current task, never preloaded
 `;
+var CURATOR_INIT_PROMPT = `## IDENTITY
+You are Explorer in CURATOR_INIT mode. You consolidate prior session knowledge into an architect briefing.
+DO NOT use the Task tool to delegate. You ARE the agent that does the work.
+
+INPUT FORMAT:
+TASK: CURATOR_INIT
+PRIOR_SUMMARY: [JSON or "none"]
+KNOWLEDGE_ENTRIES: [JSON array of high-confidence entries]
+PROJECT_CONTEXT: [context.md excerpt]
+
+ACTIONS:
+- Read the prior summary to understand session history
+- Cross-reference knowledge entries against project context
+- Identify contradictions (knowledge says X, project state shows Y)
+- Produce a concise briefing for the architect
+
+RULES:
+- Output under 2000 chars
+- No code modifications
+- Flag contradictions explicitly with CONTRADICTION: prefix
+- If no prior summary exists, state "First session \u2014 no prior context"
+
+OUTPUT FORMAT:
+BRIEFING:
+[concise summary of prior session state, key decisions, active blockers]
+
+CONTRADICTIONS:
+- [entry_id]: [description] (or "None detected")
+
+KNOWLEDGE_STATS:
+- Entries reviewed: [N]
+- Prior phases covered: [N]
+`;
+var CURATOR_PHASE_PROMPT = `## IDENTITY
+You are Explorer in CURATOR_PHASE mode. You consolidate a completed phase into a digest.
+DO NOT use the Task tool to delegate. You ARE the agent that does the work.
+
+INPUT FORMAT:
+TASK: CURATOR_PHASE [phase_number]
+PRIOR_DIGEST: [running summary or "none"]
+PHASE_EVENTS: [JSON array from events.jsonl for this phase]
+PHASE_EVIDENCE: [summary of evidence bundles]
+PHASE_DECISIONS: [decisions from context.md]
+AGENTS_DISPATCHED: [list]
+AGENTS_EXPECTED: [list from config]
+
+ACTIONS:
+- Extend the prior digest with this phase's outcomes (do NOT regenerate from scratch)
+- Identify workflow deviations: missing reviewer, missing retro, skipped test_engineer
+- Recommend knowledge updates: entries to promote, archive, or flag as contradicted
+- Summarize key decisions and blockers resolved
+
+RULES:
+- Output under 2000 chars
+- No code modifications
+- Compliance observations are READ-ONLY \u2014 report, do not enforce
+- Extend the digest, never replace it
+
+OUTPUT FORMAT:
+PHASE_DIGEST:
+phase: [N]
+summary: [what was accomplished]
+agents_used: [list]
+tasks_completed: [N]/[total]
+key_decisions: [list]
+blockers_resolved: [list]
+
+COMPLIANCE:
+- [type]: [description] (or "No deviations observed")
+
+KNOWLEDGE_UPDATES:
+- [action] [entry_id or "new"]: [reason] (or "No recommendations")
+
+EXTENDED_DIGEST:
+[the full running digest with this phase appended]
+`;
 function createExplorerAgent(model, customPrompt, customAppendPrompt) {
   let prompt = EXPLORER_PROMPT;
   if (customPrompt) {
@@ -42388,6 +42551,26 @@ ${customAppendPrompt}`;
     }
   };
 }
+function createExplorerCuratorAgent(model, mode, customAppendPrompt) {
+  const basePrompt = mode === "CURATOR_INIT" ? CURATOR_INIT_PROMPT : CURATOR_PHASE_PROMPT;
+  const prompt = customAppendPrompt ? `${basePrompt}
+
+${customAppendPrompt}` : basePrompt;
+  return {
+    name: "explorer",
+    description: `Explorer in ${mode} mode \u2014 consolidates context at phase boundaries.`,
+    config: {
+      model,
+      temperature: 0.1,
+      prompt,
+      tools: {
+        write: false,
+        edit: false,
+        patch: false
+      }
+    }
+  };
+}
 
 // src/agents/reviewer.ts
 var REVIEWER_PROMPT = `## PRESSURE IMMUNITY
@@ -44543,9 +44726,9 @@ init_schema();
 import path15 from "path";
 
 // src/hooks/curator.ts
-init_event_bus();
 import * as fs9 from "fs";
 import * as path13 from "path";
+init_event_bus();
 
 // src/hooks/knowledge-store.ts
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
@@ -44703,6 +44886,33 @@ function inferTags(lesson) {
 
 // src/hooks/curator.ts
 init_utils2();
+var CURATOR_LLM_TIMEOUT_MS = 30000;
+function parseKnowledgeRecommendations(llmOutput) {
+  const recommendations = [];
+  const section = llmOutput.match(/KNOWLEDGE_UPDATES:\s*\n([\s\S]*?)(?:\n\n|\n[A-Z_]+:|$)/);
+  if (!section)
+    return recommendations;
+  const lines = section[1].split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("-"))
+      continue;
+    const match = trimmed.match(/^-\s+(promote|archive|flag_contradiction)\s+(\S+):\s+(.+)$/i);
+    if (match) {
+      const action = match[1].toLowerCase();
+      const entryId = match[2] === "new" ? undefined : match[2];
+      const reason = match[3].trim();
+      recommendations.push({
+        action,
+        entry_id: entryId,
+        lesson: reason,
+        reason
+      });
+    }
+  }
+  return recommendations;
+}
 async function readCuratorSummary(directory) {
   const content = await readSwarmFileAsync(directory, "curator-summary.json");
   if (content === null) {
@@ -44861,7 +45071,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
   }
   return observations;
 }
-async function runCuratorInit(directory, config3) {
+async function runCuratorInit(directory, config3, llmDelegate) {
   try {
     const priorSummary = await readCuratorSummary(directory);
     const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -44905,9 +45115,41 @@ async function runCuratorInit(directory, config3) {
       briefingParts.push(contextMd.slice(0, maxContextChars));
     }
     const contradictions = allEntries.filter((e) => Array.isArray(e.tags) && e.tags.some((t) => t.includes("contradiction"))).map((e) => typeof e.lesson === "string" ? e.lesson : JSON.stringify(e.lesson));
+    let briefingText = briefingParts.join(`
+`);
+    if (llmDelegate) {
+      try {
+        const curatorAgent = createExplorerCuratorAgent("default", "CURATOR_INIT");
+        const userInput = [
+          "TASK: CURATOR_INIT",
+          `PRIOR_SUMMARY: ${priorSummary ? JSON.stringify(priorSummary) : "none"}`,
+          `KNOWLEDGE_ENTRIES: ${JSON.stringify(highConfidenceEntries.slice(0, 10))}`,
+          `PROJECT_CONTEXT: ${contextMd?.slice(0, config3.max_summary_tokens * 2) ?? "none"}`
+        ].join(`
+`);
+        const systemPrompt = curatorAgent.config.prompt ?? "";
+        const llmOutput = await Promise.race([
+          llmDelegate(systemPrompt, userInput),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("CURATOR_LLM_TIMEOUT")), CURATOR_LLM_TIMEOUT_MS))
+        ]);
+        if (llmOutput?.trim()) {
+          briefingText = `${briefingText}
+
+## LLM-Enhanced Analysis
+${llmOutput.trim()}`;
+        }
+        getGlobalEventBus().publish("curator.init.llm_completed", {
+          enhanced: true
+        });
+      } catch (err2) {
+        console.warn(`[curator] LLM delegation failed during CURATOR_INIT, using data-only mode: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        getGlobalEventBus().publish("curator.init.llm_fallback", {
+          error: String(err2)
+        });
+      }
+    }
     const result = {
-      briefing: briefingParts.join(`
-`),
+      briefing: briefingText,
       contradictions,
       knowledge_entries_reviewed: allEntries.length,
       prior_phases_covered: priorSummary ? priorSummary.last_phase_covered : 0
@@ -44932,7 +45174,7 @@ Could not load prior session context.`,
     };
   }
 }
-async function runCuratorPhase(directory, phase, agentsDispatched, _config, _knowledgeConfig) {
+async function runCuratorPhase(directory, phase, agentsDispatched, _config, _knowledgeConfig, llmDelegate) {
   try {
     const priorSummary = await readCuratorSummary(directory);
     const eventsJsonlContent = await readSwarmFileAsync(directory, "events.jsonl");
@@ -44965,7 +45207,40 @@ async function runCuratorPhase(directory, phase, agentsDispatched, _config, _kno
       key_decisions: keyDecisions.slice(0, 5),
       blockers_resolved: []
     };
-    const knowledgeRecommendations = [];
+    let knowledgeRecommendations = [];
+    if (llmDelegate) {
+      try {
+        const curatorAgent = createExplorerCuratorAgent("default", "CURATOR_PHASE");
+        const priorDigest = priorSummary?.digest ?? "none";
+        const systemPrompt = curatorAgent.config.prompt ?? "";
+        const userInput = [
+          `TASK: CURATOR_PHASE ${phase}`,
+          `PRIOR_DIGEST: ${priorDigest}`,
+          `PHASE_EVENTS: ${JSON.stringify(phaseEvents.slice(0, 50))}`,
+          `PHASE_DECISIONS: ${JSON.stringify(keyDecisions)}`,
+          `AGENTS_DISPATCHED: ${JSON.stringify(agentsDispatched)}`,
+          `AGENTS_EXPECTED: ["reviewer", "test_engineer"]`
+        ].join(`
+`);
+        const llmOutput = await Promise.race([
+          llmDelegate(systemPrompt, userInput),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("CURATOR_LLM_TIMEOUT")), CURATOR_LLM_TIMEOUT_MS))
+        ]);
+        if (llmOutput?.trim()) {
+          knowledgeRecommendations = parseKnowledgeRecommendations(llmOutput);
+        }
+        getGlobalEventBus().publish("curator.phase.llm_completed", {
+          phase,
+          recommendations: knowledgeRecommendations.length
+        });
+      } catch (err2) {
+        console.warn(`[curator] LLM delegation failed during CURATOR_PHASE ${phase}, using data-only mode: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        getGlobalEventBus().publish("curator.phase.llm_fallback", {
+          phase,
+          error: String(err2)
+        });
+      }
+    }
     const sessionId = `session-${Date.now()}`;
     const now = new Date().toISOString();
     let updatedSummary;
@@ -50506,6 +50781,68 @@ function maskToolOutput(msg, _threshold) {
 init_schema();
 import * as fs21 from "fs";
 import * as path32 from "path";
+
+// src/parallel/review-router.ts
+async function computeComplexity(directory, changedFiles) {
+  let functionCount = 0;
+  let astChangeCount = 0;
+  let maxFileComplexity = 0;
+  for (const file3 of changedFiles) {
+    if (!/\.(ts|js|tsx|jsx|py|go|rs)$/.test(file3)) {
+      continue;
+    }
+    try {
+      const fs21 = await import("fs");
+      const path30 = await import("path");
+      const filePath = path30.join(directory, file3);
+      if (!fs21.existsSync(filePath)) {
+        continue;
+      }
+      const content = fs21.readFileSync(filePath, "utf-8");
+      const functionMatches = content.match(/\b(function|def|func|fn)\s+\w+/g);
+      const fileFunctionCount = functionMatches?.length || 0;
+      functionCount += fileFunctionCount;
+      const lines = content.split(`
+`).length;
+      const estimatedChanges = Math.min(lines / 10, 50);
+      astChangeCount += estimatedChanges;
+      const fileComplexity = fileFunctionCount + lines / 100;
+      maxFileComplexity = Math.max(maxFileComplexity, fileComplexity);
+    } catch {}
+  }
+  return {
+    fileCount: changedFiles.length,
+    functionCount,
+    astChangeCount: Math.round(astChangeCount),
+    maxFileComplexity: Math.round(maxFileComplexity * 10) / 10
+  };
+}
+function routeReview(metrics) {
+  const isHighComplexity = metrics.fileCount >= 5 || metrics.functionCount >= 10 || metrics.astChangeCount >= 30 || metrics.maxFileComplexity >= 15;
+  if (isHighComplexity) {
+    return {
+      reviewerCount: 2,
+      testEngineerCount: 2,
+      depth: "double",
+      reason: `High complexity: ${metrics.fileCount} files, ${metrics.functionCount} functions, complexity score ${metrics.maxFileComplexity}`
+    };
+  }
+  return {
+    reviewerCount: 1,
+    testEngineerCount: 1,
+    depth: "single",
+    reason: `Standard complexity: ${metrics.fileCount} files, ${metrics.functionCount} functions`
+  };
+}
+async function routeReviewForChanges(directory, changedFiles) {
+  const metrics = await computeComplexity(directory, changedFiles);
+  return routeReview(metrics);
+}
+function shouldParallelizeReview(routing) {
+  return routing.depth === "double";
+}
+
+// src/hooks/delegation-gate.ts
 init_telemetry();
 
 // src/hooks/guardrails.ts
@@ -51144,15 +51481,19 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
           const errorContent = output.error ?? outputStr;
           if (typeof errorContent === "string" && TRANSIENT_MODEL_ERROR_PATTERN.test(errorContent) && !session.modelFallbackExhausted) {
             session.model_fallback_index++;
-            session.modelFallbackExhausted = true;
             const baseAgentName = session.agentName ? session.agentName.replace(/^[^_]+[_]/, "") : "";
-            const fallbackModel = resolveFallbackModel(baseAgentName, session.model_fallback_index, getSwarmAgents());
+            const swarmAgents = getSwarmAgents();
+            const fallbackModels = swarmAgents?.[baseAgentName]?.fallback_models;
+            session.modelFallbackExhausted = !fallbackModels || session.model_fallback_index > fallbackModels.length;
+            const fallbackModel = resolveFallbackModel(baseAgentName, session.model_fallback_index, swarmAgents);
             if (fallbackModel) {
-              const swarmAgents = getSwarmAgents();
               const primaryModel = swarmAgents?.[baseAgentName]?.model ?? "default";
+              if (swarmAgents?.[baseAgentName]) {
+                swarmAgents[baseAgentName].model = fallbackModel;
+              }
               telemetry.modelFallback(input.sessionID, session.agentName, primaryModel, fallbackModel, "transient_model_error");
               session.pendingAdvisoryMessages ??= [];
-              session.pendingAdvisoryMessages.push(`MODEL FALLBACK: Transient model error detected (attempt ${session.model_fallback_index}). ` + `Configured fallback model: "${fallbackModel}". ` + `Consider retrying with this model or using /swarm handoff to reset.`);
+              session.pendingAdvisoryMessages.push(`MODEL FALLBACK: Applied fallback model "${fallbackModel}" (attempt ${session.model_fallback_index}). ` + `Using /swarm handoff to reset to primary model.`);
             } else {
               session.pendingAdvisoryMessages ??= [];
               session.pendingAdvisoryMessages.push(`MODEL FALLBACK: Transient model error detected (attempt ${session.model_fallback_index}). ` + `No fallback models configured for this agent. Add "fallback_models": ["model-a", "model-b"] ` + `to the agent's config in opencode-swarm.json.`);
@@ -51558,9 +51899,55 @@ function createDelegationGateHook(config3, directory) {
   if (!enabled) {
     return {
       messagesTransform: async (_input, _output) => {},
+      toolBefore: async () => {},
       toolAfter: async () => {}
     };
   }
+  const toolBefore = async (input, output) => {
+    if (!input.sessionID)
+      return;
+    const normalized = input.tool.replace(/^[^:]+[:.]/, "");
+    if (normalized !== "Task" && normalized !== "task")
+      return;
+    const args2 = output.args;
+    if (!args2)
+      return;
+    const subagentType = args2.subagent_type;
+    if (typeof subagentType !== "string")
+      return;
+    const targetAgent = stripKnownSwarmPrefix(subagentType);
+    if (targetAgent === "reviewer") {
+      try {
+        const reviewSession = swarmState.agentSessions.get(input.sessionID);
+        if (reviewSession) {
+          const changedFiles = reviewSession.modifiedFilesThisCoderTask ?? [];
+          if (changedFiles.length > 0) {
+            const routing = await routeReviewForChanges(directory, changedFiles);
+            if (shouldParallelizeReview(routing)) {
+              reviewSession.pendingAdvisoryMessages ??= [];
+              reviewSession.pendingAdvisoryMessages.push(`REVIEW ROUTING: High complexity detected (${routing.reason}). ` + `Consider parallel review: ${routing.reviewerCount} reviewers, ${routing.testEngineerCount} test engineers recommended.`);
+            }
+          }
+        }
+      } catch {}
+    }
+    if (targetAgent !== "coder")
+      return;
+    const session = swarmState.agentSessions.get(input.sessionID);
+    if (!session || !session.taskWorkflowStates)
+      return;
+    for (const [taskId, state2] of session.taskWorkflowStates) {
+      if (state2 !== "coder_delegated")
+        continue;
+      const turbo = hasActiveTurboMode(input.sessionID);
+      if (turbo) {
+        const isTier3 = taskId.startsWith("3.");
+        if (!isTier3)
+          continue;
+      }
+      throw new Error(`REVIEWER_GATE_VIOLATION: Cannot re-delegate to coder without reviewer delegation. ` + `Task ${taskId} state: coder_delegated. Delegate to reviewer first.`);
+    }
+  };
   const toolAfter = async (input, _output) => {
     if (!input.sessionID)
       return;
@@ -51782,6 +52169,7 @@ function createDelegationGateHook(config3, directory) {
     }
   };
   return {
+    toolBefore,
     messagesTransform: async (_input, output) => {
       const messages = output.messages;
       if (!messages || messages.length === 0)
@@ -52332,7 +52720,7 @@ init_schema();
 init_manager();
 init_detector();
 init_manager2();
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
@@ -52615,6 +53003,8 @@ init_utils();
 // src/hooks/adversarial-detector.ts
 init_constants();
 init_schema();
+import * as fs24 from "fs/promises";
+import * as path35 from "path";
 function safeGet(obj, key) {
   if (!obj || !Object.hasOwn(obj, key))
     return;
@@ -52646,6 +53036,248 @@ function formatAdversarialWarning(agentA, agentB, sharedModel, policy) {
   }
   return `\u26A0\uFE0F Same-model adversarial pair detected. Agent ${agentA} and checker ${agentB} both use model ${sharedModel}. Review may lack independence.`;
 }
+var PRECEDENT_MANIPULATION_PATTERNS = [
+  /we skipped .* in phase \d+/i,
+  /consistent with how we handled/i,
+  /going forward/i,
+  /the reviewer didn't flag this pattern before/i,
+  /this is consistent with/i,
+  /we should continue/i
+];
+var SELF_REVIEW_PATTERNS = [
+  /I (verified|checked|reviewed|validated).*(myself|my own)/i,
+  /I (think|believe) this (looks|is) correct/i,
+  /this (looks|seems|appears) (good|correct|fine)/i
+];
+var CONTENT_EXEMPTION_PATTERNS = [
+  /documentation doesn't need/i,
+  /config changes are trivial/i,
+  /just a (rename|refactor|typo)/i,
+  /test files don't need/i,
+  /this is (just|only) a/i,
+  /no need for (review|the full)/i
+];
+var GATE_DELEGATION_BYPASS_PATTERNS = [
+  /I verified the changes/i,
+  /code looks correct to me/i,
+  /the code looks (good|fine)/i,
+  /task marked complete/i,
+  /I (checked|reviewed).*myself/i,
+  /edit tool on (src|tests|config)/i,
+  /write tool on (src|tests|config)/i,
+  /writeCount.*\d+.*source/i,
+  /I'll just make this small fix directly/i,
+  /It's faster if I do it myself/i,
+  /edit tool on.*plan\.md/i,
+  /write tool on.*plan\.md/i,
+  /\[ \].*to \[x\].*in plan\.md/i,
+  /status.*pending.*complete.*plan\.json/i,
+  /I'll just mark this one as done/i,
+  /mark it done directly/i
+];
+var GATE_MISCLASSIFICATION_PATTERNS = [
+  /(?:src\/|source\/|source\s+code|source\s+file).*tier\s*[01]/i,
+  /tier\s*[01].*(?:src\/|source\/|source\s+code|source\s+file)/i,
+  /(?:security|auth|crypto|secret|credential|permission).*tier\s*[012]/i,
+  /tier\s*[012].*(?:security|auth|crypto|secret|credential|permission)/i,
+  /below\s+tier\s*3.*(?:security|auth|crypto|secret|credential|permission)/i,
+  /classification[:\s-]*tier\s*[01]/i,
+  /tier\s*[01][\s:]*classification/i,
+  /(?:small|trivial|minor).*tier\s*[01]/i,
+  /tier\s*[01].*(?:small|trivial|minor)/i,
+  /(?:small|trivial|minor).*(?:classification|classified|assigned).*tier/i,
+  /(?:classification|classified|assigned).*(?:small|trivial|minor).*tier/i,
+  /pipeline\s+started.*(?:assigning|setting|classifying).*tier/i,
+  /(?:assigning|setting|classifying).*tier.*after.*pipeline/i,
+  /tier.*assigned.*(?:after|retroactive)/i,
+  /retroactive.*(?:tier|classification)/i
+];
+var VELOCITY_RATIONALIZATION_PATTERNS = [
+  /to save time/i,
+  /since we're behind/i,
+  /quick fix/i,
+  /review.*later/i,
+  /in the interest of efficiency/i,
+  /we can (review|check).*later/i,
+  /for (speed|efficiency)/i
+];
+var INTER_AGENT_MANIPULATION_PATTERNS = [
+  /\b(5th|fifth|final|last)\s+(attempt|try|time)\b/i,
+  /\bthis\s+is\s+(blocking|blocking\s+everything|critical|urgent)\b/i,
+  /\bwe('re|\s+are)\s+(behind|late|running\s+out\s+of\s+time)\b/i,
+  /\buser\s+is\s+waiting\b/i,
+  /\bship\s+(this|it)\s+(now|today|immediately)\b/i,
+  /\b(I'm|I\s+am)\s+(frustrated|disappointed|sad|upset)\b/i,
+  /\bthis\s+is\s+(frustrating|disappointing)\b/i,
+  /\b(I've|I\s+have)\s+been\s+working\s+on\s+this\b/i,
+  /\bplease\s+(help|approve|pass)\b/i,
+  /\bor\s+I('ll|\s+will)\s+(stop|halt|pause)\b/i,
+  /\bor\s+all\s+work\s+stops\b/i,
+  /\bI('ll|\s+will)\s+have\s+to\s+alert\s+the\s+user\b/i,
+  /\bthis\s+will\s+(delay|block)\s+everything\b/i,
+  /\bjust\s+approve\s+this\b/i,
+  /\bI\s+(need|want)\s+you\s+to\s+(approve|pass)\b/i,
+  /\boverride\s+(this|the)\s+(check|gate|review)\b/i
+];
+function detectAdversarialPatterns(text) {
+  if (typeof text !== "string") {
+    return [];
+  }
+  const matches = [];
+  for (const pattern of PRECEDENT_MANIPULATION_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      matches.push({
+        pattern: "PRECEDENT_MANIPULATION",
+        severity: "HIGHEST",
+        matchedText: match[0],
+        confidence: "HIGH"
+      });
+    }
+  }
+  for (const pattern of SELF_REVIEW_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      matches.push({
+        pattern: "SELF_REVIEW",
+        severity: "HIGH",
+        matchedText: match[0],
+        confidence: "HIGH"
+      });
+    }
+  }
+  for (const pattern of CONTENT_EXEMPTION_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      matches.push({
+        pattern: "CONTENT_EXEMPTION",
+        severity: "HIGH",
+        matchedText: match[0],
+        confidence: "HIGH"
+      });
+    }
+  }
+  for (const pattern of GATE_DELEGATION_BYPASS_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      matches.push({
+        pattern: "GATE_DELEGATION_BYPASS",
+        severity: "HIGHEST",
+        matchedText: match[0],
+        confidence: "HIGH"
+      });
+    }
+  }
+  for (const pattern of GATE_MISCLASSIFICATION_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      matches.push({
+        pattern: "GATE_MISCLASSIFICATION",
+        severity: "HIGH",
+        matchedText: match[0],
+        confidence: "HIGH"
+      });
+    }
+  }
+  for (const pattern of VELOCITY_RATIONALIZATION_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      matches.push({
+        pattern: "VELOCITY_RATIONALIZATION",
+        severity: "HIGH",
+        matchedText: match[0],
+        confidence: "HIGH"
+      });
+    }
+  }
+  for (const pattern of INTER_AGENT_MANIPULATION_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      matches.push({
+        pattern: "INTER_AGENT_MANIPULATION",
+        severity: "HIGH",
+        matchedText: match[0],
+        confidence: "HIGH"
+      });
+    }
+  }
+  return matches;
+}
+function formatDebuggingSpiralEvent(match, taskId) {
+  return JSON.stringify({
+    event: "debugging_spiral_detected",
+    taskId,
+    pattern: match.pattern,
+    severity: match.severity,
+    matchedText: match.matchedText,
+    confidence: match.confidence,
+    timestamp: new Date().toISOString()
+  });
+}
+async function handleDebuggingSpiral(match, taskId, directory) {
+  let eventLogged = false;
+  let checkpointCreated = false;
+  try {
+    const swarmDir = path35.join(directory, ".swarm");
+    await fs24.mkdir(swarmDir, { recursive: true });
+    const eventsPath = path35.join(swarmDir, "events.jsonl");
+    await fs24.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
+`);
+    eventLogged = true;
+  } catch {}
+  const checkpointLabel = `spiral-${taskId}-${Date.now()}`;
+  try {
+    const { checkpoint: checkpoint2 } = await Promise.resolve().then(() => (init_checkpoint(), exports_checkpoint));
+    const result = await checkpoint2.execute({ action: "save", label: checkpointLabel }, { directory });
+    try {
+      const parsed = JSON.parse(result);
+      checkpointCreated = parsed.success === true;
+    } catch {
+      checkpointCreated = false;
+    }
+  } catch {
+    checkpointCreated = false;
+  }
+  const checkpointMsg = checkpointCreated ? `\u2713 Auto-checkpoint created: ${checkpointLabel}` : "\u26A0 Auto-checkpoint failed (non-fatal)";
+  const message = `[FOR: architect] DEBUGGING SPIRAL DETECTED for task ${taskId}
+Issue: ${match.matchedText}
+Confidence: ${match.confidence}
+${checkpointMsg}
+Recommendation: Consider escalating to user or taking a different approach
+The current fix strategy appears to be cycling without progress`;
+  return { eventLogged, checkpointCreated, message };
+}
+var recentToolCalls = [];
+var MAX_RECENT_CALLS = 20;
+var SPIRAL_THRESHOLD = 5;
+var SPIRAL_WINDOW_MS = 300000;
+function recordToolCall(tool3, args2) {
+  const argsHash = typeof args2 === "string" ? args2.slice(0, 100) : JSON.stringify(args2 ?? "").slice(0, 100);
+  recentToolCalls.push({ tool: tool3, argsHash, timestamp: Date.now() });
+  if (recentToolCalls.length > MAX_RECENT_CALLS) {
+    recentToolCalls.shift();
+  }
+}
+async function detectDebuggingSpiral(_directory) {
+  const now = Date.now();
+  const windowCalls = recentToolCalls.filter((c) => now - c.timestamp < SPIRAL_WINDOW_MS);
+  if (windowCalls.length < SPIRAL_THRESHOLD)
+    return null;
+  const lastN = windowCalls.slice(-SPIRAL_THRESHOLD);
+  const firstTool = lastN[0].tool;
+  const firstArgs = lastN[0].argsHash;
+  const allSameTool = lastN.every((c) => c.tool === firstTool);
+  const allSimilarArgs = lastN.every((c) => c.argsHash === firstArgs);
+  if (allSameTool && allSimilarArgs) {
+    return {
+      pattern: "VELOCITY_RATIONALIZATION",
+      severity: "HIGH",
+      matchedText: `Tool '${firstTool}' called ${SPIRAL_THRESHOLD}+ times with identical args`,
+      confidence: "HIGH"
+    };
+  }
+  return null;
+}
 
 // src/hooks/context-scoring.ts
 function calculateAgeFactor(ageHours, config3) {
@@ -52991,11 +53623,11 @@ function createSystemEnhancerHook(config3, directory) {
               if (handoffContent) {
                 const handoffPath = validateSwarmPath(directory, "handoff.md");
                 const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-                if (fs24.existsSync(consumedPath)) {
+                if (fs25.existsSync(consumedPath)) {
                   warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                  fs24.unlinkSync(consumedPath);
+                  fs25.unlinkSync(consumedPath);
                 }
-                fs24.renameSync(handoffPath, consumedPath);
+                fs25.renameSync(handoffPath, consumedPath);
                 const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -53276,11 +53908,11 @@ ${budgetWarning}`);
             if (handoffContent) {
               const handoffPath = validateSwarmPath(directory, "handoff.md");
               const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-              if (fs24.existsSync(consumedPath)) {
+              if (fs25.existsSync(consumedPath)) {
                 warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                fs24.unlinkSync(consumedPath);
+                fs25.unlinkSync(consumedPath);
               }
-              fs24.renameSync(handoffPath, consumedPath);
+              fs25.renameSync(handoffPath, consumedPath);
               const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -54050,8 +54682,8 @@ function isReadTool(toolName) {
 }
 
 // src/hooks/incremental-verify.ts
-import * as fs25 from "fs";
-import * as path35 from "path";
+import * as fs26 from "fs";
+import * as path36 from "path";
 
 // src/hooks/spawn-helper.ts
 import { spawn } from "child_process";
@@ -54126,21 +54758,21 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs25.existsSync(path35.join(projectDir, "bun.lockb")))
+  if (fs26.existsSync(path36.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs25.existsSync(path35.join(projectDir, "pnpm-lock.yaml")))
+  if (fs26.existsSync(path36.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs25.existsSync(path35.join(projectDir, "yarn.lock")))
+  if (fs26.existsSync(path36.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs25.existsSync(path35.join(projectDir, "package-lock.json")))
+  if (fs26.existsSync(path36.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path35.join(projectDir, "package.json");
-  if (fs25.existsSync(pkgPath)) {
+  const pkgPath = path36.join(projectDir, "package.json");
+  if (fs26.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs25.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf8"));
       const scripts = pkg.scripts;
       if (scripts?.typecheck) {
         const pm = detectPackageManager(projectDir);
@@ -54154,8 +54786,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs25.existsSync(path35.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs25.existsSync(path35.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs26.existsSync(path36.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs26.existsSync(path36.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -54163,17 +54795,17 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs25.existsSync(path35.join(projectDir, "go.mod"))) {
+  if (fs26.existsSync(path36.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs25.existsSync(path35.join(projectDir, "Cargo.toml"))) {
+  if (fs26.existsSync(path36.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs25.existsSync(path35.join(projectDir, "pyproject.toml")) || fs25.existsSync(path35.join(projectDir, "requirements.txt")) || fs25.existsSync(path35.join(projectDir, "setup.py"))) {
+  if (fs26.existsSync(path36.join(projectDir, "pyproject.toml")) || fs26.existsSync(path36.join(projectDir, "requirements.txt")) || fs26.existsSync(path36.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
-    const entries = fs25.readdirSync(projectDir);
+    const entries = fs26.readdirSync(projectDir);
     if (entries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       return {
         command: ["dotnet", "build", "--no-restore"],
@@ -54243,8 +54875,8 @@ ${errorSummary}`);
 
 // src/hooks/knowledge-reader.ts
 import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import * as path36 from "path";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import * as path37 from "path";
 var JACCARD_THRESHOLD = 0.6;
 var HIVE_TIER_BOOST = 0.05;
 var SAME_PROJECT_PENALTY = -0.05;
@@ -54292,7 +54924,7 @@ function inferCategoriesFromPhase(phaseDescription) {
   return ["process", "tooling"];
 }
 async function recordLessonsShown(directory, lessonIds, currentPhase) {
-  const shownFile = path36.join(directory, ".swarm", ".knowledge-shown.json");
+  const shownFile = path37.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     let shownData = {};
     if (existsSync22(shownFile)) {
@@ -54300,7 +54932,7 @@ async function recordLessonsShown(directory, lessonIds, currentPhase) {
       shownData = JSON.parse(content);
     }
     shownData[currentPhase] = lessonIds;
-    await mkdir4(path36.dirname(shownFile), { recursive: true });
+    await mkdir5(path37.dirname(shownFile), { recursive: true });
     await writeFile4(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
     console.warn("[swarm] Knowledge: failed to record shown lessons");
@@ -54397,7 +55029,7 @@ async function readMergedKnowledge(directory, config3, context) {
   return topN;
 }
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
-  const shownFile = path36.join(directory, ".swarm", ".knowledge-shown.json");
+  const shownFile = path37.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     if (!existsSync22(shownFile)) {
       return;
@@ -55032,7 +55664,7 @@ ${injectionText}`;
 // src/hooks/scope-guard.ts
 init_constants();
 init_schema();
-import * as path38 from "path";
+import * as path39 from "path";
 var WRITE_TOOLS = new Set([
   "write",
   "edit",
@@ -55094,13 +55726,13 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
 }
 function isFileInScope(filePath, scopeEntries, directory) {
   const dir = directory ?? process.cwd();
-  const resolvedFile = path38.resolve(dir, filePath);
+  const resolvedFile = path39.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path38.resolve(dir, scope);
+    const resolvedScope = path39.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path38.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path38.isAbsolute(rel);
+    const rel = path39.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path39.isAbsolute(rel);
   });
 }
 
@@ -55149,8 +55781,8 @@ function createSelfReviewHook(config3, injectAdvisory) {
 }
 
 // src/hooks/slop-detector.ts
-import * as fs27 from "fs";
-import * as path39 from "path";
+import * as fs28 from "fs";
+import * as path40 from "path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -55195,12 +55827,12 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
 function walkFiles(dir, exts, deadline) {
   const results = [];
   try {
-    for (const entry of fs27.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs28.readdirSync(dir, { withFileTypes: true })) {
       if (deadline !== undefined && Date.now() > deadline)
         break;
       if (entry.isSymbolicLink())
         continue;
-      const full = path39.join(dir, entry.name);
+      const full = path40.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -55215,7 +55847,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs27.existsSync(path39.join(projectDir, "package.json"));
+  const hasPackageJson = fs28.existsSync(path40.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -55238,7 +55870,7 @@ function checkDeadExports(content, projectDir, startTime) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = fs27.readFileSync(file3, "utf-8");
+          const text = fs28.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -55371,7 +56003,7 @@ Review before proceeding.`;
 
 // src/hooks/steering-consumed.ts
 init_utils2();
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -55380,7 +56012,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs28.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs29.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -55777,8 +56409,8 @@ var build_check = createSwarmTool({
 init_dist();
 init_manager();
 init_create_tool();
-import * as fs29 from "fs";
-import * as path40 from "path";
+import * as fs30 from "fs";
+import * as path41 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
 var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
 function isValidTaskId3(taskId) {
@@ -55795,18 +56427,18 @@ function isValidTaskId3(taskId) {
   return TASK_ID_PATTERN2.test(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path40.resolve(workspaceRoot);
-  const swarmPath = path40.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path40.resolve(filePath);
+  const normalizedWorkspace = path41.resolve(workspaceRoot);
+  const swarmPath = path41.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path41.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs29.existsSync(evidencePath)) {
+  if (!fs30.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs29.readFileSync(evidencePath, "utf-8");
+    content = fs30.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -55860,7 +56492,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path40.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path41.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -55952,8 +56584,8 @@ init_checkpoint();
 // src/tools/completion-verify.ts
 init_dist();
 init_utils2();
-import * as fs30 from "fs";
-import * as path41 from "path";
+import * as fs31 from "fs";
+import * as path42 from "path";
 init_create_tool();
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
@@ -56035,7 +56667,7 @@ async function executeCompletionVerify(args2, directory) {
   let plan;
   try {
     const planPath = validateSwarmPath(directory, "plan.json");
-    const planRaw = fs30.readFileSync(planPath, "utf-8");
+    const planRaw = fs31.readFileSync(planPath, "utf-8");
     plan = JSON.parse(planRaw);
   } catch {
     const result2 = {
@@ -56086,10 +56718,10 @@ async function executeCompletionVerify(args2, directory) {
     let foundCount = 0;
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
-      const resolvedPath = path41.resolve(directory, filePath);
+      const resolvedPath = path42.resolve(directory, filePath);
       let fileContent;
       try {
-        fileContent = fs30.readFileSync(resolvedPath, "utf-8");
+        fileContent = fs31.readFileSync(resolvedPath, "utf-8");
       } catch {
         blockedTasks.push({
           task_id: task.id,
@@ -56131,9 +56763,9 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path41.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path41.join(evidenceDir, "completion-verify.json");
-    fs30.mkdirSync(evidenceDir, { recursive: true });
+    const evidenceDir = path42.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path42.join(evidenceDir, "completion-verify.json");
+    fs31.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
       task_id: "completion-verify",
@@ -56154,7 +56786,7 @@ async function executeCompletionVerify(args2, directory) {
         }
       ]
     };
-    fs30.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
+    fs31.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
   } catch {}
   return JSON.stringify(result, null, 2);
 }
@@ -56194,8 +56826,8 @@ var completion_verify = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_dist();
 init_create_tool();
-import * as fs31 from "fs";
-import * as path42 from "path";
+import * as fs32 from "fs";
+import * as path43 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
 var DEFAULT_TOP_N = 20;
@@ -56324,11 +56956,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs31.statSync(filePath);
+    const stat2 = fs32.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs31.readFileSync(filePath, "utf-8");
+    const content = fs32.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -56339,7 +56971,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 = path42.extname(file3).toLowerCase();
+    const ext = path43.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -56349,8 +56981,8 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs31.existsSync(fullPath)) {
-      fullPath = path42.join(cwd, file3);
+    if (!fs32.existsSync(fullPath)) {
+      fullPath = path43.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
     if (complexity !== null) {
@@ -56558,8 +57190,8 @@ var curator_analyze = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs32 from "fs";
-import * as path43 from "path";
+import * as fs33 from "fs";
+import * as path44 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
   const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
@@ -56638,8 +57270,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path43.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path43.sep);
+    normalizedDir = path44.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path44.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -56649,11 +57281,11 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path43.resolve(normalizedDir);
+    const resolvedDir = path44.resolve(normalizedDir);
     try {
-      const realPath = fs32.realpathSync(resolvedDir);
-      const planPath2 = path43.join(realPath, ".swarm", "plan.json");
-      if (!fs32.existsSync(planPath2)) {
+      const realPath = fs33.realpathSync(resolvedDir);
+      const planPath2 = path44.join(realPath, ".swarm", "plan.json");
+      if (!fs33.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -56676,8 +57308,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     console.warn("[declare-scope] fallbackDir is undefined, falling back to process.cwd()");
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path43.resolve(directory, ".swarm", "plan.json");
-  if (!fs32.existsSync(planPath)) {
+  const planPath = path44.resolve(directory, ".swarm", "plan.json");
+  if (!fs33.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -56686,7 +57318,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs32.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs33.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -56739,8 +57371,252 @@ var declare_scope = createSwarmTool({
 });
 // src/tools/diff.ts
 init_dist();
-init_create_tool();
 import { execFileSync } from "child_process";
+
+// src/diff/ast-diff.ts
+init_tree_sitter();
+import { extname as extname6 } from "path";
+
+// src/lang/registry.ts
+init_runtime();
+var languageDefinitions = [
+  {
+    id: "javascript",
+    extensions: [".js", ".jsx"],
+    commentNodes: ["comment", "line_comment", "block_comment"]
+  },
+  {
+    id: "typescript",
+    extensions: [".ts", ".tsx"],
+    commentNodes: ["comment", "line_comment", "block_comment"]
+  },
+  {
+    id: "python",
+    extensions: [".py"],
+    commentNodes: ["comment"]
+  },
+  {
+    id: "go",
+    extensions: [".go"],
+    commentNodes: ["comment"]
+  },
+  {
+    id: "rust",
+    extensions: [".rs"],
+    commentNodes: ["line_comment", "block_comment"]
+  }
+];
+var extensionMap = new Map;
+for (const definition of languageDefinitions) {
+  for (const extension of definition.extensions) {
+    extensionMap.set(extension, definition);
+  }
+}
+function getLanguageForExtension(extension) {
+  return extensionMap.get(extension.toLowerCase());
+}
+
+// src/diff/ast-diff.ts
+init_runtime();
+var QUERIES = {
+  javascript: `
+    (function_declaration name: (identifier) @func.name) @func.def
+    (class_declaration name: (type_identifier) @class.name) @class.def
+    (export_statement) @export
+    (import_statement) @import
+    (type_alias_declaration name: (type_identifier) @type.name) @type.def
+  `,
+  typescript: `
+    (function_declaration name: (identifier) @func.name) @func.def
+    (class_declaration name: (type_identifier) @class.name) @class.def
+    (export_statement) @export
+    (import_statement) @import
+    (type_alias_declaration name: (type_identifier) @type.name) @type.def
+    (interface_declaration name: (type_identifier) @interface.name) @interface.def
+  `,
+  python: `
+    (function_definition name: (identifier) @func.name) @func.def
+    (class_definition name: (identifier) @class.name) @class.def
+    (import_statement) @import
+    (expression_statement (assignment left: (identifier) @var.name)) @var.def
+  `,
+  go: `
+    (function_declaration name: (identifier) @func.name) @func.def
+    (type_declaration (type_spec name: (type_identifier) @type.name)) @type.def
+    (import_declaration) @import
+  `,
+  rust: `
+    (function_item name: (identifier) @func.name) @func.def
+    (struct_item name: (type_identifier) @struct.name) @struct.def
+    (impl_item type: (type_identifier) @impl.name) @impl.def
+    (use_declaration) @import
+  `
+};
+var AST_TIMEOUT_MS = 500;
+async function computeASTDiff(filePath, oldContent, newContent) {
+  const startTime = Date.now();
+  const extension = extname6(filePath).toLowerCase();
+  const language = getLanguageForExtension(extension);
+  if (!language) {
+    return {
+      filePath,
+      language: null,
+      changes: [],
+      durationMs: Date.now() - startTime,
+      usedAST: false
+    };
+  }
+  try {
+    const parser = await Promise.race([
+      loadGrammar(language.id),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("AST_TIMEOUT")), AST_TIMEOUT_MS))
+    ]);
+    const oldTree = parser.parse(oldContent);
+    const newTree = parser.parse(newContent);
+    if (!oldTree || !newTree) {
+      return {
+        filePath,
+        language: language.id,
+        changes: [],
+        durationMs: Date.now() - startTime,
+        usedAST: false,
+        error: "Failed to parse file"
+      };
+    }
+    const oldSymbols = extractSymbols(oldTree, language);
+    const newSymbols = extractSymbols(newTree, language);
+    const changes = compareSymbols(oldSymbols, newSymbols);
+    oldTree.delete();
+    newTree.delete();
+    return {
+      filePath,
+      language: language.id,
+      changes,
+      durationMs: Date.now() - startTime,
+      usedAST: true
+    };
+  } catch (error93) {
+    const errorMsg = error93 instanceof Error ? error93.message : "Unknown error";
+    if (errorMsg === "AST_TIMEOUT") {
+      console.warn(`[ast-diff] Timeout for ${filePath}, falling back to raw diff`);
+    }
+    return {
+      filePath,
+      language: language.id,
+      changes: [],
+      durationMs: Date.now() - startTime,
+      usedAST: false,
+      error: errorMsg
+    };
+  }
+}
+function extractSymbols(tree, language) {
+  const symbols = [];
+  const queryStr = QUERIES[language.id];
+  if (!queryStr) {
+    return symbols;
+  }
+  try {
+    const lang = tree.language;
+    if (!lang) {
+      return symbols;
+    }
+    const query = new Query(lang, queryStr);
+    const matches = query.matches(tree.rootNode);
+    for (const match of matches) {
+      const symbol3 = parseMatch(match, language.id);
+      if (symbol3) {
+        symbols.push(symbol3);
+      }
+    }
+  } catch {}
+  return symbols;
+}
+function parseMatch(match, languageId) {
+  const captures = match.captures;
+  const defCapture = captures.find((c) => c.name.endsWith(".def"));
+  const nameCapture = captures.find((c) => c.name.endsWith(".name"));
+  if (!defCapture)
+    return null;
+  const node = defCapture.node;
+  const nameNode = nameCapture?.node;
+  return {
+    category: inferCategory(captures[0]?.name || "other"),
+    name: nameNode?.text || "anonymous",
+    lineStart: node.startPosition.row + 1,
+    lineEnd: node.endPosition.row + 1,
+    signature: extractSignature(node, languageId)
+  };
+}
+function inferCategory(captureName) {
+  if (captureName.includes("func"))
+    return "function";
+  if (captureName.includes("class"))
+    return "class";
+  if (captureName.includes("type") || captureName.includes("interface") || captureName.includes("struct"))
+    return "type";
+  if (captureName.includes("export"))
+    return "export";
+  if (captureName.includes("import") || captureName.includes("use"))
+    return "import";
+  if (captureName.includes("var"))
+    return "variable";
+  return "other";
+}
+function extractSignature(node, languageId) {
+  if (languageId === "javascript" || languageId === "typescript") {
+    const paramsNode = node.children.find((c) => c !== null && c.type === "formal_parameters");
+    if (paramsNode) {
+      return paramsNode.text;
+    }
+  }
+  return;
+}
+function compareSymbols(oldSymbols, newSymbols) {
+  const changes = [];
+  const oldMap = new Map(oldSymbols.map((s) => [s.name, s]));
+  const newMap = new Map(newSymbols.map((s) => [s.name, s]));
+  for (const [name2, symbol3] of newMap) {
+    if (!oldMap.has(name2)) {
+      changes.push({
+        type: "added",
+        category: symbol3.category,
+        name: symbol3.name,
+        lineStart: symbol3.lineStart,
+        lineEnd: symbol3.lineEnd,
+        signature: symbol3.signature
+      });
+    } else {
+      const oldSymbol = oldMap.get(name2);
+      if (oldSymbol.lineStart !== symbol3.lineStart || oldSymbol.lineEnd !== symbol3.lineEnd || oldSymbol.signature !== symbol3.signature) {
+        changes.push({
+          type: "modified",
+          category: symbol3.category,
+          name: symbol3.name,
+          lineStart: symbol3.lineStart,
+          lineEnd: symbol3.lineEnd,
+          signature: symbol3.signature
+        });
+      }
+    }
+  }
+  for (const [name2, symbol3] of oldMap) {
+    if (!newMap.has(name2)) {
+      changes.push({
+        type: "removed",
+        category: symbol3.category,
+        name: symbol3.name,
+        lineStart: symbol3.lineStart,
+        lineEnd: symbol3.lineEnd,
+        signature: symbol3.signature
+      });
+    }
+  }
+  return changes;
+}
+
+// src/tools/diff.ts
+init_create_tool();
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
 var MAX_BUFFER_BYTES = 5 * 1024 * 1024;
@@ -56767,20 +57643,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path44 of paths) {
-    if (!path44 || path44.length === 0) {
+  for (const path45 of paths) {
+    if (!path45 || path45.length === 0) {
       return "empty path not allowed";
     }
-    if (path44.length > MAX_PATH_LENGTH) {
+    if (path45.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path44)) {
+    if (SHELL_METACHARACTERS2.test(path45)) {
       return "path contains shell metacharacters";
     }
-    if (path44.startsWith("-")) {
+    if (path45.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path44)) {
+    if (CONTROL_CHAR_PATTERN2.test(path45)) {
       return "path contains control characters";
     }
   }
@@ -56861,8 +57737,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path44 = parts2[2];
-          files.push({ path: path44, additions, deletions });
+          const path45 = parts2[2];
+          files.push({ path: path45, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -56888,13 +57764,62 @@ var diff = createSwarmTool({
       }
       const hasContractChanges = contractChanges.length > 0;
       const fileCount = files.length;
+      const astDiffs = [];
+      for (const file3 of files) {
+        try {
+          let oldContent;
+          let newContent;
+          if (base === "staged") {
+            oldContent = execFileSync("git", ["show", `HEAD:${file3.path}`], {
+              encoding: "utf-8",
+              timeout: 5000,
+              cwd: directory
+            });
+            newContent = execFileSync("git", ["show", `:${file3.path}`], {
+              encoding: "utf-8",
+              timeout: 5000,
+              cwd: directory
+            });
+          } else if (base === "unstaged") {
+            oldContent = execFileSync("git", ["show", `:${file3.path}`], {
+              encoding: "utf-8",
+              timeout: 5000,
+              cwd: directory
+            });
+            newContent = execFileSync("git", ["show", `HEAD:${file3.path}`], {
+              encoding: "utf-8",
+              timeout: 5000,
+              cwd: directory
+            });
+            const fsModule = await import("fs");
+            const pathModule = await import("path");
+            newContent = fsModule.readFileSync(pathModule.join(directory, file3.path), "utf-8");
+          } else {
+            oldContent = execFileSync("git", ["show", `${base}:${file3.path}`], {
+              encoding: "utf-8",
+              timeout: 5000,
+              cwd: directory
+            });
+            newContent = execFileSync("git", ["show", `HEAD:${file3.path}`], {
+              encoding: "utf-8",
+              timeout: 5000,
+              cwd: directory
+            });
+          }
+          const astResult = await computeASTDiff(file3.path, oldContent, newContent);
+          if (astResult && astResult.changes.length > 0) {
+            astDiffs.push(astResult);
+          }
+        } catch {}
+      }
       const truncated = diffLines.length > MAX_DIFF_LINES;
       const summary = truncated ? `${fileCount} files changed. Contract changes: ${hasContractChanges ? "YES" : "NO"}. (truncated to ${MAX_DIFF_LINES} lines)` : `${fileCount} files changed. Contract changes: ${hasContractChanges ? "YES" : "NO"}`;
       const result = {
         files,
         contractChanges,
         hasContractChanges,
-        summary
+        summary,
+        ...astDiffs.length > 0 ? { astDiffs } : {}
       };
       return JSON.stringify(result, null, 2);
     } catch (e) {
@@ -56912,9 +57837,9 @@ var diff = createSwarmTool({
 init_dist();
 init_schema();
 import * as crypto4 from "crypto";
-import * as fs33 from "fs";
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import * as path44 from "path";
+import * as fs34 from "fs";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import * as path45 from "path";
 init_create_tool();
 var SKIP_DIRECTORIES2 = new Set([
   "node_modules",
@@ -56939,7 +57864,7 @@ function normalizeSeparators(filePath) {
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename5 = path44.basename(filePath);
+  const basename5 = path45.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
       if (basename5 === pattern) {
@@ -56995,7 +57920,7 @@ function stripMarkdown(text) {
   return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s*[-*\u2022]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "").trim();
 }
 async function scanDocIndex(directory) {
-  const manifestPath = path44.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path45.join(directory, ".swarm", "doc-manifest.json");
   const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
   const extraPatterns = [
     "ARCHITECTURE.md",
@@ -57012,8 +57937,8 @@ async function scanDocIndex(directory) {
       let cacheValid = true;
       for (const file3 of existingManifest.files) {
         try {
-          const fullPath = path44.join(directory, file3.path);
-          const stat2 = fs33.statSync(fullPath);
+          const fullPath = path45.join(directory, file3.path);
+          const stat2 = fs34.statSync(fullPath);
           if (stat2.mtimeMs > new Date(existingManifest.scanned_at).getTime()) {
             cacheValid = false;
             break;
@@ -57031,7 +57956,7 @@ async function scanDocIndex(directory) {
   const discoveredFiles = [];
   let rawEntries;
   try {
-    rawEntries = fs33.readdirSync(directory, { recursive: true });
+    rawEntries = fs34.readdirSync(directory, { recursive: true });
   } catch {
     const manifest2 = {
       schema_version: 1,
@@ -57042,10 +57967,10 @@ async function scanDocIndex(directory) {
   }
   const entries = rawEntries.filter((e) => typeof e === "string");
   for (const entry of entries) {
-    const fullPath = path44.join(directory, entry);
+    const fullPath = path45.join(directory, entry);
     let stat2;
     try {
-      stat2 = fs33.statSync(fullPath);
+      stat2 = fs34.statSync(fullPath);
     } catch {
       continue;
     }
@@ -57074,11 +57999,11 @@ async function scanDocIndex(directory) {
     }
     let content;
     try {
-      content = fs33.readFileSync(fullPath, "utf-8");
+      content = fs34.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
-    const { title, summary } = extractTitleAndSummary(content, path44.basename(entry));
+    const { title, summary } = extractTitleAndSummary(content, path45.basename(entry));
     const lineCount = content.split(`
 `).length;
     discoveredFiles.push({
@@ -57104,7 +58029,7 @@ async function scanDocIndex(directory) {
     files: discoveredFiles
   };
   try {
-    await mkdir5(path44.dirname(manifestPath), { recursive: true });
+    await mkdir6(path45.dirname(manifestPath), { recursive: true });
     await writeFile5(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
@@ -57154,7 +58079,7 @@ function extractConstraintsFromContent(content) {
   return constraints;
 }
 async function extractDocConstraints(directory, taskFiles, taskDescription) {
-  const manifestPath = path44.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path45.join(directory, ".swarm", "doc-manifest.json");
   let manifest;
   try {
     const content = await readFile6(manifestPath, "utf-8");
@@ -57180,7 +58105,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
     }
     let fullContent;
     try {
-      fullContent = await readFile6(path44.join(directory, docFile.path), "utf-8");
+      fullContent = await readFile6(path45.join(directory, docFile.path), "utf-8");
     } catch {
       skippedCount++;
       continue;
@@ -57203,7 +58128,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
           tier: "swarm",
           lesson: constraint,
           category: "architecture",
-          tags: ["doc-scan", path44.basename(docFile.path)],
+          tags: ["doc-scan", path45.basename(docFile.path)],
           scope: "global",
           confidence: 0.5,
           status: "candidate",
@@ -57249,9 +58174,9 @@ var doc_scan = createSwarmTool({
       }
     } catch {}
     if (force) {
-      const manifestPath = path44.join(directory, ".swarm", "doc-manifest.json");
+      const manifestPath = path45.join(directory, ".swarm", "doc-manifest.json");
       try {
-        fs33.unlinkSync(manifestPath);
+        fs34.unlinkSync(manifestPath);
       } catch {}
     }
     const { manifest, cached: cached3 } = await scanDocIndex(directory);
@@ -57476,8 +58401,8 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs34 from "fs";
-import * as path45 from "path";
+import * as fs35 from "fs";
+import * as path46 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR2 = ".swarm/evidence";
@@ -57507,9 +58432,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path45.resolve(cwd);
-  const swarmPath = path45.join(normalizedCwd, ".swarm");
-  const normalizedPath = path45.resolve(filePath);
+  const normalizedCwd = path46.resolve(cwd);
+  const swarmPath = path46.join(normalizedCwd, ".swarm");
+  const normalizedPath = path46.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -57525,12 +58450,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs34.existsSync(evidenceDir) || !fs34.statSync(evidenceDir).isDirectory()) {
+  if (!fs35.existsSync(evidenceDir) || !fs35.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs34.readdirSync(evidenceDir);
+    files = fs35.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -57539,14 +58464,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path45.join(evidenceDir, filename);
+    const filePath = path46.join(evidenceDir, filename);
     try {
-      const resolvedPath = path45.resolve(filePath);
-      const evidenceDirResolved = path45.resolve(evidenceDir);
+      const resolvedPath = path46.resolve(filePath);
+      const evidenceDirResolved = path46.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs34.lstatSync(filePath);
+      const stat2 = fs35.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -57555,7 +58480,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs34.statSync(filePath);
+      fileStat = fs35.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -57564,7 +58489,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs34.readFileSync(filePath, "utf-8");
+      content = fs35.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -57660,7 +58585,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 = path45.join(cwd, PLAN_FILE);
+    const planPath = path46.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -57674,7 +58599,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs34.readFileSync(planPath, "utf-8");
+      planContent = fs35.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -57692,7 +58617,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path45.join(cwd, EVIDENCE_DIR2);
+    const evidenceDir = path46.join(cwd, EVIDENCE_DIR2);
     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;
@@ -57709,8 +58634,8 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs35 from "fs";
-import * as path46 from "path";
+import * as fs36 from "fs";
+import * as path47 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -57772,8 +58697,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs35.existsSync(targetDir)) {
-      fs35.mkdirSync(targetDir, { recursive: true });
+    if (!fs36.existsSync(targetDir)) {
+      fs36.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -57791,16 +58716,16 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path46.join(targetDir, filename);
-      const base = path46.basename(filepath, path46.extname(filepath));
-      const ext = path46.extname(filepath);
+      let filepath = path47.join(targetDir, filename);
+      const base = path47.basename(filepath, path47.extname(filepath));
+      const ext = path47.extname(filepath);
       let counter = 1;
-      while (fs35.existsSync(filepath)) {
-        filepath = path46.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs36.existsSync(filepath)) {
+        filepath = path47.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs35.writeFileSync(filepath, code.trim(), "utf-8");
+        fs36.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -57916,8 +58841,8 @@ var gitingest = createSwarmTool({
 // src/tools/imports.ts
 init_dist();
 init_create_tool();
-import * as fs36 from "fs";
-import * as path47 from "path";
+import * as fs37 from "fs";
+import * as path48 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
@@ -57971,7 +58896,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path47.extname(filePath).toLowerCase();
+  const ext = path48.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -57995,15 +58920,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path47.resolve(targetFile);
+    _resolvedTarget = path48.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path47.basename(targetFile, path47.extname(targetFile));
+  const targetBasename = path48.basename(targetFile, path48.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path47.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path47.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path48.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path48.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];
@@ -58026,9 +58951,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path47.dirname(targetFile);
-    const targetExt = path47.extname(targetFile);
-    const targetBasenameNoExt = path47.basename(targetFile, targetExt);
+    const _targetDir = path48.dirname(targetFile);
+    const targetExt = path48.extname(targetFile);
+    const targetBasenameNoExt = path48.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, "");
@@ -58085,7 +59010,7 @@ var SKIP_DIRECTORIES3 = new Set([
 function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs36.readdirSync(dir);
+    entries = fs37.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -58096,13 +59021,13 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES3.has(entry)) {
-      stats.skippedDirs.push(path47.join(dir, entry));
+      stats.skippedDirs.push(path48.join(dir, entry));
       continue;
     }
-    const fullPath = path47.join(dir, entry);
+    const fullPath = path48.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs36.statSync(fullPath);
+      stat2 = fs37.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -58113,7 +59038,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
     if (stat2.isDirectory()) {
       findSourceFiles(fullPath, files, stats);
     } else if (stat2.isFile()) {
-      const ext = path47.extname(fullPath).toLowerCase();
+      const ext = path48.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -58170,8 +59095,8 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path47.resolve(file3);
-      if (!fs36.existsSync(targetFile)) {
+      const targetFile = path48.resolve(file3);
+      if (!fs37.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -58181,7 +59106,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs36.statSync(targetFile);
+      const targetStat = fs37.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -58192,7 +59117,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path47.dirname(targetFile);
+      const baseDir = path48.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -58207,12 +59132,12 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs36.statSync(filePath);
+          const stat2 = fs37.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs36.readFileSync(filePath);
+          const buffer = fs37.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -58767,8 +59692,8 @@ init_dist();
 init_config();
 init_schema();
 init_manager();
-import * as fs37 from "fs";
-import * as path48 from "path";
+import * as fs38 from "fs";
+import * as path49 from "path";
 init_utils2();
 init_telemetry();
 init_create_tool();
@@ -58988,11 +59913,11 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       safeWarn(`[phase_complete] Completion verify error (non-blocking):`, completionError);
     }
     try {
-      const driftEvidencePath = path48.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+      const driftEvidencePath = path49.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
       let driftVerdictFound = false;
       let driftVerdictApproved = false;
       try {
-        const driftEvidenceContent = fs37.readFileSync(driftEvidencePath, "utf-8");
+        const driftEvidenceContent = fs38.readFileSync(driftEvidencePath, "utf-8");
         const driftEvidence = JSON.parse(driftEvidenceContent);
         const entries = driftEvidence.entries ?? [];
         for (const entry of entries) {
@@ -59022,14 +59947,14 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         driftVerdictFound = false;
       }
       if (!driftVerdictFound) {
-        const specPath = path48.join(dir, ".swarm", "spec.md");
-        const specExists = fs37.existsSync(specPath);
+        const specPath = path49.join(dir, ".swarm", "spec.md");
+        const specExists = fs38.existsSync(specPath);
         if (!specExists) {
           let incompleteTaskCount = 0;
           let planPhaseFound = false;
           try {
             const planPath = validateSwarmPath(dir, "plan.json");
-            const planRaw = fs37.readFileSync(planPath, "utf-8");
+            const planRaw = fs38.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
             const targetPhase = plan.phases.find((p) => p.id === phase);
             if (targetPhase) {
@@ -59096,7 +60021,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   };
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path48.basename(dir);
+      const projectName = path49.basename(dir);
       await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
     } catch (error93) {
       safeWarn("[phase_complete] Failed to curate lessons from retrospective:", error93);
@@ -59139,7 +60064,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs37.readFileSync(planPath, "utf-8");
+      const planRaw = fs38.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && targetPhase.tasks.every((t) => t.status === "completed")) {
@@ -59170,7 +60095,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs37.readFileSync(planPath, "utf-8");
+      const planRaw = fs38.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -59208,7 +60133,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs37.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs38.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
     warnings.push(`Warning: failed to write phase complete event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -59229,12 +60154,12 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     }
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planJson = fs37.readFileSync(planPath, "utf-8");
+      const planJson = fs38.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planJson);
       const phaseObj = plan.phases.find((p) => p.id === phase);
       if (phaseObj) {
         phaseObj.status = "completed";
-        fs37.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
+        fs38.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
 `, "utf-8");
       }
     } catch (error93) {
@@ -59288,8 +60213,8 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs38 from "fs";
-import * as path49 from "path";
+import * as fs39 from "fs";
+import * as path50 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -59307,28 +60232,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs38.existsSync(path49.join(cwd, "package.json"))) {
+  if (fs39.existsSync(path50.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs38.existsSync(path49.join(cwd, "pyproject.toml")) || fs38.existsSync(path49.join(cwd, "requirements.txt"))) {
+  if (fs39.existsSync(path50.join(cwd, "pyproject.toml")) || fs39.existsSync(path50.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs38.existsSync(path49.join(cwd, "Cargo.toml"))) {
+  if (fs39.existsSync(path50.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs38.existsSync(path49.join(cwd, "go.mod"))) {
+  if (fs39.existsSync(path50.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs38.readdirSync(cwd);
+    const files = fs39.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs38.existsSync(path49.join(cwd, "Gemfile")) || fs38.existsSync(path49.join(cwd, "Gemfile.lock"))) {
+  if (fs39.existsSync(path50.join(cwd, "Gemfile")) || fs39.existsSync(path50.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs38.existsSync(path49.join(cwd, "pubspec.yaml"))) {
+  if (fs39.existsSync(path50.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -60328,47 +61253,6 @@ var pkg_audit = createSwarmTool({
 });
 // src/tools/placeholder-scan.ts
 init_manager();
-
-// src/lang/registry.ts
-init_runtime();
-var languageDefinitions = [
-  {
-    id: "javascript",
-    extensions: [".js", ".jsx"],
-    commentNodes: ["comment", "line_comment", "block_comment"]
-  },
-  {
-    id: "typescript",
-    extensions: [".ts", ".tsx"],
-    commentNodes: ["comment", "line_comment", "block_comment"]
-  },
-  {
-    id: "python",
-    extensions: [".py"],
-    commentNodes: ["comment"]
-  },
-  {
-    id: "go",
-    extensions: [".go"],
-    commentNodes: ["comment"]
-  },
-  {
-    id: "rust",
-    extensions: [".rs"],
-    commentNodes: ["line_comment", "block_comment"]
-  }
-];
-var extensionMap = new Map;
-for (const definition of languageDefinitions) {
-  for (const extension of definition.extensions) {
-    extensionMap.set(extension, definition);
-  }
-}
-function getLanguageForExtension(extension) {
-  return extensionMap.get(extension.toLowerCase());
-}
-
-// src/tools/placeholder-scan.ts
 init_utils();
 var MAX_FILE_SIZE = 1024 * 1024;
 var SUPPORTED_PARSER_EXTENSIONS = new Set([
@@ -60390,8 +61274,8 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs41 from "fs";
-import * as path52 from "path";
+import * as fs42 from "fs";
+import * as path53 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -60559,8 +61443,8 @@ init_lint();
 init_manager();
 
 // src/quality/metrics.ts
-import * as fs39 from "fs";
-import * as path50 from "path";
+import * as fs40 from "fs";
+import * as path51 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -60598,11 +61482,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs39.statSync(filePath);
+    const stat2 = fs40.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs39.readFileSync(filePath, "utf-8");
+    const content = fs40.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -60612,8 +61496,8 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path50.isAbsolute(file3) ? file3 : path50.join(workingDir, file3);
-    if (!fs39.existsSync(fullPath)) {
+    const fullPath = path51.isAbsolute(file3) ? file3 : path51.join(workingDir, file3);
+    if (!fs40.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -60734,8 +61618,8 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs39.readFileSync(filePath, "utf-8");
-    const ext = path50.extname(filePath).toLowerCase();
+    const content = fs40.readFileSync(filePath, "utf-8");
+    const ext = path51.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -60761,8 +61645,8 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path50.isAbsolute(file3) ? file3 : path50.join(workingDir, file3);
-    if (!fs39.existsSync(fullPath)) {
+    const fullPath = path51.isAbsolute(file3) ? file3 : path51.join(workingDir, file3);
+    if (!fs40.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -60795,16 +61679,16 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path50.isAbsolute(file3) ? file3 : path50.join(workingDir, file3);
-    if (!fs39.existsSync(fullPath)) {
+    const fullPath = path51.isAbsolute(file3) ? file3 : path51.join(workingDir, file3);
+    if (!fs40.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs39.statSync(fullPath);
+      const stat2 = fs40.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES5) {
         continue;
       }
-      const content = fs39.readFileSync(fullPath, "utf-8");
+      const content = fs40.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -60828,8 +61712,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename9 = path50.basename(filePath);
-  const _ext = path50.extname(filePath).toLowerCase();
+  const basename9 = path51.basename(filePath);
+  const _ext = path51.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -60910,8 +61794,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path51, glob) {
-  const normalizedPath = path51.replace(/\\/g, "/");
+function matchesGlobSegment(path52, glob) {
+  const normalizedPath = path52.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -60942,8 +61826,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path51, glob) {
-  const normalizedPath = path51.replace(/\\/g, "/");
+function globMatches(path52, glob) {
+  const normalizedPath = path52.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -60979,31 +61863,31 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path50.join(workingDir, "src");
-  if (fs39.existsSync(srcDir)) {
+  const srcDir = path51.join(workingDir, "src");
+  if (fs40.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path50.join(workingDir, dir);
-    if (fs39.existsSync(dirPath)) {
+    const dirPath = path51.join(workingDir, dir);
+    if (fs40.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path50.join(workingDir, "tests");
-  if (fs39.existsSync(testsDir)) {
+  const testsDir = path51.join(workingDir, "tests");
+  if (fs40.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path50.join(workingDir, dir);
-    if (fs39.existsSync(dirPath) && dirPath !== testsDir) {
+    const dirPath = path51.join(workingDir, dir);
+    if (fs40.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -61015,9 +61899,9 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs39.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs40.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path50.join(dirPath, entry.name);
+      const fullPath = path51.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -61025,7 +61909,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 = path50.extname(entry.name).toLowerCase();
+        const ext = path51.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -61061,7 +61945,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs39.readFileSync(fullPath, "utf-8");
+          const content = fs40.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -61275,9 +62159,9 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs40 from "fs";
-import * as path51 from "path";
-import { extname as extname9 } from "path";
+import * as fs41 from "fs";
+import * as path52 from "path";
+import { extname as extname10 } from "path";
 
 // src/sast/rules/c.ts
 var cRules = [
@@ -62143,17 +63027,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs40.statSync(filePath);
+    const stats = fs41.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES6) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs40.openSync(filePath, "r");
+    const fd = fs41.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs40.readSync(fd, buffer, 0, 8192, 0);
-    fs40.closeSync(fd);
+    const bytesRead = fs41.readSync(fd, buffer, 0, 8192, 0);
+    fs41.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -62192,7 +63076,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs40.readFileSync(filePath, "utf-8");
+    const content = fs41.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -62239,8 +63123,8 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path51.isAbsolute(filePath) ? filePath : path51.resolve(directory, filePath);
-    if (!fs40.existsSync(resolvedPath)) {
+    const resolvedPath = path52.isAbsolute(filePath) ? filePath : path52.resolve(directory, filePath);
+    if (!fs41.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -62249,7 +63133,7 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const ext = extname9(resolvedPath).toLowerCase();
+    const ext = extname10(resolvedPath).toLowerCase();
     const profile = getProfileForFile(resolvedPath);
     const langDef = getLanguageForExtension(ext);
     if (!profile && !langDef) {
@@ -62438,18 +63322,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path52.win32.resolve(inputPath);
-  } else if (path52.isAbsolute(inputPath)) {
-    resolved = path52.resolve(inputPath);
+    resolved = path53.win32.resolve(inputPath);
+  } else if (path53.isAbsolute(inputPath)) {
+    resolved = path53.resolve(inputPath);
   } else {
-    resolved = path52.resolve(baseDir, inputPath);
+    resolved = path53.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path52.resolve(workspaceDir);
+  const workspaceResolved = path53.resolve(workspaceDir);
   let relative6;
   if (isWinAbs) {
-    relative6 = path52.win32.relative(workspaceResolved, resolved);
+    relative6 = path53.win32.relative(workspaceResolved, resolved);
   } else {
-    relative6 = path52.relative(workspaceResolved, resolved);
+    relative6 = path53.relative(workspaceResolved, resolved);
   }
   if (relative6.startsWith("..")) {
     return "path traversal detected";
@@ -62510,13 +63394,13 @@ async function runLintWrapped(files, directory, _config) {
 }
 async function runLintOnFiles(linter, files, workspaceDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path52.join(workspaceDir, "node_modules", ".bin");
+  const binDir = path53.join(workspaceDir, "node_modules", ".bin");
   const validatedFiles = [];
   for (const file3 of files) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path52.resolve(file3);
+    const resolvedPath = path53.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -62534,10 +63418,10 @@ async function runLintOnFiles(linter, files, workspaceDir) {
   }
   let command;
   if (linter === "biome") {
-    const biomeBin = isWindows ? path52.join(binDir, "biome.EXE") : path52.join(binDir, "biome");
+    const biomeBin = isWindows ? path53.join(binDir, "biome.EXE") : path53.join(binDir, "biome");
     command = [biomeBin, "check", ...validatedFiles];
   } else {
-    const eslintBin = isWindows ? path52.join(binDir, "eslint.cmd") : path52.join(binDir, "eslint");
+    const eslintBin = isWindows ? path53.join(binDir, "eslint.cmd") : path53.join(binDir, "eslint");
     command = [eslintBin, ...validatedFiles];
   }
   try {
@@ -62674,7 +63558,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path52.resolve(file3);
+      const resolvedPath = path53.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -62692,14 +63576,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path52.extname(file3).toLowerCase();
+      const ext = path53.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat2;
       try {
-        stat2 = fs41.statSync(file3);
+        stat2 = fs42.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -62710,7 +63594,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs41.readFileSync(file3);
+        const buffer = fs42.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -62851,7 +63735,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path52.resolve(directory, file3));
+    changedFiles.push(path53.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -63022,7 +63906,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path52.resolve(typedArgs.directory);
+    const resolvedDirectory = path53.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory3(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -63128,10 +64012,72 @@ ${paginatedContent}`;
 });
 // src/tools/save-plan.ts
 init_tool();
+import * as fs44 from "fs";
+import * as path55 from "path";
+
+// src/parallel/file-locks.ts
+import * as fs43 from "fs";
+import * as path54 from "path";
+var LOCKS_DIR = ".swarm/locks";
+var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
+function getLockFilePath(directory, filePath) {
+  if (filePath.includes("..")) {
+    throw new Error("Invalid file path: path traversal not allowed");
+  }
+  const hash3 = Buffer.from(filePath).toString("base64").replace(/[/+=]/g, "_");
+  return path54.join(directory, LOCKS_DIR, `${hash3}.lock`);
+}
+function tryAcquireLock(directory, filePath, agent, taskId) {
+  const lockPath = getLockFilePath(directory, filePath);
+  const locksDir = path54.dirname(lockPath);
+  if (!fs43.existsSync(locksDir)) {
+    fs43.mkdirSync(locksDir, { recursive: true });
+  }
+  if (fs43.existsSync(lockPath)) {
+    try {
+      const existingLock = JSON.parse(fs43.readFileSync(lockPath, "utf-8"));
+      if (Date.now() > existingLock.expiresAt) {
+        fs43.unlinkSync(lockPath);
+      } else {
+        return { acquired: false, existing: existingLock };
+      }
+    } catch {
+      fs43.unlinkSync(lockPath);
+    }
+  }
+  const lock = {
+    filePath,
+    agent,
+    taskId,
+    timestamp: new Date().toISOString(),
+    expiresAt: Date.now() + LOCK_TIMEOUT_MS
+  };
+  const tempPath = `${lockPath}.tmp`;
+  fs43.writeFileSync(tempPath, JSON.stringify(lock, null, 2), "utf-8");
+  fs43.renameSync(tempPath, lockPath);
+  return { acquired: true, lock };
+}
+function releaseLock(directory, filePath, taskId) {
+  const lockPath = getLockFilePath(directory, filePath);
+  if (!fs43.existsSync(lockPath)) {
+    return true;
+  }
+  try {
+    const lock = JSON.parse(fs43.readFileSync(lockPath, "utf-8"));
+    if (lock.taskId === taskId) {
+      fs43.unlinkSync(lockPath);
+      return true;
+    }
+    return false;
+  } catch {
+    fs43.unlinkSync(lockPath);
+    return true;
+  }
+}
+
+// src/tools/save-plan.ts
 init_manager2();
 init_create_tool();
-import * as fs42 from "fs";
-import * as path53 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
   const placeholderPattern = /^\[\w[\w\s]*\]$/;
@@ -63232,25 +64178,42 @@ async function executeSavePlan(args2, fallbackDir) {
   };
   const tasksCount = plan.phases.reduce((acc, phase) => acc + phase.tasks.length, 0);
   const dir = targetWorkspace;
+  const lockTaskId = `save-plan-${Date.now()}`;
+  const planFilePath = "plan.json";
   try {
-    await savePlan(dir, plan);
+    const lockResult = tryAcquireLock(dir, planFilePath, "architect", lockTaskId);
+    if (!lockResult.acquired) {
+      return {
+        success: false,
+        message: `Plan write blocked: file is locked by ${lockResult.existing?.agent ?? "another agent"} (task: ${lockResult.existing?.taskId ?? "unknown"})`,
+        errors: [
+          "Concurrent plan write detected \u2014 retry after the current write completes"
+        ],
+        recovery_guidance: "Wait a moment and retry save_plan. The lock will expire automatically if the holding agent fails."
+      };
+    }
     try {
-      const markerPath = path53.join(dir, ".swarm", ".plan-write-marker");
-      const marker = JSON.stringify({
-        source: "save_plan",
-        timestamp: new Date().toISOString(),
+      await savePlan(dir, plan);
+      try {
+        const markerPath = path55.join(dir, ".swarm", ".plan-write-marker");
+        const marker = JSON.stringify({
+          source: "save_plan",
+          timestamp: new Date().toISOString(),
+          phases_count: plan.phases.length,
+          tasks_count: tasksCount
+        });
+        await fs44.promises.writeFile(markerPath, marker, "utf8");
+      } catch {}
+      return {
+        success: true,
+        message: "Plan saved successfully",
+        plan_path: path55.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount
-      });
-      await fs42.promises.writeFile(markerPath, marker, "utf8");
-    } catch {}
-    return {
-      success: true,
-      message: "Plan saved successfully",
-      plan_path: path53.join(dir, ".swarm", "plan.json"),
-      phases_count: plan.phases.length,
-      tasks_count: tasksCount
-    };
+      };
+    } finally {
+      releaseLock(dir, planFilePath, lockTaskId);
+    }
   } catch (error93) {
     return {
       success: false,
@@ -63285,8 +64248,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs43 from "fs";
-import * as path54 from "path";
+import * as fs45 from "fs";
+import * as path56 from "path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -64132,9 +65095,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs43.readdirSync(dir, { withFileTypes: true });
+      const entries = fs45.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path54.join(dir, entry.name);
+        const fullPath = path56.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -64143,7 +65106,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path54.relative(rootDir, fullPath));
+              manifestFiles.push(path56.relative(rootDir, fullPath));
               break;
             }
           }
@@ -64159,13 +65122,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs43.readdirSync(dir, { withFileTypes: true });
+      const entries = fs45.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path54.join(dir, entry.name);
+        const fullPath = path56.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path54.relative(workingDir, fullPath));
+              found.push(path56.relative(workingDir, fullPath));
               break;
             }
           }
@@ -64178,11 +65141,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path54.dirname(file3);
+    let currentDir = path56.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path54.sep) {
-        dirs.add(path54.join(workingDir, currentDir));
-        const parent = path54.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path56.sep) {
+        dirs.add(path56.join(workingDir, currentDir));
+        const parent = path56.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -64196,7 +65159,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs43.mkdirSync(outputDir, { recursive: true });
+    fs45.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -64266,7 +65229,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path54.isAbsolute(relativeOutputDir) ? relativeOutputDir : path54.join(workingDir, relativeOutputDir);
+    const outputDir = path56.isAbsolute(relativeOutputDir) ? relativeOutputDir : path56.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -64289,11 +65252,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path54.isAbsolute(manifestFile) ? manifestFile : path54.join(workingDir, manifestFile);
-        if (!fs43.existsSync(fullPath)) {
+        const fullPath = path56.isAbsolute(manifestFile) ? manifestFile : path56.join(workingDir, manifestFile);
+        if (!fs45.existsSync(fullPath)) {
           continue;
         }
-        const content = fs43.readFileSync(fullPath, "utf-8");
+        const content = fs45.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -64306,8 +65269,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path54.join(outputDir, filename);
-    fs43.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path56.join(outputDir, filename);
+    fs45.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -64349,8 +65312,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs44 from "fs";
-import * as path55 from "path";
+import * as fs46 from "fs";
+import * as path57 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -64382,28 +65345,28 @@ function normalizePath2(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path55.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path55.sep) ? cwd : cwd + path55.sep;
+    const resolvedPath = path57.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path57.sep) ? cwd : cwd + path57.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path55.extname(resolvedPath).toLowerCase();
+    const ext = path57.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs44.statSync(resolvedPath);
+    const stats = fs46.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs44.existsSync(resolvedPath)) {
+    if (!fs46.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path55.resolve(cwd, candidate);
-    if (fs44.existsSync(candidatePath)) {
-      const stats = fs44.statSync(candidatePath);
+    const candidatePath = path57.resolve(cwd, candidate);
+    if (fs46.existsSync(candidatePath)) {
+      const stats = fs46.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -64412,8 +65375,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs44.readFileSync(specFile, "utf-8");
-  const ext = path55.extname(specFile).toLowerCase();
+  const content = fs46.readFileSync(specFile, "utf-8");
+  const ext = path57.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -64484,12 +65447,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs44.readdirSync(dir, { withFileTypes: true });
+      entries = fs46.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path55.join(dir, entry.name);
+      const fullPath = path57.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -64499,7 +65462,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path55.extname(entry.name).toLowerCase();
+        const ext = path57.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -64517,7 +65480,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs44.readFileSync(filePath, "utf-8");
+  const content = fs46.readFileSync(filePath, "utf-8");
   const lines = content.split(/\r?\n/);
   const expressRegex = /(?:app|router|server|express)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/g;
   const flaskRegex = /@(?:app|blueprint|bp)\.route\s*\(\s*['"]([^'"]+)['"]/g;
@@ -64668,8 +65631,8 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs45 from "fs";
-import * as path56 from "path";
+import * as fs47 from "fs";
+import * as path58 from "path";
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsControlCharacters(str) {
@@ -64698,11 +65661,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path56.resolve(workspace, filePath);
-    const realWorkspace = fs45.realpathSync(workspace);
-    const realResolvedPath = fs45.realpathSync(resolvedPath);
-    const relativePath = path56.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path56.isAbsolute(relativePath)) {
+    const resolvedPath = path58.resolve(workspace, filePath);
+    const realWorkspace = fs47.realpathSync(workspace);
+    const realResolvedPath = fs47.realpathSync(resolvedPath);
+    const relativePath = path58.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path58.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -64714,17 +65677,17 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path56.join(cwd, filePath);
+  const fullPath = path58.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs45.statSync(fullPath);
+    const stats = fs47.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs45.readFileSync(fullPath, "utf-8");
+    content = fs47.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -64866,17 +65829,17 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path56.join(cwd, filePath);
+  const fullPath = path58.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs45.statSync(fullPath);
+    const stats = fs47.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs45.readFileSync(fullPath, "utf-8");
+    content = fs47.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -64949,7 +65912,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path56.extname(file3);
+    const ext = path58.extname(file3);
     if (containsControlCharacters(file3)) {
       return JSON.stringify({
         file: file3,
@@ -65020,8 +65983,8 @@ init_test_runner();
 init_dist();
 init_utils();
 init_create_tool();
-import * as fs46 from "fs";
-import * as path57 from "path";
+import * as fs48 from "fs";
+import * as path59 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -65092,9 +66055,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path57.resolve(paths);
-    const normalizedCwd = path57.resolve(cwd);
-    const normalizedResolved = path57.resolve(resolvedPath);
+    const resolvedPath = path59.resolve(paths);
+    const normalizedCwd = path59.resolve(cwd);
+    const normalizedResolved = path59.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -65110,13 +66073,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path57.extname(filePath).toLowerCase();
+  const ext = path59.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles2(dir, files = []) {
   let entries;
   try {
-    entries = fs46.readdirSync(dir);
+    entries = fs48.readdirSync(dir);
   } catch {
     return files;
   }
@@ -65125,10 +66088,10 @@ function findSourceFiles2(dir, files = []) {
     if (SKIP_DIRECTORIES4.has(entry)) {
       continue;
     }
-    const fullPath = path57.join(dir, entry);
+    const fullPath = path59.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs46.statSync(fullPath);
+      stat2 = fs48.statSync(fullPath);
     } catch {
       continue;
     }
@@ -65221,7 +66184,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs46.existsSync(scanPath)) {
+    if (!fs48.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -65231,13 +66194,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs46.statSync(scanPath);
+    const stat2 = fs48.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path57.extname(scanPath)}`,
+          error: `unsupported file extension: ${path59.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -65250,11 +66213,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs46.statSync(filePath);
+        const fileStat = fs48.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs46.readFileSync(filePath, "utf-8");
+        const content = fs48.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -65283,18 +66246,18 @@ var todo_extract = createSwarmTool({
 init_tool();
 init_schema();
 init_gate_evidence();
-import * as fs48 from "fs";
-import * as path59 from "path";
+import * as fs50 from "fs";
+import * as path61 from "path";
 
 // src/hooks/diff-scope.ts
-import * as fs47 from "fs";
-import * as path58 from "path";
+import * as fs49 from "fs";
+import * as path60 from "path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path58.join(directory, ".swarm", "plan.json");
-    if (!fs47.existsSync(planPath))
+    const planPath = path60.join(directory, ".swarm", "plan.json");
+    if (!fs49.existsSync(planPath))
       return null;
-    const raw = fs47.readFileSync(planPath, "utf-8");
+    const raw = fs49.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -65407,7 +66370,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path59.basename(file3);
+    const fileName = path61.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -65421,8 +66384,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     if (hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path59.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs48.readFileSync(planPath, "utf-8");
+        const planPath = path61.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs50.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -65488,8 +66451,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     try {
       const resolvedDir2 = workingDirectory;
-      const planPath = path59.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs48.readFileSync(planPath, "utf-8");
+      const planPath = path61.join(resolvedDir2, ".swarm", "plan.json");
+      const planRaw = fs50.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -65671,8 +66634,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path59.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path59.sep);
+    normalizedDir = path61.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path61.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -65682,11 +66645,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path59.resolve(normalizedDir);
+    const resolvedDir = path61.resolve(normalizedDir);
     try {
-      const realPath = fs48.realpathSync(resolvedDir);
-      const planPath = path59.join(realPath, ".swarm", "plan.json");
-      if (!fs48.existsSync(planPath)) {
+      const realPath = fs50.realpathSync(resolvedDir);
+      const planPath = path61.join(realPath, ".swarm", "plan.json");
+      if (!fs50.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -65907,10 +66870,11 @@ var OpenCodeSwarm = async (ctx) => {
   let statusArtifact;
   if (automationConfig.mode !== "manual") {
     automationManager = createAutomationManager(automationConfig);
+    automationManager.start();
     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 = path60.resolve(ctx.directory, ".swarm");
+    const swarmDir = path62.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -65954,9 +66918,16 @@ var OpenCodeSwarm = async (ctx) => {
         });
       }
     }
+    const cleanupAutomation = () => {
+      automationManager?.stop();
+    };
+    process.on("exit", cleanupAutomation);
+    process.on("SIGINT", cleanupAutomation);
+    process.on("SIGTERM", cleanupAutomation);
     log("Automation framework initialized", {
       mode: automationConfig.mode,
       enabled: automationManager?.isEnabled(),
+      running: automationManager?.isActive(),
       preflightEnabled: preflightTriggerManager?.isEnabled()
     });
   }
@@ -66221,6 +67192,7 @@ var OpenCodeSwarm = async (ctx) => {
       }
       await guardrailsHooks.toolBefore(input, output);
       await scopeGuardHook.toolBefore(input, output);
+      await delegationGateHooks.toolBefore(input, output);
       if (swarmState.lastBudgetPct >= 50) {
         const pressureSession = ensureAgentSession(input.sessionID, swarmState.activeAgent.get(input.sessionID) ?? ORCHESTRATOR_NAME);
         if (!pressureSession.contextPressureWarningSent) {
@@ -66254,6 +67226,37 @@ var OpenCodeSwarm = async (ctx) => {
         await safeHook(delegationGateHooks.toolAfter)(input, output);
         if (_dbg)
           console.error(`[DIAG] toolAfter delegationGate done tool=${_toolName}`);
+        if (isTaskTool && typeof output.output === "string") {
+          try {
+            const adversarialMatches = detectAdversarialPatterns(output.output);
+            if (adversarialMatches.length > 0) {
+              const sessionId = input.sessionID;
+              const session = swarmState.agentSessions.get(sessionId);
+              if (session) {
+                session.pendingAdvisoryMessages ??= [];
+                session.pendingAdvisoryMessages.push(`ADVERSARIAL PATTERN DETECTED: ${adversarialMatches.map((p) => p.pattern).join(", ")}. Review agent output for potential prompt injection or gate bypass.`);
+              }
+              if ("adversarialPatternDetected" in telemetry) {
+                telemetry.adversarialPatternDetected(input.sessionID, adversarialMatches);
+              }
+            }
+          } catch {}
+        }
+        try {
+          recordToolCall(normalizedTool, input.args);
+        } catch {}
+        try {
+          const spiralMatch = await detectDebuggingSpiral(ctx.directory);
+          if (spiralMatch) {
+            const taskId = swarmState.agentSessions.get(input.sessionID)?.currentTaskId ?? "unknown";
+            const spiralResult = await handleDebuggingSpiral(spiralMatch, taskId, ctx.directory);
+            const session = swarmState.agentSessions.get(input.sessionID);
+            if (session) {
+              session.pendingAdvisoryMessages ??= [];
+              session.pendingAdvisoryMessages.push(spiralResult.message);
+            }
+          }
+        } catch {}
         if (knowledgeCuratorHook)
           await safeHook(knowledgeCuratorHook)(input, output);
         if (hivePromoterHook)
@@ -66275,8 +67278,9 @@ var OpenCodeSwarm = async (ctx) => {
             await slopDetectorHook.toolAfter(input, output);
           if (incrementalVerifyHook)
             await incrementalVerifyHook.toolAfter(input, output);
-          if (compactionServiceHook)
-            await compactionServiceHook.toolAfter(input, output);
+        }
+        if (execMode !== "fast" && compactionServiceHook) {
+          await compactionServiceHook.toolAfter(input, output);
         }
         const toolOutputConfig = config3.tool_output;
         if (toolOutputConfig && toolOutputConfig.truncation_enabled !== false && typeof output.output === "string") {