agentic-qe 3.8.7 → 3.8.8

package/assets/agents/v3/qe-code-intelligence.md

@@ -77,74 +77,41 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools.
+**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning tools (via CLI or MCP).
 
 ### Query Existing KG BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "code-intelligence/kg-stats",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "code-intelligence/kg-stats" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Analysis)
 
 **1. Store Code Intelligence Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "code-intelligence/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-code-intelligence",
-    taskType: "code-analysis",
-    reward: <calculated_reward>,
-    outcome: {
-      filesIndexed: <count>,
-      entitiesDiscovered: <count>,
-      searchLatency: <ms>,
-      impactDepth: <count>,
-      testsMapped: <count>
-    },
-    kgStats: {
-      nodes: <count>,
-      edges: <count>,
-      indices: <count>
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "code-intelligence/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Code Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/code-intelligence/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<code pattern description>",
-    confidence: <0.0-1.0>,
-    type: "code-intelligence",
-    metadata: {
-      patternType: "<type>",
-      language: "<language>",
-      frequency: <count>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/code-intelligence/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "code-intelligence-complete",
-  priority: "p1",
-  payload: {
-    kgUpdated: true,
-    entitiesAdded: <count>,
-    searchReady: true
-  }
-})
+```bash
+aqe task submit \
+  "code-intelligence-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/qe-contract-validator.md

@@ -80,73 +80,41 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools.
+**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning tools (via CLI or MCP).
 
 ### Query Known Contract Patterns BEFORE Validation
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "contracts/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "contracts/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Validation)
 
 **1. Store Contract Validation Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "contract-validator/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-contract-validator",
-    taskType: "contract-validation",
-    reward: <calculated_reward>,
-    outcome: {
-      contractsValidated: <count>,
-      passed: <count>,
-      failed: <count>,
-      breakingChanges: <count>,
-      consumersAffected: <count>
-    },
-    patterns: {
-      breakingPatterns: ["<breaking change types>"],
-      compatiblePatterns: ["<compatible changes>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "contract-validator/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Breaking Change Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/contract-breaking-change/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<breaking change description>",
-    confidence: <0.0-1.0>,
-    type: "contract-breaking-change",
-    metadata: {
-      changeType: "<type>",
-      impact: "<impact>",
-      migration: "<migration path>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/contract-breaking-change/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "contract-validation-complete",
-  priority: "p1",
-  payload: {
-    validations: [...],
-    breakingChanges: [...],
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "contract-validation-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/qe-coverage-specialist.md

@@ -80,73 +80,41 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools.
+**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning tools (via CLI or MCP).
 
 ### Query Past Learnings BEFORE Starting Task
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "coverage/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "coverage/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Task Completion)
 
 **1. Store Coverage Analysis Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "coverage/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-coverage-specialist",
-    taskType: "coverage-analysis",
-    reward: <calculated_reward>,
-    outcome: {
-      filesAnalyzed: <count>,
-      gapsDetected: <count>,
-      lineCoverage: <percentage>,
-      branchCoverage: <percentage>,
-      analysisTime: <ms>
-    },
-    patterns: {
-      successful: ["<patterns that worked>"],
-      riskFactors: ["<effective risk factors>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "coverage/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Submit Result to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "coverage-analysis-complete",
-  priority: "p1",
-  payload: {
-    coverageReport: {...},
-    gaps: [...],
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "coverage-analysis-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 **3. Store Discovered Patterns (when gap prioritization is effective):**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/coverage-analysis/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<description of effective risk scoring>",
-    confidence: <0.0-1.0>,
-    type: "coverage-analysis",
-    metadata: {
-      riskFactors: ["<factors>"],
-      codebaseType: "<type>",
-      effectiveness: <rate>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/coverage-analysis/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)
@@ -216,32 +184,8 @@ Use via Claude Code: `Skill("mutation-testing")`
 **Role**: PRODUCER - Stores untestable patterns from coverage analysis
 
 ### On Coverage Gap Detection, Store Quality-Criteria Signal:
-```typescript
-mcp__agentic-qe__cross_phase_store({
-  loop: "quality-criteria",
-  data: {
-    untestablePatterns: [
-      {
-        acPattern: "<acceptance-criteria-pattern>",
-        problem: "<why-its-untestable>",
-        frequency: <0.0-1.0>,
-        betterPattern: "<improved-pattern>"
-      }
-    ],
-    coverageGaps: [
-      {
-        codeArea: "<file-or-module>",
-        coveragePercentage: <percentage>,
-        rootCause: "<why-gap-exists>",
-        acImprovement: "<how-better-AC-would-help>"
-      }
-    ],
-    recommendations: {
-      forRequirementsValidator: ["<AC improvement recommendations>"],
-      acTemplates: { "<feature>": "<template>" }
-    }
-  }
-})
+```bash
+aqe memory store --payload '{...}' --json
 ```
 
 ### Signal Flow:

package/assets/agents/v3/qe-defect-predictor.md

