agentic-qe 1.5.0 → 1.6.0

package/.claude/agents/qe-production-intelligence.md

@@ -1103,6 +1103,120 @@ const verification = await hookManager.executePreTaskVerification({
 });
 ```
 
+## Learning Protocol (Phase 6 - Option C Implementation)
+
+**⚠️ 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)
+
+**1. Store Learning Experience:**
+```typescript
+// Call this MCP tool after completing your task
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-production-intelligence",
+  taskType: "production-analysis",
+  reward: 0.95,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    // Your actual results (agent-specific)
+    incidentsAnalyzed: 12,
+    testsGenerated: 47,
+    rootCausesFound: 8,
+    executionTime: 12000
+  },
+  metadata: {
+    // Additional context (agent-specific)
+    dataSource: "datadog",
+    analysisDepth: "comprehensive",
+    rumEnabled: true
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-production-intelligence",
+  stateKey: "production-analysis-state",
+  actionKey: "incident-replay",
+  qValue: 0.85,  // Expected value of this approach (based on results)
+  metadata: {
+    // Strategy details (agent-specific)
+    analysisStrategy: "rum-incident-combined",
+    accuracyRate: 0.95,
+    coverage: 0.92
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-production-intelligence",
+  pattern: "Peak hour network failures in specific regions indicate infrastructure capacity issues - correlate with RUM data for comprehensive test generation",
+  confidence: 0.95,  // How confident you are (0-1)
+  domain: "production-intelligence",
+  metadata: {
+    // Pattern context (agent-specific)
+    incidentPatterns: ["network-timeout", "gateway-error", "connection-refused"],
+    predictionAccuracy: 0.93
+  }
+})
+```
+
+### Learning Query (Use at Task Start)
+
+**Before starting your task**, query for past learnings:
+
+```typescript
+// Query for successful experiences
+const pastLearnings = await mcp__agentic_qe__learning_query({
+  agentId: "qe-production-intelligence",
+  taskType: "production-analysis",
+  minReward: 0.8,  // Only get successful experiences
+  queryType: "all",
+  limit: 10
+});
+
+// Use the insights to optimize your current approach
+if (pastLearnings.success && pastLearnings.data) {
+  const { experiences, qValues, patterns } = pastLearnings.data;
+
+  // Find best-performing strategy
+  const bestStrategy = qValues
+    .filter(qv => qv.state_key === "production-analysis-state")
+    .sort((a, b) => b.q_value - a.q_value)[0];
+
+  console.log(`Using learned best strategy: ${bestStrategy.action_key} (Q-value: ${bestStrategy.q_value})`);
+
+  // Check for relevant patterns
+  const relevantPatterns = patterns
+    .filter(p => p.domain === "production-intelligence")
+    .sort((a, b) => b.confidence * b.success_rate - a.confidence * a.success_rate);
+
+  if (relevantPatterns.length > 0) {
+    console.log(`Applying pattern: ${relevantPatterns[0].pattern}`);
+  }
+}
+```
+
+### Success Criteria for Learning
+
+**Reward Assessment (0-1 scale):**
+- **1.0**: Perfect execution (100% incident coverage, root causes identified, <5s analysis)
+- **0.9**: Excellent (95%+ coverage, most root causes found, <10s analysis)
+- **0.7**: Good (90%+ coverage, key root causes found, <20s analysis)
+- **0.5**: Acceptable (80%+ coverage, completed successfully)
+- **<0.5**: Needs improvement (Low coverage, missed root causes, slow)
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after detecting significant findings
+- ✅ **ALWAYS** after generating recommendations
+- ✅ When discovering new effective strategies
+- ✅ When achieving exceptional performance metrics
+
 ## Memory Keys
 
 ### Input Keys

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

@@ -199,6 +199,132 @@ const finalization = await hookManager.executeSessionEndFinalization({
 });
 ```
 
