claude-flow-novice 1.5.12 → 1.5.13

package/.claude-flow-novice/dist/src/cli/simple-commands/init/templates/CLAUDE.md

@@ -220,84 +220,59 @@ npx claude-flow-novice hooks session-end --generate-summary true --persist-state
 
 ---
 
-## 📋 EXAMPLE AGENT SPAWNING PATTERNS
+## 📋 AGENT COORDINATION RULES
 
-**⚠️ IMPORTANT**: These are **ILLUSTRATIVE EXAMPLES** demonstrating coordination patterns.
-**YOU MUST adapt agent types, counts, and roles to YOUR specific task requirements.**
+### Universal Agent Spawning Pattern
 
-**Key Principles Shown:**
-- How to structure swarm initialization before agent spawning
-- How to spawn agents concurrently in one message
-- How to coordinate multiple agent types effectively
-- Topology selection based on team size
-
-**These patterns are starting points - not rigid templates. Analyze your task and customize accordingly.**
-
----
-
-### Example 1: Simple Task Pattern (2-3 agents)
-**Illustrative pattern for basic feature implementation with coordinated validation.**
+**EVERY multi-agent task follows this structure:**
 
 ```javascript
 [Single Message]:
-  // Initialize swarm coordination
+  // Step 1: ALWAYS initialize swarm first
   mcp__claude-flow-novice__swarm_init({
-    topology: "mesh",
-    maxAgents: 3,
-    strategy: "balanced"
+    topology: "mesh",          // or "hierarchical" for 8+ agents
+    maxAgents: X,              // match your actual agent count
+    strategy: "balanced"       // or "adaptive" for complex tasks
   })
 
-  // Spawn coordinated agents (customize to your needs)
-  Task("Coder", "Implement feature with TDD approach", "coder")
-  Task("Tester", "Create comprehensive test suite", "tester")
-  Task("Reviewer", "Review code quality and security", "reviewer")
+  // Step 2: Spawn ALL agents concurrently
+  Task("Agent Name", "Specific task instructions", "agent-type")
+  Task("Agent Name", "Specific task instructions", "agent-type")
+  Task("Agent Name", "Specific task instructions", "agent-type")
+  // ... continue for all agents
 ```
 
-### Example 2: Medium Task Pattern (4-6 agents)
-**Illustrative pattern for multi-component features requiring research and architecture.**
+### Coordination Checklist
 
-```javascript
-[Single Message]:
-  // Initialize swarm coordination
-  mcp__claude-flow-novice__swarm_init({
-    topology: "mesh",
-    maxAgents: 6,
-    strategy: "balanced"
-  })
+**Before spawning agents, ensure:**
+- ✅ Task analyzed and complexity assessed (Simple/Medium/Complex/Enterprise)
+- ✅ Agent count determined from requirements table
+- ✅ Agent types selected for specific needs (not generic roles)
+- ✅ Topology chosen: mesh (2-7) or hierarchical (8+)
+- ✅ All agents will spawn in SINGLE message
+- ✅ Each agent has specific, non-overlapping instructions
 
-  // Spawn coordinated specialists (adapt to your task)
-  Task("Researcher", "Analyze requirements and existing patterns", "researcher")
-  Task("Architect", "Design system architecture", "system-architect")
-  Task("Coder", "Implement core functionality with TDD", "coder")
-  Task("Tester", "Create unit, integration, and E2E tests", "tester")
-  Task("Security Reviewer", "Perform security audit", "security-specialist")
-  Task("Reviewer", "Final quality review", "reviewer")
-```
+**During execution:**
+- ✅ Agents coordinate through SwarmMemory
+- ✅ Self-validation runs before consensus
+- ✅ Each agent runs Post-edit hooks execute after file changes
 
-### Example 3: Complex Task Pattern (8-12 agents)
-**Illustrative pattern for full-scale features requiring hierarchical coordination.**
+**After completion:**
+- ✅ Consensus validation achieved (≥90% agreement)
+- ✅ Results stored in memory
+- ✅ Next steps provided with claude code continuing to the next documented phase or next steps provided to user if no todos left
 
