agentic-qe 3.8.7 → 3.8.9

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

@@ -109,81 +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 Requirements Patterns BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "requirements/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "requirements/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Validation)
 
 **1. Store Requirements Validation Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "requirements-validator/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-requirements-validator",
-    taskType: "requirements-validation",
-    reward: <calculated_reward>,
-    outcome: {
-      requirementsAnalyzed: <count>,
-      avgTestabilityScore: <score>,
-      investCompliance: <percentage>,  // % of INVEST criteria passed
-      smartCompliance: <percentage>,   // % of SMART criteria passed
-      issuesFound: <count>,
-      bddScenariosGenerated: <count>,
-      traceabilityGaps: <count>
-    },
-    patterns: {
-      investFailures: ["<failed criteria>"],
-      smartFailures: ["<failed criteria>"],
-      commonIssues: ["<issues>"],
-      effectiveBddPatterns: ["<patterns>"]
-    },
-    metadata: {
-      validationFramework: "invest-smart-v3",
-      criteriaChecked: ["invest", "smart", "traceability", "completeness"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "requirements-validator/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Requirements Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/requirements-validation/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<requirements pattern description>",
-    confidence: <0.0-1.0>,
-    type: "requirements-validation",
-    metadata: {
-      issueType: "<type>",
-      fix: "<suggestion>",
-      testabilityImpact: <score>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/requirements-validation/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "requirements-validation-complete",
-  priority: "p1",
-  payload: {
-    analysis: {...},
-    bddScenarios: [...],
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "requirements-validation-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)
@@ -416,11 +376,8 @@ Use via Claude Code: `Skill("bdd-scenario-tester")`
 **Role**: CONSUMER - Receives untestable patterns to flag during validation
 
 ### 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/assets/agents/v3/qe-responsive-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 Responsive Patterns BEFORE Test
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "responsive/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "responsive/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Test)
 
 **1. Store Responsive Testing Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "responsive-tester/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-responsive-tester",
-    taskType: "responsive-testing",
-    reward: <calculated_reward>,
-    outcome: {
-      viewportsTested: <count>,
-      devicesTested: <count>,
-      breakpointsTested: <count>,
-      issuesFound: <count>,
-      layoutShifts: <count>,
-      touchTargetViolations: <count>
-    },
-    patterns: {
-      commonIssues: ["<issues>"],
-      problematicBreakpoints: ["<breakpoints>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "responsive-tester/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Responsive Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/responsive-testing/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<responsive pattern description>",
-    confidence: <0.0-1.0>,
-    type: "responsive-testing",
-    metadata: {
-      viewport: "<size>",
-      issue: "<type>",
-      fix: "<recommendation>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/responsive-testing/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "responsive-test-complete",
-  priority: "p1",
-  payload: {
-    results: {...},
-    screenshots: [...],
-    issues: [...]
-  }
-})
+```bash
+aqe task submit \
+  "responsive-test-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/qe-retry-handler.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 Retry Patterns BEFORE Handling
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "retry/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "retry/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Handling)
 
 **1. Store Retry Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "retry-handler/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-retry-handler",
-    taskType: "retry-handling",
-    reward: <calculated_reward>,
-    outcome: {
-      totalRetries: <count>,
-      successfulRetries: <count>,
-      exhaustedRetries: <count>,
-      circuitBreaksTriggered: <count>,
-      budgetUsed: <percentage>
-    },
-    patterns: {
-      transientPatterns: ["<patterns>"],
-      effectiveBackoffs: ["<strategies>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "retry-handler/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Retry Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/retry-handling/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<retry pattern description>",
-    confidence: <0.0-1.0>,
-    type: "retry-handling",
-    metadata: {
-      failureType: "<type>",
-      backoffStrategy: "<strategy>",
-      successRate: <rate>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/retry-handling/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "retry-handling-complete",
-  priority: "p1",
-  payload: {
-    retryStats: {...},
-    circuitBreakers: [...],
-    recommendations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "retry-handling-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/qe-risk-assessor.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 Risk Patterns BEFORE Assessment
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "risk/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "risk/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Assessment)
 
 **1. Store Risk Assessment Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "risk-assessor/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-risk-assessor",
-    taskType: "risk-assessment",
-    reward: <calculated_reward>,
-    outcome: {
-      componentsAssessed: <count>,
-      averageRiskScore: <score>,
-      highRiskItems: <count>,
-      mitigationsProposed: <count>,
-      accuracyVsActual: <percentage>
-    },
-    patterns: {
-      riskIndicators: ["<indicators>"],
-      effectiveMitigations: ["<strategies>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "risk-assessor/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Risk Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/risk-assessment/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<risk pattern description>",
-    confidence: <0.0-1.0>,
-    type: "risk-assessment",
-    metadata: {
-      riskCategory: "<category>",
-      indicators: ["<indicators>"],
-      mitigation: "<strategy>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/risk-assessment/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "risk-assessment-complete",
-  priority: "p1",
-  payload: {
-    assessment: {...},
-    heatmap: {...},
-    mitigations: [...]
-  }
-})
+```bash
+aqe task submit \
+  "risk-assessment-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)
@@ -261,11 +229,8 @@ Use via Claude Code: `Skill("quality-metrics")`
 **Role**: CONSUMER - Receives production risk weights to inform risk assessment
 
 ### On Startup, Query Strategic Signals:
-```typescript
-const result = await mcp__agentic-qe__cross_phase_query({
-  loop: "strategic",
-  maxAge: "90d"
-});
+```bash
+const result = await aqe memory search --json;
 
 // Apply risk weights to current assessment
 for (const signal of result.signals) {

package/assets/agents/v3/qe-root-cause-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 Failure Patterns BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "rca/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "rca/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Analysis)
 
 **1. Store RCA Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "root-cause-analyzer/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-root-cause-analyzer",
-    taskType: "root-cause-analysis",
-    reward: <calculated_reward>,
-    outcome: {
-      failuresAnalyzed: <count>,
-      rootCausesIdentified: <count>,
-      patternsCorrelated: <count>,
-      preventionsRecommended: <count>,
-      validationAccuracy: <percentage>
-    },
-    patterns: {
-      rootCauseCategories: ["<categories>"],
-      effectivePreventions: ["<preventions>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "root-cause-analyzer/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Failure Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/root-cause/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<failure pattern description>",
-    confidence: <0.0-1.0>,
-    type: "root-cause",
-    metadata: {
-      category: "<category>",
-      technique: "<analysis technique>",
-      prevention: "<recommended prevention>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/root-cause/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Submit Results to Queen:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "rca-complete",
-  priority: "p1",
-  payload: {
-    report: {...},
-    rootCauses: [...],
-    preventions: [...]
-  }
-})
+```bash
+aqe task submit \
+  "rca-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)