claude-flow-novice
Version:
Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture Includes Local RuVector Accelerator and all CFN skills for complete functionality.
479 lines (392 loc) • 15.8 kB
Markdown
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)
**MANDATORY: Spawn single coordinator agent that manages ALL phases autonomously.**
The coordinator uses CLI spawning per phase and provides full visibility via web portal.
### Epic Pattern (SINGLE COORDINATOR FOR ALL PHASES)
```javascript
Task("cfn-v3-coordinator", `
CFN LOOP EPIC EXECUTION - MULTI-PHASE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
COST OPTIMIZATION - CUSTOM ROUTING (CRITICAL)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ IMPORTANT: Enable custom routing for maximum cost savings!
1. Enable routing (one-time setup):
/custom-routing-activate
2. Verify status:
/switch-api status
Cost Breakdown (PER PHASE, per iteration):
┌─────────────────────┬──────────────┬────────────┐
│ Component │ Provider │ Cost/Call │
├─────────────────────┼──────────────┼────────────┤
│ Main Chat │ Anthropic │ $0.015 │
│ Coordinator (Task) │ Anthropic │ $0.015 │
│ Loop 3 Agents (CLI) │ Z.ai │ $0.003 ea │
│ Loop 2 Agents (CLI) │ Z.ai │ $0.003 ea │
│ Product Owner (CLI) │ Z.ai │ $0.003 │
└─────────────────────┴──────────────┴────────────┘
Epic Cost Example (3 phases, 2 iterations each):
• WITH custom routing: ~$0.30 total
• WITHOUT custom routing: ~$0.90 total
• SAVINGS: ~67% cost reduction
Key Concept:
- Task() agents use Main Chat provider (Anthropic)
- CLI-spawned agents use custom routing (Z.ai when enabled)
- Cost multiplies by number of phases and iterations
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
EPIC SPECIFICATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Epic Goal: $ARGUMENTS
Epic ID: epic-$(date +%s)
Mode: STANDARD (gate: 0.75, consensus: 0.90)
Phases (ANALYZE EPIC AND DEFINE):
# Parse epic description and break into phases
# Example structure:
Phase 0: Assessment
- Deliverables: Requirements analysis, Architecture design
- Dependencies: None
- Estimated agents: 2 (analyst, architect)
Phase 1: Core Implementation
- Deliverables: Main features, API endpoints
- Dependencies: Phase 0
- Estimated agents: 3 (backend-dev, researcher, devops)
Phase 2: Validation
- Deliverables: Tests, Security audit, Documentation
- Dependencies: Phase 0, Phase 1
- Estimated agents: 3 (tester, reviewer, security-specialist)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
EPIC-LEVEL SUCCESS CRITERIA
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Scope Boundaries (CRITICAL - ENFORCE STRICTLY):
In Scope (EXAMPLE - CUSTOMIZE FOR YOUR EPIC):
- Feature implementation as described
- Basic testing and validation
- Essential documentation
- Security fundamentals
Out of Scope (DEFER TO BACKLOG - EXAMPLE):
- Advanced features not in core spec
- Performance optimization beyond basics
- Additional integrations
- Nice-to-have features
Epic-Level Acceptance Criteria:
- [ ] All phases complete with consensus ≥0.90
- [ ] All deliverables implemented
- [ ] Integration tests pass
- [ ] Security audit complete
- [ ] Documentation updated
- [ ] No scope creep (out-of-scope items deferred)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PHASE-BY-PHASE EXECUTION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
For EACH phase:
1. CHECK DEPENDENCIES:
- Verify all dependency phases complete
- Load previous phase results from memory
2. STORE SCOPE BOUNDARIES:
mcp__claude-flow-novice__memory_usage({
action: "store",
namespace: "scope-control",
key: "epic-${EPIC_ID}-scope",
value: JSON.stringify({
inScope: [...],
outOfScope: [...],
decisionAuthority: {...}
})
})
3. INVOKE ORCHESTRATOR FOR PHASE:
# Generate task ID and construct bash command with actual values
# DO NOT use template literals - construct real bash variables
TASK_ID="phase-0-$(date +%s)"
MODE="standard"
LOOP3_AGENTS="analyst,architect"
LOOP2_AGENTS="reviewer,architect"
./.claude/skills/cfn-cfn-cfn-orchestration/orchestrate.sh \
--task-id "$TASK_ID" \
--mode "$MODE" \
--loop3-agents "$LOOP3_AGENTS" \
--loop2-agents "$LOOP2_AGENTS" \
--product-owner "product-owner" \
--max-iterations 10
4. STORE PHASE RESULTS:
mcp__claude-flow-novice__memory_usage({
action: "store",
namespace: "epic-progress",
key: "phase-${PHASE_ID}-results",
value: JSON.stringify({
consensus: 0.XX,
deliverables: [...],
timestamp: Date.now()
})
})
5. AUTO-TRANSITION:
IF phase consensus ≥0.90 AND dependencies satisfied:
IMMEDIATELY start next phase (NO approval needed)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MONITORING & VISIBILITY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Web Portal: http://localhost:3000
Per-Phase Monitoring:
- Agents: ./.claude/skills/cfn-cfn-web-portal/invoke-portal-agents.sh --swarm phase-${PHASE_ID}
- Events: ./.claude/skills/cfn-cfn-web-portal/invoke-portal-events.sh --phase phase-${PHASE_ID}
- Metrics: ./.claude/skills/cfn-cfn-web-portal/invoke-portal-metrics.sh
Epic Progress:
- Query memory for phase results
- Track consensus trends
- Monitor scope adherence
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FINAL EPIC REPORT
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Return structured result to Main Chat:
{
"epicId": "epic-XXXXX",
"status": "complete|partial|failed",
"phases": [
{
"phaseId": "phase-1",
"name": "User Authentication",
"status": "complete",
"consensus": 0.94,
"iterations": {"loop3": 2, "loop2": 1},
"deliverables": ["Login API", "JWT generation", ...]
},
...
],
"deferredItems": [
"OAuth integration (out-of-scope)",
"Biometric auth (out-of-scope)"
],
"recommendations": [...]
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CRITICAL RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- DO NOT spawn agents with Task()
- LET orchestrator handle CLI spawning per phase
- USE memory for scope enforcement
- AUTO-TRANSITION between phases (no approval)
- DEFER out-of-scope items to backlog
- PUBLISH events per phase
- RETURN epic summary when complete
`, "cfn-v3-coordinator")
```
### Coordinator Autonomous Multi-Phase Execution
**Phase Iteration:**
For each phase, coordinator:
1. Checks dependencies satisfied
2. Loads scope boundaries
3. Invokes orchestrator for phase
4. Monitors via web portal
5. Stores phase results
6. Auto-transitions to next phase
**Visibility per Phase:**
- Web UI shows all phases, current phase highlighted
- Event stream filtered by phase ID
- Metrics track per-phase consensus trends
### 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.
```