claude-flow-novice 2.5.2 → 2.8.1

package/.claude/prompts/loop-specific/loop2.md

@@ -0,0 +1,50 @@
+# Loop 2: Validator Agent Context
+
+You are a Loop 2 validator. Your job is to REVIEW deliverables, not implement.
+
+**Requirements:**
+- Read actual files created by Loop 3
+- Check against acceptance criteria
+- Report consensus score (0.0-1.0)
+- Provide structured feedback if consensus < 0.90
+
+**DO NOT:**
+- Implement or modify code
+- Create new files
+- Fix issues (that's Loop 3's job in next iteration)
+
+**Feedback Structure:**
+```json
+{
+  "CRITICAL": ["Must-fix issues that block shipping"],
+  "WARNING": ["Should-fix issues that affect quality"],
+  "SUGGESTION": ["Nice-to-have improvements"]
+}
+```
+
+**Consensus Scoring:**
+- 0.95+: Excellent, ready to ship
+- 0.90-0.94: Good, minor issues acceptable
+- 0.80-0.89: Needs improvement, iterate
+- <0.80: Significant issues, must iterate
+
+**Example Workflow:**
+```bash
+# 1. Read deliverables
+cat /path/to/deliverable.sh
+
+# 2. Check acceptance criteria
+# - Does it exist? YES
+# - Does it work? TEST IT
+# - Does it meet requirements? VERIFY
+
+# 3. Report consensus
+./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence 0.92 \
+  --iteration 1
+```
+
+**Your Role:**
+Quality gatekeeper, not implementer. Validate, don't create.

package/.claude/prompts/loop-specific/loop3.md

@@ -0,0 +1,43 @@
+# Loop 3: Implementation Agent Context
+
+You are a Loop 3 implementer. Your job is to CREATE actual deliverables.
+
+**Requirements:**
+- Use Write/Edit/Bash tools to create files
+- Create deliverables at paths specified in context
+- Report confidence based on actual file creation
+- DO NOT just describe what you would do - DO IT
+
+**Confidence Scoring:**
+- 0.95: All deliverables created, tested, working
+- 0.85: All deliverables created, minor issues
+- 0.70: Partial deliverables, needs iteration
+- <0.70: Failed to create required deliverables
+
+**After Completion:**
+Signal done and report confidence. Orchestrator handles next steps.
+
+**Example Workflow:**
+```bash
+# 1. Create deliverable
+echo "content" > /path/to/deliverable.sh
+chmod +x /path/to/deliverable.sh
+
+# 2. Verify creation
+ls -la /path/to/deliverable.sh
+
+# 3. Signal completion
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+
+# 4. Report confidence
+./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence 0.95 \
+  --iteration 1
+```
+
+**Remember:**
+- Actual files > Plans
+- Working code > Descriptions
+- Confidence matches reality

package/.claude/prompts/loop-specific/loop4.md

@@ -0,0 +1,54 @@
+# Loop 4: Product Owner Agent Context
+
+You are the Product Owner. Make strategic business decisions.
+
+**Requirements:**
+- Review Loop 2 consensus score
+- Check deliverables against business value
+- Enforce scope boundaries (reject out-of-scope work)
+- Make decision: PROCEED, ITERATE, or ABORT
+
+**Decision Criteria:**
+- PROCEED: Consensus >= threshold, business value delivered, scope maintained
+- ITERATE: Consensus < threshold OR scope violations OR quality issues
+- ABORT: Task no longer valuable OR technical impossibility
+
+**Decision Format:**
+```
+DECISION: [PROCEED|ITERATE|ABORT]
+
+RATIONALE:
+- Consensus: [score]
+- Business Value: [delivered/not delivered]
+- Scope: [maintained/violated]
+- Strategic Fit: [aligned/misaligned]
+
+FEEDBACK (if ITERATE):
+- [Specific improvement needed]
+- [Another specific improvement]
+```
+
+**Example Workflow:**
+```bash
+# 1. Review consensus
+CONSENSUS=$(redis-cli GET "swarm:${TASK_ID}:consensus:iteration_1")
+
+# 2. Check deliverables
+git status  # Were files actually created?
+ls -la /path/to/deliverables/
+
+# 3. Make strategic decision
+# - If consensus >= 0.90 AND deliverables exist AND scope maintained: PROCEED
+# - If quality issues OR scope violations: ITERATE
+# - If fundamentally flawed OR no longer needed: ABORT
+
+# 4. Report decision
+echo "DECISION: PROCEED"
+echo "CONFIDENCE: 0.95"
+```
+
+**Your Authority:**
+- Loop 2 validates quality, you validate strategy
+- Your decision is final
+- Balance business value vs. perfection
+- Enforce scope ruthlessly

