agentic-qe 3.8.6 → 3.8.8

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

@@ -76,75 +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 Transfer Patterns BEFORE Operation
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "transfer/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "transfer/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Transfer)
 
 **1. Store Transfer Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "transfer-specialist/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-transfer-specialist",
-    taskType: "knowledge-transfer",
-    reward: <calculated_reward>,
-    outcome: {
-      sourceDomain: "<domain>",
-      targetDomain: "<domain>",
-      strategy: "<strategy>",
-      trainingTimeSaved: <percentage>,
-      performanceImprovement: <percentage>,
-      patternsTransferred: <count>,
-      adaptationsApplied: <count>
-    },
-    patterns: {
-      successfulTransfers: ["<transfer types>"],
-      failedAdaptations: ["<types>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "transfer-specialist/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Transfer Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/knowledge-transfer/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<transfer pattern description>",
-    confidence: <0.0-1.0>,
-    type: "knowledge-transfer",
-    metadata: {
-      sourceTarget: "<source→target>",
-      strategy: "<strategy>",
-      benefitRatio: <ratio>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/knowledge-transfer/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "transfer-complete",
-  priority: "p1",
-  payload: {
-    transfer: {...},
-    metrics: {...},
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "transfer-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/qe-visual-tester.md

@@ -76,54 +76,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 Visual Patterns BEFORE Testing
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "visual/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "visual/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Testing)
 
 **1. Store Visual Test Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "visual-tester/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-visual-tester",
-    taskType: "visual-testing",
-    reward: <calculated_reward>,
-    outcome: {
-      pagesTested: <count>,
-      screenshotsCaptured: <count>,
-      regressionsFound: <count>,
-      falsePositives: <count>,
-      viewportsCovered: <count>
-    },
-    patterns: {
-      regressionTypes: ["<types found>"],
-      ignorePatterns: ["<effective ignore regions>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "visual-tester/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "visual-test-complete",
-  priority: "p1",
-  payload: {
-    results: [...],
-    regressions: [...],
-    baselineUpdates: [...]
-  }
-})
+```bash
+aqe task submit \
+  "visual-test-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/subagents/qe-code-reviewer.md

@@ -75,74 +75,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 Review Patterns BEFORE Reviewing
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "review/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "review/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Review)
 
 **1. Store Review Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "code-reviewer/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-code-reviewer",
-    taskType: "code-review",
-    reward: <calculated_reward>,
-    outcome: {
-      filesReviewed: <count>,
-      issuesFound: <count>,
-      criticalIssues: <count>,
-      suggestionsGenerated: <count>,
-      approvalGiven: <boolean>
-    },
-    patterns: {
-      commonIssues: ["<issues>"],
-      effectiveFeedback: ["<feedback-patterns>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "code-reviewer/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Review Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/code-review/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<review pattern description>",
-    confidence: <0.0-1.0>,
-    type: "code-review",
-    metadata: {
-      issueType: "<type>",
-      severity: "<severity>",
-      frequency: <count>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/code-review/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Coordinator:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "review-complete",
-  priority: "p1",
-  payload: {
-    approved: <boolean>,
-    findings: [...],
-    blockers: [...],
-    suggestions: [...]
-  }
-})
+```bash
+aqe task submit \
+  "review-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/subagents/qe-integration-reviewer.md

@@ -75,74 +75,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 Integration Patterns BEFORE Analysis
 
-```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 Review)
 
 **1. Store Integration Review Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "integration-reviewer/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-integration-reviewer",
-    taskType: "integration-review",
-    reward: <calculated_reward>,
-    outcome: {
-      integrationPointsReviewed: <count>,
-      breakingChangesDetected: <count>,
-      consumersAffected: <count>,
-      testGapsIdentified: <count>,
-      migrationRisks: <count>
-    },
-    patterns: {
-      commonBreakingChanges: ["<changes>"],
-      effectiveDetection: ["<patterns>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "integration-reviewer/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Integration Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/integration-review/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<integration pattern description>",
-    confidence: <0.0-1.0>,
-    type: "integration-review",
-    metadata: {
-      changeType: "<type>",
-      impactLevel: "<level>",
-      consumersAffected: <count>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/integration-review/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Coordinator:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "integration-review-complete",
-  priority: "p0",
-  payload: {
-    breakingChanges: [...],
-    affectedConsumers: [...],
-    testGaps: [...],
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "integration-review-complete" \
+  --priority "p0" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/subagents/qe-performance-reviewer.md

@@ -75,74 +75,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 Performance Patterns BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "performance/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "performance/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Review)
 
 **1. Store Performance Review Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "performance-reviewer/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-performance-reviewer",
-    taskType: "performance-review",
-    reward: <calculated_reward>,
-    outcome: {
-      functionsAnalyzed: <count>,
-      complexityIssues: <count>,
-      queryIssues: <count>,
-      memoryIssues: <count>,
-      optimizationsSuggested: <count>
-    },
-    patterns: {
-      commonIssues: ["<issues>"],
-      effectiveOptimizations: ["<optimizations>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "performance-reviewer/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Performance Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/performance-review/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<performance pattern description>",
-    confidence: <0.0-1.0>,
-    type: "performance-review",
-    metadata: {
-      issueType: "<type>",
-      complexity: "<complexity>",
-      impactEstimate: "<impact>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/performance-review/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Coordinator:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "performance-review-complete",
-  priority: "p1",
-  payload: {
-    concerns: [...],
-    optimizations: [...],
-    resourceImpact: {...},
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "performance-review-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/subagents/qe-security-reviewer.md

@@ -75,74 +75,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 Security Patterns BEFORE Scanning
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "security/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "security/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Review)
 
 **1. Store Security Review Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "security-reviewer/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-security-reviewer",
-    taskType: "security-review",
-    reward: <calculated_reward>,
-    outcome: {
-      filesScanned: <count>,
-      vulnerabilitiesFound: <count>,
-      criticalVulnerabilities: <count>,
-      secretsDetected: <count>,
-      authIssues: <count>
-    },
-    patterns: {
-      commonVulnerabilities: ["<vulnerabilities>"],
-      effectiveDetection: ["<patterns>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "security-reviewer/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Security Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/security-review/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<security pattern description>",
-    confidence: <0.0-1.0>,
-    type: "security-review",
-    metadata: {
-      vulnerabilityType: "<type>",
-      owaspCategory: "<category>",
-      severity: "<severity>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/security-review/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Coordinator:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "security-review-complete",
-  priority: "p0",
-  payload: {
-    vulnerabilities: [...],
-    secrets: [...],
-    authIssues: [...],
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "security-review-complete" \
+  --priority "p0" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/subagents/qe-tdd-green.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 TDD GREEN Patterns BEFORE Implementation
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "tdd/green/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "tdd/green/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Implementation)
 
 **1. Store GREEN Phase Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "tdd-green/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-tdd-green",
-    taskType: "minimal-implementation",
-    reward: <calculated_reward>,
-    outcome: {
-      testsPassedCount: <count>,
-      linesOfCode: <count>,
-      iterations: <count>,
-      regressions: <count>,
-      simplicitySCore: <score>
-    },
-    patterns: {
-      effectiveApproaches: ["<approaches>"],
-      minimalPatterns: ["<patterns>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "tdd-green/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store GREEN Phase Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/tdd-green/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<green phase pattern description>",
-    confidence: <0.0-1.0>,
-    type: "tdd-green",
-    metadata: {
-      testType: "<type>",
-      implementationStyle: "<style>",
-      iterationsRequired: <count>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/tdd-green/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Signal to Parent Agent:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "green-phase-complete",
-  priority: "p1",
-  payload: {
-    implementationComplete: true,
-    allTestsPass: true,
-    readyForRefactor: true
-  }
-})
+```bash
+aqe task submit \
+  "green-phase-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)