agentic-qe 3.8.7 → 3.8.8

package/.claude/agents/v3/qe-accessibility-auditor.md

@@ -235,75 +235,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 Accessibility Patterns BEFORE Audit
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "accessibility/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "accessibility/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Audit)
 
 **1. Store Accessibility Audit Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "accessibility-auditor/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-accessibility-auditor",
-    taskType: "accessibility-audit",
-    reward: <calculated_reward>,
-    outcome: {
-      pagesAudited: <count>,
-      violationsFound: <count>,
-      critical: <count>,
-      serious: <count>,
-      moderate: <count>,
-      minor: <count>,
-      remediationsProvided: <count>
-    },
-    patterns: {
-      commonViolations: ["<violation types>"],
-      effectiveFixes: ["<fixes that work>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "accessibility-auditor/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Remediation Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/accessibility-remediation/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<accessibility fix pattern>",
-    confidence: <0.0-1.0>,
-    type: "accessibility-remediation",
-    metadata: {
-      wcagCriteria: "<criteria>",
-      violationType: "<type>",
-      codeExample: "<fix>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/accessibility-remediation/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "accessibility-audit-complete",
-  priority: "p1",
-  payload: {
-    audit: {...},
-    violations: [...],
-    remediations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "accessibility-audit-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/.claude/agents/v3/qe-bdd-generator.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 BDD Patterns BEFORE Generation
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "bdd/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "bdd/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Generation)
 
 **1. Store BDD Generation Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "bdd-generator/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-bdd-generator",
-    taskType: "bdd-generation",
-    reward: <calculated_reward>,
-    outcome: {
-      storiesProcessed: <count>,
-      scenariosGenerated: <count>,
-      examplesDiscovered: <count>,
-      stepsReused: <percentage>,
-      gapsIdentified: <count>
-    },
-    patterns: {
-      scenarioPatterns: ["<patterns>"],
-      effectiveSteps: ["<reusable steps>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "bdd-generator/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store BDD Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/bdd-generation/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<BDD pattern description>",
-    confidence: <0.0-1.0>,
-    type: "bdd-generation",
-    metadata: {
-      scenarioType: "<type>",
-      domain: "<domain>",
-      stepReuse: <percentage>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/bdd-generation/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "bdd-generation-complete",
-  priority: "p1",
-  payload: {
-    features: [...],
-    scenarios: [...],
-    stepGaps: [...]
-  }
-})
+```bash
+aqe task submit \
+  "bdd-generation-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)
@@ -267,11 +235,8 @@ Use via Claude Code: `Skill("exploratory-testing-advanced")`
 **Role**: CONSUMER - Receives untestable patterns to avoid in BDD scenarios
 
 ### On Startup, Query Quality-Criteria Signals:
-```typescript
-const result = await mcp__agentic-qe__cross_phase_query({
-  loop: "quality-criteria",
-  maxAge: "60d"
-});
+```bash
+const result = await aqe memory search --json;
 
 // Learn from historical untestable patterns
 for (const signal of result.signals) {

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

@@ -89,74 +89,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 Weaknesses BEFORE Experiment
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "chaos/known-weaknesses",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "chaos/known-weaknesses" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Experiment)
 
 **1. Store Chaos Experiment Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "chaos-engineer/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-chaos-engineer",
-    taskType: "chaos-experiment",
-    reward: <calculated_reward>,
-    outcome: {
-      experimentsRun: <count>,
-      weaknessesFound: <count>,
-      servicesAffected: <count>,
-      recoveryTime: <ms>,
-      safetyViolations: <count>
-    },
-    patterns: {
-      weaknesses: ["<discovered weaknesses>"],
-      resilience: ["<resilience patterns observed>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "chaos-engineer/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Discovered Weakness:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/resilience-weakness/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<weakness description>",
-    confidence: <0.0-1.0>,
-    type: "resilience-weakness",
-    metadata: {
-      service: "<service>",
-      faultType: "<type>",
-      impact: "<impact>",
-      remediation: "<fix>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/resilience-weakness/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "chaos-experiment-complete",
-  priority: "p1",
-  payload: {
-    experiments: [...],
-    weaknesses: [...],
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "chaos-experiment-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

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

@@ -76,74 +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 Complexity Patterns BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "complexity/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "complexity/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Analysis)
 
 **1. Store Complexity Analysis Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "code-complexity/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-code-complexity",
-    taskType: "complexity-analysis",
-    reward: <calculated_reward>,
-    outcome: {
-      filesAnalyzed: <count>,
-      functionsAnalyzed: <count>,
-      avgCyclomatic: <value>,
-      avgCognitive: <value>,
-      hotspots: <count>,
-      maintainabilityIndex: <value>
-    },
-    patterns: {
-      highComplexityPatterns: ["<patterns>"],
-      effectiveRefactorings: ["<strategies>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "code-complexity/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Complexity Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/code-complexity/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<complexity pattern description>",
-    confidence: <0.0-1.0>,
-    type: "code-complexity",
-    metadata: {
-      complexityType: "<type>",
-      threshold: <value>,
-      refactoring: "<strategy>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/code-complexity/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "complexity-analysis-complete",
-  priority: "p1",
-  payload: {
-    results: {...},
-    hotspots: [...],
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "complexity-analysis-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/.claude/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/.claude/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)