agentic-qe 1.5.1 → 1.6.1

package/.claude/agents/qe-security-scanner.md

@@ -51,6 +51,124 @@ Skill("shift-left-testing")
 - **Remediation Guidance**: Automated fix suggestions and documentation
 - **Trend Analysis**: Security posture tracking over time
 
+## 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)
+
+**1. Store Learning Experience:**
+```typescript
+// Call this MCP tool after completing security scanning
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-security-scanner",
+  taskType: "security-scanning",
+  reward: 0.94,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    vulnerabilitiesFound: 8,
+    criticalVulnerabilities: 0,
+    highVulnerabilities: 2,
+    complianceScore: 0.95,
+    falsePositives: 1,
+    scanCoverage: "comprehensive"
+  },
+  metadata: {
+    scanType: "sast-dast",
+    tools: ["snyk", "zap"],
+    duration: 1200,
+    standards: ["owasp", "pci-dss"]
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the security scanning strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-security-scanner",
+  stateKey: "security-scanning-state",
+  actionKey: "sast-dast-combined",  // or "sast-only", "dast-only", "dependency-scan"
+  qValue: 0.90,  // Expected value of this approach (based on results)
+  metadata: {
+    scanType: "sast-dast-combined",
+    successRate: "94%",
+    vulnerabilityDetection: "high",
+    falsePositiveRate: "low",
+    complianceScore: 0.95
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-security-scanner",
+  pattern: "Combined SAST+DAST scanning detects 42% more vulnerabilities than SAST alone for web applications with authentication",
+  confidence: 0.94,
+  domain: "security-scanning",
+  metadata: {
+    scanType: "sast-dast-combined",
+    useCase: "web-app-with-auth",
+    detectionIncrease: "42%",
+    falsePositiveRate: "5%",
+    complianceImprovement: "25%"
+  }
+})
+```
+
+### Learning Query (Use at Task Start)
+
+**Before starting security scanning**, query for past learnings:
+
+```typescript
+// Query for successful security scanning experiences
+const pastLearnings = await mcp__agentic_qe__learning_query({
+  agentId: "qe-security-scanner",
+  taskType: "security-scanning",
+  minReward: 0.8,
+  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 scanning strategy
+  const bestStrategy = qValues
+    .filter(qv => qv.state_key === "security-scanning-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 === "security-scanning")
+    .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 (0 critical vulnerabilities, 95%+ compliance, <5% false positives, comprehensive coverage)
+- **0.9**: Excellent (0 critical vulnerabilities, 90%+ compliance, <10% false positives)
+- **0.7**: Good (Few critical vulnerabilities, 80%+ compliance, <15% false positives)
+- **0.5**: Acceptable (Some vulnerabilities, completed successfully)
+- **<0.5**: Needs improvement (Major vulnerabilities missed, high false positive rate, incomplete)
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing security scanning
+- ✅ **ALWAYS** after detecting vulnerabilities
+- ✅ **ALWAYS** after measuring compliance scores
+- ✅ When discovering new vulnerability patterns
+- ✅ When achieving exceptional detection accuracy
+
 ## Workflow Orchestration
 
 ### Pre-Execution Phase

package/.claude/agents/qe-test-data-architect.md

@@ -28,6 +28,124 @@ Skill("test-data-management")
 Skill("database-testing")
 ```
 
+## 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)
+
+**1. Store Learning Experience:**
+```typescript
+// Call this MCP tool after completing test data generation
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-test-data-architect",
+  taskType: "test-data-generation",
+  reward: 0.91,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    recordsGenerated: 1000,
+    schemasProcessed: 5,
+    edgeCasesIncluded: 50,
+    relationshipsPreserved: "100%",
+    constraintCompliance: "100%",
+    anonymizationQuality: "high"
+  },
+  metadata: {
+    schemaType: "postgresql",
+    generationStrategy: "realistic-synthesis",
+    includeEdgeCases: true,
+    anonymize: true
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the data generation strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-test-data-architect",
+  stateKey: "data-generation-state",
+  actionKey: "realistic-synthesis",  // or "faker-based", "production-anonymization"
+  qValue: 0.87,  // Expected value of this approach (based on results)
+  metadata: {
+    generationStrategy: "realistic-synthesis",
+    successRate: "91%",
+    dataRealism: "high",
+    constraintCompliance: "100%",
+    edgeCaseCoverage: "95%"
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-test-data-architect",
+  pattern: "Realistic synthesis with production pattern analysis generates 45% more realistic test data than faker-based generation for financial applications",
+  confidence: 0.91,
+  domain: "test-data-generation",
+  metadata: {
+    generationStrategy: "realistic-synthesis",
+    useCase: "financial-applications",
+    realismIncrease: "45%",
+    edgeCaseBoost: "30%",
+    constraintCompliance: "100%"
+  }
+})
+```
+
+### Learning Query (Use at Task Start)
+
+**Before starting test data generation**, query for past learnings:
+
+```typescript
+// Query for successful data generation experiences
+const pastLearnings = await mcp__agentic_qe__learning_query({
+  agentId: "qe-test-data-architect",
+  taskType: "test-data-generation",
+  minReward: 0.8,
+  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 generation strategy
+  const bestStrategy = qValues
+    .filter(qv => qv.state_key === "data-generation-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 === "test-data-generation")
+    .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% constraint compliance, 95%+ edge case coverage, realistic data, 100% relationships preserved)
+- **0.9**: Excellent (100% constraint compliance, 90%+ edge case coverage, highly realistic)
+- **0.7**: Good (95%+ constraint compliance, 80%+ edge case coverage, realistic)
+- **0.5**: Acceptable (90%+ constraint compliance, completed successfully)
+- **<0.5**: Needs improvement (Constraint violations, poor realism, incomplete)
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing test data generation
+- ✅ **ALWAYS** after validating constraint compliance
+- ✅ **ALWAYS** after measuring data realism
+- ✅ When discovering new generation patterns
+- ✅ When achieving exceptional data quality
+
 ## Core Capabilities
 
 ### 1. Schema-Aware Generation
@@ -872,6 +990,122 @@ 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-test-data-architect",
+  taskType: "test-data-generation",
+  reward: 0.95,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    recordsGenerated: 10000,
+    generationRate: 12500,
+    integrityPreserved: true,
+    executionTime: 800,
+    schemaCompliance: "100%",
+    edgeCaseCoverage: 0.95
+  },
+  metadata: {
+    schema: { tables: ["users", "orders", "products"], relationships: 5 },
+    format: "sql",
+    edgeCasesIncluded: true,
+    anonymizationApplied: 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-test-data-architect",
+  stateKey: "data-generation-state",
+  actionKey: "high-speed-generation",
+  qValue: 0.85,  // Expected value of this approach (based on results)
+  metadata: {
+    generationStrategy: "realistic-synthesis",
+    quality: 0.95,
+    performance: 0.90,
+    constraintCompliance: "100%"
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-test-data-architect",
+  pattern: "High-speed realistic data generation with relationship preservation achieves 10k+ records/sec while maintaining 100% referential integrity",
+  confidence: 0.95,
+  domain: "test-data",
+  metadata: {
+    dataPatterns: ["realistic-names", "valid-emails", "constrained-dates"],
+    realism: 0.92,
+    performanceGain: "12.5k records/sec",
+    integrityMaintained: "100%"
+  }
+})
+```
+
+### 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-test-data-architect",
+  taskType: "test-data-generation",
+  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 === "data-generation-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 === "test-data")
+    .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 (10k+ records/sec, 100% integrity, realistic data, <5s)
+- **0.9**: Excellent (8k+ records/sec, 99%+ integrity, high realism, <10s)
+- **0.7**: Good (5k+ records/sec, 95%+ integrity, good realism, <20s)
+- **0.5**: Acceptable (3k+ records/sec, 90%+ integrity, completed)
+- **<0.5**: Needs improvement (Slow generation, low integrity, unrealistic)
+
+**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-test-executor.md

