opencode-swarm 6.24.0 → 6.25.1

package/dist/index.js

@@ -65,6 +65,7 @@ var init_tool_names = __esm(() => {
     "schema_drift",
     "todo_extract",
     "evidence_check",
+    "check_gate_status",
     "sbom_generate",
     "checkpoint",
     "pkg_audit",
@@ -141,6 +142,7 @@ var init_constants = __esm(() => {
   AGENT_TOOL_MAP = {
     architect: [
       "checkpoint",
+      "check_gate_status",
       "complexity_hotspots",
       "detect_domains",
       "evidence_check",
@@ -37457,8 +37459,8 @@ var init_tree_sitter = __esm(() => {
         bytes = Promise.resolve(input);
       } else {
         if (globalThis.process?.versions.node) {
-          const fs27 = await import("fs/promises");
-          bytes = fs27.readFile(input);
+          const fs28 = await import("fs/promises");
+          bytes = fs28.readFile(input);
         } else {
           bytes = fetch(input).then((response) => response.arrayBuffer().then((buffer) => {
             if (response.ok) {
@@ -37490,8 +37492,8 @@ ${JSON.stringify(symbolNames, null, 2)}`);
       var moduleRtn;
       var Module = moduleArg;
       var readyPromiseResolve, readyPromiseReject;
-      var readyPromise = new Promise((resolve13, reject) => {
-        readyPromiseResolve = resolve13;
+      var readyPromise = new Promise((resolve14, reject) => {
+        readyPromiseResolve = resolve14;
         readyPromiseReject = reject;
       });
       var ENVIRONMENT_IS_WEB = typeof window == "object";
@@ -37513,11 +37515,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path40) {
+      function locateFile(path41) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path40, scriptDirectory);
+          return Module["locateFile"](path41, scriptDirectory);
         }
-        return scriptDirectory + path40;
+        return scriptDirectory + path41;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -37571,13 +37573,13 @@ ${JSON.stringify(symbolNames, null, 2)}`);
           }
           readAsync = /* @__PURE__ */ __name(async (url3) => {
             if (isFileURI(url3)) {
-              return new Promise((resolve13, reject) => {
+              return new Promise((resolve14, reject) => {
                 var xhr = new XMLHttpRequest;
                 xhr.open("GET", url3, true);
                 xhr.responseType = "arraybuffer";
                 xhr.onload = () => {
                   if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                    resolve13(xhr.response);
+                    resolve14(xhr.response);
                     return;
                   }
                   reject(xhr.status);
@@ -37797,10 +37799,10 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         __name(receiveInstantiationResult, "receiveInstantiationResult");
         var info2 = getWasmImports();
         if (Module["instantiateWasm"]) {
-          return new Promise((resolve13, reject) => {
+          return new Promise((resolve14, reject) => {
             Module["instantiateWasm"](info2, (mod, inst) => {
               receiveInstance(mod, inst);
-              resolve13(mod.exports);
+              resolve14(mod.exports);
             });
           });
         }
@@ -39265,7 +39267,7 @@ var init_runtime = __esm(() => {
 });
 
 // src/index.ts
-import * as path49 from "path";
+import * as path50 from "path";
 
 // src/agents/index.ts
 init_config();
@@ -39280,6 +39282,36 @@ var ARCHITECT_PROMPT = `You are Architect - orchestrator of a multi-agent swarm.
 Swarm: {{SWARM_ID}}
 Your agents: {{AGENT_PREFIX}}explorer, {{AGENT_PREFIX}}sme, {{AGENT_PREFIX}}coder, {{AGENT_PREFIX}}reviewer, {{AGENT_PREFIX}}test_engineer, {{AGENT_PREFIX}}critic, {{AGENT_PREFIX}}docs, {{AGENT_PREFIX}}designer
 
+## PROJECT CONTEXT
+Session-start priming block. Use any known values immediately; if a field is still unresolved, run MODE: DISCOVER before relying on it.
+Language: {{PROJECT_LANGUAGE}}
+Framework: {{PROJECT_FRAMEWORK}}
+Build command: {{BUILD_CMD}}
+Test command: {{TEST_CMD}}
+Lint command: {{LINT_CMD}}
+Entry points: {{ENTRY_POINTS}}
+
+If any field is \`{{...}}\` (unresolved): run MODE: DISCOVER to populate it, then cache in \`.swarm/context.md\` under \`## Project Context\`.
+
+## CONTEXT TRIAGE
+When approaching context limits, preserve/discard in this priority order:
+
+ALWAYS PRESERVE:
+- Current task spec (FILE, TASK, CONSTRAINT, ACCEPTANCE)
+- Last gate verdicts (reviewer, test_engineer, critic)
+- Active \`.swarm/plan.md\` task list (statuses)
+- Unresolved blockers
+
+COMPRESS (keep verdict, discard detail):
+- Prior phase gate outputs
+- Completed task specs from earlier phases
+
+DISCARD:
+- Superseded SME cache entries (older than current phase)
+- Resolved blocker details
+- Old retry histories for completed tasks
+- Explorer output for areas no longer in scope
+
 ## ROLE
 
 You THINK. Subagents DO. You have the largest context window and strongest reasoning. Subagents have smaller contexts and weaker reasoning. Your job:
@@ -39541,7 +39573,8 @@ Available Tools: symbols (code symbol search), checkpoint (state snapshots), dif
 
 ## DELEGATION FORMAT
 
-All delegations use this structure:
+All delegations MUST use this exact structure (MANDATORY \u2014 malformed delegations will be rejected):
+Do NOT add conversational preamble before the agent prefix. Begin directly with the agent name.
 
 {{AGENT_PREFIX}}[agent]
 TASK: [single objective]
@@ -39609,7 +39642,7 @@ OUTPUT: Test file + VERDICT: PASS/FAIL
 {{AGENT_PREFIX}}explorer
 TASK: Integration impact analysis
 INPUT: Contract changes detected: [list from diff tool]
-OUTPUT: BREAKING CHANGES + CONSUMERS AFFECTED + VERDICT: BREAKING/COMPATIBLE
+OUTPUT: BREAKING_CHANGES + COMPATIBLE_CHANGES + CONSUMERS_AFFECTED + VERDICT: BREAKING/COMPATIBLE + MIGRATION_NEEDED
 CONSTRAINT: Read-only. grep for imports/usages of changed exports.
 
 {{AGENT_PREFIX}}docs
@@ -39866,6 +39899,12 @@ PHASE COUNT GUIDANCE:
 
 Also create .swarm/context.md with: decisions made, patterns identified, SME cache entries, and relevant file map.
 
+TRACEABILITY CHECK (run after plan is written, when spec.md exists):
+- Every FR-### in spec.md MUST map to at least one task \u2192 unmapped FRs = coverage gap, flag to user
+- Every task MUST reference its source FR-### in the description or acceptance field \u2192 tasks with no FR = potential gold-plating, flag to critic
+- Report: "TRACEABILITY: [N] FRs mapped, [M] unmapped FRs (gap), [K] tasks with no FR mapping (gold-plating risk)"
+- If no spec.md: skip this check silently.
+
 ### MODE: CRITIC-GATE
 Delegate plan to {{AGENT_PREFIX}}critic for review BEFORE any implementation begins.
 - Send the full plan.md content and codebase context summary
@@ -39924,7 +39963,7 @@ All other gates: failure \u2192 return to coder. No self-fixes. No workarounds.
 \u2192 After step 5a (or immediately if no UI task applies): Call update_task_status with status in_progress for the current task. Then proceed to step 5b.
 
 5b. {{AGENT_PREFIX}}coder - Implement (if designer scaffold produced, include it as INPUT).
-5c. Run \`diff\` tool. If \`hasContractChanges\` \u2192 {{AGENT_PREFIX}}explorer integration analysis. BREAKING \u2192 coder retry.
+5c. Run \`diff\` tool. If \`hasContractChanges\` \u2192 {{AGENT_PREFIX}}explorer integration analysis. If VERDICT=BREAKING or MIGRATION_NEEDED=yes \u2192 coder retry. If VERDICT=COMPATIBLE and MIGRATION_NEEDED=no \u2192 proceed.
     \u2192 REQUIRED: Print "diff: [PASS | CONTRACT CHANGE \u2014 details]"
     5d. Run \`syntax_check\` tool. SYNTACTIC ERRORS \u2192 return to coder. NO ERRORS \u2192 proceed to placeholder_scan.
     \u2192 REQUIRED: Print "syntaxcheck: [PASS | FAIL \u2014 N errors]"
@@ -40055,7 +40094,7 @@ The tool will automatically write the retrospective to \`.swarm/evidence/retro-{
 4. Write retrospective evidence: record phase, total_tool_calls, coder_revisions, reviewer_rejections, test_failures, security_findings, integration_issues, task_count, task_complexity, top_rejection_reasons, lessons_learned to .swarm/evidence/ via write_retro. Reset Phase Metrics in context.md to 0.
 4.5. Run \`evidence_check\` to verify all completed tasks have required evidence (review + test). If gaps found, note in retrospective lessons_learned. Optionally run \`pkg_audit\` if dependencies were modified during this phase. Optionally run \`schema_drift\` if API routes were modified during this phase.
 5. Run \`sbom_generate\` with scope='changed' to capture post-implementation dependency snapshot (saved to \`.swarm/evidence/sbom/\`). This is a non-blocking step - always proceeds to summary.
-5.5. If \`.swarm/spec.md\` exists: delegate {{AGENT_PREFIX}}critic with DRIFT-CHECK context \u2014 include phase number, list of completed task IDs and descriptions, and evidence path (\`.swarm/evidence/\`). If SIGNIFICANT DRIFT is returned: surface as a warning to the user before proceeding. If spec.md does not exist: skip silently.
+5.5. If \`.swarm/spec.md\` exists: delegate {{AGENT_PREFIX}}critic with DRIFT-CHECK context \u2014 include phase number, list of completed task IDs and descriptions, and evidence path (\`.swarm/evidence/\`). If spec alignment is anything other than ALIGNED (MINOR_DRIFT, MAJOR_DRIFT, OFF_SPEC): surface as a warning to the user before proceeding. If spec.md does not exist: skip silently.
 6. Summarize to user
 7. Ask: "Ready for Phase [N+1]?"
 
@@ -40171,6 +40210,13 @@ RULES:
 - PREFER \`const\` over \`let\`; never use \`var\`
 - When modifying existing code, MATCH the surrounding style (indentation, quote style, semicolons)
 
+## CROSS-PLATFORM RULES
+- Use \`path.join()\` or \`path.resolve()\` for ALL file paths \u2014 never hardcode \`/\` or \`\\\` separators
+- Use \`os.EOL\` or \`\\n\` consistently \u2014 never use \`\\r\\n\` literals in source
+- File operations: use \`fs.promises\` (async) unless synchronous is explicitly required by the task
+- Avoid shell commands in code \u2014 use Node.js APIs (\`fs\`, \`child_process\` with \`shell: false\`)
+- Consider case-sensitivity: Linux filesystems are case-sensitive; Windows and macOS are not
+
 ## ERROR HANDLING
 When your implementation encounters an error or unexpected state:
 1. DO NOT silently swallow errors
@@ -40188,6 +40234,10 @@ Do NOT prepend "Here's what I changed..." or any conversational preamble.
 
 DONE: [one-line summary]
 CHANGED: [file]: [what changed]
+EXPORTS_ADDED: [new exported functions/types/classes, or "none"]
+EXPORTS_REMOVED: [removed exports, or "none"]
+EXPORTS_MODIFIED: [exports with changed signatures, or "none"]
+DEPS_ADDED: [new external package imports, or "none"]
 BLOCKED: [what went wrong]
 NEED: [what additional context or change would fix it]
 
@@ -40195,9 +40245,18 @@ AUTHOR BLINDNESS WARNING:
 Your output is NOT reviewed, tested, or approved until the Architect runs the full QA gate.
 Do NOT add commentary like "this looks good," "should be fine," or "ready for production."
 You wrote the code. You cannot objectively evaluate it. That is what the gates are for.
-Output only one of:
-- DONE [one-line summary] / CHANGED [file] [what changed]
-- BLOCKED [what went wrong] / NEED [what additional context or change would fix it]
+Output only one of these structured templates:
+- Completed task:
+  DONE: [one-line summary]
+  CHANGED: [file]: [what changed]
+  EXPORTS_ADDED: [new exported functions/types/classes, or "none"]
+  EXPORTS_REMOVED: [removed exports, or "none"]
+  EXPORTS_MODIFIED: [exports with changed signatures, or "none"]
+  DEPS_ADDED: [new external package imports, or "none"]
+  SELF-AUDIT: [print the checklist below with [x]/[ ] status for every line]
+- Blocked task:
+  BLOCKED: [what went wrong]
+  NEED: [what additional context or change would fix it]
 
 SELF-AUDIT (run before marking any task complete):
 Before you report task completion, verify:
@@ -40286,7 +40345,19 @@ REVIEW CHECKLIST:
 - Task Atomicity: Does any single task touch 2+ files or contain compound verbs ("implement X and add Y and update Z")? Flag as MAJOR \u2014 oversized tasks blow coder's context and cause downstream gate failures. Suggested fix: Split into sequential single-file tasks before proceeding.
 - Governance Compliance (conditional): If \`.swarm/context.md\` contains a \`## Project Governance\` section, read the MUST and SHOULD rules and validate the plan against them. MUST rule violations are CRITICAL severity. SHOULD rule violations are recommendation-level (note them but do not block approval). If no \`## Project Governance\` section exists in context.md, skip this check silently.
 
-OUTPUT FORMAT:
+## PLAN ASSESSMENT DIMENSIONS
+Evaluate ALL seven dimensions. Report any that fail:
+1. TASK ATOMICITY: Can each task be completed and QA'd independently?
+2. DEPENDENCY CORRECTNESS: Are dependencies declared? Is the execution order valid?
+3. BLAST RADIUS: Does any single task touch too many files or systems? (>2 files = flag)
+4. ROLLBACK SAFETY: If a phase fails midway, can it be reverted without data loss?
+5. TESTING STRATEGY: Does the plan account for test creation alongside implementation?
+6. CROSS-PLATFORM RISK: Do any tasks assume platform-specific behavior (path separators, shell commands, OS APIs)?
+7. MIGRATION RISK: Do any tasks require state migration (DB schema, config format, file structure)?
+
+OUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected):
+Begin directly with VERDICT. Do NOT prepend "Here's my review..." or any conversational preamble.
+
 VERDICT: APPROVED | NEEDS_REVISION | REJECTED
 CONFIDENCE: HIGH | MEDIUM | LOW
 ISSUES: [max 5 issues, each with: severity (CRITICAL/MAJOR/MINOR), description, suggested fix]
@@ -40332,7 +40403,9 @@ STEPS:
    - Tasks missing FILE, TASK, CONSTRAINT, or ACCEPTANCE fields: LOW severity.
    - Tasks with compound verbs: LOW severity.
 
-OUTPUT FORMAT:
+OUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected):
+Begin directly with VERDICT. Do NOT prepend "Here's my analysis..." or any conversational preamble.
+
 VERDICT: CLEAN | GAPS FOUND | DRIFT DETECTED
 COVERAGE TABLE: [FR-### | Covering Tasks \u2014 list up to top 10; if more than 10 items, show "showing 10 of N" and note total count]
 GAPS: [top 10 gaps with severity \u2014 if more than 10 items, show "showing 10 of N"]
@@ -40354,22 +40427,37 @@ Activates when: Architect delegates with DRIFT-CHECK context after completing a
 
 DEFAULT POSTURE: SKEPTICAL \u2014 absence of drift \u2260 evidence of alignment.
 
-TRAJECTORY-LEVEL EVALUATION: Review sequence from Phase 1\u2192N. Look for compounding drift \u2014 small deviations that collectively pull project off-spec.
+DISAMBIGUATION: ANALYZE detects spec-plan divergence before implementation. DRIFT-CHECK detects spec-execution divergence after implementation. Your job is to find drift, not to confirm alignment.
+
+TRAJECTORY-LEVEL EVALUATION: Review sequence from Phase 1 through the current phase (1\u2192N). Look for compounding drift \u2014 small deviations that collectively pull project off-spec.
 
-FIRST-ERROR FOCUS: When drift detected, identify EARLIEST deviation point. Do not enumerate all downstream consequences. Report root deviation and recommend correction at source.
+FIRST-ERROR FOCUS: When drift detected, identify the EARLIEST point where deviation began. Do not enumerate all downstream consequences. Report the root deviation and recommend correction at source.
 
 INPUT: Phase number (from "DRIFT-CHECK phase N"). Ask if not provided.
 
 STEPS:
 1. Read spec.md \u2014 extract FR-### requirements for phase.
 2. Read plan.md \u2014 extract tasks marked complete ([x]) for Phases 1\u2192N.
-3. Read evidence files for phases 1\u2192N.
+3. Read evidence files for all phases 1\u2192N. If evidence files are missing, proceed with available data and note the gap.
 4. Compare implementation against FR-###. Look for: scope additions, omissions, assumption changes.
 5. Classify: CRITICAL (core req not met), HIGH (significant scope), MEDIUM (minor), LOW (stylistic).
 6. If drift: identify FIRST deviation (Phase X, Task Y) and compounding effects.
-7. Produce report. Architect saves to .swarm/evidence/phase-{N}-drift.md.
+7. If phase N has no completed tasks, report "no tasks found for phase N" and stop.
+8. Produce report. Architect saves to .swarm/evidence/phase-{N}-drift.md.
+
+## DRIFT-CHECK SCORING
+Calculate and report quantitative metrics:
+- COVERAGE: (implemented FRs / total FRs) \xD7 100 = COVERAGE %
+- GOLD-PLATING: (tasks with no FR mapping / total tasks) \xD7 100 = GOLD-PLATING %
+- Alignment thresholds (use the worst applicable match):
+  - ALIGNED: COVERAGE \u2265 90% and GOLD-PLATING \u2264 10% and no HIGH/CRITICAL findings
+  - MINOR_DRIFT: COVERAGE \u2265 75% and GOLD-PLATING \u2264 25% and no CRITICAL findings
+  - MAJOR_DRIFT: COVERAGE \u2265 50% and GOLD-PLATING \u2264 40%, or any HIGH finding
+  - OFF_SPEC: COVERAGE < 50%, GOLD-PLATING > 40%, or any CRITICAL finding / core requirement missed
+
+OUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected):
+Begin directly with DRIFT-CHECK RESULT. Do NOT prepend conversational preamble.
 
-OUTPUT FORMAT:
 DRIFT-CHECK RESULT:
 Phase reviewed: [N]
 Spec alignment: ALIGNED | MINOR_DRIFT | MAJOR_DRIFT | OFF_SPEC
@@ -40383,9 +40471,9 @@ Spec alignment: ALIGNED | MINOR_DRIFT | MAJOR_DRIFT | OFF_SPEC
 VERBOSITY CONTROL: ALIGNED = 3-4 lines. MAJOR_DRIFT = full output. No padding.
 
 DRIFT-CHECK RULES:
-- Advisory only
+- Advisory only \u2014 does NOT block phase transitions
 - READ-ONLY: no file modifications
-- If no spec.md, stop immediately
+- If spec.md is missing, report missing and stop immediately
 
 ---
 
@@ -40495,7 +40583,29 @@ DESIGN CHECKLIST:
    - Transitions and animations (duration, easing)
    - Optimistic updates where applicable
 
-OUTPUT FORMAT:
+## DESIGN SYSTEM DETECTION
+Before producing a scaffold:
+1. Check for existing design system files: \`tailwind.config.*\`, \`theme.ts\`, \`design-tokens.json\`, shadcn components in \`components/ui/\`
+2. Check for existing component library: detect existing Button, Input, Modal, Card components
+3. REUSE existing components \u2014 do NOT create new ones that duplicate existing functionality
+4. Match the project's existing CSS approach (Tailwind classes, CSS modules, styled-components, etc.)
+5. If no design system is detected: use sensible Tailwind defaults and flag: "No design system detected \u2014 scaffold uses generic Tailwind classes"
+
+WRONG: Creating a new \`<Button>\` component when \`components/ui/button.tsx\` already exists
+RIGHT: Importing and using the existing \`<Button>\` component
+
+## RESPONSIVE APPROACH
+Design MOBILE-FIRST:
+1. Base styles apply to mobile (< 640px) \u2014 this is the default
+2. Add tablet overrides with \`sm:\` prefix (640px\u20131024px)
+3. Add desktop overrides with \`lg:\` prefix (> 1024px)
+
+WRONG: Desktop-first design that uses \`max-width\` media queries to shrink for mobile
+RIGHT: Base = mobile, \`sm:\` = tablet, \`lg:\` = desktop
+
+## OUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected)
+Begin directly with the code scaffold. Do NOT prepend "Here's the design..." or any conversational preamble.
+
 Produce a CODE SCAFFOLD in the target framework. This is a skeleton file with:
 - Component structure with typed props and proper imports
 - Layout structure using the project's CSS framework (Tailwind classes, CSS modules, styled-components, etc.)
@@ -40662,6 +40772,14 @@ WORKFLOW:
 - Inline comments explaining obvious code (code should be self-documenting)
 - TODO comments in code (those go through the task system, not code comments)
 
+## QUALITY RULES
+- Code examples in docs MUST be syntactically valid \u2014 test them mentally against the actual code
+- API examples MUST show both a success case AND an error/edge case
+- Parameter descriptions MUST include: type, required/optional, and default value (if any)
+- NEVER document internal implementation details in public-facing docs
+- MATCH existing documentation tone and style exactly \u2014 do not change voice or formatting conventions
+- If you find existing docs that are INCORRECT based on the code changes you're reviewing, FIX THEM \u2014 do not leave known inaccuracies
+
 RULES:
 - Be accurate: documentation MUST match the actual code behavior
 - Be concise: update only what changed, do not rewrite entire files
@@ -40767,6 +40885,25 @@ DOMAINS: [relevant SME domains: powershell, security, python, etc.]
 
 REVIEW NEEDED:
 - [path]: [why, which SME]
+
+## INTEGRATION IMPACT ANALYSIS MODE
+Activates when delegated with "Integration impact analysis" or INPUT lists contract changes.
+
+INPUT: List of contract changes (from diff tool output \u2014 changed exports, signatures, types)
+
+STEPS:
+1. For each changed export: grep the codebase for imports and usages of that symbol
+2. Classify each change: BREAKING (callers must update) or COMPATIBLE (callers unaffected)
+3. List all files that import or use the changed exports
+
+OUTPUT FORMAT (MANDATORY \u2014 deviations will be rejected):
+Begin directly with BREAKING_CHANGES. Do NOT prepend conversational preamble.
+
+BREAKING_CHANGES: [list with affected consumer files, or "none"]
+COMPATIBLE_CHANGES: [list, or "none"]
+CONSUMERS_AFFECTED: [list of files that import/use changed exports, or "none"]
+VERDICT: BREAKING | COMPATIBLE
+MIGRATION_NEEDED: [yes \u2014 description of required caller updates | no]
 `;
 function createExplorerAgent(model, customPrompt, customAppendPrompt) {
   let prompt = EXPLORER_PROMPT;
@@ -40885,6 +41022,7 @@ VERDICT: APPROVED | REJECTED
 RISK: LOW | MEDIUM | HIGH | CRITICAL
 ISSUES: list with line numbers, grouped by CHECK dimension
 FIXES: required changes if rejected
+Use INFO only inside ISSUES for non-blocking suggestions. RISK reflects the highest blocking severity, so it never uses INFO.
 
 ## RULES
 - Be specific with line numbers
@@ -40892,11 +41030,17 @@ FIXES: required changes if rejected
 - Don't reject for style if functionally correct
 - No code modifications
 
-## RISK LEVELS
-- LOW: defense in depth improvements
-- MEDIUM: fix before production
-- HIGH: must fix
-- CRITICAL: blocks approval
+## SEVERITY CALIBRATION
+Use these definitions precisely \u2014 do not inflate severity:
+- CRITICAL: Will crash, corrupt data, or bypass security at runtime. Blocks approval. Must fix before merge.
+- HIGH: Logic error that produces wrong results in realistic scenarios. Should fix before merge.
+- MEDIUM: Edge case that could fail under unusual but possible conditions. Recommended fix.
+- LOW: Code smell, readability concern, or minor optimization opportunity. Optional.
+- INFO: Suggestion for future improvement. Not a blocker.
+
+CALIBRATION RULE \u2014 If you find NO issues, state this explicitly:
+"NO ISSUES FOUND \u2014 Reviewed [N] changed functions. Preconditions verified for: [list]. Edge cases considered: [list]. No logic errors, security concerns, or contract changes detected."
+A blank APPROVED without reasoning is NOT acceptable \u2014 it indicates you did not actually review.
 
 `;
 function createReviewerAgent(model, customPrompt, customAppendPrompt) {
@@ -40981,6 +41125,30 @@ PLATFORM: [cross-platform notes if OS-interaction APIs]
 GOTCHAS: [common pitfalls or edge cases]
 DEPS: [required dependencies/tools]
 
+## DOMAIN CHECKLISTS
+Apply the relevant checklist when the DOMAIN matches:
+
+### SECURITY domain
+- [ ] OWASP Top 10 considered for the relevant attack surface
+- [ ] Input validation strategy defined (allowlist, not denylist)
+- [ ] Authentication/authorization model clear and least-privilege
+- [ ] Secret management approach specified (no hardcoded secrets)
+- [ ] Error messages do not leak internal implementation details
+
+### CROSS-PLATFORM domain
+- [ ] Path handling: \`path.join()\` not string concatenation
+- [ ] Line endings: consistent handling (\`os.EOL\` or \`\\n\`)
+- [ ] File system: case sensitivity considered (Linux = case-sensitive)
+- [ ] Shell commands: cross-platform alternatives identified
+- [ ] Node.js APIs: no platform-specific APIs without fallbacks
+
+### PERFORMANCE domain
+- [ ] Time complexity analyzed (O(n) vs O(n\xB2) for realistic input sizes)
+- [ ] Memory allocation patterns reviewed (no unnecessary object creation in hot paths)
+- [ ] I/O operations minimized (batch where possible)
+- [ ] Caching strategy considered
+- [ ] Streaming vs. buffering decision made for large data
+
 ## RULES
 - Be specific: exact names, paths, parameters, versions
 - Be concise: under 1500 characters
@@ -41140,6 +41308,20 @@ COVERAGE FLOOR: If you tested fewer than 80% of public functions, report:
 INCOMPLETE \u2014 [N] of [M] public functions tested. Missing: [list of untested functions]
 Do NOT report PASS/FAIL until coverage is at least 80%.
 
+## ADVERSARIAL TEST PATTERNS
+When writing adversarial or security-focused tests, cover these attack categories:
+
+- OVERSIZED INPUT: Strings > 10KB, arrays > 100K elements, deeply nested objects (100+ levels)
+- TYPE CONFUSION: Pass number where string expected, object where array expected, null where object expected
+- INJECTION: SQL fragments, HTML/script tags (\`<script>alert(1)</script>\`), template literals (\`\${...}\`), path traversal (\`../\`)
+- UNICODE: Null bytes (\`\\x00\`), RTL override characters, zero-width spaces, emoji, combining characters
+- BOUNDARY: \`Number.MAX_SAFE_INTEGER\`, \`-0\`, \`NaN\`, \`Infinity\`, empty string vs null vs undefined
+- AUTH BYPASS: Missing headers, expired tokens, tokens for wrong users, malformed JWT structure
+- CONCURRENCY: Simultaneous calls to same function/endpoint, race conditions on shared state
+- FILESYSTEM: Paths with spaces, Unicode filenames, symlinks, paths that would escape workspace
+
+For each adversarial test: assert a SPECIFIC outcome (error thrown, value rejected, sanitized output) \u2014 not just "it doesn't crash."
+
 ## EXECUTION VERIFICATION
 
 After writing tests, you MUST run them. A test file that was written but never executed is NOT a deliverable.
@@ -41335,6 +41517,7 @@ function getAgentConfigs(config2) {
     };
     if (agent.name === "architect" || agent.name.endsWith("_architect")) {
       sdkConfig.mode = "primary";
+      sdkConfig.permission = { task: "allow" };
     } else {
       sdkConfig.mode = "subagent";
     }
@@ -52800,12 +52983,139 @@ var build_check = createSwarmTool({
     return JSON.stringify(result, null, 2);
   }
 });
+// src/tools/check-gate-status.ts
+init_dist();
+init_create_tool();
+import * as fs19 from "fs";
+import * as path32 from "path";
+var EVIDENCE_DIR = ".swarm/evidence";
+function isPathWithinSwarm(filePath, workspaceRoot) {
+  const normalizedWorkspace = path32.resolve(workspaceRoot);
+  const swarmPath = path32.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path32.resolve(filePath);
+  return normalizedPath.startsWith(swarmPath);
+}
+function readEvidenceFile(evidencePath) {
+  if (!fs19.existsSync(evidencePath)) {
+    return null;
+  }
+  let content;
+  try {
+    content = fs19.readFileSync(evidencePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed.required_gates) && typeof parsed.gates === "object" && parsed.gates !== null) {
+    return parsed;
+  }
+  return null;
+}
+var check_gate_status = createSwarmTool({
+  description: "Read-only tool to check the gate status of a specific task. Reads .swarm/evidence/{taskId}.json and returns structured JSON describing required, passed, and missing gates.",
+  args: {
+    task_id: tool.schema.string().min(1).regex(/^\d+\.\d+(\.\d+)?$/, "Task ID must be in N.M or N.M.P format").describe('The task ID to check gate status for (e.g., "1.1", "2.3.1")')
+  },
+  async execute(args2, directory) {
+    let taskIdInput;
+    try {
+      if (args2 && typeof args2 === "object") {
+        const obj = args2;
+        taskIdInput = typeof obj.task_id === "string" ? obj.task_id : undefined;
+      }
+    } catch {}
+    if (!taskIdInput) {
+      const errorResult = {
+        taskId: "",
+        status: "no_evidence",
+        required_gates: [],
+        passed_gates: [],
+        missing_gates: [],
+        gates: {},
+        message: "Invalid task_id: task_id is required"
+      };
+      return JSON.stringify(errorResult, null, 2);
+    }
+    const taskIdPattern = /^\d+\.\d+(\.\d+)?$/;
+    if (!taskIdPattern.test(taskIdInput)) {
+      const errorResult = {
+        taskId: taskIdInput,
+        status: "no_evidence",
+        required_gates: [],
+        passed_gates: [],
+        missing_gates: [],
+        gates: {},
+        message: `Invalid task_id format: "${taskIdInput}". Must match pattern N.M or N.M.P (e.g., "1.1", "1.2.3")`
+      };
+      return JSON.stringify(errorResult, null, 2);
+    }
+    const evidencePath = path32.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    if (!isPathWithinSwarm(evidencePath, directory)) {
+      const errorResult = {
+        taskId: taskIdInput,
+        status: "no_evidence",
+        required_gates: [],
+        passed_gates: [],
+        missing_gates: [],
+        gates: {},
+        message: "Invalid path: evidence path validation failed"
+      };
+      return JSON.stringify(errorResult, null, 2);
+    }
+    const evidenceData = readEvidenceFile(evidencePath);
+    if (!evidenceData) {
+      const errorResult = {
+        taskId: taskIdInput,
+        status: "no_evidence",
+        required_gates: [],
+        passed_gates: [],
+        missing_gates: [],
+        gates: {},
+        message: `No evidence file found for task "${taskIdInput}" at ${evidencePath}. Evidence file may be missing or invalid.`
+      };
+      return JSON.stringify(errorResult, null, 2);
+    }
+    const requiredGates = evidenceData.required_gates || [];
+    const gatesMap = evidenceData.gates || {};
+    const passedGates = [];
+    const missingGates = [];
+    for (const requiredGate of requiredGates) {
+      if (gatesMap[requiredGate]) {
+        passedGates.push(requiredGate);
+      } else {
+        missingGates.push(requiredGate);
+      }
+    }
+    const status = missingGates.length === 0 ? "all_passed" : "incomplete";
+    let message;
+    if (status === "all_passed") {
+      message = `All required gates have passed for task "${taskIdInput}".`;
+    } else {
+      message = `Task "${taskIdInput}" is incomplete. Missing gates: ${missingGates.join(", ")}.`;
+    }
+    const result = {
+      taskId: taskIdInput,
+      status,
+      required_gates: requiredGates,
+      passed_gates: passedGates,
+      missing_gates: missingGates,
+      gates: gatesMap,
+      message
+    };
+    return JSON.stringify(result, null, 2);
+  }
+});
 // src/tools/checkpoint.ts
 init_tool();
 init_create_tool();
 import { spawnSync } from "child_process";
-import * as fs19 from "fs";
-import * as path32 from "path";
+import * as fs20 from "fs";
+import * as path33 from "path";
 var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json";
 var MAX_LABEL_LENGTH = 100;
 var GIT_TIMEOUT_MS = 30000;
@@ -52856,13 +53166,13 @@ function validateLabel(label) {
   return null;
 }
 function getCheckpointLogPath(directory) {
-  return path32.join(directory, CHECKPOINT_LOG_PATH);
+  return path33.join(directory, CHECKPOINT_LOG_PATH);
 }
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
   try {
-    if (fs19.existsSync(logPath)) {
-      const content = fs19.readFileSync(logPath, "utf-8");
+    if (fs20.existsSync(logPath)) {
+      const content = fs20.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -52874,13 +53184,13 @@ function readCheckpointLog(directory) {
 }
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
-  const dir = path32.dirname(logPath);
-  if (!fs19.existsSync(dir)) {
-    fs19.mkdirSync(dir, { recursive: true });
+  const dir = path33.dirname(logPath);
+  if (!fs20.existsSync(dir)) {
+    fs20.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs19.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs19.renameSync(tempPath, logPath);
+  fs20.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs20.renameSync(tempPath, logPath);
 }
 function gitExec(args2) {
   const result = spawnSync("git", args2, {
@@ -53081,8 +53391,8 @@ var checkpoint = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_dist();
 init_create_tool();
-import * as fs20 from "fs";
-import * as path33 from "path";
+import * as fs21 from "fs";
+import * as path34 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
 var DEFAULT_TOP_N = 20;
@@ -53211,11 +53521,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs20.statSync(filePath);
+    const stat2 = fs21.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs20.readFileSync(filePath, "utf-8");
+    const content = fs21.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -53226,7 +53536,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path33.extname(file3).toLowerCase();
+    const ext = path34.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -53236,8 +53546,8 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs20.existsSync(fullPath)) {
-      fullPath = path33.join(cwd, file3);
+    if (!fs21.existsSync(fullPath)) {
+      fullPath = path34.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
     if (complexity !== null) {
@@ -53384,8 +53694,8 @@ var complexity_hotspots = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs21 from "fs";
-import * as path34 from "path";
+import * as fs22 from "fs";
+import * as path35 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
   const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
@@ -53464,8 +53774,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path34.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path34.sep);
+    normalizedDir = path35.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path35.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -53475,11 +53785,11 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path34.resolve(normalizedDir);
+    const resolvedDir = path35.resolve(normalizedDir);
     try {
-      const realPath = fs21.realpathSync(resolvedDir);
-      const planPath2 = path34.join(realPath, ".swarm", "plan.json");
-      if (!fs21.existsSync(planPath2)) {
+      const realPath = fs22.realpathSync(resolvedDir);
+      const planPath2 = path35.join(realPath, ".swarm", "plan.json");
+      if (!fs22.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -53499,8 +53809,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
   }
   const directory = normalizedDir ?? fallbackDir ?? process.cwd();
-  const planPath = path34.resolve(directory, ".swarm", "plan.json");
-  if (!fs21.existsSync(planPath)) {
+  const planPath = path35.resolve(directory, ".swarm", "plan.json");
+  if (!fs22.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -53509,7 +53819,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs21.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs22.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -53589,20 +53899,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path35 of paths) {
-    if (!path35 || path35.length === 0) {
+  for (const path36 of paths) {
+    if (!path36 || path36.length === 0) {
       return "empty path not allowed";
     }
-    if (path35.length > MAX_PATH_LENGTH) {
+    if (path36.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path35)) {
+    if (SHELL_METACHARACTERS2.test(path36)) {
       return "path contains shell metacharacters";
     }
-    if (path35.startsWith("-")) {
+    if (path36.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path35)) {
+    if (CONTROL_CHAR_PATTERN2.test(path36)) {
       return "path contains control characters";
     }
   }
@@ -53682,8 +53992,8 @@ var diff = tool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path35 = parts2[2];
-          files.push({ path: path35, additions, deletions });
+          const path36 = parts2[2];
+          files.push({ path: path36, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -53912,11 +54222,11 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs22 from "fs";
-import * as path35 from "path";
+import * as fs23 from "fs";
+import * as path36 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
-var EVIDENCE_DIR = ".swarm/evidence";
+var EVIDENCE_DIR2 = ".swarm/evidence";
 var PLAN_FILE = ".swarm/plan.md";
 var SHELL_METACHAR_REGEX2 = /[;&|%$`\\]/;
 var VALID_EVIDENCE_FILENAME_REGEX = /^[a-zA-Z0-9_-]+\.json$/;
@@ -53935,10 +54245,10 @@ function validateRequiredTypes(input) {
   }
   return null;
 }
-function isPathWithinSwarm(filePath, cwd) {
-  const normalizedCwd = path35.resolve(cwd);
-  const swarmPath = path35.join(normalizedCwd, ".swarm");
-  const normalizedPath = path35.resolve(filePath);
+function isPathWithinSwarm2(filePath, cwd) {
+  const normalizedCwd = path36.resolve(cwd);
+  const swarmPath = path36.join(normalizedCwd, ".swarm");
+  const normalizedPath = path36.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -53954,12 +54264,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs22.existsSync(evidenceDir) || !fs22.statSync(evidenceDir).isDirectory()) {
+  if (!fs23.existsSync(evidenceDir) || !fs23.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs22.readdirSync(evidenceDir);
+    files = fs23.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -53968,14 +54278,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path35.join(evidenceDir, filename);
+    const filePath = path36.join(evidenceDir, filename);
     try {
-      const resolvedPath = path35.resolve(filePath);
-      const evidenceDirResolved = path35.resolve(evidenceDir);
+      const resolvedPath = path36.resolve(filePath);
+      const evidenceDirResolved = path36.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs22.lstatSync(filePath);
+      const stat2 = fs23.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -53984,7 +54294,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs22.statSync(filePath);
+      fileStat = fs23.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -53993,7 +54303,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs22.readFileSync(filePath, "utf-8");
+      content = fs23.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -54078,8 +54388,8 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
-    const planPath = path35.join(cwd, PLAN_FILE);
-    if (!isPathWithinSwarm(planPath, cwd)) {
+    const planPath = path36.join(cwd, PLAN_FILE);
+    if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
         completedTasks: [],
@@ -54092,7 +54402,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs22.readFileSync(planPath, "utf-8");
+      planContent = fs23.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -54110,7 +54420,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path35.join(cwd, EVIDENCE_DIR);
+    const evidenceDir = path36.join(cwd, EVIDENCE_DIR2);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -54127,8 +54437,8 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs23 from "fs";
-import * as path36 from "path";
+import * as fs24 from "fs";
+import * as path37 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -54190,8 +54500,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs23.existsSync(targetDir)) {
-      fs23.mkdirSync(targetDir, { recursive: true });
+    if (!fs24.existsSync(targetDir)) {
+      fs24.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -54209,16 +54519,16 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path36.join(targetDir, filename);
-      const base = path36.basename(filepath, path36.extname(filepath));
-      const ext = path36.extname(filepath);
+      let filepath = path37.join(targetDir, filename);
+      const base = path37.basename(filepath, path37.extname(filepath));
+      const ext = path37.extname(filepath);
       let counter = 1;
-      while (fs23.existsSync(filepath)) {
-        filepath = path36.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs24.existsSync(filepath)) {
+        filepath = path37.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs23.writeFileSync(filepath, code.trim(), "utf-8");
+        fs24.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -54247,7 +54557,7 @@ init_dist();
 var GITINGEST_TIMEOUT_MS = 1e4;
 var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
 var GITINGEST_MAX_RETRIES = 2;
-var delay = (ms) => new Promise((resolve12) => setTimeout(resolve12, ms));
+var delay = (ms) => new Promise((resolve13) => setTimeout(resolve13, ms));
 async function fetchGitingest(args2) {
   for (let attempt = 0;attempt <= GITINGEST_MAX_RETRIES; attempt++) {
     try {
@@ -54331,8 +54641,8 @@ var gitingest = tool({
 });
 // src/tools/imports.ts
 init_dist();
-import * as fs24 from "fs";
-import * as path37 from "path";
+import * as fs25 from "fs";
+import * as path38 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
@@ -54386,7 +54696,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path37.extname(filePath).toLowerCase();
+  const ext = path38.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -54410,15 +54720,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path37.resolve(targetFile);
+    _resolvedTarget = path38.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path37.basename(targetFile, path37.extname(targetFile));
+  const targetBasename = path38.basename(targetFile, path38.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path37.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path37.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path38.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path38.normalize(targetWithoutExt).replace(/\\/g, "/");
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
   for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
     const modulePath = match[1] || match[2] || match[3];
@@ -54441,9 +54751,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path37.dirname(targetFile);
-    const targetExt = path37.extname(targetFile);
-    const targetBasenameNoExt = path37.basename(targetFile, targetExt);
+    const _targetDir = path38.dirname(targetFile);
+    const targetExt = path38.extname(targetFile);
+    const targetBasenameNoExt = path38.basename(targetFile, targetExt);
     const moduleNormalized = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
     const moduleName = modulePath.split(/[/\\]/).pop() || "";
     const moduleNameNoExt = moduleName.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
@@ -54500,7 +54810,7 @@ var SKIP_DIRECTORIES2 = new Set([
 function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs24.readdirSync(dir);
+    entries = fs25.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -54511,13 +54821,13 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES2.has(entry)) {
-      stats.skippedDirs.push(path37.join(dir, entry));
+      stats.skippedDirs.push(path38.join(dir, entry));
       continue;
     }
-    const fullPath = path37.join(dir, entry);
+    const fullPath = path38.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs24.statSync(fullPath);
+      stat2 = fs25.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -54528,7 +54838,7 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat2.isDirectory()) {
       findSourceFiles2(fullPath, files, stats);
     } else if (stat2.isFile()) {
-      const ext = path37.extname(fullPath).toLowerCase();
+      const ext = path38.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -54584,8 +54894,8 @@ var imports = tool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path37.resolve(file3);
-      if (!fs24.existsSync(targetFile)) {
+      const targetFile = path38.resolve(file3);
+      if (!fs25.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -54595,7 +54905,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs24.statSync(targetFile);
+      const targetStat = fs25.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -54606,7 +54916,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path37.dirname(targetFile);
+      const baseDir = path38.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -54621,12 +54931,12 @@ var imports = tool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs24.statSync(filePath);
+          const stat2 = fs25.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs24.readFileSync(filePath);
+          const buffer = fs25.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -54691,7 +55001,7 @@ var imports = tool({
 });
 // src/tools/knowledge-query.ts
 init_dist();
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 init_create_tool();
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
@@ -54761,14 +55071,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync25(swarmPath)) {
+  if (!existsSync26(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync25(hivePath)) {
+  if (!existsSync26(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -54927,8 +55237,8 @@ init_dist();
 init_config();
 init_schema();
 init_manager();
-import * as fs25 from "fs";
-import * as path38 from "path";
+import * as fs26 from "fs";
+import * as path39 from "path";
 init_utils2();
 init_create_tool();
 function safeWarn(message, error93) {
@@ -55123,7 +55433,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path38.basename(dir);
+      const projectName = path39.basename(dir);
       const knowledgeConfig = {
         enabled: true,
         swarm_max_entries: 100,
@@ -55171,7 +55481,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs25.readFileSync(planPath, "utf-8");
+      const planRaw = fs26.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && targetPhase.tasks.every((t) => t.status === "completed")) {
@@ -55212,7 +55522,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs25.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs26.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)}`);
@@ -55231,12 +55541,12 @@ async function executePhaseComplete(args2, workingDirectory) {
     }
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planJson = fs25.readFileSync(planPath, "utf-8");
+      const planJson = fs26.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planJson);
       const phaseObj = plan.phases.find((p) => p.id === phase);
       if (phaseObj) {
         phaseObj.status = "completed";
-        fs25.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
+        fs26.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
 `, "utf-8");
       }
     } catch (error93) {
@@ -55286,8 +55596,8 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs26 from "fs";
-import * as path39 from "path";
+import * as fs27 from "fs";
+import * as path40 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -55305,28 +55615,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs26.existsSync(path39.join(cwd, "package.json"))) {
+  if (fs27.existsSync(path40.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs26.existsSync(path39.join(cwd, "pyproject.toml")) || fs26.existsSync(path39.join(cwd, "requirements.txt"))) {
+  if (fs27.existsSync(path40.join(cwd, "pyproject.toml")) || fs27.existsSync(path40.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs26.existsSync(path39.join(cwd, "Cargo.toml"))) {
+  if (fs27.existsSync(path40.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs26.existsSync(path39.join(cwd, "go.mod"))) {
+  if (fs27.existsSync(path40.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs26.readdirSync(cwd);
+    const files = fs27.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs26.existsSync(path39.join(cwd, "Gemfile")) || fs26.existsSync(path39.join(cwd, "Gemfile.lock"))) {
+  if (fs27.existsSync(path40.join(cwd, "Gemfile")) || fs27.existsSync(path40.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs26.existsSync(path39.join(cwd, "pubspec.yaml"))) {
+  if (fs27.existsSync(path40.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -55339,7 +55649,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -55462,7 +55772,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -55593,7 +55903,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -55720,7 +56030,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -55856,7 +56166,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -55975,7 +56285,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -56122,7 +56432,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -56388,8 +56698,8 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs29 from "fs";
-import * as path42 from "path";
+import * as fs30 from "fs";
+import * as path43 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -56480,26 +56790,26 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run2 = async (function_, resolve13, arguments_2) => {
+  const run2 = async (function_, resolve14, arguments_2) => {
     const result = (async () => function_(...arguments_2))();
-    resolve13(result);
+    resolve14(result);
     try {
       await result;
     } catch {}
     next();
   };
-  const enqueue = (function_, resolve13, reject, arguments_2) => {
+  const enqueue = (function_, resolve14, reject, arguments_2) => {
     const queueItem = { reject };
     new Promise((internalResolve) => {
       queueItem.run = internalResolve;
       queue.enqueue(queueItem);
-    }).then(run2.bind(undefined, function_, resolve13, arguments_2));
+    }).then(run2.bind(undefined, function_, resolve14, arguments_2));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_2) => new Promise((resolve13, reject) => {
-    enqueue(function_, resolve13, reject, arguments_2);
+  const generator = (function_, ...arguments_2) => new Promise((resolve14, reject) => {
+    enqueue(function_, resolve14, reject, arguments_2);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -56556,8 +56866,8 @@ init_lint();
 init_manager();
 
 // src/quality/metrics.ts
-import * as fs27 from "fs";
-import * as path40 from "path";
+import * as fs28 from "fs";
+import * as path41 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -56595,11 +56905,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs27.statSync(filePath);
+    const stat2 = fs28.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs27.readFileSync(filePath, "utf-8");
+    const content = fs28.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -56609,8 +56919,8 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path40.isAbsolute(file3) ? file3 : path40.join(workingDir, file3);
-    if (!fs27.existsSync(fullPath)) {
+    const fullPath = path41.isAbsolute(file3) ? file3 : path41.join(workingDir, file3);
+    if (!fs28.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -56731,8 +57041,8 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs27.readFileSync(filePath, "utf-8");
-    const ext = path40.extname(filePath).toLowerCase();
+    const content = fs28.readFileSync(filePath, "utf-8");
+    const ext = path41.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -56758,8 +57068,8 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path40.isAbsolute(file3) ? file3 : path40.join(workingDir, file3);
-    if (!fs27.existsSync(fullPath)) {
+    const fullPath = path41.isAbsolute(file3) ? file3 : path41.join(workingDir, file3);
+    if (!fs28.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -56792,16 +57102,16 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path40.isAbsolute(file3) ? file3 : path40.join(workingDir, file3);
-    if (!fs27.existsSync(fullPath)) {
+    const fullPath = path41.isAbsolute(file3) ? file3 : path41.join(workingDir, file3);
+    if (!fs28.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs27.statSync(fullPath);
+      const stat2 = fs28.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES5) {
         continue;
       }
-      const content = fs27.readFileSync(fullPath, "utf-8");
+      const content = fs28.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -56825,8 +57135,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename8 = path40.basename(filePath);
-  const _ext = path40.extname(filePath).toLowerCase();
+  const basename8 = path41.basename(filePath);
+  const _ext = path41.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -56907,8 +57217,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path41, glob) {
-  const normalizedPath = path41.replace(/\\/g, "/");
+function matchesGlobSegment(path42, glob) {
+  const normalizedPath = path42.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -56939,8 +57249,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path41, glob) {
-  const normalizedPath = path41.replace(/\\/g, "/");
+function globMatches(path42, glob) {
+  const normalizedPath = path42.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -56976,31 +57286,31 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path40.join(workingDir, "src");
-  if (fs27.existsSync(srcDir)) {
+  const srcDir = path41.join(workingDir, "src");
+  if (fs28.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path40.join(workingDir, dir);
-    if (fs27.existsSync(dirPath)) {
+    const dirPath = path41.join(workingDir, dir);
+    if (fs28.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path40.join(workingDir, "tests");
-  if (fs27.existsSync(testsDir)) {
+  const testsDir = path41.join(workingDir, "tests");
+  if (fs28.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path40.join(workingDir, dir);
-    if (fs27.existsSync(dirPath) && dirPath !== testsDir) {
+    const dirPath = path41.join(workingDir, dir);
+    if (fs28.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -57012,9 +57322,9 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs27.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs28.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path40.join(dirPath, entry.name);
+      const fullPath = path41.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -57022,7 +57332,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${process.cwd()}/`, "");
-        const ext = path40.extname(entry.name).toLowerCase();
+        const ext = path41.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -57058,7 +57368,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs27.readFileSync(fullPath, "utf-8");
+          const content = fs28.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -57272,8 +57582,8 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs28 from "fs";
-import * as path41 from "path";
+import * as fs29 from "fs";
+import * as path42 from "path";
 import { extname as extname9 } from "path";
 
 // src/sast/rules/c.ts
@@ -58021,7 +58331,7 @@ function mapSemgrepSeverity(severity) {
   }
 }
 async function executeWithTimeout(command, args2, options) {
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     const child = spawn(command, args2, {
       shell: false,
       cwd: options.cwd
@@ -58030,7 +58340,7 @@ async function executeWithTimeout(command, args2, options) {
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve13({
+      resolve14({
         stdout,
         stderr: "Process timed out",
         exitCode: 124
@@ -58044,7 +58354,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve13({
+      resolve14({
         stdout,
         stderr,
         exitCode: code ?? 0
@@ -58052,7 +58362,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve13({
+      resolve14({
         stdout,
         stderr: err2.message,
         exitCode: 1
@@ -58140,17 +58450,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs28.statSync(filePath);
+    const stats = fs29.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES6) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs28.openSync(filePath, "r");
+    const fd = fs29.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs28.readSync(fd, buffer, 0, 8192, 0);
-    fs28.closeSync(fd);
+    const bytesRead = fs29.readSync(fd, buffer, 0, 8192, 0);
+    fs29.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -58189,7 +58499,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs28.readFileSync(filePath, "utf-8");
+    const content = fs29.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -58236,8 +58546,8 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path41.isAbsolute(filePath) ? filePath : path41.resolve(directory, filePath);
-    if (!fs28.existsSync(resolvedPath)) {
+    const resolvedPath = path42.isAbsolute(filePath) ? filePath : path42.resolve(directory, filePath);
+    if (!fs29.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -58435,18 +58745,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path42.win32.resolve(inputPath);
-  } else if (path42.isAbsolute(inputPath)) {
-    resolved = path42.resolve(inputPath);
+    resolved = path43.win32.resolve(inputPath);
+  } else if (path43.isAbsolute(inputPath)) {
+    resolved = path43.resolve(inputPath);
   } else {
-    resolved = path42.resolve(baseDir, inputPath);
+    resolved = path43.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path42.resolve(workspaceDir);
+  const workspaceResolved = path43.resolve(workspaceDir);
   let relative5;
   if (isWinAbs) {
-    relative5 = path42.win32.relative(workspaceResolved, resolved);
+    relative5 = path43.win32.relative(workspaceResolved, resolved);
   } else {
-    relative5 = path42.relative(workspaceResolved, resolved);
+    relative5 = path43.relative(workspaceResolved, resolved);
   }
   if (relative5.startsWith("..")) {
     return "path traversal detected";
@@ -58507,13 +58817,13 @@ async function runLintWrapped(files, directory, _config) {
 }
 async function runLintOnFiles(linter, files, workspaceDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path42.join(workspaceDir, "node_modules", ".bin");
+  const binDir = path43.join(workspaceDir, "node_modules", ".bin");
   const validatedFiles = [];
   for (const file3 of files) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path42.resolve(file3);
+    const resolvedPath = path43.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -58531,10 +58841,10 @@ async function runLintOnFiles(linter, files, workspaceDir) {
   }
   let command;
   if (linter === "biome") {
-    const biomeBin = isWindows ? path42.join(binDir, "biome.EXE") : path42.join(binDir, "biome");
+    const biomeBin = isWindows ? path43.join(binDir, "biome.EXE") : path43.join(binDir, "biome");
     command = [biomeBin, "check", ...validatedFiles];
   } else {
-    const eslintBin = isWindows ? path42.join(binDir, "eslint.cmd") : path42.join(binDir, "eslint");
+    const eslintBin = isWindows ? path43.join(binDir, "eslint.cmd") : path43.join(binDir, "eslint");
     command = [eslintBin, ...validatedFiles];
   }
   try {
@@ -58671,7 +58981,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path42.resolve(file3);
+      const resolvedPath = path43.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -58689,14 +58999,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path42.extname(file3).toLowerCase();
+      const ext = path43.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat2;
       try {
-        stat2 = fs29.statSync(file3);
+        stat2 = fs30.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -58707,7 +59017,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs29.readFileSync(file3);
+        const buffer = fs30.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -58848,7 +59158,7 @@ async function runPreCheckBatch(input, workspaceDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path42.resolve(directory, file3));
+    changedFiles.push(path43.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -58999,7 +59309,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path42.resolve(typedArgs.directory);
+    const resolvedDirectory = path43.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory3(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -59106,8 +59416,8 @@ ${paginatedContent}`;
 init_tool();
 init_manager2();
 init_create_tool();
-import * as fs30 from "fs";
-import * as path43 from "path";
+import * as fs31 from "fs";
+import * as path44 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
   const placeholderPattern = /^\[\w[\w\s]*\]$/;
@@ -59211,19 +59521,19 @@ async function executeSavePlan(args2, fallbackDir) {
   try {
     await savePlan(dir, plan);
     try {
-      const markerPath = path43.join(dir, ".swarm", ".plan-write-marker");
+      const markerPath = path44.join(dir, ".swarm", ".plan-write-marker");
       const marker = JSON.stringify({
         source: "save_plan",
         timestamp: new Date().toISOString(),
         phases_count: plan.phases.length,
         tasks_count: tasksCount
       });
-      await fs30.promises.writeFile(markerPath, marker, "utf8");
+      await fs31.promises.writeFile(markerPath, marker, "utf8");
     } catch {}
     return {
       success: true,
       message: "Plan saved successfully",
-      plan_path: path43.join(dir, ".swarm", "plan.json"),
+      plan_path: path44.join(dir, ".swarm", "plan.json"),
       phases_count: plan.phases.length,
       tasks_count: tasksCount
     };
@@ -59261,8 +59571,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs31 from "fs";
-import * as path44 from "path";
+import * as fs32 from "fs";
+import * as path45 from "path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -60108,9 +60418,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs31.readdirSync(dir, { withFileTypes: true });
+      const entries = fs32.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path44.join(dir, entry.name);
+        const fullPath = path45.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -60119,7 +60429,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path44.relative(rootDir, fullPath));
+              manifestFiles.push(path45.relative(rootDir, fullPath));
               break;
             }
           }
@@ -60135,13 +60445,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs31.readdirSync(dir, { withFileTypes: true });
+      const entries = fs32.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path44.join(dir, entry.name);
+        const fullPath = path45.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path44.relative(workingDir, fullPath));
+              found.push(path45.relative(workingDir, fullPath));
               break;
             }
           }
@@ -60154,11 +60464,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path44.dirname(file3);
+    let currentDir = path45.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path44.sep) {
-        dirs.add(path44.join(workingDir, currentDir));
-        const parent = path44.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path45.sep) {
+        dirs.add(path45.join(workingDir, currentDir));
+        const parent = path45.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -60172,7 +60482,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs31.mkdirSync(outputDir, { recursive: true });
+    fs32.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -60242,7 +60552,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path44.isAbsolute(relativeOutputDir) ? relativeOutputDir : path44.join(workingDir, relativeOutputDir);
+    const outputDir = path45.isAbsolute(relativeOutputDir) ? relativeOutputDir : path45.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -60265,11 +60575,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path44.isAbsolute(manifestFile) ? manifestFile : path44.join(workingDir, manifestFile);
-        if (!fs31.existsSync(fullPath)) {
+        const fullPath = path45.isAbsolute(manifestFile) ? manifestFile : path45.join(workingDir, manifestFile);
+        if (!fs32.existsSync(fullPath)) {
           continue;
         }
-        const content = fs31.readFileSync(fullPath, "utf-8");
+        const content = fs32.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -60282,8 +60592,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path44.join(outputDir, filename);
-    fs31.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path45.join(outputDir, filename);
+    fs32.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -60325,8 +60635,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs32 from "fs";
-import * as path45 from "path";
+import * as fs33 from "fs";
+import * as path46 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -60358,28 +60668,28 @@ function normalizePath2(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path45.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path45.sep) ? cwd : cwd + path45.sep;
+    const resolvedPath = path46.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path46.sep) ? cwd : cwd + path46.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path45.extname(resolvedPath).toLowerCase();
+    const ext = path46.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs32.statSync(resolvedPath);
+    const stats = fs33.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs32.existsSync(resolvedPath)) {
+    if (!fs33.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path45.resolve(cwd, candidate);
-    if (fs32.existsSync(candidatePath)) {
-      const stats = fs32.statSync(candidatePath);
+    const candidatePath = path46.resolve(cwd, candidate);
+    if (fs33.existsSync(candidatePath)) {
+      const stats = fs33.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -60388,8 +60698,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs32.readFileSync(specFile, "utf-8");
-  const ext = path45.extname(specFile).toLowerCase();
+  const content = fs33.readFileSync(specFile, "utf-8");
+  const ext = path46.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -60460,12 +60770,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs32.readdirSync(dir, { withFileTypes: true });
+      entries = fs33.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path45.join(dir, entry.name);
+      const fullPath = path46.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -60475,7 +60785,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path45.extname(entry.name).toLowerCase();
+        const ext = path46.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -60493,7 +60803,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs32.readFileSync(filePath, "utf-8");
+  const content = fs33.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;
@@ -60644,8 +60954,8 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs33 from "fs";
-import * as path46 from "path";
+import * as fs34 from "fs";
+import * as path47 from "path";
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsControlCharacters(str) {
@@ -60674,11 +60984,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path46.resolve(workspace, filePath);
-    const realWorkspace = fs33.realpathSync(workspace);
-    const realResolvedPath = fs33.realpathSync(resolvedPath);
-    const relativePath = path46.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path46.isAbsolute(relativePath)) {
+    const resolvedPath = path47.resolve(workspace, filePath);
+    const realWorkspace = fs34.realpathSync(workspace);
+    const realResolvedPath = fs34.realpathSync(resolvedPath);
+    const relativePath = path47.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path47.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -60690,17 +61000,17 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path46.join(cwd, filePath);
+  const fullPath = path47.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs33.statSync(fullPath);
+    const stats = fs34.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs33.readFileSync(fullPath, "utf-8");
+    content = fs34.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -60842,17 +61152,17 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path46.join(cwd, filePath);
+  const fullPath = path47.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs33.statSync(fullPath);
+    const stats = fs34.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs33.readFileSync(fullPath, "utf-8");
+    content = fs34.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -60925,7 +61235,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path46.extname(file3);
+    const ext = path47.extname(file3);
     if (containsControlCharacters(file3)) {
       return JSON.stringify({
         file: file3,
@@ -60996,8 +61306,8 @@ init_test_runner();
 init_dist();
 init_utils();
 init_create_tool();
-import * as fs34 from "fs";
-import * as path47 from "path";
+import * as fs35 from "fs";
+import * as path48 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -61068,9 +61378,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path47.resolve(paths);
-    const normalizedCwd = path47.resolve(cwd);
-    const normalizedResolved = path47.resolve(resolvedPath);
+    const resolvedPath = path48.resolve(paths);
+    const normalizedCwd = path48.resolve(cwd);
+    const normalizedResolved = path48.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -61086,13 +61396,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path47.extname(filePath).toLowerCase();
+  const ext = path48.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
   let entries;
   try {
-    entries = fs34.readdirSync(dir);
+    entries = fs35.readdirSync(dir);
   } catch {
     return files;
   }
@@ -61101,10 +61411,10 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES3.has(entry)) {
       continue;
     }
-    const fullPath = path47.join(dir, entry);
+    const fullPath = path48.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs34.statSync(fullPath);
+      stat2 = fs35.statSync(fullPath);
     } catch {
       continue;
     }
@@ -61197,7 +61507,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs34.existsSync(scanPath)) {
+    if (!fs35.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -61207,13 +61517,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs34.statSync(scanPath);
+    const stat2 = fs35.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path47.extname(scanPath)}`,
+          error: `unsupported file extension: ${path48.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -61226,11 +61536,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs34.statSync(filePath);
+        const fileStat = fs35.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs34.readFileSync(filePath, "utf-8");
+        const content = fs35.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -61259,8 +61569,8 @@ var todo_extract = createSwarmTool({
 init_tool();
 init_schema();
 init_manager2();
-import * as fs35 from "fs";
-import * as path48 from "path";
+import * as fs36 from "fs";
+import * as path49 from "path";
 init_create_tool();
 var VALID_STATUSES2 = [
   "pending",
@@ -61285,8 +61595,8 @@ function checkReviewerGate(taskId, workingDirectory) {
   try {
     const resolvedDir = workingDirectory ?? process.cwd();
     try {
-      const evidencePath = path48.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
-      const raw = fs35.readFileSync(evidencePath, "utf-8");
+      const evidencePath = path49.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
+      const raw = fs36.readFileSync(evidencePath, "utf-8");
       const evidence = JSON.parse(raw);
       if (evidence?.required_gates && Array.isArray(evidence.required_gates) && evidence?.gates) {
         const allGatesMet = evidence.required_gates.every((gate) => evidence.gates[gate] != null);
@@ -61326,8 +61636,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     try {
       const resolvedDir2 = workingDirectory ?? process.cwd();
-      const planPath = path48.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs35.readFileSync(planPath, "utf-8");
+      const planPath = path49.join(resolvedDir2, ".swarm", "plan.json");
+      const planRaw = fs36.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -61437,8 +61747,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path48.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path48.sep);
+    normalizedDir = path49.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path49.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -61448,11 +61758,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path48.resolve(normalizedDir);
+    const resolvedDir = path49.resolve(normalizedDir);
     try {
-      const realPath = fs35.realpathSync(resolvedDir);
-      const planPath = path48.join(realPath, ".swarm", "plan.json");
-      if (!fs35.existsSync(planPath)) {
+      const realPath = fs36.realpathSync(resolvedDir);
+      const planPath = path49.join(realPath, ".swarm", "plan.json");
+      if (!fs36.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -61609,7 +61919,7 @@ var OpenCodeSwarm = async (ctx) => {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path49.resolve(ctx.directory, ".swarm");
+    const swarmDir = path50.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -61703,6 +62013,7 @@ var OpenCodeSwarm = async (ctx) => {
     name: "opencode-swarm",
     agent: agents,
     tool: {
+      check_gate_status,
       checkpoint,
       complexity_hotspots,
       detect_domains,