package/.claude/root-claude-distribute/CLAUDE.md

@@ -6,6 +6,35 @@
 
 ## 1) Critical Rules (Single Source of Truth)
 
+### Core Operational Rules
+* **Use agents for all non-trivial work** (≥4 steps or any multi-file / research / testing / architecture / security / integration / refactor / feature)
+* **Initialize swarm before any multi-agent work**
+* **Batch operations**: one message per related batch (spawn, file edits, bash, todos, memory ops)
+* **Run post-edit hook after every file edit** inclusive of .md files and await the response
+* **Never work solo** on multi-step tasks. Spawn parallel specialists
+* **Never mix implementers and validators in the same message**
+* **Never run tests inside agents.** Execute once; agents read results
+* **Never save to project root.** Use proper subdirs
+* **No guides/summaries/reports** unless explicitly asked
+* **Use spartan language and give answers in plain english**
+* **Concise summaries only** - no code examples unless requested
+* **Redis persistence enables swarm recovery** - swarm state survives interruptions
+* **ALL agent communication MUST use Redis pub/sub** - no direct file coordination
+
+**Consensus thresholds:**
+* Gate (agent self-confidence): **≥0.75 each**
+* Validators consensus: **≥0.90**
+
+### CTO Delegation Persona
+* **Act as a busy CTO** who delegates all non-trivial work to specialized agents
+* **Define clear success criteria** for implementation (working code, passing tests, documented features)
+* **Never define adoption criteria** (user engagement, rollout strategy, training plans)
+* **Ruthlessly delegate** - if task requires >3 steps, spawn agents immediately
+* **Provide context, not solutions** - agents figure out implementation details
+* **Success = implementation complete** - not "users love it" or "team adopts it"
+
+---
+
 ### Skills-Based Coordination
 **Core Skills:**
 - Redis Coordination (`.claude/skills/redis-coordination/SKILL.md`)
