claude-flow-novice 2.9.0 → 2.10.0

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

@@ -1,6 +1,6 @@
 ---
 description: "Execute autonomous 3-loop self-correcting CFN workflow with automatic retry and consensus validation"
-argument-hint: "<task description> [--phase=name] [--mode=mvp|standard|enterprise] [--max-loop2=10] [--max-loop3=10]"
+argument-hint: "<task description> [--phase=name] [--mode=mvp|standard|enterprise] [--spawn-mode=cli|task] [--max-loop2=10] [--max-loop3=10]"
 allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Edit", "Bash", "Glob", "Grep"]
 ---
 
@@ -25,16 +25,21 @@ LOOP 3: Primary Swarm Execution with subtask iterations
 ## Command Options
 
 ```bash
+# CLI Mode (default - cost-optimized)
 /cfn-loop "Implement JWT authentication" --phase=implementation --mode=standard
 /cfn-loop "Fix security vulnerabilities" --phase=security-audit --mode=enterprise --max-loop2=10
-/cfn-loop "Build MVP feature" --phase=mvp-dev --mode=mvp --max-loop3=5
-/cfn-loop "Refactor API layer" --mode=standard --max-loop3=15
-/cfn-loop "Add test coverage for auth module" --phase=testing --max-loop2=10
+
+# Task Mode (debugging - full visibility)
+/cfn-loop "Build MVP feature" --spawn-mode=task --mode=mvp
+/cfn-loop "Refactor API layer" --spawn-mode=task --mode=standard --max-loop3=15
 ```
 
 **Options:**
 - `--phase=<name>`: Optional phase name for tracking
 - `--mode=<mvp|standard|enterprise>`: Coordinator mode (default: standard)
+- `--spawn-mode=<cli|task>`: Agent spawning method (default: cli)
+  - **cli**: Cost-optimized (95-98% savings), background execution, Redis monitoring
+  - **task**: Full visibility in Main Chat, direct spawning, debugging
 - `--max-loop2=<n>`: Max consensus iterations (default: 10)
 - `--max-loop3=<n>`: Max primary swarm iterations (default: 10)
 
@@ -77,12 +82,40 @@ The coordinator uses CLI spawning (95-98% cost savings) and provides full visibi
 ### Step 1: Parse Command Arguments
 
 Extract parameters from command:
+- `--spawn-mode=cli|task` (default: cli)
 - `--mode=mvp|standard|enterprise` (default: standard)
 - `--phase=<name>` (optional phase identifier)
 - `--max-loop2=<n>` (max consensus iterations, default: 10)
 - `--max-loop3=<n>` (max implementation iterations, default: 10)
 
-### Step 2: Spawn Coordinator Agent (SINGLE AGENT PATTERN)
+### Step 1.5: Load Task Mode Guide (If Applicable)
+
+**If `--spawn-mode=task` detected:**
+
+```javascript
+// Read Task Mode guide for agent specialization and workflow
+const taskModeGuide = await Read('.claude/commands/cfn/CFN_LOOP_TASK_MODE.md');
+
+// Guide provides:
+// - Agent specialization (Loop 3: implementers, Loop 2: validators, Loop 4: PO)
+// - Adaptive validator scaling (2-6 validators based on complexity)
+// - Sprint completion workflow (consensus → deliverables → git → summary)
+// - Product Owner spawning via Task() (NOT execute-decision.sh)
+// - Backlog mechanism and background worker patterns
+
+console.log('Task Mode: Using guide for agent selection and coordination');
+```
+
+**Key Task Mode Differences:**
+- Coordinator spawns agents via Task() (NOT CLI)
+- Product Owner spawned via Task() directly by coordinator
+- Use helper scripts: `parse-decision.sh`, `validate-deliverables.sh`
+- Do NOT use `execute-decision.sh` (it spawns PO via CLI → duplicate agents)
+- Full agent output visible in Main Chat (debugging)
+
+### Step 2: Execute CFN Loop
+
+**CLI Mode (default) - Spawn Coordinator:**
 
 ```javascript
 Task("cfn-v3-coordinator", `
