claude-flow-novice 1.6.1 → 1.6.2

package/.claude/commands/cfn-loop-epic.md

@@ -0,0 +1,290 @@
+---
+description: "Execute multi-phase epic with CFN Loop orchestration and autonomous phase transitions"
+argument-hint: "<epic description>"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+---
+
+# CFN Loop Epic - Multi-Phase Autonomous Development
+
+Execute a large multi-phase epic using the full 4-loop CFN structure with autonomous phase orchestration.
+
+🚨 **AUTONOMOUS MULTI-PHASE SELF-LOOPING PROCESS**
+
+**Epic Goal**: $ARGUMENTS
+
+## CFN Loop Structure (4 Loops)
+
+```
+LOOP 0: Epic/Sprint Orchestration (THIS COMMAND)
+   ├─ Phase 1 → Phase 2 → Phase 3 → ... → Phase N
+   ↓
+LOOP 1: Phase Execution (current phase)
+   ↓
+LOOP 2: Consensus Validation (≥90% Byzantine consensus)
+   ↓
+LOOP 3: Primary Swarm Execution (implementation with confidence scores)
+```
+
+## Epic Planning (Loop 0)
+
+### Step 1: Parse Epic into Phases
+```javascript
+// Use parse-epic utility to break down epic
+const epicPlan = {
+  epic_name: "auth-system",
+  phases: [
+    {
+      phase_id: "1",
+      name: "User Authentication",
+      deliverables: ["Login API", "JWT generation", "Password hashing"],
+      dependencies: [],
+      estimated_agents: 5
+    },
+    {
+      phase_id: "2",
+      name: "Authorization & RBAC",
+      deliverables: ["Role system", "Permission checks", "Middleware"],
+      dependencies: ["1"],
+      estimated_agents: 6
+    },
+    {
+      phase_id: "3",
+      name: "Session Management",
+      deliverables: ["Refresh tokens", "Logout", "Session tracking"],
+      dependencies: ["1", "2"],
+      estimated_agents: 4
+    }
+  ]
+}
+```
+
+### Step 2: Store Scope Boundaries (CRITICAL)
+```javascript
+mcp__claude-flow-novice__memory_usage({
+  action: "store",
+  namespace: "scope-control",
+  key: "project-boundaries",
+  value: JSON.stringify({
+    primary_goal: "Build complete authentication system",
+    in_scope: [
+      "JWT authentication",
+      "Role-based access control",
+      "Session management",
+      "Password security (bcrypt)"
+    ],
+    out_of_scope: [
+      "OAuth/social login",
+      "Multi-factor authentication",
+      "Biometric authentication",
+      "Advanced rate limiting beyond basic"
+    ],
+    risk_profile: "public-facing-medium-risk",
+    decision_authority_config: {
+      auto_approve_threshold: 0.90,
+      auto_relaunch_max_iteration: 10,
+      escalation_criteria: ["security vulnerability", "data loss risk"]
+    }
+  })
+})
+```
+
+## Phase Execution (Loop 1)
+
+For EACH phase in epic:
+
+### Phase Initialization
+1. Check dependencies satisfied
+2. Load scope boundaries from memory
+3. Initialize swarm for phase
+4. Execute Loop 2 & Loop 3 (as defined in /cfn-loop command)
+
+### Phase Pattern
+```javascript
+// PHASE 1: User Authentication
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",
+  maxAgents: 5,
+  strategy: "balanced"
+})
+
+// Loop 3: Primary swarm
+Task("Coder 1", `
+  Implement JWT generation...
+
+  MANDATORY: After EVERY file edit:
+  node config/hooks/post-edit-pipeline.js "[FILE_PATH]" --memory-key "swarm/auth/coder-1"
+
+  Report confidence score.
+`, "backend-dev")
+
+// ... more agents
+
+// Self-Assessment Gate → Consensus → Product Owner → Action
+
+// If Phase 1 consensus ≥90% → AUTO-TRANSITION to Phase 2
+```
+
+### Phase Transition Logic
+```javascript
+// After each phase completes
+if (consensusScore >= 0.90 && allDeliverablesComplete) {
+  // Store phase results
+  mcp__claude-flow-novice__memory_usage({
+    action: "store",
+    namespace: "epic-progress",
+    key: `phase-${phaseId}-results`,
+    value: JSON.stringify({
+      consensus: consensusScore,
+      deliverables: completedDeliverables,
+      timestamp: Date.now()
+    })
+  })
+
+  // Check next phase dependencies
+  const nextPhase = epicPlan.phases[currentPhaseIndex + 1];
+  if (dependenciesSatisfied(nextPhase)) {
+    // IMMEDIATELY transition (NO approval needed)
+    executePhase(nextPhase);
+  }
+}
+```
+
+## Product Owner Integration (GOAP)
+
+Product Owner operates at EACH phase completion:
+
+```javascript
+Task("Product Owner", `
+  GOAP DECISION - Phase ${phaseId} Complete
+
+  CURRENT STATE:
+  - Phase ${phaseId} consensus: ${consensusScore}
+  - Remaining phases: ${remainingPhases}
+  - Validator concerns: ${concerns}
+
+  RETRIEVE EPIC SCOPE:
+  mcp__claude-flow-novice__memory_usage({
+    action: "retrieve",
+    namespace: "scope-control",
+    key: "project-boundaries"
+  })
+
+  EXECUTE GOAP A* SEARCH:
+  1. Classify phase completion quality
+  2. Evaluate scope adherence
+  3. Calculate cost of scope expansion vs backlog defer
+  4. Make autonomous decision
+
+  DECISION OPTIONS:
+  - PROCEED_NEXT_PHASE (dependencies satisfied, scope intact)
+  - DEFER_CONCERNS (save to backlog, continue epic)
+  - ESCALATE (critical scope violation or blocker)
+
+  OUTPUT: {decision: "...", next_action: "..."}
+`, "product-owner")
+```
+
+## Autonomous Multi-Phase Execution
+
+**FORBIDDEN PATTERNS:**
+- ❌ "Phase 1 complete. Proceed to Phase 2?" (AUTO-PROCEED)
+- ❌ "Should I continue the epic?" (ALWAYS continue until all phases done)
+- ❌ Waiting for approval between phases (AUTONOMOUS TRANSITION)
+
+**REQUIRED PATTERNS:**
+```
+Phase 1 consensus: 94% ✅
+Dependencies for Phase 2 satisfied.
+IMMEDIATELY transitioning to Phase 2...
+
+Phase 2: Authorization & RBAC
+[Spawning agents autonomously - no permission needed]
+```
+
+## Iteration Limits (Per Phase)
+- **Loop 2** (Consensus): 10 iterations max per phase
+- **Loop 3** (Primary Swarm): 10 iterations max per phase
+- **Loop 1** (Phases): Unlimited (continues until all phases complete)
+
+## Epic Progress Tracking
+
+```javascript
+// Query epic progress
+mcp__claude-flow-novice__memory_usage({
+  action: "list",
+  namespace: "epic-progress"
+})
+
+// Output:
+{
+  "phase-1-results": {consensus: 0.94, deliverables: [...]},
+  "phase-2-results": {consensus: 0.91, deliverables: [...]},
+  "phase-3-results": null // Current phase in progress
+}
+```
+
+## Example Multi-Phase Execution
+
+```
+[Turn 1] Epic: Auth System (3 phases)
+         → Scope boundaries stored in memory
+         → Phase 1: User Authentication
+
+[Turn 2-5] Phase 1 Execution (Loop 3 + Loop 2)
+           → Loop 3 iterations (confidence checks)
+           → Loop 2 consensus validation
+           → Product Owner: PROCEED_NEXT_PHASE
+           → Phase 1 COMPLETE (consensus: 94%)
+
+[Turn 6] AUTONOMOUS TRANSITION
+         → Dependencies for Phase 2 satisfied
+         → IMMEDIATELY starting Phase 2: Authorization & RBAC
+
+[Turn 7-10] Phase 2 Execution
+            → Loop 3 + Loop 2 cycles
+            → Product Owner: DEFER (OAuth out-of-scope)
+            → Phase 2 COMPLETE (consensus: 91%)
+
+[Turn 11] AUTONOMOUS TRANSITION
+          → Phase 3: Session Management
+
+[Turn 12-14] Phase 3 Execution
+             → Final phase completion
+             → Epic COMPLETE ✅
+```
+
+## Output Format
+
+```
+Epic: auth-system (3 phases)
+Phase 1/3: User Authentication
+
+Loop 3 Iteration 2/10 - Confidence: 85% avg ✅
+Loop 2 Iteration 1/10 - Consensus: 94% ✅
+
+Phase 1 COMPLETE
+Dependencies satisfied for Phase 2.
+IMMEDIATELY transitioning to Phase 2...
+
+─────────────────────────────────
+Phase 2/3: Authorization & RBAC
+[Executing autonomously - no permission needed]
+```
+
+## Epic Completion
+
+When final phase achieves ≥90% consensus:
+```
+Phase 3 COMPLETE - Consensus: 92% ✅
+
+Epic: auth-system - ALL PHASES COMPLETE ✅
+- Phase 1: User Authentication (94%)
+- Phase 2: Authorization & RBAC (91%)
+- Phase 3: Session Management (92%)
+
+Deferred items saved to backlog:
+- OAuth/social login integration
+- Multi-factor authentication
+
+Epic execution complete. Self-looping terminated.
+```

