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.
257 lines (199 loc) • 9.68 kB
Markdown
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
**MANDATORY: Spawn single coordinator agent that manages all orchestration internally.**
The coordinator uses CLI spawning (95-98% cost savings) and provides full visibility via web portal.
### Step 1: Spawn Coordinator Agent (SINGLE AGENT PATTERN)
```javascript
Task("cfn-v3-coordinator", `
CFN LOOP SINGLE TASK EXECUTION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
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 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 │
└─────────────────────┴──────────────┴────────────┘
Expected Savings:
• WITH custom routing: ~64% cost reduction
• WITHOUT custom routing: Full Anthropic pricing
• Combined with CLI: 95-98% vs all-Task-tool
Key Concept:
- Task() agents use Main Chat provider (Anthropic)
- CLI-spawned agents use custom routing (Z.ai when enabled)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TASK SPECIFICATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Task Description: $ARGUMENTS
Task ID: cfn-single-$(date +%s)
Mode: STANDARD (gate: 0.75, consensus: 0.90)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SUCCESS CRITERIA (REQUIRED - CUSTOMIZE FOR TASK)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Acceptance Criteria:
- [ ] Core functionality implemented
- [ ] Tests pass with >80% coverage
- [ ] Code reviewed for security
- [ ] Documentation complete
- [ ] No breaking changes
Quality Gates:
- Loop 3 Gate Threshold: 0.75 (standard mode)
- Loop 2 Consensus Threshold: 0.90 (standard mode)
- Max Loop 3 Iterations: 10
- Max Loop 2 Iterations: 10
Definition of Done:
- All acceptance criteria checked
- Consensus ≥0.90 achieved
- Product Owner approval
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AGENT CONFIGURATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Loop 3 Agents (Implementation):
- researcher (requirement analysis)
- backend-dev (implementation)
- devops (deployment/infrastructure)
Loop 2 Agents (Validation):
- reviewer (code review)
- architect (design validation)
- tester (quality assurance)
- security-specialist (security audit)
Product Owner: product-owner (GOAP decision-making)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
EXECUTION INSTRUCTIONS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. INVOKE ORCHESTRATOR:
./.claude/skills/cfn-cfn-orchestration/orchestrate.sh \\
--task-id "cfn-single-$(date +%s)" \\
--mode standard \\
--loop3-agents "researcher,backend-dev,devops" \\
--loop2-agents "reviewer,architect,tester,security-specialist" \\
--product-owner "product-owner" \\
--max-iterations 10
2. MONITOR PROGRESS:
- Web portal: http://localhost:3000
- CLI metrics: ./.claude/skills/cfn-web-portal/invoke-portal-agents.sh
- Event stream: ./.claude/skills/cfn-web-portal/invoke-portal-events.sh
3. REPORT STRUCTURED RESULT:
{
"taskId": "cfn-single-XXXXX",
"status": "complete|failed",
"iterations": {"loop3": N, "loop2": M},
"finalConsensus": 0.XX,
"acceptanceCriteria": {
"met": ["Core functionality", "Tests passing", ...],
"pending": ["Documentation"]
},
"recommendations": [...]
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CRITICAL RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- DO NOT spawn agents with Task()
- LET orchestrator handle CLI spawning
- USE Redis BLPOP for dependencies
- PUBLISH events to web-portal channel
- RETURN structured result to Main Chat
`, "cfn-v3-coordinator")
```
### Step 2: Coordinator Autonomous Execution
The coordinator runs orchestrator script internally:
**Loop 3: Implementation**
- Spawns agents via CLI: `npx cfn-spawn agent <type>`
- Collects confidence scores
- Gate check (≥0.75): PASS → Wake Loop 2 | FAIL → Iterate
**Loop 2: Validation**
- **WAITS** for Loop 3 gate pass (Redis BLPOP)
- Spawns validators via CLI
- Collects consensus scores
- Consensus check (≥0.90): PASS → Complete | FAIL → Iterate
**Loop 1: Product Owner**
- GOAP decision-making
- Returns structured result to Main Chat
### Step 3: Visibility via Web Portal
**Monitor execution:**
```bash
# Start web portal (if not running)
./.claude/skills/cfn-web-portal/invoke-portal-start.sh
# View agents
./.claude/skills/cfn-web-portal/invoke-portal-agents.sh --status active
# Track events
./.claude/skills/cfn-web-portal/invoke-portal-events.sh --limit 50
# Get metrics
./.claude/skills/cfn-web-portal/invoke-portal-metrics.sh
```
**Web UI:** http://localhost:3000 (real-time updates)
## 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]
```