claude-flow-novice 1.6.1 → 1.6.2

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

@@ -0,0 +1,384 @@
+---
+description: "Execute single phase with multiple sprints using CFN Loop autonomous coordination"
+argument-hint: "<phase description>"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+---
+
+# CFN Loop Sprints - Single Phase, Multiple Sprints
+
+Execute a single phase broken into multiple sprints using CFN Loop autonomous coordination.
+
+🚨 **AUTONOMOUS SPRINT-BASED SELF-LOOPING PROCESS**
+
+**Phase Goal**: $ARGUMENTS
+
+## CFN Loop Structure (4 Loops)
+
+```
+LOOP 0: Epic/Sprint Orchestration (THIS COMMAND - sprint level)
+   ├─ Sprint 1 → Sprint 2 → Sprint 3 → ... → Sprint N
+   ↓
+LOOP 1: Phase Execution (single phase with multiple sprints)
+   ↓
+LOOP 2: Consensus Validation (≥90% Byzantine consensus per sprint)
+   ↓
+LOOP 3: Primary Swarm Execution (implementation with confidence scores)
+```
+
+## Sprint Planning (Loop 0)
+
+### Step 1: Parse Phase into Sprints
+```javascript
+const sprintPlan = {
+  phase_name: "User Authentication",
+  sprints: [
+    {
+      sprint_id: "1.1",
+      name: "Core Login API",
+      deliverables: [
+        "POST /auth/login endpoint",
+        "JWT token generation",
+        "Password validation"
+      ],
+      estimated_agents: 3,
+      dependencies: []
+    },
+    {
+      sprint_id: "1.2",
+      name: "Password Security",
+      deliverables: [
+        "bcrypt password hashing",
+        "Salt generation",
+        "Hash verification"
+      ],
+      estimated_agents: 2,
+      dependencies: ["1.1"]
+    },
+    {
+      sprint_id: "1.3",
+      name: "Token Management",
+      deliverables: [
+        "Token refresh endpoint",
+        "Token expiration handling",
+        "Token blacklisting"
+      ],
+      estimated_agents: 4,
+      dependencies: ["1.1", "1.2"]
+    }
+  ]
+}
+```
+
+### Step 2: Store Scope Boundaries (Per Sprint)
+```javascript
+mcp__claude-flow-novice__memory_usage({
+  action: "store",
+  namespace: "scope-control",
+  key: "sprint-boundaries",
+  value: JSON.stringify({
+    primary_goal: "User Authentication Phase",
+    sprint_scope: {
+      "1.1": {
+        in_scope: ["Login API", "JWT generation", "Basic validation"],
+        out_of_scope: ["OAuth", "MFA", "Password reset"]
+      },
+      "1.2": {
+        in_scope: ["bcrypt hashing", "Salt generation"],
+        out_of_scope: ["Argon2", "Key derivation functions"]
+      },
+      "1.3": {
+        in_scope: ["Refresh tokens", "Expiration", "Blacklist"],
+        out_of_scope: ["Sliding sessions", "Device tracking"]
+      }
+    },
+    risk_profile: "public-facing-medium-risk"
+  })
+})
+```
+
+## Sprint Execution (Loop 1)
+
+For EACH sprint in phase:
+
+### Sprint Initialization
+```javascript
+// SPRINT 1.1: Core Login API
+console.log(`Sprint ${sprintId}: ${sprintName}`);
+
+// Initialize swarm for sprint
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",          // Use mesh for smaller sprint teams (2-7 agents)
+  maxAgents: 3,
+  strategy: "balanced"
+})
+
+// Execute Loop 3 (Primary Swarm)
+Task("Backend Dev 1", `
+  Implement POST /auth/login endpoint
+
+  Requirements:
+  - Accept email/password in request body
+  - Validate credentials against database
+  - Generate JWT on successful auth
+  - Return 401 on failure
+
+  MANDATORY: After EVERY file edit:
+  node config/hooks/post-edit-pipeline.js "[FILE_PATH]" --memory-key "swarm/sprint-1.1/backend-1"
+
+  Report confidence score when complete.
+`, "backend-dev")
+
+Task("Tester 1", `
+  Create tests for login endpoint...
+
+  MANDATORY: Run post-edit hook after each test file.
+
+  Report confidence score.
+`, "tester")
+
+Task("Security 1", `
+  Review login security...
+
+  Report confidence score.
+`, "security-specialist")
+```
+
+### Sprint Self-Assessment Gate
+```javascript
+// Collect confidence scores
+const sprintConfidence = {
+  "backend-1": 0.88,
+  "tester-1": 0.82,
+  "security-1": 0.79
+}
+
+// Gate logic
+if (allAgents >= 0.75) {
+  // PROCEED to Loop 2 (Consensus)
+  console.log("Sprint ${sprintId} gate PASSED. Proceeding to consensus...");
+} else {
+  // RELAUNCH Loop 3 (autonomous retry)
+  console.log("Sprint ${sprintId} gate FAILED. Relaunching Loop 3 with feedback...");
+}
+```
+
+### Sprint Consensus Validation
+```javascript
+// MESSAGE 2: Validators (AFTER sprint implementation complete)
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",
+  maxAgents: 2,
+  strategy: "balanced"
+})
+
+Task("Reviewer 1", `
+  Review completed Sprint ${sprintId} work:
+  - Files: [list specific files]
+  - Deliverables: ${JSON.stringify(deliverables)}
+
+  Validate code quality, test coverage, security.
+  Report consensus score.
+`, "reviewer")
+
+Task("Architect 1", `
+  Validate Sprint ${sprintId} architecture:
+  - API design consistency
+  - Integration patterns
+  - Scalability considerations
+
+  Report consensus score.
+`, "architect")
+```
+
+### Sprint Product Owner Decision
+```javascript
+Task("Product Owner", `
+  GOAP DECISION - Sprint ${sprintId} Complete
+
+  CURRENT STATE:
+  - Sprint ${sprintId} consensus: ${consensusScore}
+  - Remaining sprints: ${remainingSprints}
+  - Validator concerns: ${concerns}
+
+  RETRIEVE SPRINT SCOPE:
+  mcp__claude-flow-novice__memory_usage({
+    action: "retrieve",
+    namespace: "scope-control",
+    key: "sprint-boundaries"
+  })
+
+  EXECUTE GOAP A* SEARCH:
+  1. Classify concerns by sprint scope
+  2. Calculate cost: in-scope fix vs defer to backlog
+  3. A* pathfinding for optimal decision
+  4. Make autonomous decision
+
+  DECISION OPTIONS:
+  - PROCEED_NEXT_SPRINT (dependencies satisfied, scope intact)
+  - RELAUNCH_SPRINT (in-scope blockers remain)
+  - DEFER_CONCERNS (out-of-scope, save to backlog)
+
+  OUTPUT: {decision: "...", next_action: "..."}
+`, "product-owner")
+```
+
+### Sprint Transition Logic
+```javascript
+// Product Owner decision outcomes
+switch (decision) {
+  case "PROCEED_NEXT_SPRINT":
+    // Store sprint results
+    mcp__claude-flow-novice__memory_usage({
+      action: "store",
+      namespace: "sprint-progress",
+      key: `sprint-${sprintId}-results`,
+      value: JSON.stringify({
+        consensus: consensusScore,
+        deliverables: completedDeliverables,
+        timestamp: Date.now()
+      })
+    })
+
+    // Check next sprint dependencies
+    const nextSprint = sprintPlan.sprints[currentSprintIndex + 1];
+    if (dependenciesSatisfied(nextSprint)) {
+      // IMMEDIATELY transition (NO approval needed)
+      console.log(`IMMEDIATELY transitioning to Sprint ${nextSprint.sprint_id}...`);
+      executeSprint(nextSprint);
+    }
+    break;
+
+  case "RELAUNCH_SPRINT":
+    // IMMEDIATELY relaunch Loop 3 with targeted agents (NO approval)
+    console.log(`Relaunching Sprint ${sprintId} Loop 3 with targeted agents...`);
+    break;
+
+  case "DEFER_CONCERNS":
+    // Save to backlog, proceed to next sprint
+    console.log(`Deferred out-of-scope items. Proceeding to next sprint...`);
+    break;
+}
+```
+
+## Autonomous Sprint Execution
+
+**FORBIDDEN PATTERNS:**
+- ❌ "Sprint 1.1 complete. Proceed to Sprint 1.2?" (AUTO-PROCEED)
+- ❌ "Should I continue with sprints?" (ALWAYS continue until all sprints done)
+- ❌ Waiting for approval between sprints (AUTONOMOUS TRANSITION)
+
+**REQUIRED PATTERNS:**
+```
+Sprint 1.1 consensus: 93% ✅
+Dependencies for Sprint 1.2 satisfied.
+IMMEDIATELY transitioning to Sprint 1.2...
+
+Sprint 1.2: Password Security
+[Spawning agents autonomously - no permission needed]
+```
+
+## Iteration Limits (Per Sprint)
+- **Loop 2** (Consensus): 10 iterations max per sprint
+- **Loop 3** (Primary Swarm): 10 iterations max per sprint
+- **Loop 1** (Sprints): Unlimited (continues until all sprints complete)
+
+## Sprint Progress Tracking
+
+```javascript
+// Query sprint progress
+mcp__claude-flow-novice__memory_usage({
+  action: "list",
+  namespace: "sprint-progress"
+})
+
+// Output:
+{
+  "sprint-1.1-results": {consensus: 0.93, deliverables: [...]},
+  "sprint-1.2-results": {consensus: 0.88, deliverables: [...]},
+  "sprint-1.3-results": null // Current sprint in progress
+}
+```
+
+## Example Sprint Execution
+
+```
+[Turn 1] Phase: User Authentication (3 sprints)
+         → Sprint scope boundaries stored
+         → Sprint 1.1: Core Login API
+
+[Turn 2-3] Sprint 1.1 Execution
+           → Loop 3 (backend-dev, tester, security)
+           → Gate PASSES (all ≥75%)
+           → Loop 2 consensus: 93% ✅
+           → Product Owner: PROCEED_NEXT_SPRINT
+
+[Turn 4] AUTONOMOUS TRANSITION
+         → Dependencies for Sprint 1.2 satisfied
+         → IMMEDIATELY starting Sprint 1.2: Password Security
+
+[Turn 5-6] Sprint 1.2 Execution
+           → Loop 3 (2 agents - smaller scope)
+           → Consensus: 88% ✅
+           → Product Owner: DEFER (Argon2 out-of-scope)
+
+[Turn 7] AUTONOMOUS TRANSITION
+         → Sprint 1.3: Token Management
+
+[Turn 8-10] Sprint 1.3 Execution
+            → Final sprint completion
+            → Phase COMPLETE ✅
+```
+
+## Output Format
+
+```
+Phase: User Authentication (3 sprints)
+Sprint 1.1/1.3: Core Login API
+
+Loop 3 Iteration 1/10 - Confidence: 87% avg ✅
+Loop 2 Iteration 1/10 - Consensus: 93% ✅
+
+Sprint 1.1 COMPLETE
+Dependencies satisfied for Sprint 1.2.
+IMMEDIATELY transitioning to Sprint 1.2...
+
+─────────────────────────────────
+Sprint 1.2/1.3: Password Security
+[Executing autonomously - no permission needed]
+```
+
+## Phase Completion
+
+When final sprint achieves ≥90% consensus:
+```
+Sprint 1.3 COMPLETE - Consensus: 91% ✅
+
+Phase: User Authentication - ALL SPRINTS COMPLETE ✅
+- Sprint 1.1: Core Login API (93%)
+- Sprint 1.2: Password Security (88%)
+- Sprint 1.3: Token Management (91%)
+
+Deferred items saved to backlog:
+- OAuth integration (out-of-scope)
+- Argon2 hashing (out-of-scope)
+- Sliding session windows (out-of-scope)
+
+Phase execution complete. Self-looping terminated.
+```
+
+## Integration with Epic
+
+If this phase is part of a larger epic, results are stored for epic-level tracking:
+```javascript
+mcp__claude-flow-novice__memory_usage({
+  action: "store",
+  namespace: "epic-progress",
+  key: "phase-1-results",
+  value: JSON.stringify({
+    phase_name: "User Authentication",
+    sprints_completed: ["1.1", "1.2", "1.3"],
+    overall_consensus: 0.91,
+    ready_for_next_phase: true
+  })
+})
+```

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

