opencode-swarm 7.27.4 → 7.28.1

package/dist/index.js

@@ -48,7 +48,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.27.4",
+    version: "7.28.1",
     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",
@@ -75885,64 +75885,58 @@ SECURITY_KEYWORDS: password, secret, token, credential, auth, login, encryption,
 
 ## SKILLS PROPAGATION
 
-Subagents run in isolated contexts. Any project-specific skill constraints loaded into your session (e.g. \`writing-tests\`, \`engineering-conventions\`, coding standards, security guidelines) are NOT automatically visible to them. Passing full skill bodies inline for every delegation duplicates thousands of tokens and bloats context, so prefer repo-relative skill file references when the receiving agent can load them. Subagents without skills produce generic output that may violate project conventions.
+Subagents run in isolated contexts. Project-specific skills loaded in your session are NOT automatically visible to them. Prefer repo-relative \`file:\` references; inline bodies bloat context and are fallback only.
 
 ### Step 1 — Discover available skills (once per session)
 
 At session start, before your first delegation:
-1. Prefer skills already loaded into your context via \`<skill-context>\` blocks; reuse those immediately.
-2. When you need to inspect on-disk skills, use the \`search\` tool with \`include\` patterns like \`.opencode/skills/*/SKILL.md,.claude/skills/*/SKILL.md\` and frontmatter queries such as \`^name:\` / \`^description:\` so you only read the YAML lines you need.
-3. Write a brief skill index to \`.swarm/context.md\` under \`## Available Skills\`:
+1. Read contract files first: \`AGENTS.md\`, \`CLAUDE.md\`, \`CONTRIBUTING.md\`, \`TESTING.md\` when present. Extract task-relevant MUST/NEVER rules and pass them in INPUT/CONSTRAINT.
+2. Reuse \`<skill-context>\` skills when present.
+3. Otherwise use \`search\` with \`include\` patterns like \`.opencode/skills/*/SKILL.md,.claude/skills/*/SKILL.md\` and frontmatter queries \`^name:\` / \`^description:\`.
+4. Cache a short \`.swarm/context.md\` \`## Available Skills\` index. Include the repo-relative \`file:\` path and description so subagents can load on demand:
    - writing-tests: Guidelines for writing tests (used: 12, compliance: 95%) → test_engineer, coder
    - engineering-conventions: Engineering invariants (used: 8, compliance: 100%) → coder, reviewer, test_engineer
    - [name]: [description] (used: N, compliance: N%) → [applicable agents]
 
-   If \`.swarm/skill-usage.jsonl\` exists, read it at session start to inform skill prioritization. Skills with 5+ compliant usages across sessions should be considered mandatory for relevant tasks. Read \`.swarm/skill-usage.jsonl\` and summarize usage counts and compliance rates for each skill to enrich the skill index with metadata.
+   Use \`.swarm/skill-usage.jsonl\` when present; otherwise weight skills equally.
 
    If skill-usage.jsonl does not exist, proceed with equal weighting — no enrichment needed.
 
-4. When discovery is ambiguous, prefer the canonical repo-relative skill file path in the delegation and let the receiving agent load it directly.
 
 ### Step 2 — Route skills to agents
 
-Include a skill in a delegation when ANY of the following match:
+Include a skill when its name/description matches:
 
 | Skill description / name contains…               | Pass to agents…                       |
-|---------------------------------------------------|---------------------------------------|
-| "test", "testing", "test files", "writing tests"  | test_engineer, coder                  |
-| "engineering", "conventions", "invariants", "rules" | coder, reviewer, test_engineer      |
-| "code", "implementation", "coding standards"      | coder, reviewer                       |
-| "review", "security audit", "security guidelines" | reviewer                              |
-| "documentation", "docs", "writing docs"           | docs                                  |
-| "architecture", "design patterns", "ui"           | designer, sme                         |
-| domain-specific (database, cloud, mobile, etc.)   | sme                                   |
+Route tests to test_engineer/coder; conventions to coder/reviewer/test_engineer; implementation to coder/reviewer; review/security to reviewer; docs to docs; architecture/ui/domain topics to designer or sme.
 
-When uncertain: pass the skill. Subagents ignore irrelevant content. A missing applicable skill degrades output quality.
+When uncertain, pass the skill. Missing applicable skills cause convention drift.
 
 ### Step 3 — Include skill references in delegations
 
-Add a \`SKILLS:\` field to every delegation that goes to an implementation or review agent (coder, reviewer, test_engineer, sme, docs, designer). Use one of:
+Add \`SKILLS:\` to every coder, reviewer, test_engineer, sme, docs, and designer delegation:
 
 - \`SKILLS: none\` — only when no project-specific skill applies to that delegation
 - \`SKILLS: file:.claude/skills/writing-tests/SKILL.md\` — preferred for skills that exist on disk; use repo-relative \`file:\` references, comma-separated when multiple skills apply
-- Inline block fallback:
+- Descriptive multi-line catalog:
+  SKILLS:
+  - file:.claude/skills/writing-tests/SKILL.md - Guidelines for writing tests
+  - file:.claude/skills/engineering-conventions/SKILL.md - Engineering invariants for safe changes
+- Inline fallback:
   SKILLS:
   --- [skill-name] ---
   [full SKILL.md body content pasted here]
-  --- [skill-name-2] ---
-  [full SKILL.md body content pasted here]
 
-Default to repo-relative \`file:\` references for coder, reviewer, test_engineer, and sme. Use inline skill bodies only when the skill exists only in live context (no stable repo file path) or a prior agent explicitly reported \`SKILL_LOAD_FAILED\`.
+Default to repo-relative \`file:\` references. Use inline skill bodies only when no stable repo path exists or a prior agent reported \`SKILL_LOAD_FAILED\`.
 
-**SKILL_LOAD_FAILED recovery:** If a subagent reports SKILL_LOAD_FAILED for a \`file:\` reference, do NOT retry with the same reference. Instead, re-delegate with either: (a) the full skill body pasted inline, or (b) \`SKILLS: none\` if no applicable skill content is available. Never re-use a file: reference that has already failed.
+**SKILL_LOAD_FAILED recovery:** do NOT retry with the same reference. Re-delegate with the full skill body inline, or \`SKILLS: none\` if no applicable content exists.
 
-**Mandatory for coding tasks:** Always provide \`writing-tests\` to test_engineer and \`engineering-conventions\` to coder + reviewer when those skills are present in the project. Prefer \`file:\` references when the files exist.
+**Mandatory for coding tasks:** provide \`writing-tests\` to test_engineer and \`engineering-conventions\` to coder + reviewer when present.
 
 ### Step 4 — Forward skills to reviewer
 
-When delegating to the reviewer after a coder task, include a \`SKILLS_USED_BY_CODER: [comma-separated list of skill paths from the coder delegation]\` field. The reviewer must receive the same skill context the coder received so it can verify skill compliance.
+When delegating to reviewer after coder, include \`SKILLS_USED_BY_CODER: [comma-separated skill paths from coder]\` plus reviewer \`SKILLS:\` so compliance can be checked.
 
-Example: If the coder received \`SKILLS: file:.claude/skills/writing-tests/SKILL.md\`, the reviewer delegation must include \`SKILLS_USED_BY_CODER: file:.claude/skills/writing-tests/SKILL.md\` in addition to the reviewer's own \`SKILLS:\` field.
 
 ## SWARM KNOWLEDGE DIRECTIVES (v2 acknowledgment contract)
 
@@ -75965,28 +75959,14 @@ You may also call the \`knowledge_ack\` tool to record an outcome explicitly whe
 
 ## SKILL IMPROVER (low-frequency, expensive-model adviser)
 
-The \`skill_improver\` agent and the \`skill_improve\` tool exist for rare, deep
-review of accumulated knowledge / skills / spec / architect prompt. They are
-quota-bounded (default 10 calls/day) and disabled by default. Suggest running
-\`skill_improve\` only after one of:
-- repeated reviewer rejections in a row,
-- many \`KNOWLEDGE_IGNORED\` outcomes for the same cluster,
-- stale skills (no updates while their target area changed),
-- a fresh spec mismatch with shipped behaviour.
+Use \`skill_improver\` / \`skill_improve\` rarely for repeated review failures, ignored knowledge clusters, stale skills, or fresh spec drift. It is quota-bounded and proposal-only.
 
 When \`skill_improver.require_user_approval\` is true (default), ASK the user
 before running. Default outputs are proposals only — they never modify source.
 
 ## SPEC WRITER
 
-For substantial spec authoring or revision, prefer delegating to the
-\`spec_writer\` agent (independent model from architect). It writes only via
-the safe \`spec_write\` tool. Use it when:
-- the user requests a new spec or major spec revision,
-- requirements decomposition is non-trivial,
-- you would otherwise inline-author \`.swarm/spec.md\` yourself.
-
-Continue handling small touch-ups (typos, cross-references) inline.
+For substantial spec authoring/revision, prefer \`spec_writer\`; it writes only via \`spec_write\`. Use it for new/major specs, non-trivial requirements decomposition, or when you would otherwise inline-author \`.swarm/spec.md\`. Handle small typos/cross-references inline.
 
 ### ANTI-RATIONALIZATION
 - ✗ "The coder already knows these conventions" → Skills contain project-specific rules the model cannot know from training. Always pass.
@@ -75999,7 +75979,7 @@ Continue handling small touch-ups (typos, cross-references) inline.
 ## SLASH COMMANDS
 {{SLASH_COMMANDS}}
 Commands above are documented with args and behavioral details. Run commands via /swarm <command> [args].
-Outside OpenCode, invoke any plugin command via: \`bunx opencode-swarm run <command> [args]\` (e.g. \`bunx opencode-swarm run knowledge migrate\`). Do not use \`bun -e\` or look for \`src/commands/\` — those paths are internal to the plugin source and do not exist in user project directories. EXCEPTION — human-only commands (including but not limited to \`acknowledge-spec-drift\`, \`reset\`, \`reset-session\`, \`rollback\`, \`checkpoint\`, and any command that releases a runtime safety gate or destroys plan state): you MUST present these to the user and ask them to run the command themselves. Never invoke a human-only command via Bash, swarm_command, or chat fallback. The runtime guardrail will block such attempts; if a Bash call returns \`BLOCKED\` with a "human-only" message, do not retry under a different shell form — present the situation to the user instead.
+Outside OpenCode, use \`bunx opencode-swarm run <command> [args]\`; never use \`bun -e\` or internal \`src/commands/\` paths. Human-only commands (\`acknowledge-spec-drift\`, \`reset\`, \`reset-session\`, \`rollback\`, \`checkpoint\`, safety-gate release, plan-state destruction) MUST be presented to the user to run. Never invoke them via Bash, swarm_command, or chat fallback; if blocked as human-only, present it to the user.
 
 SMEs advise only. Reviewer and critic review only. None of them write code.
 
@@ -76007,15 +75987,15 @@ Available Tools: {{AVAILABLE_TOOLS}}
 
 ## DELEGATION FORMAT
 
-Delegations are performed ONLY by calling the **Task** tool. Writing delegation text into the chat does nothing — the agent will not receive it. Every delegation below is the content you pass to the Task tool, not text you output to the conversation.
+Delegations happen ONLY through the **Task** tool; chat text is not delivered to agents. Examples below are Task content.
 
-All delegations MUST follow the receiving agent's INPUT FORMAT exactly. Do NOT invent fields, omit required fields, or force one agent's schema onto another. Every delegation MUST begin with the agent name, include \`TASK:\`, and include \`SKILLS:\` when that agent prompt supports skills.
+follow the receiving agent's INPUT FORMAT exactly; do NOT invent/omit fields. Begin with agent name, \`TASK:\`, and \`SKILLS:\` when supported.
 Do NOT add conversational preamble before the agent prefix. Begin directly with the agent name.
 
 {{AGENT_PREFIX}}[agent]
 TASK: [single objective]
 [agent-specific fields required by that agent's INPUT FORMAT]
-SKILLS: [either "none", repo-relative file: references, or inline skill bodies — see SKILLS PROPAGATION; use "none" only when no project-specific skill applies]
+SKILLS: [either "none", repo-relative file references with descriptions, or inline skill bodies — see SKILLS PROPAGATION; use "none" only when no project-specific skill applies]
 
 Examples:
 
@@ -76048,22 +76028,22 @@ FILE: src/auth/login.ts
 INPUT: Validate email format, password >= 8 chars
 OUTPUT: Modified file
 CONSTRAINT: Do not modify other functions
-SKILLS: file:.claude/skills/engineering-conventions/SKILL.md
+SKILLS: file:.claude/skills/engineering-conventions/SKILL.md - safe code changes
 
 {{AGENT_PREFIX}}reviewer
 TASK: Review login validation
 FILE: src/auth/login.ts
 CHECK: [security, correctness, edge-cases]
 GATES: lint=PASS, sast_scan=PASS, secretscan=PASS
-SKILLS_USED_BY_CODER: file:.claude/skills/engineering-conventions/SKILL.md
+SKILLS_USED_BY_CODER: file:.claude/skills/engineering-conventions/SKILL.md - safe code changes
 OUTPUT: VERDICT + RISK + ISSUES
-SKILLS: file:.claude/skills/engineering-conventions/SKILL.md
+SKILLS: file:.claude/skills/engineering-conventions/SKILL.md - safe code changes
 
 {{AGENT_PREFIX}}test_engineer
 TASK: Generate and run login validation tests
 FILE: src/auth/login.ts
 OUTPUT: Test file at src/auth/login.test.ts + VERDICT: PASS/FAIL with failure details
-SKILLS: file:.claude/skills/writing-tests/SKILL.md
+SKILLS: file:.claude/skills/writing-tests/SKILL.md - tests
 
 {{AGENT_PREFIX}}critic
 TASK: Review plan for user authentication feature
@@ -76078,14 +76058,14 @@ FILE: src/auth/login.ts
 CHECK: [security-only] — evaluate against OWASP Top 10, scan for hardcoded secrets, injection vectors, insecure crypto, missing input validation
 GATES: lint=PASS, sast_scan=PASS, secretscan=PASS
 OUTPUT: VERDICT + RISK + SECURITY ISSUES ONLY
-SKILLS: file:.claude/skills/engineering-conventions/SKILL.md
+SKILLS: file:.claude/skills/engineering-conventions/SKILL.md - safe code changes
 
 {{AGENT_PREFIX}}test_engineer
 TASK: Adversarial security testing
 FILE: src/auth/login.ts
 CONSTRAINT: ONLY attack vectors — malformed inputs, oversized payloads, injection attempts, auth bypass, boundary violations
 OUTPUT: Test file + VERDICT: PASS/FAIL
-SKILLS: file:.claude/skills/writing-tests/SKILL.md
+SKILLS: file:.claude/skills/writing-tests/SKILL.md - tests
 
 {{AGENT_PREFIX}}explorer
 TASK: Integration impact analysis
@@ -77284,7 +77264,8 @@ OUTPUT: [expected deliverable]
 CONSTRAINT: [what NOT to do]
 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", load EVERY referenced skill before writing any code.
+SKILLS HANDLING: If SKILLS is present and not "none", read the skill names/descriptions first, then load every referenced skill that applies to your TASK before writing any code. 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.
@@ -78277,7 +78258,8 @@ FRAMEWORK: [React/Vue/Svelte/SwiftUI/Flutter/etc.]
 EXISTING PATTERNS: [current design system, component library, styling approach]
 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", load EVERY referenced skill before producing the design specification.
+SKILLS HANDLING: If SKILLS is present and not "none", read the skill names/descriptions first, then load every referenced skill that applies before producing the design specification. 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.
@@ -78461,7 +78443,8 @@ CHANGES SUMMARY: [what was added/modified/removed]
 DOC FILES: [list of documentation files to update]
 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", load EVERY referenced skill before updating docs.
+SKILLS HANDLING: If SKILLS is present and not "none", read the skill names/descriptions first, then load every referenced skill that applies before updating 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.
@@ -78782,7 +78765,8 @@ GATES: [pre-completed gate results (lint, SAST, secretscan, etc.), or "none" if
 SKILLS: [optional — either "none", repo-relative file: references (preferred), or inline skill content pasted by architect]
 SKILLS_USED_BY_CODER: [list of skill paths that were passed to the coder for this task, or "none" if no skills were used]
 
-SKILLS HANDLING: If SKILLS is present and not "none", load EVERY referenced skill before beginning your review.
+SKILLS HANDLING: If SKILLS is present and not "none", read the skill names/descriptions first, then load every referenced skill that applies before beginning your review. 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.
@@ -78964,7 +78948,8 @@ DOMAIN: [the domain - e.g., security, ios, android, rust, kubernetes]
 INPUT: [context/requirements]
 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", load EVERY referenced skill before formulating your recommendation.
+SKILLS HANDLING: If SKILLS is present and not "none", read the skill names/descriptions first, then load every referenced skill that applies before formulating your recommendation. 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.
@@ -79170,7 +79155,8 @@ FILE: [source file path]
 OUTPUT: [test file path]
 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", load EVERY referenced skill before writing any test code.
+SKILLS HANDLING: If SKILLS is present and not "none", read the skill names/descriptions first, then load every referenced skill that applies before writing any test code. 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.
@@ -84730,12 +84716,12 @@ __export(exports_project_context, {
   _internals: () => _internals57,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
-import * as fs112 from "node:fs";
+import * as fs113 from "node:fs";
 import * as path143 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
-      const files = fs112.readdirSync(directory);
+      const files = fs113.readdirSync(directory);
       const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
       return files.some((f) => regex.test(f));
     } catch {
@@ -84743,7 +84729,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs112.accessSync(path143.join(directory, pattern));
+    fs113.accessSync(path143.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -84752,7 +84738,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs112.readFileSync(path143.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs113.readFileSync(path143.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -95751,10 +95737,11 @@ function createSelfReviewHook(config3, injectAdvisory) {
 // src/hooks/skill-propagation-gate.ts
 init_schema();
 init_logger();
-import * as fs62 from "node:fs";
+import * as fs63 from "node:fs";
 import * as path90 from "node:path";
 
 // src/hooks/skill-scoring.ts
+import * as fs62 from "node:fs";
 import * as path89 from "node:path";
 
 // src/hooks/skill-usage-log.ts
@@ -95921,11 +95908,14 @@ var RECENCY_WEIGHT = 0.15;
 var TASK_DIVERSITY_WEIGHT = 0.05;
 var CONTEXT_WEIGHT = 0.2;
 var RECENCY_DECAY_MS = 30 * 24 * 60 * 60 * 1000;
+var SKILL_FRONTMATTER_READ_BYTES = 16 * 1024;
 var _internals42 = {
   computeSkillRelevanceScore: null,
   rankSkillsForContext: null,
   getSkillStats: null,
   formatSkillIndexWithContext: null,
+  parseSkillFrontmatter: null,
+  readSkillMetadata: null,
   extractSkillName: null,
   computeRecencyScore: null,
   computeContextMatchScore: null
@@ -95937,6 +95927,98 @@ function extractSkillName(skillPath) {
   const parent = path89.basename(path89.dirname(skillPath));
   return parent;
 }
+function stripQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function normalizeDescription(description) {
+  const singleLine = description.replace(/\s+/g, " ").trim();
+  if (!singleLine)
+    return "No description provided";
+  return singleLine.length > 240 ? `${singleLine.slice(0, 237)}...` : singleLine;
+}
+function parseSkillFrontmatter(content, skillPath) {
+  const normalizedPath = skillPath.replace(/^file:/, "").replace(/\\/g, "/");
+  const fallbackName = extractSkillName(normalizedPath);
+  const fallback = {
+    path: normalizedPath,
+    name: fallbackName,
+    description: "No description provided"
+  };
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---")
+    return fallback;
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+  if (end === -1)
+    return fallback;
+  let name2 = fallbackName;
+  let description = "";
+  for (let i2 = 1;i2 < end; i2++) {
+    const line = lines[i2] ?? "";
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+    if (!match)
+      continue;
+    const key = match[1].toLowerCase();
+    const rawValue = match[2].trim();
+    if (key === "name") {
+      const parsed = stripQuotes(rawValue);
+      if (parsed)
+        name2 = parsed;
+      continue;
+    }
+    if (key !== "description")
+      continue;
+    if (rawValue === ">" || rawValue === "|") {
+      const collected = [];
+      for (let j = i2 + 1;j < end; j++) {
+        const next = lines[j] ?? "";
+        if (/^[A-Za-z_][A-Za-z0-9_-]*\s*:/.test(next))
+          break;
+        collected.push(next.trim());
+        i2 = j;
+      }
+      description = collected.join(" ");
+    } else {
+      description = stripQuotes(rawValue);
+    }
+  }
+  return {
+    path: normalizedPath,
+    name: name2 || fallbackName,
+    description: normalizeDescription(description)
+  };
+}
+function readFilePrefix(filePath) {
+  const fd = fs62.openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(SKILL_FRONTMATTER_READ_BYTES);
+    const bytesRead = fs62.readSync(fd, buffer, 0, SKILL_FRONTMATTER_READ_BYTES, 0);
+    return buffer.toString("utf-8", 0, bytesRead);
+  } finally {
+    fs62.closeSync(fd);
+  }
+}
+function readSkillMetadata(skillPath, directory) {
+  const normalizedPath = skillPath.replace(/^file:/, "").replace(/\\/g, "/");
+  const fallback = parseSkillFrontmatter("", normalizedPath);
+  try {
+    if (path89.isAbsolute(normalizedPath) || normalizedPath.split("/").includes("..")) {
+      return fallback;
+    }
+    const root = path89.resolve(directory);
+    const absolutePath = path89.resolve(directory, normalizedPath);
+    if (absolutePath !== root && !absolutePath.startsWith(root + path89.sep)) {
+      return fallback;
+    }
+    const content = readFilePrefix(absolutePath);
+    return parseSkillFrontmatter(content, normalizedPath);
+  } catch {
+    return fallback;
+  }
+}
 function computeRecencyScore(lastUsedTimestamp) {
   if (!lastUsedTimestamp)
     return 0;
@@ -96041,16 +96123,19 @@ function formatSkillIndexWithContext(skills, directory) {
   const allEntries = readSkillUsageEntries(directory);
   const hasHistory = allEntries.length > 0;
   if (!hasHistory) {
-    return skills.map((sp) => `  - ${extractSkillName(sp)}`).join(`
+    return skills.map((sp) => {
+      const meta3 = _internals42.readSkillMetadata(sp, directory);
+      return `  - file:${meta3.path} - ${meta3.name}: ${meta3.description}`;
+    }).join(`
 `);
   }
   const lines = [];
   for (const skillPath of skills) {
     const stats = getSkillStats(skillPath, directory);
-    const name2 = extractSkillName(skillPath);
+    const meta3 = _internals42.readSkillMetadata(skillPath, directory);
     const compliancePct = Math.round(stats.complianceRate * 100);
     const topAgentNames = stats.topAgents.slice(0, 3).map((a) => a.agent).join(", ");
-    lines.push(`  ${name2}: ${skillPath} (used: ${stats.totalUsage}, compliance: ${compliancePct}%)` + (stats.topAgents.length > 0 ? ` → ${topAgentNames}` : ""));
+    lines.push(`  - file:${meta3.path} - ${meta3.name}: ${meta3.description} (used: ${stats.totalUsage}, compliance: ${compliancePct}%)` + (stats.topAgents.length > 0 ? ` → ${topAgentNames}` : ""));
   }
   return lines.join(`
 `);
