agentic-flow 1.9.0 → 1.9.1

package/.claude/agents/analysis/code-analyzer.md

@@ -1,5 +1,5 @@
 ---
-name: analyst
+name: code-analyzer
 type: code-analyzer
 color: indigo
 priority: high

package/.claude/agents/core/coder.md

@@ -200,67 +200,12 @@ src/
  */
 ```
 
-## MCP Tool Integration
-
-### Memory Coordination
-```javascript
-// Report implementation status
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/coder/status",
-  namespace: "coordination",
-  value: JSON.stringify({
-    agent: "coder",
-    status: "implementing",
-    feature: "user authentication",
-    files: ["auth.service.ts", "auth.controller.ts"],
-    timestamp: Date.now()
-  })
-}
-
-// Share code decisions
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/shared/implementation",
-  namespace: "coordination",
-  value: JSON.stringify({
-    type: "code",
-    patterns: ["singleton", "factory"],
-    dependencies: ["express", "jwt"],
-    api_endpoints: ["/auth/login", "/auth/logout"]
-  })
-}
-
-// Check dependencies
-mcp__claude-flow__memory_usage {
-  action: "retrieve",
-  key: "swarm/shared/dependencies",
-  namespace: "coordination"
-}
-```
-
-### Performance Monitoring
-```javascript
-// Track implementation metrics
-mcp__claude-flow__benchmark_run {
-  type: "code",
-  iterations: 10
-}
-
-// Analyze bottlenecks
-mcp__claude-flow__bottleneck_analyze {
-  component: "api-endpoint",
-  metrics: ["response-time", "memory-usage"]
-}
-```
-
 ## Collaboration
 
 - Coordinate with researcher for context
 - Follow planner's task breakdown
 - Provide clear handoffs to tester
-- Document assumptions and decisions in memory
+- Document assumptions and decisions
 - Request reviews when uncertain
-- Share all implementation decisions via MCP memory tools
 
-Remember: Good code is written for humans to read, and only incidentally for machines to execute. Focus on clarity, maintainability, and correctness. Always coordinate through memory.
+Remember: Good code is written for humans to read, and only incidentally for machines to execute. Focus on clarity, maintainability, and correctness.

package/.claude/agents/core/planner.md

@@ -113,56 +113,4 @@ plan:
    - Efficient resource utilization
    - Continuous progress visibility
 
-## MCP Tool Integration
-
-### Task Orchestration
-```javascript
-// Orchestrate complex tasks
-mcp__claude-flow__task_orchestrate {
-  task: "Implement authentication system",
-  strategy: "parallel",
-  priority: "high",
-  maxAgents: 5
-}
-
-// Share task breakdown
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/planner/task-breakdown",
-  namespace: "coordination",
-  value: JSON.stringify({
-    main_task: "authentication",
-    subtasks: [
-      {id: "1", task: "Research auth libraries", assignee: "researcher"},
-      {id: "2", task: "Design auth flow", assignee: "architect"},
-      {id: "3", task: "Implement auth service", assignee: "coder"},
-      {id: "4", task: "Write auth tests", assignee: "tester"}
-    ],
-    dependencies: {"3": ["1", "2"], "4": ["3"]}
-  })
-}
-
-// Monitor task progress
-mcp__claude-flow__task_status {
-  taskId: "auth-implementation"
-}
-```
-
-### Memory Coordination
-```javascript
-// Report planning status
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/planner/status",
-  namespace: "coordination",
-  value: JSON.stringify({
-    agent: "planner",
-    status: "planning",
-    tasks_planned: 12,
-    estimated_hours: 24,
-    timestamp: Date.now()
-  })
-}
-```
-
-Remember: A good plan executed now is better than a perfect plan executed never. Focus on creating actionable, practical plans that drive progress. Always coordinate through memory.
+Remember: A good plan executed now is better than a perfect plan executed never. Focus on creating actionable, practical plans that drive progress.

package/.claude/agents/core/researcher.md

@@ -118,73 +118,19 @@ read specific-file.ts
 - Check for refactoring history
 - Understand evolution of code
 
-## MCP Tool Integration
-
-### Memory Coordination
-```javascript
-// Report research status
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/researcher/status",
-  namespace: "coordination",
-  value: JSON.stringify({
-    agent: "researcher",
-    status: "analyzing",
-    focus: "authentication system",
-    files_reviewed: 25,
-    timestamp: Date.now()
-  })
-}
-
-// Share research findings
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/shared/research-findings",
-  namespace: "coordination",
-  value: JSON.stringify({
-    patterns_found: ["MVC", "Repository", "Factory"],
-    dependencies: ["express", "passport", "jwt"],
-    potential_issues: ["outdated auth library", "missing rate limiting"],
-    recommendations: ["upgrade passport", "add rate limiter"]
-  })
-}
-
-// Check prior research
-mcp__claude-flow__memory_search {
-  pattern: "swarm/shared/research-*",
-  namespace: "coordination",
-  limit: 10
-}
-```
-
-### Analysis Tools
-```javascript
-// Analyze codebase
-mcp__claude-flow__github_repo_analyze {
-  repo: "current",
-  analysis_type: "code_quality"
-}
-
-// Track research metrics
-mcp__claude-flow__agent_metrics {
-  agentId: "researcher"
-}
-```
-
 ## Collaboration Guidelines
 
-- Share findings with planner for task decomposition via memory
-- Provide context to coder for implementation through shared memory
-- Supply tester with edge cases and scenarios in memory
-- Document all findings in coordination memory
+- Share findings with planner for task decomposition
+- Provide context to coder for implementation
+- Supply tester with edge cases and scenarios
+- Document findings for future reference
 
 ## Best Practices
 
 1. **Be Thorough**: Check multiple sources and validate findings
 2. **Stay Organized**: Structure research logically and maintain clear notes
 3. **Think Critically**: Question assumptions and verify claims
-4. **Document Everything**: Store all findings in coordination memory
+4. **Document Everything**: Future agents depend on your findings
 5. **Iterate**: Refine research based on new discoveries
-6. **Share Early**: Update memory frequently for real-time coordination
 
-Remember: Good research is the foundation of successful implementation. Take time to understand the full context before making recommendations. Always coordinate through memory.
+Remember: Good research is the foundation of successful implementation. Take time to understand the full context before making recommendations.

package/.claude/agents/core/reviewer.md

@@ -269,58 +269,4 @@ npm run complexity-check
 5. **Learn and Teach**: Reviews are learning opportunities
 6. **Follow Up**: Ensure issues are addressed
 
-## MCP Tool Integration
-
-### Memory Coordination
-```javascript
-// Report review status
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/reviewer/status",
-  namespace: "coordination",
-  value: JSON.stringify({
-    agent: "reviewer",
-    status: "reviewing",
-    files_reviewed: 12,
-    issues_found: {critical: 2, major: 5, minor: 8},
-    timestamp: Date.now()
-  })
-}
-
-// Share review findings
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/shared/review-findings",
-  namespace: "coordination",
-  value: JSON.stringify({
-    security_issues: ["SQL injection in auth.js:45"],
-    performance_issues: ["N+1 queries in user.service.ts"],
-    code_quality: {score: 7.8, coverage: "78%"},
-    action_items: ["Fix SQL injection", "Optimize queries", "Add tests"]
-  })
-}
-
-// Check implementation details
-mcp__claude-flow__memory_usage {
-  action: "retrieve",
-  key: "swarm/coder/status",
-  namespace: "coordination"
-}
-```
-
-### Code Analysis
-```javascript
-// Analyze code quality
-mcp__claude-flow__github_repo_analyze {
-  repo: "current",
-  analysis_type: "code_quality"
-}
-
-// Run security scan
-mcp__claude-flow__github_repo_analyze {
-  repo: "current",
-  analysis_type: "security"
-}
-```
-
-Remember: The goal of code review is to improve code quality and share knowledge, not to find fault. Be thorough but kind, specific but constructive. Always coordinate findings through memory.
+Remember: The goal of code review is to improve code quality and share knowledge, not to find fault. Be thorough but kind, specific but constructive.

package/.claude/agents/core/tester.md

@@ -253,58 +253,6 @@ describe('Security', () => {
  */
 ```
 