@@ -0,0 +1,180 @@
+---
+description: "Execute autonomous 3-loop self-correcting CFN workflow with automatic retry and consensus validation"
+argument-hint: "<task description> [--phase=name] [--max-loop2=10] [--max-loop3=10]"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+---
+
+# CFN Loop - Autonomous 3-Loop Self-Correcting Workflow
+
+Execute task through autonomous 3-loop CFN structure with automatic retry and consensus validation.
+
+🚨 **AUTONOMOUS SELF-LOOPING PROCESS**
+
+**Task**: $ARGUMENTS
+
+## CFN Loop Structure (3 Loops)
+
+```
+LOOP 1: Phase Completion or Escalation
+   ↓
+LOOP 2: Consensus Validation (≥90% Byzantine consensus)
+   ↓
+LOOP 3: Primary Swarm Execution with subtask iterations
+```
+
+## Command Options
+
+```bash
+/cfn-loop "Implement JWT authentication" --phase=implementation
+/cfn-loop "Fix security vulnerabilities" --phase=security-audit --max-loop2=10
+/cfn-loop "Refactor API layer" --max-loop3=15
+/cfn-loop "Add test coverage for auth module" --phase=testing --max-loop2=10
+```
+
+**Options:**
+- `--phase=<name>`: Optional phase name for tracking
+- `--max-loop2=<n>`: Max consensus iterations (default: 10)
+- `--max-loop3=<n>`: Max primary swarm iterations (default: 10)
+
+## Execution Pattern
+
+### Step 1: Initialize Swarm (MANDATORY)
+```javascript
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",          // mesh for 2-7, hierarchical for 8+
+  maxAgents: 5,
+  strategy: "balanced"
+})
+```
+
+### Step 2: Execute - Primary Swarm (Loop 3)
+```javascript
+Task("Agent 1", `
+  Implementation task...
+
+  MANDATORY: After EVERY file edit:
+  node config/hooks/post-edit-pipeline.js "[FILE_PATH]" --memory-key "swarm/agent-1/step-1"
+
+  Report confidence score when complete.
+`, "agent-type")
+```
+
+### Step 3: Self-Assessment Gate
+- ALL agents ≥75% → Proceed to Loop 2
+- ANY agent <75% → IMMEDIATELY relaunch Loop 3 (NO approval)
+
+### Step 4: Consensus Validation (Loop 2)
+**CRITICAL**: Spawn validators in SEPARATE message AFTER implementation:
+
+```javascript
+// MESSAGE 2: Validators only
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",
+  maxAgents: 3,
+  strategy: "balanced"
+})
+
+Task("Reviewer", "Review completed work", "reviewer")
+Task("Security", "Security audit", "security-specialist")
+Task("Architect", "Architecture validation", "architect")
+```
+
+### Step 5: Product Owner Decision (GOAP)
+```javascript
+Task("Product Owner", `
+  GOAP DECISION EXECUTION
+
+  CURRENT STATE:
+  - Consensus: ${consensusScore} (target: ≥0.90)
+  - Validator concerns: ${concerns}
+  - Loop iteration: ${iteration}/10
+
+  EXECUTE GOAP A* SEARCH:
+  1. Classify concerns (in-scope vs out-of-scope)
+  2. Calculate action costs
+  3. Find optimal decision path
+  4. Make autonomous decision (NO approval needed)
+
+  OUTPUT: {decision: "PROCEED|DEFER|ESCALATE", ...}
+`, "product-owner")
+```
+
+**Decision Outcomes:**
+- **PROCEED** → IMMEDIATELY relaunch Loop 3 with targeted agents
+- **DEFER** → Save to backlog, complete phase
+- **ESCALATE** → Generate alternatives (rare)
+
+### Step 6: Loop 1 Phase Completion
+- Consensus ≥90% → Phase COMPLETE
+- Max iterations reached → Escalate with diagnostics
+
+## Autonomous Execution Rules
+
+**FORBIDDEN:**
+- ❌ "Should I retry?" (ALWAYS retry if iterations < max)
+- ❌ "Proceed to consensus?" (AUTO-PROCEED when gate passes)
+- ❌ Waiting for approval during CFN Loop cycles
+
+**REQUIRED:**
+- ✅ IMMEDIATE Loop 3 relaunch on low confidence (iteration < max)
+- ✅ IMMEDIATE Loop 3 relaunch on consensus failure (iteration < max)
+- ✅ AUTOMATIC better agent selection based on failure analysis
+- ✅ ONLY escalate when truly blocked (critical error or max iterations)
+
+## Iteration Limits
+- **Loop 2** (Consensus): Configurable via `--max-loop2` (default: 10)
+- **Loop 3** (Primary Swarm): Configurable via `--max-loop3` (default: 10)
+
+## Circuit Breaker Protection
+
+Automatic timeout protection prevents infinite loops:
+- Loop 2 timeout: 30 minutes
+- Loop 3 timeout: 20 minutes
+- Escalates on timeout with diagnostic report
+
+## Example Execution
+
+```
+[Turn 1] /cfn-loop "Implement JWT auth" --phase=auth
+         → Loop 3 Iteration 1/10
+         → Swarm: backend-dev, tester, security
+         → Confidence: 72%, 68%, 85%
+         → Gate FAILS → IMMEDIATE retry
+
+[Turn 2] Loop 3 Iteration 2/10
+         → Swarm with feedback
+         → Confidence: 85%, 82%, 88%
+         → Gate PASSES → Proceed to Loop 2
+
+[Turn 3] Loop 2 Iteration 1/10
+         → Consensus validators spawned
+         → Consensus: 87% (below 90%)
+         → Product Owner: PROCEED (in-scope issues)
+         → IMMEDIATE Loop 3 relaunch
+
+[Turn 4] Loop 3 Iteration 3/10
+         → Targeted agents (backend-dev, security)
+         → Consensus achieved: 93% ✅
+         → Phase COMPLETE
+```
+
+## Output Format
+
+```
+Loop 3 Iteration 2/10 - Confidence: 85% avg ✅
+Proceeding to Loop 2 (Consensus)...
+
+Loop 2 Iteration 1/10 - Consensus: 87% ❌
+Product Owner: PROCEED (3 in-scope blockers)
+IMMEDIATELY relaunching Loop 3 with:
+- backend-dev (fix validation logic)
+- security-specialist (review auth flow)
+[Executing autonomously - no permission needed]
+```
+
+## Integration with Other CFN Commands
+
+- **Single task**: Use `/cfn-loop` (this command)
+- **Multiple sprints**: Use `/cfn-loop-sprints`
+- **Multi-phase epic**: Use `/cfn-loop-epic`
+- **Direct single task**: Use `/cfn-loop-single`

