opencode-swarm 7.47.0 → 7.48.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.47.0",
+    version: "7.48.0",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -616,6 +616,7 @@ var init_constants = __esm(() => {
       "syntax_check",
       "search",
       "summarize_work",
+      "knowledge_recall",
       "swarm_command"
     ],
     sme: [
@@ -81429,17 +81430,13 @@ var init_tool_policy = __esm(() => {
     "agents",
     "config",
     "config doctor",
-    "config-doctor",
-    "doctor",
     "doctor tools",
     "status",
     "show-plan",
-    "plan",
     "help",
     "history",
     "evidence",
     "evidence summary",
-    "evidence-summary",
     "retrieve",
     "diagnose",
     "preflight",
@@ -81456,8 +81453,7 @@ var init_tool_policy = __esm(() => {
     "memory import",
     "memory migrate",
     "sync-plan",
-    "export",
-    "list-agents"
+    "export"
   ];
   SWARM_COMMAND_TOOL_ALLOWLIST = new Set([
     "agents",
@@ -83441,7 +83437,7 @@ the safe \`spec_write\` tool. Use it when:
 - requirements decomposition is non-trivial,
 - you would otherwise inline-author \`.swarm/spec.md\` yourself.
 
-Continue handling small touch-ups (typos, cross-references) inline.
+Continue handling small touch-ups (typos, cross-references) via the spec_writer agent — the architect lacks the spec_write tool and must delegate all spec changes.
 
 ### ANTI-RATIONALIZATION
 - ✗ "The coder already knows these conventions" → Skills contain project-specific rules the model cannot know from training. Always pass.
@@ -83745,6 +83741,24 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Do NOT touch .swarm/spec.md, CHANGELOG.md, or docs/releases/pending/* in this mode.
 - Requires design_docs.enabled: true — if the docs_design agent is not registered, instruct the user to enable it and stop.
 
+### MODE: PR_REVIEW
+Activates when: architect receives \`[MODE: PR_REVIEW pr="https://github.com/..." council=true/false]\` signal from the pr-review command handler.
+
+Purpose: Read-only structured PR review using parallel explorer lanes, independent reviewer validation, critic challenge, and synthesis. Does NOT mutate source code. Does NOT delegate to coder.
+
+ACTION: Load skill file:.opencode/skills/swarm-pr-review/SKILL.md immediately and follow its protocol.
+
+HARD CONSTRAINTS (apply regardless of skill load success):
+- Do NOT delegate to coder
+- Do NOT call declare_scope
+- Do NOT mutate source code
+- Do NOT create or modify files outside .swarm/
+- The orchestrator MUST NOT classify, confirm, disprove, or judge explorer candidates — validation is exclusively the reviewer's job
+- Explorers produce candidates only — reviewers verify or reject — critics challenge HIGH/CRITICAL and borderline findings
+- No finding may appear as CONFIRMED in the final report without reviewer validation provenance
+- Test execution, explorer lanes, reviewer dispatch, and critic challenge are all permitted within this mode
+- Quality is the only metric — time, tokens, and agent dispatches are irrelevant to correctness
+
 ### MODE: ISSUE_INGEST
 Activates when the user invokes /swarm issue <url> or the architect receives an ISSUE_INGEST signal.
 
@@ -92278,11 +92292,11 @@ __export(exports_design_doc_drift, {
   runDesignDocDriftCheck: () => runDesignDocDriftCheck,
   _internals: () => _internals55
 });
-import * as fs89 from "node:fs";
-import * as path126 from "node:path";
+import * as fs94 from "node:fs";
+import * as path131 from "node:path";
 function mtimeMsOrNull(absPath) {
   try {
-    return fs89.statSync(absPath).mtimeMs;
+    return fs94.statSync(absPath).mtimeMs;
   } catch {
     return null;
   }
@@ -92290,40 +92304,40 @@ function mtimeMsOrNull(absPath) {
 function resolveAnchorWithin(directory, anchor) {
   if (!anchor || typeof anchor !== "string")
     return null;
-  const root = path126.resolve(directory);
-  const resolved = path126.resolve(root, anchor);
-  const rel = path126.relative(root, resolved);
-  if (rel.startsWith("..") || path126.isAbsolute(rel))
+  const root = path131.resolve(directory);
+  const resolved = path131.resolve(root, anchor);
+  const rel = path131.relative(root, resolved);
+  if (rel.startsWith("..") || path131.isAbsolute(rel))
     return null;
   return resolved;
 }
 async function runDesignDocDriftCheck(directory, phase, outDir) {
   try {
-    const root = path126.resolve(directory);
-    const outAbs = path126.resolve(root, outDir);
-    const outRel = path126.relative(root, outAbs);
-    if (outRel.startsWith("..") || path126.isAbsolute(outRel)) {
+    const root = path131.resolve(directory);
+    const outAbs = path131.resolve(root, outDir);
+    const outRel = path131.relative(root, outAbs);
+    if (outRel.startsWith("..") || path131.isAbsolute(outRel)) {
       return null;
     }
     const docMtimes = new Map;
     const checkedDocs = [];
     const missingDocs = [];
     for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
-      const abs = path126.join(outAbs, relFile);
+      const abs = path131.join(outAbs, relFile);
       const mtime = mtimeMsOrNull(abs);
       docMtimes.set(docName, mtime);
       if (mtime === null) {
-        missingDocs.push(path126.join(outDir, relFile));
+        missingDocs.push(path131.join(outDir, relFile));
       } else {
-        checkedDocs.push(path126.join(outDir, relFile));
+        checkedDocs.push(path131.join(outDir, relFile));
       }
     }
-    const traceabilityAbs = path126.join(outAbs, TRACEABILITY_REL);
+    const traceabilityAbs = path131.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
-      const stat9 = await fs89.promises.stat(traceabilityAbs);
+      const stat9 = await fs94.promises.stat(traceabilityAbs);
       if (stat9.size <= MAX_TRACEABILITY_BYTES) {
-        const raw = await fs89.promises.readFile(traceabilityAbs, "utf-8");
+        const raw = await fs94.promises.readFile(traceabilityAbs, "utf-8");
         const parsed = JSON.parse(raw);
         registry3 = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
       }
@@ -92331,7 +92345,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
       registry3 = null;
     }
     const noDocs = checkedDocs.length === 0 || registry3 === null;
-    const specMtime = mtimeMsOrNull(path126.join(root, ".swarm", "spec.md"));
+    const specMtime = mtimeMsOrNull(path131.join(root, ".swarm", "spec.md"));
     const staleSections = [];
     if (!noDocs && Array.isArray(registry3?.sections)) {
       for (const section of registry3.sections) {
@@ -92387,8 +92401,8 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     };
     const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
     const filePath = validateSwarmPath(directory, filename);
-    await fs89.promises.mkdir(path126.dirname(filePath), { recursive: true });
-    await fs89.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs94.promises.mkdir(path131.dirname(filePath), { recursive: true });
+    await fs94.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
     getGlobalEventBus().publish("curator.docdrift.completed", {
       phase,
       verdict,
@@ -92418,10 +92432,10 @@ var init_design_doc_drift = __esm(() => {
     domain: "domain.md",
     "technical-spec": "technical-spec.md",
     "behavior-spec": "behavior-spec.md",
-    "reference-impl": path126.join("reference", "reference-impl.md"),
-    "idiom-notes": path126.join("reference", "idiom-notes.md")
+    "reference-impl": path131.join("reference", "reference-impl.md"),
+    "idiom-notes": path131.join("reference", "idiom-notes.md")
   };
-  TRACEABILITY_REL = path126.join("reference", "traceability.json");
+  TRACEABILITY_REL = path131.join("reference", "traceability.json");
   _internals55 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
@@ -92436,12 +92450,12 @@ __export(exports_project_context, {
   _internals: () => _internals71,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
-import * as fs118 from "node:fs";
-import * as path161 from "node:path";
+import * as fs123 from "node:fs";
+import * as path166 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
-      const files = fs118.readdirSync(directory);
+      const files = fs123.readdirSync(directory);
       const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
       return files.some((f) => regex.test(f));
     } catch {
@@ -92449,7 +92463,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs118.accessSync(path161.join(directory, pattern));
+    fs123.accessSync(path166.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -92458,7 +92472,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs118.readFileSync(path161.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs123.readFileSync(path166.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -92567,7 +92581,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path162 from "node:path";
+import * as path167 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -111461,10 +111475,9 @@ init_lint();
 init_zod();
 init_config();
 init_schema();
-init_qa_gate_profile();
 init_manager2();
-import * as fs90 from "node:fs";
-import * as path127 from "node:path";
+import * as fs95 from "node:fs";
+import * as path132 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
@@ -111643,7 +111656,6 @@ init_ledger();
 init_manager();
 init_snapshot_writer();
 init_state();
-init_store();
 init_telemetry();
 
 // src/turbo/lean/phase-ready.ts
@@ -112137,12 +112149,765 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
 // src/tools/phase-complete.ts
 init_logger();
 init_create_tool();
+
+// src/tools/phase-complete/gates/architecture-supervisor-gate.ts
+init_store();
+async function runArchitectureSupervisorGate(ctx) {
+  const { phase, dir, pluginConfig, agentsDispatched, safeWarn } = ctx;
+  const asConfig = pluginConfig.architectural_supervision;
+  const summarizeFindings = (findings) => {
+    if (!Array.isArray(findings) || findings.length === 0)
+      return "";
+    const details = findings.map((f) => f && typeof f === "object" && typeof f.description === "string" ? f.description : undefined).filter((d) => Boolean(d));
+    return details.length > 0 ? `
+Findings: ${details.join("; ")}` : "";
+  };
+  const asBlocked = (reason, message) => ({
+    blocked: true,
+    reason,
+    message,
+    agentsDispatched,
+    agentsMissing: [],
+    warnings: []
+  });
+  let asEntry = null;
+  try {
+    asEntry = readSupervisorReportRaw(dir, phase);
+  } catch (asError) {
+    return asBlocked("ARCH_SUPERVISOR_ERROR", `Phase ${phase} cannot be completed: architecture supervisor gate encountered an error. Error: ${String(asError)}`);
+  }
+  if (!asEntry) {
+    return asBlocked("ARCH_SUPERVISOR_REQUIRED", `Phase ${phase} cannot be completed: architectural_supervision gate mode is enabled and no architecture supervisor evidence was found at .swarm/evidence/${phase}/architecture-supervisor.json. Dispatch critic_architecture_supervisor with the phase + agent summaries, then call write_architecture_supervisor_evidence.`);
+  }
+  const now = new Date;
+  const asTime = asEntry.timestamp ? new Date(asEntry.timestamp) : null;
+  if (!asTime || Number.isNaN(asTime.getTime())) {
+    return asBlocked("ARCH_SUPERVISOR_INVALID_TIMESTAMP", `Phase ${phase} cannot be completed: architecture supervisor evidence has a missing or invalid timestamp.`);
+  }
+  if (asTime.getTime() > now.getTime()) {
+    return asBlocked("ARCH_SUPERVISOR_FUTURE_TIMESTAMP", `Phase ${phase} cannot be completed: architecture supervisor evidence timestamp is in the future.`);
+  }
+  if (now.getTime() - asTime.getTime() > 24 * 60 * 60 * 1000) {
+    return asBlocked("ARCH_SUPERVISOR_STALE_EVIDENCE", `Phase ${phase} cannot be completed: architecture supervisor evidence is older than 24 hours. Re-run the supervisor for fresh review.`);
+  }
+  if (typeof asEntry.phase_number !== "number" || asEntry.phase_number !== phase) {
+    return asBlocked("ARCH_SUPERVISOR_PHASE_MISMATCH", `Phase ${phase} cannot be completed: architecture supervisor evidence is for phase ${String(asEntry.phase_number)}, not phase ${phase}.`);
+  }
+  const asVerdict = asEntry.verdict;
+  if (asVerdict === "REJECT") {
+    return asBlocked("ARCH_SUPERVISOR_REJECTED", `Phase ${phase} cannot be completed: architecture supervisor returned verdict 'REJECT'. Address the system-level findings before completing the phase.${summarizeFindings(asEntry.findings)}`);
+  }
+  if (asVerdict === "CONCERNS") {
+    if (asConfig?.allow_concerns_to_complete === false) {
+      return asBlocked("ARCH_SUPERVISOR_CONCERNS", `Phase ${phase} cannot be completed: architecture supervisor returned verdict 'CONCERNS' and allow_concerns_to_complete is disabled.${summarizeFindings(asEntry.findings)}`);
+    }
+    safeWarn(`[phase_complete] Architecture supervisor returned CONCERNS for phase ${phase} — proceeding (allow_concerns_to_complete is enabled)`, undefined);
+  } else if (asVerdict !== "APPROVE") {
+    return asBlocked("ARCH_SUPERVISOR_INVALID", `Phase ${phase} cannot be completed: architecture supervisor evidence contains unrecognized verdict '${String(asVerdict)}'. Expected one of: APPROVE, CONCERNS, REJECT.`);
+  }
+  return { blocked: false, agentsDispatched, agentsMissing: [], warnings: [] };
+}
+// src/tools/phase-complete/gates/completion-verify-gate.ts
+async function runCompletionVerifyGate(ctx) {
+  const { phase, dir, agentsDispatched, safeWarn } = ctx;
+  try {
+    const completionResultRaw = await executeCompletionVerify({ phase }, dir);
+    const completionResult = JSON.parse(completionResultRaw);
+    if (completionResult.status === "blocked") {
+      return {
+        blocked: true,
+        reason: "COMPLETION_INCOMPLETE",
+        message: `Phase ${phase} cannot be completed: ${completionResult.reason}`,
+        agentsDispatched,
+        agentsMissing: [],
+        warnings: completionResult.blockedTasks ? [
+          `Blocked tasks: ${completionResult.blockedTasks.map((t) => t.task_id).join(", ")}`
+        ] : []
+      };
+    }
+    return {
+      blocked: false,
+      agentsDispatched,
+      agentsMissing: [],
+      warnings: []
+    };
+  } catch (completionError) {
+    safeWarn(`[phase_complete] Completion verify error (non-blocking):`, completionError);
+    return {
+      blocked: false,
+      agentsDispatched,
+      agentsMissing: [],
+      warnings: []
+    };
+  }
+}
+// src/tools/phase-complete/gates/drift-gate.ts
+init_qa_gate_profile();
+init_manager();
+init_state();
+import * as fs89 from "node:fs";
+import * as path126 from "node:path";
+async function runDriftGate(ctx) {
+  const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
+  let driftCheckEnabled = true;
+  let driftHasSpecMd = false;
+  try {
+    const specMdPath = path126.join(dir, ".swarm", "spec.md");
+    driftHasSpecMd = fs89.existsSync(specMdPath);
+    const gatePlan = await loadPlan(dir);
+    if (gatePlan) {
+      const gatePlanId = derivePlanId(gatePlan);
+      const gateProfile = getProfile(dir, gatePlanId);
+      if (gateProfile) {
+        const gateSession = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
+        const gateOverrides = gateSession?.qaGateSessionOverrides ?? {};
+        const gateEffective = getEffectiveGates(gateProfile, gateOverrides);
+        driftCheckEnabled = gateEffective.drift_check === true;
+      }
+    }
+  } catch (gateLoadError) {
+    safeWarn(`[phase_complete] QA gate profile load error, drift_check defaults to enabled:`, gateLoadError);
+  }
+  if (!driftCheckEnabled) {
+    return {
+      blocked: false,
+      agentsDispatched,
+      agentsMissing: [],
+      warnings: [
+        `drift_check gate is disabled. Drift verification was skipped for phase ${phase}.`
+      ]
+    };
+  }
+  let phaseType;
+  try {
+    const planPath = path126.join(dir, ".swarm", "plan.json");
+    if (fs89.existsSync(planPath)) {
+      const planRaw = fs89.readFileSync(planPath, "utf-8");
+      const plan = JSON.parse(planRaw);
+      const targetPhase = plan.phases?.find((p) => p.id === phase);
+      phaseType = targetPhase?.type;
+    }
+  } catch {}
+  if (phaseType === "non-code") {
+    return {
+      blocked: false,
+      agentsDispatched,
+      agentsMissing: [],
+      warnings: [
+        `Phase ${phase} is annotated as 'non-code'. Drift verification was skipped per phase type annotation.`
+      ]
+    };
+  }
+  try {
+    const driftEvidencePath = path126.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+    let driftVerdictFound = false;
+    let driftVerdictApproved = false;
+    try {
+      const driftEvidenceContent = fs89.readFileSync(driftEvidencePath, "utf-8");
+      const driftEvidence = JSON.parse(driftEvidenceContent);
+      const entries = driftEvidence.entries ?? [];
+      for (const entry of entries) {
+        if (typeof entry.type === "string" && entry.type.includes("drift") && typeof entry.verdict === "string") {
+          driftVerdictFound = true;
+          if (entry.verdict === "approved") {
+            driftVerdictApproved = true;
+          }
+          if (entry.verdict === "rejected" || typeof entry.summary === "string" && entry.summary.includes("NEEDS_REVISION")) {
+            return {
+              blocked: true,
+              reason: "DRIFT_VERIFICATION_REJECTED",
+              message: `Phase ${phase} cannot be completed: drift verifier returned verdict '${entry.verdict}'. Address the drift issues before completing the phase.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: []
+            };
+          }
+        }
+      }
+    } catch (readError) {
+      if (readError.code !== "ENOENT") {
+        safeWarn(`[phase_complete] Drift verifier evidence unreadable:`, readError);
+      }
+      driftVerdictFound = false;
+    }
+    if (!driftVerdictFound) {
+      if (!driftHasSpecMd) {
+        let incompleteTaskCount = 0;
+        let planParseable = false;
+        try {
+          const planPath = path126.join(dir, ".swarm", "plan.json");
+          if (fs89.existsSync(planPath)) {
+            const planRaw = fs89.readFileSync(planPath, "utf-8");
+            const plan = JSON.parse(planRaw);
+            planParseable = true;
+            const planPhase = plan.phases?.find((p) => p.id === phase);
+            if (planPhase?.tasks) {
+              incompleteTaskCount = planPhase.tasks.filter((t) => t.status !== "completed" && t.status !== "closed").length;
+            }
+          }
+        } catch {}
+        if (!planParseable) {
+          return {
+            blocked: false,
+            agentsDispatched,
+            agentsMissing: [],
+            warnings: [
+              `No spec.md found and drift verification evidence missing — consider running critic_drift_verifier before phase completion.`
+            ]
+          };
+        } else if (incompleteTaskCount > 0) {
+          return {
+            blocked: false,
+            agentsDispatched,
+            agentsMissing: [],
+            warnings: [
+              `No spec.md found and drift verification evidence missing. Phase ${phase} has ${incompleteTaskCount} incomplete task(s) in plan.json — consider running critic_drift_verifier before phase completion.`
+            ]
+          };
+        } else {
+          return {
+            blocked: false,
+            agentsDispatched,
+            agentsMissing: [],
+            warnings: [
+              `No spec.md found. Phase ${phase} tasks are all completed in plan.json. Drift verification was skipped.`
+            ]
+          };
+        }
+      } else {
+        return {
+          blocked: true,
+          reason: "DRIFT_VERIFICATION_MISSING",
+          message: `Phase ${phase} cannot be completed: drift_check is enabled and drift verifier evidence not found at .swarm/evidence/${phase}/drift-verifier.json. Run drift verification before completing the phase.`,
+          agentsDispatched,
+          agentsMissing: [],
+          warnings: []
+        };
+      }
+    }
+    if (!driftVerdictApproved && driftVerdictFound) {
+      return {
+        blocked: true,
+        reason: "DRIFT_VERIFICATION_REJECTED",
+        message: `Phase ${phase} cannot be completed: drift verifier verdict is not approved.`,
+        agentsDispatched,
+        agentsMissing: [],
+        warnings: []
+      };
+    }
+    return {
+      blocked: false,
+      agentsDispatched,
+      agentsMissing: [],
+      warnings: []
+    };
+  } catch (driftError) {
+    return {
+      blocked: true,
+      reason: "DRIFT_VERIFICATION_ERROR",
+      message: `Phase ${phase} cannot be completed: drift verification encountered an error: ${driftError instanceof Error ? driftError.message : String(driftError)}. This is a hard block — resolve the error before completing the phase.`,
+      agentsDispatched,
+      agentsMissing: [],
+      warnings: []
+    };
+  }
+}
+// src/tools/phase-complete/gates/final-council-gate.ts
+init_qa_gate_profile();
+init_manager();
+init_state();
+import * as fs90 from "node:fs";
+import * as path127 from "node:path";
+async function runFinalCouncilGate(ctx) {
+  const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
+  let finalCouncilEnabled = false;
+  try {
+    const plan = await loadPlan(dir);
+    if (plan) {
+      const lastPhaseId = plan.phases[plan.phases.length - 1]?.id;
+      if (lastPhaseId !== undefined && phase === lastPhaseId) {
+        const planId = derivePlanId(plan);
+        const profile = getProfile(dir, planId);
+        if (profile) {
+          const session = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
+          const overrides = session?.qaGateSessionOverrides ?? {};
+          const effective = getEffectiveGates(profile, overrides);
+          if (effective.final_council === true) {
+            finalCouncilEnabled = true;
+            const fcPath = path127.join(dir, ".swarm", "evidence", "final-council.json");
+            let fcVerdictFound = false;
+            let _fcVerdict;
+            try {
+              const fcContent = fs90.readFileSync(fcPath, "utf-8");
+              const fcBundle = JSON.parse(fcContent);
+              for (const entry of fcBundle.entries ?? []) {
+                if (typeof entry.type === "string" && entry.type === "final-council" && typeof entry.verdict === "string") {
+                  fcVerdictFound = true;
+                  _fcVerdict = entry.verdict;
+                  if (plan) {
+                    const currentPlanId = derivePlanId(plan);
+                    if (entry.plan_id && entry.plan_id !== currentPlanId) {
+                      return {
+                        blocked: true,
+                        reason: "final_council_plan_mismatch",
+                        message: `Final council evidence belongs to a different plan (evidence: ${entry.plan_id}, current: ${currentPlanId}). Re-run the final council.`,
+                        agentsDispatched,
+                        agentsMissing: [],
+                        warnings: []
+                      };
+                    }
+                    if (!entry.plan_id) {
+                      return {
+                        blocked: true,
+                        reason: "FINAL_COUNCIL_PLAN_ID_REQUIRED",
+                        message: `Phase ${phase} (last phase) cannot be completed: final council evidence is missing plan_id binding. Re-run the final council to generate evidence with plan identity.`,
+                        agentsDispatched,
+                        agentsMissing: [],
+                        warnings: []
+                      };
+                    }
+                  }
+                  if (typeof entry.quorumSize !== "number" || !Number.isFinite(entry.quorumSize) || entry.quorumSize < 5) {
+                    return {
+                      blocked: true,
+                      reason: "FINAL_COUNCIL_MISSING_QUORUM",
+                      message: `Phase ${phase} (last phase) cannot be completed: final council evidence is missing valid quorum metadata. Re-run the project-scoped five-member final council and call write_final_council_evidence to generate quorumed evidence.`,
+                      agentsDispatched,
+                      agentsMissing: [],
+                      warnings: []
+                    };
+                  }
+                  const requiredFinalCouncilMembers = [
+                    "critic",
+                    "reviewer",
+                    "sme",
+                    "test_engineer",
+                    "explorer"
+                  ];
+                  const membersVoted = Array.isArray(entry.membersVoted) ? entry.membersVoted.filter((member) => typeof member === "string") : [];
+                  const membersAbsent = Array.isArray(entry.membersAbsent) ? entry.membersAbsent.filter((member) => typeof member === "string") : [];
+                  const distinctMembersVoted = new Set(membersVoted);
+                  const hasAllRequiredMembers = requiredFinalCouncilMembers.every((member) => distinctMembersVoted.has(member)) && distinctMembersVoted.size === requiredFinalCouncilMembers.length && membersAbsent.length === 0;
+                  if (!hasAllRequiredMembers) {
+                    return {
+                      blocked: true,
+                      reason: "FINAL_COUNCIL_MISSING_QUORUM",
+                      message: `Phase ${phase} (last phase) cannot be completed: final council evidence does not prove all five required members voted. Re-run the project-scoped five-member final council and call write_final_council_evidence to generate complete evidence.`,
+                      agentsDispatched,
+                      agentsMissing: [],
+                      warnings: []
+                    };
+                  }
+                  if (entry.verdict === "rejected" || entry.verdict === "REJECTED") {
+                    return {
+                      blocked: true,
+                      reason: "FINAL_COUNCIL_REJECTED",
+                      message: `Phase ${phase} (last phase) cannot be completed: final council returned verdict 'REJECTED'. Address the required fixes before completing the project.`,
+                      agentsDispatched,
+                      agentsMissing: [],
+                      warnings: []
+                    };
+                  }
+                  if (entry.verdict !== "approved" && entry.verdict !== "APPROVED") {
+                    return {
+                      blocked: true,
+                      reason: "FINAL_COUNCIL_INVALID_VERDICT",
+                      message: `Phase ${phase} (last phase) cannot be completed: final council evidence contains unrecognized verdict '${entry.verdict}'. Expected 'approved'.`,
+                      agentsDispatched,
+                      agentsMissing: [],
+                      warnings: []
+                    };
+                  }
+                }
+              }
+            } catch (readErr) {
+              if (readErr.code !== "ENOENT") {
+                safeWarn(`[phase_complete] Final council evidence unreadable:`, readErr);
+              }
+              fcVerdictFound = false;
+            }
+            if (!fcVerdictFound) {
+              return {
+                blocked: true,
+                reason: "FINAL_COUNCIL_REQUIRED",
+                final_council_required: true,
+                message: `Phase ${phase} (last phase) cannot be completed: final_council is enabled and final council evidence not found at .swarm/evidence/final-council.json. Dispatch critic, reviewer, sme, test_engineer, and explorer with project-scoped context, collect their CouncilMemberVerdict JSON, and call write_final_council_evidence before completing the project. Do not use convene_general_council for this gate.`,
+                agentsDispatched,
+                agentsMissing: [],
+                warnings: [
+                  `Final council required - dispatch the five project-scoped council members, then call write_final_council_evidence to persist quorumed evidence.`
+                ]
+              };
+            }
+          }
+        }
+      }
+    }
+  } catch (fcError) {
+    if (finalCouncilEnabled) {
+      return {
+        blocked: true,
+        reason: "FINAL_COUNCIL_ERROR",
+        message: `Phase ${phase} (last phase) cannot be completed: final council gate encountered an error. Error: ${String(fcError)}`,
+        agentsDispatched,
+        agentsMissing: [],
+        warnings: [`FINAL_COUNCIL_ERROR: ${String(fcError)}`]
+      };
+    } else {
+      safeWarn(`[phase_complete] Final council gate error (non-blocking):`, fcError);
+    }
+  }
+  return { blocked: false, agentsDispatched, agentsMissing: [], warnings: [] };
+}
+// src/tools/phase-complete/gates/hallucination-gate.ts
+init_qa_gate_profile();
+init_manager();
+init_state();
+import * as fs91 from "node:fs";
+import * as path128 from "node:path";
+async function runHallucinationGate(ctx) {
+  const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
+  try {
+    const plan = await loadPlan(dir);
+    if (plan) {
+      const planId = derivePlanId(plan);
+      const profile = getProfile(dir, planId);
+      if (profile) {
+        const session = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
+        const overrides = session?.qaGateSessionOverrides ?? {};
+        const effective = getEffectiveGates(profile, overrides);
+        if (effective.hallucination_guard === true) {
+          const hgPath = path128.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+          let hgVerdictFound = false;
+          let hgVerdictApproved = false;
+          try {
+            const hgContent = fs91.readFileSync(hgPath, "utf-8");
+            const hgBundle = JSON.parse(hgContent);
+            for (const entry of hgBundle.entries ?? []) {
+              if (typeof entry.type === "string" && entry.type.includes("hallucination") && typeof entry.verdict === "string") {
+                hgVerdictFound = true;
+                if (entry.verdict === "approved") {
+                  hgVerdictApproved = true;
+                }
+                if (entry.verdict === "rejected" || typeof entry.summary === "string" && entry.summary.includes("NEEDS_REVISION")) {
+                  return {
+                    blocked: true,
+                    reason: "HALLUCINATION_VERIFICATION_REJECTED",
+                    message: `Phase ${phase} cannot be completed: hallucination verifier returned verdict '${entry.verdict}'. Remove fabricated APIs/signatures and fix broken citations before completing the phase.`,
+                    agentsDispatched,
+                    agentsMissing: [],
+                    warnings: []
+                  };
+                }
+              }
+            }
+          } catch (readErr) {
+            if (readErr.code !== "ENOENT") {
+              safeWarn(`[phase_complete] Hallucination guard evidence unreadable:`, readErr);
+            }
+            hgVerdictFound = false;
+          }
+          if (!hgVerdictFound) {
+            return {
+              blocked: true,
+              reason: "HALLUCINATION_VERIFICATION_MISSING",
+              message: `Phase ${phase} cannot be completed: hallucination_guard is enabled and evidence not found at .swarm/evidence/${phase}/hallucination-guard.json. Delegate to critic_hallucination_verifier and call write_hallucination_evidence before completing the phase.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: []
+            };
+          }
+          if (!hgVerdictApproved) {
+            return {
+              blocked: true,
+              reason: "HALLUCINATION_VERIFICATION_REJECTED",
+              message: `Phase ${phase} cannot be completed: hallucination verifier verdict is not approved.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: []
+            };
+          }
+        }
+      }
+    }
+  } catch (hgError) {
+    safeWarn(`[phase_complete] Hallucination guard error (non-blocking):`, hgError);
+  }
+  return { blocked: false, agentsDispatched, agentsMissing: [], warnings: [] };
+}
+// src/tools/phase-complete/gates/mutation-gate.ts
+init_qa_gate_profile();
+init_manager();
+init_state();
+import * as fs92 from "node:fs";
+import * as path129 from "node:path";
+async function runMutationGate(ctx) {
+  const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
+  try {
+    const plan = await loadPlan(dir);
+    if (plan) {
+      const planId = derivePlanId(plan);
+      const profile = getProfile(dir, planId);
+      if (profile) {
+        const session = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
+        const overrides = session?.qaGateSessionOverrides ?? {};
+        const effective = getEffectiveGates(profile, overrides);
+        if (effective.mutation_test === true) {
+          const mgPath = path129.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+          let mgVerdictFound = false;
+          let mgVerdict;
+          try {
+            const mgContent = fs92.readFileSync(mgPath, "utf-8");
+            const mgBundle = JSON.parse(mgContent);
+            for (const entry of mgBundle.entries ?? []) {
+              if (typeof entry.type === "string" && entry.type === "mutation-gate" && typeof entry.verdict === "string") {
+                mgVerdictFound = true;
+                mgVerdict = entry.verdict;
+                if (entry.verdict === "fail") {
+                  return {
+                    blocked: true,
+                    reason: "MUTATION_GATE_FAIL",
+                    message: `Phase ${phase} cannot be completed: mutation gate returned verdict 'fail'. Resolve surviving mutants or lower the kill-rate threshold before completing the phase.`,
+                    agentsDispatched,
+                    agentsMissing: [],
+                    warnings: []
+                  };
+                } else if (!["pass", "warn", "skip"].includes(entry.verdict)) {
+                  return {
+                    blocked: true,
+                    reason: "MUTATION_GATE_FAIL",
+                    message: `Phase ${phase} cannot be completed: mutation gate evidence contains unrecognized verdict '${entry.verdict}'. Expected one of: pass, warn, fail, skip.`,
+                    agentsDispatched,
+                    agentsMissing: [],
+                    warnings: []
+                  };
+                }
+              }
+            }
+          } catch (readErr) {
+            if (readErr.code !== "ENOENT") {
+              safeWarn(`[phase_complete] Mutation gate evidence unreadable:`, readErr);
+            }
+            mgVerdictFound = false;
+          }
+          if (!mgVerdictFound) {
+            return {
+              blocked: true,
+              reason: "MUTATION_GATE_MISSING",
+              message: `Phase ${phase} cannot be completed: mutation_test is enabled and evidence not found at .swarm/evidence/${phase}/mutation-gate.json. Run mutation_test, then call write_mutation_evidence before completing the phase.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: []
+            };
+          }
+          if (mgVerdict === "warn") {
+            safeWarn(`[phase_complete] Mutation gate verdict is 'warn' for phase ${phase} — proceeding with warning`, undefined);
+          }
+        }
+      }
+    }
+  } catch (mgError) {
+    safeWarn(`[phase_complete] Mutation gate error (non-blocking):`, mgError);
+  }
+  return { blocked: false, agentsDispatched, agentsMissing: [], warnings: [] };
+}
+// src/tools/phase-complete/gates/phase-council-gate.ts
+init_qa_gate_profile();
+init_manager();
+init_state();
+import * as fs93 from "node:fs";
+import * as path130 from "node:path";
+async function runPhaseCouncilGate(ctx) {
+  const { phase, dir, sessionID, pluginConfig, agentsDispatched, safeWarn } = ctx;
+  let councilModeEnabled = false;
+  try {
+    const plan = await loadPlan(dir);
+    if (plan) {
+      const planId = derivePlanId(plan);
+      const profile = getProfile(dir, planId);
+      if (profile) {
+        const session = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
+        const overrides = session?.qaGateSessionOverrides ?? {};
+        const effective = getEffectiveGates(profile, overrides);
+        if (effective.council_mode === true) {
+          councilModeEnabled = true;
+          const pcPath = path130.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+          let pcVerdictFound = false;
+          let _pcVerdict;
+          let pcQuorumSize;
+          let pcTimestamp;
+          let pcPhaseNumber;
+          try {
+            const pcContent = fs93.readFileSync(pcPath, "utf-8");
+            const pcBundle = JSON.parse(pcContent);
+            for (const entry of pcBundle.entries ?? []) {
+              if (typeof entry.type === "string" && entry.type === "phase-council" && typeof entry.verdict === "string") {
+                pcVerdictFound = true;
+                _pcVerdict = entry.verdict;
+                pcQuorumSize = typeof entry.quorumSize === "number" ? entry.quorumSize : undefined;
+                pcTimestamp = typeof entry.timestamp === "string" ? entry.timestamp : undefined;
+                pcPhaseNumber = typeof entry.phase_number === "number" ? entry.phase_number : typeof entry.phase === "number" ? entry.phase : undefined;
+                const now = new Date;
+                const pcTime = pcTimestamp ? new Date(pcTimestamp) : null;
+                if (!pcTime || Number.isNaN(pcTime.getTime())) {
+                  return {
+                    blocked: true,
+                    reason: "PHASE_COUNCIL_INVALID_TIMESTAMP",
+                    message: `Phase ${phase} cannot be completed: phase council evidence has missing or invalid timestamp.`,
+                    agentsDispatched,
+                    agentsMissing: [],
+                    warnings: []
+                  };
+                }
+                const maxAge = 24 * 60 * 60 * 1000;
+                if (pcTime.getTime() > now.getTime()) {
+                  return {
+                    blocked: true,
+                    reason: "PHASE_COUNCIL_FUTURE_TIMESTAMP",
+                    message: `Phase ${phase} cannot be completed: phase council evidence timestamp is in the future.`,
+                    agentsDispatched,
+                    agentsMissing: [],
+                    warnings: []
+                  };
+                }
+                if (now.getTime() - pcTime.getTime() > maxAge) {
+                  return {
+                    blocked: true,
+                    reason: "PHASE_COUNCIL_STALE_EVIDENCE",
+                    message: `Phase ${phase} cannot be completed: phase council evidence is older than 24 hours. Re-convene council for fresh review.`,
+                    agentsDispatched,
+                    agentsMissing: [],
+                    warnings: []
+                  };
+                }
+                if (entry.verdict === "REJECT" || entry.verdict === "reject") {
+                  const requiredFixes = entry.requiredFixes ?? entry.required_fixes ?? [];
+                  const fixesDetail = Array.isArray(requiredFixes) && requiredFixes.length > 0 ? `
+Required fixes: ${requiredFixes.map((f) => f.detail ?? JSON.stringify(f)).join("; ")}` : "";
+                  return {
+                    blocked: true,
+                    reason: "PHASE_COUNCIL_REJECTED",
+                    message: `Phase ${phase} cannot be completed: phase council returned verdict 'REJECT'. Address the required fixes before completing the phase.${fixesDetail}`,
+                    agentsDispatched,
+                    agentsMissing: [],
+                    warnings: []
+                  };
+                }
+                if (entry.verdict === "CONCERNS" || entry.verdict === "concerns") {
+                  const phaseConcernsAllow = pluginConfig.council?.phaseConcernsAllowComplete ?? true;
+                  if (!phaseConcernsAllow) {
+                    const advisoryNotes = entry.advisoryNotes ?? entry.advisory_notes ?? [];
+                    const notesDetail = Array.isArray(advisoryNotes) && advisoryNotes.length > 0 ? `
+Advisory notes: ${advisoryNotes.join("; ")}` : "";
+                    return {
+                      blocked: true,
+                      reason: "PHASE_COUNCIL_CONCERNS",
+                      message: `Phase ${phase} cannot be completed: phase council returned verdict 'CONCERNS'.${notesDetail}`,
+                      agentsDispatched,
+                      agentsMissing: [],
+                      warnings: []
+                    };
+                  }
+                  safeWarn(`[phase_complete] Phase council returned CONCERNS for phase ${phase} — proceeding (phaseConcernsAllowComplete is enabled)`, undefined);
+                }
+                if (entry.verdict !== "APPROVE" && entry.verdict !== "approve" && entry.verdict !== "CONCERNS" && entry.verdict !== "concerns") {
+                  return {
+                    blocked: true,
+                    reason: "PHASE_COUNCIL_INVALID",
+                    message: `Phase ${phase} cannot be completed: phase council evidence contains unrecognized verdict '${entry.verdict}'. Expected one of: APPROVE, CONCERNS, REJECT.`,
+                    agentsDispatched,
+                    agentsMissing: [],
+                    warnings: []
+                  };
+                }
+              }
+            }
+          } catch (readErr) {
+            if (readErr.code !== "ENOENT") {
+              safeWarn(`[phase_complete] Phase council evidence unreadable:`, readErr);
+            }
+            pcVerdictFound = false;
+          }
+          if (!pcVerdictFound) {
+            return {
+              blocked: true,
+              reason: "PHASE_COUNCIL_REQUIRED",
+              phase_council_required: true,
+              message: `Phase ${phase} cannot be completed: council_mode is enabled and phase council evidence not found at .swarm/evidence/${phase}/phase-council.json. Convene a phase-level council (dispatch 5 members, collect verdicts, call submit_phase_council_verdicts) before completing the phase.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: [
+                `Phase council required — convene 5 council members (critic, reviewer, sme, test_engineer, explorer) for holistic phase review. Call submit_phase_council_verdicts to synthesize verdicts and write phase-council.json evidence.`
+              ]
+            };
+          }
+          if (pcQuorumSize === undefined || typeof pcQuorumSize !== "number") {
+            return {
+              blocked: true,
+              reason: "PHASE_COUNCIL_MISSING_QUORUM",
+              message: `Phase ${phase} cannot be completed: phase council evidence is missing quorumSize field.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: []
+            };
+          }
+          if (pcQuorumSize < 3) {
+            return {
+              blocked: true,
+              reason: "PHASE_COUNCIL_INSUFFICIENT_QUORUM",
+              message: `Phase ${phase} cannot be completed: phase council quorum (${pcQuorumSize}) is below minimum (3). Re-convene council with sufficient members.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: []
+            };
+          }
+          if (pcPhaseNumber === undefined || typeof pcPhaseNumber !== "number") {
+            return {
+              blocked: true,
+              reason: "PHASE_COUNCIL_MISSING_PHASE",
+              message: `Phase ${phase} cannot be completed: phase council evidence is missing phase_number field.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: []
+            };
+          }
+          if (pcPhaseNumber !== phase) {
+            return {
+              blocked: true,
+              reason: "PHASE_COUNCIL_PHASE_MISMATCH",
+              message: `Phase ${phase} cannot be completed: phase council evidence is for phase ${pcPhaseNumber}, not phase ${phase}. Run council for the correct phase.`,
+              agentsDispatched,
+              agentsMissing: [],
+              warnings: []
+            };
+          }
+        }
+      }
+    }
+  } catch (pcError) {
+    if (councilModeEnabled) {
+      return {
+        blocked: true,
+        reason: "PHASE_COUNCIL_ERROR",
+        message: `Phase ${phase} cannot be completed: phase council gate encountered an error when council_mode was enabled. Error: ${String(pcError)}`,
+        agentsDispatched,
+        agentsMissing: [],
+        warnings: [`PHASE_COUNCIL_ERROR: ${String(pcError)}`]
+      };
+    } else {
+      safeWarn(`[phase_complete] Phase council gate error (non-blocking):`, pcError);
+    }
+  }
+  return { blocked: false, agentsDispatched, agentsMissing: [], warnings: [] };
+}
+// src/tools/phase-complete.ts
 init_resolve_working_directory();
 function safeWarn(message, error93) {
   try {
     warn(message, error93 instanceof Error ? error93.message : String(error93));
   } catch {}
 }
+var MAX_OUTPUT_BYTES5 = 512000;
 var TASK_GATE_INFERABLE_AGENTS = new Set([
   "coder",
   "reviewer",
@@ -112213,6 +112978,28 @@ function _getDelegationsSince(sessionID, sinceTimestamp) {
 function isValidRetroEntry(entry, phase) {
   return entry.type === "retrospective" && "phase_number" in entry && entry.phase_number === phase && "verdict" in entry && entry.verdict === "pass";
 }
+function blockedResult(phase, gateResult) {
+  const {
+    reason,
+    message,
+    agentsDispatched,
+    agentsMissing,
+    warnings,
+    blocked: _blocked,
+    ...extra
+  } = gateResult;
+  return JSON.stringify({
+    success: false,
+    phase,
+    status: "blocked",
+    reason,
+    message,
+    agentsDispatched,
+    agentsMissing,
+    warnings,
+    ...extra
+  }, null, 2);
+}
 async function executePhaseComplete(args2, workingDirectory, directory) {
   const phase = Number(args2.phase);
   const summary = args2.summary;
@@ -112351,719 +113138,66 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       ]
     }, null, 2);
   }
+  const gateCtx = {
+    phase,
+    dir,
+    sessionID,
+    pluginConfig: config3,
+    agentsDispatched,
+    safeWarn
+  };
   if (hasActiveTurboMode(sessionID)) {
     warnings.push(`Turbo mode active — skipped completion-verify, drift-verifier, hallucination-guard, mutation-gate, phase-council, and final-council gates for phase ${phase}.`);
   } else {
-    try {
-      const completionResultRaw = await executeCompletionVerify({ phase }, dir);
-      const completionResult = JSON.parse(completionResultRaw);
-      if (completionResult.status === "blocked") {
-        return JSON.stringify({
-          success: false,
-          phase,
-          status: "blocked",
-          reason: "COMPLETION_INCOMPLETE",
-          message: `Phase ${phase} cannot be completed: ${completionResult.reason}`,
-          agentsDispatched,
-          agentsMissing: [],
-          warnings: completionResult.blockedTasks ? [
-            `Blocked tasks: ${completionResult.blockedTasks.map((t) => t.task_id).join(", ")}`
-          ] : []
-        }, null, 2);
+    {
+      const gateResult = await runCompletionVerifyGate(gateCtx);
+      if (gateResult.blocked) {
+        return blockedResult(phase, gateResult);
       }
-    } catch (completionError) {
-      safeWarn(`[phase_complete] Completion verify error (non-blocking):`, completionError);
+      warnings.push(...gateResult.warnings);
     }
-    let driftCheckEnabled = true;
-    let driftHasSpecMd = false;
-    try {
-      const specMdPath = path127.join(dir, ".swarm", "spec.md");
-      driftHasSpecMd = fs90.existsSync(specMdPath);
-      const gatePlan = await loadPlan(dir);
-      if (gatePlan) {
-        const gatePlanId = derivePlanId(gatePlan);
-        const gateProfile = getProfile(dir, gatePlanId);
-        if (gateProfile) {
-          const gateSession = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
-          const gateOverrides = gateSession?.qaGateSessionOverrides ?? {};
-          const gateEffective = getEffectiveGates(gateProfile, gateOverrides);
-          driftCheckEnabled = gateEffective.drift_check === true;
-        }
-      }
-    } catch (gateLoadError) {
-      safeWarn(`[phase_complete] QA gate profile load error, drift_check defaults to enabled:`, gateLoadError);
-    }
-    if (!driftCheckEnabled) {
-      warnings.push(`drift_check gate is disabled. Drift verification was skipped for phase ${phase}.`);
-    } else {
-      let phaseType;
-      try {
-        const planPath = path127.join(dir, ".swarm", "plan.json");
-        if (fs90.existsSync(planPath)) {
-          const planRaw = fs90.readFileSync(planPath, "utf-8");
-          const plan = JSON.parse(planRaw);
-          const targetPhase = plan.phases?.find((p) => p.id === phase);
-          phaseType = targetPhase?.type;
-        }
-      } catch {}
-      if (phaseType === "non-code") {
-        warnings.push(`Phase ${phase} is annotated as 'non-code'. Drift verification was skipped per phase type annotation.`);
-      } else {
-        try {
-          const driftEvidencePath = path127.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
-          let driftVerdictFound = false;
-          let driftVerdictApproved = false;
-          try {
-            const driftEvidenceContent = fs90.readFileSync(driftEvidencePath, "utf-8");
-            const driftEvidence = JSON.parse(driftEvidenceContent);
-            const entries = driftEvidence.entries ?? [];
-            for (const entry of entries) {
-              if (typeof entry.type === "string" && entry.type.includes("drift") && typeof entry.verdict === "string") {
-                driftVerdictFound = true;
-                if (entry.verdict === "approved") {
-                  driftVerdictApproved = true;
-                }
-                if (entry.verdict === "rejected" || typeof entry.summary === "string" && entry.summary.includes("NEEDS_REVISION")) {
-                  return JSON.stringify({
-                    success: false,
-                    phase,
-                    status: "blocked",
-                    reason: "DRIFT_VERIFICATION_REJECTED",
-                    message: `Phase ${phase} cannot be completed: drift verifier returned verdict '${entry.verdict}'. Address the drift issues before completing the phase.`,
-                    agentsDispatched,
-                    agentsMissing: [],
-                    warnings: []
-                  }, null, 2);
-                }
-              }
-            }
-          } catch (readError) {
-            if (readError.code !== "ENOENT") {
-              safeWarn(`[phase_complete] Drift verifier evidence unreadable:`, readError);
-            }
-            driftVerdictFound = false;
-          }
-          if (!driftVerdictFound) {
-            if (!driftHasSpecMd) {
-              let incompleteTaskCount = 0;
-              let planParseable = false;
-              try {
-                const planPath = path127.join(dir, ".swarm", "plan.json");
-                if (fs90.existsSync(planPath)) {
-                  const planRaw = fs90.readFileSync(planPath, "utf-8");
-                  const plan = JSON.parse(planRaw);
-                  planParseable = true;
-                  const planPhase = plan.phases?.find((p) => p.id === phase);
-                  if (planPhase?.tasks) {
-                    incompleteTaskCount = planPhase.tasks.filter((t) => t.status !== "completed" && t.status !== "closed").length;
-                  }
-                }
-              } catch {}
-              if (!planParseable) {
-                warnings.push(`No spec.md found and drift verification evidence missing — consider running critic_drift_verifier before phase completion.`);
-              } else if (incompleteTaskCount > 0) {
-                warnings.push(`No spec.md found and drift verification evidence missing. Phase ${phase} has ${incompleteTaskCount} incomplete task(s) in plan.json — consider running critic_drift_verifier before phase completion.`);
-              } else {
-                warnings.push(`No spec.md found. Phase ${phase} tasks are all completed in plan.json. Drift verification was skipped.`);
-              }
-            } else {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "DRIFT_VERIFICATION_MISSING",
-                message: `Phase ${phase} cannot be completed: drift_check is enabled and drift verifier evidence not found at .swarm/evidence/${phase}/drift-verifier.json. Run drift verification before completing the phase.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: []
-              }, null, 2);
-            }
-          }
-          if (!driftVerdictApproved && driftVerdictFound) {
-            return JSON.stringify({
-              success: false,
-              phase,
-              status: "blocked",
-              reason: "DRIFT_VERIFICATION_REJECTED",
-              message: `Phase ${phase} cannot be completed: drift verifier verdict is not approved.`,
-              agentsDispatched,
-              agentsMissing: [],
-              warnings: []
-            }, null, 2);
-          }
-        } catch (driftError) {
-          return JSON.stringify({
-            success: false,
-            phase,
-            status: "blocked",
-            reason: "DRIFT_VERIFICATION_ERROR",
-            message: `Phase ${phase} cannot be completed: drift verification encountered an error: ${driftError instanceof Error ? driftError.message : String(driftError)}. This is a hard block — resolve the error before completing the phase.`,
-            agentsDispatched,
-            agentsMissing: [],
-            warnings: []
-          }, null, 2);
-        }
+    {
+      const gateResult = await runDriftGate(gateCtx);
+      if (gateResult.blocked) {
+        return blockedResult(phase, gateResult);
       }
+      warnings.push(...gateResult.warnings);
     }
-    try {
-      const plan = await loadPlan(dir);
-      if (plan) {
-        const planId = derivePlanId(plan);
-        const profile = getProfile(dir, planId);
-        if (profile) {
-          const session2 = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
-          const overrides = session2?.qaGateSessionOverrides ?? {};
-          const effective = getEffectiveGates(profile, overrides);
-          if (effective.hallucination_guard === true) {
-            const hgPath = path127.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
-            let hgVerdictFound = false;
-            let hgVerdictApproved = false;
-            try {
-              const hgContent = fs90.readFileSync(hgPath, "utf-8");
-              const hgBundle = JSON.parse(hgContent);
-              for (const entry of hgBundle.entries ?? []) {
-                if (typeof entry.type === "string" && entry.type.includes("hallucination") && typeof entry.verdict === "string") {
-                  hgVerdictFound = true;
-                  if (entry.verdict === "approved") {
-                    hgVerdictApproved = true;
-                  }
-                  if (entry.verdict === "rejected" || typeof entry.summary === "string" && entry.summary.includes("NEEDS_REVISION")) {
-                    return JSON.stringify({
-                      success: false,
-                      phase,
-                      status: "blocked",
-                      reason: "HALLUCINATION_VERIFICATION_REJECTED",
-                      message: `Phase ${phase} cannot be completed: hallucination verifier returned verdict '${entry.verdict}'. Remove fabricated APIs/signatures and fix broken citations before completing the phase.`,
-                      agentsDispatched,
-                      agentsMissing: [],
-                      warnings: []
-                    }, null, 2);
-                  }
-                }
-              }
-            } catch (readErr) {
-              if (readErr.code !== "ENOENT") {
-                safeWarn(`[phase_complete] Hallucination guard evidence unreadable:`, readErr);
-              }
-              hgVerdictFound = false;
-            }
-            if (!hgVerdictFound) {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "HALLUCINATION_VERIFICATION_MISSING",
-                message: `Phase ${phase} cannot be completed: hallucination_guard is enabled and evidence not found at .swarm/evidence/${phase}/hallucination-guard.json. Delegate to critic_hallucination_verifier and call write_hallucination_evidence before completing the phase.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: []
-              }, null, 2);
-            }
-            if (!hgVerdictApproved) {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "HALLUCINATION_VERIFICATION_REJECTED",
-                message: `Phase ${phase} cannot be completed: hallucination verifier verdict is not approved.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: []
-              }, null, 2);
-            }
-          }
-        }
+    {
+      const gateResult = await runHallucinationGate(gateCtx);
+      if (gateResult.blocked) {
+        return blockedResult(phase, gateResult);
       }
-    } catch (hgError) {
-      safeWarn(`[phase_complete] Hallucination guard error (non-blocking):`, hgError);
+      warnings.push(...gateResult.warnings);
     }
-    try {
-      const plan = await loadPlan(dir);
-      if (plan) {
-        const planId = derivePlanId(plan);
-        const profile = getProfile(dir, planId);
-        if (profile) {
-          const session2 = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
-          const overrides = session2?.qaGateSessionOverrides ?? {};
-          const effective = getEffectiveGates(profile, overrides);
-          if (effective.mutation_test === true) {
-            const mgPath = path127.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
-            let mgVerdictFound = false;
-            let mgVerdict;
-            try {
-              const mgContent = fs90.readFileSync(mgPath, "utf-8");
-              const mgBundle = JSON.parse(mgContent);
-              for (const entry of mgBundle.entries ?? []) {
-                if (typeof entry.type === "string" && entry.type === "mutation-gate" && typeof entry.verdict === "string") {
-                  mgVerdictFound = true;
-                  mgVerdict = entry.verdict;
-                  if (entry.verdict === "fail") {
-                    return JSON.stringify({
-                      success: false,
-                      phase,
-                      status: "blocked",
-                      reason: "MUTATION_GATE_FAIL",
-                      message: `Phase ${phase} cannot be completed: mutation gate returned verdict 'fail'. Resolve surviving mutants or lower the kill-rate threshold before completing the phase.`,
-                      agentsDispatched,
-                      agentsMissing: [],
-                      warnings: []
-                    }, null, 2);
-                  } else if (!["pass", "warn", "skip"].includes(entry.verdict)) {
-                    return JSON.stringify({
-                      success: false,
-                      phase,
-                      status: "blocked",
-                      reason: "MUTATION_GATE_FAIL",
-                      message: `Phase ${phase} cannot be completed: mutation gate evidence contains unrecognized verdict '${entry.verdict}'. Expected one of: pass, warn, fail, skip.`,
-                      agentsDispatched,
-                      agentsMissing: [],
-                      warnings: []
-                    }, null, 2);
-                  }
-                }
-              }
-            } catch (readErr) {
-              if (readErr.code !== "ENOENT") {
-                safeWarn(`[phase_complete] Mutation gate evidence unreadable:`, readErr);
-              }
-              mgVerdictFound = false;
-            }
-            if (!mgVerdictFound) {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "MUTATION_GATE_MISSING",
-                message: `Phase ${phase} cannot be completed: mutation_test is enabled and evidence not found at .swarm/evidence/${phase}/mutation-gate.json. Run mutation_test, then call write_mutation_evidence before completing the phase.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: []
-              }, null, 2);
-            }
-            if (mgVerdict === "warn") {
-              safeWarn(`[phase_complete] Mutation gate verdict is 'warn' for phase ${phase} — proceeding with warning`, undefined);
-            }
-          }
-        }
+    {
+      const gateResult = await runMutationGate(gateCtx);
+      if (gateResult.blocked) {
+        return blockedResult(phase, gateResult);
       }
-    } catch (mgError) {
-      safeWarn(`[phase_complete] Mutation gate error (non-blocking):`, mgError);
+      warnings.push(...gateResult.warnings);
     }
-    let councilModeEnabled = false;
-    try {
-      const plan = await loadPlan(dir);
-      if (plan) {
-        const planId = derivePlanId(plan);
-        const profile = getProfile(dir, planId);
-        if (profile) {
-          const session2 = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
-          const overrides = session2?.qaGateSessionOverrides ?? {};
-          const effective = getEffectiveGates(profile, overrides);
-          if (effective.council_mode === true) {
-            councilModeEnabled = true;
-            const pcPath = path127.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
-            let pcVerdictFound = false;
-            let _pcVerdict;
-            let pcQuorumSize;
-            let pcTimestamp;
-            let pcPhaseNumber;
-            try {
-              const pcContent = fs90.readFileSync(pcPath, "utf-8");
-              const pcBundle = JSON.parse(pcContent);
-              for (const entry of pcBundle.entries ?? []) {
-                if (typeof entry.type === "string" && entry.type === "phase-council" && typeof entry.verdict === "string") {
-                  pcVerdictFound = true;
-                  _pcVerdict = entry.verdict;
-                  pcQuorumSize = typeof entry.quorumSize === "number" ? entry.quorumSize : undefined;
-                  pcTimestamp = typeof entry.timestamp === "string" ? entry.timestamp : undefined;
-                  pcPhaseNumber = typeof entry.phase_number === "number" ? entry.phase_number : typeof entry.phase === "number" ? entry.phase : undefined;
-                  const now2 = new Date;
-                  const pcTime = pcTimestamp ? new Date(pcTimestamp) : null;
-                  if (!pcTime || Number.isNaN(pcTime.getTime())) {
-                    return JSON.stringify({
-                      success: false,
-                      phase,
-                      status: "blocked",
-                      reason: "PHASE_COUNCIL_INVALID_TIMESTAMP",
-                      message: `Phase ${phase} cannot be completed: phase council evidence has missing or invalid timestamp.`,
-                      agentsDispatched,
-                      agentsMissing: [],
-                      warnings: []
-                    }, null, 2);
-                  }
-                  const maxAge = 24 * 60 * 60 * 1000;
-                  if (pcTime.getTime() > now2.getTime()) {
-                    return JSON.stringify({
-                      success: false,
-                      phase,
-                      status: "blocked",
-                      reason: "PHASE_COUNCIL_FUTURE_TIMESTAMP",
-                      message: `Phase ${phase} cannot be completed: phase council evidence timestamp is in the future.`,
-                      agentsDispatched,
-                      agentsMissing: [],
-                      warnings: []
-                    }, null, 2);
-                  }
-                  if (now2.getTime() - pcTime.getTime() > maxAge) {
-                    return JSON.stringify({
-                      success: false,
-                      phase,
-                      status: "blocked",
-                      reason: "PHASE_COUNCIL_STALE_EVIDENCE",
-                      message: `Phase ${phase} cannot be completed: phase council evidence is older than 24 hours. Re-convene council for fresh review.`,
-                      agentsDispatched,
-                      agentsMissing: [],
-                      warnings: []
-                    }, null, 2);
-                  }
-                  if (entry.verdict === "REJECT" || entry.verdict === "reject") {
-                    const requiredFixes = entry.requiredFixes ?? entry.required_fixes ?? [];
-                    const fixesDetail = Array.isArray(requiredFixes) && requiredFixes.length > 0 ? `
-Required fixes: ${requiredFixes.map((f) => f.detail ?? JSON.stringify(f)).join("; ")}` : "";
-                    return JSON.stringify({
-                      success: false,
-                      phase,
-                      status: "blocked",
-                      reason: "PHASE_COUNCIL_REJECTED",
-                      message: `Phase ${phase} cannot be completed: phase council returned verdict 'REJECT'. Address the required fixes before completing the phase.${fixesDetail}`,
-                      agentsDispatched,
-                      agentsMissing: [],
-                      warnings: []
-                    }, null, 2);
-                  }
-                  if (entry.verdict === "CONCERNS" || entry.verdict === "concerns") {
-                    const phaseConcernsAllow = config3.council?.phaseConcernsAllowComplete ?? true;
-                    if (!phaseConcernsAllow) {
-                      const advisoryNotes = entry.advisoryNotes ?? entry.advisory_notes ?? [];
-                      const notesDetail = Array.isArray(advisoryNotes) && advisoryNotes.length > 0 ? `
-Advisory notes: ${advisoryNotes.join("; ")}` : "";
-                      return JSON.stringify({
-                        success: false,
-                        phase,
-                        status: "blocked",
-                        reason: "PHASE_COUNCIL_CONCERNS",
-                        message: `Phase ${phase} cannot be completed: phase council returned verdict 'CONCERNS'.${notesDetail}`,
-                        agentsDispatched,
-                        agentsMissing: [],
-                        warnings: []
-                      }, null, 2);
-                    }
-                    safeWarn(`[phase_complete] Phase council returned CONCERNS for phase ${phase} — proceeding (phaseConcernsAllowComplete is enabled)`, undefined);
-                  }
-                  if (entry.verdict !== "APPROVE" && entry.verdict !== "approve" && entry.verdict !== "CONCERNS" && entry.verdict !== "concerns") {
-                    return JSON.stringify({
-                      success: false,
-                      phase,
-                      status: "blocked",
-                      reason: "PHASE_COUNCIL_INVALID",
-                      message: `Phase ${phase} cannot be completed: phase council evidence contains unrecognized verdict '${entry.verdict}'. Expected one of: APPROVE, CONCERNS, REJECT.`,
-                      agentsDispatched,
-                      agentsMissing: [],
-                      warnings: []
-                    }, null, 2);
-                  }
-                }
-              }
-            } catch (readErr) {
-              if (readErr.code !== "ENOENT") {
-                safeWarn(`[phase_complete] Phase council evidence unreadable:`, readErr);
-              }
-              pcVerdictFound = false;
-            }
-            if (!pcVerdictFound) {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "PHASE_COUNCIL_REQUIRED",
-                phase_council_required: true,
-                message: `Phase ${phase} cannot be completed: council_mode is enabled and phase council evidence not found at .swarm/evidence/${phase}/phase-council.json. Convene a phase-level council (dispatch 5 members, collect verdicts, call submit_phase_council_verdicts) before completing the phase.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: [
-                  `Phase council required — convene 5 council members (critic, reviewer, sme, test_engineer, explorer) for holistic phase review. Call submit_phase_council_verdicts to synthesize verdicts and write phase-council.json evidence.`
-                ]
-              }, null, 2);
-            }
-            if (pcQuorumSize === undefined || typeof pcQuorumSize !== "number") {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "PHASE_COUNCIL_MISSING_QUORUM",
-                message: `Phase ${phase} cannot be completed: phase council evidence is missing quorumSize field.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: []
-              }, null, 2);
-            }
-            if (pcQuorumSize < 3) {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "PHASE_COUNCIL_INSUFFICIENT_QUORUM",
-                message: `Phase ${phase} cannot be completed: phase council quorum (${pcQuorumSize}) is below minimum (3). Re-convene council with sufficient members.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: []
-              }, null, 2);
-            }
-            if (pcPhaseNumber === undefined || typeof pcPhaseNumber !== "number") {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "PHASE_COUNCIL_MISSING_PHASE",
-                message: `Phase ${phase} cannot be completed: phase council evidence is missing phase_number field.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: []
-              }, null, 2);
-            }
-            if (pcPhaseNumber !== phase) {
-              return JSON.stringify({
-                success: false,
-                phase,
-                status: "blocked",
-                reason: "PHASE_COUNCIL_PHASE_MISMATCH",
-                message: `Phase ${phase} cannot be completed: phase council evidence is for phase ${pcPhaseNumber}, not phase ${phase}. Run council for the correct phase.`,
-                agentsDispatched,
-                agentsMissing: [],
-                warnings: []
-              }, null, 2);
-            }
-          }
-        }
-      }
-    } catch (pcError) {
-      if (councilModeEnabled) {
-        warnings.push(`PHASE_COUNCIL_ERROR: ${String(pcError)}`);
-        return JSON.stringify({
-          success: false,
-          phase,
-          status: "blocked",
-          reason: "PHASE_COUNCIL_ERROR",
-          message: `Phase ${phase} cannot be completed: phase council gate encountered an error when council_mode was enabled. Error: ${String(pcError)}`,
-          agentsDispatched,
-          agentsMissing: [],
-          warnings: [`PHASE_COUNCIL_ERROR: ${String(pcError)}`]
-        }, null, 2);
-      } else {
-        safeWarn(`[phase_complete] Phase council gate error (non-blocking):`, pcError);
+    {
+      const gateResult = await runPhaseCouncilGate(gateCtx);
+      if (gateResult.blocked) {
+        return blockedResult(phase, gateResult);
       }
+      warnings.push(...gateResult.warnings);
     }
   }
   if (config3.architectural_supervision?.enabled && config3.architectural_supervision.mode === "gate") {
-    const asConfig = config3.architectural_supervision;
-    const summarizeFindings = (findings) => {
-      if (!Array.isArray(findings) || findings.length === 0)
-        return "";
-      const details = findings.map((f) => f && typeof f === "object" && typeof f.description === "string" ? f.description : undefined).filter((d) => Boolean(d));
-      return details.length > 0 ? `
-Findings: ${details.join("; ")}` : "";
-    };
-    const asBlocked = (reason, message2) => JSON.stringify({
-      success: false,
-      phase,
-      status: "blocked",
-      reason,
-      message: message2,
-      agentsDispatched,
-      agentsMissing: [],
-      warnings: []
-    }, null, 2);
-    let asEntry = null;
-    try {
-      asEntry = readSupervisorReportRaw(dir, phase);
-    } catch (asError) {
-      return asBlocked("ARCH_SUPERVISOR_ERROR", `Phase ${phase} cannot be completed: architecture supervisor gate encountered an error. Error: ${String(asError)}`);
-    }
-    if (!asEntry) {
-      return asBlocked("ARCH_SUPERVISOR_REQUIRED", `Phase ${phase} cannot be completed: architectural_supervision gate mode is enabled and no architecture supervisor evidence was found at .swarm/evidence/${phase}/architecture-supervisor.json. Dispatch critic_architecture_supervisor with the phase + agent summaries, then call write_architecture_supervisor_evidence.`);
-    }
-    const now2 = new Date;
-    const asTime = asEntry.timestamp ? new Date(asEntry.timestamp) : null;
-    if (!asTime || Number.isNaN(asTime.getTime())) {
-      return asBlocked("ARCH_SUPERVISOR_INVALID_TIMESTAMP", `Phase ${phase} cannot be completed: architecture supervisor evidence has a missing or invalid timestamp.`);
-    }
-    if (asTime.getTime() > now2.getTime()) {
-      return asBlocked("ARCH_SUPERVISOR_FUTURE_TIMESTAMP", `Phase ${phase} cannot be completed: architecture supervisor evidence timestamp is in the future.`);
-    }
-    if (now2.getTime() - asTime.getTime() > 24 * 60 * 60 * 1000) {
-      return asBlocked("ARCH_SUPERVISOR_STALE_EVIDENCE", `Phase ${phase} cannot be completed: architecture supervisor evidence is older than 24 hours. Re-run the supervisor for fresh review.`);
-    }
-    if (typeof asEntry.phase_number !== "number" || asEntry.phase_number !== phase) {
-      return asBlocked("ARCH_SUPERVISOR_PHASE_MISMATCH", `Phase ${phase} cannot be completed: architecture supervisor evidence is for phase ${String(asEntry.phase_number)}, not phase ${phase}.`);
-    }
-    const asVerdict = asEntry.verdict;
-    if (asVerdict === "REJECT") {
-      return asBlocked("ARCH_SUPERVISOR_REJECTED", `Phase ${phase} cannot be completed: architecture supervisor returned verdict 'REJECT'. Address the system-level findings before completing the phase.${summarizeFindings(asEntry.findings)}`);
-    }
-    if (asVerdict === "CONCERNS") {
-      if (asConfig.allow_concerns_to_complete === false) {
-        return asBlocked("ARCH_SUPERVISOR_CONCERNS", `Phase ${phase} cannot be completed: architecture supervisor returned verdict 'CONCERNS' and allow_concerns_to_complete is disabled.${summarizeFindings(asEntry.findings)}`);
-      }
-      safeWarn(`[phase_complete] Architecture supervisor returned CONCERNS for phase ${phase} — proceeding (allow_concerns_to_complete is enabled)`, undefined);
-    } else if (asVerdict !== "APPROVE") {
-      return asBlocked("ARCH_SUPERVISOR_INVALID", `Phase ${phase} cannot be completed: architecture supervisor evidence contains unrecognized verdict '${String(asVerdict)}'. Expected one of: APPROVE, CONCERNS, REJECT.`);
+    const gateResult = await runArchitectureSupervisorGate(gateCtx);
+    if (gateResult.blocked) {
+      return blockedResult(phase, gateResult);
     }
+    warnings.push(...gateResult.warnings);
   }
   if (!hasActiveTurboMode(sessionID)) {
-    let finalCouncilEnabled = false;
-    try {
-      const plan = await loadPlan(dir);
-      if (plan) {
-        const lastPhaseId = plan.phases[plan.phases.length - 1]?.id;
-        if (lastPhaseId !== undefined && phase === lastPhaseId) {
-          const planId = derivePlanId(plan);
-          const profile = getProfile(dir, planId);
-          if (profile) {
-            const session2 = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
-            const overrides = session2?.qaGateSessionOverrides ?? {};
-            const effective = getEffectiveGates(profile, overrides);
-            if (effective.final_council === true) {
-              finalCouncilEnabled = true;
-              const fcPath = path127.join(dir, ".swarm", "evidence", "final-council.json");
-              let fcVerdictFound = false;
-              let _fcVerdict;
-              try {
-                const fcContent = fs90.readFileSync(fcPath, "utf-8");
-                const fcBundle = JSON.parse(fcContent);
-                for (const entry of fcBundle.entries ?? []) {
-                  if (typeof entry.type === "string" && entry.type === "final-council" && typeof entry.verdict === "string") {
-                    fcVerdictFound = true;
-                    _fcVerdict = entry.verdict;
-                    if (plan) {
-                      const currentPlanId = derivePlanId(plan);
-                      if (entry.plan_id && entry.plan_id !== currentPlanId) {
-                        return JSON.stringify({
-                          success: false,
-                          phase,
-                          status: "blocked",
-                          reason: "final_council_plan_mismatch",
-                          message: `Final council evidence belongs to a different plan (evidence: ${entry.plan_id}, current: ${currentPlanId}). Re-run the final council.`,
-                          agentsDispatched,
-                          agentsMissing: [],
-                          warnings: []
-                        }, null, 2);
-                      }
-                      if (!entry.plan_id) {
-                        return JSON.stringify({
-                          success: false,
-                          phase,
-                          status: "blocked",
-                          reason: "FINAL_COUNCIL_PLAN_ID_REQUIRED",
-                          message: `Phase ${phase} (last phase) cannot be completed: final council evidence is missing plan_id binding. Re-run the final council to generate evidence with plan identity.`,
-                          agentsDispatched,
-                          agentsMissing: [],
-                          warnings: []
-                        }, null, 2);
-                      }
-                    }
-                    if (typeof entry.quorumSize !== "number" || !Number.isFinite(entry.quorumSize) || entry.quorumSize < 5) {
-                      return JSON.stringify({
-                        success: false,
-                        phase,
-                        status: "blocked",
-                        reason: "FINAL_COUNCIL_MISSING_QUORUM",
-                        message: `Phase ${phase} (last phase) cannot be completed: final council evidence is missing valid quorum metadata. Re-run the project-scoped five-member final council and call write_final_council_evidence to generate quorumed evidence.`,
-                        agentsDispatched,
-                        agentsMissing: [],
-                        warnings: []
-                      }, null, 2);
-                    }
-                    const requiredFinalCouncilMembers = [
-                      "critic",
-                      "reviewer",
-                      "sme",
-                      "test_engineer",
-                      "explorer"
-                    ];
-                    const membersVoted = Array.isArray(entry.membersVoted) ? entry.membersVoted.filter((member) => typeof member === "string") : [];
-                    const membersAbsent = Array.isArray(entry.membersAbsent) ? entry.membersAbsent.filter((member) => typeof member === "string") : [];
-                    const distinctMembersVoted = new Set(membersVoted);
-                    const hasAllRequiredMembers = requiredFinalCouncilMembers.every((member) => distinctMembersVoted.has(member)) && distinctMembersVoted.size === requiredFinalCouncilMembers.length && membersAbsent.length === 0;
-                    if (!hasAllRequiredMembers) {
-                      return JSON.stringify({
-                        success: false,
-                        phase,
-                        status: "blocked",
-                        reason: "FINAL_COUNCIL_MISSING_QUORUM",
-                        message: `Phase ${phase} (last phase) cannot be completed: final council evidence does not prove all five required members voted. Re-run the project-scoped five-member final council and call write_final_council_evidence to generate complete evidence.`,
-                        agentsDispatched,
-                        agentsMissing: [],
-                        warnings: []
-                      }, null, 2);
-                    }
-                    if (entry.verdict === "rejected" || entry.verdict === "REJECTED") {
-                      return JSON.stringify({
-                        success: false,
-                        phase,
-                        status: "blocked",
-                        reason: "FINAL_COUNCIL_REJECTED",
-                        message: `Phase ${phase} (last phase) cannot be completed: final council returned verdict 'REJECTED'. Address the required fixes before completing the project.`,
-                        agentsDispatched,
-                        agentsMissing: [],
-                        warnings: []
-                      }, null, 2);
-                    }
-                    if (entry.verdict !== "approved" && entry.verdict !== "APPROVED") {
-                      return JSON.stringify({
-                        success: false,
-                        phase,
-                        status: "blocked",
-                        reason: "FINAL_COUNCIL_INVALID_VERDICT",
-                        message: `Phase ${phase} (last phase) cannot be completed: final council evidence contains unrecognized verdict '${entry.verdict}'. Expected 'approved'.`,
-                        agentsDispatched,
-                        agentsMissing: [],
-                        warnings: []
-                      }, null, 2);
-                    }
-                  }
-                }
-              } catch (readErr) {
-                if (readErr.code !== "ENOENT") {
-                  safeWarn(`[phase_complete] Final council evidence unreadable:`, readErr);
-                }
-                fcVerdictFound = false;
-              }
-              if (!fcVerdictFound) {
-                return JSON.stringify({
-                  success: false,
-                  phase,
-                  status: "blocked",
-                  reason: "FINAL_COUNCIL_REQUIRED",
-                  final_council_required: true,
-                  message: `Phase ${phase} (last phase) cannot be completed: final_council is enabled and final council evidence not found at .swarm/evidence/final-council.json. Dispatch critic, reviewer, sme, test_engineer, and explorer with project-scoped context, collect their CouncilMemberVerdict JSON, and call write_final_council_evidence before completing the project. Do not use convene_general_council for this gate.`,
-                  agentsDispatched,
-                  agentsMissing: [],
-                  warnings: [
-                    `Final council required - dispatch the five project-scoped council members, then call write_final_council_evidence to persist quorumed evidence.`
-                  ]
-                }, null, 2);
-              }
-            }
-          }
-        }
-      }
-    } catch (fcError) {
-      if (finalCouncilEnabled) {
-        warnings.push(`FINAL_COUNCIL_ERROR: ${String(fcError)}`);
-        return JSON.stringify({
-          success: false,
-          phase,
-          status: "blocked",
-          reason: "FINAL_COUNCIL_ERROR",
-          message: `Phase ${phase} (last phase) cannot be completed: final council gate encountered an error. Error: ${String(fcError)}`,
-          agentsDispatched,
-          agentsMissing: [],
-          warnings: [`FINAL_COUNCIL_ERROR: ${String(fcError)}`]
-        }, null, 2);
-      } else {
-        safeWarn(`[phase_complete] Final council gate error (non-blocking):`, fcError);
-      }
+    const gateResult = await runFinalCouncilGate(gateCtx);
+    if (gateResult.blocked) {
+      return blockedResult(phase, gateResult);
     }
+    warnings.push(...gateResult.warnings);
   }
   {
     const approval = verifyFullAutoPhaseApproval(dir, sessionID, phase, config3);
@@ -113112,7 +113246,7 @@ Findings: ${details.join("; ")}` : "";
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path127.basename(dir);
+      const projectName = path132.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -113212,14 +113346,14 @@ Findings: ${details.join("; ")}` : "";
     const markerPath = validateSwarmPath(dir, "skill-usage-last-processed.json");
     let sinceTimestamp;
     try {
-      const markerData = JSON.parse(fs90.readFileSync(markerPath, "utf-8"));
+      const markerData = JSON.parse(fs95.readFileSync(markerPath, "utf-8"));
       sinceTimestamp = markerData.lastProcessedTimestamp;
     } catch {}
     const feedbackResult = await applySkillUsageFeedback(dir, {
       sinceTimestamp
     });
     try {
-      fs90.writeFileSync(markerPath, JSON.stringify({ lastProcessedTimestamp: new Date().toISOString() }), "utf-8");
+      fs95.writeFileSync(markerPath, JSON.stringify({ lastProcessedTimestamp: new Date().toISOString() }), "utf-8");
     } catch {}
     if (feedbackResult.processed > 0) {
       const sessionState = swarmState.agentSessions.get(sessionID);
@@ -113239,7 +113373,7 @@ Findings: ${details.join("; ")}` : "";
   let phaseRequiredAgents;
   try {
     const planPath = validateSwarmPath(dir, "plan.json");
-    const planRaw = fs90.readFileSync(planPath, "utf-8");
+    const planRaw = fs95.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     const phaseObj = plan.phases.find((p) => p.id === phase);
     phaseRequiredAgents = phaseObj?.required_agents;
@@ -113254,7 +113388,7 @@ Findings: ${details.join("; ")}` : "";
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs90.readFileSync(planPath, "utf-8");
+      const planRaw = fs95.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && canInferMissingAgentsFromTaskGates(agentsMissing) && await allCompletedTasksHavePassedGateEvidence(dir, targetPhase.tasks)) {
@@ -113294,7 +113428,7 @@ Findings: ${details.join("; ")}` : "";
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs90.readFileSync(planPath, "utf-8");
+      const planRaw = fs95.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -113348,7 +113482,7 @@ Findings: ${details.join("; ")}` : "";
   }
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs90.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs95.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)}`);
@@ -113423,12 +113557,12 @@ Findings: ${details.join("; ")}` : "";
         warnings.push(`Warning: failed to update plan.json phase status`);
         try {
           const planPath = validateSwarmPath(dir, "plan.json");
-          const planRaw = fs90.readFileSync(planPath, "utf-8");
+          const planRaw = fs95.readFileSync(planPath, "utf-8");
           const plan2 = JSON.parse(planRaw);
           const phaseObj = plan2.phases.find((p) => p.id === phase);
           if (phaseObj) {
             phaseObj.status = "complete";
-            fs90.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
+            fs95.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
           }
         } catch {}
       } else if (plan) {
@@ -113465,12 +113599,12 @@ Findings: ${details.join("; ")}` : "";
       warnings.push(`Warning: failed to update plan.json phase status`);
       try {
         const planPath = validateSwarmPath(dir, "plan.json");
-        const planRaw = fs90.readFileSync(planPath, "utf-8");
+        const planRaw = fs95.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         const phaseObj = plan.phases.find((p) => p.id === phase);
         if (phaseObj) {
           phaseObj.status = "complete";
-          fs90.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
+          fs95.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
         }
       } catch {}
     }
@@ -113480,7 +113614,32 @@ Findings: ${details.join("; ")}` : "";
   }
   await flushPendingSnapshot(dir);
   await writeCheckpoint(dir).catch(() => {});
-  return JSON.stringify({ ...result, timestamp: event.timestamp, duration_ms: durationMs }, null, 2);
+  const outputData = {
+    ...result,
+    timestamp: event.timestamp,
+    duration_ms: durationMs
+  };
+  return _buildOutputJson(outputData);
+}
+function _buildOutputJson(outputData) {
+  let json3 = JSON.stringify(outputData, null, 2);
+  if (json3.length > MAX_OUTPUT_BYTES5) {
+    const truncated = {
+      _truncated: true,
+      _truncation_reason: `Output exceeded MAX_OUTPUT_BYTES (${MAX_OUTPUT_BYTES5}) limit`,
+      phase: outputData.phase,
+      success: outputData.success,
+      status: outputData.status,
+      message: outputData.message,
+      agentsDispatched: outputData.agentsDispatched?.slice(0, 10),
+      agentsMissing: outputData.agentsMissing?.slice(0, 10),
+      warnings: ["(output truncated — full output exceeded size limit)"],
+      timestamp: outputData.timestamp,
+      duration_ms: outputData.duration_ms
+    };
+    json3 = JSON.stringify(truncated, null, 2);
+  }
+  return json3;
 }
 var phase_complete = createSwarmTool({
   description: "Mark a phase as complete and track which agents were dispatched. Used for phase completion gating and tracking. Accepts phase number and optional summary. Returns list of agents that were dispatched.",
@@ -113528,9 +113687,9 @@ init_discovery();
 init_utils();
 init_bun_compat();
 init_create_tool();
-import * as fs91 from "node:fs";
-import * as path128 from "node:path";
-var MAX_OUTPUT_BYTES5 = 52428800;
+import * as fs96 from "node:fs";
+import * as path133 from "node:path";
+var MAX_OUTPUT_BYTES6 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
   return typeof value === "string" && [
@@ -113557,31 +113716,31 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs91.existsSync(path128.join(cwd, "package.json"))) {
+  if (fs96.existsSync(path133.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs91.existsSync(path128.join(cwd, "pyproject.toml")) || fs91.existsSync(path128.join(cwd, "requirements.txt"))) {
+  if (fs96.existsSync(path133.join(cwd, "pyproject.toml")) || fs96.existsSync(path133.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs91.existsSync(path128.join(cwd, "Cargo.toml"))) {
+  if (fs96.existsSync(path133.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs91.existsSync(path128.join(cwd, "go.mod"))) {
+  if (fs96.existsSync(path133.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs91.readdirSync(cwd);
+    const files = fs96.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs91.existsSync(path128.join(cwd, "Gemfile")) || fs91.existsSync(path128.join(cwd, "Gemfile.lock"))) {
+  if (fs96.existsSync(path133.join(cwd, "Gemfile")) || fs96.existsSync(path133.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs91.existsSync(path128.join(cwd, "pubspec.yaml"))) {
+  if (fs96.existsSync(path133.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs91.existsSync(path128.join(cwd, "composer.lock"))) {
+  if (fs96.existsSync(path133.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -113613,8 +113772,8 @@ async function runNpmAudit(directory) {
       };
     }
     let { stdout, stderr } = result;
-    if (stdout.length > MAX_OUTPUT_BYTES5) {
-      stdout = stdout.slice(0, MAX_OUTPUT_BYTES5);
+    if (stdout.length > MAX_OUTPUT_BYTES6) {
+      stdout = stdout.slice(0, MAX_OUTPUT_BYTES6);
     }
     const exitCode = await proc.exited;
     if (exitCode === 0) {
@@ -113733,8 +113892,8 @@ async function runPipAudit(directory) {
       };
     }
     let { stdout, stderr } = result;
-    if (stdout.length > MAX_OUTPUT_BYTES5) {
-      stdout = stdout.slice(0, MAX_OUTPUT_BYTES5);
+    if (stdout.length > MAX_OUTPUT_BYTES6) {
+      stdout = stdout.slice(0, MAX_OUTPUT_BYTES6);
     }
     const exitCode = await proc.exited;
     if (exitCode === 0 && !stdout.trim()) {
@@ -113861,8 +114020,8 @@ async function runCargoAudit(directory) {
       };
     }
     let { stdout, stderr: _stderr } = result;
-    if (stdout.length > MAX_OUTPUT_BYTES5) {
-      stdout = stdout.slice(0, MAX_OUTPUT_BYTES5);
+    if (stdout.length > MAX_OUTPUT_BYTES6) {
+      stdout = stdout.slice(0, MAX_OUTPUT_BYTES6);
     }
     const exitCode = await proc.exited;
     if (exitCode === 0) {
@@ -113985,8 +114144,8 @@ async function runGoAudit(directory) {
       };
     }
     let { stdout } = result;
-    if (stdout.length > MAX_OUTPUT_BYTES5) {
-      stdout = stdout.slice(0, MAX_OUTPUT_BYTES5);
+    if (stdout.length > MAX_OUTPUT_BYTES6) {
+      stdout = stdout.slice(0, MAX_OUTPUT_BYTES6);
     }
     const exitCode = await proc.exited;
     if (exitCode !== 0 && exitCode !== 3) {
@@ -114118,8 +114277,8 @@ async function runDotnetAudit(directory) {
       };
     }
     let { stdout } = result;
-    if (stdout.length > MAX_OUTPUT_BYTES5) {
-      stdout = stdout.slice(0, MAX_OUTPUT_BYTES5);
+    if (stdout.length > MAX_OUTPUT_BYTES6) {
+      stdout = stdout.slice(0, MAX_OUTPUT_BYTES6);
     }
     const exitCode = await proc.exited;
     if (exitCode !== 0 && !stdout.includes("has the following vulnerable packages")) {
@@ -114234,8 +114393,8 @@ async function runBundleAudit(directory) {
       };
     }
     let { stdout } = result;
-    if (stdout.length > MAX_OUTPUT_BYTES5) {
-      stdout = stdout.slice(0, MAX_OUTPUT_BYTES5);
+    if (stdout.length > MAX_OUTPUT_BYTES6) {
+      stdout = stdout.slice(0, MAX_OUTPUT_BYTES6);
     }
     const exitCode = await proc.exited;
     if (exitCode !== 0 && exitCode !== 1) {
@@ -114379,8 +114538,8 @@ async function runDartAudit(directory) {
       };
     }
     let { stdout } = result;
-    if (stdout.length > MAX_OUTPUT_BYTES5) {
-      stdout = stdout.slice(0, MAX_OUTPUT_BYTES5);
+    if (stdout.length > MAX_OUTPUT_BYTES6) {
+      stdout = stdout.slice(0, MAX_OUTPUT_BYTES6);
     }
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
@@ -114494,8 +114653,8 @@ async function runComposerAudit(directory) {
       };
     }
     let { stdout } = result;
-    if (stdout.length > MAX_OUTPUT_BYTES5) {
-      stdout = stdout.slice(0, MAX_OUTPUT_BYTES5);
+    if (stdout.length > MAX_OUTPUT_BYTES6) {
+      stdout = stdout.slice(0, MAX_OUTPUT_BYTES6);
     }
     const exitCode = await proc.exited;
     const hasVulnerabilities = (exitCode & 1) !== 0;
@@ -114716,8 +114875,8 @@ var pkg_audit = createSwarmTool({
 // src/tools/placeholder-scan.ts
 init_zod();
 init_manager2();
-import * as fs92 from "node:fs";
-import * as path129 from "node:path";
+import * as fs97 from "node:fs";
+import * as path134 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -114840,7 +114999,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path129.basename(filePath);
+  const filename = path134.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -114857,7 +115016,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path129.basename(filePath);
+    const filename = path134.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -114866,7 +115025,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path129.extname(filePath).toLowerCase();
+  const ext = path134.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -115113,28 +115272,28 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path129.isAbsolute(filePath) ? filePath : path129.resolve(directory, filePath);
-    const resolvedDirectory = path129.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path129.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path134.isAbsolute(filePath) ? filePath : path134.resolve(directory, filePath);
+    const resolvedDirectory = path134.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path134.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
-    if (!fs92.existsSync(fullPath)) {
+    if (!fs97.existsSync(fullPath)) {
       continue;
     }
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path129.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path134.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
     let content;
     try {
-      const stat9 = fs92.statSync(fullPath);
+      const stat9 = fs97.statSync(fullPath);
       if (stat9.size > MAX_FILE_SIZE) {
         continue;
       }
-      content = fs92.readFileSync(fullPath, "utf-8");
+      content = fs97.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -115195,8 +115354,8 @@ var placeholder_scan = createSwarmTool({
   }
 });
 // src/tools/pre-check-batch.ts
-import * as fs96 from "node:fs";
-import * as path133 from "node:path";
+import * as fs101 from "node:fs";
+import * as path138 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -115336,8 +115495,8 @@ var _internals56 = {
 init_zod();
 init_manager2();
 init_detector();
-import * as fs95 from "node:fs";
-import * as path132 from "node:path";
+import * as fs100 from "node:fs";
+import * as path137 from "node:path";
 import { extname as extname20 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -116052,8 +116211,8 @@ function executeRulesSync(filePath, content, language) {
 
 // src/sast/semgrep.ts
 import * as child_process9 from "node:child_process";
-import * as fs93 from "node:fs";
-import * as path130 from "node:path";
+import * as fs98 from "node:fs";
+import * as path135 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
@@ -116240,14 +116399,14 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path130.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path135.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
 function hasBundledRules(projectRoot) {
   const rulesDir = getRulesDirectory(projectRoot);
   try {
-    return fs93.existsSync(rulesDir);
+    return fs98.existsSync(rulesDir);
   } catch {
     return false;
   }
@@ -116260,25 +116419,25 @@ init_create_tool();
 // src/tools/sast-baseline.ts
 init_utils2();
 import * as crypto11 from "node:crypto";
-import * as fs94 from "node:fs";
-import * as path131 from "node:path";
+import * as fs99 from "node:fs";
+import * as path136 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
 var MAX_BASELINE_BYTES = 2 * 1048576;
 var LOCK_RETRY_DELAYS_MS = [50, 100, 200, 400, 800];
 function normalizeFindingPath(directory, file3) {
-  const resolved = path131.isAbsolute(file3) ? file3 : path131.resolve(directory, file3);
-  const rel = path131.relative(path131.resolve(directory), resolved);
+  const resolved = path136.isAbsolute(file3) ? file3 : path136.resolve(directory, file3);
+  const rel = path136.relative(path136.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path131.join("evidence", String(phase), "sast-baseline.json");
+  return path136.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path131.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path136.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path131.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path136.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -116295,7 +116454,7 @@ function fingerprintFinding(finding, directory, occurrenceIndex) {
   }
   const lineNum = finding.location.line;
   try {
-    const content = fs94.readFileSync(finding.location.file, "utf-8");
+    const content = fs99.readFileSync(finding.location.file, "utf-8");
     const lines = content.split(`
 `);
     const idx = lineNum - 1;
@@ -116326,7 +116485,7 @@ function assignOccurrenceIndices(findings, directory) {
     try {
       if (relFile.startsWith(".."))
         throw new Error("escapes workspace");
-      const content = fs94.readFileSync(finding.location.file, "utf-8");
+      const content = fs99.readFileSync(finding.location.file, "utf-8");
       const lines = content.split(`
 `);
       const idx = lineNum - 1;
@@ -116355,11 +116514,11 @@ function assignOccurrenceIndices(findings, directory) {
 async function acquireLock2(lockPath) {
   for (let attempt = 0;attempt <= LOCK_RETRY_DELAYS_MS.length; attempt++) {
     try {
-      const fd = fs94.openSync(lockPath, "wx");
-      fs94.closeSync(fd);
+      const fd = fs99.openSync(lockPath, "wx");
+      fs99.closeSync(fd);
       return () => {
         try {
-          fs94.unlinkSync(lockPath);
+          fs99.unlinkSync(lockPath);
         } catch {}
       };
     } catch {
@@ -116399,13 +116558,13 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs94.mkdirSync(path131.dirname(baselinePath), { recursive: true });
-  fs94.mkdirSync(path131.dirname(tempPath), { recursive: true });
+  fs99.mkdirSync(path136.dirname(baselinePath), { recursive: true });
+  fs99.mkdirSync(path136.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
     try {
-      const raw = fs94.readFileSync(baselinePath, "utf-8");
+      const raw = fs99.readFileSync(baselinePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.schema_version === BASELINE_SCHEMA_VERSION) {
         existing = parsed;
@@ -116465,8 +116624,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
           message: `Baseline would exceed size cap (${json4.length} bytes > ${MAX_BASELINE_BYTES})`
         };
       }
-      fs94.writeFileSync(tempPath, json4, "utf-8");
-      fs94.renameSync(tempPath, baselinePath);
+      fs99.writeFileSync(tempPath, json4, "utf-8");
+      fs99.renameSync(tempPath, baselinePath);
       return {
         status: "merged",
         path: baselinePath,
@@ -116497,8 +116656,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
         message: `Baseline would exceed size cap (${json3.length} bytes > ${MAX_BASELINE_BYTES})`
       };
     }
-    fs94.writeFileSync(tempPath, json3, "utf-8");
-    fs94.renameSync(tempPath, baselinePath);
+    fs99.writeFileSync(tempPath, json3, "utf-8");
+    fs99.renameSync(tempPath, baselinePath);
     return {
       status: "written",
       path: baselinePath,
@@ -116523,7 +116682,7 @@ function loadBaseline(directory, phase) {
     };
   }
   try {
-    const raw = fs94.readFileSync(baselinePath, "utf-8");
+    const raw = fs99.readFileSync(baselinePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schema_version !== BASELINE_SCHEMA_VERSION) {
       return {
@@ -116571,17 +116730,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs95.statSync(filePath);
+    const stats = fs100.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES8) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs95.openSync(filePath, "r");
+    const fd = fs100.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs95.readSync(fd, buffer, 0, 8192, 0);
-    fs95.closeSync(fd);
+    const bytesRead = fs100.readSync(fd, buffer, 0, 8192, 0);
+    fs100.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -116620,7 +116779,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs95.readFileSync(filePath, "utf-8");
+    const content = fs100.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -116673,13 +116832,13 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path132.isAbsolute(filePath) ? filePath : path132.resolve(directory, filePath);
-    const resolvedDirectory = path132.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path132.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path137.isAbsolute(filePath) ? filePath : path137.resolve(directory, filePath);
+    const resolvedDirectory = path137.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path137.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
-    if (!fs95.existsSync(resolvedPath)) {
+    if (!fs100.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -116990,18 +117149,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path133.win32.resolve(inputPath);
-  } else if (path133.isAbsolute(inputPath)) {
-    resolved = path133.resolve(inputPath);
+    resolved = path138.win32.resolve(inputPath);
+  } else if (path138.isAbsolute(inputPath)) {
+    resolved = path138.resolve(inputPath);
   } else {
-    resolved = path133.resolve(baseDir, inputPath);
+    resolved = path138.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path133.resolve(workspaceDir);
+  const workspaceResolved = path138.resolve(workspaceDir);
   let relative27;
   if (isWinAbs) {
-    relative27 = path133.win32.relative(workspaceResolved, resolved);
+    relative27 = path138.win32.relative(workspaceResolved, resolved);
   } else {
-    relative27 = path133.relative(workspaceResolved, resolved);
+    relative27 = path138.relative(workspaceResolved, resolved);
   }
   if (relative27.startsWith("..")) {
     return "path traversal detected";
@@ -117066,7 +117225,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path133.resolve(file3);
+    const resolvedPath = path138.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -117223,7 +117382,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path133.resolve(file3);
+      const resolvedPath = path138.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -117241,14 +117400,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path133.extname(file3).toLowerCase();
+      const ext = path138.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat9;
       try {
-        stat9 = fs96.statSync(file3);
+        stat9 = fs101.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -117259,7 +117418,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs96.readFileSync(file3);
+        const buffer = fs101.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -117460,7 +117619,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path133.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path138.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -117511,7 +117670,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path133.resolve(directory, file3));
+    changedFiles.push(path138.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -117712,9 +117871,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path133.resolve(typedArgs.directory);
-    const workspaceAnchor = path133.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path133.sep)) {
+    const resolvedDirectory = path138.resolve(typedArgs.directory);
+    const workspaceAnchor = path138.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path138.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -117765,7 +117924,7 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/repo-map.ts
 init_zod();
-import * as path134 from "node:path";
+import * as path139 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -117790,7 +117949,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path134.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path139.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -117813,8 +117972,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path134.isAbsolute(normalized)) {
-    const rel = path134.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path139.isAbsolute(normalized)) {
+    const rel = path139.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -117958,8 +118117,8 @@ var repo_map = createSwarmTool({
 // src/tools/req-coverage.ts
 init_zod();
 init_create_tool();
-import * as fs97 from "node:fs";
-import * as path135 from "node:path";
+import * as fs102 from "node:fs";
+import * as path140 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS = ["MUST", "SHOULD", "SHALL"];
@@ -118018,19 +118177,19 @@ function extractObligationAndText(id, lineText) {
 var PHASE_TASK_ID_REGEX = /^\d+\.\d+(\.\d+)*$/;
 function readTouchedFiles(evidenceDir, phase, cwd) {
   const touchedFiles = new Set;
-  if (!fs97.existsSync(evidenceDir) || !fs97.statSync(evidenceDir).isDirectory()) {
+  if (!fs102.existsSync(evidenceDir) || !fs102.statSync(evidenceDir).isDirectory()) {
     return [];
   }
   let entries;
   try {
-    entries = fs97.readdirSync(evidenceDir);
+    entries = fs102.readdirSync(evidenceDir);
   } catch {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path135.join(evidenceDir, entry);
+    const entryPath = path140.join(evidenceDir, entry);
     try {
-      const stat9 = fs97.statSync(entryPath);
+      const stat9 = fs102.statSync(entryPath);
       if (!stat9.isDirectory()) {
         continue;
       }
@@ -118044,14 +118203,14 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path135.join(entryPath, "evidence.json");
+    const evidenceFilePath = path140.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path135.resolve(evidenceFilePath);
-      const evidenceDirResolved = path135.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path135.sep)) {
+      const resolvedPath = path140.resolve(evidenceFilePath);
+      const evidenceDirResolved = path140.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path140.sep)) {
         continue;
       }
-      const stat9 = fs97.lstatSync(evidenceFilePath);
+      const stat9 = fs102.lstatSync(evidenceFilePath);
       if (!stat9.isFile()) {
         continue;
       }
@@ -118063,7 +118222,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     }
     let content;
     try {
-      content = fs97.readFileSync(evidenceFilePath, "utf-8");
+      content = fs102.readFileSync(evidenceFilePath, "utf-8");
     } catch {
       continue;
     }
@@ -118082,7 +118241,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
             if (Array.isArray(diffEntry.files_changed)) {
               for (const file3 of diffEntry.files_changed) {
                 if (typeof file3 === "string") {
-                  touchedFiles.add(path135.resolve(cwd, file3));
+                  touchedFiles.add(path140.resolve(cwd, file3));
                 }
               }
             }
@@ -118095,12 +118254,12 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path135.resolve(filePath);
-    const cwdResolved = path135.resolve(cwd);
+    const resolvedPath = path140.resolve(filePath);
+    const cwdResolved = path140.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
-    const content = fs97.readFileSync(resolvedPath, "utf-8");
+    const content = fs102.readFileSync(resolvedPath, "utf-8");
     for (const keyword of keywords) {
       const regex = new RegExp(`\\b${keyword}\\b`, "i");
       if (regex.test(content)) {
@@ -118230,10 +118389,10 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path135.join(cwd, SPEC_FILE);
+    const specPath = path140.join(cwd, SPEC_FILE);
     let specContent;
     try {
-      specContent = fs97.readFileSync(specPath, "utf-8");
+      specContent = fs102.readFileSync(specPath, "utf-8");
     } catch (readError) {
       return JSON.stringify({
         success: false,
@@ -118257,7 +118416,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path135.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path140.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -118283,12 +118442,12 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path135.join(evidenceDir, reportFilename);
+    const reportPath = path140.join(evidenceDir, reportFilename);
     try {
-      if (!fs97.existsSync(evidenceDir)) {
-        fs97.mkdirSync(evidenceDir, { recursive: true });
+      if (!fs102.existsSync(evidenceDir)) {
+        fs102.mkdirSync(evidenceDir, { recursive: true });
       }
-      fs97.writeFileSync(reportPath, JSON.stringify(result, null, 2), "utf-8");
+      fs102.writeFileSync(reportPath, JSON.stringify(result, null, 2), "utf-8");
     } catch (writeError) {
       console.warn(`Failed to write coverage report: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
     }
@@ -118370,8 +118529,8 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as crypto12 from "node:crypto";
-import * as fs98 from "node:fs";
-import * as path136 from "node:path";
+import * as fs103 from "node:fs";
+import * as path141 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -118452,17 +118611,17 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path136.resolve(args2.working_directory);
-    const resolvedRoot = path136.resolve(fallbackDir);
+    const resolvedTarget = path141.resolve(args2.working_directory);
+    const resolvedRoot = path141.resolve(fallbackDir);
     let fallbackExists = false;
     try {
-      fs98.accessSync(resolvedRoot, fs98.constants.F_OK);
+      fs103.accessSync(resolvedRoot, fs103.constants.F_OK);
       fallbackExists = true;
     } catch {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path136.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path141.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -118478,11 +118637,11 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path136.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path141.join(targetWorkspace, ".swarm", "spec.md");
     try {
-      const stat9 = await fs98.promises.stat(specPath);
+      const stat9 = await fs103.promises.stat(specPath);
       specMtime = stat9.mtime.toISOString();
-      const content = await fs98.promises.readFile(specPath, "utf8");
+      const content = await fs103.promises.readFile(specPath, "utf8");
       specHash = crypto12.createHash("sha256").update(content).digest("hex");
     } catch {
       return {
@@ -118494,10 +118653,10 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path136.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path141.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
-      contextContent = await fs98.promises.readFile(contextPath, "utf8");
+      contextContent = await fs103.promises.readFile(contextPath, "utf8");
     } catch {}
     const hasPendingSection = contextContent.includes("## Pending QA Gate Selection");
     if (!hasPendingSection) {
@@ -118784,14 +118943,14 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path136.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path141.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 fs98.promises.writeFile(markerPath, marker, "utf8");
+        await fs103.promises.writeFile(markerPath, marker, "utf8");
       } catch {}
       const warnings = [];
       let criticReviewFound = false;
@@ -118807,7 +118966,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path136.join(dir, ".swarm", "plan.json"),
+        plan_path: path141.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -118872,8 +119031,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_zod();
 init_manager2();
-import * as fs99 from "node:fs";
-import * as path137 from "node:path";
+import * as fs104 from "node:fs";
+import * as path142 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -119721,9 +119880,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs99.readdirSync(dir, { withFileTypes: true });
+      const entries = fs104.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path137.join(dir, entry.name);
+        const fullPath = path142.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -119732,7 +119891,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path137.relative(rootDir, fullPath));
+              manifestFiles.push(path142.relative(rootDir, fullPath));
               break;
             }
           }