+## Learning Protocol (Phase 6 - Option C Implementation)
+
+**⚠️ 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)
+
+**1. Store Learning Experience:**
+```typescript
+// Call this MCP tool after completing your task
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-quality-analyzer",
+  taskType: "quality-analysis",
+  reward: 0.95,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    // Your actual results (agent-specific)
+    metricsAnalyzed: 47,
+    trendsDetected: 3,
+    recommendations: 12,
+    executionTime: 8500,
+    overallScore: 87.3,
+    codeQuality: 85.2,
+    testQuality: 89.1,
+    technicalDebt: 2.5
+  },
+  metadata: {
+    // Additional context (agent-specific)
+    scope: "full-codebase",
+    metricsCategories: ["code-quality", "test-quality", "technical-debt"],
+    timeframe: "last-30-days",
+    toolsUsed: ["eslint", "sonarqube", "coverage"],
+    analysisDepth: "comprehensive"
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-quality-analyzer",
+  stateKey: "quality-analysis-state",
+  actionKey: "comprehensive-analysis",
+  qValue: 0.85,  // Expected value of this approach (based on results)
+  metadata: {
+    // Strategy details (agent-specific)
+    analysisDepth: "comprehensive",
+    insightQuality: 0.92,
+    actionability: 0.88,
+    toolCombination: ["eslint", "sonarqube", "coverage"],
+    executionTime: 8500
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-quality-analyzer",
+  pattern: "High complexity with low coverage indicates technical debt hotspot requiring immediate refactoring",
+  confidence: 0.95,  // How confident you are (0-1)
+  domain: "quality-metrics",
+  metadata: {
+    // Pattern context (agent-specific)
+    qualityPatterns: ["complexity-coverage-correlation", "debt-hotspot-detection"],
+    predictiveAccuracy: 0.93,
+    detectedIn: "payment.service.ts",
+    complexity: 18.4,
+    coverage: 45.2,
+    recommendation: "Increase coverage and refactor"
+  }
+})
+```
+
+### Learning Query (Use at Task Start)
+
+**Before starting your task**, query for past learnings:
+
+```typescript
+// Query for successful experiences
+const pastLearnings = await mcp__agentic_qe__learning_query({
+  agentId: "qe-quality-analyzer",
+  taskType: "quality-analysis",
+  minReward: 0.8,  // Only get successful experiences
+  queryType: "all",
+  limit: 10
+});
+
+// Use the insights to optimize your current approach
+if (pastLearnings.success && pastLearnings.data) {
+  const { experiences, qValues, patterns } = pastLearnings.data;
+
+  // Find best-performing strategy
+  const bestStrategy = qValues
+    .filter(qv => qv.state_key === "quality-analysis-state")
+    .sort((a, b) => b.q_value - a.q_value)[0];
+
+  console.log(`Using learned best strategy: ${bestStrategy.action_key} (Q-value: ${bestStrategy.q_value})`);
+
+  // Check for relevant patterns
+  const relevantPatterns = patterns
+    .filter(p => p.domain === "quality-metrics")
+    .sort((a, b) => b.confidence * b.success_rate - a.confidence * a.success_rate);
+
+  if (relevantPatterns.length > 0) {
+    console.log(`Applying pattern: ${relevantPatterns[0].pattern}`);
+  }
+}
+```
+
+### Success Criteria for Learning
+
+**Reward Assessment (0-1 scale):**
+- **1.0**: Perfect execution (All metrics analyzed, actionable insights, <5s analysis)
+- **0.9**: Excellent (95%+ metrics covered, high-quality insights, <10s)
+- **0.7**: Good (90%+ metrics covered, useful insights, <20s)
+- **0.5**: Acceptable (80%+ metrics covered, completed successfully)
+- **<0.5**: Needs improvement (Limited coverage, low-quality insights, slow)
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after detecting significant findings
+- ✅ **ALWAYS** after generating recommendations
+- ✅ When discovering new effective strategies
+- ✅ When achieving exceptional performance metrics
+
 ## Analysis Workflow
 
 ### Phase 1: Data Collection

package/.claude/agents/qe-quality-gate.md

