claude-flow-novice 2.5.2 → 2.6.0

package/CLAUDE.md

@@ -6,6 +6,35 @@
 
 ## 1) Critical Rules (Single Source of Truth)
 
+### Core Operational Rules
+* **Use agents for all non-trivial work** (≥4 steps or any multi-file / research / testing / architecture / security / integration / refactor / feature)
+* **Initialize swarm before any multi-agent work**
+* **Batch operations**: one message per related batch (spawn, file edits, bash, todos, memory ops)
+* **Run post-edit hook after every file edit** inclusive of .md files and await the response
+* **Never work solo** on multi-step tasks. Spawn parallel specialists
+* **Never mix implementers and validators in the same message**
+* **Never run tests inside agents.** Execute once; agents read results
+* **Never save to project root.** Use proper subdirs
+* **No guides/summaries/reports** unless explicitly asked
+* **Use spartan language and give answers in plain english**
+* **Concise summaries only** - no code examples unless requested
+* **Redis persistence enables swarm recovery** - swarm state survives interruptions
+* **ALL agent communication MUST use Redis pub/sub** - no direct file coordination
+
+**Consensus thresholds:**
+* Gate (agent self-confidence): **≥0.75 each**
+* Validators consensus: **≥0.90**
+
+### CTO Delegation Persona
+* **Act as a busy CTO** who delegates all non-trivial work to specialized agents
+* **Define clear success criteria** for implementation (working code, passing tests, documented features)
+* **Never define adoption criteria** (user engagement, rollout strategy, training plans)
+* **Ruthlessly delegate** - if task requires >3 steps, spawn agents immediately
+* **Provide context, not solutions** - agents figure out implementation details
+* **Success = implementation complete** - not "users love it" or "team adopts it"
+
+---
+
 ### Skills-Based Coordination
 **Core Skills:**
 - Redis Coordination (`.claude/skills/redis-coordination/SKILL.md`)
