claude-flow-novice 2.10.4 → 2.10.6

package/claude-assets/commands/cfn/hello-world-tests.md

@@ -0,0 +1,381 @@
+---
+description: "Run comprehensive hello-world test suite validating agent tooling, mesh coordination, review handoff, and SQLite storage"
+argument-hint: "[--layer=0|1|2|3|all] [--skip-validation]"
+allowed-tools: ["Bash", "Read", "TodoWrite", "Write"]
+---
+
+# Hello World Tests - CFN Coordination Validation
+
+Run comprehensive 4-layer test suite validating core CFN coordination capabilities.
+
+**Test Scope**: $ARGUMENTS
+
+## Test Layers
+
+### Layer 0: Agent Tool Validation
+- ✅ **15 agent types** (coder, architect, tester, analyst, reviewer, backend-dev, code-analyzer, code-quality-validator, security-specialist, devops-engineer, api-docs, mobile-dev, base-template-generator, perf-analyzer, pseudocode)
+- ✅ **7 tools per agent** (Read, Write, Edit, Bash, Grep, Glob, TodoWrite)
+- ✅ **Success criteria**: All agents spawn, ≥5/7 tools working, 6 critical tools at 100%
+
+### Layer 1: Mesh Coordination
+- ✅ **2 peer coordinators** managing 35 combos each
+- ✅ **70 Hello World files** (7 languages × 10 translations)
+- ✅ **Redis pub/sub coordination** with claim negotiation
+- ✅ **SQLite persistence** for agent state and coordination history
+- ✅ **Success criteria**: 72 agents, 70 unique files, 0 conflicts, balanced distribution
+
+### Layer 2: Review Coordination
+- ✅ **Dynamic reviewer pool** (3-10 reviewers)
+- ✅ **Queue-driven spawning/despawning**
+- ✅ **Review handoff from implementers to reviewers**
+- ✅ **Success criteria**: All 70 files reviewed, queue depth ≤15, dynamic scaling observed
+
+### Layer 3: Error Handling
+- ✅ **50% error injection** with 4 error types
+- ✅ **Fresh agent spawning for retries**
+- ✅ **Exponential backoff** (100ms, 200ms, 400ms)
+- ✅ **Success criteria**: 50% initial failures, ≤10 retries per file, 100% final pass rate
+
+## Command Options
+
+```bash
+# Run all layers sequentially (default)
+/hello-world-tests
+
+# Run specific layer
+/hello-world-tests --layer=0    # Agent tooling only
+/hello-world-tests --layer=1    # Mesh coordination only
+/hello-world-tests --layer=2    # Review coordination only
+/hello-world-tests --layer=3    # Error handling only
+
+# Run multiple layers
+/hello-world-tests --layer=0,1  # Tooling + mesh
+
+# Skip validation (run tests without checking results)
+/hello-world-tests --skip-validation
+```
+
+## Execution Strategy
+
+You MUST execute the tests using the following autonomous workflow:
+
+### 1. Initialize Test Environment
+
+```bash
+# Verify Redis is running
+redis-cli ping  # Must return "PONG"
+
+# Create output directories
+mkdir -p test-results/layer0-tool-validation
+mkdir -p test-results/hello-world
+
+# Initialize SQLite database for coordination
+node tests/hello-world/lib/init-sqlite.js
+```
+
+### 2. Execute Test Layers Sequentially
+
+Parse the `--layer` argument to determine which layers to run:
+
+**Layer 0: Agent Tool Validation**
+```bash
+node tests/hello-world/layer0-tool-validation.js 2>&1 | tee test-results/layer0-output.log
+```
+- **Validates**: Agent tooling works (15 agents × 7 tools)
+- **Reports to**: `test-results/layer0-tool-validation/layer0-results.json`
+- **Must pass before**: Layer 1 mesh coordination
+
+**Layer 1: Mesh Coordination**
+```bash
+node tests/hello-world/layer1-mesh-coordination.js 2>&1 | tee test-results/layer1-output.log
+```
+- **Validates**: Peer-to-peer claim negotiation, SQLite state persistence
+- **Reports to**: `test-results/hello-world/layer1-results.json`
+- **Must pass before**: Layer 2 review coordination
+
+**Layer 2: Review Coordination** (if implemented)
+```bash
+node tests/hello-world/layer2-review-coordination.js 2>&1 | tee test-results/layer2-output.log
+```
+- **Validates**: Dynamic reviewer pool, review handoff
+- **Reports to**: `test-results/hello-world/layer2-results.json`
+- **Must pass before**: Layer 3 error handling
+
+**Layer 3: Error Handling** (if implemented)
+```bash
+node tests/hello-world/layer3-error-retry.js 2>&1 | tee test-results/layer3-output.log
+```
+- **Validates**: Error injection, retry coordination, SQLite retry history
+- **Reports to**: `test-results/hello-world/layer3-results.json`
+
+### 3. Validate Results (unless --skip-validation)
+
+After each layer completes, validate success criteria:
+
+```javascript
+const layerResults = JSON.parse(fs.readFileSync('test-results/layer0-tool-validation/layer0-results.json'));
+
+// Layer 0 validation
+if (!layerResults.summary.layerPassed) {
+  console.error('❌ Layer 0 FAILED:', layerResults.summary);
+  process.exit(1);
+}
+
+// Layer 1 validation
+if (!layer1Results.successCriteria.allMet) {
+  console.error('❌ Layer 1 FAILED:', layer1Results.successCriteria);
+  process.exit(1);
+}
+
+// Continue for Layer 2, 3...
+```
+
+### 4. Generate Combined Report
+
+After all layers complete:
+
+```javascript
+{
+  "testSuite": "Hello World CFN Coordination Tests",
+  "timestamp": "2025-10-13T18:45:00Z",
+  "layers": [
+    {
+      "layer": 0,
+      "name": "Agent Tool Validation",
+      "status": "PASSED",
+      "duration": "10.3 minutes",
+      "agents": 15,
+      "toolsValidated": 7,
+      "reportPath": "test-results/layer0-tool-validation/layer0-results.json"
+    },
+    {
+      "layer": 1,
+      "name": "Mesh Coordination",
+      "status": "PASSED",
+      "duration": "15.2 minutes",
+      "agents": 72,
+      "filesCreated": 70,
+      "conflicts": 0,
+      "sqliteWrites": 145,
+      "reportPath": "test-results/hello-world/layer1-results.json"
+    },
+    {
+      "layer": 2,
+      "name": "Review Coordination",
+      "status": "PASSED",
+      "duration": "12.1 minutes",
+      "reviewers": 7,
+      "reviewsCompleted": 70,
+      "reportPath": "test-results/hello-world/layer2-results.json"
+    },
+    {
+      "layer": 3,
+      "name": "Error Handling",
+      "status": "PASSED",
+      "duration": "18.4 minutes",
+      "initialFailures": 35,
+      "retries": 52,
+      "finalPassRate": "100%",
+      "reportPath": "test-results/hello-world/layer3-results.json"
+    }
+  ],
+  "summary": {
+    "totalDuration": "56.0 minutes",
+    "totalAgents": 170,
+    "totalLayers": 4,
+    "layersPassed": 4,
+    "layersFailed": 0,
+    "overallStatus": "✅ ALL TESTS PASSED"
+  },
+  "sqliteValidation": {
+    "databasePath": "./swarm-memory.db",
+    "totalWrites": 312,
+    "totalReads": 847,
+    "aclViolations": 0,
+    "encryptionVerified": true,
+    "performanceMs": {
+      "avgWrite": 45,
+      "avgRead": 12
+    }
+  }
+}
+```
+
+Save to: `test-results/hello-world/combined-report.json`
+
+### 5. SQLite Validation Requirements
+
+**Critical**: Each layer MUST validate SQLite storage is working:
+
+**Layer 0**: No SQLite validation (tooling-only)
+
+**Layer 1**: Validate SQLite coordinator state persistence
+```javascript
+// Store coordinator claims
+await memory.memoryAdapter.set(
+  `coordination:coordinator:${coordinatorId}:claimed`,
+  claimedCombos,
+  { agentId: coordinatorId, aclLevel: 2 } // Team level
+);
+
+// Verify storage worked
+const stored = await memory.memoryAdapter.get(
+  `coordination:coordinator:${coordinatorId}:claimed`,
+  { agentId: coordinatorId }
+);
+
+console.log(`✅ SQLite validation: ${stored.length} claims persisted`);
+```
+
+**Layer 2**: Validate SQLite review queue persistence
+```javascript
+// Store review assignments
+await memory.memoryAdapter.set(
+  `review:assignments:${reviewerId}`,
+  assignedFiles,
+  { agentId: reviewerId, aclLevel: 2 }
+);
+
+// Verify ACL enforcement
+try {
+  await memory.memoryAdapter.get(
+    `review:assignments:${reviewerId}`,
+    { agentId: 'wrong-agent' } // Should fail
+  );
+  throw new Error('ACL violation: unauthorized access succeeded');
+} catch (e) {
+  console.log('✅ SQLite ACL working: unauthorized access blocked');
+}
+```
+
+**Layer 3**: Validate SQLite retry history
+```javascript
+// Store retry attempts with encryption
+await memory.memoryAdapter.set(
+  `retry:history:${combo}`,
+  { attempts: retries, errors: errorLog },
+  { agentId: coordinatorId, aclLevel: 1, encrypted: true } // Private, encrypted
+);
+
+// Verify encryption
+const encrypted = await memory.memoryAdapter.getRaw(`retry:history:${combo}`);
+if (!encrypted.includes('encrypted:')) {
+  throw new Error('SQLite encryption failed');
+}
+
+console.log('✅ SQLite encryption verified');
+```
+
+## Final Report
+
+Print comprehensive summary:
+
+```
+══════════════════════════════════════════════════════════════════════
+HELLO WORLD CFN COORDINATION TEST SUITE - COMPLETE
+══════════════════════════════════════════════════════════════════════
+
+📊 Overall Results:
+  Total Duration: 56.0 minutes
+  Total Agents: 170
+  Layers Passed: 4/4
+  Overall Status: ✅ ALL TESTS PASSED
+
+🔧 Layer 0: Agent Tool Validation
+  Status: ✅ PASSED
+  Agents: 15
+  Tools Validated: 7
+  Success Rate: 100%
+
+🤝 Layer 1: Mesh Coordination
+  Status: ✅ PASSED
+  Coordinators: 2
+  Files Created: 70
+  Conflicts: 0
+  SQLite Writes: 145
+
+👥 Layer 2: Review Coordination
+  Status: ✅ PASSED
+  Reviewers: 7
+  Reviews Completed: 70
+  Queue Depth Max: 12
+
+🔄 Layer 3: Error Handling
+  Status: ✅ PASSED
+  Initial Failures: 35 (50%)
+  Retries: 52
+  Final Pass Rate: 100%
+
+💾 SQLite Validation:
+  Total Writes: 312
+  Total Reads: 847
+  ACL Violations: 0
+  Encryption: ✅ Verified
+  Avg Write: 45ms
+  Avg Read: 12ms
+
+📄 Detailed Reports:
+  - test-results/layer0-tool-validation/layer0-results.json
+  - test-results/hello-world/layer1-results.json
+  - test-results/hello-world/layer2-results.json
+  - test-results/hello-world/layer3-results.json
+  - test-results/hello-world/combined-report.json
+
+══════════════════════════════════════════════════════════════════════
+✅ CFN COORDINATION VALIDATION COMPLETE
+══════════════════════════════════════════════════════════════════════
+```
+
+## Error Handling
+
+If any layer fails:
+
+1. **Stop execution** (don't proceed to next layer)
+2. **Print failure details** from JSON report
+3. **Save partial combined report** with failed layer marked
+4. **Exit with code 1**
+
+Example failure output:
+```
+❌ Layer 1 FAILED: Mesh Coordination
+
+Failure Reason: Conflict resolution failed
+  Expected: 0 conflicts
+  Actual: 3 conflicts
+  Details: Coordinators coord-a and coord-b claimed same combo 3 times
+
+📄 Full Report: test-results/hello-world/layer1-results.json
+
+⚠️  Cannot proceed to Layer 2 until Layer 1 passes.
+```
+
+## TodoWrite Tracking
+
+Use TodoWrite to track test progress:
+
+```javascript
+[
+  { "content": "Initialize test environment (Redis, SQLite, dirs)", "status": "in_progress" },
+  { "content": "Run Layer 0: Agent Tool Validation", "status": "pending" },
+  { "content": "Validate Layer 0 results", "status": "pending" },
+  { "content": "Run Layer 1: Mesh Coordination", "status": "pending" },
+  { "content": "Validate Layer 1 results + SQLite", "status": "pending" },
+  { "content": "Run Layer 2: Review Coordination", "status": "pending" },
+  { "content": "Validate Layer 2 results + SQLite ACL", "status": "pending" },
+  { "content": "Run Layer 3: Error Handling", "status": "pending" },
+  { "content": "Validate Layer 3 results + SQLite encryption", "status": "pending" },
+  { "content": "Generate combined report", "status": "pending" },
+  { "content": "Print final summary", "status": "pending" }
+]
+```
+
+Update status as each layer completes.
+
+## References
+
+- **Test Suite**: `tests/hello-world/README.md`
+- **Architecture**: `tests/hello-world/ARCHITECTURE.md`
+- **Layer 0 Test**: `tests/hello-world/layer0-tool-validation.js`
+- **Layer 1 Test**: `tests/hello-world/layer1-mesh-coordination.js`
+- **SQLite Memory**: `src/sqlite/MemoryStoreAdapter.cjs`
+- **CFN Loop Guide**: `docs/cfn-loop/CFN_LOOP_COMPLETE_GUIDE.md`

package/claude-assets/commands/cfn/hooks.md

@@ -0,0 +1,38 @@
+---
+description: "Automation hooks management"
+argument-hint: "<action> [parameters]"
+allowed-tools: ["Bash", "mcp__claude-flow-novice__memory_usage"]
+---
+
+# Automation Hooks Management
+
+Manage automation hooks for pre/post operations and session coordination.
+
+**Action**: $ARGUMENTS
+
+**Available Hook Actions**:
+- `enable` - Enable all automation hooks
+- `disable` - Disable automation hooks
+- `pre-task "<description>"` - Execute pre-task hook
+- `post-task "<task-id>"` - Execute post-task hook
+- `session-start` - Start coordination session
+- `session-end` - End session with summary
+- `notify "<message>"` - Send notification to swarm
+
+**Hook Types**:
+
+## Pre-Operation Hooks
+- **Pre-Command**: Validate commands for safety
+- **Pre-Edit**: Auto-assign agents by file type
+- **Pre-Task**: Prepare resources and context
+
+## Post-Operation Hooks
+- **Post-Command**: Track metrics and results
+- **Post-Edit**: Auto-format code and update memory
+- **Post-Task**: Store completion data
+
+## Session Hooks
+- **Session Start**: Initialize coordination context
+- **Session End**: Generate summaries and persist state
+
+Execute the specified hook action and coordinate with the claude-flow-novice system for automation.

package/claude-assets/commands/cfn/launch-web-dashboard.md

@@ -0,0 +1,295 @@
+# Launch Web Dashboard - Start Web Portal Development Server
+
+Launch the claude-flow-novice web portal with hot-reload development servers for both client and server.
+
+## Command
+
+```bash
+/launch-web-dashboard [--port <port>] [--production]
+```
+
+## Execution Pattern
+
+### Default Development Mode
+
+```bash
+# Navigate to web portal package
+cd packages/web-portal
+
+# Kill any existing processes on ports 3001-3003 (client) and 3000-3002 (server)
+lsof -ti:3001,3002,3003,3000 | xargs -r kill -9
+
+# Start development servers with hot-reload
+npm run dev
+```
+
+This will:
+1. **Client (Vite)**: Start on port 3001 (or next available: 3002, 3003)
+2. **Server (tsx watch)**: Start on port 3000 (or next available: 3001, 3002)
+
+### Production Mode
+
+```bash
+# Build for production
+npm run build
+
+# Start production server
+npm run start
+```
+
+## Port Configuration
+
+### Default Ports
+- **Client (Vite)**: 3001
+- **Server (Express)**: 3000
+- **WebSocket**: Same as server port
+
+### Port Conflict Resolution
+If ports are in use, automatically tries next available port:
+- Client: 3001 → 3002 → 3003
+- Server: 3000 → 3001 → 3002
+
+## Output
+
+```
+🚀 Launching Web Portal...
+
+📦 Package: @claude-flow-novice/web-portal
+📂 Directory: packages/web-portal
+
+🔧 Cleaning up existing processes...
+✅ Ports cleared: 3001, 3002, 3000
+
+🎬 Starting development servers...
+
+[Client] VITE v7.1.9  ready in 951 ms
+[Client] ➜  Local:   http://localhost:3001/
+[Client] ➜  Network: use --host to expose
+
+[Server] 🚀 Server running on http://localhost:3000
+[Server] 📊 Metrics: http://localhost:3000/api/metrics
+[Server] 🔌 WebSocket: ws://localhost:3000
+
+✅ Web Dashboard Launched Successfully!
+
+📱 Access Points:
+   • Main UI: http://localhost:3001
+   • API Server: http://localhost:3000
+   • API Docs: http://localhost:3000/api-docs
+   • Health Check: http://localhost:3000/health
+
+🛠️  Available Features:
+   ✓ Agent Management & Monitoring
+   ✓ CFN Loop Execution & Visualization
+   ✓ Real-time Metrics Dashboard
+   ✓ WebSocket Live Updates
+   ✓ Hybrid Routing Control Panel
+   ✓ SQLite Memory Browser
+   ✓ Redis Coordination Monitor
+
+💡 Tips:
+   • Hot-reload enabled for instant updates
+   • Check console for detailed logs
+   • Press Ctrl+C to stop servers
+```
+
+## Flags
+
+### --port <port>
+Specify custom client port (server will use port-1)
+
+```bash
+/launch-web-dashboard --port 4000
+# Client: http://localhost:4000
+# Server: http://localhost:3999
+```
+
+### --production
+Build and run in production mode
+
+```bash
+/launch-web-dashboard --production
+# Optimized build with minification
+# No hot-reload, better performance
+```
+
+### --debug
+Enable verbose logging
+
+```bash
+/launch-web-dashboard --debug
+# Shows detailed startup logs
+# Includes dependency resolution
+# Displays all environment variables
+```
+
+### --kill-only
+Just kill existing processes without starting new ones
+
+```bash
+/launch-web-dashboard --kill-only
+# Cleanup only, useful for port conflicts
+```
+
+## Features Available in Dashboard
+
+### 1. Agent Management
+- View all active agents and their status
+- Monitor agent workload and performance
+- Inspect agent capabilities and roles
+- Track agent communication via Redis pub/sub
+
+### 2. CFN Loop Visualization
+- Real-time phase execution tracking
+- Loop 2/3/4 progress monitoring
+- Confidence score aggregation
+- Consensus validation status
+- Product Owner decisions
+
+### 3. Metrics Dashboard
+- Cost tracking (per provider)
+- Token usage analytics
+- API latency monitoring
+- Success/failure rates
+- Performance bottlenecks
+
+### 4. Hybrid Routing Control
+- Provider selection (Claude Max / z.ai)
+- Worker spawn monitoring
+- Coordinator intelligence tracking
+- Cost savings visualization
+
+### 5. Memory & State
+- SQLite memory browser with ACL levels
+- Redis key inspection
+- Audit trail viewer
+- Permission management
+
+### 6. Event Stream
+- Live WebSocket event feed
+- Filter by event type
+- Search historical events
+- Export event logs
+
+## Troubleshooting
+
+### Port Already in Use
+
+```bash
+# Automatic resolution
+/launch-web-dashboard
+# Will try ports 3001 → 3002 → 3003 automatically
+
+# Manual cleanup
+/launch-web-dashboard --kill-only
+# Then try again
+/launch-web-dashboard
+```
+
+### Build Errors
+
+```bash
+# Clean build cache
+cd packages/web-portal
+rm -rf node_modules .vite dist
+npm install
+npm run build
+
+# Then launch
+/launch-web-dashboard
+```
+
+### WebSocket Connection Issues
+
+Check that both client and server are running:
+```bash
+# Client should show: http://localhost:3001
+# Server should show: http://localhost:3000
+
+# WebSocket connects to server port
+# Ensure VITE_API_URL matches server URL
+```
+
+### Missing Dependencies
+
+```bash
+# Install all dependencies
+npm install
+
+# Web portal specific
+cd packages/web-portal
+npm install
+
+# Rebuild TypeScript
+npm run build
+```
+
+## Integration with Other Commands
+
+### With CFN Loop
+```bash
+# Launch dashboard first
+/launch-web-dashboard
+
+# In another terminal, run CFN Loop
+/cfn-loop "Task description" --mode=standard
+
+# Dashboard will show real-time progress
+```
+
+### With Hybrid Routing
+```bash
+# Start dashboard
+/launch-web-dashboard
+
+# Spawn workers (dashboard monitors them)
+npx claude-flow-spawn "Task" --max-agents 5
+```
+
+### With Swarm Coordination
+```bash
+# Launch dashboard
+/launch-web-dashboard
+
+# Initialize swarm
+node tests/manual/test-swarm-direct.js "Objective" --executor
+
+# Dashboard shows agent coordination
+```
+
+## Environment Variables
+
+The dashboard uses these environment variables (auto-configured):
+
+```bash
+# Client (.env in packages/web-portal)
+VITE_API_URL=http://localhost:3000
+VITE_WS_URL=ws://localhost:3000
+
+# Server
+PORT=3000
+NODE_ENV=development
+REDIS_URL=redis://localhost:6379
+SQLITE_DB_PATH=../../data/swarm-memory.db
+```
+
+## Security Note
+
+Development mode runs with:
+- CORS enabled for localhost
+- Authentication disabled
+- Verbose error messages
+
+For production deployment, use `--production` flag which enables:
+- CORS restrictions
+- Authentication requirements
+- Error sanitization
+- Rate limiting
+
+## Related Commands
+
+- `/cfn-loop` - Execute CFN Loop (visible in dashboard)
+- `/swarm` - Manage swarms (dashboard monitors)
+- `/github-commit` - Commit changes (shows in activity feed)
+- `/sqlite-memory` - Memory management (browsable in dashboard)
+- `/context-stats` - Context metrics (displayed in dashboard)