@@ -190,6 +223,13 @@ Task("cfn-v3-coordinator", `
        --product-owner "product-owner" \
        --max-iterations 10
 
+     # Orchestrator handles complete workflow:
+     # - Spawns Loop 3 agents → gate check → iteration if needed
+     # - Spawns Loop 2 validators → consensus check
+     # - Spawns Product Owner → PROCEED/ITERATE/ABORT decision
+     # - On PROCEED: git add/commit/push + sprint summary
+     # - Returns when complete or max iterations reached
+
   2. MONITOR PROGRESS:
      - Use web portal: http://localhost:3000
      - Query metrics: ./.claude/skills/cfn-web-portal/invoke-portal-metrics.sh
@@ -227,7 +267,103 @@ Task("cfn-v3-coordinator", `
 `, "cfn-v3-coordinator")
 ```
 
-### Step 3: Coordinator Autonomous Execution
+**Task Mode (for debugging) - Main Chat Coordinates Directly:**
+
+Main Chat does NOT spawn a coordinator. Instead, it coordinates directly following the guide:
+
+```javascript
+// Step 1: Read Task Mode Guide
+const guide = await Read('.claude/commands/cfn/CFN_LOOP_TASK_MODE.md');
+
+// Step 2: Analyze Task Complexity (from guide)
+const complexity = analyzeComplexity({
+  task: "$ARGUMENTS",
+  files: estimateFileCount(),
+  loc: estimateLOC()
+});
+
+// Step 3: Select Agents (from guide's adaptive scaling)
+const agents = selectAgents(complexity);
+// Simple: 2 validators (reviewer, tester)
+// Standard: 4 validators (+architect, +security-specialist)
+// Complex: 5+ validators (+code-analyzer, +perf/ada)
+
+// Step 4: Loop 3 - Implementation
+let iteration = 1;
+let loop3Confidence = 0;
+
+do {
+  // Spawn Loop 3 agents in parallel
+  const loop3Results = await Promise.all(
+    agents.loop3.map(agent =>
+      Task(agent, `Implement: $ARGUMENTS (iteration ${iteration})`)
+    )
+  );
+
+  loop3Confidence = average(loop3Results.map(r => r.confidence));
+
+  if (loop3Confidence >= 0.75) break;
+
+  iteration++;
+} while (iteration <= maxIterations);
+
+// Step 5: Loop 2 - Validation
+const loop2Results = await Promise.all(
+  agents.loop2.map(validator =>
+    Task(validator, "Review implementation")
+  )
+);
+
+const consensus = average(loop2Results.map(r => r.confidence));
+
+// Step 6: Product Owner Decision
+const poContext = `
+  Iteration ${iteration} complete.
+  Consensus: ${consensus} (threshold: 0.90)
+
+  Decision Framework:
+  - PROCEED: Consensus >= 0.90 AND deliverables verified
+  - ITERATE: Consensus < 0.90 AND iteration < max
+  - ABORT: Max iterations reached
+
+  Output format: Decision: [PROCEED|ITERATE|ABORT]
+`;
+
+const poOutput = Task("product-owner", poContext);
+
+// Step 7: Parse Decision (using helper script)
+const decision = Bash(`./.claude/skills/cfn-product-owner-decision/parse-decision.sh --output "${poOutput}"`);
+
+// Step 8: Validate Deliverables
+const deliverableStatus = Bash(`./.claude/skills/cfn-product-owner-decision/validate-deliverables.sh --task-id "${taskId}"`);
+
+if (deliverableStatus === "FAILED" && taskRequiresImplementation) {
+  decision = "ITERATE";
+}
+
+// Step 9: Execute Decision
+if (decision === "PROCEED") {
+  Bash("git add . && git commit -m 'feat: $ARGUMENTS' && git push");
+  Write(`docs/SPRINT_${iteration}_COMPLETE.md`, generateSummary());
+  console.log("✅ Sprint complete - changes committed and pushed");
+} else if (decision === "ITERATE") {
+  console.log("🔄 Iterating with feedback...");
+  // Repeat from Step 4
+} else {
+  console.log("❌ Max iterations reached - aborting");
+}
+```
+
+**Why No Coordinator in Task Mode:**
+- Main Chat has full visibility already
+- Guide provides all coordination logic
+- Direct Task() spawning is simpler
+- No abstraction layer needed
+- Easier debugging (no coordinator to trace through)
+
+### Step 3: Autonomous Execution (CLI Mode Only)
+
+**This applies to CLI Mode only.** Task Mode follows the workflow above (Step 2).
 
 The coordinator runs the orchestrator script internally, which:
 
@@ -248,7 +384,32 @@ The coordinator runs the orchestrator script internally, which:
 
 **Loop 1: Product Owner**
 - Reviews final consensus and acceptance criteria
-- Makes autonomous go/no-go decision
+- Makes autonomous go/no-go decision (PROCEED/ITERATE/ABORT)
+- **If PROCEED:**
+  - Validates deliverables exist (git status check)
+  - Creates structured git commit:
+    ```bash
+    git add .
+    git commit -m "$(cat <<'EOF'
+    feat(cfn-loop): [task description]
+
+    Deliverables:
+    - [files created/modified]
+
+    Validation:
+    - Consensus: [0.XX]
+    - Iterations: Loop 3: [N], Loop 2: [M]
+    - Tests: [status]
+
+    🤖 Generated with [Claude Code](https://claude.com/claude-code)
+    Co-Authored-By: Claude <noreply@anthropic.com>
+    EOF
+    )"
+    git push origin main
+    ```
+  - Generates sprint summary: `docs/SPRINT_${ITERATION}_COMPLETE.md`
+- **If ITERATE:** Wake agents for iteration N+1
+- **If ABORT:** Exit with error report
 - Returns structured result to Main Chat
 
 ### Step 4: Visibility via Web Portal

package/{CFN-CLAUDE.md → .claude/root-claude-distribute/CFN-CLAUDE.md}

@@ -1,6 +1,6 @@
 # Claude Flow Novice — AI Agent Orchestration
 
-**🚀 Production Status:** Skills-First Migration Completed (Phase 8 - 2025-10-18)
+**🚀 Production Status:** v2.9.1 - Namespace Isolation Complete (2025-10-25)
 
 ---
 
@@ -49,8 +49,28 @@
 - Redis Coordination (`.claude/skills/cfn-redis-coordination/SKILL.md`)
 - Agent Spawning (`.claude/skills/cfn-agent-spawning/SKILL.md`)
 - CFN Loop Validation (`.claude/skills/cfn-loop-validation/SKILL.md`)
-- **Product Owner Decision** (`.claude/skills/cfn-product-owner-decision/SKILL.md`) - Strategic CFN loop decision execution
-- **Agent Output Processing** (`.claude/skills/cfn-agent-output-processing/SKILL.md`) - Universal structured output extraction
+- Product Owner Decision (`.claude/skills/cfn-product-owner-decision/SKILL.md`)
+- Agent Output Processing (`.claude/skills/cfn-agent-output-processing/SKILL.md`)
+
+### Namespace Isolation (v2.9.1)
+
+**Structure:**
+- Agents: `.claude/agents/cfn-dev-team/` (23 production agents)
+- Skills: `.claude/skills/cfn-*/` (43 skills, cfn- prefix)
+- Hooks: `.claude/hooks/cfn-*` (7 hooks, cfn- prefix)
+- Commands: `.claude/commands/cfn/` (45+ commands, subdirectory)
+
+**Installation:**
+```bash
+npm install claude-flow-novice
+npx cfn-init  # Copy namespace-isolated files
+```
+
+**Collision Risk:** ~0.01% (user custom files preserved)
+
+**Package:** 573 KB tarball, 2.4 MB unpacked, 303 files (68% reduction from v2.0.0)
+
+**Agent Discovery:** Recursive search through `.claude/agents/**/*.md` finds both cfn-dev-team and user custom agents
 
 **Coordination Principles:**
 * ALL agent communication via explicit Redis pub/sub dependencies

package/.claude/skills/cfn-ace-system/SKILL.md

@@ -0,0 +1,364 @@
+# ACE System Skill
+
+## Version
+**Version:** 1.0.0
+**Status:** OPERATIONAL
+
+## Overview
+The ACE (Adaptive Context Extension) System skill provides agents with access to advanced context management capabilities including reflection, curation, generation, and injection. This skill wraps the core ACE implementation from `src/ace/` and exposes it through simple shell command interfaces.
+
+## Features
+- Context Reflection (Cognitive complexity analysis)
+- Context Curation (Merge and prioritize contexts)
+- Context Generation (Adaptive context creation)
+- Context Injection (Dynamic context augmentation)
+- Context Statistics (Query and analyze stored contexts)
+
+## Core Components
+
+### 1. ACE Reflector
+Performs cognitive reflection on context data, calculating complexity and generating insights.
+
+**Methods:**
+- `reflect()` - Analyze context and generate reflection
+- `retrieveReflection()` - Query stored reflections
+
+### 2. ACE Curator
+Manages context merging and prioritization for multi-agent scenarios.
+
+**Methods:**
+- `mergeContexts()` - Merge multiple contexts with conflict resolution
+- `prioritizeReflections()` - Rank reflections by relevance
+
+### 3. ACE Generator
+Generates adaptive context based on task requirements and historical data.
+
+**Methods:**
+- `generateContext()` - Create new context from specifications
+
+### 4. Context Injector
+Dynamically injects context into execution environments.
+
+**Methods:**
+- `injectContext()` - Augment execution with additional context
+- `executeWithContext()` - Run operations with injected context
+
+## Agent Integration Examples
+
+### 1. Context Reflection
+
+#### Reflect on Current Context
+```bash
+# Agent analyzes current task context
+./.claude/skills/ace-system/invoke-context-reflect.sh \
+  --context '{"task": "feature-implementation", "complexity": "high"}' \
+  --output /tmp/reflection.json
+```
+
+**Returns:** Cognitive reflection with insights and complexity metrics
+
+### 2. Context Statistics
+
+#### Query Context Database
+```bash
+# Retrieve reflection statistics
+./.claude/skills/ace-system/invoke-context-stats.sh \
+  --query "reflections" \
+  --filter '{"complexity": {"$gt": 0.7}}' \
+  --limit 10
+```
+
+**Returns:** JSON array of matching reflections
+
+### 3. Context Query
+
+#### Search Similar Contexts
+```bash
+# Find similar past contexts
+./.claude/skills/ace-system/invoke-context-query.sh \
+  --keywords "authentication,security" \
+  --similarity-threshold 0.8 \
+  --max-results 5
+```
+
+**Returns:** Ranked list of similar contexts
+
+### 4. Context Injection
+
+#### Inject Context into Execution
+```bash
+# Augment current execution with historical context
+./.claude/skills/ace-system/invoke-context-inject.sh \
+  --context-file /tmp/reflection.json \
+  --target-task "implement-auth" \
+  --merge-strategy "deep"
+```
+
+**Returns:** Execution context augmented with injected data
+
+### 5. Context Curation
+
+#### Merge Multiple Contexts
+```bash
+# Curator merges contexts from multiple agents
+./.claude/skills/ace-system/invoke-context-curate.sh \
+  --contexts "agent1-context.json,agent2-context.json,agent3-context.json" \
+  --strategy "priority-weighted" \
+  --output curated-context.json
+```
+
+**Returns:** Single merged context with conflict resolution
+
+## Integration with CFN Loop
+
+### Loop 3 Integration (Primary Swarm)
+Agents in Loop 3 use ACE for context generation and reflection:
+
+```bash
+# Agent completes implementation and reflects
+./.claude/skills/ace-system/invoke-context-reflect.sh \
+  --context '{"phase": "implementation", "changes": [...]}' \
+  --output /tmp/loop3-reflection.json
+
+# Report confidence based on reflection complexity
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+```
+
+### Loop 2 Integration (Consensus Validation)
+Validators use ACE curator to merge perspectives:
+
+```bash
+# Collect reflections from Loop 3 agents
+./.claude/skills/ace-system/invoke-context-curate.sh \
+  --contexts "loop3-agent1.json,loop3-agent2.json,loop3-agent3.json" \
+  --strategy "consensus-weighted" \
+  --output /tmp/loop2-merged.json
+
+# Validate merged context
+./.claude/skills/ace-system/invoke-context-stats.sh \
+  --query "validation" \
+  --input /tmp/loop2-merged.json
+```
+
+### Product Owner Integration
+Product Owner uses ACE for final context injection:
+
+```bash
+# Inject business context into technical implementation
+./.claude/skills/ace-system/invoke-context-inject.sh \
+  --context-file /tmp/loop2-merged.json \
+  --business-rules /config/product-requirements.json \
+  --output /tmp/final-context.json
+```
+
+## Configuration
+
+### Memory Path
+ACE uses SQLite for persistence. Default path: `./.artifacts/database/swarm-memory.db`
+
+Override with environment variable:
+```bash
+export ACE_MEMORY_PATH="/custom/path/swarm-memory.db"
+```
+
+### Complexity Thresholds
+
+| Threshold | Value | Description |
+|-----------|-------|-------------|
+| Low | < 0.3 | Simple, straightforward contexts |
+| Medium | 0.3-0.7 | Moderate complexity |
+| High | > 0.7 | High complexity requiring deep reflection |
+
+### Merge Strategies
+
+| Strategy | Use Case |
+|----------|----------|
+| `simple` | Basic context merge, last-write-wins |
+| `deep` | Recursive merge with nested conflict resolution |
+| `priority-weighted` | Merge based on agent priority levels |
+| `consensus-weighted` | Weight by consensus confidence scores |
+
+## Command Reference
+
+### invoke-context-reflect.sh
+**Purpose:** Generate cognitive reflection on context
+
+**Arguments:**
+- `--context` - JSON context object
+- `--complexity` - Override complexity calculation (optional)
+- `--output` - Output file path (optional)
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-reflect.sh \
+  --context '{"task": "deploy"}' \
+  --output reflection.json
+```
+
+### invoke-context-stats.sh
+**Purpose:** Query reflection database
+
+**Arguments:**
+- `--query` - Query type (reflections, insights, summary)
+- `--filter` - MongoDB-style filter JSON (optional)
+- `--limit` - Maximum results (default: 100)
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-stats.sh \
+  --query reflections \
+  --filter '{"timestamp": {"$gt": 1697000000}}' \
+  --limit 20
+```
+
+### invoke-context-query.sh
+**Purpose:** Search for similar contexts
+
+**Arguments:**
+- `--keywords` - Comma-separated keywords
+- `--similarity-threshold` - Minimum similarity (0.0-1.0, default: 0.7)
+- `--max-results` - Maximum results (default: 10)
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-query.sh \
+  --keywords "authentication,JWT,OAuth" \
+  --similarity-threshold 0.8 \
+  --max-results 5
+```
+
+### invoke-context-inject.sh
+**Purpose:** Inject context into execution environment
+
+**Arguments:**
+- `--context-file` - Source context JSON file
+- `--target-task` - Task ID to inject into
+- `--merge-strategy` - Merge strategy (simple, deep, priority-weighted, consensus-weighted)
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-inject.sh \
+  --context-file historical-context.json \
+  --target-task "sprint-3-auth" \
+  --merge-strategy deep
+```
+
+### invoke-context-curate.sh
+**Purpose:** Merge and curate multiple contexts
+
+**Arguments:**
+- `--contexts` - Comma-separated list of context files
+- `--strategy` - Curation strategy
+- `--output` - Output file path
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-curate.sh \
+  --contexts "ctx1.json,ctx2.json,ctx3.json" \
+  --strategy consensus-weighted \
+  --output merged.json
+```
+
+## Use Cases
+
+### 1. Multi-Agent Consensus Building
+Use ACE curator to merge insights from multiple agents and reach consensus on complex decisions.
+
+### 2. Historical Context Reuse
+Query similar past contexts to inform current task execution and avoid repeating mistakes.
+
+### 3. Complexity-Driven Validation
+Use reflection complexity scores to determine appropriate validation depth and gate thresholds.
+
+### 4. Adaptive Resource Allocation
+Generate context dynamically based on task requirements to optimize resource usage.
+
+### 5. Cross-Sprint Learning
+Inject curated context from previous sprints into new iterations for continuous improvement.
+
+## Dependencies
+- Node.js runtime (for TypeScript ACE modules)
+- SQLite3 (for persistent context storage)
+- Redis (for cross-agent context sharing)
+- jq (for JSON processing in shell scripts)
+
+## Error Handling
+
+All ACE skill wrappers follow a consistent error handling pattern:
+
+```bash
+if ! result=$(invoke-command.sh --args); then
+  echo "ERROR: ACE operation failed"
+  exit 1
+fi
+
+# Validate JSON output
+if ! echo "$result" | jq . > /dev/null 2>&1; then
+  echo "ERROR: Invalid JSON response"
+  exit 1
+fi
+```
+
+## Performance Considerations
+
+### Reflection Complexity
+High-complexity reflections (> 0.8) may require additional processing time. Consider:
+- Batching reflection operations
+- Using async reflection for non-blocking execution
+- Caching frequently accessed reflections
+
+### Context Curation
+Merging large numbers of contexts (> 10) can be resource-intensive:
+- Use progressive merging for large agent swarms
+- Apply early filtering to reduce context set size
+- Leverage Redis for intermediate result caching
+
+### Database Queries
+Optimize context queries by:
+- Creating appropriate SQLite indexes
+- Limiting query result sets
+- Using filters to reduce full table scans
+
+## Testing
+
+Test suite location: `.claude/skills/ace-system/test-ace-skill.sh`
+
+**Run tests:**
+```bash
+./.claude/skills/ace-system/test-ace-skill.sh
+```
+
+**Expected output:**
+```
+[PASS] Context reflection generates valid output
+[PASS] Context stats returns filtered results
+[PASS] Context query finds similar contexts
+[PASS] Context injection merges successfully
+[PASS] Context curation handles conflicts
+```
+
+## Version History
+
+### v1.0.0 (2025-10-19)
+- Initial release
+- Wrapper for all 5 ACE slash commands
+- Integration with CFN Loop coordination
+- Complete test coverage
+
+## Maintenance
+
+**Last Updated:** 2025-10-19
+**Next Review:** 2025-11-19
+**Owner:** System Architecture Team
+
+## Related Skills
+- Redis Coordination (`redis-coordination`)
+- SQLite Memory (`sqlite-memory`)
+- CFN Loop Validation (`cfn-loop-validation`)
+
+## Support
+
+For issues or questions about the ACE System skill:
+1. Check test suite for usage examples
+2. Review ACE implementation docs in `src/ace/`
+3. Consult Redis Coordination skill for integration patterns