agentic-qe 2.2.2 → 2.3.1

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

@@ -298,8 +298,7 @@ notifyTestCompletion({
 });
 ```
 
-## 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)
@@ -412,6 +411,7 @@ if (pastLearnings.success && pastLearnings.data) {
 - ✅ **ALWAYS** after generating recommendations
 - ✅ When discovering new effective strategies
 - ✅ When achieving exceptional performance metrics
+</learning_protocol>
 
 ## Error Handling & Recovery
 

package/.claude/agents/qe-test-generator.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-test-generator",
   taskType: "test-generation",
@@ -80,43 +83,73 @@ 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-test-generator",
   taskType: "test-generation",
-  reward: 0.95,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
-    testsGenerated: 42,
-    coverageImprovement: 0.15,
-    framework: "jest",
-    executionTime: 8000
+    testsGenerated: <count>,
+    coverageAchieved: <percentage>,
+    passRate: <percentage>,
+    framework: "<framework>",
+    executionTime: <ms>
   },
   metadata: {
-    algorithm: "ml-property-based",
-    testTypes: ["unit", "integration"]
+    algorithm: "<algorithm_used>",
+    testTypes: ["<types>"],
+    codeComplexity: "<low|medium|high>"
   }
 })
 ```
 
-Store successful patterns when discovered:
-```javascript
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/test-generation/results/<task_id>",
+  value: {
+    testsGenerated: [...],
+    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: "ML-based property testing generates 40% more edge cases than template-based for complex business logic",
-  confidence: 0.95,
+  pattern: "<description of successful strategy>",
+  confidence: <0.0-1.0>,
   domain: "test-generation",
   metadata: {
-    testPatterns: ["property-based", "boundary-value"],
-    effectiveness: 0.92
+    testPatterns: ["<patterns>"],
+    effectiveness: <rate>,
+    codeContext: "<when this works best>"
   }
 })
 ```
 
-Reward criteria (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)
-- 0.5: Acceptable (70%+ coverage, completed successfully)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect: 95%+ coverage, all tests pass, <5s generation |
+| 0.9 | Excellent: 90%+ coverage, <10s generation, minor issues |
+| 0.7 | Good: 80%+ coverage, <20s generation |
+| 0.5 | Acceptable: 70%+ coverage, completed successfully |
+| 0.3 | Partial: Some tests generated but coverage <70% |
+| 0.0 | Failed: No tests generated or major errors |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing main task
+- ✅ **ALWAYS** after generating test suites
+- ✅ **ALWAYS** after analyzing coverage
+- ✅ When discovering new effective testing patterns
+- ✅ When achieving exceptional coverage metrics
 </learning_protocol>
 
 <output_format>

package/.claude/agents/qe-visual-tester.md

@@ -69,8 +69,11 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-Query before testing:
-```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-visual-tester",
   taskType: "visual-testing",
@@ -80,12 +83,14 @@ 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-visual-tester",
   taskType: "visual-testing",
-  reward: 0.95,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
     regressionsDetected: 3,
     accuracy: 0.98,
@@ -100,8 +105,23 @@ mcp__agentic_qe__learning_store_experience({
 })
 ```
 
-Store patterns when discovered:
-```javascript
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/visual/test-results/<task_id>",
+  value: {
+    regressions: [],
+    accessibilityViolations: [],
+    screenshots: {},
+    diffImages: []
+  },
+  namespace: "aqe",
+  persist: true  // IMPORTANT: Must be true for persistence
+})
+```
+
+**3. Store Discovered Patterns (when applicable):**
+```typescript
 mcp__agentic_qe__learning_store_pattern({
   pattern: "AI-powered visual diff with 95% threshold detects regressions with <2% false positives",
   confidence: 0.95,
@@ -113,11 +133,22 @@ mcp__agentic_qe__learning_store_pattern({
 })
 ```
 
