git:20251210.62c1225 to git:20260725.c9691fc

- # CFN Docker Loop Orchestration Skill

-

- **Purpose:** Orchestrate container-based CFN Loop execution with agent spawning, loop management, consensus collection, and product owner decision flow.

-

- ## Overview

-

- This skill manages the complete CFN Loop execution lifecycle for docker-based agents, coordinating Loop 3 (implementer) and Loop 2 (validator) phases, collecting confidence scores and consensus, and triggering Product Owner decisions.

-

- ## Architecture

-

- ```bash

- CFN Docker V3 Coordinator

- ↓ (task analysis)

- CFN Docker Loop Orchestration

- ↓ (context storage)

- Redis (State Management)

- ↓ (agent spawning)

- CFN Docker Agent Spawning

- ↓ (container execution)

- Docker Containers (Agents)

- ↓ (completion signals)

- Consensus Collection

- ↓ (decision flow)

- Product Owner Decision

- ```

-

- ## Loop Execution Model

-

- ### Loop 3: Primary Implementation (Implementers)

- - **Purpose**: Create, build, and implement the solution

- - **Agents**: 3 specialized implementers based on task requirements

- - **Process**: Parallel execution → Confidence reporting → Gate check

-

- ### Loop 2: Consensus Validation (Validators)

- - **Purpose**: Review and validate Loop 3 work

- - **Agents**: 2-4 validators (reviewers, testers, security specialists)

- - **Process**: Sequential validation → Consensus collection → Decision

-

- ### Loop 4: Product Owner Decision

- - **Purpose**: Strategic decision based on consensus and deliverables

- - **Agent**: Single product owner with GOAP methodology

- - **Process**: Decision analysis → PROCEED/ITERATE/ABORT

-

- ## Core Functions

-

- ### 1. Task Analysis and Context Setup

- Analyze task requirements and prepare execution context:

-

- ```bash

- # Initialize loop orchestration

- cfn-docker-loop-orchestration init \

- --task-id task-authentication \

- --task-description "Implement user authentication system" \

- --mode standard \

- --max-iterations 5

- ```

-

- ### 2. Loop 3 Agent Spawning

- Spawn implementer agents based on task requirements:

-

- ```bash

- # Spawn Loop 3 implementers

- cfn-docker-loop-orchestration spawn-loop3 \

- --task-id task-authentication \

- --agents backend-developer,frontend-engineer,security-specialist \

- --context "${TASK_CONTEXT}"

- ```

-

- ### 3. Loop 3 Completion Monitoring

- Monitor implementer progress and collect confidence scores:

-

- ```bash

- # Monitor Loop 3 completion

- cfn-docker-loop-orchestration monitor-loop3 \

- --task-id task-authentication \

- --wait-for-complete \

- --gate-threshold 0.75

- ```

-

- ### 4. Gate Check and Decision

- Evaluate Loop 3 results and decide next steps:

-

- ```bash

- # Check Loop 3 gate

- cfn-docker-loop-orchestration gate-check \

- --task-id task-authentication \

- --gate-threshold 0.75 \

- --max-iterations 5

- ```

-

- ### 5. Loop 2 Validator Spawning

- Spawn validator agents if gate passed:

-

- ```bash

- # Spawn Loop 2 validators

- cfn-docker-loop-orchestration spawn-loop2 \

- --task-id task-authentication \

- --agents reviewer,tester,security-specialist \

- --loop3-work "${WORK_SUMMARY}"

- ```

-

- ### 6. Consensus Collection

- Collect and analyze validator consensus:

-

- ```bash

- # Collect Loop 2 consensus

- cfn-docker-loop-orchestration collect-consensus \

- --task-id task-authentication \

- --required-consensus 0.90 \

- --timeout 300

- ```

-

- ### 7. Product Owner Decision

- Trigger final decision process:

-

- ```bash

- # Trigger Product Owner decision

- cfn-docker-loop-orchestration trigger-po-decision \

- --task-id task-authentication \

- --consensus-data "${CONSENSUS_RESULTS}"

- ```

-

- ## Loop Management

-

- ### Iteration Control

- ```bash

- # Control loop iterations

- cfn-docker-loop-orchestration control-iterations \

- --task-id task-authentication \

- --current-iteration 2 \

- --max-iterations 5 \

- --gate-threshold 0.75 \

- --consensus-threshold 0.90

- ```

-

- ### Adaptive Agent Selection

- ```bash

- # Select agents based on iteration and feedback

- cfn-docker-loop-orchestration select-adaptive-agents \

- --task-id task-authentication \

- --iteration 2 \

- --previous-feedback "${FEEDBACK_DATA}"

- ```

-

- ### Error Handling and Recovery