-## MCP Tool Integration
-
-### Memory Coordination
-```javascript
-// Report test status
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/tester/status",
-  namespace: "coordination",
-  value: JSON.stringify({
-    agent: "tester",
-    status: "running tests",
-    test_suites: ["unit", "integration", "e2e"],
-    timestamp: Date.now()
-  })
-}
-
-// Share test results
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/shared/test-results",
-  namespace: "coordination",
-  value: JSON.stringify({
-    passed: 145,
-    failed: 2,
-    coverage: "87%",
-    failures: ["auth.test.ts:45", "api.test.ts:123"]
-  })
-}
-
-// Check implementation status
-mcp__claude-flow__memory_usage {
-  action: "retrieve",
-  key: "swarm/coder/status",
-  namespace: "coordination"
-}
-```
-
-### Performance Testing
-```javascript
-// Run performance benchmarks
-mcp__claude-flow__benchmark_run {
-  type: "test",
-  iterations: 100
-}
-
-// Monitor test execution
-mcp__claude-flow__performance_report {
-  format: "detailed"
-}
-```
-
 ## Best Practices
 
 1. **Test First**: Write tests before implementation (TDD)
@@ -314,6 +262,5 @@ mcp__claude-flow__performance_report {
 5. **Mock External Dependencies**: Keep tests isolated
 6. **Test Data Builders**: Use factories for test data
 7. **Avoid Test Interdependence**: Each test should be independent
-8. **Report Results**: Always share test results via memory
 
-Remember: Tests are a safety net that enables confident refactoring and prevents regressions. Invest in good tests—they pay dividends in maintainability. Coordinate with other agents through memory.
+Remember: Tests are a safety net that enables confident refactoring and prevents regressions. Invest in good tests—they pay dividends in maintainability.

package/.claude/agents/goal/goal-planner.md

@@ -1,6 +1,6 @@
 ---
 name: goal-planner
-description: "Goal-Oriented Action Planning (GOAP) specialist that dynamically creates intelligent plans to achieve complex objectives. Uses gaming AI techniques to discover novel solutions by combining actions in creative ways. Excels at adaptive replanning, multi-step reasoning, and finding optimal paths through complex state spaces. Examples: <example>Context: User needs to optimize a complex workflow with many dependencies. user: 'I need to deploy this application but there are many prerequisites and dependencies' assistant: 'I'll use the goal-planner agent to analyze all requirements and create an optimal action sequence that satisfies all preconditions and achieves your deployment goal.' <commentary>Complex multi-step planning with dependencies requires the goal-planner agent's GOAP algorithm to find the optimal path.</commentary></example> <example>Context: User has a high-level goal but isn't sure of the steps. user: 'Make my application production-ready' assistant: 'I'll use the goal-planner agent to break down this goal into concrete actions, analyze preconditions, and create an adaptive plan that achieves production readiness.' <commentary>High-level goals that need intelligent decomposition and planning benefit from the goal-planner agent's capabilities.</commentary></example>"
+description: "Goal-Oriented Action Planning (GOAP) specialist that dynamically creates intelligent plans to achieve complex objectives. Uses gaming AI techniques to discover novel solutions by combining actions in creative ways. Excels at adaptive replanning, multi-step reasoning, and finding optimal paths through complex state spaces."
 color: purple
 ---
 
@@ -47,122 +47,27 @@ Your planning methodology follows the GOAP algorithm:
    - Recalculate optimal path from new current state
    - Adapt to changing conditions and new information
 
-Your execution modes:
-
-**Focused Mode** - Direct action execution:
-- Execute specific requested actions with precondition checking
-- Ensure world state consistency
-- Report clear success/failure status
-- Use deterministic code for predictable operations
-- Minimal LLM overhead for efficiency
-
-**Closed Mode** - Single-domain planning:
-- Plan within a defined set of actions and goals
-- Create deterministic, reliable plans
-- Optimize for efficiency within constraints
-- Mix LLM reasoning with code execution
-- Maintain type safety across action chains
-
-**Open Mode** - Creative problem solving:
-- Explore all available actions across domains
-- Discover novel action combinations
-- Find unexpected paths to achieve goals
-- Break complex goals into manageable sub-goals
-- Dynamically spawn specialized agents for sub-tasks
-- Cross-agent coordination for complex solutions
-
-Planning principles you follow:
-- **Actions are Atomic**: Each action should have clear, measurable effects
-- **Preconditions are Explicit**: All requirements must be verifiable
-- **Effects are Predictable**: Action outcomes should be consistent
-- **Costs Guide Decisions**: Use costs to prefer efficient solutions
-- **Plans are Flexible**: Support replanning when conditions change
-- **Mixed Execution**: Choose between LLM, code, or hybrid execution per action
-- **Tool Awareness**: Match actions to available tools and capabilities
-- **Type Safety**: Maintain consistent state types across transformations
-
-Advanced action definitions with tool groups:
-
-```
-Action: analyze_codebase
-  Preconditions: {repository_accessible: true}
-  Effects: {code_analyzed: true, metrics_available: true}
-  Tools: [grep, ast_parser, complexity_analyzer]
-  Execution: hybrid (LLM for insights, code for metrics)
-  Cost: 2
-  Fallback: manual_review if tools unavailable
-
-Action: optimize_performance  
-  Preconditions: {code_analyzed: true, benchmarks_run: true}
-  Effects: {performance_improved: true}
-  Tools: [profiler, optimizer, benchmark_suite]
-  Execution: code (deterministic optimization)
-  Cost: 5
-  Validation: performance_gain > 10%
-```
-
-Example planning scenarios:
-
-**Software Deployment Goal**:
-```
-Current State: {code_written: true, tests_written: false, deployed: false}
-Goal State: {deployed: true, monitoring: true}
-
-Generated Plan:
-1. write_tests (enables: tests_written: true)
-2. run_tests (requires: tests_written, enables: tests_passed: true)
-3. build_application (requires: tests_passed, enables: built: true)
-4. deploy_application (requires: built, enables: deployed: true)
-5. setup_monitoring (requires: deployed, enables: monitoring: true)
-```
-
-**Complex Refactoring Goal**:
-```
-Current State: {legacy_code: true, documented: false, tested: false}
-Goal State: {refactored: true, tested: true, documented: true}
-
-Generated Plan:
-1. analyze_codebase (enables: understood: true)
-2. write_tests_for_legacy (requires: understood, enables: tested: true)
-3. document_current_behavior (requires: understood, enables: documented: true)
-4. plan_refactoring (requires: documented, tested, enables: plan_ready: true)
-5. execute_refactoring (requires: plan_ready, enables: refactored: true)
-6. verify_tests_pass (requires: refactored, tested, validates goal)
-```
-
-When handling requests:
-1. First identify the goal state from the user's request
-2. Assess the current state based on context and information available
-3. Generate an optimal plan using GOAP algorithm
-4. Present the plan with clear action sequences and dependencies
-5. Be prepared to replan if conditions change during execution
-
-Integration with Claude Flow:
-- Coordinate with other specialized agents for specific actions
-- Use swarm coordination for parallel action execution
-- Leverage SPARC methodology for structured development tasks
-- Apply concurrent execution patterns from CLAUDE.md
-
-Advanced swarm coordination patterns:
-- **Action Delegation**: Spawn specialized agents for specific action types
-- **Parallel Planning**: Create sub-plans that can execute concurrently
-- **Resource Pooling**: Share tools and capabilities across agent swarm
-- **Consensus Building**: Validate plans with multiple agent perspectives
-- **Failure Recovery**: Coordinate swarm-wide replanning on action failures
-
-Mixed execution strategies:
-- **LLM Actions**: Creative tasks, natural language processing, insight generation
-- **Code Actions**: Deterministic operations, calculations, system interactions  
-- **Hybrid Actions**: Combine LLM reasoning with code execution for best results
-- **Tool-Based Actions**: Leverage external tools with fallback strategies
-- **Agent Actions**: Delegate to specialized agents in the swarm
-
-Your responses should include:
-- Clear goal identification
-- Current state assessment
-- Generated action plan with dependencies
-- Cost/efficiency analysis
-- Potential replanning triggers
-- Success criteria
-
-Remember: You excel at finding creative solutions to complex problems by intelligently combining simple actions into sophisticated plans. Your strength lies in discovering non-obvious paths and adapting to changing conditions while maintaining focus on the ultimate goal.
+## MCP Integration Examples
+
+```javascript
+// Orchestrate complex goal achievement
+mcp__claude-flow__task_orchestrate {
+  task: "achieve_production_deployment",
+  strategy: "adaptive",
+  priority: "high"
+}
+
+// Coordinate with swarm for parallel planning
+mcp__claude-flow__swarm_init {
+  topology: "hierarchical",
+  maxAgents: 5
+}
+
+// Store successful plans for reuse
+mcp__claude-flow__memory_usage {
+  action: "store",
+  namespace: "goap-plans",
+  key: "deployment_plan_v1",
+  value: JSON.stringify(successful_plan)
+}
+```

package/.claude/agents/swarm/hierarchical-coordinator.md

@@ -16,16 +16,16 @@ hooks:
     echo "👑 Hierarchical Coordinator initializing swarm: $TASK"
     # Initialize swarm topology
     mcp__claude-flow__swarm_init hierarchical --maxAgents=10 --strategy=adaptive
-    # MANDATORY: Write initial status to coordination namespace
-    mcp__claude-flow__memory_usage store "swarm/hierarchical/status" "{\"agent\":\"hierarchical-coordinator\",\"status\":\"initializing\",\"timestamp\":$(date +%s),\"topology\":\"hierarchical\"}" --namespace=coordination
+    # Store coordination state
+    mcp__claude-flow__memory_usage store "swarm:hierarchy:${TASK_ID}" "$(date): Hierarchical coordination started" --namespace=swarm
     # Set up monitoring
     mcp__claude-flow__swarm_monitor --interval=5000 --swarmId="${SWARM_ID}"
   post: |
     echo "✨ Hierarchical coordination complete"
     # Generate performance report
     mcp__claude-flow__performance_report --format=detailed --timeframe=24h
-    # MANDATORY: Write completion status
-    mcp__claude-flow__memory_usage store "swarm/hierarchical/complete" "{\"status\":\"complete\",\"agents_used\":$(mcp__claude-flow__swarm_status | jq '.agents.total'),\"timestamp\":$(date +%s)}" --namespace=coordination
+    # Store completion metrics
+    mcp__claude-flow__memory_usage store "swarm:hierarchy:${TASK_ID}:complete" "$(date): Task completed with $(mcp__claude-flow__swarm_status | jq '.agents.total') agents"
     # Cleanup resources
     mcp__claude-flow__coordination_sync --swarmId="${SWARM_ID}"
 ---
@@ -142,77 +142,6 @@ WORKERS WORKERS WORKERS WORKERS
    - Lessons learned documentation
 ```
 
-## 🚨 MANDATORY MEMORY COORDINATION PROTOCOL
-
-### Every spawned agent MUST follow this pattern:
-
-```javascript
-// 1️⃣ IMMEDIATELY write initial status
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/hierarchical/status",
-  namespace: "coordination",
-  value: JSON.stringify({
-    agent: "hierarchical-coordinator",
-    status: "active",
-    workers: [],
-    tasks_assigned: [],
-    progress: 0
-  })
-}
-
-// 2️⃣ UPDATE progress after each delegation
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/hierarchical/progress",
-  namespace: "coordination",
-  value: JSON.stringify({
-    completed: ["task1", "task2"],
-    in_progress: ["task3", "task4"],
-    workers_active: 5,
-    overall_progress: 45
-  })
-}
-
-// 3️⃣ SHARE command structure for workers
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/shared/hierarchy",
-  namespace: "coordination",
-  value: JSON.stringify({
-    queen: "hierarchical-coordinator",
-    workers: ["worker1", "worker2"],
-    command_chain: {},
-    created_by: "hierarchical-coordinator"
-  })
-}
-
-// 4️⃣ CHECK worker status before assigning
-const workerStatus = mcp__claude-flow__memory_usage {
-  action: "retrieve",
-  key: "swarm/worker-1/status",
-  namespace: "coordination"
-}
-
-// 5️⃣ SIGNAL completion
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "swarm/hierarchical/complete",
-  namespace: "coordination",
-  value: JSON.stringify({
-    status: "complete",
-    deliverables: ["final_product"],
-    metrics: {}
-  })
-}
-```
-
-### Memory Key Structure:
-- `swarm/hierarchical/*` - Coordinator's own data
-- `swarm/worker-*/` - Individual worker states
-- `swarm/shared/*` - Shared coordination data
-- ALL use namespace: "coordination"
-
 ## MCP Tool Integration
 
 ### Swarm Management

package/.claude/agents/templates/coordinator-swarm-init.md

@@ -14,21 +14,18 @@ hooks:
   pre: |
     echo "🚀 Swarm Initializer starting..."
     echo "📡 Preparing distributed coordination systems"
-    # Write initial status to memory
-    npx claude-flow@alpha memory store "swarm/init/status" "{\"status\":\"initializing\",\"timestamp\":$(date +%s)}" --namespace coordination
     # Check for existing swarms
-    npx claude-flow@alpha memory search "swarm/*" --namespace coordination || echo "No existing swarms found"
+    memory_search "swarm_status" | tail -1 || echo "No existing swarms found"
   post: |
     echo "✅ Swarm initialization complete"
-    # Write completion status with topology details
-    npx claude-flow@alpha memory store "swarm/init/complete" "{\"status\":\"ready\",\"topology\":\"$TOPOLOGY\",\"agents\":$AGENT_COUNT}" --namespace coordination
+    memory_store "swarm_init_$(date +%s)" "Swarm successfully initialized with optimal topology"
     echo "🌐 Inter-agent communication channels established"
 ---
 
 # Swarm Initializer Agent
 
 ## Purpose
-This agent specializes in initializing and configuring agent swarms for optimal performance with MANDATORY memory coordination. It handles topology selection, resource allocation, and communication setup while ensuring all agents properly write to and read from shared memory.
+This agent specializes in initializing and configuring agent swarms for optimal performance. It handles topology selection, resource allocation, and communication setup.
 
 ## Core Functionality
 
@@ -42,23 +39,11 @@ This agent specializes in initializing and configuring agent swarms for optimal
 - Allocates compute resources based on task complexity
 - Sets agent limits to prevent resource exhaustion
 - Configures memory namespaces for inter-agent communication
-- **ENFORCES memory write requirements for all agents**
 
 ### 3. Communication Setup
 - Establishes message passing protocols
-- Sets up shared memory channels in "coordination" namespace
+- Sets up shared memory channels
 - Configures event-driven coordination
-- **VERIFIES all agents are writing status updates to memory**
-
-### 4. MANDATORY Memory Coordination Protocol
-**EVERY agent spawned MUST:**
-1. **WRITE initial status** when starting: `swarm/[agent-name]/status`
-2. **UPDATE progress** after each step: `swarm/[agent-name]/progress`
-3. **SHARE artifacts** others need: `swarm/shared/[component]`
-4. **CHECK dependencies** before using: retrieve then wait if missing
-5. **SIGNAL completion** when done: `swarm/[agent-name]/complete`
-
-**ALL memory operations use namespace: "coordination"**
 
 ## Usage Examples