opencode-swarm 7.46.5 → 7.47.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.46.5",
+    version: "7.47.0",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -350,6 +350,7 @@ var init_constants = __esm(() => {
   ALL_SUBAGENT_NAMES = [
     "sme",
     "docs",
+    "docs_design",
     "designer",
     "critic_sounding_board",
     "critic_drift_verifier",
@@ -740,6 +741,19 @@ var init_constants = __esm(() => {
       "summarize_work",
       "swarm_command"
     ],
+    docs_design: [
+      "detect_domains",
+      "extract_code_blocks",
+      "imports",
+      "retrieve_summary",
+      "search",
+      "symbols",
+      "doc_scan",
+      "doc_extract",
+      "knowledge_recall",
+      "summarize_work",
+      "swarm_command"
+    ],
     designer: [
       "extract_code_blocks",
       "retrieve_summary",
@@ -793,6 +807,7 @@ var init_constants = __esm(() => {
     critic_hallucination_verifier: ["swarm_memory_recall"],
     critic_architecture_supervisor: ["swarm_memory_recall"],
     docs: ["swarm_memory_recall", "swarm_memory_propose"],
+    docs_design: ["swarm_memory_recall", "swarm_memory_propose"],
     designer: ["swarm_memory_recall", "swarm_memory_propose"],
     curator_init: ["swarm_memory_recall"],
     curator_phase: ["swarm_memory_recall"],
@@ -913,6 +928,7 @@ var init_constants = __esm(() => {
     critic_oversight: "opencode/gpt-5-nano",
     critic_architecture_supervisor: "opencode/big-pickle",
     docs: "opencode/big-pickle",
+    docs_design: "opencode/big-pickle",
     designer: "opencode/big-pickle",
     curator_init: "opencode/gpt-5-nano",
     curator_phase: "opencode/gpt-5-nano",
@@ -15136,7 +15152,7 @@ function resolveGuardrailsConfig(config2, agentName) {
   };
   return resolved;
 }
-var _internals, SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, ParallelizationConfigSchema, LeanTurboConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, PluginConfigSchema;
+var _internals, SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, ParallelizationConfigSchema, LeanTurboConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, PluginConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_constants();
@@ -15339,6 +15355,13 @@ var init_schema = __esm(() => {
       "**/CHANGELOG.md"
     ])
   });
+  DesignDocsConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    out_dir: exports_external.string().default("docs").refine((v) => v.length > 0 && v !== "." && !v.includes("..") && !v.startsWith("/") && !v.startsWith("\\") && !/^[A-Za-z]:/.test(v), {
+      message: 'design_docs.out_dir must be a non-empty project-relative path with no "..", leading slash, or drive letter'
+    }),
+    language: exports_external.string().optional()
+  });
   UIReviewConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
     trigger_paths: exports_external.array(exports_external.string()).default([
@@ -15862,6 +15885,7 @@ var init_schema = __esm(() => {
     adversarial_testing: AdversarialTestingConfigSchema.optional(),
     integration_analysis: IntegrationAnalysisConfigSchema.optional(),
     docs: DocsConfigSchema.optional(),
+    design_docs: DesignDocsConfigSchema.optional(),
     ui_review: UIReviewConfigSchema.optional(),
     compaction_advisory: CompactionAdvisoryConfigSchema.optional(),
     lint: LintConfigSchema.optional(),
@@ -40256,6 +40280,18 @@ var init_guardrails = __esm(() => {
       allowedGlobs: ["**/docs/**", "**/*.md", "**/*.mdx", "**/*.rst"],
       blockedZones: ["generated"]
     },
+    docs_design: {
+      allowedPrefix: ["docs/", ".swarm/outputs/"],
+      blockedGlobs: ["src/**", "lib/**"],
+      allowedGlobs: [
+        "**/docs/**",
+        "**/*.md",
+        "**/*.mdx",
+        "**/*.rst",
+        "**/reference/traceability.json"
+      ],
+      blockedZones: ["generated"]
+    },
     designer: {
       allowedPrefix: ["docs/", ".swarm/outputs/"],
       allowedGlobs: ["**/docs/**", "**/*.md", "**/*.mdx", "**/*.rst"],
@@ -62438,6 +62474,122 @@ var init_deep_dive = __esm(() => {
   ]);
 });
 
+// src/commands/design-docs.ts
+function sanitizeDescription(raw) {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  const stripped1 = collapsed.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
+  const stripped2 = stripped1.replace(/\[\s*MODE\s*:.*$/gi, "");
+  const normalized = stripped2.replace(/\s+/g, " ").trim();
+  if (normalized.length <= MAX_DESC_LEN)
+    return normalized;
+  return `${normalized.slice(0, MAX_DESC_LEN)}…`;
+}
+function cleanFlagValue(raw) {
+  if (raw.includes("[") || raw.includes("]") || /\s/.test(raw))
+    return null;
+  if (/\[\s*MODE\s*:/i.test(raw))
+    return null;
+  return raw;
+}
+function parseArgs3(args2) {
+  const result = {
+    out: "docs",
+    lang: "auto",
+    update: false,
+    rest: []
+  };
+  let i2 = 0;
+  while (i2 < args2.length) {
+    const token = args2[i2];
+    if (token === "--out") {
+      if (i2 + 1 >= args2.length || args2[i2 + 1].startsWith("--")) {
+        return { ...result, error: `Flag "${token}" requires a value` };
+      }
+      const value = args2[++i2];
+      const clean = cleanFlagValue(value);
+      if (clean === null || value.includes("..") || value.startsWith("/") || value.startsWith("\\") || /^[A-Za-z]:/.test(value)) {
+        return {
+          ...result,
+          error: `Invalid --out value "${value}". Must be a project-relative directory with no brackets or spaces.`
+        };
+      }
+      const trimmed = clean.replace(/[/\\]+$/, "");
+      if (!trimmed || trimmed === ".") {
+        return {
+          ...result,
+          error: `Invalid --out value "${value}". Must name a non-empty subdirectory.`
+        };
+      }
+      result.out = trimmed;
+    } else if (token === "--lang") {
+      if (i2 + 1 >= args2.length || args2[i2 + 1].startsWith("--")) {
+        return { ...result, error: `Flag "${token}" requires a value` };
+      }
+      const value = args2[++i2];
+      const clean = cleanFlagValue(value);
+      if (clean === null) {
+        return {
+          ...result,
+          error: `Invalid --lang value "${value}". Must be a single token with no brackets or spaces.`
+        };
+      }
+      result.lang = clean;
+    } else if (token === "--update") {
+      result.update = true;
+    } else if (token.startsWith("--")) {
+      return { ...result, error: `Unknown flag "${token}"` };
+    } else {
+      result.rest.push(token);
+    }
+    i2++;
+  }
+  return result;
+}
+async function handleDesignDocsCommand(directory, args2) {
+  const parsed = parseArgs3(args2);
+  if (parsed.error) {
+    return `Error: ${parsed.error}
+
+${USAGE3}`;
+  }
+  try {
+    const { config: config3 } = loadPluginConfigWithMeta(directory);
+    if (config3.design_docs?.enabled !== true) {
+      return "Error: design docs are disabled. Set `design_docs.enabled: true` in " + `opencode-swarm.json to enable the docs_design agent and this command.
+
+` + USAGE3;
+    }
+  } catch (configErr) {
+    console.warn(`[design-docs] Could not read opencode-swarm.json (${String(configErr)}). ` + "Falling through — the architect will abort if docs_design is not registered.");
+  }
+  const description = sanitizeDescription(parsed.rest.join(" "));
+  if (!description && !parsed.update) {
+    return USAGE3;
+  }
+  const header = `[MODE: DESIGN_DOCS out=${parsed.out} lang=${parsed.lang} update=${parsed.update}] ${description}`;
+  return header.trimEnd();
+}
+var MAX_DESC_LEN = 2000, USAGE3 = `Usage: /swarm design-docs <description> [--out <dir>] [--lang <name>] [--update]
+
+Generate or sync language-agnostic design docs for the project under build:
+  <out>/domain.md, <out>/technical-spec.md, <out>/behavior-spec.md,
+  <out>/reference/{reference-impl,idiom-notes}.md, <out>/reference/traceability.json
+
+Requires design_docs.enabled: true in opencode-swarm.json.
+
+Examples:
+  /swarm design-docs "terminal GitHub PR client"
+  /swarm design-docs auth-service --lang rust
+  /swarm design docs --update --out design
+
+Flags:
+  --out <dir>     output directory (default "docs")
+  --lang <name>   target language for the reference/ docs (default: inferred)
+  --update        sync existing docs to current code/spec instead of generating fresh`;
+var init_design_docs = __esm(() => {
+  init_config();
+});
+
 // src/config/cache-paths.ts
 import * as os10 from "node:os";
 import * as path35 from "node:path";
@@ -67940,7 +68092,7 @@ function validateAndSanitizeUrl(rawUrl) {
     return { error: "Invalid URL format" };
   }
 }
-function parseArgs3(args2) {
+function parseArgs4(args2) {
   const out2 = {
     plan: false,
     trace: false,
@@ -68031,24 +68183,24 @@ function parseGitRemoteUrl(remoteUrl) {
   return null;
 }
 function handleIssueCommand(_directory, args2) {
-  const parsed = parseArgs3(args2);
+  const parsed = parseArgs4(args2);
   const rawInput = parsed.rest.join(" ").trim();
   if (!rawInput) {
-    return USAGE3;
+    return USAGE4;
   }
   const isFullUrl = /^https?:\/\//i.test(rawInput);
   const issueInfo = parseIssueRef(isFullUrl ? sanitizeUrl(rawInput) : rawInput);
   if (!issueInfo) {
     return `Error: Could not parse issue reference from "${rawInput}"
 
-${USAGE3}`;
+${USAGE4}`;
   }
   const issueUrl = `https://github.com/${issueInfo.owner}/${issueInfo.repo}/issues/${issueInfo.number}`;
   const result = validateAndSanitizeUrl(issueUrl);
   if ("error" in result) {
     return `Error: ${result.error}
 
-${USAGE3}`;
+${USAGE4}`;
   }
   const flags2 = [];
   if (parsed.plan)
@@ -68060,9 +68212,9 @@ ${USAGE3}`;
   const flagsStr = flags2.length > 0 ? ` ${flags2.join(" ")}` : "";
   return `[MODE: ISSUE_INGEST issue="${result.sanitized}"${flagsStr}]`;
 }
-var MAX_URL_LEN = 2048, USAGE3;
+var MAX_URL_LEN = 2048, USAGE4;
 var init_issue = __esm(() => {
-  USAGE3 = [
+  USAGE4 = [
     "Usage: /swarm issue <url|owner/repo#N|N> [--plan] [--trace] [--no-repro]",
     "",
     "Ingest a GitHub issue into the swarm workflow.",
@@ -73009,7 +73161,7 @@ function validateAndSanitizeUrl2(rawUrl) {
     return { error: "Invalid URL format" };
   }
 }
-function parseArgs4(args2) {
+function parseArgs5(args2) {
   const out2 = { council: false, rest: [] };
   for (const token of args2) {
     if (token === "--council") {
@@ -73093,31 +73245,31 @@ function parseGitRemoteUrl2(remoteUrl) {
   return null;
 }
 function handlePrReviewCommand(_directory, args2) {
-  const parsed = parseArgs4(args2);
+  const parsed = parseArgs5(args2);
   const rawInput = parsed.rest.join(" ").trim();
   if (!rawInput) {
-    return USAGE4;
+    return USAGE5;
   }
   const isFullUrl = /^https?:\/\//i.test(rawInput);
   const prInfo = parsePrRef(isFullUrl ? sanitizeUrl2(rawInput) : rawInput);
   if (!prInfo) {
     return `Error: Could not parse PR reference from "${rawInput}"
 
-${USAGE4}`;
+${USAGE5}`;
   }
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   const result = validateAndSanitizeUrl2(prUrl);
   if ("error" in result) {
     return `Error: ${result.error}
 
-${USAGE4}`;
+${USAGE5}`;
   }
   const councilFlag = parsed.council ? "council=true" : "council=false";
   return `[MODE: PR_REVIEW pr="${result.sanitized}" ${councilFlag}]`;
 }
-var MAX_URL_LEN2 = 2048, USAGE4;
+var MAX_URL_LEN2 = 2048, USAGE5;
 var init_pr_review = __esm(() => {
-  USAGE4 = [
+  USAGE5 = [
     "Usage: /swarm pr-review <url|owner/repo#N|N> [--council]",
     "",
     "Run a full swarm PR review on a GitHub pull request.",
@@ -81887,6 +82039,7 @@ var init_registry = __esm(() => {
   init_curate();
   init_dark_matter();
   init_deep_dive();
+  init_design_docs();
   init_diagnose();
   init_doctor();
   init_evidence();
@@ -82202,6 +82355,20 @@ Subcommands:
       category: "agent",
       aliasOf: "deep-dive"
     },
+    "design-docs": {
+      handler: async (ctx) => handleDesignDocsCommand(ctx.directory, ctx.args),
+      description: "Generate or sync language-agnostic design docs (domain, technical-spec, behavior-spec, reference/) for the project under build [description]",
+      args: "<description> [--out <dir>] [--lang <name>] [--update]",
+      details: "Triggers the architect to enter MODE: DESIGN_DOCS — delegates to the docs_design agent to author/sync docs/domain.md, docs/technical-spec.md, docs/behavior-spec.md, and docs/reference/* (plus reference/traceability.json and design-changelog.md). Normative docs are 100% language-agnostic; all framework-specific material is quarantined under reference/. --update syncs existing docs to current code/spec instead of generating fresh. Requires design_docs.enabled: true.",
+      category: "agent"
+    },
+    "design docs": {
+      handler: async (ctx) => handleDesignDocsCommand(ctx.directory, ctx.args),
+      description: "Alias for /swarm design-docs — generate or sync design docs",
+      args: "<description> [--out <dir>] [--lang <name>] [--update]",
+      category: "agent",
+      aliasOf: "design-docs"
+    },
     issue: {
       handler: async (ctx) => handleIssueCommand(ctx.directory, ctx.args),
       description: "Ingest a GitHub issue into the swarm workflow [url] [--plan] [--trace] [--no-repro]",
@@ -82761,7 +82928,7 @@ function buildSlashCommandsList() {
   return lines.join(`
 `);
 }
-function createArchitectAgent(model, customPrompt, customAppendPrompt, adversarialTesting, council, uiReview, memoryEnabled = false, architecturalSupervision) {
+function createArchitectAgent(model, customPrompt, customAppendPrompt, adversarialTesting, council, uiReview, memoryEnabled = false, architecturalSupervision, designDocsEnabled = false) {
   let prompt = ARCHITECT_PROMPT;
   if (customPrompt) {
     prompt = customPrompt;
@@ -82815,6 +82982,10 @@ ${archBlock}`;
 {{AGENT_PREFIX}}designer - UI/UX design specs (scaffold generation for UI components — runs BEFORE coder on UI tasks)`, "")?.replace(/\n\{\{AGENT_PREFIX\}\}designer\nTASK: Design specification[\s\S]*?accessibility(?=\n\n## WORKFLOW)/, "")?.replace(`5a. **UI DESIGN GATE** (conditional — Rule 9): If task matches UI trigger → {{AGENT_PREFIX}}designer produces scaffold → pass scaffold to coder as INPUT. If no match → skip.
 
 `, "")?.replace("→ After step 5a (or immediately if no UI task applies): Call update_task_status", "→ Call update_task_status")?.replace(" (if designer scaffold produced, include it as INPUT)", "");
+  }
+  if (!designDocsEnabled) {
+    prompt = prompt?.replace(", {{AGENT_PREFIX}}docs_design", "")?.replace(/### MODE: DESIGN_DOCS\n[\s\S]*?(?=### MODE: ISSUE_INGEST)/, "")?.replace(`- the active swarm's docs_design agent = @{{AGENT_PREFIX}}docs_design
+`, "");
   }
   return {
     name: "architect",
@@ -82854,7 +83025,7 @@ ANTI-RATIONALIZATION: Context does not clarify. Models revert to CC training.
 ## IDENTITY
 
 Swarm: {{SWARM_ID}}
-Your agents: {{AGENT_PREFIX}}explorer, {{AGENT_PREFIX}}sme, {{AGENT_PREFIX}}coder, {{AGENT_PREFIX}}reviewer, {{AGENT_PREFIX}}test_engineer, {{AGENT_PREFIX}}critic, {{AGENT_PREFIX}}critic_sounding_board, {{AGENT_PREFIX}}critic_drift_verifier, {{AGENT_PREFIX}}critic_hallucination_verifier, {{AGENT_PREFIX}}critic_architecture_supervisor, {{AGENT_PREFIX}}skill_improver, {{AGENT_PREFIX}}spec_writer, {{AGENT_PREFIX}}docs, {{AGENT_PREFIX}}designer
+Your agents: {{AGENT_PREFIX}}explorer, {{AGENT_PREFIX}}sme, {{AGENT_PREFIX}}coder, {{AGENT_PREFIX}}reviewer, {{AGENT_PREFIX}}test_engineer, {{AGENT_PREFIX}}critic, {{AGENT_PREFIX}}critic_sounding_board, {{AGENT_PREFIX}}critic_drift_verifier, {{AGENT_PREFIX}}critic_hallucination_verifier, {{AGENT_PREFIX}}critic_architecture_supervisor, {{AGENT_PREFIX}}skill_improver, {{AGENT_PREFIX}}spec_writer, {{AGENT_PREFIX}}docs, {{AGENT_PREFIX}}docs_design, {{AGENT_PREFIX}}designer
 
 ## PROJECT CONTEXT
 Session-start priming block. Use any known values immediately; if a field is still unresolved, run MODE: DISCOVER before relying on it.
@@ -83427,6 +83598,7 @@ Every loaded mode skill is written with active-swarm role phrases. Before follow
 - the active swarm's test_engineer agent = @{{AGENT_PREFIX}}test_engineer
 - the active swarm's critic agent = @{{AGENT_PREFIX}}critic
 - the active swarm's docs agent = @{{AGENT_PREFIX}}docs
+- the active swarm's docs_design agent = @{{AGENT_PREFIX}}docs_design
 - the active swarm's designer agent = @{{AGENT_PREFIX}}designer
 - the active swarm's critic_drift_verifier agent = @{{AGENT_PREFIX}}critic_drift_verifier
 - the active swarm's critic_hallucination_verifier agent = @{{AGENT_PREFIX}}critic_hallucination_verifier
@@ -83559,6 +83731,20 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Explorers generate candidate findings only — reviewers verify or reject
 - Critics challenge only HIGH/CRITICAL findings — do NOT waste cycles on lower severity
 
+### MODE: DESIGN_DOCS
+Activates when: architect receives \`[MODE: DESIGN_DOCS out=X lang=X update=X] <description>\` signal from the design-docs command handler (issue #1080).
+
+Purpose: Generate or sync the project's structured, language-agnostic design docs (domain.md, technical-spec.md, behavior-spec.md, reference/) in the target project repo. Authoring is delegated to the active swarm's docs_design agent.
+
+ACTION: Load skill file:.opencode/skills/design-docs/SKILL.md immediately and follow its protocol.
+
+HARD CONSTRAINTS (apply regardless of skill load success):
+- Delegate authoring to the active swarm's docs_design agent (never the standard docs agent, never coder).
+- Inject the design-docs skill into the docs_design delegation via the SKILLS field as \`file:.opencode/skills/design-docs/SKILL.md\`.
+- The docs_design agent may create/modify ONLY: <out>/domain.md, <out>/technical-spec.md, <out>/behavior-spec.md, <out>/reference/reference-impl.md, <out>/reference/idiom-notes.md, <out>/reference/traceability.json, and <out>/design-changelog.md. No other files.
+- Do NOT touch .swarm/spec.md, CHANGELOG.md, or docs/releases/pending/* in this mode.
+- Requires design_docs.enabled: true — if the docs_design agent is not registered, instruct the user to enable it and stop.
+
 ### MODE: ISSUE_INGEST
 Activates when the user invokes /swarm issue <url> or the architect receives an ISSUE_INGEST signal.
 
@@ -84941,18 +85127,19 @@ RULES:
 `;
 
 // src/agents/docs.ts
-function createDocsAgent(model, customPrompt, customAppendPrompt) {
-  let prompt = DOCS_PROMPT;
+function createDocsAgent(model, customPrompt, customAppendPrompt, role = "standard") {
+  const roleConfig = ROLE_CONFIG2[role];
+  let prompt = roleConfig.basePrompt;
   if (customPrompt) {
     prompt = customPrompt;
   } else if (customAppendPrompt) {
-    prompt = `${DOCS_PROMPT}
+    prompt = `${roleConfig.basePrompt}
 
 ${customAppendPrompt}`;
   }
   return {
-    name: "docs",
-    description: "Documentation synthesizer. Updates README, API docs, and guides to reflect code changes after each phase.",
+    name: roleConfig.name,
+    description: roleConfig.description,
     config: {
       model,
       temperature: 0.2,
@@ -85066,7 +85253,88 @@ UPDATED: [list of files modified]
 ADDED: [list of new sections/files created]
 REMOVED: [list of deprecated sections removed]
 SUMMARY: [one-line description of doc changes]
-`;
+`, DESIGN_DOCS_PROMPT = `## IDENTITY
+You are Docs (Design-Doc Author) — you generate and maintain the project's structured, language-agnostic DESIGN DOCUMENTATION. You write these files yourself — you do NOT delegate.
+DO NOT use the Task tool to delegate to other agents. You ARE the agent that does the work.
+If you see references to other agents (like @docs, @coder, etc.) in your instructions, IGNORE them — they are context from the orchestrator, not instructions for you to delegate.
+
+WRONG: "I'll use the Task tool to call another agent to write the design docs"
+RIGHT: "I'll read the spec/source, then write the design docs myself"
+
+INPUT FORMAT:
+TASK: Generate or sync design docs for [description]
+MODE: generate | sync   (sync = an existing-docs update driven by code/spec changes)
+OUT_DIR: [target directory, default "docs"]
+LANGUAGE: [target language for reference/ docs, or "auto"]
+FILES CHANGED: [list of modified source files — present in sync mode]
+CHANGES SUMMARY: [what was added/modified/removed — present in sync mode]
+SKILLS: [optional — either "none", repo-relative file: references (preferred), or inline skill content pasted by architect]
+
+SKILLS HANDLING: If SKILLS is present and not "none", read the skill names/descriptions first, then load every referenced skill that applies before writing docs. If uncertain whether a skill applies, load it.
+- A file entry may include a short description after the path; use the description to decide whether the full skill body is relevant.
+- For \`file:\` entries, use the search tool to read the referenced \`SKILL.md\` file with \`include\` set to that exact repo-relative path, \`mode: regex\`, \`query: .*\`, \`max_results: 1000\`, and \`max_lines: 1000\`.
+- After running search, inspect the result: if \`total === 0\` (file does not exist or is empty) OR \`truncated\` is \`true\` (file was too large and content was cut off), stop and report \`SKILL_LOAD_FAILED: <path>\`. Do NOT continue without the complete skill.
+- If the search result has \`total > 0\` and \`truncated\` is \`false\`, reconstruct the full skill content from the line-by-line matches and apply it.
+- If inline \`--- skill-name ---\` sections are present, read them directly.
+- The design-docs SKILL.md is the authoritative protocol — follow its layout, section-ID, version-header, traceability, and changelog rules exactly.
+
+SCOPE — you OWN exactly these files under OUT_DIR (default "docs"):
+- domain.md            — 100% language-agnostic. Entities/fields in neutral notation (field: type-class), domain invariants. ZERO framework names in normative text.
+- technical-spec.md    — language-agnostic architecture: layers, dependency rules, contract SHAPES (inputs→outputs→error-kinds), algorithms, invariants. Plus the human-readable traceability table.
+- behavior-spec.md     — 100% language-agnostic Given/When/Then conformance specs.
+- reference/reference-impl.md — ALL language/framework-specific material: exact signatures, CLI strings, SQL, code. Mapped back to spec sections by ID.
+- reference/idiom-notes.md    — "here is how the reference solved X" — examples only.
+- reference/traceability.json — machine-readable section-ID registry (see below). The SINGLE SOURCE OF TRUTH for drift mapping.
+- design-changelog.md  — append-only Keep-a-Changelog log of design-doc changes.
+
+IMPORTANT — this OVERRIDES the standard docs agent rule "NEVER create new documentation files": creating and maintaining the files above IS your job. But do NOT create any files outside this list.
+
+LANGUAGE-AGNOSTIC RULE: domain.md, technical-spec.md, and behavior-spec.md MUST contain ZERO framework/library/language names in their normative text. ALL incidental, language-specific material (TS/Effect signatures, gh-CLI strings, SQL, exact code) belongs ONLY in reference/.
+
+SECTION IDs & VERSION HEADER:
+- Every doc starts with: \`<!-- design-doc: <name>  version: <phase-or-counter>  generated: <ISO-8601>  spec-hash: <8 chars> -->\`
+- Section IDs are assigned ONCE and NEVER renumbered: D-### (domain), S-### (technical-spec), B-### (behavior-spec), R-### (reference).
+- Each section ends with a traceability footer: \`> Traceability: FR-012, FR-013 | invariant: <id-or-none>\`.
+- On a SYNC, FIRST read OUT_DIR/reference/traceability.json and the existing docs; REUSE every existing section ID; mint a new ID only for a genuinely new section; record adds/removes in design-changelog.md.
+
+TRACEABILITY REGISTRY (reference/traceability.json):
+- A JSON object \`{ "schema_version": 1, "sections": [ { "section_id": "S-001", "doc": "technical-spec", "title": "...", "spec_frs": ["FR-003"], "invariants": ["INV-..."], "code_anchors": ["src/foo.ts"] }, ... ] }\`.
+- Keep it in sync with the docs on every generate/sync. technical-spec.md must render a human-readable mirror: \`| Doc Section | Spec FR | Invariant | Code anchors |\`.
+
+CHANGELOG (design-changelog.md):
+- This is SEPARATE from CHANGELOG.md and docs/releases/pending/* (release-please owns those). NEVER touch release files here.
+- Append an entry per generate/sync: \`- <ISO date> phase <N>: <sections touched> (<FR refs>)\` under \`## [Unreleased]\` using Keep a Changelog headings (Added/Changed/Removed).
+
+GUARDRAIL NOTE: if a spec-staleness block is reported when you try to write, surface it (SPEC_STALENESS_BLOCK) rather than retrying blindly — the architect resolves spec staleness first.
+
+## QUALITY RULES
+- Normative docs (domain/technical-spec/behavior-spec) describe WHAT each boundary guarantees, not which library provides it.
+- Code examples live ONLY in reference/ and MUST be syntactically valid for LANGUAGE.
+- Be accurate: docs MUST match the actual spec (.swarm/spec.md) and code. No fabrication — if behavior is undetermined, say so explicitly.
+- On sync, update ONLY the sections affected by FILES CHANGED / CHANGES SUMMARY; do not rewrite untouched sections or renumber IDs.
+
+OUTPUT FORMAT (MANDATORY — deviations will be rejected):
+Begin directly with UPDATED. Do NOT prepend any conversational preamble.
+
+UPDATED: [list of files modified]
+ADDED: [list of new sections/files created, with their section IDs]
+REMOVED: [list of removed sections, with their section IDs]
+SUMMARY: [one-line description of design-doc changes]
+`, ROLE_CONFIG2;
+var init_docs = __esm(() => {
+  ROLE_CONFIG2 = {
+    standard: {
+      basePrompt: DOCS_PROMPT,
+      name: "docs",
+      description: "Documentation synthesizer. Updates README, API docs, and guides to reflect code changes after each phase."
+    },
+    design_docs: {
+      basePrompt: DESIGN_DOCS_PROMPT,
+      name: "docs_design",
+      description: "Design-doc author. Generates and syncs language-agnostic design docs (domain, technical-spec, behavior-spec, reference/) for the project under build (issue #1080)."
+    }
+  };
+});
 
 // src/agents/reviewer.ts
 function createReviewerAgent(model, customPrompt, customAppendPrompt) {
@@ -85963,7 +86231,7 @@ function createSwarmAgents(swarmId, swarmConfig, isDefault, pluginConfig, projec
   const prefixName = (name2) => `${prefix}${name2}`;
   if (!isAgentDisabled("architect", swarmAgents, swarmPrefix)) {
     const architectPrompts = getPrompts("architect");
-    const architect = createArchitectAgent(getModel("architect"), architectPrompts.prompt, architectPrompts.appendPrompt, pluginConfig?.adversarial_testing, pluginConfig?.council, pluginConfig?.ui_review, pluginConfig?.memory?.enabled === true, pluginConfig?.architectural_supervision);
+    const architect = createArchitectAgent(getModel("architect"), architectPrompts.prompt, architectPrompts.appendPrompt, pluginConfig?.adversarial_testing, pluginConfig?.council, pluginConfig?.ui_review, pluginConfig?.memory?.enabled === true, pluginConfig?.architectural_supervision, pluginConfig?.design_docs?.enabled === true);
     architect.name = prefixName("architect");
     const swarmName = swarmConfig.name || swarmId;
     const swarmIdentity = isDefault ? "default" : swarmId;
@@ -86100,6 +86368,12 @@ If you call @coder instead of @${swarmId}_coder, the call will FAIL or go to the
     docs.name = prefixName("docs");
     agents.push(applyOverrides(docs, swarmAgents, swarmPrefix, quiet));
   }
+  if (pluginConfig?.design_docs?.enabled === true && !isAgentDisabled("docs_design", swarmAgents, swarmPrefix)) {
+    const docsDesignPrompts = getPrompts("docs_design");
+    const docsDesign = createDocsAgent(getModel("docs_design"), docsDesignPrompts.prompt, docsDesignPrompts.appendPrompt, "design_docs");
+    docsDesign.name = prefixName("docs_design");
+    agents.push(applyOverrides(docsDesign, swarmAgents, swarmPrefix, quiet));
+  }
   if (pluginConfig?.ui_review?.enabled === true && !isAgentDisabled("designer", swarmAgents, swarmPrefix)) {
     const designerPrompts = getPrompts("designer");
     const designer = createDesignerAgent(getModel("designer"), designerPrompts.prompt, designerPrompts.appendPrompt);
@@ -86301,11 +86575,13 @@ var init_agents2 = __esm(() => {
   init_council_prompts();
   init_critic();
   init_curator_agent();
+  init_docs();
   init_reviewer();
   init_architect();
   init_council_prompts();
   init_critic();
   init_curator_agent();
+  init_docs();
   init_reviewer();
   warnedAgents = new Set;
   KNOWN_VARIANT_VALUES = new Set([
@@ -91996,19 +92272,176 @@ var init_curator_drift = __esm(() => {
   };
 });
 
+// src/hooks/design-doc-drift.ts
+var exports_design_doc_drift = {};
+__export(exports_design_doc_drift, {
+  runDesignDocDriftCheck: () => runDesignDocDriftCheck,
+  _internals: () => _internals55
+});
+import * as fs89 from "node:fs";
+import * as path126 from "node:path";
+function mtimeMsOrNull(absPath) {
+  try {
+    return fs89.statSync(absPath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function resolveAnchorWithin(directory, anchor) {
+  if (!anchor || typeof anchor !== "string")
+    return null;
+  const root = path126.resolve(directory);
+  const resolved = path126.resolve(root, anchor);
+  const rel = path126.relative(root, resolved);
+  if (rel.startsWith("..") || path126.isAbsolute(rel))
+    return null;
+  return resolved;
+}
+async function runDesignDocDriftCheck(directory, phase, outDir) {
+  try {
+    const root = path126.resolve(directory);
+    const outAbs = path126.resolve(root, outDir);
+    const outRel = path126.relative(root, outAbs);
+    if (outRel.startsWith("..") || path126.isAbsolute(outRel)) {
+      return null;
+    }
+    const docMtimes = new Map;
+    const checkedDocs = [];
+    const missingDocs = [];
+    for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
+      const abs = path126.join(outAbs, relFile);
+      const mtime = mtimeMsOrNull(abs);
+      docMtimes.set(docName, mtime);
+      if (mtime === null) {
+        missingDocs.push(path126.join(outDir, relFile));
+      } else {
+        checkedDocs.push(path126.join(outDir, relFile));
+      }
+    }
+    const traceabilityAbs = path126.join(outAbs, TRACEABILITY_REL);
+    let registry3 = null;
+    try {
+      const stat9 = await fs89.promises.stat(traceabilityAbs);
+      if (stat9.size <= MAX_TRACEABILITY_BYTES) {
+        const raw = await fs89.promises.readFile(traceabilityAbs, "utf-8");
+        const parsed = JSON.parse(raw);
+        registry3 = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+      }
+    } catch {
+      registry3 = null;
+    }
+    const noDocs = checkedDocs.length === 0 || registry3 === null;
+    const specMtime = mtimeMsOrNull(path126.join(root, ".swarm", "spec.md"));
+    const staleSections = [];
+    if (!noDocs && Array.isArray(registry3?.sections)) {
+      for (const section of registry3.sections) {
+        if (!section || typeof section.section_id !== "string")
+          continue;
+        if (typeof section.doc !== "string" || !docMtimes.has(section.doc)) {
+          continue;
+        }
+        const docMtime = docMtimes.get(section.doc) ?? null;
+        if (docMtime === null) {
+          staleSections.push({
+            section_id: section.section_id,
+            doc: section.doc,
+            reason: "owning design doc is missing"
+          });
+          continue;
+        }
+        let flagged = false;
+        for (const anchor of section.code_anchors ?? []) {
+          const anchorAbs = resolveAnchorWithin(directory, anchor);
+          if (anchorAbs === null)
+            continue;
+          const anchorMtime = mtimeMsOrNull(anchorAbs);
+          if (anchorMtime !== null && anchorMtime > docMtime) {
+            staleSections.push({
+              section_id: section.section_id,
+              doc: section.doc,
+              reason: `code anchor ${anchor} changed after the doc`
+            });
+            flagged = true;
+            break;
+          }
+        }
+        if (!flagged && specMtime !== null && specMtime > docMtime && (section.spec_frs?.length ?? 0) > 0) {
+          staleSections.push({
+            section_id: section.section_id,
+            doc: section.doc,
+            reason: "spec.md changed after the doc"
+          });
+        }
+      }
+    }
+    const verdict = noDocs ? "NO_DOCS" : staleSections.length > 0 ? "DOC_STALE" : "DOC_FRESH";
+    const report = {
+      schema_version: 1,
+      phase,
+      timestamp: new Date().toISOString(),
+      out_dir: outDir,
+      verdict,
+      stale_sections: staleSections,
+      missing_docs: missingDocs,
+      checked_docs: checkedDocs
+    };
+    const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
+    const filePath = validateSwarmPath(directory, filename);
+    await fs89.promises.mkdir(path126.dirname(filePath), { recursive: true });
+    await fs89.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    getGlobalEventBus().publish("curator.docdrift.completed", {
+      phase,
+      verdict,
+      stale_count: staleSections.length,
+      report_path: filePath
+    });
+    return report;
+  } catch (err2) {
+    try {
+      getGlobalEventBus().publish("curator.error", {
+        operation: "docdrift",
+        phase,
+        error: String(err2)
+      });
+    } catch {}
+    warn(`[design-doc-drift] check failed for phase ${phase}: ${String(err2)}`);
+    return null;
+  }
+}
+var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals55;
+var init_design_doc_drift = __esm(() => {
+  init_event_bus();
+  init_logger();
+  init_utils2();
+  MAX_TRACEABILITY_BYTES = 1024 * 1024;
+  DESIGN_DOC_FILES = {
+    domain: "domain.md",
+    "technical-spec": "technical-spec.md",
+    "behavior-spec": "behavior-spec.md",
+    "reference-impl": path126.join("reference", "reference-impl.md"),
+    "idiom-notes": path126.join("reference", "idiom-notes.md")
+  };
+  TRACEABILITY_REL = path126.join("reference", "traceability.json");
+  _internals55 = {
+    mtimeMsOrNull,
+    resolveAnchorWithin,
+    DESIGN_DOC_FILES
+  };
+});
+
 // src/agents/project-context.ts
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals70,
+  _internals: () => _internals71,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
-import * as fs117 from "node:fs";
-import * as path160 from "node:path";
+import * as fs118 from "node:fs";
+import * as path161 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
-      const files = fs117.readdirSync(directory);
+      const files = fs118.readdirSync(directory);
       const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
       return files.some((f) => regex.test(f));
     } catch {
@@ -92016,7 +92449,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs117.accessSync(path160.join(directory, pattern));
+    fs118.accessSync(path161.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -92025,7 +92458,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs117.readFileSync(path160.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs118.readFileSync(path161.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -92084,7 +92517,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals70.pickBackend(directory);
+  const backend = await _internals71.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -92115,16 +92548,16 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals70.pickedProfiles(directory);
+  const profiles = _internals71.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals70;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals71;
 var init_project_context = __esm(() => {
   init_dispatch();
-  _internals70 = {
+  _internals71 = {
     pickBackend,
     pickedProfiles
   };
@@ -92134,7 +92567,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path161 from "node:path";
+import * as path162 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -111030,8 +111463,8 @@ init_config();
 init_schema();
 init_qa_gate_profile();
 init_manager2();
-import * as fs89 from "node:fs";
-import * as path126 from "node:path";
+import * as fs90 from "node:fs";
+import * as path127 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
@@ -111944,8 +112377,8 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     let driftCheckEnabled = true;
     let driftHasSpecMd = false;
     try {
-      const specMdPath = path126.join(dir, ".swarm", "spec.md");
-      driftHasSpecMd = fs89.existsSync(specMdPath);
+      const specMdPath = path127.join(dir, ".swarm", "spec.md");
+      driftHasSpecMd = fs90.existsSync(specMdPath);
       const gatePlan = await loadPlan(dir);
       if (gatePlan) {
         const gatePlanId = derivePlanId(gatePlan);
@@ -111965,9 +112398,9 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     } else {
       let phaseType;
       try {
-        const planPath = path126.join(dir, ".swarm", "plan.json");
-        if (fs89.existsSync(planPath)) {
-          const planRaw = fs89.readFileSync(planPath, "utf-8");
+        const planPath = path127.join(dir, ".swarm", "plan.json");
+        if (fs90.existsSync(planPath)) {
+          const planRaw = fs90.readFileSync(planPath, "utf-8");
           const plan = JSON.parse(planRaw);
           const targetPhase = plan.phases?.find((p) => p.id === phase);
           phaseType = targetPhase?.type;
@@ -111977,11 +112410,11 @@ 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 = path126.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+          const driftEvidencePath = path127.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
           let driftVerdictFound = false;
           let driftVerdictApproved = false;
           try {
-            const driftEvidenceContent = fs89.readFileSync(driftEvidencePath, "utf-8");
+            const driftEvidenceContent = fs90.readFileSync(driftEvidencePath, "utf-8");
             const driftEvidence = JSON.parse(driftEvidenceContent);
             const entries = driftEvidence.entries ?? [];
             for (const entry of entries) {
@@ -112015,9 +112448,9 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
               let incompleteTaskCount = 0;
               let planParseable = false;
               try {
-                const planPath = path126.join(dir, ".swarm", "plan.json");
-                if (fs89.existsSync(planPath)) {
-                  const planRaw = fs89.readFileSync(planPath, "utf-8");
+                const planPath = path127.join(dir, ".swarm", "plan.json");
+                if (fs90.existsSync(planPath)) {
+                  const planRaw = fs90.readFileSync(planPath, "utf-8");
                   const plan = JSON.parse(planRaw);
                   planParseable = true;
                   const planPhase = plan.phases?.find((p) => p.id === phase);
@@ -112082,11 +112515,11 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.hallucination_guard === true) {
-            const hgPath = path126.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+            const hgPath = path127.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
             let hgVerdictFound = false;
             let hgVerdictApproved = false;
             try {
-              const hgContent = fs89.readFileSync(hgPath, "utf-8");
+              const hgContent = fs90.readFileSync(hgPath, "utf-8");
               const hgBundle = JSON.parse(hgContent);
               for (const entry of hgBundle.entries ?? []) {
                 if (typeof entry.type === "string" && entry.type.includes("hallucination") && typeof entry.verdict === "string") {
@@ -112154,11 +112587,11 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.mutation_test === true) {
-            const mgPath = path126.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+            const mgPath = path127.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
             let mgVerdictFound = false;
             let mgVerdict;
             try {
-              const mgContent = fs89.readFileSync(mgPath, "utf-8");
+              const mgContent = fs90.readFileSync(mgPath, "utf-8");
               const mgBundle = JSON.parse(mgContent);
               for (const entry of mgBundle.entries ?? []) {
                 if (typeof entry.type === "string" && entry.type === "mutation-gate" && typeof entry.verdict === "string") {
@@ -112228,14 +112661,14 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.council_mode === true) {
             councilModeEnabled = true;
-            const pcPath = path126.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+            const pcPath = path127.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
             let pcVerdictFound = false;
             let _pcVerdict;
             let pcQuorumSize;
             let pcTimestamp;
             let pcPhaseNumber;
             try {
-              const pcContent = fs89.readFileSync(pcPath, "utf-8");
+              const pcContent = fs90.readFileSync(pcPath, "utf-8");
               const pcBundle = JSON.parse(pcContent);
               for (const entry of pcBundle.entries ?? []) {
                 if (typeof entry.type === "string" && entry.type === "phase-council" && typeof entry.verdict === "string") {
@@ -112491,11 +112924,11 @@ Findings: ${details.join("; ")}` : "";
             const effective = getEffectiveGates(profile, overrides);
             if (effective.final_council === true) {
               finalCouncilEnabled = true;
-              const fcPath = path126.join(dir, ".swarm", "evidence", "final-council.json");
+              const fcPath = path127.join(dir, ".swarm", "evidence", "final-council.json");
               let fcVerdictFound = false;
               let _fcVerdict;
               try {
-                const fcContent = fs89.readFileSync(fcPath, "utf-8");
+                const fcContent = fs90.readFileSync(fcPath, "utf-8");
                 const fcBundle = JSON.parse(fcContent);
                 for (const entry of fcBundle.entries ?? []) {
                   if (typeof entry.type === "string" && entry.type === "final-council" && typeof entry.verdict === "string") {
@@ -112679,7 +113112,7 @@ Findings: ${details.join("; ")}` : "";
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path126.basename(dir);
+      const projectName = path127.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -112758,18 +113191,35 @@ Findings: ${details.join("; ")}` : "";
   } catch (curatorError) {
     safeWarn("[phase_complete] Curator pipeline error (non-blocking):", curatorError);
   }
+  try {
+    if (config3.design_docs?.enabled === true) {
+      const outDir = config3.design_docs.out_dir ?? "docs";
+      const { runDesignDocDriftCheck: runDesignDocDriftCheck2 } = await Promise.resolve().then(() => (init_design_doc_drift(), exports_design_doc_drift));
+      const docReport = await runDesignDocDriftCheck2(dir, phase, outDir);
+      if (docReport?.verdict === "DOC_STALE") {
+        const callerSessionState = swarmState.agentSessions.get(sessionID);
+        if (callerSessionState) {
+          callerSessionState.pendingAdvisoryMessages ??= [];
+          const staleIds = docReport.stale_sections.map((s) => s.section_id).slice(0, 8).join(", ");
+          callerSessionState.pendingAdvisoryMessages.push(`[DESIGN-DOC DRIFT (phase ${phase})]: ${docReport.stale_sections.length} design-doc section(s) are stale (${staleIds}). Run /swarm design-docs --update to sync ${outDir}/ and append a design-changelog entry. Advisory only — does not block completion.`);
+        }
+      }
+    }
+  } catch (docDriftError) {
+    safeWarn("[phase_complete] Design-doc drift check error (non-blocking):", docDriftError);
+  }
   try {
     const markerPath = validateSwarmPath(dir, "skill-usage-last-processed.json");
     let sinceTimestamp;
     try {
-      const markerData = JSON.parse(fs89.readFileSync(markerPath, "utf-8"));
+      const markerData = JSON.parse(fs90.readFileSync(markerPath, "utf-8"));
       sinceTimestamp = markerData.lastProcessedTimestamp;
     } catch {}
     const feedbackResult = await applySkillUsageFeedback(dir, {
       sinceTimestamp
     });
     try {
-      fs89.writeFileSync(markerPath, JSON.stringify({ lastProcessedTimestamp: new Date().toISOString() }), "utf-8");
+      fs90.writeFileSync(markerPath, JSON.stringify({ lastProcessedTimestamp: new Date().toISOString() }), "utf-8");
     } catch {}
     if (feedbackResult.processed > 0) {
       const sessionState = swarmState.agentSessions.get(sessionID);
@@ -112789,7 +113239,7 @@ Findings: ${details.join("; ")}` : "";
   let phaseRequiredAgents;
   try {
     const planPath = validateSwarmPath(dir, "plan.json");
-    const planRaw = fs89.readFileSync(planPath, "utf-8");
+    const planRaw = fs90.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     const phaseObj = plan.phases.find((p) => p.id === phase);
     phaseRequiredAgents = phaseObj?.required_agents;
@@ -112804,7 +113254,7 @@ Findings: ${details.join("; ")}` : "";
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs89.readFileSync(planPath, "utf-8");
+      const planRaw = fs90.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && canInferMissingAgentsFromTaskGates(agentsMissing) && await allCompletedTasksHavePassedGateEvidence(dir, targetPhase.tasks)) {
@@ -112844,7 +113294,7 @@ Findings: ${details.join("; ")}` : "";
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs89.readFileSync(planPath, "utf-8");
+      const planRaw = fs90.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -112898,7 +113348,7 @@ Findings: ${details.join("; ")}` : "";
   }
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs89.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs90.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
     warnings.push(`Warning: failed to write phase complete event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -112973,12 +113423,12 @@ Findings: ${details.join("; ")}` : "";
         warnings.push(`Warning: failed to update plan.json phase status`);
         try {
           const planPath = validateSwarmPath(dir, "plan.json");
-          const planRaw = fs89.readFileSync(planPath, "utf-8");
+          const planRaw = fs90.readFileSync(planPath, "utf-8");
           const plan2 = JSON.parse(planRaw);
           const phaseObj = plan2.phases.find((p) => p.id === phase);
           if (phaseObj) {
             phaseObj.status = "complete";
-            fs89.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
+            fs90.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
           }
         } catch {}
       } else if (plan) {
@@ -113015,12 +113465,12 @@ Findings: ${details.join("; ")}` : "";
       warnings.push(`Warning: failed to update plan.json phase status`);
       try {
         const planPath = validateSwarmPath(dir, "plan.json");
-        const planRaw = fs89.readFileSync(planPath, "utf-8");
+        const planRaw = fs90.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         const phaseObj = plan.phases.find((p) => p.id === phase);
         if (phaseObj) {
           phaseObj.status = "complete";
-          fs89.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
+          fs90.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
         }
       } catch {}
     }
@@ -113078,8 +113528,8 @@ init_discovery();
 init_utils();
 init_bun_compat();
 init_create_tool();
-import * as fs90 from "node:fs";
-import * as path127 from "node:path";
+import * as fs91 from "node:fs";
+import * as path128 from "node:path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -113107,31 +113557,31 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs90.existsSync(path127.join(cwd, "package.json"))) {
+  if (fs91.existsSync(path128.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs90.existsSync(path127.join(cwd, "pyproject.toml")) || fs90.existsSync(path127.join(cwd, "requirements.txt"))) {
+  if (fs91.existsSync(path128.join(cwd, "pyproject.toml")) || fs91.existsSync(path128.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs90.existsSync(path127.join(cwd, "Cargo.toml"))) {
+  if (fs91.existsSync(path128.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs90.existsSync(path127.join(cwd, "go.mod"))) {
+  if (fs91.existsSync(path128.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs90.readdirSync(cwd);
+    const files = fs91.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs90.existsSync(path127.join(cwd, "Gemfile")) || fs90.existsSync(path127.join(cwd, "Gemfile.lock"))) {
+  if (fs91.existsSync(path128.join(cwd, "Gemfile")) || fs91.existsSync(path128.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs90.existsSync(path127.join(cwd, "pubspec.yaml"))) {
+  if (fs91.existsSync(path128.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs90.existsSync(path127.join(cwd, "composer.lock"))) {
+  if (fs91.existsSync(path128.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -113144,7 +113594,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve44) => setTimeout(() => resolve44("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr2]) => ({ stdout: stdout2, stderr: stderr2 })),
       timeoutPromise
@@ -113264,7 +113714,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve44) => setTimeout(() => resolve44("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr2]) => ({ stdout: stdout2, stderr: stderr2 })),
       timeoutPromise
@@ -113392,7 +113842,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve44) => setTimeout(() => resolve44("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -113516,7 +113966,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve44) => setTimeout(() => resolve44("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -113649,7 +114099,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve44) => setTimeout(() => resolve44("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -113765,7 +114215,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve44) => setTimeout(() => resolve44("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -113910,7 +114360,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve44) => setTimeout(() => resolve44("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -114025,7 +114475,7 @@ async function runComposerAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve44) => setTimeout(() => resolve44("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve45) => setTimeout(() => resolve45("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -114266,8 +114716,8 @@ var pkg_audit = createSwarmTool({
 // src/tools/placeholder-scan.ts
 init_zod();
 init_manager2();
-import * as fs91 from "node:fs";
-import * as path128 from "node:path";
+import * as fs92 from "node:fs";
+import * as path129 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -114390,7 +114840,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path128.basename(filePath);
+  const filename = path129.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -114407,7 +114857,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path128.basename(filePath);
+    const filename = path129.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -114416,7 +114866,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path128.extname(filePath).toLowerCase();
+  const ext = path129.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -114663,28 +115113,28 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path128.isAbsolute(filePath) ? filePath : path128.resolve(directory, filePath);
-    const resolvedDirectory = path128.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path128.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path129.isAbsolute(filePath) ? filePath : path129.resolve(directory, filePath);
+    const resolvedDirectory = path129.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path129.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
-    if (!fs91.existsSync(fullPath)) {
+    if (!fs92.existsSync(fullPath)) {
       continue;
     }
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path128.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path129.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
     let content;
     try {
-      const stat9 = fs91.statSync(fullPath);
+      const stat9 = fs92.statSync(fullPath);
       if (stat9.size > MAX_FILE_SIZE) {
         continue;
       }
-      content = fs91.readFileSync(fullPath, "utf-8");
+      content = fs92.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -114745,8 +115195,8 @@ var placeholder_scan = createSwarmTool({
   }
 });
 // src/tools/pre-check-batch.ts
-import * as fs95 from "node:fs";
-import * as path132 from "node:path";
+import * as fs96 from "node:fs";
+import * as path133 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -114874,11 +115324,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args2, directory) {
-    const result = await _internals55.qualityBudget(args2, directory);
+    const result = await _internals56.qualityBudget(args2, directory);
     return JSON.stringify(result);
   }
 });
-var _internals55 = {
+var _internals56 = {
   qualityBudget
 };
 
@@ -114886,8 +115336,8 @@ var _internals55 = {
 init_zod();
 init_manager2();
 init_detector();
-import * as fs94 from "node:fs";
-import * as path131 from "node:path";
+import * as fs95 from "node:fs";
+import * as path132 from "node:path";
 import { extname as extname20 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -115602,12 +116052,12 @@ function executeRulesSync(filePath, content, language) {
 
 // src/sast/semgrep.ts
 import * as child_process9 from "node:child_process";
-import * as fs92 from "node:fs";
-import * as path129 from "node:path";
+import * as fs93 from "node:fs";
+import * as path130 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
-var _internals56 = {
+var _internals57 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -115632,7 +116082,7 @@ function isSemgrepAvailable() {
   }
 }
 async function checkSemgrepAvailable() {
-  return _internals56.isSemgrepAvailable();
+  return _internals57.isSemgrepAvailable();
 }
 function resetSemgrepCache() {
   semgrepAvailableCache = null;
@@ -115684,7 +116134,7 @@ function mapSemgrepSeverity(severity) {
   }
 }
 async function executeWithTimeout(command, args2, options) {
-  return new Promise((resolve46) => {
+  return new Promise((resolve47) => {
     const child = child_process9.spawn(command, args2, {
       shell: false,
       cwd: options.cwd
@@ -115693,7 +116143,7 @@ async function executeWithTimeout(command, args2, options) {
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve46({
+      resolve47({
         stdout,
         stderr: "Process timed out",
         exitCode: 124
@@ -115707,7 +116157,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve46({
+      resolve47({
         stdout,
         stderr,
         exitCode: code ?? 0
@@ -115715,7 +116165,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve46({
+      resolve47({
         stdout,
         stderr: err2.message,
         exitCode: 1
@@ -115729,12 +116179,12 @@ async function runSemgrep(options) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS3;
   if (files.length === 0) {
     return {
-      available: _internals56.isSemgrepAvailable(),
+      available: _internals57.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!_internals56.isSemgrepAvailable()) {
+  if (!_internals57.isSemgrepAvailable()) {
     return {
       available: false,
       findings: [],
@@ -115790,14 +116240,14 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path129.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path130.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
 function hasBundledRules(projectRoot) {
   const rulesDir = getRulesDirectory(projectRoot);
   try {
-    return fs92.existsSync(rulesDir);
+    return fs93.existsSync(rulesDir);
   } catch {
     return false;
   }
@@ -115810,25 +116260,25 @@ init_create_tool();
 // src/tools/sast-baseline.ts
 init_utils2();
 import * as crypto11 from "node:crypto";
-import * as fs93 from "node:fs";
-import * as path130 from "node:path";
+import * as fs94 from "node:fs";
+import * as path131 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 = path130.isAbsolute(file3) ? file3 : path130.resolve(directory, file3);
-  const rel = path130.relative(path130.resolve(directory), resolved);
+  const resolved = path131.isAbsolute(file3) ? file3 : path131.resolve(directory, file3);
+  const rel = path131.relative(path131.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path130.join("evidence", String(phase), "sast-baseline.json");
+  return path131.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path130.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path131.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path130.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path131.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -115845,7 +116295,7 @@ function fingerprintFinding(finding, directory, occurrenceIndex) {
   }
   const lineNum = finding.location.line;
   try {
-    const content = fs93.readFileSync(finding.location.file, "utf-8");
+    const content = fs94.readFileSync(finding.location.file, "utf-8");
     const lines = content.split(`
 `);
     const idx = lineNum - 1;
@@ -115876,7 +116326,7 @@ function assignOccurrenceIndices(findings, directory) {
     try {
       if (relFile.startsWith(".."))
         throw new Error("escapes workspace");
-      const content = fs93.readFileSync(finding.location.file, "utf-8");
+      const content = fs94.readFileSync(finding.location.file, "utf-8");
       const lines = content.split(`
 `);
       const idx = lineNum - 1;
@@ -115893,7 +116343,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals57.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals58.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -115905,16 +116355,16 @@ function assignOccurrenceIndices(findings, directory) {
 async function acquireLock2(lockPath) {
   for (let attempt = 0;attempt <= LOCK_RETRY_DELAYS_MS.length; attempt++) {
     try {
-      const fd = fs93.openSync(lockPath, "wx");
-      fs93.closeSync(fd);
+      const fd = fs94.openSync(lockPath, "wx");
+      fs94.closeSync(fd);
       return () => {
         try {
-          fs93.unlinkSync(lockPath);
+          fs94.unlinkSync(lockPath);
         } catch {}
       };
     } catch {
       if (attempt < LOCK_RETRY_DELAYS_MS.length) {
-        await new Promise((resolve47) => setTimeout(resolve47, LOCK_RETRY_DELAYS_MS[attempt]));
+        await new Promise((resolve48) => setTimeout(resolve48, LOCK_RETRY_DELAYS_MS[attempt]));
       }
     }
   }
@@ -115949,20 +116399,20 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs93.mkdirSync(path130.dirname(baselinePath), { recursive: true });
-  fs93.mkdirSync(path130.dirname(tempPath), { recursive: true });
+  fs94.mkdirSync(path131.dirname(baselinePath), { recursive: true });
+  fs94.mkdirSync(path131.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
     try {
-      const raw = fs93.readFileSync(baselinePath, "utf-8");
+      const raw = fs94.readFileSync(baselinePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.schema_version === BASELINE_SCHEMA_VERSION) {
         existing = parsed;
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals57.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals58.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -116015,8 +116465,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
           message: `Baseline would exceed size cap (${json4.length} bytes > ${MAX_BASELINE_BYTES})`
         };
       }
-      fs93.writeFileSync(tempPath, json4, "utf-8");
-      fs93.renameSync(tempPath, baselinePath);
+      fs94.writeFileSync(tempPath, json4, "utf-8");
+      fs94.renameSync(tempPath, baselinePath);
       return {
         status: "merged",
         path: baselinePath,
@@ -116047,8 +116497,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
         message: `Baseline would exceed size cap (${json3.length} bytes > ${MAX_BASELINE_BYTES})`
       };
     }
-    fs93.writeFileSync(tempPath, json3, "utf-8");
-    fs93.renameSync(tempPath, baselinePath);
+    fs94.writeFileSync(tempPath, json3, "utf-8");
+    fs94.renameSync(tempPath, baselinePath);
     return {
       status: "written",
       path: baselinePath,
@@ -116073,7 +116523,7 @@ function loadBaseline(directory, phase) {
     };
   }
   try {
-    const raw = fs93.readFileSync(baselinePath, "utf-8");
+    const raw = fs94.readFileSync(baselinePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schema_version !== BASELINE_SCHEMA_VERSION) {
       return {
@@ -116102,7 +116552,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals57 = {
+var _internals58 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -116121,17 +116571,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs94.statSync(filePath);
+    const stats = fs95.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES8) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs94.openSync(filePath, "r");
+    const fd = fs95.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs94.readSync(fd, buffer, 0, 8192, 0);
-    fs94.closeSync(fd);
+    const bytesRead = fs95.readSync(fd, buffer, 0, 8192, 0);
+    fs95.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -116170,7 +116620,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs94.readFileSync(filePath, "utf-8");
+    const content = fs95.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -116223,13 +116673,13 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path131.isAbsolute(filePath) ? filePath : path131.resolve(directory, filePath);
-    const resolvedDirectory = path131.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path131.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path132.isAbsolute(filePath) ? filePath : path132.resolve(directory, filePath);
+    const resolvedDirectory = path132.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path132.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
-    if (!fs94.existsSync(resolvedPath)) {
+    if (!fs95.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -116512,11 +116962,11 @@ var sast_scan = createSwarmTool({
       capture_baseline: safeArgs.capture_baseline,
       phase: safeArgs.phase
     };
-    const result = await _internals58.sastScan(input, directory);
+    const result = await _internals59.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals58 = {
+var _internals59 = {
   sastScan,
   sast_scan
 };
@@ -116540,20 +116990,20 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path132.win32.resolve(inputPath);
-  } else if (path132.isAbsolute(inputPath)) {
-    resolved = path132.resolve(inputPath);
+    resolved = path133.win32.resolve(inputPath);
+  } else if (path133.isAbsolute(inputPath)) {
+    resolved = path133.resolve(inputPath);
   } else {
-    resolved = path132.resolve(baseDir, inputPath);
+    resolved = path133.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path132.resolve(workspaceDir);
-  let relative26;
+  const workspaceResolved = path133.resolve(workspaceDir);
+  let relative27;
   if (isWinAbs) {
-    relative26 = path132.win32.relative(workspaceResolved, resolved);
+    relative27 = path133.win32.relative(workspaceResolved, resolved);
   } else {
-    relative26 = path132.relative(workspaceResolved, resolved);
+    relative27 = path133.relative(workspaceResolved, resolved);
   }
-  if (relative26.startsWith("..")) {
+  if (relative27.startsWith("..")) {
     return "path traversal detected";
   }
   return null;
@@ -116616,7 +117066,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path132.resolve(file3);
+    const resolvedPath = path133.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -116773,7 +117223,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path132.resolve(file3);
+      const resolvedPath = path133.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -116791,14 +117241,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path132.extname(file3).toLowerCase();
+      const ext = path133.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat9;
       try {
-        stat9 = fs95.statSync(file3);
+        stat9 = fs96.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -116809,7 +117259,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs95.readFileSync(file3);
+        const buffer = fs96.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -117010,7 +117460,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path132.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path133.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -117061,7 +117511,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path132.resolve(directory, file3));
+    changedFiles.push(path133.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -117262,9 +117712,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path132.resolve(typedArgs.directory);
-    const workspaceAnchor = path132.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path132.sep)) {
+    const resolvedDirectory = path133.resolve(typedArgs.directory);
+    const workspaceAnchor = path133.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path133.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -117315,7 +117765,7 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/repo-map.ts
 init_zod();
-import * as path133 from "node:path";
+import * as path134 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -117340,7 +117790,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path133.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path134.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -117363,8 +117813,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path133.isAbsolute(normalized)) {
-    const rel = path133.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path134.isAbsolute(normalized)) {
+    const rel = path134.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -117508,8 +117958,8 @@ var repo_map = createSwarmTool({
 // src/tools/req-coverage.ts
 init_zod();
 init_create_tool();
-import * as fs96 from "node:fs";
-import * as path134 from "node:path";
+import * as fs97 from "node:fs";
+import * as path135 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS = ["MUST", "SHOULD", "SHALL"];
@@ -117568,19 +118018,19 @@ function extractObligationAndText(id, lineText) {
 var PHASE_TASK_ID_REGEX = /^\d+\.\d+(\.\d+)*$/;
 function readTouchedFiles(evidenceDir, phase, cwd) {
   const touchedFiles = new Set;
-  if (!fs96.existsSync(evidenceDir) || !fs96.statSync(evidenceDir).isDirectory()) {
+  if (!fs97.existsSync(evidenceDir) || !fs97.statSync(evidenceDir).isDirectory()) {
     return [];
   }
   let entries;
   try {
-    entries = fs96.readdirSync(evidenceDir);
+    entries = fs97.readdirSync(evidenceDir);
   } catch {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path134.join(evidenceDir, entry);
+    const entryPath = path135.join(evidenceDir, entry);
     try {
-      const stat9 = fs96.statSync(entryPath);
+      const stat9 = fs97.statSync(entryPath);
       if (!stat9.isDirectory()) {
         continue;
       }
@@ -117594,14 +118044,14 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path134.join(entryPath, "evidence.json");
+    const evidenceFilePath = path135.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path134.resolve(evidenceFilePath);
-      const evidenceDirResolved = path134.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path134.sep)) {
+      const resolvedPath = path135.resolve(evidenceFilePath);
+      const evidenceDirResolved = path135.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path135.sep)) {
         continue;
       }
-      const stat9 = fs96.lstatSync(evidenceFilePath);
+      const stat9 = fs97.lstatSync(evidenceFilePath);
       if (!stat9.isFile()) {
         continue;
       }
@@ -117613,7 +118063,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     }
     let content;
     try {
-      content = fs96.readFileSync(evidenceFilePath, "utf-8");
+      content = fs97.readFileSync(evidenceFilePath, "utf-8");
     } catch {
       continue;
     }
@@ -117632,7 +118082,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(path134.resolve(cwd, file3));
+                  touchedFiles.add(path135.resolve(cwd, file3));
                 }
               }
             }
@@ -117645,12 +118095,12 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path134.resolve(filePath);
-    const cwdResolved = path134.resolve(cwd);
+    const resolvedPath = path135.resolve(filePath);
+    const cwdResolved = path135.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
-    const content = fs96.readFileSync(resolvedPath, "utf-8");
+    const content = fs97.readFileSync(resolvedPath, "utf-8");
     for (const keyword of keywords) {
       const regex = new RegExp(`\\b${keyword}\\b`, "i");
       if (regex.test(content)) {
@@ -117780,10 +118230,10 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path134.join(cwd, SPEC_FILE);
+    const specPath = path135.join(cwd, SPEC_FILE);
     let specContent;
     try {
-      specContent = fs96.readFileSync(specPath, "utf-8");
+      specContent = fs97.readFileSync(specPath, "utf-8");
     } catch (readError) {
       return JSON.stringify({
         success: false,
@@ -117807,7 +118257,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path134.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path135.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -117833,12 +118283,12 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path134.join(evidenceDir, reportFilename);
+    const reportPath = path135.join(evidenceDir, reportFilename);
     try {
-      if (!fs96.existsSync(evidenceDir)) {
-        fs96.mkdirSync(evidenceDir, { recursive: true });
+      if (!fs97.existsSync(evidenceDir)) {
+        fs97.mkdirSync(evidenceDir, { recursive: true });
       }
-      fs96.writeFileSync(reportPath, JSON.stringify(result, null, 2), "utf-8");
+      fs97.writeFileSync(reportPath, JSON.stringify(result, null, 2), "utf-8");
     } catch (writeError) {
       console.warn(`Failed to write coverage report: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
     }
@@ -117920,8 +118370,8 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as crypto12 from "node:crypto";
-import * as fs97 from "node:fs";
-import * as path135 from "node:path";
+import * as fs98 from "node:fs";
+import * as path136 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -118002,17 +118452,17 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path135.resolve(args2.working_directory);
-    const resolvedRoot = path135.resolve(fallbackDir);
+    const resolvedTarget = path136.resolve(args2.working_directory);
+    const resolvedRoot = path136.resolve(fallbackDir);
     let fallbackExists = false;
     try {
-      fs97.accessSync(resolvedRoot, fs97.constants.F_OK);
+      fs98.accessSync(resolvedRoot, fs98.constants.F_OK);
       fallbackExists = true;
     } catch {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path135.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path136.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -118028,11 +118478,11 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path135.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path136.join(targetWorkspace, ".swarm", "spec.md");
     try {
-      const stat9 = await fs97.promises.stat(specPath);
+      const stat9 = await fs98.promises.stat(specPath);
       specMtime = stat9.mtime.toISOString();
-      const content = await fs97.promises.readFile(specPath, "utf8");
+      const content = await fs98.promises.readFile(specPath, "utf8");
       specHash = crypto12.createHash("sha256").update(content).digest("hex");
     } catch {
       return {
@@ -118044,10 +118494,10 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path135.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path136.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
-      contextContent = await fs97.promises.readFile(contextPath, "utf8");
+      contextContent = await fs98.promises.readFile(contextPath, "utf8");
     } catch {}
     const hasPendingSection = contextContent.includes("## Pending QA Gate Selection");
     if (!hasPendingSection) {
@@ -118334,14 +118784,14 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path135.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path136.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
           phases_count: plan.phases.length,
           tasks_count: tasksCount
         });
-        await fs97.promises.writeFile(markerPath, marker, "utf8");
+        await fs98.promises.writeFile(markerPath, marker, "utf8");
       } catch {}
       const warnings = [];
       let criticReviewFound = false;
@@ -118357,7 +118807,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path135.join(dir, ".swarm", "plan.json"),
+        plan_path: path136.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -118422,8 +118872,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_zod();
 init_manager2();
-import * as fs98 from "node:fs";
-import * as path136 from "node:path";
+import * as fs99 from "node:fs";
+import * as path137 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -119271,9 +119721,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs98.readdirSync(dir, { withFileTypes: true });
+      const entries = fs99.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path136.join(dir, entry.name);
+        const fullPath = path137.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -119282,7 +119732,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path136.relative(rootDir, fullPath));
+              manifestFiles.push(path137.relative(rootDir, fullPath));
               break;
             }
           }
@@ -119298,13 +119748,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs98.readdirSync(dir, { withFileTypes: true });
+      const entries = fs99.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path136.join(dir, entry.name);
+        const fullPath = path137.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path136.relative(workingDir, fullPath));
+              found.push(path137.relative(workingDir, fullPath));
               break;
             }
           }
@@ -119317,11 +119767,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path136.dirname(file3);
+    let currentDir = path137.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path136.sep) {
-        dirs.add(path136.join(workingDir, currentDir));
-        const parent = path136.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path137.sep) {
+        dirs.add(path137.join(workingDir, currentDir));
+        const parent = path137.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -119335,7 +119785,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs98.mkdirSync(outputDir, { recursive: true });
+    fs99.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -119405,7 +119855,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path136.isAbsolute(relativeOutputDir) ? relativeOutputDir : path136.join(workingDir, relativeOutputDir);
+    const outputDir = path137.isAbsolute(relativeOutputDir) ? relativeOutputDir : path137.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -119428,11 +119878,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path136.isAbsolute(manifestFile) ? manifestFile : path136.join(workingDir, manifestFile);
-        if (!fs98.existsSync(fullPath)) {
+        const fullPath = path137.isAbsolute(manifestFile) ? manifestFile : path137.join(workingDir, manifestFile);
+        if (!fs99.existsSync(fullPath)) {
           continue;
         }
-        const content = fs98.readFileSync(fullPath, "utf-8");
+        const content = fs99.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -119445,8 +119895,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path136.join(outputDir, filename);
-    fs98.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path137.join(outputDir, filename);
+    fs99.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -119488,8 +119938,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_zod();
 init_create_tool();
-import * as fs99 from "node:fs";
-import * as path137 from "node:path";
+import * as fs100 from "node:fs";
+import * as path138 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -119521,28 +119971,28 @@ function normalizePath4(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path137.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path137.sep) ? cwd : cwd + path137.sep;
+    const resolvedPath = path138.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path138.sep) ? cwd : cwd + path138.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path137.extname(resolvedPath).toLowerCase();
+    const ext = path138.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs99.statSync(resolvedPath);
+    const stats = fs100.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs99.existsSync(resolvedPath)) {
+    if (!fs100.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path137.resolve(cwd, candidate);
-    if (fs99.existsSync(candidatePath)) {
-      const stats = fs99.statSync(candidatePath);
+    const candidatePath = path138.resolve(cwd, candidate);
+    if (fs100.existsSync(candidatePath)) {
+      const stats = fs100.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -119551,8 +120001,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs99.readFileSync(specFile, "utf-8");
-  const ext = path137.extname(specFile).toLowerCase();
+  const content = fs100.readFileSync(specFile, "utf-8");
+  const ext = path138.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -119623,12 +120073,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs99.readdirSync(dir, { withFileTypes: true });
+      entries = fs100.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path137.join(dir, entry.name);
+      const fullPath = path138.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -119638,7 +120088,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path137.extname(entry.name).toLowerCase();
+        const ext = path138.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -119656,7 +120106,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs99.readFileSync(filePath, "utf-8");
+  const content = fs100.readFileSync(filePath, "utf-8");
   const lines = content.split(/\r?\n/);
   const expressRegex = /(?:app|router|server|express)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/g;
   const flaskRegex = /@(?:app|blueprint|bp)\.route\s*\(\s*['"]([^'"]+)['"]/g;
@@ -119805,8 +120255,8 @@ init_zod();
 init_bun_compat();
 init_path_security();
 init_create_tool();
-import * as fs100 from "node:fs";
-import * as path138 from "node:path";
+import * as fs101 from "node:fs";
+import * as path139 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -119842,11 +120292,11 @@ function containsWindowsAttacks3(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path138.resolve(workspace, filePath);
-    const realWorkspace = fs100.realpathSync(workspace);
-    const realResolvedPath = fs100.realpathSync(resolvedPath);
-    const relativePath = path138.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path138.isAbsolute(relativePath)) {
+    const resolvedPath = path139.resolve(workspace, filePath);
+    const realWorkspace = fs101.realpathSync(workspace);
+    const realResolvedPath = fs101.realpathSync(resolvedPath);
+    const relativePath = path139.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path139.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -119859,12 +120309,12 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path138.delimiter)) {
+  for (const dir of searchPath.split(path139.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path138.join(dir, isWindows ? "rg.exe" : "rg");
-    if (fs100.existsSync(candidate))
+    const candidate = path139.join(dir, isWindows ? "rg.exe" : "rg");
+    if (fs101.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -119918,7 +120368,7 @@ async function ripgrepSearch(opts) {
       stderr: "pipe",
       cwd: opts.workspace
     });
-    const timeout = new Promise((resolve53) => setTimeout(() => resolve53("timeout"), REGEX_TIMEOUT_MS));
+    const timeout = new Promise((resolve54) => setTimeout(() => resolve54("timeout"), REGEX_TIMEOUT_MS));
     const exitPromise = proc.exited;
     const result = await Promise.race([exitPromise, timeout]);
     if (result === "timeout") {
@@ -119991,10 +120441,10 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
     return files;
   }
   try {
-    const entries = fs100.readdirSync(dir, { withFileTypes: true });
+    const entries = fs101.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path138.join(dir, entry.name);
-      const relativePath = path138.relative(workspace, fullPath);
+      const fullPath = path139.join(dir, entry.name);
+      const relativePath = path139.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -120035,13 +120485,13 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path138.join(opts.workspace, file3);
+    const fullPath = path139.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
     let stats;
     try {
-      stats = fs100.statSync(fullPath);
+      stats = fs101.statSync(fullPath);
       if (stats.size > MAX_FILE_SIZE_BYTES10) {
         continue;
       }
@@ -120050,7 +120500,7 @@ async function fallbackSearch(opts) {
     }
     let content;
     try {
-      content = fs100.readFileSync(fullPath, "utf-8");
+      content = fs101.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -120162,7 +120612,7 @@ var search = createSwarmTool({
         message: "Exclude pattern contains invalid Windows-specific sequence"
       }, null, 2);
     }
-    if (!fs100.existsSync(directory)) {
+    if (!fs101.existsSync(directory)) {
       return JSON.stringify({
         error: true,
         type: "unknown",
@@ -120440,7 +120890,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir23, rename as rename9, writeFile as writeFile18 } from "node:fs/promises";
-import * as path139 from "node:path";
+import * as path140 from "node:path";
 var MAX_SPEC_BYTES = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -120481,14 +120931,14 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path139.join(directory, ".swarm", "spec.md");
-    await mkdir23(path139.dirname(target), { recursive: true });
+    const target = path140.join(directory, ".swarm", "spec.md");
+    await mkdir23(path140.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
       try {
-        const fs101 = await import("node:fs/promises");
-        const prior = await fs101.readFile(target, "utf-8");
+        const fs102 = await import("node:fs/promises");
+        const prior = await fs102.readFile(target, "utf-8");
         finalContent = `${prior.replace(/\s+$/, "")}
 
 ${content}
@@ -120517,7 +120967,7 @@ import {
   unlinkSync as unlinkSync18,
   writeFileSync as writeFileSync28
 } from "node:fs";
-import path140 from "node:path";
+import path141 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -120647,7 +121097,7 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path140.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path141.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
     const raw = readFileSync63(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -120709,9 +121159,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis) {
-  const evidenceDir = path140.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  const evidenceDir = path141.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
   mkdirSync35(evidenceDir, { recursive: true });
-  const evidenceFile = path140.join(evidenceDir, "phase-council.json");
+  const evidenceFile = path141.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -120933,7 +121383,7 @@ var swarm_memory_propose = createSwarmTool({
     evidenceRefs: exports_external.array(exports_external.string().min(1).max(500)).max(20).optional().describe("Evidence refs such as files, commits, test outputs, or URLs")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals59.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals60.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -120949,7 +121399,7 @@ var swarm_memory_propose = createSwarmTool({
       });
     }
     const agent = getContextAgent2(ctx);
-    const gateway = _internals59.createMemoryGateway({
+    const gateway = _internals60.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -120974,7 +121424,7 @@ var swarm_memory_propose = createSwarmTool({
     }
   }
 });
-var _internals59 = {
+var _internals60 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -121011,7 +121461,7 @@ var swarm_memory_recall = createSwarmTool({
     maxItems: exports_external.number().int().min(1).max(20).optional().describe("Maximum memories to return")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals60.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals61.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -121027,7 +121477,7 @@ var swarm_memory_recall = createSwarmTool({
       });
     }
     const agent = getContextAgent3(ctx);
-    const gateway = _internals60.createMemoryGateway({
+    const gateway = _internals61.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -121060,7 +121510,7 @@ var RecallArgsSchema = exports_external.object({
   kinds: exports_external.array(exports_external.enum(MEMORY_KINDS2)).optional(),
   maxItems: exports_external.number().int().min(1).max(20).optional()
 });
-var _internals60 = {
+var _internals61 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -121080,7 +121530,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path141 from "node:path";
+import * as path142 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -121144,7 +121594,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
       if (config3.architectural_supervision?.persist_knowledge_recommendations && args2.knowledge_recommendations.length > 0) {
         const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
         const lessons = args2.knowledge_recommendations.map((r) => r.lesson);
-        const result = await curateAndStoreSwarm(lessons, path141.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
+        const result = await curateAndStoreSwarm(lessons, path142.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
         knowledgeProposed = result.stored;
       }
     } catch {}
@@ -121175,8 +121625,8 @@ var write_architecture_supervisor_evidence = createSwarmTool({
 init_zod();
 init_path_security();
 init_create_tool();
-import * as fs101 from "node:fs";
-import * as path142 from "node:path";
+import * as fs102 from "node:fs";
+import * as path143 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
@@ -121190,14 +121640,14 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path142.resolve(workspace, filePath);
-    if (!fs101.existsSync(resolvedPath)) {
+    const resolvedPath = path143.resolve(workspace, filePath);
+    if (!fs102.existsSync(resolvedPath)) {
       return true;
     }
-    const realWorkspace = fs101.realpathSync(workspace);
-    const realResolvedPath = fs101.realpathSync(resolvedPath);
-    const relativePath = path142.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path142.isAbsolute(relativePath)) {
+    const realWorkspace = fs102.realpathSync(workspace);
+    const realResolvedPath = fs102.realpathSync(resolvedPath);
+    const relativePath = path143.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path143.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -121369,7 +121819,7 @@ var suggestPatch = createSwarmTool({
         message: "changes cannot be empty"
       }, null, 2);
     }
-    if (!fs101.existsSync(directory)) {
+    if (!fs102.existsSync(directory)) {
       return JSON.stringify({
         success: false,
         error: true,
@@ -121405,8 +121855,8 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path142.resolve(directory, change.file);
-      if (!fs101.existsSync(fullPath)) {
+      const fullPath = path143.resolve(directory, change.file);
+      if (!fs102.existsSync(fullPath)) {
         errors5.push({
           success: false,
           error: true,
@@ -121420,7 +121870,7 @@ var suggestPatch = createSwarmTool({
       }
       let content;
       try {
-        content = fs101.readFileSync(fullPath, "utf-8");
+        content = fs102.readFileSync(fullPath, "utf-8");
       } catch (err3) {
         errors5.push({
           success: false,
@@ -121708,12 +122158,12 @@ var lean_turbo_acquire_locks = createSwarmTool({
 // src/tools/lean-turbo-plan-lanes.ts
 init_zod();
 init_constants();
-import * as fs103 from "node:fs";
-import * as path144 from "node:path";
+import * as fs104 from "node:fs";
+import * as path145 from "node:path";
 
 // src/turbo/lean/conflicts.ts
-import * as fs102 from "node:fs";
-import * as path143 from "node:path";
+import * as fs103 from "node:fs";
+import * as path144 from "node:path";
 var DEFAULT_GLOBAL_FILES = [
   "package.json",
   "package-lock.json",
@@ -121840,12 +122290,12 @@ function isProtectedPath2(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path143.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path144.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
-    if (!fs102.existsSync(scopePath)) {
+    if (!fs103.existsSync(scopePath)) {
       return null;
     }
-    const raw = fs102.readFileSync(scopePath, "utf-8");
+    const raw = fs103.readFileSync(scopePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.files)) {
       return null;
@@ -122228,12 +122678,12 @@ function createEmptyPlan(phaseNumber, planId) {
 // src/tools/lean-turbo-plan-lanes.ts
 init_create_tool();
 function readPlanJson(directory) {
-  const planPath = path144.join(directory, ".swarm", "plan.json");
-  if (!fs103.existsSync(planPath)) {
+  const planPath = path145.join(directory, ".swarm", "plan.json");
+  if (!fs104.existsSync(planPath)) {
     return null;
   }
   try {
-    return JSON.parse(fs103.readFileSync(planPath, "utf-8"));
+    return JSON.parse(fs104.readFileSync(planPath, "utf-8"));
   } catch {
     return null;
   }
@@ -122282,8 +122732,8 @@ init_config();
 
 // src/turbo/lean/reviewer.ts
 init_state();
-import * as fs104 from "node:fs/promises";
-import * as path145 from "node:path";
+import * as fs105 from "node:fs/promises";
+import * as path146 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
   reviewerAgent: "",
@@ -122305,7 +122755,7 @@ function resolveDefaultReviewerAgent(generatedAgentNames) {
 }
 async function compileReviewPackage(directory, phase, sessionID, requireDiffSummary) {
   const lanes = await listLaneEvidence(directory, phase);
-  const persisted = _internals61.readPersisted?.(directory) ?? null;
+  const persisted = _internals62.readPersisted?.(directory) ?? null;
   if (persisted) {
     let matchingRunState = null;
     for (const sessionState of Object.values(persisted.sessions)) {
@@ -122399,9 +122849,9 @@ function parseReviewerVerdict(responseText) {
   return { verdict, reason };
 }
 async function writeReviewerEvidence(directory, phase, verdict, reason) {
-  const evidenceDir = path145.join(directory, ".swarm", "evidence", String(phase));
-  await fs104.mkdir(evidenceDir, { recursive: true });
-  const evidencePath = path145.join(evidenceDir, "lean-turbo-reviewer.json");
+  const evidenceDir = path146.join(directory, ".swarm", "evidence", String(phase));
+  await fs105.mkdir(evidenceDir, { recursive: true });
+  const evidencePath = path146.join(evidenceDir, "lean-turbo-reviewer.json");
   const content = JSON.stringify({
     phase,
     verdict,
@@ -122410,11 +122860,11 @@ async function writeReviewerEvidence(directory, phase, verdict, reason) {
   }, null, 2);
   const tempPath = `${evidencePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    await fs104.writeFile(tempPath, content, "utf-8");
-    await fs104.rename(tempPath, evidencePath);
+    await fs105.writeFile(tempPath, content, "utf-8");
+    await fs105.rename(tempPath, evidencePath);
   } catch (error93) {
     try {
-      await fs104.unlink(tempPath);
+      await fs105.unlink(tempPath);
     } catch {}
     throw error93;
   }
@@ -122497,7 +122947,7 @@ Be specific and evidence-based. Do not approve a phase with unresolved degraded
     client.session.delete({ path: { id: sessionId } }).catch(() => {});
   }
 }
-var _internals61 = {
+var _internals62 = {
   compileReviewPackage,
   parseReviewerVerdict,
   writeReviewerEvidence,
@@ -122514,28 +122964,28 @@ async function dispatchPhaseReviewer(directory, phase, sessionID, config3) {
   };
   const generatedAgentNames = swarmState.generatedAgentNames;
   const agentName = mergedConfig.reviewerAgent || resolveDefaultReviewerAgent(generatedAgentNames);
-  const pkg = await _internals61.compileReviewPackage(directory, phase, sessionID, mergedConfig.requireDiffSummary);
+  const pkg = await _internals62.compileReviewPackage(directory, phase, sessionID, mergedConfig.requireDiffSummary);
   let responseText;
   try {
-    responseText = await _internals61.dispatchReviewerAgent(directory, pkg, agentName, mergedConfig.timeoutMs);
+    responseText = await _internals62.dispatchReviewerAgent(directory, pkg, agentName, mergedConfig.timeoutMs);
   } catch (error93) {
-    const evidencePath2 = await _internals61.writeReviewerEvidence(directory, phase, "REJECTED", error93 instanceof Error ? error93.message : String(error93));
+    const evidencePath2 = await _internals62.writeReviewerEvidence(directory, phase, "REJECTED", error93 instanceof Error ? error93.message : String(error93));
     return {
       verdict: "REJECTED",
       reason: `Reviewer dispatch failed: ${error93 instanceof Error ? error93.message : String(error93)}`,
       evidencePath: evidencePath2
     };
   }
-  const parsed = _internals61.parseReviewerVerdict(responseText);
+  const parsed = _internals62.parseReviewerVerdict(responseText);
   if (!parsed) {
-    const evidencePath2 = await _internals61.writeReviewerEvidence(directory, phase, "REJECTED", "Reviewer response could not be parsed");
+    const evidencePath2 = await _internals62.writeReviewerEvidence(directory, phase, "REJECTED", "Reviewer response could not be parsed");
     return {
       verdict: "REJECTED",
       reason: "Reviewer response could not be parsed",
       evidencePath: evidencePath2
     };
   }
-  const evidencePath = await _internals61.writeReviewerEvidence(directory, phase, parsed.verdict, parsed.reason);
+  const evidencePath = await _internals62.writeReviewerEvidence(directory, phase, parsed.verdict, parsed.reason);
   return {
     verdict: parsed.verdict,
     reason: parsed.reason,
@@ -123041,7 +123491,7 @@ ${fileList}
 
 // src/tools/lean-turbo-run-phase.ts
 init_create_tool();
-var _internals62 = {
+var _internals63 = {
   LeanTurboRunner,
   loadPluginConfigWithMeta
 };
@@ -123051,9 +123501,9 @@ async function executeLeanTurboRunPhase(args2) {
   let runError = null;
   let runner = null;
   try {
-    const { config: config3 } = _internals62.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals63.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.strategy === "lean" ? config3.turbo.lean : undefined;
-    runner = new _internals62.LeanTurboRunner({
+    runner = new _internals63.LeanTurboRunner({
       directory,
       sessionID,
       opencodeClient: swarmState.opencodeClient ?? null,
@@ -123205,8 +123655,8 @@ var lean_turbo_status = createSwarmTool({
 // src/tools/lint-spec.ts
 init_spec_schema();
 init_create_tool();
-import * as fs105 from "node:fs";
-import * as path146 from "node:path";
+import * as fs106 from "node:fs";
+import * as path147 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -123259,8 +123709,8 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path146.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
-    if (!fs105.existsSync(specPath)) {
+    const specPath = path147.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    if (!fs106.existsSync(specPath)) {
       const result2 = {
         valid: false,
         specMtime: null,
@@ -123279,12 +123729,12 @@ var lint_spec = createSwarmTool({
     }
     let specMtime = null;
     try {
-      const stats = fs105.statSync(specPath);
+      const stats = fs106.statSync(specPath);
       specMtime = stats.mtime.toISOString();
     } catch {}
     let content;
     try {
-      content = fs105.readFileSync(specPath, "utf-8");
+      content = fs106.readFileSync(specPath, "utf-8");
     } catch (e) {
       const result2 = {
         valid: false,
@@ -123329,13 +123779,13 @@ var lint_spec = createSwarmTool({
 });
 // src/tools/mutation-test.ts
 init_zod();
-import * as fs106 from "node:fs";
-import * as path148 from "node:path";
+import * as fs107 from "node:fs";
+import * as path149 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
 import { unlinkSync as unlinkSync19, writeFileSync as writeFileSync29 } from "node:fs";
-import * as path147 from "node:path";
+import * as path148 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -123407,7 +123857,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals63 = {
+var _internals64 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -123447,7 +123897,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals63.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals64.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err3) {
       results.push({
@@ -123466,7 +123916,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
 var MUTATION_TIMEOUT_MS = 30000;
 var TOTAL_BUDGET_MS = 300000;
 var GIT_APPLY_TIMEOUT_MS = 5000;
-var _internals64 = {
+var _internals65 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -123481,7 +123931,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path147.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path148.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync29(patchFile, patch.patch);
     } catch (writeErr) {
@@ -123498,7 +123948,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
       };
     }
     try {
-      const applyResult = _internals64.spawnSync("git", ["apply", "--", patchFile], {
+      const applyResult = _internals65.spawnSync("git", ["apply", "--", patchFile], {
         cwd: workingDir,
         timeout: GIT_APPLY_TIMEOUT_MS,
         stdio: "pipe"
@@ -123527,7 +123977,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
     }
     let testPassed = false;
     try {
-      const spawnResult = _internals64.spawnSync(testCommand[0], testCommand.slice(1), {
+      const spawnResult = _internals65.spawnSync(testCommand[0], testCommand.slice(1), {
         cwd: workingDir,
         timeout: MUTATION_TIMEOUT_MS,
         stdio: "pipe"
@@ -123560,7 +124010,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   } finally {
     if (patchFile) {
       try {
-        const revertResult = _internals64.spawnSync("git", ["apply", "-R", "--", patchFile], {
+        const revertResult = _internals65.spawnSync("git", ["apply", "-R", "--", patchFile], {
           cwd: workingDir,
           timeout: GIT_APPLY_TIMEOUT_MS,
           stdio: "pipe"
@@ -123753,7 +124203,7 @@ async function executeMutationSuite(patches, testCommand, testFiles, workingDir,
 }
 
 // src/mutation/gate.ts
-var _internals65 = {
+var _internals66 = {
   evaluateMutationGate,
   buildTestImprovementPrompt,
   buildMessage
@@ -123774,8 +124224,8 @@ function evaluateMutationGate(report, passThreshold = PASS_THRESHOLD, warnThresh
   } else {
     verdict = "fail";
   }
-  const testImprovementPrompt = _internals65.buildTestImprovementPrompt(report, passThreshold, verdict);
-  const message = _internals65.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
+  const testImprovementPrompt = _internals66.buildTestImprovementPrompt(report, passThreshold, verdict);
+  const message = _internals66.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
   return {
     verdict,
     killRate: report.killRate,
@@ -123885,8 +124335,8 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path148.resolve(cwd, filePath);
-          sourceFiles.set(filePath, fs106.readFileSync(resolvedPath, "utf-8"));
+          const resolvedPath = path149.resolve(cwd, filePath);
+          sourceFiles.set(filePath, fs107.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
       const report = await executeMutationSuite(typedArgs.patches, typedArgs.test_command, typedArgs.files, cwd, undefined, undefined, sourceFiles.size > 0 ? sourceFiles : undefined);
@@ -123904,8 +124354,8 @@ var mutation_test = createSwarmTool({
 init_zod();
 init_manager2();
 init_detector();
-import * as fs107 from "node:fs";
-import * as path149 from "node:path";
+import * as fs108 from "node:fs";
+import * as path150 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -123971,7 +124421,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path149.extname(file3.path).toLowerCase();
+      const ext = path150.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -123984,7 +124434,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path149.isAbsolute(filePath) ? filePath : path149.join(directory, filePath);
+    const fullPath = path150.isAbsolute(filePath) ? filePath : path150.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -124014,7 +124464,7 @@ async function syntaxCheck(input, directory, config3) {
       }
       let content;
       try {
-        content = fs107.readFileSync(fullPath, "utf8");
+        content = fs108.readFileSync(fullPath, "utf8");
       } catch {
         result.skipped_reason = "file_read_error";
         skippedCount++;
@@ -124033,7 +124483,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path149.extname(filePath).toLowerCase();
+      const ext = path150.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -124130,8 +124580,8 @@ init_zod();
 init_utils();
 init_create_tool();
 init_path_security();
-import * as fs108 from "node:fs";
-import * as path150 from "node:path";
+import * as fs109 from "node:fs";
+import * as path151 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -124197,9 +124647,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path150.resolve(paths);
-    const normalizedCwd = path150.resolve(cwd);
-    const normalizedResolved = path150.resolve(resolvedPath);
+    const resolvedPath = path151.resolve(paths);
+    const normalizedCwd = path151.resolve(cwd);
+    const normalizedResolved = path151.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -124215,13 +124665,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path150.extname(filePath).toLowerCase();
+  const ext = path151.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
   let entries;
   try {
-    entries = fs108.readdirSync(dir);
+    entries = fs109.readdirSync(dir);
   } catch {
     return files;
   }
@@ -124230,10 +124680,10 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path150.join(dir, entry);
+    const fullPath = path151.join(dir, entry);
     let stat9;
     try {
-      stat9 = fs108.statSync(fullPath);
+      stat9 = fs109.statSync(fullPath);
     } catch {
       continue;
     }
@@ -124326,7 +124776,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs108.existsSync(scanPath)) {
+    if (!fs109.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -124336,13 +124786,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat9 = fs108.statSync(scanPath);
+    const stat9 = fs109.statSync(scanPath);
     if (stat9.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path150.extname(scanPath)}`,
+          error: `unsupported file extension: ${path151.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -124355,11 +124805,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs108.statSync(filePath);
+        const fileStat = fs109.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES11) {
           continue;
         }
-        const content = fs108.readFileSync(filePath, "utf-8");
+        const content = fs109.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -124390,19 +124840,19 @@ init_loader();
 init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
-import * as fs112 from "node:fs";
-import * as path154 from "node:path";
+import * as fs113 from "node:fs";
+import * as path155 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
-import * as fs110 from "node:fs";
-import * as path152 from "node:path";
+import * as fs111 from "node:fs";
+import * as path153 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
-import * as fs109 from "node:fs";
-import * as path151 from "node:path";
-var _internals66 = { bunSpawn };
+import * as fs110 from "node:fs";
+import * as path152 from "node:path";
+var _internals67 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
   for (const rawLine of content.split(`
@@ -124435,7 +124885,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
       checkIgnoreExitCode
     ] = await Promise.all([
       (async () => {
-        const proc = _internals66.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+        const proc = _internals67.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -124445,7 +124895,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals66.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+        const proc = _internals67.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -124455,7 +124905,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals66.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+        const proc = _internals67.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
         try {
           return await proc.exited;
         } finally {
@@ -124475,16 +124925,16 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path151.isAbsolute(excludeRelPath) ? excludeRelPath : path151.join(directory, excludeRelPath);
+    const excludePath = path152.isAbsolute(excludeRelPath) ? excludeRelPath : path152.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs109.mkdirSync(path151.dirname(excludePath), { recursive: true });
+        fs110.mkdirSync(path152.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
-          existing = fs109.readFileSync(excludePath, "utf8");
+          existing = fs110.readFileSync(excludePath, "utf8");
         } catch {}
         if (!fileCoversSwarm(existing)) {
-          fs109.appendFileSync(excludePath, `
+          fs110.appendFileSync(excludePath, `
 # opencode-swarm local runtime state
 .swarm/
 `, "utf8");
@@ -124494,7 +124944,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       } catch {}
     }
-    const trackedProc = _internals66.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    const trackedProc = _internals67.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
     let trackedExitCode;
     let trackedOutput;
     try {
@@ -124519,13 +124969,13 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 }
 
 // src/hooks/diff-scope.ts
-var _internals67 = { bunSpawn };
+var _internals68 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path152.join(directory, ".swarm", "plan.json");
-    if (!fs110.existsSync(planPath))
+    const planPath = path153.join(directory, ".swarm", "plan.json");
+    if (!fs111.existsSync(planPath))
       return null;
-    const raw = fs110.readFileSync(planPath, "utf-8");
+    const raw = fs111.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -124554,7 +125004,7 @@ var GIT_DIFF_SPAWN_OPTIONS = {
 };
 async function getChangedFiles(directory) {
   try {
-    const proc = _internals67.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals68.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -124571,7 +125021,7 @@ async function getChangedFiles(directory) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = _internals67.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals68.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -124627,9 +125077,9 @@ init_telemetry();
 
 // src/turbo/lean/task-completion.ts
 init_file_locks();
-import * as fs111 from "node:fs";
-import * as path153 from "node:path";
-var _internals68 = {
+import * as fs112 from "node:fs";
+import * as path154 from "node:path";
+var _internals69 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
 };
@@ -124647,7 +125097,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path153.basename(file3);
+    const fileName = path154.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -124659,14 +125109,14 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path153.join(directory, ".swarm", "turbo-state.json");
-    if (!fs111.existsSync(statePath)) {
+    const statePath = path154.join(directory, ".swarm", "turbo-state.json");
+    if (!fs112.existsSync(statePath)) {
       return {
         ok: false,
         reason: "Lean Turbo state file not found"
       };
     }
-    const raw = fs111.readFileSync(statePath, "utf-8");
+    const raw = fs112.readFileSync(statePath, "utf-8");
     persisted = JSON.parse(raw);
   } catch {
     return {
@@ -124743,11 +125193,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path153.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path153.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path153.resolve(evidencePath);
-  const resolvedDir = path153.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path153.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path154.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path154.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path154.resolve(evidencePath);
+  const resolvedDir = path154.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path154.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -124759,7 +125209,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  if (!fs111.existsSync(evidencePath)) {
+  if (!fs112.existsSync(evidencePath)) {
     return {
       ok: false,
       reason: `Lane ${lane.laneId} evidence file not found: ${evidencePath}`,
@@ -124771,7 +125221,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  const activeLocks = _internals68.listActiveLocks(directory);
+  const activeLocks = _internals69.listActiveLocks(directory);
   const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
   if (laneLocks.length > 0) {
     return {
@@ -124787,8 +125237,8 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path153.join(directory, ".swarm", "plan.json");
-    const planRaw = fs111.readFileSync(planPath, "utf-8");
+    const planPath = path154.join(directory, ".swarm", "plan.json");
+    const planRaw = fs112.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
       for (const task of planPhase.tasks ?? []) {
@@ -124871,7 +125321,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path154.basename(file3);
+    const fileName = path155.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -124910,8 +125360,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path154.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs112.readFileSync(planPath, "utf-8");
+        const planPath = path155.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs113.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -124988,8 +125438,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path154.join(resolvedDir, ".swarm", "plan.json");
-        const planRaw = fs112.readFileSync(planPath, "utf-8");
+        const planPath = path155.join(resolvedDir, ".swarm", "plan.json");
+        const planRaw = fs113.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -125225,8 +125675,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
         };
       }
     }
-    normalizedDir = path154.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path154.sep);
+    normalizedDir = path155.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path155.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -125236,11 +125686,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
         ]
       };
     }
-    const resolvedDir = path154.resolve(normalizedDir);
+    const resolvedDir = path155.resolve(normalizedDir);
     try {
-      const realPath = fs112.realpathSync(resolvedDir);
-      const planPath = path154.join(realPath, ".swarm", "plan.json");
-      if (!fs112.existsSync(planPath)) {
+      const realPath = fs113.realpathSync(resolvedDir);
+      const planPath = path155.join(realPath, ".swarm", "plan.json");
+      if (!fs113.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -125270,9 +125720,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     directory = fallbackDir;
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs112.realpathSync(path154.resolve(directory));
-    const canonicalRoot = fs112.realpathSync(path154.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path154.sep)) {
+    const canonicalDir = fs113.realpathSync(path155.resolve(directory));
+    const canonicalRoot = fs113.realpathSync(path155.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path155.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -125284,22 +125734,22 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path154.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs112.mkdirSync(path154.dirname(evidencePath), { recursive: true });
-      const fd = fs112.openSync(evidencePath, "wx");
+      const evidencePath = path155.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs113.mkdirSync(path155.dirname(evidencePath), { recursive: true });
+      const fd = fs113.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
-        fs112.writeSync(fd, JSON.stringify({
+        fs113.writeSync(fd, JSON.stringify({
           taskId: args2.task_id,
           required_gates: [],
           gates: {}
         }, null, 2));
         writeOk = true;
       } finally {
-        fs112.closeSync(fd);
+        fs113.closeSync(fd);
         if (!writeOk) {
           try {
-            fs112.unlinkSync(evidencePath);
+            fs113.unlinkSync(evidencePath);
           } catch {}
         }
       }
@@ -125309,8 +125759,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path154.join(directory, ".swarm", "plan.json");
-      const planRaw = fs112.readFileSync(planPath, "utf-8");
+      const planPath = path155.join(directory, ".swarm", "plan.json");
+      const planRaw = fs113.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
       if (taskPhase?.required_agents && !taskPhase.required_agents.includes("reviewer")) {
@@ -125537,7 +125987,7 @@ init_utils2();
 init_redaction();
 import { createHash as createHash12 } from "node:crypto";
 import { appendFile as appendFile14, mkdir as mkdir25 } from "node:fs/promises";
-import * as path155 from "node:path";
+import * as path156 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
 async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
@@ -125545,7 +125995,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir25(path155.dirname(filePath), { recursive: true });
+    await mkdir25(path156.dirname(filePath), { recursive: true });
     await appendFile14(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -125700,7 +126150,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals69.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals70.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -125728,7 +126178,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals69 = {
+var _internals70 = {
   writeEvidenceDocuments
 };
 // src/tools/write-drift-evidence.ts
@@ -125738,8 +126188,8 @@ init_utils2();
 init_ledger();
 init_manager();
 init_create_tool();
-import fs113 from "node:fs";
-import path156 from "node:path";
+import fs114 from "node:fs";
+import path157 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -125787,7 +126237,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path156.join("evidence", String(phase), filename);
+  const relativePath = path157.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -125798,12 +126248,12 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path156.dirname(validatedPath);
+  const evidenceDir = path157.dirname(validatedPath);
   try {
-    await fs113.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path156.join(evidenceDir, `.${filename}.tmp`);
-    await fs113.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs113.promises.rename(tempPath, validatedPath);
+    await fs114.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path157.join(evidenceDir, `.${filename}.tmp`);
+    await fs114.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs114.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
     let snapshotError;
     let qaProfileLocked;
@@ -125896,8 +126346,8 @@ var write_drift_evidence = createSwarmTool({
 // src/tools/write-final-council-evidence.ts
 init_zod();
 init_loader();
-import fs114 from "node:fs";
-import path157 from "node:path";
+import fs115 from "node:fs";
+import path158 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -125985,7 +126435,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path157.join("evidence", filename);
+  const relativePath = path158.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -125999,12 +126449,12 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path157.dirname(validatedPath);
+  const evidenceDir = path158.dirname(validatedPath);
   try {
-    await fs114.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path157.join(evidenceDir, `.${filename}.tmp`);
-    await fs114.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs114.promises.rename(tempPath, validatedPath);
+    await fs115.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path158.join(evidenceDir, `.${filename}.tmp`);
+    await fs115.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs115.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase: input.phase,
@@ -126060,8 +126510,8 @@ var write_final_council_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs115 from "node:fs";
-import path158 from "node:path";
+import fs116 from "node:fs";
+import path159 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -126109,7 +126559,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path158.join("evidence", String(phase), filename);
+  const relativePath = path159.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126120,12 +126570,12 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path158.dirname(validatedPath);
+  const evidenceDir = path159.dirname(validatedPath);
   try {
-    await fs115.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path158.join(evidenceDir, `.${filename}.tmp`);
-    await fs115.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs115.promises.rename(tempPath, validatedPath);
+    await fs116.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path159.join(evidenceDir, `.${filename}.tmp`);
+    await fs116.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs116.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -126171,8 +126621,8 @@ var write_hallucination_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs116 from "node:fs";
-import path159 from "node:path";
+import fs117 from "node:fs";
+import path160 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -126246,7 +126696,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path159.join("evidence", String(phase), filename);
+  const relativePath = path160.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -126257,12 +126707,12 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path159.dirname(validatedPath);
+  const evidenceDir = path160.dirname(validatedPath);
   try {
-    await fs116.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path159.join(evidenceDir, `.${filename}.tmp`);
-    await fs116.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs116.promises.rename(tempPath, validatedPath);
+    await fs117.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path160.join(evidenceDir, `.${filename}.tmp`);
+    await fs117.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs117.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -126610,7 +127060,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 = path161.resolve(ctx.directory, ".swarm");
+    const swarmDir = path162.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -127207,7 +127657,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path161.basename(path161.dirname(s.skillPath));
+                    desc = path162.basename(path162.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -127217,7 +127667,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path161.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path162.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {