claude-flow-novice 2.11.0 → 2.13.0

package/claude-assets/commands/cfn/write-plan.md

@@ -1,104 +1,275 @@
-# Write Plan Command
+---
+description: "CFN Loop pre-planning: Generate structured implementation plans with TDD approach"
+argument-hint: "<task description> [--mode=mvp|standard|enterprise]"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Bash"]
+---
 
-## Overview
-The `write-plan` command helps create structured, test-driven implementation plans for claude-flow-novice projects, leveraging our CFN Loop workflow and adaptive context strategies.
+# Write Plan - CFN Loop Pre-Planning
 
-## Core Principles
+Generate structured implementation plan BEFORE executing CFN Loop. Outputs plan document for review.
 
-### 1. Test-Driven Development (TDD)
-- Always start with failure scenarios (Red phase)
-- Implement minimal code to pass tests (Green phase)
-- Refactor for quality and maintainability (Refactor phase)
+🎯 **Use this BEFORE /cfn-loop-cli or /cfn-loop-task**
 
-### 2. CFN Loop Integration
-Utilize the CFN Loop workflow for complex implementations:
-- **Loop 3 (Implementation)**: Create detailed implementation plan
-- **Loop 2 (Validation)**: Comprehensive test and review
-- **Product Owner Decision**: Strategic go/no-go checkpoint
+**Task**: $ARGUMENTS
 
-## Plan Structure Template
+## What This Does
 
+**Pre-planning phase for CFN Loop:**
+1. Analyzes task complexity
+2. Selects appropriate agents
+3. Defines test cases and success criteria
+4. Creates implementation roadmap
+5. Outputs plan document for approval
+
+**Then run:**
+```bash
+# After reviewing plan
+/cfn-loop-cli "Implement JWT authentication" --mode=standard
+# OR
+/cfn-loop-task "Implement JWT authentication" --mode=standard
+```
+
+## Command Options
+
+```bash
+# Standard planning
+/write-plan "Implement JWT authentication"
+
+# MVP planning (faster, simpler)
+/write-plan "Build prototype feature" --mode=mvp
+
+# Enterprise planning (comprehensive)
+/write-plan "Production security system" --mode=enterprise
+```
+
+**Options:**
+- `--mode=<mvp|standard|enterprise>`: Planning depth (default: standard)
+
+## Execution Pattern
+
+### Step 1: Analyze Task
+
+```javascript
+Task("planner", `
+  ANALYZE TASK FOR CFN LOOP PLANNING
+
+  Task: $ARGUMENTS
+  Mode: ${mode}
+
+  ANALYSIS REQUIRED:
+  1. Complexity Assessment:
+     - Estimated files: 1-2 (simple) | 3-5 (standard) | >5 (complex)
+     - Estimated LOC: <200 (simple) | 200-500 (standard) | >500 (complex)
+     - Keywords: security, performance, frontend, mobile, etc.
+
+  2. Agent Selection:
+     - Loop 3 (Implementation): Based on task type
+       * Backend: backend-dev, researcher, devops
+       * Full-stack: backend-dev, react-frontend-engineer, devops
+       * Mobile: mobile-dev, backend-dev
+       * Security: security-specialist, backend-dev
+     - Loop 2 (Validation): Scale by complexity
+       * Simple: reviewer, tester
+       * Standard: +architect, +security-specialist
+       * Complex: +code-analyzer, +performance-benchmarker
+
+  3. Test Cases (TDD Approach):
+     - Red Phase: Failure scenarios
+     - Green Phase: Minimal passing implementation
+     - Refactor Phase: Quality improvements
+
+  4. Success Criteria:
+     - Test coverage target (≥80%)
+     - Performance benchmarks (if applicable)
+     - Security requirements (if applicable)
+     - Deliverables list
+
+  OUTPUT: planning/PLAN_${sanitize($ARGUMENTS)}.md
+`)
+```
+
+### Step 2: Generate Plan Document
+
+**Plan Structure:**
 ```markdown
-# [Feature/Task Name]
+# Implementation Plan: [Task Name]
 
-## Objectives
-- Clear, measurable implementation goals
-- Specific deliverables
+## Task Analysis
+- **Complexity**: Simple | Standard | Complex
+- **Estimated Files**: N
+- **Estimated LOC**: N
+- **Mode**: ${mode}
 
-## Context Injection
-- Epic Context
-- Sprint Context
-- Specific Deliverables
+## Agent Configuration
 
-## Coordination Strategy
-- Coordinator: `cost-savings-cfn-loop-coordinator`
-- Agents: Specify roles (backend-dev, researcher, etc.)
-- Iteration Strategy
+### Loop 3 (Implementation)
+- agent-1 (role)
+- agent-2 (role)
+- agent-3 (role)
 
-## Phase 1: Test and Specification
-### Deliverables
-- [ ] Test script (tests/test-[feature].sh)
-- [ ] Specification document
+### Loop 2 (Validation)
+- reviewer (code review)
+- tester (quality assurance)
+[+ architect, security-specialist for standard/enterprise]
 
-### Test Cases
-- Failure scenarios
-- Edge cases
-- Performance expectations
+### Product Owner
+- product-owner (PROCEED/ITERATE/ABORT decision)
 
-## Phase 2: Minimal Implementation
-### Deliverables
+## Test-Driven Development Plan
+
+### Phase 1: Red (Failure Scenarios)
+**Deliverables:**
+- [ ] Test script: tests/test-[feature].sh
+- [ ] Failure test cases defined
+
+**Test Cases:**
+1. [Test case 1 - expected failure]
+2. [Test case 2 - edge case]
+3. [Test case 3 - performance requirement]
+
+### Phase 2: Green (Minimal Implementation)
+**Deliverables:**
 - [ ] Minimal working implementation
-- [ ] Initial test coverage
+- [ ] All test cases passing
 
-## Phase 3: Refactoring and Optimization
-### Deliverables
-- [ ] Improved code quality
-- [ ] Enhanced test coverage
-- [ ] Performance optimization
+**Implementation Steps:**
+1. [Core functionality]
+2. [Basic validation]
+3. [Minimal error handling]
+
+### Phase 3: Refactor (Quality Improvement)
+**Deliverables:**
+- [ ] Code quality improvements
+- [ ] Enhanced test coverage (≥80%)
+- [ ] Documentation
 
-## Redis Coordination Checkpoints
-- Entry point validation
-- Iteration confidence reporting
-- Context extraction verification
+**Refactoring Goals:**
+1. [Code organization]
+2. [Performance optimization]
+3. [Security hardening]
 
 ## Success Criteria
-- Test coverage ≥ 90%
-- Complexity score < 15
-- Meets architectural guidelines
+
+### Quality Gates
+- Loop 3 Gate: ≥${mode === 'enterprise' ? 0.85 : mode === 'standard' ? 0.75 : 0.70}
+- Loop 2 Consensus: ≥${mode === 'enterprise' ? 0.95 : mode === 'standard' ? 0.90 : 0.80}
+
+### Deliverables
+- [ ] All test cases passing
+- [ ] Test coverage ≥80%
+- [ ] Code complexity <15 per function
+- [ ] Security review complete
+- [ ] Documentation updated
+
+### Performance Benchmarks (if applicable)
+- [Benchmark 1]
+- [Benchmark 2]
 
 ## Potential Blockers
-- Identify potential implementation challenges
-- Pre-emptive mitigation strategies
+
+**Technical:**
+- [Potential blocker 1]
+- [Mitigation strategy]
+
+**Dependencies:**
+- [External dependency 1]
+- [Fallback plan]
 
 ## Iteration Strategy
-- Maximum iterations: 10
-- Confidence threshold: ≥ 0.90
-- Adaptive agent spawning based on feedback
+- Max iterations: ${mode === 'enterprise' ? 15 : mode === 'standard' ? 10 : 5}
+- Confidence threshold: ${mode === 'enterprise' ? 0.95 : mode === 'standard' ? 0.90 : 0.80}
+- Adaptive agent spawning: YES
+
+## Next Steps
+
+1. Review this plan
+2. Execute CFN Loop:
+   \`\`\`bash
+   /cfn-loop-cli "$ARGUMENTS" --mode=${mode}
+   # OR for debugging:
+   /cfn-loop-task "$ARGUMENTS" --mode=${mode}
+   \`\`\`
 ```
 