-```javascript
-[Single Message]:
-  // Initialize hierarchical swarm for larger teams
-  mcp__claude-flow-novice__swarm_init({
-    topology: "hierarchical",
-    maxAgents: 12,
-    strategy: "adaptive"
-  })
+### Agent Selection Guide
 
-  // Spawn full specialist team (customize roles to your project)
-  Task("Product Owner", "Define requirements", "planner")
-  Task("System Architect", "Design architecture", "system-architect")
-  Task("Backend Developer", "Implement backend services", "backend-dev")
-  Task("Frontend Developer", "Create UI components", "coder")
-  Task("Tester", "Comprehensive testing", "tester")
-  Task("Security Specialist", "Security review", "security-specialist")
-  Task("Performance Analyst", "Performance optimization", "perf-analyzer")
-  Task("DevOps Engineer", "CI/CD setup", "cicd-engineer")
-  Task("API Documenter", "API documentation", "api-docs")
-  Task("Reviewer", "Final quality gate", "reviewer")
-```
+**Core Development**: coder, tester, reviewer
+**Backend**: backend-dev, api-docs, system-architect
+**Frontend**: coder (specialized), mobile-dev
+**Quality**: tester, reviewer, security-specialist, perf-analyzer
+**Planning**: researcher, planner, architect
+**Operations**: devops-engineer, cicd-engineer
+**Documentation**: api-docs, researcher
+
+**Select agents based on actual task needs, not predefined patterns.**
 
 ---
 
@@ -398,7 +373,7 @@ claude mcp add claude-flow-novice npx claude-flow-novice mcp start
 - **PASS** →
   1. Store results in SwarmMemory
   2. Update documentation
-  3. Move to next task
+  3. Update todos and move to next task
 
 - **FAIL** →
   1. Round counter++
@@ -408,7 +383,7 @@ claude mcp add claude-flow-novice npx claude-flow-novice mcp start
 ### 🚨 ENFORCEMENT CHECKPOINTS
 
 **MANDATORY before proceeding:**
-1. ✅ Agents spawned (minimum count met for task complexity)
+1. ✅ Agents spawned
 2. ✅ Each file edit followed by enhanced post-edit hook
 3. ✅ Self-validation confidence scores recorded
 4. ✅ Consensus swarm spawned for verification
@@ -425,39 +400,3 @@ claude mcp add claude-flow-novice npx claude-flow-novice mcp start
 2. **📊 Validation results**: Confidence scores, test coverage, consensus approval
 3. **🔍 Identified issues**: Any technical debt, warnings, or concerns discovered
 4. **💡 Recommended next steps**: Prioritized suggestions for logical continuation
-
-### Next Steps Template
-
-```markdown
-## Task Completion Summary
-
-**✅ Completed**: [What was delivered]
-**📊 Validation**:
-- Confidence: X%
-- Coverage: Y%
-- Consensus: Z%
-
-**⚠️ Identified Concerns**:
-- [Issue 1] - Severity: [High/Medium/Low]
-- [Issue 2] - Severity: [High/Medium/Low]
-
-**💡 Recommended Next Steps** (in priority order):
-
-1. **[High Priority]**: [Action item]
-   - Why: [Business/technical rationale]
-   - Effort: [Estimated time/complexity]
-
-2. **[Medium Priority]**: [Action item]
-   - Why: [Value proposition]
-   - Effort: [Estimated time/complexity]
-
-3. **[Low Priority]**: [Enhancement opportunity]
-   - Why: [Long-term benefit]
-   - Effort: [Estimated time/complexity]
-
-**🤔 Questions for User**:
-- [Decision point requiring clarification]?
-- [Alternative approach consideration]?
-```
-
-**Rationale**: Proactive next steps ensure continuous progress, prevent workflow dead-ends, and help users understand logical task progression without requiring them to determine next actions.

package/.claude-flow-novice/dist/src/coordination/swarm-coordinator-factory.js