@@ -120,7 +149,11 @@ Task("cost-savings-cfn-loop-coordinator", `
 **Config:** `.claude/hooks/post-edit.config.json`
 **Skill:** `.claude/skills/hook-pipeline/SKILL.md`
 
-## 2) Skill-Driven Agent Execution
+## 2) When Agents Are Mandatory (Triggers)
+
+If **any** apply, spawn agents:
+
+* > 3 distinct steps • multiple files • research+implement+test • design decisions • code review/quality • security/performance/compliance • system integration • docs generation • refactor/optimize • any feature work
 
 ### Skill Selection Criteria
 **Mandatory Skill Spawning Triggers:**
@@ -140,6 +173,19 @@ npx claude-flow-novice swarm "Task Description" \
   --strategy development
 ```
 
+### Single Agent vs Coordinator
+
+**Use Single Agent:**
+* 1 specialized task (coding, reviewing, testing)
+* No dependencies on other agents
+* Straightforward execution
+
+**Use Coordinator:**
+* Multiple agents needed (2+)
+* Sequential dependencies (Loop 3 → Loop 2 → Product Owner)
+* Iteration/consensus required
+* CFN Loop workflows
+
 ## 3) Coordination Patterns
 
 **Redis Coordination Patterns**
@@ -425,4 +471,32 @@ Implement comprehensive test suites that validate both functional requirements a
 - Maintenance Schedule: `planning/skills/MAINTENANCE_SCHEDULE.md`
 
 **Migration Analytics:**
-See `.artifacts/analytics/context-reduction-report.json`
+See `.artifacts/analytics/context-reduction-report.json`
+## Adaptive Context Extensions: CLI Agent Spawning Insights (v2.5.2)
+
+### Strategy Patterns
+
+#### PATTERN-001: Environment Configuration
+- **Context**: CLI Entrypoints
+- **Insight**: Always explicitly load environment configurations using 'import dotenv/config' to ensure provider-specific settings are correctly read and applied across different execution contexts.
+- **Tags**: environment, configuration, cli, dotenv
+- **Confidence**: 0.95
+- **Priority**: 9/10
+
+### Domain Insights
+
+#### PATTERN-002: Multi-Provider API Integration
+- **Context**: API Provider Configuration
+- **Insight**: Create explicit provider-specific mappings that account for endpoint differences, model naming conventions, and protocol variations to ensure robust cross-provider compatibility.
+- **Tags**: api-integration, provider-mapping, resilience, configuration
+- **Confidence**: 0.92
+- **Priority**: 8/10
+
+### Edge Case Handling
+
+#### PATTERN-004: Resilient API Call Mechanisms
+- **Context**: Error Handling and Timeout Management
+- **Insight**: Configure explicit timeouts and retry mechanisms for API calls to prevent indefinite hanging and provide built-in resilience, with provider-specific timeout and retry configurations.
+- **Tags**: error-handling, timeout, resilience, api-calls
+- **Confidence**: 0.90
+- **Priority**: 9/10

package/.claude/skills/ace-system/sprint-7-lessons.json

@@ -0,0 +1,46 @@
+{
+    "lessons": [
+        {
+            "bullet_id": "STRAT-007",
+            "category": "strategy",
+            "content": "When implementing long-running orchestration workflows (>10 minutes), use background execution with Redis-based status monitoring instead of synchronous Bash calls. Bash tool has hard 10-minute timeout limit that cannot be extended.",
+            "confidence": 0.95,
+            "tags": ["orchestration", "bash-timeout", "redis-monitoring", "background-execution"]
+        },
+        {
+            "bullet_id": "PATTERN-008",
+            "category": "pattern",
+            "content": "Implement a strategic Product Owner decision flow that provides explicit PROCEED/ITERATE/ABORT options after Loop 2 consensus to prevent validator scope creep and maintain clear workflow boundaries.",
+            "confidence": 0.90,
+            "tags": ["workflow-management", "consensus", "product-owner", "decision-flow"]
+        },
+        {
+            "bullet_id": "EDGE-005",
+            "category": "edge_case",
+            "content": "Enforce strict agent ID consistency across orchestrator and CLI spawning by using iteration-suffixed tracking arrays and dynamic agent selection based on task keywords to prevent orchestrator hanging.",
+            "confidence": 0.88,
+            "tags": ["agent-management", "id-tracking", "spawning", "consistency"]
+        },
+        {
+            "bullet_id": "OPT-006",
+            "category": "optimization",
+            "content": "Implement token limit strategies with headroom, targeting 10K tokens with a hard limit of 16K, and use incremental output patterns to handle complex, multi-stage agent workflows.",
+            "confidence": 0.85,
+            "tags": ["token-management", "llm-optimization", "incremental-processing"]
+        },
+        {
+            "bullet_id": "ANTI-004",
+            "category": "anti_pattern",
+            "content": "Avoid using simplistic regex matching for agent validation, such as `[[ \" $AGENTS \" =~ \" $AGENTS \" ]]`, which creates false-positive matches and breaks agent tracking logic.",
+            "confidence": 0.92,
+            "tags": ["regex", "validation", "agent-tracking", "error-prevention"]
+        },
+        {
+            "bullet_id": "DOMAIN-003",
+            "category": "domain_insight",
+            "content": "Design orchestration systems with explicit, unbound state management for tracking agent completion, ensuring that components like LOOP2_COMPLETED_AGENTS can handle dynamic workflow iterations without premature termination.",
+            "confidence": 0.87,
+            "tags": ["orchestration", "state-management", "workflow-design", "agent-coordination"]
+        }
+    ]
+}

package/.claude/skills/ace-system/store-reflection.sh

@@ -1,149 +1,46 @@
 #!/bin/bash
-# Store reflection in context_reflections table
-# Usage: ./store-reflection.sh --reflection-type success --task-id sprint-123 --lessons-file lessons.json
-
-set -e
-
-# Default values
-DB_PATH="${ACE_DB_PATH:-./.artifacts/database/swarm-memory.db}"
-REFLECTION_TYPE=""
-TASK_ID=""
-AGENT_ID=""
-EXECUTION_TRACE=""
-FEEDBACK_SIGNALS=""
-LESSONS_FILE=""
-ACL_LEVEL=3
-SWARM_ID="default-swarm"
-PROJECT_ID="default-project"
 
 # Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --reflection-type)
-      REFLECTION_TYPE="$2"
-      shift 2
-      ;;
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --agent-id)
-      AGENT_ID="$2"
-      shift 2
-      ;;
-    --execution-trace-file)
-      if [ -f "$2" ]; then
-        EXECUTION_TRACE=$(cat "$2")
-      fi
-      shift 2
-      ;;
-    --feedback-signals-file)
-      if [ -f "$2" ]; then
-        FEEDBACK_SIGNALS=$(cat "$2")
-      fi
-      shift 2
-      ;;
-    --lessons-file)
-      LESSONS_FILE="$2"
-      shift 2
-      ;;
-    --acl-level)
-      ACL_LEVEL="$2"
-      shift 2
-      ;;
-    --swarm-id)
-      SWARM_ID="$2"
-      shift 2
-      ;;
-    --project-id)
-      PROJECT_ID="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
+while [ $# -gt 0 ]; do
+    key="$1"
+    case $key in
+        --sprint)
+            SPRINT="$2"
+            shift 2
+            ;;
+        --file)
+            LESSONS_FILE="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown parameter: $1"
+            exit 1
+            ;;
+    esac
 done
 
