claude-flow-novice 2.14.16 → 2.14.17

package/claude-assets/commands/cfn-loop-cli.md

@@ -15,7 +15,7 @@ Execute CFN Loop using CLI spawning for maximum cost savings (95-98% vs Task too
 ## What is CLI Mode?
 
 **CLI Mode Architecture v3.0 (Enhanced):**
-- Main Chat spawns **single coordinator agent** via Task()
+- Main Chat spawns **single coordinator agent**
 - Enhanced coordinator spawns **all workers via CLI** with protocol compliance
 - CLI agents use **Z.ai custom routing** (when enabled)
 - **Real-time monitoring** with automatic recovery from stuck agents
@@ -77,23 +77,121 @@ Savings: 64% with custom routing, 95-98% vs all-Task
 | Standard | ≥0.75 | ≥0.90 | 10 | 3-4 | Production features |
 | Enterprise | ≥0.85 | ≥0.95 | 15 | 5 | Security, compliance, critical systems |
 
-## 🚨 CRITICAL EXECUTION INSTRUCTIONS
+## How CLI Mode Works
 
-**YOU ARE MAIN CHAT. YOU SPAWN ONLY THE cfn-v3-coordinator AGENT.**
+1. **Main Chat** spawns a single `cfn-v3-coordinator` agent
+2. **Coordinator** orchestrates the entire CFN Loop workflow
+3. **Loop 3** agents implement the solution and validate against quality gates
+4. **Loop 2** agents review and provide validation feedback
+5. **Product Owner** makes the final decision on deliverables
+6. **Background execution** with Redis coordination for scalability
 
-**DO NOT spawn Loop 3 agents (backend-dev, researcher, etc.)**
-**DO NOT spawn Loop 2 agents (reviewer, tester, etc.)**
-**DO NOT spawn product-owner**
+The coordinator handles all agent spawning internally using optimized CLI processes.
 
-The coordinator handles ALL agent spawning internally via enhanced CLI mode v3.0.
+## CLI Mode Benefits
+
+**Cost Savings:**
+- 64% savings with Z.ai routing vs all-Anthropic
+- 95-98% savings vs Task tool spawning
+- Scales linearly with iterations (Task mode scales exponentially)
+
+**Production Features v3.0:**
+- Background execution (no timeout issues)
+- Redis state persistence (crash recovery)
+- Zero-token waiting (BLPOP blocks without API calls)
+- Web portal visibility (http://localhost:3000)
+- **Enhanced monitoring**: Real-time agent progress tracking
+- **Automatic recovery**: Dead process cleanup and agent restart
+- **Protocol compliance**: Prevents "consensus on vapor" anti-patterns
+- **Progress visibility**: Detailed reports with timestamps and health status
+
+**Performance:**
+- Parallel agent spawning (no sequential bottleneck)
+- Instant wake-up (<100ms latency)
+- Scalable (10+ agents, indefinite cycles)
+
+## When to Use CLI Mode
+
+**Use CLI Mode for:**
+- ✅ Production features
+- ✅ Long-running tasks (>10 min)
+- ✅ Multi-iteration workflows
+- ✅ Cost-sensitive projects
+- ✅ Background execution
+
+**Use Task Mode for:**
+- Debugging (full visibility needed)
+- Learning CFN Loop workflow
+- Short prototypes (<5 min)
+- Single-iteration tasks
+
+## Troubleshooting
+
+**Custom routing not working:**
+```bash
+/switch-api status  # Check current provider
+/switch-api zai     # Enable Z.ai routing
+```
+
+**Coordinator timeout:**
+- Expected for long tasks (>10 min)
+- Check web portal for progress: http://localhost:3000
+- Query Redis: `redis-cli HGETALL "cfn_loop:task:$TASK_ID:context"`
+
+**No deliverables created:**
+- Orchestrator validates deliverables before PROCEED
+- Will force ITERATE if git diff shows zero changes
+- Check coordinator output for validation failures
+
+**Web Portal Access:**
+- Monitor real-time agent progress at http://localhost:3000
+- View detailed execution logs and health status
+- Track iteration progress and confidence scores
+
+## Usage Examples
+
+**Simple API Development:**
+```bash
+/cfn-loop-cli "Build REST API with user authentication"
+```
+
+**Complex Feature with High Quality Requirements:**
+```bash
+/cfn-loop-cli "Implement payment processing with PCI compliance" --mode=enterprise --max-iterations=15
+```
+
+**Quick Prototype:**
+```bash
+/cfn-loop-cli "Build MVP landing page" --mode=mvp
+```
+
+**Infrastructure Deployment:**
+```bash
+/cfn-loop-cli "Set up CI/CD pipeline for microservices"
+```
+
+## Related Commands
+
+- **Task Mode**: `/cfn-loop-task` (debugging, full visibility)
+- **Frontend**: `/cfn-loop-frontend` (visual iteration workflow)
+- **Documentation**: `/cfn-loop-document` (generate docs)
+
+## Related Documentation
+
+- Task Mode Guide: `.claude/commands/cfn/CFN_LOOP_TASK_MODE.md`
+- Coordinator Parameters: `.claude/commands/cfn/CFN_COORDINATOR_PARAMETERS.md`
+- Redis Coordination: `.claude/skills/cfn-redis-coordination/SKILL.md`
+- Orchestration: `.claude/skills/cfn-loop-orchestration/SKILL.md`
 
 ---
 
-### Execute This Task() Call:
+## 🚨 EXECUTION INSTRUCTIONS (Internal Use)
+
+**Main Chat: Execute this Task() call after slash command processing:**
 
 ```javascript
 Task("cfn-v3-coordinator", `
-  CFN LOOP CLI MODE - ENHANCED PRODUCTION EXECUTION v3.0
+  CFN LOOP CLI MODE v3.0 - PRODUCTION EXECUTION WITH ENHANCED MONITORING
 
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   TASK SPECIFICATION
@@ -103,6 +201,8 @@ Task("cfn-v3-coordinator", `
   Task ID: cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}
   Mode: ${mode.toUpperCase()}
 
+  Enhanced Monitoring: Real-time agent tracking, automatic recovery, protocol compliance
+
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   SUCCESS CRITERIA
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -129,6 +229,7 @@ Task("cfn-v3-coordinator", `
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   Mode: ${mode.toUpperCase()}
+  Enhanced Features: Real-time monitoring, automatic recovery, protocol compliance
 
   Loop 3 Agents (Implementation) - SELECT BASED ON TASK:
   Examples:
@@ -145,10 +246,10 @@ Task("cfn-v3-coordinator", `
   Product Owner: product-owner
 
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  ENHANCED EXECUTION INSTRUCTIONS v3.0
+  EXECUTION INSTRUCTIONS (Enhanced v3.0)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  1. INVOKE ENHANCED ORCHESTRATOR (CLI spawning v3.0):
+  1. INVOKE ENHANCED ORCHESTRATOR (CLI spawning with monitoring):
 
      TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
      MODE="${mode}"
@@ -164,16 +265,15 @@ Task("cfn-v3-coordinator", `
        --max-iterations ${maxIterations}
 
   2. ENHANCED ORCHESTRATOR HANDLES v3.0:
-     - **Real-time monitoring** with automatic stuck agent recovery
-     - **Process health checking** and dead process cleanup
-     - **Protocol compliance** preventing "consensus on vapor" anti-patterns
-     - **Progress visibility** with detailed timestamped reports
-     - Spawns all agents via enhanced CLI (background)
-     - Loop 3: Gate check (≥threshold) → PASS/ITERATE
-     - Loop 2: Consensus check (≥threshold) → COMPLETE/ITERATE
-     - Product Owner: PROCEED/ITERATE/ABORT decision
-     - Git commit/push on PROCEED
-     - Returns structured result to Main Chat
+     - ✅ Spawns all agents via CLI (background) with protocol compliance
+     - ✅ Real-time agent progress monitoring and stuck detection
+     - ✅ Automatic recovery from dead processes
+     - ✅ Enhanced context validation prevents "consensus on vapor"
+     - ✅ Loop 3: Gate check (≥threshold) → PASS/ITERATE with health verification
+     - ✅ Loop 2: Consensus check (≥threshold) → COMPLETE/ITERATE
+     - ✅ Product Owner: PROCEED/ITERATE/ABORT decision with deliverable validation
+     - ✅ Git commit/push on PROCEED
+     - ✅ Returns structured result to Main Chat
 
   3. RETURN STRUCTURED RESULT:
      {
@@ -186,90 +286,26 @@ Task("cfn-v3-coordinator", `
          "pending": [...]
        },
        "deliverables": [...],
+       "enhancedMonitoring": {
+         "agentHealth": "healthy|recovered",
+         "processRecovery": true,
+         "protocolCompliance": true
+       },
        "recommendations": [...]
      }
 
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  CRITICAL RULES
+  CRITICAL ENHANCED RULES v3.0
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  - DO NOT spawn agents with Task() - orchestrator uses enhanced CLI
-  - ALL agents run in background via npx claude-flow-novice
-  - USE Redis BLPOP for loop dependencies
-  - AGENTS use Z.ai routing automatically (when enabled)
-  - ORCHESTRATOR provides real-time monitoring and recovery
-  - RETURN structured result when complete
+  - ✅ USE enhanced orchestration script with real-time monitoring
+  - ✅ ALL agents run in background via npx claude-flow-novice (enhanced v3.0)
+  - ✅ USE Redis BLPOP for loop dependencies (zero-token coordination)
+  - ✅ AGENTS use Z.ai routing automatically (when enabled)
+  - ✅ ENFORCE protocol compliance (prevent "consensus on vapor")
+  - ✅ MONITOR agent health and auto-recover stuck processes
+  - ✅ RETURN structured result with enhanced monitoring data
 `, "cfn-v3-coordinator")
 ```
 
-## CLI Mode Benefits
-
-**Cost Savings:**
-- 64% savings with Z.ai routing vs all-Anthropic
-- 95-98% savings vs Task tool spawning
-- Scales linearly with iterations (Task mode scales exponentially)
-
-**Production Features v3.0:**
-- Background execution (no timeout issues)
-- Redis state persistence (crash recovery)
-- Zero-token waiting (BLPOP blocks without API calls)
-- Web portal visibility (http://localhost:3000)
-- **Enhanced monitoring**: Real-time agent progress tracking
-- **Automatic recovery**: Dead process cleanup and agent restart
-- **Protocol compliance**: Prevents "consensus on vapor" anti-patterns
-- **Progress visibility**: Detailed reports with timestamps and health status
-
-**Performance:**
-- Parallel agent spawning (no sequential bottleneck)
-- Instant wake-up (<100ms latency)
-- Scalable (10+ agents, indefinite cycles)
-
-## When to Use CLI Mode
-
-**Use CLI Mode for:**
-- ✅ Production features
-- ✅ Long-running tasks (>10 min)
-- ✅ Multi-iteration workflows
-- ✅ Cost-sensitive projects
-- ✅ Background execution
-
-**Use Task Mode for:**
-- Debugging (full visibility needed)
-- Learning CFN Loop workflow
-- Short prototypes (<5 min)
-- Single-iteration tasks
-
-## Troubleshooting
-
-**Custom routing not working:**
-```bash
-/switch-api status  # Check current provider
-/switch-api zai     # Enable Z.ai routing
-```
-
-**Coordinator timeout:**
-- Expected for long tasks (>10 min)
-- Check web portal for progress: http://localhost:3000
-- Query Redis: `redis-cli HGETALL "cfn_loop:task:$TASK_ID:context"`
-
-**No deliverables created:**
-- Orchestrator validates deliverables before PROCEED
-- Will force ITERATE if git diff shows zero changes
-- Check coordinator output for validation failures
-
-## Related Commands
-
-- **Task Mode**: `/cfn-loop-task` (debugging, full visibility)
-- **Frontend**: `/cfn-loop-frontend` (visual iteration workflow)
-- **Documentation**: `/cfn-loop-document` (generate docs)
-
-## Related Documentation
-
-- Task Mode Guide: `.claude/commands/cfn/CFN_LOOP_TASK_MODE.md`
-- Coordinator Parameters: `.claude/commands/cfn/CFN_COORDINATOR_PARAMETERS.md`
-- Redis Coordination: `.claude/skills/cfn-redis-coordination/SKILL.md`
-- Orchestration: `.claude/skills/cfn-loop-orchestration/SKILL.md`
-
----
-
-**Version:** 1.0.0 (2025-10-31) - CLI mode: production execution, cost-optimized, background processing
+**Version:** 3.0.0 (2025-11-05) - Enhanced CLI mode: production execution with real-time monitoring, automatic recovery, and protocol compliance

package/dist/agents/agent-loader.js

@@ -1,145 +1,12 @@
-"use strict";
 /**
  * Dynamic Agent Loader - Reads agent definitions from .claude/agents/ directory
  * Single source of truth for agent types in the system
- */ var __awaiter = this && this.__awaiter || function(thisArg, _arguments, P, generator) {
-    function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-            resolve(value);
-        });
-    }
-    return new (P || (P = Promise))(function(resolve, reject) {
-        function fulfilled(value) {
-            try {
-                step(generator.next(value));
-            } catch (e) {
-                reject(e);
-            }
-        }
-        function rejected(value) {
-            try {
-                step(generator["throw"](value));
-            } catch (e) {
-                reject(e);
-            }
-        }
-        function step(result) {
-            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-        }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = this && this.__generator || function(thisArg, body) {
-    var _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-        return this;
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-};
-var __spreadArray = this && this.__spreadArray || function(to, from, pack) {
-    if (pack || arguments.length === 2) for(var i = 0, l = from.length, ar; i < l; i++){
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.refreshAgents = exports.getAgentsByCategory = exports.isValidAgentType = exports.searchAgents = exports.getAgentCategories = exports.getAllAgents = exports.getAgent = exports.getAvailableAgentTypes = exports.agentLoader = exports.AgentLoader = void 0;
-exports.resolveLegacyAgentType = resolveLegacyAgentType;
-var node_fs_1 = require("node:fs");
-var glob_1 = require("glob");
-var node_path_1 = require("node:path");
-var yaml_1 = require("yaml");
+ */ import { readFileSync, existsSync } from 'node:fs';
+import { glob } from 'glob';
+import { resolve, dirname } from 'node:path';
+import { parse as parseYaml } from 'yaml';
 // Legacy agent type mapping for backward compatibility
-var LEGACY_AGENT_MAPPING = {
+const LEGACY_AGENT_MAPPING = {
     analyst: 'code-analyzer',
     coordinator: 'hierarchical-coordinator',
     optimizer: 'perf-analyzer',
@@ -150,40 +17,38 @@ var LEGACY_AGENT_MAPPING = {
 };
 /**
  * Resolve legacy agent types to current equivalents
- */ function resolveLegacyAgentType(legacyType) {
+ */ export function resolveLegacyAgentType(legacyType) {
     return LEGACY_AGENT_MAPPING[legacyType] || legacyType;
 }
-var AgentLoader = /** @class */ function() {
-    function AgentLoader() {
-        this.agentCache = new Map();
-        this.categoriesCache = [];
-        this.lastLoadTime = 0;
-        this.CACHE_EXPIRY = 60000; // 1 minute cache
-    }
-    AgentLoader.prototype.getAgentsDirectory = function() {
-        var currentDir = process.cwd();
+export class AgentLoader {
+    agentCache = new Map();
+    categoriesCache = [];
+    lastLoadTime = 0;
+    CACHE_EXPIRY = 60_000;
+    getAgentsDirectory() {
+        let currentDir = process.cwd();
         while(currentDir !== '/'){
-            var claudeAgentsPath = (0, node_path_1.resolve)(currentDir, '.claude', 'agents');
-            if ((0, node_fs_1.existsSync)(claudeAgentsPath)) {
+            const claudeAgentsPath = resolve(currentDir, '.claude', 'agents');
+            if (existsSync(claudeAgentsPath)) {
                 return claudeAgentsPath;
             }
-            currentDir = (0, node_path_1.dirname)(currentDir);
+            currentDir = dirname(currentDir);
         }
-        return (0, node_path_1.resolve)(process.cwd(), '.claude', 'agents');
-    };
-    AgentLoader.prototype.parseAgentFile = function(filePath) {
+        return resolve(process.cwd(), '.claude', 'agents');
+    }
+    parseAgentFile(filePath) {
         try {
-            var content = (0, node_fs_1.readFileSync)(filePath, 'utf-8');
-            var frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+            const content = readFileSync(filePath, 'utf-8');
+            const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
             if (!frontmatterMatch) {
-                console.warn("No frontmatter found in ".concat(filePath));
+                console.warn(`No frontmatter found in ${filePath}`);
                 return null;
             }
-            var yamlContent = frontmatterMatch[1], markdownContent = frontmatterMatch[2];
-            var frontmatter = (0, yaml_1.parse)(yamlContent);
-            var description = frontmatter.description;
+            const [, yamlContent, markdownContent] = frontmatterMatch;
+            const frontmatter = parseYaml(yamlContent);
+            const description = frontmatter.description;
             if (!frontmatter.name || !description) {
-                console.warn("Missing required fields (name, description) in ".concat(filePath));
+                console.warn(`Missing required fields (name, description) in ${filePath}`);
                 return null;
             }
             return {
@@ -204,13 +69,129 @@ var AgentLoader = /** @class */ function() {
                 content: markdownContent.trim()
             };
         } catch (error) {
-            console.error("Error parsing agent file ".concat(filePath, ":"), error);
+            console.error(`Error parsing agent file ${filePath}:`, error);
             return null;
         }
-    };
-    AgentLoader.prototype.parseTools = function(frontmatter) {
-        var extractTools = function(input) {
+    }
+    parseTools(frontmatter) {
+        const extractTools = (input)=>{
             if (Array.isArray(input)) return input.map(String);
+            if (typeof input === 'string') {
+                return input.split(/[,\s]+/).map((t)=>t.trim()).filter((t)=>t.length > 0);
+            }
+            return [];
+        };
+        // Safely handle tools and capabilities.tools
+        const toolsFromFrontmatter = frontmatter.tools ? extractTools(frontmatter.tools) : [];
+        const toolsFromCapabilities = frontmatter.capabilities && typeof frontmatter.capabilities === 'object' ? extractTools(Object(frontmatter.capabilities).tools) : [];
+        return [
+            ...toolsFromFrontmatter,
+            ...toolsFromCapabilities
+        ];
+    }
+    async loadAgents() {
+        const agentsDir = this.getAgentsDirectory();
+        if (!existsSync(agentsDir)) {
+            console.warn(`Agents directory not found: ${agentsDir}`);
+            return;
+        }
+        const agentFiles = await new Promise((resolve, reject)=>{
+            glob('**/*.md', {
+                cwd: agentsDir,
+                ignore: [
+                    '**/README.md',
+                    '**/MIGRATION_SUMMARY.md'
+                ],
+                absolute: true
+            }, (err, matches)=>{
+                if (err) reject(err);
+                else resolve(matches);
+            });
+        });
+        this.agentCache.clear();
+        this.categoriesCache = [];
+        const categoryMap = new Map();
+        for (const filePath of agentFiles){
+            const agent = this.parseAgentFile(filePath);
+            if (agent) {
+                this.agentCache.set(agent.name, agent);
+                const relativePath = filePath.replace(agentsDir, '');
+                const pathParts = relativePath.split('/');
+                const category = pathParts[1] || 'uncategorized';
+                if (!categoryMap.has(category)) {
+                    categoryMap.set(category, []);
+                }
+                categoryMap.get(category).push(agent);
+            }
+        }
+        this.categoriesCache = Array.from(categoryMap.entries()).map(([name, agents])=>({
+                name,
+                agents: agents.sort((a, b)=>a.name.localeCompare(b.name))
+            }));
+        this.lastLoadTime = Date.now();
+    }
+    // Rest of the methods remain similar to the original implementation
+    needsRefresh() {
+        return Date.now() - this.lastLoadTime > this.CACHE_EXPIRY;
+    }
+    async ensureLoaded() {
+        if (this.agentCache.size === 0 || this.needsRefresh()) {
+            await this.loadAgents();
+        }
+    }
+    async getAvailableAgentTypes() {
+        await this.ensureLoaded();
+        const currentTypes = Array.from(this.agentCache.keys());
+        const legacyTypes = Object.keys(LEGACY_AGENT_MAPPING);
+        return Array.from(new Set([
+            ...currentTypes,
+            ...legacyTypes
+        ])).sort();
+    }
+    async getAgent(name) {
+        await this.ensureLoaded();
+        return this.agentCache.get(name) || this.agentCache.get(resolveLegacyAgentType(name)) || null;
+    }
+    async getAllAgents() {
+        await this.ensureLoaded();
+        return Array.from(this.agentCache.values()).sort((a, b)=>a.name.localeCompare(b.name));
+    }
+    async getAgentCategories() {
+        await this.ensureLoaded();
+        return this.categoriesCache;
+    }
+    async searchAgents(query) {
+        await this.ensureLoaded();
+        const lowerQuery = query.toLowerCase();
+        return Array.from(this.agentCache.values()).filter((agent)=>agent.name.toLowerCase().includes(lowerQuery) || agent.description.toLowerCase().includes(lowerQuery) || agent.capabilities?.some((cap)=>cap.toLowerCase().includes(lowerQuery)));
+    }
+    async isValidAgentType(name) {
+        await this.ensureLoaded();
+        return this.agentCache.has(name) || this.agentCache.has(resolveLegacyAgentType(name));
+    }
+    async getAgentsByCategory(category) {
+        const categories = await this.getAgentCategories();
+        const found = categories.find((cat)=>cat.name === category);
+        return found?.agents || [];
+    }
+    async refresh() {
+        this.lastLoadTime = 0;
+        await this.loadAgents();
+    }
+}
+// Singleton instance
+export const agentLoader = new AgentLoader();
+// Convenience exports for use in other modules
+export const getAvailableAgentTypes = ()=>agentLoader.getAvailableAgentTypes();
+export const getAgent = (name)=>agentLoader.getAgent(name);
+export const getAllAgents = ()=>agentLoader.getAllAgents();
+export const getAgentCategories = ()=>agentLoader.getAgentCategories();
+export const searchAgents = (query)=>agentLoader.searchAgents(query);
+export const isValidAgentType = (name)=>agentLoader.isValidAgentType(name);
+export const getAgentsByCategory = (category)=>agentLoader.getAgentsByCategory(category);
+export const refreshAgents = ()=>agentLoader.refresh();
+
+//# sourceMappingURL=agent-loader.js.map.isArray(input)) return input.map(String);
             if (typeof input === 'string') {
                 return input.split(/[,\s]+/).map(function(t) {
                     return t.trim();