@@ -0,0 +1,36 @@
+/**
+ * Swarm Coordinator Factory
+ *
+ * Provides singleton access to the swarm coordinator instance.
+ * Used by validators and other components to check swarm status.
+ *
+ * @module coordination/swarm-coordinator-factory
+ */ let swarmCoordinatorInstance = null;
+/**
+ * Sets the global swarm coordinator instance
+ *
+ * @param coordinator - Swarm coordinator instance
+ */ export function setSwarmCoordinator(coordinator) {
+    swarmCoordinatorInstance = coordinator;
+}
+/**
+ * Gets the global swarm coordinator instance
+ *
+ * @returns Swarm coordinator instance or null if not initialized
+ */ export function getSwarmCoordinator() {
+    return swarmCoordinatorInstance;
+}
+/**
+ * Clears the global swarm coordinator instance
+ */ export function clearSwarmCoordinator() {
+    swarmCoordinatorInstance = null;
+}
+/**
+ * Checks if swarm coordinator is initialized
+ *
+ * @returns true if coordinator is initialized
+ */ export function hasSwarmCoordinator() {
+    return swarmCoordinatorInstance !== null;
+}
+
+//# sourceMappingURL=swarm-coordinator-factory.js.map

package/.claude-flow-novice/dist/src/coordination/swarm-coordinator-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/coordination/swarm-coordinator-factory.ts"],"names":["swarmCoordinatorInstance","setSwarmCoordinator","coordinator","getSwarmCoordinator","clearSwarmCoordinator","hasSwarmCoordinator"],"mappings":"AAAA;;;;;;;CAOC,GAID,IAAIA,2BAAoD;AAExD;;;;CAIC,GACD,OAAO,SAASC,oBAAoBC,WAA6B;IAC/DF,2BAA2BE;AAC7B;AAEA;;;;CAIC,GACD,OAAO,SAASC;IACd,OAAOH;AACT;AAEA;;CAEC,GACD,OAAO,SAASI;IACdJ,2BAA2B;AAC7B;AAEA;;;;CAIC,GACD,OAAO,SAASK;IACd,OAAOL,6BAA6B;AACtC"}

package/.claude-flow-novice/dist/src/validators/index.js

@@ -0,0 +1,12 @@
+/**
+ * Validators Module
+ *
+ * Provides validation functionality for enforcing best practices and detecting anti-patterns.
+ *
+ * @module validators
+ */ // TodoWrite Batching Validator
+export { TodoWriteValidator, getGlobalValidator, resetGlobalValidator } from './todowrite-batching-validator';
+// TodoWrite Integration
+export { isValidationEnabled, getIntegrationConfig, validateTodoWrite, parseValidationFlags, displayValidationHelp, todoWriteWithValidation, createValidationMiddleware, getValidationStatus } from './todowrite-integration';
+
+//# sourceMappingURL=index.js.map

package/.claude-flow-novice/dist/src/validators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/validators/index.ts"],"names":["TodoWriteValidator","getGlobalValidator","resetGlobalValidator","isValidationEnabled","getIntegrationConfig","validateTodoWrite","parseValidationFlags","displayValidationHelp","todoWriteWithValidation","createValidationMiddleware","getValidationStatus"],"mappings":"AAAA;;;;;;CAMC,GAED,+BAA+B;AAC/B,SACEA,kBAAkB,EAClBC,kBAAkB,EAClBC,oBAAoB,QAKf,iCAAiC;AAExC,wBAAwB;AACxB,SACEC,mBAAmB,EACnBC,oBAAoB,EACpBC,iBAAiB,EACjBC,oBAAoB,EACpBC,qBAAqB,EACrBC,uBAAuB,EACvBC,0BAA0B,EAC1BC,mBAAmB,QAEd,0BAA0B"}

package/.claude-flow-novice/dist/src/validators/swarm-init-validator.js