package/.claude/commands/cfn-loop-single.md

@@ -0,0 +1,168 @@
+---
+description: "Execute single task through autonomous CFN Loop (natural language, file path, or partial reference)"
+argument-hint: "<task description or file reference>"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+---
+
+# CFN Loop Single - Single Task Autonomous Execution
+
+Execute a single task through the CFN Loop without sprint/phase structure. Supports natural language, file paths, or partial file references.
+
+🚨 **AUTONOMOUS SELF-LOOPING PROCESS**
+
+**Task**: $ARGUMENTS
+
+## CFN Loop Structure (4 Loops)
+
+```
+LOOP 0: Epic/Sprint Orchestration (use /cfn-loop-epic or /cfn-loop-sprints)
+   ↓
+LOOP 1: Phase Execution (this command - single phase)
+   ↓
+LOOP 2: Consensus Validation (≥90% Byzantine consensus)
+   ↓
+LOOP 3: Primary Swarm Execution (implementation with confidence scores)
+```
+
+## Execution Pattern
+
+### Step 1: Initialize Swarm (MANDATORY)
+```javascript
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",          // mesh for 2-7, hierarchical for 8+
+  maxAgents: 5,              // match actual agent count
+  strategy: "balanced"
+})
+```
+
+### Step 2: Execute - Primary Swarm (Loop 3)
+```javascript
+// Spawn ALL agents in ONE message
+Task("Coder 1", `
+  Implementation task...
+
+  MANDATORY: After EVERY file edit, run:
+  node config/hooks/post-edit-pipeline.js "[FILE_PATH]" --memory-key "swarm/coder-1/step-1"
+
+  Report confidence score when complete.
+`, "coder")
+
+Task("Tester 1", "...", "tester")
+Task("Backend Dev 1", "...", "backend-dev")
+```
+
+### Step 3: Self-Assessment Gate
+- Collect confidence scores from ALL agents
+- **PASS** (all ≥75%) → Proceed to Step 4
+- **FAIL** (any <75%) → IMMEDIATELY relaunch Loop 3 with targeted agents (NO approval)
+
+### Step 4: Verify - Consensus Swarm
+**CRITICAL**: Spawn validators in SEPARATE message AFTER implementation complete:
+
+```javascript
+// MESSAGE 2: Validators (AFTER implementation)
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",
+  maxAgents: 3,
+  strategy: "balanced"
+})
+
+Task("Validator 1", "Review completed work at [files]", "reviewer")
+Task("Validator 2", "Security audit of implementation", "security-specialist")
+Task("Validator 3", "Architecture validation", "system-architect")
+```
+
+### Step 5: Product Owner Decision Gate (GOAP)
+```javascript
+Task("Product Owner", `
+  GOAP DECISION EXECUTION - Loop 2 Iteration ${iteration}/10
+
+  CURRENT STATE:
+  - Consensus: ${consensusScore} (target: ≥0.90)
+  - Validator concerns: ${JSON.stringify(concerns)}
+
+  RETRIEVE SCOPE:
+  mcp__claude-flow-novice__memory_usage({
+    action: "retrieve",
+    namespace: "scope-control",
+    key: "project-boundaries"
+  })
+
+  EXECUTE GOAP A* SEARCH:
+  1. Classify concerns: in-scope vs out-of-scope
+  2. Generate action space with cost functions
+  3. Run A* pathfinding
+  4. Make autonomous decision
+
+  OUTPUT: {decision: "PROCEED|DEFER|ESCALATE", ...}
+`, "product-owner")
+```
+
+**Decision Outcomes:**
+- **PROCEED** → IMMEDIATELY relaunch Loop 3 with targeted agents (NO approval)
+- **DEFER** → Save to backlog, approve phase
+- **ESCALATE** → Generate alternatives (rare)
+
+### Step 6: Action Based on Decision
+- **PROCEED** → Spawn Loop 3 swarm with Product Owner's agent selections
+- **DEFER** → Transition to next phase (if applicable)
+- **ESCALATE** → Only STOP if critical error
+
+## Autonomous Execution Rules
+
+**YOU ARE FORBIDDEN FROM:**
+- ❌ Asking "Should I retry?" (ALWAYS retry if iterations < 10)
+- ❌ Asking "Proceed to next step?" (AUTO-PROCEED)
+- ❌ Waiting for approval during CFN Loop cycles
+
+**YOU MUST:**
+- ✅ IMMEDIATELY relaunch Loop 3 on low confidence (iteration < 10)
+- ✅ IMMEDIATELY relaunch Loop 3 on consensus failure (iteration < 10)
+- ✅ AUTOMATICALLY select better agents based on failure analysis
+- ✅ ONLY escalate when truly blocked (critical error or max iterations)
+
+## Iteration Limits
+- **Loop 2** (Consensus): 10 iterations max
+- **Loop 3** (Primary Swarm): 10 iterations max
+
+## Example Execution
+
+```
+[Turn 1] Loop 3 Iteration 1/10
+         → Primary swarm (coder, tester, backend-dev)
+         → Confidence: 68%, 72%, 85%
+         → Gate FAILS (2 agents <75%)
+         → IMMEDIATELY retry Loop 3 (autonomous)
+
+[Turn 2] Loop 3 Iteration 2/10
+         → Primary swarm with feedback
+         → Confidence: 82%, 79%, 88%
+         → Gate PASSES (all ≥75%)
+         → Proceed to Loop 2
+
+[Turn 3] Loop 2 Iteration 1/10
+         → Consensus validators spawned
+         → Consensus: 85% (below 90%)
+         → IMMEDIATELY retry (autonomous)
+
+[Turn 4] Loop 2 Iteration 2/10
+         → Product Owner: PROCEED (GOAP cost=50)
+         → Loop 3 relaunched with targeted agents
+         → Consensus achieved: 94% ✅
+         → PHASE COMPLETE
+```
+
+## Output Format
+
+Concise, action-oriented:
+```
+Loop 3 Iteration 2/10 - Confidence: 82% avg ✅
+Proceeding to Loop 2 (Consensus)...
+
+Loop 2 Iteration 1/10 - Consensus: 87% ❌
+Product Owner: PROCEED (5 in-scope blockers)
+IMMEDIATELY relaunching Loop 3 with:
+- backend-dev (fix SQL injection)
+- security-specialist (validate fix)
+[Executing autonomously - no permission needed]
+```