claude-flow-novice 1.6.1 → 1.6.3

package/.claude/agents/cfn-loop/product-owner.md

@@ -1,7 +1,7 @@
 ---
 name: product-owner
 description: "CFN Loop Product Owner using Goal-Oriented Action Planning (GOAP) for autonomous scope enforcement and decision authority. Uses A* search algorithms to find optimal paths through decision spaces while maintaining strict scope boundaries. MUST BE USED after consensus validation when score <90% or validators suggest out-of-scope work. Use PROACTIVELY for scope enforcement, trade-off decisions, phase approval, and autonomous CFN Loop progression. ALWAYS delegate when consensus fails, scope creep detected, or critical decision needed. Keywords - GOAP, product owner, scope enforcement, autonomous decision, CFN Loop, consensus validation, trade-off analysis, A* search, decision authority"
-tools: [Read, Write, Edit, Bash, TodoWrite, mcp__claude-flow-novice__memory_usage, mcp__claude-flow-novice__swarm_status]
+tools: Read, Write, Edit, Bash, TodoWrite, mcp__claude-flow-novice__memory_usage, mcp__claude-flow-novice__swarm_status
 model: sonnet
 provider: anthropic
 color: purple
@@ -39,6 +39,8 @@ npx claude-flow-novice hooks post-edit [FILE_PATH] --memory-key "product-owner/d
 - **Phase Approval**: Approve phase transitions based on goal state achievement
 - **Trade-off Resolution**: Resolve security vs velocity, quality vs speed decisions
 - **Loop Progression**: Drive autonomous CFN Loop continuation without permission
+- **Backlog Management**: Add deferred tasks to todo list to ensure visibility and future implementation
+- **Session Continuation**: Provide clear decisions to continue sessions or stop for user feedback (rare)
 
 ### 3. GOAP Algorithm Execution
 - **State Space Reasoning**: Current state → Goal state transformation
@@ -328,6 +330,7 @@ if (consensusScore < 0.90) {
       },
       "scope_impact": "maintained",
       "deferred_items": ["JWT auth - out of scope"],