package/.claude/commands/metrics-summary.md

@@ -0,0 +1,58 @@
+# Metrics Summary
+
+Display aggregated metrics statistics with configurable time frame and manage metrics tracking.
+
+## Usage
+
+```bash
+# Display metrics summary
+/metrics-summary [--minutes=60] [--provider=all] [--model=all]
+
+# Manage tracking
+/metrics-summary --enable    # Enable metrics tracking
+/metrics-summary --disable   # Disable metrics tracking
+/metrics-summary --status    # Check tracking status
+```
+
+## Parameters
+
+### Display Metrics
+- `--minutes` - Time frame in minutes (default: 60 = last hour)
+  - Examples: 60 (1 hour), 1440 (24 hours), 10080 (7 days)
+- `--provider` - Filter by provider: `all`, `anthropic`, `z.ai` (default: all)
+- `--model` - Filter by model name (default: all)
+
+### Manage Tracking
+- `--enable` - Enable metrics tracking
+- `--disable` - Disable metrics tracking
+- `--status` - Check current tracking status
+
+## Examples
+
+```bash
+# Last hour stats (all providers)
+/metrics-summary
+
+# Last 24 hours
+/metrics-summary --minutes=1440
+
+# Last hour Z.ai only
+/metrics-summary --minutes=60 --provider=z.ai
+
+# Last 7 days GLM-4.6 only
+/metrics-summary --minutes=10080 --model=glm-4.6
+
+# Enable/disable tracking
+/metrics-summary --enable
+/metrics-summary --disable
+/metrics-summary --status
+```
+
+## Output
+
+- **API Requests**: Total count by provider
+- **Token Usage**: Input/Output/Total by provider and model
+- **Error Rate**: Success vs error percentage
+- **Cost Breakdown**: Estimated costs by provider (if pricing available)
+- **Top Models**: Most used models in time frame
+- **Performance**: Average API duration by provider