claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-agent-lifecycle/lib/output/README.md

@@ -1,359 +0,0 @@
-# Agent Output Processing Skill (Universal)
-
-**Version:** 1.0.0
-**Status:** Production
-**Purpose:** Guaranteed structured output extraction from any agent type
-
----
-
-## Overview
-
-**Problem Solved:** Agent templates cannot force tool execution or guarantee output format.
-
-**Solution:** Orchestrator-controlled output processing with robust parsing, validation, and Redis coordination.
-
-**Applicable To:** Any agent requiring structured output (Product Owner, validators, analyzers, decision-makers)
-
----
-
-## Core Principle
-
-```
-Agent Templates → Focus on analysis/decision-making
-Skills → Handle execution/coordination/formatting
-Orchestrators → Control workflow and Redis state
-```
-
-**Why This Works:**
-- ✅ Agents do what they're good at (analysis)
-- ✅ Skills enforce structure (parsing, validation)
-- ✅ Orchestrators maintain coordination (Redis, timing)
-- ✅ No reliance on agent tool usage compliance
-
----
-
-## Architecture
-
-### Generic Flow
-
-```
-1. Orchestrator → Spawn agent with structured context
-2. Skill → Capture agent stdout/stderr
-3. Skill → Parse output (pattern matching with fallbacks)
-4. Skill → Validate output (business logic checks)
-5. Skill → Transform to required format (JSON, etc.)
-6. Skill → Push to Redis (coordination state)
-7. Skill → Signal completion
-```
-
-### Skill Components
-
-```
-.claude/skills/agent-output-processing/
-├── SKILL.md                          # This file
-├── execute-with-parsing.sh           # Generic agent wrapper
-├── parse-structured-output.sh        # Multi-pattern parser
-├── validate-output.sh                # Validation framework
-└── patterns/                         # Agent-specific patterns
-    ├── product-owner.json            # PROCEED/ITERATE/ABORT
-    ├── validator.json                # confidence + feedback
-    ├── analyzer.json                 # metrics + recommendations
-    └── decision-maker.json           # choice + reasoning
-```
-
----
-
-## Usage Patterns
-
-### Pattern 1: Decision Output (Product Owner)
-
-**Output Requirements:** Must extract PROCEED/ITERATE/ABORT
-
-```bash
-RESULT=$(./.claude/skills/agent-output-processing/execute-with-parsing.sh \
-  --agent-type "product-owner" \
-  --pattern-file "patterns/product-owner.json" \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "Loop 2 consensus: 0.92" \
-  --redis-key "swarm:${TASK_ID}:${AGENT_ID}:decision")
-
-DECISION=$(echo "$RESULT" | jq -r '.decision')
-```
-
-**Pattern File (patterns/product-owner.json):**
-```json
-{
-  "name": "product-owner-decision",
-  "required_fields": ["decision"],
-  "patterns": [
-    {
-      "field": "decision",
-      "regex": "Decision:\\s*(PROCEED|ITERATE|ABORT)",
-      "extract": "keyword",
-      "fallbacks": [
-        "(PROCEED|ITERATE|ABORT)",
-        "(?i)(proceed|iterate|abort)"
-      ]
-    },
-    {
-      "field": "reasoning",
-      "regex": "Reasoning:\\s*(.+)",
-      "extract": "capture_group"
-    }
-  ],
-  "validation": {
-    "decision": {
-      "type": "enum",
-      "values": ["PROCEED", "ITERATE", "ABORT"]
-    }
-  }
-}
-```
-
-### Pattern 2: Confidence + Feedback (Validators)
-
-**Output Requirements:** Must extract confidence score and feedback list
-
-```bash
-RESULT=$(./.claude/skills/agent-output-processing/execute-with-parsing.sh \
-  --agent-type "reviewer" \
-  --pattern-file "patterns/validator.json" \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "Review Loop 3 implementation" \
-  --redis-key "swarm:${TASK_ID}:${AGENT_ID}:result")
-
-CONFIDENCE=$(echo "$RESULT" | jq -r '.confidence')
-FEEDBACK=$(echo "$RESULT" | jq -r '.feedback[]')
-```
-
-**Pattern File (patterns/validator.json):**
-```json
-{
-  "name": "validator-result",
-  "required_fields": ["confidence"],
-  "patterns": [
-    {
-      "field": "confidence",
-      "regex": "Confidence:\\s*([0-9.]+)",
-      "extract": "float",
-      "fallbacks": [
-        "confidence[:\\s]+([0-9.]+)",
-        "score[:\\s]+([0-9.]+)"
-      ]
-    },
-    {
-      "field": "feedback",
-      "regex": "Feedback:\\s*\\n([\\s\\S]+?)(?=\\n\\n|$)",
-      "extract": "multiline_list"
-    }
-  ],
-  "validation": {
-    "confidence": {
-      "type": "float",
-      "min": 0.0,
-      "max": 1.0
-    }
-  }
-}
-```
-
-### Pattern 3: Metrics + Recommendations (Analyzers)
-
-**Output Requirements:** Must extract metrics object and recommendation list
-
-```bash
-RESULT=$(./.claude/skills/agent-output-processing/execute-with-parsing.sh \
-  --agent-type "code-analyzer" \
-  --pattern-file "patterns/analyzer.json" \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "Analyze codebase quality" \
-  --redis-key "swarm:${TASK_ID}:${AGENT_ID}:analysis")
-
-COMPLEXITY=$(echo "$RESULT" | jq -r '.metrics.complexity')
-RECOMMENDATIONS=$(echo "$RESULT" | jq -r '.recommendations[]')
-```
-
----
-
-## Implementation
-
-### execute-with-parsing.sh
-
-```bash
-#!/bin/bash
-set -euo pipefail
-
-# Parse arguments
-AGENT_TYPE=""
-PATTERN_FILE=""
-TASK_ID=""
-AGENT_ID=""
-CONTEXT=""
-REDIS_KEY=""
-TIMEOUT=900
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --agent-type) AGENT_TYPE="$2"; shift 2 ;;
-    --pattern-file) PATTERN_FILE="$2"; shift 2 ;;
-    --task-id) TASK_ID="$2"; shift 2 ;;
-    --agent-id) AGENT_ID="$2"; shift 2 ;;
-    --context) CONTEXT="$2"; shift 2 ;;
-    --redis-key) REDIS_KEY="$2"; shift 2 ;;
-    --timeout) TIMEOUT="$2"; shift 2 ;;
-    *) echo "Unknown: $1"; exit 1 ;;
-  esac
-done
-
-# Spawn agent and capture output
-AGENT_OUTPUT=$(timeout "$TIMEOUT" npx claude-flow-novice agent "$AGENT_TYPE" \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "$CONTEXT" 2>&1 || true)
-
-# Parse structured output using pattern file
-PARSED_OUTPUT=$(./parse-structured-output.sh \
-  --pattern-file "$PATTERN_FILE" \
-  --output "$AGENT_OUTPUT")
-
-# Validate parsed output
-if ! ./validate-output.sh --pattern-file "$PATTERN_FILE" --data "$PARSED_OUTPUT"; then
-  echo "ERROR: Output validation failed" >&2
-  exit 1
-fi
-
-# Push to Redis if key provided
-if [ -n "$REDIS_KEY" ]; then
-  echo "$PARSED_OUTPUT" | redis-cli -x LPUSH "$REDIS_KEY" >/dev/null
-  redis-cli LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete" >/dev/null
-fi
-
-# Output structured result
-echo "$PARSED_OUTPUT"
-```
-
----
-
-## Benefits Over Template-Based
-
-| Aspect | Template-Based | Skill-Based (Universal) |
-|--------|----------------|-------------------------|
-| **Execution Guarantee** | ❌ Agent decides | ✅ Skill enforces |
-| **Output Format** | ❌ Inconsistent | ✅ Guaranteed structure |
-| **Parsing Robustness** | ❌ None | ✅ Multi-pattern fallbacks |
-| **Validation** | ❌ Manual | ✅ Automated schema checks |
-| **Redis Coordination** | ❌ Agent-dependent | ✅ Skill-controlled |
-| **Reusability** | ❌ Per-agent templates | ✅ Universal pattern system |
-| **Testability** | ❌ Hard to test | ✅ Unit tests per pattern |
-| **Extensibility** | ❌ Template changes | ✅ Add pattern files |
-
----
-
-## Agent-Specific Implementations
-
-### Existing: Product Owner Decision
-**Location:** `.claude/skills/product-owner-decision/`
-**Pattern:** PROCEED/ITERATE/ABORT extraction
-**Status:** ✅ Operational (BUG #11 fix)
-
-### Future: Validator Agents
-**Pattern:** Confidence + feedback extraction
-**Use Case:** Loop 2 validators (reviewer, tester, security)
-**Benefit:** Guaranteed confidence scoring
-
-### Future: Analyzer Agents
-**Pattern:** Metrics + recommendations extraction
-**Use Case:** Code quality, performance, security analyzers
-**Benefit:** Structured analysis output
-
----
-
-## Migration Strategy
-
-### Phase 1: Product Owner (✅ Complete)
-- Created dedicated skill
-- Integrated with orchestrator
-- Solves BUG #11
-
-### Phase 2: Validators (Planned)
-- Extract confidence scores reliably
-- Parse feedback into structured lists
-- Prevent 0.0 confidence issues
-
-### Phase 3: All Decision-Making Agents (Future)
-- Standardize output processing
-- Centralize pattern definitions
-- Enable cross-agent consistency
-
----
-
-## Testing
-
-### Unit Tests
-```bash
-# Test pattern parsing
-./test-parse-structured-output.sh --pattern-file patterns/product-owner.json
-
-# Test validation logic
-./test-validate-output.sh --pattern-file patterns/validator.json
-```
-
-### Integration Tests
-```bash
-# Test full agent execution with parsing
-./test-execute-with-parsing.sh --agent-type product-owner
-```
-
----
-
-## Related Skills
-
-- **Product Owner Decision** (`.claude/skills/product-owner-decision/SKILL.md`) - Specific implementation
-- **Redis Coordination** (`.claude/skills/redis-coordination/SKILL.md`) - State management
-- **CFN Loop Validation** (`.claude/skills/cfn-loop-validation/SKILL.md`) - Quality gates
-
----
-
-## Lessons Learned
-
-### ANTI-PATTERN: Template-Forced Tool Usage
-**What Doesn't Work:** Telling agents "Use Bash tool to execute X"
-
-**Why:** Agents interpret instructions autonomously, treating code blocks as documentation
-
-**Better:** Capture agent output and parse it with robust patterns
-
-### PATTERN: Orchestrator Control
-**Principle:** Coordination belongs in orchestrators/skills, not agent templates
-
-**Rationale:**
-- Agents focus on analysis (what they do well)
-- Skills handle structure (parsing, validation)
-- Orchestrators manage coordination (Redis, timing)
-
-### PATTERN: Multi-Fallback Parsing
-**Principle:** Use multiple pattern matching strategies with increasing leniency
-
-**Example:**
-1. Strict: "Decision: PROCEED" (labeled, exact case)
-2. Moderate: "PROCEED" (standalone keyword)
-3. Lenient: "proceed" (case-insensitive)
-4. Desperate: JSON extraction
-
----
-
-## Version History
-
-### 1.0.0 (2025-10-20)
-- Initial skill creation
-- Generalized from Product Owner fix
-- Universal pattern-based output processing
-- Validation framework
-- Redis coordination integration
-
----
-
-**Summary:** This skill provides universal output processing for any agent type, eliminating reliance on template-based tool usage compliance and guaranteeing structured, validated results.

package/claude-assets/skills/cfn-agent-lifecycle/lib/selection/SKILL.md

@@ -1,29 +0,0 @@
----
-name: cfn-agent-selector
-description: Agent selection based on task classification with fallback support
-version: 1.0.0
-tags: [agent-selection, task-classification, fallback]
-status: production
----
-
-# Agent Selector Submodule
-
-**Parent Skill:** cfn-agent-lifecycle
-**Purpose:** Select appropriate agents based on task classification with fallback support
-
-## Components
-
-- `select-agents.sh` - Basic agent selection
-- `select-agents-with-fallback.sh` - Selection with fallback strategy
-- `task-classifier.sh` - Task classification for agent mapping
-- `agent-mappings.json` - Task-to-agent mapping configuration
-
-## Usage
-
-```bash
-# Basic selection
-./.claude/skills/cfn-agent-lifecycle/lib/selection/select-agents.sh --task "implement feature"
-
-# With fallback
-./.claude/skills/cfn-agent-lifecycle/lib/selection/select-agents-with-fallback.sh --task "implement feature"
-```

package/claude-assets/skills/cfn-agent-lifecycle/lib/selection/agent-mappings.json

@@ -1,142 +0,0 @@
-{
-  "categories": {
-    "backend-api": {
-      "loop3": [
-        "backend-developer",
-        "api-gateway-specialist"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "api-testing-specialist"
-      ],
-      "confidence": 0.92
-    },
-    "fullstack": {
-      "loop3": [
-        "backend-developer",
-        "react-frontend-engineer",
-        "typescript-specialist"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "integration-tester",
-        "playwright-tester"
-      ],
-      "confidence": 0.90
-    },
-    "mobile": {
-      "loop3": [
-        "mobile-dev",
-        "backend-developer"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "interaction-tester"
-      ],
-      "confidence": 0.88
-    },
-    "infrastructure": {
-      "loop3": [
-        "devops-engineer",
-        "docker-specialist",
-        "kubernetes-specialist"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "chaos-engineering-specialist"
-      ],
-      "confidence": 0.93
-    },
-    "security": {
-      "loop3": [
-        "security-specialist",
-        "backend-developer"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "security-specialist"
-      ],
-      "confidence": 0.95
-    },
-    "frontend": {
-      "loop3": [
-        "react-frontend-engineer",
-        "typescript-specialist",
-        "ui-designer"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "playwright-tester"
-      ],
-      "confidence": 0.89
-    },
-    "database": {
-      "loop3": [
-        "database-architect",
-        "backend-developer"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "data-engineer"
-      ],
-      "confidence": 0.91
-    },
-    "performance": {
-      "loop3": [
-        "backend-developer",
-        "perf-analyzer"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "performance-benchmarker"
-      ],
-      "confidence": 0.87
-    },
-    "default": {
-      "loop3": [
-        "backend-developer",
-        "devops-engineer"
-      ],
-      "loop2": [
-        "code-reviewer",
-        "tester",
-        "code-quality-validator"
-      ],
-      "confidence": 0.70
-    }
-  },
-  "product_owner": "product-owner",
-  "agent_aliases": {
-    "backend-developer": "developers/backend-developer.md",
-    "api-gateway-specialist": "developers/api-gateway-specialist.md",
-    "react-frontend-engineer": "developers/frontend/react-frontend-engineer.md",
-    "typescript-specialist": "developers/frontend/typescript-specialist.md",
-    "mobile-dev": "developers/frontend/mobile-dev.md",
-    "devops-engineer": "dev-ops/devops-engineer.md",
-    "docker-specialist": "dev-ops/docker-specialist.md",
-    "kubernetes-specialist": "dev-ops/kubernetes-specialist.md",
-    "security-specialist": "reviewers/quality/security-specialist.md",
-    "ui-designer": "developers/frontend/ui-designer.md",
-    "database-architect": "developers/database/database-architect.md",
-    "perf-analyzer": "reviewers/quality/perf-analyzer.md",
-    "code-reviewer": "reviewers/code-reviewer.md",
-    "tester": "testers/tester.md",
-    "api-testing-specialist": "testers/api-testing-specialist.md",
-    "integration-tester": "testers/integration-tester.md",
-    "playwright-tester": "testers/playwright-tester.md",
-    "interaction-tester": "testers/interaction-tester.md",
-    "chaos-engineering-specialist": "testers/chaos-engineering-specialist.md",
-    "data-engineer": "developers/data/data-engineer.md",
-    "performance-benchmarker": "reviewers/quality/performance-benchmarker.md",
-    "code-quality-validator": "reviewers/quality/code-quality-validator.md",
-    "product-owner": "product-owners/product-owner.md"
-  }
-}