-# Validate required parameters
-if [ -z "$REFLECTION_TYPE" ] || [ -z "$TASK_ID" ] || [ -z "$LESSONS_FILE" ]; then
-  echo "Error: Missing required parameters"
-  echo "Usage: $0 --reflection-type <type> --task-id <id> --lessons-file <path>"
-  exit 1
-fi
-
-# Validate reflection type
-case $REFLECTION_TYPE in
-  success|failure|optimization|edge_case|pattern)
-    ;;
-  *)
-    echo "Error: Invalid reflection_type. Must be: success, failure, optimization, edge_case, or pattern"
+# Validate required arguments
+if [ -z "$SPRINT" ] || [ -z "$LESSONS_FILE" ]; then
+    echo "Usage: $0 --sprint <sprint_number> --file <lessons_file_path>"
     exit 1
-    ;;
-esac
-
-# Read lessons file
-if [ ! -f "$LESSONS_FILE" ]; then
-  echo "Error: Lessons file not found: $LESSONS_FILE"
-  exit 1
 fi
 
-EXTRACTED_LESSONS=$(cat "$LESSONS_FILE")
-
-# Generate unique reflection ID
-REFLECTION_ID="refl-$(date +%s)-$(openssl rand -hex 3)"
+# Ensure artifacts directory exists
+mkdir -p .claude/artifacts/ace-reflections
 
-# Create database if not exists
-mkdir -p "$(dirname "$DB_PATH")"
+# Store reflection with timestamp
+TIMESTAMP=$(date -u +"%Y%m%d_%H%M%S")
+OUTPUT_FILE=".claude/artifacts/ace-reflections/sprint-${SPRINT}_${TIMESTAMP}.json"
 
-# Insert reflection into database
-sqlite3 "$DB_PATH" <<EOF
--- Ensure table exists (idempotent)
-CREATE TABLE IF NOT EXISTS context_reflections (
-    id TEXT PRIMARY KEY,
-    reflection_type TEXT NOT NULL CHECK (reflection_type IN ('success', 'failure', 'optimization', 'edge_case', 'pattern')),
-    task_id TEXT NOT NULL,
-    agent_id TEXT,
-    execution_trace TEXT NOT NULL,
-    feedback_signals TEXT NOT NULL,
-    extracted_lessons TEXT NOT NULL,
-    curator_status TEXT DEFAULT 'pending' CHECK (curator_status IN ('pending', 'processing', 'merged', 'rejected', 'human_review')),
-    merged_bullet_ids TEXT,
-    rejection_reason TEXT,
-    acl_level INTEGER NOT NULL DEFAULT 3 CHECK (acl_level BETWEEN 1 AND 6),
-    swarm_id TEXT NOT NULL,
-    project_id TEXT,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    processed_at DATETIME
-);
+# Copy lessons file to artifacts
+cp "$LESSONS_FILE" "$OUTPUT_FILE"
 
--- Insert reflection
-INSERT INTO context_reflections (
-  id, reflection_type, task_id, agent_id, execution_trace, feedback_signals,
-  extracted_lessons, curator_status, acl_level, swarm_id, project_id
-) VALUES (
-  '${REFLECTION_ID}',
-  '${REFLECTION_TYPE}',
-  '${TASK_ID}',
-  $([ -n "$AGENT_ID" ] && echo "'$AGENT_ID'" || echo "NULL"),
-  '${EXECUTION_TRACE:-{}}',
-  '${FEEDBACK_SIGNALS:-{}}',
-  '${EXTRACTED_LESSONS}',
-  'pending',
-  ${ACL_LEVEL},
-  '${SWARM_ID}',
-  $([ -n "$PROJECT_ID" ] && echo "'$PROJECT_ID'" || echo "NULL")
-);
-EOF
+# Update latest reflection pointer
+echo "$OUTPUT_FILE" > .claude/artifacts/ace-reflections/LATEST
 
-# Verify insertion
-COUNT=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM context_reflections WHERE id = '${REFLECTION_ID}';")
+echo "Reflection for Sprint $SPRINT stored successfully at $OUTPUT_FILE"
 
-if [ "$COUNT" -eq 1 ]; then
-  echo "{\"status\":\"success\",\"reflection_id\":\"${REFLECTION_ID}\",\"database\":\"${DB_PATH}\",\"lessons_count\":$(echo "$EXTRACTED_LESSONS" | jq 'length')}"
-  exit 0
-else
-  echo "{\"status\":\"error\",\"message\":\"Reflection insertion failed\"}"
-  exit 1
-fi
+# Optional: Use Redis to broadcast reflection event
+if command -v redis-cli &> /dev/null; then
+    redis-cli lpush "ace:reflections" "$OUTPUT_FILE"
+fi

package/.claude/skills/agent-discovery/SKILL.md

@@ -0,0 +1,40 @@
+# Agent Discovery Skill
+
+## Purpose
+Automatically discover and catalog available agents in the Claude Flow Novice system by scanning the `.claude/agents/` directory and extracting metadata from agent definition files.
+
+## Key Features
+- Scan `.claude/agents/*.md` files
+- Extract metadata: name, description, type, keywords/tags
+- Generate structured JSON registry
+- Categorize agents by loop (Loop 3 or Loop 2)
+
+## Agent Categorization
+- **Loop 3 (Implementers)**:
+  - Types: coder, developer, backend-dev, react-frontend-engineer, architect, researcher, designer, writer, analyst
+- **Loop 2 (Validators)**:
+  - Types: reviewer, tester, security-auditor, performance-analyzer, validator
+- **Coordinators**: Separate category, not included in agent selection
+
+## Usage
+```bash
+./.claude/skills/agent-discovery/discover-agents.sh
+```
+
+## Output
+Generates `.claude/skills/agent-discovery/agents-registry.json` with comprehensive agent metadata.
+
+## Error Handling
+- Robust parsing of agent files
+- Handles missing or malformed frontmatter
+- Generates sensible defaults for missing metadata
+
+## Performance
+- Optimized for quick scanning of agent files
+- Minimal computational overhead
+- Periodic refresh recommended
+
+## Best Practices
+- Keep agent definition files well-structured
+- Include comprehensive frontmatter
+- Use consistent metadata across agent definitions

package/.claude/skills/agent-discovery/agents-registry-fixed.json

@@ -0,0 +1,19 @@
+{
+  "agents": [
+    {
+      "name": "coder",
+      "description": "MUST BE USED when implementing features, writing code, fixing bugs.\nUse PROACTIVELY for API development, component creation, refactoring.\nKeywords - implement, code, build, develop, create, refactor, optimize, fix\n",
+      "type": "specialist",
+      "keywords": [
+        "code-implementation",
+        "feature-development",
+        "test-driven-development",
+        "refactoring",
+        "api-design",
+        "quality-engineering"
+      ]
+    }
+  ],
+  "last_updated": "2025-10-24T18:00:47Z",
+  "total_agents": 1
+}