@@ -119748,13 +119907,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs99.readdirSync(dir, { withFileTypes: true });
+      const entries = fs104.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path137.join(dir, entry.name);
+        const fullPath = path142.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path137.relative(workingDir, fullPath));
+              found.push(path142.relative(workingDir, fullPath));
               break;
             }
           }
@@ -119767,11 +119926,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path137.dirname(file3);
+    let currentDir = path142.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path137.sep) {
-        dirs.add(path137.join(workingDir, currentDir));
-        const parent = path137.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path142.sep) {
+        dirs.add(path142.join(workingDir, currentDir));
+        const parent = path142.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -119785,7 +119944,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs99.mkdirSync(outputDir, { recursive: true });
+    fs104.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -119855,7 +120014,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path137.isAbsolute(relativeOutputDir) ? relativeOutputDir : path137.join(workingDir, relativeOutputDir);
+    const outputDir = path142.isAbsolute(relativeOutputDir) ? relativeOutputDir : path142.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -119878,11 +120037,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path137.isAbsolute(manifestFile) ? manifestFile : path137.join(workingDir, manifestFile);
-        if (!fs99.existsSync(fullPath)) {
+        const fullPath = path142.isAbsolute(manifestFile) ? manifestFile : path142.join(workingDir, manifestFile);
+        if (!fs104.existsSync(fullPath)) {
           continue;
         }
-        const content = fs99.readFileSync(fullPath, "utf-8");
+        const content = fs104.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -119895,8 +120054,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path137.join(outputDir, filename);
-    fs99.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path142.join(outputDir, filename);
+    fs104.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -119938,8 +120097,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_zod();
 init_create_tool();
-import * as fs100 from "node:fs";
-import * as path138 from "node:path";
+import * as fs105 from "node:fs";
+import * as path143 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -119971,28 +120130,28 @@ function normalizePath4(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path138.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path138.sep) ? cwd : cwd + path138.sep;
+    const resolvedPath = path143.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path143.sep) ? cwd : cwd + path143.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path138.extname(resolvedPath).toLowerCase();
+    const ext = path143.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 = fs100.statSync(resolvedPath);
+    const stats = fs105.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs100.existsSync(resolvedPath)) {
+    if (!fs105.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path138.resolve(cwd, candidate);
-    if (fs100.existsSync(candidatePath)) {
-      const stats = fs100.statSync(candidatePath);
+    const candidatePath = path143.resolve(cwd, candidate);
+    if (fs105.existsSync(candidatePath)) {
+      const stats = fs105.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -120001,8 +120160,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs100.readFileSync(specFile, "utf-8");
-  const ext = path138.extname(specFile).toLowerCase();
+  const content = fs105.readFileSync(specFile, "utf-8");
+  const ext = path143.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -120073,12 +120232,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs100.readdirSync(dir, { withFileTypes: true });
+      entries = fs105.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path138.join(dir, entry.name);
+      const fullPath = path143.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -120088,7 +120247,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path138.extname(entry.name).toLowerCase();
+        const ext = path143.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -120106,7 +120265,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs100.readFileSync(filePath, "utf-8");
+  const content = fs105.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;
@@ -120255,8 +120414,8 @@ init_zod();
 init_bun_compat();
 init_path_security();
 init_create_tool();
-import * as fs101 from "node:fs";
-import * as path139 from "node:path";
+import * as fs106 from "node:fs";
+import * as path144 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -120292,11 +120451,11 @@ function containsWindowsAttacks3(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path139.resolve(workspace, filePath);
-    const realWorkspace = fs101.realpathSync(workspace);
-    const realResolvedPath = fs101.realpathSync(resolvedPath);
-    const relativePath = path139.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path139.isAbsolute(relativePath)) {
+    const resolvedPath = path144.resolve(workspace, filePath);
+    const realWorkspace = fs106.realpathSync(workspace);
+    const realResolvedPath = fs106.realpathSync(resolvedPath);
+    const relativePath = path144.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path144.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -120309,12 +120468,12 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path139.delimiter)) {
+  for (const dir of searchPath.split(path144.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path139.join(dir, isWindows ? "rg.exe" : "rg");
-    if (fs101.existsSync(candidate))
+    const candidate = path144.join(dir, isWindows ? "rg.exe" : "rg");
+    if (fs106.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -120441,10 +120600,10 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
     return files;
   }
   try {
-    const entries = fs101.readdirSync(dir, { withFileTypes: true });
+    const entries = fs106.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path139.join(dir, entry.name);
-      const relativePath = path139.relative(workspace, fullPath);
+      const fullPath = path144.join(dir, entry.name);
+      const relativePath = path144.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -120485,13 +120644,13 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path139.join(opts.workspace, file3);
+    const fullPath = path144.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
     let stats;
     try {
-      stats = fs101.statSync(fullPath);
+      stats = fs106.statSync(fullPath);
       if (stats.size > MAX_FILE_SIZE_BYTES10) {
         continue;
       }
@@ -120500,7 +120659,7 @@ async function fallbackSearch(opts) {
     }
     let content;
     try {
-      content = fs101.readFileSync(fullPath, "utf-8");
+      content = fs106.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -120612,7 +120771,7 @@ var search = createSwarmTool({
         message: "Exclude pattern contains invalid Windows-specific sequence"
       }, null, 2);
     }
-    if (!fs101.existsSync(directory)) {
+    if (!fs106.existsSync(directory)) {
       return JSON.stringify({
         error: true,
         type: "unknown",
@@ -120890,7 +121049,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir23, rename as rename9, writeFile as writeFile18 } from "node:fs/promises";
-import * as path140 from "node:path";
+import * as path145 from "node:path";
 var MAX_SPEC_BYTES = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -120931,14 +121090,14 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path140.join(directory, ".swarm", "spec.md");
-    await mkdir23(path140.dirname(target), { recursive: true });
+    const target = path145.join(directory, ".swarm", "spec.md");
+    await mkdir23(path145.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
       try {
-        const fs102 = await import("node:fs/promises");
-        const prior = await fs102.readFile(target, "utf-8");
+        const fs107 = await import("node:fs/promises");
+        const prior = await fs107.readFile(target, "utf-8");
         finalContent = `${prior.replace(/\s+$/, "")}
 
 ${content}
@@ -120962,12 +121121,12 @@ init_loader();
 import {
   existsSync as existsSync82,
   mkdirSync as mkdirSync35,
-  readFileSync as readFileSync63,
+  readFileSync as readFileSync68,
   renameSync as renameSync21,
   unlinkSync as unlinkSync18,
   writeFileSync as writeFileSync28
 } from "node:fs";
-import path141 from "node:path";
+import path146 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -121097,9 +121256,9 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path141.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path146.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
-    const raw = readFileSync63(mutationGatePath, "utf-8");
+    const raw = readFileSync68(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
     const gateEntry = (parsed.entries ?? []).find((entry) => entry?.type === "mutation-gate");
     if (!gateEntry) {
@@ -121159,9 +121318,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis) {
-  const evidenceDir = path141.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  const evidenceDir = path146.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
   mkdirSync35(evidenceDir, { recursive: true });
-  const evidenceFile = path141.join(evidenceDir, "phase-council.json");
+  const evidenceFile = path146.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -121530,7 +121689,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path142 from "node:path";
+import * as path147 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -121594,7 +121753,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
       if (config3.architectural_supervision?.persist_knowledge_recommendations && args2.knowledge_recommendations.length > 0) {
         const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
         const lessons = args2.knowledge_recommendations.map((r) => r.lesson);
-        const result = await curateAndStoreSwarm(lessons, path142.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
+        const result = await curateAndStoreSwarm(lessons, path147.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
         knowledgeProposed = result.stored;
       }
     } catch {}
@@ -121625,8 +121784,8 @@ var write_architecture_supervisor_evidence = createSwarmTool({
 init_zod();
 init_path_security();
 init_create_tool();
-import * as fs102 from "node:fs";
-import * as path143 from "node:path";
+import * as fs107 from "node:fs";
+import * as path148 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
@@ -121640,14 +121799,14 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path143.resolve(workspace, filePath);
-    if (!fs102.existsSync(resolvedPath)) {
+    const resolvedPath = path148.resolve(workspace, filePath);
+    if (!fs107.existsSync(resolvedPath)) {
       return true;
     }
-    const realWorkspace = fs102.realpathSync(workspace);
-    const realResolvedPath = fs102.realpathSync(resolvedPath);
-    const relativePath = path143.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path143.isAbsolute(relativePath)) {
+    const realWorkspace = fs107.realpathSync(workspace);
+    const realResolvedPath = fs107.realpathSync(resolvedPath);
+    const relativePath = path148.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path148.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -121819,7 +121978,7 @@ var suggestPatch = createSwarmTool({
         message: "changes cannot be empty"
       }, null, 2);
     }
-    if (!fs102.existsSync(directory)) {
+    if (!fs107.existsSync(directory)) {
       return JSON.stringify({
         success: false,
         error: true,
@@ -121855,8 +122014,8 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path143.resolve(directory, change.file);
-      if (!fs102.existsSync(fullPath)) {
+      const fullPath = path148.resolve(directory, change.file);
+      if (!fs107.existsSync(fullPath)) {
         errors5.push({
           success: false,
           error: true,
@@ -121870,7 +122029,7 @@ var suggestPatch = createSwarmTool({
       }
       let content;
       try {
-        content = fs102.readFileSync(fullPath, "utf-8");
+        content = fs107.readFileSync(fullPath, "utf-8");
       } catch (err3) {
         errors5.push({
           success: false,
@@ -122158,12 +122317,12 @@ var lean_turbo_acquire_locks = createSwarmTool({
 // src/tools/lean-turbo-plan-lanes.ts
 init_zod();
 init_constants();
-import * as fs104 from "node:fs";
-import * as path145 from "node:path";
+import * as fs109 from "node:fs";
+import * as path150 from "node:path";
 
 // src/turbo/lean/conflicts.ts
-import * as fs103 from "node:fs";
-import * as path144 from "node:path";
+import * as fs108 from "node:fs";
+import * as path149 from "node:path";
 var DEFAULT_GLOBAL_FILES = [
   "package.json",
   "package-lock.json",
@@ -122290,12 +122449,12 @@ function isProtectedPath2(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path144.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path149.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
-    if (!fs103.existsSync(scopePath)) {
+    if (!fs108.existsSync(scopePath)) {
       return null;
     }
-    const raw = fs103.readFileSync(scopePath, "utf-8");
+    const raw = fs108.readFileSync(scopePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.files)) {
       return null;
@@ -122678,12 +122837,12 @@ function createEmptyPlan(phaseNumber, planId) {
 // src/tools/lean-turbo-plan-lanes.ts
 init_create_tool();
 function readPlanJson(directory) {
-  const planPath = path145.join(directory, ".swarm", "plan.json");
-  if (!fs104.existsSync(planPath)) {
+  const planPath = path150.join(directory, ".swarm", "plan.json");
+  if (!fs109.existsSync(planPath)) {
     return null;
   }
   try {
-    return JSON.parse(fs104.readFileSync(planPath, "utf-8"));
+    return JSON.parse(fs109.readFileSync(planPath, "utf-8"));
   } catch {
     return null;
   }
@@ -122732,8 +122891,8 @@ init_config();
 
 // src/turbo/lean/reviewer.ts
 init_state();
-import * as fs105 from "node:fs/promises";
-import * as path146 from "node:path";
+import * as fs110 from "node:fs/promises";
+import * as path151 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
   reviewerAgent: "",
@@ -122849,9 +123008,9 @@ function parseReviewerVerdict(responseText) {
   return { verdict, reason };
 }
 async function writeReviewerEvidence(directory, phase, verdict, reason) {
-  const evidenceDir = path146.join(directory, ".swarm", "evidence", String(phase));
-  await fs105.mkdir(evidenceDir, { recursive: true });
-  const evidencePath = path146.join(evidenceDir, "lean-turbo-reviewer.json");
+  const evidenceDir = path151.join(directory, ".swarm", "evidence", String(phase));
+  await fs110.mkdir(evidenceDir, { recursive: true });
+  const evidencePath = path151.join(evidenceDir, "lean-turbo-reviewer.json");
   const content = JSON.stringify({
     phase,
     verdict,
@@ -122860,11 +123019,11 @@ async function writeReviewerEvidence(directory, phase, verdict, reason) {
   }, null, 2);
   const tempPath = `${evidencePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    await fs105.writeFile(tempPath, content, "utf-8");
-    await fs105.rename(tempPath, evidencePath);
+    await fs110.writeFile(tempPath, content, "utf-8");
+    await fs110.rename(tempPath, evidencePath);
   } catch (error93) {
     try {
-      await fs105.unlink(tempPath);
+      await fs110.unlink(tempPath);
     } catch {}
     throw error93;
   }
@@ -123655,8 +123814,8 @@ var lean_turbo_status = createSwarmTool({
 // src/tools/lint-spec.ts
 init_spec_schema();
 init_create_tool();
-import * as fs106 from "node:fs";
-import * as path147 from "node:path";
+import * as fs111 from "node:fs";
+import * as path152 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -123709,8 +123868,8 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path147.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
-    if (!fs106.existsSync(specPath)) {
+    const specPath = path152.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    if (!fs111.existsSync(specPath)) {
       const result2 = {
         valid: false,
         specMtime: null,
@@ -123729,12 +123888,12 @@ var lint_spec = createSwarmTool({
     }
     let specMtime = null;
     try {
-      const stats = fs106.statSync(specPath);
+      const stats = fs111.statSync(specPath);
       specMtime = stats.mtime.toISOString();
     } catch {}
     let content;
     try {
-      content = fs106.readFileSync(specPath, "utf-8");
+      content = fs111.readFileSync(specPath, "utf-8");
     } catch (e) {
       const result2 = {
         valid: false,
@@ -123779,13 +123938,13 @@ var lint_spec = createSwarmTool({
 });
 // src/tools/mutation-test.ts
 init_zod();
-import * as fs107 from "node:fs";
-import * as path149 from "node:path";
+import * as fs112 from "node:fs";
+import * as path154 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
 import { unlinkSync as unlinkSync19, writeFileSync as writeFileSync29 } from "node:fs";
-import * as path148 from "node:path";
+import * as path153 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -123931,7 +124090,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path148.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path153.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync29(patchFile, patch.patch);
     } catch (writeErr) {
@@ -124335,8 +124494,8 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path149.resolve(cwd, filePath);
-          sourceFiles.set(filePath, fs107.readFileSync(resolvedPath, "utf-8"));
+          const resolvedPath = path154.resolve(cwd, filePath);
+          sourceFiles.set(filePath, fs112.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
       const report = await executeMutationSuite(typedArgs.patches, typedArgs.test_command, typedArgs.files, cwd, undefined, undefined, sourceFiles.size > 0 ? sourceFiles : undefined);
@@ -124354,8 +124513,8 @@ var mutation_test = createSwarmTool({
 init_zod();
 init_manager2();
 init_detector();
-import * as fs108 from "node:fs";
-import * as path150 from "node:path";
+import * as fs113 from "node:fs";
+import * as path155 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -124421,7 +124580,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path150.extname(file3.path).toLowerCase();
+      const ext = path155.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -124434,7 +124593,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path150.isAbsolute(filePath) ? filePath : path150.join(directory, filePath);
+    const fullPath = path155.isAbsolute(filePath) ? filePath : path155.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -124464,7 +124623,7 @@ async function syntaxCheck(input, directory, config3) {
       }
       let content;
       try {
-        content = fs108.readFileSync(fullPath, "utf8");
+        content = fs113.readFileSync(fullPath, "utf8");
       } catch {
         result.skipped_reason = "file_read_error";
         skippedCount++;
@@ -124483,7 +124642,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path150.extname(filePath).toLowerCase();
+      const ext = path155.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -124580,8 +124739,8 @@ init_zod();
 init_utils();
 init_create_tool();
 init_path_security();
-import * as fs109 from "node:fs";
-import * as path151 from "node:path";
+import * as fs114 from "node:fs";
+import * as path156 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -124647,9 +124806,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path151.resolve(paths);
-    const normalizedCwd = path151.resolve(cwd);
-    const normalizedResolved = path151.resolve(resolvedPath);
+    const resolvedPath = path156.resolve(paths);
+    const normalizedCwd = path156.resolve(cwd);
+    const normalizedResolved = path156.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -124665,13 +124824,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path151.extname(filePath).toLowerCase();
+  const ext = path156.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
   let entries;
   try {
-    entries = fs109.readdirSync(dir);
+    entries = fs114.readdirSync(dir);
   } catch {
     return files;
   }
@@ -124680,10 +124839,10 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path151.join(dir, entry);
+    const fullPath = path156.join(dir, entry);
     let stat9;
     try {
-      stat9 = fs109.statSync(fullPath);
+      stat9 = fs114.statSync(fullPath);
     } catch {
       continue;
     }
@@ -124776,7 +124935,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs109.existsSync(scanPath)) {
+    if (!fs114.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -124786,13 +124945,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat9 = fs109.statSync(scanPath);
+    const stat9 = fs114.statSync(scanPath);
     if (stat9.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path151.extname(scanPath)}`,
+          error: `unsupported file extension: ${path156.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -124805,11 +124964,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs109.statSync(filePath);
+        const fileStat = fs114.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES11) {
           continue;
         }
-        const content = fs109.readFileSync(filePath, "utf-8");
+        const content = fs114.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -124840,18 +124999,18 @@ init_loader();
 init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
-import * as fs113 from "node:fs";
-import * as path155 from "node:path";
+import * as fs118 from "node:fs";
+import * as path160 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
-import * as fs111 from "node:fs";
-import * as path153 from "node:path";
+import * as fs116 from "node:fs";
+import * as path158 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
-import * as fs110 from "node:fs";
-import * as path152 from "node:path";
+import * as fs115 from "node:fs";
+import * as path157 from "node:path";
 var _internals67 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
@@ -124925,16 +125084,16 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path152.isAbsolute(excludeRelPath) ? excludeRelPath : path152.join(directory, excludeRelPath);
+    const excludePath = path157.isAbsolute(excludeRelPath) ? excludeRelPath : path157.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs110.mkdirSync(path152.dirname(excludePath), { recursive: true });
+        fs115.mkdirSync(path157.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
-          existing = fs110.readFileSync(excludePath, "utf8");
+          existing = fs115.readFileSync(excludePath, "utf8");
         } catch {}
         if (!fileCoversSwarm(existing)) {
-          fs110.appendFileSync(excludePath, `
+          fs115.appendFileSync(excludePath, `
 # opencode-swarm local runtime state
 .swarm/
 `, "utf8");
@@ -124972,10 +125131,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 var _internals68 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path153.join(directory, ".swarm", "plan.json");
-    if (!fs111.existsSync(planPath))
+    const planPath = path158.join(directory, ".swarm", "plan.json");
+    if (!fs116.existsSync(planPath))
       return null;
-    const raw = fs111.readFileSync(planPath, "utf-8");
+    const raw = fs116.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -125077,8 +125236,8 @@ init_telemetry();
 
 // src/turbo/lean/task-completion.ts
 init_file_locks();
-import * as fs112 from "node:fs";
-import * as path154 from "node:path";
+import * as fs117 from "node:fs";
+import * as path159 from "node:path";
 var _internals69 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
@@ -125097,7 +125256,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path154.basename(file3);
+    const fileName = path159.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -125109,14 +125268,14 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path154.join(directory, ".swarm", "turbo-state.json");
-    if (!fs112.existsSync(statePath)) {
+    const statePath = path159.join(directory, ".swarm", "turbo-state.json");
+    if (!fs117.existsSync(statePath)) {
       return {
         ok: false,
         reason: "Lean Turbo state file not found"
       };
     }
-    const raw = fs112.readFileSync(statePath, "utf-8");
+    const raw = fs117.readFileSync(statePath, "utf-8");
     persisted = JSON.parse(raw);
   } catch {
     return {
@@ -125193,11 +125352,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path154.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path154.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path154.resolve(evidencePath);
-  const resolvedDir = path154.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path154.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path159.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path159.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path159.resolve(evidencePath);
+  const resolvedDir = path159.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path159.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -125209,7 +125368,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  if (!fs112.existsSync(evidencePath)) {
+  if (!fs117.existsSync(evidencePath)) {
     return {
       ok: false,
       reason: `Lane ${lane.laneId} evidence file not found: ${evidencePath}`,
@@ -125237,8 +125396,8 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path154.join(directory, ".swarm", "plan.json");
-    const planRaw = fs112.readFileSync(planPath, "utf-8");
+    const planPath = path159.join(directory, ".swarm", "plan.json");
+    const planRaw = fs117.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
       for (const task of planPhase.tasks ?? []) {
@@ -125321,7 +125480,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path155.basename(file3);
+    const fileName = path160.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -125360,8 +125519,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path155.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs113.readFileSync(planPath, "utf-8");
+        const planPath = path160.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs118.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -125438,8 +125597,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path155.join(resolvedDir, ".swarm", "plan.json");
-        const planRaw = fs113.readFileSync(planPath, "utf-8");
+        const planPath = path160.join(resolvedDir, ".swarm", "plan.json");
+        const planRaw = fs118.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -125657,72 +125816,35 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
       session.currentTaskId = args2.task_id;
     }
   }
-  let normalizedDir;
   let directory;
-  if (args2.working_directory != null) {
-    if (args2.working_directory.includes("\x00")) {
-      return {
-        success: false,
-        message: "Invalid working_directory: null bytes are not allowed"
-      };
-    }
-    {
-      const devicePathPattern = /^\\\\|^(NUL|CON|AUX|COM[1-9]|LPT[1-9])(\..*)?$/i;
-      if (devicePathPattern.test(args2.working_directory)) {
-        return {
-          success: false,
-          message: "Invalid working_directory: Windows device paths are not allowed"
-        };
-      }
-    }
-    normalizedDir = path155.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path155.sep);
-    if (pathParts.includes("..")) {
-      return {
-        success: false,
-        message: "Invalid working_directory: path traversal sequences (..) are not allowed",
-        errors: [
-          "Invalid working_directory: path traversal sequences (..) are not allowed"
-        ]
-      };
-    }
-    const resolvedDir = path155.resolve(normalizedDir);
-    try {
-      const realPath = fs113.realpathSync(resolvedDir);
-      const planPath = path155.join(realPath, ".swarm", "plan.json");
-      if (!fs113.existsSync(planPath)) {
-        return {
-          success: false,
-          message: `Invalid working_directory: plan not found in "${realPath}"`,
-          errors: [
-            `Invalid working_directory: plan not found in "${realPath}"`
-          ]
-        };
-      }
-      directory = realPath;
-    } catch {
-      return {
-        success: false,
-        message: `Invalid working_directory: path "${resolvedDir}" does not exist or is inaccessible`,
-        errors: [
-          `Invalid working_directory: path "${resolvedDir}" does not exist or is inaccessible`
-        ]
-      };
-    }
-  } else {
-    if (!fallbackDir) {
-      return {
-        success: false,
-        message: "No working_directory provided and fallbackDir is undefined",
-        errors: ["Cannot resolve directory for task status update"]
-      };
-    }
-    directory = fallbackDir;
+  if (!args2.working_directory && !fallbackDir) {
+    return {
+      success: false,
+      message: "No working_directory provided and fallbackDir is undefined",
+      errors: ["Cannot resolve directory for task status update"]
+    };
+  }
+  const resolveResult = resolveWorkingDirectory(args2.working_directory ?? fallbackDir, fallbackDir);
+  if (!resolveResult.success) {
+    return {
+      success: false,
+      message: resolveResult.message,
+      errors: [resolveResult.message]
+    };
+  }
+  directory = resolveResult.directory;
+  const planPath = path160.join(directory, ".swarm", "plan.json");
+  if (!fs118.existsSync(planPath)) {
+    return {
+      success: false,
+      message: `Invalid working_directory: plan not found in "${directory}"`,
+      errors: [`Invalid working_directory: plan not found in "${directory}"`]
+    };
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs113.realpathSync(path155.resolve(directory));
-    const canonicalRoot = fs113.realpathSync(path155.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path155.sep)) {
+    const canonicalDir = fs118.realpathSync(path160.resolve(directory));
+    const canonicalRoot = fs118.realpathSync(path160.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path160.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -125734,22 +125856,22 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path155.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs113.mkdirSync(path155.dirname(evidencePath), { recursive: true });
-      const fd = fs113.openSync(evidencePath, "wx");
+      const evidencePath = path160.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs118.mkdirSync(path160.dirname(evidencePath), { recursive: true });
+      const fd = fs118.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
-        fs113.writeSync(fd, JSON.stringify({
+        fs118.writeSync(fd, JSON.stringify({
           taskId: args2.task_id,
           required_gates: [],
           gates: {}
         }, null, 2));
         writeOk = true;
       } finally {
-        fs113.closeSync(fd);
+        fs118.closeSync(fd);
         if (!writeOk) {
           try {
-            fs113.unlinkSync(evidencePath);
+            fs118.unlinkSync(evidencePath);
           } catch {}
         }
       }
@@ -125759,8 +125881,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path155.join(directory, ".swarm", "plan.json");
-      const planRaw = fs113.readFileSync(planPath, "utf-8");
+      const planPath2 = path160.join(directory, ".swarm", "plan.json");
+      const planRaw = fs118.readFileSync(planPath2, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
       if (taskPhase?.required_agents && !taskPhase.required_agents.includes("reviewer")) {
@@ -125987,7 +126109,7 @@ init_utils2();
 init_redaction();
 import { createHash as createHash12 } from "node:crypto";
 import { appendFile as appendFile14, mkdir as mkdir25 } from "node:fs/promises";
-import * as path156 from "node:path";
+import * as path161 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
 async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
@@ -125995,7 +126117,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir25(path156.dirname(filePath), { recursive: true });
+    await mkdir25(path161.dirname(filePath), { recursive: true });
     await appendFile14(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -126188,8 +126310,8 @@ init_utils2();
 init_ledger();
 init_manager();
 init_create_tool();
-import fs114 from "node:fs";
-import path157 from "node:path";
+import fs119 from "node:fs";
+import path162 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -126237,7 +126359,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path157.join("evidence", String(phase), filename);
+  const relativePath = path162.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126248,12 +126370,12 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path157.dirname(validatedPath);
+  const evidenceDir = path162.dirname(validatedPath);
   try {
-    await fs114.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path157.join(evidenceDir, `.${filename}.tmp`);
-    await fs114.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs114.promises.rename(tempPath, validatedPath);
+    await fs119.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path162.join(evidenceDir, `.${filename}.tmp`);
+    await fs119.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs119.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
     let snapshotError;
     let qaProfileLocked;
@@ -126346,8 +126468,8 @@ var write_drift_evidence = createSwarmTool({
 // src/tools/write-final-council-evidence.ts
 init_zod();
 init_loader();
-import fs115 from "node:fs";
-import path158 from "node:path";
+import fs120 from "node:fs";
+import path163 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -126435,7 +126557,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path158.join("evidence", filename);
+  const relativePath = path163.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126449,12 +126571,12 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path158.dirname(validatedPath);
+  const evidenceDir = path163.dirname(validatedPath);
   try {
-    await fs115.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path158.join(evidenceDir, `.${filename}.tmp`);
-    await fs115.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs115.promises.rename(tempPath, validatedPath);
+    await fs120.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path163.join(evidenceDir, `.${filename}.tmp`);
+    await fs120.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs120.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase: input.phase,
@@ -126510,8 +126632,8 @@ var write_final_council_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs116 from "node:fs";
-import path159 from "node:path";
+import fs121 from "node:fs";
+import path164 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -126559,7 +126681,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path159.join("evidence", String(phase), filename);
+  const relativePath = path164.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126570,12 +126692,12 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path159.dirname(validatedPath);
+  const evidenceDir = path164.dirname(validatedPath);
   try {
-    await fs116.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path159.join(evidenceDir, `.${filename}.tmp`);
-    await fs116.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs116.promises.rename(tempPath, validatedPath);
+    await fs121.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path164.join(evidenceDir, `.${filename}.tmp`);
+    await fs121.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs121.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -126621,8 +126743,8 @@ var write_hallucination_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs117 from "node:fs";
-import path160 from "node:path";
+import fs122 from "node:fs";
+import path165 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -126696,7 +126818,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path160.join("evidence", String(phase), filename);
+  const relativePath = path165.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126707,12 +126829,12 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path160.dirname(validatedPath);
+  const evidenceDir = path165.dirname(validatedPath);
   try {
-    await fs117.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path160.join(evidenceDir, `.${filename}.tmp`);
-    await fs117.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs117.promises.rename(tempPath, validatedPath);
+    await fs122.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path165.join(evidenceDir, `.${filename}.tmp`);
+    await fs122.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs122.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -127060,7 +127182,7 @@ async function initializeOpenCodeSwarm(ctx) {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path162.resolve(ctx.directory, ".swarm");
+    const swarmDir = path167.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -127657,7 +127779,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path162.basename(path162.dirname(s.skillPath));
+                    desc = path167.basename(path167.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -127667,7 +127789,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path162.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path167.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {