agentic-qe 3.8.7 → 3.8.9

package/.claude/agents/v3/qe-gap-detector.md

@@ -109,73 +109,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 Gap Patterns BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "coverage/gap-patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "coverage/gap-patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Analysis)
 
 **1. Store Gap Detection Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "gap-detector/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-gap-detector",
-    taskType: "gap-detection",
-    reward: <calculated_reward>,
-    outcome: {
-      filesAnalyzed: <count>,
-      gapsIdentified: <count>,
-      criticalGaps: <count>,
-      recommendationsGenerated: <count>,
-      estimatedEffort: <hours>
-    },
-    patterns: {
-      gapCategories: ["<categories>"],
-      highRiskPatterns: ["<patterns>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "gap-detector/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Gap Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/coverage-gap/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<gap pattern description>",
-    confidence: <0.0-1.0>,
-    type: "coverage-gap",
-    metadata: {
-      gapType: "<type>",
-      riskScore: <score>,
-      testType: "<recommended test>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/coverage-gap/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "gap-detection-complete",
-  priority: "p1",
-  payload: {
-    gaps: [...],
-    recommendations: [...],
-    riskSummary: {...}
-  }
-})
+```bash
+aqe task submit \
+  "gap-detection-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)
@@ -281,32 +249,8 @@ Use via Claude Code: `Skill("test-design-techniques")`
 **Role**: PRODUCER - Stores coverage gap patterns for AC improvement
 
 ### On Gap Detection, Store Quality-Criteria Signal:
-```typescript
-mcp__agentic-qe__cross_phase_store({
-  loop: "quality-criteria",
-  data: {
-    untestablePatterns: [
-      {
-        acPattern: "<vague-ac-pattern>",
-        problem: "Not testable - missing specific assertions",
-        frequency: <0.0-1.0>,
-        betterPattern: "Given/When/Then with specific values"
-      }
-    ],
-    coverageGaps: [
-      {
-        codeArea: "<path/to/file>",
-        coveragePercentage: <percentage>,
-        rootCause: "No acceptance criteria for this path",
-        acImprovement: "Add explicit AC for edge cases"
-      }
-    ],
-    recommendations: {
-      forRequirementsValidator: ["<recommendations for AC validation>"],
-      acTemplates: {}
-    }
-  }
-})
+```bash
+aqe memory store --payload '{...}' --json
 ```
 
 ### Signal Flow:

package/.claude/agents/v3/qe-graphql-tester.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 GraphQL Patterns BEFORE Test
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "graphql/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "graphql/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Test)
 
 **1. Store GraphQL Testing Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "graphql-tester/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-graphql-tester",
-    taskType: "graphql-testing",
-    reward: <calculated_reward>,
-    outcome: {
-      queriesTested: <count>,
-      mutationsTested: <count>,
-      subscriptionsTested: <count>,
-      fieldCoverage: <percentage>,
-      securityIssues: <count>,
-      performanceIssues: <count>
-    },
-    patterns: {
-      schemaPatterns: ["<patterns>"],
-      securityVulnerabilities: ["<types>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "graphql-tester/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store GraphQL Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/graphql-testing/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<graphql pattern description>",
-    confidence: <0.0-1.0>,
-    type: "graphql-testing",
-    metadata: {
-      operationType: "<query|mutation|subscription>",
-      issue: "<issue type>",
-      fix: "<recommendation>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/graphql-testing/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "graphql-test-complete",
-  priority: "p1",
-  payload: {
-    results: {...},
-    coverage: {...},
-    security: {...}
-  }
-})
+```bash
+aqe task submit \
+  "graphql-test-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/.claude/agents/v3/qe-impact-analyzer.md

@@ -87,73 +87,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 Impact Patterns BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "impact/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "impact/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Analysis)
 
 **1. Store Impact Analysis Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "impact-analyzer/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-impact-analyzer",
-    taskType: "impact-analysis",
-    reward: <calculated_reward>,
-    outcome: {
-      changesAnalyzed: <count>,
-      filesImpacted: <count>,
-      testsSelected: <count>,
-      riskLevel: "<level>",
-      analysisDepth: <depth>
-    },
-    patterns: {
-      highImpactPatterns: ["<patterns>"],
-      testStrategies: ["<effective strategies>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "impact-analyzer/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Impact Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/impact-analysis/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<impact pattern description>",
-    confidence: <0.0-1.0>,
-    type: "impact-analysis",
-    metadata: {
-      changeType: "<type>",
-      blastRadius: <size>,
-      riskLevel: "<level>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/impact-analysis/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "impact-analysis-complete",
-  priority: "p1",
-  payload: {
-    impact: {...},
-    testSelection: {...},
-    risk: {...}
-  }
-})
+```bash
+aqe task submit \
+  "impact-analysis-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/.claude/agents/v3/qe-integration-architect.md

@@ -21,10 +21,10 @@ hooks:
     # Check agentic-flow version
     npx agentic-flow --version 2>/dev/null || echo "agentic-flow not installed"
     # Load integration patterns
-    mcp__agentic-qe__memory_query --pattern="integration:agentic-flow:*" --namespace="architecture" --limit=5
+    aqe memory search --pattern="integration:agentic-flow:*" --namespace="architecture" --limit=5
   post: |
     echo "✅ Integration analysis complete"
-    mcp__agentic-qe__memory_store --action="store" --namespace="architecture" --key="integration:analysis:$(date +%s)" --value="ADR-001 compliance checked"
+    aqe memory store --action="store" --namespace="architecture" --key="integration:analysis:$(date +%s)" --value="ADR-001 compliance checked"
 ---
 
 # V3 Integration Architect Agent

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

@@ -77,53 +77,32 @@ 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 Integration Patterns BEFORE Starting
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "integration/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "integration/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Test Generation)
 
 **1. Store Integration Test Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "integration-tester/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-integration-tester",
-    taskType: "integration-testing",
-    reward: <calculated_reward>,
-    outcome: {
-      testsGenerated: <count>,
-      componentsIntegrated: <count>,
-      boundariesTested: <count>,
-      isolationStrategy: "<strategy>"
-    },
-    patterns: {
-      effective: ["<patterns that worked>"],
-      fixtures: ["<fixture strategies>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "integration-tester/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Submit Result to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "integration-tests-complete",
-  priority: "p1",
-  payload: {
-    tests: [...],
-    coverage: {...},
-    boundaryIssues: [...]
-  }
-})
+```bash
+aqe task submit \
+  "integration-tests-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/.claude/agents/v3/qe-kg-builder.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 KG Patterns BEFORE Building
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "kg/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "kg/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Building)
 
 **1. Store KG Building Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "kg-builder/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-kg-builder",
-    taskType: "kg-construction",
-    reward: <calculated_reward>,
-    outcome: {
-      filesProcessed: <count>,
-      entitiesExtracted: <count>,
-      relationshipsInferred: <count>,
-      buildTime: <seconds>,
-      graphSize: <bytes>
-    },
-    patterns: {
-      entityTypes: ["<types>"],
-      relationshipPatterns: ["<patterns>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "kg-builder/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store KG Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/knowledge-graph/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<graph pattern description>",
-    confidence: <0.0-1.0>,
-    type: "knowledge-graph",
-    metadata: {
-      patternType: "<type>",
-      frequency: <count>,
-      languages: ["<languages>"]
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/knowledge-graph/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "kg-build-complete",
-  priority: "p1",
-  payload: {
-    graphStats: {...},
-    queryReady: true,
-    exportAvailable: [...]
-  }
-})
+```bash
+aqe task submit \
+  "kg-build-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/.claude/agents/v3/qe-learning-coordinator.md

@@ -77,71 +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 Knowledge BEFORE Learning Cycle
 
-```typescript
-mcp__agentic-qe__memory_query({
-  pattern: "learning/*",
-  namespace: "experiences"
-})
+```bash
+aqe memory search --pattern "learning/*" --namespace "experiences" --json
 ```
 
 ### Required Learning Actions (Call AFTER Learning Cycle)
 
 **1. Store Learning Coordination Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "learning-coordinator/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-learning-coordinator",
-    taskType: "learning-coordination",
-    reward: <calculated_reward>,
-    outcome: {
-      patternsDiscovered: <count>,
-      knowledgeSynthesized: <count>,
-      agentsImproved: <count>,
-      fleetPerformanceGain: <percentage>
-    },
-    meta: {
-      domainsProcessed: ["<domains>"],
-      transfersApplied: <count>
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "learning-coordinator/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Discovered Patterns:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "learning/patterns/fleet-{timestamp}",
-  namespace: "patterns",
-  value: {
-    pattern: "<pattern description>",
-    confidence: <0.0-1.0>,
-    type: "fleet-learning",
-    metadata: {
-      sourceAgents: ["<agents>"],
-      applicableDomains: ["<domains>"],
-      effectiveness: <rate>
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "learning/patterns/fleet-{timestamp}" \
+  --namespace "patterns" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Trigger Learning Consolidation:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "learning/cycles/consolidate-{timestamp}",
-  namespace: "learning",
-  value: {
-    action: "consolidate",
-    trajectoryIds: ["<recent trajectories>"],
-    timestamp: Date.now()
-  }
-})
+```bash
+aqe memory store \
+  --key "learning/cycles/consolidate-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)