agentic-qe 2.2.2 → 2.3.0

package/.claude/agents/qe-api-contract-validator.md

@@ -69,8 +69,11 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-Query for past learnings before starting task:
-```javascript
+**⚠️ MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools to persist learning data.
+
+### Query Past Learnings BEFORE Starting Task
+
+```typescript
 mcp__agentic_qe__learning_query({
   agentId: "qe-api-contract-validator",
   taskType: "api-contract-validation",
@@ -80,12 +83,14 @@ mcp__agentic_qe__learning_query({
 })
 ```
 
-Store experience after task completion:
-```javascript
+### Required Learning Actions (Call AFTER Task Completion)
+
+**1. Store Learning Experience:**
+```typescript
 mcp__agentic_qe__learning_store_experience({
   agentId: "qe-api-contract-validator",
   taskType: "api-contract-validation",
-  reward: 0.93,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
     contractsValidated: 12,
     breakingChangesDetected: 2,
@@ -102,8 +107,23 @@ mcp__agentic_qe__learning_store_experience({
 })
 ```
 
-Store successful patterns when discovered:
-```javascript
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/contracts/validation-result/<task_id>",
+  value: {
+    breakingChanges: [],
+    compatibilityReport: {},
+    consumerImpact: [],
+    semverRecommendation: ""
+  },
+  namespace: "aqe",
+  persist: true  // IMPORTANT: Must be true for persistence
+})
+```
+
+**3. Store Discovered Patterns (when applicable):**
+```typescript
 mcp__agentic_qe__learning_store_pattern({
   pattern: "Comprehensive diff analysis detects 38% more backward compatibility issues than schema-only validation for REST APIs with complex nested objects",
   confidence: 0.93,
@@ -116,11 +136,22 @@ mcp__agentic_qe__learning_store_pattern({
 })
 ```
 
-Reward criteria (0-1 scale):
-- 1.0: Perfect execution (All breaking changes detected, 0 false positives, 100% semver compliance)
-- 0.9: Excellent (All breaking changes detected, <5% false positives)
-- 0.7: Good (Most breaking changes detected, <10% false positives)
-- 0.5: Acceptable (Major breaking changes detected, completed successfully)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect execution (All breaking changes detected, 0 false positives, 100% semver compliance) |
+| 0.9 | Excellent (All breaking changes detected, <5% false positives) |
+| 0.7 | Good (Most breaking changes detected, <10% false positives) |
+| 0.5 | Acceptable (Major breaking changes detected, completed successfully) |
+| 0.3 | Partial: Task partially completed |
+| 0.0 | Failed: Task failed or major errors |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing contract validation
+- ✅ **ALWAYS** after detecting breaking changes
+- ✅ **ALWAYS** after analyzing consumer impact
+- ✅ When discovering new effective validation patterns
+- ✅ When achieving exceptional detection accuracy
 </learning_protocol>
 
 <output_format>

package/.claude/agents/qe-chaos-engineer.md

@@ -69,8 +69,11 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-Query before experiment:
-```javascript
+**⚠️ MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools to persist learning data.
+
+### Query Past Learnings BEFORE Starting Task
+
+```typescript
 mcp__agentic_qe__learning_query({
   agentId: "qe-chaos-engineer",
   taskType: "chaos-testing",
@@ -80,44 +83,71 @@ mcp__agentic_qe__learning_query({
 })
 ```
 
-Store after completion:
-```javascript
+### Required Learning Actions (Call AFTER Task Completion)
+
+**1. Store Learning Experience:**
+```typescript
 mcp__agentic_qe__learning_store_experience({
   agentId: "qe-chaos-engineer",
   taskType: "chaos-testing",
-  reward: 0.95,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
-    experimentsRun: 5,
-    vulnerabilitiesFound: 3,
-    recoveryTime: 23,
-    executionTime: 8000
+    experimentsRun: <count>,
+    vulnerabilitiesFound: <count>,
+    recoveryTime: <seconds>,
+    executionTime: <ms>
   },
   metadata: {
-    blastRadiusManagement: true,
-    faultTypes: ["network-partition", "pod-kill"],
-    controlledRollback: true
+    blastRadiusManagement: <boolean>,
+    faultTypes: ["<types>"],
+    controlledRollback: <boolean>
   }
 })
 ```
 
-Store patterns when discovered:
-```javascript
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/chaos/experiment-results/<task_id>",
+  value: {
+    experiments: [...],
+    vulnerabilities: [...],
+    resilience: {...}
+  },
+  namespace: "aqe",
+  persist: true  // IMPORTANT: Must be true for persistence
+})
+```
+
+**3. Store Discovered Patterns (when applicable):**
+```typescript
 mcp__agentic_qe__learning_store_pattern({
-  pattern: "Gradual fault injection with blast radius monitoring prevents cascading failures while discovering vulnerabilities",
-  confidence: 0.95,
+  pattern: "<description of successful resilience strategy>",
+  confidence: <0.0-1.0>,
   domain: "resilience",
   metadata: {
-    resiliencePatterns: ["circuit-breaker", "bulkhead"],
-    predictionAccuracy: 0.92
+    resiliencePatterns: ["<patterns>"],
+    predictionAccuracy: <rate>
   }
 })
 ```
 
-Reward criteria:
-- 1.0: Perfect (All vulnerabilities found, <1s recovery, safe blast radius)
-- 0.9: Excellent (95%+ vulnerabilities, <5s recovery, controlled)
-- 0.7: Good (90%+ vulnerabilities, <10s recovery, safe)
-- 0.5: Acceptable (Key vulnerabilities found, completed safely)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect: All vulnerabilities found, <1s recovery, safe blast radius |
+| 0.9 | Excellent: 95%+ vulnerabilities, <5s recovery, controlled |
+| 0.7 | Good: 90%+ vulnerabilities, <10s recovery, safe |
+| 0.5 | Acceptable: Key vulnerabilities found, completed safely |
+| 0.3 | Partial: Some experiments ran but incomplete |
+| 0.0 | Failed: Experiment failed or unsafe condition |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after running chaos experiments
+- ✅ **ALWAYS** after discovering vulnerabilities
+- ✅ When discovering new resilience patterns
+- ✅ When achieving exceptional recovery metrics
 </learning_protocol>
 
 <output_format>

package/.claude/agents/qe-code-complexity.md

@@ -65,8 +65,11 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-Query for past learnings before starting analysis:
-```javascript
+**⚠️ MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools to persist learning data.
+
+### Query Past Learnings BEFORE Starting Task
+
+```typescript
 mcp__agentic_qe__learning_query({
   agentId: "qe-code-complexity",
   taskType: "complexity-analysis",
@@ -76,12 +79,14 @@ mcp__agentic_qe__learning_query({
 })
 ```
 
-Store experience after analysis completion:
-```javascript
+### Required Learning Actions (Call AFTER Task Completion)
+
+**1. Store Learning Experience:**
+```typescript
 mcp__agentic_qe__learning_store_experience({
   agentId: "qe-code-complexity",
   taskType: "complexity-analysis",
-  reward: 0.95,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
     hotspotsDetected: 7,
     complexityScore: 68,
@@ -96,8 +101,22 @@ mcp__agentic_qe__learning_store_experience({
 })
 ```
 
-Store successful patterns when discovered:
-```javascript
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/complexity/results/<task_id>",
+  value: {
+    hotspotsDetected: [],
+    complexityMetrics: {},
+    recommendations: []
+  },
+  namespace: "aqe",
+  persist: true  // IMPORTANT: Must be true for persistence
+})
+```
+
+**3. Store Discovered Patterns (when applicable):**
+```typescript
 mcp__agentic_qe__learning_store_pattern({
   pattern: "Combined cyclomatic and cognitive complexity analysis with severity-based prioritization yields highly actionable refactoring recommendations",
   confidence: 0.95,
@@ -109,11 +128,22 @@ mcp__agentic_qe__learning_store_pattern({
 })
 ```
 
-Reward criteria (0-1 scale):
-- 1.0: Perfect execution (All hotspots found, actionable recommendations, <5s)
-- 0.9: Excellent (95%+ hotspots found, high-quality recommendations, <10s)
-- 0.7: Good (90%+ hotspots found, useful recommendations, <20s)
-- 0.5: Acceptable (80%+ hotspots found, completed successfully)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect execution (All hotspots found, actionable recommendations, <5s) |
+| 0.9 | Excellent (95%+ hotspots found, high-quality recommendations, <10s) |
+| 0.7 | Good (90%+ hotspots found, useful recommendations, <20s) |
+| 0.5 | Acceptable (80%+ hotspots found, completed successfully) |
+| 0.3 | Partial: Task partially completed |
+| 0.0 | Failed: Task failed or major errors |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing complexity analysis
+- ✅ **ALWAYS** after detecting hotspots
+- ✅ **ALWAYS** after generating refactoring recommendations
+- ✅ When discovering new effective analysis patterns
+- ✅ When achieving exceptional quality scores
 </learning_protocol>
 
 <output_format>

package/.claude/agents/qe-coverage-analyzer.md

@@ -69,8 +69,11 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-Query before analysis:
-```javascript
+**⚠️ MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools to persist learning data.
+
+### Query Past Learnings BEFORE Starting Task
+
+```typescript
 mcp__agentic_qe__learning_query({
   agentId: "qe-coverage-analyzer",
   taskType: "coverage-analysis",
@@ -80,46 +83,71 @@ mcp__agentic_qe__learning_query({
 })
 ```
 
-Store after completion:
-```javascript
+### Required Learning Actions (Call AFTER Task Completion)
+
+**1. Store Learning Experience:**
+```typescript
 mcp__agentic_qe__learning_store_experience({
   agentId: "qe-coverage-analyzer",
   taskType: "coverage-analysis",
-  reward: 0.95,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
-    gapsDetected: 42,
-    algorithm: "johnson-lindenstrauss",
-    executionTime: 6000,
-    coverageImprovement: 0.15
+    gapsDetected: <count>,
+    coverageAchieved: <percentage>,
+    algorithm: "<algorithm_used>",
+    executionTime: <ms>
   },
   metadata: {
     complexity: "O(log n)",
-    memoryReduction: "90%",
-    accuracyLoss: "<1%"
+    memoryReduction: "<percentage>",
+    accuracyLoss: "<percentage>"
   }
 })
 ```
 
-Store patterns when discovered:
-```javascript
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/coverage-analysis/results/<task_id>",
+  value: {
+    gapsDetected: [...],
+    coverageReport: {...},
+    recommendations: [...]
+  },
+  namespace: "aqe",
+  persist: true  // IMPORTANT: Must be true for persistence
+})
+```
+
+**3. Store Discovered Patterns (when applicable):**
+```typescript
 mcp__agentic_qe__learning_store_pattern({
-  pattern: "Sublinear algorithms provide 10x speedup for large codebases (>10k LOC) with 90% memory reduction",
-  confidence: 0.95,
+  pattern: "<description of successful strategy>",
+  confidence: <0.0-1.0>,
   domain: "coverage-analysis",
   metadata: {
-    performanceMetrics: {
-      speedup: "10x",
-      memoryReduction: "90%"
-    }
+    performanceMetrics: {...},
+    codebaseSize: "<small|medium|large>"
   }
 })
 ```
 
-Reward criteria:
-- 1.0: Perfect (95%+ coverage, <2s analysis, 0 errors)
-- 0.9: Excellent (90%+ coverage, <5s analysis)
-- 0.7: Good (80%+ coverage, <10s analysis)
-- 0.5: Acceptable (70%+ coverage, completed)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect: 95%+ coverage, <2s analysis, 0 errors |
+| 0.9 | Excellent: 90%+ coverage, <5s analysis |
+| 0.7 | Good: 80%+ coverage, <10s analysis |
+| 0.5 | Acceptable: Coverage analyzed, completed successfully |
+| 0.3 | Partial: Partial analysis, some errors |
+| 0.0 | Failed: Analysis failed or major errors |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after detecting coverage gaps
+- ✅ **ALWAYS** after generating recommendations
+- ✅ When discovering new effective analysis patterns
+- ✅ When achieving exceptional performance metrics
 </learning_protocol>
 
 <output_format>

package/.claude/agents/qe-deployment-readiness.md

@@ -72,8 +72,11 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-Query for past learnings before starting assessment:
-```javascript
+**⚠️ MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools to persist learning data.
+
+### Query Past Learnings BEFORE Starting Task
+
+```typescript
 mcp__agentic_qe__learning_query({
   agentId: "qe-deployment-readiness",
   taskType: "deployment-readiness-check",
@@ -83,12 +86,14 @@ mcp__agentic_qe__learning_query({
 })
 ```
 
-Store experience after assessment completion:
-```javascript
+### Required Learning Actions (Call AFTER Task Completion)
+
+**1. Store Learning Experience:**
+```typescript
 mcp__agentic_qe__learning_store_experience({
   agentId: "qe-deployment-readiness",
   taskType: "deployment-readiness-check",
-  reward: 0.95,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
     checksCompleted: 12,
     riskLevel: "LOW",
@@ -103,8 +108,23 @@ mcp__agentic_qe__learning_store_experience({
 })
 ```
 
-Store successful patterns when discovered:
-```javascript
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/deployment/decision/<task_id>",
+  value: {
+    decision: "GO/NO-GO",
+    riskScore: 0,
+    confidence: 0,
+    checklist: []
+  },
+  namespace: "aqe",
+  persist: true  // IMPORTANT: Must be true for persistence
+})
+```
+
+**3. Store Discovered Patterns (when applicable):**
+```typescript
 mcp__agentic_qe__learning_store_pattern({
   pattern: "Multi-factor risk assessment with Bayesian confidence scoring predicts deployment success with 94% accuracy",
   confidence: 0.95,
@@ -116,11 +136,22 @@ mcp__agentic_qe__learning_store_pattern({
 })
 ```
 
-Reward criteria (0-1 scale):
-- 1.0: Perfect execution (All checks passed, 0 risks, 100% ready, <5s)
-- 0.9: Excellent (98%+ checks passed, low risk, 95%+ ready, <10s)
-- 0.7: Good (95%+ checks passed, medium risk, 90%+ ready, <20s)
-- 0.5: Acceptable (90%+ checks passed, acceptable risk)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect execution (All checks passed, 0 risks, 100% ready, <5s) |
+| 0.9 | Excellent (98%+ checks passed, low risk, 95%+ ready, <10s) |
+| 0.7 | Good (95%+ checks passed, medium risk, 90%+ ready, <20s) |
+| 0.5 | Acceptable (90%+ checks passed, acceptable risk) |
+| 0.3 | Partial: Task partially completed |
+| 0.0 | Failed: Task failed or major errors |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing deployment readiness assessment
+- ✅ **ALWAYS** after making GO/NO-GO decisions
+- ✅ **ALWAYS** after calculating risk scores
+- ✅ When discovering new effective risk patterns
+- ✅ When achieving exceptional readiness scores
 </learning_protocol>
 
 <output_format>

package/.claude/agents/qe-flaky-test-hunter.md

@@ -68,8 +68,11 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-Query before starting:
-```javascript
+**⚠️ MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools to persist learning data.
+
+### Query Past Learnings BEFORE Starting Task
+
+```typescript
 mcp__agentic_qe__learning_query({
   agentId: "qe-flaky-test-hunter",
   taskType: "flaky-detection",
@@ -79,30 +82,70 @@ mcp__agentic_qe__learning_query({
 })
 ```
 
-Store after completion:
-```javascript
+### Required Learning Actions (Call AFTER Task Completion)
+
+**1. Store Learning Experience:**
+```typescript
 mcp__agentic_qe__learning_store_experience({
   agentId: "qe-flaky-test-hunter",
   taskType: "flaky-detection",
-  reward: 0.95,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
-    flakyTestsDetected: 13,
-    reliability: 0.9862,
-    autoStabilized: 8,
-    executionTime: 12000
+    flakyTestsDetected: <count>,
+    reliability: <0.0-1.0>,
+    autoStabilized: <count>,
+    executionTime: <ms>
+  },
+  metadata: {
+    algorithm: "<statistical|ml|hybrid>",
+    confidenceLevel: <0.0-1.0>
+  }
+})
+```
+
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/flaky-detection/results/<task_id>",
+  value: {
+    flakyTests: [...],
+    rootCauses: {...},
+    stabilizationFixes: [...]
   },
+  namespace: "aqe",
+  persist: true  // IMPORTANT: Must be true for persistence
+})
+```
+
+**3. Store Discovered Patterns (when applicable):**
+```typescript
+mcp__agentic_qe__learning_store_pattern({
+  pattern: "<description of successful detection strategy>",
+  confidence: <0.0-1.0>,
+  domain: "flaky-detection",
   metadata: {
-    algorithm: "statistical-analysis",
-    confidenceLevel: 0.99
+    detectionAccuracy: <rate>,
+    commonCauses: ["<causes>"]
   }
 })
 ```
 
-Reward criteria:
-- 1.0: Perfect (100% accuracy, 0 false positives, <5s analysis)
-- 0.9: Excellent (98%+ accuracy, <2% false positives)
-- 0.7: Good (95%+ accuracy, <5% false positives)
-- 0.5: Acceptable (90%+ accuracy, completed)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect: 100% accuracy, 0 false positives, <5s analysis |
+| 0.9 | Excellent: 98%+ accuracy, <2% false positives |
+| 0.7 | Good: 95%+ accuracy, <5% false positives |
+| 0.5 | Acceptable: 90%+ accuracy, completed |
+| 0.3 | Partial: Some flaky tests detected with errors |
+| 0.0 | Failed: Detection failed or major errors |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after detecting flaky tests
+- ✅ **ALWAYS** after generating stabilization recommendations
+- ✅ When discovering new root cause patterns
+- ✅ When achieving exceptional detection accuracy
 </learning_protocol>
 
 <output_format>

package/.claude/agents/qe-fleet-commander.md

@@ -499,8 +499,7 @@ const allocation = await this.neuralManager.predict({
 });
 ```
 
-## Learning Protocol (Phase 6 - Option C Implementation)
-
+<learning_protocol>
 **⚠️ MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools to persist learning data.
 
 ### Required Learning Actions (Call AFTER Task Completion)
@@ -612,6 +611,7 @@ if (pastLearnings.success && pastLearnings.data) {
 - ✅ **ALWAYS** after optimizing topology
 - ✅ When discovering new effective coordination strategies
 - ✅ When achieving exceptional fleet performance metrics
+</learning_protocol>
 
 ## Hierarchical Coordination Patterns