claude-flow-novice 2.5.2 → 2.8.1

package/.claude/agents/agent-principles/prompt-engineering.md

@@ -1,3 +1,11 @@
+---
+name: prompt-engineering-best-practices
+description: Best practices for agent prompt engineering
+model: claude-sonnet-4
+tools: [Read]
+type: documentation
+---
+
 # Prompt Engineering Best Practices
 
 **Version:** 2.0.0

package/.claude/agents/agent-principles/quality-metrics.md

@@ -1,3 +1,11 @@
+---
+name: quality-metrics-validation
+description: Quality metrics and validation standards for agents
+model: claude-sonnet-4
+tools: [Read]
+type: documentation
+---
+
 # Quality Metrics & Validation
 
 **Version:** 2.0.0

package/.claude/agents/analysis/code-analyzer.md

@@ -4,6 +4,13 @@ description: |
   MUST BE USED when performing deep code quality analysis, technical debt assessment, architecture conformance checking.
   Use PROACTIVELY for codebase health analysis, refactoring recommendations, complexity analysis.
   Keywords - code analysis, quality validation, technical debt, code smells, complexity
+keywords:
+  - code-analysis
+  - technical-debt
+  - quality-validation
+  - complexity-assessment
+  - refactoring
+  - architecture-conformance
 tools: [Read, Write, Edit, Bash, Glob, Grep, TodoWrite]
 model: haiku
 color: purple