@@ -96059,6 +96144,8 @@ _internals42.computeSkillRelevanceScore = computeSkillRelevanceScore;
 _internals42.rankSkillsForContext = rankSkillsForContext;
 _internals42.getSkillStats = getSkillStats;
 _internals42.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals42.parseSkillFrontmatter = parseSkillFrontmatter;
+_internals42.readSkillMetadata = readSkillMetadata;
 _internals42.extractSkillName = extractSkillName;
 _internals42.computeRecencyScore = computeRecencyScore;
 _internals42.computeContextMatchScore = computeContextMatchScore;
@@ -96079,13 +96166,13 @@ var SKILL_SEARCH_ROOTS = [
 ];
 var MAX_SCORING_SESSION_ENTRIES = 500;
 var _internals43 = {
-  readdirSync: fs62.readdirSync.bind(fs62),
-  existsSync: fs62.existsSync.bind(fs62),
-  statSync: fs62.statSync.bind(fs62),
-  mkdirSync: fs62.mkdirSync.bind(fs62),
-  appendFileSync: fs62.appendFileSync.bind(fs62),
-  readFileSync: fs62.readFileSync.bind(fs62),
-  writeFileSync: fs62.writeFileSync.bind(fs62),
+  readdirSync: fs63.readdirSync.bind(fs63),
+  existsSync: fs63.existsSync.bind(fs63),
+  statSync: fs63.statSync.bind(fs63),
+  mkdirSync: fs63.mkdirSync.bind(fs63),
+  appendFileSync: fs63.appendFileSync.bind(fs63),
+  readFileSync: fs63.readFileSync.bind(fs63),
+  writeFileSync: fs63.writeFileSync.bind(fs63),
   skillPropagationGateBefore: null,
   skillPropagationTransformScan: null,
   SKILL_CAPABLE_AGENTS,
@@ -96096,6 +96183,7 @@ var _internals43 = {
   appendSkillUsageEntry,
   readSkillUsageEntries,
   readSkillUsageEntriesTail,
+  extractSkillsFieldFromPrompt: null,
   parseSkillPaths: null,
   extractTaskIdFromPrompt: null,
   computeSkillRelevanceScore,
@@ -96120,7 +96208,7 @@ function discoverAvailableSkills(directory) {
       const skillFile = path90.join(skillDir, "SKILL.md");
       try {
         if (_internals43.statSync(skillDir).isDirectory() && _internals43.existsSync(skillFile)) {
-          results.push(path90.join(root, entry, "SKILL.md"));
+          results.push(path90.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
         }
       } catch (err2) {
         warn(`[skill-propagation-gate] failed to stat skill directory ${entry}: ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -96151,19 +96239,42 @@ function parseDelegationArgs(args2) {
   }
   if (!targetAgent)
     return null;
-  let skillsField = "";
-  if (prompt) {
-    const lines = prompt.split(`
+  const skillsField = prompt ? _internals43.extractSkillsFieldFromPrompt(prompt) : "";
+  return { targetAgent, skillsField };
+}
+function extractSkillsFieldFromPrompt(prompt) {
+  const lines = prompt.split(`
 `);
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("SKILLS:")) {
-        skillsField = trimmed.slice("SKILLS:".length).trim();
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const trimmed = lines[i2].trim();
+    if (!/^SKILLS\s*:/i.test(trimmed))
+      continue;
+    const firstLine2 = trimmed.replace(/^SKILLS\s*:/i, "").trim();
+    const collected = [];
+    if (firstLine2)
+      collected.push(firstLine2);
+    for (let j = i2 + 1;j < lines.length; j++) {
+      const next = lines[j];
+      const nextTrimmed = next.trim();
+      if (!nextTrimmed) {
+        if (collected.length === 0)
+          continue;
+        break;
+      }
+      if (/^[A-Z][A-Z0-9_ -]{1,40}\s*:/i.test(nextTrimmed))
         break;
+      if (/^(?:-|\*|\d+\.)\s+/.test(nextTrimmed) || /^\s+/.test(next)) {
+        collected.push(nextTrimmed);
+        continue;
       }
+      if (collected.length === 0)
+        collected.push(nextTrimmed);
+      break;
     }
+    return collected.join(`
+`).trim();
   }
-  return { targetAgent, skillsField };
+  return "";
 }
 function writeWarnEvent2(directory, record3) {
   const filePath = path90.join(directory, ".swarm", "events.jsonl");
@@ -96184,7 +96295,22 @@ function parseSkillPaths(fieldValue) {
   const trimmed = fieldValue.trim();
   if (trimmed.toLowerCase() === "none" || trimmed === "")
     return [];
-  return trimmed.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  const lines = trimmed.split(/\r?\n/);
+  const hasCatalogLines = lines.some((line) => /^(?:-|\*|\d+\.)\s+/.test(line.trim()));
+  const parts2 = hasCatalogLines ? lines : trimmed.split(",");
+  const paths = [];
+  for (const rawPart of parts2) {
+    const part = rawPart.trim().replace(/^(?:-|\*|\d+\.)\s+/, "").trim();
+    if (!part || part.toLowerCase() === "none")
+      continue;
+    const fileRef = part.match(/\bfile:[^\s,;)\]]+/);
+    if (fileRef) {
+      paths.push(fileRef[0].replace(/\\/g, "/"));
+      continue;
+    }
+    paths.push(part);
+  }
+  return [...new Set(paths)];
 }
 function extractTaskIdFromPrompt(prompt) {
   if (!prompt || typeof prompt !== "string")
@@ -96473,8 +96599,10 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
       continue;
     let currentTargetAgent = "";
     let skillsField = "";
-    for (const line of text.split(`
-`)) {
+    const textLines = text.split(`
+`);
+    for (let lineIndex = 0;lineIndex < textLines.length; lineIndex++) {
+      const line = textLines[lineIndex] ?? "";
       const trimmed = line.trim();
       if (trimmed.match(/TO\s+(coder|reviewer|test_engineer|sme|docs|designer)/i)) {
         const agentMatch = trimmed.match(/TO\s+(coder|reviewer|test_engineer|sme|docs|designer)/i);
@@ -96482,7 +96610,8 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
           currentTargetAgent = agentMatch[1].toLowerCase();
       }
       if (trimmed.startsWith("SKILLS:")) {
-        skillsField = trimmed.slice("SKILLS:".length).trim();
+        skillsField = _internals43.extractSkillsFieldFromPrompt(textLines.slice(lineIndex).join(`
+`));
       }
       if (currentTargetAgent && skillsField && skillsField.toLowerCase() !== "none") {
         const skillPaths = _internals43.parseSkillPaths(skillsField);
@@ -96518,12 +96647,13 @@ _internals43.skillPropagationTransformScan = skillPropagationTransformScan;
 _internals43.writeWarnEvent = writeWarnEvent2;
 _internals43.discoverAvailableSkills = discoverAvailableSkills;
 _internals43.parseDelegationArgs = parseDelegationArgs;
+_internals43.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
 _internals43.parseSkillPaths = parseSkillPaths;
 _internals43.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
 _internals43.formatSkillIndexWithContext = formatSkillIndexWithContext;
 
 // src/hooks/slop-detector.ts
-import * as fs63 from "node:fs";
+import * as fs64 from "node:fs";
 import * as path91 from "node:path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
@@ -96569,7 +96699,7 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
 function walkFiles(dir, exts, deadline) {
   const results = [];
   try {
-    for (const entry of fs63.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs64.readdirSync(dir, { withFileTypes: true })) {
       if (deadline !== undefined && Date.now() > deadline)
         break;
       if (entry.isSymbolicLink())
@@ -96589,7 +96719,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs63.existsSync(path91.join(projectDir, "package.json"));
+  const hasPackageJson = fs64.existsSync(path91.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -96612,7 +96742,7 @@ function checkDeadExports(content, projectDir, startTime) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = fs63.readFileSync(file3, "utf-8");
+          const text = fs64.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -96704,7 +96834,7 @@ function checkDuplicateUtility(content, projectDir, startTime, targetFile) {
     if (Date.now() > deadline)
       break;
     const utilPath = path91.join(projectDir, utilDir);
-    if (!fs63.existsSync(utilPath))
+    if (!fs64.existsSync(utilPath))
       continue;
     const files = walkFiles(utilPath, [".ts", ".tsx", ".js", ".jsx"], deadline);
     for (const file3 of files) {
@@ -96713,7 +96843,7 @@ function checkDuplicateUtility(content, projectDir, startTime, targetFile) {
       if (targetFile && path91.resolve(file3) === path91.resolve(targetFile))
         continue;
       try {
-        const text = fs63.readFileSync(file3, "utf-8");
+        const text = fs64.readFileSync(file3, "utf-8");
         for (const name2 of newExports) {
           const exportPattern = new RegExp(`\\bexport\\s+(?:function|class|const|type|interface)\\s+${name2}\\b`);
           if (exportPattern.test(text)) {
@@ -96796,7 +96926,7 @@ Review before proceeding.`;
 // src/hooks/steering-consumed.ts
 init_bun_compat();
 init_utils2();
-import * as fs64 from "node:fs";
+import * as fs65 from "node:fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -96805,7 +96935,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs64.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs65.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -96847,12 +96977,12 @@ function createSteeringConsumedHook(directory) {
 
 // src/hooks/trajectory-logger.ts
 init_manager2();
-import * as fs66 from "node:fs/promises";
+import * as fs67 from "node:fs/promises";
 import * as path93 from "node:path";
 
 // src/prm/trajectory-store.ts
 init_utils2();
-import * as fs65 from "node:fs/promises";
+import * as fs66 from "node:fs/promises";
 import * as path92 from "node:path";
 function getTrajectoryPath(sessionId, directory) {
   const relativePath = path92.join("trajectories", `${sessionId}.jsonl`);
@@ -96874,10 +97004,10 @@ async function appendTrajectoryEntry(sessionId, entry, directory, maxLines = 100
       _inMemoryTrajectoryCache.set(sessionId, cached3);
     }
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    await fs65.mkdir(path92.dirname(trajectoryPath), { recursive: true });
+    await fs66.mkdir(path92.dirname(trajectoryPath), { recursive: true });
     const line = `${JSON.stringify(entry)}
 `;
-    await fs65.appendFile(trajectoryPath, line, "utf-8");
+    await fs66.appendFile(trajectoryPath, line, "utf-8");
   } catch (err2) {
     console.warn(`[trajectory-store] Failed to append trajectory entry: ${err2}`);
   }
@@ -96885,7 +97015,7 @@ async function appendTrajectoryEntry(sessionId, entry, directory, maxLines = 100
 async function readTrajectory(sessionId, directory) {
   try {
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    const content = await fs65.readFile(trajectoryPath, "utf-8");
+    const content = await fs66.readFile(trajectoryPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     const entries = [];
@@ -96909,15 +97039,15 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
   for (const subdir of ["trajectories", "replays"]) {
     try {
       const dirPath = validateSwarmPath(directory, subdir);
-      const entries = await fs65.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs66.readdir(dirPath, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile())
           continue;
         const filePath = path92.join(dirPath, entry.name);
         try {
-          const stat8 = await fs65.stat(filePath);
+          const stat8 = await fs66.stat(filePath);
           if (now - stat8.mtimeMs > cutoffMs) {
-            await fs65.unlink(filePath);
+            await fs66.unlink(filePath);
           }
         } catch {}
       }
@@ -96967,7 +97097,7 @@ function isSensitiveKey(key) {
 }
 async function truncateTrajectoryFile(filePath, maxLines) {
   try {
-    const content = await fs66.readFile(filePath, "utf-8");
+    const content = await fs67.readFile(filePath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     if (lines.length <= maxLines) {
@@ -96975,7 +97105,7 @@ async function truncateTrajectoryFile(filePath, maxLines) {
     }
     const keepCount = Math.floor(maxLines / 2);
     const keptLines = lines.slice(-keepCount);
-    await fs66.writeFile(filePath, `${keptLines.join(`
+    await fs67.writeFile(filePath, `${keptLines.join(`
 `)}
 `, "utf-8");
   } catch {}
@@ -97108,10 +97238,10 @@ function createTrajectoryLoggerHook(config3, _directory) {
       const relativePath = path93.join("evidence", sanitized, "trajectory.jsonl");
       const trajectoryPath = validateSwarmPath(_directory, relativePath);
       try {
-        await fs66.mkdir(path93.dirname(trajectoryPath), { recursive: true });
+        await fs67.mkdir(path93.dirname(trajectoryPath), { recursive: true });
         const line = `${JSON.stringify(entry)}
 `;
-        await fs66.appendFile(trajectoryPath, line, "utf-8");
+        await fs67.appendFile(trajectoryPath, line, "utf-8");
         await truncateTrajectoryFile(trajectoryPath, maxLines);
       } catch {}
       try {
@@ -97658,7 +97788,7 @@ init_state();
 init_telemetry();
 
 // src/prm/replay.ts
-import { promises as fs67 } from "node:fs";
+import { promises as fs68 } from "node:fs";
 import path94 from "node:path";
 function isPathSafe2(targetPath, basePath) {
   const resolvedTarget = path94.resolve(targetPath);
@@ -97689,7 +97819,7 @@ async function startReplayRecording(sessionID, directory) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
     }
-    await fs67.mkdir(replayDir, { recursive: true });
+    await fs68.mkdir(replayDir, { recursive: true });
     return filepath;
   } catch (err2) {
     console.warn(`[replay] Failed to start recording for session ${sessionID}: ${err2}`);
@@ -97709,7 +97839,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
     };
     const line = `${JSON.stringify(fullEntry)}
 `;
-    await fs67.appendFile(artifactPath, line, "utf-8");
+    await fs68.appendFile(artifactPath, line, "utf-8");
   } catch (err2) {
     console.warn(`[replay] Failed to record entry: ${err2}`);
   }
@@ -98064,7 +98194,7 @@ init_telemetry();
 // src/tools/batch-symbols.ts
 init_dist();
 init_create_tool();
-import * as fs68 from "node:fs";
+import * as fs69 from "node:fs";
 import * as path95 from "node:path";
 init_path_security();
 var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
@@ -98083,11 +98213,11 @@ function containsWindowsAttacks2(str) {
 function isPathInWorkspace2(filePath, workspace) {
   try {
     const resolvedPath = path95.resolve(workspace, filePath);
-    if (!fs68.existsSync(resolvedPath)) {
+    if (!fs69.existsSync(resolvedPath)) {
       return true;
     }
-    const realWorkspace = fs68.realpathSync(workspace);
-    const realResolvedPath = fs68.realpathSync(resolvedPath);
+    const realWorkspace = fs69.realpathSync(workspace);
+    const realResolvedPath = fs69.realpathSync(resolvedPath);
     const relativePath = path95.relative(realWorkspace, realResolvedPath);
     if (relativePath.startsWith("..") || path95.isAbsolute(relativePath)) {
       return false;
@@ -98132,7 +98262,7 @@ function processFile2(file3, cwd, exportedOnly) {
     };
   }
   const fullPath = path95.join(cwd, file3);
-  if (!fs68.existsSync(fullPath)) {
+  if (!fs69.existsSync(fullPath)) {
     return {
       file: file3,
       success: false,
@@ -98163,14 +98293,14 @@ function processFile2(file3, cwd, exportedOnly) {
   }
   let isEmptyFile = false;
   try {
-    const stats = fs68.statSync(fullPath);
+    const stats = fs69.statSync(fullPath);
     if (stats.size === 0) {
       isEmptyFile = true;
     }
   } catch {}
   if (syms.length === 0) {
     try {
-      const content = fs68.readFileSync(fullPath, "utf-8");
+      const content = fs69.readFileSync(fullPath, "utf-8");
       if (content.trim().length === 0) {
         isEmptyFile = true;
       }
@@ -98422,7 +98552,7 @@ init_manager2();
 init_task_id();
 init_create_tool();
 init_resolve_working_directory();
-import * as fs69 from "node:fs";
+import * as fs70 from "node:fs";
 import * as path96 from "node:path";
 var EVIDENCE_DIR = ".swarm/evidence";
 function isValidTaskId3(taskId) {
@@ -98435,12 +98565,12 @@ function isPathWithinSwarm(filePath, workspaceRoot) {
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs69.existsSync(evidencePath)) {
+  if (!fs70.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs69.readFileSync(evidencePath, "utf-8");
+    content = fs70.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -98608,7 +98738,7 @@ init_utils2();
 init_state();
 init_create_tool();
 init_resolve_working_directory();
-import * as fs70 from "node:fs";
+import * as fs71 from "node:fs";
 import * as path97 from "node:path";
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
@@ -98703,7 +98833,7 @@ async function executeCompletionVerify(args2, directory) {
   let plan;
   try {
     const planPath = validateSwarmPath(directory, "plan.json");
-    const planRaw = fs70.readFileSync(planPath, "utf-8");
+    const planRaw = fs71.readFileSync(planPath, "utf-8");
     plan = JSON.parse(planRaw);
   } catch {
     const result2 = {
@@ -98777,7 +98907,7 @@ async function executeCompletionVerify(args2, directory) {
       }
       let fileContent;
       try {
-        fileContent = fs70.readFileSync(resolvedPath, "utf-8");
+        fileContent = fs71.readFileSync(resolvedPath, "utf-8");
       } catch {
         blockedTasks.push({
           task_id: task.id,
@@ -98821,7 +98951,7 @@ async function executeCompletionVerify(args2, directory) {
   try {
     const evidenceDir = path97.join(directory, ".swarm", "evidence", `${phase}`);
     const evidencePath = path97.join(evidenceDir, "completion-verify.json");
-    fs70.mkdirSync(evidenceDir, { recursive: true });
+    fs71.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
       task_id: "completion-verify",
@@ -98842,7 +98972,7 @@ async function executeCompletionVerify(args2, directory) {
         }
       ]
     };
-    fs70.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
+    fs71.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
   } catch {}
   return JSON.stringify(result, null, 2);
 }
@@ -98896,11 +99026,11 @@ var completion_verify = createSwarmTool({
 });
 // src/tools/complexity-hotspots.ts
 init_zod();
-import * as fs72 from "node:fs";
+import * as fs73 from "node:fs";
 import * as path99 from "node:path";
 
 // src/quality/metrics.ts
-import * as fs71 from "node:fs";
+import * as fs72 from "node:fs";
 import * as path98 from "node:path";
 var MAX_FILE_SIZE_BYTES4 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
@@ -98939,11 +99069,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat8 = fs71.statSync(filePath);
+    const stat8 = fs72.statSync(filePath);
     if (stat8.size > MAX_FILE_SIZE_BYTES4) {
       return null;
     }
-    const content = fs71.readFileSync(filePath, "utf-8");
+    const content = fs72.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -98954,7 +99084,7 @@ async function computeComplexityDelta(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path98.isAbsolute(file3) ? file3 : path98.join(workingDir, file3);
-    if (!fs71.existsSync(fullPath)) {
+    if (!fs72.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile(fullPath);
@@ -99075,7 +99205,7 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs71.readFileSync(filePath, "utf-8");
+    const content = fs72.readFileSync(filePath, "utf-8");
     const ext = path98.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
@@ -99103,7 +99233,7 @@ async function computePublicApiDelta(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path98.isAbsolute(file3) ? file3 : path98.join(workingDir, file3);
-    if (!fs71.existsSync(fullPath)) {
+    if (!fs72.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -99137,15 +99267,15 @@ async function computeDuplicationRatio(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path98.isAbsolute(file3) ? file3 : path98.join(workingDir, file3);
-    if (!fs71.existsSync(fullPath)) {
+    if (!fs72.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat8 = fs71.statSync(fullPath);
+      const stat8 = fs72.statSync(fullPath);
       if (stat8.size > MAX_FILE_SIZE_BYTES4) {
         continue;
       }
-      const content = fs71.readFileSync(fullPath, "utf-8");
+      const content = fs72.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -99321,7 +99451,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
   const srcDir = path98.join(workingDir, "src");
-  if (fs71.existsSync(srcDir)) {
+  if (fs72.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
@@ -99329,14 +99459,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
     const dirPath = path98.join(workingDir, dir);
-    if (fs71.existsSync(dirPath)) {
+    if (fs72.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
   const testsDir = path98.join(workingDir, "tests");
-  if (fs71.existsSync(testsDir)) {
+  if (fs72.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
@@ -99344,7 +99474,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
     const dirPath = path98.join(workingDir, dir);
-    if (fs71.existsSync(dirPath) && dirPath !== testsDir) {
+    if (fs72.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -99356,7 +99486,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs71.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs72.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path98.join(dirPath, entry.name);
       if (entry.isDirectory()) {
@@ -99402,7 +99532,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs71.readFileSync(fullPath, "utf-8");
+          const content = fs72.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -99602,11 +99732,11 @@ async function getGitChurn(days, directory) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat8 = fs72.statSync(filePath);
+    const stat8 = fs73.statSync(filePath);
     if (stat8.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs72.readFileSync(filePath, "utf-8");
+    const content = fs73.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -99627,7 +99757,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs72.existsSync(fullPath)) {
+    if (!fs73.existsSync(fullPath)) {
       fullPath = path99.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -100368,7 +100498,7 @@ var submit_council_verdicts = createSwarmTool({
 // src/tools/convene-general-council.ts
 init_zod();
 init_loader();
-import * as fs73 from "node:fs";
+import * as fs74 from "node:fs";
 import * as path100 from "node:path";
 
 // src/council/general-council-advisory.ts
@@ -100802,8 +100932,8 @@ var convene_general_council = createSwarmTool({
     const evidenceFile = `${safeTimestamp}-${input.mode}.json`;
     const evidencePath = path100.join(evidenceDir, evidenceFile);
     try {
-      await fs73.promises.mkdir(evidenceDir, { recursive: true });
-      await fs73.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
+      await fs74.promises.mkdir(evidenceDir, { recursive: true });
+      await fs74.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
     } catch (err2) {
       const message = err2 instanceof Error ? err2.message : String(err2);
       console.warn(`[convene_general_council] Failed to write evidence to ${evidencePath}: ${message}`);
@@ -101044,7 +101174,7 @@ init_scope_persistence();
 init_state();
 init_task_id();
 init_create_tool();
-import * as fs74 from "node:fs";
+import * as fs75 from "node:fs";
 import * as path101 from "node:path";
 function validateTaskIdFormat2(taskId) {
   return validateTaskIdFormat(taskId);
@@ -101132,9 +101262,9 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
     const resolvedDir = path101.resolve(normalizedDir);
     try {
-      const realPath = fs74.realpathSync(resolvedDir);
+      const realPath = fs75.realpathSync(resolvedDir);
       const planPath2 = path101.join(realPath, ".swarm", "plan.json");
-      if (!fs74.existsSync(planPath2)) {
+      if (!fs75.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -101154,8 +101284,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
     if (normalizedDir && fallbackDir) {
       try {
-        const canonicalWorkingDir = fs74.realpathSync(path101.resolve(normalizedDir));
-        const canonicalProjectRoot = fs74.realpathSync(path101.resolve(fallbackDir));
+        const canonicalWorkingDir = fs75.realpathSync(path101.resolve(normalizedDir));
+        const canonicalProjectRoot = fs75.realpathSync(path101.resolve(fallbackDir));
         if (canonicalWorkingDir.startsWith(canonicalProjectRoot + path101.sep)) {
           return {
             success: false,
@@ -101179,7 +101309,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   const directory = normalizedDir || fallbackDir;
   const planPath = path101.resolve(directory, ".swarm", "plan.json");
-  if (!fs74.existsSync(planPath)) {
+  if (!fs75.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -101188,7 +101318,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs74.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs75.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -101279,7 +101409,7 @@ var declare_scope = createSwarmTool({
 // src/tools/diff.ts
 init_zod();
 import * as child_process7 from "node:child_process";
-import * as fs75 from "node:fs";
+import * as fs76 from "node:fs";
 import * as path102 from "node:path";
 init_create_tool();
 var MAX_DIFF_LINES = 500;
@@ -101471,7 +101601,7 @@ var diff = createSwarmTool({
           } else if (base === "unstaged") {
             const oldRef = `:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
-            newContent = fs75.readFileSync(path102.join(directory, file3.path), "utf-8");
+            newContent = fs76.readFileSync(path102.join(directory, file3.path), "utf-8");
           } else {
             const oldRef = `${base}:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
@@ -101545,7 +101675,7 @@ var diff = createSwarmTool({
 // src/tools/diff-summary.ts
 init_zod();
 import * as child_process8 from "node:child_process";
-import * as fs76 from "node:fs";
+import * as fs77 from "node:fs";
 import * as path103 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
@@ -101599,7 +101729,7 @@ var diff_summary = createSwarmTool({
         }
         try {
           let oldContent;
-          const newContent = fs76.readFileSync(path103.join(workingDir, filePath), "utf-8");
+          const newContent = fs77.readFileSync(path103.join(workingDir, filePath), "utf-8");
           if (fileExistsInHead) {
             oldContent = child_process8.execFileSync("git", ["show", `HEAD:${filePath}`], {
               encoding: "utf-8",
@@ -101827,7 +101957,7 @@ Use these as DOMAIN values when delegating to @sme.`;
 init_zod();
 init_create_tool();
 init_path_security();
-import * as fs77 from "node:fs";
+import * as fs78 from "node:fs";
 import * as path104 from "node:path";
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
@@ -101873,12 +102003,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs77.existsSync(evidenceDir) || !fs77.statSync(evidenceDir).isDirectory()) {
+  if (!fs78.existsSync(evidenceDir) || !fs78.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs77.readdirSync(evidenceDir);
+    files = fs78.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -101894,7 +102024,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat8 = fs77.lstatSync(filePath);
+      const stat8 = fs78.lstatSync(filePath);
       if (!stat8.isFile()) {
         continue;
       }
@@ -101903,7 +102033,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs77.statSync(filePath);
+      fileStat = fs78.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES6) {
         continue;
       }
@@ -101912,7 +102042,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs77.readFileSync(filePath, "utf-8");
+      content = fs78.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -102022,7 +102152,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs77.readFileSync(planPath, "utf-8");
+      planContent = fs78.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -102057,7 +102187,7 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_zod();
 init_create_tool();
-import * as fs78 from "node:fs";
+import * as fs79 from "node:fs";
 import * as path105 from "node:path";
 var EXT_MAP = {
   python: ".py",
@@ -102120,8 +102250,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs78.existsSync(targetDir)) {
-      fs78.mkdirSync(targetDir, { recursive: true });
+    if (!fs79.existsSync(targetDir)) {
+      fs79.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -102143,12 +102273,12 @@ var extract_code_blocks = createSwarmTool({
       const base = path105.basename(filepath, path105.extname(filepath));
       const ext = path105.extname(filepath);
       let counter = 1;
-      while (fs78.existsSync(filepath)) {
+      while (fs79.existsSync(filepath)) {
         filepath = path105.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs78.writeFileSync(filepath, code.trim(), "utf-8");
+        fs79.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -102314,7 +102444,7 @@ init_create_tool();
 var GITINGEST_TIMEOUT_MS = 1e4;
 var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
 var GITINGEST_MAX_RETRIES = 2;
-var delay = (ms) => new Promise((resolve35) => setTimeout(resolve35, ms));
+var delay = (ms) => new Promise((resolve36) => setTimeout(resolve36, ms));
 async function fetchGitingest(args2) {
   for (let attempt = 0;attempt <= GITINGEST_MAX_RETRIES; attempt++) {
     try {
@@ -102401,7 +102531,7 @@ var gitingest = createSwarmTool({
 init_zod();
 init_create_tool();
 init_path_security();
-import * as fs79 from "node:fs";
+import * as fs80 from "node:fs";
 import * as path106 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
@@ -102564,7 +102694,7 @@ var SKIP_DIRECTORIES4 = new Set([
 function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs79.readdirSync(dir);
+    entries = fs80.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -102581,7 +102711,7 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
     const fullPath = path106.join(dir, entry);
     let stat8;
     try {
-      stat8 = fs79.statSync(fullPath);
+      stat8 = fs80.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -102650,7 +102780,7 @@ var imports = createSwarmTool({
     }
     try {
       const targetFile = path106.resolve(file3);
-      if (!fs79.existsSync(targetFile)) {
+      if (!fs80.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -102660,7 +102790,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs79.statSync(targetFile);
+      const targetStat = fs80.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -102686,12 +102816,12 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat8 = fs79.statSync(filePath);
+          const stat8 = fs80.statSync(filePath);
           if (stat8.size > MAX_FILE_SIZE_BYTES7) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs79.readFileSync(filePath);
+          const buffer = fs80.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -103273,22 +103403,22 @@ init_config();
 init_schema();
 init_qa_gate_profile();
 init_manager2();
-import * as fs84 from "node:fs";
+import * as fs85 from "node:fs";
 import * as path111 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state2();
-import * as fs80 from "node:fs";
+import * as fs81 from "node:fs";
 import * as path107 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
     const dirPath = validateSwarmPath(directory, path107.posix.join("evidence", String(phase)));
-    if (!fs80.existsSync(dirPath))
+    if (!fs81.existsSync(dirPath))
       return [];
-    const entries = fs80.readdirSync(dirPath);
+    const entries = fs81.readdirSync(dirPath);
     return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path107.join(dirPath, e));
   } catch {
     return [];
@@ -103296,7 +103426,7 @@ function readEvidenceDir(directory, phase) {
 }
 function parseEvidence(filePath) {
   try {
-    const raw = fs80.readFileSync(filePath, "utf-8");
+    const raw = fs81.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch (error93) {
@@ -103385,9 +103515,9 @@ function verifyFullAutoPhaseApproval(directory, sessionID, phase, config3) {
 function phaseIsExplicitlyNonCode(directory, phase) {
   try {
     const planPath = validateSwarmPath(directory, "plan.json");
-    if (!fs80.existsSync(planPath))
+    if (!fs81.existsSync(planPath))
       return false;
-    const raw = fs80.readFileSync(planPath, "utf-8");
+    const raw = fs81.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     const phases = Array.isArray(plan.phases) ? plan.phases : [];
     const entry = phases.find((p) => p.id === phase || p.phase === phase);
@@ -103428,7 +103558,7 @@ init_file_locks();
 init_plan_schema();
 init_ledger();
 init_manager();
-import * as fs81 from "node:fs";
+import * as fs82 from "node:fs";
 import * as path108 from "node:path";
 async function writeCheckpoint(directory) {
   try {
@@ -103436,12 +103566,12 @@ async function writeCheckpoint(directory) {
     if (!plan)
       return;
     const swarmDir = path108.join(directory, ".swarm");
-    fs81.mkdirSync(swarmDir, { recursive: true });
+    fs82.mkdirSync(swarmDir, { recursive: true });
     const jsonPath = path108.join(swarmDir, "SWARM_PLAN.json");
     const mdPath = path108.join(swarmDir, "SWARM_PLAN.md");
-    fs81.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
+    fs82.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
-    fs81.writeFileSync(mdPath, md, "utf8");
+    fs82.writeFileSync(mdPath, md, "utf8");
   } catch (error93) {
     console.warn(`[checkpoint] Failed to write SWARM_PLAN checkpoint: ${error93 instanceof Error ? error93.message : String(error93)}`);
   }
@@ -103456,13 +103586,13 @@ init_telemetry();
 
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
-import * as fs83 from "node:fs";
+import * as fs84 from "node:fs";
 import * as path110 from "node:path";
 
 // src/turbo/lean/evidence.ts
 init_bun_compat();
 import { rmSync as rmSync6 } from "node:fs";
-import * as fs82 from "node:fs/promises";
+import * as fs83 from "node:fs/promises";
 import * as path109 from "node:path";
 function leanTurboEvidenceDir(directory, phase) {
   return path109.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
@@ -103497,11 +103627,11 @@ function laneEvidencePath(directory, phase, laneId) {
 async function atomicWriteJson(filePath, data) {
   const content = JSON.stringify(data, null, 2);
   const dir = path109.dirname(filePath);
-  await fs82.mkdir(dir, { recursive: true });
+  await fs83.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   try {
     await bunWrite(tempPath, content);
-    await fs82.rename(tempPath, filePath);
+    await fs83.rename(tempPath, filePath);
   } catch (error93) {
     try {
       rmSync6(tempPath, { force: true });
@@ -103520,7 +103650,7 @@ async function readPhaseEvidence(directory, phase) {
   const targetPath = phaseEvidencePath(directory, phase);
   let content;
   try {
-    content = await fs82.readFile(targetPath, "utf-8");
+    content = await fs83.readFile(targetPath, "utf-8");
   } catch (error93) {
     const code = error93.code;
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -103538,7 +103668,7 @@ async function listLaneEvidence(directory, phase) {
   const evidenceDir = leanTurboEvidenceDir(directory, phase);
   let entries;
   try {
-    entries = await fs82.readdir(evidenceDir);
+    entries = await fs83.readdir(evidenceDir);
   } catch (error93) {
     const code = error93.code;
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -103557,7 +103687,7 @@ async function listLaneEvidence(directory, phase) {
     const filePath = path109.join(evidenceDir, entry);
     let content;
     try {
-      content = await fs82.readFile(filePath, "utf-8");
+      content = await fs83.readFile(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -103579,9 +103709,9 @@ var DEFAULT_CONFIG2 = {
 function defaultReadPlanJson(dir) {
   try {
     const planPath = path110.join(dir, ".swarm", "plan.json");
-    if (!fs83.existsSync(planPath))
+    if (!fs84.existsSync(planPath))
       return null;
-    const raw = fs83.readFileSync(planPath, "utf-8");
+    const raw = fs84.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     if (typeof plan !== "object" || plan === null || !Array.isArray(plan.phases)) {
       return null;
@@ -103594,10 +103724,10 @@ function defaultReadPlanJson(dir) {
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
     const evidencePath = path110.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
-    if (!fs83.existsSync(evidencePath)) {
+    if (!fs84.existsSync(evidencePath)) {
       return null;
     }
-    const raw = fs83.readFileSync(evidencePath, "utf-8");
+    const raw = fs84.readFileSync(evidencePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || typeof parsed.verdict !== "string") {
       return null;
@@ -103614,10 +103744,10 @@ function readReviewerEvidenceFromFile(directory, phase) {
 function readCriticEvidenceFromFile(directory, phase) {
   try {
     const evidencePath = path110.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
-    if (!fs83.existsSync(evidencePath)) {
+    if (!fs84.existsSync(evidencePath)) {
       return null;
     }
-    const raw = fs83.readFileSync(evidencePath, "utf-8");
+    const raw = fs84.readFileSync(evidencePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || typeof parsed.verdict !== "string") {
       return null;
@@ -103635,7 +103765,7 @@ function listLaneEvidenceSync(directory, phase) {
   const evidenceDir = path110.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
-    entries = fs83.readdirSync(evidenceDir);
+    entries = fs84.readdirSync(evidenceDir);
   } catch {
     return [];
   }
@@ -103703,7 +103833,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...actualConfig
   };
   const statePath = path110.join(directory, ".swarm", "turbo-state.json");
-  if (!fs83.existsSync(statePath)) {
+  if (!fs84.existsSync(statePath)) {
     return {
       ok: false,
       reason: "Lean Turbo state unreadable or missing"
@@ -103893,7 +104023,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     const evidencePath = path110.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
-      const content = fs83.readFileSync(evidencePath, "utf-8");
+      const content = fs84.readFileSync(evidencePath, "utf-8");
       const evidence = JSON.parse(content);
       hasDiff = !!evidence.integratedDiffSummary;
     } catch {}
@@ -104186,7 +104316,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     let driftHasSpecMd = false;
     try {
       const specMdPath = path111.join(dir, ".swarm", "spec.md");
-      driftHasSpecMd = fs84.existsSync(specMdPath);
+      driftHasSpecMd = fs85.existsSync(specMdPath);
       const gatePlan = await loadPlan(dir);
       if (gatePlan) {
         const gatePlanId = derivePlanId(gatePlan);
@@ -104207,8 +104337,8 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       let phaseType;
       try {
         const planPath = path111.join(dir, ".swarm", "plan.json");
-        if (fs84.existsSync(planPath)) {
-          const planRaw = fs84.readFileSync(planPath, "utf-8");
+        if (fs85.existsSync(planPath)) {
+          const planRaw = fs85.readFileSync(planPath, "utf-8");
           const plan = JSON.parse(planRaw);
           const targetPhase = plan.phases?.find((p) => p.id === phase);
           phaseType = targetPhase?.type;
@@ -104222,7 +104352,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           let driftVerdictFound = false;
           let driftVerdictApproved = false;
           try {
-            const driftEvidenceContent = fs84.readFileSync(driftEvidencePath, "utf-8");
+            const driftEvidenceContent = fs85.readFileSync(driftEvidencePath, "utf-8");
             const driftEvidence = JSON.parse(driftEvidenceContent);
             const entries = driftEvidence.entries ?? [];
             for (const entry of entries) {
@@ -104257,8 +104387,8 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
               let planParseable = false;
               try {
                 const planPath = path111.join(dir, ".swarm", "plan.json");
-                if (fs84.existsSync(planPath)) {
-                  const planRaw = fs84.readFileSync(planPath, "utf-8");
+                if (fs85.existsSync(planPath)) {
+                  const planRaw = fs85.readFileSync(planPath, "utf-8");
                   const plan = JSON.parse(planRaw);
                   planParseable = true;
                   const planPhase = plan.phases?.find((p) => p.id === phase);
@@ -104327,7 +104457,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
             let hgVerdictFound = false;
             let hgVerdictApproved = false;
             try {
-              const hgContent = fs84.readFileSync(hgPath, "utf-8");
+              const hgContent = fs85.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") {
@@ -104399,7 +104529,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
             let mgVerdictFound = false;
             let mgVerdict;
             try {
-              const mgContent = fs84.readFileSync(mgPath, "utf-8");
+              const mgContent = fs85.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") {
@@ -104476,7 +104606,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
             let pcTimestamp;
             let pcPhaseNumber;
             try {
-              const pcContent = fs84.readFileSync(pcPath, "utf-8");
+              const pcContent = fs85.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") {
@@ -104681,7 +104811,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
               let fcVerdictFound = false;
               let _fcVerdict;
               try {
-                const fcContent = fs84.readFileSync(fcPath, "utf-8");
+                const fcContent = fs85.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") {
@@ -104945,7 +105075,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   let phaseRequiredAgents;
   try {
     const planPath = validateSwarmPath(dir, "plan.json");
-    const planRaw = fs84.readFileSync(planPath, "utf-8");
+    const planRaw = fs85.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     const phaseObj = plan.phases.find((p) => p.id === phase);
     phaseRequiredAgents = phaseObj?.required_agents;
@@ -104960,7 +105090,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs84.readFileSync(planPath, "utf-8");
+      const planRaw = fs85.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)) {
@@ -105000,7 +105130,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs84.readFileSync(planPath, "utf-8");
+      const planRaw = fs85.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -105054,7 +105184,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   }
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs84.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs85.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)}`);
@@ -105129,12 +105259,12 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
         warnings.push(`Warning: failed to update plan.json phase status`);
         try {
           const planPath = validateSwarmPath(dir, "plan.json");
-          const planRaw = fs84.readFileSync(planPath, "utf-8");
+          const planRaw = fs85.readFileSync(planPath, "utf-8");
           const plan2 = JSON.parse(planRaw);
           const phaseObj = plan2.phases.find((p) => p.id === phase);
           if (phaseObj) {
             phaseObj.status = "complete";
-            fs84.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
+            fs85.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
           }
         } catch {}
       } else if (plan) {
@@ -105171,12 +105301,12 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
       warnings.push(`Warning: failed to update plan.json phase status`);
       try {
         const planPath = validateSwarmPath(dir, "plan.json");
-        const planRaw = fs84.readFileSync(planPath, "utf-8");
+        const planRaw = fs85.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         const phaseObj = plan.phases.find((p) => p.id === phase);
         if (phaseObj) {
           phaseObj.status = "complete";
-          fs84.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
+          fs85.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
         }
       } catch {}
     }
@@ -105234,7 +105364,7 @@ init_discovery();
 init_utils();
 init_bun_compat();
 init_create_tool();
-import * as fs85 from "node:fs";
+import * as fs86 from "node:fs";
 import * as path112 from "node:path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
@@ -105263,31 +105393,31 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs85.existsSync(path112.join(cwd, "package.json"))) {
+  if (fs86.existsSync(path112.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs85.existsSync(path112.join(cwd, "pyproject.toml")) || fs85.existsSync(path112.join(cwd, "requirements.txt"))) {
+  if (fs86.existsSync(path112.join(cwd, "pyproject.toml")) || fs86.existsSync(path112.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs85.existsSync(path112.join(cwd, "Cargo.toml"))) {
+  if (fs86.existsSync(path112.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs85.existsSync(path112.join(cwd, "go.mod"))) {
+  if (fs86.existsSync(path112.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs85.readdirSync(cwd);
+    const files = fs86.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs85.existsSync(path112.join(cwd, "Gemfile")) || fs85.existsSync(path112.join(cwd, "Gemfile.lock"))) {
+  if (fs86.existsSync(path112.join(cwd, "Gemfile")) || fs86.existsSync(path112.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs85.existsSync(path112.join(cwd, "pubspec.yaml"))) {
+  if (fs86.existsSync(path112.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs85.existsSync(path112.join(cwd, "composer.lock"))) {
+  if (fs86.existsSync(path112.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -105300,7 +105430,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve37) => setTimeout(() => resolve37("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve38) => setTimeout(() => resolve38("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
@@ -105420,7 +105550,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve37) => setTimeout(() => resolve37("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve38) => setTimeout(() => resolve38("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
@@ -105548,7 +105678,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve37) => setTimeout(() => resolve37("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve38) => setTimeout(() => resolve38("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -105672,7 +105802,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve37) => setTimeout(() => resolve37("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve38) => setTimeout(() => resolve38("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -105805,7 +105935,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve37) => setTimeout(() => resolve37("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve38) => setTimeout(() => resolve38("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -105921,7 +106051,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve37) => setTimeout(() => resolve37("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve38) => setTimeout(() => resolve38("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -106066,7 +106196,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve37) => setTimeout(() => resolve37("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve38) => setTimeout(() => resolve38("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -106181,7 +106311,7 @@ async function runComposerAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve37) => setTimeout(() => resolve37("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve38) => setTimeout(() => resolve38("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -106422,7 +106552,7 @@ var pkg_audit = createSwarmTool({
 // src/tools/placeholder-scan.ts
 init_zod();
 init_manager2();
-import * as fs86 from "node:fs";
+import * as fs87 from "node:fs";
 import * as path113 from "node:path";
 init_utils();
 init_create_tool();
@@ -106824,7 +106954,7 @@ async function placeholderScan(input, directory) {
     if (!fullPath.startsWith(resolvedDirectory + path113.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
-    if (!fs86.existsSync(fullPath)) {
+    if (!fs87.existsSync(fullPath)) {
       continue;
     }
     if (isAllowedByGlobs(filePath, allow_globs)) {
@@ -106836,11 +106966,11 @@ async function placeholderScan(input, directory) {
     }
     let content;
     try {
-      const stat8 = fs86.statSync(fullPath);
+      const stat8 = fs87.statSync(fullPath);
       if (stat8.size > MAX_FILE_SIZE) {
         continue;
       }
-      content = fs86.readFileSync(fullPath, "utf-8");
+      content = fs87.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -106901,7 +107031,7 @@ var placeholder_scan = createSwarmTool({
   }
 });
 // src/tools/pre-check-batch.ts
-import * as fs90 from "node:fs";
+import * as fs91 from "node:fs";
 import * as path117 from "node:path";
 init_zod();
 init_manager2();
@@ -107042,7 +107172,7 @@ var _internals45 = {
 init_zod();
 init_manager2();
 init_detector();
-import * as fs89 from "node:fs";
+import * as fs90 from "node:fs";
 import * as path116 from "node:path";
 import { extname as extname20 } from "node:path";
 
@@ -107758,7 +107888,7 @@ function executeRulesSync(filePath, content, language) {
 
 // src/sast/semgrep.ts
 import * as child_process9 from "node:child_process";
-import * as fs87 from "node:fs";
+import * as fs88 from "node:fs";
 import * as path114 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
@@ -107840,7 +107970,7 @@ function mapSemgrepSeverity(severity) {
   }
 }
 async function executeWithTimeout(command, args2, options) {
-  return new Promise((resolve39) => {
+  return new Promise((resolve40) => {
     const child = child_process9.spawn(command, args2, {
       shell: false,
       cwd: options.cwd
@@ -107849,7 +107979,7 @@ async function executeWithTimeout(command, args2, options) {
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve39({
+      resolve40({
         stdout,
         stderr: "Process timed out",
         exitCode: 124
@@ -107863,7 +107993,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve39({
+      resolve40({
         stdout,
         stderr,
         exitCode: code ?? 0
@@ -107871,7 +108001,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve39({
+      resolve40({
         stdout,
         stderr: err2.message,
         exitCode: 1
@@ -107953,7 +108083,7 @@ function getRulesDirectory(projectRoot) {
 function hasBundledRules(projectRoot) {
   const rulesDir = getRulesDirectory(projectRoot);
   try {
-    return fs87.existsSync(rulesDir);
+    return fs88.existsSync(rulesDir);
   } catch {
     return false;
   }
@@ -107966,7 +108096,7 @@ init_create_tool();
 // src/tools/sast-baseline.ts
 init_utils2();
 import * as crypto10 from "node:crypto";
-import * as fs88 from "node:fs";
+import * as fs89 from "node:fs";
 import * as path115 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
@@ -108001,7 +108131,7 @@ function fingerprintFinding(finding, directory, occurrenceIndex) {
   }
   const lineNum = finding.location.line;
   try {
-    const content = fs88.readFileSync(finding.location.file, "utf-8");
+    const content = fs89.readFileSync(finding.location.file, "utf-8");
     const lines = content.split(`
 `);
     const idx = lineNum - 1;
@@ -108032,7 +108162,7 @@ function assignOccurrenceIndices(findings, directory) {
     try {
       if (relFile.startsWith(".."))
         throw new Error("escapes workspace");
-      const content = fs88.readFileSync(finding.location.file, "utf-8");
+      const content = fs89.readFileSync(finding.location.file, "utf-8");
       const lines = content.split(`
 `);
       const idx = lineNum - 1;
@@ -108061,16 +108191,16 @@ function assignOccurrenceIndices(findings, directory) {
 async function acquireLock2(lockPath) {
   for (let attempt = 0;attempt <= LOCK_RETRY_DELAYS_MS.length; attempt++) {
     try {
-      const fd = fs88.openSync(lockPath, "wx");
-      fs88.closeSync(fd);
+      const fd = fs89.openSync(lockPath, "wx");
+      fs89.closeSync(fd);
       return () => {
         try {
-          fs88.unlinkSync(lockPath);
+          fs89.unlinkSync(lockPath);
         } catch {}
       };
     } catch {
       if (attempt < LOCK_RETRY_DELAYS_MS.length) {
-        await new Promise((resolve40) => setTimeout(resolve40, LOCK_RETRY_DELAYS_MS[attempt]));
+        await new Promise((resolve41) => setTimeout(resolve41, LOCK_RETRY_DELAYS_MS[attempt]));
       }
     }
   }
@@ -108105,13 +108235,13 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs88.mkdirSync(path115.dirname(baselinePath), { recursive: true });
-  fs88.mkdirSync(path115.dirname(tempPath), { recursive: true });
+  fs89.mkdirSync(path115.dirname(baselinePath), { recursive: true });
+  fs89.mkdirSync(path115.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
     try {
-      const raw = fs88.readFileSync(baselinePath, "utf-8");
+      const raw = fs89.readFileSync(baselinePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.schema_version === BASELINE_SCHEMA_VERSION) {
         existing = parsed;
@@ -108171,8 +108301,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
           message: `Baseline would exceed size cap (${json4.length} bytes > ${MAX_BASELINE_BYTES})`
         };
       }
-      fs88.writeFileSync(tempPath, json4, "utf-8");
-      fs88.renameSync(tempPath, baselinePath);
+      fs89.writeFileSync(tempPath, json4, "utf-8");
+      fs89.renameSync(tempPath, baselinePath);
       return {
         status: "merged",
         path: baselinePath,
@@ -108203,8 +108333,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
         message: `Baseline would exceed size cap (${json3.length} bytes > ${MAX_BASELINE_BYTES})`
       };
     }
-    fs88.writeFileSync(tempPath, json3, "utf-8");
-    fs88.renameSync(tempPath, baselinePath);
+    fs89.writeFileSync(tempPath, json3, "utf-8");
+    fs89.renameSync(tempPath, baselinePath);
     return {
       status: "written",
       path: baselinePath,
@@ -108229,7 +108359,7 @@ function loadBaseline(directory, phase) {
     };
   }
   try {
-    const raw = fs88.readFileSync(baselinePath, "utf-8");
+    const raw = fs89.readFileSync(baselinePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schema_version !== BASELINE_SCHEMA_VERSION) {
       return {
@@ -108277,17 +108407,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs89.statSync(filePath);
+    const stats = fs90.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 = fs89.openSync(filePath, "r");
+    const fd = fs90.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs89.readSync(fd, buffer, 0, 8192, 0);
-    fs89.closeSync(fd);
+    const bytesRead = fs90.readSync(fd, buffer, 0, 8192, 0);
+    fs90.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -108326,7 +108456,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs89.readFileSync(filePath, "utf-8");
+    const content = fs90.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -108385,7 +108515,7 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    if (!fs89.existsSync(resolvedPath)) {
+    if (!fs90.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -108954,7 +109084,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let stat8;
       try {
-        stat8 = fs90.statSync(file3);
+        stat8 = fs91.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -108965,7 +109095,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs90.readFileSync(file3);
+        const buffer = fs91.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -109664,7 +109794,7 @@ var repo_map = createSwarmTool({
 // src/tools/req-coverage.ts
 init_zod();
 init_create_tool();
-import * as fs91 from "node:fs";
+import * as fs92 from "node:fs";
 import * as path119 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
@@ -109724,19 +109854,19 @@ function extractObligationAndText(id, lineText) {
 var PHASE_TASK_ID_REGEX = /^\d+\.\d+(\.\d+)*$/;
 function readTouchedFiles(evidenceDir, phase, cwd) {
   const touchedFiles = new Set;
-  if (!fs91.existsSync(evidenceDir) || !fs91.statSync(evidenceDir).isDirectory()) {
+  if (!fs92.existsSync(evidenceDir) || !fs92.statSync(evidenceDir).isDirectory()) {
     return [];
   }
   let entries;
   try {
-    entries = fs91.readdirSync(evidenceDir);
+    entries = fs92.readdirSync(evidenceDir);
   } catch {
     return [];
   }
   for (const entry of entries) {
     const entryPath = path119.join(evidenceDir, entry);
     try {
-      const stat8 = fs91.statSync(entryPath);
+      const stat8 = fs92.statSync(entryPath);
       if (!stat8.isDirectory()) {
         continue;
       }
@@ -109757,7 +109887,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
       if (!resolvedPath.startsWith(evidenceDirResolved + path119.sep)) {
         continue;
       }
-      const stat8 = fs91.lstatSync(evidenceFilePath);
+      const stat8 = fs92.lstatSync(evidenceFilePath);
       if (!stat8.isFile()) {
         continue;
       }
@@ -109769,7 +109899,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     }
     let content;
     try {
-      content = fs91.readFileSync(evidenceFilePath, "utf-8");
+      content = fs92.readFileSync(evidenceFilePath, "utf-8");
     } catch {
       continue;
     }
@@ -109806,7 +109936,7 @@ function searchFileForKeywords(filePath, keywords, cwd) {
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
-    const content = fs91.readFileSync(resolvedPath, "utf-8");
+    const content = fs92.readFileSync(resolvedPath, "utf-8");
     for (const keyword of keywords) {
       const regex = new RegExp(`\\b${keyword}\\b`, "i");
       if (regex.test(content)) {
@@ -109939,7 +110069,7 @@ var req_coverage = createSwarmTool({
     const specPath = path119.join(cwd, SPEC_FILE);
     let specContent;
     try {
-      specContent = fs91.readFileSync(specPath, "utf-8");
+      specContent = fs92.readFileSync(specPath, "utf-8");
     } catch (readError) {
       return JSON.stringify({
         success: false,
@@ -109991,10 +110121,10 @@ var req_coverage = createSwarmTool({
     const reportFilename = `req-coverage-phase-${phase}.json`;
     const reportPath = path119.join(evidenceDir, reportFilename);
     try {
-      if (!fs91.existsSync(evidenceDir)) {
-        fs91.mkdirSync(evidenceDir, { recursive: true });
+      if (!fs92.existsSync(evidenceDir)) {
+        fs92.mkdirSync(evidenceDir, { recursive: true });
       }
-      fs91.writeFileSync(reportPath, JSON.stringify(result, null, 2), "utf-8");
+      fs92.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)}`);
     }
@@ -110076,7 +110206,7 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as crypto11 from "node:crypto";
-import * as fs92 from "node:fs";
+import * as fs93 from "node:fs";
 import * as path120 from "node:path";
 init_ledger();
 init_manager();
@@ -110159,7 +110289,7 @@ async function executeSavePlan(args2, fallbackDir) {
     const resolvedRoot = path120.resolve(fallbackDir);
     let fallbackExists = false;
     try {
-      fs92.accessSync(resolvedRoot, fs92.constants.F_OK);
+      fs93.accessSync(resolvedRoot, fs93.constants.F_OK);
       fallbackExists = true;
     } catch {
       fallbackExists = false;
@@ -110183,9 +110313,9 @@ async function executeSavePlan(args2, fallbackDir) {
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
     const specPath = path120.join(targetWorkspace, ".swarm", "spec.md");
     try {
-      const stat8 = await fs92.promises.stat(specPath);
+      const stat8 = await fs93.promises.stat(specPath);
       specMtime = stat8.mtime.toISOString();
-      const content = await fs92.promises.readFile(specPath, "utf8");
+      const content = await fs93.promises.readFile(specPath, "utf8");
       specHash = crypto11.createHash("sha256").update(content).digest("hex");
     } catch {
       return {
@@ -110200,7 +110330,7 @@ async function executeSavePlan(args2, fallbackDir) {
     const contextPath = path120.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
-      contextContent = await fs92.promises.readFile(contextPath, "utf8");
+      contextContent = await fs93.promises.readFile(contextPath, "utf8");
     } catch {}
     const hasPendingSection = contextContent.includes("## Pending QA Gate Selection");
     if (!hasPendingSection) {
@@ -110461,7 +110591,7 @@ async function executeSavePlan(args2, fallbackDir) {
           phases_count: plan.phases.length,
           tasks_count: tasksCount
         });
-        await fs92.promises.writeFile(markerPath, marker, "utf8");
+        await fs93.promises.writeFile(markerPath, marker, "utf8");
       } catch {}
       const warnings = [];
       let criticReviewFound = false;
@@ -110541,7 +110671,7 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_zod();
 init_manager2();
-import * as fs93 from "node:fs";
+import * as fs94 from "node:fs";
 import * as path121 from "node:path";
 
 // src/sbom/detectors/index.ts
@@ -111390,7 +111520,7 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs93.readdirSync(dir, { withFileTypes: true });
+      const entries = fs94.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path121.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
@@ -111417,7 +111547,7 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs93.readdirSync(dir, { withFileTypes: true });
+      const entries = fs94.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path121.join(dir, entry.name);
         if (entry.isFile()) {
@@ -111454,7 +111584,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs93.mkdirSync(outputDir, { recursive: true });
+    fs94.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -111548,10 +111678,10 @@ var sbom_generate = createSwarmTool({
     for (const manifestFile of manifestFiles) {
       try {
         const fullPath = path121.isAbsolute(manifestFile) ? manifestFile : path121.join(workingDir, manifestFile);
-        if (!fs93.existsSync(fullPath)) {
+        if (!fs94.existsSync(fullPath)) {
           continue;
         }
-        const content = fs93.readFileSync(fullPath, "utf-8");
+        const content = fs94.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -111565,7 +111695,7 @@ var sbom_generate = createSwarmTool({
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
     const outputPath = path121.join(outputDir, filename);
-    fs93.writeFileSync(outputPath, bomJson, "utf-8");
+    fs94.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -111607,7 +111737,7 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_zod();
 init_create_tool();
-import * as fs94 from "node:fs";
+import * as fs95 from "node:fs";
 import * as path122 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
@@ -111649,19 +111779,19 @@ function discoverSpecFile(cwd, specFileArg) {
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs94.statSync(resolvedPath);
+    const stats = fs95.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs94.existsSync(resolvedPath)) {
+    if (!fs95.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
     const candidatePath = path122.resolve(cwd, candidate);
-    if (fs94.existsSync(candidatePath)) {
-      const stats = fs94.statSync(candidatePath);
+    if (fs95.existsSync(candidatePath)) {
+      const stats = fs95.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -111670,7 +111800,7 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs94.readFileSync(specFile, "utf-8");
+  const content = fs95.readFileSync(specFile, "utf-8");
   const ext = path122.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
@@ -111742,7 +111872,7 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs94.readdirSync(dir, { withFileTypes: true });
+      entries = fs95.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -111775,7 +111905,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs94.readFileSync(filePath, "utf-8");
+  const content = fs95.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;
@@ -111924,7 +112054,7 @@ init_zod();
 init_bun_compat();
 init_path_security();
 init_create_tool();
-import * as fs95 from "node:fs";
+import * as fs96 from "node:fs";
 import * as path123 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
@@ -111962,8 +112092,8 @@ function containsWindowsAttacks3(str) {
 function isPathInWorkspace3(filePath, workspace) {
   try {
     const resolvedPath = path123.resolve(workspace, filePath);
-    const realWorkspace = fs95.realpathSync(workspace);
-    const realResolvedPath = fs95.realpathSync(resolvedPath);
+    const realWorkspace = fs96.realpathSync(workspace);
+    const realResolvedPath = fs96.realpathSync(resolvedPath);
     const relativePath = path123.relative(realWorkspace, realResolvedPath);
     if (relativePath.startsWith("..") || path123.isAbsolute(relativePath)) {
       return false;
@@ -111983,7 +112113,7 @@ function findRgInEnvPath() {
       continue;
     const isWindows = process.platform === "win32";
     const candidate = path123.join(dir, isWindows ? "rg.exe" : "rg");
-    if (fs95.existsSync(candidate))
+    if (fs96.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -112037,7 +112167,7 @@ async function ripgrepSearch(opts) {
       stderr: "pipe",
       cwd: opts.workspace
     });
-    const timeout = new Promise((resolve46) => setTimeout(() => resolve46("timeout"), REGEX_TIMEOUT_MS));
+    const timeout = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), REGEX_TIMEOUT_MS));
     const exitPromise = proc.exited;
     const result = await Promise.race([exitPromise, timeout]);
     if (result === "timeout") {
@@ -112110,7 +112240,7 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
     return files;
   }
   try {
-    const entries = fs95.readdirSync(dir, { withFileTypes: true });
+    const entries = fs96.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path123.join(dir, entry.name);
       const relativePath = path123.relative(workspace, fullPath);
@@ -112160,7 +112290,7 @@ async function fallbackSearch(opts) {
     }
     let stats;
     try {
-      stats = fs95.statSync(fullPath);
+      stats = fs96.statSync(fullPath);
       if (stats.size > MAX_FILE_SIZE_BYTES10) {
         continue;
       }
@@ -112169,7 +112299,7 @@ async function fallbackSearch(opts) {
     }
     let content;
     try {
-      content = fs95.readFileSync(fullPath, "utf-8");
+      content = fs96.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -112281,7 +112411,7 @@ var search = createSwarmTool({
         message: "Exclude pattern contains invalid Windows-specific sequence"
       }, null, 2);
     }
-    if (!fs95.existsSync(directory)) {
+    if (!fs96.existsSync(directory)) {
       return JSON.stringify({
         error: true,
         type: "unknown",
@@ -112569,8 +112699,8 @@ var spec_write = createSwarmTool({
     let finalContent = content;
     if (mode === "append") {
       try {
-        const fs96 = await import("node:fs/promises");
-        const prior = await fs96.readFile(target, "utf-8");
+        const fs97 = await import("node:fs/promises");
+        const prior = await fs97.readFile(target, "utf-8");
         finalContent = `${prior.replace(/\s+$/, "")}
 
 ${content}
@@ -112878,7 +113008,7 @@ function createSwarmCommandTool(agents) {
 init_zod();
 init_path_security();
 init_create_tool();
-import * as fs96 from "node:fs";
+import * as fs97 from "node:fs";
 import * as path126 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
@@ -112894,11 +113024,11 @@ function containsWindowsAttacks4(str) {
 function isPathInWorkspace4(filePath, workspace) {
   try {
     const resolvedPath = path126.resolve(workspace, filePath);
-    if (!fs96.existsSync(resolvedPath)) {
+    if (!fs97.existsSync(resolvedPath)) {
       return true;
     }
-    const realWorkspace = fs96.realpathSync(workspace);
-    const realResolvedPath = fs96.realpathSync(resolvedPath);
+    const realWorkspace = fs97.realpathSync(workspace);
+    const realResolvedPath = fs97.realpathSync(resolvedPath);
     const relativePath = path126.relative(realWorkspace, realResolvedPath);
     if (relativePath.startsWith("..") || path126.isAbsolute(relativePath)) {
       return false;
@@ -113072,7 +113202,7 @@ var suggestPatch = createSwarmTool({
         message: "changes cannot be empty"
       }, null, 2);
     }
-    if (!fs96.existsSync(directory)) {
+    if (!fs97.existsSync(directory)) {
       return JSON.stringify({
         success: false,
         error: true,
@@ -113109,7 +113239,7 @@ var suggestPatch = createSwarmTool({
         continue;
       }
       const fullPath = path126.resolve(directory, change.file);
-      if (!fs96.existsSync(fullPath)) {
+      if (!fs97.existsSync(fullPath)) {
         errors5.push({
           success: false,
           error: true,
@@ -113123,7 +113253,7 @@ var suggestPatch = createSwarmTool({
       }
       let content;
       try {
-        content = fs96.readFileSync(fullPath, "utf-8");
+        content = fs97.readFileSync(fullPath, "utf-8");
       } catch (err3) {
         errors5.push({
           success: false,
@@ -113411,11 +113541,11 @@ var lean_turbo_acquire_locks = createSwarmTool({
 // src/tools/lean-turbo-plan-lanes.ts
 init_zod();
 init_constants();
-import * as fs98 from "node:fs";
+import * as fs99 from "node:fs";
 import * as path128 from "node:path";
 
 // src/turbo/lean/conflicts.ts
-import * as fs97 from "node:fs";
+import * as fs98 from "node:fs";
 import * as path127 from "node:path";
 var DEFAULT_GLOBAL_FILES = [
   "package.json",
@@ -113545,10 +113675,10 @@ function isProtectedPath2(normalizedPath) {
 function readTaskScopes(directory, taskId) {
   const scopePath = path127.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
-    if (!fs97.existsSync(scopePath)) {
+    if (!fs98.existsSync(scopePath)) {
       return null;
     }
-    const raw = fs97.readFileSync(scopePath, "utf-8");
+    const raw = fs98.readFileSync(scopePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.files)) {
       return null;
@@ -113932,11 +114062,11 @@ function createEmptyPlan(phaseNumber, planId) {
 init_create_tool();
 function readPlanJson(directory) {
   const planPath = path128.join(directory, ".swarm", "plan.json");
-  if (!fs98.existsSync(planPath)) {
+  if (!fs99.existsSync(planPath)) {
     return null;
   }
   try {
-    return JSON.parse(fs98.readFileSync(planPath, "utf-8"));
+    return JSON.parse(fs99.readFileSync(planPath, "utf-8"));
   } catch {
     return null;
   }
@@ -113985,7 +114115,7 @@ init_config();
 
 // src/turbo/lean/reviewer.ts
 init_state();
-import * as fs99 from "node:fs/promises";
+import * as fs100 from "node:fs/promises";
 import * as path129 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
@@ -114103,7 +114233,7 @@ function parseReviewerVerdict(responseText) {
 }
 async function writeReviewerEvidence(directory, phase, verdict, reason) {
   const evidenceDir = path129.join(directory, ".swarm", "evidence", String(phase));
-  await fs99.mkdir(evidenceDir, { recursive: true });
+  await fs100.mkdir(evidenceDir, { recursive: true });
   const evidencePath = path129.join(evidenceDir, "lean-turbo-reviewer.json");
   const content = JSON.stringify({
     phase,
@@ -114113,11 +114243,11 @@ async function writeReviewerEvidence(directory, phase, verdict, reason) {
   }, null, 2);
   const tempPath = `${evidencePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    await fs99.writeFile(tempPath, content, "utf-8");
-    await fs99.rename(tempPath, evidencePath);
+    await fs100.writeFile(tempPath, content, "utf-8");
+    await fs100.rename(tempPath, evidencePath);
   } catch (error93) {
     try {
-      await fs99.unlink(tempPath);
+      await fs100.unlink(tempPath);
     } catch {}
     throw error93;
   }
@@ -114908,7 +115038,7 @@ var lean_turbo_status = createSwarmTool({
 // src/tools/lint-spec.ts
 init_spec_schema();
 init_create_tool();
-import * as fs100 from "node:fs";
+import * as fs101 from "node:fs";
 import * as path130 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
@@ -114963,7 +115093,7 @@ var lint_spec = createSwarmTool({
     const errors5 = [];
     const warnings = [];
     const specPath = path130.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
-    if (!fs100.existsSync(specPath)) {
+    if (!fs101.existsSync(specPath)) {
       const result2 = {
         valid: false,
         specMtime: null,
@@ -114982,12 +115112,12 @@ var lint_spec = createSwarmTool({
     }
     let specMtime = null;
     try {
-      const stats = fs100.statSync(specPath);
+      const stats = fs101.statSync(specPath);
       specMtime = stats.mtime.toISOString();
     } catch {}
     let content;
     try {
-      content = fs100.readFileSync(specPath, "utf-8");
+      content = fs101.readFileSync(specPath, "utf-8");
     } catch (e) {
       const result2 = {
         valid: false,
@@ -115032,7 +115162,7 @@ var lint_spec = createSwarmTool({
 });
 // src/tools/mutation-test.ts
 init_zod();
-import * as fs101 from "node:fs";
+import * as fs102 from "node:fs";
 import * as path132 from "node:path";
 
 // src/mutation/engine.ts
@@ -115589,7 +115719,7 @@ var mutation_test = createSwarmTool({
       for (const filePath of uniquePaths) {
         try {
           const resolvedPath = path132.resolve(cwd, filePath);
-          sourceFiles.set(filePath, fs101.readFileSync(resolvedPath, "utf-8"));
+          sourceFiles.set(filePath, fs102.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
       const report = await executeMutationSuite(typedArgs.patches, typedArgs.test_command, typedArgs.files, cwd, undefined, undefined, sourceFiles.size > 0 ? sourceFiles : undefined);
@@ -115607,7 +115737,7 @@ var mutation_test = createSwarmTool({
 init_zod();
 init_manager2();
 init_detector();
-import * as fs102 from "node:fs";
+import * as fs103 from "node:fs";
 import * as path133 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
@@ -115717,7 +115847,7 @@ async function syntaxCheck(input, directory, config3) {
       }
       let content;
       try {
-        content = fs102.readFileSync(fullPath, "utf8");
+        content = fs103.readFileSync(fullPath, "utf8");
       } catch {
         result.skipped_reason = "file_read_error";
         skippedCount++;
@@ -115833,7 +115963,7 @@ init_zod();
 init_utils();
 init_create_tool();
 init_path_security();
-import * as fs103 from "node:fs";
+import * as fs104 from "node:fs";
 import * as path134 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
@@ -115924,7 +116054,7 @@ function isSupportedExtension(filePath) {
 function findSourceFiles3(dir, files = []) {
   let entries;
   try {
-    entries = fs103.readdirSync(dir);
+    entries = fs104.readdirSync(dir);
   } catch {
     return files;
   }
@@ -115936,7 +116066,7 @@ function findSourceFiles3(dir, files = []) {
     const fullPath = path134.join(dir, entry);
     let stat8;
     try {
-      stat8 = fs103.statSync(fullPath);
+      stat8 = fs104.statSync(fullPath);
     } catch {
       continue;
     }
@@ -116029,7 +116159,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs103.existsSync(scanPath)) {
+    if (!fs104.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -116039,7 +116169,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat8 = fs103.statSync(scanPath);
+    const stat8 = fs104.statSync(scanPath);
     if (stat8.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
@@ -116058,11 +116188,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs103.statSync(filePath);
+        const fileStat = fs104.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES11) {
           continue;
         }
-        const content = fs103.readFileSync(filePath, "utf-8");
+        const content = fs104.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -116093,17 +116223,17 @@ init_loader();
 init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
-import * as fs107 from "node:fs";
+import * as fs108 from "node:fs";
 import * as path138 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
-import * as fs105 from "node:fs";
+import * as fs106 from "node:fs";
 import * as path136 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
-import * as fs104 from "node:fs";
+import * as fs105 from "node:fs";
 import * as path135 from "node:path";
 var _internals54 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
@@ -116181,13 +116311,13 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludePath = path135.isAbsolute(excludeRelPath) ? excludeRelPath : path135.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs104.mkdirSync(path135.dirname(excludePath), { recursive: true });
+        fs105.mkdirSync(path135.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
-          existing = fs104.readFileSync(excludePath, "utf8");
+          existing = fs105.readFileSync(excludePath, "utf8");
         } catch {}
         if (!fileCoversSwarm(existing)) {
-          fs104.appendFileSync(excludePath, `
+          fs105.appendFileSync(excludePath, `
 # opencode-swarm local runtime state
 .swarm/
 `, "utf8");
@@ -116226,9 +116356,9 @@ var _internals55 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
     const planPath = path136.join(directory, ".swarm", "plan.json");
-    if (!fs105.existsSync(planPath))
+    if (!fs106.existsSync(planPath))
       return null;
-    const raw = fs105.readFileSync(planPath, "utf-8");
+    const raw = fs106.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -116330,7 +116460,7 @@ init_telemetry();
 
 // src/turbo/lean/task-completion.ts
 init_file_locks();
-import * as fs106 from "node:fs";
+import * as fs107 from "node:fs";
 import * as path137 from "node:path";
 var _internals56 = {
   listActiveLocks,
@@ -116363,13 +116493,13 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
     const statePath = path137.join(directory, ".swarm", "turbo-state.json");
-    if (!fs106.existsSync(statePath)) {
+    if (!fs107.existsSync(statePath)) {
       return {
         ok: false,
         reason: "Lean Turbo state file not found"
       };
     }
-    const raw = fs106.readFileSync(statePath, "utf-8");
+    const raw = fs107.readFileSync(statePath, "utf-8");
     persisted = JSON.parse(raw);
   } catch {
     return {
@@ -116462,7 +116592,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  if (!fs106.existsSync(evidencePath)) {
+  if (!fs107.existsSync(evidencePath)) {
     return {
       ok: false,
       reason: `Lane ${lane.laneId} evidence file not found: ${evidencePath}`,
@@ -116491,7 +116621,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let filesTouched = [];
   try {
     const planPath = path137.join(directory, ".swarm", "plan.json");
-    const planRaw = fs106.readFileSync(planPath, "utf-8");
+    const planRaw = fs107.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
       for (const task of planPhase.tasks ?? []) {
@@ -116614,7 +116744,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
       const resolvedDir2 = workingDirectory;
       try {
         const planPath = path138.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs107.readFileSync(planPath, "utf-8");
+        const planRaw = fs108.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -116692,7 +116822,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (resolvedDir) {
       try {
         const planPath = path138.join(resolvedDir, ".swarm", "plan.json");
-        const planRaw = fs107.readFileSync(planPath, "utf-8");
+        const planRaw = fs108.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -116941,9 +117071,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     }
     const resolvedDir = path138.resolve(normalizedDir);
     try {
-      const realPath = fs107.realpathSync(resolvedDir);
+      const realPath = fs108.realpathSync(resolvedDir);
       const planPath = path138.join(realPath, ".swarm", "plan.json");
-      if (!fs107.existsSync(planPath)) {
+      if (!fs108.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -116973,8 +117103,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     directory = fallbackDir;
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs107.realpathSync(path138.resolve(directory));
-    const canonicalRoot = fs107.realpathSync(path138.resolve(fallbackDir));
+    const canonicalDir = fs108.realpathSync(path138.resolve(directory));
+    const canonicalRoot = fs108.realpathSync(path138.resolve(fallbackDir));
     if (canonicalDir.startsWith(canonicalRoot + path138.sep)) {
       return {
         success: false,
@@ -116988,21 +117118,21 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   if (args2.status === "in_progress") {
     try {
       const evidencePath = path138.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs107.mkdirSync(path138.dirname(evidencePath), { recursive: true });
-      const fd = fs107.openSync(evidencePath, "wx");
+      fs108.mkdirSync(path138.dirname(evidencePath), { recursive: true });
+      const fd = fs108.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
-        fs107.writeSync(fd, JSON.stringify({
+        fs108.writeSync(fd, JSON.stringify({
           taskId: args2.task_id,
           required_gates: [],
           gates: {}
         }, null, 2));
         writeOk = true;
       } finally {
-        fs107.closeSync(fd);
+        fs108.closeSync(fd);
         if (!writeOk) {
           try {
-            fs107.unlinkSync(evidencePath);
+            fs108.unlinkSync(evidencePath);
           } catch {}
         }
       }
@@ -117013,7 +117143,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     let phaseRequiresReviewer = true;
     try {
       const planPath = path138.join(directory, ".swarm", "plan.json");
-      const planRaw = fs107.readFileSync(planPath, "utf-8");
+      const planRaw = fs108.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")) {
@@ -117323,7 +117453,7 @@ init_utils2();
 init_ledger();
 init_manager();
 init_create_tool();
-import fs108 from "node:fs";
+import fs109 from "node:fs";
 import path139 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
@@ -117385,10 +117515,10 @@ async function executeWriteDriftEvidence(args2, directory) {
   }
   const evidenceDir = path139.dirname(validatedPath);
   try {
-    await fs108.promises.mkdir(evidenceDir, { recursive: true });
+    await fs109.promises.mkdir(evidenceDir, { recursive: true });
     const tempPath = path139.join(evidenceDir, `.${filename}.tmp`);
-    await fs108.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs108.promises.rename(tempPath, validatedPath);
+    await fs109.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs109.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
     let snapshotError;
     let qaProfileLocked;
@@ -117481,7 +117611,7 @@ var write_drift_evidence = createSwarmTool({
 // src/tools/write-final-council-evidence.ts
 init_zod();
 init_loader();
-import fs109 from "node:fs";
+import fs110 from "node:fs";
 import path140 from "node:path";
 init_utils2();
 init_manager();
@@ -117586,10 +117716,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   };
   const evidenceDir = path140.dirname(validatedPath);
   try {
-    await fs109.promises.mkdir(evidenceDir, { recursive: true });
+    await fs110.promises.mkdir(evidenceDir, { recursive: true });
     const tempPath = path140.join(evidenceDir, `.${filename}.tmp`);
-    await fs109.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs109.promises.rename(tempPath, validatedPath);
+    await fs110.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs110.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase: input.phase,
@@ -117645,7 +117775,7 @@ var write_final_council_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs110 from "node:fs";
+import fs111 from "node:fs";
 import path141 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
@@ -117707,10 +117837,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
   }
   const evidenceDir = path141.dirname(validatedPath);
   try {
-    await fs110.promises.mkdir(evidenceDir, { recursive: true });
+    await fs111.promises.mkdir(evidenceDir, { recursive: true });
     const tempPath = path141.join(evidenceDir, `.${filename}.tmp`);
-    await fs110.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs110.promises.rename(tempPath, validatedPath);
+    await fs111.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs111.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -117756,7 +117886,7 @@ var write_hallucination_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs111 from "node:fs";
+import fs112 from "node:fs";
 import path142 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
@@ -117844,10 +117974,10 @@ async function executeWriteMutationEvidence(args2, directory) {
   }
   const evidenceDir = path142.dirname(validatedPath);
   try {
-    await fs111.promises.mkdir(evidenceDir, { recursive: true });
+    await fs112.promises.mkdir(evidenceDir, { recursive: true });
     const tempPath = path142.join(evidenceDir, `.${filename}.tmp`);
-    await fs111.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs111.promises.rename(tempPath, validatedPath);
+    await fs112.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs112.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,