@@ -558,4 +558,123 @@ node -e "import('agentic-qe/tools/qe/quality-gates').then(m => console.log(m.ava
 // aqe quality gate merge-decision --environment production
 ```
 
+## Learning Protocol (Phase 6 - Option C Implementation)
+
+**⚠️ 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)
+
+**1. Store Learning Experience:**
+```typescript
+// Call this MCP tool after completing your task
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-quality-gate",
+  taskType: "quality-gate-evaluation",
+  reward: 0.95,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    // Your actual results (agent-specific)
+    gateResult: "pass",
+    riskLevel: "low",
+    metricsValidated: 15,
+    decisionsBlocked: 0,
+    executionTime: 2500
+  },
+  metadata: {
+    // Additional context (agent-specific)
+    environment: "production",
+    policyApplied: "strict",
+    thresholds: {
+      coverage: 90,
+      complexity: 15,
+      security: 0
+    }
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-quality-gate",
+  stateKey: "quality-gate-state",
+  actionKey: "risk-based-evaluation",
+  qValue: 0.85,  // Expected value of this approach (based on results)
+  metadata: {
+    // Strategy details (agent-specific)
+    evaluationStrategy: "risk-based-ml",
+    accuracy: 0.98,
+    falsePositiveRate: 0.02
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-quality-gate",
+  pattern: "Risk-based evaluation with ML scoring reduces false positives by 40% while maintaining 98% accuracy for quality gate decisions",
+  confidence: 0.95,  // How confident you are (0-1)
+  domain: "quality-gate",
+  metadata: {
+    // Pattern context (agent-specific)
+    riskPatterns: ["coverage-trend-negative", "security-scan-new-vulns"],
+    decisionAccuracy: 0.98
+  }
+})
+```
+
+### Learning Query (Use at Task Start)
+
+**Before starting your task**, query for past learnings:
+
+```typescript
+// Query for successful experiences
+const pastLearnings = await mcp__agentic_qe__learning_query({
+  agentId: "qe-quality-gate",
+  taskType: "quality-gate-evaluation",
+  minReward: 0.8,  // Only get successful experiences
+  queryType: "all",
+  limit: 10
+});
+
+// Use the insights to optimize your current approach
+if (pastLearnings.success && pastLearnings.data) {
+  const { experiences, qValues, patterns } = pastLearnings.data;
+
+  // Find best-performing strategy
+  const bestStrategy = qValues
+    .filter(qv => qv.state_key === "quality-gate-state")
+    .sort((a, b) => b.q_value - a.q_value)[0];
+
+  console.log(`Using learned best strategy: ${bestStrategy.action_key} (Q-value: ${bestStrategy.q_value})`);
+
+  // Check for relevant patterns
+  const relevantPatterns = patterns
+    .filter(p => p.domain === "quality-gate")
+    .sort((a, b) => b.confidence * b.success_rate - a.confidence * a.success_rate);
+
+  if (relevantPatterns.length > 0) {
+    console.log(`Applying pattern: ${relevantPatterns[0].pattern}`);
+  }
+}
+```
+
+### Success Criteria for Learning
+
+**Reward Assessment (0-1 scale):**
+- **1.0**: Perfect execution (100% accurate decisions, 0 false positives, <2s evaluation)
+- **0.9**: Excellent (98%+ accuracy, <1% false positives, <5s evaluation)
+- **0.7**: Good (95%+ accuracy, <3% false positives, <10s evaluation)
+- **0.5**: Acceptable (90%+ accuracy, completed successfully)
+- **<0.5**: Needs improvement (Low accuracy, many false positives, slow)
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after detecting significant findings
+- ✅ **ALWAYS** after generating recommendations
+- ✅ When discovering new effective strategies
+- ✅ When achieving exceptional performance metrics
+
 

package/.claude/agents/qe-regression-risk-analyzer.md

@@ -783,6 +783,120 @@ const verification = await hookManager.executePreTaskVerification({
 });
 ```
 
+## Learning Protocol (Phase 6 - Option C Implementation)
+
+**⚠️ 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)
+
+**1. Store Learning Experience:**
+```typescript
+// Call this MCP tool after completing your task
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-regression-risk-analyzer",
+  taskType: "regression-risk-analysis",
+  reward: 0.95,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    // Your actual results (agent-specific)
+    riskScore: 78.3,
+    testsSelected: 47,
+    executionTimeReduction: 0.963,
+    accuracy: 0.95
+  },
+  metadata: {
+    // Additional context (agent-specific)
+    algorithm: "ml-enhanced-selection",
+    blastRadiusAnalyzed: true,
+    coverageImpact: 0.90
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-regression-risk-analyzer",
+  stateKey: "regression-risk-state",
+  actionKey: "ml-risk-prediction",
+  qValue: 0.85,  // Expected value of this approach (based on results)
+  metadata: {
+    // Strategy details (agent-specific)
+    selectionStrategy: "hybrid-coverage-ml",
+    accuracyRate: 0.95,
+    timeReduction: 0.963
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-regression-risk-analyzer",
+  pattern: "Changes to payment service after 5PM require full integration suite",
+  confidence: 0.95,  // How confident you are (0-1)
+  domain: "regression-analysis",
+  metadata: {
+    // Pattern context (agent-specific)
+    riskPatterns: ["late-day-commits", "payment-critical"],
+    predictionAccuracy: 0.95
+  }
+})
+```
+
+### Learning Query (Use at Task Start)
+
+**Before starting your task**, query for past learnings:
+
+```typescript
+// Query for successful experiences
+const pastLearnings = await mcp__agentic_qe__learning_query({
+  agentId: "qe-regression-risk-analyzer",
+  taskType: "regression-risk-analysis",
+  minReward: 0.8,  // Only get successful experiences
+  queryType: "all",
+  limit: 10
+});
+
+// Use the insights to optimize your current approach
+if (pastLearnings.success && pastLearnings.data) {
+  const { experiences, qValues, patterns } = pastLearnings.data;
+
+  // Find best-performing strategy
+  const bestStrategy = qValues
+    .filter(qv => qv.state_key === "regression-risk-state")
+    .sort((a, b) => b.q_value - a.q_value)[0];
+
+  console.log(`Using learned best strategy: ${bestStrategy.action_key} (Q-value: ${bestStrategy.q_value})`);
+
+  // Check for relevant patterns
+  const relevantPatterns = patterns
+    .filter(p => p.domain === "regression-analysis")
+    .sort((a, b) => b.confidence * b.success_rate - a.confidence * a.success_rate);
+
+  if (relevantPatterns.length > 0) {
+    console.log(`Applying pattern: ${relevantPatterns[0].pattern}`);
+  }
+}
+```
+
+### Success Criteria for Learning
+
+**Reward Assessment (0-1 scale):**
+- **1.0**: Perfect execution (99%+ accuracy, 70%+ time reduction, 0 false negatives)
+- **0.9**: Excellent (95%+ accuracy, 60%+ time reduction, <1% false negatives)
+- **0.7**: Good (90%+ accuracy, 50%+ time reduction, <5% false negatives)
+- **0.5**: Acceptable (85%+ accuracy, 40%+ time reduction)
+- **<0.5**: Needs improvement (Low accuracy, minimal time savings, false negatives)
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after detecting significant findings
+- ✅ **ALWAYS** after generating recommendations
+- ✅ When discovering new effective strategies
+- ✅ When achieving exceptional performance metrics
+
 ## Integration Points
 
 ### Upstream Dependencies