- ```bash

- # Handle execution errors

- cfn-docker-loop-orchestration handle-errors \

- --task-id task-authentication \

- --error-type agent-failure \

- --failed-agent-id agent-backend-001 \

- --restart-strategy adaptive

- ```

-

- ## Configuration Modes

-

- ### MVP Mode (Quick Execution)

- ```bash

- cfn-docker-loop-orchestration execute \

- --task-id task-authentication \

- --mode mvp \

- --max-iterations 3 \

- --gate-threshold 0.70 \

- --consensus-threshold 0.80 \

- --validators 2

- ```

-

- ### Standard Mode (Balanced)

- ```bash

- cfn-docker-loop-orchestration execute \

- --task-id task-authentication \

- --mode standard \

- --max-iterations 10 \

- --gate-threshold 0.75 \

- --consensus-threshold 0.90 \

- --validators 3

- ```

-

- ### Enterprise Mode (Thorough)

- ```bash

- cfn-docker-loop-orchestration execute \

- --task-id task-authentication \

- --mode enterprise \

- --max-iterations 15 \

- --gate-threshold 0.85 \

- --consensus-threshold 0.95 \

- --validators 5

- ```

-

- ## Agent Selection Strategy

-

- ### Task-Based Agent Selection

- ```bash

- # Analyze task and select appropriate agents

- cfn-docker-loop-orchestration analyze-and-select \

- --task-description "Implement secure user authentication" \

- --output-agent-types

- ```

-

- ### Skill-Based Selection

- ```bash

- # Select agents based on required skills

- cfn-docker-loop-orchestration select-by-skills \

- --required-skills "security,backend-development,frontend-development" \

- --agent-count 3

- ```

-

- ### Experience-Based Selection

- ```bash

- # Select agents based on previous performance

- cfn-docker-loop-orchestration select-by-experience \

- --task-domain authentication \

- --success-threshold 0.85

- ```

-

- ## Integration with CFN Docker Skills

-

- ### Redis Coordination Integration

- ```bash

- # Store loop state in Redis

- cfn-docker-redis-coordination store-loop-state \

- --task-id task-authentication \

- --loop-number 3 \

- --iteration 1 \

- --state "in-progress"

-

- # Retrieve loop state

- cfn-docker-redis-coordination get-loop-state \

- --task-id task-authentication \

- --loop-number 3

- ```

-

- ### Agent Spawning Integration

- ```bash

- # Spawn agents with MCP configuration

- cfn-docker-agent-spawn batch \

- --agent-types backend-developer,frontend-engineer \

- --task-id task-authentication \

- --mcp-auto-select

- ```

-

- ### Skill Selection Integration

- ```bash

- # Configure MCP access for agents

- for agent_type in backend-developer frontend-engineer; do

- cfn-docker-skill-mcp-selector configure \

- --agent-type $agent_type \

- --task-id task-authentication

- done

- ```

-

- ## Monitoring and Observability

-

- ### Loop Progress Monitoring

- ```bash

- # Monitor overall loop progress

- cfn-docker-loop-orchestration monitor-progress \

- --task-id task-authentication \

- --real-time \

- --include-agents

-

- # Monitor specific loop

- cfn-docker-loop-orchestration monitor-loop \

- --task-id task-authentication \

- --loop-number 3 \

- --detailed

- ```

-

- ### Performance Metrics

- ```bash

- # Collect performance metrics

- cfn-docker-loop-orchestration metrics \

- --task-id task-authentication \

- --include-timing \

- --include-resource-usage \

- --include-confidence-trends

- ```

-

- ### Agent Performance Tracking

- ```bash

- # Track agent performance across loops

- cfn-docker-loop-orchestration agent-performance \

- --task-id task-authentication \

- --agent-id agent-backend-001 \

- --all-iterations

- ```

-

- ## Decision Flow Logic

-

- ### Gate Check Algorithm

- 1. **Collect Confidence Scores**: Gather all Loop 3 confidence scores

- 2. **Calculate Average**: Compute mean confidence score

- 3. **Check Threshold**: Compare against gate threshold

- 4. **Decision Logic**:

- - `confidence >= threshold` → Proceed to Loop 2

- - `confidence < threshold` → Iterate Loop 3 (if iterations remaining)

-

- ### Consensus Validation Algorithm

- 1. **Collect Validator Feedback**: Gather all Loop 2 validator responses

- 2. **Calculate Consensus**: Compute average confidence and agreement level

- 3. **Check Threshold**: Compare against consensus threshold

- 4. **Decision Logic**:

- - `consensus >= threshold` → Trigger Product Owner

- - `consensus < threshold` → Iterate (if iterations remaining)

-

- ### Product Owner Decision Triggers

- 1. **High Consensus (≥0.95)**: AUTO-COMPLETE