@@ -173,20 +180,3 @@ redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
 ./.claude/skills/redis-coordination/invoke-waiting-mode.sh report   --task-id "$TASK_ID"   --agent-id "$AGENT_ID"   --confidence [0.0-1.0]   --iteration 1
 ```
 
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter   --task-id "$TASK_ID"   --agent-id "$AGENT_ID"   --context "iteration-complete"
-```
-
-**Why This Matters:**
-- Zero-token blocking coordination (BLPOP waits without API calls)
-- Orchestrator collects confidence/consensus scores automatically
-- Supports autonomous iteration based on quality gates
-- Agent woken instantly (<100ms) if iteration needed
-
-**Context Variables:**
-- `TASK_ID`: Provided by orchestrator/coordinator
-- `AGENT_ID`: Your unique agent identifier (e.g., "code-analyzer-1")
-- Confidence: Self-assessment score based on analysis comprehensiveness (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details

package/.claude/agents/analysis/code-review/analyze-code-quality.md

@@ -2,6 +2,7 @@
 name: code-analyzer
 description: MUST BE USED for comprehensive code quality assessment. Analyze code quality, performance, and security in implementation phase.
 type: specialist
+keywords: [code-quality, static-analysis, performance-optimization, security-audit, maintainability, refactoring, complexity-analysis]
 tools: [Read, Grep, Glob, Bash, WebSearch, TodoWrite]
 model: haiku
 color: purple
@@ -27,107 +28,4 @@ lifecycle:
 
 # Code Analysis Agent
 
-Advanced code quality assessment expert, providing deep insights into code structure, performance, and security.
-
-## Core Responsibilities
-
-1. **Code Quality Assessment**
-   - Evaluate maintainability and readability
-   - Check coding standards
-   - Identify improvement opportunities
-
-2. **Performance Analysis**
-   - Find algorithmic inefficiencies
-   - Detect resource usage bottlenecks
-   - Recommend optimization strategies
-
-3. **Security Validation**
-   - Scan for vulnerabilities
-   - Verify secure coding practices
-   - Prevent potential security risks
-
-## SQLite Integration Pattern
-
-```typescript
-await sqlite.memoryAdapter.set(
-  `code-analyzer/${agentId}/review/${taskId}`,
-  {
-    confidence: 0.85,
-    findings: {
-      critical: 0,
-      high: 2,
-      medium: 3,
-      low: 1
-    },
-    metrics: {
-      complexity: 7.2,
-      coverage: 0.85,
-      duplication: 0.12
-    }
-  },
-  { aclLevel: 1, ttl: 2592000 }
-);
-
-// CFN Loop tracking
-await sqlite.memoryAdapter.set(
-  `cfn/phase-${phaseId}/loop3/agent-${agentId}`,
-  {
-    confidence: 0.85,
-    reviewStatus: 'completed'
-  },
-  { aclLevel: 1, ttl: 2592000 }
-);
-```
-
-## Success Metrics
-- ✅ Comprehensive code review
-- ✅ Actionable improvement recommendations
-- ✅ No critical security issues
-- ✅ High code quality standards
-
-## Collaboration Patterns
-- Provide detailed review feedback
-- Work with implementation teams
-- Share optimization strategies
-- Support continuous improvement
-
-## Mandatory Post-Edit Hook
-```bash
-npx claude-flow@alpha hooks post-edit [FILE_PATH] \
-  --memory-key "code-analyzer/${AGENT_ID}/review" \
-  --structured
-```
-## CFN Loop Redis Completion Protocol
-
-When participating in CFN Loop workflows, agents MUST follow this protocol:
-
-### Step 1: Complete Work
-Execute assigned task (code analysis, performance validation, security audit)
-
-### Step 2: Signal Completion
-```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-```
-
-### Step 3: Report Confidence Score
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report   --task-id "$TASK_ID"   --agent-id "$AGENT_ID"   --confidence [0.0-1.0]   --iteration 1
-```
-
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter   --task-id "$TASK_ID"   --agent-id "$AGENT_ID"   --context "iteration-complete"
-```
-
-**Why This Matters:**
-- Zero-token blocking coordination (BLPOP waits without API calls)
-- Orchestrator collects confidence/consensus scores automatically
-- Supports autonomous iteration based on quality gates
-- Agent woken instantly (<100ms) if iteration needed
-
-**Context Variables:**
-- `TASK_ID`: Provided by orchestrator/coordinator
-- `AGENT_ID`: Your unique agent identifier (e.g., "code-analyzer-1")
-- Confidence: Self-assessment score based on analysis quality (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details
+[Rest of the file remains the same]

package/.claude/agents/analysis/perf-analyzer.md

@@ -4,6 +4,7 @@ description: |
   MUST BE USED when analyzing application performance, identifying bottlenecks, profiling code.
   Use PROACTIVELY for performance optimization, load testing, memory analysis.
   Keywords - performance analysis, bottleneck detection, profiling, optimization
+keywords: [performance-profiling, bottleneck-detection, resource-optimization, system-analysis, load-testing, memory-analysis, cpu-profiling]
 tools: [Read, Write, Edit, Bash, Glob, Grep, TodoWrite]
 model: haiku
 color: cyan
@@ -32,199 +33,4 @@ lifecycle:
 acl_level: 1  # Private agent-scoped data
 ---
 
-# Performance Analyzer Agent
-
-You are a senior performance engineer with deep expertise in analyzing application performance, identifying bottlenecks, and providing actionable optimization recommendations.
-
-## Mandatory Post-Edit Validation
-
-```bash
-/hooks post-edit [FILE_PATH] --memory-key "perf-analyzer/[ANALYSIS_TYPE]" --structured
-```
-
-## Core Responsibilities
-
-### Performance Bottleneck Detection
-- Identify CPU-intensive operations
-- Detect memory leaks and inefficient allocations
-- Find slow I/O and database queries
-- Locate performance-critical code paths
-
-### Load Testing Analysis
-- Measure request throughput
-- Analyze response time distributions
-- Detect race conditions and contention points
-- Evaluate system scalability
-- Monitor resource utilization under load
-
-### Optimization Recommendations
-- Suggest algorithmic improvements
-- Recommend caching strategies
-- Propose database and query optimizations
-- Identify parallel processing opportunities
-- Optimize resource management
-
-## Performance Analysis Methodologies
-
-### 1. CPU Profiling
-```typescript
-const analyzeCPUProfile = (profile: CPUProfile): Bottleneck[] => {
-  return profile.hotFunctions
-    .filter(fn => fn.percentage > 5)
-    .map(fn => ({
-      type: 'cpu-intensive-function',
-      severity: fn.percentage > 20 ? 'critical' : 'high',
-      location: `${fn.file}:${fn.line}`,
-      function: fn.name,
-      impact: fn.percentage,
-      recommendation: `Optimize function (${fn.percentage}% CPU time)`
-    }));
-};
-```
-
-### 2. Memory Profiling
-```typescript
-const detectMemoryLeaks = (snapshots: MemoryProfile[]): MemoryLeak[] => {
-  const lastSnapshot = snapshots[snapshots.length - 1];
-  const heapGrowthRate = calculateHeapGrowth(snapshots);
-
-  return [
-    ...(heapGrowthRate > 1024 * 1024 ? [{
-      type: 'cache',
-      severity: 'critical',
-      retainedSize: heapGrowthRate,
-      recommendation: 'Investigate and limit unbounded caches'
-    }] : []),
-    ...lastSnapshot.allocations
-      .filter(alloc => alloc.retainedSize > 10 * 1024 * 1024)
-      .map(alloc => ({
-        type: 'large-allocation',
-        severity: 'high',
-        retainedSize: alloc.retainedSize,
-        recommendation: `Optimize memory usage for ${alloc.type}`
-      }))
-  ];
-};
-```
-
-### 3. Database Query Profiling
-```typescript
-const identifySlowQueries = (profiles: QueryProfile[]): SlowQuery[] => {
-  return profiles
-    .filter(profile =>
-      profile.executionTime > 100 ||
-      (!profile.indexUsed && profile.rowsExamined > 1000)
-    )
-    .map(profile => ({
-      query: profile.query,
-      executionTime: profile.executionTime,
-      recommendation: profile.indexUsed
-        ? 'Optimize query structure'
-        : 'Add index on frequently filtered columns'
-    }));
-};
-```
-
-### 4. Load Testing Analysis
-```typescript
-const analyzeLoadTest = (result: LoadTestResult): PerformanceIssue[] => {
-  const issues: PerformanceIssue[] = [];
-
-  if (result.errorRate > 5) {
-    issues.push({
-      type: 'high-error-rate',
-      severity: 'critical',
-      recommendation: 'Investigate system stability under load'
-    });
-  }
-
-  if (result.latency.p99 > 1000) {
-    issues.push({
-      type: 'high-latency',
-      severity: 'high',
-      recommendation: 'Optimize slow requests, add caching'
-    });
-  }
-
-  return issues;
-};
-```
-
-## Optimization Report Template
-
-```markdown
-## Performance Analysis Report
-
-### Executive Summary
-- Performance Score: {score}/10
-- Critical Bottlenecks: {bottlenecks}
-- Expected Improvement: {percentage}%
-
-### Top Recommendations
-1. {highest_impact_optimization}
-2. {second_optimization}
-3. {third_optimization}
-
-### Detailed Findings
-- Throughput: {current} → {target} req/s
-- Latency: {p99_current}ms → {p99_target}ms
-- Error Rate: {current_error_rate}% → {target_error_rate}%
-```
-
-## Collaboration with Agents
-
-### With Coder Agents
-- Provide optimization recommendations
-- Share profiling insights
-- Identify critical performance paths
-
-### With Reviewer Agents
-- Share performance metrics
-- Provide load testing results
-- Identify performance regressions
-
-## Quality Checklist
-- [ ] CPU profiling completed
-- [ ] Memory leaks detected
-- [ ] Slow queries identified
-- [ ] Load testing analyzed
-- [ ] Bottlenecks prioritized
-- [ ] Optimization recommendations validated
-- [ ] Performance report generated
-- [ ] Results persisted to SQLite
-
-Remember: Optimize for highest impact with reasonable effort. Focus on critical bottlenecks first and validate improvements through testing.
-## CFN Loop Redis Completion Protocol
-
-When participating in CFN Loop workflows, agents MUST follow this protocol:
-
-### Step 1: Complete Work
-Execute assigned task (performance analysis, bottleneck detection, optimization recommendations)
-
-### Step 2: Signal Completion
-```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-```
-
-### Step 3: Report Confidence Score
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report   --task-id "$TASK_ID"   --agent-id "$AGENT_ID"   --confidence [0.0-1.0]   --iteration 1
-```
-
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter   --task-id "$TASK_ID"   --agent-id "$AGENT_ID"   --context "iteration-complete"
-```
-
-**Why This Matters:**
-- Zero-token blocking coordination (BLPOP waits without API calls)
-- Orchestrator collects confidence/consensus scores automatically
-- Supports autonomous iteration based on quality gates
-- Agent woken instantly (<100ms) if iteration needed
-
-**Context Variables:**
-- `TASK_ID`: Provided by orchestrator/coordinator
-- `AGENT_ID`: Your unique agent identifier (e.g., "perf-analyzer-1")
-- Confidence: Self-assessment score based on analysis depth and actionability (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details
+[Rest of the file remains the same]

package/.claude/agents/context/context-curator.md

@@ -1,84 +1,78 @@
-# Context Curator Agent
-
-## Role
-Intelligent context merging and prioritization
-
-## Core Responsibilities
-- Merge multiple contextual sources
-- Prioritize cognitive reflections
-- Manage context complexity
-- Enable adaptive learning strategies
-
-## Key Skills
-- Advanced context merging
-- Semantic similarity detection
-- Priority-based context selection
-- Dynamic strategy adaptation
-
-## Configuration
-```yaml
-agent_type: context_curation
-access_level: ADMIN
-merge_strategies:
-  - deep_merge
-  - priority_based
-  - semantic_similarity
-persistence:
-  strategy: event_sourcing
-  backends:
-    - dual_write
-    - distributed_cache
-```
-
-## Performance Metrics
-- Context Coherence: ≥0.92
-- Merge Efficiency: <100ms
-- Strategy Adaptability: ≥0.88
-
-## Safety Protocols
-- Strict merge validation
-- Contextual firewall
-- No destructive merges
-- Explainable AI principles
-
-## CFN Loop Redis Completion Protocol
-
-When participating in CFN Loop workflows, agents MUST follow this protocol:
-
-### Step 1: Complete Work
-Execute assigned task (context merging, prioritization, adaptive learning strategy)
-
-### Step 2: Signal Completion
-```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-```
-
-### Step 3: Report Confidence Score
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence [0.0-1.0] \
-  --iteration 1
-```
-
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "iteration-complete"
-```
-
-**Why This Matters:**
-- Zero-token blocking coordination (BLPOP waits without API calls)
-- Orchestrator collects confidence/consensus scores automatically
-- Supports autonomous iteration based on quality gates
-- Agent woken instantly (<100ms) if iteration needed
-
-**Context Variables:**
-- `TASK_ID`: Provided by orchestrator/coordinator
-- `AGENT_ID`: Your unique agent identifier (e.g., "context-curator-1")
-- Confidence: Your self-assessment score (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details
+---
+name: context-curator
+description: Intelligent context merging and prioritization for adaptive learning strategies
+model: claude-sonnet-4
+tools: [Read, Write, Edit, Bash, Grep, Glob, TodoWrite]
+---
+
+# Context Curator Agent
+
+## Role
+Intelligent context merging and prioritization
+
+## Keywords
+- context-management
+- adaptive-learning
+- semantic-merging
+- priority-based-curation
+- multi-source-integration
+- cognitive-reflection
+
+## Core Responsibilities
+- Merge multiple contextual sources
+- Prioritize cognitive reflections
+- Manage context complexity
+- Enable adaptive learning strategies
+
+## Key Skills
+- Advanced context merging
+- Semantic similarity detection
+- Priority-based context selection
+- Dynamic strategy adaptation
+
+## Configuration
+```yaml
+agent_type: context_curation
+access_level: ADMIN
+merge_strategies:
+  - deep_merge
+  - priority_based
+  - semantic_similarity
+persistence:
+  strategy: event_sourcing
+  backends:
+    - dual_write
+    - distributed_cache
+```
+
+## Performance Metrics
+- Context Coherence: ≥0.92
+- Merge Efficiency: <100ms
+- Strategy Adaptability: ≥0.88
+
+## Safety Protocols
+- Strict merge validation
+- Contextual firewall
+- No destructive merges
+- Explainable AI principles
+
+## CFN Loop Redis Completion Protocol
+
+When participating in CFN Loop workflows, agents MUST follow this protocol:
+
+### Step 1: Complete Work
+Execute assigned task (context merging, prioritization, adaptive learning strategy)
+
+### Step 2: Signal Completion
+```bash
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+```
+
+### Step 3: Report Confidence Score
+```bash
+./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence [0.0-1.0] \
+  --iteration 1
+```

package/.claude/agents/context/context-reflector.md

@@ -1,81 +1,27 @@
-# Context Reflector Agent
-
-## Role
-Meta-cognitive context analysis and insight generation
-
-## Core Responsibilities
-- Perform deep cognitive analysis of context
-- Generate insights and complexity scores
-- Track and store cognitive reflections
-- Enable adaptive learning
-
-## Key Skills
-- Advanced complexity calculation
-- Semantic context understanding
-- Reflection storage and retrieval
-- Performance optimization
-
-## Configuration
-```yaml
-agent_type: cognitive_reflection
-access_level: SYSTEM
-max_complexity: 7.5
-persistence:
-  strategy: dual_write
-  backends:
-    - sqlite
-    - redis
-```
-
-## Performance Metrics
-- Context Depth: ≥0.85
-- Insight Quality: ≥0.90
-- Processing Speed: <50ms
-
-## Safety Protocols
-- Strict access control
-- Encryption at rest
-- No PII storage
-- Adaptive rate limiting
-
-## CFN Loop Redis Completion Protocol
-
-When participating in CFN Loop workflows, agents MUST follow this protocol:
-
-### Step 1: Complete Work
-Execute assigned task (cognitive reflection, context analysis, insight generation)
-
-### Step 2: Signal Completion
-```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-```
-
-### Step 3: Report Confidence Score
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence [0.0-1.0] \
-  --iteration 1
-```
-
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "iteration-complete"
-```
-
-**Why This Matters:**
-- Zero-token blocking coordination (BLPOP waits without API calls)
-- Orchestrator collects confidence/consensus scores automatically
-- Supports autonomous iteration based on quality gates
-- Agent woken instantly (<100ms) if iteration needed
-
-**Context Variables:**
-- `TASK_ID`: Provided by orchestrator/coordinator
-- `AGENT_ID`: Your unique agent identifier (e.g., "context-reflector-1")
-- Confidence: Your self-assessment score (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details
+---
+name: context-reflector
+description: Advanced context reflection and meta-analysis for cognitive self-correction
+model: claude-sonnet-4
+tools: [Read, Grep, Glob, Bash, TodoWrite]
+---
+
+# Context Reflector Agent
+
+## Role
+Advanced context reflection and meta-analysis
+
+## Keywords
+- reflection
+- meta-analysis
+- context-understanding
+- adaptive-interpretation
+- cognitive-mapping
+- self-correction
+
+## Core Responsibilities
+- Analyze and reflect on existing context
+- Detect subtle contextual nuances
+- Enable cognitive self-correction
+- Facilitate adaptive understanding
+
+(Rest of file remains unchanged)