opencode-swarm 7.0.0 → 7.0.2

package/dist/index.js

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.0.0",
+    version: "7.0.2",
     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",
@@ -245,8 +245,9 @@ var init_constants = __esm(() => {
     "critic_hallucination_verifier",
     "curator_init",
     "curator_phase",
-    "council_member",
-    "council_moderator",
+    "council_generalist",
+    "council_skeptic",
+    "council_domain_expert",
     ...QA_AGENTS,
     ...PIPELINE_AGENTS
   ];
@@ -319,7 +320,8 @@ var init_constants = __esm(() => {
       "repo_map",
       "get_qa_gate_profile",
       "set_qa_gates",
-      "convene_general_council"
+      "convene_general_council",
+      "web_search"
     ],
     explorer: [
       "complexity_hotspots",
@@ -470,8 +472,9 @@ var init_constants = __esm(() => {
     ],
     curator_init: ["knowledge_recall"],
     curator_phase: ["knowledge_recall"],
-    council_member: ["web_search"],
-    council_moderator: []
+    council_generalist: [],
+    council_skeptic: [],
+    council_domain_expert: []
   };
   WRITE_TOOL_NAMES = [
     "write",
@@ -533,8 +536,8 @@ var init_constants = __esm(() => {
     gitingest: "fetch a GitHub repository full content via gitingest.com",
     retrieve_summary: "retrieve the full content of a stored tool output summary",
     search: "Workspace-scoped ripgrep-style text search with structured JSON output. Supports literal and regex modes, glob filtering, and result limits. NOTE: This is text search, not structural AST search — use symbols and imports tools for structural queries.",
-    web_search: "External web search (Tavily or Brave) for General Council member agents. Returns titled results with snippets and URLs. Restricted to council_member agents via AGENT_TOOL_MAP. Config-gated on council.general.enabled; requires a search API key.",
-    convene_general_council: "Synthesize responses from a multi-model General Council. Accepts parallel member responses (Round 1, optionally Round 2), detects disagreements, and returns consensus points, persisting disagreements, a structured synthesis, and an optional moderator prompt. Architect-only. Config-gated on council.general.enabled.",
+    web_search: "External web search (Tavily or Brave) for architect-driven council research. Returns titled results with snippets and URLs. Config-gated on council.general.enabled; requires a search API key. Used by the architect in MODE: COUNCIL to gather a RESEARCH CONTEXT before dispatching council agents.",
+    convene_general_council: "Synthesize responses from a multi-model General Council. Accepts parallel member responses (Round 1, optionally Round 2), detects disagreements, and returns consensus points, persisting disagreements, and a structured synthesis. Architect-only. Config-gated on council.general.enabled.",
     batch_symbols: "Batched symbol extraction across multiple files. Returns per-file symbol summaries with isolated error handling.",
     suggest_patch: "Reviewer-safe structured patch suggestion tool. Produces context-anchored patch artifacts without file modification. Returns structured diagnostics on context mismatch.",
     lint_spec: "validate .swarm/spec.md format and required fields",
@@ -565,8 +568,6 @@ var init_constants = __esm(() => {
     designer: "opencode/big-pickle",
     curator_init: "opencode/big-pickle",
     curator_phase: "opencode/big-pickle",
-    council_member: "opencode/big-pickle",
-    council_moderator: "opencode/big-pickle",
     default: "opencode/big-pickle"
   };
   DEFAULT_SCORING_CONFIG = {
@@ -16750,7 +16751,7 @@ async function loadPlan(directory) {
                   const rebuilt = await replayFromLedger(directory);
                   if (rebuilt) {
                     await rebuildPlan(directory, rebuilt);
-                    warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at SWARM_PLAN.md if it exists.");
+                    warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/SWARM_PLAN.md if it exists.");
                     return rebuilt;
                   }
                 } catch (replayError) {
@@ -16771,7 +16772,7 @@ async function loadPlan(directory) {
                       return approved.plan;
                     }
                   } catch {}
-                  warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
+                  warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check .swarm/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
                 }
               }
             }
@@ -16817,7 +16818,7 @@ async function loadPlan(directory) {
         }
         return validated;
       } catch (error49) {
-        warn(`[loadPlan] plan.json validation failed: ${error49 instanceof Error ? error49.message : String(error49)}. Attempting rebuild from ledger. If rebuild fails, check SWARM_PLAN.md for a checkpoint.`);
+        warn(`[loadPlan] plan.json validation failed: ${error49 instanceof Error ? error49.message : String(error49)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/SWARM_PLAN.md for a checkpoint.`);
         let rawPlanId = null;
         try {
           const rawParsed = JSON.parse(planJsonContent);
@@ -39463,6 +39464,7 @@ var init_create_tool = __esm(() => {
 // src/tools/checkpoint.ts
 var exports_checkpoint = {};
 __export(exports_checkpoint, {
+  saveCheckpointRecord: () => saveCheckpointRecord,
   checkpoint: () => checkpoint
 });
 import * as child_process from "node:child_process";
@@ -39617,6 +39619,38 @@ function handleSave(label, directory) {
     }, null, 2);
   }
 }
+function saveCheckpointRecord(label, directory) {
+  const labelError = validateLabel(label);
+  if (labelError) {
+    return { success: false, error: labelError };
+  }
+  try {
+    const log2 = readCheckpointLog(directory);
+    if (log2.checkpoints.find((c) => c.label === label)) {
+      return { success: false, error: `duplicate label: "${label}"` };
+    }
+    let sha = "";
+    if (isGitRepo()) {
+      try {
+        sha = getCurrentSha();
+      } catch {
+        sha = "";
+      }
+    }
+    log2.checkpoints.push({
+      label,
+      sha,
+      timestamp: new Date().toISOString()
+    });
+    writeCheckpointLog(log2, directory);
+    return { success: true, sha };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : "unknown error"
+    };
+  }
+}
 function handleRestore(label, directory) {
   try {
     const log2 = readCheckpointLog(directory);
@@ -41933,7 +41967,7 @@ async function handleCloseCommand(directory, args2) {
   try {
     const evidenceDir = path18.join(swarmDir, "evidence");
     const evidenceEntries = await fs12.readdir(evidenceDir);
-    const retroDirs = evidenceEntries.filter((e) => e.startsWith("retro-"));
+    const retroDirs = evidenceEntries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
       const evidencePath = path18.join(evidenceDir, retroDir, "evidence.json");
       try {
@@ -42084,22 +42118,20 @@ async function handleCloseCommand(directory, args2) {
     }
   } catch {}
   let swarmPlanFilesRemoved = 0;
-  const swarmPlanJsonPath = path18.join(directory, "SWARM_PLAN.json");
-  const swarmPlanMdPath = path18.join(directory, "SWARM_PLAN.md");
-  try {
-    await fs12.unlink(swarmPlanJsonPath);
-    swarmPlanFilesRemoved++;
-  } catch (err2) {
-    if (err2?.code !== "ENOENT") {
-      warnings.push(`Failed to remove SWARM_PLAN.json: ${err2 instanceof Error ? err2.message : String(err2)}`);
-    }
-  }
-  try {
-    await fs12.unlink(swarmPlanMdPath);
-    swarmPlanFilesRemoved++;
-  } catch (err2) {
-    if (err2?.code !== "ENOENT") {
-      warnings.push(`Failed to remove SWARM_PLAN.md: ${err2 instanceof Error ? err2.message : String(err2)}`);
+  const candidates = [
+    path18.join(directory, ".swarm", "SWARM_PLAN.json"),
+    path18.join(directory, ".swarm", "SWARM_PLAN.md"),
+    path18.join(directory, "SWARM_PLAN.json"),
+    path18.join(directory, "SWARM_PLAN.md")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await fs12.unlink(candidate);
+      swarmPlanFilesRemoved++;
+    } catch (err2) {
+      if (err2?.code !== "ENOENT") {
+        warnings.push(`Failed to remove ${path18.basename(candidate)}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+      }
     }
   }
   clearAllScopes(directory);
@@ -42174,9 +42206,7 @@ async function handleCloseCommand(directory, args2) {
     "- Reset context.md for next session",
     "- Cleared agent sessions and delegation chains",
     ...configBackupsRemoved > 0 ? [`- Removed ${configBackupsRemoved} stale config backup file(s)`] : [],
-    ...swarmPlanFilesRemoved > 0 ? [
-      `- Removed ${swarmPlanFilesRemoved} root-level SWARM_PLAN checkpoint artifact(s)`
-    ] : [],
+    ...swarmPlanFilesRemoved > 0 ? [`- Removed ${swarmPlanFilesRemoved} SWARM_PLAN checkpoint artifact(s)`] : [],
     ...planExists && !planAlreadyDone ? ["- Set non-completed phases/tasks to closed status"] : [],
     ...curationSucceeded && allLessons.length > 0 ? [`- Committed ${allLessons.length} lesson(s) to knowledge store`] : [],
     "",
@@ -44094,11 +44124,21 @@ function getPluginConfigDir() {
 function getPluginCachePaths() {
   const cacheBase = process.env.XDG_CACHE_HOME || path24.join(os5.homedir(), ".cache");
   const configDir = getPluginConfigDir();
-  return [
+  const paths = [
+    path24.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
     path24.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path24.join(configDir, "node_modules", "opencode-swarm"),
-    path24.join(cacheBase, "opencode", "node_modules", "opencode-swarm")
+    path24.join(configDir, "node_modules", "opencode-swarm")
   ];
+  if (process.platform === "darwin") {
+    const libCaches = path24.join(os5.homedir(), "Library", "Caches");
+    paths.push(path24.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path24.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path24.join(os5.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path24.join(os5.homedir(), "AppData", "Roaming");
+    paths.push(path24.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path24.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path24.join(appData, "opencode", "node_modules", "opencode-swarm"));
+  }
+  return paths;
 }
 var init_cache_paths = () => {};
 
@@ -49224,6 +49264,13 @@ function parseGitRemoteUrl2(remoteUrl) {
       repo: sshMatch[2].replace(/\.git$/, "")
     };
   }
+  const pathMatch = remoteUrl.match(/\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  if (pathMatch) {
+    return {
+      owner: pathMatch[1],
+      repo: pathMatch[2].replace(/\.git$/, "")
+    };
+  }
   return null;
 }
 function handlePrReviewCommand(_directory, args2) {
@@ -53940,13 +53987,14 @@ var init_manager3 = __esm(() => {
 
 // src/commands/reset.ts
 import * as fs25 from "node:fs";
+import * as path38 from "node:path";
 async function handleResetCommand(directory, args2) {
   const hasConfirm = args2.includes("--confirm");
   if (!hasConfirm) {
     return [
       "## Swarm Reset",
       "",
-      "⚠️ This will delete plan.md and context.md from .swarm/",
+      "⚠️ This will delete all swarm state from .swarm/ (plan, context, checkpoints, SWARM_PLAN artifacts)",
       "",
       "**Tip**: Run `/swarm export` first to backup your state.",
       "",
@@ -53954,7 +54002,15 @@ async function handleResetCommand(directory, args2) {
     ].join(`
 `);
   }
-  const filesToReset = ["plan.md", "context.md"];
+  const filesToReset = [
+    "plan.md",
+    "plan.json",
+    "context.md",
+    "SWARM_PLAN.md",
+    "SWARM_PLAN.json",
+    "checkpoints.json",
+    "events.jsonl"
+  ];
   const results = [];
   for (const filename of filesToReset) {
     try {
@@ -53969,6 +54025,15 @@ async function handleResetCommand(directory, args2) {
       results.push(`- ❌ Failed to delete ${filename}`);
     }
   }
+  for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
+    try {
+      const rootPath = path38.join(directory, filename);
+      if (fs25.existsSync(rootPath)) {
+        fs25.unlinkSync(rootPath);
+        results.push(`- ✅ Deleted ${filename} (root)`);
+      }
+    } catch {}
+  }
   try {
     resetAutomationManager();
     results.push("- ✅ Stopped background automation (in-memory queues cleared)");
@@ -54002,7 +54067,7 @@ var init_reset = __esm(() => {
 
 // src/commands/reset-session.ts
 import * as fs26 from "node:fs";
-import * as path38 from "node:path";
+import * as path39 from "node:path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -54017,13 +54082,13 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("❌ Failed to delete state.json");
   }
   try {
-    const sessionDir = path38.dirname(validateSwarmPath(directory, "session/state.json"));
+    const sessionDir = path39.dirname(validateSwarmPath(directory, "session/state.json"));
     if (fs26.existsSync(sessionDir)) {
       const files = fs26.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path38.join(sessionDir, file3);
+        const filePath = path39.join(sessionDir, file3);
         if (fs26.lstatSync(filePath).isFile()) {
           fs26.unlinkSync(filePath);
           deletedCount++;
@@ -54056,7 +54121,7 @@ var init_reset_session = __esm(() => {
 
 // src/summaries/manager.ts
 import { mkdirSync as mkdirSync13, readdirSync as readdirSync10, renameSync as renameSync10, rmSync as rmSync4, statSync as statSync10 } from "node:fs";
-import * as path39 from "node:path";
+import * as path40 from "node:path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -54090,9 +54155,9 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   if (serializedSize > maxStoredBytes) {
     throw new Error(`Summary entry size (${serializedSize} bytes) exceeds maximum (${maxStoredBytes} bytes)`);
   }
-  const relativePath = path39.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path40.join("summaries", `${sanitizedId}.json`);
   const summaryPath = validateSwarmPath(directory, relativePath);
-  const summaryDir = path39.dirname(summaryPath);
+  const summaryDir = path40.dirname(summaryPath);
   const entry = {
     id: sanitizedId,
     summaryText,
@@ -54102,7 +54167,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   };
   const entryJson = JSON.stringify(entry);
   mkdirSync13(summaryDir, { recursive: true });
-  const tempPath = path39.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
+  const tempPath = path40.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await Bun.write(tempPath, entryJson);
     renameSync10(tempPath, summaryPath);
@@ -54115,7 +54180,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path39.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path40.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -54177,7 +54242,7 @@ var init_retrieve = __esm(() => {
 
 // src/commands/rollback.ts
 import * as fs27 from "node:fs";
-import * as path40 from "node:path";
+import * as path41 from "node:path";
 async function handleRollbackCommand(directory, args2) {
   const phaseArg = args2[0];
   if (!phaseArg) {
@@ -54242,8 +54307,8 @@ async function handleRollbackCommand(directory, args2) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path40.join(checkpointDir, file3);
-    const dest = path40.join(swarmDir, file3);
+    const src = path41.join(checkpointDir, file3);
+    const dest = path41.join(swarmDir, file3);
     try {
       fs27.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
@@ -54262,12 +54327,12 @@ async function handleRollbackCommand(directory, args2) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path40.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path41.join(swarmDir, "plan-ledger.jsonl");
   if (fs27.existsSync(existingLedgerPath)) {
     fs27.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path40.join(swarmDir, "plan.json");
+    const planJsonPath = path41.join(swarmDir, "plan.json");
     if (fs27.existsSync(planJsonPath)) {
       const planRaw = fs27.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -54345,9 +54410,9 @@ async function handleSimulateCommand(directory, args2) {
   const report = reportLines.filter(Boolean).join(`
 `);
   const fs28 = await import("node:fs/promises");
-  const path41 = await import("node:path");
-  const reportPath = path41.join(directory, ".swarm", "simulate-report.md");
-  await fs28.mkdir(path41.dirname(reportPath), { recursive: true });
+  const path42 = await import("node:path");
+  const reportPath = path42.join(directory, ".swarm", "simulate-report.md");
+  await fs28.mkdir(path42.dirname(reportPath), { recursive: true });
   await fs28.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
@@ -54366,7 +54431,7 @@ async function handleSpecifyCommand(_directory, args2) {
 
 // src/services/compaction-service.ts
 import * as fs28 from "node:fs";
-import * as path41 from "node:path";
+import * as path42 from "node:path";
 function makeInitialState() {
   return {
     lastObservationAt: 0,
@@ -54388,7 +54453,7 @@ function getSessionState(sessionId) {
 }
 function appendSnapshot(directory, tier, budgetPct, message) {
   try {
-    const snapshotPath = path41.join(directory, ".swarm", "context-snapshot.md");
+    const snapshotPath = path42.join(directory, ".swarm", "context-snapshot.md");
     const timestamp = new Date().toISOString();
     const entry = `
 ## [${tier.toUpperCase()}] ${timestamp} — ${budgetPct.toFixed(1)}% used
@@ -55060,9 +55125,9 @@ var init_registry = __esm(() => {
     },
     council: {
       handler: (ctx) => handleCouncilCommand(ctx.directory, ctx.args),
-      description: "Enter architect MODE: COUNCIL — multi-model deliberation [question] [--preset <name>] [--spec-review]",
-      args: "<question> [--preset <name>] [--spec-review]",
-      details: "Triggers the architect to convene a configurable General Council: each member independently web-searches, answers, and engages in one structured deliberation round on disagreements; an optional moderator pass synthesizes the final answer. --preset <name> selects a member group from council.general.presets. --spec-review switches to single-pass advisory mode for spec review. Requires council.general.enabled: true and a search API key in opencode-swarm.json."
+      description: "Enter architect MODE: COUNCIL — multi-model deliberation [question] [--spec-review]",
+      args: "<question> [--spec-review]",
+      details: "Triggers the architect to convene a three-agent General Council: " + "Generalist (reviewer model), Skeptic (critic model), and Domain Expert (SME model). " + "The architect first runs 1–3 targeted web searches and passes a compiled RESEARCH CONTEXT " + "to all three agents before dispatching them in parallel. " + "Agents deliberate using the NSED peer-review protocol (Round 1 independent analysis, " + "Round 2 MAINTAIN/CONCEDE/NUANCE for disagreements). " + "The architect synthesizes the final answer directly from convene_general_council output. " + "--spec-review switches to single-pass advisory mode for spec review. " + "Requires council.general.enabled: true and a search API key in opencode-swarm.json."
     },
     "pr-review": {
       handler: async (ctx) => handlePrReviewCommand(ctx.directory, ctx.args),
@@ -55305,7 +55370,7 @@ Present the ten gates with their defaults (DEFAULT_QA_GATES) as a single user-fa
 - council_mode (default: OFF) — multi-member council gate (recommended for high-impact architecture, public APIs, schema/data mutation, security-sensitive code)
 - hallucination_guard (default: OFF) — when enabled, mandatory per-phase API/signature/claim/citation verification via critic_hallucination_verifier at PHASE-WRAP; phase_complete will REJECT phase completion unless .swarm/evidence/{phase}/hallucination-guard.json exists with an APPROVED verdict (recommended for claim-heavy or research-heavy work)
 - mutation_test (default: OFF) — when enabled, runs mutation testing on source files touched this phase via generate_mutants + mutation_test + write_mutation_evidence at PHASE-WRAP; FAIL verdict blocks phase_complete; WARN is non-blocking (recommended for projects with coverage gaps or safety-critical code)
-- council_general_review (default: OFF) — when enabled, MODE: SPECIFY runs convene_general_council on the draft spec before the critic-gate; multiple models each independently search the web, deliberate on disagreements, and a moderator synthesizes a final answer that the architect folds into the spec (recommended for novel architecture, unclear best practices, or high-risk design decisions). Requires council.general.enabled: true and a configured search API key.
+- council_general_review (default: OFF) — when enabled, MODE: SPECIFY runs convene_general_council on the draft spec before the critic-gate; the architect runs a curated web_search pass, dispatches council_generalist / council_skeptic / council_domain_expert in parallel with a shared RESEARCH CONTEXT block, deliberates on disagreements, and synthesizes the result directly into the spec (recommended for novel architecture, unclear best practices, or high-risk design decisions). Requires council.general.enabled: true and a configured search API key.
 - drift_check (default: ON) — when enabled, mandatory per-phase drift verification via critic_drift_verifier at PHASE-WRAP; compares implemented changes against spec.md intent; hard-blocks phase_complete when spec.md exists and drift evidence is missing or REJECTED; advisory-only when no spec.md exists (recommended for all projects with a specification)
 
 One question, one message, defaults pre-stated. Wait for the user's answer.`;
@@ -56140,13 +56205,13 @@ Read the elected QA gates (parse the \`## Pending QA Gate Selection\` section fr
 
 If \`council_general_review\` is true:
 1. Read \`council.general\` config. If \`council.general.enabled\` is not true OR no search API key is configured, surface to the user: "council_general_review gate is enabled but the General Council is not configured. Set council.general.enabled: true and configure a search API key in opencode-swarm.json, or unset council_general_review and re-run." Then stop.
-2. Determine the council members from \`council.general.members\` (or \`council.general.presets[<name>]\` if you were invoked via \`/swarm council --preset <name>\` originally).
-3. Delegate to each council member in PARALLEL — one message per member, then STOP and wait. Pass: the spec text as the question, the member's role/persona, round number 1. Do NOT share other members' perspectives at this stage.
-4. Collect all member JSON responses.
+2. Run the Research Phase: formulate 1–3 targeted \`web_search\` queries grounded in the spec's domain, then compile a RESEARCH CONTEXT block (same format as MODE: COUNCIL step 2). If web_search fails, proceed without a context block.
+3. Dispatch \`{{AGENT_PREFIX}}council_generalist\`, \`{{AGENT_PREFIX}}council_skeptic\`, and \`{{AGENT_PREFIX}}council_domain_expert\` in PARALLEL — one message per agent, then STOP and wait. Pass: the spec text as the question, round number 1, the RESEARCH CONTEXT block, and the instruction "Cite from the RESEARCH CONTEXT for external evidence. Your memberId and role are hardcoded in your system prompt." Do NOT share other agents' perspectives at this stage.
+4. Collect all three JSON responses.
 5. Call \`convene_general_council\` with mode: 'spec_review', the spec as question, and the collected \`round1Responses\`. Omit \`round2Responses\` — spec review is a single-pass advisory, not a full deliberation.
 6. Read \`consensusPoints\` — incorporate unambiguous consensus directly into the spec.
 7. Read \`disagreements\` — for each: (a) accept one position with rationale, (b) mark as \`[NEEDS CLARIFICATION]\` in the spec, or (c) schedule an SME consultation.
-8. If \`council.general.moderator\` is true, the tool returned a \`moderatorPrompt\` field. Delegate this prompt to \`{{AGENT_PREFIX}}council_moderator\`. Use the moderator's output to refine the spec further.
+8. Synthesize the final spec-review answer directly from the \`synthesis\` returned by \`convene_general_council\`. Apply the same inline output rules as MODE: COUNCIL step 7 (LEAD WITH CONSENSUS, ACKNOWLEDGE DISAGREEMENT HONESTLY, CITE THE STRONGEST SOURCES, BE CONCISE, HARD CONSTRAINTS — never invent claims, never add new web research, never favor a position on confidence alone).
 9. Revise \`.swarm/spec.md\` to reflect the council input.
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
@@ -56157,8 +56222,8 @@ SPECIFY-COUNCIL-REVIEW RULES:
     → WRONG when gate is true: the user enabled this gate for a reason. Run it regardless.
   ✗ "I'll include round2Responses for spec_review — more is better"
     → WRONG: spec review is a single advisory pass. Omit \`round2Responses\` for spec_review mode.
-  ✗ "I'll skip the moderator pass to save time"
-    → WRONG when council.general.moderator is true: invoke \`{{AGENT_PREFIX}}council_moderator\` with the moderatorPrompt the tool returns.
+  ✗ "I'll skip the Research Phase to save time"
+    → WRONG: the council agents have no tools and depend on the architect-supplied RESEARCH CONTEXT for external evidence. Skipping the pre-search degrades every downstream agent's grounding.
 <!-- BEHAVIORAL_GUIDANCE_END -->
 
 7. Report a summary to the user (MUST count, SHALL count, scenario count, clarification markers, elected QA gates) and suggest the next step: \`CLARIFY-SPEC\` (if markers exist) or \`PLAN\`.
@@ -56331,36 +56396,54 @@ GREENFIELD EXEMPTION: If the work is purely greenfield (new project, no existing
 
 ### MODE: COUNCIL
 
-Activates when: user invokes \`/swarm council <question>\` (optionally with \`--preset <name>\` or \`--spec-review\`).
+Activates when: user invokes \`/swarm council <question>\` (optionally with \`--spec-review\`).
 
-Purpose: convene a configurable multi-model General Council for an advisory deliberation. Each member independently web-searches and answers; the architect routes any disagreements back for one targeted reconciliation round; an optional moderator pass synthesizes the final user-facing answer.
+Purpose: convene a fixed three-agent multi-model General Council (generalist / skeptic / domain expert) for an advisory deliberation. The architect runs a curated web research pass upfront, dispatches the three agents in parallel with the gathered RESEARCH CONTEXT, routes any disagreements back for one targeted reconciliation round, and synthesizes the final user-facing answer directly.
 
 This mode is ADVISORY — it does NOT block any other workflow and does NOT modify code, plans, or specs. The output is for the user (general mode) or for the spec being drafted in MODE: SPECIFY (spec_review mode, gated by \`council_general_review\`).
 
 #### Pre-flight (always run first)
 1. Read \`council.general\` config. If \`council.general.enabled\` is not true OR no search API key is configured (neither \`council.general.searchApiKey\` nor the corresponding env var \`TAVILY_API_KEY\` / \`BRAVE_SEARCH_API_KEY\`), surface to the user: "General Council is not enabled. Set council.general.enabled: true and configure a search API key in opencode-swarm.json." Then STOP.
 
-#### Round 1 — Parallel Independent Search
-2. Determine council members. Default: \`council.general.members\`. If invoked with \`--preset <name>\`: \`council.general.presets[<name>]\`. If a named preset is missing, surface a clear error and stop.
-3. Delegate to each council member in PARALLEL — one message per member, then STOP and wait for all responses to come back. Pass: the question, the member's role/persona, round number 1. Do NOT share other members' responses at this stage.
-4. Collect all member JSON responses (each member returns a fenced JSON block per the council_member prompt).
+#### Research Phase (always run — before dispatching council agents)
+2. Formulate 1–3 targeted \`web_search\` queries that best capture the information needed to answer the question. Prefer specific, keyword-focused queries over broad ones. Call \`web_search\` for each query. Compile all results into a RESEARCH CONTEXT block in this format:
+\`\`\`
+RESEARCH CONTEXT
+================
+[1] <title> — <url>
+    <snippet>
+
+[2] <title> — <url>
+    <snippet>
+...
+\`\`\`
+If \`web_search\` returns no results or an error (check \`result.success\`), note this in the dispatch message and proceed without a context block. Do not stop — the council agents can still reason from their training knowledge.
+
+#### Round 1 — Parallel Independent Analysis
+3. Dispatch \`{{AGENT_PREFIX}}council_generalist\`, \`{{AGENT_PREFIX}}council_skeptic\`, and \`{{AGENT_PREFIX}}council_domain_expert\` in PARALLEL — one message per agent, then STOP and wait for all responses. Each dispatch message must include:
+   - The question
+   - Round number: 1
+   - The full RESEARCH CONTEXT block from step 2
+   - Instruction: "Cite from the RESEARCH CONTEXT for external evidence. Your memberId and role are hardcoded in your system prompt."
+Do NOT share other agents' responses at this stage.
+4. Collect all three JSON responses. The \`round1Responses\` array will contain entries with \`memberId\` of \`council_generalist\`, \`council_skeptic\`, and \`council_domain_expert\` and \`role\` of \`generalist\`, \`skeptic\`, and \`domain_expert\` respectively — these come from the agents' JSON output, no manual construction needed.
 
 #### Synthesis and Deliberation (when council.general.deliberate is true; default true)
 5. Call \`convene_general_council\` with mode set from the command (\`general\` or \`spec_review\`), \`question\`, and the collected \`round1Responses\` only (omit \`round2Responses\`). Inspect the returned \`disagreementsCount\`.
 6. If \`disagreementsCount > 0\`:
-   a. For each disagreement in the tool's response, identify the disputing members (the members listed in the disagreement's positions).
-   b. Re-delegate ONLY to the disputing members — one message per member — passing: their Round 1 response, the disagreement topic, the opposing position(s), round number 2.
+   a. For each disagreement in the tool's response, identify the disputing agents (the agents listed in the disagreement's positions, identified by memberId: \`council_generalist\`, \`council_skeptic\`, or \`council_domain_expert\`).
+   b. Re-delegate ONLY to the disputing agents — one message per agent — passing: their Round 1 response, the disagreement topic, the opposing position(s), round number 2, and the same RESEARCH CONTEXT block.
    c. Collect the Round 2 responses.
    d. Call \`convene_general_council\` AGAIN with both \`round1Responses\` AND \`round2Responses\` populated.
 
-#### Moderator Pass (when council.general.moderator is true; default true)
-7. The most recent \`convene_general_council\` call returned a \`moderatorPrompt\` field. Delegate this prompt to \`{{AGENT_PREFIX}}council_moderator\`. The moderator agent has no tools and no web access — it synthesizes a final user-facing answer from the council output you give it. Collect the moderator's markdown output.
-
 #### Output
-8. Present the final answer to the user:
-   - If the moderator pass ran: present the moderator's output verbatim, prefaced with the participating models (one line).
-   - If no moderator: present the structural \`synthesis\` markdown from the tool's return.
-   In either case, do NOT present the raw per-member JSON. Do NOT silently pick a winner among persisting disagreements — surface them honestly.
+7. Present the final answer to the user from the \`synthesis\` returned by \`convene_general_council\`. Apply these output rules directly:
+   - LEAD WITH CONSENSUS: open with the strongest consensus position. Confidence-weighted: higher-confidence claims from multiple agents rank first, but evidence quality outranks raw confidence. Never elevate a single confident voice over a well-evidenced contrary majority.
+   - ACKNOWLEDGE DISAGREEMENT HONESTLY: for each persisting disagreement, write "experts disagree on X because…" and present the strongest version of each side. Do NOT pretend disagreements are resolved. Do NOT silently pick a winner.
+   - CITE THE STRONGEST SOURCES: link key claims with [title](url) format from the source list in the synthesis. Pick the most reputable source per claim; do not cite duplicates.
+   - BE CONCISE: a few short paragraphs plus a bulleted summary. Expand only when the question genuinely requires it.
+   - HARD CONSTRAINTS: You MUST NOT invent claims not present in the council's responses. You MUST NOT add new web research. You MUST NOT favor a position based on confidence alone.
+   Preface the answer with one line listing the participating models (reviewer model as generalist, critic model as skeptic, SME model as domain expert). Do NOT present raw per-member JSON.
 
 ### MODE: ISSUE_INGEST
 Activates when: user invokes \`/swarm issue <url>\`; OR architect receives \`[MODE: ISSUE_INGEST issue="<url>"]\` signal.
@@ -57095,60 +57178,28 @@ META.SUMMARY CONVENTION — When reporting task completion, include:
 
 `;
 
-// src/agents/council-member.ts
-function createCouncilMemberAgent(model, customPrompt, customAppendPrompt) {
-  let prompt = COUNCIL_MEMBER_PROMPT;
-  if (customPrompt) {
-    prompt = customPrompt;
-  } else if (customAppendPrompt) {
-    prompt = `${COUNCIL_MEMBER_PROMPT}
-
-${customAppendPrompt}`;
-  }
-  return {
-    name: "council_member",
-    description: "General Council deliberation member. Independently web-searches and answers in Round 1; " + "targeted MAINTAIN/CONCEDE/NUANCE deliberation in Round 2. Tool-restricted to web_search only.",
-    config: {
-      model,
-      temperature: 0.4,
-      prompt,
-      tools: {
-        write: false,
-        edit: false,
-        patch: false
-      }
-    }
-  };
-}
-var COUNCIL_MEMBER_PROMPT = `You are Council Member {{MEMBER_ID}} ({{ROLE}}) on a multi-model General Council.
-
-{{PERSONA_BLOCK}}
-
-You are participating in Round {{ROUND}} of a structured deliberation. Your job is to give your independent, evidence-grounded perspective — not to agree with the group.
-
-================================================================
-ROUND {{ROUND}} PROTOCOL
+// src/agents/council-prompts.ts
+var ROUND_PROTOCOL = `================================================================
+ROUND PROTOCOL
 ================================================================
 
-ROUND 1 — Independent Research and Answer
-- Issue 1–3 targeted web_search calls to gather evidence relevant to the question.
-- Cite EVERY factual claim with a source URL from your search results.
+ROUND 1 — Independent Analysis and Answer
+- Use the RESEARCH CONTEXT block provided by the architect in your dispatch message as your external evidence source. The architect has already gathered the relevant web search results.
+- Cite EVERY factual claim that depends on external evidence with a source from the RESEARCH CONTEXT (use the title and URL exactly as given).
 - State your confidence (0.0–1.0) explicitly. Be honest — overconfident answers hurt the council.
 - Enumerate areas of uncertainty so the architect knows where you're guessing vs. where you're sure.
 - Do NOT coordinate with other members. You will not see their responses until Round 2.
 - Do NOT pad. Be concise. Substance over volume.
 
 ROUND 2 — Targeted Deliberation (ONLY when this round is invoked for you)
-- {{DISAGREEMENT_BLOCK}}
-- Issue at most 1 additional web_search call.
+- The architect will pass you the disagreement topic and the opposing position(s) in the dispatch message.
+- Re-read the RESEARCH CONTEXT for any evidence relevant to the disagreement.
 - Declare your stance explicitly using one of these keywords as the FIRST word of a paragraph:
-    MAINTAIN  — your Round 1 position holds; cite the new evidence supporting it
+    MAINTAIN  — your Round 1 position holds; cite the evidence supporting it
     CONCEDE   — the opposing position is correct; state specifically what you got wrong
     NUANCE    — both positions are partially right; state the boundary condition that distinguishes them
 - Never CONCEDE without evidence. Sycophantic capitulation degrades the council below an individual member's baseline (NSED arXiv:2601.16863).
-- Never MAINTAIN without engaging the opposing argument on its merits.
-
-================================================================
+- Never MAINTAIN without engaging the opposing argument on its merits.`, RESPONSE_FORMAT = `================================================================
 RESPONSE FORMAT (always — both rounds)
 ================================================================
 
@@ -57156,11 +57207,11 @@ Reply with a single fenced JSON block. No prose outside the block.
 
 \`\`\`json
 {
-  "memberId": "{{MEMBER_ID}}",
-  "role": "{{ROLE}}",
-  "round": {{ROUND}},
+  "memberId": "<your hardcoded memberId>",
+  "role": "<your hardcoded role>",
+  "round": 1,
   "response": "Your full answer (Round 1) or stance + reasoning (Round 2). Markdown OK inside the string.",
-  "searchQueries": ["query 1", "query 2"],
+  "searchQueries": [],
   "sources": [
     { "title": "...", "url": "...", "snippet": "...", "query": "..." }
   ],
@@ -57172,111 +57223,69 @@ Reply with a single fenced JSON block. No prose outside the block.
 }
 \`\`\`
 
-For Round 1: leave \`disagreementTopics\` as []. For Round 2: list the specific disagreement topics this response addresses.
-
-================================================================
+Notes:
+- \`searchQueries\` is optional — list queries you would have run if you had web access (the architect uses these for audit), or omit / leave empty if none.
+- \`sources\` MUST come from the RESEARCH CONTEXT only. Copy title/url/snippet/query verbatim. Never invent sources.
+- For Round 1: leave \`disagreementTopics\` as []. For Round 2: list the specific disagreement topics this response addresses.`, HARD_RULES = `================================================================
 HARD RULES
 ================================================================
-- web_search is your ONLY tool. You cannot read or write files, run commands, or delegate.
-- Never invent sources. If a search returns nothing useful, say so in \`areasOfUncertainty\`.
+- You have no tools. Reason from the provided RESEARCH CONTEXT and your training knowledge.
+- Never invent sources. If the RESEARCH CONTEXT does not cover a needed claim, say so in \`areasOfUncertainty\`.
 - Never echo other members' responses verbatim. Paraphrase or quote with attribution.
-- Stay within your role and persona. The architect chose you for a specific perspective.
-`;
+- Stay within your role and persona. The architect chose you for a specific perspective.`, GENERALIST_COUNCIL_PROMPT, SKEPTIC_COUNCIL_PROMPT, DOMAIN_EXPERT_COUNCIL_PROMPT;
+var init_council_prompts = __esm(() => {
+  GENERALIST_COUNCIL_PROMPT = `You are the GENERALIST voice on a multi-model General Council.
 
-// src/agents/council-moderator.ts
-function createCouncilModeratorAgent(model, customPrompt, customAppendPrompt) {
-  let prompt = COUNCIL_MODERATOR_PROMPT;
-  if (customPrompt) {
-    prompt = customPrompt;
-  } else if (customAppendPrompt) {
-    prompt = `${COUNCIL_MODERATOR_PROMPT}
+You are the GENERALIST voice on this council. Your perspective is broad and synthesizing:
+- You reason from first principles and across disciplines.
+- You weigh competing considerations without domain bias.
+- You surface tensions between different valid approaches.
+- You are the integrating voice — you see what the specialists might miss by being too deep in their domain.
+Member ID: "council_generalist" | Role: "generalist"
 
-${customAppendPrompt}`;
-  }
-  return {
-    name: "council_moderator",
-    description: "General Council moderator. Synthesizes a coherent final answer from member " + "responses; no web search (works on already-gathered content).",
-    config: {
-      model,
-      temperature: 0.3,
-      prompt,
-      tools: {
-        write: false,
-        edit: false,
-        patch: false
-      }
-    }
-  };
-}
-var COUNCIL_MODERATOR_PROMPT = `You are the General Council Moderator.
+You are participating in a structured deliberation. Your job is to give your independent, evidence-grounded perspective — not to agree with the group.
 
-You are receiving the structural synthesis from a multi-model council deliberation:
-- Question (and mode: general or spec_review)
-- All member Round 1 responses with sources
-- Detected disagreements
-- Round 2 deliberation responses (if any)
-- Confidence-weighted consensus claims
-- Persisting disagreements after deliberation
+${ROUND_PROTOCOL}
 
-Your job: produce a coherent, well-structured final answer for the user.
+${RESPONSE_FORMAT}
 
-================================================================
-RULES
-================================================================
-
-1. LEAD WITH CONSENSUS — open with the strongest consensus position. Use the
-   confidence-weighted ordering (Quadratic Voting): higher-confidence claims
-   from multiple members rank higher, but evidence quality outranks raw
-   confidence. Never elevate a single confident voice over a well-evidenced
-   contrary majority.
-
-2. ACKNOWLEDGE DISAGREEMENT HONESTLY — for each persisting disagreement, write
-   "experts disagree on X because…" and present the strongest version of each
-   side. Do NOT pretend disagreements are resolved when they are not. Do NOT
-   silently pick a winner.
-
-3. CITE THE STRONGEST SOURCES — link key claims with [title](url) format from
-   the deduplicated source list. Pick the most reputable source for each claim;
-   do not cite duplicates.
-
-4. BE CONCISE — the user wants an answer, not a committee report. Default
-   length: a few short paragraphs plus a bulleted summary. Expand only when
-   the question genuinely requires it.
-
-================================================================
-HARD CONSTRAINTS
-================================================================
-
-- You MUST NOT invent claims that are not present in the council's responses.
-- You MUST NOT add new web research. If something was missed, say so.
-- You MUST NOT favor a position based on member confidence alone — evidence
-  quality is the tie-breaker.
-- You have NO tools. You write the final synthesis from the input given.
+${HARD_RULES}
+`;
+  SKEPTIC_COUNCIL_PROMPT = `You are the SKEPTIC voice on a multi-model General Council.
 
-================================================================
-OUTPUT FORMAT
-================================================================
+You are the SKEPTIC voice on this council. Your job is rigorous stress-testing:
+- You challenge assumptions the other members take for granted.
+- You look for weak points, edge cases, and unstated dependencies.
+- You are NOT contrarian for its own sake — your pushback must be evidence-grounded.
+- You make the council's final answer more robust by finding what could go wrong before the user does.
+Member ID: "council_skeptic" | Role: "skeptic"
 
-Plain markdown. No code fences. No JSON. Suggested structure:
+You are participating in a structured deliberation. Your job is to give your independent, evidence-grounded perspective — not to agree with the group.
 
-# Answer
+${ROUND_PROTOCOL}
 
-<lead consensus position with citation(s)>
+${RESPONSE_FORMAT}
 
-<remaining consensus / context paragraphs as needed>
+${HARD_RULES}
+`;
+  DOMAIN_EXPERT_COUNCIL_PROMPT = `You are the DOMAIN EXPERT voice on a multi-model General Council.
 
-## Where Experts Disagree
+You are the DOMAIN EXPERT voice on this council. Your perspective is technically precise:
+- You go deep where others stay broad.
+- You cite specific mechanisms, constraints, and implementation-level detail.
+- You surface edge cases and gotchas that only emerge at depth.
+- Your answers are concrete — no hand-waving, no vague recommendations.
+Member ID: "council_domain_expert" | Role: "domain_expert"
 
-- <topic 1>: <position A> vs <position B>, with sources for each
-- <topic 2>: ...
+You are participating in a structured deliberation. Your job is to give your independent, evidence-grounded perspective — not to agree with the group.
 
-## Sources
+${ROUND_PROTOCOL}
 
-- [title](url)
-- ...
+${RESPONSE_FORMAT}
 
-(Omit any section that is empty.)
+${HARD_RULES}
 `;
+});
 
 // src/agents/critic.ts
 function parseSoundingBoardResponse(raw) {
@@ -58769,7 +58778,7 @@ COVERAGE REPORTING:
 
 // src/agents/index.ts
 import { mkdir as mkdir6, writeFile as writeFile6 } from "node:fs/promises";
-import * as path42 from "node:path";
+import * as path43 from "node:path";
 function stripSwarmPrefix(agentName, swarmPrefix) {
   if (!swarmPrefix || !agentName)
     return agentName;
@@ -58951,18 +58960,25 @@ If you call @coder instead of @${swarmId}_coder, the call will FAIL or go to the
     testEngineer.name = prefixName("test_engineer");
     agents.push(applyOverrides(testEngineer, swarmAgents, swarmPrefix, quiet));
   }
-  if (pluginConfig?.council?.general?.enabled === true && !isAgentDisabled("council_member", swarmAgents, swarmPrefix)) {
-    const councilMemberPrompts = getPrompts("council_member");
-    const councilMember = createCouncilMemberAgent(getModel("council_member"), councilMemberPrompts.prompt, councilMemberPrompts.appendPrompt);
-    councilMember.name = prefixName("council_member");
-    agents.push(applyOverrides(councilMember, swarmAgents, swarmPrefix, quiet));
-  }
-  if (pluginConfig?.council?.general?.enabled === true && pluginConfig?.council?.general?.moderator === true && !isAgentDisabled("council_moderator", swarmAgents, swarmPrefix)) {
-    const moderatorPrompts = getPrompts("council_moderator");
-    const moderatorModel = pluginConfig?.council?.general?.moderatorModel ?? getModel("council_moderator");
-    const councilModerator = createCouncilModeratorAgent(moderatorModel, moderatorPrompts.prompt, moderatorPrompts.appendPrompt);
-    councilModerator.name = prefixName("council_moderator");
-    agents.push(applyOverrides(councilModerator, swarmAgents, swarmPrefix, quiet));
+  if (pluginConfig?.council?.general?.enabled === true) {
+    if (!isAgentDisabled("reviewer", swarmAgents, swarmPrefix)) {
+      const councilGeneralist = createReviewerAgent(getModel("reviewer"), GENERALIST_COUNCIL_PROMPT);
+      councilGeneralist.name = prefixName("council_generalist");
+      agents.push(applyOverrides(councilGeneralist, swarmAgents, swarmPrefix, quiet));
+    }
+    if (!isAgentDisabled("critic", swarmAgents, swarmPrefix)) {
+      const councilSkeptic = createCriticAgent(getModel("critic"), SKEPTIC_COUNCIL_PROMPT);
+      councilSkeptic.name = prefixName("council_skeptic");
+      agents.push(applyOverrides(councilSkeptic, swarmAgents, swarmPrefix, quiet));
+    }
+    if (!isAgentDisabled("sme", swarmAgents, swarmPrefix)) {
+      const councilDomainExpert = createSMEAgent(getModel("sme"), DOMAIN_EXPERT_COUNCIL_PROMPT);
+      councilDomainExpert.name = prefixName("council_domain_expert");
+      agents.push(applyOverrides(councilDomainExpert, swarmAgents, swarmPrefix, quiet));
+    }
+    if (pluginConfig?.council?.general?.moderatorModel !== undefined) {
+      addDeferredWarning("[opencode-swarm] council.general.moderatorModel is deprecated and ignored. The architect now synthesizes the final answer directly using inline output rules. Remove this field (and council.general.moderator if set) from opencode-swarm.json to silence this warning.");
+    }
   }
   if (!isAgentDisabled("docs", swarmAgents, swarmPrefix)) {
     const docsPrompts = getPrompts("docs");
@@ -59080,14 +59096,14 @@ function getAgentConfigs(config3, directory, sessionId) {
   }));
   if (directory) {
     const sid = sessionId ?? `init-${Date.now()}`;
-    const evidenceDir = path42.join(directory, ".swarm", "evidence");
+    const evidenceDir = path43.join(directory, ".swarm", "evidence");
     const filename = `agent-tools-${sid}.json`;
     const snapshotData = JSON.stringify({
       sessionId: sid,
       generatedAt: new Date().toISOString(),
       agents: agentToolSnapshot
     }, null, 2);
-    mkdir6(evidenceDir, { recursive: true }).then(() => writeFile6(path42.join(evidenceDir, filename), snapshotData)).catch(() => {});
+    mkdir6(evidenceDir, { recursive: true }).then(() => writeFile6(path43.join(evidenceDir, filename), snapshotData)).catch(() => {});
   }
   return result;
 }
@@ -59098,9 +59114,11 @@ var init_agents2 = __esm(() => {
   init_schema();
   init_warning_buffer();
   init_architect();
+  init_council_prompts();
   init_curator_agent();
   init_reviewer();
   init_architect();
+  init_council_prompts();
   init_curator_agent();
   init_reviewer();
   warnedAgents = new Set;
@@ -59113,13 +59131,13 @@ __export(exports_evidence_summary_integration, {
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
 import { existsSync as existsSync24, mkdirSync as mkdirSync14, writeFileSync as writeFileSync6 } from "node:fs";
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 function persistSummary(projectDir, artifact, filename) {
-  const swarmPath = path43.join(projectDir, ".swarm");
+  const swarmPath = path44.join(projectDir, ".swarm");
   if (!existsSync24(swarmPath)) {
     mkdirSync14(swarmPath, { recursive: true });
   }
-  const artifactPath = path43.join(swarmPath, filename);
+  const artifactPath = path44.join(swarmPath, filename);
   const content = JSON.stringify(artifact, null, 2);
   writeFileSync6(artifactPath, content, "utf-8");
   log("[EvidenceSummaryIntegration] Summary persisted", {
@@ -59238,7 +59256,7 @@ __export(exports_status_artifact, {
   AutomationStatusArtifact: () => AutomationStatusArtifact
 });
 import * as fs30 from "node:fs";
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 function createEmptySnapshot(mode, capabilities) {
   return {
     timestamp: Date.now(),
@@ -59297,7 +59315,7 @@ class AutomationStatusArtifact {
     });
   }
   getFilePath() {
-    return path45.join(this.swarmDir, this.filename);
+    return path46.join(this.swarmDir, this.filename);
   }
   load() {
     const filePath = this.getFilePath();
@@ -59710,12 +59728,12 @@ __export(exports_review_receipt, {
 });
 import * as crypto5 from "node:crypto";
 import * as fs34 from "node:fs";
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 function resolveReceiptsDir(directory) {
-  return path46.join(directory, ".swarm", "review-receipts");
+  return path47.join(directory, ".swarm", "review-receipts");
 }
 function resolveReceiptIndexPath(directory) {
-  return path46.join(resolveReceiptsDir(directory), "index.json");
+  return path47.join(resolveReceiptsDir(directory), "index.json");
 }
 function buildReceiptFilename(id, date9) {
   const dateStr = date9.toISOString().slice(0, 10);
@@ -59754,7 +59772,7 @@ async function readReceiptIndex(directory) {
 }
 async function writeReceiptIndex(directory, index) {
   const indexPath = resolveReceiptIndexPath(directory);
-  const dir = path46.dirname(indexPath);
+  const dir = path47.dirname(indexPath);
   await fs34.promises.mkdir(dir, { recursive: true });
   const tmpPath = `${indexPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   await fs34.promises.writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
@@ -59765,7 +59783,7 @@ async function persistReviewReceipt(directory, receipt) {
   await fs34.promises.mkdir(receiptsDir, { recursive: true });
   const now = new Date(receipt.reviewed_at);
   const filename = buildReceiptFilename(receipt.id, now);
-  const receiptPath = path46.join(receiptsDir, filename);
+  const receiptPath = path47.join(receiptsDir, filename);
   const tmpPath = `${receiptPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   await fs34.promises.writeFile(tmpPath, JSON.stringify(receipt, null, 2), "utf-8");
   fs34.renameSync(tmpPath, receiptPath);
@@ -59787,7 +59805,7 @@ async function readReceiptById(directory, receiptId) {
   const entry = index.entries.find((e) => e.id === receiptId);
   if (!entry)
     return null;
-  const receiptPath = path46.join(resolveReceiptsDir(directory), entry.filename);
+  const receiptPath = path47.join(resolveReceiptsDir(directory), entry.filename);
   try {
     const content = await fs34.promises.readFile(receiptPath, "utf-8");
     return JSON.parse(content);
@@ -59800,7 +59818,7 @@ async function readReceiptsByScopeHash(directory, scopeHash) {
   const matching = index.entries.filter((e) => e.scope_hash === scopeHash).sort((a, b) => b.reviewed_at.localeCompare(a.reviewed_at));
   const receipts = [];
   for (const entry of matching) {
-    const receiptPath = path46.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path47.join(resolveReceiptsDir(directory), entry.filename);
     try {
       const content = await fs34.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
@@ -59813,7 +59831,7 @@ async function readAllReceipts(directory) {
   const sorted = [...index.entries].sort((a, b) => b.reviewed_at.localeCompare(a.reviewed_at));
   const receipts = [];
   for (const entry of sorted) {
-    const receiptPath = path46.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path47.join(resolveReceiptsDir(directory), entry.filename);
     try {
       const content = await fs34.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
@@ -61401,11 +61419,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path57) {
+      function locateFile(path58) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path57, scriptDirectory);
+          return Module["locateFile"](path58, scriptDirectory);
         }
-        return scriptDirectory + path57;
+        return scriptDirectory + path58;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -63154,13 +63172,13 @@ __export(exports_runtime, {
   getInitializedLanguages: () => getInitializedLanguages,
   clearParserCache: () => clearParserCache
 });
-import * as path57 from "node:path";
+import * as path58 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function initTreeSitter() {
   if (treeSitterInitialized) {
     return;
   }
-  const thisDir = path57.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path58.dirname(fileURLToPath2(import.meta.url));
   const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/lang");
   if (isSource) {
     await Parser.init();
@@ -63168,7 +63186,7 @@ async function initTreeSitter() {
     const grammarsDir = getGrammarsDirAbsolute();
     await Parser.init({
       locateFile(scriptName) {
-        return path57.join(grammarsDir, scriptName);
+        return path58.join(grammarsDir, scriptName);
       }
     });
   }
@@ -63189,11 +63207,11 @@ function getWasmFileName(languageId) {
   return `tree-sitter-${sanitized}.wasm`;
 }
 function getGrammarsDirAbsolute() {
-  const thisDir = path57.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path58.dirname(fileURLToPath2(import.meta.url));
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/lang");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource ? path57.join(thisDir, "grammars") : isCliBundle ? path57.join(thisDir, "..", "lang", "grammars") : path57.join(thisDir, "lang", "grammars");
+  return isSource ? path58.join(thisDir, "grammars") : isCliBundle ? path58.join(thisDir, "..", "lang", "grammars") : path58.join(thisDir, "lang", "grammars");
 }
 async function loadGrammar(languageId) {
   if (typeof languageId !== "string" || languageId.length > 100) {
@@ -63209,7 +63227,7 @@ async function loadGrammar(languageId) {
   await initTreeSitter();
   const parser = new Parser;
   const wasmFileName = getWasmFileName(normalizedId);
-  const wasmPath = path57.join(getGrammarsDirAbsolute(), wasmFileName);
+  const wasmPath = path58.join(getGrammarsDirAbsolute(), wasmFileName);
   const { existsSync: existsSync30 } = await import("node:fs");
   if (!existsSync30(wasmPath)) {
     throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
@@ -63244,7 +63262,7 @@ async function isGrammarAvailable(languageId) {
   }
   try {
     const wasmFileName = getWasmFileName(normalizedId);
-    const wasmPath = path57.join(getGrammarsDirAbsolute(), wasmFileName);
+    const wasmPath = path58.join(getGrammarsDirAbsolute(), wasmFileName);
     const { statSync: statSync18 } = await import("node:fs");
     statSync18(wasmPath);
     return true;
@@ -63303,13 +63321,13 @@ __export(exports_doc_scan, {
 import * as crypto7 from "node:crypto";
 import * as fs43 from "node:fs";
 import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile8 } from "node:fs/promises";
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 function normalizeSeparators(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename8 = path59.basename(filePath);
+  const basename8 = path60.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
       if (basename8 === pattern) {
@@ -63365,7 +63383,7 @@ function stripMarkdown(text) {
   return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s*[-*•]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "").trim();
 }
 async function scanDocIndex(directory) {
-  const manifestPath = path59.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path60.join(directory, ".swarm", "doc-manifest.json");
   const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
   const extraPatterns = [
     "ARCHITECTURE.md",
@@ -63382,7 +63400,7 @@ async function scanDocIndex(directory) {
       let cacheValid = true;
       for (const file3 of existingManifest.files) {
         try {
-          const fullPath = path59.join(directory, file3.path);
+          const fullPath = path60.join(directory, file3.path);
           const stat3 = fs43.statSync(fullPath);
           if (stat3.mtimeMs > file3.mtime) {
             cacheValid = false;
@@ -63412,7 +63430,7 @@ async function scanDocIndex(directory) {
   }
   const entries = rawEntries.filter((e) => typeof e === "string");
   for (const entry of entries) {
-    const fullPath = path59.join(directory, entry);
+    const fullPath = path60.join(directory, entry);
     let stat3;
     try {
       stat3 = fs43.statSync(fullPath);
@@ -63448,7 +63466,7 @@ async function scanDocIndex(directory) {
     } catch {
       continue;
     }
-    const { title, summary } = extractTitleAndSummary(content, path59.basename(entry));
+    const { title, summary } = extractTitleAndSummary(content, path60.basename(entry));
     const lineCount = content.split(`
 `).length;
     discoveredFiles.push({
@@ -63474,7 +63492,7 @@ async function scanDocIndex(directory) {
     files: discoveredFiles
   };
   try {
-    await mkdir9(path59.dirname(manifestPath), { recursive: true });
+    await mkdir9(path60.dirname(manifestPath), { recursive: true });
     await writeFile8(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
@@ -63513,7 +63531,7 @@ function extractConstraintsFromContent(content) {
   return constraints;
 }
 async function extractDocConstraints(directory, taskFiles, taskDescription) {
-  const manifestPath = path59.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path60.join(directory, ".swarm", "doc-manifest.json");
   let manifest;
   try {
     const content = await readFile8(manifestPath, "utf-8");
@@ -63539,7 +63557,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
     }
     let fullContent;
     try {
-      fullContent = await readFile8(path59.join(directory, docFile.path), "utf-8");
+      fullContent = await readFile8(path60.join(directory, docFile.path), "utf-8");
     } catch {
       skippedCount++;
       continue;
@@ -63562,7 +63580,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
           tier: "swarm",
           lesson: constraint,
           category: "architecture",
-          tags: ["doc-scan", path59.basename(docFile.path)],
+          tags: ["doc-scan", path60.basename(docFile.path)],
           scope: "global",
           confidence: 0.5,
           status: "candidate",
@@ -63635,7 +63653,7 @@ var init_doc_scan = __esm(() => {
         }
       } catch {}
       if (force) {
-        const manifestPath = path59.join(directory, ".swarm", "doc-manifest.json");
+        const manifestPath = path60.join(directory, ".swarm", "doc-manifest.json");
         try {
           fs43.unlinkSync(manifestPath);
         } catch {}
@@ -63826,9 +63844,9 @@ __export(exports_curator_drift, {
   buildDriftInjectionText: () => buildDriftInjectionText
 });
 import * as fs46 from "node:fs";
-import * as path62 from "node:path";
+import * as path63 from "node:path";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path62.join(directory, ".swarm");
+  const swarmDir = path63.join(directory, ".swarm");
   const entries = await fs46.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
@@ -63855,7 +63873,7 @@ async function readPriorDriftReports(directory) {
 async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
-  const swarmDir = path62.dirname(filePath);
+  const swarmDir = path63.dirname(filePath);
   await fs46.promises.mkdir(swarmDir, { recursive: true });
   try {
     await fs46.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
@@ -63991,7 +64009,7 @@ var init_curator_drift = __esm(() => {
 init_package();
 init_agents2();
 import * as fs87 from "node:fs";
-import * as path105 from "node:path";
+import * as path106 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -64002,7 +64020,7 @@ init_manager3();
 init_manager();
 init_utils();
 import * as fs29 from "node:fs";
-import * as path44 from "node:path";
+import * as path45 from "node:path";
 
 class PlanSyncWorker {
   directory;
@@ -64026,10 +64044,10 @@ class PlanSyncWorker {
     this.onSyncComplete = options.onSyncComplete;
   }
   getSwarmDir() {
-    return path44.resolve(this.directory, ".swarm");
+    return path45.resolve(this.directory, ".swarm");
   }
   getPlanJsonPath() {
-    return path44.join(this.getSwarmDir(), "plan.json");
+    return path45.join(this.getSwarmDir(), "plan.json");
   }
   start() {
     if (this.disposed) {
@@ -64248,8 +64266,8 @@ class PlanSyncWorker {
   checkForUnauthorizedWrite() {
     try {
       const swarmDir = this.getSwarmDir();
-      const planJsonPath = path44.join(swarmDir, "plan.json");
-      const markerPath = path44.join(swarmDir, ".plan-write-marker");
+      const planJsonPath = path45.join(swarmDir, "plan.json");
+      const markerPath = path45.join(swarmDir, ".plan-write-marker");
       const planStats = fs29.statSync(planJsonPath);
       const planMtimeMs = Math.floor(planStats.mtimeMs);
       const markerContent = fs29.readFileSync(markerPath, "utf8");
@@ -64486,11 +64504,11 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path46 = nodePath2.join(directory, ".swarm", "context.md");
-    const tempPath = `${path46}.tmp`;
+    const path47 = nodePath2.join(directory, ".swarm", "context.md");
+    const tempPath = `${path47}.tmp`;
     try {
       await Bun.write(tempPath, updated);
-      renameSync11(tempPath, path46);
+      renameSync11(tempPath, path47);
     } catch (writeError) {
       try {
         unlinkSync8(tempPath);
@@ -64541,7 +64559,7 @@ ${content.substring(endIndex + 1)}`;
 init_manager();
 init_utils2();
 import * as fs31 from "node:fs";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 function createCompactionCustomizerHook(config3, directory) {
   const enabled = config3.hooks?.compaction !== false;
   if (!enabled) {
@@ -64586,7 +64604,7 @@ function createCompactionCustomizerHook(config3, directory) {
         }
       }
       try {
-        const summariesDir = join42(directory, ".swarm", "summaries");
+        const summariesDir = join43(directory, ".swarm", "summaries");
         const files = await fs31.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
@@ -65851,7 +65869,7 @@ init_schema();
 init_manager();
 init_curator();
 init_utils2();
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 function createPhaseMonitorHook(directory, preflightManager, curatorRunner, delegateFactory) {
   let lastKnownPhase = null;
   const handler = async (input, _output) => {
@@ -65871,9 +65889,9 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const llmDelegate = delegateFactory?.(sessionId);
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
-            const briefingPath = path47.join(directory, ".swarm", "curator-briefing.md");
+            const briefingPath = path48.join(directory, ".swarm", "curator-briefing.md");
             const { mkdir: mkdir7, writeFile: writeFile7 } = await import("node:fs/promises");
-            await mkdir7(path47.dirname(briefingPath), { recursive: true });
+            await mkdir7(path48.dirname(briefingPath), { recursive: true });
             await writeFile7(briefingPath, initResult.briefing, "utf-8");
             const { buildApprovedReceipt: buildApprovedReceipt2, persistReviewReceipt: persistReviewReceipt2 } = await Promise.resolve().then(() => (init_review_receipt(), exports_review_receipt));
             const initReceipt = buildApprovedReceipt2({
@@ -65998,7 +66016,7 @@ ${originalText}`;
 }
 // src/hooks/repo-graph-builder.ts
 init_constants();
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 
 // src/tools/repo-graph.ts
 init_utils2();
@@ -66007,14 +66025,14 @@ init_path_security();
 import * as fsSync2 from "node:fs";
 import { constants as constants3, existsSync as existsSync28, realpathSync as realpathSync6 } from "node:fs";
 import * as fsPromises3 from "node:fs/promises";
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 
 // src/tools/symbols.ts
 init_zod();
 init_create_tool();
 init_path_security();
 import * as fs35 from "node:fs";
-import * as path48 from "node:path";
+import * as path49 from "node:path";
 var MAX_FILE_SIZE_BYTES2 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks(str) {
@@ -66031,11 +66049,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path48.resolve(workspace, filePath);
+    const resolvedPath = path49.resolve(workspace, filePath);
     const realWorkspace = fs35.realpathSync(workspace);
     const realResolvedPath = fs35.realpathSync(resolvedPath);
-    const relativePath = path48.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path48.isAbsolute(relativePath)) {
+    const relativePath = path49.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path49.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -66047,7 +66065,7 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path48.join(cwd, filePath);
+  const fullPath = path49.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -66199,7 +66217,7 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path48.join(cwd, filePath);
+  const fullPath = path49.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -66282,7 +66300,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path48.extname(file3);
+    const ext = path49.extname(file3);
     if (containsControlChars(file3)) {
       return JSON.stringify({
         file: file3,
@@ -66346,7 +66364,7 @@ var symbols = createSwarmTool({
 var WINDOWS_RENAME_MAX_RETRIES = 3;
 var WINDOWS_RENAME_RETRY_DELAY_MS = 50;
 function normalizeGraphPath(filePath) {
-  return path49.normalize(filePath).replace(/\\/g, "/");
+  return path50.normalize(filePath).replace(/\\/g, "/");
 }
 var REPO_GRAPH_FILENAME = "repo-graph.json";
 var GRAPH_SCHEMA_VERSION = "1.0.0";
@@ -66455,8 +66473,8 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
   }
   try {
     if (specifier.startsWith(".")) {
-      const sourceDir = path49.dirname(sourceFile);
-      let resolved = path49.resolve(sourceDir, specifier);
+      const sourceDir = path50.dirname(sourceFile);
+      let resolved = path50.resolve(sourceDir, specifier);
       let realResolved;
       try {
         realResolved = realpathSync6(resolved);
@@ -66467,7 +66485,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       try {
         realRoot = realpathSync6(workspaceRoot);
       } catch {
-        realRoot = path49.normalize(workspaceRoot);
+        realRoot = path50.normalize(workspaceRoot);
       }
       if (!existsSync28(resolved)) {
         const EXTENSIONS = [
@@ -66499,9 +66517,9 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
           return null;
         }
       }
-      const normalizedResolved = path49.normalize(realResolved);
-      const normalizedRoot = path49.normalize(realRoot);
-      if (!normalizedResolved.startsWith(normalizedRoot + path49.sep) && normalizedResolved !== normalizedRoot) {
+      const normalizedResolved = path50.normalize(realResolved);
+      const normalizedRoot = path50.normalize(realRoot);
+      if (!normalizedResolved.startsWith(normalizedRoot + path50.sep) && normalizedResolved !== normalizedRoot) {
         return null;
       }
       return resolved;
@@ -66514,7 +66532,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
 function createEmptyGraph(workspaceRoot) {
   return {
     schema_version: GRAPH_SCHEMA_VERSION,
-    workspaceRoot: path49.normalize(workspaceRoot),
+    workspaceRoot: path50.normalize(workspaceRoot),
     nodes: {},
     edges: [],
     metadata: {
@@ -66548,10 +66566,10 @@ function addEdge(graph, edge) {
   }
 }
 function getCachedGraph(workspace) {
-  return graphCache.get(path49.normalize(workspace));
+  return graphCache.get(path50.normalize(workspace));
 }
 function setCachedGraph(workspace, graph, mtime) {
-  const normalized = path49.normalize(workspace);
+  const normalized = path50.normalize(workspace);
   graphCache.set(normalized, graph);
   dirtyFlags.set(normalized, false);
   if (mtime !== undefined) {
@@ -66559,10 +66577,10 @@ function setCachedGraph(workspace, graph, mtime) {
   }
 }
 function isDirty(workspace) {
-  return dirtyFlags.get(path49.normalize(workspace)) ?? false;
+  return dirtyFlags.get(path50.normalize(workspace)) ?? false;
 }
 function clearCache(workspace) {
-  const normalized = path49.normalize(workspace);
+  const normalized = path50.normalize(workspace);
   graphCache.delete(normalized);
   dirtyFlags.delete(normalized);
   mtimeCache.delete(normalized);
@@ -66575,7 +66593,7 @@ function getGraphPath(workspace) {
 }
 async function loadGraph(workspace) {
   validateWorkspace(workspace);
-  const normalized = path49.normalize(workspace);
+  const normalized = path50.normalize(workspace);
   const cached3 = getCachedGraph(normalized);
   if (cached3 && !isDirty(normalized)) {
     try {
@@ -66669,28 +66687,28 @@ async function saveGraph(workspace, graph, options) {
   if (!Array.isArray(graph.edges)) {
     throw new Error("Graph must have edges array");
   }
-  const normalizedWorkspace = path49.normalize(workspace);
+  const normalizedWorkspace = path50.normalize(workspace);
   let realWorkspace;
   try {
     realWorkspace = realpathSync6(workspace);
   } catch {
     realWorkspace = normalizedWorkspace;
   }
-  const normalizedGraphRoot = path49.normalize(graph.workspaceRoot);
+  const normalizedGraphRoot = path50.normalize(graph.workspaceRoot);
   let realGraphRoot;
   try {
     realGraphRoot = realpathSync6(graph.workspaceRoot);
   } catch {
     realGraphRoot = normalizedGraphRoot;
   }
-  if (path49.normalize(realWorkspace) !== path49.normalize(realGraphRoot)) {
+  if (path50.normalize(realWorkspace) !== path50.normalize(realGraphRoot)) {
     throw new Error(`Graph workspaceRoot mismatch: graph was built for "${graph.workspaceRoot}" but save was called for "${workspace}"`);
   }
   const normalized = normalizedWorkspace;
   const graphPath = getGraphPath(workspace);
   updateGraphMetadata(graph);
   const tempPath = `${graphPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  await fsPromises3.mkdir(path49.dirname(tempPath), { recursive: true });
+  await fsPromises3.mkdir(path50.dirname(tempPath), { recursive: true });
   let lastError = null;
   try {
     if (options?.createAtomic) {
@@ -66821,7 +66839,7 @@ function findSourceFiles(dir, stats) {
       stats.skippedDirs++;
       continue;
     }
-    const fullPath = path49.join(dir, entry);
+    const fullPath = path50.join(dir, entry);
     let stat3;
     try {
       stat3 = fsSync2.statSync(fullPath);
@@ -66832,7 +66850,7 @@ function findSourceFiles(dir, stats) {
       const subFiles = findSourceFiles(fullPath, stats);
       files.push(...subFiles);
     } else if (stat3.isFile()) {
-      const ext = path49.extname(fullPath).toLowerCase();
+      const ext = path50.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -66841,11 +66859,11 @@ function findSourceFiles(dir, stats) {
   return files;
 }
 function toModuleName(filePath, workspaceRoot) {
-  const relative9 = path49.relative(workspaceRoot, filePath);
-  return relative9.split(path49.sep).join("/");
+  const relative9 = path50.relative(workspaceRoot, filePath);
+  return relative9.split(path50.sep).join("/");
 }
 function getLanguage(filePath) {
-  const ext = path49.extname(filePath).toLowerCase();
+  const ext = path50.extname(filePath).toLowerCase();
   return EXTENSION_TO_LANGUAGE[ext] ?? "unknown";
 }
 function isBinaryContent(content) {
@@ -66858,7 +66876,7 @@ function buildWorkspaceGraph(workspaceRoot, options) {
   validateWorkspace(workspaceRoot);
   const maxFileSize = options?.maxFileSizeBytes ?? 1024 * 1024;
   const maxFiles = options?.maxFiles ?? 1e4;
-  const absoluteRoot = path49.resolve(workspaceRoot);
+  const absoluteRoot = path50.resolve(workspaceRoot);
   if (!existsSync28(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
@@ -66899,16 +66917,16 @@ function buildWorkspaceGraph(workspaceRoot, options) {
       continue;
     }
     stats.filesScanned++;
-    const ext = path49.extname(filePath).toLowerCase();
+    const ext = path50.extname(filePath).toLowerCase();
     let exports = [];
     let parsedImports = [];
     try {
       if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-        const relativePath = path49.relative(absoluteRoot, filePath);
+        const relativePath = path50.relative(absoluteRoot, filePath);
         const symbols2 = extractTSSymbols(relativePath, absoluteRoot);
         exports = symbols2.filter((s) => s.exported).map((s) => s.name);
       } else if (ext === ".py") {
-        const relativePath = path49.relative(absoluteRoot, filePath);
+        const relativePath = path50.relative(absoluteRoot, filePath);
         const symbols2 = extractPythonSymbols(relativePath, absoluteRoot);
         exports = symbols2.filter((s) => s.exported).map((s) => s.name);
       }
@@ -66965,15 +66983,15 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
   if (isBinaryContent(content)) {
     return { node: null, edges: [] };
   }
-  const ext = path49.extname(filePath).toLowerCase();
+  const ext = path50.extname(filePath).toLowerCase();
   let exports = [];
   try {
     if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-      const relativePath = path49.relative(absoluteRoot, filePath);
+      const relativePath = path50.relative(absoluteRoot, filePath);
       const symbols2 = extractTSSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     } else if (ext === ".py") {
-      const relativePath = path49.relative(absoluteRoot, filePath);
+      const relativePath = path50.relative(absoluteRoot, filePath);
       const symbols2 = extractPythonSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     }
@@ -67017,7 +67035,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
     return graph2;
   }
   const graph = existingGraph;
-  const absoluteRoot = path49.resolve(workspaceRoot);
+  const absoluteRoot = path50.resolve(workspaceRoot);
   const maxFileSize = 1024 * 1024;
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
@@ -67130,7 +67148,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       if (!isSupportedSourceFile(filePath)) {
         return;
       }
-      const absoluteFilePath = path50.isAbsolute(filePath) ? filePath : path50.resolve(workspaceRoot, filePath);
+      const absoluteFilePath = path51.isAbsolute(filePath) ? filePath : path51.resolve(workspaceRoot, filePath);
       const normalizedAbsolute = absoluteFilePath.replace(/\\/g, "/");
       const normalizedWorkspace = workspaceRoot.replace(/\\/g, "/");
       if (!normalizedAbsolute.startsWith(`${normalizedWorkspace}/`) && normalizedAbsolute !== normalizedWorkspace) {
@@ -67138,7 +67156,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       }
       try {
         await _updateGraphForFiles(workspaceRoot, [absoluteFilePath]);
-        log(`[repo-graph] Incremental update for ${path50.basename(filePath)}`);
+        log(`[repo-graph] Incremental update for ${path51.basename(filePath)}`);
       } catch (error93) {
         const message = error93 instanceof Error ? error93.message : String(error93);
         error48(`[repo-graph] Incremental update failed: ${message}`);
@@ -67157,14 +67175,14 @@ init_manager2();
 init_detector();
 init_manager();
 import * as fs44 from "node:fs";
-import * as path60 from "node:path";
+import * as path61 from "node:path";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager();
 init_utils();
 import * as fs36 from "node:fs";
-import * as path51 from "node:path";
+import * as path52 from "node:path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
   detectContradictions: true,
@@ -67318,7 +67336,7 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
         currentPhase = legacyPhase;
       }
     }
-    const contextPath = path51.join(directory, ".swarm", "context.md");
+    const contextPath = path52.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
       if (fs36.existsSync(contextPath)) {
@@ -67457,7 +67475,7 @@ init_utils();
 init_constants();
 init_schema();
 import * as fs37 from "node:fs/promises";
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 function safeGet(obj, key) {
   if (!obj || !Object.hasOwn(obj, key))
     return;
@@ -67689,23 +67707,18 @@ async function handleDebuggingSpiral(match, taskId, directory) {
   let eventLogged = false;
   let checkpointCreated = false;
   try {
-    const swarmDir = path52.join(directory, ".swarm");
+    const swarmDir = path53.join(directory, ".swarm");
     await fs37.mkdir(swarmDir, { recursive: true });
-    const eventsPath = path52.join(swarmDir, "events.jsonl");
+    const eventsPath = path53.join(swarmDir, "events.jsonl");
     await fs37.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
 `);
     eventLogged = true;
   } catch {}
   const checkpointLabel = `spiral-${taskId}-${Date.now()}`;
   try {
-    const { checkpoint: checkpoint2 } = await Promise.resolve().then(() => (init_checkpoint(), exports_checkpoint));
-    const result = await checkpoint2.execute({ action: "save", label: checkpointLabel }, { directory });
-    try {
-      const parsed = JSON.parse(result);
-      checkpointCreated = parsed.success === true;
-    } catch {
-      checkpointCreated = false;
-    }
+    const { saveCheckpointRecord: saveCheckpointRecord2 } = await Promise.resolve().then(() => (init_checkpoint(), exports_checkpoint));
+    const result = saveCheckpointRecord2(checkpointLabel, directory);
+    checkpointCreated = result.success === true;
   } catch {
     checkpointCreated = false;
   }
@@ -67831,7 +67844,7 @@ import * as fs41 from "node:fs";
 
 // src/graph/graph-builder.ts
 import * as fs39 from "node:fs";
-import * as path55 from "node:path";
+import * as path56 from "node:path";
 
 // node_modules/yocto-queue/index.js
 class Node {
@@ -67992,7 +68005,7 @@ function validateConcurrency(concurrency) {
 // src/graph/import-extractor.ts
 init_path_security();
 import * as fs38 from "node:fs";
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 var SOURCE_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -68037,14 +68050,14 @@ function getLanguageFromExtension(ext) {
   return null;
 }
 function toRelForwardSlash(absPath, root) {
-  return path53.relative(root, absPath).replace(/\\/g, "/");
+  return path54.relative(root, absPath).replace(/\\/g, "/");
 }
 function tryResolveTSJS(rawModule, sourceFileAbs) {
   if (!rawModule.startsWith(".") && !rawModule.startsWith("/")) {
     return null;
   }
-  const sourceDir = path53.dirname(sourceFileAbs);
-  const baseAbs = path53.resolve(sourceDir, rawModule);
+  const sourceDir = path54.dirname(sourceFileAbs);
+  const baseAbs = path54.resolve(sourceDir, rawModule);
   const probe = (basePath) => {
     for (const ext of RESOLVE_EXTENSION_CANDIDATES) {
       const test = basePath + ext;
@@ -68055,7 +68068,7 @@ function tryResolveTSJS(rawModule, sourceFileAbs) {
       } catch {}
     }
     for (const indexFile of RESOLVE_INDEX_CANDIDATES) {
-      const test = path53.join(basePath, indexFile);
+      const test = path54.join(basePath, indexFile);
       try {
         const stat3 = fs38.statSync(test);
         if (stat3.isFile())
@@ -68085,13 +68098,13 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
   }
   const remainder = rawModule.slice(leadingDots).replace(/\./g, "/");
   const upDirs = "../".repeat(Math.max(0, leadingDots - 1));
-  const sourceDir = path53.dirname(sourceFileAbs);
-  const baseAbs = path53.resolve(sourceDir, upDirs + remainder);
+  const sourceDir = path54.dirname(sourceFileAbs);
+  const baseAbs = path54.resolve(sourceDir, upDirs + remainder);
   const accept = (test) => {
     try {
       const stat3 = fs38.statSync(test);
       if (stat3.isFile()) {
-        const rel = path53.relative(workspaceRoot, test).replace(/\\/g, "/");
+        const rel = path54.relative(workspaceRoot, test).replace(/\\/g, "/");
         if (rel.startsWith(".."))
           return null;
         return test;
@@ -68105,7 +68118,7 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
       return hit;
   }
   for (const indexFile of PY_INDEX_CANDIDATES) {
-    const hit = accept(path53.join(baseAbs, indexFile));
+    const hit = accept(path54.join(baseAbs, indexFile));
     if (hit)
       return hit;
   }
@@ -68476,7 +68489,7 @@ function parseRustUses(content) {
 }
 function extractImports2(opts) {
   const { absoluteFilePath, workspaceRoot } = opts;
-  const ext = path53.extname(absoluteFilePath).toLowerCase();
+  const ext = path54.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -68527,9 +68540,9 @@ function extractImports2(opts) {
 }
 
 // src/graph/symbol-extractor.ts
-import * as path54 from "node:path";
+import * as path55 from "node:path";
 function extractExportedSymbols(relativeFilePath, workspaceRoot) {
-  const ext = path54.extname(relativeFilePath).toLowerCase();
+  const ext = path55.extname(relativeFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -68618,15 +68631,15 @@ function findSourceFiles2(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name))
           continue;
-        stack.push(path55.join(dir, entry.name));
+        stack.push(path56.join(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const ext = path55.extname(entry.name).toLowerCase();
+      const ext = path56.extname(entry.name).toLowerCase();
       if (!SOURCE_EXT_SET.has(ext))
         continue;
-      out2.push(path55.join(dir, entry.name));
+      out2.push(path56.join(dir, entry.name));
     }
   }
   return out2;
@@ -68654,7 +68667,7 @@ async function buildRepoGraph(workspaceRoot, options = {}) {
   };
 }
 async function processFile(absoluteFilePath, workspaceRoot) {
-  const ext = path55.extname(absoluteFilePath).toLowerCase();
+  const ext = path56.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return null;
@@ -68674,7 +68687,7 @@ async function processFile(absoluteFilePath, workspaceRoot) {
   } catch {
     return null;
   }
-  const relPath = path55.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
+  const relPath = path56.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
   const imports = extractImports2({
     absoluteFilePath,
     workspaceRoot,
@@ -68916,10 +68929,10 @@ function formatSummary(opts) {
 // src/graph/graph-store.ts
 import * as crypto6 from "node:crypto";
 import * as fs40 from "node:fs";
-import * as path56 from "node:path";
+import * as path57 from "node:path";
 var SWARM_DIR = ".swarm";
 function getGraphPath2(workspaceRoot) {
-  return path56.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
+  return path57.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
 }
 function loadGraph2(workspaceRoot) {
   const file3 = getGraphPath2(workspaceRoot);
@@ -68941,7 +68954,7 @@ function loadGraph2(workspaceRoot) {
 }
 function saveGraph2(workspaceRoot, graph) {
   const file3 = getGraphPath2(workspaceRoot);
-  const dir = path56.dirname(file3);
+  const dir = path57.dirname(file3);
   try {
     const stat3 = fs40.lstatSync(dir);
     if (stat3.isSymbolicLink()) {
@@ -69047,7 +69060,7 @@ function buildReviewerBlastRadiusBlock(directory, changedFiles) {
 // src/hooks/semantic-diff-injection.ts
 import * as child_process5 from "node:child_process";
 import * as fs42 from "node:fs";
-import * as path58 from "node:path";
+import * as path59 from "node:path";
 
 // src/diff/ast-diff.ts
 init_tree_sitter();
@@ -69794,17 +69807,17 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
     const fileConsumers = {};
     if (graph) {
       for (const f of filesToProcess) {
-        const relativePath = path58.isAbsolute(f) ? path58.relative(directory, f) : f;
+        const relativePath = path59.isAbsolute(f) ? path59.relative(directory, f) : f;
         const normalized = normalizeGraphPath2(relativePath);
         fileConsumers[normalized] = getImporters(graph, normalized).length;
         fileConsumers[f] = fileConsumers[normalized];
       }
     }
     for (const filePath of filesToProcess) {
-      const normalizedPath = path58.normalize(filePath);
-      const resolvedPath = path58.resolve(directory, normalizedPath);
-      const relativeToDir = path58.relative(directory, resolvedPath);
-      if (relativeToDir.startsWith("..") || path58.isAbsolute(relativeToDir)) {
+      const normalizedPath = path59.normalize(filePath);
+      const resolvedPath = path59.resolve(directory, normalizedPath);
+      const relativeToDir = path59.relative(directory, resolvedPath);
+      if (relativeToDir.startsWith("..") || path59.isAbsolute(relativeToDir)) {
         continue;
       }
       try {
@@ -69831,7 +69844,7 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
           stdio: "pipe",
           maxBuffer: 5 * 1024 * 1024
         }) : "";
-        const newContent = fs42.readFileSync(path58.join(directory, filePath), "utf-8");
+        const newContent = fs42.readFileSync(path59.join(directory, filePath), "utf-8");
         const astResult = await computeASTDiff(filePath, oldContent, newContent);
         if (astResult && (astResult.changes.length > 0 || astResult.error !== undefined)) {
           astDiffs.push(astResult);
@@ -70173,7 +70186,7 @@ function createSystemEnhancerHook(config3, directory) {
               await fs44.promises.writeFile(darkMatterPath, darkMatterReport, "utf-8");
               warn(`[system-enhancer] Dark matter scan complete: ${darkMatter.length} co-change patterns found`);
               try {
-                const projectName = path60.basename(path60.resolve(directory));
+                const projectName = path61.basename(path61.resolve(directory));
                 const knowledgeEntries = darkMatterToKnowledgeEntries2(darkMatter, projectName);
                 const knowledgePath = resolveSwarmKnowledgePath(directory);
                 const existingEntries = await readKnowledge(knowledgePath);
@@ -70372,7 +70385,7 @@ ${lines.join(`
             try {
               const taskId_ccp = ccpSession?.currentTaskId;
               if (taskId_ccp && !taskId_ccp.includes("..") && !taskId_ccp.includes("/") && !taskId_ccp.includes("\\") && !taskId_ccp.includes("\x00")) {
-                const evidencePath = path60.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
+                const evidencePath = path61.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
                 if (fs44.existsSync(evidencePath)) {
                   const evidenceContent = fs44.readFileSync(evidencePath, "utf-8");
                   const evidenceData = JSON.parse(evidenceContent);
@@ -71518,7 +71531,7 @@ init_hive_promoter();
 
 // src/hooks/incremental-verify.ts
 import * as fs45 from "node:fs";
-import * as path61 from "node:path";
+import * as path62 from "node:path";
 
 // src/hooks/spawn-helper.ts
 import * as child_process6 from "node:child_process";
@@ -71596,18 +71609,18 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs45.existsSync(path61.join(projectDir, "bun.lockb")))
+  if (fs45.existsSync(path62.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs45.existsSync(path61.join(projectDir, "pnpm-lock.yaml")))
+  if (fs45.existsSync(path62.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs45.existsSync(path61.join(projectDir, "yarn.lock")))
+  if (fs45.existsSync(path62.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs45.existsSync(path61.join(projectDir, "package-lock.json")))
+  if (fs45.existsSync(path62.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path61.join(projectDir, "package.json");
+  const pkgPath = path62.join(projectDir, "package.json");
   if (fs45.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(fs45.readFileSync(pkgPath, "utf8"));
@@ -71624,8 +71637,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs45.existsSync(path61.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs45.existsSync(path61.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs45.existsSync(path62.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs45.existsSync(path62.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -71633,13 +71646,13 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs45.existsSync(path61.join(projectDir, "go.mod"))) {
+  if (fs45.existsSync(path62.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs45.existsSync(path61.join(projectDir, "Cargo.toml"))) {
+  if (fs45.existsSync(path62.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs45.existsSync(path61.join(projectDir, "pyproject.toml")) || fs45.existsSync(path61.join(projectDir, "requirements.txt")) || fs45.existsSync(path61.join(projectDir, "setup.py"))) {
+  if (fs45.existsSync(path62.join(projectDir, "pyproject.toml")) || fs45.existsSync(path62.join(projectDir, "requirements.txt")) || fs45.existsSync(path62.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
@@ -71989,7 +72002,7 @@ init_scope_persistence();
 init_state();
 init_delegation_gate();
 init_normalize_tool_name();
-import * as path63 from "node:path";
+import * as path64 from "node:path";
 var WRITE_TOOLS = new Set(WRITE_TOOL_NAMES);
 function createScopeGuardHook(config3, directory, injectAdvisory) {
   const enabled = config3.enabled ?? true;
@@ -72047,13 +72060,13 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
 }
 function isFileInScope(filePath, scopeEntries, directory) {
   const dir = directory ?? process.cwd();
-  const resolvedFile = path63.resolve(dir, filePath);
+  const resolvedFile = path64.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path63.resolve(dir, scope);
+    const resolvedScope = path64.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path63.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path63.isAbsolute(rel);
+    const rel = path64.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path64.isAbsolute(rel);
   });
 }
 
@@ -72105,7 +72118,7 @@ function createSelfReviewHook(config3, injectAdvisory) {
 
 // src/hooks/slop-detector.ts
 import * as fs47 from "node:fs";
-import * as path64 from "node:path";
+import * as path65 from "node:path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -72155,7 +72168,7 @@ function walkFiles(dir, exts, deadline) {
         break;
       if (entry.isSymbolicLink())
         continue;
-      const full = path64.join(dir, entry.name);
+      const full = path65.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -72170,7 +72183,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs47.existsSync(path64.join(projectDir, "package.json"));
+  const hasPackageJson = fs47.existsSync(path65.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -72378,14 +72391,14 @@ function createSteeringConsumedHook(directory) {
 // src/hooks/trajectory-logger.ts
 init_manager2();
 import * as fs50 from "node:fs/promises";
-import * as path66 from "node:path";
+import * as path67 from "node:path";
 
 // src/prm/trajectory-store.ts
 init_utils2();
 import * as fs49 from "node:fs/promises";
-import * as path65 from "node:path";
+import * as path66 from "node:path";
 function getTrajectoryPath(sessionId, directory) {
-  const relativePath = path65.join("trajectories", `${sessionId}.jsonl`);
+  const relativePath = path66.join("trajectories", `${sessionId}.jsonl`);
   return validateSwarmPath(directory, relativePath);
 }
 var _inMemoryTrajectoryCache = new Map;
@@ -72404,7 +72417,7 @@ async function appendTrajectoryEntry(sessionId, entry, directory, maxLines = 100
       _inMemoryTrajectoryCache.set(sessionId, cached3);
     }
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    await fs49.mkdir(path65.dirname(trajectoryPath), { recursive: true });
+    await fs49.mkdir(path66.dirname(trajectoryPath), { recursive: true });
     const line = `${JSON.stringify(entry)}
 `;
     await fs49.appendFile(trajectoryPath, line, "utf-8");
@@ -72443,7 +72456,7 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
       for (const entry of entries) {
         if (!entry.isFile())
           continue;
-        const filePath = path65.join(dirPath, entry.name);
+        const filePath = path66.join(dirPath, entry.name);
         try {
           const stat4 = await fs49.stat(filePath);
           if (now - stat4.mtimeMs > cutoffMs) {
@@ -72635,10 +72648,10 @@ function createTrajectoryLoggerHook(config3, _directory) {
         elapsed_ms
       };
       const sanitized = sanitizeTaskId2(taskId);
-      const relativePath = path66.join("evidence", sanitized, "trajectory.jsonl");
+      const relativePath = path67.join("evidence", sanitized, "trajectory.jsonl");
       const trajectoryPath = validateSwarmPath(_directory, relativePath);
       try {
-        await fs50.mkdir(path66.dirname(trajectoryPath), { recursive: true });
+        await fs50.mkdir(path67.dirname(trajectoryPath), { recursive: true });
         const line = `${JSON.stringify(entry)}
 `;
         await fs50.appendFile(trajectoryPath, line, "utf-8");
@@ -73189,16 +73202,16 @@ init_telemetry();
 
 // src/prm/replay.ts
 import { promises as fs51 } from "node:fs";
-import path67 from "node:path";
+import path68 from "node:path";
 function isPathSafe2(targetPath, basePath) {
-  const resolvedTarget = path67.resolve(targetPath);
-  const resolvedBase = path67.resolve(basePath);
-  const rel = path67.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path67.isAbsolute(rel);
+  const resolvedTarget = path68.resolve(targetPath);
+  const resolvedBase = path68.resolve(basePath);
+  const rel = path68.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path68.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path67.resolve(targetPath);
-  const parts2 = resolved.split(path67.sep);
+  const resolved = path68.resolve(targetPath);
+  const parts2 = resolved.split(path68.sep);
   for (let i2 = 0;i2 < parts2.length - 1; i2++) {
     if (parts2[i2] === ".swarm" && parts2[i2 + 1] === "replays") {
       return true;
@@ -73211,10 +73224,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path67.join(directory, ".swarm", "replays");
+    const replayDir = path68.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path67.join(replayDir, filename);
+    const filepath = path68.join(replayDir, filename);
     if (!isPathSafe2(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -73587,7 +73600,7 @@ init_telemetry();
 init_dist();
 init_create_tool();
 import * as fs52 from "node:fs";
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 init_path_security();
 var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks2(str) {
@@ -73604,14 +73617,14 @@ function containsWindowsAttacks2(str) {
 }
 function isPathInWorkspace2(filePath, workspace) {
   try {
-    const resolvedPath = path68.resolve(workspace, filePath);
+    const resolvedPath = path69.resolve(workspace, filePath);
     if (!fs52.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs52.realpathSync(workspace);
     const realResolvedPath = fs52.realpathSync(resolvedPath);
-    const relativePath = path68.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path68.isAbsolute(relativePath)) {
+    const relativePath = path69.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path69.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -73620,7 +73633,7 @@ function isPathInWorkspace2(filePath, workspace) {
   }
 }
 function processFile2(file3, cwd, exportedOnly) {
-  const ext = path68.extname(file3);
+  const ext = path69.extname(file3);
   if (containsControlChars(file3)) {
     return {
       file: file3,
@@ -73653,7 +73666,7 @@ function processFile2(file3, cwd, exportedOnly) {
       errorType: "path-outside-workspace"
     };
   }
-  const fullPath = path68.join(cwd, file3);
+  const fullPath = path69.join(cwd, file3);
   if (!fs52.existsSync(fullPath)) {
     return {
       file: file3,
@@ -73945,15 +73958,15 @@ init_task_id();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs53 from "node:fs";
-import * as path69 from "node:path";
+import * as path70 from "node:path";
 var EVIDENCE_DIR = ".swarm/evidence";
 function isValidTaskId3(taskId) {
   return isStrictTaskId(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path69.resolve(workspaceRoot);
-  const swarmPath = path69.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path69.resolve(filePath);
+  const normalizedWorkspace = path70.resolve(workspaceRoot);
+  const swarmPath = path70.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path70.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
@@ -74034,7 +74047,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path69.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path70.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -74131,7 +74144,7 @@ init_state();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs54 from "node:fs";
-import * as path70 from "node:path";
+import * as path71 from "node:path";
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
 }
@@ -74283,10 +74296,10 @@ async function executeCompletionVerify(args2, directory) {
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
       const normalizedPath = filePath.replace(/\\/g, "/");
-      const resolvedPath = path70.resolve(directory, normalizedPath);
-      const projectRoot = path70.resolve(directory);
-      const relative16 = path70.relative(projectRoot, resolvedPath);
-      const withinProject = relative16 === "" || !relative16.startsWith("..") && !path70.isAbsolute(relative16);
+      const resolvedPath = path71.resolve(directory, normalizedPath);
+      const projectRoot = path71.resolve(directory);
+      const relative16 = path71.relative(projectRoot, resolvedPath);
+      const withinProject = relative16 === "" || !relative16.startsWith("..") && !path71.isAbsolute(relative16);
       if (!withinProject) {
         blockedTasks.push({
           task_id: task.id,
@@ -74341,8 +74354,8 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path70.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path70.join(evidenceDir, "completion-verify.json");
+    const evidenceDir = path71.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path71.join(evidenceDir, "completion-verify.json");
     fs54.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
@@ -74419,11 +74432,11 @@ var completion_verify = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_zod();
 import * as fs56 from "node:fs";
-import * as path72 from "node:path";
+import * as path73 from "node:path";
 
 // src/quality/metrics.ts
 import * as fs55 from "node:fs";
-import * as path71 from "node:path";
+import * as path72 from "node:path";
 var MAX_FILE_SIZE_BYTES4 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -74475,7 +74488,7 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
+    const fullPath = path72.isAbsolute(file3) ? file3 : path72.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -74598,7 +74611,7 @@ function countGoExports(content) {
 function getExportCountForFile(filePath) {
   try {
     const content = fs55.readFileSync(filePath, "utf-8");
-    const ext = path71.extname(filePath).toLowerCase();
+    const ext = path72.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -74624,7 +74637,7 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
+    const fullPath = path72.isAbsolute(file3) ? file3 : path72.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -74658,7 +74671,7 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
+    const fullPath = path72.isAbsolute(file3) ? file3 : path72.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -74691,8 +74704,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename10 = path71.basename(filePath);
-  const _ext = path71.extname(filePath).toLowerCase();
+  const basename10 = path72.basename(filePath);
+  const _ext = path72.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -74773,8 +74786,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path72, glob) {
-  const normalizedPath = path72.replace(/\\/g, "/");
+function matchesGlobSegment(path73, glob) {
+  const normalizedPath = path73.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -74805,8 +74818,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path72, glob) {
-  const normalizedPath = path72.replace(/\\/g, "/");
+function globMatches(path73, glob) {
+  const normalizedPath = path73.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -74842,7 +74855,7 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path71.join(workingDir, "src");
+  const srcDir = path72.join(workingDir, "src");
   if (fs55.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
@@ -74850,14 +74863,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path71.join(workingDir, dir);
+    const dirPath = path72.join(workingDir, dir);
     if (fs55.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path71.join(workingDir, "tests");
+  const testsDir = path72.join(workingDir, "tests");
   if (fs55.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
@@ -74865,7 +74878,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path71.join(workingDir, dir);
+    const dirPath = path72.join(workingDir, dir);
     if (fs55.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
@@ -74880,7 +74893,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
   try {
     const entries = fs55.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path71.join(dirPath, entry.name);
+      const fullPath = path72.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -74888,7 +74901,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${dirPath}/`, "");
-        const ext = path71.extname(entry.name).toLowerCase();
+        const ext = path72.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -75141,7 +75154,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path72.extname(file3).toLowerCase();
+    const ext = path73.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -75152,7 +75165,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
     if (!fs56.existsSync(fullPath)) {
-      fullPath = path72.join(cwd, file3);
+      fullPath = path73.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
     if (complexity !== null) {
@@ -75326,7 +75339,7 @@ import {
   readFileSync as readFileSync36,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { join as join66 } from "node:path";
+import { join as join67 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
@@ -75360,9 +75373,9 @@ function writeCouncilEvidence(workingDir, synthesis) {
   if (!VALID_TASK_ID.test(synthesis.taskId)) {
     throw new Error(`writeCouncilEvidence: invalid taskId "${synthesis.taskId}" — must match N.M or N.M.P format`);
   }
-  const dir = join66(workingDir, EVIDENCE_DIR2);
+  const dir = join67(workingDir, EVIDENCE_DIR2);
   mkdirSync18(dir, { recursive: true });
-  const filePath = join66(dir, `${synthesis.taskId}.json`);
+  const filePath = join67(dir, `${synthesis.taskId}.json`);
   const existingRoot = Object.create(null);
   if (existsSync37(filePath)) {
     try {
@@ -75396,7 +75409,7 @@ function writeCouncilEvidence(workingDir, synthesis) {
     updated.required_gates = [];
   writeFileSync11(filePath, JSON.stringify(updated, null, 2));
   try {
-    const councilDir = join66(workingDir, ".swarm", "council");
+    const councilDir = join67(workingDir, ".swarm", "council");
     mkdirSync18(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
@@ -75404,7 +75417,7 @@ function writeCouncilEvidence(workingDir, synthesis) {
       timestamp: synthesis.timestamp,
       vetoedBy: synthesis.vetoedBy
     });
-    appendFileSync6(join66(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
+    appendFileSync6(join67(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
 `);
   } catch (auditError) {
     console.warn(`writeCouncilEvidence: failed to append round-history audit log: ${auditError instanceof Error ? auditError.message : String(auditError)}`);
@@ -75538,20 +75551,20 @@ function buildUnifiedFeedback(taskId, verdict, vetoedBy, requiredFixes, advisory
 
 // src/council/criteria-store.ts
 import { existsSync as existsSync38, mkdirSync as mkdirSync19, readFileSync as readFileSync37, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join67 } from "node:path";
+import { join as join68 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 function writeCriteria(workingDir, taskId, criteria) {
-  const dir = join67(workingDir, COUNCIL_DIR);
+  const dir = join68(workingDir, COUNCIL_DIR);
   mkdirSync19(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
     declaredAt: new Date().toISOString()
   };
-  writeFileSync12(join67(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
+  writeFileSync12(join68(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
 }
 function readCriteria(workingDir, taskId) {
-  const filePath = join67(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
+  const filePath = join68(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
   if (!existsSync38(filePath))
     return null;
   try {
@@ -75704,7 +75717,7 @@ var submit_council_verdicts = createSwarmTool({
 init_zod();
 init_loader();
 import * as fs57 from "node:fs";
-import * as path73 from "node:path";
+import * as path74 from "node:path";
 
 // src/council/general-council-advisory.ts
 var ADVISORY_HEADER = "[general_council] (advisory; not blocking)";
@@ -75719,12 +75732,7 @@ function pushGeneralCouncilAdvisory(session, result) {
 ${body2}`);
 }
 function renderAdvisoryBody(result) {
-  const parts2 = [result.synthesis];
-  if (result.moderatorOutput && result.moderatorOutput.trim().length > 0) {
-    parts2.push("", "### Moderator Output", result.moderatorOutput);
-  }
-  return parts2.join(`
-`).trim();
+  return result.synthesis.trim();
 }
 
 // src/council/disagreement-detector.ts
@@ -76050,23 +76058,8 @@ var ArgsSchema2 = exports_external.object({
   round2Responses: exports_external.array(Round2ResponseSchema).optional(),
   working_directory: exports_external.string().optional()
 });
-function buildModeratorPrompt(question, synthesis) {
-  return [
-    "A multi-model council has deliberated on the following question. Your job is to synthesize",
-    "the council output into a single coherent answer for the user, following the rules in your",
-    "system prompt (lead with consensus, acknowledge persisting disagreement honestly, cite the",
-    "strongest sources, be concise, do not invent claims, do not run new searches).",
-    "",
-    `QUESTION:
-${question}`,
-    "",
-    "COUNCIL OUTPUT:",
-    synthesis
-  ].join(`
-`);
-}
 var convene_general_council = createSwarmTool({
-  description: "Synthesize responses from a multi-model General Council. Accepts parallel member " + "responses (Round 1, optionally Round 2), detects disagreements, and returns " + "consensus points, persisting disagreements, a structured synthesis, and an optional " + "moderator prompt. Architect-only. Config-gated on council.general.enabled.",
+  description: "Synthesize responses from a multi-model General Council. Accepts parallel member " + "responses (Round 1, optionally Round 2), detects disagreements, and returns " + "consensus points, persisting disagreements, and a structured synthesis. " + "Architect-only. Config-gated on council.general.enabled.",
   args: {
     question: exports_external.string().min(1).max(8000).describe("The question put to the council, or the spec text to review."),
     mode: exports_external.enum(["general", "spec_review"]).optional().describe('"general" for /swarm council; "spec_review" for SPECIFY-COUNCIL-REVIEW gate.'),
@@ -76152,10 +76145,10 @@ var convene_general_council = createSwarmTool({
     const round1 = input.round1Responses;
     const round2 = input.round2Responses ?? [];
     const result = synthesizeGeneralCouncil(input.question, input.mode, round1, round2);
-    const evidenceDir = path73.join(workingDir, ".swarm", "council", "general");
+    const evidenceDir = path74.join(workingDir, ".swarm", "council", "general");
     const safeTimestamp = result.timestamp.replace(/[:.]/g, "-");
     const evidenceFile = `${safeTimestamp}-${input.mode}.json`;
-    const evidencePath = path73.join(evidenceDir, evidenceFile);
+    const evidencePath = path74.join(evidenceDir, evidenceFile);
     try {
       await fs57.promises.mkdir(evidenceDir, { recursive: true });
       await fs57.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
@@ -76172,7 +76165,6 @@ var convene_general_council = createSwarmTool({
         }
       }
     } catch {}
-    const moderatorPrompt = generalConfig.moderator === true ? buildModeratorPrompt(input.question, result.synthesis) : undefined;
     const ok = {
       success: true,
       question: input.question,
@@ -76183,7 +76175,6 @@ var convene_general_council = createSwarmTool({
       persistingDisagreements: result.persistingDisagreements,
       allSourcesCount: result.allSources.length,
       synthesis: result.synthesis,
-      ...moderatorPrompt !== undefined && { moderatorPrompt },
       evidencePath
     };
     return JSON.stringify(ok, null, 2);
@@ -76392,7 +76383,7 @@ init_state();
 init_task_id();
 init_create_tool();
 import * as fs58 from "node:fs";
-import * as path74 from "node:path";
+import * as path75 from "node:path";
 function validateTaskIdFormat2(taskId) {
   return validateTaskIdFormat(taskId);
 }
@@ -76466,8 +76457,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path74.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path74.sep);
+    normalizedDir = path75.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path75.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -76477,10 +76468,10 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path74.resolve(normalizedDir);
+    const resolvedDir = path75.resolve(normalizedDir);
     try {
       const realPath = fs58.realpathSync(resolvedDir);
-      const planPath2 = path74.join(realPath, ".swarm", "plan.json");
+      const planPath2 = path75.join(realPath, ".swarm", "plan.json");
       if (!fs58.existsSync(planPath2)) {
         return {
           success: false,
@@ -76504,7 +76495,7 @@ async function executeDeclareScope(args2, fallbackDir) {
     console.warn("[declare-scope] fallbackDir is undefined, falling back to process.cwd()");
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path74.resolve(directory, ".swarm", "plan.json");
+  const planPath = path75.resolve(directory, ".swarm", "plan.json");
   if (!fs58.existsSync(planPath)) {
     return {
       success: false,
@@ -76544,8 +76535,8 @@ async function executeDeclareScope(args2, fallbackDir) {
   const normalizeErrors = [];
   const dir = normalizedDir || fallbackDir || process.cwd();
   const mergedFiles = rawMergedFiles.map((file3) => {
-    if (path74.isAbsolute(file3)) {
-      const relativePath = path74.relative(dir, file3).replace(/\\/g, "/");
+    if (path75.isAbsolute(file3)) {
+      const relativePath = path75.relative(dir, file3).replace(/\\/g, "/");
       if (relativePath.startsWith("..")) {
         normalizeErrors.push(`Path '${file3}' resolves outside the project directory`);
         return file3;
@@ -76606,7 +76597,7 @@ var declare_scope = createSwarmTool({
 init_zod();
 import * as child_process7 from "node:child_process";
 import * as fs59 from "node:fs";
-import * as path75 from "node:path";
+import * as path76 from "node:path";
 init_create_tool();
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
@@ -76635,20 +76626,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path76 of paths) {
-    if (!path76 || path76.length === 0) {
+  for (const path77 of paths) {
+    if (!path77 || path77.length === 0) {
       return "empty path not allowed";
     }
-    if (path76.length > MAX_PATH_LENGTH) {
+    if (path77.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path76)) {
+    if (SHELL_METACHARACTERS2.test(path77)) {
       return "path contains shell metacharacters";
     }
-    if (path76.startsWith("-")) {
+    if (path77.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path76)) {
+    if (CONTROL_CHAR_PATTERN2.test(path77)) {
       return "path contains control characters";
     }
   }
@@ -76754,8 +76745,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path76 = parts2[2];
-          files.push({ path: path76, additions, deletions });
+          const path77 = parts2[2];
+          files.push({ path: path77, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -76795,7 +76786,7 @@ var diff = createSwarmTool({
           } else if (base === "unstaged") {
             const oldRef = `:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
-            newContent = fs59.readFileSync(path75.join(directory, file3.path), "utf-8");
+            newContent = fs59.readFileSync(path76.join(directory, file3.path), "utf-8");
           } else {
             const oldRef = `${base}:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
@@ -76870,7 +76861,7 @@ var diff = createSwarmTool({
 init_zod();
 import * as child_process8 from "node:child_process";
 import * as fs60 from "node:fs";
-import * as path76 from "node:path";
+import * as path77 from "node:path";
 init_create_tool();
 var diff_summary = createSwarmTool({
   description: "Generate a filtered semantic diff summary from AST analysis. Returns SemanticDiffSummary with optional filtering by classification or riskLevel.",
@@ -76918,7 +76909,7 @@ var diff_summary = createSwarmTool({
         }
         try {
           let oldContent;
-          const newContent = fs60.readFileSync(path76.join(workingDir, filePath), "utf-8");
+          const newContent = fs60.readFileSync(path77.join(workingDir, filePath), "utf-8");
           if (fileExistsInHead) {
             oldContent = child_process8.execFileSync("git", ["show", `HEAD:${filePath}`], {
               encoding: "utf-8",
@@ -77147,7 +77138,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs61 from "node:fs";
-import * as path77 from "node:path";
+import * as path78 from "node:path";
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR3 = ".swarm/evidence";
@@ -77174,9 +77165,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path77.resolve(cwd);
-  const swarmPath = path77.join(normalizedCwd, ".swarm");
-  const normalizedPath = path77.resolve(filePath);
+  const normalizedCwd = path78.resolve(cwd);
+  const swarmPath = path78.join(normalizedCwd, ".swarm");
+  const normalizedPath = path78.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -77206,10 +77197,10 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path77.join(evidenceDir, filename);
+    const filePath = path78.join(evidenceDir, filename);
     try {
-      const resolvedPath = path77.resolve(filePath);
-      const evidenceDirResolved = path77.resolve(evidenceDir);
+      const resolvedPath = path78.resolve(filePath);
+      const evidenceDirResolved = path78.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
@@ -77327,7 +77318,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path77.join(cwd, PLAN_FILE);
+    const planPath = path78.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -77359,7 +77350,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path77.join(cwd, EVIDENCE_DIR3);
+    const evidenceDir = path78.join(cwd, EVIDENCE_DIR3);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -77377,7 +77368,7 @@ var evidence_check = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs62 from "node:fs";
-import * as path78 from "node:path";
+import * as path79 from "node:path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -77458,12 +77449,12 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path78.join(targetDir, filename);
-      const base = path78.basename(filepath, path78.extname(filepath));
-      const ext = path78.extname(filepath);
+      let filepath = path79.join(targetDir, filename);
+      const base = path79.basename(filepath, path79.extname(filepath));
+      const ext = path79.extname(filepath);
       let counter = 1;
       while (fs62.existsSync(filepath)) {
-        filepath = path78.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path79.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -77727,7 +77718,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs63 from "node:fs";
-import * as path79 from "node:path";
+import * as path80 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
@@ -77775,7 +77766,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path79.extname(filePath).toLowerCase();
+  const ext = path80.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -77799,15 +77790,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path79.resolve(targetFile);
+    _resolvedTarget = path80.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path79.basename(targetFile, path79.extname(targetFile));
+  const targetBasename = path80.basename(targetFile, path80.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path79.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path79.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path80.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path80.normalize(targetWithoutExt).replace(/\\/g, "/");
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
   for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
     const modulePath = match[1] || match[2] || match[3];
@@ -77830,9 +77821,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path79.dirname(targetFile);
-    const targetExt = path79.extname(targetFile);
-    const targetBasenameNoExt = path79.basename(targetFile, targetExt);
+    const _targetDir = path80.dirname(targetFile);
+    const targetExt = path80.extname(targetFile);
+    const targetBasenameNoExt = path80.basename(targetFile, targetExt);
     const moduleNormalized = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
     const moduleName = modulePath.split(/[/\\]/).pop() || "";
     const moduleNameNoExt = moduleName.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
@@ -77900,10 +77891,10 @@ function findSourceFiles3(dir, files = [], stats = { skippedDirs: [], skippedFil
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES4.has(entry)) {
-      stats.skippedDirs.push(path79.join(dir, entry));
+      stats.skippedDirs.push(path80.join(dir, entry));
       continue;
     }
-    const fullPath = path79.join(dir, entry);
+    const fullPath = path80.join(dir, entry);
     let stat4;
     try {
       stat4 = fs63.statSync(fullPath);
@@ -77917,7 +77908,7 @@ function findSourceFiles3(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat4.isDirectory()) {
       findSourceFiles3(fullPath, files, stats);
     } else if (stat4.isFile()) {
-      const ext = path79.extname(fullPath).toLowerCase();
+      const ext = path80.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -77974,7 +77965,7 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path79.resolve(file3);
+      const targetFile = path80.resolve(file3);
       if (!fs63.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
@@ -77996,7 +77987,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path79.dirname(targetFile);
+      const baseDir = path80.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -78542,7 +78533,7 @@ init_qa_gate_profile();
 init_manager2();
 init_curator();
 import * as fs65 from "node:fs";
-import * as path81 from "node:path";
+import * as path82 from "node:path";
 init_knowledge_curator();
 init_knowledge_reader();
 init_knowledge_store();
@@ -78555,14 +78546,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs64 from "node:fs";
-import * as path80 from "node:path";
+import * as path81 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const jsonPath = path80.join(directory, "SWARM_PLAN.json");
-    const mdPath = path80.join(directory, "SWARM_PLAN.md");
+    const swarmDir = path81.join(directory, ".swarm");
+    fs64.mkdirSync(swarmDir, { recursive: true });
+    const jsonPath = path81.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path81.join(swarmDir, "SWARM_PLAN.md");
     fs64.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs64.writeFileSync(mdPath, md, "utf8");
@@ -78797,7 +78790,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     let driftCheckEnabled = true;
     let driftHasSpecMd = false;
     try {
-      const specMdPath = path81.join(dir, ".swarm", "spec.md");
+      const specMdPath = path82.join(dir, ".swarm", "spec.md");
       driftHasSpecMd = fs65.existsSync(specMdPath);
       const gatePlan = await loadPlan(dir);
       if (gatePlan) {
@@ -78819,7 +78812,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     } else {
       let phaseType;
       try {
-        const planPath = path81.join(dir, ".swarm", "plan.json");
+        const planPath = path82.join(dir, ".swarm", "plan.json");
         if (fs65.existsSync(planPath)) {
           const planRaw = fs65.readFileSync(planPath, "utf-8");
           const plan = JSON.parse(planRaw);
@@ -78832,7 +78825,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         warnings.push(`Phase ${phase} is annotated as 'non-code'. Drift verification was skipped per phase type annotation.`);
       } else {
         try {
-          const driftEvidencePath = path81.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+          const driftEvidencePath = path82.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
           let driftVerdictFound = false;
           let driftVerdictApproved = false;
           try {
@@ -78870,7 +78863,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
               let incompleteTaskCount = 0;
               let planParseable = false;
               try {
-                const planPath = path81.join(dir, ".swarm", "plan.json");
+                const planPath = path82.join(dir, ".swarm", "plan.json");
                 if (fs65.existsSync(planPath)) {
                   const planRaw = fs65.readFileSync(planPath, "utf-8");
                   const plan = JSON.parse(planRaw);
@@ -78937,7 +78930,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.hallucination_guard === true) {
-            const hgPath = path81.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+            const hgPath = path82.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
             let hgVerdictFound = false;
             let hgVerdictApproved = false;
             try {
@@ -79009,7 +79002,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.mutation_test === true) {
-            const mgPath = path81.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+            const mgPath = path82.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
             let mgVerdictFound = false;
             let mgVerdict;
             try {
@@ -79083,7 +79076,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.council_mode === true) {
             councilModeEnabled = true;
-            const pcPath = path81.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+            const pcPath = path82.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
             let pcVerdictFound = false;
             let _pcVerdict;
             let pcQuorumSize;
@@ -79285,7 +79278,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path81.basename(dir);
+      const projectName = path82.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -79654,7 +79647,7 @@ init_discovery();
 init_utils();
 init_create_tool();
 import * as fs66 from "node:fs";
-import * as path82 from "node:path";
+import * as path83 from "node:path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -79682,16 +79675,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs66.existsSync(path82.join(cwd, "package.json"))) {
+  if (fs66.existsSync(path83.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs66.existsSync(path82.join(cwd, "pyproject.toml")) || fs66.existsSync(path82.join(cwd, "requirements.txt"))) {
+  if (fs66.existsSync(path83.join(cwd, "pyproject.toml")) || fs66.existsSync(path83.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs66.existsSync(path82.join(cwd, "Cargo.toml"))) {
+  if (fs66.existsSync(path83.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs66.existsSync(path82.join(cwd, "go.mod"))) {
+  if (fs66.existsSync(path83.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -79700,13 +79693,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs66.existsSync(path82.join(cwd, "Gemfile")) || fs66.existsSync(path82.join(cwd, "Gemfile.lock"))) {
+  if (fs66.existsSync(path83.join(cwd, "Gemfile")) || fs66.existsSync(path83.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs66.existsSync(path82.join(cwd, "pubspec.yaml"))) {
+  if (fs66.existsSync(path83.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs66.existsSync(path82.join(cwd, "composer.lock"))) {
+  if (fs66.existsSync(path83.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -80866,7 +80859,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs67 from "node:fs";
-import * as path83 from "node:path";
+import * as path84 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -80989,7 +80982,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path83.basename(filePath);
+  const filename = path84.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -81006,7 +80999,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path83.basename(filePath);
+    const filename = path84.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -81015,7 +81008,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path83.extname(filePath).toLowerCase();
+  const ext = path84.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -81262,9 +81255,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path83.isAbsolute(filePath) ? filePath : path83.resolve(directory, filePath);
-    const resolvedDirectory = path83.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path83.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path84.isAbsolute(filePath) ? filePath : path84.resolve(directory, filePath);
+    const resolvedDirectory = path84.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path84.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs67.existsSync(fullPath)) {
@@ -81273,7 +81266,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path83.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path84.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -81345,7 +81338,7 @@ var placeholder_scan = createSwarmTool({
 });
 // src/tools/pre-check-batch.ts
 import * as fs70 from "node:fs";
-import * as path86 from "node:path";
+import * as path87 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -81482,7 +81475,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs69 from "node:fs";
-import * as path85 from "node:path";
+import * as path86 from "node:path";
 import { extname as extname18 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -82376,24 +82369,24 @@ init_create_tool();
 init_utils2();
 import * as crypto8 from "node:crypto";
 import * as fs68 from "node:fs";
-import * as path84 from "node:path";
+import * as path85 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 = path84.isAbsolute(file3) ? file3 : path84.resolve(directory, file3);
-  const rel = path84.relative(path84.resolve(directory), resolved);
+  const resolved = path85.isAbsolute(file3) ? file3 : path85.resolve(directory, file3);
+  const rel = path85.relative(path85.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path84.join("evidence", String(phase), "sast-baseline.json");
+  return path85.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path84.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path85.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path84.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path85.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -82514,8 +82507,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs68.mkdirSync(path84.dirname(baselinePath), { recursive: true });
-  fs68.mkdirSync(path84.dirname(tempPath), { recursive: true });
+  fs68.mkdirSync(path85.dirname(baselinePath), { recursive: true });
+  fs68.mkdirSync(path85.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock(lockPath);
   try {
     let existing = null;
@@ -82782,9 +82775,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path85.isAbsolute(filePath) ? filePath : path85.resolve(directory, filePath);
-    const resolvedDirectory = path85.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path85.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path86.isAbsolute(filePath) ? filePath : path86.resolve(directory, filePath);
+    const resolvedDirectory = path86.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path86.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -83095,18 +83088,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path86.win32.resolve(inputPath);
-  } else if (path86.isAbsolute(inputPath)) {
-    resolved = path86.resolve(inputPath);
+    resolved = path87.win32.resolve(inputPath);
+  } else if (path87.isAbsolute(inputPath)) {
+    resolved = path87.resolve(inputPath);
   } else {
-    resolved = path86.resolve(baseDir, inputPath);
+    resolved = path87.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path86.resolve(workspaceDir);
+  const workspaceResolved = path87.resolve(workspaceDir);
   let relative20;
   if (isWinAbs) {
-    relative20 = path86.win32.relative(workspaceResolved, resolved);
+    relative20 = path87.win32.relative(workspaceResolved, resolved);
   } else {
-    relative20 = path86.relative(workspaceResolved, resolved);
+    relative20 = path87.relative(workspaceResolved, resolved);
   }
   if (relative20.startsWith("..")) {
     return "path traversal detected";
@@ -83171,7 +83164,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path86.resolve(file3);
+    const resolvedPath = path87.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -83328,7 +83321,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path86.resolve(file3);
+      const resolvedPath = path87.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -83346,7 +83339,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path86.extname(file3).toLowerCase();
+      const ext = path87.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -83565,7 +83558,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path86.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path87.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -83616,7 +83609,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path86.resolve(directory, file3));
+    changedFiles.push(path87.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -83817,7 +83810,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path86.resolve(typedArgs.directory);
+    const resolvedDirectory = path87.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory2(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -83858,7 +83851,7 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/repo-map.ts
 init_zod();
-import * as path87 from "node:path";
+import * as path88 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -83883,7 +83876,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path87.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path88.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -83906,8 +83899,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path87.isAbsolute(normalized)) {
-    const rel = path87.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path88.isAbsolute(normalized)) {
+    const rel = path88.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -84052,7 +84045,7 @@ var repo_map = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs71 from "node:fs";
-import * as path88 from "node:path";
+import * as path89 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS = ["MUST", "SHOULD", "SHALL"];
@@ -84121,7 +84114,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path88.join(evidenceDir, entry);
+    const entryPath = path89.join(evidenceDir, entry);
     try {
       const stat4 = fs71.statSync(entryPath);
       if (!stat4.isDirectory()) {
@@ -84137,11 +84130,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path88.join(entryPath, "evidence.json");
+    const evidenceFilePath = path89.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path88.resolve(evidenceFilePath);
-      const evidenceDirResolved = path88.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path88.sep)) {
+      const resolvedPath = path89.resolve(evidenceFilePath);
+      const evidenceDirResolved = path89.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path89.sep)) {
         continue;
       }
       const stat4 = fs71.lstatSync(evidenceFilePath);
@@ -84175,7 +84168,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(path88.resolve(cwd, file3));
+                  touchedFiles.add(path89.resolve(cwd, file3));
                 }
               }
             }
@@ -84188,8 +84181,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path88.resolve(filePath);
-    const cwdResolved = path88.resolve(cwd);
+    const resolvedPath = path89.resolve(filePath);
+    const cwdResolved = path89.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -84323,7 +84316,7 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path88.join(cwd, SPEC_FILE);
+    const specPath = path89.join(cwd, SPEC_FILE);
     let specContent;
     try {
       specContent = fs71.readFileSync(specPath, "utf-8");
@@ -84350,7 +84343,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path88.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path89.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -84376,7 +84369,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path88.join(evidenceDir, reportFilename);
+    const reportPath = path89.join(evidenceDir, reportFilename);
     try {
       if (!fs71.existsSync(evidenceDir)) {
         fs71.mkdirSync(evidenceDir, { recursive: true });
@@ -84464,7 +84457,7 @@ init_qa_gate_profile();
 init_file_locks();
 import * as crypto9 from "node:crypto";
 import * as fs72 from "node:fs";
-import * as path89 from "node:path";
+import * as path90 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -84542,8 +84535,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path89.resolve(args2.working_directory);
-    const resolvedRoot = path89.resolve(fallbackDir);
+    const resolvedTarget = path90.resolve(args2.working_directory);
+    const resolvedRoot = path90.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs72.accessSync(resolvedRoot, fs72.constants.F_OK);
@@ -84552,7 +84545,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path89.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path90.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -84568,7 +84561,7 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path89.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path90.join(targetWorkspace, ".swarm", "spec.md");
     try {
       const stat4 = await fs72.promises.stat(specPath);
       specMtime = stat4.mtime.toISOString();
@@ -84584,7 +84577,7 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path89.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path90.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs72.promises.readFile(contextPath, "utf8");
@@ -84734,7 +84727,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path89.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path90.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -84757,7 +84750,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path89.join(dir, ".swarm", "plan.json"),
+        plan_path: path90.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -84810,7 +84803,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs73 from "node:fs";
-import * as path90 from "node:path";
+import * as path91 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -85660,7 +85653,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs73.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path90.join(dir, entry.name);
+        const fullPath = path91.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -85669,7 +85662,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path90.relative(rootDir, fullPath));
+              manifestFiles.push(path91.relative(rootDir, fullPath));
               break;
             }
           }
@@ -85687,11 +85680,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs73.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path90.join(dir, entry.name);
+        const fullPath = path91.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path90.relative(workingDir, fullPath));
+              found.push(path91.relative(workingDir, fullPath));
               break;
             }
           }
@@ -85704,11 +85697,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path90.dirname(file3);
+    let currentDir = path91.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path90.sep) {
-        dirs.add(path90.join(workingDir, currentDir));
-        const parent = path90.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path91.sep) {
+        dirs.add(path91.join(workingDir, currentDir));
+        const parent = path91.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -85792,7 +85785,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path90.isAbsolute(relativeOutputDir) ? relativeOutputDir : path90.join(workingDir, relativeOutputDir);
+    const outputDir = path91.isAbsolute(relativeOutputDir) ? relativeOutputDir : path91.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -85815,7 +85808,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path90.isAbsolute(manifestFile) ? manifestFile : path90.join(workingDir, manifestFile);
+        const fullPath = path91.isAbsolute(manifestFile) ? manifestFile : path91.join(workingDir, manifestFile);
         if (!fs73.existsSync(fullPath)) {
           continue;
         }
@@ -85832,7 +85825,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path90.join(outputDir, filename);
+    const outputPath = path91.join(outputDir, filename);
     fs73.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -85876,7 +85869,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs74 from "node:fs";
-import * as path91 from "node:path";
+import * as path92 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -85908,12 +85901,12 @@ function normalizePath3(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path91.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path91.sep) ? cwd : cwd + path91.sep;
+    const resolvedPath = path92.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path92.sep) ? cwd : cwd + path92.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path91.extname(resolvedPath).toLowerCase();
+    const ext = path92.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -85927,7 +85920,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path91.resolve(cwd, candidate);
+    const candidatePath = path92.resolve(cwd, candidate);
     if (fs74.existsSync(candidatePath)) {
       const stats = fs74.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -85939,7 +85932,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs74.readFileSync(specFile, "utf-8");
-  const ext = path91.extname(specFile).toLowerCase();
+  const ext = path92.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -86015,7 +86008,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path91.join(dir, entry.name);
+      const fullPath = path92.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -86025,7 +86018,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path91.extname(entry.name).toLowerCase();
+        const ext = path92.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -86192,7 +86185,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs75 from "node:fs";
-import * as path92 from "node:path";
+import * as path93 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -86228,11 +86221,11 @@ function containsWindowsAttacks3(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path92.resolve(workspace, filePath);
+    const resolvedPath = path93.resolve(workspace, filePath);
     const realWorkspace = fs75.realpathSync(workspace);
     const realResolvedPath = fs75.realpathSync(resolvedPath);
-    const relativePath = path92.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path92.isAbsolute(relativePath)) {
+    const relativePath = path93.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path93.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -86245,11 +86238,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path92.delimiter)) {
+  for (const dir of searchPath.split(path93.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path92.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path93.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs75.existsSync(candidate))
       return candidate;
   }
@@ -86379,8 +86372,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs75.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path92.join(dir, entry.name);
-      const relativePath = path92.relative(workspace, fullPath);
+      const fullPath = path93.join(dir, entry.name);
+      const relativePath = path93.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -86421,7 +86414,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path92.join(opts.workspace, file3);
+    const fullPath = path93.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -86678,7 +86671,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs76 from "node:fs";
-import * as path93 from "node:path";
+import * as path94 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
@@ -86692,14 +86685,14 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path93.resolve(workspace, filePath);
+    const resolvedPath = path94.resolve(workspace, filePath);
     if (!fs76.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs76.realpathSync(workspace);
     const realResolvedPath = fs76.realpathSync(resolvedPath);
-    const relativePath = path93.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path93.isAbsolute(relativePath)) {
+    const relativePath = path94.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path94.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -86907,7 +86900,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path93.resolve(directory, change.file);
+      const fullPath = path94.resolve(directory, change.file);
       if (!fs76.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -87170,7 +87163,7 @@ var generate_mutants = createSwarmTool({
 init_spec_schema();
 init_create_tool();
 import * as fs77 from "node:fs";
-import * as path94 from "node:path";
+import * as path95 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -87223,7 +87216,7 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path94.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    const specPath = path95.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
     if (!fs77.existsSync(specPath)) {
       const result2 = {
         valid: false,
@@ -87294,12 +87287,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs78 from "node:fs";
-import * as path96 from "node:path";
+import * as path97 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { unlinkSync as unlinkSync13, writeFileSync as writeFileSync19 } from "node:fs";
-import * as path95 from "node:path";
+import * as path96 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -87434,7 +87427,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path95.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path96.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync19(patchFile, patch.patch);
     } catch (writeErr) {
@@ -87828,7 +87821,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path96.resolve(cwd, filePath);
+          const resolvedPath = path97.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs78.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -87848,7 +87841,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs79 from "node:fs";
-import * as path97 from "node:path";
+import * as path98 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -87914,7 +87907,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path97.extname(file3.path).toLowerCase();
+      const ext = path98.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -87927,7 +87920,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path97.isAbsolute(filePath) ? filePath : path97.join(directory, filePath);
+    const fullPath = path98.isAbsolute(filePath) ? filePath : path98.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -87976,7 +87969,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path97.extname(filePath).toLowerCase();
+      const ext = path98.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -88069,7 +88062,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs80 from "node:fs";
-import * as path98 from "node:path";
+import * as path99 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -88135,9 +88128,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path98.resolve(paths);
-    const normalizedCwd = path98.resolve(cwd);
-    const normalizedResolved = path98.resolve(resolvedPath);
+    const resolvedPath = path99.resolve(paths);
+    const normalizedCwd = path99.resolve(cwd);
+    const normalizedResolved = path99.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -88153,7 +88146,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path98.extname(filePath).toLowerCase();
+  const ext = path99.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles4(dir, files = []) {
@@ -88168,7 +88161,7 @@ function findSourceFiles4(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path98.join(dir, entry);
+    const fullPath = path99.join(dir, entry);
     let stat4;
     try {
       stat4 = fs80.statSync(fullPath);
@@ -88280,7 +88273,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path98.extname(scanPath)}`,
+          error: `unsupported file extension: ${path99.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -88329,14 +88322,14 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs82 from "node:fs";
-import * as path100 from "node:path";
+import * as path101 from "node:path";
 
 // src/hooks/diff-scope.ts
 import * as fs81 from "node:fs";
-import * as path99 from "node:path";
+import * as path100 from "node:path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path99.join(directory, ".swarm", "plan.json");
+    const planPath = path100.join(directory, ".swarm", "plan.json");
     if (!fs81.existsSync(planPath))
       return null;
     const raw = fs81.readFileSync(planPath, "utf-8");
@@ -88455,7 +88448,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path100.basename(file3);
+    const fileName = path101.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -88469,7 +88462,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path100.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path101.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs82.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -88539,7 +88532,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     try {
       const resolvedDir2 = workingDirectory;
-      const planPath = path100.join(resolvedDir2, ".swarm", "plan.json");
+      const planPath = path101.join(resolvedDir2, ".swarm", "plan.json");
       const planRaw = fs82.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
@@ -88697,7 +88690,7 @@ function checkCouncilGate(workingDirectory, taskId) {
     return { blocked: false, reason: "" };
   }
   try {
-    const planPath = path100.join(workingDirectory, ".swarm", "plan.json");
+    const planPath = path101.join(workingDirectory, ".swarm", "plan.json");
     const planRaw = fs82.readFileSync(planPath, "utf-8");
     const planObj = JSON.parse(planRaw);
     if (planObj.swarm && planObj.title) {
@@ -88788,8 +88781,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path100.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path100.sep);
+    normalizedDir = path101.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path101.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -88799,10 +88792,10 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path100.resolve(normalizedDir);
+    const resolvedDir = path101.resolve(normalizedDir);
     try {
       const realPath = fs82.realpathSync(resolvedDir);
-      const planPath = path100.join(realPath, ".swarm", "plan.json");
+      const planPath = path101.join(realPath, ".swarm", "plan.json");
       if (!fs82.existsSync(planPath)) {
         return {
           success: false,
@@ -88834,8 +88827,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path100.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs82.mkdirSync(path100.dirname(evidencePath), { recursive: true });
+      const evidencePath = path101.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs82.mkdirSync(path101.dirname(evidencePath), { recursive: true });
       const fd = fs82.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -88859,7 +88852,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     recoverTaskStateFromDelegations(args2.task_id);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path100.join(directory, ".swarm", "plan.json");
+      const planPath = path101.join(directory, ".swarm", "plan.json");
       const planRaw = fs82.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -89100,7 +89093,7 @@ var ArgsSchema4 = exports_external.object({
   working_directory: exports_external.string().optional()
 });
 var web_search = createSwarmTool({
-  description: "External web search for council member agents. Returns titled results with snippets and URLs. " + "Restricted to council_member agents via AGENT_TOOL_MAP. Requires council.general.enabled and a " + "configured search API key (Tavily or Brave). max_results is capped at 10 with default from council.general.maxSourcesPerMember.",
+  description: "External web search for architect-driven council research. Returns titled results with snippets and URLs. " + "Used by the architect in MODE: COUNCIL to gather a RESEARCH CONTEXT before dispatching council agents. " + "Requires council.general.enabled and a configured search API key (Tavily or Brave). max_results is capped at 10 with default from council.general.maxSourcesPerMember.",
   args: {
     query: exports_external.string().min(1).max(500).describe("Search query string (1–500 characters)."),
     max_results: exports_external.number().int().min(1).max(20).optional().describe(`Number of results to request (1–20). Hard-capped at ${MAX_RESULTS_HARD_CAP}. Defaults to council.general.maxSourcesPerMember.`),
@@ -89179,7 +89172,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs83 from "node:fs";
-import path101 from "node:path";
+import path102 from "node:path";
 function derivePlanId5(plan) {
   return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
 }
@@ -89230,7 +89223,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path101.join("evidence", String(phase), filename);
+  const relativePath = path102.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -89241,10 +89234,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path101.dirname(validatedPath);
+  const evidenceDir = path102.dirname(validatedPath);
   try {
     await fs83.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path101.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path102.join(evidenceDir, `.${filename}.tmp`);
     await fs83.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs83.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -89341,7 +89334,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs84 from "node:fs";
-import path102 from "node:path";
+import path103 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -89389,7 +89382,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path102.join("evidence", String(phase), filename);
+  const relativePath = path103.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -89400,10 +89393,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path102.dirname(validatedPath);
+  const evidenceDir = path103.dirname(validatedPath);
   try {
     await fs84.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path102.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path103.join(evidenceDir, `.${filename}.tmp`);
     await fs84.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs84.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -89452,7 +89445,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs85 from "node:fs";
-import path103 from "node:path";
+import path104 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -89526,7 +89519,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path103.join("evidence", String(phase), filename);
+  const relativePath = path104.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -89537,10 +89530,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path103.dirname(validatedPath);
+  const evidenceDir = path104.dirname(validatedPath);
   try {
     await fs85.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path103.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path104.join(evidenceDir, `.${filename}.tmp`);
     await fs85.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs85.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -89597,19 +89590,19 @@ init_utils();
 
 // src/utils/gitignore-warning.ts
 import * as fs86 from "node:fs";
-import * as path104 from "node:path";
+import * as path105 from "node:path";
 var _gitignoreWarningEmitted = false;
 function findGitRoot(startDir) {
   let current = startDir;
   while (true) {
     try {
-      const gitPath = path104.join(current, ".git");
+      const gitPath = path105.join(current, ".git");
       const stat4 = fs86.statSync(gitPath);
       if (stat4.isDirectory()) {
         return current;
       }
     } catch {}
-    const parent = path104.dirname(current);
+    const parent = path105.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -89641,12 +89634,12 @@ function warnIfSwarmNotGitignored(directory, quiet = false) {
     const gitRoot = findGitRoot(directory);
     if (!gitRoot)
       return;
-    const gitignoreContent = readFileSafe(path104.join(gitRoot, ".gitignore"));
+    const gitignoreContent = readFileSafe(path105.join(gitRoot, ".gitignore"));
     if (gitignoreContent !== null && fileCoversSwarm(gitignoreContent)) {
       _gitignoreWarningEmitted = true;
       return;
     }
-    const excludeContent = readFileSafe(path104.join(gitRoot, ".git", "info", "exclude"));
+    const excludeContent = readFileSafe(path105.join(gitRoot, ".git", "info", "exclude"));
     if (excludeContent !== null && fileCoversSwarm(excludeContent)) {
       _gitignoreWarningEmitted = true;
       return;
@@ -89694,8 +89687,8 @@ init_warning_buffer();
 var _heartbeatTimers = new Map;
 function writeSwarmConfigExampleIfNew(projectDirectory) {
   try {
-    const swarmDir = path105.join(projectDirectory, ".swarm");
-    const dest = path105.join(swarmDir, "config.example.json");
+    const swarmDir = path106.join(projectDirectory, ".swarm");
+    const dest = path106.join(swarmDir, "config.example.json");
     if (fs87.existsSync(dest))
       return;
     const example = {
@@ -89899,7 +89892,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 = path105.resolve(ctx.directory, ".swarm");
+    const swarmDir = path106.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -90069,7 +90062,7 @@ async function initializeOpenCodeSwarm(ctx) {
         ...opencodeConfig.command || {},
         swarm: {
           template: "/swarm $ARGUMENTS",
-          description: "Swarm management commands: /swarm [status|plan|agents|history|config|evidence|handoff|archive|diagnose|diagnosis|preflight|sync-plan|benchmark|export|reset|rollback|retrieve|clarify|analyze|specify|brainstorm|qa-gates|dark-matter|knowledge|curate|turbo|full-auto|write-retro|reset-session|simulate|promote|checkpoint|acknowledge-spec-drift|doctor-tools|close]"
+          description: "Swarm management commands: /swarm [status|plan|agents|history|config|evidence|handoff|archive|diagnose|diagnosis|preflight|sync-plan|benchmark|export|reset|rollback|retrieve|clarify|analyze|specify|brainstorm|council|qa-gates|dark-matter|knowledge|curate|turbo|full-auto|write-retro|reset-session|simulate|promote|checkpoint|acknowledge-spec-drift|doctor-tools|close]"
         },
         "swarm-status": {
           template: "/swarm status",
@@ -90155,6 +90148,10 @@ async function initializeOpenCodeSwarm(ctx) {
           template: "/swarm brainstorm $ARGUMENTS",
           description: "Use /swarm brainstorm to enter the architect MODE: BRAINSTORM planning workflow"
         },
+        "swarm-council": {
+          template: "/swarm council $ARGUMENTS",
+          description: "Use /swarm council <question> to convene a multi-model General Council deliberation (generalist / skeptic / domain expert) [--spec-review]"
+        },
         "swarm-qa-gates": {
           template: "/swarm qa-gates $ARGUMENTS",
           description: "Use /swarm qa-gates to view or modify QA gate profile for the current plan"