@@ -77,73 +77,41 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools.
+**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning tools (via CLI or MCP).
 
 ### Query Historical Models BEFORE Prediction
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "defect/prediction-model",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "defect/prediction-model" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Prediction)
 
 **1. Store Prediction Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "defect-predictor/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-defect-predictor",
-    taskType: "defect-prediction",
-    reward: <calculated_reward>,
-    outcome: {
-      filesAnalyzed: <count>,
-      highRiskFiles: <count>,
-      predictedDefects: <count>,
-      modelAccuracy: <percentage>,
-      featureImportance: {...}
-    },
-    validation: {
-      truePositives: <count>,
-      falsePositives: <count>
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "defect-predictor/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Update Model with New Data:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/defect-prediction/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<defect pattern description>",
-    confidence: <0.0-1.0>,
-    type: "defect-prediction",
-    metadata: {
-      predictiveFeatures: ["<features>"],
-      defectType: "<type>",
-      accuracy: <rate>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/defect-prediction/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Prediction to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "defect-prediction-complete",
-  priority: "p1",
-  payload: {
-    predictions: [...],
-    riskScores: {...},
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "defect-prediction-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)
@@ -240,29 +208,8 @@ Use via Claude Code: `Skill("mutation-testing")`
 **Role**: PRODUCER - Stores risk weights from production defect analysis
 
 ### On Completion, Store Strategic Signal:
-```typescript
-mcp__agentic-qe__cross_phase_store({
-  loop: "strategic",
-  data: {
-    riskWeights: [
-      {
-        category: "<defect-prone-area>",
-        weight: <0.0-1.0>,
-        confidence: <0.0-1.0>,
-        evidence: {
-          defectCount: <count>,
-          percentageOfTotal: <percentage>,
-          severityDistribution: { critical: <n>, high: <n>, medium: <n> },
-          timeRange: { start: "<date>", end: "<date>" }
-        }
-      }
-    ],
-    recommendations: {
-      forRiskAssessor: ["<recommendations for risk assessment>"],
-      forQualityCriteria: ["<recommendations for acceptance criteria>"]
-    }
-  }
-})
+```bash
+aqe memory store --payload '{...}' --json
 ```
 
 ### Signal Flow:

package/assets/agents/v3/qe-dependency-mapper.md

@@ -76,73 +76,41 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools.
+**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning tools (via CLI or MCP).
 
 ### Query Dependency Patterns BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "dependencies/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "dependencies/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Analysis)
 
 **1. Store Dependency Analysis Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "dependency-mapper/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-dependency-mapper",
-    taskType: "dependency-analysis",
-    reward: <calculated_reward>,
-    outcome: {
-      modulesAnalyzed: <count>,
-      dependenciesFound: <count>,
-      circularDetected: <count>,
-      vulnerabilitiesFound: <count>,
-      avgInstability: <score>
-    },
-    patterns: {
-      couplingPatterns: ["<patterns>"],
-      riskDependencies: ["<high risk deps>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "dependency-mapper/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Dependency Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/dependency-analysis/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<dependency pattern description>",
-    confidence: <0.0-1.0>,
-    type: "dependency-analysis",
-    metadata: {
-      patternType: "<type>",
-      riskLevel: "<level>",
-      recommendation: "<fix>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/dependency-analysis/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "dependency-analysis-complete",
-  priority: "p1",
-  payload: {
-    graph: {...},
-    metrics: {...},
-    issues: [...]
-  }
-})
+```bash
+aqe task submit \
+  "dependency-analysis-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/qe-deployment-advisor.md

@@ -90,74 +90,41 @@ Coordination:
 </memory_namespace>
 
 <learning_protocol>
-**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools.
+**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning tools (via CLI or MCP).
 
 ### Query Deployment Patterns BEFORE Assessment
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "deployment/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "deployment/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Assessment)
 
 **1. Store Deployment Assessment Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "deployment-advisor/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-deployment-advisor",
-    taskType: "deployment-assessment",
-    reward: <calculated_reward>,
-    outcome: {
-      gatesEvaluated: <count>,
-      gatesPassed: <count>,
-      riskScore: <score>,
-      decision: "<go/no-go>",
-      confidence: <percentage>,
-      blockersIdentified: <count>
-    },
-    patterns: {
-      successIndicators: ["<indicators>"],
-      riskFactors: ["<factors>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "deployment-advisor/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Deployment Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/deployment-readiness/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<deployment pattern description>",
-    confidence: <0.0-1.0>,
-    type: "deployment-readiness",
-    metadata: {
-      environment: "<environment>",
-      decision: "<decision>",
-      outcome: "<actual outcome>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/deployment-readiness/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "deployment-assessment-complete",
-  priority: "p0",
-  payload: {
-    assessment: {...},
-    decision: {...},
-    rollbackPlan: {...}
-  }
-})
+```bash
+aqe task submit \
+  "deployment-assessment-complete" \
+  --priority "p0" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)