package/.claude/agents/qe-requirements-validator.md

@@ -293,6 +293,120 @@ this.registerEventHandler({
 });
 ```
 
+## Learning Protocol (Phase 6 - Option C Implementation)
+
+**⚠️ 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)
+
+**1. Store Learning Experience:**
+```typescript
+// Call this MCP tool after completing your task
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-requirements-validator",
+  taskType: "requirements-validation",
+  reward: 0.95,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    // Your actual results
+    requirementsValidated: 12,
+    testabilityScore: 8.5,
+    bddScenariosGenerated: 32,
+    executionTime: 4200
+  },
+  metadata: {
+    // Additional context
+    validationFramework: "invest-smart",
+    strictMode: true,
+    criteriaChecked: ["invest", "smart", "5w"]
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-requirements-validator",
+  stateKey: "requirements-validation-state",
+  actionKey: "invest-analysis",
+  qValue: 0.85,  // Expected value of this approach (based on results)
+  metadata: {
+    // Strategy details
+    validationStrategy: "invest-smart-combined",
+    accuracy: 0.95,
+    completeness: 0.92
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-requirements-validator",
+  pattern: "Vague performance requirements converted to specific percentile-based metrics",
+  confidence: 0.95,  // How confident you are (0-1)
+  domain: "requirements",
+  metadata: {
+    // Pattern context
+    requirementPatterns: ["vague-nfr", "missing-metrics", "unclear-sla"],
+    testabilityPrediction: 0.92
+  }
+})
+```
+
+### Learning Query (Use at Task Start)
+
+**Before starting your task**, query for past learnings:
+
+```typescript
+// Query for successful experiences
+const pastLearnings = await mcp__agentic_qe__learning_query({
+  agentId: "qe-requirements-validator",
+  taskType: "requirements-validation",
+  minReward: 0.8,  // Only get successful experiences
+  queryType: "all",
+  limit: 10
+});
+
+// Use the insights to optimize your current approach
+if (pastLearnings.success && pastLearnings.data) {
+  const { experiences, qValues, patterns } = pastLearnings.data;
+
+  // Find best-performing strategy
+  const bestStrategy = qValues
+    .filter(qv => qv.state_key === "requirements-validation-state")
+    .sort((a, b) => b.q_value - a.q_value)[0];
+
+  console.log(`Using learned best strategy: ${bestStrategy.action_key} (Q-value: ${bestStrategy.q_value})`);
+
+  // Check for relevant patterns
+  const relevantPatterns = patterns
+    .filter(p => p.domain === "requirements")
+    .sort((a, b) => b.confidence * b.success_rate - a.confidence * a.success_rate);
+
+  if (relevantPatterns.length > 0) {
+    console.log(`Applying pattern: ${relevantPatterns[0].pattern}`);
+  }
+}
+```
+
+### Success Criteria for Learning
+
+**Reward Assessment (0-1 scale):**
+- **1.0**: Perfect execution (All requirements testable, 100% INVEST compliance, <3s validation)
+- **0.9**: Excellent (95%+ testable, 95%+ INVEST compliance, <5s validation)
+- **0.7**: Good (90%+ testable, 90%+ INVEST compliance, <10s validation)
+- **0.5**: Acceptable (80%+ testable, 80%+ INVEST compliance)
+- **<0.5**: Needs improvement (Low testability, poor INVEST compliance)
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after detecting significant findings
+- ✅ **ALWAYS** after generating recommendations
+- ✅ When discovering new effective strategies
+- ✅ When achieving exceptional performance metrics
+
 ## Integration Points
 
 ### Upstream Dependencies