-## Usage Guidelines
+### Step 3: Output Plan
+
+```javascript
+const planPath = `planning/PLAN_${sanitize($ARGUMENTS)}.md`;
+Write(planPath, planContent);
+
+console.log(`✅ Implementation plan generated: ${planPath}`);
+console.log('');
+console.log('📋 Plan Summary:');
+console.log(`- Complexity: ${complexity}`);
+console.log(`- Loop 3 Agents: ${loop3Agents.length}`);
+console.log(`- Loop 2 Validators: ${loop2Agents.length}`);
+console.log(`- Test Cases: ${testCases.length}`);
+console.log(`- Success Criteria: ${successCriteria.length}`);
+console.log('');
+console.log('Next: Review plan, then execute CFN Loop');
+console.log(`/cfn-loop-cli "$ARGUMENTS" --mode=${mode}`);
+```
+
+## Integration with CFN Loop
+
+**Workflow:**
+```
+1. /write-plan "Task description" --mode=standard
+   ↓ Generates planning/PLAN_task.md
+
+2. Human reviews plan (optional)
+   ↓ Approve or request changes
+
+3. /cfn-loop-cli "Task description" --mode=standard
+   ↓ Executes implementation following plan
+
+4. CFN Loop autonomously implements following TDD phases
+```
+
+## Mode Comparison
+
+| Mode | Complexity | Agents | Test Coverage | Use Case |
+|------|------------|--------|---------------|----------|
+| MVP | Low | 3-4 total | ≥70% | Prototypes, proof-of-concept |
+| Standard | Medium | 5-7 total | ≥80% | Production features |
+| Enterprise | High | 8-10 total | ≥90% | Critical systems, compliance |
+
+## Example Output
 
-### Spawning Plan Creation
-```bash
-/write-plan "Implement JWT Authentication" \
-  --epic-context '{"goal":"Secure API access"}' \
-  --sprint-context '{"sprint":"Authentication MVP"}' \
-  --agents "backend-dev,security-specialist"
 ```
+Analyzing task...
 