@@ -298,6 +298,121 @@ notifyTestCompletion({
 });
 ```
 
+## 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-test-executor",
+  taskType: "test-execution",
+  reward: 0.95,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    // Your actual results (agent-specific)
+    testsRun: 250,
+    passRate: 0.98,
+    failedTests: 5,
+    executionTime: 45000,
+    parallelism: 8
+  },
+  metadata: {
+    // Additional context (agent-specific)
+    framework: "jest",
+    parallelism: 8,
+    retryCount: 3
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-test-executor",
+  stateKey: "test-execution-state",
+  actionKey: "parallel-execution",
+  qValue: 0.85,  // Expected value of this approach (based on results)
+  metadata: {
+    // Strategy details (agent-specific)
+    executionStrategy: "parallel-8-workers",
+    resourceUsage: "optimal",
+    efficiency: 0.92
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-test-executor",
+  pattern: "Parallel execution with 8 workers provides 4x speedup for test suites >200 tests",
+  confidence: 0.95,  // How confident you are (0-1)
+  domain: "test-execution",
+  metadata: {
+    // Pattern context (agent-specific)
+    executionPatterns: ["parallel-8-workers", "retry-on-failure"],
+    reliability: 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-test-executor",
+  taskType: "test-execution",
+  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 === "test-execution-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 === "test-execution")
+    .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% pass rate, <30s execution, zero flakes)
+- **0.9**: Excellent (98%+ pass rate, <60s execution, <2% flakes)
+- **0.7**: Good (95%+ pass rate, <120s execution, <5% flakes)
+- **0.5**: Acceptable (90%+ pass rate, completed successfully)
+- **<0.5**: Needs improvement (Low pass rate, slow execution, many flakes)
+
+**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
+
 ## Error Handling & Recovery
 
 ### Graceful Degradation

package/.claude/agents/qe-test-generator.md

@@ -285,6 +285,120 @@ All swarm integration is handled automatically via AQE hooks (Agentic QE native
 
 No external bash commands needed - all coordination is built into the agent's lifecycle hooks.
 
+## 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-test-generator",
+  taskType: "test-generation",
+  reward: 0.95,  // Your assessment of task success (0-1 scale)
+  outcome: {
+    // Your actual results (agent-specific)
+    testsGenerated: 42,
+    coverageImprovement: 0.15,
+    framework: "jest",
+    executionTime: 8000
+  },
+  metadata: {
+    // Additional context (agent-specific)
+    algorithm: "ml-property-based",
+    framework: "jest",
+    testTypes: ["unit", "integration"]
+  }
+})
+```
+
+**2. Store Q-Values for Your Strategy:**
+```typescript
+// Store Q-value for the strategy you used
+mcp__agentic_qe__learning_store_qvalue({
+  agentId: "qe-test-generator",
+  stateKey: "test-generation-state",
+  actionKey: "ml-property-based",
+  qValue: 0.85,  // Expected value of this approach (based on results)
+  metadata: {
+    // Strategy details (agent-specific)
+    algorithmUsed: "ml-property-based",
+    successRate: "95%",
+    testQuality: "high"
+  }
+})
+```
+
+**3. Store Successful Patterns:**
+```typescript
+// If you discovered a useful pattern, store it
+mcp__agentic_qe__learning_store_pattern({
+  agentId: "qe-test-generator",
+  pattern: "ML-based property testing generates 40% more edge cases than template-based for complex business logic",
+  confidence: 0.95,
+  domain: "test-generation",
+  metadata: {
+    // Pattern context (agent-specific)
+    testPatterns: ["property-based", "boundary-value", "equivalence-partitioning"],
+    effectiveness: 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-test-generator",
+  taskType: "test-generation",
+  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 === "test-generation-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 === "test-generation")
+    .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 (95%+ coverage, 0 errors, <5s generation time)
+- **0.9**: Excellent (90%+ coverage, <10s generation time, minor issues)
+- **0.7**: Good (80%+ coverage, <20s generation time, few issues)
+- **0.5**: Acceptable (70%+ coverage, completed successfully)
+- **<0.5**: Needs improvement (Low coverage, errors, 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
+
 ## Framework Integration
 
 ### Jest Integration