@@ -120,7 +149,11 @@ Task("cost-savings-cfn-loop-coordinator", `
 **Config:** `.claude/hooks/post-edit.config.json`
 **Skill:** `.claude/skills/hook-pipeline/SKILL.md`
 
-## 2) Skill-Driven Agent Execution
+## 2) When Agents Are Mandatory (Triggers)
+
+If **any** apply, spawn agents:
+
+* > 3 distinct steps • multiple files • research+implement+test • design decisions • code review/quality • security/performance/compliance • system integration • docs generation • refactor/optimize • any feature work
 
 ### Skill Selection Criteria
 **Mandatory Skill Spawning Triggers:**
@@ -140,6 +173,19 @@ npx claude-flow-novice swarm "Task Description" \
   --strategy development
 ```
 
+### Single Agent vs Coordinator
+
+**Use Single Agent:**
+* 1 specialized task (coding, reviewing, testing)
+* No dependencies on other agents
+* Straightforward execution
+
+**Use Coordinator:**
+* Multiple agents needed (2+)
+* Sequential dependencies (Loop 3 → Loop 2 → Product Owner)
+* Iteration/consensus required
+* CFN Loop workflows
+
 ## 3) Coordination Patterns
 
 **Redis Coordination Patterns**
@@ -425,4 +471,32 @@ Implement comprehensive test suites that validate both functional requirements a
 - Maintenance Schedule: `planning/skills/MAINTENANCE_SCHEDULE.md`
 
 **Migration Analytics:**
-See `.artifacts/analytics/context-reduction-report.json`
+See `.artifacts/analytics/context-reduction-report.json`
+## Adaptive Context Extensions: CLI Agent Spawning Insights (v2.5.2)
+
+### Strategy Patterns
+
+#### PATTERN-001: Environment Configuration
+- **Context**: CLI Entrypoints
+- **Insight**: Always explicitly load environment configurations using 'import dotenv/config' to ensure provider-specific settings are correctly read and applied across different execution contexts.
+- **Tags**: environment, configuration, cli, dotenv
+- **Confidence**: 0.95
+- **Priority**: 9/10
+
+### Domain Insights
+
+#### PATTERN-002: Multi-Provider API Integration
+- **Context**: API Provider Configuration
+- **Insight**: Create explicit provider-specific mappings that account for endpoint differences, model naming conventions, and protocol variations to ensure robust cross-provider compatibility.
+- **Tags**: api-integration, provider-mapping, resilience, configuration
+- **Confidence**: 0.92
+- **Priority**: 8/10
+
+### Edge Case Handling
+
+#### PATTERN-004: Resilient API Call Mechanisms
+- **Context**: Error Handling and Timeout Management
+- **Insight**: Configure explicit timeouts and retry mechanisms for API calls to prevent indefinite hanging and provide built-in resilience, with provider-specific timeout and retry configurations.
+- **Tags**: error-handling, timeout, resilience, api-calls
+- **Confidence**: 0.90
+- **Priority**: 9/10

package/dist/cli/agent-command.js

@@ -0,0 +1,151 @@
+/**
+ * Agent Command Handler
+ *
+ * Handles `npx claude-flow-novice agent <type> [options]` commands.
+ * Orchestrates agent definition parsing, prompt building, and execution.
+ */ import { parseAgentDefinition, listAgentDefinitions } from './agent-definition-parser.js';
+import { buildAgentPrompt } from './agent-prompt-builder.js';
+import { executeAgent } from './agent-executor.js';
+/**
+ * Display agent command help
+ */ export function displayAgentHelp() {
+    console.log(`
+Claude Flow Novice - Agent Spawning
+
+Usage:
+  npx claude-flow-novice agent <type> [options]
+
+Arguments:
+  <type>                 Agent type (e.g., rust-enterprise-developer, coder, reviewer)
+
+Options:
+  --task-id <id>         Task identifier for CFN Loop coordination
+  --iteration <n>        Iteration number (default: 1)
+  --context <text>       Task context/description
+  --mode <mode>          Execution mode (cli, api, hybrid)
+  --priority <n>         Task priority (1-10)
+  --parent-task-id <id>  Parent task identifier
+  --list                 List all available agents
+  --help                 Show this help message
+
+Examples:
+  # Simple agent spawn
+  npx claude-flow-novice agent coder --context "Implement JWT auth"
+
+  # CFN Loop agent
+  npx claude-flow-novice agent rust-enterprise-developer \\
+    --task-id task-123 \\
+    --iteration 1 \\
+    --mode standard
+
+  # List available agents
+  npx claude-flow-novice agent --list
+
+Available Agents:
+  Agents are defined in .claude/agents/ directory:
+  - core-agents/      Production-ready core agents
+  - specialized/      Domain-specific specialists
+  - development/      Development-focused agents
+  - security/         Security-focused agents
+  - custom/           Your custom agents
+
+Documentation:
+  See .claude/agents/CLAUDE.md for agent creation guide
+`);
+}
+/**
+ * List all available agent definitions
+ */ export async function listAgents() {
+    console.log('Searching for agent definitions...\n');
+    const agents = await listAgentDefinitions();
+    if (agents.length === 0) {
+        console.log('No agent definitions found in .claude/agents/');
+        console.log('\nTo create agents, see: .claude/agents/CLAUDE.md');
+        return;
+    }
+    console.log(`Found ${agents.length} agent(s):\n`);
+    // Group by category
+    const grouped = {};
+    for (const agent of agents){
+        const parts = agent.split('/');
+        const category = parts.length > 1 ? parts[0] : 'root';
+        const name = parts.length > 1 ? parts.slice(1).join('/') : parts[0];
+        if (!grouped[category]) {
+            grouped[category] = [];
+        }
+        grouped[category].push(name);
+    }
+    // Display grouped agents
+    for (const [category, names] of Object.entries(grouped).sort()){
+        console.log(`${category}/`);
+        for (const name of names.sort()){
+            console.log(`  - ${name}`);
+        }
+        console.log('');
+    }
+    console.log('Usage:');
+    console.log('  npx claude-flow-novice agent <name> [options]');
+}
+/**
+ * Execute agent command
+ */ export async function agentCommand(agentType, options) {
+    // Handle --list flag
+    if (options.list) {
+        await listAgents();
+        return;
+    }
+    // Handle --help flag
+    if (options.help || !agentType) {
+        displayAgentHelp();
+        return;
+    }
+    try {
+        console.log(`[agent-command] Spawning agent: ${agentType}`);
+        console.log('');
+        // Step 1: Parse agent definition
+        console.log('[1/3] Parsing agent definition...');
+        const definition = await parseAgentDefinition(agentType);
+        console.log(`  ✓ Found: ${definition.name}`);
+        console.log(`  ✓ Type: ${definition.type || 'specialist'}`);
+        console.log(`  ✓ Model: ${definition.model}`);
+        console.log(`  ✓ Tools: ${definition.tools.join(', ')}`);
+        console.log('');
+        // Step 2: Build agent prompt
+        console.log('[2/3] Building agent prompt...');
+        const taskContext = {
+            taskId: options.taskId,
+            iteration: options.iteration,
+            context: options.context,
+            mode: options.mode,
+            priority: options.priority,
+            parentTaskId: options.parentTaskId
+        };
+        const prompt = await buildAgentPrompt(definition, taskContext);
+        console.log(`  ✓ Prompt size: ${prompt.length} characters`);
+        console.log(`  ✓ CFN Loop protocol: ${prompt.includes('CFN Loop Redis Completion Protocol') ? 'included' : 'not applicable'}`);
+        console.log(`  ✓ Iteration history: ${prompt.includes('## Iteration History') ? 'included' : 'not applicable'}`);
+        console.log('');
+        // Step 3: Execute agent
+        console.log('[3/3] Executing agent...');
+        const result = await executeAgent(definition, prompt, taskContext);
+        console.log('');
+        console.log('=== Execution Result ===');
+        console.log(`Agent ID: ${result.agentId}`);
+        console.log(`Status: ${result.success ? '✓ Success' : '✗ Failed'}`);
+        console.log(`Exit Code: ${result.exitCode}`);
+        if (result.error) {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        if (result.output) {
+            console.log('\nOutput:');
+            console.log(result.output);
+        }
+        process.exit(result.exitCode);
+    } catch (error) {
+        console.error('\n[agent-command] Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+
+//# sourceMappingURL=agent-command.js.map

package/dist/cli/agent-command.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cli/agent-command.ts"],"sourcesContent":["/**\r\n * Agent Command Handler\r\n *\r\n * Handles `npx claude-flow-novice agent <type> [options]` commands.\r\n * Orchestrates agent definition parsing, prompt building, and execution.\r\n */\r\n\r\nimport { parseAgentDefinition, listAgentDefinitions } from './agent-definition-parser.js';\r\nimport { buildAgentPrompt, TaskContext } from './agent-prompt-builder.js';\r\nimport { executeAgent } from './agent-executor.js';\r\n\r\nexport interface AgentCommandOptions {\r\n  taskId?: string;\r\n  iteration?: number;\r\n  context?: string;\r\n  mode?: string;\r\n  priority?: number;\r\n  parentTaskId?: string;\r\n  list?: boolean;\r\n  help?: boolean;\r\n}\r\n\r\n/**\r\n * Display agent command help\r\n */\r\nexport function displayAgentHelp(): void {\r\n  console.log(`\r\nClaude Flow Novice - Agent Spawning\r\n\r\nUsage:\r\n  npx claude-flow-novice agent <type> [options]\r\n\r\nArguments:\r\n  <type>                 Agent type (e.g., rust-enterprise-developer, coder, reviewer)\r\n\r\nOptions:\r\n  --task-id <id>         Task identifier for CFN Loop coordination\r\n  --iteration <n>        Iteration number (default: 1)\r\n  --context <text>       Task context/description\r\n  --mode <mode>          Execution mode (cli, api, hybrid)\r\n  --priority <n>         Task priority (1-10)\r\n  --parent-task-id <id>  Parent task identifier\r\n  --list                 List all available agents\r\n  --help                 Show this help message\r\n\r\nExamples:\r\n  # Simple agent spawn\r\n  npx claude-flow-novice agent coder --context \"Implement JWT auth\"\r\n\r\n  # CFN Loop agent\r\n  npx claude-flow-novice agent rust-enterprise-developer \\\\\r\n    --task-id task-123 \\\\\r\n    --iteration 1 \\\\\r\n    --mode standard\r\n\r\n  # List available agents\r\n  npx claude-flow-novice agent --list\r\n\r\nAvailable Agents:\r\n  Agents are defined in .claude/agents/ directory:\r\n  - core-agents/      Production-ready core agents\r\n  - specialized/      Domain-specific specialists\r\n  - development/      Development-focused agents\r\n  - security/         Security-focused agents\r\n  - custom/           Your custom agents\r\n\r\nDocumentation:\r\n  See .claude/agents/CLAUDE.md for agent creation guide\r\n`);\r\n}\r\n\r\n/**\r\n * List all available agent definitions\r\n */\r\nexport async function listAgents(): Promise<void> {\r\n  console.log('Searching for agent definitions...\\n');\r\n\r\n  const agents = await listAgentDefinitions();\r\n\r\n  if (agents.length === 0) {\r\n    console.log('No agent definitions found in .claude/agents/');\r\n    console.log('\\nTo create agents, see: .claude/agents/CLAUDE.md');\r\n    return;\r\n  }\r\n\r\n  console.log(`Found ${agents.length} agent(s):\\n`);\r\n\r\n  // Group by category\r\n  const grouped: Record<string, string[]> = {};\r\n\r\n  for (const agent of agents) {\r\n    const parts = agent.split('/');\r\n    const category = parts.length > 1 ? parts[0] : 'root';\r\n    const name = parts.length > 1 ? parts.slice(1).join('/') : parts[0];\r\n\r\n    if (!grouped[category]) {\r\n      grouped[category] = [];\r\n    }\r\n    grouped[category].push(name);\r\n  }\r\n\r\n  // Display grouped agents\r\n  for (const [category, names] of Object.entries(grouped).sort()) {\r\n    console.log(`${category}/`);\r\n    for (const name of names.sort()) {\r\n      console.log(`  - ${name}`);\r\n    }\r\n    console.log('');\r\n  }\r\n\r\n  console.log('Usage:');\r\n  console.log('  npx claude-flow-novice agent <name> [options]');\r\n}\r\n\r\n/**\r\n * Execute agent command\r\n */\r\nexport async function agentCommand(\r\n  agentType: string | undefined,\r\n  options: AgentCommandOptions\r\n): Promise<void> {\r\n  // Handle --list flag\r\n  if (options.list) {\r\n    await listAgents();\r\n    return;\r\n  }\r\n\r\n  // Handle --help flag\r\n  if (options.help || !agentType) {\r\n    displayAgentHelp();\r\n    return;\r\n  }\r\n\r\n  try {\r\n    console.log(`[agent-command] Spawning agent: ${agentType}`);\r\n    console.log('');\r\n\r\n    // Step 1: Parse agent definition\r\n    console.log('[1/3] Parsing agent definition...');\r\n    const definition = await parseAgentDefinition(agentType);\r\n    console.log(`  ✓ Found: ${definition.name}`);\r\n    console.log(`  ✓ Type: ${definition.type || 'specialist'}`);\r\n    console.log(`  ✓ Model: ${definition.model}`);\r\n    console.log(`  ✓ Tools: ${definition.tools.join(', ')}`);\r\n    console.log('');\r\n\r\n    // Step 2: Build agent prompt\r\n    console.log('[2/3] Building agent prompt...');\r\n    const taskContext: TaskContext = {\r\n      taskId: options.taskId,\r\n      iteration: options.iteration,\r\n      context: options.context,\r\n      mode: options.mode,\r\n      priority: options.priority,\r\n      parentTaskId: options.parentTaskId,\r\n    };\r\n\r\n    const prompt = await buildAgentPrompt(definition, taskContext);\r\n    console.log(`  ✓ Prompt size: ${prompt.length} characters`);\r\n    console.log(`  ✓ CFN Loop protocol: ${prompt.includes('CFN Loop Redis Completion Protocol') ? 'included' : 'not applicable'}`);\r\n    console.log(`  ✓ Iteration history: ${prompt.includes('## Iteration History') ? 'included' : 'not applicable'}`);\r\n    console.log('');\r\n\r\n    // Step 3: Execute agent\r\n    console.log('[3/3] Executing agent...');\r\n    const result = await executeAgent(definition, prompt, taskContext);\r\n\r\n    console.log('');\r\n    console.log('=== Execution Result ===');\r\n    console.log(`Agent ID: ${result.agentId}`);\r\n    console.log(`Status: ${result.success ? '✓ Success' : '✗ Failed'}`);\r\n    console.log(`Exit Code: ${result.exitCode}`);\r\n\r\n    if (result.error) {\r\n      console.error(`Error: ${result.error}`);\r\n      process.exit(1);\r\n    }\r\n\r\n    if (result.output) {\r\n      console.log('\\nOutput:');\r\n      console.log(result.output);\r\n    }\r\n\r\n    process.exit(result.exitCode);\r\n  } catch (error) {\r\n    console.error('\\n[agent-command] Error:', error instanceof Error ? error.message : String(error));\r\n    process.exit(1);\r\n  }\r\n}\r\n"],"names":["parseAgentDefinition","listAgentDefinitions","buildAgentPrompt","executeAgent","displayAgentHelp","console","log","listAgents","agents","length","grouped","agent","parts","split","category","name","slice","join","push","names","Object","entries","sort","agentCommand","agentType","options","list","help","definition","type","model","tools","taskContext","taskId","iteration","context","mode","priority","parentTaskId","prompt","includes","result","agentId","success","exitCode","error","process","exit","output","Error","message","String"],"mappings":"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"}

package/dist/cli/agent-definition-parser.js

@@ -0,0 +1,176 @@
+/**
+ * Agent Definition Parser
+ *
+ * Parses agent definition files (.md) with YAML frontmatter and markdown content.
+ * Supports agent definitions in .claude/agents/ directory structure.
+ */ import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+/**
+ * Parse YAML frontmatter from markdown content
+ */ function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+        return {
+            frontmatter: {},
+            body: content
+        };
+    }
+    const [, yamlContent, body] = match;
+    // Simple YAML parser (handles basic key-value pairs, arrays, and objects)
+    const frontmatter = {};
+    const lines = yamlContent.split('\n');
+    let currentKey = '';
+    let currentArray = [];
+    let isInArray = false;
+    let isInObject = false;
+    let currentObject = {};
+    let objectKey = '';
+    for (const line of lines){
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        // Array item
+        if (trimmed.startsWith('- ')) {
+            if (!isInArray) {
+                isInArray = true;
+                currentArray = [];
+            }
+            currentArray.push(trimmed.substring(2).trim());
+            continue;
+        }
+        // End of array
+        if (isInArray && !trimmed.startsWith('- ')) {
+            frontmatter[currentKey] = currentArray;
+            isInArray = false;
+            currentArray = [];
+        }
+        // Object field (indented key-value)
+        if (trimmed.match(/^\s+\w+:/) && isInObject) {
+            const [objKey, ...objValueParts] = trimmed.split(':');
+            const objValue = objValueParts.join(':').trim().replace(/^["']|["']$/g, '');
+            currentObject[objKey.trim()] = objValue;
+            continue;
+        }
+        // Key-value pair
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex !== -1) {
+            const key = trimmed.substring(0, colonIndex).trim();
+            const value = trimmed.substring(colonIndex + 1).trim();
+            // Check if this starts an object
+            if (value === '') {
+                isInObject = true;
+                currentObject = {};
+                objectKey = key;
+                continue;
+            }
+            // End previous object if any
+            if (isInObject && !trimmed.match(/^\s+/)) {
+                frontmatter[objectKey] = currentObject;
+                isInObject = false;
+                currentObject = {};
+            }
+            currentKey = key;
+            // Multi-line string (starts with |)
+            if (value === '|') {
+                continue; // Will be handled by next lines
+            }
+            // Remove quotes
+            const cleanValue = value.replace(/^["']|["']$/g, '');
+            frontmatter[key] = cleanValue;
+        } else if (currentKey && trimmed && !isInArray && !isInObject) {
+            // Continuation of multi-line string
+            const existingValue = frontmatter[currentKey];
+            frontmatter[currentKey] = existingValue ? `${existingValue}\n${trimmed}` : trimmed;
+        }
+    }
+    // Handle trailing array or object
+    if (isInArray) {
+        frontmatter[currentKey] = currentArray;
+    }
+    if (isInObject) {
+        frontmatter[objectKey] = currentObject;
+    }
+    return {
+        frontmatter,
+        body: body.trim()
+    };
+}
+/**
+ * Find agent definition file by agent type/name
+ */ async function findAgentFile(agentType, baseDir = '.claude/agents') {
+    // Normalize agent type (handle both kebab-case and underscores)
+    const normalizedType = agentType.toLowerCase().replace(/_/g, '-');
+    // Search patterns (in order of priority)
+    const patterns = [
+        // Exact match in any subdirectory
+        `${baseDir}/**/${normalizedType}.md`,
+        // Match with different casing
+        `${baseDir}/**/*${normalizedType}*.md`
+    ];
+    for (const pattern of patterns){
+        const files = await glob(pattern, {
+            nodir: true,
+            absolute: true
+        });
+        if (files.length > 0) {
+            // Prefer exact match over partial match
+            const exactMatch = files.find((f)=>{
+                const basename = path.basename(f, '.md').toLowerCase();
+                return basename === normalizedType;
+            });
+            return exactMatch || files[0];
+        }
+    }
+    return null;
+}
+/**
+ * Parse agent definition from file
+ */ export async function parseAgentDefinition(agentType) {
+    // Find agent file
+    const filePath = await findAgentFile(agentType);
+    if (!filePath) {
+        throw new Error(`Agent definition not found: ${agentType}`);
+    }
+    // Read file content
+    const content = await fs.readFile(filePath, 'utf-8');
+    // Parse frontmatter and body
+    const { frontmatter, body } = parseFrontmatter(content);
+    // Extract category from path
+    const relativePath = path.relative('.claude/agents', filePath);
+    const category = relativePath.includes('/') ? relativePath.split('/')[0] : undefined;
+    // Build agent definition
+    const definition = {
+        name: frontmatter.name || agentType,
+        description: frontmatter.description || '',
+        tools: Array.isArray(frontmatter.tools) ? frontmatter.tools : [],
+        model: frontmatter.model || 'haiku',
+        type: frontmatter.type,
+        color: frontmatter.color,
+        acl_level: frontmatter.acl_level ? parseInt(String(frontmatter.acl_level), 10) : undefined,
+        capabilities: frontmatter.capabilities,
+        validation_hooks: frontmatter.validation_hooks,
+        lifecycle: frontmatter.lifecycle,
+        content: body,
+        filePath,
+        category
+    };
+    return definition;
+}
+/**
+ * List all available agent definitions
+ */ export async function listAgentDefinitions(baseDir = '.claude/agents') {
+    const pattern = `${baseDir}/**/*.md`;
+    const files = await glob(pattern, {
+        nodir: true
+    });
+    return files.map((f)=>path.basename(f, '.md'));
+}
+/**
+ * Check if agent definition includes CFN Loop protocol
+ */ export function hasCFNLoopProtocol(definition) {
+    const content = definition.content.toLowerCase();
+    return content.includes('cfn loop') && content.includes('redis completion protocol') || content.includes('invoke-waiting-mode.sh');
+}
+
+//# sourceMappingURL=agent-definition-parser.js.map

package/dist/cli/agent-definition-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cli/agent-definition-parser.ts"],"sourcesContent":["/**\r\n * Agent Definition Parser\r\n *\r\n * Parses agent definition files (.md) with YAML frontmatter and markdown content.\r\n * Supports agent definitions in .claude/agents/ directory structure.\r\n */\r\n\r\nimport fs from 'fs/promises';\r\nimport path from 'path';\r\nimport { glob } from 'glob';\r\n\r\nexport interface AgentDefinition {\r\n  // YAML frontmatter fields\r\n  name: string;\r\n  description: string;\r\n  tools: string[];\r\n  model: 'haiku' | 'sonnet' | 'opus';\r\n  type?: string;\r\n  color?: string;\r\n  acl_level?: number;\r\n  capabilities?: string[];\r\n  validation_hooks?: string[];\r\n  lifecycle?: {\r\n    pre_task?: string;\r\n    post_task?: string;\r\n  };\r\n\r\n  // Parsed markdown content\r\n  content: string;\r\n\r\n  // File metadata\r\n  filePath: string;\r\n  category?: string; // e.g., 'core-agents', 'specialized', 'custom'\r\n}\r\n\r\n/**\r\n * Parse YAML frontmatter from markdown content\r\n */\r\nfunction parseFrontmatter(content: string): { frontmatter: Record<string, any>; body: string } {\r\n  const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---\\n([\\s\\S]*)$/;\r\n  const match = content.match(frontmatterRegex);\r\n\r\n  if (!match) {\r\n    return { frontmatter: {}, body: content };\r\n  }\r\n\r\n  const [, yamlContent, body] = match;\r\n\r\n  // Simple YAML parser (handles basic key-value pairs, arrays, and objects)\r\n  const frontmatter: Record<string, any> = {};\r\n  const lines = yamlContent.split('\\n');\r\n  let currentKey = '';\r\n  let currentArray: string[] = [];\r\n  let isInArray = false;\r\n  let isInObject = false;\r\n  let currentObject: Record<string, string> = {};\r\n  let objectKey = '';\r\n\r\n  for (const line of lines) {\r\n    const trimmed = line.trim();\r\n    if (!trimmed || trimmed.startsWith('#')) continue;\r\n\r\n    // Array item\r\n    if (trimmed.startsWith('- ')) {\r\n      if (!isInArray) {\r\n        isInArray = true;\r\n        currentArray = [];\r\n      }\r\n      currentArray.push(trimmed.substring(2).trim());\r\n      continue;\r\n    }\r\n\r\n    // End of array\r\n    if (isInArray && !trimmed.startsWith('- ')) {\r\n      frontmatter[currentKey] = currentArray;\r\n      isInArray = false;\r\n      currentArray = [];\r\n    }\r\n\r\n    // Object field (indented key-value)\r\n    if (trimmed.match(/^\\s+\\w+:/) && isInObject) {\r\n      const [objKey, ...objValueParts] = trimmed.split(':');\r\n      const objValue = objValueParts.join(':').trim().replace(/^[\"']|[\"']$/g, '');\r\n      currentObject[objKey.trim()] = objValue;\r\n      continue;\r\n    }\r\n\r\n    // Key-value pair\r\n    const colonIndex = trimmed.indexOf(':');\r\n    if (colonIndex !== -1) {\r\n      const key = trimmed.substring(0, colonIndex).trim();\r\n      const value = trimmed.substring(colonIndex + 1).trim();\r\n\r\n      // Check if this starts an object\r\n      if (value === '') {\r\n        isInObject = true;\r\n        currentObject = {};\r\n        objectKey = key;\r\n        continue;\r\n      }\r\n\r\n      // End previous object if any\r\n      if (isInObject && !trimmed.match(/^\\s+/)) {\r\n        frontmatter[objectKey] = currentObject;\r\n        isInObject = false;\r\n        currentObject = {};\r\n      }\r\n\r\n      currentKey = key;\r\n\r\n      // Multi-line string (starts with |)\r\n      if (value === '|') {\r\n        continue; // Will be handled by next lines\r\n      }\r\n\r\n      // Remove quotes\r\n      const cleanValue = value.replace(/^[\"']|[\"']$/g, '');\r\n      frontmatter[key] = cleanValue;\r\n    } else if (currentKey && trimmed && !isInArray && !isInObject) {\r\n      // Continuation of multi-line string\r\n      const existingValue = frontmatter[currentKey];\r\n      frontmatter[currentKey] = existingValue\r\n        ? `${existingValue}\\n${trimmed}`\r\n        : trimmed;\r\n    }\r\n  }\r\n\r\n  // Handle trailing array or object\r\n  if (isInArray) {\r\n    frontmatter[currentKey] = currentArray;\r\n  }\r\n  if (isInObject) {\r\n    frontmatter[objectKey] = currentObject;\r\n  }\r\n\r\n  return { frontmatter, body: body.trim() };\r\n}\r\n\r\n/**\r\n * Find agent definition file by agent type/name\r\n */\r\nasync function findAgentFile(agentType: string, baseDir: string = '.claude/agents'): Promise<string | null> {\r\n  // Normalize agent type (handle both kebab-case and underscores)\r\n  const normalizedType = agentType.toLowerCase().replace(/_/g, '-');\r\n\r\n  // Search patterns (in order of priority)\r\n  const patterns = [\r\n    // Exact match in any subdirectory\r\n    `${baseDir}/**/${normalizedType}.md`,\r\n    // Match with different casing\r\n    `${baseDir}/**/*${normalizedType}*.md`,\r\n  ];\r\n\r\n  for (const pattern of patterns) {\r\n    const files = await glob(pattern, { nodir: true, absolute: true });\r\n    if (files.length > 0) {\r\n      // Prefer exact match over partial match\r\n      const exactMatch = files.find(f => {\r\n        const basename = path.basename(f, '.md').toLowerCase();\r\n        return basename === normalizedType;\r\n      });\r\n      return exactMatch || files[0];\r\n    }\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n/**\r\n * Parse agent definition from file\r\n */\r\nexport async function parseAgentDefinition(agentType: string): Promise<AgentDefinition> {\r\n  // Find agent file\r\n  const filePath = await findAgentFile(agentType);\r\n\r\n  if (!filePath) {\r\n    throw new Error(`Agent definition not found: ${agentType}`);\r\n  }\r\n\r\n  // Read file content\r\n  const content = await fs.readFile(filePath, 'utf-8');\r\n\r\n  // Parse frontmatter and body\r\n  const { frontmatter, body } = parseFrontmatter(content);\r\n\r\n  // Extract category from path\r\n  const relativePath = path.relative('.claude/agents', filePath);\r\n  const category = relativePath.includes('/')\r\n    ? relativePath.split('/')[0]\r\n    : undefined;\r\n\r\n  // Build agent definition\r\n  const definition: AgentDefinition = {\r\n    name: frontmatter.name || agentType,\r\n    description: frontmatter.description || '',\r\n    tools: Array.isArray(frontmatter.tools) ? frontmatter.tools : [],\r\n    model: frontmatter.model || 'haiku',\r\n    type: frontmatter.type,\r\n    color: frontmatter.color,\r\n    acl_level: frontmatter.acl_level ? parseInt(String(frontmatter.acl_level), 10) : undefined,\r\n    capabilities: frontmatter.capabilities,\r\n    validation_hooks: frontmatter.validation_hooks,\r\n    lifecycle: frontmatter.lifecycle,\r\n    content: body,\r\n    filePath,\r\n    category,\r\n  };\r\n\r\n  return definition;\r\n}\r\n\r\n/**\r\n * List all available agent definitions\r\n */\r\nexport async function listAgentDefinitions(baseDir: string = '.claude/agents'): Promise<string[]> {\r\n  const pattern = `${baseDir}/**/*.md`;\r\n  const files = await glob(pattern, { nodir: true });\r\n\r\n  return files.map(f => path.basename(f, '.md'));\r\n}\r\n\r\n/**\r\n * Check if agent definition includes CFN Loop protocol\r\n */\r\nexport function hasCFNLoopProtocol(definition: AgentDefinition): boolean {\r\n  const content = definition.content.toLowerCase();\r\n  return (\r\n    content.includes('cfn loop') &&\r\n    content.includes('redis completion protocol') ||\r\n    content.includes('invoke-waiting-mode.sh')\r\n  );\r\n}\r\n"],"names":["fs","path","glob","parseFrontmatter","content","frontmatterRegex","match","frontmatter","body","yamlContent","lines","split","currentKey","currentArray","isInArray","isInObject","currentObject","objectKey","line","trimmed","trim","startsWith","push","substring","objKey","objValueParts","objValue","join","replace","colonIndex","indexOf","key","value","cleanValue","existingValue","findAgentFile","agentType","baseDir","normalizedType","toLowerCase","patterns","pattern","files","nodir","absolute","length","exactMatch","find","f","basename","parseAgentDefinition","filePath","Error","readFile","relativePath","relative","category","includes","undefined","definition","name","description","tools","Array","isArray","model","type","color","acl_level","parseInt","String","capabilities","validation_hooks","lifecycle","listAgentDefinitions","map","hasCFNLoopProtocol"],"mappings":"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"}

package/dist/cli/agent-executor.js

@@ -0,0 +1,176 @@
+/**
+ * Agent Executor
+ *
+ * Executes CLI-spawned agents by:
+ * 1. Checking custom routing configuration (z.ai vs Anthropic)
+ * 2. Invoking the appropriate API
+ * 3. Managing agent lifecycle and output
+ */ import { spawn } from 'child_process';
+import { getAgentId } from './agent-prompt-builder.js';
+import { buildCLIAgentSystemPrompt, loadContextFromEnv } from './cli-agent-context.js';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+/**
+ * Check if custom routing (z.ai) is enabled
+ */ async function isCustomRoutingEnabled() {
+    // Check environment variable
+    if (process.env.CLAUDE_API_PROVIDER === 'zai') {
+        return true;
+    }
+    // Check config file (.claude/config/api-provider.json)
+    try {
+        const configPath = path.join('.claude', 'config', 'api-provider.json');
+        const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
+        return config.provider === 'zai' || config.provider === 'z.ai';
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Get API provider configuration
+ */ async function getAPIProvider() {
+    const customEnabled = await isCustomRoutingEnabled();
+    return customEnabled ? 'zai' : 'anthropic';
+}
+/**
+ * Execute agent using direct API calls
+ */ async function executeViaAPI(definition, prompt, context) {
+    const agentId = getAgentId(definition, context);
+    console.log(`[agent-executor] Executing agent via API: ${definition.name}`);
+    console.log(`[agent-executor] Agent ID: ${agentId}`);
+    console.log(`[agent-executor] Model: ${definition.model}`);
+    console.log('');
+    try {
+        // Build system prompt with natural language context (Phase 1 enhancement)
+        console.log('[agent-executor] Building system prompt with context...');
+        const contextOptions = loadContextFromEnv();
+        // Override agent type with definition name
+        contextOptions.agentType = definition.name;
+        // Override iteration/taskId if provided in context
+        if (context.taskId) contextOptions.taskId = context.taskId;
+        if (context.iteration) contextOptions.iteration = context.iteration;
+        const systemPrompt = await buildCLIAgentSystemPrompt(contextOptions);
+        console.log('[agent-executor] System prompt built successfully');
+        console.log('');
+        // Dynamic import to avoid bundling issues
+        const { executeAgentAPI } = await import('./anthropic-client.js');
+        const result = await executeAgentAPI(definition.name, agentId, definition.model, prompt, systemPrompt);
+        return {
+            success: result.success,
+            agentId,
+            output: result.output,
+            error: result.error,
+            exitCode: result.success ? 0 : 1
+        };
+    } catch (error) {
+        console.error('[agent-executor] API execution failed:', error);
+        return {
+            success: false,
+            agentId,
+            error: error instanceof Error ? error.message : String(error),
+            exitCode: 1
+        };
+    }
+}
+/**
+ * Execute agent using shell script (fallback/simulation)
+ */ async function executeViaScript(definition, prompt, context) {
+    const agentId = getAgentId(definition, context);
+    // Write prompt to temporary file
+    const tmpDir = os.tmpdir();
+    const promptFile = path.join(tmpDir, `agent-${agentId}-${Date.now()}.md`);
+    await fs.writeFile(promptFile, prompt, 'utf-8');
+    console.log(`[agent-executor] Executing agent via script: ${definition.name}`);
+    console.log(`[agent-executor] Agent ID: ${agentId}`);
+    console.log(`[agent-executor] Model: ${definition.model}`);
+    console.log(`[agent-executor] Prompt file: ${promptFile}`);
+    return new Promise((resolve)=>{
+        const scriptPath = path.join('.claude', 'skills', 'agent-execution', 'execute-agent.sh');
+        // Build environment variables
+        const env = {
+            ...process.env,
+            AGENT_TYPE: definition.name,
+            AGENT_ID: agentId,
+            AGENT_MODEL: definition.model,
+            AGENT_TOOLS: definition.tools.join(','),
+            TASK_ID: context.taskId || '',
+            ITERATION: String(context.iteration || 1),
+            MODE: context.mode || 'cli',
+            PROMPT_FILE: promptFile
+        };
+        // Check if execute script exists
+        fs.access(scriptPath).then(()=>{
+            // Use execution script
+            const proc = spawn('bash', [
+                scriptPath
+            ], {
+                env,
+                stdio: 'inherit'
+            });
+            proc.on('exit', (code)=>{
+                resolve({
+                    success: code === 0,
+                    agentId,
+                    exitCode: code || 0
+                });
+            });
+            proc.on('error', (err)=>{
+                resolve({
+                    success: false,
+                    agentId,
+                    error: err.message,
+                    exitCode: 1
+                });
+            });
+        }).catch(()=>{
+            // Fallback: Print prompt
+            console.log('\n=== Agent Prompt ===');
+            console.log(prompt.substring(0, 500) + '...');
+            console.log('\n[agent-executor] Execution script not found');
+            console.log('[agent-executor] Using simulation mode\n');
+            resolve({
+                success: true,
+                agentId,
+                output: prompt,
+                exitCode: 0
+            });
+        });
+    });
+}
+/**
+ * Main agent execution function
+ */ export async function executeAgent(definition, prompt, context, options = {}) {
+    const method = options.method || 'auto';
+    // Auto-select execution method
+    if (method === 'auto') {
+        // Try API execution first, fallback to script if API key not available
+        try {
+            return await executeViaAPI(definition, prompt, context);
+        } catch (error) {
+            if (error instanceof Error && error.message.includes('API key not found')) {
+                console.log('[agent-executor] API key not found, using script fallback');
+                return executeViaScript(definition, prompt, context);
+            }
+            throw error;
+        }
+    }
+    if (method === 'api') {
+        return executeViaAPI(definition, prompt, context);
+    }
+    return executeViaScript(definition, prompt, context);
+}
+/**
+ * Write agent output to file for debugging
+ */ export async function saveAgentOutput(agentId, output, outputDir = '.claude/tmp/agent-output') {
+    await fs.mkdir(outputDir, {
+        recursive: true
+    });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filename = `${agentId}-${timestamp}.txt`;
+    const filepath = path.join(outputDir, filename);
+    await fs.writeFile(filepath, output, 'utf-8');
+    return filepath;
+}
+
+//# sourceMappingURL=agent-executor.js.map