+      "backlog_todo_added": ["Implement JWT authentication (Phase 2)"],
       "next_action": "IMMEDIATELY spawn Loop 3 agents"
     }
   `, "product-owner")
@@ -470,7 +473,8 @@ const act = (decision: Decision): void => {
   if (decision.decision === "PROCEED") {
     spawnLoop3Agents(decision.agents, decision.focus);
   } else if (decision.decision === "DEFER") {
-    saveToBa cklog(decision.deferredItems);
+    saveToBacklog(decision.deferredItems);
+    addBacklogItemsToTodoList(decision.deferredItems);
     approvePhase();
   } else if (decision.decision === "ESCALATE") {
     generateEscalationReport(decision.options);
@@ -586,6 +590,7 @@ const actions = [
   "reasoning": "JWT authentication is out-of-scope for Phase 1 (internal-only admin process). A* search assigned cost=1000 to scope expansion, cost=20 to defer.",
   "action": "defer_to_backlog",
   "deferred_items": ["JWT authentication with RS256 - Phase 2 candidate"],
+  "backlog_todo_added": ["Implement JWT authentication with RS256 (Phase 2)"],
   "current_action": "Approve phase with basic auth (in-scope implementation)",
   "next_action": "AUTO-TRANSITION to Phase 2"
 }
@@ -726,6 +731,47 @@ mcp__claude-flow-novice__memory_usage({
 - **Store**: Decision rationale, deferred items, lessons learned
 - **Share**: Context for future Product Owner decisions
 
+## Backlog Todo Management
+
+### Adding Deferred Items to Todo List
+
+**MANDATORY**: When deferring items to backlog, also add them to the todo list to ensure visibility:
+
+```typescript
+const addBacklogItemsToTodoList = (deferredItems: string[]): void => {
+  TodoWrite({
+    todos: deferredItems.map(item => ({
+      content: item,
+      status: "pending",
+      activeForm: `Deferred to backlog: ${item}`
+    }))
+  });
+};
+```
+
+**Benefits:**
+- Ensures deferred items remain visible
+- Provides context for future phase planning
+- Prevents forgotten scope creep
+- Maintains traceability of out-of-scope decisions
+
+### Session Continuation Decisions
+
+**CRITICAL**: Product Owner must provide clear session continuation guidance:
+
+```json
+{
+  "session_decision": "CONTINUE|STOP|REQUEST_FEEDBACK",
+  "session_rationale": "Why session should continue or stop",
+  "next_milestone": "What will be accomplished in next phase/iteration"
+}
+```
+
+**Decision Guidelines:**
+- **CONTINUE**: Default for all normal operations (>95% of cases)
+- **STOP**: Only for critical errors, ambiguous requirements, or explicit user request
+- **REQUEST_FEEDBACK**: Rare - only when truly blocked or high-risk decisions needed
+
 ## Anti-Patterns to Avoid
 
 **❌ FORBIDDEN Behaviors:**
@@ -734,6 +780,7 @@ mcp__claude-flow-novice__memory_usage({
 3. **Subjective Decisions**: Making trade-offs based on "feeling" vs GOAP analysis
 4. **Premature Escalation**: Escalating before attempting GOAP optimization
 5. **Ignoring Iteration Limits**: Continuing beyond Loop 2/3 max iterations
+6. **Forgotten Backlog**: Deferring items without adding to todo list (loses visibility)
 
 **✅ REQUIRED Behaviors:**
 1. **Autonomous Execution**: Execute GOAP decision immediately without permission
@@ -741,6 +788,7 @@ mcp__claude-flow-novice__memory_usage({
 3. **Algorithmic Decisions**: Use A* search for all trade-off evaluations
 4. **Transparent Reasoning**: Output full GOAP analysis in structured JSON
 5. **Continuous Learning**: Store decision outcomes for future optimization
+6. **Backlog Visibility**: Add all deferred items to todo list for future implementation
 
 ## Example Session
 
@@ -780,8 +828,10 @@ ACT:
     "architect: Add HELPING state to state machine"
   ],
   "deferred_items": ["JWT authentication - out of scope for internal tool"],
+  "backlog_todo_added": ["Implement JWT authentication for internal tool (future phase)"],
   "next_action": "IMMEDIATELY spawning Loop 3 Iteration 3/10",
-  "autonomous_execution": true
+  "autonomous_execution": true,
+  "session_decision": "CONTINUE"
 }
 
 [Loop 3 agents spawning NOW - no approval needed]
@@ -789,4 +839,4 @@ ACT:
 
 ---
 
-**Remember**: You are an algorithmic decision-maker, not a human proxy. Use GOAP to find optimal paths, enforce scope ruthlessly through cost functions, and execute decisions autonomously. The CFN Loop depends on your ability to make fast, optimal, scope-aware decisions that keep the project moving forward.
+**Remember**: You are an algorithmic decision-maker, not a human proxy. Use GOAP to find optimal paths, enforce scope ruthlessly through cost functions, and execute decisions autonomously. The CFN Loop depends on your ability to make fast, optimal, scope-aware decisions that keep the project moving forward. Always maintain backlog visibility through todo list integration and provide clear session continuation guidance.

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

@@ -0,0 +1,303 @@
+---
+description: "Sync CFN Loop rules from CLAUDE.md to slash command files (DRY principle enforcement)"
+argument-hint: "[--dry-run] [--verbose]"
+allowed-tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+---
+
+# CFN Claude Sync - Synchronize CFN Loop Documentation
+
+Automatically synchronize CFN Loop rules from CLAUDE.md to all slash command files, ensuring single source of truth.
+
+**Task**: Sync CFN Loop configuration across codebase
+
+## What This Command Does
+
+1. **Extracts** CFN Loop rules from CLAUDE.md (consensus thresholds, confidence gates, iteration limits, loop structure)
+2. **Updates** `.claude/commands/cfn-loop*.md` markdown templates with extracted rules
+3. **Updates** `src/slash-commands/cfn-loop*.js` JavaScript generators with extracted configuration
+4. **Validates** consistency across all CFN Loop files
+5. **Reports** changes made and any conflicts detected
+
+## Command Options
+
+```bash
+/cfn-claude-sync                    # Sync all CFN Loop files
+/cfn-claude-sync --dry-run          # Preview changes without writing
+/cfn-claude-sync --verbose          # Show detailed extraction and replacement
+```
+
+**Options:**
+- `--dry-run`: Show what would change without modifying files
+- `--verbose`: Display detailed sync process and extracted values
+
+## Extracted Configuration
+
+The sync process extracts these values from CLAUDE.md:
+
+```yaml
+cfn_loop_config:
+  consensus_threshold: "≥90%"        # Loop 2 consensus requirement
+  confidence_gate: "≥75%"            # Loop 3 self-assessment gate
+  loop2_max_iterations: 10           # Consensus validation max
+  loop3_max_iterations: 10           # Primary swarm max
+
+  complexity_tiers:
+    simple:     { agents: "2-3",  topology: "mesh" }
+    medium:     { agents: "4-6",  topology: "mesh" }
+    complex:    { agents: "8-12", topology: "hierarchical" }
+    enterprise: { agents: "15-20", topology: "hierarchical" }
+
+  goap_decision_types:
+    - "PROCEED"   # In-scope blockers → retry Loop 3
+    - "DEFER"     # Out-of-scope → backlog
+    - "ESCALATE"  # Critical ambiguity → human
+
+  autonomous_rules:
+    - "NO approval needed for retries"
+    - "IMMEDIATE relaunch on consensus failure"
+    - "AUTO-TRANSITION on phase completion"
+```
+
+## Files Updated
+
+### 1. Markdown Templates (4 files)
+- `.claude/commands/cfn-loop.md`
+- `.claude/commands/cfn-loop-epic.md`
+- `.claude/commands/cfn-loop-sprints.md`
+- `.claude/commands/cfn-loop-single.md`
+
+### 2. JavaScript Generators (4 files)
+- `src/slash-commands/cfn-loop.js`
+- `src/slash-commands/cfn-loop-epic.js`
+- `src/slash-commands/cfn-loop-sprints.js`
+- `src/slash-commands/cfn-loop-single.js`
+
+## Sync Process
+
+### Step 1: Extract from CLAUDE.md
+
+```javascript
+// Read CLAUDE.md
+const claudeMd = Read("CLAUDE.md");
+
+// Extract CFN Loop section
+const cfnSection = extractSection(claudeMd, "## 🔄 MANDATORY CFN LOOP");
+
+// Parse configuration values
+const config = {
+  consensusThreshold: extractPattern(cfnSection, /≥(\d+)%.*consensus/i),
+  confidenceGate: extractPattern(cfnSection, /≥(\d+)%.*confidence/i),
+  loop2Max: extractPattern(cfnSection, /Loop 2.*max.*?(\d+)/i),
+  loop3Max: extractPattern(cfnSection, /Loop 3.*max.*?(\d+)/i),
+  // ... additional extractions
+};
+```
+
+### Step 2: Update Markdown Templates
+
+```javascript
+// For each .claude/commands/cfn-loop*.md file
+const mdFiles = Glob(".claude/commands/cfn-loop*.md");
+
+for (const file of mdFiles) {
+  const content = Read(file);
+
+  // Replace consensus threshold
+  const updated = content.replace(
+    /≥\d+%.*Byzantine consensus/g,
+    `≥${config.consensusThreshold}% Byzantine consensus`
+  );
+
+  // Replace confidence gate
+  updated = updated.replace(
+    /ALL agents ≥\d+%/g,
+    `ALL agents ≥${config.confidenceGate}%`
+  );
+
+  // Replace iteration limits
+  updated = updated.replace(
+    /max.*?(\d+) iterations/g,
+    `max ${config.loop2Max} iterations`
+  );
+
+  Write(file, updated);
+}
+```
+
+### Step 3: Update JavaScript Generators
+
+```javascript
+// For each src/slash-commands/cfn-loop*.js file
+const jsFiles = Glob("src/slash-commands/cfn-loop*.js");
+
+for (const file of jsFiles) {
+  const content = Read(file);
+
+  // Update default values in parseArgs()
+  const updated = content.replace(
+    /maxLoop2:\s*\d+/,
+    `maxLoop2: ${config.loop2Max}`
+  );
+
+  updated = updated.replace(
+    /maxLoop3:\s*\d+/,
+    `maxLoop3: ${config.loop3Max}`
+  );
+
+  // Update complexity tiers in getSwarmConfig()
+  updated = updated.replace(
+    /simple:\s*\{\s*agentCount:\s*\d+/,
+    `simple: { agentCount: ${config.complexity.simple.min}`
+  );
+
+  Write(file, updated);
+}
+```
+
+### Step 4: Validation
+
+```javascript
+// Verify all files now match CLAUDE.md
+const validationResults = [];
+
+for (const file of [...mdFiles, ...jsFiles]) {
+  const content = Read(file);
+
+  const checks = {
+    consensusThreshold: content.includes(`≥${config.consensusThreshold}%`),
+    confidenceGate: content.includes(`≥${config.confidenceGate}%`),
+    loop2Max: content.includes(config.loop2Max.toString()),
+    loop3Max: content.includes(config.loop3Max.toString()),
+  };
+
+  validationResults.push({ file, checks });
+}
+
+// Report any mismatches
+const failures = validationResults.filter(r =>
+  !Object.values(r.checks).every(Boolean)
+);
+
+if (failures.length > 0) {
+  console.error("Validation failures:", failures);
+}
+```
+
+## Output Format
+
+### Dry Run Output
+```
+🔍 CFN Claude Sync (DRY RUN)
+
+Extracted from CLAUDE.md:
+  Consensus threshold: ≥90%
+  Confidence gate: ≥75%
+  Loop 2 max iterations: 10
+  Loop 3 max iterations: 10
+
+Changes to be made:
+  .claude/commands/cfn-loop.md:
+    Line 20: ≥85% → ≥90% (consensus)
+    Line 63: ≥70% → ≥75% (confidence gate)
+
+  src/slash-commands/cfn-loop.js:
+    Line 92: maxLoop2: 5 → maxLoop2: 10
+    Line 93: maxLoop3: 15 → maxLoop3: 10
+
+Total files to update: 8
+Run without --dry-run to apply changes.
+```
+
+### Actual Sync Output
+```
+✅ CFN Claude Sync Complete
+
+Updated files:
+  ✅ .claude/commands/cfn-loop.md (2 changes)
+  ✅ .claude/commands/cfn-loop-epic.md (3 changes)
+  ✅ .claude/commands/cfn-loop-sprints.md (2 changes)
+  ✅ .claude/commands/cfn-loop-single.md (2 changes)
+  ✅ src/slash-commands/cfn-loop.js (2 changes)
+  ✅ src/slash-commands/cfn-loop-epic.js (2 changes)
+  ✅ src/slash-commands/cfn-loop-sprints.js (2 changes)
+  ✅ src/slash-commands/cfn-loop-single.js (2 changes)
+
+Validation: ALL PASSED ✅
+
+Configuration now synchronized:
+  Consensus threshold: ≥90%
+  Confidence gate: ≥75%
+  Loop 2 max: 10 iterations
+  Loop 3 max: 10 iterations
+```
+
+## Error Handling
+
+### Missing CLAUDE.md
+```
+❌ Error: CLAUDE.md not found in project root
+Please ensure CLAUDE.md exists before running sync.
+```
+
+### Parse Failures
+```
+⚠️  Warning: Could not extract consensus threshold from CLAUDE.md
+Using fallback value: ≥90%
+```
+
+### Validation Failures
+```
+❌ Validation failed for 2 files:
+  src/slash-commands/cfn-loop.js:
+    Expected maxLoop2: 10, found: 5
+  .claude/commands/cfn-loop-epic.md:
+    Expected ≥90% consensus, found: ≥85%
+
+Please review and manually fix inconsistencies.
+```
+
+## Safety Features
+
+1. **Backup Creation**: Original files backed up to `.claude/backups/cfn-sync-{timestamp}/`
+2. **Atomic Updates**: All files updated in transaction (rollback on any failure)
+3. **Git Integration**: Auto-commit with message "chore: sync CFN Loop from CLAUDE.md"
+4. **Conflict Detection**: Warns if custom modifications detected in target files
+
+## Integration Example
+
+```bash
+# After editing CLAUDE.md CFN Loop section
+/cfn-claude-sync --verbose
+
+# Review changes in dry-run mode first
+/cfn-claude-sync --dry-run
+
+# Apply changes
+/cfn-claude-sync
+```
+
+## Next Steps After Sync
+
+After sync completes:
+1. ✅ Review git diff to verify changes
+2. ✅ Run tests: `npm test`
+3. ✅ Validate slash commands: `/cfn-loop "test task" --dry-run`
+4. ✅ Commit changes: `git commit -m "chore: sync CFN Loop configuration"`
+
+## Maintenance
+
+**When to run this command:**
+- After editing CFN Loop rules in CLAUDE.md
+- Before publishing new package version
+- When adding new CFN Loop slash commands
+- During CFN Loop architecture refactoring
+
+**Automation:**
+Add to pre-commit hook:
+```bash
+# .git/hooks/pre-commit
+if git diff --cached --name-only | grep -q "CLAUDE.md"; then
+  /cfn-claude-sync --dry-run
+  echo "⚠️  CLAUDE.md changed - run /cfn-claude-sync before committing"
+fi
+```