- 2. **Good Consensus (≥threshold)**: PROCEED to Product Owner

- 3. **Low Consensus (<threshold)**: ITERATE with specific feedback

-

- ## Error Handling Strategies

-

- ### Agent Failure Handling

- ```bash

- # Handle agent container failure

- cfn-docker-loop-orchestration handle-agent-failure \

- --task-id task-authentication \

- --failed-agent-id agent-backend-001 \

- --strategy respawn \

- --backup-agent-type backend-developer

- ```

-

- ### Timeout Handling

- ```bash

- # Handle loop timeouts

- cfn-docker-loop-orchestration handle-timeout \

- --task-id task-authentication \

- --loop-number 3 \

- --timeout-extension 300

- ```

-

- ### MCP Server Failures

- ```bash

- # Handle MCP server connectivity issues

- cfn-docker-loop-orchestration handle-mcp-failure \

- --task-id task-authentication \

- --failed-mcp playwright \

- --fallback direct-tools

- ```

-

- ## Performance Optimization

-

- ### Parallel Execution

- - **Loop 3**: Spawn all implementers simultaneously

- - **Loop 2**: Sequential validator execution to prevent conflicts

- - **Resource Management**: Balance concurrent execution with resource limits

-

- ### Adaptive Iteration

- - **Smart Iteration**: Only iterate when specific issues identified

- - **Agent Specialization**: Select different specialists based on feedback

- - **Context Preservation**: Maintain context across iterations

-

- ### Resource Optimization

- - **Container Reuse**: Reuse containers where possible

- - **MCP Server Optimization**: Share MCP servers across compatible agents

- - **Memory Management**: Optimize memory usage across loop phases

-

- ## Quality Assurance

-

- ### Deliverable Validation

- ```bash

- # Validate required deliverables created

- cfn-docker-loop-orchestration validate-deliverables \

- --task-id task-authentication \

- --required-files "auth-service.js,login.html" \

- --acceptance-criteria "${CRITERIA}"

- ```

-

- ### Code Quality Checks

- ```bash

- # Run automated quality checks

- cfn-docker-loop-orchestration quality-check \

- --task-id task-authentication \

- --include-linting \

- --include-security-scan \

- --include-tests

- ```

-

- ### Integration Testing

- ```bash

- # Run integration tests for complete solution

- cfn-docker-loop-orchestration integration-test \

- --task-id task-authentication \

- --test-suite authentication-tests

- ```

-

- ## Best Practices

-

- ### Loop Design

- - **Clear Success Criteria**: Define measurable success criteria for each loop

- - **Appropriate Thresholds**: Set realistic confidence and consensus thresholds

- - **Iteration Limits**: Establish maximum iteration limits to prevent infinite loops

-

- ### Agent Selection

- - **Task-Appropriate Skills**: Select agents with relevant domain expertise

- - **Diverse Perspectives**: Include different agent types for comprehensive coverage

- - **Performance History**: Consider past agent performance when selecting

-

- ### Error Recovery

- - **Graceful Degradation**: Implement fallback mechanisms for failures

- - **State Persistence**: Maintain state for recovery from interruptions

- - **Monitoring**: Comprehensive monitoring for early issue detection

-

- ## Configuration

-

- ### Environment Variables

- ```bash

- # Loop configuration

- CFN_DOCKER_MAX_ITERATIONS=10

- CFN_DOCKER_GATE_THRESHOLD=0.75

- CFN_DOCKER_CONSENSUS_THRESHOLD=0.90

- CFN_DOCKER_LOOP_TIMEOUT=600

-

- # Agent configuration

- CFN_DOCKER_MAX_CONCURRENT_AGENTS=5

- CFN_DOCKER_AGENT_TIMEOUT=300

- CFN_DOCKER_CONTAINER_MEMORY_LIMIT=1g

-

- # Decision configuration

- CFN_DOCKER_AUTO_COMPLETE_THRESHOLD=0.95

- CFN_DOCKER_FORCE_ITERATION_THRESHOLD=0.60

- ```

-

- ### Loop Configuration File

- ```json

- {

- "loopConfig": {

- "maxIterations": 10,

- "gateThreshold": 0.75,

- "consensusThreshold": 0.90,

- "loopTimeouts": {

- "loop3": 600,

- "loop2": 300,

- "productOwner": 180

- }

- },

- "agentConfig": {

- "maxConcurrentAgents": 5,

- "defaultMemoryLimit": "1g",

- "defaultCpuLimit": 1.0,

- "restartPolicy": "on-failure"

- },

- "decisionConfig": {

- "autoCompleteThreshold": 0.95,

- "forceIterationThreshold": 0.60,

- "enableAdaptiveSelection": true

- }

- }