-### Example Workflow
-1. Generate initial plan
-2. Review with team via Redis pub/sub
-3. Refine plan based on feedback
-4. Execute using `cost-savings-cfn-loop-coordinator`
+✅ Implementation plan generated: planning/PLAN_jwt_authentication.md
+
+📋 Plan Summary:
+- Complexity: Standard
+- Loop 3 Agents: 3 (backend-dev, researcher, devops)
+- Loop 2 Validators: 4 (reviewer, tester, architect, security-specialist)
+- Test Cases: 8
+- Success Criteria: 6
+
+Next: Review plan, then execute CFN Loop
+/cfn-loop-cli "Implement JWT authentication" --mode=standard
+```
 
 ## Best Practices
-- Keep tasks small and focused
-- Prioritize testability
-- Leverage adaptive context injection
-- Use explicit deliverable tracking
-
-## Notes
-- This is a living document
-- Continuously update based on team feedback
-- Align with claude-flow-novice adaptive context strategies
+
+**When to Use:**
+- ✅ Complex tasks (>3 steps)
+- ✅ Security-critical features
+- ✅ Team collaboration (plan review needed)
+- ✅ Learning CFN Loop workflow
+
+**When to Skip:**
+- Simple bug fixes (go straight to /cfn-loop-cli)
+- Urgent hotfixes (no time for planning)
+- Well-understood patterns (agent knows what to do)
+
+## Related Commands
+
+- **Execute Plan**: `/cfn-loop-cli` (production) or `/cfn-loop-task` (debugging)
+- **Document Results**: `/cfn-loop-document` (after completion)
+
+---
+
+**Version:** 2.0.0 (2025-10-31) - Integrated with CFN Loop v3 architecture

package/claude-assets/skills/cfn-changelog-management/SKILL.md

@@ -0,0 +1,349 @@
+---
+skill_id: cfn-changelog-management
+name: CFN Changelog Management
+version: 1.0.0
+category: documentation
+tags: [changelog, versioning, release-notes, sparse-logging]
+dependencies: []
+---
+
+# CFN Changelog Management Skill
+
+## Purpose
+Systematically track implementation changes with sparse, structured entries appended to project changelog. Enables quick visibility into what changed, when, and why without verbose commit-style messages.
+
+## Problem Solved
+Traditional changelogs require manual curation and often become stale or inconsistent. Agents completing features, fixing bugs, or making architectural changes need a lightweight way to document impact without context-switching to git commits or detailed documentation.
+
+## When to Use
+
+### ✅ REQUIRED Usage Scenarios
+- **After feature implementation** - Agent completes feature work
+- **After bug fix** - Agent resolves issue with code changes
+- **After breaking change** - API/interface modifications that affect consumers
+- **After dependency update** - Major version bumps or security patches
+- **After architectural change** - Coordination pattern modifications, skill refactors
+
+### ⚠️ OPTIONAL Usage Scenarios
+- **After performance optimization** - Measurable improvements (>10% speedup)
+- **After security enhancement** - Hardening, vulnerability fixes
+- **Internal refactoring** - Code cleanup without behavioral changes (use judgment)
+
+### ❌ DO NOT USE For
+- **Routine maintenance** - Formatting, linting, comment updates
+- **Work-in-progress** - Incomplete features or experimental changes
+- **Test-only changes** - Adding tests without production code changes
+- **Documentation-only updates** - README edits, comment clarifications
+
+## Interface
+
+### Primary Script: `add-changelog-entry.sh`
+
+**Required Parameters:**
+- `--type`: Entry type (feature|bugfix|breaking|dependency|architecture|performance|security)
+- `--summary`: One-line description (10-100 chars)
+- `--impact`: What changed and why it matters
+
+**Optional Parameters:**
+- `--version`: Target version (default: auto-increment patch)
+- `--issue`: Related issue/bug number (e.g., "BUG-123", "#456")
+- `--files`: Key files affected (comma-separated, max 5)
+- `--migration`: Migration notes for breaking changes
+
+**Usage:**
+```bash
+./.claude/skills/cfn-changelog-management/add-changelog-entry.sh \
+  --type "feature" \
+  --summary "Add backlog management skill for deferred work tracking" \
+  --impact "Agents can now systematically capture deferred items with structured metadata instead of losing context in chat history" \
+  --files ".claude/skills/cfn-backlog-management/SKILL.md,readme/BACKLOG.md"
+```
+
+### Output Location
+All entries appended to: `readme/CHANGELOG.md`
+
+## Changelog File Structure
+
+```markdown
+# Claude Flow Novice Changelog
+
+## [Unreleased]
+
+### Features
+- Add backlog management skill (2025-10-31)
+  - Impact: Systematic deferred work tracking with priority/tag organization
+  - Files: `.claude/skills/cfn-backlog-management/`
+
+### Bug Fixes
+
+### Breaking Changes
+
+### Dependencies
+
+### Architecture
+
+### Performance
+
+### Security
+
+---
+
+## [2.11.0] - 2025-10-31
+
+### Features
+- Backlog management skill implementation
+  - Impact: Centralized tracking of deferred work items
+  - Files: `.claude/skills/cfn-backlog-management/add-backlog-item.sh`
+
+...
+```
+
+## Entry Types
+
+### Feature
+New functionality, skills, commands, or capabilities.
+```bash
+--type "feature"
+--summary "Implement Redis pub/sub coordination for zero-token waiting"
+--impact "Agents block on BLPOP instead of polling, eliminating API calls during wait cycles"
+```
+
+### Bug Fix
+Defect resolution, error handling improvements.
+```bash
+--type "bugfix"
+--summary "Fix race condition in Loop 3 confidence collection"
+--impact "Orchestrator now uses synchronous temp file capture instead of polling Redis keys"
+--issue "BUG-10"
+```
+
+### Breaking Change
+Incompatible changes requiring user/agent migration.
+```bash
+--type "breaking"
+--summary "Rename skill cfn-redis-coordination → cfn-swarm-coordination"
+--impact "All agent spawn commands must update skill references"
+--migration "Run: sed -i 's/cfn-redis-coordination/cfn-swarm-coordination/g' .claude/agents/**/*.md"
+```
+
+### Dependency
+Package updates, version bumps, security patches.
+```bash
+--type "dependency"
+--summary "Upgrade redis 5.0.0 → 5.8.3"
+--impact "Fixes CVE-2024-1234, adds BLPOP timeout parameter support"
+```
+
+### Architecture
+Coordination pattern changes, skill refactors, system design updates.
+```bash
+--type "architecture"
+--summary "Extract output processing into dedicated skill"
+--impact "95% code reuse between Loop 3 and Loop 2 consensus collection"
+--files ".claude/skills/cfn-agent-output-processing/SKILL.md"
+```
+
+### Performance
+Optimizations with measurable impact.
+```bash
+--type "performance"
+--summary "Parallel agent spawning with background processes"
+--impact "3x speedup for 3-agent coordination (sequential: 15s → parallel: 5s max latency)"
+```
+
+### Security
+Hardening, vulnerability fixes, audit improvements.
+```bash
+--type "security"
+--summary "Add pre-edit backup hook for safe file revert"
+--impact "Prevents git conflicts in parallel sessions, 24h backup retention"
+```
+
+## Validation Rules
+
+1. **Type validation**: Must be one of 7 defined types
+2. **Summary length**: 10-100 characters (enforces brevity)
+3. **Impact required**: Cannot be empty (enforces "why it matters")
+4. **File limit**: Max 5 files (prevents noise)
+5. **Version format**: Semantic versioning (X.Y.Z)
+
+## Sparse Language Guidelines
+
+### ✅ Good Examples
+```
+Summary: "Add Redis coordination skill"
+Impact: "Zero-token agent waiting via BLPOP"
+
+Summary: "Fix confidence parsing edge case"
+Impact: "Handles percentage format (85%) in addition to decimal (0.85)"
+
+Summary: "Upgrade better-sqlite3 to v12.4.1"
+Impact: "Node 22 compatibility, fixes installation errors on WSL2"
+```
+
+### ❌ Bad Examples (Too Verbose)
+```
+Summary: "We have implemented a comprehensive Redis-based coordination system..."
+Impact: "This change allows agents to coordinate more efficiently by using a blocking..."
+
+Summary: "Fixed a bug"
+Impact: "There was an issue that has been resolved"
+```
+
+### Sparse Pattern Rules
+- **Active voice**: "Add feature" not "Feature added"
+- **No articles**: "Fix bug" not "Fix the bug"
+- **No fluff**: "Enables X" not "This change enables X"
+- **Measurable impact**: Include numbers when relevant (3x speedup, 95% reduction)
+
+## Integration Examples
+
+### Loop 3 Agent (After Feature Implementation)
+```bash
+# Agent completes feature work
+Edit: file_path="src/new-feature.ts" ...
+
+# Document change
+./.claude/skills/cfn-changelog-management/add-changelog-entry.sh \
+  --type "feature" \
+  --summary "JWT authentication middleware" \
+  --impact "Stateless auth reduces session storage by 80%" \
+  --files "src/middleware/auth.ts,src/types/jwt.ts"
+```
+
+### Loop 2 Validator (After Identifying Bug Fix)
+```bash
+# Validator reviews fix
+./.claude/skills/cfn-changelog-management/add-changelog-entry.sh \
+  --type "bugfix" \
+  --summary "Prevent null pointer in Redis connection retry" \
+  --impact "Eliminates crashes during Redis unavailability" \
+  --issue "BUG-42" \
+  --files "src/redis/client.ts"
+```
+
+### Product Owner (After Architectural Decision)
+```bash
+# Product Owner approves design change
+./.claude/skills/cfn-changelog-management/add-changelog-entry.sh \
+  --type "architecture" \
+  --summary "Split orchestrator into modular helper scripts" \
+  --impact "78% code reduction, improved testability" \
+  --files ".claude/skills/cfn-loop-orchestration/helpers/"
+```
+
+## Versioning Strategy
+
+### Auto-Increment (Default)
+Script reads current version from `package.json`, increments patch:
+- Current: `2.11.0` → Entry added to: `[Unreleased]`
+- On release: Move `[Unreleased]` → `[2.11.1] - YYYY-MM-DD`
+
+### Manual Version (Override)
+```bash
+--version "3.0.0"  # Specify major/minor bump explicitly
+```
+
+### Release Workflow
+1. Agents add entries to `[Unreleased]` section
+2. On release trigger (manual or automated):
+   - Rename `[Unreleased]` → `[X.Y.Z] - DATE`
+   - Create new empty `[Unreleased]` section
+   - Update `package.json` version
+
+## Query Interface
+
+**Filter by type:**
+```bash
+sed -n '/### Features/,/### Bug Fixes/p' readme/CHANGELOG.md
+```
+
+**Recent entries (last 10):**
+```bash
+grep -A 2 "^- " readme/CHANGELOG.md | head -30
+```
+
+**Search by keyword:**
+```bash
+grep -i "redis" readme/CHANGELOG.md
+```
+
+**Entries for specific version:**
+```bash
+sed -n '/## \[2.11.0\]/,/## \[2.10.0\]/p' readme/CHANGELOG.md
+```
+
+## Best Practices
+
+1. **Immediate logging**: Add entry immediately after completing work, not batched
+2. **User perspective**: Describe impact from user/agent consumer viewpoint
+3. **File references**: Include key files for context (not exhaustive list)
+4. **Link issues**: Reference bug numbers or GitHub issues when applicable
+5. **Migration notes**: Always include for breaking changes
+
+## Anti-Patterns
+
+❌ **Verbose commit messages**: "This commit implements a new feature that..."
+❌ **Generic summaries**: "Fixed bugs", "Updated code", "Improvements"
+❌ **Missing impact**: "Added function X" (Why does it matter?)
+❌ **Duplicate entries**: Check existing changelog before adding
+❌ **Version conflicts**: Don't manually edit version, use --version flag
+
+## Example Entry Lifecycle
+
+**Step 1: Agent completes feature**
+```bash
+add-changelog-entry.sh \
+  --type "feature" \
+  --summary "Multi-pattern confidence parsing" \
+  --impact "100% extraction success, supports explicit/percentage/qualitative formats"
+```
+
+**Result in CHANGELOG.md:**
+```markdown
+## [Unreleased]
+
+### Features
+- Multi-pattern confidence parsing (2025-10-31)
+  - Impact: 100% extraction success, supports explicit/percentage/qualitative formats
+  - Files: `.claude/skills/cfn-agent-output-processing/parse-confidence.sh`
+```
+
+**Step 2: Release triggered**
+```bash
+# Manual or automated
+npm version minor  # 2.11.0 → 2.12.0
+```
+
+**Result:**
+```markdown
+## [2.12.0] - 2025-11-01
+
+### Features
+- Multi-pattern confidence parsing (2025-10-31)
+  - Impact: 100% extraction success, supports explicit/percentage/qualitative formats
+  - Files: `.claude/skills/cfn-agent-output-processing/parse-confidence.sh`
+
+---
+
+## [Unreleased]
+
+### Features
+
+### Bug Fixes
+...
+```
+
+## Success Metrics
+
+- **Entry quality**: ≥90% of entries include measurable impact
+- **Sparse language**: Average summary length ≤60 characters
+- **Timeliness**: ≥80% of entries added within same sprint as implementation
+- **Coverage**: 100% of features/breaking changes documented
+- **Queryability**: Users can find relevant changes in <30 seconds
+
+## References
+
+- **Sparse Language**: readme/CLAUDE.md - Documentation Guidelines
+- **Backlog Management**: `.claude/skills/cfn-backlog-management/SKILL.md`
+- **Versioning**: `package.json` - Single source of truth