claude-flow-novice 2.13.0 → 2.14.1

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

@@ -0,0 +1,256 @@
+---
+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]
+```

package/claude-assets/commands/cfn/cfn-loop-sprints.md

@@ -0,0 +1,396 @@
+---
+description: "Execute single phase with multiple sprints using CFN Loop autonomous coordination"
+argument-hint: "<phase description>"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+---
+
+# CFN Loop Sprints - Single Phase, Multiple Sprints
+
+Execute a single phase broken into multiple sprints using CFN Loop autonomous coordination.
+
+🚨 **AUTONOMOUS SPRINT-BASED SELF-LOOPING PROCESS**
+
+**Phase Goal**: $ARGUMENTS
+
+## CFN Loop Structure (4 Loops)
+
+```
+LOOP 0: Epic/Sprint Orchestration (THIS COMMAND - sprint level)
+   ├─ Sprint 1 → Sprint 2 → Sprint 3 → ... → Sprint N
+   ↓
+LOOP 1: Phase Execution (single phase with multiple sprints)
+   ↓
+LOOP 2: Consensus Validation (≥90% Byzantine consensus per sprint)
+   ↓
+LOOP 3: Primary Swarm Execution (implementation with confidence scores)
+```
+
+## Sprint Planning (Loop 0)
+
+### Step 1: Parse Phase into Sprints
+```javascript
+const sprintPlan = {
+  phase_name: "User Authentication",
+  sprints: [
+    {
+      sprint_id: "1.1",
+      name: "Core Login API",
+      deliverables: [
+        "POST /auth/login endpoint",
+        "JWT token generation",
+        "Password validation"
+      ],
+      estimated_agents: 3,
+      dependencies: []
+    },
+    {
+      sprint_id: "1.2",
+      name: "Password Security",
+      deliverables: [
+        "bcrypt password hashing",
+        "Salt generation",
+        "Hash verification"
+      ],
+      estimated_agents: 2,
+      dependencies: ["1.1"]
+    },
+    {
+      sprint_id: "1.3",
+      name: "Token Management",
+      deliverables: [
+        "Token refresh endpoint",
+        "Token expiration handling",
+        "Token blacklisting"
+      ],
+      estimated_agents: 4,
+      dependencies: ["1.1", "1.2"]
+    }
+  ]
+}
+```
+
+### Step 2: Store Scope Boundaries (Per Sprint)
+```javascript
+mcp__claude-flow-novice__memory_usage({
+  action: "store",
+  namespace: "scope-control",
+  key: "sprint-boundaries",
+  value: JSON.stringify({
+    primary_goal: "User Authentication Phase",
+    sprint_scope: {
+      "1.1": {
+        in_scope: ["Login API", "JWT generation", "Basic validation"],
+        out_of_scope: ["OAuth", "MFA", "Password reset"]
+      },
+      "1.2": {
+        in_scope: ["bcrypt hashing", "Salt generation"],
+        out_of_scope: ["Argon2", "Key derivation functions"]
+      },
+      "1.3": {
+        in_scope: ["Refresh tokens", "Expiration", "Blacklist"],
+        out_of_scope: ["Sliding sessions", "Device tracking"]
+      }
+    },
+    risk_profile: "public-facing-medium-risk"
+  })
+})
+```
+
+## Sprint Execution (Loop 1)
+
+For EACH sprint in phase:
+
+### Sprint Initialization (MANDATORY Coordinator Pattern)
+
+**CRITICAL:** Use CFN Loop Coordinator agent with automatic orchestration.
+
+```javascript
+// SPRINT 1.1: Core Login API - Spawn coordinator (DO NOT spawn implementers directly)
+Task("CFN Loop Coordinator", `
+  Execute CFN Loop for Sprint ${sprintId}: ${sprintName}
+
+  MANDATORY: Use orchestrator script for dependency enforcement.
+
+  ./.claude/skills/cfn-cfn-orchestration/orchestrate.sh \
+    --task-id "sprint-${sprintId}-$(date +%s)" \
+    --mode standard \
+    --loop3-agents "backend-dev,tester,security-specialist" \
+    --loop2-agents "reviewer,architect" \
+    --product-owner "product-owner" \
+    --max-iterations 10
+
+  The orchestrator will:
+  - Spawn all agents automatically
+  - Enforce BLPOP dependency blocking
+  - Collect consensus after validators finish
+  - Wake agents for next iteration if needed
+  - Report final result
+
+  DO NOT spawn agents manually with Task().
+`, "cfn-loop-coordinator")
+```
+
+### Alternative: Manual Spawning (NOT RECOMMENDED)
+
+If you must spawn agents manually (NOT recommended due to lack of dependency enforcement), follow this pattern:
+
+```javascript
+// Initialize swarm for sprint
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",
+  maxAgents: 3,
+  strategy: "balanced"
+})
+
+// Execute Loop 3 (Primary Swarm)
+Task("Backend Dev 1", `
+  Implement POST /auth/login endpoint
+
+  MANDATORY: After EVERY file edit:
+  node config/hooks/post-edit-pipeline.js "[FILE_PATH]" --memory-key "swarm/sprint-1.1/backend-1"
+
+  Report confidence score when complete.
+`, "backend-dev")
+
+// ... more agents
+```
+
+### Sprint Self-Assessment Gate
+```javascript
+// Collect confidence scores
+const sprintConfidence = {
+  "backend-1": 0.88,
+  "tester-1": 0.82,
+  "security-1": 0.79
+}
+
+// Gate logic
+if (allAgents >= 0.75) {
+  // PROCEED to Loop 2 (Consensus)
+  console.log("Sprint ${sprintId} gate PASSED. Proceeding to consensus...");
+} else {
+  // RELAUNCH Loop 3 (autonomous retry)
+  console.log("Sprint ${sprintId} gate FAILED. Relaunching Loop 3 with feedback...");
+}
+```
+
+### Sprint Consensus Validation
+```javascript
+// MESSAGE 2: Validators (AFTER sprint implementation complete)
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",
+  maxAgents: 2,
+  strategy: "balanced"
+})
+
+Task("Reviewer 1", `
+  Review completed Sprint ${sprintId} work:
+  - Files: [list specific files]
+  - Deliverables: ${JSON.stringify(deliverables)}
+
+  Validate code quality, test coverage, security.
+  Report consensus score.
+`, "reviewer")
+
+Task("Architect 1", `
+  Validate Sprint ${sprintId} architecture:
+  - API design consistency
+  - Integration patterns
+  - Scalability considerations
+
+  Report consensus score.
+`, "architect")
+```
+
+### Sprint Product Owner Decision
+```javascript
+Task("Product Owner", `
+  GOAP DECISION - Sprint ${sprintId} Complete
+
+  CURRENT STATE:
+  - Sprint ${sprintId} consensus: ${consensusScore}
+  - Remaining sprints: ${remainingSprints}
+  - Validator concerns: ${concerns}
+
+  RETRIEVE SPRINT SCOPE:
+  mcp__claude-flow-novice__memory_usage({
+    action: "retrieve",
+    namespace: "scope-control",
+    key: "sprint-boundaries"
+  })
+
+  EXECUTE GOAP A* SEARCH:
+  1. Classify concerns by sprint scope
+  2. Calculate cost: in-scope fix vs defer to backlog
+  3. A* pathfinding for optimal decision
+  4. Make autonomous decision
+
+  DECISION OPTIONS:
+  - PROCEED_NEXT_SPRINT (dependencies satisfied, scope intact)
+  - RELAUNCH_SPRINT (in-scope blockers remain)
+  - DEFER_CONCERNS (out-of-scope, save to backlog)
+
+  OUTPUT: {decision: "...", next_action: "..."}
+`, "product-owner")
+```
+
+### Sprint Transition Logic
+```javascript
+// Product Owner decision outcomes
+switch (decision) {
+  case "PROCEED_NEXT_SPRINT":
+    // Store sprint results
+    mcp__claude-flow-novice__memory_usage({
+      action: "store",
+      namespace: "sprint-progress",
+      key: `sprint-${sprintId}-results`,
+      value: JSON.stringify({
+        consensus: consensusScore,
+        deliverables: completedDeliverables,
+        timestamp: Date.now()
+      })
+    })
+
+    // Check next sprint dependencies
+    const nextSprint = sprintPlan.sprints[currentSprintIndex + 1];
+    if (dependenciesSatisfied(nextSprint)) {
+      // IMMEDIATELY transition (NO approval needed)
+      console.log(`IMMEDIATELY transitioning to Sprint ${nextSprint.sprint_id}...`);
+      executeSprint(nextSprint);
+    }
+    break;
+
+  case "RELAUNCH_SPRINT":
+    // IMMEDIATELY relaunch Loop 3 with targeted agents (NO approval)
+    console.log(`Relaunching Sprint ${sprintId} Loop 3 with targeted agents...`);
+    break;
+
+  case "DEFER_CONCERNS":
+    // Save to backlog, proceed to next sprint
+    console.log(`Deferred out-of-scope items. Proceeding to next sprint...`);
+    break;
+}
+```
+
+## Autonomous Sprint Execution
+
+**FORBIDDEN PATTERNS:**
+- ❌ "Sprint 1.1 complete. Proceed to Sprint 1.2?" (AUTO-PROCEED)
+- ❌ "Should I continue with sprints?" (ALWAYS continue until all sprints done)
+- ❌ Waiting for approval between sprints (AUTONOMOUS TRANSITION)
+
+**REQUIRED PATTERNS:**
+```
+Sprint 1.1 consensus: 93% ✅
+Dependencies for Sprint 1.2 satisfied.
+IMMEDIATELY transitioning to Sprint 1.2...
+
+Sprint 1.2: Password Security
+[Spawning agents autonomously - no permission needed]
+```
+
+## Iteration Limits (Per Sprint)
+- **Loop 2** (Consensus): 10 iterations max per sprint
+- **Loop 3** (Primary Swarm): 10 iterations max per sprint
+- **Loop 1** (Sprints): Unlimited (continues until all sprints complete)
+
+## Sprint Progress Tracking
+
+```javascript
+// Query sprint progress
+mcp__claude-flow-novice__memory_usage({
+  action: "list",
+  namespace: "sprint-progress"
+})
+
+// Output:
+{
+  "sprint-1.1-results": {consensus: 0.93, deliverables: [...]},
+  "sprint-1.2-results": {consensus: 0.88, deliverables: [...]},
+  "sprint-1.3-results": null // Current sprint in progress
+}
+```
+
+## Example Sprint Execution
+
+```
+[Turn 1] Phase: User Authentication (3 sprints)
+         → Sprint scope boundaries stored
+         → Sprint 1.1: Core Login API
+
+[Turn 2-3] Sprint 1.1 Execution
+           → Loop 3 (backend-dev, tester, security)
+           → Gate PASSES (all ≥75%)
+           → Loop 2 consensus: 93% ✅
+           → Product Owner: PROCEED_NEXT_SPRINT
+
+[Turn 4] AUTONOMOUS TRANSITION
+         → Dependencies for Sprint 1.2 satisfied
+         → IMMEDIATELY starting Sprint 1.2: Password Security
+
+[Turn 5-6] Sprint 1.2 Execution
+           → Loop 3 (2 agents - smaller scope)
+           → Consensus: 88% ✅
+           → Product Owner: DEFER (Argon2 out-of-scope)
+
+[Turn 7] AUTONOMOUS TRANSITION
+         → Sprint 1.3: Token Management
+
+[Turn 8-10] Sprint 1.3 Execution
+            → Final sprint completion
+            → Phase COMPLETE ✅
+```
+
+## Output Format
+
+```
+Phase: User Authentication (3 sprints)
+Sprint 1.1/1.3: Core Login API
+
+Loop 3 Iteration 1/10 - Confidence: 87% avg ✅
+Loop 2 Iteration 1/10 - Consensus: 93% ✅
+
+Sprint 1.1 COMPLETE
+Dependencies satisfied for Sprint 1.2.
+IMMEDIATELY transitioning to Sprint 1.2...
+
+─────────────────────────────────
+Sprint 1.2/1.3: Password Security
+[Executing autonomously - no permission needed]
+```
+
+## Phase Completion
+
+When final sprint achieves ≥90% consensus:
+```
+Sprint 1.3 COMPLETE - Consensus: 91% ✅
+
+Phase: User Authentication - ALL SPRINTS COMPLETE ✅
+- Sprint 1.1: Core Login API (93%)
+- Sprint 1.2: Password Security (88%)
+- Sprint 1.3: Token Management (91%)
+
+Deferred items saved to backlog:
+- OAuth integration (out-of-scope)
+- Argon2 hashing (out-of-scope)
+- Sliding session windows (out-of-scope)
+
+Phase execution complete. Self-looping terminated.
+```
+
+## Integration with Epic
+
+If this phase is part of a larger epic, results are stored for epic-level tracking:
+```javascript
+mcp__claude-flow-novice__memory_usage({
+  action: "store",
+  namespace: "epic-progress",
+  key: "phase-1-results",
+  value: JSON.stringify({
+    phase_name: "User Authentication",
+    sprints_completed: ["1.1", "1.2", "1.3"],
+    overall_consensus: 0.91,
+    ready_for_next_phase: true
+  })
+})
+```

package/claude-assets/commands/cfn/cfn-loop-task.md

@@ -4,13 +4,21 @@ argument-hint: "<task description> [--mode=mvp|standard|enterprise] [--max-itera
 allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Edit", "Bash", "Glob", "Grep"]
 ---
 
-# CFN Loop Task Mode - Debugging & Learning
+# 🚨 TASK MODE INSTRUCTIONS FOR MAIN CHAT
 
-Execute CFN Loop using Task() spawning for full visibility and debugging.
+**YOU are executing this CFN Loop. These are YOUR instructions.**
 
-🚨 **TASK MODE: Debugging, Learning, Full Transparency**
+**Task to execute**: $ARGUMENTS
 
-**Task**: $ARGUMENTS
+## MODE: Task Mode (Full Visibility, Direct Coordination)
+
+**CRITICAL RULES:**
+1. ❌ **DO NOT spawn cfn-v3-coordinator** - that's for CLI mode
+2. ❌ **DO NOT ask user "which mode?"** - they already chose Task mode
+3. ❌ **DO NOT offer options** - execute these instructions directly
+4. ✅ **YOU spawn all agents** using Task() tool
+5. ✅ **YOU coordinate the entire workflow** step by step
+6. ✅ **Follow the 9-step workflow below** exactly
 
 ## What is Task Mode?
 
@@ -81,17 +89,27 @@ Cost: 3x CLI mode, but full visibility for debugging
 | Standard | ≥0.75 | ≥0.90 | 10 | 3-4 | Production features |
 | Enterprise | ≥0.85 | ≥0.95 | 15 | 5 | Security, compliance, critical systems |
 
-## Execution Instructions
+## 🚨 CRITICAL EXECUTION INSTRUCTIONS
+
+**YOU ARE MAIN CHAT. YOU COORDINATE THIS ENTIRE WORKFLOW.**
+
+**DO NOT spawn cfn-v3-coordinator or any coordinator agent.**
+**DO NOT ask user which mode to use.**
+**DO NOT offer options.**
+
+You must execute this CFN Loop directly using the Task() tool to spawn agents.
 
-**Main Chat coordinates directly. NO coordinator agent spawned.**
+---
 
 ### Step 1: Read Task Mode Guide
 
-```javascript
-const guide = Read('.claude/commands/cfn/CFN_LOOP_TASK_MODE.md');
+Read the complete Task Mode guide for detailed workflow:
 
-console.log('Task Mode: Main Chat coordinating CFN Loop directly');
 ```
+Read('.claude/commands/cfn/CFN_LOOP_TASK_MODE.md')
+```
+
+**Expected output:** Complete guide with agent selection, workflow steps, helper scripts
 
 ### Step 2: Analyze Task Complexity