@@ -0,0 +1,261 @@
+/**
+ * Swarm Initialization Validator
+ *
+ * Validates that swarm initialization is performed before spawning multiple agents.
+ * Ensures proper coordination and prevents inconsistent implementations across agents.
+ *
+ * @module validators/swarm-init-validator
+ */ import { Logger } from '../core/logger.js';
+const DEFAULT_CONFIG = {
+    requireSwarmForMultiAgent: true,
+    minAgentsRequiringSwarm: 2,
+    meshTopologyMaxAgents: 7,
+    hierarchicalTopologyMinAgents: 8
+};
+/**
+ * Validates swarm initialization before agent spawning
+ *
+ * @param agentCount - Number of agents to spawn
+ * @param swarmStatus - Current swarm status (optional, will check environment if not provided)
+ * @param config - Validator configuration
+ * @returns Validation result with error messages and suggestions
+ *
+ * @example
+ * ```typescript
+ * const result = await validateSwarmInit(3);
+ * if (!result.valid) {
+ *   console.error(result.error);
+ *   console.log(result.suggestion);
+ * }
+ * ```
+ */ export async function validateSwarmInit(agentCount, swarmStatus, config = {}) {
+    const logger = new Logger('SwarmInitValidator');
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    // Single agent spawning doesn't require swarm
+    if (agentCount < cfg.minAgentsRequiringSwarm) {
+        return {
+            valid: true
+        };
+    }
+    // Check if swarm is required for this agent count
+    if (!cfg.requireSwarmForMultiAgent) {
+        logger.warn('Swarm validation is disabled in configuration');
+        return {
+            valid: true
+        };
+    }
+    // Get swarm status
+    const status = swarmStatus || await getSwarmStatus();
+    // Validate swarm is initialized
+    if (!status.initialized) {
+        const topology = agentCount <= cfg.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+        return {
+            valid: false,
+            error: createErrorMessage(agentCount),
+            suggestion: createSuggestion(agentCount, topology),
+            topology,
+            maxAgents: agentCount
+        };
+    }
+    // Validate topology matches agent count
+    const topologyValidation = validateTopology(agentCount, status, cfg);
+    if (!topologyValidation.valid) {
+        return topologyValidation;
+    }
+    // Validate max agents capacity
+    if (status.maxAgents && agentCount > status.maxAgents) {
+        return {
+            valid: false,
+            error: `Cannot spawn ${agentCount} agents. Swarm configured for maximum ${status.maxAgents} agents.`,
+            suggestion: `Reinitialize swarm with increased maxAgents:\n  npx claude-flow-novice swarm init --topology ${status.topology} --max-agents ${agentCount}`
+        };
+    }
+    logger.info(`Swarm validation passed for ${agentCount} agents`);
+    return {
+        valid: true
+    };
+}
+/**
+ * Validates that topology matches agent count requirements
+ */ function validateTopology(agentCount, status, config) {
+    const expectedTopology = agentCount <= config.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+    if (status.topology && status.topology !== expectedTopology) {
+        return {
+            valid: false,
+            error: `Topology mismatch: ${agentCount} agents require '${expectedTopology}' topology, but swarm is using '${status.topology}'.`,
+            suggestion: `Reinitialize swarm with correct topology:\n  npx claude-flow-novice swarm init --topology ${expectedTopology} --max-agents ${agentCount}`,
+            topology: expectedTopology,
+            maxAgents: agentCount
+        };
+    }
+    return {
+        valid: true
+    };
+}
+/**
+ * Creates error message for missing swarm initialization
+ */ function createErrorMessage(agentCount) {
+    return `
+❌ SWARM INITIALIZATION REQUIRED
+
+You are attempting to spawn ${agentCount} agents without initializing swarm.
+
+Without swarm coordination:
+  • Agents work independently with no shared context
+  • Results may be inconsistent (e.g., 3 different JWT secret solutions)
+  • No consensus validation or Byzantine fault tolerance
+  • Memory coordination is disabled
+
+This violates the mandatory coordination requirements in CLAUDE.md.
+`.trim();
+}
+/**
+ * Creates suggestion message with fix command
+ */ function createSuggestion(agentCount, topology) {
+    return `
+Fix:
+1. Initialize swarm first:
+   npx claude-flow-novice swarm init --topology ${topology} --max-agents ${agentCount}
+
+2. Then spawn agents:
+   [Your agent spawning command]
+
+Topology Selection:
+  • mesh: 2-7 agents (peer-to-peer coordination)
+  • hierarchical: 8+ agents (coordinator-led structure)
+
+See CLAUDE.md section "Swarm Initialization" for coordination requirements.
+`.trim();
+}
+/**
+ * Gets current swarm status from environment or MCP server
+ */ async function getSwarmStatus() {
+    const logger = new Logger('SwarmInitValidator');
+    // Check environment variables
+    const swarmId = process.env['CLAUDE_SWARM_ID'];
+    if (!swarmId) {
+        return {
+            initialized: false
+        };
+    }
+    // Try to get status from MCP server via swarm coordinator
+    try {
+        // Import dynamically to avoid circular dependencies
+        const { getSwarmCoordinator } = await import('../coordination/swarm-coordinator-factory.js').catch(()=>({
+                getSwarmCoordinator: null
+            }));
+        if (getSwarmCoordinator) {
+            const coordinator = getSwarmCoordinator();
+            if (coordinator) {
+                const status = coordinator.getSwarmStatus();
+                return {
+                    initialized: true,
+                    swarmId,
+                    activeAgents: status.agents.total,
+                    maxAgents: status.agents.total
+                };
+            }
+        }
+    } catch (error) {
+        logger.debug('Could not get swarm status from coordinator', error);
+    }
+    // If we have a swarm ID but can't get details, assume initialized
+    return {
+        initialized: true,
+        swarmId
+    };
+}
+/**
+ * Validates swarm initialization and throws error if invalid
+ *
+ * This is a convenience wrapper for validateSwarmInit that throws on validation failure.
+ * Use this in CLI commands where you want to halt execution on validation errors.
+ *
+ * @param agentCount - Number of agents to spawn
+ * @param swarmStatus - Current swarm status (optional)
+ * @param config - Validator configuration
+ * @throws Error if validation fails
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await requireSwarmInit(3);
+ *   // Proceed with spawning agents
+ * } catch (error) {
+ *   console.error(error.message);
+ *   process.exit(1);
+ * }
+ * ```
+ */ export async function requireSwarmInit(agentCount, swarmStatus, config) {
+    const result = await validateSwarmInit(agentCount, swarmStatus, config);
+    if (!result.valid) {
+        const errorMessage = `${result.error}\n\n${result.suggestion}`;
+        throw new Error(errorMessage);
+    }
+}
+/**
+ * Gets recommended topology for agent count
+ *
+ * @param agentCount - Number of agents
+ * @param config - Validator configuration
+ * @returns Recommended topology
+ */ export function getRecommendedTopology(agentCount, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    return agentCount <= cfg.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+}
+/**
+ * Checks if swarm initialization is required for agent count
+ *
+ * @param agentCount - Number of agents
+ * @param config - Validator configuration
+ * @returns true if swarm initialization is required
+ */ export function isSwarmRequired(agentCount, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    return cfg.requireSwarmForMultiAgent && agentCount >= cfg.minAgentsRequiringSwarm;
+}
+/**
+ * Validates swarm configuration before initialization
+ *
+ * @param topology - Requested topology
+ * @param maxAgents - Maximum number of agents
+ * @param config - Validator configuration
+ * @returns Validation result
+ */ export function validateSwarmConfig(topology, maxAgents, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    // Validate topology matches max agents
+    const recommendedTopology = getRecommendedTopology(maxAgents, config);
+    if (topology !== recommendedTopology) {
+        return {
+            valid: false,
+            error: `Topology '${topology}' is not optimal for ${maxAgents} agents.`,
+            suggestion: `Recommended topology: '${recommendedTopology}'\n  • mesh: 2-${cfg.meshTopologyMaxAgents} agents\n  • hierarchical: ${cfg.hierarchicalTopologyMinAgents}+ agents`,
+            topology: recommendedTopology,
+            maxAgents
+        };
+    }
+    return {
+        valid: true
+    };
+}
+/**
+ * Factory for creating a swarm coordinator factory module
+ * This is a placeholder that will be replaced with actual implementation
+ */ export const SwarmCoordinatorFactory = {
+    getSwarmCoordinator () {
+        return null;
+    }
+};
+
+//# sourceMappingURL=swarm-init-validator.js.map

package/.claude-flow-novice/dist/src/validators/swarm-init-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/validators/swarm-init-validator.ts"],"names":["Logger","DEFAULT_CONFIG","requireSwarmForMultiAgent","minAgentsRequiringSwarm","meshTopologyMaxAgents","hierarchicalTopologyMinAgents","validateSwarmInit","agentCount","swarmStatus","config","logger","cfg","valid","warn","status","getSwarmStatus","initialized","topology","error","createErrorMessage","suggestion","createSuggestion","maxAgents","topologyValidation","validateTopology","info","expectedTopology","trim","swarmId","process","env","getSwarmCoordinator","catch","coordinator","activeAgents","agents","total","debug","requireSwarmInit","result","errorMessage","Error","getRecommendedTopology","isSwarmRequired","validateSwarmConfig","recommendedTopology","SwarmCoordinatorFactory"],"mappings":"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"}