-Reward criteria:
-- 1.0: Perfect (100% regressions detected, 0 false positives, <10s)
-- 0.9: Excellent (99%+ detected, <1% false positives, <20s)
-- 0.7: Good (95%+ detected, <5% false positives, <40s)
-- 0.5: Acceptable (90%+ detected, completed)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect (100% regressions detected, 0 false positives, <10s) |
+| 0.9 | Excellent (99%+ detected, <1% false positives, <20s) |
+| 0.7 | Good (95%+ detected, <5% false positives, <40s) |
+| 0.5 | Acceptable (90%+ detected, completed) |
+| 0.3 | Partial: Task partially completed |
+| 0.0 | Failed: Task failed or major errors |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing visual testing
+- ✅ **ALWAYS** after detecting regressions
+- ✅ **ALWAYS** after validating accessibility
+- ✅ When discovering new effective comparison patterns
+- ✅ When achieving exceptional detection accuracy
 </learning_protocol>
 
 <output_format>

package/.claude/agents/qx-partner.md

@@ -89,8 +89,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: "qx-partner",
   taskType: "qx-analysis",
@@ -100,12 +103,14 @@ 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: "qx-partner",
   taskType: "qx-analysis",
-  reward: 0.95,
+  reward: <calculated_reward>,  // 0.0-1.0 based on criteria below
   outcome: {
     qxScore: 82,
     oracleProblemsDetected: 2,
@@ -121,8 +126,24 @@ mcp__agentic_qe__learning_store_experience({
 })
 ```
 
-Store patterns when discovered:
-```javascript
+**2. Store Task Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/qx/analysis-results/<task_id>",
+  value: {
+    qxScore: 0,
+    oracleProblems: [],
+    recommendations: [],
+    balanceAssessment: {},
+    impactAnalysis: {}
+  },
+  namespace: "aqe",
+  persist: true  // IMPORTANT: Must be true for persistence
+})
+```
+
+**3. Store Discovered Patterns (when applicable):**
+```typescript
 mcp__agentic_qe__learning_store_pattern({
   pattern: "User convenience vs business revenue conflicts indicate oracle problem requiring stakeholder alignment session",
   confidence: 0.92,
@@ -135,11 +156,22 @@ mcp__agentic_qe__learning_store_pattern({
 })
 ```
 
-Reward criteria:
-- 1.0: Perfect (All heuristics applied, oracle problems resolved, <5s)
-- 0.9: Excellent (95%+ heuristics, actionable recommendations, <10s)
-- 0.7: Good (90%+ heuristics, balance found, <20s)
-- 0.5: Acceptable (Core analysis complete, recommendations generated)
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Perfect (All heuristics applied, oracle problems resolved, <5s) |
+| 0.9 | Excellent (95%+ heuristics, actionable recommendations, <10s) |
+| 0.7 | Good (90%+ heuristics, balance found, <20s) |
+| 0.5 | Acceptable (Core analysis complete, recommendations generated) |
+| 0.3 | Partial: Task partially completed |
+| 0.0 | Failed: Task failed or major errors |
+
+**When to Call Learning Tools:**
+- ✅ **ALWAYS** after completing QX analysis
+- ✅ **ALWAYS** after detecting oracle problems
+- ✅ **ALWAYS** after generating recommendations
+- ✅ When discovering new effective heuristic patterns
+- ✅ When achieving exceptional QX scores
 </learning_protocol>
 
 <output_format>

package/.claude/agents/subagents/qe-code-reviewer.md

@@ -42,4 +42,35 @@ Returns approval/rejection verdict with detailed issues list, quality metrics, a
 Reports to: qe-test-generator (TDD workflow coordinator)
 Triggers: After REFACTOR phase completes, before final code acceptance
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-code-reviewer",
+  taskType: "code-review",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "REVIEW", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/review/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: No critical issues, complexity <15, coverage ≥95%, security scan clean, all quality gates pass
+- 0.7: Minor issues only, complexity <20, coverage ≥90%, no security vulnerabilities
+- 0.5: Some issues, acceptable quality thresholds met
+- 0.0: Critical issues detected, security vulnerabilities, or quality gate failures
+</learning_protocol>
 </qe_subagent_definition>

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

@@ -42,4 +42,35 @@ Returns prioritized gap list with risk scores, test recommendations, and project
 Reports to: qe-coverage-analyzer, qe-quality-gate
 Triggers: When coverage below target thresholds or quality gate validation
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-coverage-gap-analyzer",
+  taskType: "coverage-gap-analysis",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "COVERAGE_ANALYSIS", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/coverage-gaps/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: All gaps identified with accurate risk scores, actionable test templates generated, impact analysis complete
+- 0.7: Good gap detection, reasonable prioritization, test recommendations provided
+- 0.5: Gaps identified, basic prioritization, acceptable recommendations
+- 0.0: Missed critical gaps or inaccurate risk assessment
+</learning_protocol>
 </qe_subagent_definition>

package/.claude/agents/subagents/qe-data-generator.md

@@ -43,4 +43,35 @@ Reports to: qe-test-data-architect
 Triggers: When test data needed for TDD cycles or integration testing
 Handoff: Set readyForHandoff=true when all data generated with valid referential integrity
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-data-generator",
+  taskType: "test-data-generation",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "DATA_GENERATION", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/test-data/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: Realistic data, 100% referential integrity, edge cases included, high throughput achieved
+- 0.7: Good data quality, minor relationship issues, edge cases present
+- 0.5: Acceptable data, some integrity issues, basic edge case coverage
+- 0.0: Invalid data, broken relationships, or missing edge cases
+</learning_protocol>
 </qe_subagent_definition>

package/.claude/agents/subagents/qe-flaky-investigator.md

@@ -57,4 +57,35 @@ Reports to: qe-flaky-test-hunter, qe-quality-gate
 Triggers: When test run history available for flakiness analysis
 Handoff: Emit flaky-investigator:completed with flakyTestsFound count
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-flaky-investigator",
+  taskType: "flaky-investigation",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "FLAKY_ANALYSIS", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/flaky/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: All flaky tests detected, accurate root cause classification, high-confidence fixes with effort estimates
+- 0.7: Good detection, reasonable root cause analysis, actionable fixes
+- 0.5: Flaky tests identified, basic classification, some fix recommendations
+- 0.0: Missed flaky tests or incorrect root cause analysis
+</learning_protocol>
 </qe_subagent_definition>

package/.claude/agents/subagents/qe-integration-tester.md

@@ -56,4 +56,35 @@ Reports to: qe-test-executor
 Triggers: When integration test scope requested
 Handoff: Set readyForHandoff=true when all critical tests pass
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-integration-tester",
+  taskType: "integration-testing",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "INTEGRATION", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/integration/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: All critical tests pass, contracts validated, proper connection lifecycle, no latency issues
+- 0.7: Most tests pass, minor contract issues, acceptable performance
+- 0.5: Core tests pass, some integration failures, acceptable for non-critical paths
+- 0.0: Critical test failures, contract violations, or connection errors
+</learning_protocol>
 </qe_subagent_definition>

package/.claude/agents/subagents/qe-performance-validator.md

@@ -58,4 +58,35 @@ Reports to: qe-performance-tester
 Triggers: After performance test execution completes
 Handoff: Set readyForHandoff=true only if all SLA validations pass
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-performance-validator",
+  taskType: "performance-validation",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "PERFORMANCE", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/performance/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: All SLA validations pass, no regressions, performance budgets met
+- 0.7: Most SLAs pass, minor regressions (<10%), acceptable performance
+- 0.5: Core SLAs pass, some violations, acceptable for non-critical endpoints
+- 0.0: Critical SLA violations or significant performance regressions (>10%)
+</learning_protocol>
 </qe_subagent_definition>

package/.claude/agents/subagents/qe-security-auditor.md

@@ -60,4 +60,35 @@ Reports to: qe-security-scanner
 Triggers: Before release or when security scan requested
 Handoff: ALWAYS block if critical vulnerabilities detected, set readyForHandoff=false
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-security-auditor",
+  taskType: "security-audit",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "SECURITY", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/security/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: No critical/high vulnerabilities, all compliance standards met, comprehensive remediation guidance
+- 0.7: Only medium/low vulnerabilities, most compliance checks pass, good remediation steps
+- 0.5: Some vulnerabilities detected, partial compliance, basic remediation
+- 0.0: Critical vulnerabilities detected or major compliance violations
+</learning_protocol>
 </qe_subagent_definition>

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

@@ -59,4 +59,35 @@ Reports to: qe-test-data-architect, qe-integration-orchestrator
 Triggers: When test data generation is requested with schema definition
 Handoff: Store dataset in memory namespace, emit `test-data-architect-sub:completed` event
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-test-data-architect-sub",
+  taskType: "test-data-architecture",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "DATA_ARCHITECTURE", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/test-data-arch/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: 100% referential integrity, high throughput (>10k rec/sec), comprehensive edge cases, proper streaming
+- 0.7: Good integrity (no orphans), acceptable throughput, edge cases included
+- 0.5: Minor integrity issues, adequate throughput, basic edge case coverage
+- 0.0: Broken relationships, low throughput, or missing edge cases
+</learning_protocol>
 </qe_subagent_definition>

package/.claude/agents/subagents/qe-test-implementer.md

@@ -72,4 +72,35 @@ Receives from: qe-test-writer (RED phase output with failing tests)
 Handoff: Store GREEN output in memory, emit `test-implementer:completed`, qe-test-refactorer picks up
 Validation: readyForHandoff=true ONLY if allTestsPassing=true AND testFile.hash unchanged
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-test-implementer",
+  taskType: "tdd-green-phase",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "GREEN", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/tdd/green/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: All tests pass, minimal implementation, YAGNI enforced, no test modifications
+- 0.7: All tests pass, slightly over-engineered, tests unchanged
+- 0.5: Tests pass but implementation too complex or tests were modified
+- 0.0: Tests still failing or test file hash changed
+</learning_protocol>
 </qe_subagent_definition>

package/.claude/agents/subagents/qe-test-refactorer.md

@@ -83,4 +83,35 @@ Receives from: qe-test-implementer (GREEN phase output with passing tests)
 Handoff: Store REFACTOR output, emit `test-refactorer:completed`, TDD cycle COMPLETE
 Validation: cycleComplete=true ONLY if allTestsPassing=true AND testFile.hash unchanged AND coverage not decreased
 </coordination>
+
+<learning_protocol>
+**⚠️ MANDATORY**: After completing your task, call learning MCP tools.
+
+**Store Experience:**
+```typescript
+mcp__agentic_qe__learning_store_experience({
+  agentId: "qe-test-refactorer",
+  taskType: "tdd-refactor-phase",
+  reward: <calculated_reward>,  // 0.0-1.0
+  outcome: { /* task-specific results */ },
+  metadata: { phase: "REFACTOR", cycleId: "<cycleId>" }
+})
+```
+
+**Store Artifacts:**
+```typescript
+mcp__agentic_qe__memory_store({
+  key: "aqe/tdd/refactor/<task_id>",
+  value: { /* task artifacts */ },
+  namespace: "aqe",
+  persist: true
+})
+```
+
+**Reward Criteria:**
+- 1.0: Tests pass, significant quality improvement (complexity -50%+, maintainability +30%+), no coverage drop
+- 0.7: Tests pass, good quality improvement, minor coverage change
+- 0.5: Tests pass, minimal improvement, coverage maintained
+- 0.0: Tests fail or coverage decreased
+</learning_protocol>
 </qe_subagent_definition>